Todos lo hemos hecho, bueno, tal vez no, pero crear tu propio lenguaje alienígena y sistema de numeración es un elemento básico de la escritura especialmente fantástica, pero es principalmente una actividad divertida.

La tarea es simple, tome dos entradas:

1. Una entrada de lista ordenada de 10 [diez] 'números' únicos (cualquier carácter ASCII imprimible) e interpretarlos, en orden, como los valores 0, 1, 2, 3, ..., 9

   + Hay excepciones a lo que puede ser un número aquí. Los operadores aritméticos (+, -, *, /), paréntesis y espacios no se pueden usar como uno de los números.

2. Un problema aritmético usando solo esos 'números'

Y genera el resultado entero equivalente en la forma dada.

Aquí hay un ejemplo:

INPUT

abcdefghij

bcd + efg + hij

OUTPUT

bdgi

En el ejemplo, la lista de entrada (puede elegir en qué forma se incluye la lista) de 'abcdefghij' corresponde a '0123456789' así como 'hjkloiwdfp' también correspondería 1 a 1 con '0123456789' donde en lugar de 'a' se asocia con cero, 'h' hace. La siguiente aritmética 'se traduce' a 123 + 456 + 789, lo que equivale a 1368. Esto se debe generar en la forma que le dimos, entonces b (que representa 1) d (para 2) g (para 6) e i (para 8)

CASOS DE PRUEBA

abcdefghij
abc + def - ghij

-gedc

qwertyuiop
qwerty / uiop

e

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

y9|8

MÁS REGLAS

• ¡Las lagunas estándar están prohibidas!
• Este es el código de golf, por lo que gana las respuestas más cortas en bytes.
• Debe ser un programa completo o una función que tome las entradas y salidas en cualquier formato que funcione mejor para usted. (Simplemente no puede agregar información adicional en las entradas, solo 'números' y la expresión.
• Use el idioma que desee (siempre que cumpla con otras reglas)

05AB1E , 10 9 bytes

žh‡.Eò¹Åв

(Ahora) sale como una lista de caracteres.

Pruébalo en línea o verifique todos los casos de prueba .

Explicación:

  ‡        # 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 nueva versión de 05AB1E es build is build en Elixir . los.E función llamará call_unary(fn x -> {result, _} = Code.eval_string(to_string(x)); result end, a), donde elCode.eval_string es un Elixir incorporado .

Tenga en cuenta que la versión heredada de 05AB1E no funcionará para esto, porque está construida en Python. Los números con ceros a la izquierda no se evaluarán:
vea todos los casos de prueba en la versión heredada (que usa la versión de 10 bytes porque la versión Åвincorporada es nueva).

R , 58 bytes

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

Pruébalo en línea!

Utiliza la traducción de caracteres chartrpara intercambiar los dígitos, parsesy evals la expresión, y luego chartrvuelve a los dígitos originales.

Si se requiere redondear al entero más cercano, esto es

R , 65 bytes

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

Pruébalo en línea!

T-SQL, 117 bytes

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

Los saltos de línea son solo para legibilidad.

La entrada se realiza a través de una tabla t existente con columnas de texto c (caracteres) y e (ecuación), según nuestras reglas IO .

Utiliza la función SQL 2017 TRANSLATEpara cambiar entre caracteres y generar una cadena que contiene no solo la ecuación, sino también el código para traducir de nuevo a los caracteres originales:

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

Esta cadena se evalúa utilizando EXEC() .

Puede haber algunos caracteres (como una comilla simple) ' ) que rompan este código; No he probado todos los posibles caracteres ASCII.

Según el desafío, estoy evaluando la expresión como se da, sujeta a cómo mi lenguaje interpreta esos operadores. Como tal, el segundo caso de prueba devuelve 1 ( w), y no 2 ( e), debido a la división de enteros.

Perl 6 , 38 bytes

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

Pruébalo en línea!

No estoy seguro de cómo se supone que funciona el redondeo. Si se redondea al final entonces puedo añadir .rounda +6 bytes . Si el comportamiento de /debe ser diferente, entonces puede ser más largo. Toma entrada como curryf(arithmetic)(numerals)(arithmetic) .

Explicación:

{                                    }  # 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 bytes

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

Ejecutar y depurarlo

A Stax no le va bien aquí, ya que carece de una verdadera instrucción "eval". Tiene uno que se llama "eval" en los documentos, pero solo funciona en valores literales, no en expresiones completas.

Bash, 97 bytes

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

Podría ser menos si pudiéramos truncar, en lugar de redondear. También es difícil manejar los ceros iniciales (como en el caso de prueba # 2) ya que Bash interpreta los números que comienzan con 0 como octales.

Bean , 94 90 bytes

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]
)

Explicación

Este programa asigna implícitamente la primera y segunda líneas de entrada como cadenas a las variables ay brespectivamente.

Cada carácter cen línea bse reemplaza con el índice respectivo idel carácter encontrado en líneaa , o en sí mismo si no se encuentra.

Luego, elimina cada secuencia de uno o más 0s precedidos por un límite de la cadena resultante. Esto es para evitar eval()evaluar cualquier secuencia de dígitos que comience 0como un literal octal.

