Như bạn có thể biết, gần đây đã xuất hiện nhiều thử thách đáng yêu của Jimmy . Trong những thử thách này, bạn đã được thử thách với kỹ năng nhào lộn của người bạn yêu quý của chúng tôi. Bây giờ chúng tôi có một thử thách khác cho bạn. Hôm nay bạn sẽ xác định được các loại Jimmys khác nhau!

Giải trình

Có ba loại Jimmys: lùn, acrobat và thể hình.

This is dwarf Jimmy:               o

This is acrobat Jimmy:            /o\

This is bodybuilder Jimmy:       /-o-\

Những Jimmys này đều là những người bạn tuyệt vời và họ thích đứng trên cùng một hàng với nhau. Nhiệm vụ của bạn là, được đưa ra một cảnh Jimmy như vậy:

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

Xuất ra số lượng người lùn, nhào lộn và người tập thể hình trên đường, tương ứng.

Các thách thức

• Lấy đầu vào dưới bất kỳ hình thức hợp lý nào dưới dạng cảnh Jimmy, như trong một ví dụ ở trên.

  1. Chuỗi đầu vào phải là một dòng và tùy ý chứa ba loại Jimmys và khoảng trắng tùy chọn.

  2. Chuỗi sẽ không nhất thiết phải chứa tất cả các giống hoặc khoảng trắng của Jimmy.

  3. Chuỗi sẽ không chứa bất kỳ ký tự không có trong o/\ -.

  4. Bất kỳ sự kết hợp của các giống Jimmy là có thể. Điều này có nghĩa là cùng một loại hoặc khác nhau của Jimmy có thể nằm cạnh nhau. Bạn phải tính đến điều đó.

  5. Khoảng trắng hàng đầu và dấu là không bắt buộc và không có nghĩa là bắt buộc - chương trình của bạn sẽ chiếm một chuỗi có hoặc không có khoảng trắng hàng đầu và / hoặc dấu.

  6. Chuỗi chỉ nên chứa Jimmys hợp lệ và khoảng trắng. Chẳng hạn, ---///---không được phép vì nó không phải là một chuỗi hợp lệ của Jimmy.

• Xuất ba số: Số người lùn, nhào lộn và người tập thể hình trong cảnh (theo thứ tự tương ứng).

  1. Đây có thể là một đầu ra cho bàn điều khiển dưới dạng các số nguyên được phân tách bằng dấu cách hoặc nó có thể là giá trị trả về từ một hàm như một loại bộ chứa (tức là một kiểu mảng).

  2. Đầu ra, ở bất kỳ định dạng nào, phải được sắp xếp như được đề cập trong dấu đầu dòng trên quy tắc này.

• Quy tắc tiêu chuẩn và sơ hở áp dụng.

Các trường hợp thử nghiệm

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

Nếu bạn muốn có nhiều trường hợp thử nghiệm hơn, hãy sử dụng công cụ này để tạo ra nhiều trường hợp thử nghiệm ngẫu nhiên hơn.

Chấm điểm

Đây là môn đánh gôn , vì vậy điểm số thấp nhất tính theo byte sẽ thắng.

