किसी भी संख्या का उपयोग किए बिना दो संख्याओं को गुणा करें

30

आपको आधार 10 में सकारात्मक पूर्णांक का प्रतिनिधित्व करने वाले इनपुट दो तार दिए गए हैं, जैसे "12345"और "42"। आपका कार्य "518490"इस मामले में , उनके उत्पाद युक्त स्ट्रिंग को आउटपुट करना है ।

मोड़ यह है कि आप अपने कोड में किसी भी संख्यात्मक प्रकार का उपयोग नहीं कर सकते हैं। नहीं ints, floatएस, unsigned longएस, आदि, कोई अंतर्निहित जटिल संख्या प्रकार या मनमाने ढंग से सटीक पूर्णांक, या उन पंक्तियों के साथ कुछ भी नहीं। आप बहुत से उन प्रकारों के शाब्दिक उपयोग नहीं करते हैं, न ही कोई फ़ंक्शन, विधि, ऑपरेटर आदि जो उन्हें लौटाते हैं।

आप तार, बूलियन, सरणियों या किसी और चीज का उपयोग कर सकते हैं जो आमतौर पर किसी संख्या का प्रतिनिधित्व करने के लिए उपयोग नहीं किया जाएगा। (लेकिन ध्यान दें कि न तो किसी सरणी में अनुक्रमित करना और न ही इसकी लंबाई को एक संख्यात्मक प्रकार के आह्वान के बिना संभव हो सकता है।) की charअनुमति है, लेकिन आप उन पर कोई अंकगणित या बिटवाइज़ संचालन नहीं कर सकते हैं या अन्यथा उन्हें किसी अन्य के रूप में मान सकते हैं। एक स्ट्रिंग का एक टोकन प्रतिनिधित्व वाला हिस्सा। (एस की लेक्सोग्राफ़िक तुलना की charअनुमति है।)

आप प्रतिबंध के आसपास काम नहीं कर सकते हैं। इसमें किसी evalप्रकार के फ़ंक्शन के अंदर संख्यात्मक प्रकारों का उपयोग करना (लेकिन यह सीमित नहीं है) , संख्यात्मक प्रकारों में निहितार्थ रूपांतरणों का उपयोग करते हुए, गैर-संख्यात्मक प्रकारों पर संख्यात्मक या बिटवाइज़ ऑपरेटरों का उपयोग करके, जो उन्हें समर्थन करते हैं, कंटेनर प्रकारों के अंदर संग्रहीत संख्यात्मक प्रकारों का उपयोग करके, या कॉलिंग फ़ंक्शन या बाह्य प्रोग्राम जो संख्यात्मक परिणामों को स्ट्रिंग रूप में लौटाते हैं। (यदि उत्तर में अन्य वर्कअराउंड दिखाई देते हैं, तो मुझे इस सूची में शामिल होने का अधिकार सुरक्षित है।) आपको केवल गैर-संख्यात्मक प्रकारों का उपयोग करके गुणन को लागू करना होगा।

इनपुट और आउटपुट किसी भी सुविधाजनक विधि द्वारा हो सकता है, जब तक डेटा प्रवेश करता है और एक स्ट्रिंग के रूप में आपके कोड को बाहर निकालता है। आप मान सकते हैं कि दो में से प्रत्येक इनपुट तर्क में केवल ASCII वर्ण हैं [0-9]और इसके साथ शुरू नहीं होगा 0। आपके आउटपुट में अग्रणी शून्य नहीं होना चाहिए।

एक और बात: आपके कोड को सही ढंग से लंबाई में कम से कम 10 वर्णों तक इनपुट को सही ढंग से संभालना चाहिए , और उस सीमा में सभी इनपुट के लिए एक आधुनिक कंप्यूटर पर एक मिनट के भीतर चलना चाहिए । पोस्ट करने से पहले, कृपया जांच लें कि कब इनपुट दिया गया है और , आपका प्रोग्राम एक मिनट से भी कम समय में आउटपुट देता है । यह प्रतिबंध विशेष रूप से उन उत्तरों को रोकने के लिए मौजूद है, जो आकार की एक सरणी आवंटित करके और फिर उस पर पुनरावृत्ति करके काम करते हैं , इसलिए कृपया ध्यान रखें कि उस फॉर्म के उत्तर जीतने के योग्य नहीं होंगे।9999999999999999999999999999980000000001a*b

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध समाधान (बाइट्स में) जीतता है।

code-golf  restricted-source  arithmetic 
— नथानिएल
स्रोत
क्या हम "12345"STDIN के बजाय स्वीकार कर सकते हैं 12345? या हम दोनों संख्याओं को स्वीकार कर सकते हैं "12345", "42"?
— जस्टिन
मेरा पहला विचार था कि एक फ़ंक्शन लिखो जिसमें लंबाई के स्ट्रिंग तर्क हो और लंबाई mका nएक तर्क लौटाया जाए m*n। लेकिन जैसा कि स्ट्रिंग्स को संख्याओं के एएससीआईआई प्रतिनिधित्व का शाब्दिक अर्थ होता है, मुझे लगता है कि यह नियमों के खिलाफ है।
— लेवल रिवर सेंट
1
कई भाषाओं में @xnor सभी मामलों को लिखने के लिए छोटा हो सकता है। लेकिन मुझे पायथन में इस तरह से मिला:a,b="0123456789x".split('0');c=iter(b).next() if c=='x': c='0'
— नाथनियल
1
या पायथन 3 में,a,b="0123456789x".split(x);c,*d=b if c=='x': c='0'
— नाथनिएल
2
@ नथानियलd='123456789';I=dict(zip('0'+d,d+'0'))
— जस्टिन

जवाबों:

6

हास्केल - 180 206 214

r=reverse
f=filter
z=['0'..'9']
a?f|f="1"!a
a?_=a
(a:b)!(c:d)=e:b!d?(e<a)where e=fst$last$zip(f(>=c)z++z)$f(<=a)z
a!c=a++c
a%(b:c)=foldr(!)('0':a%c)$f(<b)z>>[a]
_%b=b
a#b=r$r a%r b

दोहराए गए जोड़ के माध्यम से गुणन गुणन, और सभी प्रकार के अंकों के जादू को ['0'..'9']सूची को स्थानांतरित करने और फ़िल्टर करने से नियंत्रित किया जाता है । #प्रकार के एक ऑपरेटर को परिभाषित करता है String -> String -> String:

*> :set +s
*> "9990123456789"#"9999876543210"
"99900001219316321126352690"
(0.02 secs, 9862288 bytes)
— mniip
स्रोत
लगता है, हमारे पास एक नया विजेता है! (हालांकि पहले की तरह, मैं परिष्कार की इस डिग्री के हास्केल को नहीं पढ़ सकता - क्या कोई स्वतंत्र रूप से इसकी जांच कर सकता है?)
— नथानिएल
(इसके अलावा [Also 0 ’..’ ९ ’] थोड़ा सा लगता है कि कथित तौर पर वर्णों को संख्याओं के रूप में माना जाता है जो कि पुनरावृत्त हो सकते हैं - क्या इसके बजाय" 0123456789 "स्ट्रिंग से उस सूची को उत्पन्न करने का एक छोटा तरीका है?)
— नटालिएल
@Nathaniel खैर सब से पहले स्ट्रिंग "0123456789" है सूची ['0'..'9']। दूसरा, हास्केल [ab] एक एन्यूमरेशन है, Enumटाइपसेकल्स के उदाहरणों को घोषित किया गया है, उस तरह से एन्यूमरेट किया जा सकता है, और घोषणा यह बताती है कि एन्यूमरेशन कैसे काम करता है। Bool, बूलियन प्रकार का भी एक उदाहरण है, और इसलिए आप भी कर सकते हैं [False..True]। इसमें बमुश्किल कोई संख्या शामिल है।
— मैनीप
14

सीड, 339 338 बाइट्स

मुझे पता है कि यह एक पुराना है, लेकिन मैं ब्राउज़ कर रहा था और इसने मेरी रुचि को बढ़ाया। वास्तव में एक उपयोगकर्ता के रूप में रजिस्टर करने के लिए पर्याप्त है! मुझे लगता है कि मैं " मैं एक पूर्ण sed समाधान - Nathaniel " देखना चाहते हैं द्वारा बह गया था ... 

s/[1-9]/0&/g
s/[5-9]/4&/g
y/8/4/
s/9/4&/g
s/4/22/g
s/[37]/2x/g
s/[26]/xx/g
s/[1-9]/x/g
:o
s/\( .*\)0$/0\1/
/x$/{
x
G
s/ .*/\n/
:a
s/\(.*\)0\(x*\)\n\(.*\)0\(x*\)\n/\1\n\3\n0\2\4/
ta
s/\n//g
:c
s/^x/0x/
s/0xxxxxxxxxx/x0/
tc
x
s/x$//
}
/ 0/bo
g
s/0x/-x/g
s/xx/2/g
y/x/1/
s/22/4/g
s/44/8/g
s/81/9/g
s/42/6/g
s/21/3/g
s/61/7/g
s/41/5/g
s/-//g

यह सेड लिपि दो दशमलव संख्याओं को इनपुट के रूप में लेती है, जो एक स्थान से अलग होती है

परीक्षण:

time test 518490 = $(./40297.sed <<<)"12345 42" || echo fail
time test 99999999980000000001 = $(./40297.sed <<<"9999999999 9999999999") || echo fail
time test 1522605027922533360535618378132637429718068114961380688657908494580122963258952897654000350692006139 = $(./40297.sed <<<"37975227936943673922808872755445627854565536638199 40094690950920881030683735292761468389214899724061") || echo fail
time test 1230186684530117755130494958384962720772853569595334792197322452151726400507263657518745202199786469389956474942774063845925192557326303453731548268507917026122142913461670429214311602221240479274737794080665351419597459856902143413 = $(./40297.sed <<<"33478071698956898786044169848212690817704794983713768568912431388982883793878002287614711652531743087737814467999489 36746043666799590428244633799627952632279158164343087642676032283815739666511279233373417143396810270092798736308917") || echo fail

