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

Tổng quan

Đưa ra đầu vào gồm 3 số nguyên dương có một chữ số đại diện cho một tập các trọng số, xuất ra một biểu diễn ASCII của một cái bập bênh với các trọng số được đặt trên đó để nó cân bằng quanh một trục trung tâm, tính đến các hiệu ứng đòn bẩy.

Mỗi số có trọng số bằng giá trị của nó. Mô-men xoắn của mỗi số là trọng lượng nhân với khoảng cách từ tâm tính theo ký tự. Để chiếc bập bênh cân bằng, mô-men xoắn tổng của trọng lượng bên trái của chiếc bập bênh phải bằng với cái bên phải, như thế này .

Đầu vào

3 số nguyên trong phạm vi 1-9. Tuy nhiên, bạn có thể nhập các số nguyên thuận tiện, ví dụ: một tuple, 3 giá trị được phân tách bằng dấu phẩy, v.v. Tuy nhiên, chương trình của bạn phải có thể xử lý các số đầu vào theo bất kỳ thứ tự nào (nghĩa là không giả sử các giá trị sẽ được sắp xếp). Số trùng lặp có thể là đầu vào (ví dụ 2,3,2).

Các đầu vào sẽ luôn cho phép về mặt toán học cho một đầu ra hợp lệ, nếu không thì đầu vào không hợp lệ.

Đầu ra

Đầu ra phải là một đại diện ASCII 2 dòng của bập bênh với các trọng số được đặt trên nó. Trên dòng đầu tiên là các chữ số, cách đều nhau để cân bằng chúng trên bập bênh.

Các số có thể không được đặt ở chính giữa của thang đo, trong đó khoảng cách và do đó mô-men xoắn sẽ bằng không. Khoảng cách hợp lệ từ phạm vi trung tâm từ 1-10 ký tự bao gồm bên trái hoặc bên phải của trục.

Trong các khoảng trống không có số lượng là 18 ký tự gạch dưới (một dấu gạch dưới ở giữa và 10 ở mỗi bên, trừ đi 3 vị trí bị chiếm bởi các số). Trên dòng cuối cùng là một ký tự dấu mũ đơn được căn chỉnh với tâm của tỷ lệ, đại diện cho trục.

Ví dụ

Đầu vào:

4,7,2

Đầu ra:

________7___42_______
          ^

7 * 2 = 4 * 2 + 2 * 3

Các số có thể là đầu ra ở hai bên, ví dụ, điều này cũng sẽ hợp lệ:

_______24___7________
          ^

2 * 3 + 4 * 2 = 7 * 2

Các số có thể được đặt ở bất cứ đâu trên thang miễn là chúng cân bằng, ví dụ:

Đầu vào:

3,1,5

Đầu ra:

_____5________1__3___
          ^

5 * 5 = 1 * 4 + 3 * 7

hoặc là

____5________1_____3_
          ^

5 * 6 = 1 * 3 + 3 * 9

hoặc là

____5___________1_3__
          ^

5 * 6 = 1 * 6 + 3 * 8

v.v.

Chương trình của bạn chỉ phải xuất một trong những đầu ra hợp lệ. Nó không phải xuất ra lỗi nếu đầu vào không hợp lệ.

Ghi chú

• Đây là môn đánh gôn, vì vậy chương trình ngắn nhất tính bằng byte sẽ thắng
• Chương trình có thể là một độc lập hoặc một hàm chấp nhận các số làm đầu vào và trả về một chuỗi.
• Trailing dòng mới và khoảng trắng trên dòng cuối cùng là tùy chọn
• Nếu bạn không biết bập bênh là gì, thì nó còn được gọi là teeter-totter hoặc teeterboard.

CJam, 40 39 38 byte

q~21Ue]e!{21,Af-Aest.*:+!}=0'_erNAS*'^

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

Làm thế nào nó hoạt động

q~                                     e# Read and evaluate the input.
  21Ue]                                e# Append zeroes to achieve a length of 21.
       e!                              e# Push all unique permutations.
         {               }=            e# Find the first permutation such that:
          21,                          e#  Push [0 ... 20].
             Af-                       e#  Subtract 10 from each.
                Aest                   e#  Replace the element at index 10 with the
                                       e#  current time (ms since epoch) to push
                                       e#  [-10 ... -1 <big number> 1 ... 10].
                    .*                 e#  Multiply each number of the permutation
                                       e#  by the corresponding distance.
                      :+               e#  Add the products.
                                       e#  The timestamp makes sure that this sum
                                       e#  is non-zero for a non-zero element in
                                       e#  the middle of the permutation.    
                        !              e#  Push the logical NOT of the sum.
                           0'_er       e# Replace zeroes with underscores.
                                NAS*'^ e# Push a linefeed, ten spaces and a caret.

CJam, 46 44 byte

