जिपर गुणा

Question

परिचय

आइए एक नए अंकगणितीय ऑपरेशन को परिभाषित करें, जिसे मैं ज़िपर गुणा कहता हूं । जिपर को दो nonnegative पूर्णांक से गुणा करने के लिए, आप लंबाई मिलान करने के लिए अग्रणी शून्य जोड़ते हैं, संख्याओं के संगत आधार -10 अंकों को गुणा करते हैं, परिणाम के लिए अग्रणी शून्य जोड़ते हैं, 2-अंकीय संख्या प्राप्त करते हैं, उन्हें समेटते हैं, और अंत में अग्रणी शून्य छोड़ते हैं।

यहाँ A = 1276 और B = 933024 के साथ एक उदाहरण दिया गया है :

1. Add leading zeros
 A = 001276
 B = 933024

2. Multiply digit-wise
 A = 0  0  1  2  7  6
 B = 9  9  3  0  2  4
 ->  0  0  3  0 14 24

3. Pad to 2 digits
 -> 00 00 03 00 14 24

4. Concatenate
 -> 000003001424

5. Drop leading zeros
 -> 3001424

ऑपरेशन सामान्य साइन नियमों के साथ सभी पूर्णांकों तक विस्तारित होता है: सकारात्मक समय नकारात्मक नकारात्मक है, नकारात्मक समय नकारात्मक सकारात्मक है और इसी तरह।

काम

आपके इनपुट दो पूर्णांक हैं, और आपका आउटपुट उनका जिपर गुणन है। आपको मनमाने ढंग से बड़े इनपुट को संभालने में सक्षम होना चाहिए। इनपुट और / या आउटपुट स्ट्रिंग प्रारूप में हो सकता है (और वास्तव में होना चाहिए, यदि आपकी भाषा मनमाने ढंग से बड़े पूर्णांक का समर्थन नहीं करती है)। ध्यान दें कि -0एक वैध इनपुट या आउटपुट नहीं है।

नियम और स्कोरिंग

आप एक पूर्ण प्रोग्राम या फ़ंक्शन लिख सकते हैं, और सबसे कम बाइट काउंट जीतता है।

परीक्षण के मामलों

0 0 -> 0
302 40 -> 0
302 -40 -> 0
-4352 448 -> -122016
0 6623 -> 0
0 -6623 -> 0
20643 -56721 -> -1000420803
63196 21220 -> 1203021800
1276 933024 -> 3001424
-1276 933024 -> -3001424
-1276 -933024 -> 3001424
5007204555 350073039 -> 12001545
-612137119 -8088606033 -> 816060042000327
3389903661 -6619166963 -> -18180881090018543603
-23082746128560880381 1116941217 -> -8050600723200060807
-668336881543038127783364011867 896431401738330915057436190556 -> -485448120906320001351224000900090235004021121824000900403042
402878826066336701417493206805490000415 312487283677673237790517973105761463808 -> 120004325656161618004242182118140007280900200921180018080025285400000000320040

Answer 1

जेली , 11 10 बाइट्स

ƓDUz0P€Uḅ³

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

मैं इसे अपने आप से 10 बाइट्स तक नहीं पहुंचा सका, लेकिन @ Pietu1998 ने मुझे एक परमाणु के लिए इशारा किया, जो मुझे याद है, इसने 10-बाइट समाधान दिया। जेली के लिए असामान्य रूप से, यह मानक इनपुट (फॉर्म में 1276,933024) से इनपुट लेता है , कमांड लाइन से नहीं (यह कमांड के उपयोग को सक्षम करता है ³, जो कमांड लाइन तर्क को लौटाता है, 100 के लिए डिफ़ॉल्ट)।

स्पष्टीकरण:

ƓDUz0P€Uḅ³
Ɠ           read standard input
 D          convert to base 10
  U         reverse elements
   z0       transpose, padding the end with zeroes
     P€     take the product of each (€) inner list
       U    reverse elements back
        b³  convert from base 100

बेस 100 का उपयोग "पैड टू 2 अंकों को लागू करने का एक सरल तरीका है, फिर बेस 10" तकनीक में परिवर्तित करें। यहाँ केवल दूसरी सूक्ष्म बात ही उलट है; हम संख्या की शुरुआत में शून्य के साथ पैड करना चाहते हैं, लेकिन zअंत में जेली का कमांड पैड है, इसलिए सूचियों को उलटने का मतलब है कि zसही ढंग से पैड होगा।

Comments

आप 10 बाइट्स प्राप्त करने के b⁵साथ बदल सकते हैं D। : पी

