พระราชบัญญัติการปรับสมดุล

See-saw (สมมุติจาก 'ci-ça', ความหมาย 'this-that') ในรูปแบบหนึ่งในสามของอุปกรณ์สนามเด็กเล่นศักดิ์สิทธิ์พร้อมด้วยสไลด์และแกว่งที่แพร่หลายในทำนองเดียวกัน การเลื่อยนั้นมีความสมดุลที่สมบูรณ์แบบหากและถ้าหากผลรวมของช่วงเวลาในแต่ละด้านเท่ากัน เลื่อยสามารถปรับสมดุลได้โดยการเพิ่มน้ำหนักที่เฉพาะเจาะจงกับด้านข้างด้วยผลรวมช่วงเวลาที่ต่ำกว่า การบรรลุเป้าหมายนี้เป็นเป้าหมายของคุณสำหรับความท้าทายนี้

ท้าทาย

ความท้าทายของคุณคือการแสดงให้เห็นถึงการมองเห็นเป็นอินพุทและเอาท์พุทมันอีกครั้งโดยมีการเพิ่มน้ำหนักที่ปลายด้านหนึ่งของการเลื่อยเพื่อความสมดุล

อินพุต

โปรแกรมของคุณจะต้องใช้รูปแบบที่เหมาะสมในรูปแบบ ASCII ที่จะเห็นดังต่อไปนี้:

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

บรรทัดแรกมีตัวเลขสองตัวโดยแต่ละตัวแทนน้ำหนักที่เห็นได้ มีน้ำหนักตัวเดียวอยู่ด้านข้างแต่ละอันทำหน้าที่ส่วนปลายสุดของไม้กระดาน น้ำหนักถูกรับประกันว่าจะเป็นจำนวนเต็มและจัดให้สอดคล้องกับจุดสิ้นสุดของไม้กระดานเสมอ ตัวเลขเหล่านี้จะไม่ทับซ้อนกับศูนย์กลาง ( ^)

บรรทัดที่สองแสดงถึง 'ไม้กระดาน' ของเลื่อย แต่ละเส้นประ ( -) แสดงความยาวเท่ากันของเส้นประแต่ละเส้นยกเว้นเพียงขีดกลางเหนือจุดศูนย์กลาง ( ^) โดยตรงซึ่งไม่มีความยาว

บรรทัดที่สามแสดงถึงศูนย์กลางของการเลื่อย จุดศูนย์กลางนี้มีการทำเครื่องหมายด้วยตัวละครเท่านั้นที่ไม่ได้มีช่องว่างในบรรทัดนี้เป็นหมวก ('^') ศูนย์กลางสามารถวางตำแหน่งใดก็ได้ตามความยาวของไม้กระดานในอินพุตที่ถูกต้องตราบใดที่มีพื้นที่เหลือเพียงพอเพื่อให้ตัวเลขที่เป็นตัวแทนของน้ำหนักไม่ทับซ้อนกับศูนย์กลางในอินพุตหรือเอาต์พุต

อินพุตรับประกันว่ามีสามบรรทัดและไม่มี white-space ก่อนหรือหลังอักขระที่ประกอบด้วย see-saw (ยกเว้นแน่นอนบรรทัดที่สามซึ่งจำเป็นต้องใช้)

เอาท์พุต

สำหรับเอาท์พุทภาพวาดที่เห็นแบบเดียวกันควรถูกพิมพ์ไปยัง stdout แต่มีน้ำหนักหนึ่ง (และมีเพียงหนึ่ง) ที่ถูกแทนที่ด้วยน้ำหนักที่มีขนาดใหญ่ขึ้นเพื่อที่จะปรับสมดุลของเลื่อย อินพุตมีการรับประกันว่าจะทำให้เป็นไปได้โดยใช้จำนวนเต็มเพียงอย่างเดียว ดังนั้นน้ำหนักจะต้องแสดงโดยไม่มีจุดทศนิยมหรือสัญลักษณ์อื่นที่คล้ายคลึงกัน หากภาษาของคุณไม่ได้ใช้ stdout คุณควรไปตามมติของชุมชน / เมตาในการแสดงผล การขึ้นบรรทัดใหม่มีผลดี แต่การเปลี่ยนแปลงรูปแบบอื่น ๆ นั้นอาจไม่เป็นที่ยอมรับ

การยกตัวอย่าง

ทดสอบอินพุตและเอาต์พุตที่สอดคล้องกัน

อินพุต 1

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

เอาท์พุท 1

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

อินพุต 2

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

เอาท์พุท 2

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

อินพุต 3

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

เอาท์พุท 3

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

อินพุต 4

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

เอาท์พุท 4

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

การดำเนินการอ้างอิง - 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",
                "-------------------",
                "    ^              "])

กฎระเบียบ

