কোনও সংখ্যা ব্যবহার না করে দুটি সংখ্যাকে গুণ করুন


30

বেস 10 তে ইতিবাচক পূর্ণসংখ্যার প্রতিনিধিত্ব করে আপনাকে ইনপুট হিসাবে দুটি স্ট্রিং দেওয়া হবে, যেমন "12345"এবং "42"। আপনার কাজটি হ'ল "518490"এই ক্ষেত্রে তাদের পণ্য যুক্ত একটি স্ট্রিং আউটপুট করা ।

মোড়টি হ'ল আপনি আপনার কোডে কোনও সংখ্যক প্রকার ব্যবহার করতে পারবেন না। না ints, floatগুলি, unsigned longএস, ইত্যাদি, কোনও অন্তর্নির্মিত জটিল সংখ্যার ধরণ বা স্বেচ্ছাসেবী নির্ভুলতা পূর্ণসংখ্যা, বা lines লাইনগুলি বরাবর কিছুই নয়। আপনি অনেকগুলি এই ধরণের আক্ষরিক ব্যবহার করেন না বা কোনও ফাংশন, পদ্ধতি, অপারেটর ইত্যাদি ব্যবহার করেন না যা এগুলি দেয়।

আপনি স্ট্রিং, বুলিয়ান, অ্যারে বা অন্য কোনও কিছু ব্যবহার করতে পারেন যা সাধারণত কোনও সংখ্যার প্রতিনিধিত্ব করতে ব্যবহৃত হয় না। (তবে মনে রাখবেন যে একটি অ্যারেতে সূচি তৈরি করা বা তার দৈর্ঘ্য না পাওয়া কোনও সংখ্যক প্রকারের সাহায্যে প্রেরণ না করেই সম্ভব হতে পারে)) charএর অনুমতি দেওয়া হয়েছে তবে আপনি তাদের উপর কোনও গাণিতিক বা বিটওয়াইজ অপারেশন করতে পারবেন না বা অন্যথায় এগুলি ছাড়া অন্য কোনও কিছু হিসাবে বিবেচনা করবেন না s একটি টোকেন একটি স্ট্রিংয়ের অংশ উপস্থাপন করে। (এর লিক্সোগ্রাফিকাল তুলনা charঅনুমোদিত))

আপনি সীমাবদ্ধতার আশেপাশে কাজ করতে পারেন না। এর মধ্যে রয়েছে (তবে এতে সীমাবদ্ধ নয়) কোনও evalপ্রকারের ফাংশনের অভ্যন্তরে সংখ্যাসূচক প্রকারগুলি ব্যবহার করে, সংখ্যাসূচক প্রকারে অন্তর্নিহিত ধরণের রূপান্তরকরণ, সংখ্যাসূচক বা বিটওয়াইজ অপারেটরগুলি ব্যবহার করে যা তাদের সমর্থন করে, ধারক প্রকারের ভিতরে সঞ্চিত সংখ্যাসূচক প্রকারগুলি ব্যবহার করে, বা কলিং ফাংশনগুলি বা বাহ্যিক প্রোগ্রামগুলি যে স্ট্রিং আকারে সংখ্যাসূচক ফলাফল দেয়। (উত্তরে অন্যান্য কর্মক্ষেত্রগুলি উপস্থিত হলে আমি এই তালিকায় যুক্ত করার অধিকার সংরক্ষণ করি)) আপনাকে কেবলমাত্র অ-সংখ্যািক প্রকারের সাহায্যে গুণটি নিজেই প্রয়োগ করতে হবে।

ইনপুট এবং আউটপুট যে কোনও সুবিধাজনক পদ্ধতির দ্বারা হতে পারে, যতক্ষণ না কোনও স্ট্রিং আকারে ডেটা আপনার কোডটি প্রবেশ করে এবং প্রস্থান করে। আপনি ধরে নিতে পারেন দুটি ইনপুট আর্গুমেন্টগুলির প্রত্যেকটিতে কেবলমাত্র ASCII অক্ষর রয়েছে [0-9]এবং এটি দিয়ে শুরু হবে না 0। আপনার আউটপুটে নেতৃস্থানীয় জিরো থাকা উচিত নয়।

