นี่เป็นครั้งแรกในซีรีส์ที่สองคือถนนสองสายที่แยกจากกันในป่าสีเหลือง (ตอนที่ 2)

ความท้าทายนี้ได้รับแรงบันดาลใจจากบทกวีที่มีชื่อเสียงของ Robert Frost "The Road Not Taken":

ถนนสองสายแยกกันด้วยไม้สีเหลือง
และขอโทษที่ฉันไม่สามารถเดินทางได้ทั้งคู่
และเป็นนักเดินทางคนหนึ่งฉันยืน
และมองดูถนนที่ไกลที่สุดเท่าที่ฉันจะ
ไปได้

จากนั้นก็เอาคนอื่น ๆ อย่างยุติธรรม
และอาจมีสิทธิที่ดีกว่า
เพราะมันเป็นหญ้าและต้องการสวม;
แม้ว่าจะผ่านไปที่นั่นได้
สวมใส่พวกเขาเกี่ยวกับสิ่งเดียวกัน

และในเช้าวันนั้นทั้งสองนอนหลับอย่างเท่าเทียมกัน
ในใบไม้ที่ไม่มีขั้นบันไดมีสีดำเหยียบย่ำ
โอ้ฉันเก็บไว้วันแรกสำหรับอีกวัน!
ยังรู้วิธีนำไปสู่
ฉันสงสัยว่าฉันควรจะกลับมา

ฉันจะบอกสิ่งนี้ด้วยการถอนหายใจ
ที่ไหนสักแห่งในยุคนี้:
ถนนสองสายแยกจากกันในป่าและฉัน -
ฉันเอาเส้นทางที่เดินทางน้อยกว่า
และนั่นทำให้เกิดความแตกต่าง

สังเกตบรรทัดที่สองถึงบรรทัดสุดท้ายI took the one less traveled by,.

ความท้าทายที่แท้จริงของคุณ

คุณจะป้อนข้อมูลในรูปแบบดังนี้:

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

และคุณต้องไปตามถนนทินเนอร์

ถนนเริ่มที่ด้านล่างด้วย a #ถนนเริ่มต้นที่ด้านล่างด้วยถนนสองสายอื่น ๆ ซึ่งสิ้นสุดที่แถวบนเสมอคือถนนที่คุณต้องตรวจสอบ ถนนที่มีความหนาที่สุดคือเส้นทางที่เดินทางมากที่สุดดังนั้นจึงไม่ใช่สิ่งที่คุณต้องการ อีกคนหนึ่งเดินทางน้อยที่สุดและเป็นอีกคนที่คุณต้องการ

เอาท์พุต

โปรแกรม / ฟังก์ชั่นของคุณจะต้องส่งออกหนึ่งใน 2 ค่าที่แตกต่าง (เช่น. 0 หรือ 1, จริงหรือเท็จ), หนึ่งค่าสำหรับแต่ละตำแหน่งที่เป็นไปได้ของถนนที่ไม่ได้ถ่าย ตัวอย่างเช่นคุณสามารถส่งออก 0 หากถนนที่ไม่ได้อยู่ทางด้านซ้ายของถนนและ 1 เป็นอย่างอื่นหรือคุณสามารถส่งออกสตริง "ซ้าย" หรือ "ขวา", จริง, เท็จ ฯลฯ

กรณีทดสอบ:

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

อาจเอาต์พุต "ถูกต้อง"

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

อาจเอาต์พุต "ถูกต้อง"

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

อาจเอาต์พุต "ถูกต้อง"

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

อาจเอาต์พุต "ถูกต้อง"

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

อาจส่งออก "ซ้าย"

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

อาจส่งออก "ซ้าย"

หมายเหตุ

• นี่คือโค้ดกอล์ฟดังนั้นคำตอบที่สั้นที่สุดในหน่วยไบต์ชนะ
• ช่องโหว่มาตรฐานต้องห้าม
• คุณต้องระบุผลลัพธ์ของคุณสำหรับ "ซ้าย" และ "ขวา" และพวกเขาจะต้องแตกต่างกัน
• อินพุตจะเป็นหนึ่งสตริงใหญ่และอาจมีจำนวนบรรทัดใด ๆ
• คุณไม่จำเป็นต้องกังวลเกี่ยวกับอินพุตที่ถูกต้อง
• ถนนเป็นรูปตัว Y เสมอดังนั้นคุณต้องดูที่ด้านบนเท่านั้น
• มีคำถามอะไรไหม? ความคิดเห็นด้านล่าง:

