Poliglotta palindromo

15

Il tuo compito è scrivere un programma che viene eseguito in due lingue diverse e che procede come segue:

  • In una lingua, palindromizza una determinata stringa.
    • Prendi la corda. abcde
    • Invertire la stringa. edcba
    • Rimuovi il primo personaggio. dcba
    • Incollalo sulla corda originale. abcdedcba
  • In un'altra lingua, depalindromizza una determinata stringa.
    • Prendi una stringa palidromizzata con il metodo sopra. abcdedcba
    • Ottieni i personaggi dall'inizio alla metà. abcde

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

Classifiche

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, usando il seguente modello Markdown:

# Language 1/Language 2, N bytes

dov'è Nla dimensione del tuo invio. Se si migliora il punteggio, è possibile mantenere i vecchi punteggi nel titolo, colpendoli. Per esempio:

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

Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità del flag dell'interprete), assicurarsi che il punteggio effettivo sia l' ultimo numero nell'intestazione:

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

Puoi anche rendere il nome della lingua un collegamento che verrà quindi visualizzato nello snippet della classifica:

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

Mostra snippet di codice

code-golf  palindrome  polyglot 
— Oliver Ni
fonte
@LuisMendo Un secondo ...
— Oliver Ni
@LuisMendo Okay, ho aggiornato il quesiton
— Oliver Ni
La stringa conterrà mai nuove righe?
— Erik the Outgolfer,
Il formato di input può essere diverso nelle due lingue? Come una stringa con virgolette racchiuse o senza di esse
— Luis Mendo,
@LuisMendo Sì.
— Oliver Ni,

Risposte:

14

05AB1E / MATL , 10 9 caratteri

9LQ2/)%¹û

In 05AB1E questo palindromizza . In MATL depalindromizza .

Spiegazione in 05AB1E

Questa parte del codice non fa nulla (a livello globale):

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

Questa è la parte che fa il lavoro:

¹     Push input again
û     Palindromize. Implicitly display

Spiegazione in MATL

Questa è la parte che fa il lavoro: 

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

Questo è ignorato:

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

05AB1E / Jelly , 6 personaggi

Palindromizza in 05AB1E.
Depalindromizza in gelatina.

œs2Ḣ¹û

Provalo in 05AB1E

05AB1E Spiegazione

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

Provalo in gelatina

Spiegazione della gelatina

œ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 caratteri

Salvato 2 byte grazie a @LevitatingLion

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

Python palindromizza , JavaScript depalindromizza .

Ho provato a mantenere più codice costante tra i due, ma non sono riuscito a trovare un buon modo per intrufolarmi .slicein Python. Ecco un metodo 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
È possibile sostituire x[::-1][1:]con x[-2::-1]per salvare due caratteri.
— Levitante
@LevitatingLion Grazie! Avevo provato a capire come combinare le due fette, ma nulla sembrava funzionare.
— ETHproductions
5

Scala / Javascript, 106 byte

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

Palindromizza in scala e depalindromizza in javascript.

Provalo su ideone (scala) - Attenzione: evidenziazione della sintassi errata

Provalo su jsfiddle (javascript).

Spiegazione:

Scala, come java, elabora gli escape unicode prima di ogni altra cosa, quindi scalac vede il codice in questo modo:

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

Il javascript viene analizzato in questo modo:

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

r_W%(;
"j9LQ2/)%";

In CJam questo palindromizza . In MATL depalindromizza .

Spiegazione in CJam

Parte di lavoro:

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

Parte fittizia:

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

Spiegazione in MATL

Parte fittizia:

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

Parte di lavoro:

"           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

Un'altra parte fittizia:

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

𝔼𝕊𝕄𝕚𝕟 / Javascript ES6, 55 caratteri

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

Try it here (ES6 browsers only).

Palindromizza in 𝔼𝕊𝕄𝕚𝕟, depalindromizza in Javascript ES6.

Pensavo che sarebbe stato facile, dato che 𝔼𝕊𝕄𝕚𝕟 viene compilato in ES6 e la maggior parte di ES6 può essere eseguita in 𝔼𝕊𝕄𝕚𝕟. Apparentemente, mi sbaglio completamente.

Spiegazione

this._controlla se _esiste una variabile nell'ambito globale; 𝔼𝕊𝕄𝕚𝕟 usa Lodash e quindi ha _archiviato, ma ES6 puro no.

Il segmento - - Σ(`ï+ï.Ħ⬮.Đ1`)- valuta da stringa il codice che palindromizza l'input. Normalmente, il codice sarebbe ï+ïĦ⬮Đ1, ma ho inserito i punti per rendere felice il compilatore .

Il segmento Javascript - (x=prompt()).slice(0,-x.length/2)- depalindromizza una stringa da un prompt.

Stavo per usare una funzione (quindi non dovevo occuparmene prompt), ma la funzione di valutazione di 𝔼𝕊𝕄𝕚𝕟 non mi piaceva, quindi ho usato prompte nessuna funzione per rendere felice il compilatore .

— Mama Fun Roll
fonte
Wow, il compilatore schizzinoso.
— HyperNeutrino,
4

JavaScript ES6 / JavaScript ES3, 143 byte

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()}

Palindromizza in JavaScript ES6, depalindromizza in JavaScript ES3. Non competere , è solo un tentativo di creare un poliglotta per due versioni della stessa lingua.

