Depalindromieren Sie ein Palindrom, das gemäß dieser Herausforderung erzeugt wurde.

Testfälle

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

Da es sich um eine Depalindromierung handelt, kann Ihr Code kein Palindrom sein .

Denken Sie daran, das ist Code-Golf , also gewinnt der Code mit den wenigsten Bytes.

Julia, 21-15 Bytes

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

Probieren Sie es online! (zusätzlicher Code für die Druckausgabe)

05AB1E , 3 Bytes

2ä¬

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Python 2, 23 Bytes

Ich kann auf meinem Handy nicht testen, aber das sollte funktionieren:

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

Fuzzy Octo Guacamole, 4 Bytes

2.^/

Ich habe eine Weile nach einer Sprache gesucht, in der diese Herausforderung kurz ist, und mir wurde klar, dass ich dumm war, und meine eigene Sprache hat das getan.

05AB1E, 5 Bytes

Dg;î£

Probieren Sie es online!

Erläuterung:

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

Cheddar, 22 18 Bytes

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

So einfach, ich glaube nicht, dass es einer Erklärung bedarf, aber ich werde eine hinzufügen, wenn ich will.

Probieren Sie es online aus

Pyth - 4 Bytes

hc2Q

Test Suite .

JavaScript (ES6), 32 26 25 Byte

1 Byte gespart dank 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'))

Bisherige Lösungen
26 Bytes dank 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, indem Sie nicht NULL einfügen, sondern length an übergeben da

Die Eingabe erfolgt über eine Adresse im Pseudo-Register $t0. Zum Beispiel:

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.

Dies funktioniert, indem das rechte Zeichen des mittleren Zeichens (oder das rechte Zeichen des mittleren Zeichens, wenn die Zeichenfolge gerade Länge hat) durch eine Null ersetzt und die Zeichenfolge dann von der ursprünglichen Anfangsspeicheradresse gedruckt wird.

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

Ausgabe:

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

Pointfree-Version von

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

Das sind auch 27 Bytes.

MATL , 7 6 Bytes

9LQ2/)

Probieren Sie es online!

Erläuterung

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]

Gelee , 4 Bytes

œs2Ḣ

Probieren Sie es online!

Erläuterung

œ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

Zwei völlig unterschiedliche Lösungen, beide 12 Bytes.

ò"Bx$xh|ò"bP

Probieren Sie es online!

Ó./&ò
MjdGÍî

Probieren Sie es online!

Brachylog , 4 Bytes

@2tr

Probieren Sie es online!

Erläuterung

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

Wenn die Eingabe eine ungerade Länge hat, ist die von erzeugte zweite Hälfte @2die längste, die wir zurückgeben sollten (nachdem wir sie umgekehrt haben).

Dyalog APL , 9 Bytes

⊢↑⍨2÷⍨1+≢

⊢ das Argument

↑⍨ abgeschnitten bei

2÷⍨ die Hälfte von

1+ eins plus

≢ die Länge

TryAPL online!

Perl, 15 Bytes

Beinhaltet +2 für -lp

Geben Sie die Eingabezeichenfolge für STDIN ein:

depal.pl <<< "HelleH"

depal.pl:

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

Das -lwird nicht wirklich benötigt, wenn Sie das Palindrom ohne letzten Zeilenumbruch eingeben, aber ich habe es hinzugefügt, um es den anderen Perl-Lösungen, die es verwenden, gerecht zu werden.

Java 7, 57 Bytes

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

TI-Basic, 14 Bytes

Standardfunktion. Gibt einen String von Index 1 bis Index zurück (Länge / 2 + 1/2).

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

GameMaker-Sprache, 59 Byte

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)/2wird auf int umgewandelt, wobei die Eingabe immer eine ungerade Länge hat, was zum +1Aufrunden ausreicht.

42 Bytes für jede Länge:

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

für unbekannte Länge (1+strlen)/2wird auf int geworfen und aufgerundet strlen/2.

Dip, 8 Bytes

H{C'0ÏEI

Erläuterung:

           # 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

Dies könnte wahrscheinlich erheblich verbessert werden.

Perl, 23 + 2 ( -plFlag) = 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
}

Vielen Dank an @ardnew.

Befunge , 24 22 Bytes

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

Probieren Sie es online!

Befunge hat keinen String- oder Array-Typ, daher wird das Ganze zeichenweise auf dem Stack ausgeführt. Die erste Schleife (in der obersten Zeile) zählt die Anzahl der gelesenen Zeichen (das Vertauschen mit weniger als 2 Elementen im Stapel ergibt eine anfängliche 0). Die zweite Zeile (in der mittleren Zeile) druckt Zeichen, während der Countdown doppelt so schnell erfolgt. Infolgedessen wird nur die letzte Hälfte der Eingabe gedruckt, LIFO also in der richtigen Reihenfolge.

Vielen Dank an Brian Gradin für eine bessere Version der ersten Runde.

Perl, 14 + 3 ( -lFFlag) = 19 17 Bytes

Für 5.20.0+:

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

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

Vielen Dank an @simbabque.

Brainfuck, 20 Bytes

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

Probieren Sie es online aus.

Dies erspart ein Byte gegenüber dem einfacheren Ansatz, die Eingabe vor dem Starten der Hauptschleife zu verbrauchen:

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

Pyth , 8 7 Bytes

<zh/lz2

1 mit Dank an @Steven H gespeichert

Nicht die kürzeste Pyth-Antwort (um die Hälfte), aber ich bemühe mich, die Sprache zu lernen, und dies ist mein erster Beitrag, der sie verwendet. Gepostet so viel für Kommentare und Feedback wie nichts. Es ist auch das erste Pyth-Programm, mit dem ich tatsächlich arbeiten muss :)

Jetzt muss ich nur noch herausfinden, wie die 4-Byte-Antwort von @Maltysen funktioniert :-)

Eigentlich 5 Bytes

l½KßH

Probieren Sie es online!

-1 Byte dank Sherlock9

Erläuterung:

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

C 31-30 Bytes

Dank Cyoce 1 Byte sparen.

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

Verwendungszweck:

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 weniger beim Ausleihen einer Idee aus der Antwort von Easterly Irk ( 1anstelle von .5)
2 Byte weniger dank @StewieGriffin (unnötige Klammern)

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

Probieren Sie es bei Ideone .