他原父亲的另一个吉米挑战。看看这些其他 可爱的 挑战。

众所周知，最近我们在平台上看到了与Jimmy相关的挑战。现在，吉米是我之前提到的杂技演员，而他还有其他技巧。

这些技巧之一是用绳子吊起来。这是吉米可以悬挂的绳索的示例：

            ||
            ||
            ||
            ||
            ||
            ||

当吉米挂在绳子上时，看起来像这样：

            ||
            ||
           /o\
            ||
            ||
            ||

他可以挂在绳子的左侧或右侧，因此：

            ||
            ||
            ||
            /o\
            ||
            ||

也有效。但是他不能只垂悬一个身体部位，所以像这样：

            ||
            ||
            ||
          /o\|
            ||
            ||

是无效的。请注意，当他垂悬在身体的一部分上时，可以看到绳的另一半，因为吉米没有遮住它。

另外，吉米（Jimmy）不喜欢挂在绳子的底部-吓到他了-因此：

            ||
            ||
            ||
            ||
            ||
            /o\

是无效的。

挑战

像上面那样输入吉米的情况，并通过真实或虚假的值输出吉米是否会坚持到底。

细节

• 编写一个需要输入的程序。这可以通过函数或任何其他适当的输入方法。

  1. 输入应该是一个吉米和一根绳子的场景，如上面示例所示。

• 程序应分别根据Jimmy可以挂在绳子上还是从绳子上掉下来，向控制台输出真实或虚假的值。

• 吉米能够胜任的标准：

  1. 他的两个身体部位都在绳子上。

  2. 他不在绳底。

  3. 他没有漂浮在空中。

• 您可以假设绳索是直的，由||线段组成，并且高度超过一个字符。

• 您可以假设一整个绳子和一个奇异的吉米将出现在您的场景中，不多也不少。

• 您可以假设绳索的底部没有尾随的换行符。

• 绳索前后，您必须覆盖任何数量的前导或尾随空间。

测试用例

           ||
           ||
           ||                 TRUTHY
           /o\
           ||
           ||


            ||
            ||
          /o\|                FALSY
            ||
            ||


        ||
       /o\                    TRUTHY
        ||


            ||
           /o\                FALSY


         /o\
          ||                  TRUTHY


            ||
            ||
       /o\  ||                FALSY
            ||
            ||

计分

这是代码高尔夫球，因此以字节为单位的最低得分将在大约一周后获胜。

排行榜

您可以通过展开下面的小部件/片段来查看此帖子的页首横幅。为了使您的帖子包含在排名中，您需要一个# header text带有以下信息的标题（）：

• 语言名称（以逗号,或破折号结尾-），后跟...。

• 字节数，作为出现在标题中的最后一个数字。

例如，JavaScript (ES6), 72 bytes有效但Fortran, 143 bytes (8-bit)无效，因为字节数不是标头中的最后一个数字（您的答案将被识别为8个字节-请勿利用此字节）。

<!-- Run the snippet to see the leaderboard. Report any bugs to @ozewski on Github. -->    <iframe src="https://ozewski.github.io/ppcg-leaderboard/?id=187759" width="100%" height="100%" style="border:none;">Oops, your browser is too old to view this content! Please upgrade to a newer version of your browser that supports HTML5.</iframe><style>html,body{margin:0;padding:0;height:100%;overflow:hidden}</style>

Japt，5个字节

我认为这是对的。我已经连续工作了16个小时，几乎不知道自己的名字，所以如果不是我也不会感到惊讶！

Õø|io

尝试一下

Õø|io     :Implicit input
Õ         :Transpose
 ø        :Contains?
  |io     :  "|" prepended with "o"

Python 2或3，  33  30个字节

-3感谢麦克斯韦

lambda l:'o'in map(max,l[:-1])

接受行列表的未命名函数

在线尝试！

怎么样？

吉米需要遮盖一部分绳子，而不是底部的绳子。

lambda l:'o'in map(max,l[:-1])
lambda l:                      # a function taking l (the lines as strings)
                       l[:-1]  # strip off the last line
               map(max,      ) # maximum of each line (where '|'>'o'>'\'>'/'>' ')
         'o'in                 # was 'o' one of them? (hence Jimmy obscured all the rope)

Python 2，28个字节

lambda x:"o', '|"in`zip(*x)`

在线尝试！

它是如何工作的？它以输入作为字符串列表，并使用zip将字符串连接在一起。如果有“ |”，吉米就呆在绳子上 在“ o”下面，因此此代码将所有行连接起来，并检查是否有“ o”后跟“ |”。

带注释的代码：

