Hành động cân bằng

Một cái cưa (được cho là từ 'ci-ça' của Pháp, có nghĩa là 'cái này-cái đó') tạo thành một phần ba trong bộ ba thiết bị sân chơi, cùng với cầu trượt và đu quay tương tự. Một cái cưa là cân bằng hoàn hảo nếu, và chỉ khi, tổng số khoảnh khắc ở mỗi bên là tương đương. Do đó, một cái cưa có thể được cân bằng bằng cách thêm một lượng trọng lượng cụ thể vào bên cạnh với tổng thời điểm thấp hơn; đạt được điều này là mục tiêu của bạn cho thử thách này.

Thử thách

Thách thức của bạn là lấy một mô tả của một cái cưa làm đầu vào và đầu ra nó một lần nữa, với trọng lượng được thêm vào một đầu của cưa để cân bằng nó.

Đầu vào

Chương trình của bạn phải có, ở bất kỳ định dạng hợp lý nào, máy cưa ASCII như sau:

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

Dòng đầu tiên chứa hai số, mỗi số đại diện cho các trọng số trên cưa. Chính xác một trọng lượng có mặt ở mỗi bên, mỗi trọng lượng tác động vào phần cuối của mặt bên của tấm ván. Trọng lượng được đảm bảo là số nguyên và luôn thẳng hàng với phần cuối tương ứng của tấm ván. Những con số này sẽ không bao giờ trùng với điểm tựa ( ^).

Dòng thứ hai đại diện cho 'tấm ván' của cưa máy. Mỗi dấu gạch ngang ( -) biểu thị một độ dài bằng nhau với dấu gạch ngang khác, ngoại trừ dấu gạch ngang trực tiếp trên điểm tựa ( ^) không có độ dài.

Dòng thứ ba đại diện cho điểm tựa của cưa. Điểm tựa này được đánh dấu bởi ký tự duy nhất không phải là khoảng trắng trên dòng này, dấu mũ ('^'). Điểm tựa có thể được định vị ở bất cứ đâu dọc theo chiều dài của tấm ván trong một đầu vào hợp lệ miễn là còn đủ không gian để các số đại diện cho trọng số không trùng với điểm tựa ở đầu vào hoặc đầu ra.

Đầu vào được đảm bảo có ba dòng và không có khoảng trắng trước hoặc sau các ký tự cấu thành cưa (tất nhiên, ngoại trừ dòng thứ ba, yêu cầu nó).

Đầu ra

Đối với đầu ra, mô tả cùng một cưa nhìn thấy nên được in ra thiết bị xuất chuẩn, nhưng với một (và chỉ một) trọng lượng được thay thế bằng trọng lượng lớn hơn, để cân bằng với cưa. Đầu vào được đảm bảo để thực hiện điều này có thể bằng cách sử dụng số nguyên một mình. Do đó, các trọng số phải được hiển thị mà không có dấu thập phân hoặc bất kỳ ký hiệu tương tự nào khác. Nếu ngôn ngữ của bạn không sử dụng thiết bị xuất chuẩn, bạn nên đi theo sự đồng thuận của cộng đồng / meta về đầu ra. Trailing newlines là tốt nhưng bất kỳ thay đổi khác đối với định dạng mô tả có thể không ổn.

Gương mẫu

Kiểm tra đầu vào và đầu ra tương ứng

Đầu vào 1

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

Đầu ra 1

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

Đầu vào 2

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

Đầu ra 2

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

Đầu vào 3

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

Đầu ra 3

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

Đầu vào 4

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

Đầu ra 4

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

Tham chiếu thực hiện - 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",
                "-------------------",
                "    ^              "])

Quy tắc

• Đây là môn đánh gôn , vì vậy đoạn mã ngắn nhất sẽ được tính bằng byte. Kiểm tra meta nếu đếm byte là khó xử trong ngôn ngữ của bạn.

• Quy tắc chuẩn / sơ hở áp dụng.

• Đầu vào phải được thực hiện trong một định dạng hợp lý. Một danh sách không đầy đủ các định dạng phù hợp được đưa ra như sau:

  • Một chuỗi đơn có các dòng được phân tách bằng các ký tự dòng mới
  • Một danh sách các chuỗi, mỗi chuỗi đại diện cho một dòng
  • Mảng 2D hoặc Ma trận các ký tự

Những thách thức liên quan

• Cân bằng một tập các trọng số trên một cái cưa - Dự kiến ​​tháng 8 năm 2015 bởi samgak

05AB1E ,60 51 50 49 47 45 byte

Đã lưu 10 byte nhờ Emigna và 1 byte nhờ Adnan.

Tất cả các dòng đầu vào phải có cùng số lượng ký tự.

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

Hãy thử trực tuyến!

Cần có một quy tắc chung, như "nếu mã 05AB1E của bạn dài hơn 40 byte, có lẽ bạn đã làm sai". Có vẻ như chơi golf, bất kỳ ý tưởng đều được chào đón!

JavaScript (ES6), 136

Có lẽ không hoạt động trong Chrome, vì nó sử dụng các tham số mặc định và gán bị hủy.

Lưu ý rằng phương thức đầu ra JS tiêu chuẩn alertđặc biệt không phù hợp cho tác vụ, vì phông chữ tỷ lệ được sử dụng.

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

Ít chơi gôn

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

Kiểm tra

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 ký tự

Yêu cầu các tùy chọn dòng lệnh -p0(điều này mang lại cho tôi hình phạt 2 byte trên đầu 149 byte trong chính chương trình).

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

Giải trình:

• Công -p0tắc đọc toàn bộ đầu vào lên đến byte NUL hoặc EOF đầu tiên. Vấn đề này không cho phép NUL, vì vậy chúng tôi sẽ nhận toàn bộ đầu vào trong biến $_được sử dụng cho biểu thức chính, v.v., theo mặc định.
• Chúng tôi bắt đầu với một regex phân tích cú pháp đầu vào (giữa dấu gạch chéo thứ nhất và thứ hai). Có một số cách chúng ta có thể phân tích trọng lượng đầu tiên (ví dụ .+?), nhưng tôi không thể lấy nó dưới 3 ký tự để tôi cũng có thể sử dụng rõ ràng \d+. Số thứ hai nằm ở cuối dòng để có thể được phân tích cú pháp dưới dạng .+(2 ký tự). Đường trung tâm được sử dụng để xác định độ rộng của thang đo; nó được phân tích cú pháp như -+(nhiều đại diện khác sẽ hoạt động). Các khoảng trống trước dấu mũ trên dòng cuối cùng là +. Khi dấu mũ (hoặc thực sự là bất kỳ không gian nào) xuất hiện, chúng ta bỏ qua phần còn lại của đầu vào.
• Perl sẽ tự động chụp bốn nhóm regex (trọng lượng đầu tiên, trọng lượng thứ hai, hàng có dấu gạch nối, không gian trước khi caret) vào $1, $2, $3, $4. Đưa ra một biểu thức chính quy làm đối số để mapsử dụng thêm một mảng các nhóm đó làm mảng để ánh xạ. Do đó, chúng tôi có chiều dài của họ; đây là một cách thuận tiện để lưu trữ độ dài $3và $4không phải viết lengthhai lần. Chúng tôi cũng ghi đè lên $_với chiều dài của$1 ; chúng tôi không thực sự quan tâm đến giá trị của điều này (số chữ số ở đầu vào bên trái là vô dụng), nhưng thực tế là nó ngắn ( $_chiều dài bây giờ là số chữ số trong số chữ số trong trọng lượng đầu tiên, nhất thiết phải rất nhỏ so với chiều rộng của cân).
• Chúng tôi đo tỷ lệ $r trong đó các tỷ lệ được chia.
• $1*$r>$2kiểm tra xem bên nào nặng hơn Chúng tôi lưu trữ trọng lượng mới trong $xvà$y ; chúng có các phép tính rất đơn giản một khi tỷ lệ trọng lượng được biết đến.
• Chúng tôi tiếp nhau $x, $,và $yvào $_để sản xuất hàng đầu, sau đó giữ không gian thêm ( $"chứa một không gian duy nhất bằng cách mặc định, và ngắn hơn so với một không gian đen ' 'sẽ) vào $,cho đến khi nó là chiều dài tương tự như hàng giữa (tức là có chiều dài $c). (Tôi đã chọn biến $,vì đây là biến tích hợp có thể thay đổi một cách an toàn trong ngữ cảnh này và bắt đầu trống theo mặc định.) Khi lengthhoạt động trên$_ theo mặc định, chúng tôi không cần phải đưa ra một đối số rõ ràng. Tôi đã sử dụng một điều kiện Yoda bởi vì nó cần cú pháp định hướng ít hơn đáng kể để phân tích chính xác.
• Cuối cùng, tôi xác định lại ý tưởng của Perl về quy ước kết thúc dòng đầu ra ( $\) để chứa phần còn lại của tập hợp tỷ lệ (giống như trong đầu vào, vì vậy tôi có thể chỉ cần sử dụng $3và$4 trực tiếp để sản xuất phần lớn của nó). Lưu ý rằng điều này có nghĩa là không có khoảng trắng ở cuối dòng thứ ba; thêm nó sẽ làm cho chương trình dài hơn một chút và dường như không phục vụ bất kỳ mục đích nào, vì vậy tôi đã bỏ nó.
• Khi kết thúc chương trình, công -ptắc kích hoạt lại; lần này, nó xuất ra $_sau một "dòng mới" ( $\). Vì tôi đã xác định lại dòng mới đầu ra, hai bản in ngầm này tạo ra bộ tỷ lệ mới giữa chúng (mặc dù là hiệu ứng phụ, không có dòng mới nào trên đầu ra).
• Công -ptắc bây giờ cố gắng đọc lại đầu vào, nhưng chúng tôi đã xóa toàn bộ tệp, vì vậy nó đọc EOF và kết thúc chương trình.

PHP, 212 209 205 byte

có lẽ là golf

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

Lấy đầu vào từ đối số dòng lệnh; thoát dòng mới. Chạy với -r.

Thay thế bằng một trình giữ chỗ không hoạt động như mong đợi; Vì vậy, tôi đã phải thêm nhiều parens vào regex đầu tiên.

Befunge, 223 217 byte

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

Hãy thử trực tuyến!

Python 2, 184 183 byte

Chắc chắn có thể chơi được

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

Khá đơn giản. Chỉ cần lấy các trọng số đã điều chỉnh để điều chỉnh cả hai bên, xem cái nào lớn hơn bản gốc và thay đổi cái đó và đầu ra.

EDIT Chuyển đổi nhân và chia vì phân chia số nguyên là evile (cảm ơn @Jonathan ALLan vì đã nhận thấy điều này)

EDIT -1 byte được thay đổi i().index('^')thành i().find('^')(cảm ơn @Jonathan ALLan [một lần nữa!])

C ++ 14, 482 byte

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

phiên bản dễ đọc hơn:

#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 byte (tham chiếu tối thiểu)

Tôi chỉ thu nhỏ tài liệu tham khảo, vì tôi rất mới với môn đánh gôn.

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

Bạn sử dụng nó chính xác giống như ví dụ, nhưng chức năng là sthay vì balance_seesaw.