Calculadora de operación entera simple


28

Implemente una calculadora de script de operación entera simple.

Concepto

El acumulador comienza en 0 y tiene operaciones realizadas en él. Al final de la salida del programa, el valor del acumulador.

Operaciones:

  • +agrega 1al acumulador
  • -resta 1del acumulador
  • * multiplica el acumulador por 2
  • / divide el acumulador por 2

Script de muestra

La entrada ++**--/debe dar la salida 3.

Implementación de ejemplo

def calc(s)
    i = 0
    s.chars.each do |o|
        case o
            when '+'
                i += 1
            when '-'
                i -= 1
            when '*'
                i *= 2
            when '/'
                i /= 2
        end
    end
    return i
end

Reglas

  • Este es el , por lo que la respuesta más baja en bytes gana, pero no está seleccionada.
  • Se recomiendan implementaciones creativas.
  • Las lagunas estándar están prohibidas.
  • Obtiene el programa a través de stdin o argumentos, y puede generar la respuesta a través del valor de retorno o stdout.
  • Que te diviertas.
  • La división se trunca porque es una división entera.
  • El programa -/vuelve -1.

Casos de prueba

*///*-*+-+
-1
/*+/*+++/*///*/+-+//*+-+-/----*-*-+++*+**+/*--///+*-/+//*//-+++--++/-**--/+--/*-/+*//*+-*-*/*+*+/+*-
-17 
+++-+--/-*/---++/-+*-//+/++-*--+*+/*/*/++--++-+//++--*/***-*+++--+-*//-*/+*/+-*++**+--*/*//-*--**-/-*+**-/*-**/*+*-*/--+/+/+//-+*/---///+**////-*//+-+-/+--/**///*+//+++/+*++**++//**+**+-*/+/*/*++-/+**+--+*++++/-*-/*+--/++*/-++/-**++++/-/+/--*/-/+---**//*///-//*+-*----+//--/-/+*/-+++-+*-*+*+-/-//*-//+/*-+//+/+/*-/-/+//+**/-****/-**-//+/+-+/*-+*++*/-/++*/-//*--+*--/-+-+/+/**/-***+/-/++-++*+*-+*+*-+-//+/-++*+/*//*-+/+*/-+/-/*/-/-+*+**/*//*+/+---+*+++*+/+-**/-+-/+*---/-*+/-++*//*/-+-*+--**/-////*/--/*--//-**/*++*+/*+/-+/--**/*-+*+/+-*+*+--*///+-++/+//+*/-+/**--//*/+++/*+*////+-*-//--*+/*/-+**/*//+*+-//+--+*-+/-**-*/+//*+---*+//*/+**/*--/--+/*-*+*++--*+//+*+-++--+-*-*-+--**+/+*-/+*+-/---+-*+-+-/++/+*///*/*-+-*//-+-++/++/*/-++/**--+-////-//+/*//+**/*+-+/+/+///*+*///*-/+/*/-//-*-**//-/-+--+/-*--+-++**++//*--/*++--*-/-///-+/+//--+*//-**-/*-*/+*/-*-*//--++*//-*/++//+/-++-+-*/*-+++**-/-*++++**+-+++-+-***-+//+-/**-+/*+****-*+++*/-*-/***/-/*+/*****++*+/-/-**-+-*-*-++**/*+-/*-+*++-/+/-++*-/*-****-*
18773342

2
Entonces ... no es estrictamente entero, ya que /puede producir no enteros.
Conor O'Brien

2
Entonces debe especificar esto explícitamente.
Conor O'Brien

55
¿Qué debería -/volver?
Dennis

44
No puedo evitar notar que el fragmento de código que aparece en la página de inicio de rust-lang resuelve este desafío.
Zwei

44
Por favor agregue más casos de prueba.
Martin Ender

Respuestas:


28

Python 2, 48 bytes

i=0
for c in input():exec"i=i%s2&-2"%c
print i/2

Ciervas +2, -2, *2, o /2. Al hacer +2y en -2lugar de +1y -1, estamos trabajando en unidades duplicadas, por lo que el resultado final debe reducirse a la mitad. Excepto, la división de piso /ahora necesita redondearse a un múltiplo de 2, lo que se hace con &-2.


