Tháp sẽ cân bằng?

36

Giới thiệu

Cho một tháp ASCII và lực của gió, hãy viết chương trình hoặc chức năng để xác định xem tháp sẽ cân bằng hay nó sẽ rơi theo cách nào.

Ví dụ, tháp thứ nhất cân bằng nhưng tháp thứ hai rơi về phía bên trái.

  # #            # #
  ###            ### 
 ###            ### 
 # #            # # 
#####          ##### 
 ###            ### 
 ###              #

Đây là thử thách đầu tiên của tôi. Tôi hy vọng bạn thích nó.

Hướng

Tòa tháp bao gồm các khối kết nối được đại diện bởi #và tạo thành một vật thể cứng nhắc . Mỗi khối là một hình vuông có chiều rộng và chiều cao của một đơn vị và có mật độ không đổi. Có hai lực tác dụng lên tháp, trọng lượng của nó và lực gió. Tất cả các lực tác động lên từng khối riêng lẻ và đi qua tâm của khối.

  • Do trọng lượng của nó, mỗi khối có lực hướng xuống của một đơn vị tác động lên nó.
  • Ngoài ra, mỗi khối không có một khối khác liền kề với nó ở phía gió của nó có một lực tác động lên nó theo chiều ngang của hướng gió. Độ lớn của lực này được đưa ra như một đầu vào.
  • Hướng của gió được biểu thị bằng cờ ASCII ở đâu đó trong đầu vào. Sẽ có một cờ trong đầu vào khi và chỉ khi gió không bằng không. Cờ không ảnh hưởng đến bất kỳ lực lượng.

Cờ sẽ trông chính xác như nó xuất hiện bên dưới.

Flag design and corresponding wind direction:

 o~~        ~~o
 |~~        ~~|

--->        <---

Để làm rõ, tòa tháp là một vật thể rắn và sẽ không vỡ ra và không được gắn vào mặt đất. Tuy nhiên, chương trình của bạn nên tính toán các lực cho từng khối riêng lẻ để xác định xem tháp có cân bằng không.

Thí dụ

  o~~
  |~~
  # #              > > 
  ###              >## 
 ###              >##  
 # #              > >  
#####            >#### 
 ###              >##  
 ###              >##  

Wind force: 1    Wind direction: --->

Gió thổi phải và sẽ đẩy vào các khối được hiển thị với một >bên phải. Lưu ý rằng gió tác động vào bên trong các lỗ.

Giả sử góc dưới bên trái của tháp có tọa độ (0,0). Khoảnh khắc xung quanh chân trái của tòa tháp (0,0)là 71 đơn vị theo chiều kim đồng hồ để tháp không bị rơi sang trái. Khoảnh khắc xung quanh chân phải của tháp tại (0,3) là 8 đơn vị theo chiều kim đồng hồ nên tháp sẽ rơi phải.

Nếu gió thổi về phía bên trái, các khoảnh khắc tương ứng sẽ là 2 đơn vị theo chiều kim đồng hồ và 61 đơn vị ngược chiều kim đồng hồ tại cùng một điểm, do đó tháp sẽ cân bằng.

Đầu vào

  • Chương trình hoặc chức năng của bạn phải có hai đầu vào, một số thập phân và một chuỗi phân tách dòng mới.
  • Số thập phân sẽ lớn hơn 0 và biểu thị lực tác động của gió lên từng khối tiếp xúc như trong ví dụ.
  • Chuỗi sẽ đại diện cho tháp từ trên xuống dưới và có thể chứa khoảng trắng, #|o~ký tự và dòng mới. Bạn có thể tùy ý giả sử một dòng mới và / hoặc đệm tháp với các khoảng trắng ở cuối để tạo thành một hình chữ nhật.
  • Tháp sẽ có ít nhất một #cái ở hàng dưới cùng.
  • Bạn có thể nhập số và chuỗi theo thứ tự.
  • Nếu cường độ của lực gió là khác không, sẽ có một lá cờ ở đâu đó trong đầu vào, trên mặt đất hoặc được kết nối với tháp. Cờ sẽ có hình thức chính xác được hiển thị ở trên.
  • Các #khối sẽ tạo thành một hình dạng kết nối có thể chứa lỗ. Nói cách khác, tất cả các khối sẽ liền kề với một khối khác trừ khi chỉ có một khối.

