Backstory

Rencontrez mon ami Jimmy:

/o\

Jimmy est un petit personnage qui aime se tenir debout sur les plateformes. Voici Jimmy debout en toute sécurité sur une plate-forme:

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

Maintenant, Jimmy a un bon sens de l'équilibre, il peut donc se tenir en toute sécurité avec une jambe hors de la plate-forme, comme ceci:

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

Bien que s'il se tient avec deux ou plusieurs parties du corps hors de la plate-forme, il tombera. Ces deux exemples sont ceux où Jimmy tombera:

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

Le défi

Votre défi est d'écrire un programme pour déterminer, étant donné une chaîne avec la plate-forme et la position de Jimmy, si Jimmy peut se tenir sur la plate-forme sans tomber.

• Entrée: deux lignes montrant la position de Jimmy et la position de la plate-forme sous lui. Cela peut provenir de deux entrées distinctes, d'une seule entrée ou d'un tableau quelconque.

  1. Vous pouvez saisir des informations sous toute forme raisonnable, y compris des fonctions et des entrées standard. N'utilisez le codage en dur que si votre langue ne prend pas en charge les autres méthodes de saisie.

• Sortie: les valeurs booléennes true et false, ou les entiers 1 ou 0 pour représenter respectivement true / false.

  1. La valeur booléenne est basée sur le fait que Jimmy puisse rester sur la plate-forme ou non - vrai si Jimmy peut rester sur la plate-forme, ou faux s'il tombera.

• La taille de la plateforme est arbitraire et peut être modifiée à volonté. Votre programme devrait en tenir compte.

  1. La plate-forme ne peut pas avoir une longueur nulle et la plate-forme doit être complète (pas de trous dans la plate-forme).

  2. N'oubliez pas que Jimmy tombe lorsque deux de ses parties du corps pendent de la plate-forme. Une partie du corps est un caractère ASCII de son corps.

  3. Il n'est pas nécessaire de laisser un espace à la fin de la plate-forme, mais votre programme doit prendre en compte les deux situations, où il y a un espace après la plate-forme et où il n'y en a pas.

• Faites attention aux failles standard qui sont interdites.

Cas de test

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

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

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

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

    /o\                    ❌ FALSE
     -

Notation

Il s'agit de code-golf , donc le nombre d'octets le plus bas l'emporte.

Classement

Vous pouvez afficher le classement de cet article en développant le widget / extrait ci-dessous. Pour que votre message soit inclus dans le classement, vous avez besoin d'un en-tête ( # header text) avec les informations suivantes:

• Le nom de la langue (terminez-le par une virgule ,ou un tiret -), suivi de ...

• Le nombre d'octets, comme le dernier nombre à apparaître dans votre en-tête.