¡Esto es brillante! Si desea publicarlo usted mismo, un puerto CJam de este sería actualmente el desafío: 0q{2\~-2&}/2/( 2\~evalúa el operador con el segundo operando 2, -2&es el AND bit a bit, 2/es la división final por dos. q{...}/Es un foreach sobre la entrada y 0es solo el inicial valor.)
Martin Ender

Puedes publicarlo, no sé CJam.
xnor

¡Muy inteligente! Portado a ES6, esto superaría fácilmente mi respuesta
edc65

Uso brillante de python. Aprendí algo nuevo de esto.
Jacobr365

12

Haskell, 51 bytes

x#'+'=x+1
x#'-'=x-1
x#'*'=x*2
x#_=div x 2 
foldl(#)0

Ejemplo de uso: foldl(#)0 $ "++**--/"-> 3.


12

Jalea , 18 17 bytes

‘

’

:2
Ḥ
O0;ṛĿ/

Pruébalo en línea!

Cómo funciona

Las primeras seis líneas definen enlaces auxiliares con índices que van del 1 al 6 ; aumentan, no hacen nada, disminuyen, no hacen nada, se reducen a la mitad (pisos) y se duplican.

El enlace principal O0;ṛĿ/- convierte los caracteres de entrada a sus puntos de código ( O), antepone un 0 (valor inicial) a la matriz de puntos de código 0;, luego reduce la matriz generada de la siguiente manera.

El valor inicial es el primer elemento de la matriz, es decir, el 0 antepuesto . Se ṛĿllama al enlace rápido para cada elemento siguiente en la matriz, con el último valor de retorno como argumento izquierdo y el elemento actual como derecho. Inspecciona su argumento correcto ( ) y evalúa el enlace con ese índice de forma monádica ( Ŀ), aplicando así la operación deseada.


10
Esta parece la respuesta de gelatina con más líneas nuevas
Conor O'Brien el

10

Python 2, 54 bytes

i=0
for c in input():exec"i=i"+c+`~ord(c)%5%3`
print i

La entrada se toma como un literal de cadena. ~ord(c)%5%3asigna los operadores a los correspondientes operandos derechos.

Anteriormente, utilicé hash(c)%55%3lo que no produjo resultados consistentes entre diferentes versiones de Python. Esto me animó a explorar otras fórmulas.


no parece funcionar ...
Destructible Lemon

55,3 y 65,4 son los dos más cortos para doble mod de hash en python 2
Jonathan Allan

@DestructibleWatermelon lo hace por mí: ideone
Jonathan Allan

Creo que hashes específica de la versión de Python: ideone usa 2.7.10 que da [1, 1, 2, 2]como las cuatro asignaciones, mientras que localmente en 2.7.12 obtengo[2, 0, 1, 0]
Sp3000

1
funciona en ideone, pero no en mi computadora python. Probablemente depende de la versión, en cuyo caso debe notarse la versión EDITAR: ninja'd: /
Destructible Lemon

10

SILOS , 133 211 bytes

:s
def : lbl G GOTO
readIO
i-46
if i a
i+2
if i b
i+2
if i c
i+1
if i d
G e
:a
G v
:p
a-1
a/2
G o
:v
a+1
if a p
a-1
j=a
j/2
k=j
k*2
k-a
a/2
if k t
G o
:t
a-1
:o
G s
:b
a-1
G s
:c
a+1
G s
:d
a*2
G s
:e
printInt a

Toma los códigos ASCII de los operadores.

Pruébelo en línea con casos de prueba:
-/
++**--/
*///*-*+-+


es loadLine golfier?
Rohan Jhunjhunwala

El OP aclaró; -/debería devolver -1 , no 0 .
Dennis

@Dennis arreglado. Sin embargo, se agregaron muchos bytes: /
betseg

9

Máquina de Turing - 23 estados (684 bytes)

Pruébalo aquí - enlace permanente

0 * * r 0
0 _ . l 1
1 * * l 1
1 _ * l 2
2 * 0 r 3
3 _ * r 3
3 + _ l +
3 - _ l -
3 x _ l x
3 / _ l /
+ _ * l +
+ * * * 4
4 - * l 5
4 _ 1 r 6
4 0 1 l 7
4 1 0 l 4
- _ * l -
- * * * 5
5 - * l 4
5 _ * r 8
5 0 1 l 5
5 1 0 l 7
x * * l x
x 1 0 l 9
x 0 0 l a
9 _ 1 r 6
9 1 1 l 9
9 0 1 l a
a _ _ r 6
a 1 0 l 9
a 0 0 l a
/ _ * l /
/ * * l b
b * * l b
b _ * r c
c 0 0 r d
c 1 0 r e
d * * l 7 
d 0 0 r d
d 1 0 r e
e _ * l 7
e - * l 4
e 0 1 r d
e 1 1 r e
8 * * r 8
8 - _ r 3
8 _ - r 3
7 * * l 7
7 _ * r f
f 0 _ r f
f 1 * r 6
f * _ l g
g * 0 r 6
6 * * r 6
6 _ * r 3
3 . _ l h
h _ * l h
h - _ l i
h * * l halt
i * * l i
i _ - r halt

La entrada no debe contener ningún '*' ya que es un carácter especial en el código de máquina de Turing. Use 'x' en su lugar. Emite la respuesta en binario.

Código no ofuscado

init2 * * r init2
init2 _ . l init0
init0 * * l init0
init0 _ * l init1
init1 * 0 r readop
readop _ * r readop
readop + _ l +
readop - _ l -
readop x _ l x
readop / _ l /
+ _ * l +
+ * * * inc
inc - * l dec
inc _ 1 r return
inc 0 1 l zero
inc 1 0 l inc
- _ * l -
- * * * dec
dec - * l inc
dec _ * r neg
dec 0 1 l dec
dec 1 0 l zero
x * * l x
x 1 0 l x1
x 0 0 l x0
x1 _ 1 r return
x1 1 1 l x1
x1 0 1 l x0
x0 _ _ r return
x0 1 0 l x1
x0 0 0 l x0
/ _ * l /
/ * * l //
// * * l //
// _ * r div
div 0 0 r div0
div 1 0 r div1
div0 * * l zero 
div0 0 0 r div0
div0 1 0 r div1
div1 _ * l zero
div1 - * l inc
div1 0 1 r div0
div1 1 1 r div1
neg * * r neg
neg - _ r readop
neg _ - r readop
zero * * l zero
zero _ * r zero1
zero1 0 _ r zero1
zero1 1 * r return
zero1 * _ l zero2
zero2 * 0 r return
return * * r return
return _ * r readop
readop . _ l fin
fin _ * l fin
fin - _ l min
fin * * l halt
min * * l min
min _ - r halt

Explicación de los estados:

Inicialización:
estos estados se visitan una vez al comienzo de cada ejecución, comenzando con init2

  • init2: muévete completamente hacia la derecha y pon un '.'. De esa manera, el TM sabe cuándo detenerse. Cambie a 'init0'.
  • init0: mueve toda la espalda hacia la izquierda hasta que la cabeza lea un espacio. Luego mueva una celda hacia la izquierda. Cambie a 'init1'.
  • init1: Pon un cero y mueve una celda a la derecha y cambia a 'readop'.

Instrucciones de lectura:
estos estados se visitarán varias veces durante todo el programa

  • readop: se mueve completamente hacia la derecha hasta que lee un operador o el '.'. Si golpea a un operador, cambie al estado correspondiente (+, -, x, /). Si toca un '.', Cambie al estado 'fin'.

  • return: Devuelve la cabeza al espacio vacío entre el total acumulado y los operadores. Luego cambia a 'readop'.

Operaciones:
estas operaciones hacen el trabajo sucio real

  • +: Mueve hacia la izquierda hasta que la cabeza lea cualquier carácter que no sea un espacio en blanco. Si este personaje es un '-', muévase a la izquierda y cambie a 'dec'. De lo contrario, cambie a 'inc'.

  • -: Similar a '+', excepto cambiar a 'inc' si hay un '-' y 'dec' de lo contrario.

  • inc: si el dígito debajo de la cabecera es un 0 (o un espacio en blanco), cámbielo a 1 y cambie a 'cero'. Si el dígito es un 1, cámbielo a 0, luego repita en el siguiente dígito.

  • dec: Similar a inc, excepto que 1 va a 0, 0 va a 1, y si la cabeza lee un espacio en blanco, cambie a 'neg'.

  • x, x0, x1: Bitshift el número uno a la izquierda. Cambiar a 'volver'.

  • /, //, div, div0, div1: muévete completamente a la derecha del número, luego desplaza uno a la derecha. Si hay un '-', cambie a 'inc'. Esto simula redondear números negativos. De lo contrario, cambie a 'cero'

  • neg: coloque un '-' después del número y luego cambie a 'readop'

  • cero, cero1, cero2: elimine los ceros a la izquierda y cambie a 'readop'

Limpieza: hace que la salida sea presentable

  • fin, min: mueva el '-' delante del número si es necesario. Detener.

1
Pensé que leer este código era muy, muy bueno. Así que gracias por alegrarme el día.
Jacobr365

8

Perl 6 , 53  52 bytes

{([Ro] %(<+ - * />Z=>*+1,*-1,* *2,*div 2){.comb})(0)}

{[Ro](%(<+ - * />Z=>*+1,*-1,*×2,*div 2){.comb})(0)}

Explicación:

# bare block lambda that has one implicit parameter 「$_」
{
  (
    # reduce the code refs using ring operator 「∘」 in reverse 「R」
    [R[o]]

      # produce a hash from:
      %(

        # list of pairs of "operator" to code ref
        # ( similar to 「'+' => { $^a + 1 }」 )

          # keys
          < + - * / >

        # keys and values joined using infix zip operator 「Z」
        # combined with the infix Pair constructor operator 「=>」
        Z[=>]

          # values (Whatever lambdas)
          * + 1,
          * - 1,
          * × 2, # same as 「* * 2」
          * div 2,

      ){

        # split the block's argument into chars
        # and use them as keys to the hash
        # which will result in a list of code refs
        .comb

      }

  # call composed code ref with 0
  )(0)
}

Uso:

my $input = '++**--/'
my $output = {[Ro](%(<+ - * />Z=>*+1,*-1,*×2,*div 2){.comb})(0)}.( $input );
say $output; # 3
say $output.^name; # Int


6

05AB1E , 20 bytes

¡Gracias a Enigma por arreglar el -/error!

Para 16 bytes si no fuera número entero división: Î"+-*/""><·;"‡.V.

Î…+-*"><·"‡'/"2÷":.V

Explicación:

Î                      # Push 0, which is our starting variable, and input
 …+-*                  # Push the string "+-*"
     "><·"             # Push the string "><·"
          ‡            # Transliterate. The following changes:
                           "+" -> ">"
                           "-" -> "<"
                           "*" -> "·"
           '/"2÷":     # Replace "/" by "2÷"
                  .V   # Evaluate the code as 05AB1E code...
                           '>' is increment by 1
                           '<' is decrement by 1
                           '·' is multiply by 2
                           '2÷' is integer divide by two
                       # Implicitly output the result

Utiliza la codificación CP-1252 . Pruébalo en línea!


El OP aclaró; -/debería devolver -1 , no 0 .
Dennis

El problema de la división de números negativos podría solucionarse con Î…+-*"><·"‡'/"2÷":.Vel mismo recuento de bytes.
Emigna

@Dennis Solucionó el problema.
Adnan

@Emigna Gracias :)
Adnan

5

JavaScript ES6, 80 68 bytes

k=>[...k].reduce((c,o)=>+{"+":c+1,"-":c-1,"*":c*2,"/":c/2|0}‌​[o],0)

¡Ahorró la friolera de 12 bytes gracias a Neil!


La segunda respuesta sería más legible si eliminaras "c"+y escribieras, "c+1 c-1 c*2 c/2|0".splitetc.
Neil

Para la primera respuesta, ¿por qué no escribir o=>c=[c+1,c-1,c*2,c/2|0]["+-*/".indexOf(o)], o creo que puede continuar para guardar otro byte usando o=>c={"+":c+1,"-":c-1,"*":c*2,"/":c/2|0}[o]?
Neil

k=>[...k].reduce((c,o)=>+{"+":c+1,"-":c-1,"*":c*2,"/":c/2|0}[o],0)podría funcionar aún más corto aún, pero he perdido la cuenta ...
Neil

@Neil Ah, sí, me olvidé de esto
Conor O'Brien el

1
De alguna manera llegaste a caracteres de ancho cero entre }y [o], por lo que en realidad solo tiene 66 bytes de longitud. Además, el OP aclaró; -/debería devolver -1 , no 0 .
Dennis

