Mais um desafio de Jimmy por seu pai original. Veja esses outros desafios adoráveis .

Como todos sabem, recentemente enfrentamos desafios relacionados ao Jimmy nas plataformas. Agora, Jimmy é um acrobata, como mencionei antes, e ele tem outros truques na manga.

Um desses truques está pendurado por cordas. Aqui está um exemplo de uma corda que Jimmy poderia pendurar:

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

Quando Jimmy fica pendurado em uma corda, fica assim:

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

Ele pode ficar à esquerda ou à direita da corda, de modo que isto:

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

também é válido. Mas ele não pode ficar com apenas uma parte do corpo, então algo assim:

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

é inválido. Observe que quando ele está pendurado por uma parte do corpo, a outra metade da corda é visível porque Jimmy não a cobre.

Além disso, Jimmy não gosta de pendurar na parte inferior da corda - isso o assusta - então isso:

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

é inválido.

O desafio

Tome conhecimento de uma situação de Jimmy como as descritas acima e analise se Jimmy se agarrará à corda ou não através de um valor verdadeiro ou falso.

Os detalhes

• Escreva um programa que aceite entrada. Isso pode ser por meio de uma função ou qualquer outro método de entrada apropriado.

  1. A entrada deve ser uma cena de um Jimmy e uma corda, como exemplificado acima.

• O programa deve gerar um valor verdadeiro ou falso para o console, com base no fato de Jimmy poder se agarrar à corda ou se ele cair da corda, respectivamente.

• Os critérios para Jimmy poder pendurar na corda:

  1. Duas de suas partes do corpo estão na corda.

  2. Ele não está no fundo da corda.

  3. Ele não está flutuando no ar.

• Você pode assumir que a corda será reta, composta de ||segmentos e terá mais de um caractere de altura.

• Você pode assumir uma corda inteira e um Jimmy singular estará presente em sua cena, nem mais nem menos.

• Você pode assumir que não haverá novas linhas à direita na parte inferior da corda.

• Você deve cobrir qualquer quantidade de espaços à esquerda ou à direita antes e depois da corda.

Casos de teste

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


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


        ||
       /o\                    TRUTHY
        ||


            ||
           /o\                FALSY


         /o\
          ||                  TRUTHY


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

Pontuação

Isso é código-golfe , então a pontuação mais baixa em bytes vence após cerca de uma semana.

Entre os melhores

