Ini adalah yang pertama dalam seri, yang kedua adalah Dua jalan yang dibelah dalam kayu kuning (bagian 2)

Tantangan ini terinspirasi oleh puisi terkenal Robert Frost, "The Road Not Taken":

Dua jalan bercabang di kayu kuning,
Dan maaf aku tidak bisa melakukan keduanya.
Dan menjadi satu pengembara, lama aku berdiri
Dan melihat ke bawah sejauh yang aku bisa
Ke tempat itu membungkuk di semak-semak;

Kemudian mengambil yang lain, sama adil,
dan mungkin memiliki klaim yang lebih baik,
Karena itu berumput dan ingin dipakai;
Meskipun untuk yang lewat di sana
Memakai mereka benar-benar hampir sama,

Dan kedua pagi itu sama-sama berbaring
Di daun, tidak ada langkah menginjak hitam.
Oh, aku menyimpan yang pertama untuk hari lain!
Namun mengetahui bagaimana jalan menuju ke jalan,
saya ragu apakah saya harus kembali.

Saya akan mengatakan ini dengan menghela nafas
Di suatu tempat berabad-abad karena itu:
Dua jalan menyimpang dalam sebuah kayu, dan saya -
saya mengambil satu yang jarang dilalui oleh,
Dan itu telah membuat perbedaan.

Perhatikan baris kedua hingga terakhir I took the one less traveled by,,.

Tantangan Anda yang sebenarnya

Anda akan mengambil input dalam bentuk seperti:

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

dan Anda harus menemukan jalan yang lebih tipis.

Jalan dimulai dari bawah dengan a #. 2 jalan lainnya, yang selalu berakhir di baris atas, adalah jalan yang harus Anda periksa. Jalan yang paling tebal adalah yang paling banyak dilalui, dan karena itu bukan yang Anda inginkan. Yang lain adalah yang paling jarang dilalui, dan itu yang Anda inginkan.

Keluaran

Program / fungsi Anda harus menampilkan satu dari 2 nilai berbeda (mis. 0 atau 1, benar atau salah), satu untuk setiap posisi jalan yang mungkin tidak diambil. Misalnya, Anda dapat menampilkan 0 jika jalan tidak diambil di sebelah kiri jalan yang diambil, dan 1 jika tidak, atau Anda dapat menampilkan string "kiri" atau "kanan", benar, salah, dll.

Kasus uji:

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

Mungkin menghasilkan "benar".

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

Mungkin menghasilkan "benar".

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

Mungkin menghasilkan "benar".

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

Mungkin menghasilkan "benar".

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

Mungkin keluaran "kiri"

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

Mungkin keluaran "kiri"

Catatan

• Ini adalah kode-golf , jadi jawaban tersingkat dalam byte menang
• Celah standar dilarang
• Anda harus menentukan output untuk "kiri" dan "kanan" dan hasilnya harus berbeda
• Input akan menjadi satu string besar, dan mungkin memiliki jumlah baris berapa pun
• Anda tidak perlu khawatir tentang input yang valid.
• Jalan selalu berbentuk Y, jadi Anda hanya perlu melihat bagian atas.
• Ada pertanyaan? Komentar dibawah:

Hitungan byte terendah menang!

CJam , 1 byte

r

rmenempatkan string pertama dari karakter non-spasi putih yang berdekatan dari STDIN pada tumpukan, jadi ini akan mencetak ##ke kiri dan #ke kanan .

Cobalah online!

JavaScript (ES6), 19 12 byte

Edit:

Versi yang lebih golf adalah

a=>a.trim[1]

Kembali # ke kanan dan ruang untuk kiri.

Asli:

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

Penjelasan

Tidak Disatukan :

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

