Dado un palíndromo generado de acuerdo con este desafío , despalindromécelo.

Casos de prueba

abcdedcba -> abcde
johncenanecnhoj -> johncena
ppapapp -> ppap
codegolflogedoc -> codegolf

Como se trata de despalindromizar, su código no puede ser un palíndromo .

Recuerde, esto es código golf , por lo que gana el código con la menor cantidad de bytes.

Julia, 21 15 bytes

x->x[1:end/2+1]

Pruébalo en línea! (el código adicional es para imprimir la salida)

05AB1E , 3 bytes

2ä¬

Utiliza la codificación CP-1252 . Pruébalo en línea!

Python 2, 23 bytes

No puedo probar en mi teléfono, pero esto debería funcionar:

lambda s:s[:-~len(s)/2]

Guacamole Octo Fuzzy, 4 bytes

2.^/

Pasé un tiempo buscando un idioma en el que este desafío es corto, y me di cuenta de que era tonto y mi propio idioma lo hizo.

05AB1E, 5 bytes

Dg;î£

Pruébalo en línea!

Explicación:

D      Duplicate
 g;î   Divide length by two and round up
    £  First b letters of a

Cheddar, 22 18 bytes

@.head($0.len/2+1)

Tan simple que no creo que necesite explicación, pero agregaré una si lo desea.

Pruébalo en línea

Pyth - 4 bytes

hc2Q

Test Suite .

JavaScript (ES6), 32 26 25 bytes

1 byte guardado gracias a Neil:

s=>s.slice(0,-s.length/2)

f=
  s=>s.slice(0,-s.length/2)
;
console.log(f('abcdedcba'))
console.log(f('johncenanecnhoj'))
console.log(f('ppapapp'))
console.log(f('codegolflogedoc'))

Soluciones anteriores
26 bytes gracias a Downgoat:

s=>s.slice(0,s.length/2+1)

32 bytes:

s=>s.slice(0,(l=s.length/2)+l%2)

WinDbg, 87 71 bytes

db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};da$t0 L(@$t1-@$t0)/2

-16 bytes al no insertar NULL, en lugar de pasar la longitud a da

La entrada se pasa a través de una dirección en psuedo-register $t0. Por ejemplo:

eza 2000000 "abcdedcba"       * Write string "abcdedcba" into memory at 0x02000000
r $t0 = 33554432              * Set $t0 = 0x02000000
* Edit: Something got messed up in my WinDB session, of course r $t0 = 2000000 should work
* not that crazy 33554432.

Funciona reemplazando la derecha de char medio (o derecha-media si la cadena tiene una longitud uniforme) con un valor nulo y luego imprime la cadena desde la dirección de memoria inicial original.

db $t0 L1;                                   * Set $p = memory-at($t0)
.for (r $t1 = @$t0; @$p; r $t1 = @$t1 + 1)   * Set $t1 = $t0 and increment until $p == 0
{
    db $t1 L1                                * Set $p = memory-at($t1)
};
da $t0 L(@$t1-@$t0)/2                        * Print half the string

Salida:

0:000> eza 2000000 "abcdeedcba"
0:000> r $t0 = 33554432
0:000> db$t0 L1;.for(r$t1=@$t0;@$p;r$t1=@$t1+1){db$t1 L1};da$t0 L(@$t1-@$t0)/2
02000000  61                                               a
02000000  61                                               a
02000001  62                                               b
02000002  63                                               c
02000003  64                                               d
02000004  65                                               e
02000005  65                                               e
02000006  64                                               d
02000007  63                                               c
02000008  62                                               b
02000009  61                                               a
0200000a  00                                               .
02000000  "abcde"

Haskell, 27 bytes

take=<<succ.(`div`2).length

Versión de Pointfree de

\x->take(div(length x)2+1)x

que también es de 27 bytes.

MATL , 7 6 bytes

9LQ2/)

Pruébalo en línea!

Explicación

9L       % Push array [1, 1j]
  Q      % Add 1: transforms into [2, 1+1j]
   2/    % Divide by 2: transforms into [1, 0.5+0.5j]
     )   % Apply as index into implicit input. The array [1, 0.5+0.5j] used as an index
         % is interpreted as [1:0.5+end*0.5]

Jalea , 4 bytes

œs2Ḣ

Pruébalo en línea!

Explicación

œs2      Split input into 2 chunks of similar lengths. For odd-length input,
         the first chunk is the longest
   Ḣ     Keep the first chunk

V , 12 bytes

Dos soluciones completamente diferentes, ambas de 12 bytes.

ò"Bx$xh|ò"bP

Pruébalo en línea!

Ó./&ò
MjdGÍî

Pruébalo en línea!

Brachylog , 4 bytes

@2tr

Pruébalo en línea!

Explicación

@2        Split in half
  t       Take the second half
   r      Reverse it

Si la entrada tiene una longitud impar, la segunda mitad generada por @2es la más larga, es la que deberíamos devolver (después de revertirla).

Dyalog APL , 9 bytes

⊢↑⍨2÷⍨1+≢

