Đây là lần đầu tiên trong một loạt, thứ hai là Hai con đường được phân chia trong một gỗ màu vàng (phần 2)

Thử thách này được lấy cảm hứng từ bài thơ nổi tiếng của Robert Frost, "Con đường chưa đi":

Hai con đường tách ra trong một khu rừng vàng,
Và xin lỗi tôi không thể di chuyển cả
Và là một du khách, lâu tôi đứng
Và nhìn xuống một xa như tôi có thể
Để nơi nó cúi trong những bụi cây;

Sau đó, người khác, cũng như công bằng,
Và có lẽ có yêu cầu tốt hơn,
bởi vì nó là cỏ và muốn mặc;
Mặc dù về việc đi qua đó
đã mặc chúng thực sự giống nhau,

Và cả buổi sáng hôm đó đều nằm
trong lá, không bước nào có màu đen.
Oh, tôi giữ cái đầu tiên cho một ngày khác!
Chưa biết con đường dẫn đến con đường nào,
tôi nghi ngờ liệu mình có nên quay lại không.

Tôi sẽ nói điều này với một tiếng thở dài Ở
đâu đó và mọi lứa tuổi:
Hai con đường rẽ vào một khúc gỗ, và tôi -
tôi đã đi một con đường ít đi qua,
và điều đó đã tạo nên sự khác biệt.

Lưu ý dòng thứ hai đến dòng cuối cùng , I took the one less traveled by,.

Thử thách thực tế của bạn

Bạn sẽ nhận đầu vào ở dạng như:

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

và bạn phải tìm con đường mỏng hơn.

Con đường bắt đầu từ phía dưới với a #. Hai con đường khác, luôn luôn chấm dứt ở hàng trên cùng, là những con đường bạn phải kiểm tra. Con đường dày nhất được đi qua nhiều nhất, và do đó nó không phải là điều bạn muốn. Một cái khác là ít đi du lịch nhất, và đó là một trong những bạn muốn.

Đầu ra

Chương trình / chức năng của bạn phải xuất một trong 2 giá trị riêng biệt (ví dụ: 0 hoặc 1, đúng hoặc sai), một cho mỗi vị trí có thể của đường không được thực hiện. Ví dụ: bạn có thể xuất 0 nếu đường không được đặt ở bên trái đường đã lấy và 1 nếu không, hoặc bạn có thể xuất chuỗi "trái" hoặc "phải", đúng, sai, v.v.

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

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

Có thể xuất "đúng".

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

Có thể xuất "đúng".

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

Có thể xuất "đúng".

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

Có thể xuất "đúng".

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

Có thể xuất "trái"

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

Có thể xuất "trái"

Ghi chú

• Đây là môn đánh gôn , vì vậy câu trả lời ngắn nhất bằng byte sẽ thắng
• Sơ hở tiêu chuẩn bị cấm
• Bạn phải chỉ định kết quả đầu ra của mình cho "trái" và "phải" và chúng phải khác biệt
• Đầu vào sẽ là một chuỗi lớn và có thể có bất kỳ số lượng dòng nào
• Bạn không cần phải lo lắng về đầu vào hợp lệ.
• Con đường luôn có hình chữ Y, vì vậy bạn chỉ cần nhìn vào đỉnh.
• Có câu hỏi nào không? Bình luận dưới đây:

Số byte thấp nhất sẽ thắng!

CJam , 1 byte

r

rputs chuỗi đầu tiên của ký tự không phải khoảng trắng liền kề từ STDIN trên stack, vì vậy bản in này ##cho trái và #cho đúng .

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

JavaScript (ES6), 19 12 byte

Biên tập:

Một phiên bản golf hơn là

a=>a.trim[1]

Trả về #cho bên phải và một không gian cho bên trái.

Nguyên:

a=>a.trim()[1]=='#'

Giải trình

Ung dung :

function(input) {
  return input.trim().charAt(1) === '#';
};

