Políglota Palindrome

15

Su tarea es escribir un programa que se ejecute en dos idiomas diferentes y haga lo siguiente:

  • En un idioma, palindromiza una cadena dada.
    • Toma la cuerda. abcde
    • Invierte la cuerda. edcba
    • Elimina el primer personaje. dcba
    • Pégalo en la cuerda original. abcdedcba
  • En otro idioma, despalindromiza una cadena dada.
    • Tome una cuerda palidromizada por el método anterior. abcdedcba
    • Consigue los personajes desde el principio hasta el medio. abcde

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

Tablas de clasificación

Aquí hay un fragmento de pila para generar una tabla de clasificación regular y una descripción general de los ganadores por idioma.

Para asegurarse de que su respuesta se muestre, comience con un título, usando la siguiente plantilla de Markdown:

# Language 1/Language 2, N bytes

¿Dónde Nestá el tamaño de su envío? Si mejora su puntaje, puede mantener los puntajes antiguos en el título, tachándolos. Por ejemplo:

# Ruby/Python, <s>104</s> <s>101</s> 96 bytes

Si desea incluir varios números en su encabezado (por ejemplo, porque su puntaje es la suma de dos archivos o desea enumerar las penalizaciones de la bandera del intérprete por separado), asegúrese de que el puntaje real sea el último número en el encabezado:

# Perl/C, 43 + 2 (-p flag) = 45 bytes

También puede hacer que el nombre del idioma sea un enlace que luego aparecerá en el fragmento de la tabla de clasificación:

# [><>](http://esolangs.org/wiki/Fish)/Python, 121 bytes

Mostrar fragmento de código

code-golf  palindrome  polyglot 
— Oliver Ni
fuente
@LuisMendo Un segundo ...
— Oliver Ni
@LuisMendo Bien, he actualizado la pregunta
— Oliver Ni el
¿La cadena contendrá alguna vez nuevas líneas?
— Erik the Outgolfer
¿Puede el formato de entrada ser diferente en los dos idiomas? Como una cadena con comillas encerradas o sin ellas
— Luis Mendo
@LuisMendo Sí.
— Oliver Ni

Respuestas:

14

05AB1E / MAT , 10 9 caracteres

9LQ2/)%¹û

En 05AB1E esto palindromiza . En MATL se despalindromiza .

Explicación en 05AB1E

Esta parte del código no hace nada (globalmente):

9L    Pushes array [1, 2, ... 9]
Q     Consumes the array, takes the input implicitly, and produces no output
2/    With no further input to take implicitly, this gives no output
)     Wrap stack into an array: gives an empty array
%     Consumes that array and, with no further input to take implicitly, gives no ouput

Esta es la parte que hace el trabajo:

¹     Push input again
û     Palindromize. Implicitly display

Explicación en MATL

Esta es la parte que hace el trabajo: 

9L    Push array [0, 1j]
Q2/   Add 1, divide by two: transforms into [1/2, (1+1j)/2]
)     Use as index into implicit input. [1/2, (1+1j)/2] is interpreted as
      1/2:(end+1)/2, which is rounded to 1:(end+1)/2. So this takes elements
      from first to half, including both. Implicitly display

Esto se ignora:

%¹û   Everything after '%' is a comment
— Luis Mendo
fuente
12

05AB1E / Jelly , 6 caracteres

Palindromiza en 05AB1E.
Despalindromiza en gelatina.

œs2Ḣ¹û

Pruébalo en 05AB1E

05AB1E Explicación

œ       # compute powerset of input
 s      # swap (does nothing)
  2     # push 2
   Ḣ    # does nothing
    ¹û  # palindromize input

Pruébalo en gelatina

Explicación de gelatina

œs2     # split input in 2 chunks (first chunk is larger for odd length strings)
   Ḣ    # head, take first
    ¹û  # does nothing
— Emigna
fuente
6

Python 3 / JavaScript, 83 caracteres

Guardado 2 bytes gracias a @LevitatingLion

1//2;x=input();print(x+x[-2::-1]);"""
x=prompt();alert(x.slice(0,-x.length/2))//"""

Python palindromiza , JavaScript despalindromiza .

