Historia de fondo

Conoce a mi amigo Jimmy:

/o\

Jimmy es un pequeño personaje al que le gusta estar parado en plataformas. Aquí está Jimmy parado de manera segura en una plataforma:

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

Ahora, Jimmy tiene un buen sentido del equilibrio, por lo que puede pararse con seguridad con una pierna fuera de la plataforma, así:

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

Aunque si se para con dos o más partes del cuerpo fuera de la plataforma, se caerá. Ambos son ejemplos en los que Jimmy caerá:

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

El reto

Su desafío es escribir un programa para determinar, dada una cadena con la plataforma y la posición de Jimmy, si Jimmy puede pararse en la plataforma sin caerse.

• Entrada: Dos líneas que muestran la posición de Jimmy y la posición de la plataforma debajo de él. Esto puede ser de dos entradas separadas, una sola entrada o una matriz de algún tipo.

  1. Puede recibir información a través de cualquier forma razonable, incluidas las funciones y la información estándar. Solo recurra a la codificación rígida si su idioma no admite los otros métodos de entrada.

• Salida: los valores booleanos verdadero y falso, o los enteros 1 o 0 para representar verdadero / falso respectivamente.

  1. El valor booleano se basa en si Jimmy puede permanecer en la plataforma o no: verdadero si Jimmy puede permanecer en la plataforma o falso si se cae.

• El tamaño de la plataforma es arbitrario y se puede cambiar a voluntad. Su programa debería explicar eso.

  1. La plataforma no puede tener una longitud de cero, y la plataforma debe estar completa (sin agujeros en la plataforma).

  2. Recuerde que Jimmy se cae cuando dos partes de su cuerpo cuelgan de la plataforma. Una parte del cuerpo es un personaje ASCII de su cuerpo.

  3. No se requiere el espacio en blanco al final de la plataforma, pero su programa debe tener en cuenta ambas situaciones, donde hay espacio en blanco después de la plataforma y donde no lo hay.

• Tenga en cuenta las lagunas estándar que están prohibidas.

Casos de prueba

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

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

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

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

    /o\                    ❌ FALSE
     -

Tanteo

Este es el código golf , por lo que gana el conteo de bytes más bajo.

Tabla de clasificación