Hal pertama yang dilakukan fungsi ini adalah menghilangkan spasi putih di awal dan akhir input. Ini berarti bahwa karakter pertama selalu #. Kemudian dari sana saya memeriksa karakter kedua (JavaScript dimulai pada 0) dan melihat apakah itu adalah #karakter. Ini mengembalikan boolean. Jika jalan rightitu akan true, jika dibiarkan akan kembalifalse .

Bagaimana saya bermain golf

Dalam ES6 ada singkatan fungsi anonim yang disebut fungsi panah . Ini berarti bahwa saya dapat mengambil fungsi pembungkus saya dan mengubahnya menjadi:

input => ...;

Karena aturan fungsi panah itu akan mengembalikan sisa kode. Dari sana saya dikonversi charAt(1)menjadi [1]cara yang lebih pendek, meskipun tidak disarankan . Lalu saya mengambil ===dan mengubahnya menjadi ==. Meskipun mereka berbeda dalam kasus ini, itu tidak masalah. Akhirnya, saya mengganti nama inputmenjadi adan menghapus semua spasi putih.

Keluaran kanan dan kiri

Meskipun puzzle tidak benar-benar membutuhkan program untuk menampilkan kanan dan kiri, berikut adalah contoh dari output lain:

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

Satu-satunya bagian yang ditambahkan adalah ?'right':'left'. Ini menciptakan operator ternary , pernyataan if terkondensasi, ini berarti bahwa kode (yang tidak dikurung) sama dengan *:

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

Contoh

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

hc

Output #untuk kiri dan## kanan.

Cobalah online

Penjelasan

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

Acc !!, 30 byte

Karena cara Acc !! mengambil input, itu akan memberikan output setelah hanya satu baris input yang dimasukkan. Tetapi jika Anda mem-pipe input atau mengarahkannya dari file, Anda seharusnya tidak melihat perbedaannya.

Count i while 35-N {
}
Write N

Mengambil input dari stdin. Keluaran jika jalan kiri kurang dilalui, atau #jika jalan kanan kurang dilalui.Cobalah online!

Penjelasan

Nmembaca nilai ASCII dari karakter dari stdin setiap kali direferensikan. Kami berputar sementara 35-Nitu benar; itu adalah, sementara 35-N != 0atau N != 35. Karena itu, ketika loop keluar, kita baru saja membaca #karakter pertama di telepon. Karakter selanjutnya kemudian dibaca Ndan ditulis kembali bersama stdout Write.

Retina, 5 byte

Keluaran 1jika benar, 0jika kiri.

^ *##

Cobalah online

Jika nilai untuk hasil positif tidak harus berbeda (5 byte):

Menghasilkan bilangan bulat positif jika benar, nol jika kiri.

## +#

Cobalah online

Bahasa Formula IBM / Lotus Notes, 37 35 26 byte

Sunting Saya selalu lupa bahwa @Likedengan wildcard lebih murah 2 byte daripada @Contains.

Sunting 2 Sebenarnya tidak perlu @ifkarena hanya mencetak 1atau 0tergantung pada apakah rumus menghasilkan @Trueatau @False.

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

Rumus bidang terkomputasi. Cukup bawa semuanya ke kiri yang pertama ##ditemukan di lapangan adan jika ada #di dalamnya output 1untuk kiri jika tidak output 0untuk kanan.

Dengan terima kasih kepada @DavidArchibald, berikut adalah solusi untuk 22 byte. Karena menghormati solusi Davids saya tidak akan mempostingnya sebagai jawaban utama saya.

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

Ini output 1untuk kanan dan 0kiri.

Pip , 8 6 byte

a~`#+`

Mengambil input sebagai argumen baris perintah (yang perlu mengutip dan keluar dari baris baru saat dijalankan dari baris perintah yang sebenarnya). Keluaran #jika jalan kiri kurang dilalui, dan ##jika jalan kanan kurang dilalui. Cobalah online!

Penjelasan

Ini menggunakan operator regex pertandingan pertama Pip yang baru ditambahkan.

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)

