Une tirelire est un conteneur utilisé pour collecter des pièces. Pour ce défi, utilisez les quatre pièces américaines: le quart, le dixième de dollar, le nickel et le sou .

Défi

Votre défi est de créer une tirelire électronique. Écrivez un programme (ou une fonction) qui, lorsqu'il est exécuté (ou appelé), génère (ou renvoie) le nombre de chaque pièce que vous avez, ainsi que le montant total des pièces.

Contribution

Une chaîne, un tableau, etc ... (votre choix) des pièces dans votre tirelire (insensible à la casse).

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

Production

Le nombre de pièces de l'entrée et le montant total, séparés par le délimiteur non entier de votre choix. (L'ordre dans lequel vous sortez les totaux des pièces n'a pas d'importance, mais la valeur totale des pièces (somme) doit être le dernier élément)

Exemples

 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

Règles

Les échappatoires standard ne sont pas autorisées.

Il s'agit de code-golf , donc le code le plus court en octets pour chaque langue gagne!

Python 2 , 73 octets

-3 octets grâce à @Rod

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

Essayez-le en ligne!

Python 2 , 63 octets

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

Essayez-le en ligne!

Python 2 , 63 octets

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

Essayez-le en ligne!

APL (Dyalog Unicode) , 28 27 octets

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

Essayez-le en ligne!

Fonction tacite. Prend l'entrée en tant que vecteur au format ,'<input>'.

Merci à ngn pour un octet!

Comment?

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 octets

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

Essayez-le en ligne!

Prend la saisie comme vecteur de caractères individuels. Les convertit en factorset tabulateles s, calcule ensuite les valeurs avec un produit scalaire.

Pour faciliter les tests, j'ai ajouté un moyen de convertir les cas de test ci-dessus en entrée attendue par la fonction.

Cela bat à peine le stockage des noms de pièces en tant que vecteur names, ce qui signifie que l'approche ci-dessous serait probablement plus golfique si nous avions plus de types de pièces:

R , 71 70 octets

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

Essayez-le en ligne!

Gelée , 19 octets

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

Essayez-le en ligne!

Comment ça fonctionne

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

Sauvegardé 2 octets grâce à Shaggy

Prend l'entrée comme un tableau de caractères. Sorties P,N,D,Q,total.
Inspiré par la réponse Python des ovs .

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

Essayez-le en ligne!

Réponse originale, 73 octets

Prend l'entrée comme un tableau de caractères. Sorties 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

Essayez-le en ligne!

MATL , 22 20 octets

!'PNDQ'=Xst[l5X25]*s

Essayez-le en ligne! Ou vérifiez tous les cas de test .

Explication avec exemple

Considérez la saisie 'PNNDNNQPDNPQND'comme exemple. Le contenu de la pile est affiché à l'envers, c'est-à-dire que l'élément supérieur apparaît ci-dessous.

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

Enregistré 3 octets grâce à @Shaggy

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

Testez-le en ligne! Prend l'entrée en minuscules

Explication

`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 (version en langue polonaise), 150 octets

L'entrée est en A1. Les formules sont dans les cellules 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

résultant en sortie du nombre de quartiers, dimes, nickels, pennys et la somme dans les cellules B1, C1, D1, E1et , F1respectivement.

Version en langue anglaise (162 octets):

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 octets

5 octets enregistrés grâce à Adam

Invite à saisir à l'écran la chaîne de pièces.

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

05AB1E , 30 26 22 21 19 octets

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

Essayez-le en ligne!

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.

Déverser:

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]

Sortie imprimée:

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

Parce que quelque chose a été imprimé, la pile de fin est ignorée.

J , 29 octets

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

Essayez-le en ligne!

Explication:

'PNDQ'=/] crée une table d'égalité

   '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#. trouve la somme de chaque ligne du tableau, donc le nombre d'occurrences de chaque valeur

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

1#.* trouve le produit scalaire de son argument gauche et droit

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

], ajoute le produit scalaire à la liste de valeurs

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

C # (.NET Core) , 163136 octets

Merci à @raznagul pour y avoir sauvé beaucoup d'octets!

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

Essayez-le en ligne!

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

Essayez-le en ligne!

Perl 5 -pF , 59 octets

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

Essayez-le en ligne!

Rubis , 66 octets

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

Essayez-le en ligne!

Pas génial.

05AB1E , 19 octets

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

Essayez-le en ligne!

Explication

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

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

Essayez-le en ligne!

Eh bien, c'est seulement un octet plus court que l' autre soumission Java, mais bon - plus court est plus court: D

Explication:

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 octets

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

Essayez-le en ligne!

Le format de sortie est [P Q N D Value].

Comment ça fonctionne

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 octets

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

Essayez-le en ligne!

Pyth, 23 27 26 octets

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

Un octet enregistré grâce à @RK. Sorties comme [P, N, D, Q, valeur].
Essayez-le ici

Explication

+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 octets

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

Essayez-le en ligne!

La sortie seq est maintenant de P, Q, D, N, valeur totale
Fonctionne avec les entrées en minuscules et en majuscules.

Explication:

"AYJE"ou {64+1,64+25,64+10,64+5}est. 64 + valeur de la pièce.
d=(c|c/2)&3(utilisé comme indice) a une valeur 1,2,3,0pour les q,d,n,pentrées respectivement, en majuscule et en minuscule.

C # (.NET Core) , 156 octets

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 octets

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

Essayez-le en ligne!

Rétine , 50 octets

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

Essayez-le en ligne! Sorties dans l'ordre D, N, P, Q, total. Explication:

P
P_
N
N5*
D
D10*
Q
Q25*

Calculez le total en insérant _s correspondant à la valeur de chaque pièce.

^
PNDQ_

Insérez une copie supplémentaire de chaque caractère pour qu'il y en ait au moins un de chaque correspondant.

O`.

Triez les caractères dans l'ordre.

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

Comptez le nombre de chaque caractère après le premier.

SmileBASIC, 70 octets

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

Exemple:

? PNDNDNDQP
2   3   3   1   72

Explication:

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 octets

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

Essayez-le en ligne!

C n'a pas de tableaux associatifs, donc je le simule (très inefficacement, en termes de mémoire!), Puis je boucle à nouveau avec un tableau de recherche pour additionner les pièces. Il ne calculera pas les devises étrangères, cependant :-)