Sin embargo, otro desafío Jimmy de su padre original. Vea estos otros encantadores desafíos .

Como todos saben, recientemente hemos visto desafíos relacionados con Jimmy en las plataformas. Ahora, Jimmy es un acróbata como mencioné antes, y tiene otros trucos bajo la manga.

Uno de estos trucos es colgar de cuerdas. Aquí hay un ejemplo de una cuerda de la que Jimmy podría colgar:

            ||
            ||
            ||
            ||
            ||
            ||

Cuando Jimmy cuelga de una cuerda, se ve así:

            ||
            ||
           /o\
            ||
            ||
            ||

Puede colgar a la izquierda o a la derecha de la cuerda, así que esto:

            ||
            ||
            ||
            /o\
            ||
            ||

También es válido. Pero no puede colgarse de una sola parte del cuerpo, así que algo como esto:

            ||
            ||
            ||
          /o\|
            ||
            ||

no es válido. Tenga en cuenta que cuando está colgando de una parte del cuerpo, la otra mitad de la cuerda es visible porque Jimmy no la cubre.

Además, a Jimmy no le gusta colgar en la parte inferior de la cuerda, lo asusta, así que esto:

            ||
            ||
            ||
            ||
            ||
            /o\

no es válido.

El reto

Tome en cuenta una situación de Jimmy como las anteriores y haga saber si Jimmy se aferrará a la cuerda o no a través de un valor verdadero o falso.

Los detalles

• Escribe un programa que tome entrada. Esto puede ser a través de una función o cualquier otro método de entrada apropiado.

  1. La entrada debe ser una escena de un Jimmy y una cuerda como se ejemplificó anteriormente.

• El programa debería generar un valor verdadero o falso en la consola en función de si Jimmy puede aferrarse a la cuerda o si se caería, respectivamente.

• Los criterios para que Jimmy pueda colgarse de la cuerda:

  1. Dos de sus partes del cuerpo están en la cuerda.

  2. Él no está en el fondo de la cuerda.

  3. Él no está flotando en el aire.

• Puede suponer que la cuerda será recta, formada por ||segmentos y tendrá más de un carácter de altura.

• Puedes asumir que una cuerda entera y un Jimmy singular estarán presentes en tu escena, ni más ni menos.

• Puede suponer que no habrá nuevas líneas al final de la cuerda.

• Debe cubrir cualquier cantidad de espacios iniciales o finales antes y después de la cuerda.

Casos de prueba

           ||
           ||
           ||                 TRUTHY
           /o\
           ||
           ||


            ||
            ||
          /o\|                FALSY
            ||
            ||


        ||
       /o\                    TRUTHY
        ||


            ||
           /o\                FALSY


         /o\
          ||                  TRUTHY


            ||
            ||
       /o\  ||                FALSY
            ||
            ||

Puntuación

Este es el código de golf , por lo que la puntuación más baja en bytes gana después de aproximadamente una semana.

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 conteo 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 @ozewski on Github. -->    <iframe src="https://ozewski.github.io/ppcg-leaderboard/?id=187759" 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>

Japt , 5 bytes

Creo que esto es correcto; He estado trabajando durante 16 horas seguidas y apenas sé mi propio nombre, ¡así que no me sorprendería si no fuera así!

Õø|io

Intentalo

Õø|io     :Implicit input
Õ         :Transpose
 ø        :Contains?
  |io     :  "|" prepended with "o"

Python 2 o 3 ,  33  30 bytes

-3 gracias a Maxwell

lambda l:'o'in map(max,l[:-1])

Una función sin nombre que acepta una lista de líneas

Pruébalo en línea!

¿Cómo?

Debe haber una sección de cuerda oscurecida por Jimmy que no sea la inferior.

lambda l:'o'in map(max,l[:-1])
lambda l:                      # a function taking l (the lines as strings)
                       l[:-1]  # strip off the last line
               map(max,      ) # maximum of each line (where '|'>'o'>'\'>'/'>' ')
         'o'in                 # was 'o' one of them? (hence Jimmy obscured all the rope)

Python 2, 28 bytes

lambda x:"o', '|"in`zip(*x)`

Pruébalo en línea!

¿Como funciona? Toma la entrada como una lista de cadenas y zip se une a la cadena. Jimmy se queda en la cuerda si hay un "|" debajo de una "o", por lo que este código une todas las líneas y comprueba si hay una "o" seguida de una "|".

Código anotado:

lambda x: # Creates an anonymous function that takes one argument
  "o', '|" # If this substring is in the zip object, then Jimmy's "o" is above a "|"
    in
    `    # Back quotes change the object into its string representation
    zip(*x)` # Joins the lines together

(Respuesta anterior) Python 2 o 3, 39 bytes

lambda x:1-all("|"in i for i in x[:-1])

Una función que toma la entrada como una lista de cadenas, cada cadena es una línea diferente.

-11 bytes gracias a xnor! -2 bytes gracias a Jonathan Allan!

Pruébalo en línea! (Si desea probar más casos de prueba, simplemente coloque un "." Después de cada conjunto de líneas en el cuadro de entrada).