Solusi regex langsung (port jawaban Retina mbomb007 ) adalah 9 byte:

`^ +##`Na

Chip , 7 byte

AZ~S
at

Cobalah online!

Output 0x0untuk kiri, dan 0x1untuk kanan. (TIO menyertakan flag -vsehingga Anda dapat melihat nilai biner di stderr. Untuk melihat output di ASCII,e*f dapat ditambahkan ke akhir baris pertama.)

Chip beroperasi pada bit individual dalam aliran byte, yang sebenarnya membuatnya cukup baik untuk masalah spesifik ini.

Aadalah bit paling tidak signifikan dari byte input, dan '#' adalah satu-satunya karakter input yang bit ini diatur. Ketika bit ini pertama kali ditemukan, kami telah mencapai '#' pertama dari baris pertama.

Z menunda sinyal itu untuk satu siklus, sehingga kita sekarang melihat karakter berikutnya.

tsekarang diaktifkan, yang berarti mengakhiri eksekusi setelah siklus ini selesai. Kita tidak perlu melihat lebih jauh dari lebar jalan pertama.

~Smenekan output untuk semua siklus kecuali yang terakhir. Jika ini tidak ada di sini, kami akan mendapatkan output di setiap siklus.

amenempatkan nilai terkini dari tetangganya (hanya Adalam kasus ini) ke bit byte keluaran paling tidak signifikan.

Semua ini berarti bahwa kita mendapatkan a 0x1jika '#' pertama segera diikuti oleh '#' yang lain, dan 0x0sebaliknya.

C, 35 byte

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

Ide yang sama dengan jawaban PragmaticProgrammer : cari yang pertama #, dan keluaran apa yang muncul setelahnya - #untuk "benar", dan <space>untuk "kiri".

C (celah), 16 byte

Menurut kasus uji, sepertinya jalan kiri selalu tepat satu ruang dari margin kiri. Begitu...

#define f(s)2[s]

Batch, 46 byte

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

Membaca satu baris dari STDIN, membaginya pada spasi, dan mencetak kata pertama, jadi keluarlah # untuk kiri dan ##kanan. Jika larik parameter baris perintah yang dikutip dapat diterima, maka untuk 36 byte:

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

Tanda kutip argumen pertama sehingga akan terpecah pada spasi dan mencetak kata pertamanya.

Python 2, 21 byte

Cobalah online

lambda S:S.split()[0]

Output #untuk kiri dan ##kanan

Retina , 5 byte

