Đưa ra một chuỗi trong đó dòng đầu tiên chứa khoảng trắng và một khoảng thời gian ( ., "quả bóng"), theo sau là dòng chứa khoảng trắng, dấu gạch chéo ( /) và dấu gạch chéo ngược ( \), xác định cột nào bóng sẽ hạ cánh sau khi rơi từ vị trí bắt đầu . Mỗi /lần di chuyển nó sang bên trái 1 cột và mỗi lần \di chuyển nó sang bên phải 1 cột.

Đầu vào mẫu

    .
  /   \  \
    /   /
 \   \/  \
   \   /\
    \ /\  \
     \    /

Sản lượng mẫu

Quả bóng bắt đầu trong cột 5, chạm /vào dòng 3, sau đó ba \bóng trên dòng 5 đến 7 cho vị trí cuối cùng là:

7

Lưu ý rằng các cột được lập chỉ mục 1, chủ yếu là để thống nhất với các quy ước soạn thảo văn bản.

Trường hợp cạnh

Nếu quả bóng chạm /vào cột đầu tiên, nó sẽ bị kẹt vĩnh viễn trong cột không tồn tại 0. Chương trình của bạn sẽ xử lý chính xác điều này bằng cách in 0.

Nếu quả bóng chạm vào một trong hai phía của một \/mẫu, kết quả là không xác định. Chương trình của bạn được phép chấm dứt không có đầu ra, lặp vô hạn hoặc in thông báo lỗi (giải pháp của tôi in -1), nhưng nó không được in bất cứ điều gì có thể được coi là đầu ra hợp lệ.

Nếu quả bóng chạm vào dấu gạch chéo trái trong một \\mẫu, nó sẽ kết thúc trực tiếp bên dưới dấu gạch chéo phải, chứ không phải bên phải của nó. Giải pháp ban đầu tôi hình dung là dễ mắc phải sai lầm này, vì vậy đừng đi vào con đường đó!

Có thể có hoặc không có khoảng trắng sau .hoặc cuối cùng /hoặc \trên mỗi dòng. Chương trình của bạn không nên dựa vào phần đệm như vậy có sẵn. Trên một lưu ý tương tự, có thể có hoặc không có bất kỳ dòng nào sau dòng đầu tiên.

Bạn có thể giả định rằng dòng đầu tiên sẽ có không hoặc nhiều khoảng trắng và chính xác là một khoảng trắng .. Các dòng tiếp theo, nếu có, sẽ có 0 hoặc nhiều khoảng trắng và 0 hoặc nhiều dấu gạch chéo.

Chi tiết thực hiện

Chương trình của bạn có thể đọc từ một tệp (được chỉ định làm đối số dòng lệnh) hoặc đọc từ đầu vào tiêu chuẩn, một cách thuận tiện.

Chương trình của bạn phải xuất một số duy nhất thành đầu ra tiêu chuẩn. (Có, một dòng mới kéo dài là tốt. Có, số có thể có nhiều hơn một chữ số.)

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

Đầu vào:

.

Đầu ra:

1

Lưu ý rằng đầu vào ở đây chính xác là một byte. Đây là trường hợp nhỏ nhất bạn sẽ có thể xử lý.

Đầu vào:

 .
 \
  \
   \
    \

Đầu ra:

 6

Lưu ý rằng không có khoảng trắng sau các dấu gạch chéo này.

Đầu vào:

  .
  /
 /\\  /  \
//\ \/// //
\\/ \/\ /\/

Đầu ra:

0

Đầu vào:

  .
/ / /
 \\\
  /\\
 /   \

Đầu ra:

1

Đầu vào:

   .


 \
       /
/

      \

Đầu ra:

4

Đầu vào:

 .
 \

\/\/\/

Đầu ra:

(anything but a nonnegative number)

Đóng nhận xét

Câu hỏi này tương tự như Mô phỏng một máy tính loại bi-a (dựa trên trọng lực) , nhưng đơn giản hơn đáng kể, vì vậy hy vọng nó sẽ thu được nhiều sự quan tâm hơn.

Tôi có một giải pháp 169 ký tự trong Python. Dù vậy, tôi chắc chắn rằng những người chơi golf tài năng ở đây có thể xé nát kỷ lục đó thành từng mảnh. : ^)

Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất trong các ký tự sẽ được chấp nhận vào cuối tháng!

Con trăn, 143B

import sys
for l in sys.stdin:
 a=l.find('.')
 if a>-1:F=a
 elif F>-1: 
    if'\\/'in l[F-1:F+2]:z
    F+={'\\':1,'/':-1}.get((l+' '*F)[F],0)
print F+1

Sử dụng thủ thuật thụt lề không gian / tab. Tôi chưa làm gì đặc biệt thông minh ở đây. Flà chỉ số hiện tại, llà dòng hiện tại; zkhông được xác định để nó ném một ngoại lệ, chắc chắn không phải là số nguyên dương, xử lý \/tình huống.

