Pourquoi un simulateur?

De nos jours, les enfants n’ont ni le temps ni l’ambition voulus pour empiler des boîtes sur la balançoire ou pour jouer avec des objets physiques équilibrés. Cela laisse beaucoup de place sur le marché des logiciels pour un simulateur à levier qui, selon mes modèles, se vendra comme un fou!

Programmation d'aide recherchée

J'ai déposé le brevet pour un tel jeu (en attente), mais j'ai besoin d'un programmeur expert pour écrire la logique du jeu pour moi. À ma connaissance, il est de pratique courante de rémunérer les programmeurs en fonction de la taille en octets du programme final. En tant que tel, je vais attribuer ce contrat lucratif au plus bas soumissionnaire.

spécification

Un levier est une série de cases ou d'espaces vides équilibrés par un point d'appui. Chaque boîte a un poids particulier de un à neuf et les espaces n’ont pas de poids. Comme vous le savez, le poids d'une boîte sur le levier est directement proportionnel à sa distance par rapport au point d'appui. Une boîte de poids 4qui se trouve sur le troisième espace du point d'appui apportera 12des unités de force efficaces à ce côté du levier.

J'ai besoin d'un programme qui, avec un levier d'entrée, émettra un signal indiquant si le levier sera incliné vers la gauche, vers la droite ou s'il sera parfaitement équilibré.

Directives I / O

• Vous allez écrire pour moi un programme.
• L'entrée contiendra une ligne de texte.
• L'entrée viendra de stdinou sous forme d'une chaîne de ligne de commande.
• Les cases seront représentées par les caractères ' 1' à travers ' 9'. Ces caractères représentent leurs poids respectifs. Un espace vide sera représenté par un espace ' '. Le point d'appui sera représenté par un caret ' ^'.

Un exemple de levier d’entrée pourrait ressembler à: 8 2^ 941

Ce levier est parfaitement équilibré: (4*8) + 0 + 0 + (1*2) == 0 + (2*9) + (3*4) + (4*1) == 34

• Il n'y aura pas d'espaces de début ni de fin. Il n'y aura pas de nouvelle ligne de fuite.
• Nul besoin de traiter une entrée malformée, l’entrée aura toujours exactement un pivot, et uniquement des nombres et des espaces.
• La sortie indiquera si le levier est lourd à gauche, à droite ou équilibré.
• Votre programme doit avoir exactement 3 sorties possibles pouvant résulter d’une entrée bien formée. Vous pouvez choisir ce que ce sont.
• La sortie doit être soit imprimer stdoutsoit le code de retour du programme.

Cas de test

Ici , je l' utilise L, R, Bsignifie gauche lourd, droit lourd, équilibré:

1. Entrée: 11 ^9sortie:B

2. Entrée: 321^ 12sortie:L

3. Entrée: 9^ 1sortie:R

(Si quelqu'un a des cas de test "plus difficiles", n'hésitez pas à les éditer).

Bibliographie

Pas nécessairement inspiré par, mais lié à l' équilibre d'un ensemble de poids sur une bascule

Python 2, 69 octets

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

Le module ord(c)%16extrait la valeur d'un caractère numérique tout en obtenant 0 pour l'espace. Pour chaque caractère, sa contribution au couple est calculée comme son poids multiplié par la distance signée du pivot i-s.find('^'), et ces derniers sont additionnés et comparés à 0, produisant l'un des -1,0,1. Le caractère ^est calculé pour avoir un poids de 14, mais cela n'a pas d'importance, car c'est sur le pivot.

Un port Pyth de 18 octets par Maltysen:

._s.e*-kxz\^%Cb16z

Pour le code Python, si un programme complet est requis, voici 79 octets. L'idée est de démarrer l'index idécalé de s.find('^')et de le décompter.

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 octets

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

• -1 si laissé est plus lourd
• 0 si équilibré
• 1 si le droit est plus lourd

Ungolfed:

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)

Tests exécutés (attribution d'une fonction anonyme à f):

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

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

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

• -11 octets: modification de la sortie de R B Là-1 0 1
• -3 octets: remplacé e.split``par [...e](merci @ V)
• -33 octets: modification de l'algorithme pour utiliser des poids négatifs plutôt que de scinder au pivot
• -9 octets: vérification de pivot supprimée (apparemment, est ~~'^'évaluée à 0...)
• -2 octets: fonction rendue anonyme (merci @ cᴏɴᴏʀ-obʀɪᴇɴ)

Japt , 22 octets

Japt est une version abrégée de Ja vaScri pt . Interprète

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

Retourne -1pour L, 0pour Bet 1pour R.

Comment ça fonctionne

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 octets

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

Après avoir relu les règles, j’ai changé ceci en sortie -1 0 1au lieu de L B R, en économisant neuf octets.

Essayez ici .

Pyth, 20 octets

._s*V-Rxz\^Uzm.xsd0z

Suite de tests

-1pour biaisé à gauche, 0pour équilibré, 1pour partiellement à droite.

Comment ça fonctionne:

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

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

La sortie est 0équilibrée, -1lourde à gauche et lourde 1à droite.

Exemple d'utilisation: f "321^ 12"->-1

Comment ça marche: trouvez la partie avant le ^. Multipliez la chaîne d'entrée et la liste des poids qui commence par - length-of-first-part. Le ^a un poids de 0 et ne pas ajouter à la somme. J'utilise l'astuce du mod 16 de @ xnor pour convertir les chiffres / espaces en valeurs entières. Si la somme est négative (positive), le levier est lourd à gauche (à droite) et équilibré si la somme est à 0.

TeaScript , 23 octets 25

J'ai essayé d'écrire une réponse Pyth mais ça s'est passé horriblement: \

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

Cela ²semble tellement déplacé mais cela économise 1 octet, alors je le garderai.

Essayez-le en ligne!

Tester tous les cas

Pour le schéma de sortie que j'ai choisi:

• -1si Left est plus lourd que Right ( L)
• 0si Left est aussi lourd que Right ( B)
• 1is Left est moins lourd que Right ( R)

Ungolfed && Explanation

Cela utilise des cartes et réduit pour faire le travail.

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

^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]