lambda x: # Creates an anonymous function that takes one argument
  "o', '|" # If this substring is in the zip object, then Jimmy's "o" is above a "|"
    in
    `    # Back quotes change the object into its string representation
    zip(*x)` # Joins the lines together

（旧答案）Python 2或3，39个字节

lambda x:1-all("|"in i for i in x[:-1])

一种将输入作为字符串列表的函数，每个字符串都是不同的行。

-11个字节感谢xnor！-2字节感谢乔纳森·艾伦！

在线尝试！（如果您想尝试更多的测试用例，只需在输入框中的每行之后添加一个“。”。）

这是如何运作的？好吧，如果Jimmy完全掌握了，那条线将不会有任何“ |” 字符。因此，我们可以检查每一行，以及是否找到没有“ |”的行 角色，那么我们知道吉米可以留在绳子上。但是，吉米不能挂在绳子的底部。因此，我们在检查中不包括最后一行。如果最后一行只是绳索的另一部分，那么没关系，因为我们仍然会在上方找到有效的行，但是如果最后一行是与Jimmy在一起的那一行，那么它将找不到行没有“ |” 任何地方，都会返回False。

果冻， 9 7  6 个字节

Ṗ<”|ṀẠ

接受行列表的单子链接

在线尝试！

怎么样？

吉米需要遮盖一部分绳子，而不是底部的绳子。

Ṗ<”|ṀẠ - Main Link: list of lines of characters
Ṗ      - remove last line
  ”|   - pipe character
 <     - less than? (vectorises) - Note that all other characters are
    Ṁ  - maximum
     Ạ - all?

污垢，5个字节

\o/\|

在线尝试！

这项工作的正确工具。

\o        # match an "o"
  /       # above
   \|     # a "|"

Brainfuck，79 64字节

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

在线尝试！

输出0x01字节表示真实，不输出任何内容表示虚假。

Z: 0
A: input
B: 0
C: has no | been found on this line?

>>+<<                       initialize C to 1
,[                          loop over each char

  ----------                set A to 0 if input was \n
  [<]>>                     move to C if input was \n; B otherwise
  [                         if input was \n and C is true
    .-                      output 1
  ]

  +                         this will reinitialize C to 1 if input was \n
                            but also clobber B with 1 if it wasn't
                            now we have { 0   0   0  (1)} if input was \n;
                                        { 0   _  (1)  _ } otherwise
  <[>-]                     clear own cell if the one to the left is positive
                            this yields { 0   0  (0)  1 } and
                                        { 0   _  (0)  _ } as desired

  +[---------<-->]          set A to 0 if input was |
  <[<]>>                    move to C if input was |; B otherwise
  [-]                       zero out current cell: clears C if input was |
  <[>]<                     realign pointer onto A

,]                          break on end of input

Stax，6 个字节

é¿┤4╠q

运行并调试

转置输入，然后搜索“ o |”。

05AB1E，5个字节

Çü%àθ

在线尝试！

Ç         # convert the input to a 2D array of codepoints
 ü%       # pairwise modulo (vectorized)
   à      # maximum (*not* vectorized, returns a single number)
    θ     # tail (last digit)

输入中可能出现的唯一字符是\o/ |，分别带有代码点92、111、47、32、124（没有换行符，因为我们选择将输入作为行的数组）。通过对这些数字中的两个取模，可能得到的结果是0、13、15、17、19、28、30、32、45、47、92、111。111是最大的数字，也是唯一以1结尾的数字，因此，当且仅当列表中存在111时，代码才会输出true（在05AB1E中只有1是true）。111是111（o）％124（|），因此只有在输入中有一个o大于a的情况下才会发生|。

APL（Dyalog Unicode），8 字节 ^SBCS

匿名隐式前缀函数，以字符矩阵为参数。

1∊'o|'⍷⍉

在线尝试！

⍉ 转置

'o|'⍷ 随处可见的面具o紧随其后|

1∊ 是其中的一员吗？

Dyalog APL扩展，14 13 11 9字节

3∊¯1+/⍤↓<

在线尝试！

JavaScript， 39 33字节

感谢@Daniil Tutubalin打高尔夫球2个字节

x=>!!x.match(/^( *)\/[^|]*\n/m)

这匹配了任何一条线，这些线不是他的左臂出现的那条线，也没有一条绳子出现。

在线尝试！

///，53 50字节

/~/\/\~/\/o\\/1~1 /1~ 1/1~|1~/1|~/|~/1.~/ ~/.~/
~.

在线尝试！

因为没有其他方法可以///输入，所以它是硬编码的：

