Une scène de la diversité de Jimmy

25

Comme vous le savez probablement, il y a eu plusieurs belles Jimmy défis récemment fleurissent. Dans ces défis, vous avez été mis au défi avec les compétences acrobatiques de notre ami bien-aimé. Maintenant, nous avons un défi différent pour vous. Aujourd'hui, vous identifierez différents types de Jimmys!

Explication

Il existe trois variétés de Jimmys: nain, acrobate et bodybuilder.

This is dwarf Jimmy:               o

This is acrobat Jimmy:            /o\

This is bodybuilder Jimmy:       /-o-\

Ces Jimmys sont tous de grands amis et ils aiment se tenir sur la même ligne les uns que les autres. Votre tâche est, étant donné une scène Jimmy comme ça:

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

Affiche le nombre de nains, acrobates et culturistes sur la ligne, respectivement.

Le défi

  • Prenez une entrée sous n'importe quelle forme raisonnable en tant que scène Jimmy, comme indiqué dans l'exemple ci-dessus.

    1. La chaîne d'entrée doit être une ligne et contient facultativement les trois variétés de Jimmys et des espaces facultatifs.

    2. La chaîne ne contiendra pas nécessairement toutes les variétés ou espaces Jimmy.

    3. La chaîne ne contiendra aucun caractère absent o/\ -.

    4. Toute combinaison de variétés Jimmy est possible. Cela signifie que le même type ou un type différent de Jimmy peut être côte à côte. Vous devez en tenir compte.

    5. Les espaces blancs de début et de fin sont facultatifs et nullement requis - votre programme doit prendre en compte une chaîne avec ou sans espaces blancs de début et / ou de fin.

    6. La chaîne ne doit contenir que des Jimmys et des espaces valides. Par exemple, ---///---n'est pas autorisé car il ne s'agit pas d'une séquence Jimmy valide.

  • Sortie trois nombres: le nombre de nains, acrobates et culturistes dans la scène (dans l'ordre respectif).

    1. Il peut s'agir d'une sortie vers la console sous forme d'entiers séparés par des espaces, ou il peut s'agir d'une valeur de retour d'une fonction comme une sorte de conteneur (c'est-à-dire un type de tableau).

    2. La sortie, dans n'importe quel format, doit être ordonnée comme mentionné dans la puce supérieure au-dessus de cette règle.

  • Des règles et des lacunes standard s'appliquent.

Cas de test

     /-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 vous souhaitez plus de cas de test, utilisez cet outil pour générer plus de cas de test aléatoires.

Notation

C'est le code-golf , donc le score le plus bas en octets l'emporte.

Vous pouvez afficher le classement de cet article en développant le widget / extrait ci-dessous. Pour que votre message soit inclus dans le classement, vous avez besoin d'un en-tête ( # header text) avec les informations suivantes:

  • Le nom de la langue (terminez-le par une virgule ,ou un tiret -), suivi de ...

  • Le nombre d'octets, comme le dernier nombre à apparaître dans votre en-tête.

Par exemple, JavaScript (ES6), 72 bytesest valide, mais Fortran, 143 bytes (8-bit)n'est pas valide car le nombre d'octets n'est pas le dernier nombre dans l'en-tête (votre réponse sera reconnue comme 8 octets - n'en profitez pas).

<!-- 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>
Développer l'extrait

code-golf  string  counting 
— Branchez votre chargeur
source
Pouvons-nous supposer que toutes les entrées auront au moins un espace de début et de fin?
— Shaggy
7
@connectyourcharger une manière plus standard serait d'exiger des réponses pour spécifier la commande.
— Données expirées le
4
Juste pour être explicite, Dwarf Jimmys peut-il se tenir ensemble? Je ne vois rien suggérer le contraire. Si oui, un cas de test oo /o\ o oserait bien
— Veskah
1
@Veskah: Le générateur de cas de test est capable de générer la séquence oo.
— récursif
8
Il doit y avoir une balise Jimmy .
— MilkyWay90

Réponses:

8

Gelée , (12?) 13 octets

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

Un lien monadique acceptant une liste de caractères qui donne une liste d'entiers, [ dwarves, acrobats, and body-builders](enregistrez l' Ṛoctet si nous pouvons spécifier notre sortie)

Essayez-le en ligne!

Comment?

Tous les Jimmys montrent un o; tous les non-nains montrent un /; tous les culturistes en montrent deux -. Comptez-les, divisez par deux le nombre de -, et effectuez une soustraction pour trouver le nombre 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
source
21

Python 3.8 (pré-version) , 51 octets

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

Essayez-le en ligne!

— Erik le Outgolfer
source
ENFIN python a ajouté quelque chose comme ça. J'attends depuis un moment que Python autorise les affectations en tant qu'expressions. Dommage que cela prenne un octet supplémentaire, mais je le prendrai: P
— HyperNeutrino
@HyperNeutrino C'est essentiellement la seule raison pour laquelle vous pouvez maintenant voir "Python 3.8 (pré-version)" flottant autour du site. Une autre restriction est que, à moins qu'elle ne soit seule et non la seule expression dans une instruction (auquel cas vous préféreriez plutôt une affectation régulière), elle doit être mise entre parenthèses (+2 octets).
— Erik the Outgolfer le
Comment est le premier compte sur le fait de ('o')se faire appeler sans c?
— Quinn
@Quinn L'expression d'affectation est affectée s.countà c, puis la renvoie.
— Erik the Outgolfer le
@ErikTheOutgolfer cool, TIL
— Quinn
12

Python 2 , 50 octets

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

Essayez-le en ligne!

-10 octets en convertissant l'expression lambda en un programme complet grâce à @xnor (supprime la chose imbriquée double-lambda et utilise l'affectation à la place)

— HyperNeutrino
source
3
C'est une bonne méthode, et elle est plus courte en tant que programme .
— xnor
8

PowerShell , 59 55 octets

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

Essayez-le en ligne!

Déroulé:

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

J , 36 25 octets

-11 octets grâce à Cole!

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

Essayez-le en ligne!

Solution originale

J , 36 octets

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

Essayez-le en ligne!

Explication:

                            '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

Un exemple de session J :

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
source
1
— cole
Oups, je ne peux plus éditer mon commentaire - c'est aussi 25 octets si c'est correct, fait une manière différente d'ajouter le 0.
— cole
1
@cole Hah, comme cela me vient souvent à l'esprit, je n'ai pas vu le schéma. Merci!
— Galen Ivanov
c'est dommage que je ne l'ai vu que lorsque vous éditiez cette explication - toujours dommage de perdre autant d'efforts d'explication.
— cole
@cole C'est pourquoi je garderai l'explication de ma bévue visible :)
— Galen Ivanov
5

