Vue d'ensemble

Avec une chaîne de 3 lignes, déterminez si la structure tombe à gauche, est équilibrée ou tombe à droite.

Structure d'entrée

Vous pouvez imaginer la structure comme une tige de métal avec des éléments sur le dessus, le tout équilibré sur une tige verticale.

1  7 4        a
===============
        |

La première ligne est les articles. Le poids de chaque élément est calculé comme la valeur ascii du caractère moins 32. (Les caractères de moins de 32 ans ne sont pas pris en compte et les espaces pèsent 0). Gardez à l'esprit que la force d'un élément sur la tige est son poids multiplié par la distance jusqu'au pivot.

La deuxième ligne est la tige. Chaque longueur de tige pèse 1 unité à elle seule. Cette ligne est exclusivement égale à des signes ( =).

La troisième ligne est le point pivot. Cela peut être placé n'importe où et est représenté par un nombre d'espaces suivi d'un seul caractère pipe ( |).

Exemples

Contribution:

=====
  |

Sortie: balance

Contribution:

=====
   |

Sortie: chutes à gauche

Contribution:

    %
=====
   |

Sortie: balance (car %pèse assez pour compenser le poids du côté gauche de la tige)

Contribution:

 aa
=======
   |

Sortie: tombe à droite (parce que ala droite est plus éloignée du point de pivot)

Contribution:

1  7 4        A
===============
        |

Sortie: chutes à gauche

Contribution:

1  7 4        a
===============
        |

Sortie: tombe à droite (les lettres minuscules sont lourdes!)

Contribution:

            $ ~
===============
             |

Sortie: balance

Remarques

• Les espaces de fuite sont autorisés, mais pas les espaces de début.
• Votre programme peut sortir dans le format de votre choix, à condition qu'il y ait 3 sorties distinctes pour gauche, balance et droite.
• Votre programme doit accepter le format indiqué en entrée.

JavaScript (ES6), 116 111 108 106 octets

-5 octets en sommant via eval(array.join`+`)au lieu de array.reduce().
-3 octets par défaut à la 1place de 32 - 31, ce qui permet de supprimer les parenthèses.
-2 octets puisque le point de pivot est la longueur de la dernière ligne - 1

(s,[t,r,b]=s.split`
`)=>Math.sign(eval([...r].map((_,i)=>(t.charCodeAt(i)-31||1)*(i-b.length+1)).join`+`))

Sorties -1, 0ou 1, pour gauche, symétrique ou droite, respectivement. Il s'est avéré être similaire à la réponse de Chas Brown en python , le crédit y est donc crédité.

Peut économiser 4 octets si la première ligne est complétée pour correspondre à la longueur de la tige en utilisant
(31-t.charCodeAt(i))*(b.length+~i).

Test Snippet

Inclut une sortie supplémentaire ( Left/ Balanced/ Right) avec le nombre.

f=
(s,[t,r,b]=s.split`
`)=>Math.sign(eval([...r].map((_,i)=>(t.charCodeAt(i)-31||1)*(i-b.length+1)).join`+`))

<textarea id=I rows=3 cols=20></textarea><br><button onclick="O.value=I.value?`${x=f(I.value)} (${['Left','Balanced','Right'][x+1]})`:''">Run</button> <input id=O disabled>

Une autre méthode de 106 octets

(s,[t,r,b]=s.split`
`)=>Math.sign(eval(r.replace(/./g,(_,i)=>"+"+(t.charCodeAt(i)-31||1)*(i-b.length+1))))

Au lieu d’ joininclure un tableau sur +s, nous créons une chaîne de nombres, chacun précédé de préfixe +. Le principal +est ignoré.

Python 2 , 112 110 octets

def f(s):w,b,p=s.split('\n');return cmp(sum((ord((w+' '*-~i)[i])-31)*(i-p.find('|'))for i in range(len(b))),0)

Essayez-le en ligne!

