Nesse desafio simples, mas divertido , você foi solicitado a determinar se Jimmy cairia da plataforma deles. Jimmy tem três partes do corpo /, oe \dispostas como este

/o\

As plataformas são representadas por -. Jimmy cairá da plataforma se tiverem duas ou mais partes do corpo que não estão diretamente acima da plataforma.

Alguns exemplos:

   /o\
- -------

Jimmy se equilibrará, já que todas as partes do corpo estão acima de -.

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

Jimmy vai equilibrar uma vez que duas partes do corpo estão acima de -s.

 /o\
-- ----  --

Jimmy se equilibrará mesmo estando divididos entre duas plataformas

  /o\
   -

Jimmy não estará equilibrado, pois duas partes do corpo não estão acima de uma plataforma.

Sua tarefa é escrever um programa que utilize uma plataforma como um contêiner de comprimento contendo apenas -s e s (por exemplo, uma string) e produza o número de Jimmys que podem ser colocados na plataforma, para que nenhum deles caia e nenhum deles caia. sobreposição. Um Jimmy pode ter uma de suas partes do corpo à esquerda do início da corda ou à direita do fim da corda.

Isso é código-golfe, então as respostas são pontuadas em bytes, com menos bytes sendo o objetivo.

Casos de teste

Entradas

-  -  -

- -
--
-- --
----
- -- --
------- -

Resultados respectivos

0
0
1
1
2
2
2
3

JavaScript (ES6),  45 41  40 bytes

Guardado 4 bytes graças a @Shaggy

s=>(0+s+0).split(/.--|-.-|--./).length-1

Experimente online!

Python 2 , 53 bytes

lambda s:len(re.findall('.--|-.-|--.',`s`))
import re

Experimente online!

Baseado no regex de Arnauld . Avidamente procura por todas as substrings de comprimento 3 não sobrepostas com duas ou mais -. Um truque é fazer `s`para colocar a sequência de entrada entre aspas como preenchimento para deixar espaço para Jimmys ficar em uma das extremidades como

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

Python 2 , 57 bytes

f=lambda s:'--'in s[:3]*2and-~f(s[3:])or s>''and f(s[1:])

Experimente online!

Requer um formato de E / S brega da entrada já entre aspas. Saídas Falsepara 0.

Uma função recursiva que coloca cada Jimmy na posição mais à esquerda permitida, colocando Jimmy sobre os três primeiros caracteres, se eles puderem segurar Jimmy, ou excluindo o primeiro caractere. Um truque bonito é verificar se s[:3]contém duas ou mais -ações '--'in s[:3]*2, o que concatena duas cópias s[:3]e verifica duas adjacentes -.

Perl 5 -p , 28 bytes

Usa o mesmo método que o JavaScript de @ Arnauld.

$_=@a=" $_ "=~/.--|-.-|--./g

Experimente online!

Japonês , 16 bytes

Baseado na solução JS original da Arnauld. Tentei alguns métodos diferentes para obter o preenchimento necessário em ambos os lados da entrada, mas todos vieram com o mesmo comprimento - ainda procurando um caminho mais curto ...

ûUÊÄÄ è".--|-."ê

Teste-o

ûUÊÄÄ è".--|-."ê     :Implicit input of string U
û                    :Centre pad with spaces to length
 UÊ                  :  Length of U
   ÄÄ                :  Add 1, twice
      è              :Count the occurrences of
       ".--|-."ê     :  ".--|-." palindromised, resulting in the RegEx /.--|-.-|--./g

Excel, 96 bytes

A1= plataforma. Introduzido como matriz Formula Ctrl+ Shift+Enter

=SUM(IF(LEN(TRIM(MID(IF(MOD(LEN(A1),3)=1," ","")&A1,3*ROW(INDIRECT("A1:A"&LEN(A1)))-2,3)))>1,1))

05AB1E , 16 bytes

ðì‚ε3ôʒ'-¢2@}g}à

