Ley de equilibrio

Visión general

Dada una entrada de 3 enteros positivos de un solo dígito que representan un conjunto de pesos, genera una representación ASCII de un balancín con los pesos colocados sobre él para que esté en equilibrio alrededor de un pivote central, teniendo en cuenta los efectos de palanca.

Cada número tiene un peso igual a su valor. El torque de cada número es el peso multiplicado por la distancia desde el centro en caracteres. Para el sube y baja para estar en equilibrio, el par suma de los pesos de la parte izquierda el sube y baja debe ser igual a la de los de la derecha, como este .

Entrada

3 enteros en el rango de 1-9. Puede ingresar los enteros, sin embargo, es conveniente, por ejemplo, una tupla, 3 valores separados por comas, etc. Sin embargo, su programa debe ser capaz de manejar la entrada de números en cualquier orden (es decir, sin suponer que los valores se ordenarán). Se pueden ingresar números duplicados (por ejemplo, 2,3,2).

Las entradas siempre permitirán matemáticamente una salida válida, de lo contrario la entrada no es válida.

Salida

La salida debe ser una representación ASCII de 2 líneas del balancín con los pesos colocados en él. En la primera línea están los dígitos, espaciados para equilibrarlos en el balancín.

Los números no se pueden colocar en el centro de la escala, donde la distancia y, por lo tanto, el par, serían cero. Las distancias válidas desde el centro varían de 1 a 10 caracteres, incluidos a la izquierda o derecha del pivote.

En los espacios desocupados por los números hay 18 caracteres de subrayado (un subrayado central y 10 en cada lado, menos las 3 posiciones ocupadas por los números). En la última línea hay un solo carácter de intercalación alineado con el centro de la escala, que representa el pivote.

Ejemplos

Entrada:

4,7,2

Salida:

________7___42_______
          ^

7 * 2 = 4 * 2 + 2 * 3

Los números se pueden generar en cualquier lado, por ejemplo, esto también sería válido:

_______24___7________
          ^

2 * 3 + 4 * 2 = 7 * 2

Los números se pueden colocar en cualquier lugar de la escala siempre que se equilibren, por ejemplo:

Entrada:

3,1,5

Salida:

_____5________1__3___
          ^

5 * 5 = 1 * 4 + 3 * 7

o

____5________1_____3_
          ^

5 * 6 = 1 * 3 + 3 * 9

o

____5___________1_3__
          ^

5 * 6 = 1 * 6 + 3 * 8

etc.

Su programa solo tiene que generar una de las salidas válidas. No tiene que generar un error si la entrada no es válida.

Notas

• Este es el código de golf, por lo que gana el programa más corto en bytes
• El programa puede ser independiente o una función que acepta los números como entrada y devuelve una cadena.
• La nueva línea final y el espacio en blanco en la última línea es opcional
• Si no sabe lo que es un balancín , también se lo conoce como un balancín o un teeboard.

CJam, 40 39 38 bytes

q~21Ue]e!{21,Af-Aest.*:+!}=0'_erNAS*'^

Pruébalo en línea.

Cómo funciona

q~                                     e# Read and evaluate the input.
  21Ue]                                e# Append zeroes to achieve a length of 21.
       e!                              e# Push all unique permutations.
         {               }=            e# Find the first permutation such that:
          21,                          e#  Push [0 ... 20].
             Af-                       e#  Subtract 10 from each.
                Aest                   e#  Replace the element at index 10 with the
                                       e#  current time (ms since epoch) to push
                                       e#  [-10 ... -1 <big number> 1 ... 10].
                    .*                 e#  Multiply each number of the permutation
                                       e#  by the corresponding distance.
                      :+               e#  Add the products.
                                       e#  The timestamp makes sure that this sum
                                       e#  is non-zero for a non-zero element in
                                       e#  the middle of the permutation.    
                        !              e#  Push the logical NOT of the sum.
                           0'_er       e# Replace zeroes with underscores.
                                NAS*'^ e# Push a linefeed, ten spaces and a caret.

CJam, 46 44 bytes

'_21*q~K,Am3m*{___&=*Afm1$.*:+!}=.{\t}NAS*'^

Pruébalo aquí.

Explicación

Primero, una observación: nunca necesitamos poner dos dígitos en los extremos del balancín. Siempre que sea una solución válida, hay al menos otra solución válida (de acuerdo con el pastebin en el comentario sobre el desafío).

