backstory

พบกับจิมมี่เพื่อนของฉัน:

/o\

จิมมี่เป็นตัวละครตัวเล็ก ๆ ที่ชอบยืนบนแพลตฟอร์ม นี่คือจิมมี่ยืนบนแพลตฟอร์มอย่างปลอดภัย:

         /o\
  -------------

ตอนนี้จิมมี่มีความสมดุลที่ดีดังนั้นเขาจึงสามารถยืนได้อย่างปลอดภัยด้วยขาข้างหนึ่งออกจากแท่นอย่างเช่น:

   /o\
    -------------------

แม้ว่าเขาจะยืนอยู่กับส่วนของร่างกายสองชิ้นหรือมากกว่าจากแพลตฟอร์มเขาจะล้มลง ทั้งสองนี้เป็นตัวอย่างที่ Jimmy จะล้ม:

/o\                                       /o\
  ----------        ----------------------   

ความท้าทาย

ความท้าทายของคุณคือการเขียนโปรแกรมเพื่อตรวจสอบกำหนดสตริงด้วยแพลตฟอร์มและตำแหน่งของ Jimmy หาก Jimmy สามารถยืนบนแพลตฟอร์มได้โดยไม่ล้ม

• อินพุต: สองบรรทัดแสดงตำแหน่งของจิมมี่และตำแหน่งของแพลตฟอร์มใต้เขา สิ่งนี้อาจมาจากอินพุตสองแบบแยกกันอินพุตเดี่ยวหรืออาเรย์ของการเรียงลำดับบางอย่าง

  1. คุณสามารถรับอินพุตผ่านแบบฟอร์มที่สมเหตุสมผลรวมถึงฟังก์ชั่นและอินพุตมาตรฐาน ใช้การเข้ารหัสอย่างหนักหากภาษาของคุณไม่รองรับวิธีการป้อนข้อมูลอื่น ๆ

• เอาท์พุท: ค่าบูลีนจริงและเท็จหรือจำนวนเต็ม 1 หรือ 0 เพื่อเป็นตัวแทนของจริง / เท็จตามลำดับ

  1. ค่าบูลีนนั้นขึ้นอยู่กับว่า Jimmy สามารถอยู่บนแพลตฟอร์มได้หรือไม่ - จริงถ้า Jimmy สามารถอยู่บนแพลตฟอร์มได้หรือเป็นเท็จถ้าเขาจะหลุด

• ขนาดของแพลตฟอร์มนั้นสามารถเปลี่ยนแปลงได้ตามต้องการ โปรแกรมของคุณควรคำนึงถึงสิ่งนั้น

  1. แพลตฟอร์มต้องมีความยาวไม่เป็นศูนย์และแพลตฟอร์มต้องสมบูรณ์ (ไม่มีรูในแพลตฟอร์ม)

  2. โปรดจำไว้ว่าจิมมี่ตกลงไปเมื่อส่วนของร่างกายของเขาทั้งสองห้อยออกจากแท่น ส่วนของร่างกายคือหนึ่งตัวอักษร ASCII ของร่างกายของเขา

  3. ไม่จำเป็นต้องมีช่องว่าง Trailing ที่ส่วนท้ายของแพลตฟอร์ม แต่โปรแกรมของคุณควรคำนึงถึงทั้งสองกรณีที่มีช่องว่างหลังแพลตฟอร์มและที่ไม่มี

• ระวังช่องโหว่มาตรฐานที่ถูกห้าม

กรณีทดสอบ

         /o\               ✔️ TRUE
  -------------

/o\                        ✔️ TRUE
 ----------

                    /o\    ❌ FALSE
  ------------------

               /o\         ❌ FALSE
  -------

    /o\                    ❌ FALSE
     -

เกณฑ์การให้คะแนน

นี่คือโค้ดกอล์ฟดังนั้นจำนวนไบต์ที่น้อยที่สุดจึงชนะ

ลีดเดอร์บอร์ด

