Một con heo đất là một container được sử dụng để thu thập tiền xu. Đối với thử thách này, hãy sử dụng bốn đồng tiền của Mỹ: quý, xu, niken và đồng xu .

Thử thách

Thách thức của bạn là tạo ra một con heo đất điện tử. Viết chương trình (hoặc chức năng) mà khi chạy (hoặc được gọi), sẽ xuất (hoặc trả về) số lượng của mỗi đồng tiền bạn có, cũng như tổng số tiền mà số tiền đó đạt được.

Đầu vào

Một chuỗi, mảng, v.v ... (sự lựa chọn của bạn) của các đồng tiền vào ngân hàng heo của bạn (trường hợp không nhạy cảm).

 Q - Quarter(Value of 25)
 D - Dime(Value of 10)
 N - Nickel(Value of 5)
 P - Penny(Value of 1)

Đầu ra

Số lượng tiền từ đầu vào và tổng số tiền, được phân tách bằng dấu phân cách không nguyên mà bạn chọn. (Thứ tự bạn xuất tổng số tiền không quan trọng, nhưng tổng giá trị đồng tiền (tổng) phải là yếu tố cuối cùng)

Ví dụ

 Input          ->       Output

 P              ->       1,0,0,0,1 or 0,0,0,1,1 or 0,0,1,0,1 or 1,1
 N              ->       0,1,0,0,5
 D              ->       0,0,1,0,10 
 Q              ->       0,0,0,1,25
 QQQQ           ->       0,0,0,4,100
 QNDPQNDPQNDP   ->       3,3,3,3,123
 PPPPPPPPPP     ->       10,0,0,0,10
 PNNDNNQPDNPQND ->       3,6,3,2,113

Quy tắc

Sơ hở tiêu chuẩn không được phép.

Đây là môn đánh gôn , vì vậy mã ngắn nhất tính theo byte cho mỗi ngôn ngữ sẽ thắng!

Python 2 , 73 byte

-3 byte nhờ @Rod

C=map(input().count,'QDNP')
print C+[sum(map(int.__mul__,C,[25,10,5,1]))]

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

Python 2 , 63 byte

a,b,c,d=map(input().count,'PNDQ')
print a,b,c,d,a+b*5+c*10+d*25

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

Python 2 , 63 byte

l=map(input().count,'PNDQ')
a,b,c,d=l
print l+[a+b*5+c*10+d*25]

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

APL (Dyalog Unicode) , 28 27 byte

1 5 10 25(⊢,+.×)'PNDQ'+.=¨⊂

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

Hàm ngầm. Đưa đầu vào như một vector trong định dạng ,'<input>'.

Cảm ơn ngn cho một byte!

Làm sao?

1 5 10 25(⊢,+.×)'PNDQ'+.=¨⊂ ⍝ Main function, tacit.
                          ⊂ ⍝ Enclose
                         ¨  ⍝ Each character of the input
                      +.=   ⍝ Sum the number of matched characters
                'PNDQ'      ⍝ From this string
1 5 10 25(  +.×)            ⍝ Multiply the values with the left argument, then sum them.
          ⊢,                ⍝ And append to the original vector of coins.

R , 70 69 byte

function(n)c(x<-table(factor(n,c("P","N","Q","D"))),x%*%c(1,5,25,10))

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

Đưa đầu vào như một vector của các ký tự riêng lẻ. Chuyển đổi chúng thành factorsvà tabulates chúng, sau đó tính toán các giá trị với một sản phẩm chấm.

Để dễ kiểm tra, tôi đã thêm một cách để chuyển đổi từ các trường hợp thử nghiệm ở trên sang đầu vào mà hàm đang mong đợi.

Điều này hầu như không vượt qua được việc lưu trữ các tên đồng xu dưới dạng vector names, điều đó có nghĩa là cách tiếp cận dưới đây có thể sẽ trở nên golf hơn nếu chúng ta có nhiều loại tiền xu hơn:

R , 71 70 byte

function(n)c(x<-table(factor(n,names(v<-c(P=1,N=5,Q=25,D=10)))),x%*%v)

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