आप पिछले दो को RSA-100 (50 x 50 अंक) और RSA-768 (116 x 116 अंक) के रूप में पहचान सकते हैं।

एक बहुत-आधुनिक (2007-युग इंटेल कोर 2) पर GNU sed का उपयोग करना, उनमें से अंतिम एक मिनट से अधिक समय लगता है, लेकिन यह एक नए प्रोसेसर पर तेजी से आता है:

  • Q6600:> 1 मिनट
  • i7-3770: 26 सेकंड
  • i7-6700: 22 सेकंड

प्रश्न में निर्दिष्ट 10-अंकों का गुणा इनमें से किसी पर भी एक दूसरे के तहत अच्छी तरह से होता है (पैथोलॉजिकल नाइन से भरा होने के बावजूद)।

मेरा मानना ​​है कि यह बिना किसी एक्सटेंशन के स्टैण्डर्ड सेड है। POSIX गारंटी केवल 8192 बाइट्स का स्थान रखता है, जो हमें 400x400 अंकों की संख्या को गुणा करने के लिए सीमित करता है, लेकिन कार्यान्वयन अधिक प्रदान कर सकता है। GNU sed केवल उपलब्ध मेमोरी द्वारा सीमित है, इसलिए यदि आप प्रतीक्षा करने के इच्छुक हैं, तो कुछ अधिक बड़ा प्रबंधित कर सकते हैं।

और मुझे विश्वास है कि मैंने नियमों का अनुपालन किया है - यह लगभग एक ऐसी भाषा में दिया गया है जिसकी कोई संख्या नहीं है। :-)

व्याख्या

मैं एक यूनिरी / दशमलव हाइब्रिड का उपयोग करता हूँ, दशमलव संख्याओं को एक सीरी के अनुक्रम में परिवर्तित करता है:

 42 => _xxxx_xx

एकात्मक दशमलव में, इसके अलावा आसान है। हम x को समाप्‍त करने के लिए कम से कम से सबसे महत्वपूर्ण अंकों तक पुनरावृति करते हैं:

   X=965                   Y=106                                 SUM
   _xxxxxxxxx_xxxxxx_xxxxx _x__xxxxxx
   _xxxxxxxxx_xxxxxx       _x_                          _xxxxxxxxxxx
   _xxxxxxxxx              _x                    _xxxxxx_xxxxxxxxxxx
                                      _xxxxxxxxxx_xxxxxx_xxxxxxxxxxx

फिर हम व्हाट्सएप को हटाते हैं, और अगली इकाई में से 10 लगातार x को परिवर्तित करके कैरी करते हैं:

 _xxxxxxxxxx_xxxxxx_xxxxxxxxxxx       10.6.11
 _xxxxxxxxxx_xxxxxxx_x                10.7.1
 _x__xxxxxxx_x                        1.0.7.1

एक बार हमारे पास होने के बाद, गुणा करना संभव है। हम y के अंतिम अंक पर विचार करके x * y को गुणा करते हैं। संचयकर्ता के लिए x को कई बार जोड़ें, फिर अगले अंक पर जाएं और x एक दशमलव स्थान को बाईं ओर स्थानांतरित करें। Y शून्य होने तक दोहराएं।

विस्तारित कोड

#!/bin/sed -f

# Convert to unary decimal.  We save two or three bytes of code by
# reusing 0 as the digit separator.
s/[1-9]/0&/g
s/[5-9]/4&/g
y/8/4/
s/9/4&/g
s/4/22/g
s/[37]/2x/g
s/[26]/xx/g
s/[1-9]/x/g

# until y==0

:one

# y ends in zero => x *= 10 and y /= 10
s/\( .*\)0$/0\1/

# while y%10, acc += x, y -= 1
/x$/{
x
G
s/ .*/\n/
# Add x
:add
s/\(.*\)0\(x*\)\n\(.*\)0\(x*\)\n/\1\n\3\n0\2\4/
tadd
s/\n//g
:carry
s/^x/0x/
s/0xxxxxxxxxx/x0/
tcarry

# repeat for each unit of y
x
s/x$//
}

# y?
/ 0/bone


# convert hold space to decimal
g
s/0x/-x/g
s/xx/2/g
y/x/1/
s/22/4/g
s/44/8/g
s/81/9/g
s/42/6/g
s/21/3/g
s/61/7/g
s/41/5/g
s/-//g
— टोबी स्पाईट
स्रोत
1
बहुत संतोषजनक जवाब, धन्यवाद!
— नाथनियल
9

सीड, 379 बाइट्स

इस शानदार उत्तर का श्रेय यूनिक्स और लिनक्स पर @LuigiTiburzi को जाता है । ईएसई: https://unix.stackexchange.com/a/37213/34061 मैंने अभी कुछ दिनों पहले इस पर ठोकर खाई थी:

