Todos nós já fizemos isso, bem, talvez não, mas criar sua própria linguagem alienígena e sistema de numeração é um grampo especialmente da escrita de fantasia, mas é principalmente uma atividade divertida.

A tarefa é simples, use duas entradas:

1. Uma entrada de lista ordenada de 10 [dez] 'numerais' exclusivos (qualquer caractere ASCII imprimível) e os interpreta, em ordem, como os valores 0, 1, 2, 3, ..., 9

   + Há exceções no que pode ser um numeral aqui. Operadores aritméticos (+, -, *, /), parênteses e espaços não podem ser usados ​​como um dos números.

2. Um problema aritmético usando apenas os 'numerais'

E imprima o resultado inteiro equivalente no formulário fornecido.

Aqui está um exemplo:

INPUT

abcdefghij

bcd + efg + hij

OUTPUT

bdgi

No exemplo, a lista de entrada (você pode escolher em qual formulário a lista entra) de 'abcdefghij' corresponde a '0123456789', assim como 'hjkloiwdfp' também corresponderia 1 a 1 a '0123456789' onde, em vez de 'a' associado a zero, 'h' faz. O seguinte aritmético 'se traduz' em 123 + 456 + 789, o que equivale a 1368. Isso deve ser gerado na forma que fornecemos, então b (que representa 1) d (para 2) g (para 6) e i (para 8)

CASOS DE TESTE

abcdefghij
abc + def - ghij

-gedc

qwertyuiop
qwerty / uiop

e

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

y9|8

MAIS REGRAS

• As brechas padrão são proibidas!
• Isso é código de golfe, então respostas mais curtas em bytes ganham.
• Deve ser um programa ou função completo, com entradas e saídas no formato que for melhor para você. (Apenas não é possível adicionar informações adicionais nas entradas, apenas 'numerais' e a expressão.
• Use qualquer idioma que desejar (desde que esteja em conformidade com outras regras)

05AB1E , 10 9 bytes

žh‡.Eò¹Åв

(Agora) gera como uma lista de caracteres.

Experimente online ou verifique todos os casos de teste .

Explicação:

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

A nova versão do 05AB1E é build é build no Elixir . A .Efunção chamará call_unary(fn x -> {result, _} = Code.eval_string(to_string(x)); result end, a), onde Code.eval_stringestá um Elixir embutido .

Observe que a versão herdada do 05AB1E não funcionará para isso, porque é compilada no Python. Os números com 0 iniciais não serão avaliados:
veja todos os casos de teste na versão herdada (que usa a versão de 10 bytes porque o Åвbuiltin é novo).

R , 58 bytes

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

Experimente online!

Tradução personagem usa chartrpara trocar os dígitos, parseS e evalé a expressão, e depois chartrestá de volta aos dígitos originais.

Se for necessário arredondar para o número inteiro mais próximo, isso é

R , 65 bytes

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

Experimente online!

T-SQL, 117 bytes

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

Quebras de linha são apenas para legibilidade.

A entrada é feita através de uma tabela preexistente t com as colunas de texto c (caracteres) ee (equação), de acordo com nossas regras de IO .

Usa a função SQL 2017 TRANSLATEpara alternar entre caracteres e gerar uma sequência que não contém apenas a equação, mas o código para converter novamente nos caracteres originais:

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

Essa sequência é avaliada usando EXEC().

Pode haver alguns caracteres (como aspas simples ') que quebrariam esse código; Não testei todos os caracteres ASCII possíveis.

De acordo com o desafio, estou avaliando a expressão como dada, sujeita à maneira como meu idioma interpreta esses operadores. Como tal, o segundo caso de teste retorna 1 ( w) e não 2 ( e), devido à divisão inteira.

Perl 6 , 38 bytes

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

Experimente online!

Não tenho certeza de como o arredondamento deve funcionar. Se arredonda no final, então eu posso adicionar .roundpara +6 bytes . Se o comportamento de /deve ser diferente, pode ser mais longo. Leva a entrada como curry f(arithmetic)(numerals)(arithmetic).

Explicação:

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

Execute e depure

Stax não se sai bem aqui, sem uma verdadeira instrução "eval". Ele tem um chamado "eval" nos documentos, mas funciona apenas em valores literais, não em expressões 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"

Poderia ser menor se pudéssemos truncar, em vez de arredondar. Também é complicado lidar com zeros à esquerda (como no caso de teste nº 2), pois o Bash interpreta números começando com 0 como octal.

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

Explicação

Este programa designa implicitamente a primeira e a segunda linhas de entrada como seqüências de caracteres para as variáveis ae brespectivamente.

Cada caractere con-line bé substituído pelo respectivo índicei do caractere encontrado on-line aou ele próprio, se não for encontrado.

Em seguida, remove cada sequência de um ou mais 0s precedidos por um limite da sequência resultante. Isso evita a eval()avaliação de qualquer sequência de dígitos que comece com0 um literal octal.

Após eval()e Math.round(), o resultado é coagido novamente em uma sequência e cada caractere de dígito ié substituído pelo caractere correspondente da linha ano índicei .

Casos de teste

Demo

abcdefghij
abcd + efg + hij

bdgi

Demo

abcdefghij
abc + def - ghij

-gedc

Demo

qwertyuiop
qwerty / uiop

e

Demo

%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/"

Experimente online!

Pega a expressão na primeira linha de entrada e a lista de tradução na 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}

Experimente online!

Talvez essa avaliação dupla possa ser transformada s/.../.../geer.

Carvão , 14 bytes

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

Experimente online! Link é a versão detalhada do código. Nota: A expressão é avaliada de acordo com a semântica do Python 3; portanto, por exemplo, zeros à esquerda em números diferentes de zero são ilegais. Explicação:

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

Uma abordagem sem regex usando str.translatee str.maketranspara substituir os caracteres. Perdi muitos caracteres ao aparar os zeros principais ...

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

Experimente online!

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)

