Backstory

Gặp bạn tôi là Jimmy:

/o\

Jimmy là một nhân vật nhỏ thích đứng trên nền tảng. Đây là Jimmy đang đứng an toàn trên một nền tảng:

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

Bây giờ, Jimmy có một cảm giác cân bằng tốt, vì vậy anh ta có thể đứng một cách an toàn với một chân ra khỏi nền tảng, như vậy:

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

Mặc dù nếu anh ta đứng với hai hoặc nhiều bộ phận cơ thể ra khỏi nền tảng, anh ta sẽ ngã. Cả hai đều là những ví dụ mà Jimmy sẽ rơi:

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

Các thách thức

Thách thức của bạn là viết một chương trình để xác định, đưa ra một chuỗi với nền tảng và vị trí của Jimmy, nếu Jimmy có thể đứng trên nền tảng mà không bị ngã.

• Đầu vào: Hai dòng hiển thị vị trí của Jimmy và vị trí của nền tảng dưới anh ta. Điều này có thể từ hai đầu vào riêng biệt, một đầu vào hoặc một mảng nào đó.

  1. Bạn có thể nhận đầu vào thông qua bất kỳ hình thức hợp lý, bao gồm các chức năng và đầu vào tiêu chuẩn. Chỉ sử dụng mã hóa cứng nếu ngôn ngữ của bạn không hỗ trợ các phương thức nhập khác.

• Đầu ra: Các giá trị boolean đúng và sai hoặc các số nguyên 1 hoặc 0 để biểu thị đúng / sai tương ứng.

  1. Giá trị boolean dựa trên việc liệu Jimmy có thể ở lại nền tảng hay không - đúng nếu Jimmy có thể ở lại trên nền tảng, hoặc sai nếu anh ta sẽ rơi ra.

• Kích thước nền tảng là tùy ý và có thể thay đổi theo ý muốn. Chương trình của bạn nên giải thích cho điều đó.

  1. Nền tảng không thể có độ dài bằng 0 và nền tảng phải được hoàn thành (không có lỗ hổng nào trong nền tảng).

  2. Hãy nhớ rằng Jimmy rơi ra khi hai bộ phận cơ thể của anh ta đang treo trên nền tảng. Một phần cơ thể là một nhân vật ASCII của cơ thể anh ta.

  3. Không yêu cầu khoảng trắng ở cuối nền tảng, nhưng chương trình của bạn nên tính đến cả hai tình huống, nơi có khoảng trắng sau nền tảng và nơi không có.

• Hãy chú ý đến những sơ hở tiêu chuẩn bị cấm.

Các trường hợp thử nghiệm

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

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

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

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

    /o\                    ❌ FALSE
     -

Chấm điểm

Đây là mã golf , vì vậy số byte thấp nhất sẽ thắng.

Bảng xếp hạng