— पुरकाकूदरी

Answer 2

पायथन 2, 99 बाइट्स

a,b=input();o=0;p=1-2*(a*b<0);a,b=abs(a),abs(b)
while a:o+=a%10*(b%10)*p;p*=100;a/=10;b/=10
print o

नकारात्मक इनपुट के मामले में संकेत के लिए बहुत सारे बाइट्स हैं। पाइथन में, n%dहमेशा गैर-नकारात्मक होता dहै यदि सकारात्मक ^{1 है} । मेरी राय में यह आम तौर पर वांछनीय है, लेकिन यहां यह असुविधाजनक लगता है: कॉल को हटाने absसे उपरोक्त कोड टूट जाएगा। इस बीच p"स्थान मान" (लोगों, सैकड़ों, आदि) का ट्रैक रखता है और आउटपुट के वांछित संकेत को भी याद रखता है।

कोड मूल रूप से aऔर bसिवाय इस whileस्थिति में सममित है : हम तब तक चलते रहते हैं जब तक aकि शून्य न हो, और उस समय समाप्त हो जाए। बेशक अगर bपहले शून्य है, तो हम aशून्य को थोड़ी देर के लिए जोड़ देंगे, जब तक कि शून्य शून्य न हो ।

---

¹ उदाहरण के लिए, (-33)%10रिटर्न 7, और पूर्णांक भागफल (-33)/10है -4। यह सही है क्योंकि है (-4)*10 + 7 = -33। हालांकि, के ज़िपर उत्पाद (-33)के साथ 33में समाप्त होना चाहिए 3*3 = 09बजाय 7*3 = 21।

Answer 3

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

f=(x,y)=>x&&f(x/10|0,y/10|0)*100+x%10*(y%10)

आसानी से यह स्वचालित रूप से नकारात्मक संख्याओं के लिए काम करता है।

Comments

@ जाकुब मैं हमेशा ऐसा कर रहा हूं, हालांकि कम से कम मैंने f=बाइट की गिनती में शामिल किया । इसके अलावा, यह |0है कि मुझे पूर्णांक विभाजन की आवश्यकता है, मुझे नहीं पता कि आपको कैसे लगता है कि आपको इसके बिना सही उत्तर मिल रहा है।

— नील

आह, यह समझ में आता है। अब निकालते समय मुझे गलत उत्तर भी मिले |0। हो सकता है कि नए फ़ंक्शन का f के लिए पुन: असाइनमेंट काम न करे और मैंने अभी भी पुराने संस्करण का परीक्षण किया हो |0।

— जकुबे

Answer 4

सी, 77 बाइट्स

निरर्थक ब्रेसिज़ ( *साहचर्य) को हटाने के लिए -2 बाइट्स ।

r,t;f(a,b){t=1;r=0;while(a|b)r+=t*(a%10)*(b%10),a/=10,b/=10,t*=100;return r;}

t= 1,100,10000, ... का उपयोग पेडिंग के लिए किया जाता है। जब तक aया bशून्य पिछले अंक multiplicating रखें नहीं है %10के साथ tऔर संचित। फिर ( ) ( ) के अंतिम अंक aऔर 2 अंकों ( ) द्वारा स्थानांतरित करें । b/=10t*=100

अधूरा और उपयोग:

r,t;
f(a,b){
 t=1;
 r=0;
 while(a|b)
  r+=t*(a%10)*(b%10),
  a/=10,
  b/=10,
  t*=100;
 return r;
}

main(){
 printf("%d\n", f(1276,933024));
}

Comments

के for(r=0;a|b;t*=100)r+=a%10*t*(b%10),a/=10,b/=10बजाय सुझावr=0;while(a|b)r+=t*(a%10)*(b%10),a/=10,b/=10,t*=100

— छत

Answer 5

दरअसल , 23 19 बाइट्स

इनपुट को दो तारों के रूप में लिया जाता है। इसके अलावा, जाहिरा तौर पर आधार 100 से बदलने की कोशिश की जा रही है, क्योंकि ais523 उनके जेली जवाब में करता है, वास्तव में इतनी अच्छी तरह से काम नहीं करता है। अगर यह काम किया है तो 9 बाइट्स बचा सकता है: / गोल्फ सुझाव का स्वागत करते हैं! इसे ऑनलाइन आज़माएं!

संपादित करें: परिणाम को एक नई संख्या में कैसे बनाया जाता है इसे बदलने से -4 बाइट्स।