Después eval()y Math.round(), el resultado se vuelve a convertir en una cadena y cada carácter de dígito ise reemplaza por el carácter correspondiente de la línea aen el índice i.

Casos de prueba

Manifestación

abcdefghij
abcd + efg + hij

bdgi

Manifestación

abcdefghij
abc + def - ghij

-gedc

Manifestación

qwertyuiop
qwerty / uiop

e

Manifestación

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

y9|8

Perl 5 -p , 63 bytes

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

Pruébalo en línea!

Toma la expresión en la primera línea de entrada y la lista de traducción en la segunda.

Perl 5 , 130 bytes

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}

Pruébalo en línea!

Tal vez esa doble evaluación de alguna manera pueda convertirse s/.../.../geer.

Carbón , 14 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Nota: La expresión se evalúa de acuerdo con la semántica de Python 3, por lo que, por ejemplo, los ceros iniciales en números distintos de cero son ilegales. Explicación:

   ⭆η           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 bytes

Un enfoque no regex que usa str.translatey str.maketranspara reemplazar los caracteres. Perdí muchos personajes al recortar los ceros iniciales ...

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

Pruébalo en línea!

Python 3 , 167 bytes

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)

Pruébalo en línea!

Margen de mejora...

Wolfram Language (Mathematica) , 121 bytes

Defino una función pura con dos argumentos. Como algunas funciones se repiten, las guardo en una variable para guardar algunos caracteres. Este código simplemente hace algunos reemplazos de cadena y luego lo usa ToExpressionpara evaluar la expresión con el núcleo Wolfram.

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

Pruébalo en línea!

Lua , 162 151 150 bytes

• -11 bytes gracias a mi idea de usar en loadlugar defunction(...) end
• -1 byte omitiendo nueva línea

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)')))

Pruébalo en línea!

No es la cosa más corta del mundo (Lua te obliga a ser muy difícil, especialmente con grandes palabras clave), pero fue muy divertido de crear. Programa completo que toma datos como argumentos y resultados de impresión.

Explicación

Introducción

l,p=...

Asignar valores de argumentos a variables. Nuestro diccionario es ly la expresión esp .

La siguiente expresión es bastante difícil de entender porque tiene un orden de ejecución extraño, así que lo explicaré paso a paso:

Convertir a números normales

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

Realice el reemplazo en la cadena de expresión: tome cada símbolo y páselo a la función (load demostró estar más corto que la declaración normal).

La función encuentra la posición de ocurrencia en la cadena dict para el símbolo pasado usando find. ...es el primer (y único) argumento aquí, ya que estamos en la función vaarg (cualquier loaded es) que es nuestro símbolo actual. Se requieren los siguientes argumentos para findignorar símbolos especiales ( 1es solo un valor corto que se evalúa como truecuando se convierte en booleano): posición inicial (una es predeterminada aquí) y plain, que en realidad deshabilita el manejo de patrones. Sin esos programas falla en el tercer caso de prueba debido a% es especial.

Si se encuentra una coincidencia, reste uno ya que las cadenas Lua (y las matrices por cierto) están basadas en 1. Si no se encuentra ninguna coincidencia, no devolverá nada, por lo que no se realizará ningún reemplazo.

Resolviendo

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

Anteponga returna nuestra expresión para dejar que devuelva el resultado, calcúlelo compilando como función Lua y llamándolo, realice el redondeo ( esto cambió para hacerlo más corto).

Al final, obtenemos una solución numérica a nuestro problema, solo queda convertirla de nuevo.

Volviéndolo loco otra vez

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

La primera línea es una forma corta de convertir un número en una cadena, por lo que ahora podemos llamar a los métodos de cadena de una manera corta. ¡Hagámoslo!

Ahora gsubse llama nuevamente para reemplazar todo de nuevo a la locura. Este tiempo %dse usa en lugar de .como patrón de reemplazo, ya que nuestra función puede y debe procesar solo números ( .daría como resultado un error en números negativos). Esta función de tiempo ( loaded nuevamente para guardar bytes) primero agrega1 a su primer (y único) argumento, convirtiéndolo en una posición en la cadena dict, luego devuelve el carácter de él en esa posición.

¡Hurra, casi allí!

Dramático final, o por qué importan los corchetes

print((ABOVE))

Bueno ... ¿por qué dos pares de paréntesis de todos modos? Es hora de hablar sobre parall ... eh, retorno múltiple en Lua. La cosa es que una función puede devolver pocos valores de una llamada (mira esta meta pregunta para más ejemplos).

Aquí, el último gsubdevolvió dos valores: la cadena de respuesta que necesitamos y la cantidad de reemplazos realizados (recuento de dígitos en realidad, pero a quién le importa). Si no fuera por el par interno, tanto la cadena como el número se imprimirían, jodiéndonos. Así que aquí sacrificamos dos bytes para omitir el segundo resultado y finalmente imprimir el producto de esta fábrica de locura.

Bueno, he disfrutado explicando casi tanto como jugar golf en primer lugar, espero que entiendas lo que está pasando aquí.