5

Ruby, 48 44 42 + 1 = 43 bytes

+1 byte para -nbandera. Toma entrada en STDIN.

i=0
gsub(/./){i=i.send$&,"+-"[$&]?1:2}
p i

Véalo en ideone (usos $_ya que ideone no toma banderas de línea de comando): http://ideone.com/3udQ3H



4

Python 2, 58 56 bytes

-2 bytes gracias a @Lynn

r=0
for c in input():exec'r=r'+c+`2-ord(c)%11%3`
print r

Los ordinales de los personajes +-*/son 43,45,42,47de módulo 11 son 10,1,9,3de módulo 3 son aquellos 1,1,0,0, 2 menos los que están 1,1,2,2dando las cantidades que necesitamos para cada operación: r=r+1, r=r-1, r=r*2, yr=r/2


Anterior:

r=0
for c in input():exec'r=r'+c+`(ord(c)%5==2)+1`
print r

¿Qué tal 2-ord(c)%11%3?
Lynn

@ Lynn Bueno, lo llevaré si te parece bien? (pero realmente creo que es un cambio suficiente que podría publicarlo)
Jonathan Allan

2
Adelante :) ----
Lynn

4

Mathematica, 83 73 70 bytes

10 bytes guardados debido a @MartinEnder .

(#/*##2&@@#/.Thread[{"+","-","*","/"}->{#+1&,#-1&,2#&,⌊#/2⌋&}])@0&

Función anónima. Toma una lista de caracteres como entrada y devuelve un número como salida. Sugerencias de golf bienvenidas.


4

SILOS , 175 164 bytes

loadLine
a=256
o=get a
lbla
a+1
o-42
p=o
p-1
p/p
p-1
r-p
s=o
s-3
s/s
s-1
r+s
m=o
m/m
m-2
m|
r*m
t=r
t%2
d=o
d-5
d/d
d-1
t*d
d-1
d|
r-t
r/d
o=get a
if o a
printInt r

Pruébalo en línea!

Método de entrada sano. División entera correcta (redondeada hacia -infinito).


4

C #, 87 81 bytes

int f(string s){int i=0;foreach(var c in s)i=c<43?i*2:c<46?i+44-c:i>>1;return i;}

Sin golf:

int f(string s)
{
    int i = 0;

    foreach (var c in s)
        i = c < 43 ? i * 2
          : c < 46 ? i + 44 - c
          : i >> 1;

    return i;
}

Se supone que la entrada es válida. La división por dos se realiza desplazando un bit hacia la derecha, porque la división regular siempre se redondea hacia cero, y el desplazamiento de bits siempre se reduce. El incremento y la disminución hacen un uso útil de la distancia 1 entre los códigos ASCII para +y -.


¿Te encanta la nueva sintaxis C # 6 y el método agregado de Linq? int f(string s)=>s.Aggregate(0,(i,c)=>c<43?i*2:c<46?i+44-c:i>>1);(65 bytes)
Cyril Gandon

@CyrilGandon, que yo sepa, tendría que incluir el "uso de System.Linq;", lo que lo hace 19 más largo y lo pone a 84 bytes. Por eso no lo hice.
Scepheo

4

Javascript (ES6), 57 bytes (matriz) / 60 bytes (entero)

Devolver una matriz de todos los resultados intermedios:

o=>[...o].map(c=>x=[x>>1,x+1,x*2,x-1][eval(2+c+3)&3],x=0)

Por ejemplo, la salida para "++**--/"será [1, 2, 4, 8, 7, 6, 3].

Devolviendo solo el resultado final:

o=>[...o].reduce((x,c)=>[x>>1,x+1,x*2,x-1][eval(2+c+3)&3],0)

Cómo funciona

Ambas soluciones se basan en la misma idea: el uso de la función hash perfecta eval(2+c+3)&3para mapear los diferentes caracteres operadores cen [0, 3].

 operator | eval(2+c+3)  | eval(2+c+3)&3
----------+--------------+---------------
    +     |  2+3 = 5     |    5 & 3 = 1
    -     |  2-3 = -1    |   -1 & 3 = 3
    *     |  2*3 = 6     |    6 & 3 = 2
    /     |  2/3 ~= 0.67 | 0.67 & 3 = 0

3

JavaScript (ES6), 57

a=>[...a].map(c=>a=c<'+'?a<<1:c<'-'?-~a:c<'/'?~-a:a>>1)|a

Nota: el valor inicial para el acumulador es la cadena del programa, utilizando operaciones de bit (~, >>, <<, |) se convierte a 0 en el primer uso.

Como nota al margen, la respuesta inteligente de @xnor obtendría 40 puntos portados a javascript:

a=>[...a].map(c=>a=eval(~~a+c+2))&&a>>1

(si te gusta esto, vota por él)

Prueba

f=a=>[...a].map(c=>a=c<'+'?a<<1:c<'-'?-~a:c<'/'?~-a:a>>1)|a

function update() {
  O.textContent = f(I.value);
}

update()
<input value='++**--/' id=I oninput='update()'><pre id=O></pre>


3

Java, 77 bytes

int f(String s){return s.chars().reduce(0,(r,c)->c<43?r*2:c<46?r+44-c:r>>1);}

Utiliza java 8 transmisiones.


1
Buena respuesta, y bienvenido al sitio! No sé nada acerca de Java, pero se puede cambiar r >> 1a r>>1y ahorro 2 bytes?
DJMcMayhem

Tienes toda la razón, gracias @DJMcMayhem
primodemus

1
Impresionante, me alegro de poder ayudar! Una nota más, estoy contando 77 bytes. ¿Incluiste la nueva línea en tu recuento de bytes? Puede quitar un byte más ya que no es necesario.
DJMcMayhem

Corrija nuevamente @DJMcMayhem, aparentemente wc cuenta el byte de
terminación

1
como está usando java8, ¿por qué no define la función usando lambda, s->s.chars().reduce(0,(r,c)->c<43?r*2:c<46?r+44-c:r>>1);que le dará 56 bytes
user902383

3

GNU sed, 65 59 57 bytes

Editar: 2 bytes más cortos gracias a los comentarios de Toby Speight

s/[+-]/1&/g
s/*/2&/g
s:/:d0>@2&:g
s/.*/dc -e"0[1-]s@&p"/e

Correr:

sed -f simple_calculator.sed <<< "*///*-*+-+"

Salida:

-1

El sedscript prepara la entrada para la dcllamada de shell al final, este último acepta la entrada en notación polaca inversa . En la división, si el número es negativo ( d0>), se llama al [1-]comando de disminución almacenado en el registro @. Ejemplo de conversión: + - * /-> 1+ 1- 2* d0>@2/.


No necesita las comillas alrededor del argumento para dc, si no hay espacios y no hay archivos que coincidan con el [1-]patrón ...
Toby Speight

@TobySpeight En mi mente cambié el significado de scon S. Olvidé que no reemplaza la pila del registro, lo empuja, teniendo el efecto contrario de lo que quería (ya que lo usé para todos /). Las comillas todavía son necesarias porque tiene /símbolos que hacen que la cadena se interprete como una ruta de archivo :) Afeité 1 byte más al eliminar el espacio después de -e.
seshoumara