s/[0-9]/<&/g
s/0//g
s/1/|/g
s/2/||/g
s/3/|||/g
s/4/||||/g
s/5/|||||/g
s/6/||||||/g
s/7/|||||||/g
s/8/||||||||/g
s/9/|||||||||/g
:t
s/|</<||||||||||/g
tt
s/<//g
s/.*\*$/0/
s/^\*.*/0/
s/*|/*/
:m
s/\(|*\)\*|/\1<\1*/
tm
s/*//g
s/<//g
:b
s/||||||||||/</g
s/<\([0-9]*\)$/<0\1/
s/|||||||||/9/
s/||||||||/8/
s/|||||||/7/
s/||||||/6/
s/|||||/5/
s/||||/4/
s/|||/3/
s/||/2/
s/|/1/
s/</|/g
tb

व्यापक व्याख्या

  • प्रत्येक अंक को अलग करें। इस प्रकार 12*3बन जाता है<1<2*<3
  • प्रत्येक अंक को |वर्णों की संख्या में परिवर्तित करें । इस प्रकार <1<2*<3बन जाता है<|<||*<|||
  • बार बार स्थानापन्न |<के साथ <||||||||||आदेश उच्च दशमलव स्थानों इकाइयों की स्थिति में सभी नीचे शिफ्ट करने में। इस प्रकार <|<||*<|||बन जाता है<||||||||||||*<|||
  • हटा दें <। इस प्रकार <||||||||||||*<|||बन जाता है||||||||||||*|||
  • |के RHS से 1 निकालें *। इस प्रकार ||||||||||||*|||बन जाता है||||||||||||*||
  • LHS पर |सभी के साथ RHS पर बार-बार बदलें |। इस के एलएचएस और आरएचएस संख्या से गुणा का प्रभाव पड़ता है |की उत्पाद संख्या देने के लिए | इस प्रकार ||||||||||||*||हो जाता है||||||||||||||||||||||||||||||||||||*
  • हटा दें *। इस प्रकार ||||||||||||||||||||||||||||||||||||*बन जाता है||||||||||||||||||||||||||||||||||||
  • |पहले कुछ चरणों के रिवर्स द्वारा दशमलव की संख्या में परिवर्तन करें। इस प्रकार ||||||||||||||||||||||||||||||||||||बन जाता है 36।

आउटपुट:

$ echo "04*3
4*3
40*3
42*32
150*20
1*3
3*1
0*3
3*0" | sed -f mult.sed
12
12
120
1344
3000
3
3
0
0
$

दुर्भाग्य से यह समय की आवश्यकता पर बुरी तरह विफल रहता है - 200*1000मेरे उबंटू वीएम पर 41 सेकंड लगते हैं, और रनटाइम अनुभवजन्य रूप से अंतिम उत्पाद के वर्ग के साथ ऊपर जाता है।

— डिजिटल आघात
स्रोत
1
यह लगभग हटाए गए जेएस उत्तर के लगभग एल्गोरिदम के बराबर है, जो कि संख्या भाग में परिवर्तित होने के अलावा है।
— ऑप्टिमाइज़र
@ ऑप्टीमाइजर सहमत। अंतर यह है कि आपका उपयोग करता है length()जो एक नंबर देता है। यह कोई भी संख्यात्मक प्रकार के साथ शुद्ध रूप से रेगेक्स प्रतिस्थापन का उपयोग करता है। मुझे लगता है कि आपका जवाब संभावित रूप से विजेता है, हालांकि यदि आप हटा सकते हैं length()- शायद आप इसके बजाय कुछ इसी तरह के रेगेक्स प्रतिस्थापन कर सकते हैं?
— डिजिटल ट्रामा
1
बहुत अच्छा है, लेकिन एक मिनट का प्रतिबंध विशेष रूप से समाधान को रोकने के लिए है जो उत्तर तक गिनती करके काम करता है। मैं काफी पूर्ण समाधान देखना चाहूंगा, हालांकि।
— नथानिएल
1
मेरे पास एक उत्तर है जो बड़ी संख्या में काम करता है (उदाहरण के लिए सिस्टम के पता स्थान से बड़ा)।
— टॉबी स्पाइट
@TobySpeight हाँ, बहुत अच्छा। मुझे लगता है कि मैंने कुछ समय पहले ही आपका उत्थान किया होगा :)
— डिजिटल ट्रामा
9

अजगर - 312 286 273

D={}
e=t=""
N=[e]
for c in"0123456789":D[c]=t;D[t]=c;t+="I";N+=N
B=lambda s:[D[c]for c in reversed(s)]
Y=B(input())+N
for a in B(input())+N:
 for c in a:
    s=[];o=e
    for a,b in zip(N,Y):i=a+b+o;o=t<=i and"I"or e;s+=i.replace(t,e),;N=s
 Y=[e]+Y
print e.join(B(N)).lstrip("0")

यदि (बहुत सारे) अग्रणी शून्य की अनुमति है, तो अंतिम 12 वर्णों की आवश्यकता नहीं है।

यह अनिवार्य रूप से हाथ से मानक गुणा करता है। अंकों को बार-बार Iएस (आदिम रोमन अंकों की तरह) के रूप में दर्शाया जाता है । संख्याओं को रिवर्स ऑर्डर में अंकों की सूची के रूप में दर्शाया जाता है। एकल अंकों का जोड़ स्ट्रिंग्स cocatenating द्वारा किया जाता है और Iयदि आवश्यक हो तो दस एस को हटा दिया जाता है।

यहाँ एक ungolfed संस्करण है:

N = [""] # zero object: list with a lot of empty strings
D = {}   # dictionary for conversion from and to digits
i = ""   # iterates over digits
for c in "0123456789":
    D[c] = i  # map digit to Roman digit
    D[i] = c  # and vice versa
    i += "I"  # increments Roman digit
    N += N    # add leading zeros to zero

ten = "IIIIIIIIII" # Roman digit ten

# Conversion function
B = lambda s: [D[c] for c in reversed(s)]

def Add(x,y):
    Sum = []
    carryover = ""
    for a,b in zip(x,y):
        increment = a+b+carryover
        carryover = "I" if ten in increment else ""
        increment = increment.replace(ten,"") # take increment modulo ten
        Sum += [increment]
    return Sum

def M(x,y):
    Sum = N[:] # Initiate Sum as zero
    X = B(x)+N # Convert and add leading zeros
    Y = B(y)+N
    for a in X:
        for c in a:
            Sum = Add(Sum,p+Y)
        Y = [""] + Y # multiply Y by 10
    return "".join(B(Sum)).lstrip("0") # Convert back and to string, remove leading zeros.

M(input(),input())
— Wrzlprmft
स्रोत
1
ये क्या जादू है! यह कैसे काम करता है! वाह। इसके अलावा, यहाँ एक और गोल्फ आप कर सकते हैं: def A(x,y):\n S=[];o=""-> def A(x,y,S=[],o=""):। इसके अलावा, दुर्भाग्य से, ["","1"][t in i]अनुमति नहीं है; यह सूचकांक के लिए एक बूल का उपयोग कर रहा है, इसे एक संख्या के रूप में मानता है। मुझे लगता है कि t in i and"1"or""हालांकि काम करना चाहिए।
— जस्टिन
@Quincunx: Sडिफ़ॉल्ट के साथ एक तर्क के रूप में परिभाषित करने से काम नहीं चलेगा, क्योंकि यह फ़ंक्शन की विभिन्न कॉल के लिए भी हमेशा एक ही सूची होगी और इस प्रकार रीसेट नहीं होगी []। आप के बारे में सही थे ["","1"][t in i], मैंने तय किया। मैंने एक स्पष्टीकरण भी जोड़ा।
— Wrzlprmft
यह बहुत अद्भुत है। यह अब के लिए हरी टिक हो जाता है। (मैंने प्रश्न को स्पष्ट करने के लिए संपादित किया है कि आउटपुट में अग्रणी शून्य की अनुमति नहीं है - क्षमा करें!)
— नथानिएल
7

रूबी: 752 698

यह सिर्फ एक उत्तर पाने के लिए है, बस जिज्ञासा से बाहर किया जाता है। संपादित: अब थोड़ा गोल्फ।

$F='0123456789'
$G="#{$F}abcdefghij"
def x(a,b);p(a=~/[13579]$/?b:"",a==""?"":x(Hash[*%w(b0 5 b1 6 b2 7 b3 8 b4 9)].to_a.inject(a.tr($F,'0011223344').chars.zip(a.tr($F,'ababababab').chars).flatten.join("")){|n,q|k,v=q;n.gsub(k,v)}.gsub(/[ab]/,'').sub(/^0*/,''),p(b,b)));end
def p(a,b);j,k=["0#{a}","0#{b}"].map{|c|c.gsub(/./,'0')};c="#{k}#{a}".chars.zip("#{j}#{b}".chars).drop_while{|z|z==%w(0 0)}.map{|m|$G.sub(/#{m.map{|n|"122333444455555666666777777788888888999999999".chars.select{|c|c==n}}.flatten.map{|c|'.'}.join("")}/,"").chars.first}.flatten.join("");d=nil;
while c!=d
 d=c;c="0#{d}".gsub(/[0-9][a-j]/) {|m| m.tr($G,"123456789a#{$F}")}.sub(/^0/,'')
end;c;end
puts x(ARGV.shift,ARGV.shift)

उपयोग: मैंने इसे p किसान.rb नामक फ़ाइल में दिया था:

$ time ruby peasant.rb 9999999999 9999999999
99999999980000000001

real    0m0.129s
user    0m0.096s
sys 0m0.027s

स्पष्टीकरण: यह किसान गुणा है, इसलिए मैं बार-बार आधा और दोहराता हूं। हाल्टिंग अंकों को रोकने और इस तरह के अवशेषों को चिह्नित करने के द्वारा किया जाता है: 1234 -> 0b1a1b2a; फिर बी पर खोजें और बदलें: 06a17a; फिर सफाई -> 617।

जोड़ ऐसा किया जाता है ... सबसे पहले, मैं दोनों तारों को एक ही लंबाई में पैड करता हूं और अंकों से जोड़े बनाता हूं। फिर मैं एक स्ट्रिंग का निर्माण करके अंकों को जोड़ता हूं जिसमें प्रत्येक अंक की लंबाई और समवर्ती होती है; मैं '0123456789abcdefghij' की शुरुआत से उस लंबाई की एक स्ट्रिंग को हटाता हूं, और फिर पहले चार को रखता हूं। तो, उदाहरण के लिए, "9" + "9" -> "मैं"। एनबी I वास्तव में पूरी तरह से संख्या प्रकारों से बचने के लिए यहां लंबाई के कार्यों का उपयोग करने से बचता है; उपसर्ग को हटाने के बजाय एक regexp के साथ किया जाता है।

इसलिए अब मेरे पास एक स्ट्रिंग है जिसमें अंकों और अक्षरों का मिश्रण है। पत्र एक ले जाने के अंक के साथ संख्या का प्रतिनिधित्व करते हैं; मैं संख्या में 0 को पूर्व निर्धारित करता हूं, फिर बार-बार ले जाने के परिणाम के साथ अंक-पत्र के पैटर्न को प्रतिस्थापित करता हूं जब तक कि जोड़ पूरा न हो जाए।

— bazzargh
स्रोत
1
बहुत ही चतुर जवाब, बिलकुल उसी तरह की चीज़ जिसे मैं देखने की उम्मीद कर रहा था!
— नथानिएल
1
मैं वास्तव में उम्मीद कर रहा हूं कि कोई व्यक्ति चर्च अंकों के साथ एक पोस्ट करेगा!
— bazzargh
यह अच्छा होगा, हालांकि मुझे यकीन नहीं है कि यह दक्षता की आवश्यकता के साथ काम करेगा - मुझे लगता है कि तार और चर्च के अंकों के बीच रूपांतरण प्रभावी रूप से 99999999980000000001 तक की गिनती में शामिल होगा।
— नाथनियल
7

ब्रेनफक (1328 बाइट्स)

पहली बार में विचार:

  • निश्चित नहीं है कि अगर ब्रेनफक इस सवालों का एक वैध जवाब है क्योंकि मुझे यकीन नहीं है कि आप सेल मानों को 'संख्यात्मक प्रकार' के रूप में मानते हैं या नहीं। मुझे नहीं लगता कि चूंकि bf प्रकार नहीं जानता है, लेकिन यह मेरी अपनी राय है, कृपया मुझे सही करें अगर मैं गलत हूं।
  • एक कार्यान्वयन समर्थन (लगभग) असीमित मूल्य आवश्यक है।
  • यह कार्यान्वयन के आधार पर बहुत धीमी गति से हो सकता है।

मैंने केवल अपने स्वयं के दुभाषिया के साथ कार्यक्रम का परीक्षण किया, आप इसे यहां पा सकते हैं ।

इनपुट को दोनों नंबरों को एक ही ASCII स्थान से अलग करना चाहिए।

golfed:

,>++++++[<----->-]<--[>,>++++++[<----->-]<--]>>>+<<<<[>>++++[<<---->>-]<<[>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]>>>>>[<<<<<+>>>>>-]<[>++++++++++<-]>[<<+>>-]<<<<<[->+<]>[-<+>]<<]>>>>[-]<,[>,]>>>+<<<<[>>+++++++[<<------->>-]<<+[>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]>>>>>[<<<<<+>>>>>-]<[>++++++++++<-]>[<<+>>-]<<<<<[->+<]>[-<+>]<<]>>>>[-]<<<<<[>>[>+>+<<-]>>[<<+>>-]<<<<-]>>[-]>[<+>-]<[>>+>+<<<-]>>>[<<<+>>>-]<[[-]<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<-]>[<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<->>[-]]+>-]<-]<<+>]<[>>+<<-]>>[<<<[>+>+<<-]>>[<<+>>-]>-]<<[<<->>-]<[-]<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>[>>]+[<<]>[>[>>]<+<[<<]>-]<<<<<<<<<<[>>+>+<<<-]>>>[<<<+>>>-]+[<+>-]<<<[-]>>[<<+>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+<<-]>>[<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<<->>>[-]]+>-]<-]<<<+>>]<[-]<<<<[-]>>>[<<<+>>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[<+>-]<]<[>+>+<<-]>>[<<+>>-]<[>+<[-]]+>[<[-]<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[[-]>>>>>>>>[>>]<[<[<<]<<<<<+>>>>>>>[>>]<-]<-<<[<<]<<<<<>++++++++++++++++++++++++++++++++++++++++++++++++[<+>-]<.[-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]+[<->-]<<<<<[-]>>>>[<<<<+>>>>-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]<[<+>-]<]<[-]]<[>>++++++[<++++++++>-]<.[-]<[-]]<[-]<[-]>>>>>>>>>>>>[>[-]>]<<[-<<]<<<<<<<<<<<<<<<<<[-]<[-]

Ungolfed:

,
>++++++[<----->-]<--
[                                           # read input until space
    >,
    >++++++[<----->-]<--                    # decrease cell by 32 to check if it's a space
]
>>>+<<<<                                    # set multiplier to 1

[

    >>++++[<<---->>-]<<                     # decrease by 16 to get cell value of number

    [>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]        # multiply value by multiplier
    >>>>>[<<<<<+>>>>>-]                     # copy value back
    <[>++++++++++<-]>[<<+>>-]               # multiply multiplier by 10
    <<<<<                                   # go back to number

    [->+<]>[-<+>]                           # add value to next cell and move sum to previous cell

    <<                                      # go to next number
]