Đầu ra

  • Một trong các ký tự B, Lhoặc R, tùy thuộc vào việc tháp sẽ cân bằng, rơi về bên trái (ngược chiều kim đồng hồ) hay rơi về phía bên phải (theo chiều kim đồng hồ).
  • Đầu ra có thể có một dòng mới tùy chọn.

Đây là môn đánh gôn ; quy tắc tiêu chuẩn và sơ hở áp dụng.

B Các trường hợp thử nghiệm:

Wind: 1
    ~~o
    ~~|
      # #
      ###
     ###
     # #
    #####
     ###
     ###

Wind: 0
##
# ##
###

Wind: 1.7
o~~
|~~
#
##

Wind: 0.768
      o~~
      |~~
      # #
      ###
     ###
     # #
    #####
     ###
     ###

Wind: 0.1
#
#
#
#
#
# o~~
# |~~

Wind: 0
#

Wind: 0
############

Wind: 144
               o~~
############   |~~

Wind: 0
#######
 ##
 #
 ##

Wind: 0
                ############
           ############
       ############
    ############
   ############
 ############
############

Wind: 41
                 ############
            ############
        ############
     ############
    ############
  ############     ~~o
 ############      ~~|

L Các trường hợp thử nghiệm:

Wind: 0
#####
   #


Wind: 42
                 ############
            ############
        ############
     ############
    ############
  ############     ~~o
 ############      ~~|

Wind: 4
########
    ###
 ~~o# ##
 ~~|#  #

Wind: 3
########
    ###
 o~~# ##
 |~~   #

R Các trường hợp thử nghiệm:

Wind: 1
      o~~
      |~~
      # #
      ###
     ###
     # #
    #####
     ###
     ###

Wind: 2
o~~
|~~
#

Wind: 0.001
                 ############
            ############
        ############
     ############
    ############
  ############     o~~
 ############      |~~

Wind: 145
               o~~
############   |~~

Wind: 1
#
#
#
#
#
# o~~
# |~~

Wind: 0.26
#######
 ##
 #   o~~
 ##  |~~

Giải pháp tham khảo (JavaScript)

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

function balanced(tower, wind) {
    var rows = tower.split('\n').reverse(); // Reverse so row index matches height of row.
    var height = rows.length;
    var leftEdge = rows[0].indexOf('#'); // Find bottom left corner of tower.
    var rightEdge = rows[0].lastIndexOf('#') + 1; // Find bottom right corner of tower.
    var leftMoment = 0, rightMoment = 0; // Moments around the bottoms corners of tower.
    wind *= tower.indexOf('~o')>-1 ? -1 : 1; // Find direction of the wind.

    // Sum the moments for each block in the tower.
    for (var i = height - 1; i >= 0; i--) {
        rows[i].split('').map(function(ch, index, arr) {
            if (ch=='#') {
                // If there's not a block toward the windward side of the current one.
                if ((wind < 0 && arr[index-1] != '#') || (wind > 0 && arr[index+1]!='#')) {
                    // Add moments from wind.
                    leftMoment += (i+0.5)*-wind;
                    rightMoment += (i+0.5)*-wind; 
                }

                leftMoment += leftEdge - (index + 0.5);
                rightMoment += rightEdge - (index + 0.5);
            }
        }, 0);
    }
    if (leftMoment > 0) return 'L';
    else if (rightMoment < 0) return 'R';
    else return 'B';
}

Bảng xếp hạng

Dưới đây là Stack Snippet để tạo cả bảng xếp hạng thông thường và tổng quan về người chiến thắng theo ngôn ngữ.

Để đảm bảo rằng câu trả lời của bạn hiển thị, vui lòng bắt đầu câu trả lời của bạn bằng một tiêu đề, sử dụng mẫu Markdown sau:

