[Question]
  [
# Backstory
Meet my friend Jimmy:
```
/o\
```
Jimmy is a little character who likes to stand on platforms. Here's Jimmy safely standing on a platform:
```
         /o\
  -------------
```
Now, Jimmy has a good sense of balance, so he can safely stand with one leg off of the platform, like so:
```
   /o\
    -------------------
```
Although if he stands with two or more body parts off of the platform, he will fall. Both of these are examples where Jimmy will fall:
```
/o\                                       /o\
  ----------        ----------------------   
```
# The challenge
Your challenge is to write a program to determine, given a string with Jimmy's platform and position, if Jimmy can stand on the platform without falling off.
* Input: Two lines showing Jimmy's position and the position of the platform under him. This can be from two separate inputs, a single input, or an array of some sort.
1. You may take input through any reasonable form, includings functions and standard input. Only resort to hard-coding if your language does not support the other input methods.
* Output: The boolean values true and false, or the integers 1 or 0 to represent true/false respectively.
1. The boolean value is based off of whether Jimmy can stay on the platform or not - true if Jimmy can stay on the platform, or false if he will fall off.
* The platform size is arbitrary and can be changed at will. Your program should account for that.
1. The platform cannot be a length of zero, and the platform must be complete (no holes in the platform).
2. Remember that Jimmy falls off when two of his body parts are hanging off the platform. A body part is one ASCII character of his body.
3. Trailing whitespace at the end of the platform is not required, but your program should account for both situations, where there is whitespace after the platform and where there is not.
* Be mindful of the [standard loopholes](https://codegolf.meta.stackexchange.com/q/1061/) that are forbidden.
# Test cases
```
         /o\               ✔️ TRUE
  -------------
/o\                        ✔️ TRUE
 ----------
                    /o\    ❌ FALSE
  ------------------
               /o\         ❌ FALSE
  -------
    /o\                    ❌ FALSE
     -
```
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so lowest byte count wins.
  
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), 6 bytes
```
n⁶Sċ2Ẓ
```
[Try it online!](https://tio.run/##y0rNyan8/z/vUeO24CPdRg93Tfr//3@0un5@TIy6joK6gq56LAA "Jelly – Try It Online")
Explanation:
```
n⁶Sċ2Ẓ  args: z (e.g. [['/', 'o', '\\'], [' ', '-']] => 0)
        implicit return value: z ([['/', 'o', '\\'], [' ', '-']])
n⁶      dyad-nilad pair ([[1, 1, 1], [0, 1]])
 ⁶       4th command-line argument or space [4th CLA assumed absent] (' ')
n        vectorized inequality ([[1, 1, 1], [0, 1]])
  S     reduction by addition with base case 0 ([1, 2, 1])
   ċ2   dyad-nilad pair (1)
    2    literal (2)
   ċ     number of occurrences of right in left (1)
     Ẓ  primality (0)
```
[Answer]
# JavaScript (ES6), 38 bytes
Takes input as `(a)(b)`. Returns \$0\$ or \$1\$.
```
a=>b=>b[a.search`o`]=='-'&/--/.test(b)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/R1i4JiKIT9YpTE4uSMxLyE2JtbdV11dX0dXX19UpSi0s0kjT/J@fnFefnpOrl5KdrpHEpKGgoKcCAfn5MjAICKGlCpXWRAZKsJhemYWhmYBiGaRAew7AZBLIAu8tgphJnGNyh6IZhuJsSw/BoR/EIEOhCLPsPAA "JavaScript (Node.js) – Try It Online")
### How?
We look for the position of the middle part `"o"` of Jimmy's body in the first string and test wether there's a dash in the second string at the same position.
```
b[a.search`o`] == '-'
```
The only case where Jimmy would be unsafe in this situation is with a single-dash platform:
```
/o\
 -
```
So we additionally make sure that the platform has a width of at least \$2\$:
```
/--/.test(b)
```
---
# JavaScript (ES6), 36 bytes
Alternate version if we assume that there's always either dashes or spaces below Jimmy (i.e. the input is rectangular).
```
a=>b=>b[a.search`o`]!=0&/--/.test(b)
```
[Try it online!](https://tio.run/##y0osSyxOLsosKNHNy09J/Z9m@z/R1i4JiKIT9YpTE4uSMxLyE2IVbQ3U9HV19fVKUotLNJI0/yfn5xXn56Tq5eSna6RxKShoKCnAgH5@TIwCAihpQqV1kQGSrCYXpmFoZmAYhmkQHsOwGQSyALvLYKYSZxjcoeiGYbgbl2EoLgECXYjq/wA "JavaScript (Node.js) – Try It Online")
Takes advantage of the fact that the coercion to a numeric value is \$0\$ for a space and *NaN* for a dash.
[Answer]
## Python 3, ~~88~~ 43 bytes
Input is given in the form of a list containing two strings: the first string is the first line; the second string is the second line.
```
lambda a:sum(1-(" "in i)for i in zip(*a))>1
```
[Try it online!](https://tio.run/##bY5BCsIwEEX3PcWnqxkxSHBX0ItYFxENHWiTUFNELx8LVoyat5lZvD/zwz123m2TxQ5t6s1wOhuY5joNpBXVqMVB2PoRgnl9SKCVYd7rdOukv0A3CKO4SJYO4sIUidfLPDInvNn4Ft9UgMqp/pXMzbyS8Mr@niz6@ZtPoCqXXKQZ9QQ)
Another version, tying for 43 bytes (I haven't been able to get it shorter than 43):
```
lambda a,b:b[a.find("/"):][:3].count("-")>1
```
[Try it online!](https://tio.run/##K6gsycjPM/6fpmCrEPM/JzE3KSVRIVEnySopOlEvLTMvRUNJX0nTKjbayjhWLzm/NK9EQ0lXSdPO8H95RmZOqoKhlUJBUSZQNE0jM6@gtERDUwdKa2r@V4AB/fwYBVTApaCgiwy4MJUgqUVSh00BRC@6kVjVI1uD0MCF3ZFQRUCgCwA)
Down by 42 bytes thanks to a tip from Jo King.
Old Version:
```
lambda s:sum((s.split("\n")[1]+" "*len(s))[i]=="-"and s[i]!=" "for i in range(len(s)))>1
```
-2 bytes thanks to Sriotchilism O'Zaic.
This works by taking two separate inputs, then pairing up corresponding letters. It counts the number of pairs where neither character is a space, then returns True if that number is greater than 1.
[Answer]
# Excel, ~~67~~ ~~45~~ 44 bytes
```
=(MID(A2,FIND("o",A1),1)="-")*(TRIM(A2)>"-")
```
Put Jimmy in `A1`, on a platform in `A2`.
2 conditions checked:
* Is Jimmy's torso (`o`) on the platform?
* Is the platform more than just `-`?
[Answer]
# [Python 2](https://docs.python.org/2/), ~~42~~ 37 bytes
```
lambda j,p:'--'in p[j.find('/'):][:3]
```
[Try it online!](https://tio.run/##fYxBCsMgEEXX8RSzG4WaQLsTss0lYhYJVmpIjUQ3Pb0VjNCA9O2G99@4T3jt9h51L@M2vxc1w3pzAjlHY8GNa6uNVRQ7ZGIaxWOK6qlhoJ4J0rjD2ACeNCmBHnzr3WYCRWmRFatpkuUiZKCICIVul5IA8F@SZ3mWbc1Ahdqv/9m1uM5Ol8gifgE "Python 2 – Try It Online")
5 bytes thx to [negative seven](https://codegolf.stackexchange.com/users/86422/negative-seven)
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), 18 bytes
```
{?/''B|Bq/}o&[~^]
```
[Try it online!](https://tio.run/##K0gtyjH7n1upoJamYPu/2l5fnUndqcapUL82Xy26Li72vzVXWn6RQk5mXmqxXlF@SX6RhpGmQjWXAhAUJ1YqpGnUqMRrctX@V4AB/fwYBVQAVKyLDLgwlSCpRVKHTQFEL7qRWNUjW4PQwIXdkVBFQKALAA "Perl 6 – Try It Online")
Takes a two parameters and returns a boolean of whether Jimmy will stay on the platform. This works by XORing the two lines together and checking if either part of Jimmy is still on the platform.
### Explanation:
```
             &[~^]   # String XOR operator
{          }o        # Combined with the anonymous function
 ?/       /          # That checks for the regex match
   ''B              # Unprintable, B, which is "/o" ~^ "--"
       |Bq           # Or B, q, which is "o\" ~^ "--"
```
[Answer]
# [Haskell](https://www.haskell.org/), 34 bytes
```
a#b=[1|(p,'-')<-zip a b,p>' ']>[1]
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/P1E5yTbasEajQEddV13TRrcqs0AhUSFJp8BOXUE91i7aMPZ/bmJmnm1BUWZeiYqSfn5MjJKykoKu0n8A "Haskell – Try It Online")
I got this one by combining my below technique with [the other haskell answer](https://codegolf.stackexchange.com/a/187599/56656).
# [Haskell](https://www.haskell.org/), 45 bytes
```
x#'-'|x/=' '=1
x#y=0
(((>1).sum).).zipWith(#)
```
[Try it online!](https://tio.run/##y0gszk7Nyfn/v0JZXVe9pkLfVl1B3daQq0K50taAK81WQ0PDzlBTr7g0V1NPU68qsyA8syRDQ1nzf25iZp5tQVFmXolKmpJ@fkyMkoKSgq7SfwA "Haskell – Try It Online")
This counts the number of body parts (non-space characters) that are on top of the platform and then checks it is greater than 1. The reason we count body parts on the platform rather than body parts off is that `zipWith` will chop the top line to be the length of the bottom and thus can chop off Jimmy's body parts. This prevents us from having to do something like `cycle" "` to pad the list.
[Answer]
# [///](https://esolangs.org/wiki////), ~~85 93~~ 87 bytes
```
/~/\/\///\/o\\/(o)~ 
/
~
~/ (o) /(o)~ (o)-/(o)~- -/--~(o) - ~/) ~/)-~/o~/(-/1~-~/(~/)~ 
```
[Try it online!](https://tio.run/##JYmxCsBADEL3fEXGu0Gk/5OlQ6FDIcPt/nqaaxHlqes5132tKorRYjsjOHLKjSYTvYv/Swc@goOA9gMX5zbEFAd4qHH0Iq96AQ "/// – Try It Online")
Output's a 1 if Jimmy is safe. Otherwise outputs nothing. (Unary 1 and 0.) Because there is no other way to take input in ///, it needs to be hard-coded:
```
/~/\/\///\/o\\/(o)~ 
/
~
~/ (o) /(o)~ (o)-/(o)~- -/--~(o) - ~/) ~/)-~/o~/(-/1~-~/(~/)~ //<INPUT HERE> 
```
For example:
```
/\/o\\/(o)// 
/
//
/// (o) /(o)// (o)-/(o)//- -/--//(o) - ///) ///)-///o///(-/1//-///(///)//         /o\
  ------------- 
```
([Try it online!](https://tio.run/##TU0xCsAwENrzCsdkEOl/snQodChkyP@5ek0LlTtR8bh57fM8ZoS6Ru@qo0koKsoR7PGGZi5JUKTSgHCtPeREw1upzaVUGfv0g1@UpfgHIm4 "/// – Try It Online"))
Note the space after the `<INPUT HERE>`.
**Explanation:**
NOTE! The explanation code cannot be run due to the comments. The comments are enclosed in curly braces. Also, the original code uses a golf where `//` is replaced with `~`. This code is omitted from the explanation.
```
/\/o\\/(o)/            {replace Jimmy with a Jimmy with curvy arms, because slashes are hard to manipulate in this language}
/ 
/
/                      {remove unneeded spaces after Jimmy, but before the floor}
/
//                     {get rid of the line break
/ (o) /(o)/            {remove all the spaces before both Jimmy and the floor}
/ (o)-/(o)/            {for each floor tile, remove it and one space before Jimmy. This detects whether Jimmy lines up with the floor.}
                       {If Jimmy is before the floor, then there will be extra floor.}
                       {If Jimmy is behind the floor, then there will be extra spaces before Jimmy.}
/- -/--/               {Handle the case where there is a hole beneath Jimmy but he is still well-supported}
/(o) - //              {Handle the case where only Jimmy's head is on the floor. The space at the end of the code is necessary for this.}
/) //                  {The rest of the substitutions clean up the result and handle each of the possible results that could exist at this point}
/)-//
/o//
/(-/1/
/-//
/(//
/)//
              /o\   
               --
 {there is a space right before this comment. The comment is only here to make the space visible and explain itself.}
```
---
* +8 bytes to fix a bug
* -6 bytes by applying a standard `///` golf trick.
[Answer]
# [///](https://esolangs.org/wiki////), 57 bytes
```
/|/\/\///\/o\\/J| J/J*|
/|* /|  -/  | /|*-/|--/!|-/|*/|J|
```
[Try it online!](https://tio.run/##LYuhDcBADAP5T@HSSJH3yAwhBZUevFQQ6t3TgNo6@Yjr3LWf6qaYUw5vJkMIhmlRBgpwAhozp9x5adaoUAOYy4L/6Q8 "/// – Try It Online")
Append the input to the end of the program in order to run. Returns the empty string if Jimmy falls off the platform, a string of exclamation points otherwise.
* `/|/\/\//` replaces `|` with `//`, which makes the code both shorter and more readable (`|` is used to demarcate each replacement)
* `/\/o\\/J| J/J*/` replaces Jimmy with `J` for brevity and changes the space to the left of him to `*` to the right of him
* The next replacement gets rid of newlines.
* `/* /| -/ | //` cancels out `*`s and with the space to the left of the platform. If there are two or more spaces left, Jimmy is falling off to the left, and the platform is deleted. This part also removes any whitespace to the right of the platform.
* `/*-/|--/!/` cancels out `*`s and with length of the platform. If there are at least two `-` left, Jimmy isn't falling off to the right, so they are replaced with a `!`.
* `/-/|*/|J//` deletes every remaining character that isn't `!`
[Answer]
# Dyalog APL Extended, ~~11~~ ~~10~~ 8 bytes
```
2≤1⊥∧⌿⍤<
```
[Try it online!](https://tio.run/##SyzI0U2pTMzJT9dNrShJzUtJTfn/3@hR5xLDR11LH3Usf9Sz/1HvEpv/aY/aJjzq7XvUN9XT/1FX86H1xo/aJgJ5wUHOQDLEwzP4f5oCUEhdQUE/P0ZBQV1BXRcC1LnQJRQUgMJAFlYJBewSCrh0AGVwGKWA0yhcEiA5dQA "APL (Dyalog Extended) – Try It Online")
Explanation:
```
2≤1⊥∧⌿⍤<  a monadic train
       <  Compare the input with the implicit prototype element - a space.
          Returns a boolean matrix of characters that are greater than 0x20
    ∧⌿⍤   and-reduce that, i.e. places where both Jimmy and a platform is
  1⊥      base 1 decode, aka sum - the amount of body parts over the platform
2≤        is that greater-or-equal to 2?
```
-2 thanks to Adám.
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf), ~~6~~ 14 bytes
```
`^@╞^αmÆû-oñ╧╙
```
[Try it online!](https://tio.run/##y00syUjPz0n7/z8hzuHR1Hlx5zbmHm47vFs3//DGR1OXP5o68/9/dQUY0M@PiQFS6kCooIsM1LnUoXIwAFKDIq@ABYD0YBqGQwe6YqgKuDAQwNwB5APl/wMA "MathGolf – Try It Online")
8 bytes had to be added to account for the edge case presented by Nick Kennedy.
Checks if `"-o-"` is a substring of the zipped string of both lines, and the zipped string where the first input line has the first character removed. Takes input as two separate strings, with the only change being that the character is input as `/o\\`, since `\\` is the correct way to input a backslash in a string in MathGolf. 
## Explanation
```
`                duplicate the top two items
 ^               zip top two elements on stack
  @              rrot3
   ╞             discard from left of string/array
    ^            zip top two elements on stack
     α           wrap last two elements in array
      mÆ         explicit map using 5 operators
        û-oñ     push "-o" and palindromize to make "-o-"
            ╧    pop a, b, a.contains(b)
                 map block ends here
             ╙   max of list
```
[Answer]
# [chevron](https://ch.superloach.xyz/?inp=&src=PiA-XmoKMD5eaQpeaSsxPj5eaQpeaixeaX5jPj5eaAotPisyPz9eaD0vCi0-LTMKPiA-XnEKXnF-cz4-XnMKLT4rNT9eaT5ecwpeX3A-XnMKXnFec15zLF5pLDN-Yz4-XnAKLT4rMj8_XnNec15zfl5zXnBecwo-PDEKPjww) - 126 bytes
not an improvement over my old answer (at all), but rewritten after a rewrite of chevron itself.
```
> >^j
0>^i
^i+1>>^i
^j,^i~c>>^h
->+2??^h=/
->-3
> >^q
^q~s>>^s
->+5?^i>^s
^_p>^s
^q^s^s,^i,3~c>>^p
->+2??^s^s^s~^s^p^s
><1
><0
```
[Answer]
# [05AB1E (legacy)](https://github.com/Adriandmen/05AB1E/wiki/Commands), ~~9~~ ~~8~~ 7 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
ζðм2ùgp
```
-1 byte thanks to *@Mr.Xcoder* with the approach of `ðм2ù`.
Input as a list of two strings.
Only works in the legacy version of 05AB1E, because `ζ` can transpose a list of strings as well as a 2D list of characters, whereas the `ζ` in the new 05AB1E version only works with the 2D list of characters.
[Try it online](https://tio.run/##MzBNTDJM/V/z/9y2wxsu7DE6vDO94P9/BSxAPz@GS0FBFwMAAA) or [verify all test cases](https://tio.run/##MzBNTDJM/V9W@f/ctsMbLuwxOrwzveC/zv/oaCUFGNDPj4lR0gHydZGBUqxOtBJMCk1YAQvAbgpOPejKUa1Tio0FAA).
**Explanation:**
```
ζ        # Zip/transpose; swapping rows/columns, with space as default filler
 ðм      # Remove all spaces from each string
   2ù    # Only leave strings of size 2
     g   # Count how many there are left
      p  # Check if this is a prime (2 or 3)
         # (after which the result is output implicitly)
```
[Answer]
# [Ruby](https://www.ruby-lang.org/), 28 bytes
```
->a,b{!(/--/!~b[a=~/\//,3])}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1y5RJ6laUUNfV1dfsS4pOtG2Tj9GX1/HOFaz9n@FrY1NBZcCDOjnx8QAebrIgAsiiCSggAVg04lVNapCLiQhINDlquCq0MvJzEst1ktNTM6IL87JTE7VMNKsrimqKSgtKVYo0kmL1iqKrf0PAA "Ruby – Try It Online")
[Answer]
# Excel, 36 bytes
```
=LEN(TRIM(MID(A2,FIND("/",A1),3)))>1
```
Jimmy in `A1`, on a platform in `A2`.
Finds the position of Jimmy, and takes the 3 bytes of the platform and trims off spaces. If the resulting platform length is long enough, Jimmy stands.
[Answer]
# EXCEL, ~~94~~ 71 bytes . ~~VBA (Excel), 87 bytes~~
`A1` = Jimmy , `A2` = platform
-23 bytes. Thank you @Wernisch.
```
=(FIND("-",A2)-FIND("/",A1)<2)*(FIND("\",A1)-LEN(A2)<2)*(TRIM(A2)<>"-")
```
~~?`[(FIND("-",A2)-FIND("/",A1)<2)*(FIND("\",A1)-LEN(A2)<2)]*(len(replace([A2]," ",""))>1)`~~
[Answer]
# [Husk](https://github.com/barbuz/Husk), 5 bytes
```
¬εδ#&
```
[Try it online!](https://tio.run/##yygtzv6f6/aoqfH/oTXntp7boqz2////aA0lBRjQz4@JUdIB8nWRgZKmjoYSTApNWAELwG4KTj3oyuFq4BJAABSNBQA "Husk – Try It Online") This function takes the two lines as separate arguments. `δ#&` zips the two strings together and counts the number of pairs in which both characters are truthy, i.e., neither is a space character, and `¬ε` tests that the count is greater than 1.
[Answer]
# [R](https://www.r-project.org/), 35 bytes
```
function(x)sum(colSums(x!=" ")>1)>1
```
[Try it online!](https://tio.run/##K/qfZvs/rTQvuSQzP0@jQrO4NFcjOT8nuDS3WKNC0VZJQUnTzhCI/qdpFCVl5qVoJGsAxXTgWB@I84E4JkZJUwcopwtko2OgGZqa/wE "R – Try It Online")
Based on [@EriktheOutgolfer’s excellent Jelly answer](https://codegolf.stackexchange.com/a/187589/42248) so please upvote that one too!
Input is a 2-d matrix of characters.
[Answer]
# Haskell, 59 bytes
```
f a b=sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2
```
[Try it online!](https://tio.run/##hY/dCoJAEIXvfYrDImioSF67b9AbZODfqEvr@rddFL27qaGEBZ2LgTnfGWamSoYrSTmOBRKkXJIqdXW2W7c7PJcaeg/RIjFTx8numSQG5rYxSapj5jdRxNyOcwvWJQzGOhEKHHljYJI8IvRQkj4JRW8n2DuimGM@ByOVM@iK1Do@q@2F0jCxpGSw@fOipSE5EHrSt17BPowrx3TZxL1PGZu9A9/4L/8ZWKhnTI@8AA "Haskell – Try It Online")
The function is called like so: `f "/o\\ " " -- "`
How it works (for `f "/o\\" " -"`):
`b++cycle" "` - Adds an infinite number of spaces after `b` to ensure that Jimmy is always above a `-` or  (`" -"` → `" - ..."`
`zip a$b++cycle" "` - Zips the two strings together (`[('/',' '), ('o','-'), ('\\',' ')]`)
`(p,q)<-zip a$b++cycle` - For each pair in the zipped list
`[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']` - Generates a list of `1`s, whose length is the number of pairs satisfying the conditions:
`elem p"/o\\"` - The character in the top string is one of Jimmy's body parts. (Satisfied by all three pairs in this example)
`q==' '` - The character in the bottom string is a space. (Satisfied by `('/', ' ')` and `('\\', ' ')`)
So, the pair has to be one where one of Jimmy's body parts is above a space.
Because in this example, two pairs satisfy both conditions, the list is `[1,1]`
`sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']` - Take the sum of those `1`s (i.e. the length of the list), which in this example is `2`.
`sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2` - Check if the number of body parts above a space is less than 2. In this example, it's not, so Jimmy will fall off. :(
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 73 bytes
```
f(s,t,c)char*s,*t;{for(t=strchr(s,c=10);*s%5**t;)c-=*++t%2**s++%8;c=c<0;}
```
[Try it online!](https://tio.run/##lY1BCsIwEEX3nmIIBJJJilUQCjE3yaaM1HZhKkl2pWePAS2IBNG3Gua/P0PNlSjnQUSdNEka@4BRYzLLMAeRbEyBxlBSsodWGoz8hCWV1FhUKvEjYlSKd4YsnVuz5sknuPWTFxKWHcA9lMUgGL84zzSUCTb2s3POAzTvMClNtfayfzChQvXXX2c@LnytbW7hKa75AQ "C (gcc) – Try It Online")
[Answer]
# Kotlin, 60 bytes
```
fun String.c(b:String)=zip(b){i,j->i>' '&&j>' '}.count{it}>1
```
Explanation:
```
fun String.c  # Define an extension function on string, so we don't have to provide a first argument (and we also have string method calls for free)
(b:String)    # Pass the second string as argument
=             # Shorthand syntax for fun body
zip(b)        # Essentially a.zip(b). Creates a List<Pair> by joining both arrays. 
              # Takes care of trailing whitespace, because it will be the size of the smaller array
{i,j->        # Declare a transformer lambda as second function argument
i>' '&&j>' '} # This essentially translates to: If i!=' ' and j=='-'
.count{it}    # Count the true values
>1
```
[Answer]
# [Julia 1.0](http://julialang.org/), ~~42~~ 40 bytes
```
y(a,b)=strip(b[findfirst("/o\\",a)])>"-"
```
[Try it online!](https://tio.run/##yyrNyUw0rPj/v1IjUSdJ07a4pCizQCMpOi0zLyUts6i4RENJPz8mRkknUTNW005JVwmokEsBCJRABEgKxNaBC@mCgYISl6ZCjZ1CQVFmXklOHhd@PRBdJOiB2AFmouohbBGmpv8A)
[Answer]
# [SnakeEx](http://www.brianmacintosh.com/snakeex/spec.html), 13 bytes
```
j:<R>o<T>\-\-
```
SnakeEx does well because it's a 2D pattern-matching language, but not too well because it wasn't designed to be very golfy. [Try it here!](http://www.brianmacintosh.com/snakeex/)
### Explanation
```
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 (or is it his head?) and move down
      <T>      Turn either left or right
         \-\-  Match two platform characters
```
This will match if there are two platform characters under Jimmy, or fail to match if there are not. We don't need to consider the case where there are platforms only under his legs, since the platform cannot have holes.
[Answer]
# [Japt](https://github.com/ETHproductions/japt), 8 bytes
```
Õ·kèS Êz
```
[Try it](https://petershaggynoble.github.io/Japt-Interpreter/?v=1.4.6&code=1bdr6FMgyno&input=Ii9vXAogLSI)
[Answer]
# [Retina 0.8.2](https://github.com/m-ender/retina/wiki/The-Language/a950ad7d925ec9316e3e2fb2cf5d49fd15d23e3d), 16 bytes
```
 (.*¶).
$1
¶ ?--
```
[Try it online!](https://tio.run/##K0otycxL/H9oG1c8V3y8NheQoaoRnBD/X0FDT@vQNk09LhVDoKCCva7u//8KMKCfH8OloKCLDLi4wILIAgpYABad2FWjKITIQoSAQBcA "Retina 0.8.2 – Try It Online") Link includes test suite. Explanation:
```
+`^ (.*¶).
$1
```
While there is still a space on the first line, and both lines still have more than one character, delete the space and the first character of the next line. Note: This assumes that there is no trailing space after Jimmy. +1 byte needed if trailing space needs to be allowed.
```
¶ ?--
```
Check that there are at least two pieces of platform under Jimmy.
[Answer]
# [Perl 5](https://www.perl.org/) `-pl`, 42 bytes
```
/o/g;$_=(($_=<>)=~/./g)[-1+pos]eq'-'&&/--/
```
[Try it online!](https://tio.run/##K0gtyjH9/18/Xz/dWiXeVkMDSNjYadrW6evpp2tG6xpqF@QXx6YWquuqq6np6@rq//@voKCgnx@jAAJcQKyrq/svv6AkMz@v@L@ur6megaHBf92CHAA "Perl 5 – Try It Online")
[Answer]
# Ruby 2.5.3, 44 bytes
```
->a,b{a.zip(b).map(&:join).grep(/\S-/).size>1}
```
Input taken as two arrays. Definitely not the most golf-friendly approach (see G B's answer), but I like any excuse to use the `zip` function.
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~63..55~~ 53 bytes
-1 byte thanks to mazzy
```
param($j,$f)''+($f|% t*y|?{$j[$i++]-gt32})-match'- -'
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfmvkmZb/b8gsSgxV0MlS0clTVNdXVtDJa1GVaFEq7LGvlolK1olU1s7Vje9xNioVlM3N7EkOUNdV0FX/b9KFpdKGpe6OlctF5eaSpqCkgIM6OfHgDhKushACaIILKekgCGugAmgShV0MQCaWbiNIMEUZCf9BwA "PowerShell – Try It Online")
Takes input as two lines. 
Unrolled:
```
param($j,$f)            #Take $jimmy and $floor
''+                     #Implicitly converts next part to string
($f |% ToCharArray      #Convert $f to a char[] and...
    |?{                 #Only take the chars where...
        $j[$i++]-gt32   #The same indexed char in $j's ASCII # is > ' ' i.e. only get /o\
     }
)-match'- -'            #Arrays.ToString are joined with a space and we need 2 -'s
```
[Answer]
# 40 column Commodore BASIC (C64, C16/+4, C128, PET, C64Mini) - non-competing`*` - 98 tokenized and BASIC bytes used
```
 0a=rN(.)*36:b=rN(.)*39:c=-rN(.)*(b-39):fOi=0tob:a$=a$+"-":nE:?tAa)"/o\
 1?tAc)a$:?-(a>c-2anda<c+b+2)
```
Here is the unobfuscated listing for explanation purposes
```
 0 let a=rnd(0) * 36
 1 let b=rnd(0) * 39
 2 let c=-rnd(0) * (b - 39)
 3 for i=0 to b
 4  let a$=a$+"-"
 5 next i
 6 print tab(a);"/o\"
 7 print tab(c);a$
 8 print -(a>c - 2 and a<c + b + 2)
```
The variable `a` is used for positioning Jimmy (using `PRINT TAB(A)` which is zero-indexed).
The varaible `b` is used for the length of the platform.
And finally the variable `c` is used for the position of the platform.
The loop in lines 3 through to 5 inclusive builds the platform for Jimmy, with line 6 printing Jimmy at his pre-determined position, and 7 for the pre-determined position of the platform. Finally, `1` or `0` is outputted to represent our `TRUE` or `FALSE` value.
Note, the listing includes keyword abbreviations to ensure we break the 80 character limit per line on standard Commodore C64 BASIC.
[![enter image description here](https://i.stack.imgur.com/Q2ZTp.png)](https://i.stack.imgur.com/Q2ZTp.png)
`* Assumed non-competing because PETSCII is not ASCII. Jimmy looks better in PETSCII though, of course.`
[Answer]
# [C# (Visual C# Interactive Compiler)](http://www.mono-project.com/docs/about-mono/releases/5.0.0/#csc), ~~44~~ ~~40~~ 39 bytes
*-4 bytes thanks to Jo King*
```
a=>b=>a.Zip(b,(x,y)=>x>y?y:0).Sum()>109
```
[Try it online!](https://tio.run/##Sy7WTS7O/O9WmpdsU1xSlJmXroPMTsrPz7GzU0hTsP2faGuXZGuXqBeVWaCRpKNRoVOpaWtXYVdpX2lloKkXXJqroWlnaGD535qLK7wosyTVJzMvVSNNQ0kBBvTzY2KAlJImlwICgOR1kYGSpuZ/AA "C# (Visual C# Interactive Compiler) – Try It Online")
]