>>>>[-]<                                    # delete old multiplier

,[>,]                                       # read second number until end of input
>>>+<<<<                                    # set new multiplier

[

    >>+++++++[<<------->>-]<<+              # decrease by 48 to get cell value of number

    [>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]        # multiply value by multiplier
    >>>>>[<<<<<+>>>>>-]                     # copy value back
    <[>++++++++++<-]>[<<+>>-]               # multiply multiplier by 10
    <<<<<                                   # go back to number

    [->+<]>[-<+>]                           # add value to next cell and move sum to previous cell

    <<                                      # go to next number
]

>>>>[-]<<<<<                                # delete multiplier

[>>[>+>+<<-]>>[<<+>>-]<<<<-]>>[-]>          # multiply both values

# magical algorithm for printing cell value as number taken from Cedric Mamo's code from a previous question
[<+>-]<[>>+>+<<<-]>>>[<<<+>>>-]<[[-]<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<-]>[<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<->>[-]]+>-]<-]<<+>]<[>>+<<-]>>[<<<[>+>+<<-]>>[<<+>>-]>-]<<[<<->>-]<[-]<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>[>>]+[<<]>[>[>>]<+<[<<]>-]<<<<<<<<<<[>>+>+<<<-]>>>[<<<+>>>-]+[<+>-]<<<[-]>>[<<+>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+<<-]>>[<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<<->>>[-]]+>-]<-]<<<+>>]<[-]<<<<[-]>>>[<<<+>>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[<+>-]<]<[>+>+<<-]>>[<<+>>-]<[>+<[-]]+>[<[-]<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[[-]>>>>>>>>[>>]<[<[<<]<<<<<+>>>>>>>[>>]<-]<-<<[<<]<<<<<>++++++++++++++++++++++++++++++++++++++++++++++++[<+>-]<.[-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]+[<->-]<<<<<[-]>>>>[<<<<+>>>>-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]<[<+>-]<]<[-]]<[>>++++++[<++++++++>-]<.[-]<[-]]<[-]<[-]>>>>>>>>>>>>[>[-]>]<<[-<<]<<<<<<<<<<<<<<<<<[-]<[-]

मैंने इस उत्तर से मूल्य के आउटपुट के लिए कोड लिया है , इसके लिए लेखक को धन्यवाद!

कार्यक्रम हो सकता है मान्य नहीं हो, लेकिन किसी भी तरह में मैं इसे आपके साथ साझा करना चाहता था ^^

अपडेट: अब आप यह, @ Sp3000 के लिए परीक्षण कर सकते हैं (केवल छोटे गुणा के लिए) यहाँ धन्यवाद जवाब के लिए इस प्रतियोगिता और एसई के नए ढेर स्निपेट्स!

var NUM_CELLS = 30000;var ITERS_PER_SEC = 100000;var TIMEOUT_MILLISECS = 5000;function clear_output(){document.getElementById("output").value="";document.getElementById("stderr").innerHTML=""}function stop(){running=false;document.getElementById("run").disabled=false;document.getElementById("stop").disabled=true;document.getElementById("clear").disabled=false;document.getElementById("wrap").disabled=false;document.getElementById("timeout").disabled=false;document.getElementById("eof").disabled=false}function interrupt(){error(ERROR_INTERRUPT)}function error(e){document.getElementById("stderr").innerHTML=e;stop()}function run(){clear_output();document.getElementById("run").disabled=true;document.getElementById("stop").disabled=false;document.getElementById("clear").disabled=true;document.getElementById("wrap").disabled=true;document.getElementById("timeout").disabled=true;document.getElementById("eof").disabled=true;code=document.getElementById("code").value;input=document.getElementById("input").value;wrap=document.getElementById("wrap").value;timeout=document.getElementById("timeout").checked;eof=document.getElementById("eof").value;loop_stack=[];loop_map={};for(var e=0;e<code.length;++e){if(code[e]=="["){loop_stack.push(e)}else if(code[e]=="]"){if(loop_stack.length==0){error(ERROR_BRACKET);return}else{var t=loop_stack.pop();loop_map[t]=e;loop_map[e]=t}}}if(loop_stack.length>0){error(ERROR_BRACKET);return}running=true;start_time=Date.now();code_ptr=0;input_ptr=0;cell_ptr=Math.floor(NUM_CELLS/2);cells={};iterations=0;bf_iter(1)}function bf_iter(e){if(code_ptr>=code.length||!running){stop();return}var t=Date.now();for(var n=0;n<e;++n){if(cells[cell_ptr]==undefined){cells[cell_ptr]=0}switch(code[code_ptr]){case"+":if(wrap=="8"&&cells[cell_ptr]==255||wrap=="16"&&cells[cell_ptr]==65535||wrap=="32"&&cells[cell_ptr]==2147483647){cells[cell_ptr]=0}else{cells[cell_ptr]++}break;case"-":if(cells[cell_ptr]==0){if(wrap=="8"){cells[cell_ptr]=255}if(wrap=="16"){cells[cell_ptr]=65535}if(wrap=="32"){cells[cell_ptr]=2147483647}}else{cells[cell_ptr]--}break;case"<":cell_ptr--;break;case">":cell_ptr++;break;case".":document.getElementById("output").value+=String.fromCharCode(cells[cell_ptr]);break;case",":if(input_ptr>=input.length){if(eof!="nochange"){cells[cell_ptr]=parseInt(eof)}}else{cells[cell_ptr]=input.charCodeAt(input_ptr);input_ptr++}break;case"[":if(cells[cell_ptr]==0){code_ptr=loop_map[code_ptr]}break;case"]":if(cells[cell_ptr]!=0){code_ptr=loop_map[code_ptr]}break}code_ptr++;iterations++;if(timeout&&Date.now()-start_time>TIMEOUT_MILLISECS){error(ERROR_TIMEOUT);return}}setTimeout(function(){bf_iter(ITERS_PER_SEC*(Date.now()-t)/1e3)},0)}var ERROR_BRACKET="Mismatched brackets";var ERROR_TIMEOUT="Timeout";var ERROR_INTERRUPT="Interrupted by user";var code,input,wrap,timeout,eof,loop_stack,loop_map;var running,start_time,code_ptr,input_ptr,cell_ptr,cells,iterations
<div style="font-size:12px;font-family:Verdana, Geneva, sans-serif;"> <div style="float:left; width:50%;"> Code: <br> <textarea id="code" rows="4" style="overflow:scroll;overflow-x:hidden;width:90%;">,>++++++[<----->-]<--[>,>++++++[<----->-]<--]>>>+<<<<[>>++++[<<---->>-]<<[>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]>>>>>[<<<<<+>>>>>-]<[>++++++++++<-]>[<<+>>-]<<<<<[->+<]>[-<+>]<<]>>>>[-]<,[>,]>>>+<<<<[>>+++++++[<<------->>-]<<+[>>>>[>+>+<<-]>>[<<+>>-]<<<<<<-]>>>>>[<<<<<+>>>>>-]<[>++++++++++<-]>[<<+>>-]<<<<<[->+<]>[-<+>]<<]>>>>[-]<<<<<[>>[>+>+<<-]>>[<<+>>-]<<<<-]>>[-]>[<+>-]<[>>+>+<<<-]>>>[<<<+>>>-]<[[-]<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<-]>[<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<->>[-]]+>-]<-]<<+>]<[>>+<<-]>>[<<<[>+>+<<-]>>[<<+>>-]>-]<<[<<->>-]<[-]<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>[>>]+[<<]>[>[>>]<+<[<<]>-]<<<<<<<<<<[>>+>+<<<-]>>>[<<<+>>>-]+[<+>-]<<<[-]>>[<<+>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+<<-]>>[<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<<->>>[-]]+>-]<-]<<<+>>]<[-]<<<<[-]>>>[<<<+>>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[<+>-]<]<[>+>+<<-]>>[<<+>>-]<[>+<[-]]+>[<[-]<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[[-]>>>>>>>>[>>]<[<[<<]<<<<<+>>>>>>>[>>]<-]<-<<[<<]<<<<<>++++++++++++++++++++++++++++++++++++++++++++++++[<+>-]<.[-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]+[<->-]<<<<<[-]>>>>[<<<<+>>>>-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]<[<+>-]<]<[-]]<[>>++++++[<++++++++>-]<.[-]<[-]]<[-]<[-]>>>>>>>>>>>>[>[-]>]<<[-<<]<<<<<<<<<<<<<<<<<[-]<[-]</textarea> <br>Input: <br> <textarea id="input" rows="2" style="overflow:scroll;overflow-x:hidden;width:90%;">7 6</textarea> <p> Wrap: <select id="wrap"> <option value="8">8-bit</option> <option value="16">16-bit</option> <option value="32" selected="selected">32-bit</option> </select> &nbsp; Timeout: <input id="timeout" type="checkbox"></input>&nbsp; EOF: <select id="eof"> <option value="nochange">Same</option> <option value="0" selected="selected">0</option> <option value="-1">-1</option> </select> </p> </div> <div style="float:left; width:50%;"> Output: <br> <textarea id="output" rows="6" style="overflow:scroll;width:90%;"></textarea> <p> <input id="run" type="button" value="Run" onclick="run()"></input> <input id="stop" type="button" value="Stop" onclick="interrupt()" disabled="true"></input> <input id="clear" type="button" value="Clear" onclick="clear_output()"></input> &nbsp; <span id="stderr" style="color:red"></span></p></div></div>
स्निपेट का विस्तार करें

— सिफ़र
स्रोत
मुझे नहीं पता कि क्या यह वैध है या नहीं! मुझे लगता है कि ब्रेनफक में या तो सब कुछ एक नंबर है, या कुछ भी नहीं है।
— नथानिएल
मुझे यह उत्तर पसंद है। मैं अपने आप को bf के साथ हाल ही में गड़बड़ कर रहा हूँ। यह इस तरह से प्रकाश डालता है कि मशीन स्तर पर, सब कुछ वैसे भी सिर्फ टोकन है। यह कहना मुश्किल है कि क्या यह वास्तव में नियमों का पालन करता है या नहीं।
— ऑक्टोपस
6

पायथन, 394 349 340 वर्ण