k`♂≈R`M┬ñ`iτ╤@π*`MΣ

Ungolfing

          Implicit input a and b.
k         Wrap a and b into a list.
`...`M    Map over the list of strings.
  ♂≈        Convert each digit to its own int.
  R         Reverse for later.
┬         Transpose to get pairs of digits from a and b.
ñ         enumerate(transpose) to get all of the indices as well.
`...`M    Map over the transpose.
  i         Flatten (index, pair) onto the stack.
  τ╤        Push 10**(2*index) == 100**index to the stack.
  @π        Swap and get the product of the pair of integers.
  *         Multiply the product by 100**index.
Σ         Sum everything into one number.
          Implicit return.

Answer 6

गणितज्ञ 66 बाइट्स

i=IntegerDigits;p=PadLeft;FromDigits@Flatten@p[i/@Times@@p[i/@#]]&

Ungolfed:

IntegerDigits/@{1276,933024}
PadLeft[%]
Times@@%
IntegerDigits/@%
PadLeft[%]
Flatten@%
FromDigits@%

जहां% का मतलब है पिछले आउटपुट की पैदावार

{{1,2,7,6},{9,3,3,0,2,4}}
{{0,0,1,2,7,6},{9,3,3,0,2,4}}
{0,0,3,0,14,24}
{{0},{0},{3},{0},{1,4},{2,4}}
{{0,0},{0,0},{0,3},{0,0},{1,4},{2,4}}
{0,0,0,0,0,3,0,0,1,4,2,4}
3001424

Answer 7

आर, 182 110 107 86 बाइट्स

अब सबसे लंबे समय तक जवाब (धन्यवाद, रैकेट), और वास्तव में अजगर समाधान (एक दुर्लभ इलाज) की तुलना में कम है! एक अनाम फ़ंक्शन जो इनपुट के रूप में दो पूर्णांक लेता है।

function(a,b)sum((s=function(x)abs(x)%%10^(99:1)%/%(e=10^(98:0))*e)(a)*s(b))*sign(a*b)

यहां देखिए यह कैसे काम करता है।

जिपर गुणन में इनपुट संख्या को उनके घटक अंकों में विभाजित करना शामिल है। हम संख्या का निरपेक्ष मान लेते हैं और 10 की अवरोही शक्तियों के लिए मोडुलो को ले जाते हैं:

abs(x) %% 10^(99:1)

इसलिए यहां हम एक नंबर ले रहे हैं x, और 99 अन्य नंबरों ( 10^99माध्यम से 10^1) के साथ मोड्यूलो को लागू कर रहे हैं । स्पष्ट रूप से x99 बार दोहराता है, एक वेक्टर (सूची) को 99 तत्वों के साथ वापस करता है। ( x %% 10^99, x %% 10^98, x %% 10^97, आदि)

हम के 10^99माध्यम से उपयोग करें 10^1। एक अधिक कुशल कार्यान्वयन सबसे अधिक संख्या में अंकों की संख्या के मूल्य का उपयोग करेगा (इस पोस्ट के संपादित इतिहास की जांच करें; पिछले संस्करणों ने ऐसा किया था), लेकिन बस 99..1कम बाइट्स का उपयोग करता है।

इसके लिए x = 1276हमें देता है

1276 1276 1276 ... 1276 276 76 6

इसके बाद, हम संख्याओं को पूरा करने के लिए 10 की शक्तियां नीचे करके पूर्णांक विभाजन का उपयोग करते हैं:

abs(x) %% 10^(99:1) %/% 10^(98:0)

यह प्रदान करता है

0 0 0 ... 1 2 7 6

हम चाहते हैं कि वास्तव में प्रतिनिधित्व है। कोड में, हम 10^(98:0)बाद में फिर से उपयोग करना चाहते हैं , इसलिए हम इसे एक चर पर नियत करते हैं:

abs(x) %% 10^(99:1) %/% (e = 10^(98:0))

(आर में कोष्ठक में एक अभिव्यक्ति लपेटना आम तौर पर अभिव्यक्ति का मूल्यांकन करता है (इस मामले में, मान प्रदान 10^(98:0)करता है e), और फिर अभिव्यक्ति का आउटपुट भी लौटाता है, जिससे हम अन्य गणनाओं के भीतर चर असाइनमेंट को एम्बेड कर सकते हैं।)

इसके बाद, हम इनपुट में अंकों के जोड़ो को गुणा करते हैं। फिर आउटपुट को दो अंकों में बांधा जाता है और समवर्ती किया जाता है। दो अंकों और पैडिंग के लिए पैडिंग प्रत्येक संख्या को गुणा करने के बराबर है 10^n, जहां nदाहिने किनारे से दूरी है, और फिर सभी संख्याओं को समेटें।

 A = 0         0         1         2         7         6
 B = 9         9         3         0         2         4
 ->  0         0         3         0        14        24
 -> 00        00        03        00        14        24
 ->  0*10^6 +  0*10^5 +  3*10^4 +  0*10^3 + 14*10^2 + 24*10^1
 =  000003001424

विशेष रूप से, क्योंकि गुणन सराहनीय है, हम गुणा को A से B से 10^n पहले गुणा कर सकते हैं । इसलिए, हम अपनी पिछली गणना लेते हैं और इसके द्वारा गुणा करते हैं :10^(98:0)

abs(x) %% 10^(99:1) %/% 10^(98:0) * 10^(98:0)

के बराबर है

abs(x) %% 10^(99:1) %/% (e = 10^(98:0)) * e

ए में इसे लागू करने के बाद , हम फिर बी पर इस पूरे ऑपरेशन को दोहराना चाहेंगे । लेकिन यह कीमती बाइट्स लेता है, इसलिए हम एक फ़ंक्शन को परिभाषित करते हैं, इसलिए हमें केवल एक बार इसे लिखना होगा:

s = function(x) abs(x) %% 10^(99:1) %/% (e=10^(98:0)) * e

हम एक ही समय में एक फ़ंक्शन को परिभाषित करने और लागू करने की अनुमति देने के लिए हमारे एम्बेडिंग-इन-कोष्ठक चाल करते हैं, इस फ़ंक्शन को ए और बी पर कॉल करने और उन्हें एक साथ गुणा करने के लिए। (हम इसे एक अलग लाइन पर परिभाषित कर सकते हैं, लेकिन क्योंकि हम अंततः इस सभी को एक अनाम फ़ंक्शन में डालने जा रहे हैं, अगर हमारे पास एक से अधिक कोड हैं तो सब कुछ घुंघराले ब्रेसिज़ में लपेटने की आवश्यकता है, जिसकी कीमत मूल्यवान है बाइट्स।)

(s = function(x) abs(x) %% 10^(99:1) %/% (e=10^(98:0)) * e)(a) * s(b)

और हम इस सब का योग लेते हैं, और हम लगभग समाप्त हो चुके हैं:

sum((s = function(x) abs(x) %% 10^(99:1) %/% (e=10^(98:0)) * e)(a) * s(b))

अब केवल विचार करने के लिए इनपुट का संकेत है। हम नियमित गुणन नियमों का पालन करना चाहते हैं, इसलिए यदि एक और केवल एक ए और बी में से नकारात्मक है, तो उत्पादन नकारात्मक है। हम उस फ़ंक्शन का उपयोग करते हैं signजो 1एक सकारात्मक संख्या -1दिए जाने पर और जब एक ऋणात्मक संख्या दी जाती है, तो एक गुणांक का उत्पादन करने के लिए जो हम अपनी गणना को गुणा करते हैं:

sum((s = function(x) abs(x) %% 10^(99:1) %/% (e=10^(98:0)) * e)(a) * s(b)) * sign(a * b)

अंत में, पूरी बात को उस अज्ञात फ़ंक्शन लेता में लपेटा जाता है aऔर bइनपुट के रूप में:

function(a, b) sum((s = function(x) abs(x) %% 10^(99:1) %/% (e=10^(98:0)) * e)(a) * s(b)) * sign(a * b)

व्हाट्सएप को हटा दें और यह 86 बाइट्स है।

Comments

यह बहुत अच्छा होगा यदि आप सभी के लाभ के लिए एक अनऑर्गनाइज्ड, समझाया गया संस्करण प्रदान कर सकते हैं।

— rnso

मैंने एक स्पष्टीकरण के साथ पोस्ट को अपडेट किया है।

— rturnbull

अच्छा काम। बहुत चालाक विधि का इस्तेमाल किया।

— rnso

Answer 8

पायथन 3 , 92 बाइट्स , 119 बाइट्स

lambda m,n:(1-(n*m<0)*2)*int(''.join([f"{int(a)*int(b):02}"for a,b in zip(str(abs(n))[::-1],str(abs(m))[::-1])][::-1]))

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

नकारात्मक संख्या को संभालने के लिए फिक्स 29 बाइट की लागत: /

Comments

अच्छा उत्तर! मुझे लगता है कि आप lstripसब कुछ अंदर लपेटकर int()और एक नंबर वापस करके भाग को बदल सकते हैं ।

— अरबो

आप सही हे। तब मुझे लगा कि एक सुसंगत इंटरफ़ेस रखना है। Int के बजाय तर्कों के रूप में लेते हुए, फिर एक int लौटाना मुझे अजीब लगता है;) मैंने एक नक्शा कॉल के लिए लूप के लिए zip + को बदलने की आशा की, लेकिन वह काम नहीं करेगा: /

— movatica

मैं कोड गोल्फ में स्थिरता के बारे में बहुत ज्यादा चिंता नहीं करूंगा, लेकिन यह आपके ऊपर है :)। यदि आप इसे करने के लिए एक अतिरिक्त भेड़ का बच्चा बनाने की आवश्यकता होगी, तो मैपिंग आमतौर पर पायथन में बहुत गोल्फ नहीं है।