Você pode visualizar o cabeçalho desta postagem expandindo o widget / snippet abaixo. Para que sua postagem seja incluída na classificação, você precisa de um cabeçalho ( # header text) com as seguintes informações:

• O nome do idioma (termine com vírgula ,ou hífen -), seguido por ...

• A contagem de bytes, como o último número a aparecer no seu cabeçalho.

Por exemplo, JavaScript (ES6), 72 bytesé válido, mas Fortran, 143 bytes (8-bit)é inválido porque a contagem de bytes não é o último número no cabeçalho (sua resposta será reconhecida como 8 bytes - não tire proveito disso).

<!-- Run the snippet to see the leaderboard. Report any bugs to @xMikee1 on Github. -->    <iframe src="https://xmikee1.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

Eu acho que isso está certo; Estou trabalhando há 16 horas seguidas e mal sei o meu próprio nome, então não ficaria surpreso se não!

Õø|io

Tente

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

Python 2 ou 3 ,  33  30 bytes

-3 graças a Maxwell

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

Uma função sem nome que aceita uma lista de linhas

Experimente online!

Quão?

Precisa haver uma seção de corda obscurecida por Jimmy que não seja a de baixo.

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

Experimente online!

Como funciona? Ele recebe a entrada como uma lista de cadeias e o zip se junta à cadeia. Jimmy fica na corda se houver um "|" abaixo de um "o", portanto, esse código une todas as linhas e verifica se existe um "o" seguido de "|".

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

(Resposta antiga) Python 2 ou 3, 39 bytes

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

Uma função que recebe entrada como uma lista de cadeias, cada uma sendo uma linha diferente.

-11 bytes graças ao xnor! -2 bytes graças a Jonathan Allan!

Experimente online! (Se você quiser tentar mais casos de teste, basta colocar um "." Após cada conjunto de linhas na caixa de entrada.)

Como é que isso funciona? Bem, se Jimmy estiver totalmente na corda, essa linha não terá nenhum "|" personagens. Portanto, podemos verificar cada linha e, se encontrarmos nenhuma sem "|" personagens, então sabemos que Jimmy pode ficar na corda. No entanto, Jimmy não pode segurar o fundo da corda; portanto, não incluímos a linha final em nossa verificação. Se a linha final for apenas mais uma parte da corda, isso não importará, porque ainda encontraremos uma linha válida mais acima, mas se a linha final for aquela com Jimmy, ela não encontrará uma linha. sem "|" em qualquer lugar e retornará False.

Geléia ,  9 7  6 bytes

Ṗ<”|ṀẠ

Um link monádico que aceita uma lista de linhas

Experimente online!

Quão?

Precisa haver uma seção de corda obscurecida por Jimmy que não seja a de baixo.

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

brainfuck, 79 64 bytes

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

Experimente online!

Emite o byte 0x01 para verdade e nada para falsidade.

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

Grime , 5 bytes

\o/\|

Experimente online!

A ferramenta certa para o trabalho.

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

Stax , 6 bytes

é¿┤4╠q

Execute e depure

Transpõe a entrada e procura "o |".

05AB1E , 5 bytes

Çü%àθ

Experimente online!

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

Os únicos caracteres que podem aparecer na entrada são \o/ |, com os respectivos pontos de código 92, 111, 47, 32, 124 (não há novas linhas, pois optamos por receber a entrada como uma matriz de linhas). Os resultados possíveis modulando dois desses números são 0, 13, 15, 17, 19, 28, 30, 32, 45, 47, 92, 111. 111 é o maior desses, e também o único que termina com 1 , portanto, o código emitirá verdade se e somente se 111 estiver presente na lista (apenas 1 é verdade em 05AB1E). 111 é 111 ( o)% 124 ( |) e, portanto, só ocorre se houver um oacima de |na entrada.

APL (Dyalog Unicode) , 8 bytes ^SBCS

Função de prefixo tácito anônimo, usando uma matriz de caracteres como argumento.

1∊'o|'⍷⍉

Experimente online!

⍉ transpor

'o|'⍷ máscara para todos os lugares oé imediata seguida por|

1∊ um deles é membro?

Dyalog APL estendido, 14 13 11 9 bytes

3∊¯1+/⍤↓<

Experimente online!

JavaScript, 39 33 bytes

Obrigado @Daniil Tutubalin por jogar fora 2 bytes

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

Isso corresponde a qualquer linha que não seja a linha em que o braço esquerdo aparece e nenhuma corda aparece.

Experimente online!

/// , 53 50 bytes

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

Experimente online!

Como não há outra maneira de obter entrada em ///, ela é codificada:

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

Explicação:

A abordagem geral é substituir Jimmy por 1 unário e removê-lo de todas as situações em que ele estiver em perigo. Se ele sobreviver, ele é produzido. Se ele não, então nada é. O ~no código é um substituto para //, o que permite que o código seja reduzido em 3 bytes aqui. Eles são omitidos da explicação.

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

          {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\
           ||.

Experimente online!

Ruby 2.5.5, 22 bytes

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

Espera uma matriz de linhas. Requer um mínimo da versão 2.5.5 porque é nesse momento queArray#all?(pattern) foi foi adicionado.

Devido às restrições de que a entrada sempre será uma cena válida de Jimmy e uma corda, tudo se resume a se alguma das linhas anteriores à última linha tem a corda obscurecida.

Kotlin , 93 84 bytes

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

Experimente online!

JavaScript, 38 37 bytes

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

Experimente online!

Retina , 9 bytes

m`^[^|]+^

Experimente online!

Agora, eu nunca tinha programado na Retina antes, mas até onde eu sei, isso funciona. É uma expressão regular que encontra uma string contendo (1) o início da entrada, (2) no "|" caracteres e (3) uma nova linha.

As pessoas mais familiarizadas com as expressões regulares ou com a Retina são incentivadas a oferecer sugestões. -2 bytes graças a Neil!

Perl 5 -p , 26 bytes

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

Experimente online!

Befunge-98 (PyFunge) , 26 24 bytes

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

Experimente online!

Sai com o código de retorno 3 se \n for encontrado e a última linha continha 3 caracteres não espaciais, caso contrário, sai com o código de retorno 0 no EOF. Portanto, isso depende da última linha que não contém uma nova linha à direita.

Dissecado

]~                     :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 (herdado) , 6 bytes

ζJ„o|å

Porto de @Shaggy resposta Japt 's .

Insira como uma lista de linhas.

Experimente online.

Explicação:

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

Olmo 0,19, 68 bytes

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

Recebe a entrada como uma lista de linhas. Desconsiderando a última linha, ele verifica se há algum sem '|'neles - o que implica que a corda está totalmente coberta por Jimmy.

Verifique todos os casos de teste aqui .

PowerShell , 26 bytes

Resposta do porto de Maxwell para Retina .

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

Experimente online!

Explicação:

true E se:

1. há uma linha em uma cena que não contém o personagem |
2. e depois dessa linha, inicia-se uma nova linha.

false de outra forma.

Pitão , 9 bytes

sPm!sqR\|

Suíte de teste!

Pyret, 79 bytes

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

Espera uma matriz de linhas como seqüências de caracteres. Faz uma cópia na link(0,l)qual todas as linhas foram deslocadas uma a uma. Percorre cada linha re nonde n é a linha abaixo de r. Verifica se o corpo de Jimmy "o"está em alguma posição, a linha abaixo dele tem um cano ali (por exemplo, Jimmy está pendurado na corda e não está no fundo).