Ustawa o równoważeniu

Piła (podobno z francuskiego „ci-ça”, co oznacza „to-to”) stanowi jedną trzecią świętej trójcy wyposażenia placów zabaw wraz z podobnie wszechobecną zjeżdżalnią i huśtawką. Piła jest w doskonałej równowadze, jeśli i tylko wtedy, gdy suma momentów z każdej strony jest równoważna. Pilarkę można zatem wyważyć, dodając do boku określoną ilość ciężaru z sumą niższego momentu; osiągnięcie tego jest twoim celem tego wyzwania.

Wyzwanie

Twoim zadaniem jest zobrazowanie piły jako wkładu i wyprowadzenie jej ponownie, z dodanym ciężarem na jednym końcu piły, aby ją zrównoważyć.

Wejście

Twój program musi mieć, w dowolnym rozsądnym formacie, znacznik ASCII, taki jak:

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

Pierwszy wiersz zawiera dwie liczby, z których każda reprezentuje wagi na piły. Dokładnie jeden ciężar jest obecny z każdej strony, z których każdy działa na samym końcu swojej deski. Odważniki są gwarantowane jako liczby całkowite i zawsze są wyrównane z odpowiadającym im końcem deski. Liczby te nigdy nie będą zachodzić na fulcrum ( ^).

Druga linia reprezentuje „deskę” piły. Każda myślnik ( -) reprezentuje równą długość myślnika, z wyjątkiem myślnika bezpośrednio nad punktem podrzędnym ( ^), który nie ma długości.

Trzecia linia przedstawia punkt podparcia piły. Punkt podparcia jest oznaczony jedynym znakiem, który nie jest spacją w tej linii, daszkiem („^”). Punkt podparcia można umieścić w dowolnym miejscu na długości deski na ważnym wejściu, pod warunkiem, że pozostanie wystarczająca ilość miejsca, aby liczby reprezentujące wagi nie zachodziły na punkt podparcia ani na wejściu, ani na wyjściu.

Dane wejściowe mają trzy wiersze i nie zawierają spacji przed znakami tworzącymi saw lub po nich (z wyjątkiem oczywiście trzeciej linii, która tego wymaga).

Wynik

Aby wydrukować, to samo przedstawienie piły powinno być wydrukowane na stdout, ale jeden (i tylko jeden) obciążnik należy zastąpić większym ciężarem, aby wyważyć piłę. Wejścia są gwarantowane, aby umożliwić to za pomocą samych liczb całkowitych. Dlatego wagi muszą być pokazywane bez miejsc po przecinku lub innych podobnych oznaczeń. Jeśli twój język nie używa standardowego wyjścia, powinieneś przejść przez konsensus społeczności / meta co do wyników. Końcowe znaki nowej linii są w porządku, ale wszelkie inne zmiany w formacie obrazu prawdopodobnie nie są w porządku.

Egzemplifikacja

Wejścia testowe i odpowiadające wyjścia

Wejście 1

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

Wyjście 1

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

Wejście 2

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

Wyjście 2

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

Wejście 3

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

Wyjście 3

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

Wejście 4

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

Wyjście 4

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

Implementacja referencji - 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",
                "-------------------",
                "    ^              "])

Zasady

• To jest golf golfowy , więc wygrywa najkrótszy kod liczony w bajtach. Sprawdź meta, jeśli liczenie bajtów jest niezręczne w twoim języku.

• Obowiązują standardowe zasady / luki.

• Dane wejściowe muszą być pobierane w rozsądnym formacie. Niewyczerpująca lista odpowiednich formatów jest podana w następujący sposób:

  • Pojedynczy ciąg znaków z wierszami oddzielonymi znakami nowej linii
  • Lista ciągów, każdy ciąg reprezentuje linię
  • Tablica 2D lub macierz znaków

Powiązane wyzwania

• Zrównoważyć zestaw ciężarów na piłie - Proponowane przez sierpnia 2015 przez samgak

05AB1E ,60 51 50 49 47 45 bajtów

Zaoszczędzono 10 bajtów dzięki Emignie i 1 bajt dzięki Adnan.

Wszystkie wiersze wprowadzania muszą mieć taką samą liczbę znaków.

#õ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)

Wypróbuj online!

Powinny istnieć ogólna zasada, na przykład: „jeśli kod 05AB1E jest dłuższy niż 40 bajtów, prawdopodobnie robisz to źle”. Wydaje się, że gra w golfa, każdy pomysł jest mile widziany!

JavaScript (ES6), 136

Prawdopodobnie nie działa w Chrome, ponieważ używa zniszczonego przypisania i parametrów domyślnych.

Zauważ, że standardowa metoda wyjściowa JS alertjest szczególnie nieodpowiednia do tego zadania, ze względu na zastosowaną czcionkę proporcjonalną.

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

Mniej golfa

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

Test

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 znaków

Wymaga opcji wiersza poleceń -p0(daje mi to 2 bajty kary na 149 bajtów w samym programie).