আরও একটি জিনিস: আপনার কোড অবশ্যই কমপক্ষে 10 অক্ষর দৈর্ঘ্যের ইনপুটগুলি সঠিকভাবে পরিচালনা করতে হবে এবং অবশ্যই এই সীমাতে থাকা সমস্ত ইনপুটগুলির জন্য একটি আধুনিক কম্পিউটারে এক মিনিটের মধ্যে চলতে হবে । পোস্ট করার আগে, দয়া করে পরীক্ষা করে নিন যে ইনপুট দেওয়ার সময় 9999999999এবং 9999999999, আপনার প্রোগ্রামটি 99999999980000000001এক মিনিটেরও কম সময়ে একটি আউটপুট দেয় । আকারের অ্যারে বরাদ্দ করে a*bএবং তারপরে পুনরাবৃত্তি করে যে কাজ করে এমন উত্তরগুলি রোধ করার জন্য এই সীমাবদ্ধতাটি বিশেষভাবে বিদ্যমান , সুতরাং দয়া করে মনে রাখবেন যে এই ফর্মের উত্তরগুলি জয়ের যোগ্য হবে না।

এটি , সুতরাং সংক্ষিপ্ততম বৈধ সমাধান (বাইটে) জিতেছে।


আমরা কি এর "12345"চেয়ে এসটিডিএন থেকে গ্রহণ করতে পারি 12345? অথবা আমরা উভয় সংখ্যা হিসাবে গ্রহণ করতে পারি "12345", "42"?
জাস্টিন

আমার প্রথম চিন্তা একটি ফাংশন দৈর্ঘ্য স্ট্রিং আর্গুমেন্ট গ্রহণ লিখতে ছিল mএবং nএবং দৈর্ঘ্যের একটি আর্গুমেন্ট ফেরার m*n। তবে স্ট্রিংগুলিতে আক্ষরিক অর্থে সংখ্যার ASCII উপস্থাপনা থাকতে হবে বলে আমি অনুমান করি যে এটি নিয়মের বিপরীতে।
স্তর নদী সেন্ট

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)

দেখে মনে হচ্ছে আমাদের নতুন বিজয়ী আছে! (যদিও আগের মতোই, আমি এই ডিগ্রিটির হ্যাস্কেলটি পড়তে পারি না - কেউ কি স্বাধীনভাবে এটি পরীক্ষা করে দেখতে পারে?)
নাথানিয়েল

(এছাড়াও ['0' .. '9'] অক্ষরকে সংখ্যার মতো স্পষ্টভাবে আচরণের মতো মনে করে যা পুনরাবৃত্তি করা যায় - তার পরিবর্তে "0123456789" স্ট্রিং থেকে সেই তালিকাটি তৈরি করার কোনও সংক্ষিপ্ত উপায় আছে?)
নাথানিয়েল

@ নাথানিয়েল ওয়েল সমস্ত স্ট্রিংয়ের প্রথমটি "0123456789" হল তালিকা ['0'..'9']। দ্বিতীয়ত, হাস্কেলের মধ্যে [a..b] একটি গণনা, Enumটাইপক্লাসের উদাহরণগুলি যেমন ঘোষণা করা হয়েছে সেগুলিও সেইভাবে গণনা করা যেতে পারে এবং ঘোষণাপত্রটি বর্ণনা করে যে কীভাবে গণনাটি কাজ করে। Bool, বুলিয়ান ধরণের একটি উদাহরণও রয়েছে এবং তাই আপনি এটিও করতে পারেন [False..True]। জড়িত কোনও সংখ্যা রয়েছে।
এমনিআইপি

14

সেড, 339 338 বাইট

আমি জানি এটি একটি পুরানো, তবে আমি ব্রাউজ করছিলাম এবং এটি আমার আগ্রহ প্রকাশ করেছে। আসলে একজন ব্যবহারকারী হিসাবে নিবন্ধন করা যথেষ্ট! আমি অনুমান করি যে " আমি সম্পূর্ণ সিড সলিউশনটি দেখতে চাই - নাথানিয়েল " ...

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

আপনি শেষ দুটিকে আরএসএ -100 (50 x 50 সংখ্যা) এবং আরএসএ -768 (116 x 116 সংখ্যা) হিসাবে স্বীকৃতি দিতে পারেন।

খুব বেশি আধুনিক (২০০--এর যুগের ইন্টেল কোর ২) জিএনইউ সেড ব্যবহার করে, এর মধ্যে শেষটি এক মিনিটের বেশি সময় নেয়, তবে এটি আরও নতুন প্রসেসরের উপর দ্রুত আসে:

  • Q6600:> 1 মিনিট
  • i7-3770: 26 সেকেন্ড
  • i7-6700: 22 সেকেন্ড