1
dc no interpretará el argumento -ecomo un nombre de archivo, por lo que no necesita comillas para el /- ¡pruébelo! Creo que es razonable que un código de golf requiera que el directorio de trabajo actual no contenga ningún archivo que comience con 01s@o 0-s@.
Toby Speight

@TobySpeight que tenías razón -erespecto /, sin embargo, las cotizaciones aún se requieren como acabo de ver ahora. El >intérprete interpreta directamente el shell como un operador de redireccionamiento, ya que recibí este error:cannot create @2/d0: Directory nonexistent
seshoumara

Ah, sí, no consideré el >. Necesitas citas, después de todo. ¡Disculpas por (intentar) engañar! Y, aunque agregar una barra diagonal inversa parece un personaje, debe duplicarse en un s///reemplazo, por lo que no hay beneficio allí ...
Toby Speight

3

PHP, 75 bytes

Utiliza una versión modificada de la respuesta de Jörg Hülsermann .

eval(preg_replace('~.~','$s=($s\0(2-ord("\0")%11%3))|0;',$argv[1]));echo$s;

Se basa en gran medida en la sustitución de cadenas, utilizando una expresión regular simple ( ~.~).

La variable $sse reasigna con el nuevo valor para cada carácter. Al final, genera el resultado.


Nota : Esto está destinado a ejecutarse utilizando la -rbandera.


