Bir kumbara para toplamak için kullanılan bir konteynırdır. Bu meydan okuma için dört ABD parasını kullanın: çeyrek, kuruş, nikel ve kuruş .

Meydan okuma

Zorluğunuz elektronik bir kumbara oluşturmaktır. Çalıştırıldığında (veya çağrıldığında), sahip olduğunuz her bir paranın sayısını ve aynı zamanda jetonların toplam tutarını veren (veya döndüren) bir program (veya işlev) yazın.

Giriş

Kumbara içine bir dize, dizi, vb ... (seçim) (büyük / küçük harf duyarsız).

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

Çıktı

Girdiğiniz jeton sayısı ve seçtiğiniz tamsayı olmayan sınırlayıcı ile ayrılmış toplam miktar. (Bozuk para toplamlarını verdiğiniz sıra önemli değildir, ancak toplam bozuk para değeri (toplam) son öğe olmalıdır)

Örnekler

 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

kurallar

Standart boşluklara izin verilmez.

Bu kod golf , bu yüzden her dil için bayt olarak en kısa kod kazanır!

Python 2 , 73 bayt

@Rod sayesinde -3 bayt

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

Çevrimiçi deneyin!

Python 2 , 63 bayt

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

Çevrimiçi deneyin!

Python 2 , 63 bayt

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

Çevrimiçi deneyin!

APL (Dyalog Unicode) , 28 27 bayt

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

Çevrimiçi deneyin!

Tacit işlevi. Girişi vektör formatında alır ,'<input>'.

Bir bayt için ngn'e teşekkürler!

Nasıl?

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 bayt

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

Çevrimiçi deneyin!

Girdiyi tek tek karakterlerin vektörü olarak alır. Onları dönüştürür factorsve tabulatesonra bir nokta ürünü ile değerleri hesaplar.

Test amacıyla, yukarıdaki test senaryolarından işlevin beklediği girişe dönüştürmenin bir yolunu ekledim.

Bu, madeni para isimlerini vektör olarak saklamaktan çok az atıyor names, bu da, daha fazla para türümüz olsaydı aşağıdaki yaklaşımın daha golfçü olacağı anlamına geliyor:

R , 71 70 bayt

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

Çevrimiçi deneyin!

Jöle , 19 bayt

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

Çevrimiçi deneyin!

Nasıl çalışır

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

Shaggy sayesinde 2 bayt kaydedildi

Girişi bir karakter dizisi olarak alır. Çıktılar P,N,D,Q,total. Ovs'un Python cevabından
ilham aldı .

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

Çevrimiçi deneyin!

Orijinal cevap, 73 bayt

Girişi bir karakter dizisi olarak alır. Çıktılar 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

Çevrimiçi deneyin!

MATL , 22 20 bayt

!'PNDQ'=Xst[l5X25]*s

Çevrimiçi deneyin! Veya tüm test senaryolarını doğrulayın .

Örnek ile açıklama

Girişi 'PNNDNNQPDNPQND'örnek olarak ele alalım. Yığın içeriği baş aşağı gösterilir, yani üst eleman aşağıda görünür.

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

@Shaggy sayesinde 3 bayt kaydedildi

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

Çevrimiçi test edin! Küçük harfle girdi alır

açıklama

`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 (Lehçe dil sürümü), 150 bayt

Giriş A1'dir. Formüller hücrelerde vardır 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

dörtte, Dimes, Paranın, Meteorological sayısı ve hücrelerde toplamının çıkış ile sonuçlanan B1, C1, D1, E1ve F1sırasıyla.

İngilizce dil sürümü (162 bayt):

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 bayt

Adam sayesinde 5 bayt kurtardı

Bozuk para dizesinin ekran girişi için bilgi istemleri.

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

05AB1E , 30 26 22 21 19 bayt

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

Çevrimiçi deneyin!

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.

Damperli:

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]

Yazdırılan Çıktı:

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

Bir şey yazdırıldığından, bitiş yığını yok sayılır.

J , 29 bayt

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

Çevrimiçi deneyin!

Açıklama:

'PNDQ'=/] bir eşitlik tablosu oluşturur

   '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#. tablonun her satırının toplamını, dolayısıyla her bir değerin gerçekleşme sayısını bulur

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

1#.* sol ve sağ argümanının nokta çarpımını bulur

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

], nokta ürünü değerler listesine ekler

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

C # (.NET Core) , 163 136 bayt

Orada çok byte tasarruf için @raznagul teşekkürler!

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

Çevrimiçi deneyin!

Eski versiyon:

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

Çevrimiçi deneyin!

Perl 5 -pF , 59 bayt

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

Çevrimiçi deneyin!

Ruby , 66 bayt

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

Çevrimiçi deneyin!

Harika değil.

05AB1E , 19 bayt

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

Çevrimiçi deneyin!

açıklama

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

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

Çevrimiçi deneyin!

Eh o daha sadece bir byte daha kısa diğer Java gönderiminden , ancak daha kısa: D

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

Çıktı biçimi [P Q N D Value] .

Nasıl çalışır

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 bayt

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

Çevrimiçi deneyin!

Pyth, 23 27 26 bayt

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

@RK sayesinde bir bayt kaydetti. [P, N, D, Q, değer] olarak çıktılar.
Burada deneyin

açıklama

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

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

Çevrimiçi deneyin!

Çıkış seq değeri şimdi P, Q, D, N, total-value
Hem küçük hem de büyük harf girişleriyle çalışır.

Açıklama:

"AYJE"veya {64+1,64+25,64+10,64+5}. 64 + değer-of-para.
d=(c|c/2)&3(indeks olarak kullanılır) sırasıyla hem büyük hem de küçük harf olmak 1,2,3,0üzere q,d,n,pgirdiler için değer içerir .

C # (.NET Core) , 156 bayt

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 bayt

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

Çevrimiçi deneyin!

Retina , 50 bayt

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

Çevrimiçi deneyin! D, N, P, Q sırasıyla toplam çıktılar. Açıklama:

P
P_
N
N5*
D
D10*
Q
Q25*

_Her madalyonun değerine karşılık gelen s ekleyerek toplamı hesaplayın .

^
PNDQ_

Her karakterin ek bir kopyasını ekleyerek her birinin en az bir tane eşleşmesini sağlayın.

O`.

Karakterleri sıraya göre sıralayın.

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

Birinciden sonraki her karakterin sayısını sayın.

SmileBASIC, 70 bayt

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

Misal:

? PNDNDNDQP
2   3   3   1   72

Açıklama:

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 bayt

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

Çevrimiçi deneyin!

C ilişkisel dizileri yok, bu yüzden sahte (çok verimsiz, bellek açısından!) Ve sonra paraları eklemek için bir arama dizisi ile tekrar döngü. Ancak, döviz hesaplamak olmaz :-)