প্রশ্নের মধ্যে উল্লিখিত শাস্তিযুক্ত 10-সংখ্যার গুণিতক এর কোনওটির (প্যাথলজিকাল নাইনগুলি পূর্ণ থাকা সত্ত্বেও) এক সেকেন্ডের অধীনে ভাল লাগে।

আমি বিশ্বাস করি এটি স্ট্যান্ডার্ড সেড, কোনও এক্সটেনশন ছাড়াই। পসিক্স কেবল 8192 বাইটের স্থান ধারণের গ্যারান্টি দেয়, যা আমাদের 400x400 অঙ্কের সংখ্যাগুলিতে সীমাবদ্ধ করে, তবে বাস্তবায়ন আরও সরবরাহ করতে পারে। GNU সেড কেবল উপলভ্য মেমরির দ্বারা সীমাবদ্ধ, তাই আপনি অপেক্ষা করতে ইচ্ছুক হলে আরও বড় কিছু পরিচালনা করতে পারে।

এবং আমি আত্মবিশ্বাসী যে আমি নিয়মগুলি মেনে চলেছি - এটি প্রায় এমন একটি ভাষায় দেওয়া আছে যার কোনও সংখ্যা নেই। :-)

ব্যাখ্যা

দশমিক সংখ্যাগুলি আনারির ক্রমে রূপান্তরিত করে আমি একটি অ্যানারি / দশমিক সংকর ব্যবহার করি:

 42 => _xxxx_xx

অবিচ্ছিন্ন দশমিক, সংযোজন সহজ। আমরা কমপক্ষে-তাত্পর্যপূর্ণ থেকে সর্বাধিক-উল্লেখযোগ্য অঙ্কে পুনরাবৃত্তি করি, এক্স এর সাথে যুক্ত করে:

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

তারপরে আমরা হোয়াইটস্পেস সরিয়ে ফেলি এবং পরের দশটি এক্স এর পরের ইউনিটে রূপান্তর করে ক্যারি নিয়ে ডিল করি:

 _xxxxxxxxxx_xxxxxx_xxxxxxxxxxx       10.6.11
 _xxxxxxxxxx_xxxxxxx_x                10.7.1
 _x__xxxxxxx_x                        1.0.7.1 

একবার আমাদের যোগ করার পরে, গুণগুলি সম্ভব lic Y এর শেষ সংখ্যাটি বিবেচনা করে আমরা x * y গুণ করি। বহুবার এক্সকুলেটরটিতে এক্স যোগ করুন, তারপরে পরবর্তী অঙ্কে যান এবং এক্সকে এক দশমিক স্থান বামে স্থানান্তর করুন। 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 বাইট

এই উজ্জ্বল উত্তরের ক্রেডিট ইউনিক্স এবং লিনাক্স.এসইতে @ লুইজিটিবুরজি ওভারে যায়: 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হয়ে যায়<|<||*<|||
  • বারবার প্রতিস্থাপন |<সঙ্গে <||||||||||জন্যে উচ্চ দশমিক স্থান ইউনিট অবস্থানে সব নিচে নামান হবে। এভাবে <|<||*<|||হয়ে যায়<||||||||||||*<|||
  • সরান <। এভাবে <||||||||||||*<|||হয়ে যায়||||||||||||*|||
  • |এর আরএইচএস থেকে 1 সরান *। এভাবে ||||||||||||*|||হয়ে যায়||||||||||||*||
  • বারে |বারে আরএইচএসের প্রত্যেকটি এলএইচএসের সাথে প্রতিস্থাপন করুন |। এর ফলে এলএইচএস এবং আরএইচএস সংখ্যাকে গুণিত করার |ফলে | এইভাবে পণ্য সংখ্যাটি দেওয়া ||||||||||||*||যায়||||||||||||||||||||||||||||||||||||*
  • সরান *। এভাবে ||||||||||||||||||||||||||||||||||||*হয়ে যায়||||||||||||||||||||||||||||||||||||
  • |প্রথম কয়েকটি পদক্ষেপের বিপরীতে দশমিককে পিছনে সংখ্যায় রূপান্তর করুন । এভাবে ||||||||||||||||||||||||||||||||||||হয়ে যায় 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
