Ein Sparschwein ist ein Behälter, in dem Münzen gesammelt werden. Verwenden Sie für diese Herausforderung die vier US-Münzen: Viertel, Cent, Nickel und Penny .

Herausforderung

Ihre Herausforderung besteht darin, ein elektronisches Sparschwein zu schaffen. Schreiben Sie ein Programm (oder eine Funktion), das beim Ausführen (oder Aufrufen) die Anzahl jeder Münze sowie den Gesamtbetrag der Münzen ausgibt (oder zurückgibt).

Eingang

Eine Zeichenfolge, ein Array usw. (nach Ihrer Wahl) der Münzen in Ihr Sparschwein (ohne Berücksichtigung der Groß- und Kleinschreibung).

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

Ausgabe

Die Anzahl der Münzen aus der Eingabe und der Gesamtbetrag, getrennt durch das nicht ganzzahlige Trennzeichen Ihrer Wahl. (Die Reihenfolge, in der Sie die Münzsummen ausgeben, spielt keine Rolle, aber der Gesamtmünzwert (Summe) muss das letzte Element sein.)

Beispiele

 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

Regeln

Standardlücken sind nicht erlaubt.

Dies ist Code-Golf , also gewinnt der kürzeste Code in Bytes für jede Sprache!

Python 2 , 73 Bytes

-3 Bytes dank @Rod

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

Probieren Sie es online aus!

Python 2 , 63 Bytes

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

Probieren Sie es online aus!

Python 2 , 63 Bytes

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

Probieren Sie es online aus!

APL (Dyalog Unicode) , 28 27 Bytes

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

Probieren Sie es online aus!

Stillschweigende Funktion. Übernimmt die Eingabe als Vektor im Format ,'<input>'.

Danke an ngn für ein Byte!

Wie?

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 Bytes

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

Probieren Sie es online aus!

Nimmt die Eingabe als Vektor einzelner Zeichen auf. Konvertiert sie in factorsund tabulates und berechnet dann die Werte mit einem Punktprodukt.

Zur Vereinfachung der Testzwecke habe ich eine Möglichkeit hinzugefügt, die obigen Testfälle in die von der Funktion erwartete Eingabe zu konvertieren.

Dies ist kaum namesbesser als das Speichern der Münznamen als Vektor , was bedeutet, dass der folgende Ansatz wahrscheinlich Golfspieler wäre, wenn wir mehr Münztypen hätten:

R , 71 70 Bytes

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

Probieren Sie es online aus!

Gelee , 19 Bytes

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

Probieren Sie es online aus!

Wie es funktioniert

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

2 Bytes dank Shaggy gespeichert

Nimmt die Eingabe als Array von Zeichen auf. Ausgänge P,N,D,Q,total.
Inspiriert von der Python-Antwort von ovs .

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

Probieren Sie es online aus!

Ursprüngliche Antwort, 73 Bytes

Nimmt die Eingabe als Array von Zeichen auf. Ausgänge 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

Probieren Sie es online aus!

MATL , 22 20 Bytes

!'PNDQ'=Xst[l5X25]*s

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

Erklärung mit Beispiel

Betrachten Sie die Eingabe 'PNNDNNQPDNPQND'als Beispiel. Der Stapelinhalt wird verkehrt herum angezeigt, dh das obere Element wird unten angezeigt.

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

3 Bytes dank @Shaggy gespeichert

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

Testen Sie es online! Nimmt Eingaben in Kleinbuchstaben vor

Erläuterung

`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 (polnische Sprachversion), 150 Bytes

Die Eingabe erfolgt in A1. Die Formeln sind in Zellen 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

was zu einer Ausgabe der Anzahl von Vierteln, Dimes, Nickels, pennys und die Summe in Zellen B1, C1, D1, E1und F1sind.

Englische Sprachversion (162 Bytes):

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 Bytes

5 Bytes dank Adam gespeichert

Fordert zur Bildschirmeingabe der Münzzeichenfolge auf.

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

05AB1E , 30 26 22 21 19 Bytes

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

Probieren Sie es online aus!

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.

Dump:

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]

Gedruckte Ausgabe:

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

Da etwas gedruckt wurde, wird der Endstapel ignoriert.

J , 29 Bytes

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

Probieren Sie es online aus!

Erläuterung:

'PNDQ'=/] erstellt eine Gleichheitstabelle

   '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#. findet die Summe jeder Zeile der Tabelle, also die Anzahl der Vorkommen jedes Wertes

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

1#.* findet das Punktprodukt seines linken und rechten Arguments

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

], Hängt das Punktprodukt an die Werteliste an

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

C # (.NET Core) , 163 136 Byte

Vielen Dank an @raznagul für das Speichern vieler Bytes!

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

Probieren Sie es online aus!

Alte Version:

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

Probieren Sie es online aus!

Perl 5 -pF , 59 Bytes

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

Probieren Sie es online aus!

Ruby , 66 Bytes

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

Probieren Sie es online aus!

Nicht gut.

05AB1E , 19 Bytes

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

Probieren Sie es online aus!

Erläuterung

"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 Bytes

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

Probieren Sie es online aus!

Nun, es ist nur ein Byte kürzer als die andere Java-Übermittlung, aber hey - kürzer ist kürzer: D.

Erläuterung:

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 Bytes

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

Probieren Sie es online aus!

Das Ausgabeformat ist [P Q N D Value].

Wie es funktioniert

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 Bytes

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

Probieren Sie es online aus!

Pyth, 23 27 26 Bytes

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

Dank @RK ein Byte gespeichert. Ausgaben als [P, N, D, Q, Wert].
Probieren Sie es hier aus

Erläuterung

+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 (Klirren) , 112 Bytes

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

Probieren Sie es online aus!

Die Ausgangssequenz ist jetzt P, Q, D, N, Gesamtwert.
Funktioniert sowohl mit Eingaben in Klein- als auch in Großbuchstaben.

Erläuterung:

"AYJE"oder {64+1,64+25,64+10,64+5}ist. 64 + Münzwert.
d=(c|c/2)&3(wird als Index verwendet) hat einen Wert 1,2,3,0für q,d,n,pEingaben, sowohl in Groß- als auch in Kleinbuchstaben.

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 Bytes

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

Probieren Sie es online aus!

Netzhaut , 50 Bytes

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

Probieren Sie es online aus! Ausgaben in der Reihenfolge D, N, P, Q, gesamt. Erläuterung:

P
P_
N
N5*
D
D10*
Q
Q25*

Berechnen Sie die Summe, indem Sie _s einfügen , das dem Wert jeder Münze entspricht.

^
PNDQ_

Fügen Sie eine zusätzliche Kopie jedes Zeichens ein, damit mindestens eine davon übereinstimmt.

O`.

Sortieren Sie die Zeichen in der richtigen Reihenfolge.

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

Zählen Sie die Nummer jedes Zeichens nach dem ersten.

SmileBASIC, 70 Bytes

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

Beispiel:

? PNDNDNDQP
2   3   3   1   72

Erläuterung:

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 Bytes

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

Probieren Sie es online aus!

C hat keine assoziativen Arrays, also fälsche ich es (sehr ineffizient, was den Speicher betrifft!) Und durchlaufe es dann erneut mit einem Lookup-Array, um die Münzen zu addieren. Es wird jedoch keine Fremdwährung berechnet :-)