¡Depalindromize esta cadena!

48

Dado un palíndromo generado de acuerdo con este desafío , despalindromécelo.

Casos de prueba

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

Como se trata de despalindromizar, su código no puede ser un palíndromo .

Recuerde, esto es código golf , por lo que gana el código con la menor cantidad de bytes.

code-golf  restricted-source  palindrome 
— Oliver Ni
fuente
23
-1 por la restricción inútil de que tu código no sea un palíndromo. No agrega nada al desafío de la OMI, en muy pocos idiomas importaría.
— Rɪᴋᴇʀ
25
+1 para la restricción. Es un reflejo del desafío paliondrome ... y agrega desafío a esolangs. Me gusta. ¿Estoy en lo cierto al suponer que la entrada siempre tendrá una longitud desigual?
— Titus
42
La restricción de no palíndromo es probablemente una broma basada en el desafío anterior. ¿Alguien realmente votó en contra de eso?
— Luis Mendo
55
Previene soluciones de un solo byte. @diynevala +1 para el innecesario +1.
— Adám
55
¿Qué pasa si la cuerda no es un palíndromo para empezar?
— Xavon_Wrentaile

Respuestas:

6

Python 2, 23 bytes

No puedo probar en mi teléfono, pero esto debería funcionar:

lambda s:s[:-~len(s)/2]
— Kade
fuente
2
Si está ejecutando en Android, puede usar QPython desde la tienda de Google Play. Es lo mejor que he encontrado :)
— Yytsi
termux apt-get install python2
— Matt
@Matt Eso es exagerado si todo lo que quieres es Python.
— mbomb007
@Matt además de eso, si puedes encontrarlo apt-geten tu teléfono, probablemente no sea un teléfono normal.
— Legal Lazy
@MathManiac termux se instala desde Google Play en cualquier teléfono Android no rooteado. No puede ser mucho más normal que eso.
— Matt
6

Guacamole Octo Fuzzy, 4 bytes

2.^/

Pasé un tiempo buscando un idioma en el que este desafío es corto, y me di cuenta de que era tonto y mi propio idioma lo hizo.

— Rɪᴋᴇʀ
fuente
4

JavaScript (ES6), 32 26 25 bytes

1 byte guardado gracias a Neil:

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

Mostrar fragmento de código

Soluciones anteriores
26 bytes gracias a Downgoat:

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

32 bytes:

s=>s.slice(0,(l=s.length/2)+l%2)
— Hedi
fuente
1
Puede acortar a solo s=>s.slice(0,s.length/2+1)Dado que la longitud siempre será extraña
— Downgoat el
@Downgoat gracias a ti, descubrí que un byte s=>s.slice(0,s.length/2+.5)más también funcionaría para una longitud uniforme.
— Hedi
2
-s.length/2funciona tanto para longitudes pares como impares.
— 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 al no insertar NULL, en lugar de pasar la longitud a da

La entrada se pasa a través de una dirección en psuedo-register $t0. Por ejemplo:

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.

Funciona reemplazando la derecha de char medio (o derecha-media si la cadena tiene una longitud uniforme) con un valor nulo y luego imprime la cadena desde la dirección de memoria 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

Salida:

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"
— Leche
fuente
3

Haskell, 27 bytes

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

Versión de Pointfree de

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

que también es de 27 bytes.

— nimi
fuente
3

MATL , 7 6 bytes

9LQ2/)

Pruébalo en línea!

Explicación

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
fuente
1
Wow, esa es una forma muy ordenada de manejar valores complejos como argumentos para rebanar
— millas
@miles ¡Gracias! Sí, es útil. La unidad imaginaria funciona como end, y los dos puntos entre los elementos de la matriz están implícitos
— Luis Mendo
3

Brachylog , 4 bytes

@2tr

Pruébalo en línea!

Explicación

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

Si la entrada tiene una longitud impar, la segunda mitad generada por @2es la más larga, es la que deberíamos devolver (después de revertirla).

— Fatalizar
fuente
3

Perl, 15 bytes

Incluye +2 para -lp

Dar cadena de entrada en STDIN:

depal.pl <<< "HelleH"

depal.pl:

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

No -les realmente necesario si ingresa el palíndromo sin una nueva línea final, pero lo incluí para ser justo con las otras soluciones de Perl que lo usan.

— Ton Hospel
fuente
2

TI-Basic, 14 bytes

Función estándar. Devuelve la cadena del índice 1 al índice (longitud / 2 + 1/2).

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

Lenguaje GameMaker, 59 bytes

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

PHP, 40 bytes

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

strlen($a)/2se convierte en int, con la entrada siempre con una longitud impar, es +1suficiente para redondear.

42 bytes para cualquier longitud:

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