এটি প্রায় অ্যালগোরিদমিকভাবে সংখ্যার অংশে ফিরে রূপান্তর ব্যতীত আমার মোছা জেএস উত্তরের সমতুল্য।
অপ্টিমাইজার 20

@ অপ্টিমাইজার সম্মত পার্থক্যটি হ'ল আপনার ব্যবহারগুলি length()যা একটি নম্বর দেয়। এটির কোনও সংখ্যক প্রকারবিহীন বিশুদ্ধরূপে রেগেক্স বিকল্প ব্যবহার করে। আমি মনে করি আপনার উত্তরটি সম্ভাব্য বিজয়ী যদিও আপনি যদি এটি সরিয়ে ফেলতে পারেন length()- সম্ভবত আপনি এর পরিবর্তে কিছু অনুরূপ রেজেক্স বিকল্প করতে পারেন?
ডিজিটাল ট্রমা

1
খুব সুন্দর, তবে এক মিনিটের সীমাবদ্ধতাটি নির্দিষ্টভাবে উত্তরগুলি গণনা করে কাজ করে এমন সমাধানগুলি প্রতিরোধের জন্য বোঝানো হয়। যদিও আমি একটি সম্পূর্ণ সেড সমাধান দেখতে চাই।
নাথানিয়েল

1
আমার কাছে একটি উত্তর রয়েছে যা বড় সংখ্যায় কাজ করে (যেমন সিস্টেমের ঠিকানা জায়গার চেয়ে বড়)।
টবি স্পিড

@ টবিস্পাইট হ্যাঁ, খুব ভাল। আমি মনে করি কিছুক্ষণ আগেই আমি অবশ্যই আপনার আপগ্রেড করেছি :)
ডিজিটাল ট্রমা

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 টি অক্ষরের প্রয়োজন নেই are

এটি মূলত হাতে হাতে মানক গুণটি সম্পাদন করে। অঙ্কগুলি পুনরাবৃত্তিগুলির স্ট্রিং হিসাবে উপস্থাপিত হয় I(আদিম রোমান সংখ্যার মতো)। নম্বরগুলি বিপরীত ক্রমে অঙ্কের তালিকা হিসাবে প্রতিনিধিত্ব করা হয়। একক অঙ্কের সংযোজন স্ট্রিং কোকেটেনটিং করে এবং Iপ্রয়োজনে দশটি মুছে ফেলা দ্বারা সম্পাদিত হয় ।

এখানে একটি অবারিত সংস্করণ:

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

1
এই মায়া কি! এটা কিভাবে কাজ করে! কি দারুন. এছাড়াও, আপনি করতে পারেন এমন আরও একটি গল্ফ এখানে রয়েছে: def A(x,y):\n S=[];o=""-> def A(x,y,S=[],o=""):। দুর্ভাগ্যক্রমে, ["","1"][t in i]অনুমোদিত নয়; এটি একটি সংখ্যার হিসাবে বিবেচনা করে সূচকগুলিতে একটি বুল ব্যবহার করছে। আমি মনে করি এটি t in i and"1"or""কাজ করা উচিত, যদিও।
জাস্টিন

@ কুইনকুনাক্স: 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)

ব্যবহার: আমি এটি একটি কৃষক.আরবি নামক একটি ফাইলে রেখেছিলাম:

$ time ruby peasant.rb 9999999999 9999999999
99999999980000000001

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

ব্যাখ্যা: এটি কৃষকের গুণ, তাই আমি বারবার অর্ধেক এবং দ্বিগুণ। অর্ধবৃদ্ধি করা সংখ্যাগুলি অর্ধগোলন করে এবং এর মতো অবশিষ্টাংশগুলি চিহ্নিত করে করা হয়: 1234 -> 0 বি 1 এ 1 বি 2 এ; তারপরে বি এর সন্ধান করুন এবং প্রতিস্থাপন করুন: 06a17a; তারপরে পরিষ্কার করা -> 617।

সংযোজনটি এর মতো হয় ... সবার আগে, আমি উভয় স্ট্রিংকে একই দৈর্ঘ্যে প্যাড করব এবং অঙ্কগুলি থেকে জোড় তৈরি করব। তারপরে আমি একটি স্ট্রিং তৈরি করে ডিজিটগুলি যুক্ত করি যা প্রতিটি অঙ্কের দৈর্ঘ্য এবং সংক্ষিপ্ত করে তোলে; আমি '0123456789abcdefghij' এর শুরু থেকে সেই দৈর্ঘ্যের একটি স্ট্রিং সরিয়েছি এবং তারপরে প্রথম চরটি রাখি। সুতরাং, যেমন, "9" + "9" -> "আমি"। NB আমি সংখ্যার ধরণের পুরোপুরি এড়াতে এখানে দৈর্ঘ্যের ফাংশনগুলি ব্যবহার করা এড়াতে চাই; উপসর্গ অপসারণ পরিবর্তে একটি regexp সঙ্গে সম্পন্ন করা হয়।

