Nous l'avons tous fait, eh bien, peut-être pas, mais créer votre propre langue étrangère et votre système de numérotation est un aliment de base de l'écriture particulièrement fantastique, mais c'est surtout une activité amusante.

La tâche est simple, prenez deux entrées:

1. Une entrée de liste ordonnée de 10 [dix] «chiffres» uniques (n'importe quel caractère ASCII imprimable) et les interpréter, dans l'ordre, comme les valeurs 0, 1, 2, 3, ..., 9

   + Il y a des exceptions à ce qui peut être un chiffre ici. Les opérateurs arithmétiques (+, -, *, /), les parenthèses et les espaces ne peuvent pas être utilisés comme l'un des nombres.

2. Un problème arithmétique utilisant uniquement ces «chiffres»

Et sortez le résultat entier équivalent sous la forme donnée.

Voici un exemple:

INPUT

abcdefghij

bcd + efg + hij

OUTPUT

bdgi

Dans l'exemple, la liste d'entrée (vous pouvez choisir sous quelle forme la liste entre) de 'abcdefghij' correspond à '0123456789' tout comme 'hjkloiwdfp' correspondrait également 1 à 1 avec '0123456789' où au lieu de 'a' s'associer à zéro, «h» le fait. L'arithmétique suivante «se traduit» par 123 + 456 + 789, ce qui équivaut à 1368. Cela doit ensuite être sorti sous la forme que nous lui avons donnée, donc b (qui représente 1) d (pour 2) g (pour 6) et i (pour 8).

CAS D'ESSAI

abcdefghij
abc + def - ghij

-gedc

qwertyuiop
qwerty / uiop

e

%y83l;[=9|
(83l * 9) + 8%

y9|8

PLUS DE RÈGLES

• Les échappatoires standard sont interdites!
• C'est le golf de code, donc les réponses les plus courtes en octets gagnent.
• Doit être un programme ou une fonction complète prenant les entrées et les sorties dans le format qui vous convient le mieux. (Ne peut tout simplement pas ajouter des informations supplémentaires dans les entrées, juste des «chiffres» et l'expression.
• Utilisez n'importe quelle langue que vous souhaitez (tant qu'elle est conforme aux autres règles)

05AB1E , 10 9 octets

žh‡.Eò¹Åв

(Maintenant) sort sous forme de liste de caractères.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

  ‡        # Transliterate the second (implicit) input, replacing every character of 
           # the first (implicit) input with:
žh         # The builtin "0123456789"
   .E      # Then evaluate it as Elixir code
     ò     # Round it to the nearest integer
      ¹Åв  # And change it back by using a custom base-conversion with the first input as
           # base (which results in a character list)
           # (after which that result is output implicitly)

La nouvelle version de 05AB1E est build is build in Elixir . La .Efonction appellera call_unary(fn x -> {result, _} = Code.eval_string(to_string(x)); result end, a), où Code.eval_stringest un Elixir intégré .

Notez que la version héritée de 05AB1E ne fonctionnera pas pour cela, car elle est construite en Python. Les nombres avec des 0 en tête ne seront pas évalués:
voir tous les cas de test dans la version héritée (qui utilise la version 10 octets car la fonction Åвintégrée est nouvelle).

R , 58 octets

function(d,s,`[`=chartr)'0-9'[d,eval(parse(t=d['0-9',s]))]

Essayez-le en ligne!

Utilise la traduction de caractères chartrpour permuter les chiffres, parses et evals l'expression, puis chartrs pour revenir aux chiffres d'origine.

Si l'arrondi à l'entier le plus proche est requis, c'est

R , 65 octets

function(d,s,`[`=chartr)'0-9'[d,round(eval(parse(t=d['0-9',s])))]

Essayez-le en ligne!

T-SQL, 117 octets

DECLARE @ CHAR(99)
SELECT @='SELECT TRANSLATE('+TRANSLATE(e,c,'0123456789')+',''0123456789'','''+c+''')'FROM t
EXEC(@)

Les sauts de ligne sont uniquement à des fins de lisibilité.

L'entrée se fait via un tableau préexistant t avec les colonnes de texte c (caractères) et e (équation), selon nos règles IO .

Utilise la fonction SQL 2017 TRANSLATE pour basculer entre les caractères et générer une chaîne qui contient non seulement l'équation, mais le code à traduire en caractères d'origine:

SELECT TRANSLATE(123 + 456 + 789,'0123456789','abcdefghij') 

Cette chaîne est ensuite évaluée à l'aide de EXEC().

Il peut y avoir certains caractères (comme une seule citation ' ) qui briseraient ce code; Je n'ai pas testé tous les caractères ASCII possibles.

Par le défi, j'évalue l'expression comme donnée, sous réserve de la façon dont ma langue interprète ces opérateurs. En tant que tel, le deuxième cas de test renvoie 1 ( w) et non 2 ( e), en raison de la division entière.

Perl 6 , 38 octets

{*.trans($_=>^10).EVAL.trans(^10=>$_)}

Essayez-le en ligne!

Je ne sais pas comment l'arrondi est censé fonctionner. S'il arrondit à la fin, je peux ajouter .roundpour +6 octets . Si le comportement de/ doit être différent, il peut être plus long. Prend l'entrée au curry comme f(arithmetic)(numerals)(arithmetic).

Explication:

{                                    }  # Anonymous codeblock
 *                                      # Returning a whatever lambda
  .trans($_=>^10)       # That translates the numerals to digits
                 .EVAL  # Evaluates the result as code
                      .trans(^10=>$_)   # And translates it back again

Stax , 74 66 65 octets

┼ö8Q#xóπcM~oÖ÷╦├mî☼yº─▐4ç≥e╘o▄ê‼ø_k╜ø8%N╫ ╗e<.╗P[─╛èA±!xêj«w╠°{B♪

Exécuter et déboguer

Stax ne fait pas bien ici, faute d'une véritable instruction "eval". Il en a un qui s'appelle "eval" dans la documentation, mais il ne fonctionne que sur les valeurs littérales, pas sur les expressions complètes.

Bash, 97 octets

IFS=''
read S
read O
A=`echo "$O"|tr "$S" 0-9`
printf %0.f `bc<<<"(${A[@]##0})+0.5"`|tr 0-9 "$S"

Cela pourrait être moins si nous pouvions tronquer plutôt qu'arrondir. Il est également difficile de gérer les zéros non significatifs (comme dans le cas de test n ° 2) car Bash interprète les nombres commençant par 0 comme octal.

Bean , 94 90 octets

Hexdump

00000000: 53d0 80d6 d800 d3d0 80a0 1f20 8047 53a0  SÐ.ÖØ.ÓÐ. . .GS 
00000010: 1753 d080 d3d0 80a0 5e20 800a a181 8100  .SÐ.ÓÐ. ^ ..¡...
00000020: 40a0 5f52 cac3 4da0 6580 53d0 80a0 5d20  @ _RÊÃM e.SÐ. ] 
00000030: 8089 205f a065 205f 2080 0aa1 8181 0123  .. _ e _ ..¡...#
00000040: 0058 0020 800a a181 8102 40a0 6550 84a0  .X. ..¡...@ eP. 
00000050: 5d20 652e dce2 b02b dc64                 ] e.Üâ°+Üd

Javascript

`${Math.round(
  eval(
    b.replace(
      /./g,
      c => ~(i = a.indexOf(c)) ? i : c
    ).replace(
      /\b0+/g,
      ''
    )
  )
)}`.replace(
  /\d/g,
  i => a[i]
)

Explication

Ce programme affecte implicitement les première et deuxième lignes d'entrée sous forme de chaînes aux variables aet brespectivement.

Chaque caractère cen ligne best remplacé par l'index respectifi du caractère trouvé en ligne a, ou lui-même s'il n'est pas trouvé.

Ensuite, il supprime chaque séquence d'un ou plusieurs 0s précédée d'une limite de la chaîne résultante. Ceci pour empêcher eval()d'évaluer toute séquence de chiffres commençant par0 un littéral octal.

Après eval() etMath.round() , le résultat est contraint de nouveau dans une chaîne et chaque caractère numérique iest remplacé par le caractère correspondant de la ligne aà l'indexi .

Cas de test

Démo

abcdefghij
abcd + efg + hij

bdgi

Démo

abcdefghij
abc + def - ghij

-gedc

Démo

qwertyuiop
qwerty / uiop

e

Démo

%y83l;[=9|
(83l * 9) + 8%

y9|8

Perl 5 -p , 63 octets

$p=<>;eval"y/$p/0-9/";s/\b0+\B//g;$_=int.5+eval;eval"y/0-9/$p/"

Essayez-le en ligne!

Prend l'expression sur la première ligne d'entrée et la liste de traduction sur la seconde.

Perl 5 , 130 octets

sub f{eval sprintf"'%.0f'=~y/%s/%s/r",eval(eval(sprintf"\$_[1]=~y/%s/%s/r",@r=map"\Q$_",$_[0],'0123456789')=~s,\b0,,gr),reverse@r}

Essayez-le en ligne!

Peut-être que ce double eval peut être transformé en quelque sorte s/.../.../geer.

Fusain , 14 octets

⍘ＵＶ⭆η⎇№θι⌕θιιθ

Essayez-le en ligne! Le lien est vers la version détaillée du code. Remarque: l'expression est évaluée selon la sémantique de Python 3, par exemple, les zéros non significatifs sur les nombres non nuls sont illégaux. Explication:

   ⭆η           Map over expression's characters and join
        ι       Current character
      №θ        Count matches in first input
     ⎇          If non-zero
         ⌕θι    Replace with position in first input
            ι   Otherwise keep character unchanged
 ＵＶ             Evaluate as Python 3
⍘            θ  Convert to base using first input as digits

Python 3 , 137 octets

Une approche non regex utilisant str.translateet str.maketranspour remplacer les caractères. J'ai perdu beaucoup de personnages en rognant les zéros de tête ...

lambda s,t,d='0123456789',e=str.translate,m=str.maketrans:e(str(round(eval(' '.join(c.lstrip('0')for c in e(t,m(s,d)).split())))),m(d,s))

Essayez-le en ligne!

Python 3 , 167 octets

import re
a=[*enumerate(input())]
e=input()
for i,c in a:e=re.sub(c,str(i),e)
e=str(round(eval(re.sub(r'\b0+(?!\b)','',e))))
for i,c in a:e=re.sub(str(i),c,e)
print(e)

Essayez-le en ligne!

Marge d'amélioration...

Wolfram Language (Mathematica) , 121 octets

Je définis une fonction pure avec deux arguments. Étant donné que certaines fonctions sont répétées, je les enregistre dans une variable pour enregistrer quelques caractères. Ce code effectue simplement des remplacements de chaîne et utilise ensuite ToExpressionpour évaluer l'expression avec le noyau Wolfram.

(r=Thread[StringPartition[#,1]->(t=ToString)/@Range[0,9]];u[(u=StringReplace)[#2,r]//ToExpression//Round//t,Reverse/@r])&

Essayez-le en ligne!

Lua , 162 151 150 octets

• -11 octets grâce à mon idée d'utiliser loadau lieu defunction(...) end
• -1 octet en omettant la nouvelle ligne

l,p=...print(((math.ceil(load('return '..p:gsub('.',load'n=l:find(...,1,1)return n and n-1'))()-0.5)..''):gsub('%d',load'c=...+1 return l:sub(c,c)')))

Essayez-le en ligne!

Ce n'est pas la chose la plus courte du monde (Lua vous oblige à être assez dur, surtout par d'énormes mots-clés), mais c'était assez amusant à créer. Programme complet prenant en entrée les arguments et les résultats d'impression.

Explication

introduction

l,p=...

Attribuez des valeurs des arguments aux variables. Notre dictionnaire est let l'expression est p.

L'expression suivante est assez difficile à comprendre car elle a un ordre d'exécution étrange, je vais donc l'expliquer étape par étape:

Conversion en nombres normaux

p:gsub('.',
load'n=l:find(...,1,1)return n and n-1')

Effectuez le remplacement sur la chaîne d'expression: prenez chaque symbole et passez-le à la fonction (il loads'est avéré être court-circuité que la déclaration normale ici).

La fonction recherche la position d'occurrence dans la chaîne de dictée pour le symbole passé à l'aide de find. ...est le premier (et le seul) argument ici car nous sommes dans la fonction vaarg (n'importe quel loaded est) qui est notre symbole actuel. Les arguments suivants sont nécessaires pour fairefind ignorer les symboles spéciaux (1 c'est juste une valeur courte qui est évaluée comme trueconvertie en booléen): position de départ (une par défaut ici) et plain, qui désactive en fait la gestion des modèles. Sans ces programmes, le troisième test échoue en raison de %sa spécificité.

Si une correspondance est trouvée, soustrayez-en une car les chaînes Lua (et les tableaux btw) sont basés sur 1. Si aucune correspondance n'est trouvée, elle ne retournera rien, ce qui n'entraînera aucun remplacement.

Résoudre

math.ceil(load('return '..ABOVE)()-0.5)

Prepend return à notre expression le résultat du résultat, calculez-le en compilant la fonction Lua et appelez-le, effectuez l'arrondi ( cela a fait l'inverse pour le raccourcir).

Si nous obtenons une solution numérique à notre problème, il ne reste plus qu'à la reconvertir.

Rendre fou à nouveau

(ABOVE..'')
:gsub('%d',load'c=...+1 return l:sub(c,c)')

La première ligne est un moyen court de convertir un nombre en chaîne, nous pouvons donc maintenant appeler les méthodes de chaîne de manière courte. Faisons-le!

Maintenant gsubest appelé à nouveau pour tout replacer dans la folie. Ce temps %dest utilisé à la place d' .un modèle de remplacement car notre fonction peut et doit traiter uniquement les nombres ( .cela entraînerait une erreur sur les nombres négatifs). Cette fonction de temps ( loadédité à nouveau pour enregistrer les octets) ajoute d'abord1 à son premier (et unique) argument, en le convertissant en position dans la chaîne de dictée, puis en renvoie le caractère à cette position.

Hourra, presque là!

Fin dramatique, ou pourquoi les crochets comptent

print((ABOVE))

Eh bien… pourquoi deux paires de supports de toute façon? Il est temps de parler de parall… eh, de multiples retours à Lua. Le fait est qu'une fonction peut renvoyer quelques valeurs d'un seul appel (regardez cette méta-question pour plus d'exemples).

Ici, le dernier gsubretourne deux valeurs: la chaîne de réponse dont nous avons besoin et le nombre de remplacements effectués (nombre de chiffres en fait, mais peu importe). S'il n'y avait pas de paire interne, la chaîne et le numéro seraient imprimés, ce qui nous ferait chier. Nous sacrifions donc ici deux octets pour omettre le deuxième résultat et finalement imprimer le produit de cette usine de folie.

Eh bien, j'ai apprécié d'expliquer presque autant que le golf en premier lieu, j'espère que vous avez ce qui se passe ici.