In ES3 le funzioni sono consentite nei blocchi, ma poiché i blocchi non definiscono gli ambiti, la nuova funzione sostituisce semplicemente la prima funzione. Nella modalità ES5 rigorosa non funziona perché non consente di definire le funzioni in blocchi. In ES6 è consentito e, poiché i blocchi ora definiscono gli ambiti, la prima funzione non viene sostituita.

Testato in Internet Explorer 5 (emulato) per ES3 e Node.JS e Firefox per ES6.

— Gustavo Rodrigues
fonte
4

Jelly / CJam, 15 14 caratteri

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

-1 carattere grazie a 42545 (ETHproductions)

Provalo online! (Gelatina) (Palindromizzazione)

Interprete CJam (depalindromizzazione)

Spiegazione della gelatina:

In Jelly, è lo stesso di \n, quindi questo è ciò che Jelly vede:

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

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

Spiegazione CJam:

In CJam, tutto ciò che segue e#su una riga è un commento. Quindi, questo è ciò che vede CJam:

q_,2./m]< Code
q         All input
 _        Duplicate
  ,       Length
   2.     2.0
     /    Float division
      m]  Ceil
        < Take
— Erik l'Outgolfer
fonte
@ETHproductions Whoops, l'ho dimenticato! Si chiama "rimbalzo", ecco perché.
— Erik the Outgolfer,
4

Perl / JavaScript, 73 byte

Perl restituisce un palindromo e JavaScript "de-palindromizza" la stringa di input.

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

JavaScript

Presuppone che la stringa sia già un palindromo valido.

Tutto il lavoro avviene nella prima sezione:

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

Memorizza l'input s, quindi restituisce la prima metà (arrotondata per eccesso) della stringa. Il resto dello script sono assegnazioni di variabili inutili:

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

Provalo qui:

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

Perl

Deve essere eseguito con -pl, ad esempio:

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

Il codice è sostanzialmente due sostituzioni ( s///), ma utilizza =come delimitatore anziché /:

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

Il primo, che sostituisce prompt();console.log(s.slice(0,-s.length\/2));eg(che, certamente, rovinerà la tua stringa se contiene qualcosa come "prompt;console.logs.slice0,-s.length/2;eg"...) con 1;tcui viene evaleditato, ritornando t, il secondo sostituisce la fine della stringa ( $) con la reverse$_quale viene quindi anche evaleditato e accoda l'origine originale stringa invertita.

Provalo online!

— Dom Hastings
fonte
3

Python 2 / Nim , 76 74 byte

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

Palindromizza in Python, depalindromizza in Nim. Sintassi dei commenti sugli abusi.

Python e Nim usano entrambi #per i commenti. Python non supporta affatto i commenti di blocco (tranne che per le stringhe multilinea con """), ma Nim lo fa con #[ comment ]#.

Abbiamo abusato di questo per commentare Python (all'inizio) per Nim, quindi usare il trailing ]in Python per avviare il codice Nim, sembrando un commento per Python.

Il codice Python richiede il suo input racchiuso tra virgolette. Il codice Nim non ha questa limitazione.

Testato su Python 2.7.8 e Nim 0.14.2.

Ideone esso! - Python 2, palindromizzante

Ideone esso! - Nim, depalindromizing Apparentemente la versione di Nim Ideone utilizza (0.11.2) non supporta i commenti multilinea. Funziona su Nim 0.14.2.

— Rame
fonte
2

Japt / JavaScript, 63 caratteri

Lezione del giorno: i poliglotti Japt / JavaScript sono sempre una cattiva idea ...

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

JavaScript

La prima riga imposta la variabile $Oqsu 1, quindi esegue una no-op con$Oq &&0 .

La seconda riga richiede all'utente una stringa di input, assegnandola alla variabile $U, quindi la divide dall'indice 0*$U(sempre 0) all'indice -$U.length/2. Ciò esegue la depalindromizzazione necessaria; il risultato viene quindi alerted. Il programma termina su ReferenceError perché variabile$Uê non è definita.

Japt

In Japt, qualsiasi cosa tra i simboli di dollaro viene inserita direttamente nel codice sorgente traspilato. A parte questo, ogni lettera minuscola si traspone ad esempio .q(, a meno che il carattere precedente non sia un'altra lettera minuscola, nel qual caso diventa "q". Uno spazio viene traspilato )e tutte le parentesi mancanti vengono aggiunte automaticamente. Il programma sopra riportato si riassume approssimativamente a:

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

Questo viene quindi eseguito come JavaScript. Oq=1;imposta la variabile Oqsu 1. Questo non viene mai più usato, quindi è un no-op. O.q()è una funzione che cancella STDOUT e ritorna undefined; questo è falso, quindi l'intero&&0 .a("l".e(... parte non viene eseguita.

L'unica parte che conta davvero è U.ê(). L'input implicito inserisce la stringa di input U, la .ê()trasforma in un palindromo e l'output implicito invia il risultato a STDOUT.

Se sono consentite voci di funzione, per 34 caratteri funzionerà quanto segue:

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

La prima parte definisce una funzione ES6, ma è ancora un programma completo in Japt. Provalo online!

— ETHproductions
fonte
2

Java / Brainfuck, 71 byte

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

Palindromizza in BF, depalindromizza in Java.

Per motivi di chiarezza, questo è ciò che conta per l'interprete BF:

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

dove l'ultimo ciclo contenente caratteri dalla lambda Java viene saltato perché il puntatore punta a un carattere null in quel punto.

— user8397947
fonte
0

05AB1E / Java 8, 102 caratteri

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

Palindromizza in 05AB1E.
Depalindromize in Java 8.

Spiegazione 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

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