Loi sur l'équilibre

Une balançoire (censément du ci-ça français, qui signifie «ceci-cela») forme un tiers de la sainte trinité de l'équipement de jeux, avec le toboggan et la balançoire tout aussi omniprésents. Une balançoire est en parfait équilibre si, et seulement si, la somme des moments de chaque côté est équivalente. Une balançoire peut donc être équilibrée en ajoutant une quantité spécifique de poids sur le côté avec la somme de moment inférieure; atteindre cet objectif est votre objectif pour ce défi.

Défi

Votre défi consiste à prendre une représentation d'une bascule en entrée et à la sortir à nouveau, avec du poids ajouté à une extrémité de la bascule pour l'équilibrer.

Contribution

Votre programme doit prendre, dans tout format raisonnable, une balançoire ASCII telle que la suivante:

100             100
-------------------
         ^         

La première ligne contient deux nombres, chacun représentant des poids sur la bascule. Exactement un poids est présent de chaque côté, chacun agissant à l'extrémité de son côté de la planche. Les poids sont garantis comme des entiers et s'alignent toujours avec leur extrémité correspondante de la planche. Ces chiffres ne chevaucheront jamais le point d'appui ( ^).

La deuxième ligne représente la «planche» de la bascule. Chaque tiret ( -) représente une longueur égale à l'autre tiret, à la seule exception du tiret directement sur le point d'appui ( ^), qui n'a pas de longueur.

La troisième ligne représente le point d'appui de la bascule. Ce point d'appui est marqué par le seul caractère qui n'est pas un espace sur cette ligne, un circonflexe ('^'). Le point d'appui peut être positionné n'importe où le long de la longueur de la planche dans une entrée valide tant qu'il reste suffisamment d'espace pour que les nombres représentant les poids ne chevauchent pas le point d'appui dans l'entrée ou la sortie.

L'entrée est garantie d'avoir trois lignes et aucun espace blanc avant ou après les caractères qui constituent la bascule (à l'exception, bien sûr, de la troisième ligne, qui l'exige).

Production

Pour la sortie, la même représentation de bascule doit être imprimée sur stdout, mais avec un (et un seul) des poids remplacés par un poids plus grand, afin d'équilibrer la bascule. Les entrées sont garanties pour rendre cela possible en utilisant uniquement des entiers. Par conséquent, les poids doivent être affichés sans virgule décimale ni aucune autre notation similaire. Si votre langue n'utilise pas stdout, vous devez suivre le consensus de la communauté / méta sur la sortie. Les retours à la ligne de fin sont corrects, mais toute autre modification du format de représentation n'est probablement pas correcte.

Exemplification

Entrées de test et sorties correspondantes

Entrée 1

12                22
--------------------
             ^      

Sortie 1

12                26
--------------------
             ^      

Entrée 2

42       42
-----------
     ^     

Sortie 2

42       42
-----------
     ^     

Entrée 3

3             16
----------------
        ^      

Sortie 3

14            16
----------------
        ^      

Entrée 4

1                56
-------------------
    ^              

Sortie 4

196              56
-------------------
    ^              

Implémentation de référence - Python 3

# Takes a list of strings as input
def balance_seesaw(lines):
    weights = [int(w.strip()) for w in lines[0].split()]

    length  = len(lines[1])
    pivot   = lines[2].find("^")
    left_length    = pivot
    right_length   = length - 1 - pivot

    left_torque  = weights[0] * left_length
    right_torque = weights[1] * right_length

    if left_torque > right_torque:
        weights[1] = left_torque // right_length
    elif right_torque > left_torque:
        weights[0] = right_torque // left_length

    weights = [str(w) for w in weights]

    string_gap = " " * (length - sum(len(w) for w in weights))
    lines[0] = weights[0] + string_gap + weights[1]

    print("\n".join(lines))

balance_seesaw(["1                56",
                "-------------------",
                "    ^              "])

Règles

• Il s'agit de code-golf , donc les gains de code les plus courts sont comptés en octets. Vérifiez la méta si le comptage des octets est gênant dans votre langue.

• Des règles / lacunes standard s'appliquent.