Điều đầu tiên mà chức năng này thực hiện là loại bỏ khoảng trắng ở đầu và cuối của đầu vào. Điều này có nghĩa là nhân vật đầu tiên luôn luôn #. Sau đó, tôi kiểm tra ký tự thứ hai (JavaScript bắt đầu từ 0) và xem nó có phải là #ký tự không. Điều này trả về một boolean. Nếu đường dẫn là rightnó true, nếu nó còn lại, nó sẽ trở lại false.

Làm thế nào tôi chơi golf

Trong ES6 có một tốc ký hàm ẩn danh gọi là hàm mũi tên . Điều này có nghĩa là tôi có thể lấy chức năng trình bao bọc của mình và biến nó thành:

input => ...;

Do các quy tắc của các hàm mũi tên, nó sẽ trả về phần còn lại của mã. Từ đó tôi chuyển đổi charAt(1)thành [1]một cách ngắn hơn, mặc dù không được khuyến khích . Sau đó tôi lấy ===và biến nó thành ==. Mặc dù chúng khác nhau trong trường hợp này nhưng điều đó không thành vấn đề. Cuối cùng, tôi đổi tên inputđể avà loại bỏ tất cả các khoảng trắng.

Đầu ra phải và trái

Mặc dù câu đố không thực sự cần chương trình xuất ra phải và trái, đây là một ví dụ về các đầu ra khác:

a=>a.trim()[1]=='#'?'right':'left'

Phần duy nhất được thêm vào là ?'right':'left'. Điều này tạo ra một toán tử ternary , một câu lệnh if cô đọng, điều này có nghĩa là mã (không được mã hóa) bằng *:

function(input) {
  let output = input.trim().charAt(1) === '#';
  if(output) {
    return 'right';
  } else {
    return 'left'
  }
};

Thí dụ

// Function assignment not counted in byte count
let f =
a=>a.trim()[1]=='#'

<textarea placeholder="Put path in here" id="path" rows="10" style="width:100%"></textarea>
<button onclick="document.getElementById('result').textContent = f(document.getElementById('path').value)">Submit</button>
<p id="result"></p>

Bình thường, 2 byte

hc

Đầu ra #cho trái và ##phải.

Dùng thử trực tuyến

Giải trình

hc
 cQ     Split the (implicit) input on whitespace.
h       Get the first part.

Acc !! , 30 byte

Vì cách Acc !! nhận đầu vào, nó sẽ cho đầu ra sau khi chỉ cần nhập một dòng đầu vào. Nhưng nếu bạn đưa đầu vào vào hoặc chuyển hướng nó từ một tệp, bạn không nên nhận thấy sự khác biệt.

Count i while 35-N {
}
Write N

Lấy đầu vào từ stdin. Đầu ra nếu đường bên trái ít đi hoặc #nếu đường bên phải ít đi. Hãy thử trực tuyến!

Giải trình

Nđọc giá trị ASCII của một ký tự từ stdin mỗi khi nó được tham chiếu. Chúng tôi lặp trong khi 35-Nlà sự thật; đó là, trong khi 35-N != 0hoặc N != 35. Do đó, khi vòng lặp thoát, chúng ta vừa đọc #ký tự đầu tiên trên dòng. Các ký tự tiếp theo sau đó được đọc Nvà viết lại thành stdout với Write.

Võng mạc, 5 byte

Đầu ra 1nếu phải, 0nếu trái.

^ *##

Dùng thử trực tuyến

Nếu các giá trị cho kết quả dương tính không phải là khác biệt (5 byte):

Xuất ra một số nguyên dương nếu phải, không nếu trái.

## +#

Dùng thử trực tuyến

Ngôn ngữ công thức ghi chú của IBM / Lotus, 37 35 26 byte

Chỉnh sửa Tôi luôn quên rằng @Likevới các ký tự đại diện rẻ hơn 2 byte so với @Contains.

Chỉnh sửa 2 Trên thực tế không cần @ifvì nó chỉ in 1hoặc 0tùy thuộc vào việc công thức có kết quả @Truehay không @False.

@Like(@Left(a;"##");"%#%")