Thạch , 19 byte

ċЀ“PNDQ”µæ.“¢¦½ı‘ṭ

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

Làm thế nào nó hoạt động

ċЀ“PNDQ”µæ.“¢¦½ı‘ṭ    Main link. Arguments: s (string)
 Ѐ“PNDQ”              For each char in "PNDQ":
ċ                        Count the occurrences of the char in s.
                       Collect the results in an array. Call this a.
         µ             Start a new monadic chain. Argument: a
          æ.           Take the dot product of a with
            “¢¦½ı‘       [1, 5, 10, 25].
                  ṭ    Tack this onto the end of a.

JavaScript (ES6), 63 61 byte

Đã lưu 2 byte nhờ Shaggy

Đưa đầu vào như một mảng các ký tự. Đầu ra P,N,D,Q,total.
Lấy cảm hứng từ câu trả lời Python của ovs .

a=>eval(a.join`++,`+`++,[P,N,D,Q,P+N*5+D*10+Q*25]`,P=N=D=Q=0)

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

Câu trả lời gốc, 73 byte

Đưa đầu vào như một mảng các ký tự. Đầu ra Q,D,N,P,total.

a=>a.map(c=>o[o[4]+='521'[i='QDNP'.search(c)]*5||1,i]++,o=[0,0,0,0,0])&&o

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

MATL , 22 20 byte

!'PNDQ'=Xst[l5X25]*s

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 thích với ví dụ

Hãy xem xét đầu vào 'PNNDNNQPDNPQND'là một ví dụ. Nội dung ngăn xếp được hiển thị lộn ngược, tức là phần tử trên cùng xuất hiện bên dưới.

!        % Implicit input: string (row vector of chars). Transpose into a
         % column vector of chars
         % STACK: ['P';
                   'N';
                   'N';
                   'D';
                   'N';
                   'N';
                   'Q';
                   'P';
                   'D';
                   'N';
                   'P';
                   'Q';
                   'N';
                   'D']
'PNDQ'   % Push this string (row vector of chars)
         % STACK: ['P';
                   'N';
                   'N';
                   'D';
                   'N';
                   'N';
                   'Q';
                   'P';
                   'D';
                   'N';
                   'P';
                   'Q';
                   'N';
                   'D'],
                  'PNDQ'
=        % Implicit input. Test for equality, element-wise with broadcast
         % STACK: [1 0 0 0;
                   0 1 0 0;
                   0 1 0 0;
                   0 0 1 0;
                   0 1 0 0;
                   0 1 0 0;
                   0 0 0 1;
                   1 0 0 0;
                   0 0 1 0;
                   0 1 0 0;
                   1 0 0 0;
                   0 0 0 1;
                   0 1 0 0;
                   0 0 1 0]
Xs       % Sum of each column
         % STACK: [3 6 3 2]
t        % Duplicate
         % STACK: [3 6 3 2],
                  [3 6 3 2]
[l5X25]  % Push array [1 5 10 25]
         % STACK: [3 6 3 2],
                  [3 6 3 2],
                  [1 5 10 25]
*        % Multiply, element-wise
         % STACK: [3 6 3 2],
                  [3 30 30 50]
s        % Sum
         % STACK: [3 6 3 2],
                  113
         % Implicitly display

Japt , 25 22 byte

Đã lưu 3 byte nhờ @Shaggy

`p˜q`¬£èX
pUí*38#éìH)x

Kiểm tra nó trực tuyến! Đưa đầu vào bằng chữ thường

Giải trình

`p˜q`¬         Split the compressed string "pndq" into chars, giving ["p", "n", "d", "q"].
      £        Map each char X to
       èX      the number of occurrences of X in the input.
<newline>      Set variable U to the resulting array.
 Uí*           Multiply each item in U by the corresponding item in
    38#é         38233
        ìH       converted to base-32, giving [1, 5, 10, 25].
           x   Take the sum.
p              Append this to the end of U.
               Implicit: output result of last expression

Excel (phiên bản tiếng Ba Lan), 150 byte

Đầu vào là A1. Các công thức có trong các ô B1- F1:

cell  formula
------------------------------
B1    =DŁ(A1)-DŁ(PODSTAW(A1;"Q";""))
C1    =DŁ(A1)-DŁ(PODSTAW(A1;"D";""))
D1    =DŁ(A1)-DŁ(PODSTAW(A1;"N";""))
E1    =DŁ(A1)-DŁ(PODSTAW(A1;"P";""))
F1    =B1*25+C1*10+D1*10+E1

kết quả đầu ra của số khu, hào, nickels, pennys và tổng trong các tế bào B1, C1, D1, E1và F1tương ứng.

Phiên bản tiếng Anh (162 byte):

cell  formula
------------------------------
B1    =LEN(A1)-LEN(SUBSTITUTE(A1;"Q";""))
C1    =LEN(A1)-LEN(SUBSTITUTE(A1;"D";""))
D1    =LEN(A1)-LEN(SUBSTITUTE(A1;"N";""))
E1    =LEN(A1)-LEN(SUBSTITUTE(A1;"P";""))
F1    =B1*25+C1*10+D1*10+E1

APL + THẮNG, 33 27 byte

5 byte được lưu nhờ Adam

Nhắc nhở đầu vào màn hình của chuỗi coin.

n,+/1 5 10 25×n←+⌿⎕∘.='PNDQ'

05AB1E , 30 26 22 21 19 byte

X5T25)s.•50†•S¢=*O=

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

X                   # Push 1.
 5                  # Push 5.
  T                 # Push 10.
   25               # Push 25.
     )s             # Wrap stack to array, swap with input.
       .•50†•       # Push 'pndq'.
             S      # Push ['p','n','d','q'] (split).
              ¢     # Count (vectorized).
               =    # Print counts, without popping.
                *   # Multiply counts by [1,2,10,25]
                 O  # Sum.
                  = # Print.

Đổ:

Full program: X5T25)s.•50†•S¢=*O=
current >> X  ||  stack: []
current >> 5  ||  stack: [1]
current >> T  ||  stack: [1, '5']
current >> 2  ||  stack: [1, '5', 10]
current >> )  ||  stack: [1, '5', 10, '25']
current >> s  ||  stack: [[1, '5', 10, '25']]
current >> .  ||  stack: [[1, '5', 10, '25'], 'pnndnnqpdnpq']
current >> S  ||  stack: [[1, '5', 10, '25'], 'pnndnnqpdnpq', 'pndq']
current >> ¢  ||  stack: [[1, '5', 10, '25'], 'pnndnnqpdnpq', ['p', 'n', 'd', 'q']]
current >> =  ||  stack: [[1, '5', 10, '25'], [3, 5, 2, 2]]
[3, 5, 2, 2]
current >> *  ||  stack: [[1, '5', 10, '25'], [3, 5, 2, 2]]
current >> O  ||  stack: [[3, 25, 20, 50]]
current >> =  ||  stack: [98]
98
stack > [98]

Đầu ra in:

[3, 25, 20, 50]\n98 or [P, N, D, Q]\n<Sum>

Bởi vì một cái gì đó đã được in, ngăn xếp kết thúc bị bỏ qua.

J , 29 byte

1 5 10 25(],1#.*)1#.'PNDQ'=/]

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

Giải trình:

'PNDQ'=/] tạo một bảng bằng

   'PNDQ' =/ 'PNNDNNQPDNPQND'
1 0 0 0 0 0 0 1 0 0 1 0 0 0
0 1 1 0 1 1 0 0 0 1 0 0 1 0
0 0 0 1 0 0 0 0 1 0 0 0 0 1
0 0 0 0 0 0 1 0 0 0 0 1 0 0

1#. tìm tổng của từng hàng trong bảng, do đó số lần xuất hiện của mỗi giá trị

   1#. 'PNDQ' =/ 'PNNDNNQPDNPQND'
3 6 3 2

1#.* tìm thấy sản phẩm chấm của đối số trái và phải của nó

    1 5 10 25(1#.*)3 6 3 2
113

], nối sản phẩm chấm vào danh sách các giá trị

   1 5 10 25(],1#.*)1#.'PNDQ'=/] 'PNNDNNQPDNPQND'
