Ini adalah yang kedua dalam seri, yang ketiga adalah Dua jalan yang dibelah dalam kayu kuning (bagian 3)

Ini didasarkan pada Dua jalan yang menyimpang dari kayu kuning (bagian 1) , tantangan tambang sebelumnya. Itu diterima dengan cukup baik, tetapi juga cukup sepele (jawaban Java dalam 52 byte!) Jadi saya membuat sesuatu yang lebih kompleks ...

Inspirasi

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, aku berdiri lama
Dan melihat ke bawah sejauh yang aku bisa
Ke tempat itu membungkuk di semak-semak;

... 2 paragraf dipangkas ...

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

Perhatikan baris kedua hingga terakhir I took the one less traveled by,,. Tujuan Anda adalah menemukan jalan yang paling jarang dilalui oleh input string Anda. Anda harus menampilkan salah satu dari 2 nilai yang berbeda satu sama lain yang memberi sinyal ke arah mana Anda harus berbelok untuk menempuh jalan yang jarang dilalui. Setelah persimpangan jalan (jejak heksagon berubah menjadi angka), Anda berada di persimpangan. Dari sana, akan ada 2 jalur yang terdiri dari angka. Jalur yang digit-nya memiliki jumlah terendah adalah jalan yang tidak diambil. Perhatikan bahwa jalan yang tidak diambil mungkin memiliki jalur yang lebih besar tetapi jumlah jalur yang lebih rendah. Berikut adalah beberapa contoh / kasus uji dari program yang mencetak "kiri" atau "kanan" untuk jalur yang tidak diambil:

 1     2
  1   2
   1 2
    #
    #
    #
left (3 < 6)


 1     2
  2   2
   1 1
    #
    #
    #
left (4 < 5)


 12    2
  11  2
   1 1
    #
    #
    #
right (6 > 5)


 99   989
  99  89
  99 99
  99 99
    #
    #
    #
   # 
left (72 < 79)


1111 1110
 001 111
  11 11
  11 11
    #
   ##
  ##
 ##  
left (9 < 10) (Note: 1111 is interpreted as 1+1+1+1=4, not 1111=1111)


1       1
 0     1
  1   1
  1   1
  1   1
  1   1
   1 1 
    #
    #
    #
     #
      #
left (6 < 7)


1   1 
 0   1  
  1   1
  1   1
  1   1
  1   1
   1 1 
    #
    #
    #
     #
      #
left (6 < 7)

Hal-hal untuk diasumsikan & diingat

• Akan selalu ada 2 jalur. Tidak lebih, tidak kurang.
• Anda dapat mengambil input dari STDIN satu baris pada satu waktu, string yang berisi karakter LF, atau string yang berisi backslash literal dan n. Jika Anda membutuhkan input dengan cara lain, mintalah persetujuan dalam komentar.
• Anda tidak perlu khawatir tentang input yang tidak valid atau jalur yang diikat. Itu tidak akan pernah dimasukkan ke program / fungsi Anda.
• Input dapat berupa panjang atau lebar apa pun, kurang dari batas string bahasa Anda.
• Tidak akan pernah ada #dan nomor di baris yang sama.
• Semua digit di jalur adalah bilangan bulat positif 0 hingga 9.
• Input atau output dengan baris baru tambahan diperbolehkan.
• Lihat jawaban JS ES6 saya di bawah ini untuk contoh.
• Akan selalu ada setidaknya 1 ruang antara 2 jalur.
• 2 jalur akan selalu memiliki ketinggian yang sama untuk setiap peta, tetapi mungkin berbeda pada peta lainnya.
• Jika Anda bingung tentang kasus uji tertentu, tolong beri tahu saya.
• 1111 ditafsirkan sebagai 1 + 1 + 1 + 1 = 4, bukan 1111 = 1111. Peta ini adalah serangkaian angka satu digit, bukan angka dengan panjang sewenang-wenang.
• Ini kode-golf , jadi jawaban tersingkat dalam byte menang!
• Celah standar dilarang

Jika Anda memiliki pertanyaan tentang tantangan ini, tanyakan pada saya di komentar, dan semoga berhasil!

05AB1E , 21 15 byte