সুতরাং এখন আমি অঙ্ক এবং অক্ষরের মিশ্রণ একটি স্ট্রিং আছে। বর্ণগুলি একটি বহন অঙ্ক সহ সংখ্যাগুলি উপস্থাপন করে; আমি সংখ্যায় 0 টি প্রিপেন্ড করি, তারপরে সংযোজনটি সম্পূর্ণ না হওয়া পর্যন্ত বার বার বহন করার ফলাফলের সাথে ডিজিটাল-লেটারের ধরণগুলি প্রতিস্থাপন করব।


1
খুব চতুর উত্তর, ঠিক কী ধরণের জিনিসটি আমি আশা করে দেখছিলাম!
নাথানিয়েল

1
আমি আসলে আশা করছি যে কেউ চার্চের সংখ্যার সাথে একটি পোস্ট করবে!
বাজহারঘ

এটি দুর্দান্ত হবে, যদিও আমি নিশ্চিত নই যে এটি দক্ষতার প্রয়োজনীয়তা নিয়ে কাজ করবে কিনা - আমি মনে করি স্ট্রিং এবং চার্চ সংখ্যাগুলির মধ্যে রূপান্তর কার্যকরভাবে 99999999980000000001 পর্যন্ত গণনা জড়িত থাকতে পারে।
নাথানিয়েল

7

ব্রেইনফাক (1328 বাইট)

প্রথমে বিবেচনাগুলি:

  • ব্রেইনফাক এই প্রশ্নের একটি কার্যকর উত্তর কিনা তা নিশ্চিত নন যেহেতু আপনি নিশ্চিত নন যে আপনি কোষের মানগুলি 'সংখ্যাসূচক প্রকার' হিসাবে বিবেচনা করছেন কিনা। আমি মনে করি না যেহেতু বিএফ টাইপগুলি জানে না, তবে এটি আমার নিজের মতামত, আমি ভুল হলে দয়া করে আমাকে সংশোধন করুন।
  • একটি বাস্তবায়ন সমর্থনকারী (প্রায়) সীমাহীন মানগুলি প্রয়োজনীয়।
  • বাস্তবায়নের ভিত্তিতে এটি অনেক ধীর হতে পারে।

আমি প্রোগ্রামটি কেবল আমার নিজস্ব দোভাষী দিয়ে পরীক্ষা করেছি, আপনি এটি এখানে খুঁজে পেতে পারেন ।

ইনপুট অবশ্যই উভয় সংখ্যা একক 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
[<+>-]<[>>+>+<<<-]>>>[<<<+>>>-]<[[-]<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<-]>[<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<->>[-]]+>-]<-]<<+>]<[>>+<<-]>>[<<<[>+>+<<-]>>[<<+>>-]>-]<<[<<->>-]<[-]<[>>>>>>>>+<<<<<<<<-]>>>>>>>>>[>>]+[<<]>[>[>>]<+<[<<]>-]<<<<<<<<<<[>>+>+<<<-]>>>[<<<+>>>-]+[<+>-]<<<[-]>>[<<+>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]++++++++++<[>>+<<-]>>[<[>>+>+<<<-]>>>[<<<+>>>-]<[>+<<-[>>[-]>+<<<-]>>>[<<<+>>>-]<[<-[<<<->>>[-]]+>-]<-]<<<+>>]<[-]<<<<[-]>>>[<<<+>>>-]<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[<+>-]<]<[>+>+<<-]>>[<<+>>-]<[>+<[-]]+>[<[-]<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<[[-]>>>>>>>>[>>]<[<[<<]<<<<<+>>>>>>>[>>]<-]<-<<[<<]<<<<<>++++++++++++++++++++++++++++++++++++++++++++++++[<+>-]<.[-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]+[<->-]<<<<<[-]>>>>[<<<<+>>>>-]<<<<[>>>>+>+<<<<<-]>>>>>[<<<<<+>>>>>-]<[<+>-]<]<[-]]<[>>++++++[<++++++++>-]<.[-]<[-]]<[-]<[-]>>>>>>>>>>>>[>[-]>]<<[-<<]<<<<<<<<<<<<<<<<<[-]<[-]