($_,$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^"

Wyjaśnienie:

• -p0Przełącznik odczytuje całą wejście do pierwszego bajta NUL lub EOF. Ten problem nie zezwala na wartości NUL, więc domyślnie uzyskamy całą wartość wejściową w zmiennej $_używanej do wyrażeń regularnych .
• Zaczynamy od wyrażenia regularnego, które analizuje dane wejściowe (między pierwszym i drugim ukośnikiem). Istnieje kilka sposobów na przeanalizowanie pierwszej wagi (np. .+?), Ale nie mogę uzyskać jej poniżej 3 znaków, więc równie dobrze mogę użyć oczywistości \d+. Drugi numer znajduje się na końcu wiersza, więc można go parsować jako .+(2 znaki). Linia środkowa służy do określenia, jak szerokie są skale; jest analizowany jako -+(działałoby wiele innych reprezentacji). Spacje przed karetką w ostatniej linii to +. Po pojawieniu się karetki (lub dowolnego spacji) ignorujemy resztę danych wejściowych.
• Perl automatycznie rejestruje czterech grup regex (pierwsza waga druga waga, wiersz z łącznikami pomieszczenia przed karetki) na $1, $2, $3, $4. Podanie wyrażenia regularnego jako argumentu mapdodatkowo wykorzystuje tablicę tych grup jako tablicę do odwzorowania. Dlatego bierzemy ich długości; jest to wygodny sposób na przechowywanie długości $3i $4bez konieczności lengthdwukrotnego pisania . Zastępujemy również $_długością $1; tak naprawdę nie dbamy o wartość tego (liczba cyfr na lewym wejściu jest dość bezużyteczna), ale fakt, że jest krótki ( $_długość jest teraz liczbą cyfr w liczbie cyfr w pierwsza waga, która z konieczności jest bardzo mała w porównaniu do szerokości łuski).
• Mierzymy stosunek, $rw jakim podziałki są podzielone.
• $1*$r>$2sprawdza, która strona jest cięższa. Nowe ciężary przechowujemy w $xi $y; mają one bardzo proste obliczenia, gdy znany jest stosunek wag.
• Łączymy $x, $,oraz $yw $_celu wytworzenia górnym rzędzie, a następnie zachować przestrzenie dodawanie ( $"zawiera pojedynczą przestrzeń domyślnie i jest krótsza niż dosłowną przestrzeń ' 'będzie) na $,aż to ta sama długość jak środkowym rzędzie (czyli ma długość $c). (Wybrałem zmienną, $,ponieważ jest to zmienna wbudowana, którą można bezpiecznie zmienić w tym kontekście i domyślnie zaczyna się pusta.) Ponieważ domyślnie lengthdziała $_, nie musimy jawnie podawać argumentu. Użyłem warunkowego Yoda, ponieważ wymaga on znacznie mniej jednoznacznej składni, aby poprawnie parsować.
• Wreszcie, redefiniuję ideę Perla dotyczącą konwencji zakończenia linii wyjściowej ( $\), aby zawierała resztę zestawu skal (która jest taka sama jak na wejściu, więc mogę po prostu użyć $3i $4bezpośrednio, aby wytworzyć większość). Zauważ, że oznacza to, że w trzeciej linii nie ma końcowych białych znaków; dodanie go sprawi, że program będzie nieco dłuższy i nie wydaje się służyć żadnemu celowi, więc go pominąłem.
• Pod koniec programu -pprzełącznik ponownie się uruchamia; tym razem wyświetla wynik, $_po którym następuje „nowa linia” ( $\). Ponieważ na nowo zdefiniowałem nowy wiersz wyjściowy, te dwa niejawne wydruki generują nowy zestaw skal między nimi (chociaż jako efekt uboczny nie ma nowego wiersza na wydruku).
• -pPrzełącznik teraz próbuje ponownie odczytać wejście, ale już slurped cały plik, tak to brzmi EOF i kończy program.

PHP, 212 209 205 bajtów

prawdopodobnie gra w golfa

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

Pobiera dane wejściowe z argumentu wiersza poleceń; uciec od nowych linii. Uruchom z -r.

Zastąpienie symbolem zastępczym nie działało zgodnie z oczekiwaniami; więc musiałem dodać więcej parens do pierwszego wyrażenia regularnego.

Befunge, 223 217 bajtów

&: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_"^",@>>

Wypróbuj online!

Python 2, 184 183 bajtów

Zdecydowanie do gry w golfa

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

Całkiem proste. Po prostu weź wyregulowane ciężary, aby wyregulować obie strony, zobacz, który z nich jest większy niż oryginał, i zmień to i wyjdź.

EDYCJA Przełączane mnożenie i dzielenie, ponieważ dzielenie liczb całkowitych jest złe (dzięki @JonathanAllan za zauważenie tego)

EDYCJA -1 bajt zmieniony i().index('^')na i().find('^')(dzięki @JonathanAllan [ponownie!])

C ++ 14, 482 bajtów

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

bardziej czytelna wersja:

#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 bajtów (zminimalizowane odniesienie)

Właśnie zminimalizowałem referencje, ponieważ jestem nowy w golfie.

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

Używasz go dokładnie tak samo jak w przykładzie, ale funkcja jest szamiast balance_seesaw.