/~/\/\~/\/o\\/1~1 /1~ 1/1~|1~/1|~/|~/1.~/ ~/.~/
~<INPUT HERE>.

说明：

通常的方法是用一元1代替吉米，然后将他从处于危险中的所有情况中删除。如果他生存下来，他就被输出了。如果他不这样做，那么什么都不是。该~代码是用于替换//，这允许代码通过这里的3个字节被缩短。从解释中省略它们。

/{/\//
/}/\/\//

          {The top two lines allow me to leave comments without disturbing the code.}

/\/o\\/1/ {Replace Jimmy with a 1.}
/1 /1/    {Get rid of any spaces in front of Jimmy. This moves Jimmy towards the rope from the left.}
/ 1/1/    {Get rid of any spaces after Jimmy. This moves Jimmy towards the rope from the right.}

/|1//     {If Jimmy is touching the rope, remove him and the rope.}
/1|//     {This is based on the observation that in all cases where Jimmy is safe, there is no visible rope on his line.}


/|//      {Remove any remaining rope. If Jimmy was touching a rope, it's already too late for him.}
/1.//     {This handles the case where Jimmy is at the bottom of the rope (hence the period at the end).}


/ //      {The remaining lines clean up the output.}
/.//
/
//

           ||
           ||
           ||
           /o\
           ||.

在线尝试！

Ruby 2.5.5，22个字节

->x{x.pop;!x.all? /\|/}

期望一行行。需要最低版本2.5.5，因为这是Array#all?(pattern)添加的时间。

由于输入将始终是Jimmy和绳索的有效场景的约束，因此可以归结为最后一行之前的任何一行是否遮住了绳索。

Kotlin，93 84字节

fun j(a:List<String>){print(a.count{!it.contains("|")}==1&&!a.last().contains("o"))}

在线尝试！

JavaScript， 38 37字节

r=>r.some(x=>!~x.search`\\|`,r.pop())

在线尝试！

视网膜，9字节

m`^[^|]+^

在线尝试！

现在，我以前从未在Retina中编程过，但是据我所知。它是一个正则表达式，查找包含（1）输入开头，（2）否“ |”的字符串 字符，以及（3）换行符。

鼓励更熟悉正则表达式或Retina的人们提供建议。-2个字节，感谢Neil！

Perl 5，26 -p个字节

$\||=!/\|/;$;=/o/}{$\&&=!$

在线尝试！

Befunge-98（PyFunge），26 24字节

]~:a-!#v_' `+
^_-3q#$<
@

在线尝试！

如果退出，则返回返回码3 \n遇到最后一行包含3个非空格字符；否则，在EOF上，返回码0退出。因此，这依赖于不包含尾随换行符的最后一行。

解剖

]~                     :a-!#v_                ' `+
 Read character,      Branch downwards if   Increment counter on 
 branch up (and        equal to 10 ('\n')   the stack if greater
 loop around) if                            than 32 (' ') and
 end of stream                              implicitly loop

^_-3q#$<                    <
 Return with code 3
 if counter is equal to 3,
 otherwise reset counter
 and return to beginning

@
 Return with exit
 code 0

05AB1E（旧版），6 个字节

ζJ„o|å

@Shaggy的Japt答案的端口。

输入为行列表。

在线尝试。

说明：

ζ       # Zip/transpose the (implicit) strings in the input-list, with space as filler
        # (NOTE: zip/transpose doesn't work on string-list in the new version of 05AB1E,
        #  which is why we use the legacy version)
 J      # Join these zipped/transposed lines together to a single string
  „o|å  # And check if it contains the string "o|"
        # (after which the result is output implicitly)

Elm 0.19，68字节

f r=List.any(not<<String.contains"|")(List.take((List.length r)-1)r)

将输入作为行列表。忽略最后一行，它会检查其中是否有任何'|'东西-暗示吉米完全覆盖了绳索。

在这里验证所有测试用例。

PowerShell，26个字节

港麦克斯韦答案视网膜。

"$args"-match'(?m)^[^|]+^'

在线尝试！

说明：

true 如果：

1. 场景中有一条线不包含角色 |
2. 在此行之后，有一个新行的开始。

false 除此以外。

Pyth，9个字节

sPm!sqR\|

测试套件！

Pyret，79个字节

{(l):all2({(r,n):string-char-at(n,string-index-of(r,"o") == "|")},l,link(0,l))}

期望将行数组作为字符串。link(0,l)在所有行向下移动一格的位置进行复制。遍历每一行r，n其中n是r下面的行。检查Jimmy的身体"o"是否在某个位置，然后在其下面的那一行有一根管子（即Jimmy的绳索挂在顶部，不在底部）。