คุณสามารถดูกระดานแต้มนำสำหรับโพสต์นี้โดยขยายวิดเจ็ต / ตัวอย่างด้านล่าง เพื่อให้โพสต์ของคุณรวมอยู่ในการจัดอันดับคุณต้องมีส่วนหัว ( # header text) พร้อมข้อมูลต่อไปนี้:

• ชื่อของภาษา (ลงท้ายด้วยเครื่องหมายจุลภาค,หรือเส้นประ-) ตามด้วย ...

• จำนวนไบต์เป็นจำนวนสุดท้ายที่จะปรากฏในส่วนหัวของคุณ

ตัวอย่างเช่นJavaScript (ES6), 72 bytesถูกต้อง แต่Fortran, 143 bytes (8-bit)ไม่ถูกต้องเนื่องจากการนับไบต์ไม่ใช่ตัวเลขสุดท้ายในส่วนหัว (คำตอบของคุณจะถูกจดจำเป็น 8 ไบต์ - อย่าใช้ประโยชน์จากสิ่งนี้)

<!-- Run the snippet to see the leaderboard. Report any bugs to @xMikee1 on Github -->    <iframe src="https://xmikee1.github.io/ppcg-leaderboard/?id=187586" 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>

เยลลี่ 6 ไบต์

n⁶Sċ2Ẓ

ลองออนไลน์!

คำอธิบาย:

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)

JavaScript (ES6), 38 ไบต์

(a)(b)จะเข้าเป็น ผลตอบแทน$0$หรือ1$1$

a=>b=>b[a.search`o`]=='-'&/--/.test(b)

ลองออนไลน์!

อย่างไร?

เรามองหาตำแหน่งของส่วนตรงกลาง"o"ของร่างกายของจิมมี่ในสตริงแรกและทดสอบว่ามีเส้นประในสตริงที่สองที่ตำแหน่งเดียวกัน

b[a.search`o`] == '-'

กรณีเดียวที่ Jimmy อาจไม่ปลอดภัยในสถานการณ์นี้คือแพลตฟอร์มเดียว:

/o\
 -

ดังนั้นเราจึงต้องตรวจสอบให้แน่ใจว่าแพลตฟอร์มนั้นมีความกว้างอย่างน้อย$2$ :

/--/.test(b)

JavaScript (ES6), 36 ไบต์

รุ่นอื่นหากเราสมมติว่ามีเครื่องหมายขีดคั่นหรือช่องว่างด้านล่าง Jimmy อยู่เสมอ (เช่นอินพุตเป็นรูปสี่เหลี่ยมผืนผ้า)

a=>b=>b[a.search`o`]!=0&/--/.test(b)

ลองออนไลน์!

ใช้ประโยชน์จากความจริงที่ว่าการขู่เข็ญกับค่าตัวเลขคือ$0$สำหรับช่องว่างและNaNสำหรับเส้นประ

Excel, 67 45 44 ไบต์

=(MID(A2,FIND("o",A1),1)="-")*(TRIM(A2)>"-")

ใส่จิมมี่ในบนแพลตฟอร์มA1A2

ตรวจสอบ 2 เงื่อนไข:

• ลำตัวของ Jimmy oอยู่บนแพลตฟอร์มหรือไม่
• เป็นแพลตฟอร์มที่มากกว่าเพียงแค่-?

Python 3, 88 43 ไบต์

อินพุตถูกกำหนดในรูปแบบของรายการที่มีสองสตริง: สตริงแรกคือบรรทัดแรก สตริงที่สองคือบรรทัดที่สอง

lambda a:sum(1-(" "in i)for i in zip(*a))>1

ลองออนไลน์!

อีกรุ่นหนึ่งโดยคาดว่าจะเป็น 43 ไบต์ (ฉันไม่สามารถทำให้มันสั้นกว่า 43 ได้):

lambda a,b:b[a.find("/"):][:3].count("-")>1

ลองออนไลน์!

ลดลง 42 ไบต์ด้วยคำแนะนำจาก Jo King

เวอร์ชั่นเก่า:

lambda s:sum((s.split("\n")[1]+" "*len(s))[i]=="-"and s[i]!=" "for i in range(len(s)))>1

-2 ไบต์ขอบคุณ Sriotchilism O'Zaic