Traté de mantener más código constante entre los dos, pero no pude encontrar una buena manera de colarse .sliceen Python. Aquí hay un método alternativo:

1//2;prompt=input,alert=print
x=prompt();1//2;x+=x[-2::-1]);"""
x=x.slice(0,-x.length/2))//"""
alert(x)
— ETHproductions
fuente
Puede reemplazar x[::-1][1:]con x[-2::-1]para guardar dos caracteres.
— LevitatingLion
@LevitatingLion ¡Gracias! Traté de descubrir cómo combinar las dos rebanadas, pero nada parecía funcionar.
— ETHproductions
5

Scala / Javascript, 106 bytes

/*\u002A/print(args(0)+args(0).reverse.tail)//*/
/*/**/
alert((s=prompt()).slice(0,-s.length/2))//\u000A*/

Palindromizes en Scala y Depalindromizes en JavaScript.

Pruébalo en ideone (scala) - Advertencia: resaltado de sintaxis incorrecta

Pruébalo en jsfiddle (javascript).

Explicación:

Scala, como Java, procesa escapes Unicode antes que todo lo demás, por lo que Scalac ve el código de esta manera:

/**/                                //\u002A is as asterisk, results in an empty block comment
print(args(0)+args(0).reverse.tail) //scala code
//*/                                //a line comment
/*                                  //scala supports nested block comments, so this comment...
  /*
  */
  alert((s=prompt()).slice(0,-s.length/2)) 
  //                                  //\u000A (newline) inserted here
*/                                  //...ends here

El JavaScript se analiza de esta manera:

/*\u002A/print(args(0)+args(0).reverse.tail)//*/ //block comment
/*                                               //a block comment...
  /*
*/                                               //...ending here, no nesting
alert((s=prompt()).slice(0,-s.length/2))         //code
//\u000A*/                                       //line comment
— corvus_192
fuente
4

Cjam / MAT , 18 caracteres

r_W%(;
"j9LQ2/)%";

En CJam esto palindromiza . En MATL despalindromiza .

Explicación en CJam

Parte de trabajo:

r           Read string
_           Duplicate
W%          Reverse
(;          Remove first element

Parte ficticia:

"j9LQ2/)%"  Push this string
;           Remove it from the stack
            Implicitly display both strings obtained previously

Explicación en MATL

Parte ficticia:

r           Push random number between 0 and 1
_           Negate
W           2 raised to that
%(;  Comment (ignored)

Parte de trabajo:

"           For each element in the array at the top of the stack. Since it is a number,
            which is the same as a length-1 array, the following is executed once
  j         Input string
  9L        Push array [0, 1j]
  Q2/       Add 1, divide by 2: transforms into [1/2, (1+1j)/2]
  )         Use as index. [1/2, (1+1j)/2] is interpreted as 1/2:(end+1)/2, which is
            rounded to 1:(1+end)/2. So this takes elements from first to half,
            including both

Otra parte ficticia:

   %";      Comment (ignored)
            Implicitly display the previously obtained string
— Luis Mendo
fuente
4

𝔼𝕊𝕄𝕚𝕟 / Javascript ES6, 55 caracteres

this._?Σ(`ï+ï.Ħ⬮.Đ1`):(x=prompt()).slice(0,-x.length/2)

Try it here (ES6 browsers only).

Palindromiza en 𝔼𝕊𝕄𝕚𝕟, despalindromiza en Javascript ES6.

Pensé que esto iba a ser fácil, ya que 𝔼𝕊𝕄𝕚𝕟 compila a ES6 y la mayoría de ES6 se puede ejecutar en 𝔼𝕊𝕄𝕚𝕟. Aparentemente, estoy completamente equivocado.

Explicación

this._comprueba si _existe una variable en el ámbito global; 𝔼𝕊𝕄𝕚𝕟 usa Lodash y por lo tanto tiene_ almacenado, pero el ES6 puro no.

El segmento - - Σ(`ï+ï.Ħ⬮.Đ1`)- evalúa desde la cadena el código que palindromiza la entrada. Normalmente, el código sería ï+ïĦ⬮Đ1, pero puse los puntos para hacer feliz al compilador .

El segmento Javascript - (x=prompt()).slice(0,-x.length/2)- depalindromiza una cadena de una solicitud.

Iba a usar una función (por lo que no tenía que lidiar prompt), pero la función de evaluación de 𝔼𝕊𝕄𝕚𝕟 no me gustó, así que usé prompty ninguna función para hacer feliz al compilador .

— Mama Fun Roll
fuente
Wow, el compilador es exigente.
— HyperNeutrino
4

JavaScript ES6 / JavaScript ES3, 143 bytes

function(x){'use strict';function a(){return x+x.split('').reverse().slice(1).join('')}{function a(){return x.slice(0,-x.length/2)}}return a()}

Palindromizes en JavaScript ES6, despalindromizes en JavaScript ES3. No competidor , es solo un intento de hacer un políglota para dos versiones del mismo idioma.

En ES3, las funciones están permitidas en bloques, pero como los bloques no definen ámbitos, la nueva función simplemente reemplaza a la primera función. En el modo estricto ES5 falla porque no permite que las funciones se definan en bloques. En ES6 está permitido y, dado que los bloques ahora definen ámbitos, la primera función no se reemplaza.

Probado en Internet Explorer 5 (emulado) para ES3 y Node.JS y Firefox para ES6.

— Gustavo Rodrigues
fuente
4

Jelly / CJam, 15 14 caracteres

q_,2./m]<e#¶ŒB

-1 char gracias a 42545 (ETHproductions)

Pruébalo en línea! (Gelatina) (Palindromización)

Intérprete de CJam (despalindromización)

Explicación de gelatina:

En Jelly, es lo mismo que \n, así que esto es lo que Jelly ve:

q_,2./m]<e#
ṖṚṭ