C'était un problème. pb n'a pas été conçu pour être bon dans ce genre de chose. Il n'y a même pas de multiplication . Mais bon, ça marche.

Ed. note: Ai-je juste dit que pb n'a pas de multiplication? Quelle? pb a définitivement la multiplication. J'ai conçu et mis en œuvre ce langage, je devrais savoir qu'il est doté d'une multiplication intégrée et que je n'ai pas à faire d'ajouts idiots en boucle. Résoudre ce problème (ainsi que réarranger de manière créative maintenant que je pouvais aborder cette partie du problème sous un angle (presque littéralement) différent) me fait économiser 20 octets. Gênant.

La partie la plus difficile était, après avoir obtenu les sommes de (poids * distance) de chaque côté, de déterminer quelle lettre imprimer. pb n'a pas >ou <opérateurs, juste ==et !=. Il n'y a pas de moyen facile de déterminer quelle valeur est la plus grande. Je ne peux même pas soustraire et comparer avec 0 ... sauf si je fais quelque chose de vraiment stupide.

• Trouvez la somme des deux sommes.
• Allez aussi loin à droite, sur une ligne qui ne sert à rien.
• Jusqu'à atteindre X = 0, allez à gauche et placez les "L".
• Placez un 'B' à X = 0.
• Aller à gauche par la somme des deux sommes.
• Jusqu'à atteindre X = 0, allez à droite et placez les 'R'.

Ensuite, vous allez simplement à X = (côté gauche - côté droit), et voilà votre réponse! Supprimez tout ce qui se trouve sur cette ligne pour le nettoyer, puis imprimez la valeur trouvée en (0, 0).

... Mais il y a un moyen légèrement plus court. Au lieu d'utiliser 'L', 'B' et 'R', utilisez ces valeurs - 'B' et ajoutez 'B' à nouveau lors de l'impression. De cette façon, vous ne devez jamais placer «B» à X = 0, vous devez simplement le laisser comme le 0 qu'il était déjà. Le seul problème est qu'une fois que vous faites cela, le programme devient très maladroit en mode veille. 'L'-'B'==76-66==10=='\n'. Tout semble bien fonctionner, jusqu'à ce qu'un grand nombre de nouvelles lignes soient imprimées et qu'il soit impossible de garder une trace de ce qui se passe: D En mode d'exécution normal de pbi, tout fonctionne correctement, car les nouvelles lignes sont supprimées avant que quoi que ce soit ne soit imprimé. console.

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

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

MATLAB 91, 57, 55 octave, 50 octets

Je ne m'attendais pas à jouer plus loin, mais passer à Octave a permis d'économiser 5 octets supplémentaires! Wow, celui-ci a pris du temps ...

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

Il produit -Inf, NaN, Infpour L, B, Rrespectivement.

Suite de tests!

Explication:

C'est certainement un code difficile à lire, mais je vais essayer de vous expliquer le mieux possible. Je vais basculer entre l'explication du bloc de code et le texte.