D='0123456789'
R=reversed
U=lambda x:[R for y in D if y<x]
T=U(':')
def A(a,b,r='',c=[]):
 for x,y in map(None,R(a),R(b)):
    d=U(x)+U(y)+c;t=T;c=[R]
    if d<T:t=c=[]
    r=min(k for k in D if U(k)+t>=d)+r
 if c:r='1'+r
 return r
a,b=input()
m=''
while b:
 if list(b).pop()in'13579':m=A(m,a)
 b=list(A(b,A(b,A(b,A(b,b)))));b.pop();a=A(a,a)
print m

जैसे भागो:

echo '"9999999999","9999999999"' | ./mulstr.py

50 मिलीसेकंड लेता है।

रूसी किसान गुणन का उपयोग करता है । अंकों को जोड़ते समय, हम उन्हें एकात्मक ('5' => [R, R, R, R, R]) में बदलते हैं, सूचियों को समेटते हैं, फिर वापस परिवर्तित करते हैं। यूनिकरी अंक के रूप में Uउपयोग करते हुए, यूनरी में परिवर्तित हो Rजाता है। हम गणना b/=2करते हैं b=b*5/10।

— कीथ रान्डेल
स्रोत
एक युगल गोल्फ: def A(a,b):\n r='';c=[]-> def A(a,b,r='',c=[]):, इसी तरह के लिए def M। आप को बदलने में सक्षम हो सकता है for z in D:d.pop()\n c=['X']के लिए [d.pop()for z in D];c=['X'], जिस स्थिति में आप भी पिछले पर इसे पतन सकता है if। इसके अलावा, if list(b).pop()in'13579'बस हो सकता है if b[:].pop()in'13579'?
— जस्टिन
@Quincunx: धन्यवाद। आखिरी काम नहीं करेगा क्योंकि पहली पुनरावृत्ति bएक स्ट्रिंग है, सूची नहीं।
— कीथ रान्डेल
आप Mएक पूरा कार्यक्रम छोड़ सकते हैं और लिख सकते हैं ; a,b=input() की अनुमति है।
— जस्टिन
1
b * 5/10 एक अच्छी चाल है।
— बाज़रघ
मैं बस ठोकर खा गया reduce, जो आपको नीकन A(b,A(b,A(b,A(b,b))))करने की अनुमति देता है reduce(A,[b,b,b,b,b])। अफसोस की बात है, यह वर्ण गणना को प्रभावित नहीं करता है।
— Wrzlprmft
5

जावास्क्रिप्ट (E6) 375 395 411 449

संपादित गोल्फ
संपादित बग तय: एक ध्वज ले जाने समाशोधन लापता

यह केवल 0 समय के पास प्रतीक चिह्न हेरफेर के साथ किया जा सकता है।
इस संस्करण में आप अंकों के बजाय किसी भी चार्ट का उपयोग कर सकते हैं, जब तक कि प्रतीक आरोही क्रम में हैं।

नोट: स्ट्रिंग का उपयोग करके, स्ट्रिंग की के साथ हैशमैप, सूची के रूप में उपयोग किए गए सरणियाँ। कोई अनुक्रमण नहीं, सरणियों को 'मानचित्र' का उपयोग करके या पुश और शिफ्ट का उपयोग करके घुमाया जाता है।
सभी '+' स्ट्रिंग समवर्ती हैं। 

M=(x,y,S=a=>a.shift()||z,R=a=>[...a].reverse(),e=R('9876543210'),d=[...e])=>
  R(y)[T='map'](b=>
     R(x)[T](a=>(
       u=R[e[a+=b]+v],
       v=R[S[a]+(u<v?'1':z)],
       p[P](t=R[S(o)+u]),
       t<u?v=R[v+'1']:v
     ),o=p,p=[])
    +(v>z&&p[P](v),x+=v=z),
    d[T](a=>d[T](b=>e[P='push'](R[a+b]=S(e)))+e[P](S(e))),  
    d[T](a=>d[T](b=>e[d[T](c=>v=c<a?(u=R[u+b])<b?R[v+'1']:v:v,v=u=z='0'),S[a+b]=v,a+b]=u)),
    p=[v=z]
  )&&R(p).join(o)

कम गोल्फ (शायद मैं कल एक स्पष्टीकरण जोड़ दूंगा)

M=(x,y)=>(
  R=a=>[...a].reverse(),
  // Addition table s 
  s={},
  e=[...'9012345678'],
  [for(a of(d='0123456789'))for(b of(e.push(e.shift()),d))e.push(s[a+b]=c=e.shift())],
  // Multiplication table m,n
  m={},n={},
  [for(a of d)for(b of d)(
     [for(c of(z=u=v='0',d))
     c<a&&(t=s[u+b],t<u?v=s[v+'1']:v,u=t)
     ],m[a+b]=u,n[a+b]=v
  )],
  x=R(x),v=z,o=[],p=[],
  [for(b of R(y))(
     [for(a of x)(
       u=s[m[a+b]+v],v=s[n[a+b]+(u<v?'1':z)],
       p.push(t=s[(o.shift()||z)+u]),
       t<u?v=s[v+'1']:v
     )],
     v>z?p.push(v):o,o=p,p=[],x.unshift(v=z)
  )],
  R(o).join('')
)

फायरफॉक्स / फायरबग कंसोल में टेस्ट

t0=-new Date
r=M('9999999999','9999999999')
t1=-new Date
console.log("Result",r, "time ms", t0-t1)

उत्पादन

