Una alcancía es un contenedor que se usa para recoger monedas. Para este desafío, usa las cuatro monedas de EE. UU .: cuarto, diez centavos, cinco centavos y cinco centavos .

Desafío

Su desafío es crear una alcancía electrónica. Escriba un programa (o función) que, cuando se ejecuta (o se llama), genera (o devuelve) el recuento de cada moneda que tiene, así como la cantidad total de las monedas.

Entrada

Una cadena, matriz, etc. (su elección) de las monedas en su alcancía (no distingue entre mayúsculas y minúsculas).

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

Salida

El recuento de monedas de la entrada y la cantidad total, separadas por el delimitador no entero de su elección. (El orden en el que genera los totales de monedas no importa, pero el valor total de la moneda (suma) debe ser el último elemento)

Ejemplos

 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

Reglas

Las lagunas estándar no están permitidas.

Este es el código de golf , por lo que gana el código más corto en bytes para cada idioma.

Python 2 , 73 bytes

-3 bytes gracias a @Rod

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

Pruébalo en línea!

Python 2 , 63 bytes

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

Pruébalo en línea!

Python 2 , 63 bytes

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

Pruébalo en línea!

APL (Dyalog Unicode) , 28 27 bytes

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

Pruébalo en línea!

Función tácita. Toma la entrada como un vector en el formato ,'<input>'.

Gracias a ngn por un byte!

¿Cómo?

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

Pruébalo en línea!

Toma la entrada como un vector de caracteres individuales. Los convierte factorsy tabulatelos envía, y luego calcula los valores con un producto de puntos.

Para facilitar la prueba, he agregado una forma de convertir los casos de prueba anteriores a la entrada que la función espera.

Esto apenas supera el almacenamiento de los nombres de las monedas como vectores names, lo que significa que el siguiente enfoque probablemente sería más golfista si tuviéramos más tipos de monedas:

R , 71 70 bytes

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

Pruébalo en línea!

Jalea , 19 bytes

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

Pruébalo en línea!

Cómo funciona

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

Guardado 2 bytes gracias a Shaggy

Toma entrada como una matriz de caracteres. Salidas P,N,D,Q,total.
Inspirado por la respuesta Python de ovs .

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

Pruébalo en línea!

Respuesta original, 73 bytes

Toma entrada como una matriz de caracteres. Salidas 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

Pruébalo en línea!

MATL , 22 20 bytes

!'PNDQ'=Xst[l5X25]*s

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación con ejemplo

Considere la entrada 'PNNDNNQPDNPQND'como un ejemplo. El contenido de la pila se muestra al revés, es decir, el elemento superior aparece debajo.

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

Guardado 3 bytes gracias a @Shaggy

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

¡Pruébalo en línea! Toma entrada en minúsculas

Explicación

`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 (versión en idioma polaco), 150 bytes

La entrada está en A1. Las fórmulas están en celdas 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

resultante de la producción de número de cuartos, monedas de diez centavos, monedas de cinco centavos, pennys y la suma en las células B1, C1, D1, E1y F1respectivamente.

Versión en inglés (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 guardados gracias a Adam

Solicita la entrada en pantalla de la cadena de monedas.

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

05AB1E , 30 26 22 21 19 bytes

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

Pruébalo en línea!

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.

Tugurio:

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]

Salida impresa:

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

Como se imprimió algo, se ignora la pila final.

J , 29 bytes

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

Pruébalo en línea!

Explicación:

'PNDQ'=/] crea una tabla de igualdad

   '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#. encuentra la suma de cada fila de la tabla, por lo tanto, el número de ocurrencias de cada valor

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

1#.* encuentra el producto punto de su argumento izquierdo y derecho

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

], agrega el producto punto a la lista de valores

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

C # (.NET Core) , 163 136 bytes

¡Gracias a @raznagul por guardar muchos bytes allí!

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

Pruébalo en línea!

Versión antigua:

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

Pruébalo en línea!

Perl 5 -pF , 59 bytes

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

Pruébalo en línea!

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}

Pruébalo en línea!

No es bueno.

05AB1E , 19 bytes

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

Pruébalo en línea!

Explicación

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

Pruébalo en línea!

Bueno, es solo un byte más corto que el otro envío de Java, pero bueno, más corto es más corto: D

Explicación:

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

Pruébalo en línea!

El formato de salida es [P Q N D Value].

Cómo funciona

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

Pruébalo en línea!

Pyth, 23 27 26 bytes

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

Guardado un byte gracias a @RK. Salidas como [P, N, D, Q, valor].
Pruébalo aquí

Explicación

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

Pruébalo en línea!

La secuencia de salida ahora es P, Q, D, N, valor total
Funciona con entradas en minúsculas y mayúsculas.

Explicación:

"AYJE"o {64+1,64+25,64+10,64+5}es 64 + valor de la moneda.
d=(c|c/2)&3(utilizado como índice) tiene valor 1,2,3,0para las q,d,n,pentradas respectivamente, tanto en mayúsculas como en minúsculas.

C # (.NET Core) , 156 bytes

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

Pruébalo en línea!

Retina , 50 bytes

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

Pruébalo en línea! Salidas en el orden D, N, P, Q, total. Explicación:

P
P_
N
N5*
D
D10*
Q
Q25*

Calcule el total insertando _s correspondiente al valor de cada moneda.

^
PNDQ_

Inserte una copia adicional de cada personaje para que haya al menos uno de cada uno que coincida.

O`.

Ordena los personajes en orden.

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

Cuente el número de cada personaje después del primero.

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

Ejemplo:

? PNDNDNDQP
2   3   3   1   72

Explicación:

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

Pruébalo en línea!

C no tiene matrices asociativas, así que lo falsifico (¡muy ineficientemente, en cuanto a memoria!) Y luego vuelvo a recorrerlo con una matriz de búsqueda para sumar las monedas. Sin embargo, no calculará moneda extranjera :-)