— अरबो

यह फ़ंक्शन नकारात्मक इनपुट के लिए विफल प्रतीत होता है

— ArBo

आप सही कह रहे हैं: / यह फिक्स काफी महंगा है, हो सकता है कि इसे नीचे गिराने की क्षमता अधिक हो।

— movatica

Answer 9

पाइके, 16 बाइट्स

FY_),FBw�+`t)_sb

यहाँ कोशिश करो!

जहां Where बाइट है 0x84या132

Answer 10

PHP, 84 बाइट्स

for(list(,$a,$b)=$argv,$f=1;$a>=1;$a/=10,$b/=10,$f*=100)$r+=$a%10*($b%10)*$f;echo$r;

स्ट्रिंग संगति (86 बाइट्स) के साथ थोड़ा लंबा:

for(list(,$a,$b)=$argv;$a>=1;$a/=10,$b/=10)$r=sprintf("%02d$r",$a%10*($b%10));echo+$r;

Answer 11

रैकेट 325 बाइट्स

(let*((g string-append)(q quotient/remainder)(l(let p((a(abs a))(b(abs b))(ol'()))(define-values(x y)(q a 10))
(define-values(j k)(q b 10))(if(not(= 0 x j))(p x j(cons(* y k)ol))(cons(* y k)ol)))))(*(string->number
(apply g(map(λ(x)(let((s(number->string x)))(if(= 2(string-length s)) s (g "0" s))))l)))(if(<(* a b)0)-1 1)))

Ungolfed:

(define (f a b)
  (let* ((sa string-append)
         (q quotient/remainder)
         (ll (let loop ((a (abs a))
                        (b (abs b))
                        (ol '()))
               (define-values (x y) (q a 10))
               (define-values (j k) (q b 10))
               (if (not(= 0 x j))
                   (loop x j (cons (* y k) ol))
                   (cons (* y k) ol)))))
    (*(string->number (apply sa
                             (map (λ (x)
                                    (let ((s (number->string x)))
                                      (if (= 2 (string-length s))
                                          s
                                          (sa "0" s))))
                                  ll)))
      (if (< (* a b) 0) -1 1))))

परिक्षण:

(f 1276 933024)
(f 302 40)
(f 0 6623)
(f 63196 21220)
(f 20643 -56721)

आउटपुट:

3001424
0
0
1203021800
-1000420803

Answer 12

पॉवरशेल , 153 151 बाइट्स

param($a,$b)do{$x,$y=$a[--$i],$b[$i]|%{if($_-eq45){$s+=$_;$_=0}$_}
$r=(+"$x"*"$y"|% t*g "00")+$r}while($x+$y)$s+$r-replace'(?<!\d)0+(?=\d)|--|-(?=0+$)'

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

कम गोल्फ वाला:

param($a,$b)
do{
    $x,$y=$a[--$i],$b[$i]|%{
        if($_-eq45){                                # [char]45 is '-'
            $signs+=$_
            $_=0
        }
        $_                                          # a digit or $null
    }
    $res=(+"$x"*"$y"|% toString "00")+$res          # "00" is the custom format to get 2-digit number
}
while($x+$y)
$signs+$res-replace'(?<!\d)0+(?=\d)|--|-(?=0+$)'    # cleanup and return

Answer 13

पर्ल 5 -MList::Util=min , 140 बाइट्स

@a=<>=~/\S/g;@F=<>=~/\S/g;$q=1+min$#a,$#F;say+('-'x("@a@F"=~y/-//%2).sprintf'%02d'x$q,map$F[$_]*$a[$_],-$q..-1)=~s/^-?\K0+//r=~s/^-0*$//r||0

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