Tirelire électronique

11

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!

code-golf DevelopingDeveloper
la source
1
@Shaggy Oui, vous pouvez
DevelopingDeveloper
1
L'ordre des pièces dans le total . Pouvons-nous le donner dans l'ordre d'apparition dans l'entrée?
Adám
1
Donc, si l'ordre peut être déduit de l'entrée, pouvons-nous omettre les 0? Il sera toujours clair à quelles lettres chaque numéro fait référence.
Adám
1
Ce format de sortie est-il trop éloigné? Réponse de 19 octets dont je ne suis pas sûr qu'elle soit valide: essayez-la en ligne!
Urne de poulpe magique
1
Je pense qu'il devrait y avoir une étiquette [argent].
12Me21

Réponses:

5

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!

Possum mort
la source
4
Vous pouvez remplacer a*b for a,b in zip(C,[25,10,5,1])par map(int.__mul__,C,[25,10,5,1])pour économiser quelques octets
Rod
4

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.
J. Sallé
la source
1⊥∘.=∘'PNDQ'->'PNDQ'+.=¨⊂
ngn
4

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!

Giuseppe
la source
3

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.
ETHproductions
la source
3

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!

Arnauld
la source
Très bien fait! Vous pouvez supprimer 2 octets en mélangeant des éléments.
Shaggy
3

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
Luis Mendo
la source
!'PNDQ'=Xst[l5X25]!Y*est de 21 octets. bien que j'avoue que je ne l'ai pas testé.
Giuseppe
@Giuseppe Merci, mais le défi dit " le délimiteur non entier de votre choix", donc je suppose qu'un seul délimiteur est autorisé
Luis Mendo
Je ne l'avais pas remarqué. Et bien.
Giuseppe
1
Je pense que la solution de 21 octets est OK ... OP a commenté quelque chose à cet effet
Giuseppe
@Giuseppe Super! Jusqu'à 20 octets alors. Merci pour le heads-up
Luis Mendo
3

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
ETHproductions
la source
Essayer de trouver un moyen de jouer au golf avec la virgule, sans avoir beaucoup de chance jusqu'à présent.
Shaggy
Je l'ai!
Shaggy
Et enregistrez un autre octet en prenant l'entrée en minuscules.
Shaggy
Suppression d'un autre octet
Shaggy
@Shaggy Impressive, merci!
ETHproductions
3

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
pajonk
la source
3

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'
Graham
la source
Économisez 5 octets:n,+/1 5 10 25×n←+⌿⎕∘.='PNDQ'
Adám
@ngn Merci. La vieillesse prend le dessus sur moi :(
Graham
2

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.

Urne de poulpe magique
la source
2

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
Galen Ivanov
la source
2

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!

Ian H.
la source
1
J'ai réussi à faire grimper votre âme jusqu'à 136 octets . Pour de nombreux changements à la liste.
raznagul
@raznagul Excellente solution! Puis-je vous demander pourquoi vous avez basculé l'entrée vers une liste générique au lieu d'un tableau? AFAIK vous pouvez parcourir les caractères d'une chaîne sans utiliser de liste.
Ian H.
C'est un vestige d'une version antérieure, donc je pourrais utiliser à la n.Countplace de n.Length. Comme cela a été entièrement supprimé, vous pouvez l'utiliser stringmaintenant.
raznagul
1

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
Emigna
la source
1

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
X1M4L
la source
143 octets
plafondcat
1

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'
Bubbler
la source
1

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.

la source
Vous pouvez condenser la définition de J et la première utilisation de J pour obtenir+Jm/Qd"PNDQ"s.b*NYJ[h05T25
RK.
1

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.

GPS
la source
106 octets
plafondcat
L'élimination de c = 0 était une bonne prise. Merci.
GPS
0

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}";};
Romen
la source
0

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.

Neil
la source
0

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
12Me21
la source
0

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

ErikF
la source
133 octets
Plafond