Palindrome polyglotte

15

Votre tâche consiste à écrire un programme qui s'exécute dans deux langues différentes et effectue les opérations suivantes:

  • Dans une langue, il palindromise une chaîne donnée.
    • Prenez la ficelle. abcde
    • Inversez la chaîne. edcba
    • Supprimez le premier caractère. dcba
    • Collez-le sur la chaîne d'origine. abcdedcba
  • Dans une autre langue, il dépalindromise une chaîne donnée.
    • Prenez une chaîne palidromisée par la méthode ci-dessus. abcdedcba
    • Obtenez les personnages du début au milieu. abcde

N'oubliez pas qu'il s'agit de code-golf , donc le code avec le moins de caractères (pas d'octets) l'emporte.

Classements

Voici un extrait de pile pour générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, veuillez commencer votre réponse avec un titre, en utilisant le modèle de démarque suivant:

# Language 1/Language 2, N bytes

où Nest la taille de votre soumission. Si vous améliorez votre score, vous pouvez conserver les anciens scores dans le titre, en les barrant. Par exemple:

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

Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers ou que vous souhaitez répertorier les pénalités de drapeau d'interprète séparément), assurez-vous que le score réel est le dernier numéro de l'en-tête:

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

Vous pouvez également faire du nom de la langue un lien qui apparaîtra ensuite dans l'extrait de classement:

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

Afficher l'extrait de code

code-golf  palindrome  polyglot 
— Oliver Ni
source
@LuisMendo Une seconde ...
— Oliver Ni
@LuisMendo D'accord, j'ai mis à jour la quesiton
— Oliver Ni
La chaîne contiendra-t-elle un jour des nouvelles lignes?
— Erik the Outgolfer
Le format d'entrée peut-il être différent dans les deux langues? Comme une chaîne avec des guillemets ou sans eux
— Luis Mendo
@LuisMendo Oui.
— Oliver Ni

Réponses:

14

05AB1E / MATL , 10 9 caractères

9LQ2/)%¹û

Dans 05AB1E, cela palindromise . En MATL, il dépalindromise .

Explication dans 05AB1E

Cette partie du code ne fait rien (globalement):

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

C'est la partie qui fait le travail:

¹     Push input again
û     Palindromize. Implicitly display

Explication en MATL

C'est la partie qui fait le travail: 

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

Ceci est ignoré:

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

05AB1E / Gelée , 6 personnages

Palindromise dans 05AB1E.
Dépalindromise en gelée.

œs2Ḣ¹û

Essayez-le dans 05AB1E

05AB1E Explication

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

Essayez-le dans Jelly

Explication de la gelée

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

Python 3 / JavaScript, 83 caractères

Enregistré 2 octets grâce à @LevitatingLion

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

Python palindromise , JavaScript dépalindromise .

J'ai essayé de garder plus de code constant entre les deux, mais je n'ai pas pu trouver un bon moyen de me faufiler .slicedans Python. Voici une autre méthode:

1//2;prompt=input,alert=print
x=prompt();1//2;x+=x[-2::-1]);"""
x=x.slice(0,-x.length/2))//"""
alert(x)
— ETHproductions
source
Vous pouvez remplacer x[::-1][1:]par x[-2::-1]pour enregistrer deux caractères.
— LevitatingLion
@LevitatingLion Merci! J'avais essayé de comprendre comment combiner les deux tranches, mais rien ne semblait fonctionner.
— ETHproductions
5

Scala / Javascript, 106 octets

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

Palindromise en scala et dépalindromise en javascript.

Essayez-le sur ideone (scala) - Attention: mauvaise coloration syntaxique

Essayez-le sur jsfiddle (javascript).

Explication:

Scala, comme java, traite les échappements unicode avant tout, donc scalac voit le code comme ceci:

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

Le javascript est analysé comme ceci:

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

CJam / MATL , 18 caractères