⊢ el argumento

↑⍨ truncado en

2÷⍨ medio de

1+ uno más

≢ la longitud

TryAPL en línea!

Perl, 15 bytes

Incluye +2 para -lp

Dar cadena de entrada en STDIN:

depal.pl <<< "HelleH"

depal.pl:

#!/usr/bin/perl -lp
s/../chop/reg

No -les realmente necesario si ingresa el palíndromo sin una nueva línea final, pero lo incluí para ser justo con las otras soluciones de Perl que lo usan.

Java 7, 57 bytes

String c(String s){return s.substring(0,s.length()/2+1);}

TI-Basic, 14 bytes

Función estándar. Devuelve la cadena del índice 1 al índice (longitud / 2 + 1/2).

sub(Ans,1,.5+.5length(Ans

Lenguaje GameMaker, 59 bytes

a=argument0 return string_copy(a,1,ceil(string_length(a)/2)

PHP, 40 bytes

<?=substr($a=$argv[1],0,1+strlen($a)/2);

strlen($a)/2se convierte en int, con la entrada siempre con una longitud impar, es +1suficiente para redondear.

42 bytes para cualquier longitud:

<?=substr($a=$argv[1],0,(1+strlen($a))/2);

para longitud desconocida, (1+strlen)/2se lanza a int, redondeando strlen/2.

Dip, 8 bytes

H{C'0ÏEI

Explicación:

           # Implicit input
 H         # Push length of input
  {        # Add 1
   C       # Divide by 2
    '      # Convert to int
     0Ï    # Get string back
       E   # Push prefixes of string
        I  # Push prefixes[a]
           # Implicit print

Esto probablemente podría mejorarse mucho.

Perl, 23 + 2 ( -plbandera) = 28 25 bytes

perl -ple '$_=substr$_,0,1+y///c/2'

Sin golf:

while (<>) {             # -p flag
    chomp($_)            # -l flag
    $_ = substr($_, 0, 1 + length($_) / 2);
    print($_, "\n")      # -pl flag
}

Gracias a @ardnew.

Befunge , 24 22 bytes

~:0`!#v_\1+
0:-2,\_@#`

Pruébalo en línea!

Befunge no tiene tipo de cadena o matriz, por lo que todo se hace en la pila de un carácter a la vez. El primer bucle (en la línea superior) cuenta el número de caracteres leídos (el intercambio con menos de 2 elementos en la pila produce un 0 inicial). El segundo (en la línea media) imprime caracteres mientras realiza la cuenta regresiva el doble de rápido. Como resultado, solo se imprime la última mitad de la entrada, pero LIFO, por lo que está en el orden correcto.

Gracias a Brian Gradin por una mejor versión del primer bucle.

Perl, 14 + 3 ( -lFbandera) = 19 17 bytes

Para 5.20.0+:

perl -lF -E 'say@F[0..@F/2]'

Para 5.10.0+ (19 bytes):

perl -nlaF -E 'say@F[0..@F/2]'

Sin golf:

while (<>) {             # -n flag (implicitly sets by -F in 5.20.0+)
    chomp($_)            # -l flag
    @F = split('', $_);  # -aF flag (implicitly sets by -F in 5.20.0+)
    say(@F[0 .. (scalar(@F) / 2)]);
}

Gracias a @simbabque.

Brainfuck, 20 bytes

,
[
  [>,]
  <[<]
  >.,>[>]
  <<
]

Pruébalo en línea.

Esto ahorra un byte sobre el enfoque más directo de consumir la entrada antes de comenzar el ciclo principal:

,[>,]
<
[
  [<]
  >.,>[>]
  <,<
]

Pyth , 8 7 bytes

<zh/lz2

Guardado 1 con gracias a @Steven H

No es la respuesta Pyth más corta (a la mitad), pero estoy haciendo un esfuerzo por aprender el idioma y esta es mi primera publicación que lo uso. Publicado tanto para comentarios y comentarios como cualquier cosa. También es el primer programa Pyth que realmente tengo que trabajar :)

Ahora solo necesito averiguar cómo funciona la respuesta de 4 bytes de @Maltysen :-)

En realidad , 5 bytes

l½KßH

Pruébalo en línea!

-1 byte gracias a Sherlock9

Explicación:

l½K@H
l½K    ceil(len(input)/2)
   ßH  first (len(input)//2 + 1) characters of input

C, 31 30 bytes

Ahorro de 1 byte gracias a Cyoce.

f(char*c){c[-~strlen(c)/2]=0;}

Uso:

main(){
 char a[]="hellolleh";
 f(a);
 printf("%s\n",a);
}

Python 2, 23 bytes

lambda x:x[:len(x)/2+1]

MATLAB / Octave, 20 19 18 16 bytes

1 byte sin tomar prestada una idea de la respuesta de Easterly Irk (agregar en 1lugar de .5)
2 bytes de descuento gracias a @StewieGriffin (paréntesis innecesarios)

@(x)x(1:end/2+1)

Pruébalo en Ideone .