!1`#+

Cobalah online!

Alternatif solusi 5-byte. Mencetak #untuk kiri dan ##kanan. Idenya adalah untuk mencocokkan semua run dari #s ( #+) dan print ( !) hanya yang pertama dari mereka ( 1).

Haskell, 21 byte

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

atau dalam gaya point-free:

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

"#" Berarti Benar, dan "" Berarti Kiri

Fungsi hanya mengambil string, menjatuhkan spasi awal, dan kemudian, dibutuhkan karakter kedua (spasi jika kiri kurus dan # jika kiri tebal)

EDIT: Disimpan tiga byte berkat Laikoni dan nimi!

Brainfuck, 32 byte

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

Tidak Disatukan:

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

Cetakan #untuk kanan dan kiri.

Cobalah online!

Perl 5 , 8 + 1 = 9 byte

die$F[0]

Cobalah online!

Jalankan dengan -a (penalti 1 byte).

Output adalah (di mana nama file# at filename line 1, <> line 1 adalah nama file skrip) jika jalan kiri kurang dilalui, atau## at filename line 1, <> line 1 jika jalan kanan kurang dilalui.

Penjelasan

The -apilihan secara otomatis membaca input dan membagi ke kolom sekitar spasi, mengabaikan spasi terkemuka. Dengan demikian, datum input pertama adalah yang kita butuhkan; yang ini $F[0]. Ini juga menempatkan program dalam loop implisit, yang tidak kita inginkan. Namun, penggunaan diememungkinkan kita untuk mengeluarkan string, dan keluar dari loop implisit, pada saat yang sama (dan dengan tidak lebih dari karakter say, cara yang lebih biasa untuk mencetak string).

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

Karena OP yang ditentukan itu bisa menjadi "program / fungsi" Saya memilih untuk menulis fungsi untuk menyimpan karakter. Namun, saya masih menyertakan pernyataan "#include" dan garis pemisah yang disertakan dalam jumlah karakter karena mereka diharuskan untuk mengkompilasi fungsi.

Keluaran

Mengembalikan " "karakter spasi untuk menunjukkan kiri, atau hash"#" karakter untuk menunjukkan kanan.

Penjelasan

Fungsi strchr () memandu string yang diberikan dan mengembalikan pointer ke kemunculan pertama karakter yang ditentukan. Ini memiliki kelebihan yang menerima integer sebagai argumen kedua sebagai lawan dari char yang menyelamatkan saya 1 karakter. Misalnya '#' dapat diganti dengan 35. Saya kemudian menambahkan satu ke pointer yang dikembalikan dari fungsi untuk mendapatkan karakter segera berikut, dan dereferensi, lalu mengembalikan char yang dihasilkan.

Catatan

Saya juga ingin mengambil kesempatan ini untuk secara resmi menyatakan kekesalan saya di Visual Studio secara otomatis memformat kode saya ketika saya mencoba bermain golf (╯ ° □ °） ╯︵ ┻━┻.)

Sunting: Terima kasih kepada Ray untuk menunjukkan beberapa perbedaan dalam C dan C ++ dan di mana saya dapat menyimpan karakter <3.

JavaScript (ES6), 37 byte

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

Penjelasan:

padalah fungsi yang mengembalikan truejika jalan yang jarang dilalui adalah di sebelah kiri dan salah sebaliknya. Ini adalah jawaban pertama saya di situs ini, jadi mungkin bisa golf lebih banyak (mungkin regex.)

Ia bekerja dengan mengambil baris teratas dari input dan melihat apakah itu cocok dengan regex /^ *#( |$)/(mulai dari string, jumlah spasi, #, dan spasi atau akhir dari string.)

Ini hanya untuk memberi orang klarifikasi tentang format dan menghasilkan ide. Saya yakin itu bisa mengalahkan dan bermain golf lebih lanjut. Selamat bermain golf!

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 untuk -g1flag) Output #untuk kanan dan ruang untuk kiri. Berdasarkan jawaban JavaScript oleh David Archibald.

Cobalah online!

Excel, 17 byte

=left(trim(A1),2)

Mengasumsikan input dalam sel A1 .

Kembali ##untuk kanan dan #( #dan spasi) untuk kiri.

Dyvil , 12 byte

s=>s.trim[1]

Penjelasan:

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

Pemakaian:

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

Pengembalian (spasi putih) untuk kiri dan #kanan.

Java 7, 166 66 63 52 43 byte

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

Output 35untuk kanan dan 32kiri.
Berdasarkan @Clashsoft 's Dyvil jawabannya .

Penjelasan:

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

Kode uji:

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

Coba di sini.

Keluaran:

35
35
35
35
32
32

Menembus 98, 11 byte

-!jv~'
@.~<

Cobalah secara Online!

Mencetak 32untuk kiri, dan 35untuk kanan, keduanya dengan satu spasi tambahan.

Penjelasan

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

Satu trik yang saya gunakan adalah menempatkan yang -!jvpertama, meskipun tidak melakukan apa pun. Ini biarkan saya menyingkirkan ruang setelah 'dan menyimpan beberapa lapisan. Dengan ini yang terakhir, kodenya akan

~' -!jv
   @.~<

selama 15 byte.

Ruby, 20 byte

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

Mengembalikan nilai true untuk kiri, false untuk kanan.