ṖṚṭ         Main link. Arguments: z
Ṗ           Pop
 Ṛ          Reverse
  ṭ         Append
   ⁸        (implicit) z

Explicación de CJam:

En CJam, todo lo que sigue e#en una línea es un comentario. Entonces, esto es lo que ve CJam:

q_,2./m]< Code
q         All input
 _        Duplicate
  ,       Length
   2.     2.0
     /    Float division
      m]  Ceil
        < Take
— Erik el Outgolfer
fuente
@ETHproductions ¡Vaya, lo olvidé! Se llama "rebote", por eso.
— Erik the Outgolfer
4

Perl / JavaScript, 73 bytes

Perl devuelve un palíndromo y JavaScript 'despalindiza' la cadena de entrada.

s=prompt();console.log(s.slice(0,-s.length/2));eg=1;t=eg;s=$=reverse$_=eg

JavaScript

Asume que la cadena ya es un palíndromo válido.

Todo el trabajo sucede en la primera sección:

s=prompt();console.log(s.slice(0,-s.length/2));

Almacena la entrada s, luego devuelve la primera mitad (redondeada) de la cadena. El resto del script son asignaciones de variables sin sentido:

eg=1;t=eg;s=$=reverse$_=eg

Pruébalo aquí:

s=prompt();console.log(s.slice(0,-s.length/2));eg=1;t=eg;s=$=reverse$_=eg
Expandir fragmento

Perl

Debe ejecutarse con -pl, por ejemplo:

perl -ple 's=prompt();console.log(s.slice(0,-s.length/2));eg=1;t=eg;s=$=reverse$_=eg' <<< 'test'
# returns testtset

El código es básicamente dos sustituciones ( s///), pero se usa =como delimitador en lugar de /:

s/prompt();console.log(s.slice(0,-s.length\/2));eg/1;t/eg;s/$/reverse$_/eg

El primero, reemplazando prompt();console.log(s.slice(0,-s.length\/2));eg(que, sin duda, estropeará su cadena si contiene algo así como "prompt;console.logs.slice0,-s.length/2;eg"...) con el 1;tque se evaledita, regresando t, el segundo reemplaza el final de la cadena ( $) con el reverse$_que también se evaledita y agrega la fuente original cuerda invertida.

Pruébalo en línea!

— Dom Hastings
fuente
3

Python 2 / Nim , 76 74 bytes

#[
s=input();print s+s[-2::-1]#let s=stdin.readLine;echo s[0..s.len div 2]

Palindromiza en Python, despalindromiza en Nim. Abusa de la sintaxis de comentarios.

Python y Nim ambos usan #para comentarios. Python no admite comentarios en bloque (excepto para cadenas multilínea con """), pero Nim sí #[ comment ]#.

Abusamos de esto para comentar el Python (al principio) para Nim, luego usamos el seguimiento ]en Python para iniciar el código de Nim, como un comentario para Python.

