돼지 저금통 에 수집 동전에 사용되는 컨테이너이 문제는 네 개의 미국 동전 사용의 경우 :. 분기, 다임, 니켈, 페니를 .

도전

당신의 도전은 전자 돼지 저금통을 만드는 것입니다. 실행 (또는 호출) 할 때 보유하고있는 각 코인의 수와 코인의 총액을 출력 (또는 반환)하는 프로그램 (또는 함수)을 작성하십시오.

입력

돼지 저금통에 동전의 문자열, 배열 등 (선택) (대소 문자 구분).

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

산출

입력의 코인 수와 선택한 양의 정수가 아닌 분리 문자로 구분 된 총액. (코인 총계를 출력하는 순서는 중요하지 않지만 총 코인 값 (sum)은 마지막 요소 여야합니다)

예

 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

규칙

표준 허점 은 허용되지 않습니다.

이것은 code-golf 이므로 각 언어에 대해 가장 짧은 바이트 단위의 코드가 이깁니다!

파이썬 2 , 73 바이트

@Rod 덕분에 -3 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 63 바이트

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

온라인으로 사용해보십시오!

파이썬 2 , 63 바이트

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

온라인으로 사용해보십시오!

APL (Dyalog Unicode) , 28 27 바이트

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

온라인으로 사용해보십시오!

암묵적 기능. 형식으로 입력을 벡터로 취합니다 ,'<input>'.

1 바이트의 ngn에 감사합니다!

어떻게?

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 바이트

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

온라인으로 사용해보십시오!

개별 문자로 구성된 벡터로 입력을받습니다. 로 변환을 factors하고 tabulate그들이야, 다음 내적으로 값을 계산합니다.

테스트를 쉽게하기 위해 위의 테스트 사례에서 함수가 기대하는 입력으로 변환하는 방법을 추가했습니다.

이것은 코인 이름을 vector로 저장하는 것을 거의 능가하지 names않습니다. 따라서 코인 유형이 더 많으면 아래 접근 방식이 골퍼가 될 수 있습니다.

R , 71 70 바이트

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

온라인으로 사용해보십시오!

젤리 , 19 바이트

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

온라인으로 사용해보십시오!

작동 원리

ċЀ“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.

자바 스크립트 (ES6), 63 61 바이트

Shaggy 덕분에 2 바이트 절약

문자 배열로 입력을받습니다. 출력 P,N,D,Q,total. ovs의 Python answer에서
영감을 얻었습니다 .

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

온라인으로 사용해보십시오!

원래 답변, 73 바이트

문자 배열로 입력을받습니다. 출력 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

온라인으로 사용해보십시오!

MATL , 22 20 바이트

!'PNDQ'=Xst[l5X25]*s

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

예를 들어 설명

'PNNDNNQPDNPQND'예를 들어 입력 을 고려하십시오 . 스택 내용이 거꾸로 표시됩니다. 즉 상단 요소가 아래에 나타납니다.

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

apt , 25 22 바이트

@Shaggy 덕분에 3 바이트 절약

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

온라인으로 테스트하십시오! 소문자로 입력합니다

설명

`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 (폴란드어 버전), 150 바이트

입력은 A1에 있습니다. 수식은 셀에 있습니다 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

분기 센트, 센트, pennys 수와 셀의 합계의 산출 결과 B1, C1, D1, E1및 F1는 각각.

영어 버전 (162 바이트) :

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 + WIN, 33 27 바이트

Adam 덕분에 5 바이트 절약

코인 문자열을 화면에 입력하라는 메시지가 표시됩니다.

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

05AB1E , 30 26 22 21 19 바이트

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

온라인으로 사용해보십시오!

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]

인쇄 출력 :

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

무언가가 인쇄 되었기 때문에 엔딩 스택은 무시됩니다.

J , 29 바이트

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

온라인으로 사용해보십시오!

설명:

'PNDQ'=/] 평등 테이블을 만듭니다.

   '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#. 테이블의 각 행의 합을 찾아서 각 값의 발생 횟수를 찾습니다.

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

1#.* 왼쪽과 오른쪽 인수의 내적을 찾습니다.

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

], 내적을 값 목록에 추가합니다.

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

C # (. NET 코어) , 163136 바이트

많은 바이트를 저장해 준 @raznagul에게 감사드립니다!

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

온라인으로 사용해보십시오!

구 버전:

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

온라인으로 사용해보십시오!

펄 5 -pF , 59 바이트

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

온라인으로 사용해보십시오!

루비 , 66 바이트

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

온라인으로 사용해보십시오!

별로.

05AB1E , 19 바이트

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

온라인으로 사용해보십시오!

설명

"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

자바 (OpenJDK 8) , 148 바이트

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

온라인으로 사용해보십시오!

글쎄, 그것은 다른 Java 제출 보다 1 바이트 짧지 만 , 짧아 : D

설명:

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 바이트

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

온라인으로 사용해보십시오!

출력 형식은 [P Q N D Value]입니다.

작동 원리

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'

펄 5 -p , 47 바이트

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

온라인으로 사용해보십시오!

Pyth, 23 27 26 바이트

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

@RK 덕분에 바이트를 저장했습니다. [P, N, D, Q, 값]으로 출력합니다.
여기 사용해보십시오

설명

+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 (클랑) , 112 바이트

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

온라인으로 사용해보십시오!

출력 seq는 이제 P, Q, D, N,
총값입니다. 소문자 및 대문자 입력 모두에서 작동합니다.

설명:

"AYJE"또는 {64+1,64+25,64+10,64+5}입니다. 64+ 코인 가치.
d=(c|c/2)&3(인덱스로 사용)에는 대문자와 소문자 모두 입력 값 1,2,3,0이 q,d,n,p있습니다.

C # (. NET 코어) 156 바이트

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

자바 (OpenJDK 8) 149 바이트

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

온라인으로 사용해보십시오!

망막 , 50 바이트

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

온라인으로 사용해보십시오! 총 D, N, P, Q 순서로 출력합니다. 설명:

P
P_
N
N5*
D
D10*
Q
Q25*

_각 동전의 가치에 해당 하는 s 를 삽입하여 총계를 계산하십시오 .

^
PNDQ_

일치 할 각 문자가 하나 이상 있도록 각 문자의 추가 사본을 삽입하십시오.

O`.

문자를 순서대로 정렬하십시오.

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

첫 문자 이후의 각 문자 수를 계산하십시오.

SmileBASIC, 70 바이트

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

예:

? PNDNDNDQP
2   3   3   1   72

설명:

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 바이트

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

온라인으로 사용해보십시오!

C에는 연관 배열이 없으므로 가짜로 (매우 비효율적이며 메모리 측면에서!) 가짜 배열을 조회 루프로 다시 반복하여 동전을 추가합니다. 그러나 외화를 계산하지는 않습니다 :-)