Bạn có thể xem bảng xếp hạng cho bài đăng này bằng cách mở rộng tiện ích / đoạn trích bên dưới. Để bài đăng của bạn được đưa vào bảng xếp hạng, bạn cần một tiêu đề ( # header text) với thông tin sau:

• Tên của ngôn ngữ (kết thúc bằng dấu phẩy ,hoặc dấu gạch ngang -), theo sau là ...

• Số byte, là số cuối cùng xuất hiện trong tiêu đề của bạn.

Ví dụ: JavaScript (ES6), 72 byteshợp lệ, nhưng Fortran, 143 bytes (8-bit)không hợp lệ vì số byte không phải là số cuối cùng trong tiêu đề (câu trả lời của bạn sẽ được nhận ra là 8 byte - không tận dụng điều này).

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

Jelly , (12?) 13 byte

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

Liên kết đơn âm chấp nhận danh sách các ký tự tạo ra danh sách các số nguyên, [ dwarves, acrobats, and body-builders](lưu Ṛbyte nếu chúng tôi có thể chỉ định đầu ra của chúng tôi)

Hãy thử trực tuyến!

Làm sao?

Tất cả Jimmys hiển thị một o; tất cả những người không phải người lùn cho thấy một /; tất cả các nhà xây dựng cơ thể cho thấy hai -. Đếm các số này, giảm một nửa số đếm -và thực hiện phép trừ để tìm số đếm của 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 (tiền phát hành) , 51 byte

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

Hãy thử trực tuyến!

Python 2 , 50 byte

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

Hãy thử trực tuyến!

-10 byte bằng cách chuyển đổi biểu thức lambda thành một chương trình đầy đủ nhờ @xnor (loại bỏ điều được lồng đôi lambda và sử dụng phép gán thay thế)

PowerShell , 59 55 byte

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

Hãy thử trực tuyến!

Chưa được kiểm soát:

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

J , 36 25 byte

-11 byte nhờ cole!

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

Hãy thử trực tuyến!

Giải pháp ban đầu

J , 36 byte

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

Hãy thử trực tuyến!

Giải trình:

                            '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

Một phiên J mẫu :

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 dưới dạng CSV, 130 byte

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

Chèn đầu vào trong không gian trước tiên ,, lưu dưới dạng .csv, mở trong Excel. Đầu ra Dwarfs, Acrobats và Bodybuilders B1, B2và B3tương ứng.

Excel, 244 byte

=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'∘.=⎕

Hãy thử trực tuyến!

Kotlin 131 130 129 121 117 97 96 88 byte

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

Hãy thử trực tuyến!

Chỉnh sửa - Wew, có nó dưới 100! Tôi nghi ngờ tôi có thể thu nhỏ nó nhiều hơn, nhưng chỉ có thời gian mới trả lời ...

Chỉnh sửa - Nói quá sớm, giảm thêm một byte bằng cách sử dụng danh sách thay vì chuỗi

Chỉnh sửa - trừ 8 byte nhờ AsoLeo đề xuất sử dụng chức năng mở rộng

Võng mạc , 39 35 byte

Chỉnh sửa: -4 byte nhờ @FryAmTheEggMan

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

Hãy thử trực tuyến!

Giải trình:

Một giai đoạn thay thế đơn giản. Nó tìm thấy tất cả các kết quả của regex ^((o)|(/o.)|(/-o-.)| )*(sẽ tạo ra một kết quả khớp - toàn bộ chuỗi) và thay thế nó bằng số lần chụp của các nhóm 2, 3 và 4. Đây là regex được chia nhỏ:

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

Chúng ta phải bắt đầu bằng ^hoặc kết thúc đầu vào cũng được tính là khớp. Trong cú pháp thay thế của Retina, $ntham chiếu nhóm bắt thứ n và công cụ sửa đổi #sẽ đếm xem có bao nhiêu kết quả khớp.

JavaScript, 55 byte

Tìm kiếm chuỗi sử dụng một mô hình kết hợp regex o, o-hoặc o-\; tăng số lượng tương ứng trong một mảng, sử dụng độ dài của mỗi trận đấu để xác định chỉ mục.

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

Hãy thử trực tuyến!

Clojure , 78 byte

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

Hãy thử trực tuyến!

Ngôn ngữ Wolfram (Mathicala) , 63 byte

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

Hãy thử trực tuyến!

55 byte nếu yêu cầu thứ tự vô nghĩa bị bỏ ...

Python 3 , 69 66 60 56 byte

-4 byte nhờ @Maarten Fabré

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

Hãy thử trực tuyến!

R , 63 byte

Sử dụng kết hợp Regex để tìm và đếm Jimmys.

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

Hãy thử trực tuyến!

K (oK) , 25 byte

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

Hãy thử trực tuyến!

Perl 5 -p , 41 byte

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

Hãy thử trực tuyến!

Đếm số lần oxuất hiện mà không bị theo dõi \hoặc -để tìm người lùn và xóa chúng khỏi chuỗi. Sau đó đếm số lần /oxuất hiện để tìm nhào lộn và loại bỏ chúng khỏi chuỗi. Sau đó đếm số lượng ocòn lại để xác định người xây dựng cơ thể. Chèn khoảng trắng giữa các số và ngầm định kết quả.

Ruby , 50 byte

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

Hãy thử trực tuyến!

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

Hãy thử trực tuyến!

Loại bỏ -o, /ovà otừ chuỗi và tăng các bộ đếm thích hợp mỗi lần. Lá đằng sau rất nhiều cánh tay và chân ( /-\, \, và không có gì).

Forth (gforth) , 118 byte

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

Hãy thử trực tuyến!

Giải trình

• Nhận Tính của /, -và onhân vật
• Thể hình là số lượng -nhân vật chia cho 2
• Acrobat là số lượng /ký tự trừ đi số lượng người xây dựng cơ thể
• Dwarf là ​​số lượng onhân vật trừ đi số lượng Acrobat và Bodybuilders

Giải thích mã

\ 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 byte

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

Cái này có thể là 12 byte bằng cách loại bỏ Rnếu thứ tự đầu ra [bodybuilder, acrobat, dwarf]sẽ được cho phép.

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Thay thế byte nhỏ bằng nhau:

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

Hãy thử trực tuyến hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình:

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

-1 byte nhờ trần

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);}

Hãy thử trực tuyến!