História de fundo

Conheça meu amigo Jimmy:

/o\

Jimmy é um pequeno personagem que gosta de ficar em plataformas. Aqui está o Jimmy em pé com segurança em uma plataforma:

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

Agora, Jimmy tem um bom senso de equilíbrio, para que ele possa ficar em pé com segurança com uma perna fora da plataforma, assim:

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

Embora se ele fique com duas ou mais partes do corpo fora da plataforma, ele cairá. Ambos são exemplos em que Jimmy cairá:

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

O desafio

Seu desafio é escrever um programa para determinar, com base na posição e na plataforma de Jimmy, se Jimmy pode ficar na plataforma sem cair.

• Entrada: Duas linhas mostrando a posição de Jimmy e a posição da plataforma embaixo dele. Isso pode ser de duas entradas separadas, uma única entrada ou uma matriz de algum tipo.

  1. Você pode receber informações de qualquer forma razoável, incluindo funções e informações padrão. Recorra apenas à codificação codificada se o seu idioma não suportar os outros métodos de entrada.

• Saída: os valores booleanos true e false, ou os números inteiros 1 ou 0 para representar true / false, respectivamente.

  1. O valor booleano baseia-se em se Jimmy pode permanecer na plataforma ou não - verdadeiro se Jimmy pode permanecer na plataforma ou falso se ele cair.

• O tamanho da plataforma é arbitrário e pode ser alterado à vontade. Seu programa deve responder por isso.

  1. A plataforma não pode ter um comprimento igual a zero e deve estar completa (sem buracos na plataforma).

  2. Lembre-se de que Jimmy cai quando duas partes de seu corpo estão penduradas na plataforma. Uma parte do corpo é um caractere ASCII do seu corpo.

  3. O espaço em branco à direita no final da plataforma não é necessário, mas seu programa deve ser responsável pelas duas situações: onde há espaço em branco após a plataforma e onde não há.

• Esteja atento às brechas padrão que são proibidas.

Casos de teste

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

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

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

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

    /o\                    ❌ FALSE
     -

Pontuação

Isso é código-golfe , então a menor contagem de bytes vence.

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

Gelatina , 6 bytes

n⁶Sċ2Ẓ

Experimente online!

Explicação:

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). Retorna $0$ ou $1$ .

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

Experimente online!

Quão?

Procuramos a posição da parte "o"do meio do corpo de Jimmy na primeira corda e testamos se há um traço na segunda corda na mesma posição.

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

O único caso em que Jimmy seria inseguro nessa situação é com uma plataforma de traço único:

/o\
 -

Além disso, garantimos que a plataforma tenha uma largura de pelo menos $2$ :

/--/.test(b)

JavaScript (ES6), 36 bytes

Versão alternativa se assumirmos que sempre há traços ou espaços abaixo de Jimmy (ou seja, a entrada é retangular).

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

Experimente online!

Aproveita o fato de que a coerção para um valor numérico é $0$ para um espaço e NaN para um traço.

Excel, 67 45 44 bytes

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

Coloque Jimmy em A1uma plataforma A2.

2 condições verificadas:

• O torso de Jimmy ( o) está na plataforma?
• A plataforma é mais do que justa -?

Python 3, 88 43 bytes

A entrada é fornecida na forma de uma lista contendo duas strings: a primeira string é a primeira linha; a segunda corda é a segunda linha.

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

Experimente online!

Outra versão, com 43 bytes (não consegui obtê-lo com menos de 43):

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

Experimente online!

Redução de 42 bytes graças a uma dica de Jo King.

Versão antiga:

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

-2 bytes graças ao Sriotchilism O'Zaic.

Isso funciona com duas entradas separadas e emparelhando as letras correspondentes. Ele conta o número de pares em que nenhum caractere é um espaço e, em seguida, retorna True se esse número for maior que 1.

Perl 6 , 18 bytes

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

Experimente online!

Toma dois parâmetros e retorna um valor booleano de se Jimmy permanecerá na plataforma. Isso funciona juntando as duas linhas ao XOR e verificando se alguma parte do Jimmy ainda está na plataforma.

Explicação:

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

Experimente online!

5 bytes thx para sete negativos