'_21*   e# Push a string of 21 underscores.
q~      e# Read and eval input.
K,      e# Push the array [0 1 .. 19 20]
Am      e# Remove the 10. This is now an array of all valid positions on the seesaw.
3m*     e# Get all 3-tuples of valid positions.
{       e# Select the first tuple for which the following block yields a truthy result.
  ___   e# Make three copies of the tuple.
  &=    e# Intersect the last two copies and check for equality with the first one.
        e# This yields 1 if all positions are distinct, and 0 otherwise.
  *     e# Repeat the original tuple that many times. That is, if the positions are
        e# distinct, leave the tuple unchanged. Otherwise, replace it with an empty array.
  Afm   e# Subtract 10 from each position to get its weight.
  1$    e# Copy the input digits.
  .*    e# Take the pairwise product of weights and digits. If the weights are empty
        e# (because they were not unique), this will just yield a list of the digits.
  :+    e# Sum the weighted digits. If the weights were not unique, this will just sum
        e# the digits and will always be positive.
  !     e# Logical NOT - give 1 if the sum was 0, or 0 otherwise.
}=
.{\t}   e# For each pair of digit and position, replace that position in the underscore
        e# string with the corresponding digit.
N       e# Push a newline.
AS*     e# Push ten spaces.
'^      e# Push a caret.

Java, 519 414 321 bytes

static int f(int a,int b,int c){int i,j,k;for(i=-10;i<=10;i++)for(j=i+1;j<=10;j++)for(k=j+1;k<=10;k++){if(a*i+b*j+c*k==0&&i!=0&&j!=0&&k!=0){for(int q=0;q<21;q++){if(q==10+i)p(a);else if(q==10+j)p(b);else if(q==10+k)p(c);else p('_');}p("\n          ^\n");return 0;}}return 0;}static void p(Object a){System.out.print(a);}}

Mi primer intento de jugar al golf.

Puedes llamarlo con f(a,b,c). Pruébalo aquí

EDITAR: método de verificación izlin usado(a*i+b*j+c*k)==0

EDITAR: Gracias, J Atkin por las sugerencias de golf.

Pyth 67 58 53 49 bytes

Esto se siente un poco enorme para Pyth, pero no estoy lo suficientemente familiarizado con el lenguaje para poder ser mucho más pequeño. Sub 50 bytes, ¡finalmente estoy feliz con esto!

V.c-KrT-011Z3FY.pQIqs*VNYZjkm?}dN@YxNd\_K+*dT\^.q

La entrada se espera como una matriz de enteros, por ejemplo [1,2,3]. Pruébalo aquí

Explicación:

V.c-KrT-011Z3FY.pQIqs*VNYZjkm?}dN@YxNd\_K+*dT\^.q
                                                       Implicit: Q = eval(input())
     rT-011                                            Create range from 10 to -10
    K                                                  Store in K
   -       Z                                           Drop 0 from the above
V.c         3                                          For N in (combinations of the above of size 3)
             FY.pQ                                     For Y in (permutations of input)
                     *VNY                              Multiply each element in N by the corresponding element in Y
                    s                                  Take the sum
                  Iq     Z                             If it's equal to zero:
                            m           K              For d in K (K = [10, ..., -10])
                             ?}dN                      Is d in N?
                                 @YxNd                 If so, get corresponding value from Y
                                      \_               Otherwise, get '_'
                          jk                           Join the resulting array into a string (implicit print)
                                         +*dT\^        Join 10 spaces and '^', implicit print
                                               .q      Break all loops and exit

Y finalmente, algunos ejemplos de entradas y salidas:

[1,1,1] ->
1__________1_______1_
          ^

[2,9,5] ->
2____5_________9_____
          ^

[9,8,5] ->
5____8______________9
          ^

C - 237 228 bytes

i,j,k;f(a,b,c){char o[]="_____________________\n          ^";for(i=-10;i<9;i+=i+1?1:2){for(j=i+1;j<11;j+=j+1?1:2){for(k=j+1;k<11;k+=k+1?1:2){if((a*i+b*j+c*k)==0){o[i+10]=a+48;o[j+10]=b+48;o[k+10]=c+48;printf("%s",o);return;}}}}}

Puedes llamarlo con f(a,b,c).

Probarlo aquí .

Salidas de ejemplo:

f(4,7,2):
4_____________7_2____
          ^         

f(3,1,5)
3____1___________5___
          ^       

