Interpretare la ripetizione!

Questa sfida è la prima di una serie a due sfide sulla ripetizione. Il secondo arriverà presto.

In una lingua chiamata Repetition (qualcosa che ho appena inventato), c'è una stringa infinita di 12345678901234567890..., con la 1234567890ripetizione per sempre.

La seguente sintassi è disponibile per i numeri di output:

+-*/: Questo inserisce l'operatore nella stringa di cifre ripetute.
- Esempi:
  - +-> 1+2= 3( +inserisce una +tra 1e 2)
  - +*-> 1+2*3= 1+6= 7(Come sopra, tranne che ora vengono utilizzati due operatori)
  - /-> 1/2= 0(La ripetizione utilizza la divisione intera)
  - //-> 1/2/3= 0/3= 0(La ripetizione usa "associazione sinistra" con più sottrazioni e divisioni)
- Ogni operatore è inserito in modo che abbia una cifra alla sua sinistra, a meno che non ci siano c(vedi sotto).
c: Si concatena con la cifra successiva nella stringa.
- Esempi:
  - c+-> 12+3= 15(Il c"continua" il 1e lo concatena con la cifra successiva 2, per formare 12)
  - +c-> 1+23=24
  - ccc -> 1234
(): Parentesi per l'elaborazione dei numeri.
- Esempi:
  - (c+)*-> (12+3)*4= 15*4= 60(la ripetizione utilizza l'ordine delle operazioni)
  - (c+)/c-> (12+3)/45= 15/45=0
  - (cc+c)/-> (123+45)/6= 168/6=28
s: Salta un numero (rimuove il numero dalla stringa infinita).
- s+-> 2+3= 5( ssalta 1)
- csc-> 124(I primi cconcats 1e 2, i ssalti 3, e le finali cconcats 12a 4)
- +s+-> 7(Il primo +aggiunge 1e 2per fare 3, ssalta 3, e la finale +aggiunge 3a 4fare 7)
- cs*(++)-> 12*(4+5+6)= 12*15=180

Negli esempi precedenti, viene utilizzata solo una quantità finita di cifre nella stringa infinita. Il numero di cifre utilizzate è equivalente a number of operators, concats and skips + 1.

Il tuo compito è, quando viene data una stringa di codice ripetizione, produrre il risultato.

Esempi di input e output sono:

++ -> 6
- -> -1
(-)* -> -3
cscc -> 1245
(cc+c)/ -> 28
cc+c/ -> 130
cs*(++) -> 180

Questo è il codice golf, quindi vince il codice più breve in byte!

Specifiche:

Hai la garanzia che il risultato non andrà mai oltre 2^31-1.
Hai anche la garanzia che l'input consisterà solo dei simboli +-*/cs().
Verrà emesso un programma vuoto 1.

code-golf math code-golf string number arithmetic code-golf ascii-art kolmogorov-complexity code-golf number-theory code-golf math code-golf stack-exchange-api code-golf ascii-art code-golf string code-golf number integer code-golf number arithmetic code-golf puzzle-solver code-challenge quine palindrome polyglot

— clismique
fonte

E la ~s? Non lasciarci in sospeso.

— Robert Fraser,

@RobertFraser Whoops, è stato un errore - c era originariamente ~, ma sembra che non l'abbia risolto completamente.

— clismique,

@TonHospel Ooh, hai un buon punto lì. Il simbolo "s" rimuove sostanzialmente il numero a cui è associato dalla stringa infinita, quindi è un sì per entrambi gli scenari.

— clismique,

Le tue specifiche tuttavia dicono che s+è 2+3il primo esempio. E scontinua ancora a infastidirmi. Mi chiedo come si +s()+espande. Se è 1+(2)+4allora (viene prima, 2ma sciò che viene anche prima che (apparentemente salti ancora 3, no 2. Se tuttavia il risultato è 1+(3)+4quindi l'effetto di a sdipende da ciò che viene dopo (confrontalo con +s+)

— Ton Hospel

scè 23ed s+è 1+3? Fa ssaltare l' 1ora o il 2? Tutti gli esempi usano la prima operazione su operandi 1e 2... così scdovrebbe essere 13.

— Tito,

Risposte:

JavaScript (ES6), 110 byte

s=>eval((" "+s)[R='replace'](/[^\)](?!\()/g,x=>x+i++%10,i=1)[R](/c| (\ds)+|s\d/g,"")[R](/\d+\/\d+/g,"($&|0)"))

La divisione molto semplice, ma intera aggiunge 25 byte. Per qualche motivo, una regex in JS non può corrispondere sia all'inizio di una stringa che al primo carattere, quindi aggiunge anche alcuni byte.

Come funziona

Prepara uno spazio all'input.
Aggiungi la cifra successiva a ciascun carattere (tranne )) che non è immediatamente prima di a (.
Rimuovi ciascuno c, una cifra + sall'inizio ( 1s2-> 2) e ciascuno s+ una cifra ( 3s4-> 3).
Trasforma ogni operazione di divisione in int-division ( 1/2-> (1/2|0)).
Valuta e ritorna.

— ETHproductions
fonte

OK ... il tuo programma ha un bug ... ss+ritorna 6, quando deve tornare 7(I due ssaltano 1e 2, quindi, +aggiunge 3e 4).

— clismique,

@ Qwerp-Derp Grazie, risolto.

— ETHproductions

Qualcosa del genere /^|,|$/gcorrisponderà una sola volta all'inizio perché entrambe le partite avrebbero lo stesso indice. $non ha lo stesso problema perché la corrispondenza ha un indice maggiore di qualsiasi altra corrispondenza possibile.

— Neil,

Lotto, 332 byte

@echo off
set s=
set e=
set d=
set r=
set/ps=
:d
set/ad=-~d%%10
:l
if "%s%"=="" goto g
set c=%s:~0,1%
set s=%s:~1%
if %c%==( set e=%e%(&goto l
if %c%==) set r=%r%)&goto l
if %c%==s goto d
if %c%==c set c=
if "%r%"=="" set/ar=d,d=-~d%%10
set e=%e%%r%%c%
set/ar=d
goto d
:g
if "%r%"=="" set/ar=d
cmd/cset/a%e%%r%

Il comportamento di squesto rende molto imbarazzante. (Forse csdovrebbe valutare da 13e -sverso -2?) Variabili:

s stringa di input (esplicitamente cancellata perché set / p non cambia la variabile se non si inserisce nulla)
eespressione parziale nell'aritmetica intera normale (a cui possiamo passare set/acome una forma di eval)
d cifra successiva dalla stringa infinita di cifre
rlato destro dell'ultimo operatore. Non possiamo concatenarlo immediatamente perché (deve venire prima, ma dobbiamo memorizzarlo in modo da snon incrementarlo. Fortunatamente finisce per rendere la gestione )leggermente più semplice.
c personaggio attuale.

— Neil
fonte