Haskell , 34 bytes

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

Experimente online!

Eu peguei esse aqui combinando minha técnica abaixo com a outra resposta haskell .

Haskell , 45 bytes

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

Experimente online!

Isso conta o número de partes do corpo (caracteres que não são do espaço) que estão no topo da plataforma e, em seguida, verifica se é maior que 1. O motivo pelo qual contamos partes do corpo na plataforma em vez de partes do corpo é que zipWithcortará a linha superior para ser o comprimento do fundo e, portanto, pode cortar partes do corpo de Jimmy. Isso nos impede de ter que fazer algo como cycle" "preencher a lista.

MathGolf , 6 14 bytes

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

Experimente online!

8 bytes tiveram que ser adicionados para explicar o caso apresentado por Nick Kennedy.

Verifica se "-o-"há uma subcadeia de caracteres da seqüência compactada das duas linhas e da seqüência compactada em que a primeira linha de entrada tem o primeiro caractere removido. Recebe a entrada como duas cadeias separadas, com a única alteração que o caractere é inserido como /o\\, já que \\é a maneira correta de inserir uma barra invertida em uma string no MathGolf.

Explicação

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

ζðм2ùgp

-1 byte graças a @ Mr.Xcoder com a abordagem de ðм2ù.

Entrada como uma lista de duas cadeias.

Funciona apenas na versão herdada de 05AB1E, porque ζpode transpor uma lista de seqüências de caracteres e uma lista 2D de caracteres, enquanto que ζna nova versão 05AB1E funciona apenas com a lista 2D de caracteres.

Experimente online ou verifique todos os casos de teste .

Explicação:

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

Experimente online!

Dyalog APL estendido, 11 10 8 bytes

2≤1⊥∧⌿⍤<

Experimente online!

Explicação:

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 graças a Adám.

Excel, 36 bytes

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

Jimmy em A1uma plataforma em A2.

Localiza a posição de Jimmy, pega os 3 bytes da plataforma e apara os espaços. Se o comprimento da plataforma resultante for longo o suficiente, Jimmy se mantém.

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

A1= Jimmy, A2= plataforma

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

Experimente online!

A saída é 1 se Jimmy estiver seguro. Caso contrário, não gera nada. (Unário 1 e 0.) Como não há outra maneira de obter informações em ///, ele precisa ser codificado:

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

Por exemplo:

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

( Experimente online! )

Observe o espaço após o <INPUT HERE>.

Explicação:

NOTA! O código de explicação não pode ser executado devido aos comentários. Os comentários são colocados entre chaves. Além disso, o código original usa um campo de golfe onde //é substituído por ~. Este código é omitido da explicação.

/\/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 corrigir um erro
• -6 bytes, aplicando um ///truque de golfe padrão .

R , 35 bytes

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

Experimente online!

Com base na excelente resposta da @ EriktheOutgolfer Jelly, por favor, vote também nessa!

A entrada é uma matriz 2D de caracteres.

Haskell, 59 bytes

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

Experimente online!

A função é chamada assim: f "/o\\ " " -- "

Como funciona (para f "/o\\" " -" ):