Python 2.7 235 226 219 bytes

def s(n,p=__import__("itertools").permutations):
 l=["_"]*21
 for p,q in[[(a,x+10),(b,y+10),(c,10-z)]for a,b,c in p(n,3)for x,y,z in p(range(1,11),3)if x!=y and a*x+b*y==c*z][0]:l[q]=`p`
 return`l`[2::5]+"\n"+" "*10+"^"

Probándolo con algunos ejemplos básicos (1,1,1),(1,2,1),(3,1,5),(4,7,2): resultados en:

(1, 1, 1)
_______1___11________
          ^
(1, 2, 1)
_____1_____12________
          ^
(3, 1, 5)
________5__3_____1___
          ^
(4, 7, 2)
_2_________47________
          ^

Salidas para todas las entradas posibles pegadas aquí

PHP, 278 bytes

Una solución de fuerza bruta que utiliza un montón de bucles anidados y un par de pruebas.

$p=explode(',',$argv[$i=1]);for(;$i<=10;$i++)for($j=1;$j<=10;$j++)
for($k=1;$k<=10;$k++)if($j-$k)for($l=0;$l<3;$l++){$q=array_shift($p);
if($i*$q==$j*$p[0]+$k*$p[1]){$o=str_repeat('_',21);$o[10-$i]=$q;$o[10+$j]=$p[0];
$o[10+$k]=$p[1];echo($o."\n          ^\n");}array_push($p,$q);}

Como siempre, póngalo en un archivo (nombremoslo seesaw.php), una las líneas (dividido aquí para facilitar la lectura), coloque el marcador PHP ( <?php) al comienzo del archivo (técnicamente, no es parte del programa) y usted ' re bueno para ir.

Un ejemplo de ejecución:

$ php seesaw.php 9,2,1
_________9_2_____1___
          ^
_________9__2__1_____
          ^
_________9_1__2______
          ^
________9_____2_____1
          ^
________9______2__1__
          ^
________9_____1__2___
          ^
________9___1_____2__
          ^
_______9_________1__2
          ^
____2______9_1_______
          ^
___2_______9___1_____
          ^
__2________9_____1___
          ^
_2_________9_______1_
          ^

Genera y muestra todas las soluciones (sin reflejos), pero no elimina los duplicados (cuando los valores de entrada contienen duplicados).

Julia, 154 bytes

f(a,b,c)=(x=replace(join(first(filter(p->p⋅[-10:-1,1:10]==0,permutations([a,b,c,zeros(Int,17)])))),"0","_");print(x[1:10]*"_"*x[11:20]*"\n"*" "^10*"^"))

Ungolfed + explicación:

function f(a,b,c)
    # Create a 20-element array of the input with 17 zeros
    z = [a,b,c,zeros(Int,17)]

    # Get the set of all permutations of z such that the dot product
    # of the permutation with the distances is 0
    d = filter(p -> p ⋅ [-10:-1,1:10] == 0, permutations(z))

    # Join the first element of d into a string and replace all of
    # the zeros with underscores
    x = replace(join(first(d)), "0", "_")

    # Print the output
    print(x[1:10] * "_" * x[11:20] * "\n" * " "^10 * "^")
end

C, 252 (214) bytes

Llame con a, b, c como argumentos en la línea de comando.

e=48;main(_,v,x,y,z,a,b,c)char**v;{char s[]="_____________________\n          ^";x=*v[1]-e;y=*v[2]-e;z=*v[3]-e;for(a=-1;a+11;--a)for(b=-10;b-11;++b)_=a*x+b*y,!b|b==a|_%z?0:(c=-_/z,c&c<11&c>-11?s[a+10]=x+e,s[b+10]=y+e,s[c+10]=z+e,puts(s),exit(0):0);} 

Si se puede omitir main, el recuento de bytes cae a 214 para una función.

a,b,c;f(x,y,z){char s[]="_____________________\n          ^";for(a=-1;a+11;--a)for(b=-10;b-11;++b)!b|b==a|(a*x+b*y)%z?0:(c=-(a*x+b*y)/z,c&&c<11&&c>-11?s[a+10]=x+48,s[b+10]=y+48,s[c+10]=z+48,puts(s),b=10,a=-b:0);}

Ambos usan la misma estrategia de colocar el primer peso a la izquierda, luego escanear a lo largo de las posibles posiciones del segundo peso y calcular el tercer peso. Esto permite la eliminación de un bucle interno.