3 6 3 2 113

C # (.NET Core) , 163 136 byte

Cảm ơn @raznagul vì đã tiết kiệm rất nhiều byte ở đó!

n=>{var m="";int c=0,i=0,k=0;for(var v=new[]{1,5,10,25};i<4;m+=k+",",c+=k*v[i++],k=0)foreach(var x in n)k+=x=="PNDQ"[i]?1:0;return m+c;}

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

Phiên bản cũ:

n=>{var v=new[]{1,5,10,25};string l="PNDQ",m="";int c=0,i,j,k;for(i=0;i<4;i++){for(j=0,k=0;j<n.Length;j++)k+=n[j]==l[i]?1:0;m+=k+",";c+=k*v[i];k=0;}m+=c;return m;}

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

Perl 5 -pF , 59 byte

for$i(P,N,D,Q){say s:$i:$\+={P,1,Q,25,D,10,N,5}->{$&}:eg}}{

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

Ruby , 66 byte

->s{t=0;{P:1,N:5,D:10,Q:25}.map{|c,v|t+=v*m=s.count(c.to_s);m}<<t}

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

Không tốt.

05AB1E , 19 byte

"PNDQ"S¢D•Ωт•₂в*O)˜

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

Giải trình

"PNDQ"                # push this string
      S               # split to list of chars
       ¢              # count the occurrences of each in input
        D             # duplicate
         •Ωт•         # push 21241
             ₂в       # convert to a list of base 26 digits
               *      # element-wise multiplication
                O     # sum
                 )˜   # wrap in a flattened list

Java (OpenJDK 8) , 148 byte

c->{int q=0,d=0,n=0,p=0;for(char w:c){if(w=='Q')q++;if(w=='D')d++;if(w=='N')n++;if(w=='P')p++;}return ""+q+","+d+","+n+","+p+","+(q*25+d*10+n*5+p);}

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

Chà, nó chỉ ngắn hơn một byte so với đệ trình Java khác , nhưng ngắn hơn thì ngắn hơn: D

Giải trình:

int q=0,d=0,n=0,p=0;    //Initialize too many integers
for(char w:c){    //Loop through each coin
  if(w=='Q')q++;if(w=='D')d++;if(w=='N')n++;if(w=='P')p++;    //Increment the correct coin
}return ""+q+","+d+","+n+","+p+","+(q*25+d*10+n*5+p);    //Return each coin count and the total monetary value 

Gol> <> , 47 byte

5R0TiE!vD;
5+@P@@t>b%m$.
a+$P$t
PrPrt
9s+r$P$rt

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

Các định dạng đầu ra là [P Q N D Value].

Làm thế nào nó hoạt động

5R0TiE!vD;
       >b%m$.

5R0            Repeat command '0' (push 0) 5 times
   T           Set teleport location for later
    i          Input a char
     E         Pop if the last input was EOF; skip next otherwise

               If the last is EOF, the following is run:
      ! D;     Skip 'v', print the contents of the stack from bottom to top, then exit

               Otherwise the following is run:
       v
       >b%m$.  Take the top (input) modulo 11, and jump to (-1, input % 11)
               P%11 = 3, N%11 = 1, D%11 = 2, Q%11 = 4

5+@P@@t        Runs if the input is N
5+             Add 5 to top
  @            Rotate top 3 (the 3rd comes to the top)
   P           Increment the top
  @P@@         Increment the 3rd from top
      t        Teleport to the last 'T'

a+$P$t         Runs if the input is D
a+             Add 10 to top
  $            Swap top two
  $P$          Increment the 2nd from top
     t         Teleport to the last 'T'

PrPrt          Runs if the input is P
P              Increment the top
 r             Reverse the stack
 rPr           Increment the bottom
    t          Teleport to the last 'T'

9s+r$P$rt      Runs if the input is Q
9s+            Add 25 to the top ('s': add 16 to the top)
   r$P$r       Increment the 2nd from bottom
        t      Teleport to the last 'T'

Perl 5 -p , 47 byte

