Depalindromizza questa stringa!

48

Dato un palindromo generato secondo questa sfida , depalindromizzare.

Casi test

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

Poiché si tratta di depalindromizzare, il tuo codice non può essere un palindromo .

Ricorda, questo è code-golf , quindi vince il codice con il minor numero di byte.

code-golf  restricted-source  palindrome 
— Oliver Ni
fonte
23
-1 per la limitazione inutile che il tuo codice non sia un palindromo. Non aggiunge nulla alla sfida dell'IMO, in pochissime lingue sarebbe importante.
— R
25
+1 per la restrizione. È così rispecchiante la sfida del paliondrome ... e sta aggiungendo sfida agli esolang. Mi piace. Sono corretto nel presupposto che l'input avrà sempre una lunghezza irregolare?
— Tito
42
La restrizione non-palindromo è probabilmente uno scherzo basato sulla sfida precedente. Qualcuno ha davvero votato in base a questo?
— Luis Mendo,
5
Impedisce soluzioni a byte singolo. @diynevala +1 per il +1 non necessario.
— Adám,
5
Cosa succede se la stringa non è un palindromo per cominciare?
— Xavon_Wrentaile,

Risposte:

6

Python 2, 23 byte

Non riesco a provare sul mio telefono, ma questo dovrebbe funzionare:

lambda s:s[:-~len(s)/2]
— Kade
fonte
2
Se stai utilizzando Android, puoi utilizzare QPython dal Google Play Store. È il migliore che ho trovato :)
— Yytsi,
termux apt-get install python2
— Matt,
@Matt Questo è eccessivo se tutto ciò che vuoi è Python.
— mbomb007,
@Matt e se puoi trovarlo apt-getsul tuo telefono, probabilmente non è un telefono normale.
— Legale pigro,
@MathManiac termux è installato da Google Play su qualsiasi telefono Android non rootato. Non posso essere molto più normale di così.
— Matt
6

Fuzzy Octo Guacamole, 4 byte

2.^/

Ho trascorso un po 'a cercare una lingua in cui questa sfida è breve e mi sono reso conto che ero stupido e la mia lingua lo ha fatto.

— Rɪᴋᴇʀ
fonte
5

Cheddar, 22 18 byte

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

Così semplice che non credo abbia bisogno di spiegazioni ma ne aggiungerò uno se lo si desidera.

Provalo online

— Downgoat
fonte
4

JavaScript (ES6), 32 26 25 byte

1 byte salvato grazie a Neil:

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

Mostra snippet di codice

Soluzioni precedenti
26 byte grazie a Downgoat:

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

32 byte:

s=>s.slice(0,(l=s.length/2)+l%2)
— Hedi
fonte
1
Puoi accorciare fino a s=>s.slice(0,s.length/2+1)Dal momento che la lunghezza sarà sempre dispari
— Downgoat
@Downgoat grazie a te ho scoperto che per un byte in più s=>s.slice(0,s.length/2+.5)avrebbe funzionato anche per una lunghezza uniforme.
— Hedi,
2
-s.length/2funziona per lunghezze pari e dispari.
— Neil,
4

WinDbg, 87 71 byte

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

-16 byte non inserendo NULL, passando invece la lunghezza a da

L'immissione viene trasmessa tramite un indirizzo nel registro psuedo $t0. Per esempio:

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.

Funziona sostituendo il diritto del carattere centrale (o il centro-destra se la stringa ha lunghezza pari) con un valore null e quindi stampa la stringa dall'indirizzo di memoria iniziale iniziale.

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

Produzione:

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"
— latte
fonte
3

Haskell, 27 byte

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

Versione senza punti di

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

che è anche 27 byte.

— Nome del modello
fonte
3

MATL , 7 6 byte

9LQ2/)

Provalo online!

Spiegazione

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
fonte
1
Wow, è un modo molto semplice di gestire valori complessi come argomenti per lo slicing
— miglia
@miles Grazie! Sì, è utile. L'unità immaginaria funziona come end, e i due punti tra gli elementi dell'array sono impliciti
— Luis Mendo,
3

Gelatina , 4 byte

œs2Ḣ

Provalo online!

Spiegazione

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

Brachylog , 4 byte

@2tr

Provalo online!

Spiegazione

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

Se l'input ha una lunghezza dispari, la seconda metà generata da @2è quella più lunga, ovvero quella che dovremmo restituire (dopo averlo invertito).

— Fatalize
fonte
3

Perl, 15 byte

Include +2 per -lp

Dare una stringa di input su STDIN:

depal.pl <<< "HelleH"

depal.pl:

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

Non -lè davvero necessario se si inserisce il palindromo senza la nuova riga finale, ma l'ho incluso per essere corretto con le altre soluzioni perl che lo utilizzano.

— Ton Hospel
fonte
2

TI-Basic, 14 byte

Funzione standard. Restituisce la stringa dall'indice 1 all'indice (lunghezza / 2 + 1/2).