จำนวนไบต์ต่ำสุดชนะ!

CJam , 1 ไบต์

r

rใส่สตริงแรกของอักขระที่ไม่ใช่ช่องว่างที่อยู่ติดกันจาก STDIN บนสแต็กดังนั้นสิ่งนี้จะพิมพ์##สำหรับซ้ายและ#เพื่อทางด้านขวา

ลองออนไลน์!

JavaScript (ES6), 19 12 ไบต์

แก้ไข:

รุ่น golfed เพิ่มเติมคือ

a=>a.trim[1]

ผลตอบแทน #ทางด้านขวาและช่องว่างทางด้านซ้าย

เดิม:

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

คำอธิบาย

Ungolfed :

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

สิ่งแรกที่ฟังก์ชั่นนี้ทำคือลบพื้นที่สีขาวที่จุดเริ่มต้นและจุดสิ้นสุดของอินพุต #ซึ่งหมายความว่าตัวอักษรตัวแรกอยู่เสมอ จากนั้นฉันจะตรวจสอบอักขระตัวที่สอง (JavaScript เริ่มต้นที่ 0) และดูว่าเป็น#ตัวอักษรหรือไม่ ส่งคืนบูลีน หากเส้นทางที่rightมันจะเป็นถ้ามันจะทิ้งมันจะกลับมาtruefalse

ฉันเล่นกอล์ฟอย่างไร

ใน ES6 มีฟังก์ชั่นที่ไม่ระบุชื่อชวเลขเรียกว่าฟังก์ชั่นลูกศร ซึ่งหมายความว่าฉันสามารถใช้ฟังก์ชั่นเสื้อคลุมของฉันและเปลี่ยนเป็น:

input => ...;

เนื่องจากกฎของฟังก์ชั่นลูกศรมันจะคืนค่าส่วนที่เหลือของรหัส จากนั้นฉันแปลงcharAt(1)ไป[1]ตามที่มันเป็นวิธีที่สั้น แต่ไม่แนะนำให้ใช้ จากนั้นผมเอาและกลายเป็น=== ==ในขณะที่พวกเขาแตกต่างกันในกรณีนี้มันไม่สำคัญ สุดท้ายผมเปลี่ยนinputไปaและลบออกช่องว่างทั้งหมด

เอาท์พุทขวาและซ้าย

ในขณะที่ตัวต่อไม่ต้องการให้โปรแกรมส่งออกทางขวาและซ้ายนี่เป็นตัวอย่างของผลงานอื่น ๆ :

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

?'right':'left'ส่วนที่เพิ่มเข้ามาเพียงอย่างเดียวคือ สิ่งนี้จะสร้างตัวดำเนินการที่ประกอบไปด้วยคำสั่งย่อถ้านี่หมายความว่ารหัส (ไม่ได้รับการนับ) เท่ากับ *:

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

ตัวอย่าง

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

Pyth, 2 ไบต์

hc

เอาต์พุต#สำหรับซ้ายและ##ขวา

ลองออนไลน์

คำอธิบาย

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

Acc !!30 ไบต์

เพราะวิธีAcc !! ใช้อินพุตมันจะให้เอาต์พุตหลังจากป้อนเพียงหนึ่งบรรทัด แต่ถ้าคุณไพพ์อินพุตหรือเปลี่ยนทิศทางจากไฟล์คุณไม่ควรสังเกตเห็นความแตกต่าง

Count i while 35-N {
}
Write N

รับอินพุตจาก stdin เอาท์พุทหากถนนด้านซ้ายเดินทางน้อยกว่าหรือ#หากถนนด้านขวาเดินทางน้อยกว่าลองออนไลน์!

คำอธิบาย

Nอ่านค่า ASCII ของอักขระจาก stdin ทุกครั้งที่มีการอ้างอิง เราห่วงขณะที่ความ35-Nจริง; นั่นคือในขณะที่หรือ35-N != 0 N != 35ดังนั้นเมื่อวงออกมาเราเพิ่งอ่าน#ตัวอักษรตัวแรกของบรรทัด ตัวละครต่อไปคืออ่านแล้วด้วยNและเขียนกลับไปยัง stdout Writeกับ