@(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    

Regardons ce qui se passe entre les crochets:

[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

Celui-ci est un peu délicat:

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

Les chiffres de chaque côté de l'échelle doivent être multipliés par la distance au caret. Si nous utilisons des nombres négatifs sur le côté gauche et des nombres positifs sur le côté droit, nous pouvons simplement additionner le vecteur pour voir quel côté est le plus lourd.

Supposons que la chaîne d'entrée est: '321^ 12'. Nous voulons que ce qui suit: 3*(-3)+2*(-2)+1*(-1)+1*3+2*4. Le vecteur que nous avons créé à l'intérieur des crochets commence à 1-i, ce qui est dans ce cas -3, puisque le curseur est en 4ème position. Cela monte par nnz(x)-iincréments de un. Nous pouvons utiliser à la nnz(x)place de numel(s), car xest une chaîne ne contenant pas de zéros.

Donc:

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

Maintenant, nous pourrions faire la multiplication élément par élément s.*[...] et en prendre la somme. Mais, puisque nous avons deux vecteurs, nous pouvons aussi multiplier spar la transposée de [...]et calculer la somme en utilisant la multiplication matricielle:

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

Cela nous donne soit un nombre négatif, ce qui signifie que le côté gauche est plus lourd, un zéro, ce qui signifie qu'il est équilibré, soit un nombre positif, ce qui signifie que le côté droit est plus lourd. Au lieu d'utiliser l'approche naïve de sign(...), nous la multiplions par inf, ce qui nous donnera soit-Inf ou Infà gauche et à droite. Nous obtenons NaNpour 0*inf, car c'est indéfini.

Cela nous donne trois valeurs distinctes pour les trois résultats possibles.

, 22 caractères / 38 octets

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

Try it here (Firefox only).

JavaScript, 146 octets

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

Assez massive.

Démo .

Ruby, 111 108 octets

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

Explication

Résume la valeur pondérée de chaque nombre de chaque côté. Ensuite, il utilise l'opérateur de vaisseau spatial ruby ​​pour fournir 1,0, -1 d'égalité / inégalité des deux côtés, qui est l'index d'un tableau avec la sortie correcte.

PowerShell, 83 73 octets

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

Merci à TessellatingHeckler pour le golf.

Utilise essentiellement le même algorithme que l'ancien code ci-dessous, mais ici nous parcourons les caractères de la chaîne d'entrée un par un plutôt que de parcourir l'index, ce qui économise une poignée d'octets. Lance toujours le même message d'erreur spectaculaire lorsque l'algorithme atteint ^- n'affecte pas STDOUT.

précédent

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

Utilise le même algorithme génial que l'excellente réponse de Dendrobium , et utilise donc le même résultat que -1 / 0 / 1si l'entrée est left-heavy / balanced / right-heavy.

Pouah. Longtemps en raison d'une fonctionnalité de prédisposition au casting de PowerShell. Le plus pertinent ici est comment charmultiplié par les intfonctions. Prendre un tableau-index d'un stringrésultat dans un charobjet. PowerShell convertit le charen sa valeur ASCII correspondante (plutôt que sa valeur littérale) avant la multiplication. Donc, quelque chose comme les $a='012'[0];[int]$a*2résultats en 96.

Cela signifie que nous devons le rediffuser sous forme de chaîne. Cependant, le simple fait de nous donner le stringtemps intnous le stringrépète souvent. Par exemple, $a='0';$a*2aboutirait à 00.

Cela signifie que nous devons lancer le charverso stringavant la retransmission, pour que la intmultiplication puisse avoir lieu, avant de l'ajouter à notre accumulateur $x.

Ajoutez à cela un long chemin pour parcourir une chaîne et l'appel .NET pour afficher le signe, et nous obtenons un très long morceau de code.

_{NB - Cela jettera une erreur spectaculaire quand il arrivera ^dans la chaîne, indiquant qu'il ne peut pas le convertir en int. N'affecte pas STDOUT.}

CJam, 29 octets

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

Essayez-le en ligne

Le résultat est -1pour gauche-lourd, 0pour équilibré, 1pour droite-lourd.

Cela semblait un peu long, mais j’ai essayé de nombreuses alternatives, et elles se sont toutes terminées entre 29 et 33 octets. Un problème est que je ne pouvais pas trouver un moyen de convertir la chaîne en valeurs qui aboutiraient automatiquement à 0 pour les espaces. Donc, j'ai fini par remplacer explicitement les espaces par des «0 caractères», ce qui ajoute évidemment à la longueur du code.

Alternatives essayées:

• Fractionner la chaîne en '^, inverser la première, puis calculer la valeur pondérée pour les deux.
• Utilisation de l' eeopérateur pour ajouter l'index à la liste de valeurs.
• Au lieu de soustraire la position du curseur de chaque index, calculez le produit scalaire sans la soustraction, puis soustrayez la longueur de la chaîne du curseur par la longueur de la chaîne du résultat.

Explication:

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, 196 114 octets

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

Code régulier:

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

Explication:

1. Génère une liste de nombres + le point d'appui de stdin.
2. Pour chaque nombre, ajoute la distance du point d'appui fois le nombre de la variable au total (les nombres à gauche seront négatifs et les nombres à droite seront positifs).
3. Imprime la lettre correcte en fonction du résultat (B si égal, L si supérieur à zéro et R si inférieur à zéro).

Un grand merci à @ThomasKwa pour avoir coupé 82 octets (plus de 40%)!

C, 140 139 138 134 100 octets

Revenir:

• 1 = GAUCHE
• 2 = ÉQUILIBRÉ
• 0 = DROIT

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

Courir:

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

Comme nous avons ASCII:

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

On a:

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

Puis somme par facteur distance à ^.

SpecBAS - 140 octets

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)

test un total cumulé, les valeurs sont négatives lorsque la position du caractère est supérieure à la position carat. À la fin, il voit si le total est négatif, nul ou positif et affiche le caractère correspondant de R, B ou L.

Je pourrais gagner quelques octets en affichant simplement -1, 0 ou 1, comme certaines des autres réponses.

Java, 83 octets

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