Dengeleme Yasası

Bir testere (sözde Fransız 'ci-ça'dan, yani' bu-bu 'anlamına gelir), benzer şekilde her yerde bulunan slayt ve salınım ile birlikte, oyun alanı ekipmanının kutsal üçlüsünün üçte birini oluşturur. Bir testere, sadece ve her iki taraftaki momentlerin toplamı eşdeğerse mükemmel bir dengededir. Dolayısıyla bir testere testeresi, daha düşük moment toplamı olan tarafa belirli bir ağırlık ekleyerek dengelenebilir; bunu başarmak, bu meydan okuma için hedefinizdir.

Meydan okuma

Zorluğunuz, bir testere testeresinin giriş olarak bir tasvirini alıp tekrar çıktısını almak ve onu dengelemek için testere testeresinin bir ucuna ağırlık eklemektir.

Giriş

Programınız makul bir formatta aşağıdakiler gibi bir ASCII testere almalıdır:

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

İlk satır, her biri testere testeresindeki ağırlıkları temsil eden iki sayı içerir. Her tarafta, her biri tahta tarafının en ucuna etki eden bir ağırlık bulunur. Ağırlıkların tamsayı olması ve her zaman tahtaların karşılık gelen uçlarıyla hizalanması garanti edilir. Bu sayılar asla dayanakla çakışmaz (^ ) .

İkinci çizgi, testere testeresinin 'tahtalarını' temsil eder. Her tire ( -), doğrudan doğrudan dayanak üzerinde (^ ) .

Üçüncü çizgi, testerenin dayanağını temsil eder. Bu dayanak, bu satırda boşluk olmayan tek karakterle, inceltme işaretiyle ('^') işaretlenir. Dayanak, ağırlığı temsil eden sayılar ya girişte ya da çıktıda dayanakla çakışmayacak kadar alan kaldığı sürece, tahta uzunluğu boyunca geçerli bir girişte herhangi bir yere yerleştirilebilir.

Girdinin üç satıra sahip olması ve testere oluşturan karakterlerden önce veya sonra beyaz boşluk olmaması garanti edilir (elbette, bunu gerektiren üçüncü satır hariç).

Çıktı

Çıktı için, aynı testere tasviri stdout'a yazdırılmalıdır, ancak testere testeresini dengelemek için ağırlıklardan biri (ve sadece bir tanesi) daha büyük bir ağırlıkla değiştirilmelidir. Girdilerin bunu yalnızca tamsayılar kullanarak mümkün kılacağı garanti edilmektedir. Bu nedenle, ağırlıklar ondalık basamaklar veya benzeri gösterimler olmadan gösterilmelidir. Dilinizde stdout kullanılmıyorsa, çıktıda topluluk / meta konsensüsüne başvurmalısınız. Sondaki satırsonları iyi ancak tasvir biçiminde yapılan diğer değişiklikler büyük olasılıkla uygun değil.

Örnek

Test Girişleri ve Karşılık gelen Çıkışlar

Giriş 1

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

Çıktı 1

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

Giriş 2

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

Çıktı 2

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

Giriş 3

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

Çıkış 3

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

Giriş 4

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

Çıkış 4

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

Referans Uygulaması - 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",
                "-------------------",
                "    ^              "])

kurallar

• Bu kod golf , bu yüzden en kısa kod bayt cinsinden sayılır. Sayım baytları dilinizde garipse meta'yı kontrol edin.

• Standart kurallar / boşluklar geçerlidir.

• Giriş makul bir biçimde alınmalıdır. Uygun biçimlerin kapsamlı olmayan bir listesi aşağıdaki gibi verilir:

  • Satır yeni satır karakterleriyle ayrılmış tek bir dize
  • Dizelerin listesi, her dize bir satırı temsil eder
  • 2D Dizi veya Karakter Matrisi

İlgili Zorluklar

• Bir testere üzerinde bir ağırlık setini dengeleyin - Önerilen Ağustos 2015 by samgak

05AB1E ,60 51 50 49 47 45 bayt

Emigna sayesinde 10 bayt, Adnan sayesinde 1 bayt tasarruf etti.

Tüm giriş satırları aynı miktarda karaktere sahip olmalıdır.

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

Çevrimiçi deneyin!

"05AB1E kodunuz 40 bayttan uzunsa, büyük olasılıkla yanlış yapıyorsunuz" gibi temel bir kural olmalıdır. Çok golf gibi görünüyor, herhangi bir fikir açığız!

JavaScript (ES6), 136

Muhtemelen tahrip edilmiş atama ve varsayılan parametreleri kullandığı için Chrome'da çalışmıyor.

alertKullanılan orantılı yazı tipi nedeniyle standart JS çıktı yönteminin görev için özellikle uygun olmadığını unutmayın.

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

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

Ölçek

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 karakter

Komut satırı seçenekleri gerektirir -p0(bu bana programdaki 149 baytın üstünde 2 baytlık bir ceza verir).

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

Açıklama:

• -p0Anahtar ilk boş karakterle veya EOF kadar tüm girişini okur. Bu sorun NUL'lara izin vermez, bu nedenle varsayılan olarak normal ifadeler $_vb. İçin kullanılan değişkendeki girdinin tamamını alırız .
• Girdiyi ayrıştıran bir regex ile başlıyoruz (birinci ve ikinci eğik çizgi arasında). İlk ağırlığı (örneğin .+?) ayrıştırabileceğimiz birkaç yol var , ancak 3 karakterin altına ulaşamıyorum, bu yüzden bariz olanı da kullanabilirim \d+. İkinci sayı satırın sonunda olduğundan .+(2 karakter) olarak ayrıştırılabilir . Merkezi çizgi, ölçeklerin ne kadar geniş olduğunu belirlemek için kullanılır; -+(diğer birçok gösterim işe yarayacaktır) olarak ayrıştırılır . Son satırdaki düzeltme işaretinden önceki boşluklar +. Düzeltme işareti (veya gerçekten boşluk olmayan) göründüğünde, girdinin geri kalanını yoksayarız.
• Perl otomatik olarak düzenli ifade dört grup (çıkıntı işareti ilk önce ağırlık, ikinci ağırlık, tire satır, boşluk) yakalar $1, $2, $3, $4. Normalde mapbu gruplardan oluşan bir diziyi eşleştirmek için dizi olarak argüman olarak bir normal ifade vermek . Bu nedenle uzunluklarını alıyoruz; Bunun uzunluklarını depolamak için uygun bir yoldur $3ve $4yazmak zorunda kalmadan lengthiki kez. Ayrıca $_uzunluğu ile üzerine yazıyoruz $1; bunun değerini gerçekten umursamıyoruz (sol girişteki basamak sayısı bir tür işe yaramaz), ancak kısa olması ( $_'uzunluğu artık satırdaki basamak sayısı ölçeklerin genişliğine göre mutlaka çok küçük olan ilk ağırlık).
• $rÖlçeklerin bölünme oranını ölçüyoruz .
• $1*$r>$2hangi tarafın daha ağır olduğunu kontrol eder. Biz yeni ağırlıkları depolamak $xve $y; ağırlık oranı bilinince bunların çok basit hesaplamaları vardır.
• Biz bitiştirmek $x, $,ve $yiçine $_üst satır üretmek için, daha sonra ekleme boşluk (tutmak $"varsayılan olarak tek bir boşluk içerir ve bir hazır boşluk daha kısadır ' 'olurdu) üzerine $,orta sıranın aynı uzunlukta olana kadar (yani uzunluğa sahiptir $c). ( $,Bu bağlamda güvenli bir şekilde değiştirilebilen ve varsayılan olarak boş başlayan yerleşik bir değişken olduğu için değişkeni seçtim .) Varsayılan olarak lengthçalıştığından, $_açıkça bir argüman vermemize gerek yoktur. Bir Yoda koşullu kullandım çünkü doğru ayrıştırmak için önemli ölçüde daha az belirginleştirici sözdizimine ihtiyaç duyuyor.
• Son olarak, Perl'in çıkış çizgisi sonlandırma kuralı ( $\) fikrini, ölçek kümesinin geri kalanını içerecek şekilde yeniden tanımladım (girişteki ile aynıdır, bu yüzden basitçe $3ve $4doğrudan yığınını üretmek için kullanabilirim ). Bunun üçüncü satırda izleyen boşluk olmadığı anlamına gelir; ekleyerek programı biraz daha uzatabilir ve herhangi bir amaca hizmet etmediği için bunu dışarıda bıraktım.
• Programın sonunda -panahtar tekrar tetiklenir; bu kez çıktıdan $_sonra "newline" ( $\) gelir. Çıktı yeni satırını yeniden tanımladığım için, bu iki örtülü baskı aralarında yeni ölçekler oluşturur (her ne kadar bir yan etki olarak, çıktıda yeni satır yoktur).
• -pAnahtarı şimdi tekrar giriş okumaya çalışır, ancak EOF okur ve programı sona yüzden zaten, dosyanın tamamını slurped.

PHP, 212 209 205 bayt

muhtemelen golf yapılabilir

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

Komut satırı argümanından girdi alır; kaçış satırları. İle çalıştırın -r.

Bir yer tutucuyla değiştirmek beklendiği gibi çalışmadı; ilk regex'e daha fazla parens eklemek zorunda kaldım.

Befunge, 223 217 bayt

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

Çevrimiçi deneyin!

Python 2, 184183 bayt

Kesinlikle golf oynayabilir

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

Oldukça basit. Her iki tarafı ayarlamak için ayarlanmış ağırlıkları alın, hangisinin orijinalden daha büyük olduğunu görün ve birini değiştirin ve çıktı alın.

EDIT Tamsayı bölümü kötü olduğu için anahtarlamalı çarpma ve bölme (bunu fark ettiği için @JonathanAllan'a teşekkürler)

DÜZENLEME -1 bayt değiştirdi i().index('^')için i().find('^')(@JonathanAllan sayesinde [tekrar!])

C ++ 14, 482 bayt

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

daha okunabilir versiyon:

#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, 235230 bayt (minimize edilmiş referans)

Ben sadece referans golf, kod golf için çok yeni minimize.

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

Bunu örnekle tamamen aynı kullanırsınız, ancak işlev syerine kullanılır balance_seesaw.