r_W%(;
"j9LQ2/)%";

Dans CJam, cela palindromise . En MATL, il dépalindromise .

Explication dans CJam

Partie de travail:

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

Partie factice:

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

Explication en MATL

Partie factice:

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

Partie de travail:

"           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

Une autre partie factice:

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

𝔼𝕊𝕄𝕚𝕟 / Javascript ES6, 55 caractères

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

Try it here (ES6 browsers only).

Palindromise en 𝔼𝕊𝕄𝕚𝕟, dépalindromise en Javascript ES6.

Je pensais que cela allait être facile, car 𝔼𝕊𝕄𝕚𝕟 se compile en ES6 et la plupart d'ES6 peuvent être exécutés en 𝔼𝕊𝕄𝕚𝕟. Apparemment, je me trompe complètement.

Explication

this._vérifie si la variable _existe dans la portée globale; 𝔼𝕊𝕄𝕚𝕟 utilise Lodash et a donc _stocké, mais pas ES6 pur.

Le segment - - Σ(`ï+ï.Ħ⬮.Đ1`)- évalue à partir d'une chaîne le code qui palindromise l'entrée. Normalement, le code serait ï+ïĦ⬮Đ1, mais j'ai mis les points pour rendre le compilateur heureux .

Le segment Javascript - (x=prompt()).slice(0,-x.length/2)- dépalindromise une chaîne à partir d'une invite.

J'allais utiliser une fonction (donc je n'avais pas à m'en occuper prompt), mais la fonction d'évaluation de didn't n'aimait pas ça, alors j'ai utilisé promptet aucune fonction pour rendre le compilateur heureux .

— Mama Fun Roll
source
Wow, pointilleux du compilateur.
— HyperNeutrino
4

JavaScript ES6 / JavaScript ES3, 143 octets

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

Palindromise dans JavaScript ES6, dépalindromise dans JavaScript ES3. Non compétitif , c'est juste un essai de faire un polyglotte pour deux versions de la même langue.

Dans ES3, les fonctions sont autorisées dans les blocs, mais comme les blocs ne définissent pas les étendues, la nouvelle fonction remplace simplement la première fonction. En mode strict ES5, il échoue car il ne permet pas de définir des fonctions dans des blocs. Dans ES6, c'est autorisé et, comme les blocs définissent désormais les étendues, la première fonction n'est pas remplacée.

Testé dans Internet Explorer 5 (émulé) pour ES3 et Node.JS et Firefox pour ES6.

— Gustavo Rodrigues
source
4

Jelly / CJam, 15 14 caractères

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

-1 char grâce à 42545 (ETHproductions)

Essayez-le en ligne! (Gelée) (Palindromisation)

Interprète CJam (Depalindromization)

Explication de la gelée:

Dans Jelly, c'est la même chose \n, c'est donc ce que Jelly voit:

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

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

Explication CJam:

Dans CJam, tout ce qui suit e#sur une ligne est un commentaire. Voici donc ce que CJam voit:

q_,2./m]< Code
q         All input
 _        Duplicate
  ,       Length
   2.     2.0
     /    Float division
      m]  Ceil
        < Take
— Erik le Outgolfer
source
@ETHproductions Oups, je l'ai oublié! Cela s'appelle "rebondir", c'est pourquoi.
— Erik the Outgolfer
4

Perl / JavaScript, 73 octets

Perl renvoie un palindrome et JavaScript «dé-palindromise» la chaîne d'entrée.

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

Javascript

Suppose que la chaîne est déjà un palindrome valide.

Tout le travail se passe dans la première section:

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

Stocke l'entrée dans s, puis retourne la première moitié (arrondie) de la chaîne. Le reste du script est des affectations de variables inutiles:

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

Essayez-le ici:

s=prompt();console.log(s.slice(0,-s.length/2));eg=1;t=eg;s=$=reverse$_=eg
Développer l'extrait

Perl

