Como você provavelmente sabe, houve vários desafios adoráveis ​​do Jimmy recentemente surgindo. Nesses desafios, você foi desafiado com as habilidades acrobáticas de nosso amado amigo. Agora, temos um desafio diferente para você. Hoje você estará identificando diferentes tipos de Jimmys!

Explicação

Existem três variedades de Jimmys: anão, acrobata e fisiculturista.

This is dwarf Jimmy:               o

This is acrobat Jimmy:            /o\

This is bodybuilder Jimmy:       /-o-\

Esses Jimmys são todos grandes amigos e gostam de permanecer na mesma linha que os outros. Sua tarefa é, dada uma cena do Jimmy assim:

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

Gera a quantidade de anões, acrobatas e fisiculturistas na linha, respectivamente.

O desafio

• Tome entrada de qualquer forma razoável como uma cena de Jimmy, como mostrado no exemplo acima.

  1. A sequência de entrada deve ser uma linha e, opcionalmente, contém as três variedades de Jimmys e o espaço em branco opcional.

  2. A sequência não conterá necessariamente todas as variedades ou espaços em branco de Jimmy.

  3. A sequência não conterá nenhum caractere que não esteja o/\ -.

  4. Qualquer combinação de variedades Jimmy é possível. Isso significa que o mesmo ou diferente tipo de Jimmy pode estar próximo um do outro. Você deve responder por isso.

  5. Os espaços em branco à esquerda e à direita são opcionais e de forma alguma são necessários - seu programa deve contabilizar uma sequência com ou sem espaços em branco à esquerda e / ou à direita.

  6. A sequência deve conter apenas Jimmys e espaços em branco válidos. Por exemplo, ---///---não é permitido porque não é uma sequência Jimmy válida.

• Saída três números: A contagem de anões, acrobatas e fisiculturistas na cena (na ordem respectiva).

  1. Pode ser uma saída para o console como números inteiros separados por espaço, ou pode ser um valor de retorno de uma função como algum tipo de contêiner (ou seja, um tipo de matriz).

  2. A saída, em qualquer formato, deve ser solicitada conforme mencionado no marcador acima desta regra.

• Aplicam-se regras e brechas padrão.

Casos de teste

     /-o-\           /-o-\     o/o\  /-o-\       /-o-\                /-o-\
OUTPUT: 1 1 5


      o o               /o\    o o      o                    /o\             /o\
OUTPUT: 5 3 0


 /-o-\     /-o-\            /-o-\/-o-\   o /o\/o\    /-o-\o /-o-\       /o\/-o-\
OUTPUT: 2 3 7


  /-o-\  o                 /-o-\               o/o\
OUTPUT: 2 1 2

Se você quiser mais casos de teste, use esta ferramenta para gerar mais casos de teste aleatórios.

Pontuação

Isso é código-golfe , então a pontuação mais baixa em bytes vence.

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://ozewski.github.io/ppcg-leaderboard/?id=188391" 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 , (12?) 13 bytes

ċⱮ“-/o”H1¦ŻIṚ

Um link monádico que aceita uma lista de caracteres que gera uma lista de números inteiros [ dwarves, acrobats, and body-builders](salve o Ṛbyte se pudermos especificar nossa saída)

Experimente online!

Quão?

Todos os Jimmys mostram um o; todos os não-anões mostram a /; todos os construtores de corpo mostram dois -. Conte-os, reduza pela metade a contagem de -e execute a subtração para encontrar a contagem de Jimmy:

ċⱮ“-/o”H1¦ŻIṚ - Link: list of characters
  “-/o”       - list of characters ['-', '/', 'o']
 Ɱ            - map across right with:
ċ             -   count occurrences   = [n('-'), n('/'), n('o')]
         ¦    - sparse application...
        1     - ...to indices: [1] -- i.e. n('-')
       H      - ...action: halve    = [n('-')/2, n('/'), n('o')]
          Ż   - prepend a zero =   [0, n('-')/2, n('/'), n('o')]
           I  - incremental differences
              -     = [n('-')/2, n('/')-n('-')/2, n('o')-n('/')]
            Ṛ - reverse
              -     = [n('o')-n('/'), n('/')-n('-')/2, n('-')/2]

Python 3.8 (pré-lançamento) , 51 bytes

lambda s:((c:=s.count)('o')-c('/'),c('/o'),c('/-'))

Experimente online!

Python 2 , 50 bytes

x,y,z=map(input().count,'o/-')
print x-y,y-z/2,z/2

Experimente online!

-10 bytes convertendo a expressão lambda em um programa completo graças ao @xnor (remove a coisa aninhada lambda dupla e usa a atribuição)

PowerShell , 59 55 bytes

$c=,0*3
$args|sls '/?-?o'-a|% m*|% le*|%{++$c[$_-1]}
$c

Experimente online!

Desenrolado:

$counters=,0*3
$args|select-string '/?-?o'-AllMatches|% Matches|% Length|%{++$counters[$_-1]}
$counters

J , 36 25 bytes

-11 bytes graças a cole!

2-/\0,~1 1 2%~1#.'o/-'=/]

Experimente online!

Solução original

J , 36 bytes

[:(-/@}:,-/@}.,{:)1 1 2%~1#.'o/-'=/]

Experimente online!

Explicação:

                            'o/-'=/] compare the input with each one of "o/-" characters
                                     / the result is a 3-row matrix /
                         1#.         add up each row to find the number of occurences
                                     of each character, the result is a vector of 3 items
                  1 1 2%~            divide the last item by 2 to find the number of 
                                     bodybuilder Jimmys
[:(              )                   use the result to construct the following vector:
               {:                    the last item
              ,                      appended to
         -/@}.                       the difference of the second and the third items
        ,                            appended to
   -/@}:                             the difference of the first and the second items

Uma sessão J de amostra :

a=:'  /-o-\  o                 /-o-\               o/o\'
   'o/-'=/a
0 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
   1#.'o/-'=/a
5 3 4  
   1 1 2%~1#.'o/-'=/a
5 3 2
   (-/@}:,-/@}.,{:)1 1 2%~1#.'o/-'=/a
2 1 2

Excel como CSV, 130 bytes

,=LEN(A3)-LEN(A4)
=SUBSTITUTE(A1,"-o",""),=(LEN(A2)-LEN(A3))/2
=SUBSTITUTE(A2,"/o",""),=(LEN(A1)-LEN(A2))/2
=SUBSTITUTE(A3,"o","")

Insira a entrada no espaço antes da primeira ,, salve como .csv, abra no Excel. Produz anões, acrobatas e culturistas em B1, B2e B3respectivamente.

Excel, 244 bytes

=LEN(SUBSTITUTE(SUBSTITUTE(A1,"-o",""),"/o",""))-LEN(SUBSTITUTE(SUBSTITUTE(SUBSTITUTE(A1,"-o",""),"/o",""),"o",""))&" "&(LEN(SUBSTITUTE(A1,"-o",""))-LEN(SUBSTITUTE(SUBSTITUTE(A1,"-o",""),"/o","")))/2&" "&(LEN(A1)-LEN(SUBSTITUTE(A1,"-o","")))/2

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

2-/2÷⍨@2+/'o/-x'∘.=⎕

Experimente online!

Kotlin 131 130 129 121 117 97 96 88 bytes

fun String.j(b:Int=count{'-'==it}/2,a:Int=count{'/'==it})=listOf(count{'o'==it}-a,a-b,b)

Experimente online!

Edit - Wew, tem menos de 100! Duvido que possa encolher mais, mas só o tempo dirá ...

Editar - falou muito cedo, eliminou mais um byte usando uma lista em vez de uma sequência

Editar - menos 8 bytes, graças ao AsoLeo, sugerindo o uso de uma função de extensão

Retina , 39 35 bytes

Edit: -4 bytes graças a @FryAmTheEggMan

^((o)|(/o.)|(/-o-.)| )*
$#2 $#3 $#4

Experimente online!

Explicação:

Um simples estágio de substituição. Ele encontra todas as correspondências da regex ^((o)|(/o.)|(/-o-.)| )*(que deve resultar em uma correspondência - a cadeia inteira) e a substitui pelo número de capturas dos grupos 2, 3 e 4. Aqui está a regex dividida:

^((o)|(/o.)|(/-o-.)| )*
^                               start at the beginning of the string
 (                       )*     have any amount of Jimmy / spaces
     |       |         |        select one of:
  (o)                           capturing group 2 - dwarf
      (/o.)                   capturing group 3 - acrobat
              (/-o-.)         capturing group 4 - bodybuilder

Temos que começar ^ou o final da entrada também conta como uma correspondência. Na sintaxe de substituição da Retina, faz $nreferência ao enésimo grupo de capturas e o modificador #conta quantas correspondências foram feitas.

JavaScript, 55 bytes

Pesquisa a string usando uma correspondência padrão regex o, o-ou o-\; incrementa a contagem correspondente em uma matriz, usando o comprimento de cada correspondência para determinar o índice.

s=>s.replace(/o-?\\?/g,m=>a[m.length-1]++,a=[0,0,0])&&a

Experimente online!

Clojure , 78 bytes