Output 0 untuk kiri dan 1 untuk kanan.

|vy#õK€SO})øO`›

Cobalah online!

Penjelasan

|v                # for each line in input
  y#              # split on spaces
    õK            # remove empty strings
      €S          # split each string into a list of chars
        O         # sum each sublist
         }        # end loop
          )ø      # wrap stack in a list and zip
            O     # sum each sublist (side of the tree)
             `›   # compare left to right

Retina , 28 byte

\d
$*
%r`1\G
-
Os`.
+`-1

1+

Cobalah online!

Cetakan 0 untuk kiri dan 1kanan. Diasumsikan bahwa tidak ada spasi tambahan pada garis apa pun.

Penjelasan

\d
$*

Konversikan setiap digit Nmenjadi sejumlah N.

%r`1\G
-

Satu setiap baris ( %), cocokkan berturut-turut ( \G) dari akhir ( r) dan ganti masing-masing dengan -(yaitu mengubah cabang kanan menjadi -s).

Os`.

Sortir semua karakter, sehingga semua -s ada di depan semua 1s.

+`-1

Batalkan secara berulang sepasang -dan 1.

1+

Cobalah untuk mencocokkan setidaknya satu 1(jika demikian, ada lebih banyak bobot di jalur kiri).

Python 2 , 95 89 88 87 byte

Inilah yang pertama saya lakukan dengan python. Jelas tidak optimal tetapi awal yang layak.

f=lambda x,i:sum(sum(map(int,y))for y in x.split()[i::2]if"#"<y)
lambda x:f(x,1)>f(x,0)

Cobalah online!

Chip , 216 byte

 EZ,Z~.
E~]x-.|
F].>vm'
Ax]}#----------------.
Bx]}#---------------.|z.
Cx]}#------------.,Z|##' E
Dx]}#---------.,Z|`@@('A~^~t
 E.>#------.,Z|`@@-('
A~S`#v--.,Z|`@@-('
*f,--<,Z|`@@-('
e |,Z|`@@-('
,Z|`@@-('
>@@-('
a

Cobalah online!

Sedikit lebih besar dari jawaban untuk bagian 1 ...

Ikhtisar

Chip adalah bahasa 2D yang terinspirasi oleh sirkuit aktual, dan ini berhubungan dengan bit komponen dari setiap byte dalam aliran byte.

Solusi ini menyimpan jumlah digit yang dilihatnya, membalik tanda input setiap kali menemui hamparan spasi, lalu berakhir pada yang pertama #. Jadi, untuk input

 11   12
  2   2
   1 1
    #
    #
    #

Kami mendapatkan 1 + 1 - 1 - 2 + 2 - 2 + 1 - 1 = -1. Tanda hasil diberikan sebagai output, angka negatif menghasilkan hasilnya 1, dan positif adalah 0.

Oleh karena itu, keluaran 1berarti bahwa jalan kiri kurang diambil, dan 0berarti benar.

Penjelasan

Pada level tinggi, ini cara kerjanya:

Diagonal utama dengan @elemen adalah akumulator, output ditentukan oleh adi bagian bawah. (Delapan pasang @berarti delapan bit, tetapi bit tertinggi adalah tandanya, sehingga solusi ini dapat menangani perbedaan maksimum +127 atau -128. Melimpah di tengah jalan tidak masalah, selama kami kembali sebelum mengakhiri.)

Empat baris yang mulai seperti Ax]}#--... membaca input, dan dalam kasus digit, meniadakannya (jika perlu) dan meneruskan nilainya ke dalam adders.

Tiga baris pertama memutuskan apakah kita melihat angka, atau urutan spasi putih, dan melacak apakah digit perlu dinegasikan.

Elemen yang tersisa terjepit di bawah input dan elemen di kanan menangani kondisi penghentian, dan memetakan output ke ASCII (sehingga kita mendapatkan karakter '0'atau '1'bukan nilai 0x0atau 0x1. Pemetaan ASCII ini tidak memerlukan byte tambahan, kalau tidak saya tidak akan telah memasukkannya.)

JavaScript (ES6), 55 byte

x=>x.replace(/\d(?=.*( )|)/g,(d,s)=>t-=s?d:-d,t=0)&&t<0

Asumsikan tidak ada spasi tambahan di setiap baris, dan output trueuntuk right, falseuntuk left. Caranya adalah dengan mencocokkan setiap digit pada input, dan jika ada spasi setelahnya pada baris yang sama, kurangi dari total; jika tidak, tambahkan ke total. Jika total akhir kurang dari 0, jalan yang benar adalah yang kurang dilalui oleh, dan sebaliknya.

Cobalah:

f=x=>x.replace(/\d(?=.*( )|)/g,(d,s)=>t-=s?d:-d,t=0)&&t<0

<textarea placeholder = "paste in a map here..." oninput = "document.querySelector('div').innerText = f(this.value)"></textarea>
<div></div>

Python 3 , 85 94 byte

import re
g=lambda s,i:sum(map(int,''.join(re.findall('\d+',s)[i::2])))
lambda s:g(s,0)>g(s,1)

Cobalah online!

Kutukan! Tidak membaca masalahnya cukup dekat. Menambahkan perbaikan ( ''.join()), tetapi dengan biaya 9 byte.

Python 2, 78 byte

-1 byte terima kasih kepada @math_junkie

Cobalah online

def F(S,r=0):
 for c in S.split():
    if'#'<c:r+=sum(map(int,c));r=-r
 print r>0

Mencetak Falseuntuk jalur kiri dan Truekanan

Retina , 180 byte

Hitungan byte mengasumsikan penyandian ISO 8859-1.

^(?=( *(0|(1|(?<3>2|(?<3>3|(?<3>4|(?<3>5|(?<3>6|(?<3>7|(?<3>8|(?<3>9))))))))))+.+¶)+)(.+ (0|(?<-3>1|(?<-3>2|(?<-3>3|(?<-3>4|(?<-3>5|(?<-3>6|(?<-3>7|(?<-3>8|(?<-3>9))))))))))+¶)+ *#

Cobalah online!

Saya pikir saya juga akan mencoba solusi regex-only (di atas adalah polos .NET regex yang hanya cocok dengan input di mana jalan yang benar harus diambil, kecuali untuk digunakan ¶sebagai singkatan untuk \n).

Ini berulang berulang, tapi itulah yang terjadi ketika Anda harus memperlakukan setiap digit yang mungkin secara individual.

Solusinya adalah aplikasi yang cukup lurus ke depan kelompok penyeimbang : pertama-tama kita menjumlahkan angka di cabang kiri dengan mendorong Ntangkapan ke tumpukan 3untuk setiap digit N. Kemudian kami mencoba untuk mencapai #, sambil muncul dari tumpukan 3 Nkali untuk setiap digit Ndi cabang kanan. Ini hanya mungkin jika jumlah digit di cabang kiri lebih besar dari pada di cabang kanan (karena Anda tidak bisa muncul dari tumpukan kosong).

JavaScript (ES6), 106 104 byte

s=b=>(b=b.split`\n`,c=0,d=0,b.forEach(a=>{a=a.match(/\d+/g)||[],c+=+(a[0]?a[0]:0),d+=+(a[1]?a[1]:0)}),c<d)

s=b=>(b=b.split("\n"),c=0,d=0,b.forEach(a=>{a=a.match(/\d+/g)||[],c+=+(a[0]?a[0]:0),d+=+(a[1]?a[1]:0)}),c<d)

sadalah fungsi yang mengembalikan truejika jalan tidak diambil di sebelah kiri. Tidak Disatukan:

var proc = function(str){
    str = str.split("\n");
    var left = 0;
    var right = 0;
    str.forEach(item=>{
        var match = item.match(/\d+/g) || [];
        console.log(match);
        left += +(match[0] ? match[0] : 0);
        right += +(match[1] ? match[1] : 0);
    });
    return left < right;
};

s=b=>(b=b.split`\n`,c=0,d=0,b.forEach(a=>{a=a.match(/\d+/g)||[],c+=+(a[0]?a[0]:0),d+=+(a[1]?a[1]:0)}),c<d)

<textarea placeholder = "paste in a map here..." oninput = "document.querySelector('div').innerText = s(this.value)"></textarea>
<div></div>

PowerShell , 80 byte

$args-split'\s|#'-ne''|%{$a+=(($i=[char[]]$_-join'+'|iex),-$i)[($x=!$x)]};$a-gt0

Cobalah online!

(Hanya mencicit di bawah jawaban Python.: D)

Output Trueuntuk jalur kiri dan Falsejalur kanan.

Mengambil input sebagai string yang digambarkan dengan `n, yang merupakan padanan PowerShell dari "string yang mengandung backslash literal dan n" , atau sebagai string multiline literal. Kami kemudian -splitmemasukan \s(spasi putih termasuk baris baru) atau #dan menyaring semua hasil kosong -ne'', jadi kami hanya memiliki array digit. Itu dimasukkan ke dalam satu lingkaran |%{...}.

Setiap iterasi, pertama-tama kita mengambil elemen saat ini $_, melemparkannya sebagai chararray, -joinbersama-sama dengan tanda tambah +, dan pipa itu ke iex(kependekan dari Invoke-Expressiondan mirip dengan eval). Itu disimpan $ijadi kami dengan benar meringkas digit pada potongan jalur ini. Kami kemudian menggunakannya dan negatif sebagai dua elemen dari array ($i, -$i), diindeks menjadi dengan membalik nilai Boolean bolak-balik. Artinya, iterasi pertama melalui loop ini, potongan path kiri pertama, kami akan mengindeks ke dalam -$i; waktu berikutnya, kami akan mengambil $i; dan seterusnya. Mereka diakumulasi ke dalam $adengan +=.

Akhirnya, kami mengevaluasi apakah $aini -greater than 0. Jika ya, maka jalur kanan memiliki jumlah yang lebih besar, jika tidak, jalur kiri memiliki jumlah yang lebih besar. Hasil Boolean itu ditinggalkan di jalur pipa, dan hasilnya tersirat.

CJam , 19 18 byte

qN/Sf%z{'1*:~:+}/>

Cobalah online!

Mencetak 0untuk kiri dan 1kanan.

Penjelasan

q      e# Read all input.
N/     e# Split into lines.
Sf%    e# Split each line around runs of spaces.
z      e# Transpose to group each branch.
       e# Note that each branch will have the same number of digit segments
       e# now but the first branch will also have all the #s at the end in
       e# separate segments.
{      e# For each branch...
  '1*  e#   Join the segments into a single string with 1s as separators.
       e#   This will add the same number of 1s between digit segments in
       e#   both branches (which won't affect their relative sum) and it 
       e#   will also insert a 1 before each # in the first branch.
  :~   e#   Evaluate each character. The digit characters are simply turned
       e#   into their values, but # is the exponentiation operator in CJam.
       e#   This is why we inserted those additional 1s, because 1# is a no-op.
  :+   e#   Sum the digits in the branch.
}/
>      e# Check whether the left branch's sum is greater than the right one's.

Mathematica, 80 77 byte

Terima kasih kepada Martin Ender karena telah menghemat 3 byte!

#<#2&@@Total@Partition[Tr/@ToExpression[Characters@StringSplit@#/."#"->0],2]&

Fungsi murni mengambil string yang dibatasi-baris baru sebagai input, dan kembali Trueuntuk mengambil jalur kiri, Falseuntuk mengambil jalur yang benar. Sialan nama-nama perintah Mathematica yang panjang itu; ini seperti 10 token.

Pip , 19 18 byte

LR+XDax:-x+$+$0SGx

Mengambil input sebagai string tunggal pada baris perintah (yang perlu mengutip dan keluar dari baris baru jika dijalankan pada baris perintah yang sebenarnya). Output -1untuk kiri, 1kanan. Cobalah online!

Penjelasan

Putaran putaran digit, menambahkan jumlah digit ke penghitungan. Tanda penghitungan ditukar setiap kali, dengan hasil akhir bahwa nilai-nilai tangan kiri negatif dan nilai-nilai tangan kanan positif. Kemudian kami mencetak tanda penghitungan akhir ( -1atau 1).

                    a is 1st cmdline arg; XD is regex `\d`; x is "" (implicit)
                    Note that "" in a math context is treated as 0
  +XD               Apply regex + to XD (resulting in `\d+`)
LR   a              Loop over matches of that regex in a:
             $0      Regex match variable containing the full match
           $+        Sum digits by folding on +
      x:-x+          Swap the sign of the tally and add this sum
               SGx  After the loop, print the sign of the tally

Haskell , 64 byte

g=sum.map fromEnum
f(a:b:r)|a>"#"=g a-g b+f r|1<3=0
(>0).f.words

Cobalah online! Penggunaan: Fungsi anonim (>0).f.wordsmengambil string yang dipisahkan baris baru sebagai argumen dan kembali Falseuntuk kiri dan Truekanan.

Penjelasan:

Diberikan input

 99   989
  99  89
  99 99
    #
    #
   # 

yang string " 99 989\n 99 89\n 99 99\n #\n #\n #", maka wordsstrip semua baris dan ruang dan mengembalikan daftar string yang tersisa: ["99","989","99","89","99","99","#","#","#"]. Fungsi fmengambil dua elemen pertama adan bdari daftar ini dan memeriksa apakah astring adalah digit dengan membandingkannya dengan string "#". (Karena char '#'lebih kecil dari semua karakter digit '0', '1', ... setiap string yang dimulai dengan digit akan leksikografi lebih besar dari "#".) Fungsi gmemetakan setiap char dalam string ke kode karakter ascii dan mengembalikan jumlah mereka. Dalam fkita menerapkan gke adan bmenghitung g a - g b, itu adalah nilai dari jalur kiri dikurangi nilai yang benar, dan menambahkannya ke panggilan rekursif kefuntuk menangani baris berikut. Jika jalur kiri lebih banyak dilalui, hasilnya fakan negatif dan sebaliknya positif untuk jalur kanan, jadi (>0)periksa apakah hasilnya lebih besar dari nol.

Python 3 , 84 byte

Karena semua pengiriman Python saat ini adalah fungsi, saya pikir saya akan berkontribusi program lengkap.

x=0
try:
 while 1:
  for n in input().split():x=-x+sum(map(int,n))
except:print(x>0)

Mencetak Truejika jalur kiri kurang dilalui, Falsejika tidak. Cobalah online!

Untuk setiap baris input, ini terbagi pada spasi putih, menjumlahkan digit setiap elemen yang dihasilkan, dan menambahkannya ke penghitungan sambil membalik tanda penghitungan pada setiap langkah. Ini terus membaca jalur input sampai menyentuh satu dengan #, di mana titik map(int,n)menimbulkan pengecualian dan kami keluar dari loop, mencetak Truejika penghitungan positif dan Falsesebaliknya.

Batch, 169 byte

@echo off
set/as=0
:l
set/pr=
if not %r: =%==# call:c - %r%&goto l
cmd/cset/a"s>>9
exit/b
:c
call:r + %3
:r
set/as%1=%2%%10,d=%2/10
if %d% gtr 0 call:r %1 %d%

Mencetak 0untuk kiri, -1untuk kanan. Catatan: Membaca baris sampai menemukan satu dengan #, lalu berhenti membaca. Perbedaan jumlah path dibatasi hingga 511 (tambahkan 1 byte untuk mendukung perbedaan yang lebih besar). Tidak lebih dari 9 digit di setiap baris setiap jalur (mendukung sejumlah baris). Penjelasan: dSubrutin mengambil dua parameter: apakah akan menambah atau mengurangi dan digit. Ini mengekstrak digit terakhir dengan modulo sebesar 10 dan digit yang tersisa dengan membagi dengan 10 dan menyebut dirinya secara rekursif sementara masih ada digit yang tersisa. Thec subroutine mengambil tiga parameter: apakah untuk menambah atau mengurangi, angka menambah atau mengurangi, dan selanjutnya Angka menambahkan. Itu memanggildsubrutin untuk menangani angka untuk ditambahkan dan kemudian jatuh untuk menangani dua parameter pertama. Ini berarti bahwa memanggil csubrutin dengan parameter -dan digit kiri dan kanan akan menambah digit kanan dan mengurangi digit kiri. Akhirnya hasilnya digeser untuk mengekstrak tanda.

Oktaf, 46 byte

@(a)diff((a(:)-48)'*(bwlabel(a>35)(:)==1:2))<0

Cobalah online! Fungsi yang mengambil array karakter 2D asebagai input.

Penjelasan:

a=

    1   1  
     0   1 
      1   1
      1   1
      1   1
      1   1
       1 1 
        #  
        #  
        #  
         # 
          #

a > 35                   %convert the matrix to a binary matrix
                         %where there is a number corresponing
                         %element of the binary matrix is 1.

*   *  
 *   * 
  *   *
  *   *
  *   *
  *   *
   * * 

bwlabel(a>35)            %label each connected component. 


1   2  
 1   2 
  1   2
  1   2
  1   2
  1   2
   1 2 

B=bwlabel(a>35)(:)==1:2  % a binary `[n ,2]` matrix created 
                         % each column related to one of labels

A=(a(:)-48)'             % convert array of characters to array of numbers 

A * B                    % matrix multiplication that computes 
                         % the sum of numbers under each label

diff(A*B)<0              % check if the left is grater than the right

Java 7, 219 216 byte

boolean c(String s){int l=0,r=0;for(String x:s.split("\n")){l+=f(x,0);r+=f(x,1);}return l>r;}int f(String x,int i){if(x.contains("#"))return 0;int n=0;for(int c:x.trim().split("\\s+")[i].getBytes())n+=c-48;return n;}

Sedikit lebih lama dari 52 byte saat ini. ;)
Dan kembali lagi falseke kanan dan truekiri.

Penjelasan:

boolean c(String s){              // Method with String parameter and boolean return-type
  int l=0, r=0;                   //  Right and left counters
  for(String x : s.split("\n")){  //  Loop over de lines
    l += f(x,0);                  //   Add all left digits to the left-counter
    r += f(x,1);                  //   Add all right digits to the right-counter
  }                               //  End of loop
  return l>r;                     //  Return whether the left-counter is larger than the right-counter
}                                 // End of method

int f(String x, int i){           // Separate method with String and integer parameters, and int return-type
  if(x.contains("#"))             //  If the current line contains "#"
    return 0;                     //   Simply return 0
  int n=0;                        //  Counter
  for(int c :                     //  Loop over the digits by
              x.trim()            //    first removing leading and trailing whitespaces
              .split("\\s+")      //    then split them right in the middle
              [i]                 //    then pick either the left or right side based on the int index parameter
              .getBytes())        //    and convert that String to a byte-array
    n += c-48;                    //   For each of those digit-characters: add it to the counter
                                  //  End of loop (implicit / single-line body)
  return n;                       //  Return the counter
}                                 // End of separate method

Kode uji:

Coba di sini.

class M{
  boolean c(String s){int l=0,r=0;for(String x:s.split("\n")){l+=f(x,0);r+=f(x,1);}return l>r;}int f(String x,int i){if(x.contains("#"))return 0;int n=0;for(int c:x.trim().split("\\s+")[i].getBytes())n+=c-48;return n;}

  public static void main(String[] a){
    M m = new M();
    System.out.println(m.c(" 1     2\n  1   2\n   1 2\n    #\n    #\n    #"));
    System.out.println(m.c(" 1     2\n  2   2\n   1 1\n    #\n    #\n    #"));
    System.out.println(m.c(" 12    2\n  11  2\n   1 1\n    #\n    #\n    #"));
    System.out.println(m.c(" 99   989\n  99  89\n  99 99\n  99 99\n    #\n    #\n    #\n   # "));
    System.out.println(m.c("1111 1110\n 001 111\n  11 11\n  11 11\n    #\n   ##\n  ##\n ##  "));
    System.out.println(m.c("1       1\n 0     1\n  1   1\n  1   1\n  1   1\n  1   1\n   1 1 \n    #\n    #\n    #\n     #\n      #"));
    System.out.println(m.c("1   1 \n 0   1 \n  1   1\n  1   1\n  1   1\n  1   1\n   1 1 \n    #\n    #\n    #\n     #\n      #"));
  }
}

Keluaran:

false
false
true
false
false
false
false