Wie Sie wahrscheinlich wissen, gibt es mehr schöne Jimmy Herausforderungen vor kurzem Aufspringen. Bei diesen Herausforderungen wurden Sie mit den Akrobatikfähigkeiten unseres geliebten Freundes herausgefordert. Jetzt haben wir eine andere Herausforderung für Sie. Heute werden Sie verschiedene Arten von Jimmys identifizieren!

Erläuterung

Es gibt drei Sorten von Jimmys: Zwerg, Akrobat und Bodybuilder.

This is dwarf Jimmy:               o

This is acrobat Jimmy:            /o\

This is bodybuilder Jimmy:       /-o-\

Diese Jimmys sind alle großartige Freunde und stehen gerne in einer Linie. Ihre Aufgabe ist es, eine Jimmy-Szene wie folgt zu bestimmen:

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

Geben Sie jeweils die Anzahl der Zwerge, Akrobaten und Bodybuilder in der Linie aus.

Die Herausforderung

• Nehmen Sie die Eingabe in einer angemessenen Form als Jimmy-Szene, wie in einem Beispiel oben gezeigt.

  1. Die Eingabezeichenfolge sollte eine Zeile sein und optional die drei Sorten von Jimmys und optional das Leerzeichen enthalten.

  2. Die Zeichenfolge enthält nicht unbedingt alle Jimmy-Sorten oder Leerzeichen.

  3. Die Zeichenfolge enthält keine Zeichen, die nicht in enthalten sind o/\ -.

  4. Jede Kombination von Jimmy-Sorten ist möglich. Dies bedeutet, dass der gleiche oder ein anderer Jimmy-Typ nebeneinander sein kann. Sie müssen das berücksichtigen.

  5. Führende und nachfolgende Leerzeichen sind optional und auf keinen Fall erforderlich - Ihr Programm sollte eine Zeichenfolge mit oder ohne führende und / oder nachfolgende Leerzeichen berücksichtigen.

  6. Die Zeichenfolge sollte nur gültige Jimmys und Leerzeichen enthalten. Dies ---///---ist beispielsweise nicht zulässig, da es sich nicht um eine gültige Jimmy-Sequenz handelt.

• Gib drei Zahlen aus: Die Anzahl der Zwerge, Akrobaten und Bodybuilder in der Szene (in der jeweiligen Reihenfolge).

  1. Dies kann eine Ausgabe an die Konsole als durch Leerzeichen getrennte Ganzzahl sein oder ein Rückgabewert einer Funktion als eine Art Container (dh ein Array-Typ).

  2. Die Ausgabe in einem beliebigen Format muss wie im oberen Punkt über dieser Regel angegeben bestellt werden.

• Es gelten Standardregeln und Regelungslücken.

Testfälle

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

Wenn Sie mehr Testfälle möchten, können Sie mit diesem Tool mehr zufällige Testfälle generieren.

Wertung

Dies ist Code-Golf , also gewinnt die niedrigste Punktzahl in Bytes.

Sie können die Bestenliste für diesen Beitrag anzeigen, indem Sie das Widget / Snippet unten erweitern. Damit Ihr Beitrag in die Rangliste aufgenommen wird, benötigen Sie einen Header ( # header text) mit folgenden Informationen:

• Der Name der Sprache (Ende mit Komma ,oder Bindestrich -), gefolgt von ...

• Die Anzahl der Bytes als letzte Zahl in Ihrer Kopfzeile.

Beispielsweise JavaScript (ES6), 72 bytesist gültig, aber Fortran, 143 bytes (8-bit)ungültig, da die Byteanzahl nicht die letzte Zahl in der Kopfzeile ist (Ihre Antwort wird als 8 Byte erkannt - nutzen Sie dies nicht).

<!-- Run the snippet to see the leaderboard. Report any bugs to @xMikee1 on Github. -->    <iframe src="https://xmikee1.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>

Jelly , (12?) 13 Bytes

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

Ein monadischer Link, der eine Liste von Zeichen akzeptiert, die eine Liste von ganzen Zahlen ergibt. [ dwarves, acrobats, and body-builders](Speichern Sie das ṚByte, wenn Sie unsere Ausgabe spezifizieren möchten.)

Probieren Sie es online!

Wie?

Alle Jimmys zeigen ein o; Alle Nicht-Zwerge zeigen ein /; Alle Bodybuilder zeigen zwei -. Zählen Sie diese auf, halbieren Sie sie -und subtrahieren Sie sie, um die Jimmy-Zahlen zu ermitteln:

ċⱮ“-/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 (Vorabversion) , 51 Byte

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

Probieren Sie es online!

Python 2 , 50 Bytes

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

Probieren Sie es online!

-10 Bytes durch Konvertieren des Lambda-Ausdrucks in ein vollständiges Programm dank @xnor

PowerShell , 59-55 Byte

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

Probieren Sie es online!

Abgerollt:

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

J , 36-25 Bytes

-11 bytes dank cole!

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

Probieren Sie es online!

Originelle Lösung

J , 36 Bytes

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

Probieren Sie es online!

Erläuterung:

                            '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

Eine Beispiel- J- Sitzung:

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

Fügen Sie die Eingabe zuerst im Leerzeichen ein , , speichern Sie sie als .csv und öffnen Sie sie in Excel. Ausgänge Zwerge, Akrobaten und Bodybuilders in B1, B2und B3jeweils.

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) , 20 Byte ^SBCS

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