Pruébalo aquí:

O prueba: http://sandbox.onlinephpfunctions.com/code/7d2adc2a500268c011222d8d953d9b837f2312aa

Diferencias:

  • En lugar de echo$s, estoy usando sprintf($s). Ambos realizan la misma acción en números. Como esto es solo para probar, está bien.
  • En caso de que no haya un argumento aprobado, se ejecutará como si hubiera pasado ++*+como primer argumento, que debería mostrar 5.

¡Hurra! ¡El emodificador ha vuelto! : D
Tito

@Titus no lo entiendo. ¿Puedes elaborar un poco?
Ismael Miguel

PHP antes de la versión 7 tenía un modificador de patróne , que fue reemplazado por preg_replace_callbacky podría abusarse de él ... pero esto no es todo eso.
Titus

@Titus Ese modificador patern se usó para indicar que la salida sería un código PHP real y para tratar de mantener la sintaxis correcta. Esto aquí, no lo usa, pero reemplaza cada carácter con un código para ejecutar, independientemente de su sintaxis. Las entradas incorrectas causarán graves problemas de seguridad.
Ismael Miguel

Lo sé. Pero se parece.
Titus

2

Lote, 61 bytes

@set n=
@for %%a in (%*)do @set/an=n%%a2^&-2
@cmd/cset/an/2