Result 99999999980000000001 time ms 14
— edc65
स्रोत
संभवतः वहाँ एक मामूली बग है - 9999999999मामले से उत्पादन होना चाहिए 99999999980000000001, नहीं99999999980000000081
— नाथनियल
:( चेक करने जा रहा है
— edc65
यदि आप गुणा तालिका का उपयोग कर रहे हैं, तो आप इस तथ्य के आसपास कैसे हो रहे हैं कि योग की अनुमति नहीं है?
— सीओटीओ
1
सम्‍मिलन IS को हैशटेबल (कोड में) का उपयोग करने की अनुमति है। पूर्व। s ['34 '] ->' 7 '। सिर्फ प्रतीक, संख्या नहीं। S ['cd'] -> 'g'
— edc65
5

हास्केल, 231 बाइट्स

यह एक ऑपरेटर को परिभाषित करता है # जो प्राकृतिक संख्याओं के दो स्ट्रिंग अभ्यावेदन को गुणा करता है। यह तारों पर एक प्रारंभिक वेतन वृद्धि / क्षरण संचालन को परिभाषित करके काम करता है, फिर इसका उपयोग जोड़ और गुणा करने के लिए करता है। थोड़ा अतिरिक्त जादू कुछ घातीय गति देता है जो इसे संभव बनाते हैं।

r=reverse
n="9876543210"
t=True
c&(x:y)|c==x=head y|t=c&y
m%[]="1";m%(c:s)|c==last m=head m:m%s|t=c&m:s
[]!y=y;x![]=x;(x:a)!('0':b)=x:a!b;x!y=(r n%x)!(n%y)
"0"?_="0";x?('0':y)|all(=='0')y="0"|t=('0':x)?y;x?y=x?(n%y)!x
x#y=r$r x?r y

यह तरीका इतना तेज़ है कि 2008 के लैपटॉप पर भी अनधिकृत ghci REPL में, परीक्षण मामले में एक सेकंड का एक अंश लगता है:

λ> :set +s
λ> let test = replicate 10 '9'
(0.00 secs, 0 bytes)
λ> test
"9999999999"
(0.00 secs, 1069784 bytes)
λ> test # test
"99999999980000000001"
(0.06 secs, 13451288 bytes)

यहां देखें कि दो अंकों वाले सभी उत्पाद सही हैं:

λ> and [ show (x * y) == (show x # show y) | x <- [0..100], y <- [0..100] ]
True
— मैट नूनन
स्रोत
लगता है, हमारे पास एक नया नेता है! (हालांकि मैं हास्केल नहीं पढ़ सकता हूं - क्या कोई स्वतंत्र रूप से पुष्टि कर सकता है कि यह कल्पना फिट बैठता है?)
— नाथनियल
1
हां, यह पूरी तरह से क्रॉम्यूलेंट हैस्केल है, यह कल्पना को फिट करता है, और विज्ञापित के रूप में काम करता है। बहुत बढ़िया!
— बज्जारघ
4

बैश + इमेजमैजिक: 52

convert -size ${a}x${b} xc:red txt:-|grep -v g|wc -l

शेल चर में इनपुट होने की अपेक्षा करता है aऔर b। यह विशेष रूप से चतुर या कुशल नहीं है, लेकिन यह काम पूरा कर लेता है। यह शायद पहले किया गया है।

ध्यान दें कि xछवि के आयामों को दर्शाता है; यह इस संदर्भ में एक अंकगणितीय ऑपरेटर नहीं है।

मैंने इसका परीक्षण नहीं किया है, लेकिन मैं यह मानने को तैयार हूं कि गैर-चरम इनपुट के लिए, यह एक मिनट से कम समय में पूरा हो जाएगा। मैं कल इसका परीक्षण कर सकता हूं।

मामले में ImageMagick संस्करणों के साथ कोई मज़ेदार व्यवसाय है, यह वह है जो मैं उपयोग कर रहा हूं: ImageMagick 6.7.7-10

— millinon
स्रोत
अच्छी कोशिश, लेकिन मुझे यकीन है कि यह एक मिनट (या वास्तव में किसी भी मौजूदा मशीन पर) इनपुट के लिए 9999999999और के तहत काम नहीं करेगा 9999999999।
— नाथनियल
4
यह भी काम करता है: dd if=/dev/zero bs=$a count=$b 2>&-|wc -c।
— jimmy23013
1
9999999999x99999999998bit प्रारूप में एक छवि पृथ्वी पर वर्तमान में मौजूद सभी हार्ड ड्राइव की जगह लेगी। बेशक, एक पीएनजी बहुत छोटा होगा, यदि आप इसे पहली बार कच्ची छवि बनाए बिना बना सकते हैं। (हालांकि मुझे दृढ़ता से संदेह है कि आपके पास आकार के साथ एक छवि के साथ पूर्णांक अतिप्रवाह मुद्दे होंगे।) लेकिन फिर भी, इस तरह की विधि लगभग निश्चित रूप से कॉलिंग-चीज़ों के बेईमानी से गिर जाएगी, जो कि वापसी-संख्यात्मक-परिणाम-जैसे-तार लूपोल।
— नाथनियल
1
के $bबजाय का उपयोग करके आप 2 बाइट्स बचा सकते हैं ${b}।
— nyuszika7h
1
इसके अलावा, आप इसके grep -vc gबजाय का उपयोग करके 5 बाइट्स बचा सकते हैं grep -v g|wc -l।
— nyuszika7h
2

अजगर 2 (अवधारणा का प्रमाण)

यह समाधान केवल स्ट्रिंग्स और सूचियों और थोड़ा रेगेक्स का उपयोग करके काम करता है। मेरा मानना ​​है कि यह पूरी तरह से युक्ति को फिट करता है, सिवाय इसके कि कोई रास्ता नहीं है कि यह 9999999999x9999999999एक मिनट में कर सकता है । हालांकि पर्याप्त समय दिया गया तो यह काम करेगा। यह बहुत जल्दी 4 अंकों की संख्या गुणा कर सकता है।

चूंकि यह तकनीकी रूप से अमान्य है इसलिए मैंने अभी तक इसे पूरी तरह से गोल्फ के लिए परेशान नहीं किया है। नियम बदलेंगे तो मैं ऐसा करूंगा।

import re
D='123456789'
D=dict(zip('0'+D,D+'0'))

def toRlist(s):
    if s:t,h=re.match(r'(\d*)(\d)',s).groups();return[h,toRlist(t)]
    return''

def increment(r):
    if not r:return['1','']
    h,t=r
    return[D[h],increment(t)if h=='9'else t]

def toString(r):
    if not r:return''
    h,t=r
    return h+toString(t)

def listify(r,L):
    if not r:return
    h,t=r
    if h=='1':L.append('')
    if h=='2':L.extend(['',''])
    if h=='3':L.extend(['','',''])
    if h=='4':L.extend(['','','',''])
    if h=='5':L.extend(['','','','',''])
    if h=='6':L.extend(['','','','','',''])
    if h=='7':L.extend(['','','','','','',''])
    if h=='8':L.extend(['','','','','','','',''])
    if h=='9':L.extend(['','','','','','','','',''])
    listify(t,L);listify(t,L);listify(t,L);listify(t,L);listify(t,L)
    listify(t,L);listify(t,L);listify(t,L);listify(t,L);listify(t,L)

def add(r1,r2):
    L=[];listify(r2,L)
    for _ in L:r1=increment(r1)
    return r1

def multiply(a,b):
    total=''
    r=toRlist(a)
    L=[];listify(toRlist(b),L)
    for _ in L:total=r if total=='' else add(total,r)
    return''.join(reversed(toString(total)))

उदाहरण:

multiply('12','5') #returns the string 60

multiply('1869','1243') #returns the string 2323167
— केल्विन के शौक
स्रोत
1
+1 क्योंकि यह युक्ति को पूरा करता है (दक्षता की आवश्यकता के अलावा) जहाँ तक मैं बता सकता हूँ
— नाथनियल
2

पायथन 2 (555)

मैं आमतौर पर अपनी चुनौती का इतनी जल्दी (या बिल्कुल) जवाब नहीं देता, लेकिन मैं यह साबित करना चाहता था कि यह किया जा सकता है। (सौभाग्य से कुछ अन्य उत्तरों ने यह किया कि इससे पहले, लेकिन मैं इसे खत्म करने में मदद नहीं कर सकता।) कुछ और गोल्फिंग हैं जो किए जा सकते हैं, लेकिन मुझे लगता है कि यह उचित है। यह 9999999999x9999999999मेरी मशीन पर 0.03 के तहत मामले को संभालता है ।

d="123456789";I=dict(zip('0'+d,d+'0'))
def r(x):return reversed(x)
def s(x):return''.join(x)
def i(x):
    try:
        h=I[x.next()]
        if h!='0':h+=s(x)
        else:h+=i(x)
        return h
    except:return'1'
def b(x,y):
    for c in'0'+d:
        if c==y:break
        x=iter(i(x))
    return x
def a(x,y):
    z=''
    for c in y:
        x=b(x,c)
        try:z+=x.next()
        except:z+='0'
    return z+s(x)
def n(x,y):
    z='0'
    for c in'0'+d:
        if c==y:break
        z=a(iter(z),x)
    return z
def o(x,y):
    x=s(x)
    l='';z=''
    for c in y:
        z=a(iter(z),l+s(n(x,c)))
        l+='0'
    return z
def m(x,y):
    return s(r(o(r(x),r(y))))

उदाहरण का उपयोग करें: m("12345","42")

यह स्ट्रिंग जोड़तोड़ का उपयोग करके लंबे गुणा करके काम करता है। कभी-कभी चर स्ट्रिंग होते हैं और कभी-कभी वे स्ट्रिंग्स के ऊपर पुनरावृत्त होते हैं, जो एक पूर्णांक शाब्दिक का उपयोग किए बिना पहला तत्व प्राप्त करना संभव बनाता है। अंकों के साथ सब कुछ संग्रहीत है, ताकि पहला तत्व कम से कम महत्वपूर्ण अंक हो।

यहाँ एक फ़ंक्शन-बाय-फ़ंक्शन स्पष्टीकरण है:

  • rऔर sबहीखाता कार्य हैं। ( rकेवल इसके लिए एक उपनाम है reversed, जो रिवर्स इटरेटर बनाता है, और sपुनरावृत्तियों को स्ट्रिंग्स में परिवर्तित करता है।)

  • iजैसे 39+1=40और जैसे मामलों सहित एक स्ट्रिंग में संख्या 1 से बढ़ाता है 99+1=100।

  • bजोड़ता है xऔर y, लेकिन yकेवल एक अंक होना चाहिए। यह x yसमय बढ़ाकर काम करता है ।

  • aएक साथ दो अंकों को जोड़ता है जिसमें दोनों bप्रत्येक अंक के लिए कॉल करके कई अंक हो सकते हैं y।

  • nगुणन xऔर y, लेकिन yकेवल एक अंक होना चाहिए। यह xअपने आप को yकई बार जोड़कर काम करता है ।

  • oगुणक xऔर y, जहां दोनों तर्कों में कई अंक हो सकते हैं। यह क्लासिक लंबी-गुणा का उपयोग करता है

  • mबस अपने स्ट्रिंग आदानों को रिवर्स पुनरावृत्तियों में परिवर्तित करता है और उन्हें हाथ देता है o, फिर परिणाम को उलट देता है और इसे एक स्ट्रिंग में परिवर्तित करता है।

— नथानिएल
स्रोत
युगल गोल्फ: def a(x,y):-> def a(x,y,z=''):और अगली पंक्ति को हटा दें; लूप def o(x,y):के x=s(x)लिए x=s(x);l='';z='', अन्य कार्यों के लिए इसी तरह की चाल, में बदल जाते हैं , इसी तरह newline + paces को हटा दें; इसके बजाय उपयोग करें ;। इसके अलावा, मुझे लगता है कि if h!='0':h+=s(x)\nelse:h+=i(x)बस हो सकता है h+=h!='0'and i(x)or s(x); शायद भी h+=(h!='0'and i or s)(x); अन्यथा, बस करने के लिए बदल जाते हैं if'0'!=h। इसके अलावा चीजें def r(x):return reversed(x)->r=reversed
— जस्टिन
इसके अलावा, मैं के लिए उल्लेख करना भूल गया s, m: s=lambda x:''.join(x), m=lambda x,y:s(r(o(r(x),r(y))))पूरे समारोह घोषणा के बजाय। सिर्फ उन चीजों के साथ जो मुझे पता है कि यह काम करता है, यह आपकी बाइट-गिनती को 521 तक ले आता है।
— जस्टिन
ओह, और एक और: आपके forछोरों के लिए: for c in'0'+d:\nif c==y:break\nz=a(iter(z),x)-> for c in'0'+d:\nif c!=y:z=a(iter(z),x), हालांकि यह आपके प्रोग्राम की गति को महत्वपूर्ण रूप से बदल सकता है।
— जस्टिन
@Quincunx धन्यवाद! मैं आज सुबह और भी कुछ सुधार देख सकता हूं। (ज्यादातर कार्यों को परिभाषित करने के बजाय छोरों को घोंसला बनाना।) अगर कुछ अधिक प्रतिस्पर्धी उत्तर दिखाई देते हैं, तो मैं ये बदलाव करूंगा, जो संभावना है - वर्तमान में वे मुझे लीड में डाल देंगे, जो थोड़ा अनुचित लगता है क्योंकि यह मेरा सवाल था और मैं ' इसके बारे में सोचने के लिए लंबे समय तक था।
— नथानिएल
2

जावास्क्रिप्ट: 3710 3604 बाइट्स

  • 1 अंक गुणा के साथ स्ट्रिंग लुकअप तालिकाओं का उपयोग करना और कैरी के साथ जोड़ना।
  • गुणन अंक x रेखा के बजाय अंक x अंक द्वारा किया जाता है।

गोल्फ:

var M={
'00':'0','01':'0','02':'0','03':'0','04':'0','05':'0','06':'0','07':'0','08':'0','09':'0',
'10':'0','11':'1','12':'2','13':'3','14':'4','15':'5','16':'6','17':'7','18':'8','19':'9',
'20':'0','21':'2','22':'4','23':'6','24':'8','25':'10','26':'12','27':'14','28':'16','29':'18',
'30':'0','31':'3','32':'6','33':'9','34':'12','35':'15','36':'28','37':'21','38':'24','39':'27',
'40':'0','41':'4','42':'8','43':'12','44':'16','45':'20','46':'24','47':'28','48':'32','49':'36',
'50':'0','51':'5','52':'10','53':'15','54':'20','55':'25','56':'30','57':'35','58':'40','59':'45',
'60':'0','61':'6','62':'12','63':'18','64':'24','65':'30','66':'36','67':'42','68':'48','69':'54',
'70':'0','71':'7','72':'14','73':'21','74':'28','75':'35','76':'42','77':'49','78':'56','79':'63',
'80':'0','81':'8','82':'16','83':'24','84':'32','85':'40','86':'48','87':'56','88':'64','89':'72',
'90':'0','91':'9','92':'18','93':'27','94':'36','95':'45','96':'54','97':'63','98':'72','99':'81'
};
var A={
'000':'0','001':'1','002':'2','003':'3','004':'4','005':'5','006':'6','007':'7','008':'8','009':'9',
'010':'1','011':'2','012':'3','013':'4','014':'5','015':'6','016':'7','017':'8','018':'9','019':'10',
'020':'2','021':'3','022':'4','023':'5','024':'6','025':'7','026':'8','027':'9','028':'10','029':'11',
'030':'3','031':'4','032':'5','033':'6','034':'7','035':'8','036':'9','037':'10','038':'11','039':'12',
'040':'4','041':'5','042':'6','043':'7','044':'8','045':'9','046':'10','047':'11','048':'12','049':'13',
'050':'5','051':'6','052':'7','053':'8','054':'9','055':'10','056':'11','057':'12','058':'13','059':'14',
'060':'6','061':'7','062':'8','063':'9','064':'10','065':'11','066':'12','067':'13','068':'14','069':'15',
'070':'7','071':'8','072':'9','073':'10','074':'11','075':'12','076':'13','077':'14','078':'15','079':'16',
'080':'8','081':'9','082':'10','083':'11','084':'12','085':'13','086':'14','087':'15','088':'16','089':'17',
'090':'9','091':'10','092':'11','093':'12','094':'13','095':'14','096':'15','097':'16','098':'17','099':'18',
'100':'1','101':'2','102':'3','103':'4','104':'5','105':'6','106':'7','107':'8','108':'9','109':'10',
'110':'2','111':'3','112':'4','113':'5','114':'6','115':'7','116':'8','117':'9','118':'10','119':'11',
'120':'3','121':'4','122':'5','123':'6','124':'7','125':'8','126':'9','127':'10','128':'11','129':'12',
'130':'4','131':'5','132':'6','133':'7','134':'8','135':'9','136':'10','137':'11','138':'12','139':'13',
'140':'5','141':'6','142':'7','143':'8','144':'9','145':'10','146':'11','147':'12','148':'13','149':'14',
'150':'6','151':'7','152':'8','153':'9','154':'10','155':'11','156':'12','157':'13','158':'14','159':'15',
'160':'7','161':'8','162':'9','163':'10','164':'11','165':'12','166':'13','167':'14','168':'15','169':'16',
'170':'8','171':'9','172':'10','173':'11','174':'12','175':'13','176':'14','177':'15','178':'16','179':'17',
'180':'9','181':'10','182':'11','183':'12','184':'13','185':'14','186':'15','187':'16','188':'17','189':'18',
'190':'10','191':'11','192':'12','193':'13','194':'14','195':'15','196':'16','197':'17','198':'18','199':'19'
} 
Array.prototype.e=function(){return(''+this)==='';}
String.prototype.s=function(){return this.split('').reverse();}
function B(a,b,c) {
var r='',s='';
a=a.s();
b=b.s();
while (!a.e()||!b.e()||c!=='0') {
x=a.e()?'0':a.shift();
y=b.e()?'0':b.shift();
s=A[c+x+y];
s=s.s();
r=s.shift()+r;
c=s.e()?'0':'1';
}
return r;
}
function m(a,b) {
var s='0',m='';
b.split('').reverse().forEach(function(e){
var z=m;
a.split('').reverse().forEach(function(f){s=B(s,M[e+f]+z,'0');z+='0';});
m+='0';
});
return s;
}

परीक्षण के साथ अधूरा:

var mul = {
'00':'0','01':'0','02':'0','03':'0','04':'0','05':'0','06':'0','07':'0','08':'0','09':'0',
'10':'0','11':'1','12':'2','13':'3','14':'4','15':'5','16':'6','17':'7','18':'8','19':'9',
'20':'0','21':'2','22':'4','23':'6','24':'8','25':'10','26':'12','27':'14','28':'16','29':'18',
'30':'0','31':'3','32':'6','33':'9','34':'12','35':'15','36':'28','37':'21','38':'24','39':'27',
'40':'0','41':'4','42':'8','43':'12','44':'16','45':'20','46':'24','47':'28','48':'32','49':'36',
'50':'0','51':'5','52':'10','53':'15','54':'20','55':'25','56':'30','57':'35','58':'40','59':'45',
'60':'0','61':'6','62':'12','63':'18','64':'24','65':'30','66':'36','67':'42','68':'48','69':'54',
'70':'0','71':'7','72':'14','73':'21','74':'28','75':'35','76':'42','77':'49','78':'56','79':'63',
'80':'0','81':'8','82':'16','83':'24','84':'32','85':'40','86':'48','87':'56','88':'64','89':'72',
'90':'0','91':'9','92':'18','93':'27','94':'36','95':'45','96':'54','97':'63','98':'72','99':'81'
};

var adc = {
'000':'0','001':'1','002':'2','003':'3','004':'4','005':'5','006':'6','007':'7','008':'8','009':'9',
'010':'1','011':'2','012':'3','013':'4','014':'5','015':'6','016':'7','017':'8','018':'9','019':'10',
'020':'2','021':'3','022':'4','023':'5','024':'6','025':'7','026':'8','027':'9','028':'10','029':'11',
'030':'3','031':'4','032':'5','033':'6','034':'7','035':'8','036':'9','037':'10','038':'11','039':'12',
'040':'4','041':'5','042':'6','043':'7','044':'8','045':'9','046':'10','047':'11','048':'12','049':'13',
'050':'5','051':'6','052':'7','053':'8','054':'9','055':'10','056':'11','057':'12','058':'13','059':'14',
'060':'6','061':'7','062':'8','063':'9','064':'10','065':'11','066':'12','067':'13','068':'14','069':'15',
'070':'7','071':'8','072':'9','073':'10','074':'11','075':'12','076':'13','077':'14','078':'15','079':'16',
'080':'8','081':'9','082':'10','083':'11','084':'12','085':'13','086':'14','087':'15','088':'16','089':'17',
'090':'9','091':'10','092':'11','093':'12','094':'13','095':'14','096':'15','097':'16','098':'17','099':'18',
'100':'1','101':'2','102':'3','103':'4','104':'5','105':'6','106':'7','107':'8','108':'9','109':'10',
'110':'2','111':'3','112':'4','113':'5','114':'6','115':'7','116':'8','117':'9','118':'10','119':'11',
'120':'3','121':'4','122':'5','123':'6','124':'7','125':'8','126':'9','127':'10','128':'11','129':'12',
'130':'4','131':'5','132':'6','133':'7','134':'8','135':'9','136':'10','137':'11','138':'12','139':'13',
'140':'5','141':'6','142':'7','143':'8','144':'9','145':'10','146':'11','147':'12','148':'13','149':'14',
'150':'6','151':'7','152':'8','153':'9','154':'10','155':'11','156':'12','157':'13','158':'14','159':'15',
'160':'7','161':'8','162':'9','163':'10','164':'11','165':'12','166':'13','167':'14','168':'15','169':'16',
'170':'8','171':'9','172':'10','173':'11','174':'12','175':'13','176':'14','177':'15','178':'16','179':'17',
'180':'9','181':'10','182':'11','183':'12','184':'13','185':'14','186':'15','187':'16','188':'17','189':'18',
'190':'10','191':'11','192':'12','193':'13','194':'14','195':'15','196':'16','197':'17','198':'18','199':'19'
} 

Array.prototype.isEmpty = function() {
  return (''+this) === '';
}

function add(a, b, c) {
  var r = '', s = '';
  a = a.split("").reverse();
  b = b.split("").reverse();
  while (!a.isEmpty() || !b.isEmpty() || c !== '0') {
    x = a.isEmpty() ? '0' : a.shift();
    y = b.isEmpty() ? '0' : b.shift();
    s = adc[c + x + y];
    s = s.split("").reverse();
    r = (s.shift()) + r;
    c = (s.isEmpty()) ? '0' : '1';
  }
  return r;
}

function mult(a, b) {
  var s = '0';
  var m = '';
  b.split('').reverse().forEach(function(e) {
    var z = m;
    a.split('').reverse().forEach(function(f) {
      s = add(s, mul[e + f] + z, '0');
      z = z + '0';
    });
    m = m + '0';
  } );
  return s;
}

function test(a, b) {
  var t0 = (new Date()).getTime();
  var r = mult(a,b);
  var t1 = (new Date()).getTime();
  var e = t1 - t0;
  console.log('mult ' + a + ' * ' + b + ' = ' + r + " (" + e + " ms)");
}

test('12345', '42');
test('9999999999', '9999999999');

यह आउटपुट:

mult 12345 * 42 = 518490 (3 ms) 
mult 9999999999 * 9999999999 = 99999999980000000001 (47 ms)
— स्टीफन क्वान
स्रोत
2

हास्केल 507 496

यह मनमाने ढंग से बड़े पूर्णांकों के लिए काम करता है। मैं 0 से 18 तक प्राकृतिक संख्याओं के लिए कस्टम अभ्यावेदन को परिभाषित करता हूं (दो अंकों के योग के बराबर सबसे बड़ी प्राकृतिक संख्या), और अंक * संख्या गुणा के संदर्भ में थोड़ा-एंडियन गुणन को परिभाषित करता है, जिसे मैं संख्या + संख्या जोड़ के संदर्भ में परिभाषित करता हूं , जिसे मैं अंक + अंक जोड़ के रूप में परिभाषित करता हूं। मेरे पास एक कमी फ़ंक्शन है जो उनके डिजिटल अपघटन में 10--18 मूल्यों का विस्तार करता है। यह तब सिर्फ दो तारों को पढ़ता है और उलट देता है, कस्टम बाइंडिंग में अनुवाद करता है, गुणा करता है, और सही परिणाम प्राप्त करने के लिए उलट-पलट करता है।

संपादित करें 2

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

data S=Z|A|B|C|D|E|F|G|H|I|J|K|L|M|N|O|P|Q|R deriving(Enum, Ord, Eq)
p Z=id
p x=succ.p(pred x)
s Z=id
s x=pred.s(pred x)
z=s J
r[]=[]
r(x:y)|x<J=x:r y
r(x:[])=z x:[A]
r(x:y)=z x:(r$p A a:b)where(a:b)=r y
a x y=r$w(r x)(r y)
m Z _=[]
m _[]=[]
m x y=r$a y(m(pred x)y)
t[]_=[Z]
t _[]=[Z]
t(x:z)y=r$a(m x y)(Z:r(t z y))
i '0'=Z
i x=succ.i.pred$x
b Z='0'
b x=succ.b.pred$x
w[]y=y
w x[]=x
w(x:c)(y:d)=p x y:(w c d)
o=map
v=reverse
f=(o i).v
g=v.o b
main=getLine>>=putStrLn.(\[x,y]->g$t(f x)(f y)).words

संदर्भ के लिए, एस कस्टम पूर्णांक की तरह डेटा प्रकार है, p(अंकों + अंकों के जोड़), है 'प्लस' s(कम करने के लिए), घटाने, है rको कम करने (डिजिटल अपघटन में विस्तार) है, aइसके अलावा (संख्या + संख्या अलावा) है, mहै गुणा (अंक * संख्या गुणा), tबार है (संख्या * संख्या गुणा), i'व्याख्या' है (स्ट्रिंग को सूची में बदलें S)।b 'वापस' (एस से स्ट्रिंग की सूची) है, और एफ और जी गोल्फिंग के लिए सिर्फ छोटा कर रहे हैं प्रयोजनों। मैंने संख्याओं का उपयोग नहीं किया, यहां तक ​​कि अंतर्निहित रूप से भी; निकटतम मुझे उत्तराधिकारियों और पूर्ववर्तियों का उपयोग कर रहा था, जो प्राकृतिक संख्याओं को जोड़ने और गुणा करने की तुलना में उच्च स्तर की गणितीय अवधारणाएं हैं।

संपादित करें

टाइम प्रोफाइल को शामिल करना भूल गए।

> time echo "9999999999 9999999999" | runhaskell multnonum.hs
99999999980000000001

real    0m0.246s
user    0m0.228s
sys     0m0.012s

बस अच्छे उपाय के लिए:

> time echo "99999999980000000001 99999999980000000001" | runhaskell multnonum.hs
9999999996000000000599999999960000000001

real    0m0.244s
user    0m0.224s
sys     0m0.016s

चलो पागल हो जाओ!

> time echo "9999999996000000000599999999960000000001 9999999996000000000599999999960000000001" | runhaskell multnonum.hs
99999999920000000027999999994400000000699999999944000000002799999999920000000001

real    0m0.433s
user    0m0.424s
sys     0m0.004s

पुष्टीकरण

— archaephyrryx
स्रोत
1

अजगर 2 - 1165, 712, 668 664

I,T,V,N,X,J=raw_input,dict,reversed,None,zip,''.join
D='0123456789'
z,o='01'
A,B=I(),I()
r=i=""
K=map(J,X('666622222222911111551111555884444447773333333','678945672389954132987698765898967457989837654'))
P=T(X(K,map(J,X('344501110011800000440000332673322124652202211','628480244668154132507698505422648609367491852'))))
S=T(X(K,'cdef678945abi65243ed87a9cbaghcdab89egfcb6a987'))
for d in D:P[z+d]=z;S[z+d]=d
def Z(A,B,R=r):
 for a,b in V(map(N,V(z+A),V(z+B))):c=(a or z)+(b or z);s=S[min(c)+max(c)];R=Z(R,o)+T(X('abcdefghi',D))[s]if s>"?"else R+s
 return R
for a in V(A):
 j=""
 for b in V(B):r=Z(r,P[min(a+b)+max(a+b)]+i+j).lstrip(z);j+=z
 i+=z
print r if r else z

ध्यान दें कि मैं जैसे तार्किक अनुक्रमण का उपयोग नहीं कर रहा हूं Z = [X, Y][N == "0"], क्योंकि यह एक संख्यात्मक सूचकांक के लिए डाली गई बूलियन के रूप में व्याख्या की जा सकती है।

Ungolfed:

A = raw_input()
B = raw_input()

P = {'00':'00','01':'00','02':'00','03':'00','04':'00','05':'00','06':'00','07':'00','08':'00','09':'00',
     '10':'00','11':'01','12':'02','13':'03','14':'04','15':'05','16':'06','17':'07','18':'08','19':'09',
     '20':'00','21':'02','22':'04','23':'06','24':'08','25':'10','26':'12','27':'14','28':'16','29':'18',
     '30':'00','31':'03','32':'06','33':'09','34':'12','35':'15','36':'28','37':'21','38':'24','39':'27',
     '40':'00','41':'04','42':'08','43':'12','44':'16','45':'20','46':'24','47':'28','48':'32','49':'36',
     '50':'00','51':'05','52':'10','53':'15','54':'20','55':'25','56':'30','57':'35','58':'40','59':'45',
     '60':'00','61':'06','62':'12','63':'18','64':'24','65':'30','66':'36','67':'42','68':'48','69':'54',
     '70':'00','71':'07','72':'14','73':'21','74':'28','75':'35','76':'42','77':'49','78':'56','79':'63',
     '80':'00','81':'08','82':'16','83':'24','84':'32','85':'40','86':'48','87':'56','88':'64','89':'72',
     '90':'00','91':'09','92':'18','93':'27','94':'36','95':'45','96':'54','97':'63','98':'72','99':'81',
     }
S = {'00':'0','01':'1','02':'2','03':'3','04':'4','05':'5','06':'6','07':'7','08':'8','09':'9',
     '10':'1','11':'2','12':'3','13':'4','14':'5','15':'6','16':'7','17':'8','18':'9','19':'a',
     '20':'2','21':'3','22':'4','23':'5','24':'6','25':'7','26':'8','27':'9','28':'a','29':'b',
     '30':'3','31':'4','32':'5','33':'6','34':'7','35':'8','36':'9','37':'a','38':'b','39':'c',
     '40':'4','41':'5','42':'6','43':'7','44':'8','45':'9','46':'a','47':'b','48':'c','49':'d',
     '50':'5','51':'6','52':'7','53':'8','54':'9','55':'a','56':'b','57':'c','58':'d','59':'e',
     '60':'6','61':'7','62':'8','63':'9','64':'a','65':'b','66':'c','67':'d','68':'e','69':'f',
     '70':'7','71':'8','72':'9','73':'a','74':'b','75':'c','76':'d','77':'e','78':'f','79':'g',
     '80':'8','81':'9','82':'a','83':'b','84':'c','85':'d','86':'e','87':'f','88':'g','89':'h',
     '90':'9','91':'a','92':'b','93':'c','94':'d','95':'e','96':'f','97':'g','98':'h','99':'i',
     }
L = {'a':'0','b':'1','c':'2','d':'3','e':'4','f':'5','g':'6','h':'7','i':'8'}

def strSum(A, B):
    R = ""
    for a, b in reversed(map(None, reversed("0" + A), reversed("0" + B))):
        if a == None: a = '0'
        if b == None: b = '0'
        s = S[a + b]
        if s.isdigit():
            R += s
        else:
            R = strSum(R, "1") + L[s]
    return R

i = ""
r = "0"
for a in reversed(A):
    j = ""
    for b in reversed(B):
        p = P[a + b] + i + j
        r = strSum(r, p)
        j += "0"
    i += "0"

r = r.lstrip("0")
if r == "":
    r = "0"

print r
— फ़ाल्को
स्रोत
मैं कहूंगा कि न्यूनतम () और अधिकतम () कार्यों का उपयोग करने की अनुमति नहीं दी जानी चाहिए क्योंकि वे वास्तविक पूर्णांक मानों की तुलना कर रहे हैं, क्या वे नहीं हैं?
— वर्ल्डसेंडर
@WorldSEnder: मैं कहूंगा कि वे पात्रों की तुलना करते हैं, जिन्हें इस चुनौती में अनुमति दी गई है। ("वर्णों की लेक्सोग्राफिक तुलना की अनुमति है।")
— फाल्को
1

स्काला, 470 वर्ण

( ⇒मानक स्कैला हैं, लेकिन =>यदि हम बाइट्स की गिनती कर रहे हैं, तो इसे बदल दिया जा सकता है )

def p(a: String,b: String)={type D=List[Char]
val d="0123456789".toList
def v(s: String)=s.toList.map{c⇒d.takeWhile(c.!=)}
def u(l:D, a:D):(Char,D)=l match {
case _::_::_::_::_::_::_::_::_::_::m⇒u(m,'a'::a)
case _⇒(('a'::l).zip(d).last._2,a)}
val o=(("", List[Char]())/:v(a).tails.toList.init.map{l⇒(v(b) map {_.flatMap(_⇒l.head)})++l.tail.map(_⇒Nil) reverse}.reduce(_.zipAll(_, Nil, Nil).map{t⇒t._1++t._2}))({(t,e)⇒val s=u(t._2++e,Nil);(s._1+t._1,s._2)})
u(o._2, Nil)._1+o._1}

यहां हम सूचियों की लंबाई का उपयोग करके अंकों का अनुकरण कर रहे हैं, किसी भी संख्यात्मक कार्यों का उपयोग न करने के लिए सावधान रहें - केवल सिलवटों, नक्शे, ज़िप और इसी तरह। एक संख्या इन अंकों की एक सूची है (क्रमिक रूप से गणना के माध्यम से आधा उल्टा क्रम); हम अलग-अलग अंकों को flatMapअपनी पंक्तियों के साथ गुणा करते हैं reduce। uकैरी को संभालना (10 तत्वों की सूची के खिलाफ सीधे मिलान करके और पुनरावर्ती करना) और अंकों को वर्णों में बदलना, और हम /:उसी के साथ स्टैक के माध्यम से अपना काम करने के लिए उपयोग करते हैं। आवश्यक उदाहरण एक सेकंड से भी कम समय में पूरा होता है।

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