El código Python requiere su entrada rodeada de comillas. El código Nim no tiene esta restricción.

Probado en Python 2.7.8 y Nim 0.14.2.

Ideone it! - Python 2, palindromizante

Ideone it! - Nim, despalindromizando Aparentemente, la versión de Nim Ideone utiliza (0.11.2) no admite comentarios multilínea. Funciona en Nim 0.14.2.

— Cobre
fuente
2

Japt / JavaScript, 63 caracteres

Lección del día: los políglotas de Japt / JavaScript son siempre una mala idea ...

$Oq=1;$Oq &&0
alert(($U=prompt()).slice(0*$U,-$U.length/2));$Uê

JavaScript

La primera línea establece la variable $Oqen 1, luego realiza una operación no con $Oq &&0.

La segunda línea solicita al usuario una cadena de entrada, asignándola a la variable $U, luego la corta del índice 0*$U(siempre 0) al índice -$U.length/2. Esto realiza la despalindromización necesaria; El resultado es entonces alerted. El programa termina en un ReferenceError porque variable$Uê no está definida.

Japt

En Japt, cualquier cosa entre signos de dólar se inserta directamente en el código fuente transpilado. Aparte de eso, cada letra minúscula se transmite a .q(, por ejemplo , a menos que el carácter anterior fuera otra letra minúscula, en cuyo caso se convierte "q". Se transpira un espacio )y todos los parentes faltantes se agregan automáticamente. El programa anterior se transmite aproximadamente a:

Oq=1;O.q()&&0
.a("l".e("r".t((U=prompt()).slice(0*U,-U.length/2))));U.ê()

Esto luego se ejecuta como JavaScript. Oq=1;establece la variable Oqen 1. Esto nunca se usa de nuevo, por lo que es un no-op. O.q()es una función que borra STDOUT y regresa undefined; esto es falso, entonces todo el&&0 .a("l".e(... no se ejecuta parte.

La única parte que realmente importa es U.ê(). La entrada implícita coloca la cadena de entrada U, la .ê()convierte en un palíndromo y la salida implícita envía el resultado a STDOUT.

Si se permiten entradas de funciones, lo siguiente funcionará para 34 caracteres:

X=>($X=X).slice(0,-X.length/2);$Uê

La primera parte define una función ES6, pero sigue siendo un programa completo en Japt. ¡Pruébalo en línea!

— ETHproductions
fuente
2

Java / Brainfuck, 71 bytes

/*+[,>]<[<]>[.>]<<[.<][*/a->a.substring(0,Math.ceil(a.length()/2d));//]

Palindromiza en BF, despalindromiza en Java.

En aras de la claridad, esto es lo que le importa al intérprete de BF:

+[,>]<[<]>[.>]<<[.<][->,..]

donde se omite el último bucle que contiene caracteres de la lambda de Java porque el puntero apunta a un carácter nulo en ese punto.

— usuario8397947
fuente
0

05AB1E / Java 8, 102 caracteres

//¹ûq
interface M{static void main(String[]a){System.out.print(a[0].substring(0,a[0].length()/2+1));}}

Palindromizar en 05AB1E.
Depalindromize en Java 8.

Explicación 05AB1E:

//     # No-ops
¹      # First input
 û     # Palindromize it
  q    # Terminate the program
interface M{static void main(String[]a){System.out.print(a[0].substring(0,a[0].length()/2+1));}}
       # No-ops

Explicación Java 8:

//¹ûq                           // No-ops
interface M{                    // Class
  static void main(String[]a){  //  Mandatory main-method
    System.out.print(           //   Print to STDOUT:
      a[0].substring(0,         //    The substring of the input-argument from index 0 to
        a[0].length()/2+1));}}  //    the length of the input integer-divided by 2 plus 1
— Kevin Cruijssen
fuente
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.