¿Como funciona esto? Bueno, si Jimmy está completamente en la cuerda, entonces esa línea no tendrá ningún "|" caracteres. Por lo tanto, podemos verificar cada línea, y si encontramos alguna sin "|" personajes, entonces sabemos que Jimmy puede quedarse en la cuerda. Sin embargo, Jimmy no puede aferrarse al fondo de la cuerda; por lo tanto, no incluimos la línea final en nuestro cheque. Si la línea final es solo otra parte de la cuerda, entonces no importará, porque todavía encontraremos una fila válida más arriba, pero si la línea final es la que tiene Jimmy, entonces no encontrará una línea sin "|" en cualquier lugar, y volverá False.

Jalea ,  9 7  6 bytes

Ṗ<”|ṀẠ

Un enlace monádico que acepta una lista de líneas

Pruébalo en línea!

¿Cómo?

Debe haber una sección de cuerda oscurecida por Jimmy que no sea la inferior.

Ṗ<”|ṀẠ - Main Link: list of lines of characters
Ṗ      - remove last line
  ”|   - pipe character
 <     - less than? (vectorises) - Note that all other characters are
    Ṁ  - maximum
     Ạ - all?

Grime , 5 bytes

\o/\|

Pruébalo en línea!

La herramienta adecuada para el trabajo.

\o        # match an "o"
  /       # above
   \|     # a "|"

brainfuck, 79 64 bytes

>>+<<,[----------[<]>>[.-]+<[>-]+[---------<-->]<[<]>>[-]<[>]<,]

Pruébalo en línea!

Emite el byte 0x01 para verdadero y nada para falso.

Z: 0
A: input
B: 0
C: has no | been found on this line?

>>+<<                       initialize C to 1
,[                          loop over each char

  ----------                set A to 0 if input was \n
  [<]>>                     move to C if input was \n; B otherwise
  [                         if input was \n and C is true
    .-                      output 1
  ]

  +                         this will reinitialize C to 1 if input was \n
                            but also clobber B with 1 if it wasn't
                            now we have { 0   0   0  (1)} if input was \n;
                                        { 0   _  (1)  _ } otherwise
  <[>-]                     clear own cell if the one to the left is positive
                            this yields { 0   0  (0)  1 } and
                                        { 0   _  (0)  _ } as desired

  +[---------<-->]          set A to 0 if input was |
  <[<]>>                    move to C if input was |; B otherwise
  [-]                       zero out current cell: clears C if input was |
  <[>]<                     realign pointer onto A

,]                          break on end of input

Stax , 6 bytes

é¿┤4╠q

Ejecutar y depurarlo

Transpone la entrada, luego busca "o |".

05AB1E , 5 bytes

Çü%àθ

Pruébalo en línea!

Ç         # convert the input to a 2D array of codepoints
 ü%       # pairwise modulo (vectorized)
   à      # maximum (*not* vectorized, returns a single number)
    θ     # tail (last digit)

Los únicos caracteres que pueden aparecer en la entrada son \o/ |, con los respectivos puntos de código 92, 111, 47, 32, 124 (no hay líneas nuevas, ya que elegimos tomar la entrada como una matriz de líneas). Los posibles resultados al modular dos de estos números son 0, 13, 15, 17, 19, 28, 30, 32, 45, 47, 92, 111. 111 es el más grande de esos, y también el único que termina con 1 , por lo que el código generará veracidad si y solo si 111 está presente en la lista (solo 1 es veraz en 05AB1E). 111 es 111 ( o)% 124 ( |), por lo que solo ocurre si hay un a osuperior |en la entrada.

APL (Dyalog Unicode) , ^{SBCS de} 8 bytes

Función de prefijo tácito anónimo, tomando una matriz de caracteres como argumento.

1∊'o|'⍷⍉

Pruébalo en línea!

⍉ transponer

'o|'⍷ la máscara para todas partes oes inmediata, seguida de|

1∊ es uno de ellos miembro?

Dyalog APL Extendido, 14 13 11 9 bytes

3∊¯1+/⍤↓<

Pruébalo en línea!

JavaScript, 39 33 bytes

Gracias @Daniil Tutubalin por jugar 2 bytes

x=>!!x.match(/^( *)\/[^|]*\n/m)

Esto coincide con cualquier línea que no sea la línea donde aparece su brazo izquierdo y ninguna de las cuerdas se muestra.

Pruébalo en línea!

/// , 53 50 bytes

/~/\/\~/\/o\\/1~1 /1~ 1/1~|1~/1|~/|~/1.~/ ~/.~/
~.

Pruébalo en línea!

Debido a que no hay otra forma de tomar entrada en ///, está codificada:

/~/\/\~/\/o\\/1~1 /1~ 1/1~|1~/1|~/|~/1.~/ ~/.~/
~<INPUT HERE>.

Explicación:

El enfoque general es reemplazar a Jimmy con un 1 unario, luego eliminarlo de todas las situaciones en las que esté en peligro. Si sobrevive, es expulsado. Si no lo hace, entonces nada lo es. Los ~en el código son un reemplazo para //, que permiten acortar el código en 3 bytes aquí. Se omiten de la explicación.