আমি এই উত্তর থেকে মান আউটপুট জন্য কোড নিয়েছি , যে জন্য লেখক ধন্যবাদ!

প্রোগ্রামটি বৈধ নাও হতে পারে তবে উভয় উপায়েই আমি এটি আপনার সাথে ভাগ করে নিতে চাই ^^

আপডেট: আপনি এখন এটি পরীক্ষা করতে পারেন (কেবলমাত্র ছোট গুণগুলির জন্য) এই প্রতিযোগিতায় @ এসপি 3000 এর উত্তর এবং এসই এর নতুন স্ট্যাক স্নিপেটসকে ধন্যবাদ !

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>


আমি জানি না এটি বৈধ কিনা! আমার ধারণা হয় ব্রেনফাকের সবকিছুই একটি সংখ্যা, বা কিছুই নয়।
নাথানিয়েল

আমি এই উত্তরটি পছন্দ করি। আমি ইদানীং বিএফের সাথে ঝামেলা করছি। এটি মেশিন পর্যায়ে সমস্ত কিছু যেভাবেই টোকেন তা এই বিষয়টির উপর আলোকপাত করে। এটি সত্যিই বিধিগুলি অনুসরণ করে কিনা তা বলা শক্ত।
অক্টোপাস

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' => [আর, আর, আর, আর, আর]), তালিকাগুলি একত্রিত করুন, তারপরে ফিরে রূপান্তর করুন। অ্যানারি ডিজিট হিসাবে 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'?
জাস্টিন

@ কুইনকুনস: ধন্যবাদ শেষটি কাজ করবে না কারণ প্রথম পুনরাবৃত্তির bউপর একটি স্ট্রিং রয়েছে, তালিকা নয়।
কিথ র্যান্ডাল 5

আপনি এড়িয়ে Mএকটি সম্পূর্ণ প্রোগ্রাম লিখতে পারেন; a,b=input() অনুমতি দেওয়া হয়.
জাস্টিন 6

1
খ * 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

সম্পাদনা করুন Golfed
সম্পাদনা বাগ সংশোধন: একটি বহন পতাকা ক্লিয়ারিং নিখোঁজ

এটি প্রায় 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

সম্ভবত একটি সামান্য বাগ আছে - 9999999999কেস থেকে আউটপুট হওয়া উচিত 99999999980000000001, না99999999980000000081
নাথানিয়েল

:( চেক করতে যাচ্ছেন
edc65

আপনি যদি গুণের টেবিলগুলি ব্যবহার করছেন, তবে আপনি কীভাবে এই সংলাপের অনুমতিপ্রাপ্ত নয় এমন আশেপাশে পাচ্ছেন?
সিটিও

1
সামেশনের একটি হ্যাশটেবল (কোডগুলিতে) ব্যবহারের অনুমতি দেওয়া হয়েছে। যাত্রা। s ['34 '] ->' 7 '। শুধু চিহ্ন নয়, সংখ্যা নয়।
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

এই পদ্ধতির পক্ষে যথেষ্ট দ্রুতগতি সম্পন্ন যে এমনকি ২০০op সালের ল্যাপটপে অযৌক্তিক ghসিআইপিএল-তেও পরীক্ষার কেসটি একটি সেকেন্ডের মাত্র একটি ভগ্নাংশ নেয়:

λ> :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। এটি বিশেষত চালাক বা দক্ষ নয়, তবে এটি কাজটি করে gets এটি সম্ভবত আগে করা হয়েছে।

নোট করুন যে xচিত্রটির মাত্রা বোঝায়; এটি এই প্রসঙ্গে পাটিগণিত অপারেটর নয়।

আমি এটি পরীক্ষা করি নি, তবে আমি ধরে নিতে চাই না যে চরম-অবিশ্বাস্য ইনপুটটির জন্য এটি এক মিনিটের মধ্যেই শেষ হয়ে যাবে। আমি আগামীকাল এটি পরীক্ষা করতে পারি।

ইমেজম্যাগিক সংস্করণগুলির সাথে যদি কোনও মজার ব্যবসা না ঘটে তবে এটিই আমি ব্যবহার করছি: ImageMagick 6.7.7-10


ভাল চেষ্টা করুন, তবে আমি নিশ্চিত যে ইনপুট 9999999999এবং এর জন্য এটি এক মিনিটের (বা আসলে কোনও বিদ্যমান মেশিনে মোটেও) কাজ করবে না 9999999999
নাথানিয়েল

4
এই কাজ করে: dd if=/dev/zero bs=$a count=$b 2>&-|wc -c
জিমি 23013

1
9999999999x99999999998 বিট ফর্ম্যাটে একটি চিত্র বর্তমানে পৃথিবীতে বিদ্যমান সমস্ত হার্ড ড্রাইভের স্থান গ্রহণ করবে। অবশ্যই, প্রথমে কোনও কাঁচা চিত্র তৈরি না করে এটি তৈরি করতে পারলে একটি পিএনজি অনেক ছোট হবে। (যদিও আমি দৃ strongly়ভাবে সন্দেহ করি যে আপনার সেই আকারের একটি ইমেজ সহ পূর্ণসংখ্যার ওভারফ্লো সমস্যা হবে)) তবে তবুও, এই জাতীয় পদ্ধতিটি অবশ্যই অবশ্যই কলিং-জিনিসগুলি-যে-প্রত্যাবর্তন-সংখ্যাসূচক-ফলাফলগুলি-এর-স্ট্রিংসের লুফোলটিকে ঘৃণা করবে।
নাথানিয়েল

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পুনরাবৃত্তিকে স্ট্রিংগুলিতে রূপান্তর করে)

  • i1 একটি স্ট্রিং নম্বর, মত ক্ষেত্রে সহ বৃদ্ধি 39+1=40এবং 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 + + কদম; পরিবর্তে ব্যবহার ;। এছাড়াও, আমি মনে করি 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)যদিও এটি আপনার প্রোগ্রামের গতি উল্লেখযোগ্যভাবে পরিবর্তন করতে পারে।
