[Question]
  [
Yet another Jimmy challenge by his original father. See these [other](https://codegolf.stackexchange.com/questions/187586/will-jimmy-fall-off-his-platform) [lovely](https://codegolf.stackexchange.com/questions/187682/how-many-jimmys-can-fit) [challenges](https://codegolf.stackexchange.com/questions/187731/jimmy-needs-your-help).
---
As you all know, recently we've been seeing challenges related to Jimmy on platforms. Now, Jimmy is an acrobat as I mentioned before, and he's got other tricks up his sleeve.
One of these tricks is hanging by ropes. Here's an example of a rope Jimmy could hang from:
```
            ||
            ||
            ||
            ||
            ||
            ||
```
When Jimmy hangs on a rope, it looks like this:
```
            ||
            ||
           /o\
            ||
            ||
            ||
```
He can hang on the left or the right of the rope, so this:
```
            ||
            ||
            ||
            /o\
            ||
            ||
```
is also valid. But he cannot hang by just one body part, so anything like this:
```
            ||
            ||
            ||
          /o\|
            ||
            ||
```
is invalid. Note that when he is hanging by one body part the other half of the rope is visible because Jimmy does not cover it up.
Also, Jimmy does not like hanging on the bottom of the rope - it scares him - so this:
```
            ||
            ||
            ||
            ||
            ||
            /o\
```
is invalid.
# The challenge
Take input of a Jimmy situation like the ones above, and output whether Jimmy will hang on to the rope or not through a truthy or falsy value.
# The specifics
* Write a program that takes input. This can be through a function or any other appropriate input method.
	1. The input should be a scene of one Jimmy and a rope as exemplified above.
* The program should output a truthy or falsy value to the console based on whether Jimmy can hang on to the rope or if he would fall off the rope, respectively.
* The criteria for Jimmy being able to hang on the rope:
	1. Two of his body parts are on the rope.
	2. He is not on the bottom of the rope.
	3. He is not floating in mid-air.
* You can assume the rope will be straight, made up of `||` segments, and will be longer than one character in height.
* You can assume one whole rope and one singular Jimmy will be present in your scene, no more and no less.
* You can assume there will be no trailing newlines at the bottom of the rope.
* You must cover any amount of leading or trailing spaces before and after the rope.
# Test cases
```
           ||
           ||
           ||                 TRUTHY
           /o\
           ||
           ||
            ||
            ||
          /o\|                FALSY
            ||
            ||
        ||
       /o\                    TRUTHY
        ||
            ||
           /o\                FALSY
         /o\
          ||                  TRUTHY
            ||
            ||
       /o\  ||                FALSY
            ||
            ||
```
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so lowest score in bytes wins after about a week.
# Leaderboard
You can view the leaderboard for this post by expanding the widget/snippet below. In order for your post to be included in the rankings, you need a header (`# header text`) with the following info:
* The name of the language (end it with a comma `,` or dash `-`), followed by...
* The byte count, as the last number to appear in your header.
For example, `JavaScript (ES6), 72 bytes` is valid, but `Fortran, 143 bytes (8-bit)` is invalid because the byte count is not the last number in the header (your answer will be recognized as 8 bytes - don't take advantage of this).
```
<!-- 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>
```
  
[Answer]
# [Python 2 or 3](https://docs.python.org/3/), ~~33~~ 30 bytes
-3 thanks to [Maxwell](https://codegolf.stackexchange.com/users/87771)
```
lambda l:'o'in map(max,l[:-1])
```
An unnamed function accepting a list of lines
**[Try it online!](https://tio.run/##nZHLCsIwEEXXzVdkNwlUpbgL9EsaFxEbDORFm4VC/j3Gbmo0VHF2wxwOc7n@Hq7OHpPsedLCnC8CawYOlMVGeGLErdUD23UnmqSbcBjngPONoAkAEF4nxl@3g@ObaBa36MP/xpVrVsYv8GItpCvz@lEVrYeocGW2P8JkwXbU1UoZarSy44z7pZf97LUKBLgFOnTPzlDjJ2UDkWThKE0P "Python 3 – Try It Online")**
### How?
There needs to be a section of rope obscured by Jimmy that is not the bottom one.
```
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)
```
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 5 bytes
I *think* this is right; I've been working for 16 hours straight and barely know my own name so I wouldn't be surprised if it's not!
```
Õø|io
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=1fh8aW8&input=IiAgICAgICAgICAgfHwKICAgICAgICAgICB8fAogICAgICAgICAgIHx8ICAKICAgICAgICAgICAvb1wKICAgICAgICAgICB8fAogICAgICAgICAgIHx8Ig)
```
Õø|io     :Implicit input
Õ         :Transpose
 ø        :Contains?
  |io     :  "|" prepended with "o"
```
[Answer]
## Python 2, 28 bytes
```
lambda x:"o', '|"in`zip(*x)`
```
[Try it online!](https://tio.run/##nY@7CsIwFIb3PsWhSxORCo6FDC7i4KR1ECtaaUoDMQ1txQt599qL2itW/IeQc/vP@eQ9CUIxTX3ipNw9nzwXbpYeGmMwlM7E8cEkGt3wMeVkt9euAeMU7OhCLQ0yxSRyrwcm5CVBuMgwH2IgBHRTL1tyyYiJBPmIY/zJcSCQOeZfymNaNXPTlZIKD8U4hUpKaV8iaMtebezFtt40CZ1vDppZj1vlZpg5dRbOZ8v1dsCh2lDVMi/oUev893APaOeAnLPG0sTuM3jt@pG/OFj9z1@m3@8wjnoB5PNP)
How does it work? It takes input as a list of strings, and zip joins the string. Jimmy stays on the rope if there is a "|" below an "o", so this code joins all the lines and checks if there is an "o" followed by a "|".
Annotated code:
```
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
```
## (Old Answer) Python 2 or 3, 39 bytes
```
lambda x:1-all("|"in i for i in x[:-1])
```
A function that takes input as a list of strings, each string being a different line.
-11 bytes thanks to xnor! -2 bytes thanks to Jonathan Allan!
[Try it online! (If you want to try more test cases, just put a "." after each set of lines in the input box.)](https://tio.run/##nU89D4IwEN35FRemdhBjXAxJBxfj4KQ4GGXAWGKTszR8REz637GICgJB4xsu9@7j3T11S8@RnM5UXITsUGBwOZ4CyN3JKEAktraFBAFhFJto0nzvjiY@LZDtfet6FsjBizPuWmCQMCFVlhL6YCKEBBgD27GrdgkVC5mSkCCl7xoCA6NWphwTXg@jEyjF5YkktIAaWlsDDNrw1ltvuWsOjaPDkILlNHmr/UmNUufgYr7a7L4o1BfqntGCHrTefy33GO08UPpsePm03SfwvPWj/8fD@n//VfkVv9vRTwPl/h0)
How does this work? Well, if Jimmy is fully on the rope, then that line will not have any "|" characters. Therefore, we can check each line, and if we find any with no "|" characters, then we know that Jimmy can stay on the rope. However, Jimmy can not hang on to the bottom of the rope; therefore, we don't include the final line in our check. If the final line is just another part of the rope, than it won't matter, because we'll still find a valid row higher up, but if the final line is the one with Jimmy, then it won't find a line without "|" anywhere, and will return False.
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~9 7~~ 6 [bytes](https://github.com/DennisMitchell/jelly/wiki/CWde-page)
```
Ṗ<”|ṀẠ
```
A monadic Link accepting a list of lines
**[Try it online!](https://tio.run/##y0rNyan8///hzmk2jxrm1jzc2fBw14L/D3dvOdz@/78CEqip4cLD1c@PQZMGAA "Jelly – Try It Online")**
### How?
There needs to be a section of rope obscured by Jimmy that is not the bottom one.
```
Ṗ<”|ṀẠ - Main Link: list of lines of characters
Ṗ      - remove last line
  ”|   - pipe character
 <     - less than? (vectorises) - Note that all other characters are
    Ṁ  - maximum
     Ạ - all?
```
[Answer]
# [Grime](https://github.com/iatorm/grime), 5 bytes
```
\o/\|
```
[Try it online!](https://tio.run/##Sy/KzE39/z8mXz@m5v9/BSioqeGCsvTzY7gQogA "Grime – Try It Online")
The right tool for the job.
```
\o        # match an "o"
  /       # above
   \|     # a "|"
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 5 bytes
```
Çü%àθ
```
[Try it online!](https://tio.run/##yy9OTMpM/W/mVvP/cPvhPaqHF5zb8V/nvwIC1NRwEcnTz4/BqxSZiyaLygUaVENAMRemFLL1@G0DqeTC4Wyi3QnUht8XIC4A "05AB1E – Try It Online")
```
Ç         # convert the input to a 2D array of codepoints
 ü%       # pairwise modulo (vectorized)
   à      # maximum (*not* vectorized, returns a single number)
    θ     # tail (last digit)
```
The only characters that can appear in the input are `\o/ |`, with respective
codepoints 92, 111, 47, 32, 124 (there are no newlines, since we chose to take
input as an array of lines). The possible results by moduloing two of these
numbers are 0, 13, 15, 17, 19, 28, 30, 32, 45, 47, 92, 111. 111 is the largest
of those, and also the only one that ends with 1, so the code will output truthy
if and only if 111 is present in the list (only 1 is truthy in 05AB1E). 111
is 111 (`o`) % 124 (`|`), and so only occurs if there's an `o` above a `|` in the input.
[Answer]
## brainfuck, ~~79~~ 64 bytes
```
>>+<<,[----------[<]>>[.-]+<[>-]+[---------<-->]<[<]>>[-]<[>]<,]
```
[Try it online!](https://tio.run/##SypKzMxLK03O/v/fzk7bxkYnWhcOom1i7eyi9XRjtW2i7YAkQspGV9cu1gYirwtkADk6sf//KyBATQ0XkTz9/Bh8SgE)
Outputs the 0x01 byte for truthy and nothing for falsy.
```
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
```
[Answer]
# [Stax](https://github.com/tomtheisen/stax), 6 [bytes](https://github.com/tomtheisen/stax/blob/master/docs/packed.md#packed-stax)
```
é¿┤4╠q
```
[Run and debug it](https://staxlang.xyz/#p=82a8b434cc71&i=+++++++++++%7C%7C%0A+++++++++++%7C%7C%0A+++++++++++%7C%7C++%0A+++++++++++%2Fo%5C%0A+++++++++++%7C%7C%0A+++++++++++%7C%7C%0A%0A++++++++++++%7C%7C%0A++++++++++++%7C%7C%0A++++++++++%2Fo%5C%7C%0A++++++++++++%7C%7C%0A++++++++++++%7C%7C%0A%0A++++++++%7C%7C%0A+++++++%2Fo%5C+%0A++++++++%7C%7C%0A%0A++++++++++++%7C%7C%0A+++++++++++%2Fo%5C+%0A%0A+++++++++%2Fo%5C%0A++++++++++%7C%7C++%0A%0A++++++++++++%7C%7C%0A++++++++++++%7C%7C%0A+++++++%2Fo%5C++%7C%7C++%0A++++++++++++%7C%7C%0A++++++++++++%7C%7C&a=1&m=1)
Transposes the input, then searches for "o|".
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 8 [bytes](https://codegolf.meta.stackexchange.com/a/9429/43319 "When can APL characters be counted as 1 byte each?")[SBCS](https://github.com/abrudz/SBCS ".dyalog files using a single byte character set")
Anonymous tacit prefix function, taking a character matrix as argument.
```
1∊'o|'⍷⍉
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT///3/BRR5d6fo36o97tj3o7/6c9apvwqLfvUd9UT/9HXc2H1hs/apsI5AUHOQPJEA/P4P@eYCVruDx1QIyuJnUFBKipARLqVJTSz48h30Cgi4FyaQpAL3hyceFzN1CHOkkSQHeRqAMiQaSTsJkBtFIdu0oq@BNsOLHmYHcJ1dyCy/ekxxKmkwA "APL (Dyalog Unicode) – Try It Online")
`⍉` transpose
`'o|'⍷` mask for everywhere `o` is immediate followed by `|`
`1∊` is one a member thereof?
[Answer]
# Dyalog APL Extended, ~~14~~ ~~13~~ ~~11~~ 9 bytes
```
3∊¯1+/⍤↓<
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/P@1R2wTjRx1dh9Ybaus/6l3yqG2yzX9PoOCj3jVcnjogRleTugIC1NQACXUqSunnx5Bv4KO@qUC5NIVHbRM9ubjwuRuoQ50kCaC7SNQBkSDSSdjMAFqpjl0lFfwJNpxYc7C7hGpuweV70mMJ00n/AQ "APL (Dyalog Extended) – Try It Online")
[Answer]
# [Haskell](https://www.haskell.org/), 19 bytes
```
any(all(<'|')).init
```
[Try it online!](https://tio.run/##jYoxDsIwEAT7vGILpNhFwgccGr6R5hTsYHGcLXxFIvntOJRUiOlGM3cqD8/cwjQ3kt0Qs3F97a0do0RtT4qCCbfUARvcAI7iC9zpgtXrNYl60fKJ@RVFYQI22/BFrd3/ek7z7/u9BKa1tGHJ@QA "Haskell – Try It Online")
[Answer]
# JavaScript, ~~39~~ 33 bytes
Thanks @Daniil Tutubalin for golfing off 2 bytes
```
x=>!!x.match(/^( *)\/[^|]*\n/m)
```
This matches any line which is not the line where his left arm shows up and none of the rope shows.
[Try it online!](https://tio.run/##bVFLbsMgFNz7FC4riKl/UVYOOUG7T4WJZDk4Adlg2ThK1eTsLv6kTZOyYTRvZp4YZHbK2rwRtXlVes/7gvRnsnl5OftVZvIjDHbQXaA0oLsLW6QqqFAvRVV9atXomh@4InAAb1wdzBEPcItHwXx9ILL50p2pO0MoSwrdQEHCRKx/XYnwPDRrqGAEuMBveM0zM0ZvkQcuF5CIwjrJHHon/0F@W4qcw3Deb22BTlPgPQqmsbdE139CvLvt75k5@k2m9rqCaBGF6Npw0zXKndS@1EJBkCqAro5zysqOt4TSJY5xhGOGHXc@dGWpEEePVPRMxc/UylLMcYbmpG1OrqdNfjmVJ4fyrGNkyTSjklkm16rVJfdLfYAt@ftrcBTSkOEJRDcQ38CSIfQQUsDWcvat/Tc "JavaScript (Node.js) – Try It Online")
[Answer]
# [///](https://esolangs.org/wiki////), ~~53~~ 50 bytes
```
/~/\/\~/\/o\\/1~1 /1~ 1/1~|1~/1|~/|~/1.~/ ~/.~/
~.
```
[Try it online!](https://tio.run/##K85JLM5ILf7/Xz9GPz8mRt9QX99QAUQqGILIGiDWN6wBEiBsqAckFIAYRHMBqf//AQ "/// – Try It Online")
Because there is no other way to take input in ///, it is hard-coded:
```
/~/\/\~/\/o\\/1~1 /1~ 1/1~|1~/1|~/|~/1.~/ ~/.~/
~<INPUT HERE>.
```
**Explanation:**
The general approach is to replace Jimmy with a unary 1, then remove him from all situations where he is in danger. If he survives, he is outputted. If he doesn't, then nothing is. The `~` in the code are a replacement for `//`, which allow the code to be shortened by 3 bytes here. They are omitted from the explanation.
```
/{/\//
/}/\/\//
          {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\
           ||.
```
[Try it online!](https://tio.run/##nVNNj5wwDL3zK3xrK1VE/IqqPVZ7nIsBs4kUYpSYQauZ/e1TO8ywnR6qqggJHH@99@yUiMVTud3cxZ2ca9y7fuyngeO5vHgC4QVkY4ghUQGMkTeY7Rgi4Zlg4HmmJAW2IJ5XgTEUWXMf0iuIN/9I7XvTaHE@nVzn4PKTlogDwY8wz281DxA6DXIdWIC1/kYCOYzAE2B6g7JoQoGQYMqcxI5rdgsvPhSY@azevZ7whnkstXnmhSxjrlakSawLdH/vgpNQ/o/6Obx6qVyvnXO7hN/vQEGrCK@Df@hiqV8hk5UGH2YFMB6OqsX1UaNC0LfHQoo11TDuC@UzSqg2immj04FBg3QYnjJ9dC44aTOph2omhnMooY93BlrCWtiIDb7iv7e2WVWApo5ixZAMf4UIB7UNf@OGd2ZBPtm6ZMLRNNN1QVGtOBvZyq994ueVf6RdVuPwJwVlaK6eRVRuHdih/2dPSbfJ7IVy4PERS2n8svOBg4@t9AeRfakH3eQE67Lrusqy1jVp7Vo0z1cCrtd/tXTdn53t7fYL "/// – Try It Online")
[Answer]
# Ruby 2.5.5, 22 bytes
```
->x{x.pop;!x.all? /\|/}
```
Expects an array of lines. Requires a minimum of version 2.5.5 because this is when `Array#all?(pattern)` was added.
Because of the constraints that the input will always be a valid scene of Jimmy and a rope, it boils down to whether any of the lines prior to the last line have the rope obscured.
[Answer]
# [Kotlin](https://kotlinlang.org), ~~93~~ 84 bytes
```
fun j(a:List<String>){print(a.count{!it.contains("|")}==1&&!a.last().contains("o"))}
```
[Try it online!](https://tio.run/##bY4xD4IwEIVn@itKB9IuGFciJu5uriyNCeQQrqY9BgL97bWCUaLe8u7e9/JyN0MdYAj1gLyVujiDo8OFLGBzVNM9KkmdX82ANKVAcUPSgE6KWShflvssS3XeaUdSbaARSvmltI@G1LZxBT9Zq8d3OZ9YUhvLZQt9P64uB@TP7AKTdotyd@@ApKgwVke4vracLPHMh8DjzDP7kZ2pXtefSIThk1nNbTCCr8oH "Kotlin – Try It Online")
[Answer]
# Elm 0.19, ~~68~~ 60 bytes
```
List.any(not<<String.contains"|")<<List.drop 1<<List.reverse
```
Anonymous, points-free function. Takes input as a list of lines. Disregarding the last line, it checks whether there are any with no `'|'` in them – implying the rope is fully covered by Jimmy.
Thanks to [Lynn](https://codegolf.stackexchange.com/users/3852/lynn) for golfing 8 bytes.
Verify all test cases [here](https://ellie-app.com/bNqKW2RXqBha1).
[Answer]
# JavaScript, ~~38~~ 37 bytes
```
r=>r.some(x=>!~x.search`\\|`,r.pop())
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9h@7/I1q5Irzg/N1WjwtZOsa5Crzg1sSg5IyEmpiZBp0ivIL9AQ1Pzf3J@XnF@TqpeTn66RoZGtJICENTUgEglHTBHPz8mBsGDycVqaoLk9BVKikpTuQgZAjWDIkNAZtTgMyQtMaeYsFMUaiCOocQUsFOo4haIYyg2BTO60E35DwA "JavaScript (Node.js) – Try It Online")
[Answer]
## [Retina](https://github.com/m-ender/retina), 9 bytes
```
m`^[^|]+^
```
[Try it online!](https://tio.run/##K0otycxLNPz/PzchLjquJlY77v9/BSRQU8NFAReZp4Aip58fg6YWAA)
Now, I've never programmed in Retina before, but as far as I can tell this works. It is a regular expression that finds a string containing (1) the beginning of the input, (2) no "|" characters, and (3) a newline.
People more familiar with either regular expressions or Retina are encouraged to offer suggestions. -2 bytes thanks to Neil!
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 26 bytes
```
$\||=!/\|/;$;=/o/}{$\&&=!$
```
[Try it online!](https://tio.run/##K0gtyjH9/18lpqbGVlE/pkbfWsXaVj9fv7ZaJUZNzVZR5f9/BQSoqeHCw1NAByFBoSEekciK9PNjUPX8yy8oyczPK/6v62uqZ2Bo8F@3AAA "Perl 5 – Try It Online")
[Answer]
# [Befunge-98 (PyFunge)](https://pythonhosted.org/PyFunge/), ~~26~~ 24 bytes
```
]~:a-!#v_' `+
^_-3q#$<
@
```
[Try it online!](https://tio.run/##S0pNK81LT9W1tNAtqAQz//@PrbNK1FVULotXV0jQ5oqL1zUuVFax4XL4/18BCdTUcOHh6ufHcOFVDQA "Befunge-98 (PyFunge) – Try It Online")
Exits with return code 3 if `\n` is encountered and the last line contained 3 non-space characters, otherwise exits with return code 0 on EOF. Thus, this relies on the last line not containing a trailing newline.
### Dissected
```
]~                     :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
```
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), 6 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ζJ„o|å
```
Port of [*@Shaggy*'s Japt answer](https://codegolf.stackexchange.com/a/187786/52210).
Input as a list of lines.
[Try it online.](https://tio.run/##MzBNTDJM/V/z/9w2r0cN8/JrDi/9/18BCmpquKAs/fwYLoQoAA)
**Explanation:**
```
ζ       # 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)
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), 26 bytes
Port of [Maxwell's answer for Retina](https://codegolf.stackexchange.com/a/187766/80745).
```
"$args"-match'(?m)^[^|]+^'
```
[Try it online!](https://tio.run/##hZDdDoIwDEbv9xTNnLpFiPcmRt5DRQkWxExANqOJ89lxgj/ETN1Nl689p0nL4oSV2qKUNUtgCpeasqhKFfX3kY63Qz7bi3AemuUoHNZXQgJOiMeZro7oBZSAfcY4yrhYfKQ0EA2aRFI5WYuYL4xjXWfBL/N9zGX5h3cU76@FHCl0PQIM9OHS5AzPJcYaNx4wmeWo7H3Zqm1VqI5S22Bgz87btr8rspyucyruIz1QpYy0zvK0QSjjD8rHw0stJk8XJdf6Bg "PowerShell – Try It Online")
Explanation:
`true` if:
1. there is a line in a scene that does not contain the character `|`
2. and after this line there is a start of a new line.
`false` otherwise.
[Answer]
# [Husk](https://github.com/barbuz/Husk), 6 bytes
```
€'om▲h
```
[Try it online!](https://tio.run/##yygtzv6fm/@oqfHQtgqlQ9sObfv/qGmNen7uo2mbMv7//6@AADU1XETy9PNjYvCqReaiyaJyQSbV4FcNAA "Husk – Try It Online") A port of [Jonathan Allan's answer](https://codegolf.stackexchange.com/a/187760).
[Answer]
# [Vyxal](https://github.com/Vyxal/Vyxal), 6 bytes
```
Ḣ\|vOA
```
[Try it Online!](https://vyxal.pythonanywhere.com/#WyIiLCLilqEiLCLhuKJcXHx2T0EiLCIiLCJ8fFxufHxcbi9vXFxcbnx8Il0=)
Takes a list of lines, returns a 1 if Jimmy can't hang on, 0 if he can.
[Answer]
# [Pyth](https://pyth.readthedocs.io), 9 bytes
```
sPm!sqR\|
```
[Test suite!](https://pythtemp.herokuapp.com/?code=sPm%21sqR%5C%7C&test_suite=1&test_suite_input=%5B%22++++%7C%7C++++%22%2C%22++++%2Fo%5C%5C+++%22%2C%22+++++%7C%7C++++%22%5D%0A%5B%22++++%7C%7C++++%22%2C%22+++%2Fo%5C%5C++++%22%2C%22+++++%7C%7C++++%22%5D%0A%5B%22++++%7C%7C++++%22%2C%22++%2Fo%5C%5C%7C++++%22%2C%22+++++%7C%7C++++%22%5D%0A%5B%22++++%7C%7C++++%22%2C%22++++%7C%2Fo%5C%5C++%22%2C%22+++++%7C%7C++++%22%5D%0A%5B%22++++%7C%7C++++%22%2C%22+%2Fo%5C%5C%7C%7C++++%22%2C%22+++++%7C%7C++++%22%5D%0A%5B%22++++%7C%7C++++%22%2C%22++++%7C%7C%2Fo%5C%5C+%22%2C%22+++++%7C%7C++++%22%5D%0A%5B%22++++%7C%7C++++%22%2C%22++++%7C%7C++++%22%2C%22++++%2Fo%5C%5C++++%22%5D&debug=0)
[Answer]
# Pyret, 79 bytes
```
{(l):all2({(r,n):string-char-at(n,string-index-of(r,"o") == "|")},l,link(0,l))}
```
Expects an array of lines as strings. Makes a copy in `link(0,l)` where all rows shifted down by one. Goes through each row `r` and `n` where n is the row below r. Checks that if Jimmy's body `"o"` is at some position, then the row below it has a pipe there (i.e. Jimmy's hanging on the rope and isn't at the bottom).
[Answer]
# [SnakeEx](http://www.brianmacintosh.com/snakeex/spec.html), 7 bytes
```
j:<R>o|
```
[Try it here!](http://www.brianmacintosh.com/snakeex/)
### Explanation
The only necessary and sufficient condition is that Jimmy's torso has to have a rope character below it.
```
j:       Define the main snake, j (for Jimmy)
  <R>    Pivot right (i.e. downward, since the snake starts out moving to the right)
     o   Match Jimmy's torso and move down
      |  Match a rope character
```
[Answer]
# [Rockstar](https://codewithrockstar.com/), ~~147~~ ~~146~~ 137 bytes
Outputs `0` for `false` and `1` for `true`
```
listen to J
Y's 0
while J
cut J
listen to R
X's 0
while J
let S be R at X
let Y be+roll J's "o" and S's "|"
let X be+1
let J be R
say Y
```
[Try it here](https://codewithrockstar.com/online) (Code will need to be pasted in)
```
listen to J     :Read first line of input into variable J
Y's 0           :Initialise Y as 0
while J         :While J exists
cut J           :  Split J into an array
listen to R     :  Read next line of input into variable R
X's 0           :  Initialise X as 0
while J         :  While J is not empty
let S be        :    Assign to variable S
  R at X        :      The character in R at 0-based index S
let Y be+       :    Increment Y by
  roll J        :      Pop the first element from J
  's "o"        :      Eqaul to "o"?
  and           :      Logical AND with
  S's "|"       :      S is equal to "|"
let X be+1      :    Increment X
                :  End while loop
let J be R      :  Reassign R to J
                :End while loop
say Y           :Output Y
```
]