sub(Ans,1,.5+.5length(Ans
— Timtech
fonte
2

Lingua GameMaker, 59 byte

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

PHP, 40 byte

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

strlen($a)/2viene trasmesso a int, con input sempre di lunghezza dispari, è +1sufficiente arrotondare per eccesso.

42 byte per qualsiasi lunghezza:

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

per lunghezza sconosciuta, (1+strlen)/2viene trasmesso a int, arrotondando per eccesso strlen/2.

— Titus
fonte
Poiché l'input viene definito come proveniente da questa sfida ( codegolf.stackexchange.com/questions/98325/… ), la sua lunghezza sarà sempre strana, quindi puoi semplicemente andare con quella più corta.
— user59178
2

Dip, 8 byte

H{C'0ÏEI

Spiegazione:

           # 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

Questo potrebbe probabilmente essere molto migliorato.

— Oliver Ni
fonte
2

Perl, 23 + 2 ( -plflag) = 28 25 byte

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

Ungolfed:

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

Grazie a @ardnew.

— Denis Ibaev
fonte
1
puoi salvare 3 caratteri sostituendo length()cony|||c
— ardnew il
2

Befunge , 24 22 byte

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

Provalo online!

Befunge non ha stringhe o tipi di array, quindi tutto viene fatto in pila un carattere alla volta. Il primo ciclo (nella riga superiore) conta il numero di caratteri letti (lo scambio con meno di 2 elementi nello stack produce uno 0 iniziale). Il secondo (sulla linea centrale) stampa i caratteri mentre il conto alla rovescia è due volte più veloce. Di conseguenza viene stampata solo l'ultima metà dell'input, ma LIFO è nell'ordine corretto.

Grazie a Brian Gradin per una versione migliore del primo loop.

— Linus
fonte
1
Mi hai battuto per mezz'ora e 7 byte :) befunge.tryitonline.net/…
— Brian Gradin
@BrianGradin, bello. ora ti ho battuto per 9 byte;)
— Linus,
Ah ok. Vedo cosa hai fatto. Non mi è venuto in mente di fare un conto alla rovescia di due anziché calcolare il numero effettivo di caratteri da stampare. Ben fatto.
— Brian Gradin,
2

Perl, 14 + 3 ( -lFbandiera) = 19 17 byte

Per 5.20.0+:

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

Per 5.10.0+ (19 byte):

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

Grazie a @simbabque.

— Denis Ibaev
fonte
2
È possibile salvare due byte, non è necessario impostare -ne -aperché lo -Ffa implicitamente.
— simbabque il
@simbabque Sì. Ma solo per 5.20.0+.
— Denis Ibaev,
2

Brainfuck, 20 byte

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

Provalo online.

Ciò consente di risparmiare un byte sull'approccio più semplice di consumare l'input prima di avviare il ciclo principale:

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

Pyth , 8 7 byte

<zh/lz2

Salvato 1 con grazie a @Steven H

Non la risposta Pyth più breve (della metà) ma sto facendo uno sforzo per imparare la lingua e questo è il mio primo post che la utilizzo. Postato tanto per commenti e feedback quanto altro. È anche il primo programma Pyth che devo effettivamente lavorare :)

Ora ho solo bisogno di capire come funziona la risposta a 4 byte di @Maltysen :-)

— ElPedro
fonte
1
Se vuoi ancora sapere come funziona la risposta di Maltysen, taglia cl'ingresso Qin 2pezzi e prende il primo pezzo usando h(che, grazie all'implementazione di chop, prenderà anche la lettera centrale). Per quanto riguarda il codice, è possibile sostituire +1con h, integrato per incrementare i numeri.
— Steven H.
Grazie per la spiegazione e per il hsuggerimento @Steven H. Ci sono così tanti built-in immagino ci voglia solo un po 'di tempo per trovarli tutti :)
— ElPedro
1
Nessun problema! Se hai mai bisogno di aiuto, prova a eseguire il ping nel diciannovesimo byte.
— Steven H.
2

C, 31 30 byte

Risparmio di 1 byte grazie a Cyoce.

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

Uso:

main(){
 char a[]="hellolleh";
 f(a);
 printf("%s\n",a);
}
— Karl Napf
fonte
@KevinCruijssen risolto
— Karl Napf,
Ciao, scusa ho cancellato il mio commento. Avevo ragione nel dire che non funzionerebbe nemmeno per i palindromi. Ma, poiché questo è il contrario di quell'altra sfida, non ci saranno casi di test anche per i palindromi .. Mi dispiace, puoi annullare la modifica. +1 da me. :)
— Kevin Cruijssen,
2
Bene, ora ha la stessa lunghezza, funziona anche su + dispari e sembra più golfista. Sto bene con questo.
— Karl Napf,
Questa è probabilmente una perdita di memoria :-)
— ShreevatsaR
1
Penso che puoi rimuovere lo spazio inchar* c
— Cyoce il
1

Python 2, 23 byte

lambda x:x[:len(x)/2+1]
— Rɪᴋᴇʀ
fonte
Penso che questo richieda Python 2; dovresti indicarlo nella tua risposta
— Luis Mendo,
@LuisMendo oh, grazie!
— R
1

MATLAB / Octave, 20 19 18 16 byte

1 byte di sconto prendendo in prestito un'idea dalla risposta di Easterly Irk (aggiungi 1invece di .5)
2 byte di sconto grazie a @StewieGriffin (parentesi non necessarie)

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

Provalo su Ideone .

— Luis Mendo
fonte
@StewieGriffin Grazie! Non so cosa stavo pensando ...
— Luis Mendo,
Nemmeno io: P Non è come se fosse un "trucco" di cui non sapevi ... Ne ho avuti anche alcuni :)
— Stewie Griffin,
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.