Atto di bilanciamento

Panoramica

Dato un input di 3 numeri interi positivi a una cifra che rappresentano un insieme di pesi, emette una rappresentazione ASCII di un'altalena con i pesi posizionati su di esso in modo che sia in equilibrio attorno a un perno centrale, tenendo conto degli effetti della leva.

Ogni numero ha un peso pari al suo valore. La coppia di ciascun numero è il peso moltiplicato per la distanza dal centro in caratteri. Perché il movimento alternato sia in equilibrio, la coppia somma dei pesi a sinistra del movimento alternato deve essere uguale a quella di quelli a destra, in questo modo .

Ingresso

3 numeri interi compresi tra 1 e 9. È possibile inserire numeri interi, tuttavia è conveniente, ad esempio una tupla, 3 valori separati da virgole, ecc. Tuttavia, il programma deve essere in grado di gestire l'inserimento di numeri in qualsiasi ordine (ovvero non presupporre che i valori vengano ordinati). È possibile inserire numeri duplicati (ad esempio 2,3,2).

Gli input consentiranno sempre matematicamente un output valido, altrimenti l'input non è valido.

Produzione

L'output dovrebbe essere una rappresentazione ASCII a 2 righe dell'altalena con i pesi posizionati su di essa. Sulla prima riga ci sono le cifre, distanziate per bilanciarle sull'altalena.

I numeri non possono essere posizionati al centro della scala, dove la distanza e quindi la coppia sarebbero zero. Le distanze valide dalla gamma centrale vanno da 1 a 10 caratteri compresi a sinistra o a destra del perno.

Negli spazi non occupati dai numeri sono presenti 18 caratteri di sottolineatura (un trattino basso centrale e 10 su ciascun lato, meno le 3 posizioni occupate dai numeri). Sull'ultima riga è presente un carattere a singolo cursore allineato al centro della scala, che rappresenta il perno.

Esempi

Ingresso:

4,7,2

Produzione:

________7___42_______
          ^

7 * 2 = 4 * 2 + 2 * 3

I numeri possono essere emessi su entrambi i lati, ad esempio anche questo sarebbe valido:

_______24___7________
          ^

2 * 3 + 4 * 2 = 7 * 2

I numeri possono essere posizionati in qualsiasi punto della scala purché si bilancino, ad esempio:

Ingresso:

3,1,5

Produzione:

_____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

eccetera

Il tuo programma deve emettere solo uno degli output validi. Non è necessario generare un errore se l'input non è valido.

Gli appunti

• Questo è code-golf, quindi vince il programma più breve in byte
• Il programma può essere autonomo o una funzione che accetta i numeri come input e restituisce una stringa.
• Il trascinamento di newline e white-space sull'ultima riga è facoltativo
• Se non sai cos'è un'altalena , è anche noto come barcollare o barcollare.

CJam, 40 39 38 byte

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

Provalo online.

Come funziona

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 byte

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

Provalo qui.

Spiegazione

Innanzitutto, un'osservazione: non abbiamo mai bisogno di mettere due cifre alle estremità dell'altalena. Ogni volta che si tratta di una soluzione valida, esiste almeno un'altra soluzione valida (in base al punto di riferimento della pasta nel commento sulla sfida).

'_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 byte

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);}}

Il mio primo tentativo di giocare a golf.

Puoi chiamarlo con f(a,b,c). Provalo qui

EDIT: metodo di controllo izlin usato(a*i+b*j+c*k)==0

EDIT: Grazie, J Atkin per i suggerimenti sul golf.

Pyth, 67 58 53 49 byte

Questo sembra un po 'enorme per Pyth, ma non ho abbastanza familiarità con il linguaggio per essere in grado di ridurlo molto. Sotto 50 byte, sono finalmente contento di questo!

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

L'input è previsto come una matrice di numeri interi, ad esempio [1,2,3]. Provalo qui.

spiegazione:

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

E infine, alcuni esempi di input e output:

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

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

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

C - 237 228 byte

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;}}}}}

Puoi chiamarlo con f(a,b,c).

Provalo qui .

Esempi di output:

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

f(3,1,5)
3____1___________5___
          ^       

Python 2.7 235 226 219 byte

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+"^"

Provandolo con alcuni esempi di base, i (1,1,1),(1,2,1),(3,1,5),(4,7,2)risultati in:

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

Uscite per tutti i possibili ingressi incollati qui

PHP, 278 byte

Una soluzione a forza bruta che utilizza un mucchio di loop nidificati e un paio di test.

$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);}

Come sempre, mettilo in un file (chiamiamolo seesaw.php), unisci le linee (dividi qui per leggibilità), metti il ​​marcatore PHP ( <?php) all'inizio del file (tecnicamente, non fa parte del programma) e tu ' sei bravo ad andare.

Un esempio di esecuzione:

$ 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 e visualizza tutte le soluzioni (senza riflessi), ma non rimuove i duplicati (quando i valori di input contengono duplicati).

Julia, 154 byte

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 + spiegazione:

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) byte

Chiama con a, b, c come argomenti sulla riga di 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);} 

Se è possibile omettere main, il conteggio dei byte scende a 214 per una funzione.

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);}

Entrambi usano la stessa strategia di posizionare il primo peso a sinistra, quindi scansionare le possibili posizioni del secondo peso e calcolare il terzo peso. Ciò consente la rimozione di un anello interno.