เรติน่า 5 ไบต์

เอาต์พุต1ถ้าถูกต้อง0หากปล่อยทิ้ง

^ *##

ลองออนไลน์

หากค่าของผลลัพธ์ที่เป็นบวกไม่จำเป็นต้องแตกต่างกัน (5 ไบต์):

ส่งออกจำนวนเต็มบวกถ้าถูกต้องศูนย์ถ้าเหลือ

## +#

ลองออนไลน์

ภาษาสูตร IBM / Lotus Notes, 37 35 26 ไบต์

แก้ไขฉันมักจะลืมว่า@Likeมีสัญลักษณ์คือ 2 @Containsไบต์ราคาถูกกว่า

แก้ไข 2อันที่จริงไม่จำเป็นต้อง@ifเป็นมันเป็นเพียงแค่พิมพ์1หรือ0ขึ้นอยู่กับว่าผลสูตรการหรือ@True@False

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

สูตรฟิลด์ที่คำนวณ เพียงนำทุกอย่างไปทางซ้ายของครั้งแรกที่##พบในเขตข้อมูลaและหากมี#ในนั้นเอาท์พุท1สำหรับซ้ายมิฉะนั้นเอาท์พุท0เพื่อสิทธิ

ด้วย @DavidArchibald นี่เป็นวิธีแก้ปัญหาสำหรับ 22 ไบต์ ด้วยความเคารพโซลูชันของ Davids ฉันจะไม่โพสต์เป็นคำตอบหลักของฉัน

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

อันนี้ส่งออก1ทางขวาและ0ซ้าย

Pip , 8 6 ไบต์

a~`#+`

รับอินพุตเป็นอาร์กิวเมนต์บรรทัดคำสั่ง (ซึ่งจะต้องมีการอ้างอิงและการหลบเลี่ยงของการขึ้นบรรทัดใหม่เมื่อรันจากบรรทัดคำสั่งจริง) ส่งออก#หากถนนด้านซ้ายเดินทางน้อยกว่าและ##หากถนนด้านขวาเดินทางน้อยกว่า ลองออนไลน์!

คำอธิบาย

สิ่งนี้ใช้โอเปอเรเตอร์การจับคู่แรกของ regex ที่เพิ่มล่าสุด

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)

โซลูชัน regex ที่ตรงไปตรงมา (พอร์ตของคำตอบเรติน่า mbomb007 ) คือ 9 ไบต์:

`^ +##`Na

ชิป 7 ไบต์

AZ~S
at

ลองออนไลน์!

เอาต์พุต0x0สำหรับซ้ายและ0x1ขวา (TIO รวมถึงการตั้งค่าสถานะ-vเพื่อให้คุณสามารถดูค่าไบนารีใน stderr หากต้องการดูเอาต์พุตใน ASCII e*fสามารถผนวกเข้ากับท้ายบรรทัดแรก)

ชิปทำงานบนแต่ละบิตภายในสตรีมไบต์ซึ่งจริง ๆ แล้วทำให้ค่อนข้างดีในปัญหาเฉพาะนี้

Aเป็นบิตที่มีนัยสำคัญน้อยที่สุดของไบต์อินพุตและ '#' เป็นอักขระเฉพาะของอินพุตที่บิตนี้ถูกตั้งค่า เมื่อพบบิตนี้เป็นครั้งแรกเราได้มาถึงบรรทัดแรก '#'

Z ส่งสัญญาณล่าช้าหนึ่งรอบดังนั้นตอนนี้เรากำลังดูอักขระต่อไป

tเปิดใช้งานแล้วซึ่งหมายความว่าจะยุติการทำงานหลังจากรอบนี้เสร็จสมบูรณ์ เราไม่จำเป็นต้องมองไกลเกินความกว้างของถนนสายแรก

~Sไม่แสดงเอาต์พุตสำหรับทุกรอบยกเว้นรอบสุดท้าย หากนี่ไม่ใช่ที่นี่เราจะได้ผลลัพธ์ในทุกรอบ

aใส่ค่าปัจจุบันของเพื่อนบ้าน (เฉพาะAในกรณีนี้) ไปยังบิตไบต์ที่สำคัญน้อยที่สุด

ทั้งหมดนี้หมายความว่าเราจะได้รับ0x1ถ้า # 'แรกถูกตามด้วยอีกทันที' # 'และ0x0อื่น ๆ

