Balanceakt

Überblick

Bei einer Eingabe von 3 einstelligen positiven Ganzzahlen, die einen Satz von Gewichten darstellen, geben Sie eine ASCII-Darstellung einer Wippe mit den darauf platzierten Gewichten aus, sodass sie um einen zentralen Drehpunkt herum im Gleichgewicht ist, wobei Hebeleffekte berücksichtigt werden.

Jede Zahl hat ein Gewicht, das ihrem Wert entspricht. Das Drehmoment jeder Zahl ist das Gewicht multipliziert mit dem Abstand von der Mitte in Zeichen. Für die Wippe im Gleichgewicht zu sein, wie die Summe Drehmoment der Gewichte auf der linken Seite der Wippe müssen die derjenigen , auf der rechten Seite gleich, dies .

Eingang

3 ganze Zahlen im Bereich von 1-9. Sie können die Ganzzahlen bequem eingeben, z. B. ein Tupel, 3 durch Kommas getrennte Werte usw. Ihr Programm muss jedoch in der Lage sein, die eingegebenen Zahlen in beliebiger Reihenfolge zu verarbeiten (dh es muss nicht davon ausgegangen werden, dass die Werte sortiert werden). Es können doppelte Zahlen eingegeben werden (zB 2,3,2).

Die Eingaben lassen mathematisch immer eine gültige Ausgabe zu, andernfalls ist die Eingabe ungültig.

Ausgabe

Die Ausgabe sollte eine 2-zeilige ASCII-Darstellung der Wippe mit den darauf platzierten Gewichten sein. In der ersten Zeile stehen die Ziffern, um sie auf der Wippe auszugleichen.

Zahlen dürfen nicht genau in der Mitte der Skala platziert werden, wo der Abstand und damit das Drehmoment Null wäre. Gültige Abstände vom Mittelpunkt liegen zwischen 1 und 10 Zeichen links oder rechts vom Drehpunkt.

In den von den Zahlen nicht belegten Feldern stehen 18 Unterstriche (ein mittlerer Unterstrich und 10 auf jeder Seite abzüglich der 3 von den Zahlen belegten Stellen). In der letzten Zeile befindet sich ein einzelnes Caret-Zeichen, das an der Mitte der Skala ausgerichtet ist und den Drehpunkt darstellt.

Beispiele

Eingang:

4,7,2

Ausgabe:

________7___42_______
          ^

7 * 2 = 4 * 2 + 2 * 3

Zahlen können auf beiden Seiten ausgegeben werden, zum Beispiel wäre dies auch gültig:

_______24___7________
          ^

2 * 3 + 4 * 2 = 7 * 2

Zahlen können an einer beliebigen Stelle auf der Skala platziert werden, solange sie ausgeglichen sind, z. B .:

Eingang:

3,1,5

Ausgabe:

_____5________1__3___
          ^

5 * 5 = 1 * 4 + 3 * 7

oder

____5________1_____3_
          ^

5 * 6 = 1 * 3 + 3 * 9

oder

____5___________1_3__
          ^

5 * 6 = 1 * 6 + 3 * 8

etc

Ihr Programm muss nur eine der gültigen Ausgaben ausgeben. Es muss kein Fehler ausgegeben werden, wenn die Eingabe ungültig ist.

Anmerkungen

• Das ist Code-Golf, also gewinnt das kürzeste Programm in Bytes
• Das Programm kann ein eigenständiges Programm oder eine Funktion sein, die die Zahlen als Eingabe akzeptiert und eine Zeichenfolge zurückgibt.
• Das Nachziehen von Zeilenumbrüchen und Leerzeichen in der letzten Zeile ist optional
• Wenn Sie nicht wissen, was eine Wippe ist, wird sie auch als Wippe oder Wippe bezeichnet.

CJam, 40 39 38 Bytes

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

Probieren Sie es online aus.

Wie es funktioniert

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*'^

Teste es hier.

Erläuterung

Erstens eine Bemerkung: Wir müssen niemals zwei Ziffern an den Enden der Wippe anbringen. Immer wenn es sich um eine gültige Lösung handelt, gibt es mindestens eine andere gültige Lösung (gemäß dem Pastebin im Kommentar zur Herausforderung).

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

Mein erster Golfversuch.

Sie können es mit aufrufen f(a,b,c). Versuch es hier aus

BEARBEITEN: Verwendete Izlin-Prüfmethode(a*i+b*j+c*k)==0

EDIT: Danke, J Atkin für die Golfvorschläge.

Pyth, 67 58 53 49 Bytes

Das fühlt sich für Pyth ein wenig gewaltig an, aber ich kenne mich mit der Sprache noch nicht so gut aus, dass ich sie noch viel kleiner machen kann. Sub 50 Bytes, damit bin ich endlich zufrieden!

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

Die Eingabe wird beispielsweise als Array von Ganzzahlen erwartet [1,2,3]. Probieren Sie es hier aus.

Erklärung:

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

Und zum Schluss einige Beispiele für Ein- und Ausgänge:

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

Sie können es mit aufrufen f(a,b,c).

Probieren Sie es hier aus .

Beispielausgaben:

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

Testen Sie es mit einigen grundlegenden Beispielen - (1,1,1),(1,2,1),(3,1,5),(4,7,2)Ergebnisse in:

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

Ausgänge für alle möglichen Eingaben eingefügt hier

PHP, 278 Bytes

Eine Brute-Force-Lösung, die eine Reihe verschachtelter Schleifen und einige Tests verwendet.

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

Setzen Sie es wie immer in eine Datei (nennen wir es seesaw.php), verbinden Sie die Zeilen (hier zwecks Lesbarkeit aufgeteilt), setzen Sie den PHP-Marker (<?php ) an den Anfang der Datei (technisch gesehen ist er nicht Teil des Programms) und Sie Es ist gut zu gehen.

Ein Beispiel für die Ausführung:

$ 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_
          ^

Es werden alle Lösungen (ohne Reflexionen) generiert und angezeigt, die Duplikate werden jedoch nicht entfernt (wenn die Eingabewerte Duplikate enthalten).

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 + Erklärung:

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

Rufen Sie mit a, b, c als Argumente in der Befehlszeile auf.

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

Wenn main weggelassen werden kann, sinkt die Anzahl der Bytes für eine Funktion auf 214.

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

Beide verwenden dieselbe Strategie: Platzieren Sie das erste Gewicht links, scannen Sie dann die möglichen zweiten Gewichtspositionen ab und berechnen Sie das dritte Gewicht. Dies ermöglicht das Entfernen einer inneren Schleife.