L'abbiamo fatto tutti, beh, forse no, ma creare il tuo linguaggio alieno e il tuo sistema di numerazione è un punto fermo soprattutto per la scrittura fantasy, ma per lo più è solo un'attività divertente.

Il compito è semplice, prendi due input:

1. Un elenco ordinato immette 10 [dieci] 'numeri' unici (qualsiasi carattere ASCII stampabile) e li interpreta, in ordine, come i valori 0, 1, 2, 3, ..., 9

   + Ci sono eccezioni a ciò che può essere un numero qui. Gli operatori aritmetici (+, -, *, /), le parentesi e gli spazi non possono essere usati come uno dei numeri.

2. Un problema aritmetico usando solo quei 'numeri'

E genera il risultato intero equivalente nella forma data.

Ecco un esempio:

INPUT

abcdefghij

bcd + efg + hij

OUTPUT

bdgi

Nell'esempio, l'elenco di input (puoi scegliere da quale forma l'elenco) di 'abcdefghij' corrisponde a '0123456789' proprio come 'hjkloiwdfp' corrisponderebbe anche a 1 a 1 con '0123456789' dove invece di 'a' associato a zero, 'h' lo fa. L'aritmetica che segue 'si traduce' in 123 + 456 + 789, che equivale a 1368. Questo deve quindi essere emesso nella forma che gli abbiamo dato, quindi b (che rappresenta 1) d (per 2) g (per 6) e i (per 8).

CASI TEST

abcdefghij
abc + def - ghij

-gedc

qwertyuiop
qwerty / uiop

e

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

y9|8

ALTRE REGOLE

• Sono vietate le scappatoie standard !
• Questo è il golf del codice, quindi vince la risposta più breve in byte.
• Deve essere un programma completo o una funzione che accetta gli ingressi e le uscite in qualunque formato funzioni meglio per te. (Non è possibile aggiungere ulteriori informazioni negli input, solo "numeri" e l'espressione.
• Usa la lingua che desideri (purché conforme ad altre regole)

05AB1E , 10 9 byte

žh‡.Eò¹Åв

(Adesso) viene visualizzato come un elenco di caratteri.

Provalo online o verifica tutti i casi di test .

Spiegazione:

  ‡        # 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 nuova versione di 05AB1E è build è costruita in elisir . La .Efunzione chiamerà call_unary(fn x -> {result, _} = Code.eval_string(to_string(x)); result end, a), dove Code.eval_stringè incorporato un elisir .

Nota che la versione legacy di 05AB1E non funzionerà per questo, perché è costruita in Python. I numeri con 0 iniziali non verranno valutati:
vedi tutti i casi di test nella versione legacy (che utilizza la versione a 10 byte perché l' Åвintegrato è nuovo).

R , 58 byte

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

Provalo online!

Traduzione Usi carattere chartrdi scambiare le cifre, parseS e evals l'espressione, e poi chartrS TORNA ALLA le cifre originali.

Se è necessario arrotondare al numero intero più vicino, questo è

R , 65 byte

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

Provalo online!

T-SQL, 117 byte

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

Le interruzioni di riga sono solo per leggibilità.

L'ingresso è tramite una tabella pre-esistente t con le colonne di testo c (caratteri) e e (equazione), per le nostre regole IO .

Utilizza la funzione SQL 2017 TRANSLATEper passare da un carattere all'altro e generare una stringa che contiene non solo l'equazione, ma il codice per la conversione ai caratteri originali:

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

Questa stringa viene quindi valutata utilizzando EXEC().

Potrebbero esserci dei caratteri (come una singola virgoletta ') che infrangerebbero questo codice; Non ho testato tutti i possibili caratteri ASCII.

Per la sfida, sto valutando l'espressione data, in base al modo in cui la mia lingua interpreta quegli operatori. Pertanto, il secondo caso di test restituisce 1 ( w) e non 2 (e ), a causa della divisione dei numeri interi.

Perl 6 , 38 byte

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

Provalo online!

Non sono sicuro di come dovrebbe funzionare l'arrotondamento. Se si arrotonda alla fine, allora posso aggiungere .roundper +6 byte . Se il comportamento di /dovrebbe essere diverso, potrebbe essere più lungo. Prende input come al curry f(arithmetic)(numerals)(arithmetic).

Spiegazione:

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

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

Esegui ed esegui il debug

Stax non va bene qui, manca una vera istruzione "eval". Ne ha uno chiamato "eval" nei documenti, ma funziona solo su valori letterali, non su espressioni complete.

Bash, 97 byte

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

Potrebbe essere meno se potessimo troncare, piuttosto che arrotondare. Inoltre, è difficile gestire gli zeri iniziali (come nel caso di test n. 2) poiché Bash interpreta i numeri che iniziano con 0 come ottali.

Fagiolo , 94 90 byte

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

Spiegazione

Questo programma assegna implicitamente la prima e la seconda riga di input come stringhe alle variabili ae brispettivamente.

Ogni carattere cin linea bviene sostituito con il rispettivo indicei del carattere trovato in linea ao se stesso non viene trovato.

Quindi rimuove ogni sequenza di una o più 0s preceduta da un limite dalla stringa risultante. Questo per evitare eval()di valutare qualsiasi sequenza di cifre a partire da0 un valore letterale ottale.

Dopo eval()e Math.round(), il risultato viene riportato in una stringa e ogni carattere di cifra iviene sostituito dal carattere corrispondente dalla riga aall'indicei .

Casi test

dimostrazione

abcdefghij
abcd + efg + hij

bdgi

dimostrazione

abcdefghij
abc + def - ghij

-gedc

dimostrazione

qwertyuiop
qwerty / uiop

e

dimostrazione

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

y9|8

Perl 5 -p , 63 byte

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

Provalo online!

Prende l'espressione sulla prima riga dell'input e l'elenco delle traduzioni nella seconda.

Perl 5 , 130 byte

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}

Provalo online!

Forse quel doppio giudizio in qualche modo può essere trasformato in s/.../.../geer.

Carbone , 14 byte

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

Provalo online! Il collegamento è alla versione dettagliata del codice. Nota: l'espressione viene valutata in base alla semantica di Python 3, quindi ad esempio gli zeri iniziali su numeri diversi da zero sono illegali. Spiegazione:

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

Un approccio non regex che utilizza str.translatee str.maketransper sostituire i caratteri. Ho perso molti personaggi nel tagliare gli zeri iniziali ...

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

Provalo online!

Python 3 , 167 byte

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)

Provalo online!

Margini di miglioramento...

Wolfram Language (Mathematica) , 121 byte

Definisco una funzione pura con due argomenti. Poiché alcune funzioni vengono ripetute, le salvo in una variabile per salvare alcuni caratteri. Questo codice esegue semplicemente alcune sostituzioni di stringhe e quindi utilizza ToExpressionper valutare l'espressione con il kernel Wolfram.

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

Provalo online!

Lua , 162 151 150 byte

• -11 byte grazie alla mia idea di utilizzo load posto difunction(...) end
• -1 byte omettendo newline

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

Provalo online!

Non è la cosa più breve del mondo (Lua ti costringe a essere piuttosto difficile, soprattutto con parole chiave enormi), ma è stato abbastanza divertente da creare. Programma completo che accetta input come argomenti e stampa i risultati.

Spiegazione

introduzione

l,p=...

Assegna valori da argomenti a variabili. Il nostro dizionario èl ed espressione èp .

L'espressione seguente è piuttosto difficile da capire perché ha uno strano ordine di esecuzione, quindi lo spiegherò passo dopo passo:

Conversione in numeri normali

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

Esegui la sostituzione sulla stringa di espressioni: prendi ogni simbolo e passalo alla funzione (load si è dimostrato cortocircuito rispetto alla normale dichiarazione qui).

La funzione trova la posizione dell'occorrenza nella stringa dict per il simbolo passato usando find. ...è il primo (e unico) argomento qui dato che siamo nella funzione vaarg (qualunque loadsia uno ed) che è il nostro simbolo attuale. Per rendere findignori i simboli speciali sono necessari i seguenti argomenti ( 1è solo un valore breve che viene valutato come trueconvertito in booleano): posizione iniziale (qui si trova un valore predefinito) e plainche disabilita effettivamente la gestione dei pattern. Senza questi programmi fallisce il terzo caso di test a causa %dell'essere speciale.

Se viene trovata una corrispondenza, sottrarre una come stringhe Lua (e matrici tra l'altro) sono basate su 1. Se non viene trovata alcuna corrispondenza, non verrà restituito nulla e non verrà eseguita alcuna sostituzione.

soluzione

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

Preparati returnalla nostra espressione per far sì che restituisca il risultato, calcolalo compilando come funzione Lua e chiamandolo, esegui l'arrotondamento ( questo si è capovolto per renderlo più breve).

Alla fine otteniamo una soluzione numerica al nostro problema, rimane solo la riconversione.

Rendendolo di nuovo pazzo

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

La prima riga è un modo breve per convertire il numero in stringa, quindi ora possiamo chiamare i metodi stringa in un modo breve. Facciamolo!

Ora gsubviene chiamato di nuovo per sostituire tutto alla follia. Questa volta %dviene utilizzato al posto di un .modello di sostituzione, in quanto la nostra funzione può e deve elaborare solo numeri ( .risulterebbe in errore su numeri negativi). Questa funzione temporale (load nuovo edita per salvare byte) aggiunge per la prima volta1 suo primo (e unico) oggetto, convertendolo in posizione in stringa dict, quindi restituisce il carattere da esso in quella posizione.

Evviva, quasi lì!

Drammatico finale, o Why Brackets Matter

print((ABOVE))

Bene ... perché due coppie di parentesi comunque? È tempo di parlare di parallelo ... eh, ritorno multiplo a Lua. La cosa è che una funzione può restituire pochi valori da una chiamata (guarda questa meta domanda per altri esempi).

Qui, l'ultimo ha gsubrestituito due valori: risposta stringa di cui abbiamo bisogno e quantità di sostituzioni effettuate (conteggio delle cifre effettivamente, ma chi se ne frega). Se non fosse per la coppia interna, verrebbero stampati sia la stringa che il numero, rovinandoci. Quindi qui sacrificiamo due byte per omettere il secondo risultato e infine stampare il prodotto di questa fabbrica di follia.

Beh, mi è piaciuto spiegare quasi quanto il golf in primo luogo, spero che tu abbia quello che sta succedendo qui.