para longitud desconocida, (1+strlen)/2se lanza a int, redondeando strlen/2.

— Titus
fuente
Como la entrada se define como proveniente de este desafío ( codegolf.stackexchange.com/questions/98325/… ), su longitud siempre será extraña, por lo que puede ir con la más corta.
— user59178
2

Dip, 8 bytes

H{C'0ÏEI

Explicación:

           # 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

Esto probablemente podría mejorarse mucho.

— Oliver Ni
fuente
2

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

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

Sin golf:

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

Gracias a @ardnew.

— Denis Ibaev
fuente
1
puedes guardar 3 caracteres reemplazándolos length()cony|||c
— ardnew
2

Befunge , 24 22 bytes

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

Pruébalo en línea!

Befunge no tiene tipo de cadena o matriz, por lo que todo se hace en la pila de un carácter a la vez. El primer bucle (en la línea superior) cuenta el número de caracteres leídos (el intercambio con menos de 2 elementos en la pila produce un 0 inicial). El segundo (en la línea media) imprime caracteres mientras realiza la cuenta regresiva el doble de rápido. Como resultado, solo se imprime la última mitad de la entrada, pero LIFO, por lo que está en el orden correcto.

Gracias a Brian Gradin por una mejor versión del primer bucle.

— Linus
fuente
1
Me ganaste
— Brian Gradin el
@BrianGradin, bien. ahora te he vencido te he ganado por 9 bytes;)
— Linus
Ah ok Ya veo lo que hiciste. No se me ocurrió hacer una cuenta regresiva de dos en lugar de calcular el número real de caracteres para imprimir. Bien hecho.
— Brian Gradin el
2

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

Sin golf:

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

Gracias a @simbabque.

— Denis Ibaev
fuente
2
Puede guardar dos bytes, no necesita configurarlo -ny -aporque lo -Fhace implícitamente.
— simbabque
@simbabque Sí. Pero solo por 5.20.0+.
— Denis Ibaev el
2

Brainfuck, 20 bytes

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

Pruébalo en línea.

Esto ahorra un byte sobre el enfoque más directo de consumir la entrada antes de comenzar el ciclo principal:

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

Pyth , 8 7 bytes

<zh/lz2

Guardado 1 con gracias a @Steven H

No es la respuesta Pyth más corta (a la mitad), pero estoy haciendo un esfuerzo por aprender el idioma y esta es mi primera publicación que lo uso. Publicado tanto para comentarios y comentarios como cualquier cosa. También es el primer programa Pyth que realmente tengo que trabajar :)

Ahora solo necesito averiguar cómo funciona la respuesta de 4 bytes de @Maltysen :-)

— ElPedro
fuente
1
Si aún desea saber cómo funciona la respuesta de Maltysen, csalta la entrada Qen 2pedazos y toma la primera pieza usando h(que, gracias a la implementación de chop, también tomará la letra central). En cuanto a su código, puede reemplazarlo +1con hel incorporado para aumentar los números.
— Steven H.
Gracias por la explicación y por la hpista @Steven H. Hay tantos complementos que supongo que solo toma un tiempo encontrarlos a todos :)
— ElPedro
1
¡No hay problema! Si alguna vez necesitas ayuda, intenta enviarme un ping en el decimonoveno byte.
— Steven H.
2

C, 31 30 bytes

Ahorro de 1 byte gracias a Cyoce.

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

Uso:

main(){
 char a[]="hellolleh";
 f(a);
 printf("%s\n",a);
}
— Karl Napf
fuente
@KevinCruijssen corregido
— Karl Napf
Hola, lo siento, borré mi comentario. Estaba en lo cierto al decir que no funcionará incluso para palíndromos. Pero, dado que este es el reverso de ese otro desafío, no habrá ningún caso de prueba ni siquiera para palíndromos. Lo siento, puede deshacer su cambio. +1 de mi parte :)
— Kevin Cruijssen
2
Bueno, ahora tiene la misma longitud, funciona para pares + impares y se ve más golfista. Estoy bien con esto.
— Karl Napf
Esto podría decirse que es una pérdida de memoria :-)
— ShreevatsaR
1
Creo que puedes eliminar el espacio enchar* c
— Cyoce
1

MATLAB / Octave, 20 19 18 16 bytes

1 byte sin tomar prestada una idea de la respuesta de Easterly Irk (agregar en 1lugar de .5)
2 bytes de descuento gracias a @StewieGriffin (paréntesis innecesarios)

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

Pruébalo en Ideone .

— Luis Mendo
fuente
@StewieGriffin ¡Gracias! No sé lo que estaba pensando ...
— Luis Mendo
Yo tampoco: P No es como si fuera un "truco" del que no sabías ... También he tenido algunos de esos :)
— Stewie Griffin
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.