Una escena de la diversidad Jimmy.

25

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

conecta tu cargador
fuente
¿Podemos suponer que todas las entradas tendrán al menos un espacio inicial y final?
Shaggy
77
@connectyourcharger una forma más estándar sería requerir respuestas para especificar el orden.
Datos
44
Para ser explícito, ¿puede Dwarf Jimmys estar juntos? No veo nada que sugiera lo contrario. Si es así, un caso de prueba oo /o\ o osería bueno
Veskah
1
@Veskah: el generador de casos de prueba es capaz de generar la secuencia oo.
recursivo
8
Tiene que haber una etiqueta de Jimmy .
MilkyWay90

Respuestas:

8

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]
Jonathan Allan
fuente
21

Python 3.8 (prelanzamiento) , 51 bytes

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

Pruébalo en línea!

Erik el Outgolfer
fuente
FINALMENTE Python agregó algo como esto. He esperado un tiempo para que Python permita las asignaciones como expresiones. Una pena que tome un byte extra, pero lo tomaré: P
HyperNeutrino
@HyperNeutrino Esa es básicamente la razón por la que ahora puede ver "Python 3.8 (versión preliminar)" flotando por el sitio. Otra restricción es que, a menos que sea por sí solo y no sea la única expresión en una declaración (en cuyo caso puede preferir la asignación regular), debe estar entre paréntesis (+2 bytes).
Erik el Outgolfer
¿Cómo es el primer recuento de ('o')ser llamado sin un c?
Quinn
@Quinn La expresión de asignación asigna s.counta cy luego devuelve.
Erik el Outgolfer
@ErikTheOutgolfer genial, TIL
Quinn
12

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)

Hiperneutrino
fuente
3
Este es un buen método, y es más corto como programa .
xnor
8

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
mazzy
fuente
5

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
Galen Ivanov
fuente
1
25 bytes ?
cole
Vaya, ya no puedo editar mi comentario: esto también es de 25 bytes si es correcto, hace una forma diferente de agregar el 0.
cole
1
@cole Hah, como a menudo se me ocurre, no vi el patrón. ¡Gracias!
Galen Ivanov
es desafortunado que solo lo vi bien mientras estaba editando esa explicación, siempre es una pena perder tanto esfuerzo de explicar.
cole
@cole Es por eso que mantendré la explicación de mi error visible :)
Galen Ivanov
5

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
Wernisch
fuente
4

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

Quinn
fuente
1
Déjame contarte acerca de los métodos de extensión, mi amigo: fun String.j(b:Int=count{'-'==it}/2,a:Int=count{'/'==it})=listOf(count{'o'==it}-a,a-b,b)88 bytes.
Aso Leo
@AsoLeo agradable, en realidad lo había escrito originalmente como una función de extensión, pero debo haber estropeado algo más porque el mío tenía más bytes
Quinn
3

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.

lolad
fuente
Puede guardar algunos bytes escapando menos, ya que se garantiza que la cadena sea solo jimmys: ¡ Pruébelo en línea!
FryAmTheEggman
3

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!

Darrylyeo
fuente
1
@ JonathanAllan Reescribí mi respuesta.
Darrylyeo
2

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

Datos caducados
fuente
@Xcali ahora debería contar a los enanos en el extremo izquierdo nuevamente
Datos
2

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!

Daniil Tutubalin
fuente
1
No hay necesidad de x. Puedes hacerlo de g=input().countinmediato
Maarten Fabré
2

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!

CT Hall
fuente
1

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.

Xcali
fuente
-1 byte
Nahuel Fouilleul
@NahuelFouilleul Eso no funciona si hay un enano al final de una línea. Lo cuenta como un fisicoculturista.
Xcali
cierto, de lo contrario -4 bytes simplemente eliminando1*
Nahuel Fouilleul
@NahuelFouilleul Eso tampoco funciona. Si no hay ejemplos de esos tipos, no genera nada ( undef) en lugar de 0.
Xcali
ok, acabo de ver los casos de prueba
Nahuel Fouilleul
1

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

Giuseppe
fuente
0

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
reffu
fuente
0

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)
Kevin Cruijssen
fuente