Dado um palíndromo gerado de acordo com esse desafio , despalindromize-o.

Casos de teste

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

Como se trata de despalindromização, seu código não pode ser um palíndromo .

Lembre-se, isso é código-golfe , portanto o código com o menor número de bytes vence.

Julia, 21 15 bytes

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

Experimente online! (código extra é para impressão)

05AB1E , 3 bytes

2ä¬

Usa a codificação CP-1252 . Experimente online!

Python 2, 23 bytes

Não consigo testar no meu telefone, mas isso deve funcionar:

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

Fuzzy Octo Guacamole, 4 bytes

2.^/

Passei um tempo procurando por um idioma em que esse desafio fosse curto, e percebi que era burro e meu próprio idioma fez isso.

05AB1E, 5 bytes

Dg;î£

Experimente online!

Explicação:

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

Queijo Cheddar, 22 18 bytes

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

Tão simples que acho que não precisa de explicação, mas adicionarei uma, se desejado.

Experimente online

Pitão - 4 bytes

hc2Q

Conjunto de Teste .

JavaScript (ES6), 32 26 25 bytes

1 byte economizado graças 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'))

Soluções anteriores
26 bytes graças ao 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, não inserindo NULL, passando o comprimento para da

A entrada é passada através de um endereço no psuedo-register $t0. Por exemplo:

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.

Ele funciona substituindo o direito do meio do caractere (ou o meio-direito, se a string tiver um comprimento uniforme) por um nulo e, em seguida, imprime a string a partir do endereço de memória 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

Resultado:

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

Versão sem ponto de

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

que também tem 27 bytes.

MATL , 7 6 bytes

9LQ2/)

Experimente online!

Explicação

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]

Gelatina , 4 bytes

œs2Ḣ

Experimente online!

Explicação

œ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

Duas soluções completamente diferentes, ambas de 12 bytes.

ò"Bx$xh|ò"bP

Experimente online!

Ó./&ò
MjdGÍî

Experimente online!

Braquilog , 4 bytes

@2tr

Experimente online!

Explicação

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

Se a entrada tiver um comprimento ímpar, a segunda metade gerada por @2é a mais longa, que é a que devemos retornar (depois de revertê-la).

Dyalog APL , 9 bytes

⊢↑⍨2÷⍨1+≢

⊢ o argumento

↑⍨ truncado em

2÷⍨ metade de

1+ um mais

≢ O comprimento

TryAPL online!

Perl, 15 bytes

Inclui +2 para -lp

Dê uma string de entrada no STDIN:

depal.pl <<< "HelleH"

depal.pl:

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

A -lnão é realmente necessário, se você inserir o palíndromo sem nova linha final, mas eu incluí-lo para ser justo com as outras soluções perl que o utilizam.

Java 7, 57 bytes

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

TI-Basic, 14 bytes

Função padrão. Retorna a string do índice 1 para o índice (comprimento / 2 + 1/2).

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

Idioma do 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)/2é convertido para int, com a entrada sempre tendo um comprimento ímpar, +1é suficiente para arredondar para cima.

42 bytes para qualquer comprimento:

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

por comprimento desconhecido, (1+strlen)/2é convertido em int, arredondando para cima strlen/2.

Mergulho, 8 bytes

H{C'0ÏEI

Explicação:

           # 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

Provavelmente isso poderia ser muito melhorado.

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

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

Ungolfed:

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

Thanx para @ardnew.

Befunge , 24 22 bytes

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

Experimente online!

Como o Befunge não tem tipo de string ou array, tudo é feito na pilha, um caractere de cada vez. O primeiro loop (na linha superior) conta o número de caracteres lidos (trocar com menos de 2 elementos na pilha produz um 0 inicial). O segundo (na linha do meio) imprime caracteres enquanto conta em contagem regressiva duas vezes mais rápido. Como resultado, apenas a última metade da entrada é impressa, mas o LIFO está na ordem correta.

Agradecemos a Brian Gradin por uma versão melhor do primeiro loop.

Perl, 14 + 3 ( -lFsinalizador) = 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]'

Ungolfed:

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)]);
}

Thanx para @simbabque.

Brainfuck, 20 bytes

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

Experimente online.

Isso economiza um byte na abordagem mais direta de consumir a entrada antes de iniciar o loop principal:

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

Pitão , 8 7 bytes

<zh/lz2

Guardado 1 com graças a @Steven H

Não é a resposta mais curta do Pyth (pela metade), mas estou fazendo um esforço para aprender o idioma e este é o meu primeiro post usando-o. Postado tanto por comentários e feedback como qualquer coisa. É também o primeiro programa Pyth que eu realmente tenho que trabalhar :)

Agora só preciso descobrir como funciona a resposta de 4 bytes do @Maltysen :-)

Na verdade , 5 bytes

l½KßH

Experimente online!

-1 byte graças a Sherlock9

Explicação:

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

C, 31 30 bytes

Economizando 1 byte graças ao 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 / Oitava, 20 19 18 16 bytes

1 byte emprestado de uma ideia da resposta de Easterly Irk (adicione em 1vez de .5)
2 bytes de desconto graças a @StewieGriffin (parênteses desnecessários)

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

Experimente em Ideone .