วิธีนี้ทำงานได้โดยใช้อินพุตแยกกันสองตัวจากนั้นจับคู่ตัวอักษรที่ตรงกัน มันนับจำนวนคู่ที่ไม่มีอักขระเป็นช่องว่างแล้วส่งกลับค่า True ถ้าตัวเลขนั้นมากกว่า 1

Perl 6 , 18 ไบต์

{?/''B|Bq/}o&[~^]

ลองออนไลน์!

รับพารามิเตอร์สองตัวและส่งคืนบูลีนว่า Jimmy จะอยู่บนแพลตฟอร์มหรือไม่ มันทำงานโดย XORing สองบรรทัดด้วยกันและตรวจสอบว่าส่วนหนึ่งของ Jimmy ยังคงอยู่บนแพลตฟอร์ม

คำอธิบาย:

             &[~^]   # 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\" ~^ "--"

Python 2 , 42 37 ไบต์

lambda j,p:'--'in p[j.find('/'):][:3]

ลองออนไลน์!

5 ไบต์ขอบคุณไปยังลบเจ็ด

Haskell , 34 ไบต์

a#b=[1|(p,'-')<-zip a b,p>' ']>[1]

ลองออนไลน์!

ฉันได้หนึ่งนี้โดยรวมเทคนิคด้านล่างของฉันกับคำตอบ Haskell อื่น ๆคำตอบที่

Haskell , 45 ไบต์