Probieren Sie es 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)

Probieren Sie es online!

Bearbeiten - Wew, habe es unter 100! Ich bezweifle, dass ich es mehr schrumpfen kann, aber nur die Zeit wird es zeigen ...

Bearbeiten - Sprach zu früh, löschte ein weiteres Byte mithilfe einer Liste anstelle einer Zeichenfolge

Bearbeiten - minus 8 Bytes dank AsoLeo, der die Verwendung einer Erweiterungsfunktion vorschlägt

Retina , 39-35 Bytes

Edit: -4 Bytes dank @FryAmTheEggMan

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

Probieren Sie es online!

Erläuterung:

Eine einfache Ersetzungsstufe. Es findet alle Übereinstimmungen der Regex ^((o)|(/o.)|(/-o-.)| )*(was zu einer Übereinstimmung führen sollte - die gesamte Zeichenfolge) und ersetzt sie durch die Anzahl der Erfassungen der Gruppen 2, 3 und 4. Hier ist die Regex nach:

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

Wir müssen mit beginnen ^oder das Ende der Eingabe zählt auch als Übereinstimmung. Bezieht sich in der Substitutionssyntax von Retina $nauf die n-te Erfassungsgruppe, und der Modifikator #zählt, wie viele Übereinstimmungen damit erzielt wurden.

JavaScript, 55 Byte

Durchsucht die Zeichenfolge mit einem Regex-Mustervergleich o. o-, Oder o-\; erhöht die entsprechende Anzahl in einem Array anhand der Länge jeder Übereinstimmung, um den Index zu bestimmen.

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

Probieren Sie es online!

Clojure , 78 Bytes

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

Probieren Sie es online!

Wolfram Language (Mathematica) , 63 Byte

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

Probieren Sie es online!

55 Bytes, wenn die sinnlose Bestellanforderung entfällt ...

Python 3 , 69 66 60 56 Bytes

-4 Bytes dank @Maarten Fabré

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

Probieren Sie es online!

R , 63 Bytes

Verwendet Regex Matching, um die Jimmys zu finden und zu zählen.

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

Probieren Sie es online!

K (oK) , 25 Bytes

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

Probieren Sie es online!

Perl 5 -p , 41 Bytes

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

Probieren Sie es online!

Zählt, wie oft oangezeigt wird, ohne von \oder verfolgt -zu werden, um die Zwerge zu finden, und entfernt sie aus der Zeichenfolge. Zählt dann, wie oft /oangezeigt wird, um die Akrobaten zu finden, und entfernt sie aus der Zeichenfolge. Dann zählt die Anzahl der overbleibenden, um die Bodybuilder zu bestimmen. Fügt Leerzeichen zwischen die Zahlen ein und gibt das Ergebnis implizit aus.

Ruby , 50 Bytes

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

Probieren Sie es online!

SNOBOL4 (CSNOBOL4) , 135 Byte

	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

Probieren Sie es online!

Entfernt -o, /ound oaus der Zeichenfolge und inkrementiert den entsprechenden Zähler jedes Mal. Hinterlässt viele Arme und Beine (/-\ , \und nichts).

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

Probieren Sie es online!

Erläuterung

• Zählung abrufen von /,- undo Zeichen
• Bodybuilder ist die Nummer von - Zeichen geteilt durch 2
• Acrobat ist die Nummer von / Zeichen abzüglich der Anzahl der Bodybuilder
• Zwerg ist die Nummer von o Zeichen abzüglich der Anzahl der Acrobat- und Bodybuilder

Code-Erklärung

\ 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

Dies können 12 Bytes sein , Rwenn die Ausgabereihenfolge von entfernt worden [bodybuilder, acrobat, dwarf]wäre.

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Kleinere Alternative mit gleichen Bytes:

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

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

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

Probieren Sie es online!