Excel en CSV, 130 octets

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

Insérez l'entrée dans l'espace avant le premier ,, enregistrez sous .csv, ouvrez dans Excel. Sorties Nains, Acrobates et bodybuilders B1, B2et B3respectivement.

Excel, 244 octets

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

Kotlin 131 130 129 121 117 117 97 96 88 octets

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

Essayez-le en ligne!

Edit - Wew, je l'ai sous 100! Je doute que je puisse le rétrécir davantage, mais seul le temps nous le dira ...

Modifier - Parlé trop tôt, a supprimé un octet de plus en utilisant une liste au lieu d'une chaîne

Edit - moins 8 octets grâce à AsoLeo suggérant d'utiliser une fonction d'extension

— Quinn
source
1
Permettez-moi de vous parler des méthodes d'extension, mon ami: fun String.j(b:Int=count{'-'==it}/2,a:Int=count{'/'==it})=listOf(count{'o'==it}-a,a-b,b)88 octets.
— Aso Leo
@AsoLeo sympa, je l'avais écrit en tant que fonction d'extension à l'origine mais j'ai dû gâcher quelque chose d'autre parce que le mien était plus d'octets
— Quinn
3

Rétine , 39 35 octets

Edit: -4 octets grâce à @FryAmTheEggMan

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

Essayez-le en ligne!

Explication:

Une étape de remplacement simple. Il trouve toutes les correspondances de l'expression régulière ^((o)|(/o.)|(/-o-.)| )*(ce qui devrait entraîner une correspondance - la chaîne entière) et la remplace par le nombre de captures des groupes 2, 3 et 4. Voici l'expression régulière décomposée:

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

Nous devons commencer par ^ou la fin de l'entrée est également considérée comme une correspondance. Dans la syntaxe de substitution de Retina, fait $nréférence au nième groupe de capture et le modificateur #compte le nombre de correspondances qu'il a effectuées.

— lolade
source
Vous pouvez économiser quelques octets en vous échappant moins, car la chaîne est garantie d'être uniquement des jimmys: essayez-la en ligne!
— FryAmTheEggman
3

JavaScript, 55 octets

Recherche la chaîne en utilisant une mise en correspondance de motif d'expression rationnelle o, o-ou o-\; incrémente le nombre correspondant dans un tableau, en utilisant la longueur de chaque correspondance pour déterminer l'indice.

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

Essayez-le en ligne!

— darrylyeo
source
1
@JonathanAllan J'ai réécrit ma réponse.
— darrylyeo
2

R , 63 octets

Utilise l'appariement Regex pour trouver et compter les Jimmys. 

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

Essayez-le en ligne!

— CT Hall
source
1

Perl 5 -p , 41 octets

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

Essayez-le en ligne!

Compte le nombre de fois oapparaît sans être suivi par \ou -pour trouver les nains et les supprime de la chaîne. Compte ensuite le nombre de fois où il /oapparaît pour trouver les acrobates et les supprime de la chaîne. Compte ensuite le nombre de orestants pour déterminer les culturistes. Insère des espaces entre les nombres et génère implicitement le résultat.

— Xcali
source
— Nahuel Fouilleul
@NahuelFouilleul Cela ne fonctionne pas s'il y a un nain à la fin d'une ligne. Il le compte comme un constructeur de corps.
— Xcali
vrai, sinon -4 octets supprimant simplement1*
— Nahuel Fouilleul
@NahuelFouilleul Ça ne marche pas non plus. S'il n'y a aucun exemple de ces types, il ne produit rien ( undef) à la place de 0.
— Xcali
ok, je viens de regarder les cas de test
— Nahuel Fouilleul
1

SNOBOL4 (CSNOBOL4) , 135 octets

	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

Essayez-le en ligne!

Supprime -o, /oet ode la chaîne et incrémente les compteurs appropriés à chaque fois. Laisse derrière lui un grand nombre de bras et les jambes ( /-\, \et rien).

— Giuseppe
source
0

Forth (gforth) , 118 octets

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

Essayez-le en ligne!

Explication

  • Être comte de /, -et des opersonnages
  • Bodybuilder est le nombre de -caractères divisé par 2
  • Acrobat est le nombre de / caractères moins le nombre de culturistes
  • Nain est le nombre de ocaractères moins le nombre d'Acrobat et de culturistes

Explication du code

\ 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
source
0

05AB1E , 13 octets

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

Celui-ci pourrait être de 12 octets en supprimant Rsi un ordre de sortie de [bodybuilder, acrobat, dwarf]aurait été autorisé.

Essayez-le en ligne ou vérifiez tous les cas de test .

Alternative mineure à octets égaux:

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

Essayez-le en ligne ou vérifiez tous les cas de test .

Explication:

…-/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
source
En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.