Vais-je basculer?


36

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.


Le programme peut-il prendre les trois lignes comme trois chaînes séparées (par exemple, trois arguments d’une fonction ou une liste de trois éléments)?
Notjagan

@notjagan L'entrée doit être une chaîne unique séparée par des caractères de nouvelle ligne.
Daffy

Connexes , possible dupe.
xnor

@xnor Ce n'est pas une dupe car cette question ne traite que des lettres majuscules et son objectif est de trouver le pivot. Ma question concerne tous les caractères ascii> = 32, et la mienne fournit le pivot et demande si la structure va tomber. Essentiellement l'inverse de celui que vous avez lié.
Daffy

Réponses:


8

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é.


1
Je pense que (b.length+~i)pourrait aider à sauver un octet. (De plus, je ne comprends pas pourquoi vous en avez ||1.)
Neil

1
@ Neil b.length+~iretourne le négatif de i-b.length+1; cela pourrait aider si je pouvais nier l'autre partie. En ce qui concerne le ||1, c’est parce que j’imaginais que la première ligne n’était pas rembourrée pour correspondre à la longueur de la tige; t.charCodeAt(i)elle reviendrait donc NaNau-delà de la fin de la première ligne.
Justin Mariner

Je n'avais pas pensé à essayer un cas de test non-rembourré; merci pour expliquer.
Neil

3

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)

(ord(c)-31)Il m'a fallu un certain temps pour me rendre compte qu'il s'agissait en réalité du poids de la tige et des éléments. Très intelligent!
Daffy

1
Selon méta , vous pouvez remplacer returnpar printfor -1 octet (bien que cela ne fonctionne pas vraiment avec le code TIO actuel).
Notjagan

3

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

1
Vous pouvez utiliser fromEnumau lieu de ordet déposer le import. cpeut être simplifié en c p=max(ord p-32)0(ou avec fromEnum) et comme vous l’utilisez une seule fois, en ligne.
nimi

Ou vous pouvez ajouter (Lambdabot) à votre titre, cela importe à peu près tout ce dont vous avez besoin, voir ici .
ბიმო

1
La fonction cpeut même être simplifiée (les caractères de moins de 32 ans ne sont pas pris en compte) c p=ord p-32. C'est aussi pfondamentalement length(moins 1), donc p x=length x-1travaillerait aussi (et vous pouvez aussi le mettre en ligne). Jetez également un coup d’œil à ma solution, à la manière dont j’utilise signum- vous pouvez faire r o l s = signum $ 2 * z ...quels retours 0,1,-1pour B, L, R.
ბიმო

1
En dehors de cela, cette solution semble échouer [3,4,7]et prend 3 chaînes au lieu d'une. (voir lines)
ბიმო

1
Voici une version avec quelques astuces appliquées (enregistre 29 octets;)).
ბიმო

2

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              

2

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 .


2

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.


2

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

2

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!


1

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

10
Bienvenue chez PPCG! : D L'objectif des défis de code-golf est de rendre votre code aussi petit que possible. Vous pouvez réduire la taille de votre code en faisant en sorte que toutes les variables et les noms de fonctions ne comportent qu'un seul caractère et en supprimant les espaces, dans la mesure du possible.
Daffy

1

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!


1

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.


1

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


1

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)

1
Vous n'avez pas besoin sum([...]), vous pouvez simplement avoirsum(...)
M. Xcoder

@Daffy devrait être 100% conforme à votre spécification et à tous les exemples donnés. Si vous êtes d'accord, merci de me le faire savoir afin que je puisse l'optimiser davantage. Merci.
VeganaiZe

@veganaiZe A passé tous mes tests, ça a l'air bien! :)
Daffy

1
Stuff to shorten it: i[c:].find(e)peut être i.find(e,c), utiliser i,m,n=s.split('\n')et éviter le besoin de s, utiliser return 2*(r>l) or l>rpour réduire considérablement le coût du test à la fin (la valeur de retour est numériquement équivalente, mais c'est au Truelieu de 1et à la Falseplace de 0), ou vraiment, utilisez un ensemble de retour différent Valeurs et faites return (l>r)-(r>l)pour renvoyer le 1, 0 ou -1 comme le cmpfaisait l'ancienne fonction.
ShadowRanger

Merci ShadowRanger, M. Xcoder et Daffy! @ShadowRanger, je devais m'en tenir au i[c:]parce que la méthode la plus courte entraînait un problème étrange pour chaque saisie dans le coin (essayez de placer un point |exactement au centre, au-dessus de la barre).
VeganaiZe

1

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

1

Charbon de bois , 31 octets

A⁰ξFLθA⁺ξ×⁻ι⌕ζ|⁻℅§θι³¹ξI⁻›ξ⁰‹ξ⁰

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 ≔ΣEθ×⁻κ⌕ζ|⁻℅ι³¹ξI⁻›ξ⁰‹ξ⁰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: ≔⁰ξFLη≔⁺ξ×⁻ι⌕ζ|⁻℅§◨θLηι³¹ξI⁻›ξ⁰‹ξ⁰ Essayez-le en ligne! ≔ΣE◨θLη×⁻κ⌕ζ|⁻℅ι³¹ξI⁻›ξ⁰‹ξ⁰ Essayez-le en ligne! Les liens doivent contenir une version verbeuse du code.


Vous voudrez peut-être mentionner que ceci implique que les lignes d'entrée soient complétées à la longueur correcte par des espaces, de sorte qu'une entrée non complétée risque de ne pas fonctionner.
FlipTack

@FlipTack Mieux encore, j'ai conçu des versions acceptant les entrées non additionnées.
Neil
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.