¿Por qué un simulador?

Los niños en estos días no tienen el tiempo ni la ambición de ir a apilar cajas en el balancín o jugar con objetos físicos equilibrados. ¡Esto deja mucho espacio en el mercado de software para un simulador de palanca que, según mis modelos, se venderá como un loco!

Ayuda de programación deseada

He presentado la patente de dicho juego (pendiente), pero necesito un programador experto para que escriba la lógica del juego. Según tengo entendido, es una práctica estándar compensar a los programadores en función del tamaño en bytes del programa final. Como tal, otorgaré este lucrativo contrato al mejor postor.

Especificación

Una palanca es una serie de cajas o espacios vacíos que se equilibra con un punto de apoyo. Cada caja tiene un peso particular de uno a nueve y los espacios no tienen peso. Como sabes, el peso de una caja en la palanca es directamente proporcional a qué tan lejos está esa caja del punto de apoyo. Una caja de peso 4que se encuentra en el tercer espacio desde el punto de apoyo contribuirá 12con unidades de fuerza efectivas a ese lado de la palanca.

Necesito un programa que, dada una palanca de entrada, produzca si la palanca se inclinará hacia la izquierda, la derecha o estará perfectamente equilibrada.

Pautas de E / S

• Me escribirás un programa.
• La entrada contendrá una línea de texto.
• La entrada vendrá de stdino como una cadena de línea de comandos.
• Las cajas serán representadas por los caracteres ' 1' a ' 9'. Estos personajes representan sus respectivos pesos. Un espacio vacío será representado por un espacio ' '. El punto de apoyo estará representado por un cursor ' ^'.

Una palanca de entrada de muestra podría verse así: 8 2^ 941

