इलेक्ट्रॉनिक गुल्लक

11

एक गुल्लक में संकलित करें सिक्के करने के लिए इस्तेमाल एक कंटेनर है इस चुनौती चार अमेरिकी सिक्के का उपयोग करें:। तिमाही, पैसा भी, निकल, और पैसा ।

चुनौती

आपकी चुनौती इलेक्ट्रॉनिक गुल्लक बनाने की है। एक प्रोग्राम (या फ़ंक्शन) लिखें, जब रन (या कहा जाता है), आउटपुट (या रिटर्न) आपके पास मौजूद प्रत्येक सिक्के की गिनती, साथ ही सिक्कों की कुल राशि।

इनपुट

आपके गुल्लक (केस असंवेदनशील) में सिक्कों की एक स्ट्रिंग, सरणी, आदि ... (आपकी पसंद)।

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

उत्पादन

अपनी पसंद के गैर-पूर्णांक सीमांकक द्वारा अलग किए गए इनपुट और कुल राशि के सिक्कों की गिनती। (जिस क्रम में आप सिक्के के योग का उत्पादन करते हैं वह कोई मायने नहीं रखता है, लेकिन कुल सिक्का मूल्य (योग) अंतिम तत्व होना चाहिए)

उदाहरण

 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

नियम

मानक खामियों की अनुमति नहीं है।

यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा के लिए बाइट्स में सबसे छोटा कोड जीत जाता है!

code-golf 
— DevelopingDeveloper
स्रोत
1
@ शैगी हाँ, आप कर सकते हैं
— विकासशील
1
कुल में सिक्कों का क्रम । क्या हम इसे इनपुट में उपस्थिति के क्रम में दे सकते हैं?
— आदम
1
यदि इनपुट से आदेश का अनुमान लगाया जा सकता है, तो क्या हम 0s से बाहर हो सकते हैं? यह अभी भी स्पष्ट होगा कि प्रत्येक संख्या किन अक्षरों को संदर्भित करती है।
— अड्म
1
क्या यह आउटपुट स्वरूप बहुत दूर है? 19 बाइट का जवाब है कि मुझे यकीन नहीं है कि यह वैध है: इसे ऑनलाइन आज़माएं!
— मैजिक ऑक्टोपस Urn
1
मुझे ऐसा लगता है कि एक [पैसा] टैग होना चाहिए।
— 12M2121

जवाबों:

4

एपीएल (डायलॉग यूनिकोड) , 28 27 बाइट्स

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

इसे ऑनलाइन आज़माएं!

टैसिट फ़ंक्शन। प्रारूप में एक वेक्टर के रूप में इनपुट लेता है ,'<input>'।

एक बाइट के लिए ngn के लिए धन्यवाद!

कैसे?

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.
— जे। सल्ल
स्रोत
1⊥∘.=∘'PNDQ'->'PNDQ'+.=¨⊂
— ngn
4

आर , 70 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्यक्तिगत पात्रों के वेक्टर के रूप में इनपुट लेता है। उन्हें धर्मान्तरित करता है factorsऔर tabulateउन्हें बताता है, फिर एक डॉट उत्पाद के साथ मूल्यों की गणना करता है।

परीक्षण के उद्देश्यों में आसानी के लिए, मैंने ऊपर दिए गए परीक्षण मामलों से इनपुट में बदलने का एक तरीका जोड़ा है जो फ़ंक्शन की अपेक्षा कर रहा है।

यह सिक्के के नामों को वेक्टर के रूप में संग्रहीत करता है names, जिसका अर्थ है कि नीचे का दृष्टिकोण गोल्फ खिलाड़ी होगा यदि हमारे पास कोई सिक्का नहीं है:

आर , 71 70 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— ग्यूसेप
स्रोत
3

जेली , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

ċЀ“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
स्रोत
3

जावास्क्रिप्ट (ईएस 6), 63 61 बाइट्स

झबरा के लिए धन्यवाद 2 बाइट्स बचाता है

वर्णों के एक सरणी के रूप में इनपुट लेता है। आउटपुट P,N,D,Q,total। ओव्स पायथन जवाब
से प्रेरित है ।

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

इसे ऑनलाइन आज़माएं!

मूल उत्तर, 73 बाइट्स

वर्णों के एक सरणी के रूप में इनपुट लेता है। आउटपुट 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

इसे ऑनलाइन आज़माएं!