• นี่คือรหัสกอล์ฟดังนั้นรหัสที่สั้นที่สุดจะนับเป็นไบต์ ตรวจสอบเมตาว่าการนับไบต์เป็นภาษาที่คุณใช้ไม่ได้หรือไม่

• ใช้กฎ / ช่องโหว่มาตรฐาน

• ต้องป้อนข้อมูลในรูปแบบที่เหมาะสม รายการที่ไม่ครบถ้วนสมบูรณ์ของรูปแบบที่เหมาะสมมีดังต่อไปนี้:

  • สตริงเดี่ยวที่มีบรรทัดคั่นด้วยอักขระบรรทัดใหม่
  • รายการสตริงแต่ละสตริงแสดงบรรทัด
  • อาร์เรย์ 2 มิติหรือเมทริกซ์ของอักขระ

ความท้าทายที่เกี่ยวข้อง

• ยอดคงเหลือชุดของน้ำหนักในการดู - เสนอสิงหาคม 2015 โดย samgak

05AB1E ,60 51 50 49 47 45 ไบต์

บันทึก 10 ไบต์ขอบคุณ Emigna และ 1 ไบต์ขอบคุณ Adnan

บรรทัดอินพุตทั้งหมดต้องมีจำนวนอักขระเท่ากัน

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

ลองออนไลน์!

ควรมีกฎง่ายๆเช่น "ถ้ารหัส 05AB1E ของคุณยาวเกิน 40 ไบต์คุณอาจทำผิด" ดูเหมือนว่าสามารถเล่นกอล์ฟได้ความคิดใด ๆ ก็ยินดีต้อนรับ!

JavaScript (ES6), 136

อาจไม่ทำงานใน Chrome เนื่องจากใช้การกำหนดที่กำหนดไว้ล่วงหน้าและพารามิเตอร์เริ่มต้น

โปรดทราบว่าวิธีการแสดงผล JS มาตรฐานalertไม่เหมาะสมสำหรับงานโดยเฉพาะอย่างยิ่งเนื่องจากตัวอักษรที่ใช้สัดส่วน

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

น้อย golfed

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

ทดสอบ

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 ตัวอักษร

ต้องการตัวเลือกบรรทัดคำสั่ง-p0(สิ่งนี้ให้โทษ 2 ไบต์ที่ด้านบนของ 149 ไบต์ในโปรแกรม)

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

คำอธิบาย:

• -p0สวิทช์อ่านอินพุตขึ้นทั้งไบต์ NUL แรกหรือ EOF ปัญหานี้ไม่อนุญาตให้ใช้ NUL ดังนั้นเราจะได้รับข้อมูลทั้งหมดในตัวแปร$_ที่ใช้สำหรับ regexes เป็นต้นตามค่าเริ่มต้น
• เราเริ่มต้นด้วย regex ที่แยกวิเคราะห์อินพุต (ระหว่างเครื่องหมายสแลชแรกและวินาที) มีหลายวิธีที่เราสามารถแยกน้ำหนักแรก (เช่นมี.+?) ฉันไม่สามารถรับมันต่ำกว่า 3 \d+ตัวอักษรดังนั้นฉันเช่นกันอาจจะใช้ที่เห็นได้ชัด หมายเลขที่สองคือท้ายบรรทัดเพื่อให้สามารถแยกวิเคราะห์เป็น.+(2 ตัวอักษร) เส้นกลางใช้เพื่อกำหนดความกว้างของเครื่องชั่ง มันแยกเป็น-+(เป็นตัวแทนอื่น ๆ อีกมากมายจะทำงาน) +ช่องว่างก่อนเครื่องหมายบนบรรทัดสุดท้ายเป็น เมื่อเครื่องหมายรูปหมวก (หรือไม่มีช่องว่างใด ๆ ) ปรากฏขึ้นเราจะไม่สนใจอินพุตที่เหลือ
• Perl โดยอัตโนมัติจับสี่กลุ่ม regex (ที่น้ำหนักแรกน้ำหนักสองแถวของยัติภังค์พื้นที่ก่อนที่ลูกศร) ลง$1, $2, ,$3 $4ให้ regex เป็นอาร์กิวเมนต์เพื่อmapใช้อาร์เรย์ของกลุ่มเหล่านั้นเป็นอาร์เรย์เพื่อแมป ดังนั้นเราจึงใช้ความยาวของพวกเขา; นี่เป็นวิธีที่สะดวกในการจัดเก็บความยาว$3และ$4โดยไม่ต้องเขียนlengthสองครั้ง นอกจากนี้เรายังเขียนทับ$_ด้วยความยาวของ$1; เราไม่สนใจค่านี้ (จำนวนหลักในอินพุตด้านซ้ายเป็นชนิดที่ไร้ประโยชน์) แต่ความจริงที่ว่าสั้น ( $_ความยาวของตอนนี้คือจำนวนหลักในจำนวนหลักใน น้ำหนักแรกซึ่งจำเป็นต้องมีขนาดเล็กมากเมื่อเทียบกับความกว้างของเครื่องชั่ง)
• เราวัดอัตราส่วน$rในการแบ่งตาชั่ง
• $1*$r>$2ตรวจสอบเพื่อดูว่าด้านไหนหนักกว่า เราเก็บตุ้มน้ำหนักใหม่ใน$xและ$y; สิ่งเหล่านี้มีการคำนวณที่ง่ายมากเมื่อทราบอัตราส่วนของน้ำหนัก
• เรา concatenate $x, $,และ$yเข้าสู่$_การผลิตแถวบนจากนั้นให้เพิ่มช่องว่าง ( $"มีพื้นที่เดียวโดยค่าเริ่มต้นและสั้นกว่าพื้นที่ที่แท้จริง' 'จะ) ไป$,จนกว่าจะยาวเช่นเดียวกับแถวกลาง (คือมีความยาว$c) (ฉันเลือกตัวแปร$,เนื่องจากเป็นตัวแปรในตัวที่สามารถเปลี่ยนแปลงได้อย่างปลอดภัยในบริบทนี้และเริ่มว่างโดยค่าเริ่มต้น) ตามที่lengthทำงาน$_โดยค่าเริ่มต้นเราไม่จำเป็นต้องให้อาร์กิวเมนต์อย่างชัดเจน ฉันใช้เงื่อนไขแบบโยดาเนื่องจากต้องการไวยากรณ์ที่ทำให้กระจ่างน้อยลงอย่างมากในการแยกวิเคราะห์อย่างถูกต้อง
• ในที่สุดฉันก็นิยามความคิดใหม่ของ Perl เกี่ยวกับบรรทัดสิ้นสุดการประชุม ( $\) เพื่อให้มีส่วนที่เหลือของชุดเครื่องชั่ง (ซึ่งเหมือนกับในอินพุตดังนั้นฉันสามารถใช้$3และ$4สร้างจำนวนมากได้โดยตรง) โปรดทราบว่านี่หมายความว่าไม่มีช่องว่างต่อท้ายในบรรทัดที่สาม การเพิ่มมันจะทำให้โปรแกรมใช้งานได้นานขึ้นเล็กน้อยและดูเหมือนจะไม่ตอบสนองต่อวัตถุประสงค์ใด ๆ ดังนั้นฉันจึงทิ้งมันไว้
• เมื่อสิ้นสุดโปรแกรม-pสวิตช์จะเปิดขึ้นอีกครั้ง ครั้งนี้มันออก$_มาตามด้วย "newline" ( $\) เนื่องจากฉันได้กำหนดบรรทัดใหม่เอาท์พุทใหม่การพิมพ์โดยนัยทั้งสองนี้จึงสร้างชุดสเกลใหม่ระหว่างพวกเขา (แม้ว่าจะเป็นผลข้างเคียงจึงไม่มีการขึ้นบรรทัดใหม่ในเอาต์พุต)
• -pสวิทช์ตอนนี้พยายามที่จะอ่านเข้าอีกครั้ง แต่เรา slurped แล้วไฟล์ทั้งหมดจึงอ่าน EOF และสิ้นสุดโปรแกรม

PHP, 212 209 205 ไบต์

อาจเล่นกอล์ฟได้

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

รับอินพุตจากอาร์กิวเมนต์บรรทัดรับคำสั่ง หนี newlines -rทำงานด้วย

การแทนที่ด้วยตัวยึดตำแหน่งไม่ทำงานตามที่คาดไว้ ดังนั้นฉันต้องเพิ่ม parens ให้กับ regex แรก

Befunge, 223 217 ไบต์

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

ลองออนไลน์!

Python 2, 184 183 ไบต์

สามารถเล่นกอล์ฟได้อย่างแน่นอน

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

ค่อนข้างตรงไปตรงมา เพียงแค่นำตุ้มน้ำหนักที่ปรับแล้วสำหรับการปรับทั้งสองด้านมาดูว่ามีใครที่มีขนาดใหญ่กว่าต้นฉบับและเปลี่ยนอันนั้นและเอาท์พุท

EDIT เปลี่ยนการคูณและการหารเนื่องจากการหารจำนวนเต็มไม่เป็นผล (ขอบคุณ @JonathanAllan สำหรับการสังเกตนี้)

แก้ไข-1 ไบต์เปลี่ยนi().index('^')เป็นi().find('^')(ขอบคุณ @JonathanAllan [อีกครั้ง!])

C ++ 14, 482 ไบต์

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

รุ่นที่อ่านได้มากขึ้น:

#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 ไบต์ (การอ้างอิงน้อยที่สุด)

ฉันลดการอ้างอิงเนื่องจากฉันยังใหม่กับการเขียนโค้ดกอล์ฟมาก

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

คุณจะใช้มันเหมือนกับตัวอย่าง แต่ฟังก์ชั่นแทนsbalance_seesaw