[Question]
  [
As you probably know, there have been [multiple](https://codegolf.stackexchange.com/questions/187586/will-jimmy-fall-off-his-platform) [lovely](https://codegolf.stackexchange.com/questions/187682/how-many-jimmys-can-fit) [Jimmy](https://codegolf.stackexchange.com/questions/187731/jimmy-needs-your-help) [challenges](https://codegolf.stackexchange.com/questions/187759/can-jimmy-hang-on-his-rope) [recently](https://codegolf.stackexchange.com/questions/188140/jimmy-needs-a-new-pair-of-shoes) popping up. In these challenges, you were challenged with our beloved friend's acrobatics skills. Now we've got a different challenge for you. Today you will be identifying different types of Jimmys!
---
# Explanation
There are three varieties of Jimmys: dwarf, acrobat, and bodybuilder.
```
This is dwarf Jimmy:               o
This is acrobat Jimmy:            /o\
This is bodybuilder Jimmy:       /-o-\
```
These Jimmys are all great friends and they like to stand on the same line as each other. Your task is, given a Jimmy scene like so:
```
  o  /o\       o   /-o-\/-o-\  o          /o\
```
Output the amount of dwarves, acrobats, and bodybuilders on the line, respectively.
# The challenge
* Take input in any reasonable form as a Jimmy scene, as shown in an example above.
1. The input string should be one line and optionally contains the three varieties of Jimmys and optional whitespace.
2. The string will not necessarily contain all of the Jimmy varieties or whitespace.
3. The string will not contain any characters not in `o/\ -` .
4. Any combination of Jimmy varieties is possible. This means that the same or different type of Jimmy can be next to each other. You must account for that.
5. Leading and trailing whitespace is optional and by no means required - your program should account for a string with or without leading and/or trailing whitespace.
6. The string should contain only valid Jimmys and whitespace. For instance, `---///---` is not allowed because it is not a valid Jimmy sequence.
* Output three numbers: The count of dwarves, acrobats, and bodybuilders in the scene (in respective order).
1. This may be an output to the console as space-separated integers, or it may be a return value from a function as some sort of container (i.e an array type).
2. The output, in whatever format, must be ordered as mentioned in the top bullet above this rule.
* Standard rules and loopholes apply.
# Test cases
```
     /-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
```
If you'd like more test cases, use [this tool](https://tio.run/##ZY7LTsMwEEX3/oqrsohN25DCBoGC1EUlFrQgsQBEqyhtJ41F4okcV8DXB5uUh@Au7HncmTnNuyvZnHXd9e1DNp8unrLZ43R@dzO7R4pJgj86wmJfr8mCC9BbXjcVtXCMHRmyuSPhpeuGrYPNzZbrEZyufXlTst54b4rniKNRdMLLZfjGPPbBCkNfR7Q6Pk1EPxi3RFsZhuPwSKWEKNgigzZh947kP2R1IQKkpXZfOX9qMPjMX0tdESZ985dhmB4g455OHiDVt1EXqMjI3q9whfPkZ0tQY7VxX/1LrC3lL133AQ) to generate more random test cases.
# Scoring
This is [code-golf](/questions/tagged/code-golf "show questions tagged 'code-golf'"), so lowest score in bytes wins.
  
[Answer]
# [Python 3.8 (pre-release)](https://docs.python.org/3.8/), 51 bytes
```
lambda s:((c:=s.count)('o')-c('/'),c('/o'),c('/-'))
```
[Try it online!](https://tio.run/##VYvNCoAgEIRfxdvuQuahSwS9iZcyoqBcST309JbRDw0Ds/sN4/Ywsa1qt6Wx1Wnp1n7ohG8QTdP60nC0gRAYSBoEBVTk4DslECW3zTbgiLN1MSCdRCjJUous77p1gYeyUKxPvwX/BrnM7wE "Python 3.8 (pre-release) – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), 50 bytes
```
x,y,z=map(input().count,'o/-')
print x-y,y-z/2,z/2
```
[Try it online!](https://tio.run/##ZU7NCsMgDL73KSSXtqATehzsLXb0MopQoTNSlGlf3tWuxeoScsj3l5hgJ9RD/ExqluS5OHmXXo4AED0NdH28X6ZT2jjb9bcRnba0Rc7avjGL0pZ4FmhgKx/oNjHZgKTiDJkgufKOHEXJ19oLCM0vjuDWlQBFQdT8VVTsKTOf/Du@AyeKyXGE7BiWn@OhhC8 "Python 2 – Try It Online")
-10 bytes by converting lambda expression to a full program thanks to @xnor (removes the double-lambda nested thing and uses assignment instead)
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), (12?) 13 [bytes](https://github.com/DennisMitchell/jelly/wiki/Code-page)
```
ċⱮ“-/o”H1¦ŻIṚ
```
A monadic Link accepting a list of characters which yields a list of integers, `[ dwarves, acrobats, and body-builders]` (save the `Ṛ` byte if we may specify our output)
**[Try it online!](https://tio.run/##y0rNyan8//9I96ON6x41zNHVz3/UMNfD8NCyo7s9H@6c9f//fwV93XzdGAUQQLCgACwAE81X0M@PASK4RD6KBpAkiAsA "Jelly – Try It Online")**
### How?
All Jimmys show a `o`; all non-dwarves show a `/`; all body-builders show two `-`. Count these up, halve the count of `-`, and perform subtraction to find the Jimmy counts:
```
ċⱮ“-/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]
```
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~59~~ 55 bytes
```
$c=,0*3
$args|sls '/?-?o'-a|% m*|% le*|%{++$c[$_-1]}
$c
```
[Try it online!](https://tio.run/##bVHbbsIwDH3PV1iRGS0kKhShSUgI/mOdEOq87SFg1jBtUttv70JaemNJZMnn2MeXXPiHMvtJxlT4DlvIK0y3ajFbCTxmH7awxsI02ukdT/WxmMBp5owhZ/P5HNMXPOjlaykwrUoh9oEAd1SwD5YK3FuHCuQNijTrBLrT@RxxMuTHsR0ow1Z/rWClYHHXdzrujlI4GRBjvh/U93tVYl/l2Vfp2npo0AN3lG8ajazHeDgdJ@NZYr@ruJ6liX1s9r@1cN1uCAVMIPeCSL8XSq/0pgBtSmdyn4qHmsrIfpurA57cX9esJyQGsiGlpi/Zashw02ZtmgwpRFn9AQ "PowerShell – Try It Online")
Unrolled:
```
$counters=,0*3
$args|select-string '/?-?o'-AllMatches|% Matches|% Length|%{++$counters[$_-1]}
$counters
```
[Answer]
# [J](http://jsoftware.com/), ~~36~~ 25 bytes
-11 bytes thanks to cole!
```
2-/\0,~1 1 2%~1#.'o/-'=/]
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/jXT1Ywx06gwVDBWMVOsMlfXU8/V11W31Y/9rcilwpSZn5CukAbWBgL5uvm6MAgIg@Pn6@TGo8uhqEYLqqIYq5AMhmrL8GBQJdHlkRch8JJMR1mM4BCwAE80H6YMaBRbLR/VFfgy6m6HSmG7C5mNQuIC8@R8A "J – Try It Online")
## Original solution
# [J](http://jsoftware.com/), 36 bytes
```
[:(-/@}:,-/@}.,{:)1 1 2%~1#.'o/-'=/]
```
[Try it online!](https://tio.run/##y/qvpKeepmBrpaCuoKNgoGAFxLp6Cs5BPm7/o600dPUdaq10QKSeTrWVpqGCoYKRap2hsp56vr6uuq1@7H9NLgWu1OSMfIU0oAkgoK@brxujgAAIfr5@fgyqPLpahKA6qqEK@UCIpiw/BkUCXR5ZETIfyWSE9RgOAQvARPNB@qBGgcXyUX2RH4PuZqg0ppuw@RgULiBv/gcA "J – Try It Online")
## Explanation:
```
                            '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
```
A sample [J](http://jsoftware.com/) session:
```
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
```
[Answer]
# Excel as 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","")
```
Insert input in space before first `,`, save as .csv, open in Excel.
Outputs Dwarfs, Acrobats and Bodybuilders in `B1`, `B2` and `B3` respectively.
---
**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
```
[Answer]
# [APL (Dyalog Unicode)](https://www.dyalog.com/), 20 bytes[SBCS](https://github.com/abrudz/sbcs)
```
2-/2÷⍨@2+/'o/-x'∘.=⎕
```
[Try it online!](https://tio.run/##fZDBSgMxEIbv@xRzm4PGdCNFEAo@yF4WS0QsjoQcWkpvUqttiiCFXrz05AuIUPDkm8yLrJPtlu1uxQlhd/7/y88k@cNA9Uf5gG4KXq5uiaevnYRnT7YwSpufLw4fV@ZEI2k1RJ6tz3qCFQIkVlAOy5QX3zgZ4ymKEbdDDp@CvqQ8fZP@2qFF4PAO3uV9ew@eQD6Fl/NjQfl54@TXctheCl6mbkV3PH9EusNJghBLK1IZ1FX3pClr@m22FndZHlJZ3SoZSFaLpaxhtP1D6LBHD104h44k1zMcTVMKe5XiuSqq1Kh5FdqRkmwk@SLOXPnHQ/117/g6CP9VTE7B/AI "APL (Dyalog Unicode) – Try It Online")
[Answer]
# [Kotlin](https://kotlinlang.org) ~~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)
```
[Try it online!](https://tio.run/##bY8/b8IwEMVn@BQnhIQtxUTqiBqkjkwMZczitKQ9SO9QfKhUKJ/dJQ40DtTTvd97vj97lgrJ@/JI8Co10sd8p4rFiiR74yPJeWZmWYbSpE@JjXHaYZ1V6GRdqivmDhubWFMkhQ6NvyySsgt4qWv789yNWWo4j0cl16AUJuA0IIGdf6N8ruh9e1I6BEaHS1gqUpPN1glMcaJjOHW9Vu6yuh7YObV2M268Tw2bHPrXa045j/WwHn7wDHzPOUT/jHs/DsU62uhhXgA3ym362iAwHi7LXfLW73H@f@e0R/8C "Kotlin – Try It Online")
Edit - Wew, got it under 100! I doubt I can shrink it more, but only time will tell...
Edit - Spoke too soon, dropped one more byte by using a list instead of a string
Edit - minus 8 bytes thanks to AsoLeo suggesting using a extension function
[Answer]
# [Retina](https://github.com/m-ender/retina/wiki/The-Language), ~~39~~ 35 bytes
*Edit:* -4 bytes thanks to [@FryAmTheEggMan](https://codegolf.stackexchange.com/users/31625/fryamtheeggman)
```
^((o)|(/o.)|(/-o-.)| )*
$#2 $#3 $#4
```
[Try it online!](https://tio.run/##K0otycxLNPz/P05DI1@zRkM/Xw9E6ubrAmkFTS0uFWUjBRVlYyA2@f8fJB6jAAIIFhSABWCi@Qr6@TFABJfIR9EAkgRxAQ "Retina – Try It Online")
**Explanation:**
A simple replace stage. It finds all matches of the regex `^((o)|(/o.)|(/-o-.)| )*` (which should result in one match - the whole string) and replaces it by the number of captures of groups 2, 3, and 4. Here is the regex broken down:
```
^((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
```
We have to start with `^` or the end of the input counts as a match too.
In the substitution syntax of Retina, `$n` references the nth capturing group, and the modifier `#` counts how many matches it made.
[Answer]
# [Python 3](https://docs.python.org/3/), ~~69~~ ~~66~~ ~~60~~ 56 bytes
-4 bytes thanks to @Maarten Fabré
```
g=input().count
b,c=g('/'),g('/-')
print(g('o')-b,b-c,c)
```
[Try it online!](https://tio.run/##VUs5CsAgEOx9hZ0uuLFI7U@stDA2rgQt8nrjhhxkGJiLqUfbqKxjJJdL7U3DEqmXJoKJLmllFRgWVCDqnkvTM5ECDCZgNBHGkBYJvWR87sZVPC1JS37yHeh34JGjPwE "Python 3 – Try It Online")
[Answer]
# JavaScript, 55 bytes
Searches the string using a regex pattern matching `o`, `o-`, or `o-\`; increments the corresponding count in an array, using the length of each match to determine the index.
```
s=>s.replace(/o-?\\?/g,m=>a[m.length-1]++,a=[0,0,0])&&a
```
[Try it online!](https://tio.run/##hVDRDkNAEHz3FfckhHNomj7hI/roJC56VHOsIO3n6xHC0ejO087u7dzMi71Zl7Vl0@MaHnzIg6ELws5peSNYxg0COKI0IoVdBSGLK0fwuuif2Essy2ZB7NoSianrbCAEeRJXLYO6A8EdAYWRG/e@LevCadknRWMRDJiitdYeCFB1vt/dkKlpapqUvKILcv9IIpDYHQGqDPbz7ZLSL7q@1L2d6K5fP5iYiIWF8eosNHGgJgBU9evLiP0zv/Pro6FfYcJsafgC "JavaScript (Node.js) – Try It Online")
[Answer]
# [Clojure](https://clojure.org/), 78 bytes
```
(defn ?[s](def c #(count(re-seq % s)))[(-(c #"o")(c #"/"))(c #"/o")(c #"/-")])
```
[Try it online!](https://tio.run/##bVBJDoMwDLzzCitVpfiQ8gQeApxoEK1oXJKgPp9mISlLnYOtyXg8djfSc9Zy4crAa7L2ZqWxuPC77BVUtWl9BR1ceEezslxLYeQEVzCIWHPB3RcjhiGXDNciI4JhG@WAlAQGPkpBomngFxuASvLVjnLib1CGRVC3H1rVgdw7UCm2558jYcfaAVl/0E5/4@RsKiIZp9CfRCNMh8Uo8dOYnma/RmKdff69Ba1OC/7WD2VHBbzy90af3WViHnTIbgTi8gU "Clojure – Try It Online")
[Answer]
# [Wolfram Language (Mathematica)](https://www.wolfram.com/wolframscript/), 63 bytes
```
Reverse@{a=(m=CharacterCounts@#)["-"]/2,b=m["/"]-a,m["o"]-a-b}&
```
[Try it online!](https://tio.run/##y00syUjNTSzJTE78n2b7Pyi1LLWoONWhOtFWI9fWOSOxKDG5JLXIOb80r6TYQVkzWklXKVbfSCfJNjdaSV8pVjdRB8jIBzF0k2rV/gcUZeaVRKdFKymAgL5uvm5MjAICIAnk6@eDWChKMNQjiSrFxv4HAA "Wolfram Language (Mathematica) – Try It Online")
55 bytes if the pointless order requirement is dropped...
[Answer]
# [R](https://www.r-project.org/), 63 bytes
Uses Regex matching to find and count the Jimmys. 
```
library(stringr)
str_count(scan(,''),c('(?<![/-])o','/o','/-'))
```
[Try it online!](https://tio.run/##K/r/PyczqSixqFKjuKQoMy@9SJMLyIhPzi/NK9EoTk7M09BRV9fUSdZQ17C3UYzW143VzFfXUdcHE7rqmpr/FdQVFBT0dfN1YxQQAMHP18@PQZVHYoPlUPWo//8PAA "R – Try It Online")
[Answer]
# [K (oK)](https://github.com/JohnEarnest/ok), 25 bytes
```
{|-':|1 1 .5*+/x=\:"o/-"}
```
[Try it online!](https://tio.run/##y9bNz/7/P82qukZX3arGUMFQQc9US1u/wjbGSilfX1ep9n@agpICEOjr5uvGxCggAJJAvn4@iIWiBEM9kqjSfwA "K (oK) – Try It Online")
[Answer]
# [Perl 5](https://www.perl.org/) `-p`, 41 bytes
```
$_=1*s/o(?!\\|-)//g.$".1*s|/o||g.$".y/o//
```
[Try it online!](https://tio.run/##K0gtyjH9/18l3tZQq1g/X8NeMSamRldTXz9dT0VJDyhWo59fUwPmVOrn6@v/t3ZItNXQtP6vAAL6uvm6MQoIgODn6@fHoMqjq0UIckHY@UCIJpsfgyKBLo@sCJnPhWQZhrVgAZhoPkg51ASwWD6qm/NjYC6ECmM6AZu/QL7/l19QkpmfV/xf19dUz8DQ4L9uQQ4A "Perl 5 – Try It Online")
Counts the number of times `o` appears without being followed by `\` or `-` to find the dwarves and removes them from the string. Then counts the number of times `/o` appears to find the acrobats and removes them from the string. Then counts the number of `o` remaining to determine the body builders. Inserts spaces between the numbers and implicitly outputs the result.
[Answer]
# [Ruby](https://www.ruby-lang.org/), 50 bytes
```
->s{%w(o /o -o).map{|x|s.scan(/[\/-]?o/).count x}}
```
[Try it online!](https://tio.run/##KypNqvyfZvtf1664WrVcI19BP19BN19TLzexoLqmoqZYrzg5MU9DPzpGXzfWPl9fUy85vzSvRKGitvZ/gUJatJKCvm6@bkyMAgggMaEAIgIXB5kO5OZDFEGE81G1gRWABZRi/wMA "Ruby – Try It Online")
[Answer]
# [SNOBOL4 (CSNOBOL4)](http://www.snobol4.org/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
```
[Try it online!](https://tio.run/##Vc2xCgMhDAbgWZ/i37xDRAqdDjIotnDL2eFuu6lzaYa@P15staWJYMwXyevJd36cS1EzaF5u26qjlMaxAanpOoRRqwiKsDipaYijDtV99yQeQKG5jKfqnbNwAqXGMp1V3lbZA7IJRtKGzxX1ZUmlwDt2O2r8qhbvRu8yPO9yvsB/HyrW5wE "SNOBOL4 (CSNOBOL4) – Try It Online")
Removes `-o`, `/o`, and `o` from the string and increments the appropriate counters each time. Leaves behind a lot of arms and legs (`/-\`, `\`, and nothing).
[Answer]
# [Forth (gforth)](http://www.complang.tuwien.ac.at/forth/gforth/Docs-html/), 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 - . . ;
```
[Try it online!](https://tio.run/##bU/LDoIwELzzFRMuHEypwRtE4x/oAW7ceCjRuE0tJn49LhQtDzdt2pndnZ2tSZuruNT903UxCghNBluYtrihJNCr0miwQXHEDqphdg@BO5HCo7E38WLUiMpWIZAscdAjEAwiaSUDYtBwawh9sLL9P0TCY5VtMG9VodAIfZyy9JylMXxWZoZP4j19DCEFiRwuHCZJ@Ty/rHWkD/VTBC@6rKF8lljmp0VTPMq6uSsHA/Flqe8ZZQaO5vYpn5sdk2s3/xYl66f7AA "Forth (gforth) – Try It Online")
### Explanation
* Get Count of `/`, `-`, and `o` characters
* Bodybuilder is number of `-` characters divided by 2
* Acrobat is number of `/` characters minus the number of body builders
* Dwarf is number of `o` characters minus the number of Acrobat and Bodybuilders
### Code Explanation
```
\ 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
```
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E/wiki/Commands), 13 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)
```
…-/oS¢ć;š0š¥R
```
This one could be **12 [bytes](https://github.com/Adriandmen/05AB1E/wiki/Codepage)** by removing the `R` if an output-order of `[bodybuilder, acrobat, dwarf]` would have been allowed.
[Try it online](https://tio.run/##yy9OTMpM/f//UcMyXf384EOLjrRbH11ocHThoaVB//8rgIC@br5ujAICIPj5@vkxqPLoahGC@QA) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TpuSZV1BaYqWgZF@pw6XkX1oC4/1/1LBMVz8/@NCiI@3WRxcaHF14aGnQf51D2@z/KyjkKyjo58coQACQo6Cvm68bAyYgfCgAKuKCMCBSCAk4Px9sELI8ulqEIBfMwnx0WYhj4BLo8siKUB2HsAzDWmQ/AU0EKoeaABbLR3VzfgzMhZihgMdfIN9z5efnAwA).
Minor equal-bytes alternative:
```
…-/oS¢R`;0)üα
```
[Try it online](https://tio.run/##yy9OTMpM/f//UcMyXf384EOLghKsDTQP7zm38f9/BRDQ183XjVFAAAQ/Xz8/BlUeXS1CMB8A) or [verify all test cases](https://tio.run/##yy9OTMpM/V9TpuSZV1BaYqWgZF@pw6XkX1oC4/1/1LBMVz8/@NCioARrA83De85t/K9zaJv9fwWFfAUF/fwYBQgAchT0dfN1Y8AEhA8FQEVcEAZECiEB5@eDDUKWR1eLEOSCWZiPLgtxDFwCXR5ZEarjEJZhWIvsJ6CJQOVQE8Bi@ahuzo@BuRAzFPD4C@R7rvz8fAA).
**Explanation:**
```
…-/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)
```
[Answer]
# [C (gcc)](https://gcc.gnu.org/), ~~99~~ ~~98~~ 96 bytes
-1 byte thanks to [ceilingcat](https://codegolf.stackexchange.com/users/52904/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);}
```
[Try it online!](https://tio.run/##bU/LasMwEDxHX7EIAnIs4dIHpRXKL7Sg5OZLkLDrQ73BSnMJ/nZHlrHiR1eCXY1mZ2eNKI3pOuSaW25kwczPqdm55FZgw1BpZdWTNGrn0lRiqsz@4yWxPiv1@sb1ULzLc1PVl4LRrYVwKUehuRaW20w9J7LtrlhZKIM6eHlyI5vY5PL663j4Ph4@gXJwiSSbgoV0/rs4RvOa@kdLiOfD76mqWegvGYU@MoEiz@EREwAz7KsZZcWfoP2gKAzoz4KFQ2f8WRJmrBkQpSfz11YGJOIYWke9AcbFOjjyH@ZHwtrdv8vj6K/t7g "C (gcc) – Try It Online")
[Answer]
# [Vyxal](https://github.com/Lyxal/Vyxal), 17 bytes
```
`-/o`f$vOḣ$½p0pṘ¯
```
[Try it Online!](http://lyxal.pythonanywhere.com?flags=&code=%60-%2Fo%60f%24vO%E1%B8%A3%24%C2%BDp0p%E1%B9%98%C2%AF&inputs=%2F-o-%5C%20%20%20%20%20%2F-o-%5C%20%20%20%20%20%20%20%20%20%20%20%20%2F-o-%5C%2F-o-%5C%20%20%20o%20%2Fo%5C%2Fo%5C%20%20%20%20%2F-o-%5Co%20%2F-o-%5C%20%20%20%20%20%20%20%2Fo%5C%2F-o-%5C&header=&footer=)
[Answer]
# [Ly](https://github.com/LyricLy/Ly), 87 bytes
```
0>0>0>i['-=[pl'o=[p<1+>0]pp0]p'/=[p<<1+>>0]p'o=[p<<<1+>>>0]psp]<s<l-:l+sp<l-u>' ou>' ou
```
[Try it online!](https://tio.run/##VUtJCsAwCPxKbh6KJL2WNB9J8oBCQCH00NdbbbrQUUdnBtshEpLVlgHXzA1IOc5TCpVZB7xpM8wZ6ZCmO9fYY8OlTZ117wkcDRLxSFic4btuXMbjkvNUtN@Afg8WmjwB "Ly – Try It Online")
I think this could be shorter, but I've hit a brick wall at this point.
At a high level, it counts the number of `-` (matched), `/` and `o` characters, then subtracts to remove duplicate counts before printing the results.
First is initializes counters to `0` on three different stacks.
```
0>0>0>
```
Then it reads the input onto the stack a codepoints, and loops over each character. The code also saved the current character to the backup cell with `s` so we can only count matched `-` characters.
```
i[ ...                                                sp]
```
The first check increments the counter on the first stack if it's `-` and the previous character was `o`. That works since the characters are processes in reverse order.
```
  '-=[pl'o=[p<1+>0]pp0]p
```
The second check increments the counter on the second stack anytime the code hits a `/` character.
```
                        '/=[p<<1+>>0]p
```
And the last check increments the counter on the third stack when the code finds a `o` character.
```
                                      'o=[p<<<1+>>>0]p
```
Once all the input has been scanned and counted, to code subtracts the number of matched `-` characters (bodybuilders) from the number of `/` characters to find the number of acrobats.
```
<s<l-
```
Then it remember the number of acrobats plus the number of bodybuilders by stashing the sum of the two in the backup cell.
```
     :l+sp
```
Then is subtracts that from the number of `o` characters to get the final counter and prints it.
```
          <l-u
```
The last bits just shift to the next counter and prints with a space appended.
>' ou
And does the same shift/print to output the last counter.
```
                   >' ou
```
]