Un salvadanaio è un contenitore usato per raccogliere monete. Per questa sfida usa le quattro monete statunitensi: quarto, centesimo, nichel e penny .

Sfida

La tua sfida è quella di creare un salvadanaio elettronico. Scrivi un programma (o una funzione) che quando viene eseguito (o chiamato), genera (o restituisce) il conteggio di ogni moneta che possiedi, nonché l'importo totale a cui corrispondono le monete.

Ingresso

Una stringa, un array, ecc ... (a tua scelta) delle monete nel tuo salvadanaio (senza distinzione tra maiuscole e minuscole).

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

Produzione

Il conteggio delle monete dall'input e l'importo totale, separati dal delimitatore non intero di tua scelta. (L'ordine in cui hai emesso i totali della moneta non ha importanza, ma il valore totale della moneta (somma) deve essere l'ultimo elemento)

Esempi

 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

Regole

Non sono ammesse scappatoie standard .

Questo è code-golf , quindi vince il codice più breve in byte per ogni lingua!

Python 2 , 73 byte

-3 byte grazie a @Rod

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

Provalo online!

Python 2 , 63 byte

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

Provalo online!

Python 2 , 63 byte

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

Provalo online!

APL (Dyalog Unicode) , 28 27 byte

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

Provalo online!

Funzione tacita. Accetta input come vettore nel formato ,'<input>'.

Grazie a ngn per un byte!

Come?

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

Provalo online!

Accetta input come vettore di singoli personaggi. Li converte in factorse tabulateli, quindi calcola i valori con un prodotto punto.

Per motivi di test, ho aggiunto un modo per convertire i casi di test sopra nell'input che la funzione si aspetta.

Questo a malapena batte la memorizzazione dei nomi delle monete come vettore names, il che significa che l'approccio sotto sarebbe probabilmente più golfista se avessimo più tipi di monete:

R , 71 70 byte

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

Provalo online!

Gelatina , 19 byte

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

Provalo online!

Come funziona

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

Salvato 2 byte grazie a Shaggy

Accetta input come una matrice di caratteri. Uscite P,N,D,Q,total.
Ispirato dalla risposta Python di ovs .

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

Provalo online!

Risposta originale, 73 byte

Accetta input come una matrice di caratteri. Uscite 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

Provalo online!

MATL , 22 20 byte

!'PNDQ'=Xst[l5X25]*s

Provalo online! Oppure verifica tutti i casi di test .

Spiegazione con esempio

Considera l'input 'PNNDNNQPDNPQND'come esempio. I contenuti dello stack sono mostrati sottosopra, ovvero l'elemento superiore appare sotto.

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

Salvato 3 byte grazie a @Shaggy

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

Provalo online! Accetta input in minuscolo

Spiegazione

`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 (versione in lingua polacca), 150 byte

L'ingresso è in A1. Le formule sono nelle celle 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

conseguente uscita del numero di quarti, dimes, monetine pennys e la somma delle cellule B1, C1, D1, E1e F1rispettivamente.

Versione in lingua inglese (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 + WIN, 33 27 byte

5 byte salvati grazie ad Adam

Richiede l'inserimento dello schermo della stringa di monete.

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

05AB1E , 30 26 22 21 19 byte

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

Provalo online!

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]

Uscita stampata:

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

Poiché è stato stampato qualcosa, lo stack finale viene ignorato.

J , 29 byte

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

Provalo online!

Spiegazione:

'PNDQ'=/] crea una tabella di uguaglianza

   '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#. trova la somma di ogni riga della tabella, quindi il numero di occorrenze di ciascun valore

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

1#.* trova il prodotto punto dell'argomento sinistro e destro

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

], aggiunge il prodotto punto all'elenco dei valori

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

C # (.NET Core) , 163 136 byte

Grazie a @raznagul per aver salvato un sacco di byte lì!

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

Provalo online!

Vecchia versione:

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

Provalo online!

Perl 5 -pF , 59 byte

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

Provalo online!

Rubino , 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}

Provalo online!

Non buono.

05AB1E , 19 byte

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

Provalo online!

Spiegazione

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

Provalo online!

Bene, è solo un byte più corto dell'altro invio Java, ma più corto è più corto: D

Spiegazione:

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

Provalo online!

Il formato di output è [P Q N D Value].

Come funziona

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

Provalo online!

Pyth, 23 27 26 byte

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

Salvataggio di un byte grazie a @RK. Emette come [P, N, D, Q, valore].
Provalo qui

Spiegazione

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

Provalo online!

L'output seq ora è P, Q, D, N, valore totale
Funziona con input sia in minuscolo che maiuscolo.

Spiegazione:

"AYJE"o {64+1,64+25,64+10,64+5}è. 64 + valore della moneta.
d=(c|c/2)&3(usato come indice) ha valore 1,2,3,0per gli q,d,n,pinput rispettivamente, sia in maiuscolo che in minuscolo.

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

Provalo online!

Retina , 50 byte

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

Provalo online! Uscite nell'ordine D, N, P, Q, totale. Spiegazione:

P
P_
N
N5*
D
D10*
Q
Q25*

Calcola il totale inserendo _ s corrispondente al valore di ogni moneta.

^
PNDQ_

Inserisci una copia extra di ogni personaggio in modo che ce ne sia almeno uno da abbinare.

O`.

Ordina i personaggi in ordine.

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

Conta il numero di ogni personaggio dopo il primo.

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

Esempio:

? PNDNDNDQP
2   3   3   1   72

Spiegazione:

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

Provalo online!

C non ha array associativi, quindi lo falso (in modo molto inefficiente, dal punto di vista della memoria!) E quindi eseguo nuovamente il ciclo con un array di ricerca per sommare le monete. Non calcolerà la valuta estera, comunque :-)