— Arnauld
स्रोत
बहुत अच्छी तरह से किया! आप आसपास कुछ सामान फेरबदल करके 2 बाइट्स खटखटा सकते हैं ।
— शैगी
3

MATL , 22 20 बाइट्स

!'PNDQ'=Xst[l5X25]*s

इसे ऑनलाइन आज़माएं! या सभी परीक्षण मामलों को सत्यापित करें ।

उदाहरण के साथ स्पष्टीकरण

'PNNDNNQPDNPQND'उदाहरण के रूप में इनपुट पर विचार करें । स्टैक सामग्री को उल्टा दिखाया गया है, अर्थात शीर्ष तत्व नीचे दिखाई देता है।

!        % 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
— लुइस मेंडो
स्रोत
!'PNDQ'=Xst[l5X25]!Y*21 बाइट्स है। हालाँकि मैं मानता हूँ कि मैंने इसका परीक्षण नहीं किया है।
— ग्यूसेप
@Giuseppe धन्यवाद, लेकिन चुनौती कहते हैं, " अपनी पसंद के गैर पूर्णांक सीमांकक", इसलिए मुझे लगता है केवल एक सीमांकक अनुमति दी है
— लुइस Mendo
मैंने उस पर ध्यान नहीं दिया था। ठीक है।
— ग्यूसेप
1
मुझे लगता है कि 21 बाइट समाधान ठीक है ... ओपी ने उस प्रभाव के बारे में कुछ टिप्पणी की
— ग्यूसेप
@Giuseppe बढ़िया! नीचे 20 बाइट्स के लिए। हेड-अप के लिए धन्यवाद
— लुइस मेंडो
3

जाप , 25 22 बाइट्स

@ बस्ती के लिए 3 बाइट्स को सहेजा गया

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

इसे ऑनलाइन टेस्ट करें! लोअरकेस में इनपुट लेता है

व्याख्या

