Esse desafio é o primeiro de uma série de dois desafios sobre Repetição. O segundo será lançado em breve.

Em uma linguagem chamada Repetition (algo que acabei de inventar), existe uma sequência infinita de 12345678901234567890..., com1234567890 repetindo sempre.

A seguinte sintaxe está disponível para gerar números:

• +-*/: Isso insere o operador na sequência de dígitos repetidos.
  • Exemplos:
    • +-> 1+2= 3( +insere um +entre 1e 2)
    • +*-> 1+2*3= 1+6= 7(O mesmo que acima, exceto que dois operadores são usados ​​agora)
    • /-> 1/2= 0(Repetição usa divisão inteira)
    • //-> 1/2/3= 0/3= 0(A repetição usa "associação à esquerda" com várias subtrações e divisões)
  • Cada operador é inserido para ter um dígito à esquerda, a menos que haja c(veja abaixo).
• c: Concatena com o próximo dígito na sequência.
  • Exemplos:
    • c+-> 12+3= 15(O c"continua" 1e o concatena com o próximo dígito 2, para formar 12)
    • +c-> 1+23=24
    • ccc -> 1234
• (): Colchetes para processar números.
  • Exemplos:
    • (c+)*-> (12+3)*4= 15*4= 60(a repetição usa a ordem das operações)
    • (c+)/c-> (12+3)/45= 15/45=0
    • (cc+c)/-> (123+45)/6= 168/6=28
• s: Pula um número (remove o número da sequência infinita).
  • s+-> 2+3= 5( spula 1)
  • csc-> 124(a primeira cconcats 1e 2, os ssaltos 3e as finais cconcats 12a 4)
  • +s+-> 7(O primeiro +adiciona 1e 2fazer 3, ssaltos 3, ea final +acrescenta 3a 4fazer 7)
  • cs*(++)-> 12*(4+5+6)= 12*15=180

Nos exemplos acima, apenas uma quantidade finita de dígitos na cadeia infinita é usada. O número de dígitos usados ​​é equivalente a number of operators, concats and skips + 1.

Sua tarefa é, quando receber uma sequência de códigos de repetição, gerar o resultado.

Exemplos de entrada e saída são:

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

Este é o código golf, pelo que o código mais curto em bytes vence!

Especificações:

• Você está garantido que o resultado nunca será superior 2^31-1 .
• Você também tem a garantia de que a entrada consistirá apenas dos símbolos +-*/cs().
• Um programa vazio será exibido 1.

JavaScript (ES6), 110 bytes

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

Muito simples, mas a divisão inteira adiciona 25 bytes. Por alguma razão, uma regex em JS não pode corresponder ao início de uma sequência e ao primeiro caractere, portanto, isso adiciona alguns bytes também.

Como funciona

1. Anexe um espaço à entrada.
2. Anexe o próximo dígito a cada caractere (exceto )) que não está imediatamente antes de a (.
3. Remova cada cum, um dígito + sno início ( 1s2-> 2) e cada sum + um dígito ( 3s4-> 3).
4. Transforme cada operação de divisão em divisão int ( 1/2-> (1/2|0)).
5. Avalie e retorne.

Lote, 332 bytes

@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%

O comportamento de storna isso muito estranho. (Talvez csdeva avaliar para 13e -spara -2?) Variáveis:

• s string de entrada (explicitamente apagada porque set / p não altera a variável se você não inserir nada)
• eexpressão parcial na aritmética inteira normal (à qual podemos passar set/acomo forma de eval)
• d próximo dígito da sequência infinita de dígitos
• rlado direito do operador mais recente. Não podemos concatenar isso imediatamente porque (precisa vir primeiro, mas precisamos armazená-lo para que snão o incremente. Felizmente, acaba tornando o manuseio )um pouco mais fácil.
• c caractere atual.