Traducción de la respuesta de @ xnor's xcellent Python.


2

Pyke, 24 22 bytes

\*\}:\/\e:\+\h:\-\t:0E

Pruébalo aquí!

O 12 bytes (no competitivo)

~:"ht}e".:0E

Pruébalo aquí!

Agregar translatenodo: básicamente, buscar y reemplazar múltiples

~:           -   "+-*/"
        .:   -  input.translate(^, V)
  "ht}e"     -   "ht}e"
          0E - eval(^, stack=0)

2

PHP, 104 102 82 bytes

Primera versión con eval:

$i=0;while($c<9999)eval('$i'.['+'=>'++','-'=>'--','*'=>'*=2','/'=>'>>=1'][$argv[1]{$c++}].';');echo$i;

Segunda versión con operadores ternarios:

while($o=ord($argv[1]{$c++}))$i=$o<43?$i*2:($o<44?$i+1:($o<46?$i-1:$i>>1));echo$i;

Toma la cadena de entrada como primer argumento de la línea de comando.

Este "solo" funciona para cadenas de entrada de menos de 10,000 caracteres, lo que debería ser suficiente. Probado con todos los casos de prueba, desafortunadamente no se puede ahorrar en la inicialización al principio.La segunda versión funciona con cadenas de cualquier longitud y sin inicialización. :-)