Definitivamente, pode ser jogado golfe. Às vezes, é irritante ver todas essas respostas de regex em um desafio ao usar 05AB1E, que não possui nenhum tipo de regex. ;)

Experimente online ou verifique todos os casos de teste .

Explicação:

ðì            # Prepend a space before the (implicit) input
  ‚           # Pair it with the unmodified (implicit) input
   ε          # Map both to:
    3ô        #  Split them into parts of size 3
      ʒ       #  Filter these parts by:
       '-¢   '#   Where the amount of "-"
          2@  #   Is larger than or equal to 2
      }g      #  After the filter: take the length to get the amount of items left
   }à         # After the map: get the maximum of the two
              # (which is output implicitly as result)

Ruby , 39 bytes

->s{s.scan(/(^|.)--|-.-|--(.|$)/).size}

Experimente online!

Stax , 13 bytes

ƒó±KêyG←à╛Ωô∟

Execute e depure

Java 8, 41 bytes

s->(0+s+10).split(".--|--.|-.-").length-1

Experimente online.

Porta da resposta JavaScript do @Arnauld , exceto que +0é +10para corrigir casos de teste como ----. Isso é necessário porque o String#splitJava interno removerá as Strings vazias à direita por padrão. Isso pode ser alterado adicionando um parâmetro adicional ao splitbuiltin (que é 0por padrão no split-builtin com um único argumento String). Para citar o uso desse parâmetro adicional nos documentos:

O parâmetro limit controla o número de vezes que o padrão é aplicado e, portanto, afeta o comprimento da matriz resultante.
$n$$n-1$$n$
$n$
$n$ zero , o padrão será aplicado quantas vezes for possível, a matriz pode ter qualquer comprimento,e seqüências de caracteres vazias à direita serão descartadas .

Por esse motivo, geralmente .split("...",-1)é usado para reter TODAS as seqüências de caracteres vazias vazias, e eu também poderia ter usado essa resposta ( experimente on-line ). Nesse caso, alterar o +0para +10salva dois bytes sobre o ,-1, no entanto. :)

Gelatina , 12 bytes

n⁶,Ż$s€3§Ẓ§Ṁ

Experimente online!

Com base na resposta 05AB1E de @ KevinCrujissen, certifique-se de que ele também vota .

Carvão , 25 bytes

Ｐθ↖Ｆθ¿›№ＫＭ-¹«⊞υωＭ³→»→⎚ＩＬυ

Experimente online! Link é a versão detalhada do código. Explicação:

Ｐθ↖

Imprima a plataforma sem mover o cursor, depois mova o cursor para cima e para a esquerda, pois essa é a primeira posição potencial de Jimmy.

Ｆθ

Procure tantos Jimmies quanto houver posições na plataforma.

¿›№ＫＭ-¹

Verifique se há mais de uma peça de plataforma nesta posição.

«⊞υω

Nesse caso, observe uma posição válida do Jimmy ...

Ｍ³→»

... e mova três caracteres para a direita para que os Jimmies não se sobreponham.

→

Caso contrário, a próxima posição potencial de Jimmy é um caractere à direita.

⎚ＩＬυ

Limpe a plataforma e produza a contagem de posições descobertas.

PowerShell , 38 bytes

Resposta JavaScript do Port of Arnauld .

(" $args "-split'.--|-.-|--.').count-1

Experimente online!

Olmo 0,19, 108 bytes

import Regex as R
f p=List.length<|R.find(Maybe.withDefault R.never<|R.fromString".--|-.-|--.")(" "++p++" ")

Com base no regex na resposta JavaScript de Arnauld . Verifique todos os casos de teste aqui .

Solução alternativa sem regex, significativamente maior a 171 bytes :

f p=(String.foldl(\z{x,y,s,c}->let(t,d)=if s<1&&List.length(List.filter((==)'-')[x,y,z])>1 then(2,c+1)else(max 0 s-1,c)in{x=y,y=z,s=t,c=d}){x=' ',y=' ',s=0,c=0}(p++" ")).c

Verifique todos os casos de teste aqui .