Hintergrundgeschichte

Lerne meinen Freund Jimmy kennen:

/o\

Jimmy ist eine kleine Figur, die gerne auf Plattformen steht. Hier ist Jimmy, der sicher auf einer Plattform steht:

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

Jetzt hat Jimmy einen guten Gleichgewichtssinn, so dass er sicher mit einem Bein von der Plattform stehen kann:

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

Obwohl, wenn er mit zwei oder mehr Körperteilen von der Plattform entfernt steht, wird er fallen. Beides sind Beispiele, bei denen Jimmy fallen wird:

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

Die Herausforderung

Ihre Herausforderung besteht darin, ein Programm zu schreiben, mit dem Sie anhand von Jimmys Plattform und Position bestimmen, ob Jimmy auf der Plattform stehen kann, ohne herunterzufallen.

• Eingabe: Zwei Zeilen, die Jimmys Position und die Position der Plattform unter ihm zeigen. Dies kann von zwei separaten Eingängen, einem einzelnen Eingang oder einer Art Array stammen.

  1. Sie können Eingaben in jeder angemessenen Form vornehmen, einschließlich Funktionen und Standardeingaben. Verwenden Sie die Hardcodierung nur, wenn Ihre Sprache die anderen Eingabemethoden nicht unterstützt.

• Ausgabe: Die booleschen Werte true und false oder die Ganzzahlen 1 oder 0 stehen für true / false.

  1. Der boolesche Wert basiert darauf, ob Jimmy auf der Plattform bleiben kann oder nicht - true, wenn Jimmy auf der Plattform bleiben kann, oder false, wenn er herunterfällt.

• Die Plattformgröße ist beliebig und kann beliebig geändert werden. Ihr Programm sollte das berücksichtigen.

  1. Die Plattform darf keine Länge von Null haben, und die Plattform muss vollständig sein (keine Löcher in der Plattform).

  2. Denken Sie daran, dass Jimmy herunterfällt, wenn zwei seiner Körperteile von der Plattform hängen. Ein Körperteil ist ein ASCII-Zeichen seines Körpers.

  3. Ein nachgestelltes Leerzeichen am Ende der Plattform ist nicht erforderlich, Ihr Programm sollte jedoch beide Situationen berücksichtigen, in denen nach der Plattform ein Leerzeichen und in denen kein Leerzeichen vorhanden ist.

• Beachten Sie die verbotenen Regelungslücken .

Testfälle

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

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

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

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

    /o\                    ❌ FALSE
     -

Wertung

Dies ist Codegolf , daher gewinnt die niedrigste Bytezahl.

Bestenliste