Doit être exécuté avec -pl, par exemple:

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

Le code est essentiellement deux substitutions ( s///), mais en utilisant =comme délimiteur au lieu de /:

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

Le premier, remplaçant prompt();console.log(s.slice(0,-s.length\/2));eg(qui, certes, gâchera votre chaîne s'il contient quelque chose comme "prompt;console.logs.slice0,-s.length/2;eg"...) avec 1;tlequel est evalédité, retournant t, le second remplace la fin de la chaîne ( $) par reverse$_laquelle est également evaléditée et ajoute la source d'origine chaîne inversée.

Essayez-le en ligne!

— Dom Hastings
source
3

Python 2 / Nim , 76 74 octets

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

Palindromise en Python, dépalindromise en Nim. Abuse la syntaxe des commentaires.

Python et Nim utilisent tous les deux #pour les commentaires. Python ne prend pas du tout en charge les commentaires de bloc (sauf pour les chaînes multilignes avec""" ), mais Nim le fait avec #[ comment ]#.

Nous en abusons pour commenter le Python (au début) pour Nim, puis utilisons la fin ] du Python pour démarrer le code Nim, ressemblant à un commentaire pour Python.

Le code Python nécessite son entrée entourée de guillemets. Le code Nim n'a pas cette restriction.

Testé sur Python 2.7.8 et Nim 0.14.2.

Ideone it! - Python 2, palindromisant

Ideone it! - Nim, depalindromizing Apparemment, la version de Nim Ideone utilise (0.11.2) ne prend pas en charge les commentaires multilignes. Fonctionne sur Nim 0.14.2.

— Cuivre
source
2

Japt / JavaScript, 63 caractères

Leçon du jour: les polyglottes Japt / JavaScript sont toujours une mauvaise idée ...

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

Javascript

La première ligne définit la variable $Oqsur 1, puis effectue un no-op avec $Oq &&0.

La deuxième ligne invite l'utilisateur à saisir une chaîne d'entrée, l'affectant à la variable $U, puis la tranche d'index 0*$U(toujours 0) à index -$U.length/2. Cela effectue la dépalindromisation nécessaire; le résultat est ensuite alertédité. Le programme se termine sur une ReferenceError car la variable$Uê n'est pas définie.

Japt

Dans Japt, tout ce qui se trouve entre les signes dollar est inséré directement dans le code source transpilé. En dehors de cela, chaque lettre minuscule transpile par exemple .q(, sauf si le caractère précédent était une autre lettre minuscule, auquel cas elle devient "q". Un espace est transpilé )et toutes les parenthèses manquantes sont automatiquement ajoutées. Le programme ci-dessus se transforme approximativement en:

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

Ceci est ensuite exécuté en JavaScript. Oq=1;définit la variable Oqsur 1. Ceci n'est plus jamais utilisé, c'est donc un no-op. O.q()est une fonction qui efface STDOUT et renvoie undefined; c'est faux, donc tout&&0 .a("l".e(... partie n'est pas exécutée.

La seule partie qui compte vraiment est U.ê(). L'entrée implicite place la chaîne d'entrée U, la .ê()transforme en palindrome et la sortie implicite envoie le résultat à STDOUT.

Si les entrées de fonction sont autorisées, les éléments suivants fonctionneront pour 34 caractères:

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

La première partie définit une fonction ES6, mais c'est toujours un programme complet dans Japt. Testez-le en ligne!

— ETHproductions
source
2

Java / Brainfuck, 71 octets

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

Palindromise en BF, dépalindromise en Java.

Par souci de clarté, c'est ce qui compte pour l'interprète BF:

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

où la dernière boucle contenant des caractères de la lambda Java est ignorée car le pointeur pointe vers un caractère nul à ce point.

— user8397947
source
0

05AB1E / Java 8, 102 caractères

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

Palindromisez en 05AB1E.
Depalindromize dans Java 8.

Explication 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

Explication 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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.