Công thức tính toán trường. Đơn giản chỉ cần lấy mọi thứ ở bên trái của cái đầu tiên ##nó tìm thấy trong trường avà nếu có một #đầu ra trong nó thì đầu ra 1bên trái 0cho đầu ra bên phải.

Cảm ơn @DavidArchibald, đây là một giải pháp cho 22 byte. Vì tôn trọng giải pháp Davids, tôi sẽ không đăng nó làm câu trả lời chính.

@Left(@Trim(a);2)="##"

Điều này đầu ra 1cho bên phải và 0bên trái.

Pip , 8 6 byte

a~`#+`

Đưa đầu vào dưới dạng đối số dòng lệnh (sẽ cần trích dẫn và thoát các dòng mới khi chạy từ một dòng lệnh thực tế). Đầu ra #nếu đường bên trái ít đi và ##nếu đường bên phải ít đi. Hãy thử trực tuyến!

Giải trình

Điều này sử dụng toán tử regex đầu tiên được thêm vào gần đây của Pip.

a         First cmdline arg
 ~        Regex match the first instance of...
  `#+`    ...one or more #s (i.e. a cross-section of the left-hand road)
          Print (implicit)

Giải pháp regex đơn giản (một cổng của câu trả lời Retina của mbomb007 ) là 9 byte:

`^ +##`Na

Chip , 7 byte

AZ~S
at

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

Đầu ra 0x0cho trái, và 0x1phải. (TIO bao gồm cờ -vđể bạn có thể thấy các giá trị nhị phân trong stderr. Để xem đầu ra trong ASCII, e*fcó thể được thêm vào cuối dòng đầu tiên.)

Chip hoạt động trên các bit riêng lẻ trong một luồng byte, điều này thực sự làm cho nó khá tốt trong vấn đề cụ thể này.

Alà bit có ý nghĩa nhỏ nhất của byte đầu vào và '#' là ký tự duy nhất của đầu vào mà bit này được đặt. Khi bit này được bắt gặp lần đầu tiên, chúng tôi đã đạt đến '#' đầu tiên của dòng đầu tiên.

Z sự chậm trễ đó báo hiệu cho một chu kỳ, do đó chúng ta đang xem xét ký tự tiếp theo.

thiện được kích hoạt, có nghĩa là chấm dứt thực hiện sau khi chu trình này được hoàn thành. Chúng ta không cần nhìn xa hơn chiều rộng của con đường đầu tiên.

~Striệt tiêu đầu ra cho tất cả các chu kỳ trừ cái cuối cùng. Nếu điều này không có ở đây, chúng tôi sẽ nhận được một đầu ra trên mỗi chu kỳ.

ađặt giá trị hiện tại của các lân cận của nó (chỉ Atrong trường hợp này) vào bit có trọng số thấp nhất của byte đầu ra.

Tất cả điều này có nghĩa là chúng tôi nhận được 0x1nếu '#' đầu tiên ngay lập tức được theo sau bởi '#' khác, và 0x0nếu không.

C, 35 byte

f(char*s){while(35^*s++);return*s;}

Ý tưởng tương tự như câu trả lời của PragmaticProgrammer : tìm cái đầu tiên #và xuất ra cái gì xuất hiện sau nó - #cho "bên phải" và <space>cho "bên trái".

C (kẽ hở), 16 byte

Theo các trường hợp thử nghiệm, có vẻ như đường bên trái luôn chính xác là một khoảng trống từ lề trái. Vì thế...

#define f(s)2[s]

Mẻ, 46 byte

@set/ps=
@for %%a in (%s%)do @echo %%a&exit/b

Đọc một dòng từ STDIN, phân tách nó trên khoảng trắng và in ra từ đầu tiên, do đó, đầu ra #cho trái và ##phải. Nếu một mảng các tham số dòng lệnh được trích dẫn có thể chấp nhận được, thì với 36 byte:

@for %%a in (%~1)do @echo %%a&exit/b