/{/\//
/}/\/\//

          {The top two lines allow me to leave comments without disturbing the code.}

/\/o\\/1/ {Replace Jimmy with a 1.}
/1 /1/    {Get rid of any spaces in front of Jimmy. This moves Jimmy towards the rope from the left.}
/ 1/1/    {Get rid of any spaces after Jimmy. This moves Jimmy towards the rope from the right.}

/|1//     {If Jimmy is touching the rope, remove him and the rope.}
/1|//     {This is based on the observation that in all cases where Jimmy is safe, there is no visible rope on his line.}


/|//      {Remove any remaining rope. If Jimmy was touching a rope, it's already too late for him.}
/1.//     {This handles the case where Jimmy is at the bottom of the rope (hence the period at the end).}


/ //      {The remaining lines clean up the output.}
/.//
/
//

           ||
           ||
           ||
           /o\
           ||.

Pruébalo en línea!

Ruby 2.5.5, 22 bytes

->x{x.pop;!x.all? /\|/}

Espera una serie de líneas. Requiere un mínimo de la versión 2.5.5 porque es cuando Array#all?(pattern)se agregó.

Debido a las restricciones de que la entrada siempre será una escena válida de Jimmy y una cuerda, se reduce a si alguna de las líneas anteriores a la última línea tiene la cuerda oculta.

Kotlin , 93 84 bytes

fun j(a:List<String>){print(a.count{!it.contains("|")}==1&&!a.last().contains("o"))}

Pruébalo en línea!

JavaScript, 38 37 bytes

r=>r.some(x=>!~x.search`\\|`,r.pop())

Pruébalo en línea!

Retina , 9 bytes

m`^[^|]+^

Pruébalo en línea!

Ahora, nunca he programado en Retina antes, pero por lo que puedo decir, esto funciona. Es una expresión regular que encuentra una cadena que contiene (1) el comienzo de la entrada, (2) no "|" caracteres y (3) una nueva línea.

Se alienta a las personas más familiarizadas con expresiones regulares o Retina a que ofrezcan sugerencias. -2 bytes gracias a Neil!

Perl 5 -p , 26 bytes

$\||=!/\|/;$;=/o/}{$\&&=!$

Pruébalo en línea!

Befunge-98 (PyFunge) , 26 24 bytes

]~:a-!#v_' `+
^_-3q#$<
@

Pruébalo en línea!

Sale con el código de retorno 3 si \n se encuentra y la última línea contiene 3 caracteres que no son espacios, de lo contrario sale con el código de retorno 0 en EOF. Por lo tanto, esto se basa en la última línea que no contiene una nueva línea final.

Disecado

]~                     :a-!#v_                ' `+
 Read character,      Branch downwards if   Increment counter on 
 branch up (and        equal to 10 ('\n')   the stack if greater
 loop around) if                            than 32 (' ') and
 end of stream                              implicitly loop

^_-3q#$<                    <
 Return with code 3
 if counter is equal to 3,
 otherwise reset counter
 and return to beginning

@
 Return with exit
 code 0

05AB1E (heredado) , 6 bytes

ζJ„o|å

Puerto de la respuesta de Japs de @Shaggy .

Entrada como una lista de líneas.

Pruébalo en línea.

Explicación:

ζ       # Zip/transpose the (implicit) strings in the input-list, with space as filler
        # (NOTE: zip/transpose doesn't work on string-list in the new version of 05AB1E,
        #  which is why we use the legacy version)
 J      # Join these zipped/transposed lines together to a single string
  „o|å  # And check if it contains the string "o|"
        # (after which the result is output implicitly)

Elm 0.19, 68 bytes

f r=List.any(not<<String.contains"|")(List.take((List.length r)-1)r)

Toma la entrada como una lista de líneas. Sin tener en cuenta la última línea, comprueba si hay alguna sin'|' ellas, lo que implica que Jimmy está completamente cubierto con la cuerda.

Verifique todos los casos de prueba aquí .

Potencia Shell , 26 bytes

La respuesta del puerto de Maxwell para Retina .

"$args"-match'(?m)^[^|]+^'

Pruébalo en línea!

Explicación:

true Si:

1. hay una línea en una escena que no contiene el personaje |
2. y después de esta línea hay un comienzo de una nueva línea.

false de otra manera.

Pyth , 9 bytes

sPm!sqR\|

¡Banco de pruebas!

Pyret, 79 bytes

{(l):all2({(r,n):string-char-at(n,string-index-of(r,"o") == "|")},l,link(0,l))}

Espera una serie de líneas como cadenas. Hace una copia en link(0,l)donde todas las filas se desplazaron hacia abajo por una. Pasa por cada fila ry ndonde n es la fila debajo de r. Comprueba que si el cuerpo de Jimmy "o"está en alguna posición, entonces la fila debajo tiene una tubería allí (es decir, Jimmy está colgado de la cuerda y no está en la parte inferior).