Poliglota palíndromo

15

Sua tarefa é escrever um programa que seja executado em dois idiomas diferentes e faça o seguinte:

  • Em um idioma, ele palindromiza uma determinada sequência.
    • Pegue a corda. abcde
    • Inverta a string. edcba
    • Remova o primeiro caractere. dcba
    • Cole-o na corda original. abcdedcba
  • Em outro idioma, despalindromizes uma determinada string.
    • Pegue uma corda palidromizada pelo método acima. abcdedcba
    • Pegue os personagens do começo ao meio. abcde

Lembre-se, isso é código-golfe , então o código com o menor número de caracteres (não bytes) vence.

Classificação

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

# Language 1/Language 2, N bytes

onde Nestá o tamanho do seu envio. Se você melhorar sua pontuação, poderá manter as pontuações antigas no título, identificando-as. Por exemplo:

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

Se você quiser incluir vários números no cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos ou você deseja listar as penalidades do sinalizador de intérpretes separadamente), verifique se a pontuação real é o último número no cabeçalho:

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

Você também pode transformar o nome do idioma em um link que será exibido no snippet do placar de líderes:

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

Mostrar snippet de código

code-golf palindrome polyglot Oliver Ni
fonte
@LuisMendo Um segundo ...
Oliver Ni
@LuisMendo Ok, atualizei o quesiton #
Oliver Ni #
A string irá conter novas linhas?
Erik the Outgolfer
O formato de entrada pode ser diferente nos dois idiomas? Como uma corda com citações que encerram ou sem eles
Luis Mendo
@LuisMendo Sim.
Oliver Ni

Respostas:

14

05AB1E / MATL , 10 9 caracteres

9LQ2/)%¹û

Em 05AB1E, isso palindromiza . Em MATL ele despaliza .

Explicação em 05AB1E

Esta parte do código não faz 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 é a parte que faz o trabalho:

¹     Push input again
û     Palindromize. Implicitly display

Explicação em MATL

Esta é a parte que faz o trabalho: 

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

Isso é ignorado:

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

05AB1E / Jelly , 6 caracteres

Palindromiza em 05AB1E.
Despalindromiza em geléia.

œs2Ḣ¹û

Experimente em 05AB1E

05AB1E Explicação

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

Experimente em Jelly

Explicação da geléia

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

Python 3 / JavaScript, 83 caracteres

Guardado 2 bytes graças a @LevitatingLion

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

Python palindromiza , JavaScript despalindromiza .

Tentei manter mais código constante entre os dois, mas não consegui descobrir uma boa maneira de me infiltrar .sliceno Python. Aqui está um 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
fonte
Você pode substituir x[::-1][1:]por x[-2::-1]para salvar dois caracteres.
precisa
@LevitatingLion Thank you! Eu tentei descobrir como combinar as duas fatias, mas nada parecia funcionar.
ETHproductions
5

Scala / Javascript, 106 bytes

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

Palindromiza em scala e despalindromizes em javascript.

Experimente no ideone (scala) - Aviso: realce de sintaxe incorreto

Experimente no jsfiddle (javascript).

Explicação:

Scala, como java, processa escapes unicode antes de tudo, então o scalac vê o código assim:

/**/                                //\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

O javascript é analisado assim:

/*\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
fonte
4

CJam / MATL , 18 caracteres

r_W%(;
"j9LQ2/)%";

No CJam, isso palindromiza . Em MATL ele despaliza .

Explicação em CJam

Parte de trabalho:

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

Parte fictícia:

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

Explicação em MATL

Parte fictícia:

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

Parte de trabalho:

"           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

Outra parte fictícia:

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

𝔼𝕊𝕄𝕚𝕟 / Javascript ES6, 55 caracteres

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

Try it here (ES6 browsers only).

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

Eu pensei que isso seria fácil, já que 𝔼𝕊𝕄𝕚𝕟 compila no ES6 e a maioria do ES6 pode ser executada no 𝔼𝕊𝕄𝕚𝕟. Aparentemente, estou completamente errado.

Explicação

this._verifica se a variável _existe no escopo global; 𝔼𝕊𝕄𝕚𝕟 usa Lodash e, portanto, possui_ armazenou, mas o ES6 puro não.

O segmento - - Σ(`ï+ï.Ħ⬮.Đ1`)- avalia a partir da string o código que palindromiza a entrada. Normalmente, o código seria ï+ïĦ⬮Đ1, mas eu coloco os pontos para deixar o compilador feliz .

O segmento Javascript - (x=prompt()).slice(0,-x.length/2)- despaliza uma string de um prompt.

Eu ia usar uma função (então não precisava lidar com isso prompt), mas a função de avaliação de didn't não gostava disso, então usei prompte nenhuma função para fazer o compilador feliz .

Mama Fun Roll
fonte
Uau, o compilador é 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()}

Palindromiza no JavaScript ES6, despalindromiza no JavaScript ES3. Não competindo , é apenas uma tentativa de fazer um poliglota para duas versões do mesmo idioma.

No ES3, as funções são permitidas em blocos, mas como os blocos não definem escopos, a nova função apenas substitui a primeira. No modo estrito do ES5, ele falha porque não permite que funções sejam definidas em blocos. No ES6, é permitido e, como os blocos agora definem escopos, a primeira função não é substituída.

Testado no Internet Explorer 5 (emulado) para ES3 e Node.JS e Firefox para ES6.

Gustavo Rodrigues
fonte
4

Geléia / CJam, 15 14 caracteres

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

-1 char graças a 42545 (ETHproductions)

Experimente online! (Gelatina) (Palindromização)

Intérprete CJam (Despalindromization)

Explicação da geléia:

Em Jelly, é o mesmo que \n, então é isso que Jelly vê:

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

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

Explicação CJam:

No CJam, tudo o que está e#em uma linha é um comentário. Então, é isso que CJam vê:

q_,2./m]< Code
q         All input
 _        Duplicate
  ,       Length
   2.     2.0
     /    Float division
      m]  Ceil
        < Take
Erik, o Outgolfer
fonte
@ETHproductions Opa, eu esqueci! É chamado de "rejeição", é por isso.
Erik the Outgolfer 07/11
4

Perl / JavaScript, 73 bytes

Perl retorna um palíndromo e o JavaScript 'des-palindromiza' a sequência de entrada.

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

Javascript

Assume que a string já é um palíndromo válido.

Todo o trabalho acontece na primeira seção:

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

Armazena a entrada se retorna a primeira metade (arredondada) da string. O restante do script são atribuições de variáveis ​​inúteis:

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

Experimente aqui:

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

Perl

Deve ser executado com -pl, por exemplo:

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

O código é basicamente duas substituições ( s///), mas usando =como delimitador em vez de /:

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

A primeira, substituindo prompt();console.log(s.slice(0,-s.length\/2));eg(que, reconhecidamente, atrapalhará sua string se contiver algo como "prompt;console.logs.slice0,-s.length/2;eg"...) pela 1;tqual é evaled, retornando t, a segunda substituirá o final da string ( $) pela reverse$_qual também seráeval ed e anexará a fonte original string invertida.

Experimente online!

Dom Hastings
fonte
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 em Python, despalindromiza em Nim. Abusa de sintaxe de comentário.

Python e Nim usam # para comentários. O Python não suporta comentários de bloco (exceto para cadeias de linhas múltiplas com """), mas o Nim suporta#[ comment ]# .

Nós abusamos disso para comentar o Python (no começo) para o Nim, depois usamos o seguinte ] no Python para iniciar o código do Nim, parecendo um comentário para o Python.

O código Python requer sua entrada entre aspas. O código Nim não tem essa restrição.

Testado em Python 2.7.8 e Nim 0.14.2.

Ideone it! - Python 2, palindromizante

Ideone it! - Nim, despalindromizing Aparentemente, a versão do Nim Ideone usa (0.11.2) não suporta comentários de várias linhas. Trabalhos em Nim 0.14.2.

Cobre
fonte
2

Japonês / JavaScript, 63 caracteres

Lição do dia: os poliglotas Japt / JavaScript são sempre uma má ideia ...

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

Javascript

A primeira linha define a variável $Oqcomo 1 e, em seguida, executa um no-op com $Oq &&0.

A segunda linha solicita ao usuário uma sequência de entrada, atribuindo-a à variável e $U, em seguida, cortando-a do índice 0*$U(sempre 0) para o índice -$U.length/2. Isso realiza a despalindromização necessária; o resultado é então alerted. O programa termina em um ReferenceError porque a variável $Uênão está definida.

Japt

No Japt, qualquer coisa entre cifrões é inserida diretamente no código-fonte transpilado. Fora isso, cada letra minúscula transpila para .q(, por exemplo , a menos que o caractere anterior seja outra letra minúscula; nesse caso, ela se torna "q". Um espaço é transpilado para )e todas as parênteses ausentes são adicionadas automaticamente. O programa acima transpila aproximadamente para:

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

Isso é executado como JavaScript. Oq=1;define a variável Oqcomo 1. Isso nunca é usado novamente, por isso é um no-op. O.q()é uma função que limpa STDOUT e retorna undefined; isso é falso, então a &&0 .a("l".e(...parte inteira não é executada.

A única parte que realmente importa é U.ê(). A entrada implícita coloca a sequência de entrada U, .ê()transforma-a em um palíndromo e a saída implícita envia o resultado para STDOUT.

Se entradas de função forem permitidas, o seguinte funcionará para 34 caracteres:

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

A primeira parte define uma função ES6, mas ainda é um programa completo em japonês. Teste online!

ETHproductions
fonte
2

Java / Brainfuck, 71 bytes

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

Palindromiza em BF, despalindromiza em Java.

Por uma questão de clareza, é isso que importa para o intérprete de BF:

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

em que o último loop que contém caracteres do Java lambda é ignorado porque o ponteiro aponta para um caractere nulo nesse ponto.

user8397947
fonte
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));}}

Palindromize em 05AB1E.
Despalindromize em Java 8.

Explicação 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

Explicação 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
fonte