EDIT: Enfin réussi à éliminer le enumerateet rjustpour un maigre 2 octets ... meh!

Prend dans une ficelle; sorties -1,0, ou 1 pour les chutes à gauche, les soldes, les chutes à droite, respectivement.

Le premier passage à 112 octets était:

def f(s):w,b,p=s.split('\n');return cmp(sum((ord(c)-31)*(i-p.find('|'))for i,c in enumerate(w.rjust(len(b))),0)

Haskell, 212 171 octets (188 si prendre l'entrée comme une chaîne)

o!p=map(fst)(zip[p-0,p-1..]o)
x#p=sum(zipWith(\c w->(max(fromEnum c-32)0)*w)x(x!p))+sum(x!p)
x?c=length(takeWhile(==c)x)

Variante de 171 octets

r a b c=signum(take(b?'=')(a++repeat ' ')#(c?' '))

Variante de 188 octets

x%y=lines x!!y
r i=signum(take(i%1?'=')(i%0++repeat ' ')#(i%2?' '))

Explication

o!p=map(fst)(zip[p-0,p-1..]o)        Creates weights coefs list. 
                                     o - list, p - pivot position
                                     for list "abcdf" and p=3 (pivot under 'd')
                                     outputs [3,2,1,0,-1]

x#p                                  Calculates total balance
                                     x-list of "objects" on lever, p-pivot place
  sum(zipWith                        sum of zipped lists
   (\c w->(max(fromEnum c-32)0)*w)   weight of ascii "object" times
                                     distance from pivot
    x(x!p))                          x-ascii objects, 
                                     (x!p)-distances list(weight coefs)
  +sum(x!p)                          balance of lever ("==") itself

x?c=length(takeWhile(==c)x)          length of list before non c element met
                                     used to find '|' position
                                     and length of "===" lever
                                     before right whitespaces met

r a b c=                             Sums it all up =)
                                     a-ascii objects, b-lever, c-pivot line
   signum(                           1-tips left, 0-balance, -1-tips right
     take(b?'=')(a++repeat ' ')      takes all object on lever 
                                     plus whitespaces up to length of the lever
      #                              calculate the balance
       (c?' ')                       determine place of pivot

Gelée , 30 octets

O_31×J_¥A+\sṪ€µ÷ḢṪ_2Ṡ
ỴṪLç@ỴḢ$

Suite de tests

Sorties 0 pour équilibré, 1 pour droite et -1 pour gauche.

Comment ça marche

O_31×J_¥A+\sṪ€µ÷ḢṪ_2Ṡ - helper function. Arguments position of pivot and first line
O                        - char codes of first line
 _31                     - subtract 31 to get weight
    ×                    - elementwise product with:
     J_¥                 - distances from the pivot
        A                - absolute value
         +\              - cumulative sum
           s             - split to get [[...,left weight],...,[..., right + left weight]]
            Ṫ€           - last element of each sublist: [left weight, ... right weight]
              µ÷Ḣ        - get ratio of each element over left weight: ratio n indicates
                              right + left = n × left ===> right = left if n = 2
                 _2      - subtract 2: positive is right>left and negative is right<left
                   Ṡ     - return the sign of this


ỴṪLç@ỴḢ$              - main link. Argument: 3 line string.
   ç@                  - apply helper function with arguments:
Ỵ                        - split by linefeeds
 Ṫ                       - last line
  L                      - length (returns position of pivot)
       $               - and
     Ỵ                   - split by linefeeds
      Ḣ                  - first line              

Gelée , 24 octets

ṪO_31
ỴµṪLạЀṪL$×Çṣ0S€IṠ

Essayez-le en ligne!

-1pour tomber à gauche, 0pour équilibrer, 1pour tomber à droite (programme complet).
[-1]pour tomber à gauche, [0]pour équilibrer, [1]pour tomber à droite (fonction).

La première ligne doit avoir des espaces finaux, la dernière ligne ne doit pas.

Explication (nous commençons par la ligne du bas):

Tout d'abord, nous travaillons avec des lignes individuelles, nous devons donc les obtenir d'une manière ou d'une autre. C'est un travail pour Ỵ. Ensuite, nous devons traiter la \nversion -split de l'entrée comme s'il s'agissait de l'entrée d'origine. Nous utilisons donc µpour appliquer une chaîne monadique à la valeur actuelle.

Maintenant, nous commençons un vrai travail et notre premier travail serait de calculer les facteurs de pondération. Il s'agit essentiellement d'une plage [distance de l'extrême gauche au pivot..0..distance du pivot à l'extrême droite]. Tout d’abord, nous devons trouver l’indice 1 du pivot, qui est essentiellement la longueur de la dernière ligne sans espaces de fin. Donc, nous supprimons la dernière ligne (ligne pivot) de notre liste d'origine avec Ṫ, puisque nous n'en avons plus besoin, puis nous prenons sa longueur avec L. Nous devons ensuite prendre la longueur de la canne, pour laquelle nous faisons la même chose avec la dernière ligne (ligne de canne) ṪL$. Enfin, pour obtenir la gamme, nous cartographions | x - y | à [1..rod length], où x est l'indice de pivot et yest chaque élément de la liste sur laquelle nous cartographions. Nous faisons cela en utilisant ạЀ, où ạcalcule | x - y | et Ѐfait une gamme de 1 à et y compris la longueur de la tige. Maintenant, nous aurons la plage que nous voulons.

Après cela, nous devons multiplier chaque entier représentant un morceau de la tige avec son poids correspondant. Pour calculer les poids, nous utilisons Ç, allant à la première ligne de notre code. Nous prenons la ligne restante avec Ṫses codes de caractères avec O, puis nous calculons x - 31 en utilisant _31, x étant chaque code. Nous l' espace puis attribuez - lui poids 1 (0 + pièce de tige = 1), !poids 2 (1 + 1) , etc. Nous en avons terminé avec la ligne supérieure, maintenant Çrenverrait la liste des poids, que nous multiplier avec le correspondant entiers représentant les pièces de tige avec ×.

Après cela, nous nous sommes séparés avec ṣ0le point de pivot, représenté par un 0 (aucun poids n’y affectant le résultat), ce qui a donné une liste de la forme [[1er poids, 2e poids ... poids juste avant le pivot]] , [poids juste après pivot, poids après celui avant ... dernier poids]]. Ces listes représentent les côtés de la tige, à gauche et à droite. Nous additionnons maintenant chacune des listes en utilisant S€pour obtenir le total des poids de chaque côté et Ien prenant le delta, qui sera négatif si le côté gauche est plus lourd, zéro si elles ont une pondération égale et positif si le côté droit est plus lourd . Donc, pour retourner le résultat final en utilisant ceci correctement à notre avantage, nous prenons le signe avec Ṡ.

APL (Dyalog) , 43 octets *

{×(¯31+⎕UCS⊃⍵)+.×(⍳≢⊃⍵)-'|'⍳⍨⊃⌽⍵}⎕TC[2]∘≠⊆⊢

Essayez-le en ligne!

⊆⊢ partitionner l'argument en séries de caractères qui sont

⎕TC[2]∘≠ différente de la 2 ^ème T erminal C ontrol caractère (Linefeed) **

{… } Appliquez la fonction anonyme suivante à la liste de chaînes:

 ⊃⌽⍵ dans la première chaîne de la liste inversée (c'est-à-dire la dernière)

 '|'⍳⍨ trouver le ɩ ndex du point de pivotement

 (… )- Soustrayez cela de la liste suivante:

  ⊃⍵ la première chaîne

  ≢ sa longueur

  ⍳ tous les ɩ ndices de cette

 (… )+.× Somme pondérée avec ces poids et les valeurs suivantes:

  ⊃⍵ la première chaîne

  ⎕UCS les points de code dans le U niversal C haracter S et

  ¯31+ ajouter un négatif trente et un (32 pour le décalage requis moins un pour la tige)

 × signum de cela

^{* Pour 1 octet par caractère, utilisez {×(¯31+⎕UCS↑⍵)+.×(⍳≢↑⍵)-'|'⍳⍨↑⌽⍵}⎕TC[3]∘≠⊂⊢avec ⎕ML←3. Essayez-le en ligne!
** ⎕TCest obsolète et utilisé ici uniquement à des fins de golf. Dans le code de production, il faut utiliser ⎕UCS 10.}

Haskell (Lambdabot), 142 octets

l=length
g[a,c,b]=splitAt(l b)$a++(' '<$[1..l c-l a])
k e=sum$zipWith((*).(-31+).ord)e[1..]
f=signum.uncurry(-).(k.drop 1.reverse***k).g.lines

Essayez-le en ligne!

Version non-golfée:

-- for readability, allows reading top-down/left-right
(.>) = flip (.)

ungolfed =
     lines                                 -- separate out lines into..
  .> (\[a,b,c] ->                          -- a,b,c (first,second,third)
                                           -- ' ' pad the first line & split on pivot
       splitAt (length c) (a ++ replicate (length b - length a) ' ')
     )
  .> (weight.drop 1.reverse *** weight)    -- reverse left half, drop element above pivot & get weight for both
  .> uncurry (-)                           -- subtract right from left
  .> signum                                -- get sign

-- get ord of the character subtract 31 ('=' char from bar),
-- then multiply with scales ([1..]) and sum it all up
weight es = sum $ zipWith (ord .> subtract 31 .> (*)) es [1..]

Python 2 , 90 octets

def f(s):L=len(s)/3;print cmp(sum((ord(s[i])-31)*(i-s[-L:].find('|'))for i in range(L)),0)

Attend que les lignes d’entrée soient complétées (avec des espaces) à la longueur correcte. Les sorties -1pour des chutes à gauche , 0pour équilibre , et 1pour tombe bien .

Essayez-le en ligne!

94 octets

Pour +4 octets, nous pouvons avoir une version qui, à l'aide d'une whileboucle, nécessite des lignes brisées plutôt que des lignes complétées :

def f(s):
 i=r=0
 while''<s[i]:r+=(ord(s[i])-31)*(i-s[-3::-1].find('='));i+=1
 print cmp(r,0)

Essayez-le en ligne!

Ruby, 543 octets

def willittip(s)
leftw=0;
rightw=0;
arr=[];
fields=s.split("\n")
pos=fields[2].index("|")
fields[0].split("").each do |i|
arr << i.ord-32
end
arr[pos+1..-1].each_with_index do |x,y|
rightw=rightw+1
if x>0
if pos>0
rightw=rightw+x*(pos-y).abs
else
rightw=rightw+x
end
end
end
arr[0..pos-1].each_with_index do |x,y|
leftw=leftw+1
if x>0
if pos>0
leftw=leftw+x*(pos-y).abs
else
leftw=leftw+x
end
end
end
if leftw==rightw
return "Equal"
elsif leftw<rightw
return "Right"
elsif leftw>rightw
return "Left"
end
end

C (gcc) , 106107 121 123 124 129 131 octets

c,b,l,i;f(char*a){l=strlen(a)/3;for(i=b=c=0;32/a[l*2+c];++c);for(;i<l-1;b+=(a[i]-31)*(i++-c));a=b>0?2:!b;}

Renvoie 0 pour la gauche, 1 pour la balance et 2 pour la droite.

Exigez que les trois lignes aient la même longueur et finissez avec \npour déterminer la longueur de la chaîne.

Essayez-le en ligne!

Mathematica, 91 92 octets

Sign[(v=(g=ToCharacterCode)@#&@@(d=#~StringSplit~"
")-31).(Range@(l=Length)@v-l@g@Last@d)]&

La première ligne devrait avoir la même longueur avec la tige. La troisième ligne ne doit contenir aucun espace de fin.

Renvoie -1, 0, 1 pour une chute gauche, l'équilibre et une chute droite.

C # (.NET Core) , 127 95 90 + 18 = 108 octets

Pour cette fonction, la première ligne doit être correctement rembourrée avec des espaces de même longueur que la tige et la troisième ligne ne doit pas comporter d'espaces d'essai. Ces conditions sont autorisées (voir les commentaires de la question).

s=>s.Split('\n')[0].Select((c,i)=>(c-31)*(i-s.Split('\n')[2].Length+1)).Sum().CompareTo(0)

Essayez-le en ligne!

Les sorties:

-1 pour la pointe gauche
0 pour la balance
1 pour la droite

Python 3, 217 octets

Fonctionne également en Python 2.7

def f(s):i,b,p=s.split('\n');c=p.find('|');l=sum((ord(e)-32)*(c-i.find(e))for e in i[:c])+sum(x for x in range(1,c+1));r=sum((ord(e)-32)*i[c:].find(e)for e in i[c:])+sum(x for x in range(len(b[c:])));return(l>r)-(r>l)

Retourne 1 pour le côté gauche, -1 pour le côté droit, ou zéro si équilibré.

Version lisible:

def f(s):
    i,b,p = s.split('\n')
    c = p.find('|')

    l = sum((ord(e)-32)*(c-i.find(e))for e in i[:c])+sum(x for x in range(1, c+1))
    r = sum((ord(e)-32)*i[c:].find(e)for e in i[c:])+sum(x for x in range(len(b[c:])))

    return(l>r)-(r>l)

PHP, 105 octets

for([$a,$b,$c]=explode("
",$argn);$b[$i];)$w+=(strpos($c,"|")-$i++)*8*(max(1,ord($a[$i])-31));echo$w<=>0;

imprime -1/ 0/ 1pour gauche / balance / droite. Exécuter en pipe -nRou essayer en ligne .

panne

for([$a,$b,$c]=explode("\n",$argn); # import input
    $b[$i];)                        # loop through bar
    $f+=                                # add to force:
        ($i-strpos($c,"|"))             # distance (<0 if left, >0 if right of pivot)
        *8                              # *8
        *(max(1,ord($a[$i++])-31));     # *weight
echo$f<=>0;                         # print -1 if $f<0, 1 if $f>0, 0 if $f==0

Charbon de bois , 31 octets

Ａ⁰ξＦＬθＡ⁺ξ×⁻ι⌕ζ|⁻℅§θι³¹ξＩ⁻›ξ⁰‹ξ⁰

Essayez-le en ligne! Le lien est vers la version verbeuse du code. Sorties 0 pour la balance ou -1 ou 1 pour la chute gauche ou droite. Edit: Les changements dans le charbon signifient maintenant que cela ≔ΣＥθ×⁻κ⌕ζ|⁻℅ι³¹ξＩ⁻›ξ⁰‹ξ⁰fonctionne pour 24 octets: Essayez-le en ligne! Le lien est vers la version verbeuse du code. Remarque: les deux réponses nécessitent une entrée complétée, mais peuvent être adaptées pour accepter une entrée non complétée au coût de 3 octets: ≔⁰ξＦＬη≔⁺ξ×⁻ι⌕ζ|⁻℅§◨θＬηι³¹ξＩ⁻›ξ⁰‹ξ⁰ Essayez-le en ligne! ≔ΣＥ◨θＬη×⁻κ⌕ζ|⁻℅ι³¹ξＩ⁻›ξ⁰‹ξ⁰ Essayez-le en ligne! Les liens doivent contenir une version verbeuse du code.