x#'-'|x/=' '=1
x#y=0
(((>1).sum).).zipWith(#)

ลองออนไลน์!

สิ่งนี้นับจำนวนชิ้นส่วนร่างกาย (อักขระที่ไม่ใช่ช่องว่าง) ที่อยู่ด้านบนของแพลตฟอร์มจากนั้นตรวจสอบว่ามีค่ามากกว่า 1 เหตุผลที่เรานับส่วนของร่างกายบนแพลตฟอร์มแทนที่จะปิดส่วนของร่างกายคือzipWithสับชิ้นส่วนบนสุด ที่จะเป็นความยาวของด้านล่างและสามารถตัดส่วนของร่างกายของจิมมี่ สิ่งนี้ทำให้เราไม่ต้องทำอะไรบางอย่างเช่นcycle" "การเรียงรายการ

MathGolf , 6 14 ไบต์

`^@╞^αmÆû-oñ╧╙

ลองออนไลน์!

ต้องเพิ่ม 8 ไบต์ในบัญชีสำหรับกรณีขอบที่นำเสนอโดย Nick Kennedy

ตรวจสอบว่า"-o-"เป็นสตริงย่อยของสตริงซิปของทั้งสองบรรทัดและสตริงซิปที่บรรทัดอินพุตแรกมีอักขระตัวแรกที่ถูกลบ รับอินพุตเป็นสองสตริงแยกกันโดยมีการเปลี่ยนแปลงเพียงอย่างเดียวคืออักขระนั้นถูกป้อนเข้า/o\\เนื่องจาก\\เป็นวิธีที่ถูกต้องในการใส่แบ็กสแลชในสตริงใน MathGolf

คำอธิบาย

`                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

05AB1E (เดิม) , 9 8 7 ไบต์

ζðм2ùgp

-1 ขอบคุณไบต์@ Mr.Xcoderðм2ùกับวิธีการของ

อินพุตเป็นรายการของสองสตริง

ใช้งานได้เฉพาะในรุ่นดั้งเดิมของ 05AB1E เท่านั้นเพราะζสามารถแปลงรายการสตริงรวมทั้งรายการอักขระสองมิติในขณะที่ζรุ่น 05AB1E ใหม่จะทำงานกับรายการอักขระ 2 มิติเท่านั้น

ลองมันออนไลน์หรือตรวจสอบกรณีทดสอบทั้งหมด

คำอธิบาย:

ζ        # 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)

Ruby , 28 ไบต์

->a,b{!(/--/!~b[a=~/\//,3])}

ลองออนไลน์!

Dyalog APL Extended, 11 10 8 ไบต์

2≤1⊥∧⌿⍤<

ลองออนไลน์!

คำอธิบาย:

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 ขอบคุณอะดา

Excel, 36 ไบต์

=LEN(TRIM(MID(A2,FIND("/",A1),3)))>1

จิมมี่ในบนแพลตฟอร์มA1A2

ค้นหาตำแหน่งของ Jimmy และใช้พื้นที่ขนาด 3 ไบต์และตัดพื้นที่ออก หากความยาวของแพลตฟอร์มที่ได้นั้นยาวพอจิมมี่ก็จะยืน

EXCEL, 94 71 ไบต์ VBA (Excel), 87 ไบต์

A1 = จิมมี่ A2 = แพลตฟอร์ม

-23 ไบต์ ขอบคุณ @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)

/// , 85 93 87 ไบต์

/~/\/\///\/o\\/(o)~ 
/
~
~/ (o) /(o)~ (o)-/(o)~- -/--~(o) - ~/) ~/)-~/o~/(-/1~-~/(~/)~ 

ลองออนไลน์!

ผลลัพธ์เป็น 1 ถ้า Jimmy ปลอดภัย มิฉะนั้นจะส่งผลอะไร (กลุ่มที่ 1 และ 0) เนื่องจากไม่มีวิธีอื่นที่จะรับอินพุตใน /// จึงจำเป็นต้องมีการเข้ารหัสแบบฮาร์ด:

/~/\/\///\/o\\/(o)~ 
/
~
~/ (o) /(o)~ (o)-/(o)~- -/--~(o) - ~/) ~/)-~/o~/(-/1~-~/(~/)~ //<INPUT HERE> 

ตัวอย่างเช่น:

/\/o\\/(o)// 
/
//
/// (o) /(o)// (o)-/(o)//- -/--//(o) - ///) ///)-///o///(-/1//-///(///)//         /o\
  ------------- 

( ลองออนไลน์! )

<INPUT HERE>หมายเหตุพื้นที่หลังจากที่

คำอธิบาย:

บันทึก! รหัสคำอธิบายไม่สามารถเรียกใช้เนื่องจากความคิดเห็น ความคิดเห็นที่อยู่ในวงเล็บปีกกา นอกจากนี้รหัสเดิมใช้สนามกอล์ฟที่จะถูกแทนที่ด้วย// ~รหัสนี้ถูกตัดออกจากคำอธิบาย

/\/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 ไบต์เพื่อแก้ไขข้อบกพร่อง
• -6 ไบต์โดยใช้ลูก///กอล์ฟมาตรฐาน

R , 35 ไบต์

function(x)sum(colSums(x!=" ")>1)>1

ลองออนไลน์!

ขึ้นอยู่กับคำตอบของ Jelly ที่ยอดเยี่ยมของ @ EriktheOutgolferดังนั้นโปรดด้วยเช่นกัน!

อินพุตเป็นเมทริกซ์ 2 มิติของอักขระ

Haskell, 59 ไบต์

f a b=sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2

ลองออนไลน์!

ฟังก์ชั่นที่เรียกว่าเช่นนั้น: f "/o\\ " " -- "

มันทำงานอย่างไร (สำหรับf "/o\\" " -"):

b++cycle" "- เพิ่มช่องว่างจำนวนไม่ จำกัด หลังจากนั้นbเพื่อให้แน่ใจว่า Jimmy อยู่เหนือ-หรือ( " -"→" - ..."

zip a$b++cycle" "- บีบทั้งสองสตริงเข้าด้วยกัน ( [('/',' '), ('o','-'), ('\\',' ')])

(p,q)<-zip a$b++cycle - สำหรับแต่ละคู่ในรายการซิป

[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- สร้างรายการของ1s ซึ่งความยาวคือจำนวนคู่ที่ตรงตามเงื่อนไข:

elem p"/o\\"- ตัวละครในสายอักขระด้านบนเป็นส่วนหนึ่งของร่างกายของ Jimmy (พอใจทั้งสามคู่ในตัวอย่างนี้)

q==' '- ตัวละครในสตริงด้านล่างเป็นช่องว่าง (พอใจ('/', ' ')และ('\\', ' '))

ดังนั้นทั้งคู่จะต้องเป็นหนึ่งในส่วนใดส่วนหนึ่งของร่างกายของจิมมี่อยู่เหนือพื้นที่

เนื่องจากในตัวอย่างนี้สองคู่เป็นไปตามเงื่อนไขทั้งสองรายการคือ [1,1]

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- ใช้ผลรวมของบรรดา1s (นั่นคือความยาวของรายการ) 2ซึ่งในตัวอย่างนี้คือ

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2- ตรวจสอบว่าจำนวนชิ้นส่วนของร่างกายเหนือพื้นที่น้อยกว่า 2 ในตัวอย่างนี้ไม่ใช่หรือไม่ดังนั้น Jimmy จะล้มลง :(

C (gcc) , 73 ไบต์

f(s,t,c)char*s,*t;{for(t=strchr(s,c=10);*s%5**t;)c-=*++t%2**s++%8;c=c<0;}

ลองออนไลน์!

Kotlin, 60 ไบต์

fun String.c(b:String)=zip(b){i,j->i>' '&&j>' '}.count{it}>1

คำอธิบาย:

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

/// , 57 ไบต์

/|/\/\///\/o\\/J| J/J*|
/|* /|  -/  | /|*-/|--/!|-/|*/|J|

ลองออนไลน์!

ผนวกอินพุตที่ส่วนท้ายของโปรแกรมเพื่อเรียกใช้ ส่งคืนสตริงว่างถ้า Jimmy ตกลงจากแพลตฟอร์มสตริงอัศเจรีย์เป็นอย่างอื่น

• /|/\/\//แทนที่|ด้วย//ซึ่งทำให้โค้ดทั้งสั้นและอ่านง่ายขึ้น ( |ใช้เพื่อกำหนดเขตการแทนที่แต่ละครั้ง)
• /\/o\\/J| J/J*/จิมมี่แทนที่ด้วยJความกะทัดรัดและเปลี่ยนพื้นที่ด้านซ้ายของเขาไป*ทางขวาของเขา
• การแทนที่ครั้งต่อไปจะกำจัดบรรทัดใหม่
• /* /| -/ | //ยกเลิก*s และมีพื้นที่ทางด้านซ้ายของแพลตฟอร์ม หากมีช่องว่างเหลืออีกสองช่องทาง Jimmy จะล้มไปทางซ้ายและแพลตฟอร์มจะถูกลบ ส่วนนี้ยังลบช่องว่างใด ๆ ทางด้านขวาของแพลตฟอร์ม
• /*-/|--/!/ยกเลิก*s และกับความยาวของแพลตฟอร์ม หากมีอย่างน้อยสอง-ทางซ้าย, !จิมมี่ไม่ได้หลุดออกไปทางขวาเพื่อให้พวกเขาจะถูกแทนที่ด้วย
• /-/|*/|J// ลบอักขระที่เหลือทั้งหมดที่ไม่ใช่ !

Japtet , 8 ไบต์

Õ·kèS Êz

ลองมัน

เรติน่า 0.8.2 , 16 ไบต์

 (.*¶).
$1
¶ ?--

ลองออนไลน์! การเชื่อมโยงรวมถึงชุดทดสอบ คำอธิบาย:

+`^ (.*¶).
$1

ในขณะที่ยังมีช่องว่างในบรรทัดแรกและทั้งสองบรรทัดยังมีอักขระมากกว่าหนึ่งตัวให้ลบช่องว่างและอักขระตัวแรกของบรรทัดถัดไป หมายเหตุ: นี่ถือว่าไม่มีช่องว่างท้ายหลังจากจิมมี่ จำเป็นต้องใช้ +1 ไบต์หากต้องการเว้นวรรคต่อท้าย

¶ ?--

ตรวจสอบว่ามีแพลตฟอร์มอย่างน้อยสองชิ้นภายใต้ Jimmy

Perl 5 -pl , 42 ไบต์

/o/g;$_=(($_=<>)=~/./g)[-1+pos]eq'-'&&/--/

ลองออนไลน์!

Ruby 2.5.3, 44 ไบต์

->a,b{a.zip(b).map(&:join).grep(/\S-/).size>1}

อินพุตถูกใช้เป็นสองอาร์เรย์ ไม่ใช่วิธีที่เป็นมิตรกับกอล์ฟมากที่สุด (ดูคำตอบของ GB) แต่ฉันชอบข้ออ้างที่จะใช้zipฟังก์ชั่นนี้

PowerShell , 63..55 53 ไบต์

^{-1 byte ขอบคุณ mazzy}

param($j,$f)''+($f|% t*y|?{$j[$i++]-gt32})-match'- -'

ลองออนไลน์!

รับอินพุตเป็นสองบรรทัด

คลี่:

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

C # (Visual C # Interactive Compiler) , 44 40 39 ไบต์

-4 ไบต์ขอบคุณ Jo King

a=>b=>a.Zip(b,(x,y)=>x>y?y:0).Sum()>109

ลองออนไลน์!

Python 3.7 , 71 56 Bytes

lambda s:sum(j in'/o\\'and p=='-'for j,p in zip(*s))>1

รุ่นที่ง่ายมากและสั้นที่สุดที่ฉันสามารถนึกได้ว่าใช้วิธีนี้ อินพุตsคือรายการของสองสตริงบรรทัดแรกสำหรับแถว Jimmy แถวที่สองสำหรับแพลตฟอร์ม ซิปอักขระที่อยู่เหนืออักขระอื่นจากนั้นตรวจสอบว่า-ด้านล่างเป็นส่วนหนึ่งของ Jimmy อย่างน้อยสองกรณี

แก้ไข: ลดลงเล็กน้อยโดยไม่กี่ไบต์ขอบคุณ Blue!

เชฟรอน, 84 87 ไบต์

>^__>^j
^i<<0
^i<<^i+1
^h<^i>^j
->+2??^h=/
->-3
>^__>^p
^q<^i|2>^p
->+2??^q<--
><0
><1

นี่เป็นภาษาที่ค่อนข้างใหม่ในการสร้างของฉันเอง - ล่ามต้นแบบเอกสารและโปรแกรมตัวอย่างสามารถดูได้ที่https://github.com/superloach/chevron https://github.com/superloach/chevron

คำอธิบาย:

• >^__>^j - รับ jimmy เป็นอินพุต TXT
• ^i<<0 - ดัชนีเริ่มต้นถึง 0
• ^i<<^i+1 - ดัชนีที่เพิ่มขึ้น
• ^h<^i>^j - รับตัวอักษรจิมมี่ที่ดัชนี
• ->+2??^h=/ - กระโดดออกจากวงที่ขาซ้ายของจิมมี่
• ->-3 - กระโดดกลับไปที่จุดเริ่มต้นของลูป
• >^__>^p - ใช้แพลตฟอร์มเป็นอินพุต TXT
• ^q<^i|2>^p - ตัดออก 3 ตัวอักษรภายใต้จิมมี่
• ->+2??^q<-- - ถ้า 2 ขีดกลางภายใต้จิมมี่ข้ามไปที่ทางออกจริง
• ><0 - ทางออกที่ผิดพลาด
• ><1 - ทางออกจริง

C (gcc), 103 ไบต์

i,j,l;f(char*s){for(i=0;*s-10;j=*s++-47?j:i)++i;l=strlen(s)>j+1;s+=j;return l&&*s+s[1]+(s[2]?:32)>109;}

ลองออนไลน์!

จะสั้นกว่ามาก ( 75 ไบต์ ) หากสามารถสันนิษฐานได้ว่ามีช่องว่างต่อท้ายหลังแพลตฟอร์ม

Japt -¡ , 9 ไบต์

-1 ไบต์ถ้าอินพุตสามารถย้อนกลับได้

VtUao)è-²

ลองออนไลน์

V , 18 ไบต์

0vt/"_dj.d3lVkp0#x

ลองออนไลน์!

ช่องว่างส่งออกเฉพาะในกรณีที่จิมมี่ตกลงมาจากแพลตฟอร์ม เอาท์พุทบางอย่างที่ไม่ใช่ช่องว่างถ้าจิมมี่ยังคงอยู่บนแพลตฟอร์ม