Experimente online!

Espaço para melhorias ...

Wolfram Language (Mathematica) , 121 bytes

Eu defino uma função pura com dois argumentos. Como algumas funções são repetidas, eu as salvo em uma variável para salvar alguns caracteres. Esse código simplesmente substitui algumas strings e depois usa ToExpressionpara avaliar a expressão com o kernel Wolfram.

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

Experimente online!

Lua , 162 151 150 bytes

• -11 bytes graças à minha ideia de usar load vez defunction(...) end
• -1 byte, omitindo nova linha

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

Experimente online!

Não é a coisa mais curta do mundo (Lua obriga você a gostar bastante, principalmente por palavras-chave enormes), mas foi muito divertido de criar. Programa completo, tendo como argumento argumentos e resultado de impressão.

Explicação

Introdução

l,p=...

Atribua valores de argumentos a variáveis. Nosso dicionário é le expressão ép .

A expressão a seguir é bastante difícil de entender porque ela tem uma ordem estranha de execução, então eu explicarei passo a passo:

Convertendo para números normais

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

Execute a substituição na cadeia de expressão: pegue cada símbolo e passe-o para a função ( loadprovou ser menor que a declaração normal aqui).

A função localiza a posição de ocorrência na sequência de caracteres para o símbolo passado usando find. ...é o primeiro (e único) argumento aqui, pois estamos na função vaarg (qualquer loadum deles é) que é o nosso símbolo atual. Os seguintes argumentos são necessários para fazer findignorar símbolos especiais ( 1é apenas um valor curto que é avaliado como truequando convertido em booleano): posição inicial (um é o padrão aqui) eplain , que na verdade desabilita o tratamento de padrões. Sem esses programas falha no terceiro caso de teste devido a% ser especial.

Se a correspondência for encontrada, subtraia uma como as seqüências de caracteres Lua (e as matrizes btw) são baseadas em 1. Se nenhuma correspondência for encontrada, ela não retornará nada, resultando em nenhuma substituição sendo feita.

Resolução

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

Faça um prefixo returnà nossa expressão para que ela retorne resultado, calcule-o compilando como função Lua e chamando-a, execute o arredondamento ( isto foi inverso para torná-lo mais curto).

No final, obtemos uma solução numérica para o nosso problema, permanecendo apenas a conversão novamente.

Tornando louco de novo

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

A primeira linha é uma maneira curta de converter número em string, então agora podemos chamar métodos de string rapidamente. Vamos fazer isso!

Agora gsubé chamado novamente para substituir tudo de volta à loucura. Esse tempo %dé usado em vez de .um padrão de substituição, pois nossa função pode e deve processar apenas números ( .resultaria em erro em números negativos). Esta função de tempo ( loaded novamente para salvar bytes) adiciona primeiro1 ao seu primeiro (e único) vaargument, convertendo-o para a posição em dict string e, em seguida, retorna o caractere nessa posição.

Viva, quase lá!

Final dramático ou por que os colchetes são importantes

print((ABOVE))

Bem ... por que dois pares de suportes de qualquer maneira? É hora de falar sobre paralelo ... eh, retorno múltiplo em Lua. O problema é que uma função pode retornar poucos valores de uma chamada (veja esta meta questão para obter mais exemplos).

Aqui, gsubretornamos dois valores pela última vez : string de resposta que precisamos e quantidade de substituições realizadas (contagem de dígitos, na verdade, mas quem se importa). Se não fosse pelo par interno, tanto a string quanto o número seriam impressos, nos ferrando. Então aqui sacrificamos dois bytes para omitir o segundo resultado e finalmente imprimir o produto dessa fábrica de insanidades.

Bem, eu gostei de explicar quase tanto quanto jogar golfe, espero que você entenda o que está acontecendo aqui.