Puede ver la tabla de clasificación para esta publicación expandiendo el widget / fragmento a continuación. Para que su publicación se incluya en las clasificaciones, necesita un encabezado ( # header text) con la siguiente información:

• El nombre del idioma (finalícelo con una coma ,o guión -), seguido de ...

• El recuento de bytes, como el último número que aparece en su encabezado.

Por ejemplo, JavaScript (ES6), 72 byteses válido, pero Fortran, 143 bytes (8-bit)no es válido porque el recuento de bytes no es el último número en el encabezado (su respuesta se reconocerá como 8 bytes; no aproveche esto).

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

Jalea , 6 bytes

n⁶Sċ2Ẓ

Pruébalo en línea!

Explicación:

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 bytes

Toma entrada como (a)(b). Devuelve $0$ o $1$ .

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

Pruébalo en línea!

¿Cómo?

Buscamos la posición de la parte media "o"del cuerpo de Jimmy en la primera cuerda y probamos si hay un guión en la segunda cuerda en la misma posición.

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

El único caso en el que Jimmy no sería seguro en esta situación es con una plataforma de un solo tablero:

/o\
 -

Por lo tanto, también nos aseguramos de que la plataforma tenga un ancho de al menos $2$ :

/--/.test(b)

JavaScript (ES6), 36 bytes

Versión alternativa si suponemos que siempre hay guiones o espacios debajo de Jimmy (es decir, la entrada es rectangular).

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

Pruébalo en línea!

Aprovecha el hecho de que la coerción a un valor numérico es $0$ para un espacio y NaN para un guión.

Excel, 67 45 44 bytes

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

Pon a Jimmy adentro A1, en una plataforma adentro A2.

2 condiciones verificadas:

• ¿Está el torso de Jimmy ( o) en la plataforma?
• ¿Es la plataforma más que solo -?

Python 3, 88 43 bytes

La entrada se proporciona en forma de una lista que contiene dos cadenas: la primera cadena es la primera línea; La segunda cadena es la segunda línea.

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

Pruébalo en línea!

Otra versión, empatando 43 bytes (no he podido obtenerla más corta que 43):

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

Pruébalo en línea!

Bajó 42 bytes gracias a un consejo de Jo King.

Versión antigua:

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

-2 bytes gracias al Sriotchilism O'Zaic.

Esto funciona tomando dos entradas separadas, luego emparejando las letras correspondientes. Cuenta el número de pares donde ninguno de los caracteres es un espacio, luego devuelve True si ese número es mayor que 1.

Perl 6 , 18 bytes

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

Pruébalo en línea!

Toma dos parámetros y devuelve un valor booleano de si Jimmy permanecerá en la plataforma. Esto funciona haciendo XOR uniendo las dos líneas y verificando si alguna parte de Jimmy todavía está en la plataforma.

Explicación:

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

Pruébalo en línea!

5 bytes thx a siete negativos

Haskell , 34 bytes

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

Pruébalo en línea!

Obtuve esta combinando mi técnica a continuación con la otra respuesta de haskell .

Haskell , 45 bytes

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

Pruébalo en línea!

Esto cuenta el número de partes del cuerpo (caracteres que no son espacios) que están en la parte superior de la plataforma y luego comprueba que sea mayor que 1. La razón por la que contamos las partes del cuerpo en la plataforma en lugar de las partes del cuerpo es que zipWithcorta la línea superior ser del largo del fondo y así poder cortar las partes del cuerpo de Jimmy. Esto nos impide tener que hacer algo como cycle" "rellenar la lista.

MathGolf , 6 14 bytes

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

Pruébalo en línea!

Se tuvieron que agregar 8 bytes para tener en cuenta el caso límite presentado por Nick Kennedy.

Comprueba si "-o-"es una subcadena de la cadena comprimida de ambas líneas y la cadena comprimida donde la primera línea de entrada tiene el primer carácter eliminado. Toma la entrada como dos cadenas separadas, con el único cambio que el carácter se ingresa como /o\\, ya que\\ es la forma correcta de ingresar una barra diagonal inversa en una cadena en MathGolf.

Explicación

`                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 (heredado) , 9 8 7 bytes

ζðм2ùgp

-1 byte gracias a @ Mr.Xcoder con el enfoque de ðм2ù.

Entrada como una lista de dos cadenas.

Solo funciona en la versión heredada de 05AB1E, porque ζpuede transponer una lista de cadenas y una lista de caracteres 2D, mientras que ζen la nueva versión 05AB1E solo funciona con la lista de caracteres 2D.

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

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

Rubí , 28 bytes.

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

Pruébalo en línea!

Dyalog APL Extendido, 11 10 8 bytes

2≤1⊥∧⌿⍤<

Pruébalo en línea!

Explicación:

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 gracias a Adám.

Excel, 36 bytes

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

Jimmy adentro A1, en una plataforma adentro A2.

Encuentra la posición de Jimmy, toma los 3 bytes de la plataforma y recorta los espacios. Si la longitud de la plataforma resultante es lo suficientemente larga, Jimmy se para.

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

A1= Jimmy, A2= plataforma

-23 bytes. Gracias @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~-~/(~/)~ 

Pruébalo en línea!

La salida es 1 si Jimmy está a salvo. De lo contrario, no genera nada. (Unario 1 y 0.) Debido a que no hay otra forma de tomar datos en ///, debe estar codificado:

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

Por ejemplo:

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

(¡ Pruébelo en línea! )

Tenga en cuenta el espacio después de la <INPUT HERE> .

Explicación:

¡NOTA! El código de explicación no se puede ejecutar debido a los comentarios. Los comentarios están encerrados entre llaves. Además, el código original utiliza un campo de golf donde //se reemplaza ~. Este código se omite de la explicación.

/\/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 para corregir un error
• -6 bytes aplicando un ///truco de golf estándar .

R , 35 bytes

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

Pruébalo en línea!

Basado en la excelente respuesta de Jelly de @EriktheOutgolfer, ¡ así que vota también esa!

La entrada es una matriz de caracteres en 2-d.

Haskell, 59 bytes

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

Pruébalo en línea!

La función se llama así: f "/o\\ " " -- "

Cómo funciona (para f "/o\\" " -"):

b++cycle" "- Agrega un número infinito de espacios después bpara garantizar que Jimmy siempre esté por encima de un -o ( " -"→" - ..."

zip a$b++cycle" "- Comprime las dos cuerdas juntas ( [('/',' '), ('o','-'), ('\\',' ')])

(p,q)<-zip a$b++cycle - Para cada par en la lista comprimida

[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- Genera una lista de 1s, cuya longitud es el número de pares que satisfacen las condiciones:

elem p"/o\\"- El personaje en la cadena superior es una de las partes del cuerpo de Jimmy. (Satisfecho por los tres pares en este ejemplo)

q==' '- El carácter en la cadena inferior es un espacio. (Satisfecho por ('/', ' ')y ('\\', ' '))

Entonces, el par tiene que ser uno donde una de las partes del cuerpo de Jimmy esté por encima de un espacio.

Como en este ejemplo, dos pares satisfacen ambas condiciones, la lista es [1,1]

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- Tome la suma de esos 1s (es decir, la longitud de la lista), que en este ejemplo es 2.

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2- Compruebe si el número de partes del cuerpo sobre un espacio es menor que 2. En este ejemplo, no lo es, por lo que Jimmy se caerá. :(

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

Pruébalo en línea!

Kotlin, 60 bytes

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

Explicación:

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|

Pruébalo en línea!

Agregue la entrada al final del programa para ejecutar. Devuelve la cadena vacía si Jimmy se cae de la plataforma, una cadena de signos de exclamación de lo contrario.

• /|/\/\// reemplaza | con //, lo que hace que el código sea más corto y más legible ( |se usa para demarcar cada reemplazo)
• /\/o\\/J| J/J*/ reemplaza a Jimmy con J por brevedad y cambia el espacio a la izquierda de él a* a la derecha de él
• El próximo reemplazo elimina las nuevas líneas.
• /* /| -/ | // cancela * sy con el espacio a la izquierda de la plataforma. Si quedan dos o más espacios, Jimmy se cae a la izquierda y la plataforma se elimina. Esta parte también elimina cualquier espacio en blanco a la derecha de la plataforma.
• /*-/|--/!/cancela *sy con la longitud de la plataforma. Si quedan al menos dos -, Jimmy no se cae a la derecha, por lo que se reemplazan con un! .
• /-/|*/|J// elimina todos los caracteres restantes que no son !

Japt , 8 bytes

Õ·kèS Êz

Intentalo

Retina 0.8.2 , 16 bytes

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

Pruébalo en línea! El enlace incluye un conjunto de pruebas. Explicación:

+`^ (.*¶).
$1

Si bien todavía hay un espacio en la primera línea, y ambas líneas aún tienen más de un carácter, elimine el espacio y el primer carácter de la línea siguiente. Nota: Esto supone que no hay espacio final después de Jimmy. Se necesita +1 byte si se debe permitir el espacio final.

¶ ?--

Compruebe que hay al menos dos piezas de plataforma debajo de Jimmy.

Perl 5 -pl , 42 bytes

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

Pruébalo en línea!

Ruby 2.5.3, 44 bytes

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

Entrada tomada como dos matrices. Definitivamente no es el enfoque más amigable para el golf (ver la respuesta de GB), pero me gusta cualquier excusa para usar la zipfunción.

PowerShell , 63..55 53 bytes

^{-1 byte gracias a mazzy}

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

Pruébalo en línea!

Toma la entrada como dos líneas.

Desenrollado:

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 # (compilador interactivo de Visual C #) , 44 40 39 bytes

-4 bytes gracias a Jo King

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

Pruébalo en línea!

Python 3.7 , 71 56 bytes

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

Versión muy simple y lo más corto que se me ocurre usar este enfoque. La entrada ses una lista de dos cadenas, la primera para la fila Jimmy, la segunda para la plataforma. Comprime los caracteres que están uno encima del otro y luego comprueba si- está debajo de una parte de Jimmy en al menos dos casos.

EDITAR: ¡Reducido en bastantes bytes gracias a 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

Este es un lenguaje bastante nuevo de mi propia creación: se pueden encontrar prototipos de intérpretes, documentación y programas de ejemplo en https://github.com/superloach/chevron .

Explicación:

• >^__>^j - tome a Jimmy como entrada TXT
• ^i<<0 - inicializar índice a 0
• ^i<<^i+1 - índice de incremento
• ^h<^i>^j - Obtener el personaje de Jimmy en el índice
• ->+2??^h=/ - Saltar del bucle en la pierna izquierda de Jimmy
• ->-3 - volver al comienzo del bucle
• >^__>^p - tome la plataforma como entrada TXT
• ^q<^i|2>^p - recorta 3 personajes debajo de jimmy
• ->+2??^q<-- - Si 2 guiones debajo de Jimmy, salta a la salida verdadera
• ><0 - salida falsa
• ><1 - salida sincera

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

Pruébalo en línea!

Sería mucho más corto ( 75 bytes ), si se pudiera suponer que hay espacios en blanco al final de la plataforma.

Japt -¡, 9 bytes

-1 byte si la entrada puede invertirse.

VtUao)è-²

Pruébalo en línea

V , 18 bytes

0vt/"_dj.d3lVkp0#x

Pruébalo en línea!

Salida de espacios en blanco solo si Jimmy cae de la plataforma. Imprima algo que no sea un espacio en blanco si Jimmy permanece en la plataforma.