• L'entrée doit être prise dans un format raisonnable. Une liste non exhaustive des formats appropriés est donnée comme suit:

  • Une chaîne unique avec des lignes séparées par des caractères de nouvelle ligne
  • Une liste de chaînes, chaque chaîne représentant une ligne
  • Un tableau 2D ou une matrice de caractères

Défis liés

• Équilibrer un ensemble de poids sur une balançoire - Proposé en août 2015 par samgak

05AB1E ,60 51 50 49 47 45 octets

10 octets enregistrés grâce à Emigna et 1 octet grâce à Adnan.

Toutes les lignes d'entrée doivent avoir le même nombre de caractères.

#õKD³'^¡€gDŠ*¬-Os÷1®‚*D0›*+¬?DJg²gs-ð×?¤,²,³,

#                                             Split the first input line on spaces
 õKD                                          Push [first weight, second weight] twice
    ³'^¡€gD                                   Push both lengths from either side of the pivot '^' as an array [left, right] twice
           Š*                                 Multiply by weights to get torque
             ¬-O                              Evaluate rightTorque-leftTorque
                s÷                            Divide by each side's length to get the weights to add: [deltaLeft, deltaRight], keep integer values
                  1®‚                         Push [1,-1]
                     *D                       Yield [deltaLeft, -deltaRight]
                       0›*                    Replace the negative value by 0
                          +                   Add weights: old + deltaWeight
                           ¬?                 Print left weight
                             DJg              Take the size of total decimal representation
                                ²gs-ð×?       Print a string composed of filler spaces between both new weights
                                       ¤,     Print right weight and newline
                                         ²,³, Print the last two lines from input (unchanged)

Essayez-le en ligne!

Il devrait y avoir une règle de base, comme "si votre code 05AB1E est plus long que 40 octets, vous le faites probablement mal". Cela semble si golfable, toute idée est la bienvenue!

JavaScript (ES6), 136

Ne fonctionne probablement pas dans Chrome, car il utilise une affectation déstructurée et des paramètres par défaut.

Notez que la méthode de sortie JS standard alertest particulièrement inadaptée à la tâche, en raison de la police proportionnelle utilisée.

(m,n,o,[p,q]=m.split(/ +/),l=n.length,h=o.indexOf`^`,g=l-h-1,c=p*h<q*g?q*g:p*h)=>alert((c/h+o).slice(0,h)+(o+c/g).slice(h-l)+`
${n}
`+o)

Moins golfé

( m,n,o, // input parameters, 3 strings
  // default parameters used as local variables
  [p,q] = m.split(/ +/), // left and right weight
  l = n.length, // bar length
  h = o.indexOf`^`, // left length
  g = l-h-1, // right length
  // p*h left torque
  // q*g right torque
  c = p*h<q*g ? q*g : p*h // max torque
) => alert( (c/h+o).slice(0,h)+(o+c/g).slice(h-l) // o has enough spaces to pad left and right
     +`\n${n}\n`+o )

Tester

F=
(m,n,o,[p,q]=m.split(/ +/),l=n.length,h=o.indexOf`^`,g=l-h-1,c=p*h<q*g?q*g:p*h)=>alert((c/h+o).slice(0,h)+(o+c/g).slice(h-l)+`
${n}
`+o)

function go()
{
  var [a,b,c]=I.value.split('\n')
  if(a.length!=b.length || a.length < c.length)
    alert('The strings are not of the same length')
  else 
  {  
    if (a.length > c.length)
      c = c+' '.repeat(a.length-c-length)
    F(a,b,c)
  }  
}

<textarea id=I>3             16
----------------
        ^      </textarea>
<button onclick='go()'>go</button>

Perl, 149 + 2 = 151 caractères

Nécessite des options de ligne de commande -p0(cela me donne une pénalité de 2 octets en plus des 149 octets du programme lui-même).

($_,$b,$c,$d)=map length,/(\d+) +(.+)
(-+)
( +)/;$r=$d/($c-$d-1);($x,$y)=$1*$r>$2?($1,$1*$r):($2/$r,$2);$_="$x$,$y",$,.=$"while$c>length;$\="
$3
$4^"

Explication:

• Le -p0commutateur lit l'entrée entière jusqu'au premier octet NUL ou EOF. Ce problème n'autorise pas les NUL, nous obtiendrons donc l'intégralité de l'entrée dans la variable $_utilisée pour les expressions rationnelles, etc., par défaut.
• Nous commençons par une expression régulière qui analyse l'entrée (entre la première et la deuxième barre oblique). Il existe plusieurs façons d'analyser le premier poids (par exemple .+?), mais je ne peux pas le faire descendre en dessous de 3 caractères, je peux donc aussi utiliser l'évidence \d+. Le deuxième nombre est à la fin de la ligne, il peut donc être analysé comme .+(2 caractères). La ligne centrale est utilisée pour déterminer la largeur des échelles; c'est analysé comme-+ (de nombreuses autres représentations fonctionneraient). Les espaces avant le curseur sur la dernière ligne sont +. Une fois que le signe d'insertion (ou en fait n'importe quel espace non) apparaît, nous ignorons le reste de l'entrée.
• Perl capture automatiquement les quatre groupes de l'expression rationnelle (premier poids, le deuxième poids, une rangée de tirets, les espaces avant le caret) dans $1, $2, $3, $4. Donner une expression régulière comme argument pour maputiliser en plus un tableau de ces groupes comme tableau sur lequel mapper. Nous prenons donc leurs longueurs; c'est un moyen pratique de stocker les longueurs de $3et $4sans avoir à écrire lengthdeux fois. Nous remplaçons également $_par la longueur de $1; nous ne nous soucions pas vraiment de la valeur de cela (le nombre de chiffres dans l'entrée gauche est un peu inutile), mais le fait qu'il soit court ($_ la longueur de est maintenant le nombre de chiffres dans le nombre de chiffres dans le premier poids, qui est forcément très faible par rapport à la largeur de la balance).
• Nous mesurons le rapport $rdans lequel les échelles sont divisées.
• $1*$r>$2vérifie quel côté est le plus lourd. Nous stockons les nouveaux poids dans $xet $y; ceux-ci ont des calculs très simples une fois que le rapport des poids est connu.
• Nous concaténons $x, $,et $yen $_produire la ligne supérieure, puis garder des espaces en ajoutant ( $"contient un seul espace par défaut et est plus courte qu'un espace littéral ' 'serait) sur $,jusqu'à ce qu'il soit la même longueur que la ligne médiane (c. -à- a une longueur $c). (J'ai choisi la variable $,car il est une variable intégrée qui peut être changé en toute sécurité dans ce contexte et commence à vide par défaut.) Comme lengthfonctionne sur$_ par défaut, nous n'avons pas besoin de lui donner explicitement un argument. J'ai utilisé un Yoda conditionnel car il a besoin de beaucoup moins de syntaxe sans ambiguïté pour analyser correctement.
• Enfin, je redéfinis l'idée de Perl de la convention de fin de ligne de sortie ( $\) pour contenir le reste de l'ensemble des échelles (qui est le même que dans l'entrée, donc je peux simplement utiliser $3et $4directement pour en produire la majeure partie). Notez que cela signifie qu'il n'y a aucun espace de fin sur la troisième ligne; l'ajouter rendrait le programme un peu plus long et ne semble d'aucune utilité, donc je l'ai laissé de côté.
• À la fin du programme, le -pcommutateur se déclenche à nouveau; cette fois, il sort $_suivi d'un "newline" ( $\). Parce que j'ai redéfini la nouvelle ligne de sortie, ces deux impressions implicites génèrent le nouvel ensemble d'échelles entre elles (bien que comme effet secondaire, il n'y ait pas de nouvelle ligne sur la sortie).
• Le -pcommutateur essaie maintenant de relire l'entrée, mais nous avons déjà récupéré l'intégralité du fichier, il lit donc EOF et termine le programme.

PHP, 212 209 205 octets

probablement golfable

preg_match("#(\d+)( +)(\d+)\s*(-+)[\r\n]+( +)\^#",$s=$argv[1],$m);echo preg_replace("#\d+( +)\d+#",(($r=$m[3])>($q=$m[1]*($p=strlen($m[5]))/(-$p-1+$e=strlen($m[4])))?$r*$e/($p+1)-$q=$r:$m[1]).$m[2].$q,$s);

Prend l'entrée de l'argument de ligne de commande; échapper aux nouvelles lignes. Courez avec -r.

Le remplacement par un espace réservé n'a pas fonctionné comme prévu; j'ai donc dû ajouter plus de parens au premier regex.

Befunge, 223 217 octets

&:00p&10p~$0>~#<2#+%#1_:20p0~>8#~%#+!#1_:3v
v\g01/g03*g01_v#!\g04`*g01g04:*g03p04-1-p0<
>#g>#0>#0>#/>#<:.2\5>5>#\+/#1:#\_$50p:50g\5>5>#\+/#1:#\_$20g\-v>
1#,>#*-#4:#8_$.55+,20g>:#,1#*-#9\#5_55+,30g>:#,1#*-#8\#4_"^",@>>

Essayez-le en ligne!

Python 2, 184 183 octets

Certainement golfable

i=raw_input
j=int
w=map(j,i().split())
W=len(i())
I=i().find('^')
R=W-I-1
a=[w[1]*R/I,w[0]*I/R]
h=a[1]>w[1]
w[h]=j(a[h])
k='\n'
print(' '*(W-len(str(w))+4)).join(map(str,w))+k+'-'*W+k+' '*I+'^'

Assez simple. Prenez simplement les poids ajustés pour ajuster les deux côtés, voyez lequel est plus grand que l'original, et changez celui-là, et sortez.

EDIT Multiplication et division commutées car la division entière est maléfique (merci à @JonathanAllan de l'avoir remarqué)

EDIT -1 octet Changé i().index('^')en i().find('^')(merci à @JonathanAllan [encore!])

C ++ 14, 482 octets

include<iostream>#include<string>#include<math.h>usingnamespacestd;intmain(){stringa,b,c,d;intj=0;inte[2];getline(cin,a);getline(cin,b);getline(cin,c);for(inti=0;i<a.size();i){if(isdigit(a.at(i))){while(i<a.size()&&isdigit(a.at(i))){d=a.at(i);i;}e[j]=stoi(d);d="";}}strings(b.size()-(int)log10(e[0])-(int)log10(e[1])-2,'');intl1=(c.size()-1);intl2=(b.size()-c.size());intl=e[0]*l1;intr=e[1]*l2;if(l>r)e[1]=l/l2;elsee[0]=r/l1;cout<<e[0]<<s<<e[1]<<endl;cout<<b<<endl;cout<<c;return0;}

version plus lisible:

#include <iostream>
#include <string>
#include <math.h>
using namespace std;
int main() {
    string a,b,c,d;
    int j=0;
    int e[2];
    // input
    getline(cin,a);// 1st line
    getline(cin,b);// 2nd line
    getline(cin,c);// 3rd line
    for (int i=0;i<a.size();i++) {
        if(isdigit(a.at(i))){
            while(i<a.size() && isdigit(a.at(i))){
                d+=a.at(i);
                i++;
            }
            e[j++]=stoi(d);
            d="";
        }
    }
    // amount of white space in between 2 numbers
    string s(b.size()-(int)log10(e[0])-(int)log10(e[1])-2,' ');
    int l1 = (c.size()-1);
    int l2 = (b.size()-c.size());
    int l = e[0]*l1;
    int r = e[1]*l2;
    // change the side with smaller torque
    if (l>r)
        e[1]=l/l2;
    else
        e[0]=r/l1;
    // output
    cout<<e[0]<<s<<e[1]<<endl;// 1st line
    cout<<b<<endl;// 2nd line
    cout<<c;// 3rd line
    return 0;
}

Python 3, 235 230 octets (référence minimisée)

Je viens de minimiser la référence, car je suis très nouveau dans le code-golf.

def s(l):
 w,i,t=[int(z.strip())for z in l[0].split()],len(l[1]),l[2].find("^");k,o=i-1-t,w[0]*t;p=w[1]*k
 if o>p:w[1]=o//k
 else:w[0]=p//t
 w=[str(z)for z in w];s=" "*(i-sum(len(z)for z in w));l[0]=w[0]+s+w[1];print("\n".join(l))

Vous l'utilisez exactement comme l'exemple, mais la fonction est à la splace de balance_seesaw.