Loi sur l'équilibre

Vue d'ensemble

Étant donné une entrée de 3 entiers positifs à un chiffre représentant un ensemble de poids, sortez une représentation ASCII d'une balançoire avec les poids placés dessus afin qu'elle soit en équilibre autour d'un pivot central, en tenant compte des effets de levier.

Chaque nombre a un poids égal à sa valeur. Le couple de chaque nombre est le poids multiplié par la distance au centre en caractères. Pour que la bascule soit en équilibre, le couple total des poids à gauche de la bascule doit être égal à celui de ceux de droite, comme ceci .

Contribution

3 entiers compris entre 1 et 9. Vous pouvez saisir les nombres entiers, mais cela est pratique, par exemple un tuple, 3 valeurs séparées par des virgules, etc. Cependant, votre programme doit être capable de gérer les nombres entrés dans n'importe quel ordre (c'est-à-dire sans supposer que les valeurs seront triées). Des numéros en double peuvent être saisis (par exemple 2,3,2).

Les entrées permettront toujours mathématiquement une sortie valide, sinon l'entrée n'est pas valide.

Sortie

La sortie doit être une représentation ASCII à 2 lignes de la bascule avec les poids placés dessus. Sur la première ligne, les chiffres sont espacés pour les équilibrer sur la bascule.

Les nombres ne peuvent pas être placés au centre même de l'échelle, où la distance et donc le couple seraient nuls. Les distances valides du centre vont de 1 à 10 caractères inclus à gauche ou à droite du pivot.

Dans les espaces non occupés par les chiffres, il y a 18 caractères de soulignement (un trait de soulignement central et 10 de chaque côté, moins les 3 positions occupées par les chiffres). Sur la dernière ligne est un caractère caret unique aligné avec le centre de l'échelle, représentant le pivot.

Exemples

Contribution:

4,7,2

Sortie:

________7___42_______
          ^

7 * 2 = 4 * 2 + 2 * 3

Les numéros peuvent être sortis de chaque côté, par exemple, cela serait également valide:

_______24___7________
          ^

2 * 3 + 4 * 2 = 7 * 2

Les nombres peuvent être placés n'importe où sur l'échelle tant qu'ils s'équilibrent, par exemple:

Contribution:

3,1,5

Sortie:

_____5________1__3___
          ^

5 * 5 = 1 * 4 + 3 * 7

ou

____5________1_____3_
          ^

5 * 6 = 1 * 3 + 3 * 9

ou

____5___________1_3__
          ^

5 * 6 = 1 * 6 + 3 * 8

etc

Votre programme n'a qu'à sortir l'une des sorties valides. Il n'a pas à générer d'erreur si l'entrée n'est pas valide.

Remarques

• Ceci est du code-golf donc le programme le plus court en octets gagne
• Le programme peut être autonome ou une fonction qui accepte les nombres en entrée et renvoie une chaîne.
• La nouvelle ligne et les espaces blancs à la dernière ligne sont facultatifs
• Si vous ne savez pas ce qu'est une balançoire , elle est également connue sous le nom de bascule ou de bascule.

CJam, 40 39 38 octets

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

Essayez-le en ligne.

Comment ça marche

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 octets

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

Testez-le ici.

Explication

Tout d'abord, une observation: nous n'avons jamais besoin de mettre deux chiffres aux extrémités de la bascule. Chaque fois que c'est une solution valide, il y a au moins une autre solution valide (selon le pastebin dans le commentaire sur le défi).

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

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

Ma première tentative de golf.

Vous pouvez l'appeler avec f(a,b,c). Essayez-le ici

EDIT: méthode de vérification izlin utilisée(a*i+b*j+c*k)==0

EDIT: Merci, J Atkin pour les suggestions de golf.

Pyth, 67 58 53 49 octets

Cela semble un peu énorme pour Pyth, mais je ne suis pas assez familier avec le langage pour pouvoir le réduire beaucoup plus. Sous 50 octets, j'en suis enfin satisfait!

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

L'entrée est attendue comme un tableau d'entiers, par exemple [1,2,3]. Essayez-le ici.

Explication:

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

Et enfin, quelques exemples d'entrées et sorties:

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

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

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

C - 237 228 octets

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

Vous pouvez l'appeler avec f(a,b,c).

Essayez-le ici .

Exemple de sorties:

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

f(3,1,5)
3____1___________5___
          ^       

Python 2.7 235 226 219 octets

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

Le tester avec quelques exemples de base - (1,1,1),(1,2,1),(3,1,5),(4,7,2)résultats dans:

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

Sorties pour toutes les entrées possibles collées ici

PHP, 278 octets

Une solution de force brute qui utilise un tas de boucles imbriquées et quelques tests.

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

Comme toujours, mettez-le dans un fichier (nommons-le seesaw.php), joignez les lignes (fractionnées ici pour plus de lisibilité), mettez le marqueur PHP (<?php ) au début du fichier (techniquement, il ne fait pas partie du programme) et vous ' re bon d'aller.

Un exemple d'exécution:

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

Il génère et affiche toutes les solutions (sans réflexions), mais il ne supprime pas les doublons (lorsque les valeurs d'entrée contiennent des doublons).

Julia, 154 octets

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

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

Appelez avec a, b, c comme arguments sur la ligne de commande.

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 main peut être omis, le nombre d'octets tombe à 214 pour une fonction.

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

Les deux utilisent la même stratégie en plaçant le premier poids sur la gauche, puis en balayant le long des secondes positions de poids possibles et en calculant le troisième poids. Cela permet la suppression d'une boucle intérieure.