Compte tenu d'un palindrome généré en fonction de ce défi , dépalindromisez-le.

Cas de test

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

Comme il s’agit de dépalindromiser, votre code ne peut pas être un palindrome .

Rappelez-vous que c'est du code-golf , donc le code avec le moins d'octets gagne.

Julia, 21 15 octets

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

Essayez-le en ligne! (le code supplémentaire est pour l'impression)

05AB1E , 3 octets

2ä¬

Utilise le codage CP-1252 . Essayez-le en ligne!

Python 2, 23 octets

Je ne peux pas tester sur mon téléphone, mais cela devrait fonctionner:

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

Fuzzy Octo Guacamole, 4 octets

2.^/

J'ai passé un certain temps à chercher une langue dans laquelle ce défi est court et me suis rendu compte que j'étais idiot et que ma propre langue faisait de même.

05AB1E, 5 octets

Dg;î£

Essayez-le en ligne!

Explication:

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

Cheddar, 22 à 18 octets

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

Tellement simple que je ne pense pas besoin d'explication mais je vais en ajouter une si vous le souhaitez.

Essayez-le en ligne

Pyth - 4 octets

hc2Q

Suite de test .

JavaScript (ES6), 32 26 25 octets

1 octet enregistré grâce à 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'))

Solutions précédentes
26 octets grâce à Downgoat:

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

32 octets:

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

WinDbg, 87 71 octets

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

-16 octets en n'insérant pas la valeur NULL, en passant la longueur à da

L'entrée est transmise via une adresse dans psuedo-register $t0. Par exemple:

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.

Cela fonctionne en remplaçant le caractère du milieu du caractère (ou du milieu à droite si la chaîne a une longueur égale) par un null, puis affiche la chaîne à partir de l'adresse de la mémoire de départ d'origine.

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

Sortie:

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 octets

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

Version Pointfree de

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

qui est également 27 octets.

MATL , 7 à 6 octets

9LQ2/)

Essayez-le en ligne!

Explication

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]

Gelée , 4 octets

œs2Ḣ

Essayez-le en ligne!

Explication

œ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 octets

Deux solutions complètement différentes, les deux 12 octets.

ò"Bx$xh|ò"bP

Essayez-le en ligne!

Ó./&ò
MjdGÍî

Essayez-le en ligne!

Brachylog , 4 octets

@2tr

Essayez-le en ligne!

Explication

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

Si l'entrée a une longueur impaire, la seconde moitié générée par @2est celle qui est la plus longue, c'est celle à renvoyer (après l'inversion).

Dyalog APL , 9 octets

⊢↑⍨2÷⍨1+≢

⊢ l'argument

↑⍨ tronqué à

2÷⍨ moitié de

1+ un plus

≢ la durée

TryAPL en ligne!

Perl, 15 octets

Comprend +2 pour -lp

Donnez la chaîne d'entrée sur STDIN:

depal.pl <<< "HelleH"

depal.pl:

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

Ce -ln'est pas vraiment nécessaire si vous entrez le palindrome sans nouvelle ligne finale, mais je l'ai inclus pour être juste envers les autres solutions Perl qui l'utilisent.

Java 7, 57 octets

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

TI-Basic, 14 octets

Fonction standard. Renvoie la chaîne de l'index 1 à l'index (longueur / 2 + 1/2).

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

Langue GameMaker, 59 octets

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

PHP, 40 octets

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

strlen($a)/2est converti en int, l’entrée ayant toujours une longueur impaire, +1suffit à arrondir.

42 octets pour n'importe quelle longueur:

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

pour une longueur inconnue, (1+strlen)/2est moulé à int, arrondi strlen/2.

Dip, 8 octets

H{C'0ÏEI

Explication:

           # 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

Cela pourrait probablement être beaucoup amélioré.

Perl, 23 + 2 ( -pldrapeau) = 28 25 octets

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

Ungolfed:

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

Merci à @ardnew.

Befunge , 24 22 octets

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

Essayez-le en ligne!

Befunge n'a pas de type chaîne ou tableau donc tout est fait sur la pile, un caractère à la fois. La première boucle (sur la ligne du haut) compte le nombre de caractères lus (un échange avec moins de 2 éléments dans la pile produit un 0 initial). La seconde (sur la ligne médiane) imprime les caractères tout en effectuant un compte à rebours deux fois plus rapide. En conséquence, seule la dernière moitié de la saisie est imprimée, mais LIFO est donc dans le bon ordre.

Merci à Brian Gradin pour une meilleure version de la première boucle.

Perl, 14 + 3 ( -lFdrapeau) = 19 17 octets

Pour 5.20.0+:

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

Pour 5.10.0+ (19 octets):

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

Merci à @simbabque.

Brainfuck, 20 octets

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

Essayez-le en ligne.

Cela évite de surcharger l'approche plus simple consistant à consommer l'entrée avant de commencer la boucle principale:

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

Pyth , 8 7 octets

<zh/lz2

Enregistré 1 avec merci à @Steven H

Pas la réponse la plus courte de Pyth (de moitié) mais je fais un effort pour apprendre la langue et ceci est mon premier post l'utilisant. Publié autant pour les commentaires et les réactions que rien. C'est aussi le premier programme Pyth que je dois réellement travailler :)

Maintenant, je dois juste comprendre comment fonctionne la réponse sur 4 octets de @Maltysen :-)

En fait , 5 octets

l½KßH

Essayez-le en ligne!

-1 octet grâce à Sherlock9

Explication:

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

C, 31 30 octets

Enregistrement d'un octet grâce à Cyoce.

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

Usage:

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

Python 2, 23 octets

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

MATLAB / Octave, 20 19 18 16 octets

1 octet sur empruntant une idée de la réponse de Easterly Irk (ajouter 1au lieu de .5)
2 octets à l'aide de @StewieGriffin (parenthèses inutiles)

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

Essayez chez Ideone .