C, 35 ไบต์

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

แนวคิดเดียวกันกับ คำตอบของ PragmaticProgrammer : ค้นหาสิ่งแรก#และส่งออกสิ่งที่เกิดขึ้นหลังจากนั้น - #สำหรับ "ขวา" และ<space>"ซ้าย"

C (ช่องโหว่) 16 ไบต์

จากกรณีทดสอบดูเหมือนว่าถนนด้านซ้ายนั้นอยู่ห่างจากระยะขอบซ้ายหนึ่งช่องเสมอ ดังนั้น...

#define f(s)2[s]

แบตช์ 46 ไบต์

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

อ่านหนึ่งบรรทัดจาก STDIN แยกออกเป็นช่องว่างและพิมพ์คำแรกดังนั้นเอาต์พุต#สำหรับซ้ายและ##ขวา หากอาร์เรย์ของพารามิเตอร์บรรทัดคำสั่งที่ยกมาเป็นที่ยอมรับดังนั้นสำหรับ 36 ไบต์:

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

ยกเลิกการอ้างอิงอาร์กิวเมนต์แรกเพื่อให้แยกในช่องว่างและพิมพ์คำแรก

Python 2, 21 ไบต์

ลองออนไลน์

lambda S:S.split()[0]

เอาต์พุต#สำหรับซ้ายและ##ขวา

เรติน่า 5 ไบต์