'_21*q~K,Am3m*{___&=*Afm1$.*:+!}=.{\t}NAS*'^

Kiểm tra nó ở đây.

Giải trình

Đầu tiên, một quan sát: chúng ta không bao giờ cần đặt hai chữ số ở hai đầu của bập bênh. Bất cứ khi nào đó là một giải pháp hợp lệ, có ít nhất một giải pháp hợp lệ khác (theo pastebin trong nhận xét về thách thức).

'_21*   e# Push a string of 21 underscores.
q~      e# Read and eval input.
K,      e# Push the array [0 1 .. 19 20]
Am      e# Remove the 10. This is now an array of all valid positions on the seesaw.
3m*     e# Get all 3-tuples of valid positions.
{       e# Select the first tuple for which the following block yields a truthy result.
  ___   e# Make three copies of the tuple.
  &=    e# Intersect the last two copies and check for equality with the first one.
        e# This yields 1 if all positions are distinct, and 0 otherwise.
  *     e# Repeat the original tuple that many times. That is, if the positions are
        e# distinct, leave the tuple unchanged. Otherwise, replace it with an empty array.
  Afm   e# Subtract 10 from each position to get its weight.
  1$    e# Copy the input digits.
  .*    e# Take the pairwise product of weights and digits. If the weights are empty
        e# (because they were not unique), this will just yield a list of the digits.
  :+    e# Sum the weighted digits. If the weights were not unique, this will just sum
        e# the digits and will always be positive.
  !     e# Logical NOT - give 1 if the sum was 0, or 0 otherwise.
}=
.{\t}   e# For each pair of digit and position, replace that position in the underscore
        e# string with the corresponding digit.
N       e# Push a newline.
AS*     e# Push ten spaces.
'^      e# Push a caret.

Java, 519 414 321 byte

static int f(int a,int b,int c){int i,j,k;for(i=-10;i<=10;i++)for(j=i+1;j<=10;j++)for(k=j+1;k<=10;k++){if(a*i+b*j+c*k==0&&i!=0&&j!=0&&k!=0){for(int q=0;q<21;q++){if(q==10+i)p(a);else if(q==10+j)p(b);else if(q==10+k)p(c);else p('_');}p("\n          ^\n");return 0;}}return 0;}static void p(Object a){System.out.print(a);}}

Nỗ lực đầu tiên của tôi tại golf.

Bạn có thể gọi nó với f(a,b,c). Hãy thử nó ở đây

EDIT: Sử dụng phương pháp kiểm tra izlin(a*i+b*j+c*k)==0

EDIT: Cảm ơn, J Atkin cho các đề xuất chơi golf.

Bình thường 67 58 53 49 byte

Điều này cảm thấy một chút về khía cạnh lớn đối với Pyth, nhưng tôi gần như không đủ quen thuộc với ngôn ngữ để có thể có được điều này nhỏ hơn nhiều. Sub 50 byte, cuối cùng tôi cũng hài lòng với điều này!

V.c-KrT-011Z3FY.pQIqs*VNYZjkm?}dN@YxNd\_K+*dT\^.q

Đầu vào được dự kiến ​​là một mảng các số nguyên, ví dụ [1,2,3]. Thử nó ở đây.

Giải thích:

V.c-KrT-011Z3FY.pQIqs*VNYZjkm?}dN@YxNd\_K+*dT\^.q
                                                       Implicit: Q = eval(input())
     rT-011                                            Create range from 10 to -10
    K                                                  Store in K
   -       Z                                           Drop 0 from the above
V.c         3                                          For N in (combinations of the above of size 3)
             FY.pQ                                     For Y in (permutations of input)
                     *VNY                              Multiply each element in N by the corresponding element in Y
                    s                                  Take the sum
                  Iq     Z                             If it's equal to zero:
                            m           K              For d in K (K = [10, ..., -10])
                             ?}dN                      Is d in N?
                                 @YxNd                 If so, get corresponding value from Y
                                      \_               Otherwise, get '_'
                          jk                           Join the resulting array into a string (implicit print)
                                         +*dT\^        Join 10 spaces and '^', implicit print
                                               .q      Break all loops and exit

Và cuối cùng, một số ví dụ đầu vào và đầu ra:

[1,1,1] ->
1__________1_______1_
          ^

[2,9,5] ->
2____5_________9_____
          ^

[9,8,5] ->
5____8______________9
          ^

C - 237 228 byte

i,j,k;f(a,b,c){char o[]="_____________________\n          ^";for(i=-10;i<9;i+=i+1?1:2){for(j=i+1;j<11;j+=j+1?1:2){for(k=j+1;k<11;k+=k+1?1:2){if((a*i+b*j+c*k)==0){o[i+10]=a+48;o[j+10]=b+48;o[k+10]=c+48;printf("%s",o);return;}}}}}

Bạn có thể gọi nó với f(a,b,c).

Hãy thử nó ở đây .

