这是系列中的第一个，第二个是在黄色的树林中分叉的两条道路（第2部分）

这一挑战的灵感来自罗伯特·弗罗斯特（Robert Frost）的著名诗作《未走的路》：

两条道路在黄色的树林中分开，
对不起，我无法同时行进
，成为一个行人，我站了很久
，俯视着一条路，尽我所能
，一直到灌木丛弯曲的地方。

然后公平地取下另一个，
也许有更好的主张，
因为它长满了草，想要穿。
虽然那路过的
人真的穿了差不多的衣服，

那天早上，两个人同样躺在
地上，没有脚踩过黑色。
哦，我保留了第一天！
然而，
我知道路要走，我是否应该回来。

我将叹息地告诉这个问题，因为它
在某个年代和年代都有：
两条道路在树林中分叉，我-
我走过的路少了，
这一切都改变了。

请注意倒数第二行I took the one less traveled by,。

您的实际挑战

您将采用以下形式输入：

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

而你必须找到更薄的道路。

这条路从底部开始#。其他两条始终在最上一行终止的道路是您必须检查的道路。最厚的道路是最常经过的道路，因此这不是您想要的。另一个是经过最少的旅行，也是您想要的旅行。

输出量

您的程序/函数必须输出2个不同的值之一（例如0或1，true或false），其中一个用于未经过的道路的每个可能位置。例如，如果未行驶的道路位于已行驶道路的左侧，则可以输出0，否则输出1，或者可以输出字符串“ left”或“ right”，true，false等。

测试用例：

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

可能输出“正确”。

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

可能输出“正确”。

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

可能输出“正确”。

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

可能输出“正确”。

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

可能输出“左”

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

可能输出“左”

笔记

• 这是代码高尔夫球，因此最短答案以字节为单位
• 禁止标准漏洞
• 您必须为“ left”和“ right”指定输出，并且它们必须是不同的
• 输入将是一个大字符串，并且可以有任意数量的行
• 您无需担心有效的输入。
• 道路始终为Y形，因此您只需要查看顶部即可。
• 有什么问题吗？以下评论：

最低字节数获胜！

CJam，1个字节

r

r放从STDIN堆栈上相邻的非空白字符的第一串，所以这个打印##为左和#为右。

在线尝试！

JavaScript（ES6），19个12字节

编辑：

更高尔夫的版本是

a=>a.trim[1]

返回#右，左空格。

原版的：

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

说明

Ungolfed：

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

此功能要做的第一件事是删除输入开头和结尾的空格。这意味着第一个字符始终为#。然后从那里检查第二个字符（JavaScript从0开始），看看它是否是一个#字符。这将返回一个布尔值。如果路径是right这将是true，如果离开它会返回false。

我如何打高尔夫球

在ES6中，有一个匿名函数的简写形式，称为arrow函数。这意味着我可以使用包装函数并将其转换为：

input => ...;

由于箭头功能的规则，它将返回其余代码。从那里开始，我转换charAt(1)为，[1]因为它是一种较短的方法，尽管不建议这样做。然后我把===它变成了==。尽管它们在这种情况下有所不同，但这并不重要。最后，我重命名input为a并删除了所有空格。

左右输出

虽然难题实际上并不需要程序向左和向右输出，但以下是其他输出的示例：

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

唯一添加的部分是?'right':'left'。这将创建一个三元运算符，即一个精简的if语句，这意味着（解开的）代码等于*：

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.

加速！，30字节

由于方式acc！接受输入，仅输入一行输入即可给出输出。但是，如果您通过管道输入或从文件重定向输入，则不会注意到它们之间的区别。

Count i while 35-N {
}
Write N

接受来自stdin的输入。输出如果左手道路少走，或者#如果右手的道路是人迹罕至。在线尝试！

说明

N每次引用stdin时，都会读取字符的ASCII值。当35-N真理时我们循环；即while 35-N != 0或N != 35。因此，当循环退出时，我们只读取了#该行的第一个字符。然后使用读取下一个字符，N并使用将其写入标准输出Write。

视网膜，5个字节

1如果是，0则输出，如果是，则输出。

^ *##

在线尝试

如果肯定结果的值不必不同（5个字节）：

如果正确，则输出一个正整数，如果左侧，则输出零。

## +#

在线尝试

IBM /莲花笔记公式语言，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左。

点，8 6字节

a~`#+`

将输入作为命令行参数（从实际命令行运行时，将需要引用和转义换行符）。输出#如果左手道路少走，并且##如果右边的路是人迹罕至。在线尝试！

说明

这使用了Pip最近添加的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)

简单的正则表达式解决方案（mbomb007的Retina answer的端口）为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读取一行，将其在空格上分割，然后打印出第一个单词，因此输出#为left和## right。如果可接受带引号的命令行参数数组，则为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个字节

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

取消高尔夫：

+[                       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（）函数遍历给定的字符串，并返回指向指定字符首次出现的指针。它有一个重载，它接受一个整数作为第二个参数，而不是一个给我节省一个字符的char。例如，“＃”可以替换为35。然后，我将一个添加到从函数返回的指针中，以立即获取紧随其后的字符，然后取消引用它，然后返回结果字符。

注意

我也想借此机会在尝试打高尔夫球（╯°□°）╯︵┻━┻时在Visual Studio自动格式化我的代码时正式表达我的烦恼。

编辑：感谢Ray指出了C和C ++的一些区别以及我可以在其中保存<3字符的地方。

JavaScript（ES6），37个字节

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

说明：

p 是一个返回的函数 true如果较少行驶的道路位于左侧否则 false。这是我在此网站上的第一个答案，因此它可能会打更多的高尔夫球（也许是正则表达式）。

它通过获取输入的第一行并查看是否与正则表达式匹配来工作 /^ *#( |$)/（字符串的开头，任意数量的空格，＃，以及字符串的空格或结尾）相匹配来工作。

这只是为了让人们澄清格式并产生想法。我相信它可以被击打并打得更远。打高尔夫球快乐！

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

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

Japt，3个字节

x

（-g1标志#为2个字节）右为输出，左为空格。基于David Archibald的JavaScript回答。

在线尝试！

Excel，17个字节

=left(trim(A1),2)

假设在单元格中输入 A1。

返回##右，#（#和空格）返回左。

魔鬼，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]==' '}

左侧返回true，右侧返回false。