!1`#+

ลองออนไลน์!

โซลูชัน 5 ไบต์ทางเลือก พิมพ์#สำหรับซ้ายและ##ขวา แนวคิดคือเพื่อให้ตรงกับการทำงานทั้งหมดของ#s ( #+) และพิมพ์ ( !) เพียงคนแรกของพวกเขา ( 1)

Haskell, 21 ไบต์

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

หรือในรูปแบบปลอดจุด:

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

"#" หมายถึงถูกต้องและ "" หมายถึงเหลือ

ฟังก์ชั่นใช้เพียงแค่สตริงลดช่องว่างเริ่มต้นจากนั้นจะใช้อักขระตัวที่สอง (ช่องว่างถ้าด้านซ้ายผอมและ # ถ้าด้านซ้ายหนา)

แก้ไข: บันทึกสามไบต์ขอบคุณ Laikoni และ nimi!

Brainfuck, 32 ไบต์

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

Ungolfed:

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

พิมพ์#สำหรับขวาและซ้าย

ลองออนไลน์!

Perl 5 , 8 + 1 = 9 ไบต์

die$F[0]

ลองออนไลน์!

ทำงานด้วย -a (การลงโทษ 1 ไบต์)

ผลลัพธ์คือ(โดยชื่อไฟล์เป็นชื่อไฟล์ของสคริปต์) หากถนนด้านซ้ายเดินทางน้อยกว่าหรือ# at filename line 1, <> line 1## at filename line 1, <> line 1ถ้าถนนด้านขวาเดินทางน้อย

คำอธิบาย

-aตัวเลือกอ่านการป้อนข้อมูลโดยอัตโนมัติและแยกลงในคอลัมน์รอบช่องว่างไม่สนใจช่องว่างชั้นนำ ดังนั้นข้อมูลแรกของการป้อนข้อมูลคือสิ่งที่เราต้องการ $F[0]ว่า นอกจากนี้ยังทำให้โปรแกรมอยู่ในลูปโดยปริยายซึ่งเราไม่ต้องการ อย่างไรก็ตามการใช้dieช่วยให้เราสามารถส่งออกสตริงและออกจากห่วงโดยปริยายในเวลาเดียวกัน (และไม่มีตัวอักษรมากไปกว่าsayวิธีปกติมากขึ้นในการพิมพ์สตริง)

C 54 ไบต์

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

C ++ 58 ไบต์

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

เนื่องจาก OP ระบุจึงอาจเป็น "โปรแกรม / ฟังก์ชั่น" ฉันเลือกที่จะเขียนฟังก์ชั่นเพื่อบันทึกอักขระ อย่างไรก็ตามฉันยังคงรวมคำสั่ง "#include" และการขึ้นบรรทัดใหม่ในจำนวนอักขระเนื่องจากจำเป็นต้องรวบรวมฟังก์ชัน

เอาท์พุต

ส่งคืน" "อักขระช่องว่างเพื่อระบุซ้ายหรือ"#"อักขระแฮชเพื่อระบุขวา

คำอธิบาย

ฟังก์ชั่น strchr () เดินสตริงที่กำหนดและส่งกลับตัวชี้ไปที่การเกิดขึ้นครั้งแรกของตัวละครที่ระบุ มันมีโอเวอร์โหลดที่ยอมรับจำนวนเต็มว่าเป็นอาร์กิวเมนต์ที่สองซึ่งตรงข้ามกับถ่านซึ่งช่วยฉันได้ 1 ตัวอักษร เช่น '#' สามารถถูกแทนที่ด้วย 35 ฉันแล้วเพิ่มหนึ่งตัวชี้ที่ส่งคืนจากฟังก์ชันเพื่อให้ได้ตัวอักษรที่ตามมาทันทีและยกเลิกการอ้างอิงจากนั้นส่งคืนอักขระที่เป็นผลลัพธ์

บันทึก

ฉันต้องการใช้โอกาสนี้แสดงความรำคาญของฉันอย่างเป็นทางการที่ Visual Studio จัดรูปแบบโค้ดของฉันโดยอัตโนมัติเมื่อฉันพยายามเล่นกอล์ฟ (╯°□°） ╯︵ ┻━┻

แก้ไข:ขอบคุณRay ที่ชี้ให้เห็นความแตกต่างบางอย่างใน C และ C ++ และที่ที่ฉันสามารถบันทึกอักขระได้ <3

JavaScript (ES6), 37 ไบต์

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

คำอธิบาย:

p เป็นฟังก์ชันที่ส่งคืน trueหากถนนที่เดินทางน้อยกว่าอยู่ทางซ้ายและทางเท็จ นี่เป็นคำตอบแรกของฉันในเว็บไซต์นี้ดังนั้นมันอาจจะเป็นกอล์ฟมากกว่า (อาจเป็น regex)

มันทำงานโดยใช้บรรทัดบนสุดของอินพุตและดูว่าตรงกับ regex หรือไม่/^ *#( |$)/(เริ่มต้นของสตริงจำนวนช่องว่างใด ๆ # และช่องว่างหรือจุดสิ้นสุดของสตริง)

นี่เป็นเพียงเพื่อให้ผู้คนชี้แจงเกี่ยวกับรูปแบบและสร้างแนวคิด ฉันแน่ใจว่ามันสามารถตีและเล่นกอล์ฟต่อไปได้ มีความสุขในการเล่นกอล์ฟ!

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

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

Japt , 3 ไบต์

x

(2 ไบต์สำหรับ-g1แฟล็ก) เอาท์พุท#ทางขวาและช่องว่างทางด้านซ้าย ตามคำตอบ JavaScript โดย David Archibald

ลองออนไลน์!

Excel, 17 ไบต์

=left(trim(A1),2)

A1ถือว่าการป้อนข้อมูลในเซลล์

ส่งคืน##ทางด้านขวาและ#( #และช่องว่าง) ทางซ้าย

Dyvilขนาด 12 ไบต์

s=>s.trim[1]

คำอธิบาย:

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

การใช้งาน:

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

ส่งคืน(ช่องว่าง) สำหรับซ้ายและ#ขวา

Java 7, 166 66 63 52 43 ไบต์

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

เอาท์พุท35สำหรับขวาและ32ซ้าย
ขึ้นอยู่กับ@Clashsoft 'คำตอบ Dyvil

คำอธิบาย:

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

รหัสทดสอบ:

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     #"));
  }
}

ลองที่นี่

เอาท์พุท:

35
35
35
35
32
32

Befunge 98, 11 ไบต์

-!jv~'
@.~<

ลองออนไลน์!

พิมพ์32ทางซ้ายและ35ทางขวาทั้งสองพร้อมด้วยเว้นวรรคต่อท้าย

คำอธิบาย

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

หนึ่งในเคล็ดลับที่ฉันใช้คือการวาง-!jvครั้งแรกแม้ว่ามันจะไม่ได้ทำอะไรเลย ให้ฉันทั้งสองกำจัดพื้นที่หลังจาก'และบันทึกการขยายบางอย่าง ด้วยรหัสนี้ครั้งสุดท้าย

~' -!jv
   @.~<

15 ไบต์

Ruby, 20 ไบต์

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

ผลตอบแทนจริงสำหรับซ้าย, เท็จขวา