Par exemple, JavaScript (ES6), 72 bytesest valide, mais Fortran, 143 bytes (8-bit)n'est pas valide car le nombre d'octets n'est pas le dernier nombre dans l'en-tête (votre réponse sera reconnue comme 8 octets - n'en profitez pas).

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

Gelée , 6 octets

n⁶Sċ2Ẓ

Essayez-le en ligne!

Explication:

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 octets

Prend l'entrée comme (a)(b). Renvoie $0$ ou $1$ .

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

Essayez-le en ligne!

Comment?

Nous recherchons la position de la partie médiane "o" du corps de Jimmy dans la première chaîne et testons s'il y a un tiret dans la deuxième chaîne à la même position.

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

Le seul cas où Jimmy serait dangereux dans cette situation est avec une plate-forme à un seul tiret:

/o\
 -

Nous nous assurons donc en outre que la plate-forme a une largeur d'au moins $2$ :

/--/.test(b)

JavaScript (ES6), 36 octets

Version alternative si nous supposons qu'il y a toujours des tirets ou des espaces sous Jimmy (c'est-à-dire que l'entrée est rectangulaire).

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

Essayez-le en ligne!

Profite du fait que la contrainte à une valeur numérique est $0$ pour un espace et NaN pour un tiret.

Excel, 67 45 44 octets

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

Mettez Jimmy dedans A1, sur une plateformeA2 .

2 conditions vérifiées:

• Est le torse de Jimmy (o sur la plate-forme?
• La plateforme est-elle plus que juste -?

Python 3, 88 43 octets

L'entrée est donnée sous la forme d'une liste contenant deux chaînes: la première chaîne est la première ligne; la deuxième chaîne est la deuxième ligne.

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

Essayez-le en ligne!

Une autre version, liant pour 43 octets (je n'ai pas pu l'obtenir plus court que 43):

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

Essayez-le en ligne!

En baisse de 42 octets grâce à une astuce de Jo King.

Ancienne version:

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

-2 octets grâce au Sriotchilism O'Zaic.

Cela fonctionne en prenant deux entrées distinctes, puis en associant les lettres correspondantes. Il compte le nombre de paires où aucun caractère n'est un espace, puis renvoie True si ce nombre est supérieur à 1.

Perl 6 , 18 octets

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

Essayez-le en ligne!

Prend deux paramètres et renvoie un booléen indiquant si Jimmy restera sur la plate-forme. Cela fonctionne en XORant les deux lignes ensemble et en vérifiant si l'une des parties de Jimmy est toujours sur la plate-forme.

Explication:

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

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

Essayez-le en ligne!

5 octets thx à sept négatifs

Haskell , 34 octets

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

Essayez-le en ligne!

J'ai obtenu celui-ci en combinant ma technique ci-dessous avec l'autre réponse haskell .

Haskell , 45 octets

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

Essayez-le en ligne!

Cela compte le nombre de parties du corps (caractères non-espace) qui sont au-dessus de la plate-forme et vérifie ensuite qu'il est supérieur à 1. La raison pour laquelle nous comptons les parties du corps sur la plate-forme plutôt que les parties du corps est que zipWithcela coupera la ligne supérieure être la longueur du fond et peut donc couper les parties du corps de Jimmy. Cela nous empêche d'avoir à faire quelque chose comme cycle" "remplir la liste.

MathGolf , 6 14 octets

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

Essayez-le en ligne!

8 octets ont dû être ajoutés pour tenir compte du cas de bord présenté par Nick Kennedy.

Vérifie si "-o-"est une sous-chaîne de la chaîne zippée des deux lignes et la chaîne zippée où la première ligne d'entrée a le premier caractère supprimé. Prend l'entrée comme deux chaînes distinctes, avec le seul changement étant que le caractère est entré comme /o\\, car \\c'est la bonne façon d'entrer une barre oblique inverse dans une chaîne dans MathGolf.

Explication

`                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 (hérité) , 9 8 7 octets

ζðм2ùgp

-1 octet grâce à @ Mr.Xcoder avec l'approche deðм2ù .

Entrée sous forme de liste de deux chaînes.

Fonctionne uniquement dans la version héritée de 05AB1E, car ζpeut transposer une liste de chaînes ainsi qu'une liste 2D de caractères, tandis que ζdans la nouvelle version 05AB1E ne fonctionne qu'avec la liste 2D de caractères.

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

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

Rubis , 28 octets

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

Essayez-le en ligne!

Dyalog APL Extended, 11 10 8 octets

2≤1⊥∧⌿⍤<

Essayez-le en ligne!

Explication:

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 merci à Adám.

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.

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)

///, 85 93 87 bytes

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

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

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.

R, 35 bytes

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

Try it online!

Based on @EriktheOutgolfer’s excellent Jelly answer so please upvote that one too!

Input is a 2-d matrix of characters.

Haskell, 59 bytes

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

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 1s, 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 1s (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. :(

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

Try it online!

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

///, 57 bytes

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

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 !

Japt, 8 bytes

Õ·kèS Êz

Try it

Retina 0.8.2, 16 bytes

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

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.

Perl 5 -pl, 42 bytes

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

Try it online!

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.

PowerShell, 63..55 53 bytes

^{-1 byte thanks to mazzy}

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

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

C# (Visual C# Interactive Compiler), 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!

Python 3.7, 71 56 Bytes

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

Very simple version and the shortest I could think of using this approach. Input s is a list of two strings, the first one for the Jimmy-row, the second one for the platform. Zip the characters which are above one another and then check whether - is below a part of Jimmy in at least two instances.

EDIT: Reduced by quite a few Bytes thanks to Blue!

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

This is a fairly new language of my own creation - prototype interpreter, documentation, and example programs can be found at https://github.com/superloach/chevron.

Explanation:

• >^__>^j - take jimmy as TXT input
• ^i<<0 - initialise index to 0
• ^i<<^i+1 - increment index
• ^h<^i>^j - get character of jimmy at index
• ->+2??^h=/ - jump out of loop at jimmy's left leg
• ->-3 - hop back to beginning of loop
• >^__>^p - take platform as TXT input
• ^q<^i|2>^p - cut out 3 characters under jimmy
• ->+2??^q<-- - if 2 dashes under jimmy, jump to truthy exit
• ><0 - falsy exit
• ><1 - truthy exit

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

Try it online!

Would be much shorter (75 bytes), if it could be assumed that there is trailing whitespace after the platform.

Japt -¡, 9 bytes

-1 byte if the input can be reversed.

VtUao)è-²

Try it online

V, 18 bytes

0vt/"_dj.d3lVkp0#x

Try it online!

Output whitespace only if jimmy fall of the platform. Output something non-whitespace if jimmy stay on the platform.