Esta palanca está perfectamente equilibrada: (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

• No habrá espacios iniciales ni finales. No habrá nueva línea final.
• No es necesario manejar entradas mal formadas, las entradas siempre tendrán exactamente un punto de apoyo, y solo números y espacios.
• La salida indicará si la palanca es pesada a la izquierda, pesada a la derecha o equilibrada.
• Su programa debe tener exactamente 3 salidas posibles que podrían resultar de una entrada bien formada. Puedes elegir cuáles son.
• La salida debe imprimirse stdouto ser el código de retorno del programa.

Casos de prueba

Aquí, he utilizado L, R, Ben el sentido de pesado izquierda, derecha-pesado, equilibrado:

1. Entrada: 11 ^9Salida:B

2. Entrada: 321^ 12Salida:L

3. Entrada: 9^ 1Salida:R

(Si alguien tiene algunos casos de prueba "más complicados", no dude en editarlos).

Bibliografía

No necesariamente inspirado, pero relacionado con Balancear un conjunto de pesas en un balancín

Python 2, 69 bytes

lambda s:cmp(sum(ord(c)%16*(i-s.find('^'))for i,c in enumerate(s)),0)

El módulo ord(c)%16extrae el valor de un carácter de dígito mientras obtiene 0 para el espacio. Para cada carácter, su contribución de torque se calcula como su peso multiplicado por la distancia firmada al pivote i-s.find('^'), y estos se suman y comparan con 0, produciendo uno de -1,0,1. Se ^calcula que el personaje tiene un peso 14, pero eso no importa porque está en el pivote.

Un puerto Pyth de 18 bytes de Maltysen:

._s.e*-kxz\^%Cb16z

Para el código Python, si se requiere un programa completo, aquí hay 79 bytes. La idea es comenzar a icambiar el índice s.find('^'), y hacer que la cuenta regresiva.

s=raw_input()
t=0;i=s.find('^')
for c in s:t-=ord(c)%16*i;i-=1
print cmp(t,0)

Javascript ES6, 62 Bytes

s=>Math.sign([...s].reduce((p,c,i)=>p+~~c*(i-s.indexOf`^`),0))

• -1 si se deja es más pesado
• 0 si equilibrado
• 1 si derecho es más pesado

Sin golf:

s=>
  Math.sign(                     // output sign of weight of lever
    [...s].reduce((p,c,i)=>      // split and reduce input
      p+~~c*(i-s.indexOf`^`),0)) // add weights of all elements
                                 //   (elements left of pivot are negatively weighted)

Pruebas ejecutadas (asignando funciones anónimas a f):

>> f("11   ^9")
<< 0

>> f("321^  12")
<< -1

>> f("9^         1")
<< 1

• -11 bytes: cambio de salida de R B La-1 0 1
• -3 bytes: cambiado e.split``a [...e](gracias @ Vɪʜᴀɴ)
• -33 bytes: algoritmo cambiado para usar pesos negativos en lugar de dividir en pivote
• -9 bytes: verificación de pivote eliminada (aparentemente, ~~'^'evalúa a 0...)
• -2 bytes: función hecha anónima (gracias @ cᴏɴᴏʀ-obʀɪᴇɴ)

Japt , 22 bytes

Japt es una versión abreviada de Ja vaScri pt . Interprete

U¬r@X+~~Y*(Z-Ub'^),0 g

Devuelve -1para L, 0para By 1para R.

Cómo funciona

Uq r@X+~~Y*(Z-Ub'^),0 g
                         // Implicit: U = input string
Uq r@              ,0    // Reduce the input by this function, starting at 0:
     X+~~Y*              //  Return the previous value, plus the current value times
           (Z-Ub'^)      //   the current index minus the index of "^" in U.
                      g  // Take the sign of the resulting number.
                         // Implicit: output last expression

APL, 39 30 bytes

{×+/(10|⍵⍳⍨∊⍕¨⍳9)×(⍳⍴⍵)-⍵⍳'^'}

Después de releer las reglas, he cambiado esto a salida en -1 0 1lugar de L B Rguardar nueve bytes.

Pruébalo aquí .

Pyth, 20 bytes

._s*V-Rxz\^Uzm.xsd0z

Banco de pruebas

-1para sesgado a la izquierda, 0para equilibrado, 1para sesgado a la derecha.

Cómo funciona:

._s*V-Rxz\^Uzm.xsd0z
                        z = input()
                        Weights:
             m     z    Map over z
              .x        try:
                sd           cast charater to int
                  0     except: 0
                        Lever arm:
           Uz           range(len(input()))
     -Rxz\^             Subtract index of caret from each value.
   *V                   Vectorized multiplication.
  s                     Sum.
._                      Take sign and print.

Haskell, 116 96 82 76 bytes

 f x=signum$sum$zipWith(*)[-length(fst$span(<'^')x)..]$(`mod`16).fromEnum<$>x

La salida es 0para balanceado, -1para pesado a la izquierda y 1para pesado a la derecha.

Ejemplo de uso: f "321^ 12"->-1

Cómo funciona: encuentra la parte anterior a ^. Multiplique la cadena de entrada y la lista de pesos que comienza en - length-of-first-part. El ^Tiene un peso de 0 y no añade a la suma. Estoy usando el truco mod 16 de @ xnor para convertir dígitos / espacios a valores enteros. Si la suma es negativa (positiva), la palanca es pesada a la izquierda (pesada a la derecha) y equilibrada si la suma es 0.

TeaScript , 23 bytes 25

Traté de escribir una respuesta de Pyth pero eso fue horriblemente: \

$²xd»l+~~i*(a-xi`^`),0©

Que ²se ve tan fuera de lugar, pero se ahorra 1 byte, así que voy a ser de mantenimiento de la misma.

Pruébalo en línea!

Prueba todos los casos

Para el esquema de salida que he elegido:

• -1si Left es más pesado que Right ( L)
• 0si Left es tan pesado como Right ( B)
• 1is Left es menos pesado que Right ( R)

Ungolfed && Explicación

Esto utiliza mapas y reduce para hacer el trabajo.

$C(xd(#l+~~i*(a-xi`^`),0))

              // Implicit: x = input
$C(           // Compare...
  xd(#        // Reduce...
    l+          // Pending weight...
    ~~i         // Current weight -> int times...
    (a-         // Total length minus...
    xi`^`       // Fulcrum location
  ,0)
)             // Implicit: Output result

pb , 349 329 bytes

^w[B!94]{>}w[B!0]{vb[T]^t[T+1]>}vb[46]<w[B!0]{<}b[1]vvb[46]^^t[X]w[X!0]{<b[T-X]}^w[B!0]{w[B=32]{b[48]}>}w[X!0]{<t[B-48]vb[B*T]^}w[B!0]{vt[B]vb[1]>^w[B!46]{>}vvb[B+T]^w[B=0]{<}b[0]^b[0]^>}vb[0]vvt[B]<w[B!0]{<}t[B+T]^>[T]w[X!0]{b[10]<}<[T]w[X!0]{b[16]>}vw[B=0]{>}t[B]b[0]w[B=0]{>}t[T-B]b[0]^<[X-T]t[B]<[X]>w[B!0]{b[0]>}<[X]^b[T+66]

Esto fue complicado. PB no fue diseñado para ser bueno en este tipo de cosas. Ni siquiera tiene multiplicación . Pero bueno, funciona.

Ed. nota: ¿Acabo de decir que pb no tiene multiplicación? ¿Qué? pb definitivamente definitivamente tiene multiplicación. Me diseñado e implementado este lenguaje, debería saber que se ha construido en la multiplicación y no tener que hacer alguna adición bucle tonta. Arreglar eso (además de hacer un reordenamiento creativo ahora que podría abordar esa parte del problema desde [casi literalmente] desde un ángulo diferente) me ahorra 20 bytes. Embarazoso.

La parte más difícil fue, después de obtener las sumas de (peso * distancia) para cada lado, determinar realmente qué letra imprimir. pb no tiene >u <operadores, solo ==y !=. No hay una manera fácil de saber qué valor es mayor. Ni siquiera puedo restar y comparar con 0 ... a menos que haga algo realmente tonto.

• Encuentra la suma de las dos sumas.
• Ve tan lejos hacia la derecha, en una línea que no se usa para nada.
• Hasta llegar a X = 0, ve a la izquierda y coloca 'L's.
• Coloque una 'B' en X = 0.
• Ve a la izquierda por la suma de las dos sumas.
• Hasta llegar a X = 0, ve a la derecha y coloca 'R's.

Luego, simplemente vas a X = (lado izquierdo - lado derecho), ¡y ahí está tu respuesta! Elimine todo en esa línea para limpiar y luego imprima el valor que se encontró en (0, 0).

... Pero hay un camino un poco más corto. En lugar de usar 'L', 'B' y 'R', use esos valores: 'B' y agregue 'B' nuevamente al imprimir. De esa manera, nunca tendrá que colocar 'B' en X = 0, simplemente déjelo como el 0 que ya estaba. El único problema es que una vez que haces esto, el programa se vuelve muy tonto en el modo reloj. 'L'-'B'==76-66==10=='\n'. Todo parece estar funcionando bien, hasta que de repente se imprime una gran cantidad de nuevas líneas y es imposible hacer un seguimiento de lo que está sucediendo: D Sin embargo, en el modo de ejecución regular de pbi, todo funciona bien porque las nuevas líneas se eliminan antes de que se imprima algo en el consola.

^w[B!94]{>}                 # Find the fulcrum

w[B!0]{                     # Starting at the fulcrum and going right:
    vb[T]^                    # Store the T below each character of input
    t[T+1]                    # Increment T
    >
}

vb[46]                      # Put a '.' at the end of the values below the input

<w[B!0]{<}                  # Go to the space below the fulcrum
b[1]                        # Put a 1 (So the fulcrum will be represented as '.' later)
vvb[46]^^                   # Put a 46 two spaces below it

t[X]                        # Store the current X value in T
w[X!0]{<                    # Until reaching the beginning of the input:
    b[T-X]                    # Put T - (the current X value) below each byte
}

^w[B!0]{                    # For each byte of input:
    w[B=32]{b[48]}            # Set spaces to '0'
    >
}

w[X!0]{<                    # For each byte of input:
    t[B-48]                   # Set T to the value of the number (fulcrum becomes '.')
    vb[B*T]^                  # Multiply the value below by T
}

# This has nothing to do with the input, except that it's the right length:
w[B!0]{                     # For every byte of input:
    v                         # Go to the value below it
    t[B]                      # Store it in T
    vb[1]>^                   # Put a flag below it
    w[B!46]{>}                # Go to the next '.' value
    vvb[B+T]                  # Add T to whatever is two spaces below the '.'
                              # This will cause the sum for the right side of
                              # the fulcrum to be 46 too high. This is why 46
                              # was left below the fulcrum earlier: both sums
                              # will be off by the same amount.
    ^w[B=0]{<}                # Go back to the flag
    b[0]^b[0]                 # Erase the flag and the value above it
    ^>
}

vb[0]                       # Erase the stray '.'
vvt[B]<w[B!0]{<}t[B+T]      # Get the sum of the two sums
^>[T]                       # Go right that far
w[X!0]{b[10]<}              # Head back to X=0, leaving 'L'-'B' the whole way
<[T]                        # Go left the same amount as before
w[X!0]{b[16]>}              # Head back to X=0, leaving 'R'-'B' the whole way
vw[B=0]{>}                  # Find the sum from left of the fulcrum
t[B]b[0]                    # Save it to T and erase it from the canvas
w[B=0]{>}                   # Find the other sum
t[T-B]b[0]                  # Subtract it from T and erase it from the canvas
^<[X-T]                     # On the line that was just prepared, go to X=T
t[B]                        # Save the value of that space to T
<[X]>w[B!0]{b[0]>}          # Erase the entire visible part of that line
<[X]^b[T+66]                # Print (the value read from that line)+'B' at (0, 0)

Perl 5, 72 bytes

@_=split//,<>;($i)=grep$_[$_]eq'^',0..@_;$j+=$_*($k++-$i)for@_;say$j<=>0

MATLAB 91, 57, 55 octava, 50 bytes

No esperaba jugar más al golf, ¡pero cambiar a Octave hizo posible ahorrar 5 bytes adicionales! Wow, este tomó tiempo ...

@(x)(s=mod(+x,16))*[1-(i=find(s>9)):nnz(x)-i]'*inf 

Sale -Inf, NaN, Infpara L, B, Rrespectivamente.

¡Banco de pruebas!

Explicación:

Este es definitivamente un código difícil de leer, pero intentaré explicarlo lo mejor que pueda. Cambiaré entre la explicación del bloque de código y el texto.

@(x)                 % Anonymous function that takes a string x as input
           +x        % Convert the string into a numeric array, 
                     % where each character is represented by its ASCII-value
       mod(+x,16)    % Takes this string modulus 16, to make spaces (ASCII 32) equal 0 
    (s=mod(+x,16))   % Assigns this numeric array to s, thanks to Octave's awesome 
                     % inline variable assignment possibility
    (s=mod(+x,16))*  % Multiply s by the vector inside the brackets    

Echemos un vistazo a lo que sucede dentro de los corchetes:

[1-(i=find(s>9)):nnz(x)-i]
      find(s>9)             % The only value in the vector s that's larger than 9, 
                            % after the modulus is ^, (it's now 14)             
   (i=find(s>9))            % Assign the position of `^` to the index variable i

Este es un poco complicado:

[1-(i=find(s>9)):nnz(x)-i]

Los números a cada lado de la escalera deben multiplicarse por la distancia desde el cursor. Si usamos números negativos en el lado izquierdo y números positivos en el lado derecho, simplemente podemos sumar el vector para ver qué lado es el más pesado.

Supongamos que la cadena de entrada es: '321^ 12'. Queremos la siguiente: 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. El vector que hicimos dentro de los corchetes comienza en 1-i, que en este caso es -3, ya que el cursor está en la cuarta posición. Sube nnz(x)-ien incrementos de uno. Podemos usar en nnz(x)lugar de numel(s), porque xes una cadena que no contiene ceros.

Por lo tanto:

[1-(i=find(s>9)):nnz(x)-i]
ans =
  -3  -2  -1   0   1   2   3   4

Ahora, podríamos hacer una multiplicación por elementos s.*[...]y tomar la suma de esto. Pero, dado que tenemos dos vectores, también podemos mutilar spor la transposición de [...]y calcular la suma usando la multiplicación de matrices:

(s=mod(+x,16))*[1-(i=find(s>9)):nnz(x)-i]'

Esto nos da un número negativo, lo que significa que el lado izquierdo es más pesado, un cero, lo que significa que está equilibrado, o un número positivo, lo que significa que el lado derecho es más pesado. En lugar de utilizar el enfoque ingenuo de sign(...), lo multiplicamos por inf, lo que nos dará -Info Infpara izquierda y derecha respectivamente. Obtenemos NaNpara 0*inf, ya que es indefinido.

Esto nos da tres valores distintos para los tres resultados posibles.

𝔼𝕊𝕄𝕚𝕟, 22 caracteres / 38 bytes

МŴ⟬ïĊ⇀$+˜_*(ã-ïÿ⍘^),0⸩

Try it here (Firefox only).

JavaScript, 146 bytes

s=>{a=[0,0];d=s.split`^`;for(j=0;j<2;j++)for(i=0;i<d[j].length;i++)a[j]+=d[j][i]*(j==0?d[j].length-i:i+1);alert(a[0]==a[1]?'B':a[0]>a[1]?'L':'R')}

Bastante masivo

Demostración .

Ruby, 111108 bytes

->s{l,r=s.split'^';v=->x{x.chars.map.with_index{|c,i|c.to_i*(i+1)}.reduce:+};%w(B L R)[v[l.reverse]<=>v[r]]}

Explicación

Resume el valor ponderado de cada número en cada lado. Luego usa el operador de nave espacial ruby ​​para proporcionar un 1,0, -1 de igualdad / desigualdad de los dos lados, que es el índice de una matriz con la salida correcta.

PowerShell, 83 73 bytes

param($b)$i=-$b.indexOf('^');[char[]]$b|%{$x+=$i++*"$_"};[math]::Sign($x)

Gracias a TessellatingHeckler por el golf.

Utiliza esencialmente el mismo algoritmo que el siguiente código anterior, pero aquí iteramos a través de los caracteres en la cadena de entrada uno a la vez en lugar de iterar a través del índice, lo que ahorra un puñado de bytes. Todavía arroja el mismo mensaje de error espectacular cuando llega el algoritmo ^, no afecta a STDOUT.

Anterior

param($a)1..$a.length|%{$x+=+"$($a[$_-1])"*($_-$a.indexof('^')-1)};[math]::Sign($x)

Utiliza el mismo algoritmo impresionante que la excelente respuesta de Dendrobium , y por lo tanto usa la misma salida de -1 / 0 / 1si la entrada es left-heavy / balanced / right-heavy.

Ugh Mucho tiempo debido a una característica peculiar de casting que tiene PowerShell. Lo más pertinente aquí es cómo charmultiplicado por intfunciones. Tomar un índice de matriz de un stringresultado en un charobjeto. PowerShell convierte el chara su valor ASCII correspondiente (en lugar del valor literal) antes de la multiplicación. Entonces, algo así como $a='012'[0];[int]$a*2resultados 96.

Eso significa que tenemos que volver a lanzarlo como una cadena. Sin embargo, simplemente hacer stringtiempos intnos da una stringrepetición que muchas veces. Por ejemplo, $a='0';$a*2resultaría en 00.

Esto significa que necesitamos lanzar la parte de charatrás como a stringantes de volver a emitir como int, luego puede ocurrir la multiplicación, antes de agregarla a nuestro acumulador $x.

Combine eso con la forma larga de iterar a través de una cadena, y la llamada .NET para generar el signo, y obtenemos un fragmento de código bastante largo.

_{Nota: esto arrojará un error espectacular cuando llegue ^a la cadena, indicando que no puede convertirlo en un int. No afecta a STDOUT.}

CJam, 29 bytes

l_'^#\"^ "'0er'0f-_,,@fm.*:+g

Pruébalo en línea

El resultado es -1para pesado a la izquierda, 0para equilibrado, 1para pesado a la derecha.

Esto pareció un poco largo, pero probé un montón de alternativas, y todas terminaron entre 29 y 33 bytes. Un problema es que no pude encontrar una manera de convertir la cadena a valores que automáticamente darían como resultado 0 para los espacios. Así que terminé reemplazando explícitamente los espacios con '0 caracteres, lo que obviamente aumenta la longitud del código.

Alternativas probadas:

• Dividiendo la cadena en '^, invirtiendo la primera y luego calculando el valor ponderado para ambos.
• Usar el eeoperador para agregar el índice a la lista de valores.
• En lugar de restar la posición de intercalación de cada índice, calcule el producto escalar sin la resta y luego reste la posición de intercalación multiplicada por la longitud de la cadena del resultado.

Explicación:

l         Get input.
_'^#      Copy and find caret position.
\         Swap input back to top.
"^ "'0er  Replace caret and spaces with '0.
'0f-      Subtract '0 from all characters, to get integer values.
_,,       Build index array with same length.
@         Rotate caret position to top.
fm        Subtract it from all indices.
.*        Calculate element wise product of two vectors.
:+        Add up the element products to get dot product.
g         Signum.

Python 3, 196114 bytes

r=0
I=list(input())
p=I.index("^")
i=0
for E in I:
 if E.isdigit():r+=int(E)*(p-i)
 i+=1
print('BLR'[(r>0)-(r<0)])

Código regular:

total = 0

inp=list(input())
ful_index=inp.index("^")

i=0
for num in inp:
    if num.isdigit(): total += int(num) * (ful_index - i)
    i+=1

print('BLR'[(total>0)-(total<0)])

Explicación:

1. Genera una lista de números + el punto de apoyo de stdin.
2. Para cada número, suma la distancia del punto de apoyo multiplicado por el número de la variable al total (los números de la izquierda serán negativos y los números de la derecha serán positivos).
3. Imprime la letra correcta según el resultado (B si es igual, L si es más que cero y R si es menos que cero).

¡Muchas gracias a @ThomasKwa por recortar 82 bytes (más del 40%) de descuento!

C, 140 139 138 134 100 bytes

Regreso:

• 1 = IZQUIERDA
• 2 = EQUILIBRADO
• 0 = DERECHA

k;main(int x,char**a){char*n=a[1],*g=n;for(;*n^94;++n);for(;*g;++g)k+=(*g&15)*(n-g);return!k?2:k>0;}

Correr:

./see-saw "11   ^9"
echo $?
2

Como tenemos ASCII:

SPACE = 0x20
    0 = 0x30 ... 9 = 0x39

Obtenemos:

0x20 & 0x0f = 0
0x30 & 0x0f = 0
0x31 & 0x0f = 1
0x32 & 0x0f = 2
... etc.

Luego suma por factor distancia a ^.

SpecBAS - 140 bytes

1 INPUT b$: LET t=0,p=POS("^",b$),l$="RBL"
2 FOR i=1 TO LEN b$
3 IF b$(i) IN ["1" TO "9"] THEN INC t,(p-i)*VAL b$(i)
4 NEXT i
5 TEXT l$(2+SGN t)

tes un total acumulado, los valores son negativos cuando la posición del personaje es mayor que la posición en quilates. Al final ve si el total es negativo, cero o positivo e imprime el carácter correspondiente de R, B o L.

Podría reducir algunos bytes simplemente generando -1, 0 o 1 como algunas de las otras respuestas.

Java, 83 bytes

l->{int s=0,l=0;for(char c:l)if(l<1)s-=c-48;else s+=c-48;return s<0?-1:(s>0?1:0));}