`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
स्रोत
कॉमा को दूर भगाने का एक तरीका जानने की कोशिश की जा रही है, जिसमें अब तक ज्यादा किस्मत नहीं है।
— शैगी
— Shaggy
और लोअरकेस में इनपुट लेकर एक और बाइट बचाएं ।
— झबरा
— झबरा
@ शगुन प्रभावशाली, धन्यवाद!
— ETHproductions
3

एक्सेल (पोलिश भाषा संस्करण), 150 बाइट्स

इनपुट A1 में है। सूत्र कोशिकाओं में हैं : 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

और क्वार्टर, ऑफ डाइम्स, nickels, Pennys की संख्या कोशिकाओं में योग के उत्पादन में जिसके परिणामस्वरूप B1, C1, D1, E1और F1क्रमशः।

अंग्रेजी भाषा संस्करण (162 बाइट्स):

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
स्रोत
3

एपीएल + विन, 33 27 बाइट्स

5 बाइट्स ने एडम को धन्यवाद दिया

सिक्का स्ट्रिंग के स्क्रीन इनपुट के लिए संकेत।

n,+/1 5 10 25×n←+⌿⎕∘.='PNDQ'
— ग्राहम
स्रोत
5 बाइट्स बचाएं:n,+/1 5 10 25×n←+⌿⎕∘.='PNDQ'
— Adám
@ngn धन्यवाद वृद्धावस्था मेरे लिए बेहतर हो रही है :(
— ग्राहम
2

05AB1E , 30 26 22 21 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

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.

डंप:

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]

मुद्रित आउटपुट:

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

क्योंकि कुछ मुद्रित किया गया था, समाप्त होने वाले स्टैक को अनदेखा किया गया है।

— जादू ऑक्टोपस Urn
स्रोत
2

जे , 29 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्पष्टीकरण:

'PNDQ'=/] एक समानता तालिका बनाता है 

   '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#. तालिका की प्रत्येक पंक्ति का योग पाता है, इस प्रकार प्रत्येक मान की घटनाओं की संख्या

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

1#.* अपने बाएँ और दाएँ तर्क का डॉट उत्पाद पाता है

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

], मूल्यों की सूची में डॉट उत्पाद जोड़ता है

   1 5 10 25(],1#.*)1#.'PNDQ'=/] 'PNNDNNQPDNPQND'
3 6 3 2 113
— गैलेन इवानोव
स्रोत
2

सी # (.NET कोर) , 163 136 बाइट्स

वहाँ बाइट्स की एक बहुत बचाने के लिए @raznagul के लिए धन्यवाद!

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

इसे ऑनलाइन आज़माएं!

पुराना संस्करण:

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

इसे ऑनलाइन आज़माएं!

— इयान एच।
स्रोत
1
मैंने आपकी आत्मा को 136 बाइट्स तक नीचे गिराने में कामयाबी हासिल की है । सूची में कई बदलाव करने के लिए।
— राजनागुल
@raznagul महान समाधान! क्या मैं पूछ सकता हूं कि आपने एरे के बजाय जेनेरिक सूची में इनपुट क्यों स्विच किया? AFAIK आप एक सूची का उपयोग किए बिना एक स्ट्रिंग के पात्रों पर पुनरावृति कर सकते हैं।
— इयान एच।
यह पुराने संस्करण का एक अवशेष है, इसलिए मैं n.Countइसके बजाय उपयोग कर सकता था n.Length। जैसा कि पूरी तरह से गिरा दिया गया था stringअब आप उपयोग कर सकते हैं।
— raznagul
1

05AB1E , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!

व्याख्या

"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
स्रोत
1

जावा (ओपनजेडके 8) , 148 बाइट्स

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

इसे ऑनलाइन आज़माएं!

वैसे यह अन्य जावा सबमिशन की तुलना में केवल एक बाइट से छोटा है , लेकिन हे - शार्ट से छोटा है: डी

स्पष्टीकरण:

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
स्रोत
— सीलिंगकैट
1

गोल> <> , 47 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आउटपुट स्वरूप है [P Q N D Value]।

यह काम किस प्रकार करता है

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
स्रोत
1

पायथ, 23 27 26 बाइट्स

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

@RK को एक बाइट धन्यवाद दिया। [पी, एन, डी, क्यू, मूल्य] के रूप में आउटपुट।
इसे यहाँ आज़माएँ

व्याख्या

+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.
आप जम्मू की परिभाषा और जम्मू का सर्वप्रथम प्रयोग पाने के लिए गाढ़ा कर सकते हैं+Jm/Qd"PNDQ"s.b*NYJ[h05T25
— आर।
1

सी (क्लैंग) , 112 बाइट्स

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

इसे ऑनलाइन आज़माएं!

आउटपुट seq अब P, Q, D, N, कुल-मान
दोनों लोअर-केस और अपर-केस इनपुट्स के साथ काम करता है।

स्पष्टीकरण:

"AYJE"या {64+1,64+25,64+10,64+5}है। 64 + मूल्य के- सिक्का।
d=(c|c/2)&3(इंडेक्स के रूप में प्रयुक्त) ऊपरी और निचले दोनों मामलों में क्रमशः इनपुट के 1,2,3,0लिए मूल्य है q,d,n,p।

— GPS
स्रोत
— सीलिंगकैट
सिमटते हुए c = 0 अच्छी पकड़ थी। धन्यवाद।
— जीपीएस
0

सी # (.NET कोर) , 156 बाइट्स

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
स्रोत
0

रेटिना , 50 बाइट्स

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

इसे ऑनलाइन आज़माएं! डी, एन, पी, क्यू, कुल में आउटपुट। स्पष्टीकरण:

P
P_
N
N5*
D
D10*
Q
Q25*

_प्रत्येक सिक्के के मूल्य के अनुरूप एस लगाकर कुल की गणना करें ।

^
PNDQ_

प्रत्येक वर्ण की एक अतिरिक्त प्रतिलिपि सम्मिलित करें ताकि मिलान करने के लिए प्रत्येक में से कम से कम एक हो।

O`.

वर्णों को क्रम में क्रमबद्ध करें।

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

पहले के बाद प्रत्येक वर्ण की संख्या गिनें।

— नील
स्रोत
0

स्माइलबासिक, 70 बाइट्स

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

उदाहरण:

? PNDNDNDQP
2   3   3   1   72

स्पष्टीकरण:

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
स्रोत
0

सी, 149 बाइट्स

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

इसे ऑनलाइन आज़माएं!

C के पास साहचर्य सरणियाँ नहीं हैं, इसलिए मैं इसे नकली करता हूं (सिक्कों को जोड़ने के लिए लुकअप एरे के साथ फिर से बहुत ही अक्षमता, स्मृति-वार!) और फिर लूप के माध्यम से। यह विदेशी मुद्रा की गणना नहीं करेगा, हालांकि :-)

— ErikF
स्रोत
— सीलिंगकैट
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.