#!/usr/bin/perl -p
P1N5D10Q25=~s:\D:$\-=-$'*($n=s/$&//g);say$n:egr

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

Pyth, 23 27 26 byte

+Jm/Qd"PNDQ"s.b*NYJ[h05T25

Đã lưu một byte nhờ @RK. Đầu ra dưới dạng [P, N, D, Q, value].
Hãy thử nó ở đây

Giải trình

+Jm/Qd"PNDQ"s.b*NYJ[h05T25
 Jm/Qd"PNDQ"                Save the count of each coin (in PNDQ order) as J.
                   [h05T25  [1, 5, 10, 25].
             .b   J       For each pair of count and value...
               *NY          ... take the product...
            s               ... and get the sum.
+                          Stick that onto the list of counts.

C (tiếng kêu) , 112 byte

f(char *i){int c,d,v[5]={0};for(;c=*i++;v[d=(c|c/2)&3]++,v[4]+="AYJE"[d]-64);for(c=0;c<5;printf("%d,",v[c++]));}

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

Đầu ra seq bây giờ là P, Q, D, N, tổng giá trị
Hoạt động với cả đầu vào chữ thường và chữ hoa.

Giải trình:

"AYJE"hoặc {64+1,64+25,64+10,64+5}là. 64 + giá trị của đồng tiền.
d=(c|c/2)&3(được sử dụng như chỉ mục) có giá trị 1,2,3,0cho q,d,n,pđầu vào tương ứng, trong cả chữ hoa và chữ thường.

C # (.NET Core) , 156 byte

s=>{Func<char,int>f=i=>{return s.Split(i).Length-1;};var a=new[]{f('P'),f('N'),f('D'),f('Q')};return$"{string.Join(",",a)},{a[0]+a[1]*5+a[2]*10+a[3]*25}";};

Java (OpenJDK 8) , 149 byte

a->{int[]c={0,0,0,0,0};for(String g:a){if(g=="P")c[0]+=1;if(g=="N")c[1]+=5;if(g=="D")c[2]+=10;if(g=="Q")c[3]+=25;}c[4]=c[0]+c[1]+c[2]+c[3];return c;}

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

Võng mạc , 50 byte

P
P_
N
N5*
D
D10*
Q
Q25*
^
PNDQ_
O`.
(.)(\1*)
$.2¶

Hãy thử trực tuyến! Đầu ra theo thứ tự D, N, P, Q, tổng. Giải trình:

P
P_
N
N5*
D
D10*
Q
Q25*

Tính tổng bằng cách chèn _s tương ứng với giá trị của mỗi đồng xu.

^
PNDQ_

Chèn thêm một bản sao của mỗi ký tự để có ít nhất một trong số mỗi ký tự khớp.

O`.

Sắp xếp các ký tự theo thứ tự.

(.)(\1*)
$.2¶

Đếm số lượng của mỗi nhân vật sau lần đầu tiên.

SmileBASIC, 70 byte

INPUT C$P=N+D+Q
WHILE""<C$INC VAR(POP(C$))WEND?P,N,D,Q,P+N*5+D*10+Q*25

Thí dụ:

? PNDNDNDQP
2   3   3   1   72

Giải trình:

INPUT COINS$
P=N+D+Q 'create variables
WHILE COINS$>"" 'loop until the coin list is empty
 'pop a character from the coin list
 'and increment the variable with that name
 INC VAR(POP(COINS$))
WEND
PRINT P,N,D,Q,P+N*5+D*10+Q*25

C, 149 byte

f(char*s){int a[81]={},b[]={1,5,10,25},c=0;char*t,*v="PNDQ";for(t=s;*t;a[*t++]++);for(t=v;*t;printf("%d,",a[*t++]))c+=a[*t]*b[t-v];printf("%d\n",c);}

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

C không có mảng kết hợp, vì vậy tôi giả mạo nó (rất kém hiệu quả, thông minh về trí nhớ!) Và sau đó lặp lại một lần nữa với một mảng tra cứu để thêm tiền. Nó sẽ không tính ngoại tệ, mặc dù :-)