Sie können die Bestenliste für diesen Beitrag anzeigen, indem Sie das Widget / Snippet unten erweitern. Damit Ihr Beitrag in die Rangliste aufgenommen wird, benötigen Sie einen Header ( # header text) mit folgenden Informationen:

• Der Name der Sprache (Ende mit Komma ,oder Bindestrich -), gefolgt von ...

• Die Anzahl der Bytes als letzte Zahl in Ihrer Kopfzeile.

Beispielsweise JavaScript (ES6), 72 bytesist gültig, aber Fortran, 143 bytes (8-bit)ungültig, da die Byteanzahl nicht die letzte Zahl in der Kopfzeile ist (Ihre Antwort wird als 8 Byte erkannt - nutzen Sie dies nicht).

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

Gelee , 6 Bytes

n⁶Sċ2Ẓ

Probieren Sie es online!

Erläuterung:

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

Übernimmt die Eingabe als (a)(b). Gibt $0$ oder $1$ .

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

Probieren Sie es online!

Wie?

Wir suchen die Position des Mittelteils "o" von Jimmys Körper in der ersten Saite und prüfen, ob sich an derselben Position ein Strich in der zweiten Saite befindet.

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

Der einzige Fall, in dem Jimmy in dieser Situation unsicher wäre, ist mit einer Single-Dash-Plattform:

/o\
 -

Deshalb achten wir zusätzlich darauf, dass die Plattform mindestens $2$ mal breit ist :

/--/.test(b)

JavaScript (ES6), 36 Byte

Alternative Version, wenn wir davon ausgehen, dass unter Jimmy immer Bindestriche oder Leerzeichen stehen (dh die Eingabe ist rechteckig).

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

Probieren Sie es online!

Nutzt die Tatsache aus, dass der Zwang zu einem numerischen Wert $0$ für ein Leerzeichen und NaN für einen Bindestrich ist.

Excel, 67 45 44 Bytes

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

Setzen Sie Jimmy A1auf eine PlattformA2 .

2 Bedingungen geprüft:

• Ist Jimmys Torso (o ) auf der Plattform?
• Ist die Plattform mehr als nur -?

Python 3, 88 43 Bytes

Die Eingabe erfolgt in Form einer Liste mit zwei Zeichenfolgen: Die erste Zeichenfolge ist die erste Zeile; Die zweite Zeichenfolge ist die zweite Zeile.

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

Probieren Sie es online!

Eine andere Version, die 43 Bytes lang ist (ich konnte sie nicht kürzer als 43 bekommen):

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

Probieren Sie es online!

Dank eines Tipps von Jo King um 42 Byte gesunken.

Alte Version:

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

-2 Bytes dank Sriotchilism O'Zaic.

Dies funktioniert, indem Sie zwei separate Eingaben vornehmen und dann die entsprechenden Buchstaben koppeln. Es zählt die Anzahl der Paare, bei denen keines der Zeichen ein Leerzeichen ist, und gibt dann True zurück, wenn diese Anzahl größer als 1 ist.

Perl 6 , 18 Bytes

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

Probieren Sie es online!

Nimmt zwei Parameter und gibt einen Booleschen Wert zurück, der angibt, ob Jimmy auf der Plattform bleibt. Dies funktioniert durch XOR-Verknüpfung der beiden Zeilen und durch Überprüfen, ob sich noch ein Teil von Jimmy auf der Plattform befindet.

Erläuterung:

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

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

Probieren Sie es online!

5 Bytes thx bis negative sieben

Haskell , 34 Bytes

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

Probieren Sie es online!

Ich habe dieses erhalten, indem ich meine unten stehende Technik mit der anderen Haskell-Antwort kombiniert habe .

Haskell , 45 Bytes

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

Probieren Sie es online!

Dies zählt die Anzahl der Körperteile (keine Leerzeichen), die sich auf der Plattform befinden, und überprüft dann, ob sie größer als 1 sind. Der Grund, warum wir Körperteile auf der Plattform und keine Körperteile auszählen, liegt darin, dass zipWithdie obere Linie zerschnitten wird die Länge des Bodens zu sein und damit Jimmy Körperteile abhacken kann. Dies verhindert, dass wir etwas tun müssen cycle" ", um die Liste aufzufüllen.

MathGolf , 6 14 Bytes

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

Probieren Sie es online!

8 Bytes mussten hinzugefügt werden, um den von Nick Kennedy präsentierten Edge Case zu berücksichtigen.

Prüft ob "-o-" es sich um eine Teilzeichenfolge der komprimierten Zeichenfolge beider Zeilen und der komprimierten Zeichenfolge handelt, bei der in der ersten Eingabezeile das erste Zeichen entfernt wurde. Nimmt die Eingabe als zwei separate Zeichenfolgen an, wobei die einzige Änderung darin besteht, dass das Zeichen als /o\\, since, eingegeben wird\\ in MathGolf der richtige Weg ist, einen umgekehrten Schrägstrich in eine Zeichenfolge einzugeben.

Erläuterung

`                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 (Legacy) , 9 8 7 Bytes

ζðм2ùgp

-1 Byte danke an @ Mr.Xcoder mit dem Ansatz von ðм2ù.

Eingabe als Liste von zwei Zeichenfolgen.

Funktioniert nur in der Vorgängerversion von 05AB1E, da ζsowohl eine Liste von Zeichenfolgen als auch eine 2D-Liste von Zeichen transponiert werden kann, während dieζ in der neuen 05AB1E-Version nur mit der 2D-Liste von Zeichen funktioniert.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

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

Probieren Sie es online!

Dyalog APL Extended, 11 10 8 Bytes

2≤1⊥∧⌿⍤<

Probieren Sie es online!

Erläuterung:

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 Dank an Adám.

Excel, 36 Bytes

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

Jimmy in A1, auf einer Plattform inA2 .

Findet die Position von Jimmy, nimmt die 3 Bytes der Plattform und schneidet Leerzeichen ab. Wenn die resultierende Plattformlänge lang genug ist, steht Jimmy.

EXCEL, 94 71 Bytes. VBA (Excel), 87 Byte

A1= Jimmy, A2= Plattform

-23 Bytes. Danke @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 Bytes

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

Probieren Sie es online!

Der Ausgang ist eine 1, wenn Jimmy sicher ist. Ansonsten wird nichts ausgegeben. (Unär 1 und 0.) Da es keine andere Möglichkeit gibt, Eingaben in /// vorzunehmen, muss diese fest codiert werden:

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

Beispielsweise:

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

( Online ausprobieren! )

Beachten Sie das Leerzeichen nach dem <INPUT HERE>.

Erläuterung:

HINWEIS! Der Erklärungscode kann aufgrund der Kommentare nicht ausgeführt werden. Die Kommentare sind in geschweiften Klammern eingeschlossen. Auch der ursprüngliche Code verwendet einen Golf, bei dem //durch ersetzt wird~ . Dieser Code wird in der Erläuterung weggelassen.

/\/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, um einen Fehler zu beheben
• -6 Bytes durch Anwenden eines Standard- ///Golf-Tricks.

R , 35 Bytes

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

Probieren Sie es online!

Beyogen auf @ EriktheOutgolfers exzellenter Gelee-Antwort , bitte stimmen Sie dieser auch zu!

Die Eingabe ist eine 2D-Matrix von Zeichen.

Haskell, 59 Bytes

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

Probieren Sie es online!

Die Funktion heißt so: f "/o\\ " " -- "

Wie es funktioniert (z f "/o\\" " -" ):

b++cycle" "- Fügt eine unendliche Anzahl von Leerzeichen nach ein, bum sicherzustellen, dass Jimmy immer über einem -oder steht ." -" → steht" - ..."

zip a$b++cycle" " - Zippt die beiden Saiten zusammen ([('/',' '), ('o','-'), ('\\',' ')] )

(p,q)<-zip a$b++cycle - Für jedes Paar in der ZIP-Liste

[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' '] - Erzeugt eine Liste von 1 s, deren Länge die Anzahl der Paare ist, die die Bedingungen erfüllen:

elem p"/o\\"- Das Zeichen in der oberen Zeichenfolge ist eines von Jimmys Körperteilen. (Zufrieden mit allen drei Paaren in diesem Beispiel)

q==' '- Das Zeichen in der unteren Zeichenfolge ist ein Leerzeichen. (Zufrieden mit('/', ' ') und('\\', ' ') )

Das Paar muss also eines sein, bei dem sich ein Körperteil von Jimmy über einem Feld befindet.

Da in diesem Beispiel zwei Paare beide Bedingungen erfüllen, lautet die Liste [1,1]

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- Nehmen Sie die Summe der 1s (dh die Länge der Liste), die in diesem Beispiel ist 2.

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2- Überprüfen Sie, ob die Anzahl der Körperteile über einem Leerzeichen weniger als 2 beträgt. In diesem Beispiel ist dies nicht der Fall, sodass Jimmy herunterfällt. :(

C (gcc) , 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;}

Probieren Sie es online!

Kotlin, 60 Bytes

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

Erläuterung:

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 Bytes

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

Probieren Sie es online!

Fügen Sie die Eingabe an das Ende des Programms an, um es auszuführen. Gibt die leere Zeichenfolge zurück, wenn Jimmy von der Plattform fällt, andernfalls eine Zeichenfolge mit Ausrufezeichen.

• /|/\/\//ersetzt |durch //, wodurch der Code sowohl kürzer als auch lesbarer wird (| wird verwendet , um jeden Ersatz abgrenzen)
• /\/o\\/J| J/J*/Ersetzt Jimmy Jaus Gründen der Kürze durch und ändert das Feld links von ihm in das Feld *rechts von ihm
• Der nächste Ersatz beseitigt Zeilenumbrüche.
• /* /| -/ | //löscht *s und mit dem Leerzeichen links von der Plattform. Wenn noch zwei oder mehr Plätze frei sind, fällt Jimmy nach links ab und die Plattform wird gelöscht. Dieser Teil entfernt auch alle Leerzeichen rechts von der Plattform.
• /*-/|--/!/storniert *s und mit der Länge der Plattform. Wenn noch mindestens zwei -übrig sind, fällt Jimmy nicht nach rechts ab und wird durch a ersetzt! .
• /-/|*/|J// löscht alle verbleibenden Zeichen, die nicht vorhanden sind !

Japt , 8 Bytes

Õ·kèS Êz

Versuch es

Retina 0.8.2 , 16 Bytes

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

Probieren Sie es online! Link enthält Testsuite. Erläuterung:

+`^ (.*¶).
$1

Löschen Sie das Leerzeichen und das erste Zeichen der nächsten Zeile, während sich in der ersten Zeile noch ein Leerzeichen befindet und beide Zeilen weiterhin mehr als ein Zeichen enthalten. Hinweis: Dies setzt voraus, dass nach Jimmy kein Leerzeichen vorhanden ist. +1 Byte erforderlich, wenn der nachfolgende Speicherplatz zugelassen werden muss.

¶ ?--

Überprüfen Sie, ob sich unter Jimmy mindestens zwei Plattformteile befinden.

Perl 5 -pl , 42 Bytes

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

Probieren Sie es online!

Ruby 2.5.3, 44 Bytes

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

Eingabe als zwei Arrays. Auf jeden Fall nicht der golffreundlichste Ansatz (siehe Antwort von GB), aber ich mag jede Ausrede, um die zipFunktion zu nutzen .

PowerShell , 63..55 53 Byte

^{-1 Byte dank mazzy}

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

Probieren Sie es online!

Nimmt die Eingabe als zwei Zeilen.

Abgerollt:

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 Byte

-4 Bytes dank Jo King

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

Probieren Sie es online!

Python 3.7 , 71 56 Bytes

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

Sehr einfache Version und die kürzeste, die ich mir vorstellen kann, diesen Ansatz zu verwenden. Input sist eine Liste von zwei Strings, der erste für die Jimmy-Reihe, der zweite für die Plattform. Zippen Sie die übereinander liegenden Zeichen und prüfen Sie, ob- in mindestens zwei Fällen unter einem Teil von Jimmy liegen.

EDIT: Durch Blue um einige Bytes reduziert!

Chevron, 84 87 Bytes

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

Dies ist eine ziemlich neue Sprache meiner eigenen Schöpfung - Prototyp-Interpreter, Dokumentation und Beispielprogramme finden Sie unter https://github.com/superloach/chevron .

Erläuterung:

• >^__>^j - Jimmy als TXT-Eingang nehmen
• ^i<<0 - Index auf 0 initialisieren
• ^i<<^i+1 - Index erhöhen
• ^h<^i>^j - Holen Sie sich den Charakter von Jimmy bei Index
• ->+2??^h=/ - Spring aus der Schlaufe von Jimmy's linkem Bein
• ->-3 - Zurück zum Anfang der Schleife springen
• >^__>^p - Plattform als TXT-Eingang nehmen
• ^q<^i|2>^p - 3 Zeichen unter Jimmy ausschneiden
• ->+2??^q<-- - Wenn 2 Bindestriche unter Jimmy liegen, springe zum wahren Ausgang
• ><0 - Falscher Ausgang
• ><1 - Wahrhaftiger Ausgang

C (gcc), 103 Bytes

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

Probieren Sie es online!

Wäre viel kürzer ( 75 Byte ), wenn davon ausgegangen werden könnte, dass nach der Plattform ein Leerzeichen folgt.

Japt -¡ , 9 Bytes

-1 Byte, wenn die Eingabe umgekehrt werden kann.

VtUao)è-²

Probieren Sie es online aus

V , 18 Bytes

0vt/"_dj.d3lVkp0#x

Probieren Sie es online!

Leerzeichen nur ausgeben, wenn die Plattform herunterfällt. Gib etwas aus, das kein Leerzeichen ist, wenn Jimmy auf der Plattform bleibt.