Python 2 or 3,  33  30 bytes

-3 thanks to Maxwell

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

An unnamed function accepting a list of lines

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)

Python 2, 28 bytes

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

Try it online!

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.)

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.

Jelly,  9 7  6 bytes

Ṗ<”|ṀẠ

A monadic Link accepting a list of lines

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?

brainfuck, 79 64 bytes

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

Try it online!

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

Grime, 5 bytes

o/|

Try it online!

The right tool for the job.

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

Stax, 6 bytes

é¿┤4╠q

Run and debug it

Transposes the input, then searches for "o|".

APL (Dyalog Unicode), 8 bytes^SBCS

Anonymous tacit prefix function, taking a character matrix as argument.

1∊'o|'⍷⍉

Try it online!

⍉ transpose

'o|'⍷ mask for everywhere o is immediate followed by |

1∊ is one a member thereof?

Dyalog APL Extended, 14 13 11 9 bytes

3∊¯1+/⍤↓<

Try it online!

05AB1E, 5 bytes

Çü%àθ

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.

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!

///, 53 50 bytes

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

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!

Ruby 2.5.5, 22 bytes

->x/

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.

Kotlin, 93 84 bytes

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

Try it online!

JavaScript, 38 37 bytes

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

Try it online!

Retina, 9 bytes

m`^[^|]+^

Try it online!

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!

Perl 5 -p, 26 bytes

$||=!/|/;$;=/o/}improve this answer