Como probablemente sepa, recientemente han aparecido múltiples desafíos encantadores de Jimmy . En estos desafíos, te desafiaron con las habilidades de acrobacia de nuestro querido amigo. Ahora tenemos un desafío diferente para ti. ¡Hoy identificarás diferentes tipos de Jimmys!

Explicación

Hay tres variedades de Jimmys: enano, acróbata y culturista.

This is dwarf Jimmy:               o

This is acrobat Jimmy:            /o\

This is bodybuilder Jimmy:       /-o-\

Todos estos Jimmys son grandes amigos y les gusta estar en la misma línea que los demás. Su tarea es, dada una escena de Jimmy así:

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

Salida de la cantidad de enanos, acróbatas y culturistas en la línea, respectivamente.

El reto

• Tome la entrada en cualquier forma razonable como una escena Jimmy, como se muestra en un ejemplo anterior.

  1. La cadena de entrada debe ser una línea y opcionalmente contiene las tres variedades de Jimmys y espacios en blanco opcionales.

  2. La cadena no contendrá necesariamente todas las variedades o espacios en blanco de Jimmy.

  3. La cadena no contendrá ningún carácter que no esté en o/\ -.

  4. Cualquier combinación de variedades Jimmy es posible. Esto significa que el mismo o diferente tipo de Jimmy puede estar uno al lado del otro. Debes dar cuenta de eso.

  5. Los espacios en blanco iniciales y finales son opcionales y de ninguna manera son necesarios: su programa debe tener en cuenta una cadena con o sin espacios en blanco iniciales y / o finales.

  6. La cadena debe contener solo Jimmys y espacios en blanco válidos. Por ejemplo, ---///---no está permitido porque no es una secuencia Jimmy válida.

• Salida de tres números: el recuento de enanos, acróbatas y culturistas en la escena (en el orden respectivo).

  1. Esto puede ser una salida a la consola como enteros separados por espacios, o puede ser un valor de retorno de una función como algún tipo de contenedor (es decir, un tipo de matriz).

  2. La salida, en cualquier formato, debe ordenarse como se menciona en la viñeta superior sobre esta regla.

• Se aplican reglas estándar y lagunas.

Casos de prueba

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

Si desea más casos de prueba, use esta herramienta para generar más casos de prueba aleatorios.

Tanteo

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

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 recuento 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 @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>

Jalea , (12?) 13 bytes

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

Un enlace monádico que acepta una lista de caracteres que produce una lista de enteros [ dwarves, acrobats, and body-builders](guarde el Ṛbyte si podemos especificar nuestra salida)

Pruébalo en línea!

¿Cómo?

Todos los Jimmys muestran un o; todos los no enanos muestran a /; Todos los culturistas muestran dos -. Cuente estos, reduzca a la mitad el recuento -y reste para encontrar los recuentos 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 (prelanzamiento) , 51 bytes

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

Pruébalo en línea!

Python 2 , 50 bytes

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

Pruébalo en línea!

-10 bytes al convertir la expresión lambda en un programa completo gracias a @xnor (elimina la cosa anidada doble lambda y utiliza la asignación en su lugar)

PowerShell , 59 55 bytes

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

Pruébalo en línea!

Desenrollado:

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

J , 36 25 bytes

-11 bytes gracias a cole!

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

Pruébalo en línea!

Solución original

J , 36 bytes

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

Pruébalo en línea!

Explicación:

                            '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

Una sesión J de muestra :

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","")

Inserte la entrada en el espacio antes del primero ,, guárdela como .csv y ábrala en Excel Produce enanos, acróbatas y culturistas en B1, B2y 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'∘.=⎕

Pruébalo en línea!

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)

Pruébalo en línea!

Editar - Wew, ¡tengo menos de 100! Dudo que pueda reducirlo más, pero solo el tiempo lo dirá ...

Editar: habló demasiado pronto, dejó caer un byte más usando una lista en lugar de una cadena

Editar - menos 8 bytes gracias a AsoLeo que sugiere usar una función de extensión

Retina , 39 35 bytes

Editar: -4 bytes gracias a @FryAmTheEggMan

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

Pruébalo en línea!

Explicación:

Una simple etapa de reemplazo. Encuentra todas las coincidencias de la expresión regular ^((o)|(/o.)|(/-o-.)| )*(que debería dar como resultado una coincidencia, la cadena completa) y la reemplaza por el número de capturas de los grupos 2, 3 y 4. Aquí se desglosa la expresión regular:

^((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

Tenemos que comenzar con ^o el final de la entrada también cuenta como una coincidencia. En la sintaxis de sustitución de Retina, hace $nreferencia al enésimo grupo de captura y el modificador #cuenta cuántas coincidencias hizo.

JavaScript, 55 bytes

Busca la cadena utilizando una coincidencia de patrones de expresiones regulares o, o-o o-\; incrementa el recuento correspondiente en una matriz, utilizando la longitud de cada coincidencia para determinar el índice.

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

Pruébalo en línea!

Clojure , 78 bytes

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

Pruébalo en línea!

Wolfram Language (Mathematica) , 63 bytes

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

Pruébalo en línea!

55 bytes si se elimina el requisito de orden inútil ...

Python 3 , 69 66 60 56 bytes

-4 bytes gracias a @Maarten Fabré

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

Pruébalo en línea!

R , 63 bytes

Utiliza la combinación de expresiones regulares para encontrar y contar los Jimmys.

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

Pruébalo en línea!

K (oK) , 25 bytes

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

Pruébalo en línea!

Perl 5 -p , 41 bytes

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

Pruébalo en línea!

Cuenta el número de veces que oaparece sin ser seguido por \o -para encontrar a los enanos y los elimina de la cadena. Luego cuenta el número de veces/o parece encontrar los acróbatas y los elimina de la cadena. Luego cuenta el número de orestantes para determinar los culturistas. Inserta espacios entre los números y genera implícitamente el resultado.

Rubí , 50 bytes.

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

Pruébalo en línea!

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

Pruébalo en línea!

Elimina -o, /oy ode la cadena e incrementa los contadores apropiados cada vez. Deja tras de sí una gran cantidad de brazos y piernas ( /-\, \y nada).

Adelante (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 - . . ;

Pruébalo en línea!

Explicación

• Consigue Conde de /, -y opersonajes
• Bodybuilder es el número de -personajes dividido por 2
• Acrobat es número de / caracteres menos el número de culturistas
• Enano es el número de ocaracteres menos el número de Acrobat y culturistas

Explicación del Código

\ 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

Este podría ser de 12 bytes eliminando Rsi [bodybuilder, acrobat, dwarf]se hubiera permitido un orden de salida de .

Pruébelo en línea o verifique todos los casos de prueba .

Alternativa menor de igual número de bytes:

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

Pruébelo en línea o verifique todos los casos de prueba .

Explicación:

…-/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 gracias a 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);}

Pruébalo en línea!