b++cycle" "- Adiciona um número infinito de espaços depois bpara garantir que Jimmy esteja sempre acima de um -ou ( " -"→" - ..."

zip a$b++cycle" "- Fecha as duas cordas juntas ( [('/',' '), ('o','-'), ('\\',' ')])

(p,q)<-zip a$b++cycle - Para cada par na lista compactada

[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- Gera uma lista de 1s, cujo comprimento é o número de pares que satisfazem as condições:

elem p"/o\\"- O personagem na corda superior é uma das partes do corpo de Jimmy. (Satisfeito pelos três pares neste exemplo)

q==' '- O caractere na string inferior é um espaço. (Satisfeito por ('/', ' ')e('\\', ' ') )

Então, o par deve ser aquele em que uma das partes do corpo de Jimmy esteja acima de um espaço.

Como neste exemplo, dois pares atendem às duas condições, a lista é [1,1]

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']- Pegue a soma desses 1s (isto é, o comprimento da lista), que neste exemplo é2 .

sum[1|(p,q)<-zip a$b++cycle" ",elem p"/o\\",q==' ']<2- Verifique se o número de partes do corpo acima de um espaço é menor que 2. Neste exemplo, não é, para que Jimmy caia. :(

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

Experimente online!

Kotlin, 60 bytes

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

Explicação:

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|

Experimente online!

Anexe a entrada ao final do programa para executar. Retorna a string vazia se Jimmy cair da plataforma, caso contrário, uma string de pontos de exclamação.

• /|/\/\//substitui |por //, o que torna o código mais curto e mais legível ( |é usado para demarcar cada substituição)
• /\/o\\/J| J/J*/substitui Jimmy Jpor brevidade e altera o espaço à esquerda dele para* à direita dele
• A próxima substituição se livra das novas linhas.
• /* /| -/ | //cancela se *e com o espaço à esquerda da plataforma. Se houver dois ou mais espaços restantes, Jimmy está caindo para a esquerda e a plataforma é excluída. Esta parte também remove qualquer espaço em branco à direita da plataforma.
• /*-/|--/!/cancela se *e com o comprimento da plataforma. Se houver pelo menos dois -, Jimmy não está caindo para a direita, então eles são substituídos por a !.
• /-/|*/|J// exclui todos os caracteres restantes que não são !

Japonês , 8 bytes

Õ·kèS Êz

Tente

Retina 0.8.2 , 16 bytes

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

Experimente online! O link inclui o conjunto de testes. Explicação:

+`^ (.*¶).
$1

Enquanto ainda houver um espaço na primeira linha e as duas linhas ainda tiverem mais de um caractere, exclua o espaço e o primeiro caractere da próxima linha. Nota: Isso pressupõe que não haja espaço à direita após Jimmy. É necessário um byte de +1 se for necessário permitir espaço à direita.

¶ ?--

Verifique se há pelo menos duas peças de plataforma sob Jimmy.

Perl 5 -pl , 42 bytes

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

Experimente online!

Ruby 2.5.3, 44 bytes

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

Entrada tomada como duas matrizes. Definitivamente, não é a abordagem mais favorável ao golfe (consulte a resposta do GB), mas eu gosto de qualquer desculpa para usar a zipfunção.

PowerShell , 63..55 53 bytes

^{-1 byte graças a mazzy}

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

Experimente online!

Aceita entrada como duas linhas.

Desenrolado:

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 interativo do Visual C #) , 44 40 39 bytes

-4 bytes graças a Jo King

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

Experimente online!

Python 3.7 , 71 56 bytes

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

Versão muito simples e a mais curta que consegui pensar em usar essa abordagem. Input sé uma lista de duas strings, a primeira para a linha Jimmy, a segunda para a plataforma. Coloque os caracteres que estão acima um do outro e verifique se -há uma parte de Jimmy em pelo menos duas instâncias.

EDIT: Reduzido em alguns bytes, graças ao 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

Essa é uma linguagem bastante nova de minha própria criação - intérpretes de protótipo, documentação e programas de exemplo podem ser encontrados em https://github.com/superloach/chevron .

Explicação:

• >^__>^j - tome jimmy como entrada TXT
• ^i<<0 - inicialize o índice para 0
• ^i<<^i+1 - índice de incremento
• ^h<^i>^j - obtém o personagem de jimmy no índice
• ->+2??^h=/ - pule fora de loop na perna esquerda de jimmy
• ->-3 - volte para o início do loop
• >^__>^p - tome a plataforma como entrada TXT
• ^q<^i|2>^p - recorte 3 caracteres em jimmy
• ->+2??^q<-- - se 2 traços sob jimmy, pule para a verdadeira saída
• ><0 - saída falsa
• ><1 - saída de verdade

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

Experimente online!

Seria muito menor ( 75 bytes ), se se pudesse supor que há espaço em branco após a plataforma.

Japonês -¡, 9 bytes

-1 byte se a entrada puder ser revertida.

VtUao)è-²

Experimente online

V , 18 bytes

0vt/"_dj.d3lVkp0#x

Experimente online!

Espaço em branco de saída somente se jimmy cair da plataforma. Saída de algo que não seja espaço em branco se o jimmy permanecer na plataforma.