Kết quả ví dụ:

f(4,7,2):
4_____________7_2____
          ^         

f(3,1,5)
3____1___________5___
          ^       

Python 2.7 235 226 219 byte

def s(n,p=__import__("itertools").permutations):
 l=["_"]*21
 for p,q in[[(a,x+10),(b,y+10),(c,10-z)]for a,b,c in p(n,3)for x,y,z in p(range(1,11),3)if x!=y and a*x+b*y==c*z][0]:l[q]=`p`
 return`l`[2::5]+"\n"+" "*10+"^"

Kiểm tra nó với một số ví dụ cơ bản- (1,1,1),(1,2,1),(3,1,5),(4,7,2)kết quả trong-:

(1, 1, 1)
_______1___11________
          ^
(1, 2, 1)
_____1_____12________
          ^
(3, 1, 5)
________5__3_____1___
          ^
(4, 7, 2)
_2_________47________
          ^

Đầu ra cho tất cả các đầu vào có thể dán ở đây

PHP, 278 byte

Một giải pháp vũ phu sử dụng một loạt các vòng lặp lồng nhau và một vài thử nghiệm.

$p=explode(',',$argv[$i=1]);for(;$i<=10;$i++)for($j=1;$j<=10;$j++)
for($k=1;$k<=10;$k++)if($j-$k)for($l=0;$l<3;$l++){$q=array_shift($p);
if($i*$q==$j*$p[0]+$k*$p[1]){$o=str_repeat('_',21);$o[10-$i]=$q;$o[10+$j]=$p[0];
$o[10+$k]=$p[1];echo($o."\n          ^\n");}array_push($p,$q);}

Như mọi khi, hãy đặt nó vào một tệp (hãy đặt tên cho nó seesaw.php), nối các dòng (chia ở đây để dễ đọc), đặt điểm đánh dấu PHP ( <?php) ở đầu tệp (về mặt kỹ thuật, nó không phải là một phần của chương trình) và bạn ' lại tốt để đi

Một ví dụ về thực thi:

$ php seesaw.php 9,2,1
_________9_2_____1___
          ^
_________9__2__1_____
          ^
_________9_1__2______
          ^
________9_____2_____1
          ^
________9______2__1__
          ^
________9_____1__2___
          ^
________9___1_____2__
          ^
_______9_________1__2
          ^
____2______9_1_______
          ^
___2_______9___1_____
          ^
__2________9_____1___
          ^
_2_________9_______1_
          ^

Nó tạo và hiển thị tất cả các giải pháp (không có phản xạ), nhưng nó không loại bỏ các bản sao (khi các giá trị đầu vào chứa các bản sao).

Julia, 154 byte

f(a,b,c)=(x=replace(join(first(filter(p->p⋅[-10:-1,1:10]==0,permutations([a,b,c,zeros(Int,17)])))),"0","_");print(x[1:10]*"_"*x[11:20]*"\n"*" "^10*"^"))

Ungolfed + giải thích:

function f(a,b,c)
    # Create a 20-element array of the input with 17 zeros
    z = [a,b,c,zeros(Int,17)]

    # Get the set of all permutations of z such that the dot product
    # of the permutation with the distances is 0
    d = filter(p -> p ⋅ [-10:-1,1:10] == 0, permutations(z))

    # Join the first element of d into a string and replace all of
    # the zeros with underscores
    x = replace(join(first(d)), "0", "_")

    # Print the output
    print(x[1:10] * "_" * x[11:20] * "\n" * " "^10 * "^")
end

C, 252 (214) byte

Gọi với a, b, c làm đối số trên dòng lệnh.

e=48;main(_,v,x,y,z,a,b,c)char**v;{char s[]="_____________________\n          ^";x=*v[1]-e;y=*v[2]-e;z=*v[3]-e;for(a=-1;a+11;--a)for(b=-10;b-11;++b)_=a*x+b*y,!b|b==a|_%z?0:(c=-_/z,c&c<11&c>-11?s[a+10]=x+e,s[b+10]=y+e,s[c+10]=z+e,puts(s),exit(0):0);} 

Nếu chính có thể bị hủy bỏ, số byte giảm xuống còn 214 cho một hàm.

a,b,c;f(x,y,z){char s[]="_____________________\n          ^";for(a=-1;a+11;--a)for(b=-10;b-11;++b)!b|b==a|(a*x+b*y)%z?0:(c=-(a*x+b*y)/z,c&&c<11&&c>-11?s[a+10]=x+48,s[b+10]=y+48,s[c+10]=z+48,puts(s),b=10,a=-b:0);}

Cả hai sử dụng cùng một chiến lược đặt trọng lượng đầu tiên bên trái, sau đó quét dọc theo các vị trí trọng lượng thứ hai có thể và tính toán trọng lượng thứ ba. Điều này cho phép loại bỏ một vòng lặp bên trong.