জাস্টিন

ধন্যবাদ! আমি আজ সকালে আরও কয়েকটি উন্নতি দেখতে পাচ্ছি। (বেশিরভাগ ক্ষেত্রে ফাংশনগুলি সংজ্ঞায়নের পরিবর্তে লুপগুলি বাসা বাঁধে)) আরও কিছু প্রতিযোগিতামূলক উত্তর উপস্থিত হলে আমি এই পরিবর্তনগুলি করব, যা সম্ভবত মনে হয় - বর্তমানে তারা আমাকে নেতৃত্ব দেবে, যা আমার প্রশ্ন এবং আমি কিছুটা অন্যায় বলে মনে হচ্ছে বলে আমি মনে করি '' এটা সম্পর্কে চিন্তা করতে আর ছিল।
নাথানিয়েল

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

আমি বহু-চরিত্র কমান্ড আমি একাধিকবার ব্যবহার, সেইসাথে সরানোর স্পেস এবং প্রথম বন্ধনী, স্বল্প স্থানীয় alias লেখা তৈরি করে এবং প্রতিস্থাপন করে কয়েকটি অক্ষর সংরক্ষিত (- )সঙ্গে জোড়া $যখন সম্ভব।

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

অনুমোদন


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

আমি বলব যে ন্যূনতম () এবং সর্বোচ্চ () ফাংশনগুলি ব্যবহারের অনুমতি দেওয়া উচিত নয় কারণ এগুলি প্রকৃত পূর্ণসংখ্যার মানগুলির সাথে তুলনা করছে, তাই না?
ওয়ার্ল্ডসেন্ডার

@ ওয়ার্ল্ড এসেন্ডার: আমি বলব তারা অক্ষরগুলির সাথে তুলনা করবে, যা এই চ্যালেঞ্জটিতে অনুমোদিত। ("বর্ণের লিক্সোগ্রাফিকাল তুলনা অনুমোদিত" ")
ফালকো

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এবং আমাদের সারিগুলি দিয়ে গুণ করি reduceuক্যারিটি সনাক্তকরণ (10 টি উপাদানের তালিকার সাথে সরাসরি মিলের মাধ্যমে এবং পুনরাবৃত্তি করে) এবং অঙ্কগুলিকে অক্ষরগুলিতে ফিরে রূপান্তরিত করে এবং আমরা /:স্ট্যাকটি দিয়ে আমাদের পথে কাজ করতে ব্যবহার করি। প্রয়োজনীয় উদাহরণটি এক সেকেন্ডেরও কম সময়ে পূর্ণ হয়।

আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.