Depalindromize diese Zeichenfolge!

48

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.

code-golf  restricted-source  palindrome 
— Oliver Ni
quelle
23
-1 für die sinnlose Einschränkung, dass Ihr Code kein Palindrom ist. Es fügt der Herausforderung IMO nichts hinzu, in sehr wenigen Sprachen wäre es wichtig.
— 2.
25
+1 für die Einschränkung. Es spiegelt so die Paliondrome-Herausforderung wider ... und fügt Esolangs eine Herausforderung hinzu. Ich mag das. Stimmt die Annahme, dass die Eingabe immer eine ungerade Länge hat?
— Titus
42
Die Nicht-Palindrom-Beschränkung ist wahrscheinlich ein Witz, der auf der vorherigen Herausforderung basiert. Hat irgendjemand auf dieser Grundlage wirklich eine Ablehnung durchgeführt?
— Luis Mendo
5
Es verhindert Einzelbyte-Lösungen. @diynevala +1 für das unnötige +1.
— Adám
5
Was ist, wenn die Zeichenfolge zunächst kein Palindrom ist?
— Xavon_Wrentaile

Antworten:

6

Python 2, 23 Bytes

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

lambda s:s[:-~len(s)/2]
— Kade
quelle
2
Wenn Sie mit Android arbeiten, können Sie QPython aus dem Google Play Store verwenden. Es ist das Beste, was ich gefunden habe :)
— Yytsi
termux apt-get install python2
— Matt
@Matt Das ist übertrieben, wenn Sie nur Python wollen.
— mbomb007
@Matt und das, wenn Sie apt-getauf Ihrem Telefon finden können, ist es wahrscheinlich kein normales Telefon.
— Gesetzliche Lazy
@MathManiac termux wird von Google Play auf jedem nicht gerooteten Android-Handy installiert. Normaler geht es nicht.
— Matt
6

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.

— Rɪᴋᴇʀ
quelle
4

JavaScript (ES6), 32 26 25 Byte

1 Byte gespart dank Neil:

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

Code-Snippet anzeigen

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)
— Hedi
quelle
1
Sie können auf gerade verkürzen, s=>s.slice(0,s.length/2+1)da die Länge immer ungerade sein wird
— Downgoat
@Downgoat Dank dir fand ich, dass für ein weiteres Byte s=>s.slice(0,s.length/2+.5)auch für gerade Länge funktionieren würde.
— Hedi
2
-s.length/2Funktioniert sowohl für ungerade als auch für gerade Längen.
— Neil
4

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"
— Milch
quelle
3

Haskell, 27 Bytes

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

Pointfree-Version von

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

Das sind auch 27 Bytes.

— nimi
quelle
3

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]
— Luis Mendo
quelle
1
Wow, das ist eine sehr gute Möglichkeit, komplexe Werte als Argumente für das Schneiden zu behandeln
— Meilen
@miles Danke! Ja, es ist praktisch. Die imaginäre Einheit arbeitet als endund Doppelpunkte zwischen den Array-Elementen sind implizit
— Luis Mendo
3

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).

— Tödlich
quelle
3

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.

— Tonne Hospel
quelle
2

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
— Timtech
quelle
2

GameMaker-Sprache, 59 Byte

a=argument0 return string_copy(a,1,ceil(string_length(a)/2)
— Timtech
quelle
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.

— Titus
quelle
Da die Eingabe so definiert ist, dass sie von dieser Herausforderung ( codegolf.stackexchange.com/questions/98325/… ) stammt, ist ihre Länge immer ungerade. Sie können also einfach Ihre kürzere auswählen .
— user59178
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.

— Oliver Ni
quelle
2

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.

— Denis Ibaev
quelle
1
Sie kann durch den Austausch 3 Zeichen speichern length()mity|||c
— ardnew
2

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.

— Linus
quelle
1
Du hast mich um eine halbe Stunde und 7 Bytes geschlagen :) befunge.tryitonline.net/…
— Brian Gradin
@ BrianGradin, schön. Jetzt habe ich dich um 9 Bytes geschlagen;)
— Linus
Ach ja ok Ich verstehe, was du getan hast. Mir ist nicht eingefallen, dass ich um zwei heruntergezählt habe, anstatt die tatsächliche Anzahl der zu druckenden Zeichen zu berechnen. Schön gemacht.
— Brian Gradin
2

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.

— Denis Ibaev
quelle
2
Sie können zwei Bytes speichern, die Sie nicht festlegen müssen, -nund -aweil -Fdies implizit der Fall ist.
— Simbabque
@simbabque Ja. Aber nur für 5.20.0+.
— Denis Ibaev
2

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:

,[>,]
<
[
  [<]
  >.,>[>]
  <,<
]
— Mitch Schwartz
quelle
2

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 :-)

— ElPedro
quelle
1
Wenn Sie immer noch wissen möchten, wie die Antwort von Maltysen funktioniert, springt sie cdie Eingabe Qin 2Teile und nimmt das erste Stück mit h(das dank der Implementierung von chop auch den mittleren Buchstaben erfasst ). Wie für den Code, Sie ersetzen könnten +1mit h, Zahlen im internen für die Erhöhung.
— Steven H.
Danke für die Erklärung und für den hHinweis @Steven H. Es gibt so viele eingebaute Funktionen, dass es wohl einige Zeit dauert, sie alle zu finden :)
— ElPedro
1
Kein Problem! Wenn Sie jemals Hilfe benötigen, versuchen Sie, mich im neunzehnten Byte anzupingen.
— Steven H.
2

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);
}
— Karl Napf
quelle
@ KevinCruijssen behoben
— Karl Napf
Hallo, Entschuldigung, ich habe meinen Kommentar gelöscht. Ich habe zu Recht gesagt, dass es nicht einmal für Palindrome funktioniert. Da dies jedoch das Gegenteil dieser anderen Herausforderung ist, gibt es auch für Palindrome keine Testfälle. Sie können die Änderung jedoch rückgängig machen. +1 von mir. :)
— Kevin Cruijssen
2
Nun, es hat jetzt die gleiche Länge, funktioniert für gerade + ungerade und sieht golfer aus. Ich bin damit einverstanden.
— Karl Napf
Dies ist wohl ein Speicherleck :-)
— ShreevatsaR
1
Ich denke, Sie können das Leerzeichen in entfernenchar* c
— Cyoce
1

Python 2, 23 Bytes

lambda x:x[:len(x)/2+1]
— Rɪᴋᴇʀ
quelle
Ich denke, das erfordert Python 2; Sie sollten dies in Ihrer Antwort angeben
— Luis Mendo
@ LuisMendo oh, danke!
— 3.
Durch die Nutzung unserer Website bestätigen Sie, dass Sie unsere Cookie-Richtlinie und Datenschutzrichtlinie gelesen und verstanden haben.
Licensed under cc by-sa 3.0 with attribution required.