El elemento principal es la función eval que manipula en $ibase a un mapa de operaciones aritméticas, que son bastante sencillas excepto por la división. PHP devuelve un flotante cuando se usa /y intdivtiene demasiados bytes, por lo que hacemos un desplazamiento a la derecha .

Actualizaciones

  1. Guardado 2 bytes por el acortamiento $i=$i>>1de $i>>=1la división de número entero.
  2. Descartó eval a favor de los operadores ternarios.

2

Python 3, 98 66 60 bytes

Gracias Tukkax!

No es tan elegante como la otra respuesta, pero no puedo competir con ellos sin plagio.

i=0
for c in input():i+=[1,-i//2,-1,i][ord(c)%23%4]
print(i)

Además, también tengo una solución lambda recursiva

73 67 bytes (¡mejorado!)

s=lambda x,z=0:s(x[1:],z+[1,-z//2,-1,z][ord(x[0])%23%4])if x else z

Mediante la aplicación de parte de su solución recursiva para la versión de procedimiento: 60 bytes: i=0 for c in input():i+=[1,-i//2,-1,i][ord(c)%23%4] print(i). (no formateado correctamente, por supuesto). También creo que deberías mencionar que estás usando Python3. En Python2, input()evaluaría a int(raw_input()).
Yytsi

@TuukkaX no funciona para z = 0 ( +-hace 1)
Destructible Lemon

oh si, mi error
Yytsi

1
Agregue el título Python3 por favor.
Yytsi

2

R, 201 bytes

Golfed

p=.Primitive;"-"="+"=function(x)p("+")(x,1);body(`-`)[[1]]=p("-");"*"="/"=function(x)p("*")(x,2);body(`/`)[[1]]=p("%/%");Reduce(function(f, ...)f(...),rev(mget(strsplit(scan(stdin(),""),"")[[1]])),0,T)

Comentado

p = .Primitive                       # Redefine
"-" = "+" = function(x)p("+")(x,1)   # Define - and +
body(`-`)[[1]] = p("-")              # Change the body, what we do to save a byte
"*" = "/" = function(x)p("*")(x,2)   # Same as above
body(`/`)[[1]] = p("%/%")            # Same as above
Reduce(function(f, ...)f(...),       # Function wrapper to evaluate list of func.  
  rev(mget(strsplit(scan(stdin(),""),"")[[1]])), # Strsplit input into list of functions
  init = 0,                                      # Starting Arg = 1
  right = T)                                     # Right to left = True 

La estrategia es refinar los +, -, %operadores. Divida la cadena y luego analice la cadena en una larga lista de funciones, para alimentar al Reduce()'sacumulador.

No podía seguir jugando al golf. Si alguien puede ponerse b=body<-a trabajar, podría haber algunos bytes de ahorro (refine cada función con bafter "-"="+"="/"="*"). Inicialmente trató de sustituir y analizar eval, pero el orden de las operaciones y los paréntesis fueron aterradores.


Este es un año más tarde, pero me las arreglé para conseguir abajo 10 bytes intercambiando su enfoque un poco - que puede caer 8 bytes eliminando el espacio entre f, ...en la definición de la Reducefunción y deshacerse de stdin()en scanpero yo sólo probado un ingenuo enfoque que dejó caer dos bytes más al definir las funciones de manera un poco diferente. tio.run/##XcvLCsMgEAXQrwnO6Gge29B/…
Giuseppe

1

Lex + C, 78 , 74 , 73 bytes

El primer personaje es un espacio.

 c;F(){yylex(c=0);return c;}
%%
\+ c++;
- c--;
\* c*=2;
\/ c=floor(c/2.);

Lee desde stdin, devuelve resultado.

Compilar con lex golfed.l && cc lex.yy.c main.c -lm -lfl, prueba principal:

int main() { printf("%d\n", F()); }

1

Javascript (ES5), 127 bytes

function(b){for(a=c=0;a<b.length;++a)switch(b[a]){case"+":++c;break;case"-":--c;break;case"*":c*=2;break;case"/":c/=2}return c}

Sin golf:

function c(a){
  c=0;
  for(var i=0;i<a.length;++i){
    switch(a[i]){
      case "+":++c;break;
      case "-":--c;break;
      case "*":c*=2;break;
      case "/":c/=2;break;
    }
  }
  return c;
}

1

Pyth, 23 bytes

FNQ=Z.v%".&%sZ2_2"N;/Z2

Un programa completo que toma la entrada como una cadena e imprime el resultado.

Este es un puerto de la respuesta Python de @ xnor .

Pruébalo en línea

Cómo funciona

FNQ=Z.v%".&%sZ2_2"N;/Z2   Program. Input: Q. Z initialised as 0
FNQ                       For. For N in Q:
        ".&%sZ2_2"         String. Literal string ".&%sZ2_2"
       %          N        String format. Replace %s with the current operator N
           %sZ2            Operator. Yield Z*2, Z//2, Z+2, Z-2 as appropriate
         .&    _2          Bitwise and. Result of above & -2
     .v                    Evaluate. Yield the result of the expression
   =Z                      Assignment. Assign result of above to Z
                   ;      End. End for loop
                    /Z2   Integer division. Yield Z//2
                          Print. Print the above implicitly 

1
Convertir Python a Pyth es principalmente una mala idea. u@[yGhG0tG0/G2)CHQ019 bytes
Jakube

@Jakube Gracias: soy muy nuevo en Pyth, por lo que agradezco cualquier consejo. Siéntase libre de publicar eso como una respuesta separada, ya que es un enfoque diferente.
TheBikingViking

1

PHP, 79 bytes

<?$i=0;switch($_POST['a']){case"+":$i+1;case"-":$i-1;case"/":$i/2;case"*":$i*2}

2
Incluya el bytecount en su encabezado, elimine los espacios no necesarios y use nombres de variables de 1 letra.
TuxCrafting

¿Es esto incluso golfista? :-D
YetiCGN

@ TùxCräftîñg lo hice.
Winnie The Pooh

Divides y multiplicas por 1; necesitas dividir y multiplicar por2
TuxCrafting

@ TùxCräftîñg lo hice.
Winnie The Pooh
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.