Bạn có thể xem bảng xếp hạng cho bài đăng này bằng cách mở rộng tiện ích / đoạn trích bên dưới. Để bài đăng của bạn được đưa vào bảng xếp hạng, bạn cần một tiêu đề ( # header text) với thông tin sau:

• Tên của ngôn ngữ (kết thúc bằng dấu phẩy ,hoặc dấu gạch ngang -), theo sau là ...

• Số byte, là số cuối cùng xuất hiện trong tiêu đề của bạn.

Ví dụ: JavaScript (ES6), 72 byteshợp lệ, nhưng Fortran, 143 bytes (8-bit)không hợp lệ vì số byte không phải là số cuối cùng trong tiêu đề (câu trả lời của bạn sẽ được nhận ra là 8 byte - không tận dụng điều này).

<!-- 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>

Thạch , 6 byte

n⁶Sċ2Ẓ

Hãy thử trực tuyến!

Giải trình:

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 byte

Đưa đầu vào là (a)(b). Trả về $0$ hoặc $1$ .

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

Hãy thử trực tuyến!

Làm sao?

Chúng tôi tìm vị trí của phần giữa "o"của cơ thể của Jimmy trong chuỗi đầu tiên và kiểm tra xem có một dấu gạch ngang trong chuỗi thứ hai ở cùng vị trí không.

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

Trường hợp duy nhất mà Jimmy sẽ không an toàn trong tình huống này là với nền tảng một dấu gạch ngang:

/o\
 -

Vì vậy, chúng tôi cũng đảm bảo rằng nền tảng có chiều rộng ít nhất là $2$ :

/--/.test(b)

JavaScript (ES6), 36 byte

Phiên bản thay thế nếu chúng ta giả sử rằng luôn có dấu gạch ngang hoặc dấu cách bên dưới Jimmy (tức là đầu vào là hình chữ nhật).

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

Hãy thử trực tuyến!

Lợi dụng thực tế là sự ép buộc đối với một giá trị số là $0$ cho một khoảng trắng và NaN cho một dấu gạch ngang.

Excel, 67 45 44 byte

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

Đặt Jimmy vào A1, trên một nền tảng trong A2.

Kiểm tra 2 điều kiện:

• Là thân của Jimmy ( o) trên nền tảng?
• Là nền tảng nhiều hơn chỉ -?

Python 3, 88 43 byte

Đầu vào được đưa ra dưới dạng một danh sách chứa hai chuỗi: chuỗi đầu tiên là dòng đầu tiên; chuỗi thứ hai là dòng thứ hai.

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

Hãy thử trực tuyến!

Một phiên bản khác, buộc 43 byte (tôi không thể rút ngắn hơn 43 byte):

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

Hãy thử trực tuyến!

Giảm 42 byte nhờ một mẹo từ Jo King.

Phiên bản cũ:

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

-2 byte nhờ Sriotchilism O'Z cổ.

Điều này hoạt động bằng cách lấy hai đầu vào riêng biệt, sau đó ghép các chữ cái tương ứng. Nó đếm số cặp trong đó không có ký tự nào là khoảng trắng, sau đó trả về True nếu số đó lớn hơn 1.

Perl 6 , 18 byte

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

Hãy thử trực tuyến!

Đưa ra hai tham số và trả về một giá trị boolean cho dù Jimmy sẽ ở lại trên nền tảng. Điều này hoạt động bằng cách XOR hai dòng với nhau và kiểm tra xem một phần của Jimmy vẫn còn trên nền tảng.

Giải trình:

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

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

Hãy thử trực tuyến!

5 byte thx đến âm bảy

Haskell , 34 byte

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

Hãy thử trực tuyến!

Tôi đã có được cái này bằng cách kết hợp kỹ thuật dưới đây của tôi với câu trả lời haskell khác .

Haskell , 45 byte

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

Hãy thử trực tuyến!

Điều này đếm số phần cơ thể (ký tự không phải không gian) ở trên cùng của nền tảng và sau đó kiểm tra nó lớn hơn 1. Lý do chúng tôi đếm các phần cơ thể trên nền tảng thay vì các phần cơ thể là vì nó zipWithsẽ cắt dòng trên cùng là chiều dài của đáy và do đó có thể cắt các bộ phận cơ thể của Jimmy. Điều này ngăn chúng ta khỏi phải làm một cái gì đó như cycle" "để đệm danh sách.

MathGolf , 6 14 byte

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

Hãy thử trực tuyến!

8 byte đã được thêm vào tài khoản cho trường hợp cạnh được trình bày bởi Nick Kennedy.

Kiểm tra xem "-o-"có phải là một chuỗi con của chuỗi được nén của cả hai dòng không và chuỗi được nén trong đó dòng đầu vào đầu tiên đã loại bỏ ký tự đầu tiên. Lấy đầu vào là hai chuỗi riêng biệt, với thay đổi duy nhất là ký tự được nhập là /o\\, vì đây \\là cách chính xác để nhập dấu gạch chéo ngược trong chuỗi trong MathGolf.

Giải trình

`                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 (di sản) , 9 8 7 byte

ζðм2ùgp

-1 byte nhờ @ Mr.Xcoder với cách tiếp cận của ðм2ù.

Nhập dưới dạng danh sách hai chuỗi.

Chỉ hoạt động trong phiên bản kế thừa của 05AB1E, vì ζcó thể hoán chuyển danh sách các chuỗi cũng như danh sách các ký tự 2D, trong khi ζphiên bản 05AB1E mới chỉ hoạt động với danh sách các ký tự 2D.

Dùng thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

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

Hãy thử trực tuyến!

Dyalog APL Mở rộng, 11 10 8 byte

2≤1⊥∧⌿⍤<

Hãy thử trực tuyến!

Giải trình:

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 nhờ Adám.

Excel, 36 byte

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

Jimmy in A1, trên một nền tảng trong A2.

Tìm vị trí của Jimmy và lấy 3 byte của nền tảng và cắt bỏ khoảng trắng. Nếu chiều dài nền tảng kết quả là đủ dài, thì Jimmy đứng.

EXCEL, 94 71 byte. VBA (Excel), 87 byte

A1= Jimmy, A2= nền tảng

-23 byte. Cảm ơn bạn @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 byte

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

Hãy thử trực tuyến!

Đầu ra là 1 nếu Jimmy an toàn. Nếu không thì đầu ra không có gì. (Unary 1 và 0.) Vì không có cách nào khác để nhận đầu vào trong ///, nên nó cần được mã hóa cứng:

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

Ví dụ:

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

( Dùng thử trực tuyến! )

Lưu ý không gian sau <INPUT HERE> .

Giải trình:

CHÚ THÍCH! Mã giải thích không thể chạy do các ý kiến. Các ý kiến ​​được đính kèm trong niềng răng xoăn. Ngoài ra, mã ban đầu sử dụng một sân golf //được thay thế bằng ~. Mã này được bỏ qua từ giải thích.

/\/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 byte để sửa lỗi
• -6 byte bằng cách áp dụng một cú ///đánh golf tiêu chuẩn .

R , 35 byte

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

Hãy thử trực tuyến!

Dựa trên câu trả lời Jelly tuyệt vời của @ EriktheOutgolfer, vì vậy, hãy nâng cấp câu trả lời đó!

Đầu vào là ma trận 2 ký tự.

Haskell, 59 byte

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

Hãy thử trực tuyến!

Hàm được gọi như vậy: f "/o\\ " " -- "

Cách thức hoạt động (cho f "/o\\" " -"):

b++cycle" "- Thêm một số lượng không gian vô hạn sau bđể đảm bảo rằng Jimmy luôn ở trên một -hoặc ( " -"→" - ..."

zip a$b++cycle" "- Kéo hai chuỗi lại với nhau ( [('/',' '), ('o','-'), ('\\',' ')])

(p,q)<-zip a$b++cycle - Đối với mỗi cặp trong danh sách nén

[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- Tạo danh sách 1s, có độ dài là số cặp thỏa mãn điều kiện:

elem p"/o\\"- Nhân vật trong chuỗi trên cùng là một trong những bộ phận cơ thể của Jimmy. (Hài lòng bởi cả ba cặp trong ví dụ này)

q==' '- Ký tự trong chuỗi dưới cùng là một khoảng trắng. (Hài lòng bởi ('/', ' ')và('\\', ' ') )

Vì vậy, cặp đôi phải là một trong những bộ phận cơ thể của Jimmy nằm trên một không gian.

Bởi vì trong ví dụ này, hai cặp thỏa mãn cả hai điều kiện, danh sách là [1,1]

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- Lấy tổng của các 1s (tức là độ dài của danh sách), trong ví dụ này là 2.

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2- Kiểm tra xem số lượng bộ phận cơ thể trên một không gian có ít hơn 2. Trong ví dụ này, không phải vậy, vì vậy Jimmy sẽ rơi ra. :

C (gcc) , 73 byte

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

Hãy thử trực tuyến!

Kotlin, 60 byte

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

Giải trình:

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 byte

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

Hãy thử trực tuyến!

Nối đầu vào vào cuối chương trình để chạy. Trả về chuỗi trống nếu Jimmy rơi khỏi nền tảng, một chuỗi các dấu chấm than khác.

• /|/\/\//thay thế |bằng //, làm cho mã ngắn hơn và dễ đọc hơn ( |được sử dụng để phân định từng thay thế)
• /\/o\\/J| J/J*/thay thế cho Jimmy bằng Jsự ngắn gọn và thay đổi không gian bên trái của anh ta sang *bên phải của anh ta
• Sự thay thế tiếp theo được loại bỏ các dòng mới.
• /* /| -/ | //hủy bỏ *s và với không gian bên trái của nền tảng. Nếu có hai hoặc nhiều khoảng trống còn lại, Jimmy sẽ rơi xuống bên trái và nền tảng bị xóa. Phần này cũng loại bỏ bất kỳ khoảng trắng nào ở bên phải của nền tảng.
• /*-/|--/!/hủy bỏ *s và với chiều dài của nền tảng. Nếu có ít nhất hai -bên trái, thì Jimmy không rơi sang bên phải, vì vậy chúng được thay thế bằng a !.
• /-/|*/|J// xóa mọi ký tự còn lại không !

Japt , 8 byte

Õ·kèS Êz

Thử nó

Võng mạc 0.8.2 , 16 byte

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

Hãy thử trực tuyến! Liên kết bao gồm bộ kiểm tra. Giải trình:

+`^ (.*¶).
$1

Mặc dù vẫn còn một khoảng trắng trên dòng đầu tiên và cả hai dòng vẫn có nhiều hơn một ký tự, hãy xóa khoảng trắng và ký tự đầu tiên của dòng tiếp theo. Lưu ý: Điều này giả định rằng không có dấu cách sau Jimmy. +1 byte cần thiết nếu không gian dấu cần được cho phép.

¶ ?--

Kiểm tra xem có ít nhất hai phần của nền tảng dưới thời Jimmy.

Perl 5 -pl , 42 byte

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

Hãy thử trực tuyến!

Ruby 2.5.3, 44 byte

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

Đầu vào được thực hiện dưới dạng hai mảng. Chắc chắn không phải là cách tiếp cận thân thiện với golf nhất (xem câu trả lời của GB), nhưng tôi thích mọi lý do để sử dụng zipchức năng này.

PowerShell , 63..55 53 byte

^{-1 byte nhờ mazzy}

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

Hãy thử trực tuyến!

Lấy đầu vào là hai dòng.

Chưa được kiểm soát:

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 # (Trình biên dịch tương tác Visual C #) , 44 40 39 byte

-4 byte nhờ Jo King

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

Hãy thử trực tuyến!

Python 3.7 , 71 56 byte

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

Phiên bản rất đơn giản và ngắn nhất tôi có thể nghĩ đến khi sử dụng phương pháp này. Đầu vào slà danh sách hai chuỗi, chuỗi đầu tiên cho hàng Jimmy, chuỗi thứ hai cho nền tảng. Zip các ký tự nằm trên nhau và sau đó kiểm tra xem- nằm dưới một phần của Jimmy trong ít nhất hai trường hợp không.

EDIT: Giảm khá nhiều Byte nhờ Blue!

Chevron, 84 87 byte

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

Đây là một ngôn ngữ khá mới trong sáng tạo của riêng tôi - phiên dịch nguyên mẫu, tài liệu và các chương trình ví dụ có thể được tìm thấy tại https://github.com/superloach/chevron .

Giải trình:

• >^__>^j - lấy jimmy làm đầu vào TXT
• ^i<<0 - chỉ số khởi tạo về 0
• ^i<<^i+1 - chỉ số tăng
• ^h<^i>^j - có được tính cách của jimmy tại chỉ mục
• ->+2??^h=/ - nhảy ra khỏi vòng lặp ở chân trái của jimmy
• ->-3 - nhảy trở lại bắt đầu vòng lặp
• >^__>^p - lấy nền tảng làm đầu vào TXT
• ^q<^i|2>^p - cắt ra 3 ký tự theo jimmy
• ->+2??^q<-- - nếu 2 dấu gạch ngang dưới jimmy, hãy nhảy đến lối ra trung thực
• ><0 - lối ra giả
• ><1 - lối ra trung thực

C (gcc), 103 byte

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;}

Hãy thử trực tuyến!

Sẽ ngắn hơn nhiều ( 75 byte ), nếu có thể giả định rằng có khoảng trắng theo sau nền tảng.

Japt -¡, 9 byte

-1 byte nếu đầu vào có thể được đảo ngược.

VtUao)è-²

Dùng thử trực tuyến

V , 18 byte

0vt/"_dj.d3lVkp0#x

Hãy thử trực tuyến!

Khoảng trắng đầu ra chỉ khi jimmy rơi của nền tảng. Xuất ra một cái gì đó không phải khoảng trắng nếu jimmy ở lại trên nền tảng.