05AB1E , 37 byte

¶¡ð«ć'.ksvU…/ \yXD>‚èJD„\/Qiõqëнk<X+]>

Đầu vào dưới dạng một chuỗi nhiều dòng. Đầu ra \/nếu bóng bị kẹt.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

¶¡                       # Split the (implicit) input-string on newlines
                         # (work-around instead of `|`, because it will stop at empty lines)
  ð«                     # Add a trailing space to each line (work-around because indexing
                         # -1 in 05AB1E will wrap around to the other side)
    ć                    # Extract head; pop and push the remainder-lines and first line
                         # separated to the stack
     '.k                '# Get the 0-based index of "." in this first line
s                        # Swap to get the remainder-list of lines
v                        # Loop over each line `y`:
 U                       #  Pop and store the top value (the index) in variable `X`
       X                 #  Push the current index `X`
        D>               #  Duplicate it, and increase the copy by 1
          ‚              #  Pair to [X, X+1]
      y    è             #  Index both of those into the current line `y`
            JD           #  Join the two characters together, and duplicate it
              „\/Qi      #  If it's equal to "\/":
                   q     #   Stop the program
                         #   (after which the string is output implicitly as result)
                  ë      #  Else:
                   н     #   Only leave the first character (at index `X`)
  …/ \              k    #   Get its 0-based index in string "/ \"
                     <   #   Decrease it by 1
                      X+ #   And add it to `X`
]                        # After the loop:
 >                       # Increase the top of the stack (`X`) by 1
                         # (after which it's output implicitly as result)

CJam, 61 byte

qN/('.#)\_:,0+:e>f{' e]" /"f#0\+}{1$1$=\@2$-_@=@[\]$[W1]#/z}/

Nếu quy tắc liên quan \/được dỡ bỏ (và chúng tôi không bắt buộc phải xử lý nó), điều này có thể được rút ngắn xuống còn 41 byte:

qN/('.#)\_:,:e>f{' e]" /"f#0\+0+}{1$=-}/

Java 10, 213 208 190 byte

s->{int r=s.indexOf('.'),c;for(var x:s.split("\n")){for(;r>x.length()-2;x+=" ");c=x.charAt(r);if(c==46)continue;r/=c>47&x.charAt(r+1)==47?0:1;r+=c<33?0:c<48?-1:1;if(r<0)return 0;}return-~r;}

Ném một bộ phận bởi lỗi không khi chúng ta bị mắc kẹt bên trong a \/.

-5 byte nhờ @EdgyNerd .

Giải trình:

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

s->{                             // Method with String parameter and integer return-type
  int r=s.indexOf('.'),          //  Get the index of the dot on the first line
      c;                         //  Temp integer
  for(var x:s.split("\n")){      //  Split the input by newlines, and loop over the lines:
    for(;r>x.length()-2;x+=" "); //   Append trailing spaces if necessary
    c=x.charAt(r);               //   Get the character at the current index of this line
    if(c==46)                    //   If this is the first line (the char is the dot)
      continue;                  //    Continue to the next iteration of the loop
    r/=c>47&x.charAt(r+1)==47?   //   If we're stuck in a `\/`
        0                        //    Divide by 0 to exit the function with an error
       :1;                       //   Else: divide by 1 as no-op
    r+=c<33?                     //   If the current character is a space:
        0                        //    `r` remains at the same index
       :c<48?                    //   Else if it's a `/`:
        -1                       //    Index `r` is decreased by 1
       :                         //   Else (if it's a `\`):
        1;                       //    Index `r` is increased by 1
    if(r<0)                      //   If `r` is now -1:
      return 0;}                 //    Return 0
  return-~r;}                    //  After the loop: return the index `r` + 1

Python 3 , 124 byte

import sys
for l in sys.stdin:i=('.'in l)*l.find('.')or(i<0)*i-2*('\\/'in l[i-1:i+2])or' \\'.find((l+i*' ')[i])+i
print(i+1)

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

Cũng hoạt động trong Python 2.

Giải trình

for l in sys.stdin:i=          # Change value i for each line in the input
('.'in l)*l.find('.')          # Set i to (0-indexed) dot position if present
or(i<0)*i                      # Keep i fixed if it is below zero
-2*('\\/'in l[i-1:i+2])        # Set i to -2 if \/ trap is encountered
or' \\'.find((l+i*' ')[i])+i   # Else: move position based on character
print(i+1)                     # Print final 1-indexed position

J , 95 byte

[:>[:(<"1@|.@}.([:(1&{+_*0>[:*/2-/\])(]+{~ ::])^:(<3))&.>/@,2<@i.~{.)[:(0,'/ \'<:@i.]);._1 LF,]

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

Trả lại vô cùng _khi bóng bị mắc kẹt. Mất nhiều byte xử lý trường hợp đặc biệt đó. Mặt khác, nó ít nhiều làm giảm các hàng đơn giản. Chắc chắn có thể được chơi golf hơn nữa.