# Language Name, N bytes

nơi Nlà kích thước của trình của bạn. Nếu bạn cải thiện điểm số của mình, bạn có thể giữ điểm số cũ trong tiêu đề, bằng cách đánh bại chúng thông qua. Ví dụ:

# Ruby, <s>104</s> <s>101</s> 96 bytes

Nếu bạn muốn bao gồm nhiều số trong tiêu đề của mình (ví dụ: vì điểm của bạn là tổng của hai tệp hoặc bạn muốn liệt kê riêng các hình phạt cờ của thông dịch viên), hãy đảm bảo rằng điểm thực tế là số cuối cùng trong tiêu đề:

# Perl, 43 + 2 (-p flag) = 45 bytes

Bạn cũng có thể đặt tên ngôn ngữ thành một liên kết mà sau đó sẽ hiển thị trong đoạn trích bảng xếp hạng:

# [><>](http://esolangs.org/wiki/Fish), 121 bytes

Hiển thị đoạn mã

code-golf  ascii-art  physics 
— bộ mã hóa
nguồn
17
Chào mừng đến với PPCG; đây là một thử thách đầu tiên được viết một cách xuất sắc! :)
— tay nắm cửa

Câu trả lời:

2

JavaScript (ES6), 239 byte

Tôi đánh golf xuống thực hiện tài liệu tham khảo của tôi. Tôi đã có thể lưu byte bằng cách thay đổi vòng lặp for thành a map, sử dụng &&và ||ngắn mạch nếu các câu lệnh và sử dụng ,toán tử để khớp mọi thứ trên một câu lệnh để tránh trả về rõ ràng trong hàm.

(a,b)=>((c=a.split`
`.reverse(),d=c[f=g=0].indexOf`#`,e=c[0].lastIndexOf`#`+1),a.match`o~`&&(b*=-1),c.map((h,i)=>h.replace(/#/g,(j,k,l)=>(b>0&l[k-1]!='#'|b<0&l[k+1]!='#'&&(f+=(i+=0.5)*b,g+=i*b),f+=d-k-0.5,g+=e-k-0.5))),f>0?'L':g<0?'R':'B')

Nó vẫn có thể chơi golf này nhiều hơn. Đề nghị được chào đón.

— bộ mã hóa
nguồn
+1 tốt hơn nhiều so với giải pháp ngây thơ của tôi
— Conor O'Brien
1

JavaScript ES6, 297 293 byte

Về cơ bản là một phiên bản nén của việc thực hiện đã cho.

b=(n,e)=>{r=n.split`
`.reverse(),t=r.length,a=r[0].indexOf`#`,f=r[i=l=0].lastIndexOf`#`+1;e*=n.indexOf`~o`>-1?-1:1;for(d=t-1;d>=0;d--)r[d].split``.map((n,r,t)=>{(j="#")==n&&((0>e&&j!=t[r-1]||e>0&&j!=t[r+1])&&(i+=(d+.5)*-e,l+=(d+.5)*-e),i+=a-(r+.5),l+=f-(r+.5))},0);return i>0?"L":0>l?"R":"B"}

Bán mở rộng:

b = (n, e) => {
    r = n.split `
`.reverse(), t = r.length, a = r[0].indexOf `#`, f = r[i = l = 0].lastIndexOf `#` + 1;
    e *= n.indexOf `~o` > -1 ? -1 : 1;
    for (d = t - 1; d >= 0; d--) r[d].split ``.map((n, r, t) => {
        (j = "#") == n && ((0 > e && j != t[r - 1] || e > 0 && j != t[r + 1]) && (i += (d + .5) * -e, l += (d + .5) * -e), i += a - (r + .5), l += f - (r + .5))
    }, 0);
    return i > 0 ? "L" : 0 > l ? "R" : "B"
}
— Conor O'Brien
nguồn
Khi sử dụng trang web của chúng tôi, bạn xác nhận rằng bạn đã đọc và hiểu Chính sách cookie và Chính sách bảo mật của chúng tôi.
Licensed under cc by-sa 3.0 with attribution required.