Bỏ yêu cầu đối số đầu tiên để nó sẽ được phân chia trên khoảng trắng và in từ đầu tiên.

Python 2, 21 byte

Dùng thử trực tuyến

lambda S:S.split()[0]

Đầu ra #cho trái và## phải

Võng mạc , 5 byte

!1`#+

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

Một giải pháp 5 byte thay thế. In #cho trái và ##phải. Ý tưởng là để khớp tất cả các lần chạy của #s ( #+) và print ( !) chỉ lần đầu tiên trong số chúng ( 1).

Haskell, 21 byte

f n=snd$span(==' ')n!!1

hoặc theo kiểu không có điểm:

(!!1).snd.span(' '==)

"#" có nghĩa là phải và "" có nghĩa là trái

Hàm chỉ lấy một chuỗi, bỏ các khoảng trắng bắt đầu, và sau đó, nó lấy ký tự thứ hai (khoảng trắng nếu bên trái mỏng và # nếu bên trái dày)

EDIT: Đã lưu ba byte nhờ Laikoni và nimi!

Brainfuck, 32 byte

+[>,>+++++[<------>-]<--[,.>>]<]

Ung dung:

+[                       while 1
>,>+++++[<------>-]<--     3 if hash; 0 if space
[,.>>]                     print next char and break iff current char is hash
<]

In #cho bên phải và bên trái.

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

Perl 5 , 8 + 1 = 9 byte

die$F[0]

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

Chạy với -a (1 byte hình phạt).

Đầu ra là (trong đó tên tệp là tên tệp của tập lệnh) nếu đường bên trái ít đi hoặc# at filename line 1, <> line 1## at filename line 1, <> line 1 nếu đường bên phải ít đi.

Giải trình

Các -atùy chọn tự động đọc đầu vào và chia tách nó thành các cột xung quanh khoảng trắng, bỏ qua khoảng trắng hàng đầu. Như vậy, mốc thời gian đầu tiên là những gì chúng ta cần; rằng nhân $F[0]. Nó cũng đặt chương trình trong một vòng lặp ngầm mà chúng ta không muốn. Tuy nhiên, việc sử dụng diecho phép chúng ta xuất ra một chuỗi và thoát khỏi vòng lặp ẩn cùng một lúc (và không có nhiều ký tự hơn say, cách thông thường hơn để in một chuỗi).

C 54 byte

char*strchr();char c(char*s){return*(strchr(s,35)+1);}

C ++ 58 byte

#include<cstring>
char c(char*s){return*(strchr(s,35)+1);}

Vì OP chỉ định nó có thể là một "chương trình / chức năng", tôi đã chọn viết một hàm để lưu các ký tự. Tuy nhiên, tôi vẫn bao gồm câu lệnh "#include" và ngắt dòng đi kèm trong số lượng ký tự vì chúng được yêu cầu để biên dịch hàm.

Đầu ra

Trả về một " "ký tự khoảng trắng để chỉ bên trái hoặc "#"ký tự băm để chỉ bên phải.

Giải trình

Hàm strchr () đi theo một chuỗi đã cho và trả về một con trỏ đến lần xuất hiện đầu tiên của một ký tự được chỉ định. Nó có một tình trạng quá tải chấp nhận một số nguyên làm đối số thứ hai trái ngược với char giúp tôi tiết kiệm 1 ký tự. Ví dụ: '#' có thể được thay thế bằng 35. Sau đó, tôi thêm một con trỏ được trả về từ hàm để lấy ký tự ngay sau đó và bỏ qua nó, sau đó trả về char kết quả.

Ghi chú

Tôi cũng muốn nhân cơ hội này để chính thức bày tỏ sự khó chịu của mình tại Visual Studio tự động định dạng mã của tôi khi tôi đang cố gắng chơi gôn (╯ ° □ ° ┻ ┻ ┻.

Chỉnh sửa: Cảm ơn Ray vì đã chỉ ra một số khác biệt trong C và C ++ và nơi tôi có thể lưu các ký tự <3.

JavaScript (ES6), 37 byte

p=s=>/^ *#( |$)/.test(s.split("\n")[0])

Giải trình:

plà một hàm trả về truenếu đường ít đi qua nằm bên trái và sai khác. Đây là câu trả lời đầu tiên của tôi trên trang web này, vì vậy nó có thể được đánh gôn nhiều hơn (có thể là regex.)

Nó hoạt động bằng cách lấy dòng trên cùng của đầu vào và xem liệu nó có khớp với regex không /^ *#( |$)/(bắt đầu chuỗi, bất kỳ khoảng trắng nào, # và khoảng trắng hoặc cuối chuỗi.)

Điều này chỉ để cung cấp cho mọi người làm rõ về định dạng và tạo ý tưởng. Tôi chắc chắn rằng nó có thể được đánh bại và chơi gôn hơn nữa. Chúc bạn chơi golf vui vẻ!

p=s=>/^ *#[^#]/.test(s.split("\n")[0])

<textarea rows = "8" cols = "8" oninput = "console.log(p(this.value))"></textarea>

Japt , 3 byte

x

(2 byte cho -g1cờ) Đầu ra #cho bên phải và khoảng trắng cho bên trái. Dựa trên câu trả lời JavaScript của David Archibald.

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

Excel, 17 byte

=left(trim(A1),2)

Giả sử đầu vào trong ô A1 .

Trả về ##bên phải và #( #và không gian) cho bên trái.

Dyvil , 12 byte

s=>s.trim[1]

Giải trình:

s=>          // lambda expression
   s.trim    // removes leading (and trailing) whitespace
         [1] // gets the second character

Sử dụng:

let f: String -> char = s=>s.trim[1]
print f('...')

Trả về (khoảng trắng) cho trái và #phải.

Java 7, 166 66 63 52 43 byte

int c(String s){return s.trim().charAt(1);}

Đầu ra 35cho phải và 32trái.
Dựa trên @Clashsoft Dyvil câu trả lời 's .

Giải trình:

int c(String s){   // Method with String parameter and integer return-type
  return s.trim()  //  Remove leading and trailing whitspaces
   .charAt(1);     //  and return the second character (as int value)
}                  // End of method

Mã kiểm tra:

class M{
  static int c(String s){return s.trim().charAt(1);}

  public static void main(String[] a){
    System.out.println(c(" ##    #\n  ##  #\n   ###\n    #\n    #\n    #"));
    System.out.println(c(" ##  #   \n  ## #  \n   ###\n    ##\n     #\n     #\n     #"));
    System.out.println(c(" ##  #   \n  ## #  \n   ###\n    ##\n   # \n  #  \n #   "));
    System.out.println(c(" ##   #  \n  ## #  \n   ###\n    #\n   # \n  #  \n  #  "));
    System.out.println(c(" #    ## \n  #  ## \n   ###\n    #\n   # \n  #  \n  #  "));
    System.out.println(c(" #    ## \n  #  ## \n   ###\n    #\n     #\n     #\n     #"));
  }
}

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

Đầu ra:

35
35
35
35
32
32

Befunge 98, 11 byte

-!jv~'
@.~<

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

In 32cho bên trái và 35bên phải, cả hai chỉ có một dấu cách.

Giải trình

-!jv      This is a no-op the first time through, but used later

    ~'    Pushes the ASCII value of the next character, and pushes 32
-!        Subtracts the 2, and nots. If the character was a space, the top will be 1
  jv      Goes to the second line if the character was not a space

  ~<      Pushes the next characer's ASCII value
 .        Prints it (32 for " " and 35 for "#")
@         Ends the program

Một mẹo tôi đã sử dụng là đặt cái -!jvđầu tiên, mặc dù nó không làm gì cả. Điều này cho phép cả hai tôi thoát khỏi không gian sau 'và lưu một số phần đệm. Với cái cuối cùng này, mã sẽ là

~' -!jv
   @.~<

cho 15 byte.

Ruby, 20 byte

->r{r.strip[1]==' '}

Trả về true cho trái, false cho phải.