(defn ?[s](def c #(count(re-seq % s)))[(-(c #"o")(c #"/"))(c #"/o")(c #"/-")])

Experimente online!

Wolfram Language (Mathematica) , 63 bytes

Reverse@{a=(m=CharacterCounts@#)["-"]/2,b=m["/"]-a,m["o"]-a-b}&

Experimente online!

55 bytes se o requisito de ordem inútil for descartado ...

Python 3 , 69 66 60 56 bytes

-4 bytes graças a @Maarten Fabré

g=input().count
b,c=g('/'),g('/-')
print(g('o')-b,b-c,c)

Experimente online!

R , 63 bytes

Usa a correspondência de Regex para encontrar e contar os Jimmys.

library(stringr)
str_count(scan(,''),c('(?<![/-])o','/o','/-'))

Experimente online!

K (oK) , 25 bytes

{|-':|1 1 .5*+/x=\:"o/-"}

Experimente online!

Perl 5 -p , 41 bytes

$_=1*s/o(?!\\|-)//g.$".1*s|/o||g.$".y/o//

Experimente online!

Conta o número de vezes que oaparece sem ser seguido por \ou -para encontrar os anões e os remove da corda. Em seguida, conta o número de vezes que /oaparece para encontrar os acrobatas e os remove da string. Em seguida, conta o número de orestantes para determinar os construtores de corpo. Insere espaços entre os números e gera implicitamente o resultado.

Ruby , 50 bytes

->s{%w(o /o -o).map{|x|s.scan(/[\/-]?o/).count x}}

Experimente online!

SNOBOL4 (CSNOBOL4) , 135 bytes

	I =INPUT
B	I '-o' =	:F(A)
	B =B + 1	:(B)
A	I '/o' =	:F(D)
	A =A + 1	:(A)
D	I 'o' =	:F(O)
	D =D + 1	:(D)
O	OUTPUT =+D ' ' +A ' ' +B
END

Experimente online!

Remove -o, /oe oda corda e incrementos os contadores apropriados de cada vez. Deixa para trás um monte de braços e pernas ( /-\, \e nada).

Quarto (gforth) , 118 bytes

: c -rot 0 tuck do over i + c@ 3 pick = - loop nip nip ;
: f 2dup '/ c >r 2dup '- c 2/ -rot 'o c i - . r> over - . . ;

Experimente online!

Explicação

• Se Contagem de /, -e opersonagens
• Bodybuilder é o número de -caracteres dividido por 2
• Acrobat é o número de / caracteres menos o número de fisiculturistas
• Anão é o número de ocaracteres menos o número de Acrobat e Bodybuilders

Código Explicação

\ c counts the number of occurrences of the given character in a string
\ stack usage is ( c-addr u1 w1 - u )
: c                 \ start a new word definition
  -rot 0 tuck       \ sets up parameters for a counted loop
  do                \ loop from 0 to string-length - 1 (inclusive)
    over i +        \ get the address of the current character in the string
    c@              \ get the ascii value of the current character              
    3 pick =        \ compare it to the character we're counting
    -               \ subtract result from the accumulator (subtract because -1 = true in forth)
  loop              \ end the loop
  nip nip           \ remove extra values from the stack
;                   \ end the word definition

\ Main function 
: f                 \ start a new word definition
  2dup              \ duplicate the string address and length
  '/ c >r           \ count the number of '/' characters and stick the result on the return stack
  2dup '- c 2/      \ count the number of '-' characters and divide by 2
  -rot 'o c         \ move the string to the top of the stack and count the number of 'o characters
  i - .             \ calculate number of dwarf jimmy's and print
  r> over - .       \ calculate number of acrobat jimmy's and print (drop '/' count from return stack)
  .                 \ print number of body-builder jimmy's
;                   \ end word definition

05AB1E , 13 bytes

…-/oS¢ć;š0š¥R

Esse pode ter 12 bytes , removendo o Rse uma ordem de saída de [bodybuilder, acrobat, dwarf]for permitida.

Experimente online ou verifique todos os casos de teste .

Alternativa menor de bytes iguais:

…-/oS¢R`;0)üα

Experimente online ou verifique todos os casos de teste .

Explicação:

…-/o           # Push string "-/o"
    S          # Split to a list of characters: ["-","/","o"]
     ¢         # Count the occurrence of each character in the (implicit) input-string
      ć        # Extract the head; pop and push head and remainder-list
       ;       # Halve this head
        š      # And prepend it back in front of the remainder-list
         0š    # Then also prepend a 0
           ¥   # Get the deltas (forward differences)
            R  # And reverse the list to get the required order of output-counts
               # (after which the result is output implicitly)

…-/oS¢         # Same as above
      R        # Reverse this list
       `       # Pop the list and push its values separately to the stack
        ;      # Halve the top value on the stack
         0     # Push a 0
          )    # Wrap all values on the stack into a list
           ü   # For each overlapping pair of values:
            α  #  Get the absolute difference between the two values
               # (after which the result is output implicitly)

C (gcc) , 99 98 96 bytes

-1 byte graças ao ceilingcat

o,S,d,c;f(char*s){for(o=S=d=0;c=*s++;o+=c>93)d+=c==45,S+=c==47;printf("%d %d %d",o-S,S-d,d/=2);}

Experimente online!