প্রদত্ত সংখ্যার একাধিক সন্ধান করুন যার দশমিক প্রতিনিধিত্ব বাইনারি মত দেখাচ্ছে


34

আমি কোড রিভিউ সাইটে একটি প্রশ্ন এসেছি যা আকর্ষণীয় বলে মনে হচ্ছে। আমি মনে করি ওপি এটি ভুল করছে, তবে নিশ্চিত হতে পারে না ... সুতরাং আসুন এটির সমাধান করুন! (একটি প্রোগ্রাম লিখুন, কোন ফাংশন / পদ্ধতি নয়)

ইনপুট (স্টিডিন বা অনুরূপ):

xদশমিক স্বীকৃতিতে একটি পূর্ণসংখ্যা । এটি 1 এর চেয়ে বেশি এবং 2 ^ 31 এর চেয়ে কম।

আউটপুট (stdout বা অনুরূপ):

yদশমিক স্বীকৃতিতে একটি পূর্ণসংখ্যা । x * yদশমিক উপস্থাপনে পণ্যটিতে কেবল 0 এবং 1 সংখ্যা থাকা আবশ্যক It এটি 0 এর চেয়ে কম সংখ্যক সংখ্যক হতে হবে।

দ্রষ্টব্য: আউটপুট সীমাবদ্ধ নয় - যদি সর্বনিম্ন y10 ^ 100 এর কাছাকাছি হয় তবে আপনার প্রোগ্রামটি অবশ্যই তার 100 টি সংখ্যার আউটপুট অবশ্যই বের করবে (2 ^ 64 এর মতো কোনও যুক্তিসঙ্গত সীমা আছে কিনা তা আমি জানি না y- এটি সমাধান করেনি )।

আপনার প্রোগ্রামটি যথাযথ সময়ে (1 সেকেন্ড? 1 ঘন্টা? - এমন কিছু) xসীমাতে থাকা উচিত।

বোনাস:

যদি আপনার প্রোগ্রামটির ইনপুট (র‌্যাম ব্যতীত) আকারের কোনও সীমা না থাকে এবং বহুবচনীয় জটিলতা থাকে তবে আপনার প্রোগ্রামের বাইট গণনাটি বার বার করে গুণান 0.8


উদাহরণ: ইনপুট 2; আউটপুট 5, কারণ 2 * 5 = 10

উদাহরণ: ইনপুট 21; আউটপুট 481, কারণ 21 * 481 = 10101


দাবি অস্বীকার: কোড পর্যালোচনা সাইটে প্রশ্নের জন্য আমি দায়ী নই। কোনও তাত্পর্য থাকলে কেবলমাত্র উপরের বর্ণনাকে যথাযথ বৈশিষ্ট হিসাবে বিবেচনা করা উচিত।

OEIS A079339


6
এটি সর্বদা সমাধানযোগ্য হতে হবে। স্পষ্টতই কমপক্ষে একটি কিউর অস্তিত্ব থাকতে হবে যেমন 10 ^ n মোড x = কিউ এর অসীম সংখ্যা রয়েছে। এক্স এর মতো এন এর মান নিন এবং প্রাসঙ্গিক শক্তি 10 ^ একসাথে যুক্ত করুন।
feersum

1
9 এর গুণকগুলি মনে হয় অস্বাভাবিকভাবে উচ্চ ফলাফল দেয়।
সুপারজেডি ২৪

1
সম্পর্কিত প্রকল্প ইউলারের সমস্যা , অন্য কারও জন্য যারা এই প্রশ্নটি পরিচিত বলে মনে করেন
Sp3000

1
বহুবর্ষীয় জটিলতা দ্বারা, আপনি কি ইনপুটটির অঙ্কের সংখ্যায় বহুপদী বা ইনপুটটির মানতে বহুপদী বলতে চান?
রেটো কোরাডি

3
@নাটোলিগ খনি আমার পক্ষে নিষ্ঠুর শক্তি নয়
অদিতসু

উত্তর:


8

পাইথ, 9 বাইট

f!-`*TQ10

প্রদর্শন

প্রতিটি একাধিকের জন্য, একটি স্ট্রিংয়ে রূপান্তর করুন, অঙ্কগুলি 10(এই ক্ষেত্রে পাইথের হ্যান্ডি ইন্ট টু স্ট্র কাস্ট ব্যবহার করে) অংকগুলি বিয়োগ করুন এবং তারপরে সঠিকভাবে একাধিকটি পাওয়া গেলেই সিচটি সমাপ্ত করে যুক্তিযুক্তভাবে ফলাফলটিকে উপেক্ষা করুন।

বোনাস সমাধান, 10 বাইট:

f.xi`*TQ2Z

এই সমাধানটি আসলে এটি পরীক্ষা করে থাকে যে সংখ্যার স্ট্রিং উপস্থাপনাটিকে বাইনারি সংখ্যা ( i ... 2) হিসাবে গণ্য করা যায় এবং যখন এই প্রচেষ্টাটিতে ত্রুটি না ছড়িয়ে দেওয়া হয় তখন সমাপ্ত হয়।


18

পাইথন 2, দক্ষ সমাধান, 99

n=input()
d={n:0}
k=1
while min(d):[d.setdefault((x+k)%n,d[x]+k)for x in set(d)];k*=10
print d[0]/n

কিছু গল্ফিং টিপস জন্য Sp3000 ধন্যবাদ।

আমি অন্য সবাইকে পোস্ট করার জন্য চ্যালেঞ্জ জানাই (তাদের নিজস্ব জবাবগুলিতে) ইনপুটটির জন্য ফলাফল পেতে কত সময় লাগে 72বা 99:) যদি সেগুলি সত্যিই দ্রুত হয় তবে 79992পরবর্তী কিছু (এখনও <1 সেকেন্ড এখানে) চেষ্টা করুন।

ব্যাখ্যা:

আমি ভেবেছিলাম এটি প্রয়োজনীয় ছিল না (যেহেতু কোডটি মোটামুটি পাঠযোগ্য) তবে আমি একটি অনুরোধ পেয়েছি, সুতরাং এটি এখানে যায়:

প্রথম ধারণাটি হল যে বাইনারি-চেহারাযুক্ত সংখ্যাটি 10 ​​এর 10 বা আরও বেশি বিভিন্ন শক্তির যোগফল Therefore সুতরাং, আমরা বাকি 0 না পাওয়া পর্যন্ত আমরা বিভিন্ন উপায়ে 10 এর বিভিন্ন শক্তি যোগ করার চেষ্টা করতে পারি।

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

dএকটি অভিধান / মানচিত্র যেখানে কীগুলি অবশিষ্টাংশ এবং মানগুলি সেই বাকী বাক্সের সাথে বাইনারি-চেহারাযুক্ত সংখ্যা। প্রাথমিকটি n:0একটি বিশেষ কেস: এটি বলে মনে করা হয় 0:0যাতে আমরা এতে শক্তি যোগ করতে শুরু করতে পারি, তবে কী 0 টি সন্ধান করার সময় অ্যালগরিদম বন্ধ হয়ে যায়, তাই আমি nপরিবর্তে ব্যবহার করেছি , যা একই প্রভাব রাখার গ্যারান্টিযুক্ত এবং অন্যান্য মানগুলির সাথে হস্তক্ষেপ না করার গ্যারান্টিযুক্ত।

তারপরে আমরা kসমস্ত বিদ্যমান সংখ্যায় 10 (সঞ্চিত ) এর শক্তি যোগ করা এবং অবশিষ্টদের রেকর্ডিং শুরু করি। আমরা kবাকীটি: (x+k)%nএবং সংখ্যায় যুক্ত করি: d[x]+kএবং এটি কেবল তখনই রেকর্ড করে রাখি যদি এটি একটি নতুন অবশিষ্ট থাকে:, d.setdefault(…)তারপরে পরবর্তী ক্ষমতায় যান: k*=10এবং আমরা কী 0 না পাওয়া পর্যন্ত পুনরাবৃত্তি করুন:while min(d)

শেষে, d[0]বাইনারি-চেহারাযুক্ত নম্বর দেয় যা 0 টি মডেলের অবশিষ্ট রয়েছে n, তাই nসমাধান পেতে আমরা এটি ভাগ করে নিই ।

দ্রষ্টব্য: বিপুল সংখ্যক এড়ানো (10 টির শক্তির চেয়ে এক্সপেনডেন্ট রেকর্ডিং এবং পূর্ববর্তী মানগুলি থেকে ক্ষমতার অবশিষ্টাংশ গণনা) দ্বারা প্রোগ্রামটিকে আরও দক্ষ করা যেতে পারে, তবে এটি কোড গল্ফ, তাই ...

আসলে, আমি এখানে একটি দ্রুত সংস্করণ লিখেছি:

n=input()
d={n:0}
k=1
b=0
while 0not in d:
 for x in list(d):d.setdefault((x+k)%n,b)
 k=(k*10)%n;b+=1
x=10**d[0]
while x%n:x+=10**d[n-x%n]
print x/n

1
আমার উত্তরও পাই না। xD "ডিঙ্গিত, জাভা, ডিফল্টরূপে বিগইন্টিজার ব্যবহার করার জন্য আপনার পূর্ণসংখ্যার পছন্দকে অভিশাপ দিন MA MAX_VALUE!" - প্রতিটি জাভা প্রোগ্রামার
এডিসন ক্রম্প

@ VTCAKAVSMoACE আপনি লম্বা ব্যবহার করবেন না কেন?
aditsu

হুম। এটি একটি অতিরিক্ত বাইট, কিন্তু ... এটি মূল্যবান। ধন্যবাদ!
অ্যাডিসন ক্রম্প

অথবা না. এটি আসলে গুরুতরভাবে এটি হ্রাস করে। ধন্যবাদ!
অ্যাডিসন ক্রম্প

1
99 সমাধানের সময়: অ্যাডিটসু: 0.001 সেকেন্ড; xnor: 5+ ঘন্টা এবং এটি এখনও সম্পূর্ণ হয়নি।
ব্যবহারকারী 193661 61

13

পাইথন 2, 47 বাইট

n=a=input()
while'1'<max(str(a)):a+=n
print a/n

ইনপুট নম্বরটি ট্র্যাক করে n এবং বর্তমান একাধিকa । যখন aসৌন্দর্য বাইনারি, আউটপুট অনুপাত পছন্দ a/n। একটি সংখ্যা 0'গুলি এবং এর দ্বারা গঠিত কিনা তা পরীক্ষা করতে 1, আমরা এর স্ট্রিং উপস্থাপনায় সর্বোচ্চ চরটি তুলনা করি '1'

ব্যবহারসমূহ str(a)`a` এড়াতে পরিবর্তে করে L। দুর্ভাগ্যক্রমে, এর 'L'চেয়ে বড় '1'


12

পার্ল, 27 বাইট

#!perl -p
1while($_*++$\)=~/[2-9]/}{

শেবাংকে এক হিসাবে গণনা করা, স্টিডিনের কাছ থেকে ইনপুট নেওয়া হয়।

নমুনা ব্যবহার

$ echo 2 | perl dec-bin.pl
5

$ echo 21 | perl dec-bin.pl
481

$ echo 98 | perl dec-bin.pl
112245

পার্ল, 25 বাইট

#!perl -p
eval'0b'.++$\*$_||redo}{

দ্বারা একটি দুটি বাইট উন্নতি @ এসএসএমআরএক্স

একটি রেজেক্সের বিরুদ্ধে পরীক্ষা করার পরিবর্তে, এটি পরিবর্তে পণ্যটিকে বাইনারি আক্ষরিক হিসাবে মূল্যায়নের চেষ্টা করে। ব্যর্থতার পরে, এটি পরবর্তী দিকে চলে যায়। সাধারণতoct ফাংশনটি এই উদ্দেশ্যে ব্যবহৃত হত, তবে এটি চুপচাপ অবৈধ অঙ্কগুলি ছাঁটাই করে দেয়, যা এই চ্যালেঞ্জে কার্যকর নয়।


পার্ল, 40 বাইট

#!perl -p
1while($b=sprintf"%b",++$i)%$_;$_=$b/$_

একটি আরও কার্যকর সমাধান। বাইনারি উপস্থাপনাগুলির মাধ্যমে আমরা পুনরাবৃত্তি করি, তাদেরকে বেস 10 হিসাবে ব্যাখ্যা করি এবং তারপরে বিভাজ্যতার জন্য পরীক্ষা করি। 100 এর নিচে সমস্ত মানের রানটাইম নগণ্য।

নমুনা ব্যবহার

$ echo 72|perl dec-bin.pl
1543209875

$ echo 99|perl dec-bin.pl
1122334455667789

2
ভাল লাগল :) আমি আজ আপনার পোস্ট থেকে বেশ কয়েকটি নতুন জিনিস শিখেছি! আপনার কোডটি পড়ার সময়, আমি প্রথম কোড থেকে eval"0b".$_*++$\||redo}{
কয়েকটা

তবে আমি অনুমান করি use bigintযে বিপুল সংখ্যক
ওপিকে

1
@ এসএমআরএন এটি উজ্জ্বল। আমি চেষ্টা করেছিলাম oct'0b'.++$\*$_, কিন্তু এটি নিঃশব্দে অবৈধ অঙ্কগুলি ছাঁটাই করে দেয়। আমি evalপরিবর্তে ব্যবহার করার জন্য ভাবি নি ।
primo

11

জাভাস্ক্রিপ্ট, 43 বাইট

এটি আমার ভাবার চেয়ে ছোট দিক দিয়ে শেষ হয়েছে। এটি মূলত y1 অবধি বৃদ্ধি পায় y * (input number) = (binary-looking number)। স্পষ্টতই বেশ অদক্ষ।

for(x=prompt(y=0);!+('0b'+x*++y););alert(y)


জাভাস্ক্রিপ্ট (আরও দক্ষ সমাধান), 53 বাইট

yবাইনারি পর্যন্ত এই এক বৃদ্ধি y / (input number) = (number without a remainder)। তারপর এটি আউটপুট (number without a remainder)

for(x=prompt(y=1);(z=y.toString(2))%x;y++);alert(z/x)


জাভাস্ক্রিপ্ট (আরও কার্যকর সমাধান), 76 বাইট

এটি একটি বর্ণিত পূর্ববর্তী উভয় পদ্ধতির একত্রিত করে। এটি yউভয়ই ইনক্রিমেন্টগুলি পরীক্ষা করে y * (input number) = (binary-looking number)(অর্থ আউটপুটটি হ'ল y) বা y / (input number) = (number without a remainder)(যার অর্থ আউটপুট (number without a remainder))

for(x=prompt(y=a=0);!a;a=+('0b'+x*++y)?y:(z=y.toString(2))%x?0:z/x);alert(a)


এটি সম্ভব হলে 1 দেওয়া উচিত (উদাহরণস্বরূপ ইনপুট: 1)
edc65

@ edc65 স্থির - বাইট গণনায় কোনও পরিবর্তন ছাড়াই!
মামা ফান রোল

এটি সাফারি 9.0 ক্র্যাশ করে। Jussayin '। :)
অ্যাডিসন ক্রম্প

1
তবে এটি আউটপুটে স্বল্প সংখ্যায় সীমাবদ্ধ। জাভাস্ক্রিপ্ট সংখ্যার
যথাযথতার

প্রতিলিপি: ইনপুট try২ ব্যবহার করে দেখুন না Firef ফায়ারফক্স ৪১ মিনিটের জন্য নিথর হয়ে যায় এবং তারপরে ক্র্যাশ হয়। আমি এই কঠিন উপায় আবিষ্কার।
ইটিএইচ প্রোডাকশনস

9

হাস্কেল, 72 70 64 60 58 বাইট

main=do x<-readLn;print$[y|y<-[1..],all(<'2')$show$x*y]!!0

সম্পাদনা করুন: @ জন ডিভোরাক আমাকে 4 টি বাইট সংরক্ষণ করতে সহায়তা করেছেন।

সম্পাদনা করুন: @ ব্ল্যাকক্যাপ স্বীকৃতিটিতে স্যুইচ করে 2 বাইট সংরক্ষণ করেছে do। ধন্যবাদ!


main=print.f=<<readLn
জন ডিভোরাক

আপনি এফ লাইন দিয়ে একটি বাইট সংরক্ষণ করতে পারেন: main=readLn>>= \x->print$[y|y<-[1..],all(<'2')$show$x*y]!!0
ইনলাইন

2 আসলে main=do x<-readLn;print$[y|y<-[1..],all(<'2')$show$x*y]!!0
ব্ল্যাকক্যাপ

@ ব্ল্যাকক্যাপ: দুর্দান্ত! অনেক ধন্যবাদ!
নিমি

7

পাইথন 2, 67 65 63 60 বাইট

a=input();b=1
while set(`a*b`)&set('23456789'):b+=1
print b

ধন্যবাদ স্থিতি 2 বাইট এবং জন্য কুঁড়েঘর 5 বাইট জন্য!


1
আমি মনে করি আপনাকে অবশ্যই আরম্ভ করতে হবেb=1
anatolyg

2
আপনি করে 2 বাইট শেভ করতে পারেনany(c in`a*b`for c in'23456789')
স্থিতি

1
আমি এ সম্পর্কে নিশ্চিত নই তবে কি not c in`a*b`for c in'10'কাজ করবে?
কোলে

2
আপনার সময় শর্তটি পরিবর্তন করে আপনি 6 বাইট সংরক্ষণ করতে পারেন set('a*b')&set('23456789')
কেড

2
`দীর্ঘস্থায়ী Lজন্য এবং উত্পাদন করে 'L'>'1'
ব্যবহারকারী 193661

6

জাভাস্ক্রিপ্ট (ES6) 222 250

স্বেচ্ছাসেবী নির্ভুল গণিত ব্যবহার করে (দশমিক অঙ্কের স্ট্রিংগুলিতে অপারেটিং)

এটি আরও কিছুটা গল্ফ করা যেতে পারে (সম্পন্ন) তবে আমি এটি পছন্দ করি যে এটি জেএস স্ট্যান্ডার্ড সংখ্যাগুলির মধ্যে সীমাবদ্ধ নয় ( 17 দশমিক সংখ্যা) এবং এটি দ্রুত।

নীচে স্নিপেট চলমান পরীক্ষা করুন একমাস্ক্রিপ্ট l অনুবর্তী ব্রাউজারে। সময়টি 9998 অবধি গ্রহণযোগ্য - 9999 চেষ্টা করবেন না এবং 999 নিয়ে ধৈর্য ধরুন।

// As a complete program with I/O via popup  
for(n=+prompt(a=[0],q=[t=1]);t;){for(c=1,t=i=0;i<a.length;i++)a[i]=a[i]&c?0:a[i]|c?(c=0,t+=q[i],1):c=0;c&&(a[i]=c,t+=q[i]=q[i-1]*10%n);t%=n}a.reverse().map(a=>(z+=[a],d=z/n|0,z%=n,r||d?r+=d:0),r='',z=0);alert([r,a.join``])

// As a testable function
f=n=>{
  for(a=[0],q=[t=1];t;)
  {
    for(c=1,t=i=0;i<a.length;i++)
      a[i]=a[i]&c?0:a[i]|c?(c=0,t+=q[i],1):c=0
    c&&(a[i]=c,t+=q[i]=q[i-1]*10%n);
    t%=n
  }  
  a.reverse().map(a=>(z+=[a],d=z/n|0,z%=n,r||d?r+=d:0),r='',z=0)
  return [r,a.join``]
}

// Test and timing
out = x => O.innerHTML += x + '\n'

setTimeout(_=>{
;[1,2,10, 21, 23, 98, 72, 9, 99, 999]
.forEach((test,i) => { 
  var t0 = ~new Date  
  var result = f(test)
  out('n='+test+' '+result+' time(ms) ' + (t0-~new Date))
})},100)  
<pre id=O>Timing test cases ...
</pre>

আরও পঠনযোগ্য

এটি পৃথক ফাংশন হিসাবে মডুলাস এবং দীর্ঘ বিভাগ সহ প্রথম সংস্করণ।

// function M - Modulus with arbitrary precision - a is a string of decimal digits
M = (a, b, q = 1, t = 0, j = a.length) => {
  while (j--) + a[j] ? t += q : 0, q = (q * 10) % b;
  return t % b
}

// function D - Long division with arbitrary precision - a is a string of decimal digits
D = (a, b, r = '', z = 0) => [...a].map(a => (z += a, d = z / b | 0, z %= b, r || d ? r += d : 0)) && r

// Testable function 
f = n => {
  for (i = 0; ++i < 1e7 && (z = M(v = i.toString(2), n)););
  return z ? ['big'] : [D(v, n), v]
}

আমি এটি ফায়ারফক্সে কাজ করতে পেরেছি, তবে এটি বড় সংখ্যা হ্যান্ডেল হিসাবে মনে হচ্ছে না, যেমন 999
aditsu

আমি একটি নতুন সংস্করণ তৈরি করেছি যা 36 সেকেন্ডে 999 পরিচালনা করতে পারে তবে জাভাস্ক্রিপ্টের সময়সীমা শেষ হওয়ার সাথে 9999 এ পৌঁছানোর কোনও আশা নেই (প্রতিটি '9' যোগ করার জন্য 2 ^ 9 (~ 500
ডলার

@ অ্যাডিটসু এটি জাভাস্ক্রিপ্টে আমি সবচেয়ে ভাল করতে পারি (তবে সি # তে এটি বেশ একই রকম)। ইয়ারলি আপনার অবিশ্বাস্য আলগোরিদম ব্যাখ্যার জন্য অপেক্ষা করছেন
edc65

আমি এখনই একটি ব্যাখ্যা যুক্ত করেছি
aditsu



4

পিএইচপি, 50 বাইট

while(preg_match('/[^01]/',$argv[1]*++$y));echo$y;

কিছু পরীক্ষার মামলা

1 > 1
2 > 5
12 > 925
21 > 481

1
এই জাতীয় কিছু তৈরি করতে যাচ্ছিল, এটি আমার মনের চেয়েও সামান্য ছোট
মার্টিজন

4

সিজেম, 19 17 16 বাইট

li:V!{)_V*sAs-}g

এটি অনলাইনে চেষ্টা করুন

নিষ্ঠুর বলের সমাধান, শর্তটি সন্ধান না করা পর্যন্ত ক্রমান্বয়ে মানগুলি চেষ্টা করে।

সর্বশেষতম সংস্করণটি একটি স্ট্রিং তৈরির Asপরিবর্তে ব্যবহার করার জন্য 2 বাইট ধন্যবাদ সংরক্ষণ করে এবং যেমন @ অ্যাডিতসু পরামর্শ দিয়েছেন। মন্তব্যে সম্পূর্ণ প্রস্তাবিত সমাধানটি অন্য একটি বাইট সংরক্ষণ করে, তবে এটি আমার থেকে মোটামুটি আলাদা বলে মনে হচ্ছে, তাই আমি এটি আমার নামে পোস্ট করতে চাইনি।"01"01

এবং আরও 1 টি বাইট সংরক্ষণ করেছেন @ ডেনিস।

ব্যাখ্যা:

li      Get input and convert to int.
:V      Save it in variable V.
!       Negate the value. Since we saved it in V, we don't need it on the stack anymore.
        But we need 0 on the stack as the start value for y. This conveniently
        accomplishes both with a single operator, since the input is guaranteed to be
        larger than 0.
{       Loop over y.
  )       Increment y.
  _       Copy it.
  V*      Multiply with input in variable V.
  s       Convert to string.
  As      Push the string "10", as the number 10 converted to a string .
  -       Remove 0 and 1 digits. This will result in an empty list if there were only
          0 and 1 digits. The empty list is falsy, and will terminate the loop.
}g      End loop.

3
16:li0{1$+_sAs-}g\/
aditsu

ধন্যবাদ, @ অ্যাডিটসু আমি আসলেই আমার নামে আপনার সম্পূর্ণ সমাধানটি অনুলিপি করতে চাইনি। আমি Asস্ট্রিংটি তৈরির কাজটি করেছি , যেহেতু এটি একটি খুব স্থানীয় পরিবর্তন, যা পূর্বচক্ষে (যা সবসময়ই সহজ ...) আমার ভাবা উচিত ছিল।
রেটো কোরাডি

1
@ রিটোকোরাডি 16 বাইট, কম পরিবর্তন: li:V!{)_V*sAs-}gএছাড়াও 0{)_easi*sAs-}g(15 বাইট) জাভা দোভাষী এবং কমান্ড-লাইন আর্গুমেন্টগুলির সাথে কাজ করে।
ডেনিস

4

পাইথন 3 2, 101 76 বাইট

-25 বাইট @aditsu ধন্যবাদ

@ অ্যাডিটসুর সমাধান হিসাবে প্রায় দক্ষ

99 -> 0.436 Seconds
72 -> 0.007 Seconds
b,m,n=1,1,input()
while b%n:
 b=int("{0:b}".format(m))
 m+=1
print b/n

ক্রমবর্ধমান ক্রমে লুপগুলি চেষ্টা করার পরিবর্তে, আমি 'বাইনারি' আকারে উত্পাদিত পণ্যগুলির মাধ্যমে লুপ করার চেষ্টা করছি।


খারাপ নয় :) 9999 এর কি হবে?
অ্যাডিটসু

2
কিছু গল্ফিং টিপস: পাইথন 2 ( n=input()) ব্যবহার করুন while b%n:( b1 টি আরম্ভ করুন), কোনও ইনডেন্টেশন নয়
aditsu

@ অ্যাডিতসু ধন্যবাদ! 9999 হুম, মনে হচ্ছে এটি কয়েক দিন সময় নেবে, ভাল করে অঙ্কন বোর্ডে ফিরে যাবে
__-

1
bin(m)[2:]ফর্ম্যাট স্ট্রিংয়ের চেয়ে কম হওয়া উচিত। ডাবল অ্যাসাইনমেন্টটিও b=m=1কয়েকটি সংরক্ষণ করতে হবে।
প্রিমো

4

জাভা, 213 বাইট

import java.math.*;class P{public static void main(String[]a){BigInteger b=new java.util.Scanner(System.in).nextBigInteger(),c,d=c=b.ONE;while(!(b.multiply(c)+"").matches("[01]+"))c=c.add(d);System.out.print(c);}}

ব্যবহার BigIntegers এবং যেমন রয়েছে সীমাবদ্ধ ইনপুট আকার (যুক্তিসঙ্গত ইন্টেন্টগুলি এবং উদ্দেশ্যের জন্য)। জটিলতা সম্পর্কে নিশ্চিত না হলেও এটি আমাদের ফাংশনের বৃদ্ধির হারের উপর নির্ভর করে।

জিওবিটস এবং ypnypn কয়েক মুভি বাইট সংরক্ষণ করার জন্য ধন্যবাদ।


হাই, আপনি কিভাবে আপনার মূল পদ্ধতিতে এটি কল করবেন? এটি চেষ্টা করেও সফল হচ্ছে না
ইয়াসিন হাজাজ

আপনাকে staticপদ্ধতিতে সংশোধক যুক্ত করতে হবে।
সুপারজেডি ২৪

1
প্রশ্নটি বলে যে সমাধানটি একটি ক্রিয়াকলাপ নয়, একটি সম্পূর্ণ প্রোগ্রাম হওয়া উচিত।
রাজনগুল

আপনি 15 এর সাথে b.ONEএবং এর !(b.multiply(c)+"")পরিবর্তে কাটতে পারেন toString()
Geobits

@ রজনগুল: স্থির।
সুপারজেডি ২৪

4

সি, 3675 বাইট

কোড গল্ফের জন্য এত দীর্ঘ ...

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <time.h>
#include <assert.h>

#define min_n 1
#define max_n 10000

unsigned *mod_list; // list of mods to check
unsigned mod_list_length; // number of mods to check
char *graph; // for each mod, the power of 10 that gives it

void BuildGraph(unsigned n)
{
    unsigned mod10 = 10 % n;
    int pow = 1;

    memset(graph, 0, n);
    if (n == 1)
        return;
    mod_list[0] = 0; // mod 0 - no path coming to it yet
    mod_list[1] = 1; // mod 1 - 10^0 coming to it
    mod_list_length = 2;
    while (graph[0] == 0)
    {
        // We are going to change mod_list_length by adding new nodes.
        // This should not affect the set of nodes we check, so save its old value.
        unsigned mod_list_limit = mod_list_length;
        for (unsigned i = 0; i < mod_list_limit; ++i)
        {
            unsigned mod = mod_list[i] + mod10;
            if (mod >= n)
                mod -= n;
            if (graph[mod] == 0 && mod != 1) // new node?
            {
                graph[mod] = pow; // record the power of 10 with which we come to this node
                mod_list[mod_list_length++] = mod; // add it to the list of nodes
                if (mod == 0) // found the path to 0?
                    return; // stop calculating
            }
        }
        mod10 = (unsigned long long)mod10 * 10 % n; // go to next power of 10
        ++pow;
    }
}

void PrintPath(unsigned n, char *out)
{
    // Going to output powers of 10 in descending order
    unsigned mod = 0; // start at node 0
    int prev_pow = graph[mod] + 1; // happens to be an acceptable initialization
    do {
        int pow = graph[mod];
        while (--prev_pow > pow) // output the proper number of 0-digits
            *out++ = '0';
        *out++ = '1'; // output the digit 1, corresponding to current power of 10
        if (pow == 0)
            break;
        unsigned mod10 = 1;
        for (int p = 0; p < pow; ++p)
            mod10 = (unsigned long long)mod10 * 10 % n;
        mod = (mod + n - mod10 % n) % n; // go to the preceding node
    } while (mod != 0);
    while (--prev_pow >= 0) // output the proper number of 0-digits
        *out++ = '0';
    *out++ = 0;
}

// The long division algorithm
void DivideAndPrint(char *product, unsigned n, FILE* file)
{
    unsigned long long temp = 0;
    int print = 0;
    while (*product != '\0')
    {
        temp = temp * 10 + *product++ - '0';
        if (temp >= n)
            print = 1;
        if (print)
        {
            unsigned quotient = (unsigned)(temp / n);
            unsigned remainder = temp % n;
            fputc('0' + quotient, file);
            temp = remainder;
        }
    }
    fputc('\n', file);
    assert(temp == 0); // if not divisible, there is a bug somewhere
}

void Calc(unsigned n, FILE* file)
{
    char result[99];
    BuildGraph(n);
    PrintPath(n, result);
    DivideAndPrint(result, n, file);
}

int main(int argc, char* argv[])
{
    unsigned n;

    if (argv[1])
    {
        FILE* file = fopen(argv[1], "wt");
        mod_list = calloc(max_n, sizeof(int));
        graph = calloc(max_n, 1);
        clock_t before = clock();
        for (n = min_n; n <= max_n; ++n)
        {
            Calc(n, file);
        }
        clock_t after = clock();
        fprintf(stderr, "Time: %f\n", (after - before) / (double)CLOCKS_PER_SEC);
    }
    else
    {
        scanf("%u", &n);
        mod_list = calloc(n, sizeof(int));
        graph = calloc(n, 1);
        Calc(n, stdout);
    }
}

কোনও কমান্ড লাইন প্যারামিটার ছাড়াই চালান - এটি ফলাফলটি পেয়ে nযায় stdinএবং ফলাফলকে আউটপুট করে stdout। একটি ফাইল নাম দিয়ে চালান - এটি ফলাফল লিখেছে জন্যn = 1...10000 সেই ফাইলটির এবং সময়কে পরিমাপ করে।

1 ... 10000: 140 এমএসের জন্য পারফরম্যান্স

এই কোডটি অদিতসু দ্বারা প্রস্তাবিত অ্যালগরিদম ব্যবহার করে , গতির জন্য সি প্রয়োগ করা হয়। আমি এটি গল্ফ করার জন্য কোনও চেষ্টা করি নি, তাই কোডটি পড়া আরও সহজ হবে।

std::mapঅনুসন্ধানের ফলাফলগুলি রেকর্ড করতে আমি এটি প্রথমে সি ++ এ প্রয়োগ করেছি এবং এটি বরং ধীর ছিল। যাইহোক, কীগুলির mapক্রমাগত পূর্ণসংখ্যা হয় (আমি তাদের modএস বলি , কারণ তারা সংখ্যার মডুলোর প্রতিনিধিত্ব করে n), সুতরাং অ্যারে ব্যবহার করা স্বাভাবিক - তাই আমি এটিকে আবার সিটিতে লিখলাম in

অতিরিক্ত অপ্টিমাইজেশন ম্যাপিংয়ের মানগুলি নিয়ে উদ্বেগ প্রকাশ করে - প্রত্যেকের জন্য একটি বড় পূর্ণসংখ্যার সঞ্চয় করা এড়াতে mod, আমি সেখানে কেবলমাত্র 10 এর বৃহত্তম শক্তি সঞ্চয় করি - এটি কেবল আগেরটিতে যাওয়ার যথেষ্ট তথ্য mod। সুতরাং অ্যারে সত্যিই একটি অনুসন্ধান গাছ / গ্রাফ। অনুসন্ধানটি যখন পৌঁছে যায় mod = 0তখন গাছের নোডগুলি আবার শিকড়ে টেনে আনার ফলে ক্রমান্বয়ে 10 টির শক্তি দেওয়া হয়।

যেহেতু অনুসন্ধান সাধারণত নোডগুলির একটি ছোট ভগ্নাংশ পরিদর্শন করার পরিবর্তে দ্রুত থামে, তাই আমার সক্রিয় নোডগুলির একটি তালিকা প্রয়োজন। এটি mod_listদৈর্ঘ্য সহ একটি অ্যারে হিসাবে প্রয়োগ করা হয়েছে mod_list_length

কিছু রানটাইম পরিসংখ্যান (16 গিগাবাইট র‌্যামযুক্ত একটি মেশিনে, যা বড়দের পক্ষে গুরুত্বপূর্ণ বলে মনে হয় n, কারণ প্রোগ্রামটি 5nমেমরির বাইটগুলি বরাদ্দ করে ):

  • ইনপুট 99999999- 2 সেকেন্ড
  • ইনপুট 999999999- 27 সেকেন্ড (ফলাফলটি111111111222222222333333333444444444555555555666666666777777777888888889 - সম্ভবত 32-বিট পূর্ণসংখ্যার পক্ষে সবচেয়ে বড় ফলাফল)
  • ইনপুট 2147483647- 26 সেকেন্ড (ফলাফলটি 4661316525084584315813)
  • ইনপুট 1999999998- 52 সেকেন্ড (32-বিট পূর্ণসংখ্যার জন্য সম্ভবত দীর্ঘতম রান সময়)

2
আমি বুঝতে পারি যে আপনি অনুগ্রহের পরে, কিন্তু তবুও এটি একটি কোড-গল্ফ প্রশ্ন এবং সাইটের বিধিগুলির জন্য আপনার কোডটি গল্ফ করার জন্য কিছু প্রচেষ্টা করা প্রয়োজন ।
পিটার টেলর

আপনার প্রোগ্রামে 3546 বাইট রয়েছে।
aditsu

@ অ্যাডিটসু আমি উইন্ডোতে বাইট গণনা পরিমাপ করেছি, যা সিআর / এলএফ স্টাইল ব্যবহার করে
anatolyg

4

সি ++ ১১, অনেকগুলি বাইট, খুব দ্রুত, বাহ (১৯৯৯৯৯৯৯৮৮ তে 1.5 সে, 1 এর উপর 0.2 এস… 10000)

(নীচে গল্ফ পাইথন সংস্করণ।)

আমরা আদিতসুর সমাধানের সাথে কিছুটা অনুরূপ ধারণা দিয়ে শুরু করি, যেখানে আমরা প্ররোচিতভাবে এন পদক্ষেপগুলিতে পৌঁছনীয় মডুলার বাকী অংশগুলির সংগ্রহ তৈরি করি। তবে আমরা বাকি 0 খুঁজে না পাওয়া পর্যন্ত অপেক্ষা না করে, আমরা দু'জন খুঁজে পাওয়া যায় এবং একটি এবং খ যেমন দুটি ind 10 ^ n + b = 0 খুঁজে পেয়েছি This বড় ইনপুটগুলিতে অনেক দ্রুত এবং কম স্মৃতি ব্যবহার করে।

কিছু মানদণ্ড:

$ echo 99999999 | \time ./decbin
1111111122222222333333334444444455555555666666667777777788888889
0.18user 0.01system 0:00.20elapsed 99%CPU (0avgtext+0avgdata 69360maxresident)k
0inputs+0outputs (0major+16276minor)pagefaults 0swaps
$ echo 999999999 | \time ./decbin
111111111222222222333333333444444444555555555666666666777777777888888889
1.22user 0.04system 0:01.27elapsed 100%CPU (0avgtext+0avgdata 434776maxresident)k
0inputs+0outputs (0major+37308minor)pagefaults 0swaps
$ echo 2147483647 | \time ./decbin
4661316525084584315813
0.00user 0.00system 0:00.01elapsed 72%CPU (0avgtext+0avgdata 5960maxresident)k
0inputs+0outputs (0major+1084minor)pagefaults 0swaps
$ echo 1999999998 | \time ./decbin
555555556111111111666666667222222222777777778333333333888888889444444445
1.42user 0.08system 0:01.50elapsed 100%CPU (0avgtext+0avgdata 544140maxresident)k
0inputs+0outputs (0major+38379minor)pagefaults 0swaps
$ \time ./decbin 10000.out
0.19user 0.00system 0:00.20elapsed 100%CPU (0avgtext+0avgdata 3324maxresident)k
0inputs+264outputs (0major+160minor)pagefaults 0swaps

কোড:

#include <algorithm>
#include <boost/iterator/transform_iterator.hpp>
#include <fstream>
#include <list>
#include <iostream>
#include <string>
#include <utility>
#include <vector>

using namespace boost;
using namespace std;

static inline bool cmp_first_partnered(pair<int, pair<int, int>> a,
                                       pair<int, pair<int, int>> b) {
  return a.first < b.first;
}
static inline bool eq_first_partnered(pair<int, pair<int, int>> a,
                                      pair<int, pair<int, int>> b) {
  return a.first == b.first;
}

static pair<int, int> retrace(int modulus, int place, pair<int, int> state,
                              list<vector<int>>::iterator i,
                              list<vector<int>>::iterator j, string &ret) {
  if (i == j)
    return state;
  state = retrace(modulus, (place * 10LL) % modulus, state, next(i), j, ret);
  int remainder = state.first;
  long long k = state.second * 10LL;
  if (!binary_search(i->cbegin(), i->cend(), remainder)) {
    remainder = ((long long)remainder + modulus - place) % modulus;
    k += 1;
  }
  int digit = k / modulus;
  if (digit != 0 || ret.size())
    ret += '0' + digit;
  return make_pair(remainder, k % modulus);
}

static void mult(int modulus, int x, int y,
                 vector<pair<int, pair<int, int>>>::iterator i,
                 vector<pair<int, pair<int, int>>>::iterator j) {
  if (y - x == 1) {
    for (auto k = i; k != j; k++)
      k->first = (k->first * 10LL) % modulus;
    return;
  }

  int z = (x + y) / 2;
  vector<pair<int, pair<int, int>>>::iterator k = lower_bound(
      i, j, make_pair(int(((long long)modulus * z + 9) / 10), make_pair(0, 0)));
  mult(modulus, x, z, i, k);
  mult(modulus, z, y, k, j);
  inplace_merge(i, k, j,
                [](pair<int, pair<int, int>> a, pair<int, pair<int, int>> b) {
                  return make_pair(a.first, a.second.second) <
                         make_pair(b.first, b.second.second);
                });
}

static string go(int modulus) {
  if (modulus == 1)
    return "1";

  int sequence = 1;
  list<vector<int>> v = {{0}};
  vector<pair<int, pair<int, int>>> partnered;
  int place = 1;
  while (true) {
    v.emplace_back(v.rbegin()->size() * 2);
    vector<int> &previous = *next(v.rbegin()), &current = *v.rbegin();

    auto offset = [modulus, place, sequence](int a) {
      return (a + (long long)place) % modulus;
    };
    auto old_mid =
        lower_bound(previous.cbegin(), previous.cend(), modulus - place),
         new_mid = lower_bound(previous.cbegin(), previous.cend(), place);
    current.resize(
        set_union(new_mid, previous.cend(),
                  make_transform_iterator(previous.cbegin(), offset),
                  make_transform_iterator(old_mid, offset),
                  set_union(previous.cbegin(), new_mid,
                            make_transform_iterator(old_mid, offset),
                            make_transform_iterator(previous.cend(), offset),
                            current.begin())) -
        current.begin());

    int place2 = modulus - (long long)place * place % modulus;
    auto offset_partnered = [modulus, place, place2,
                             sequence](pair<int, pair<int, int>> a) {
      return make_pair((a.first + (long long)place2) % modulus,
                       make_pair((a.second.first + (long long)place) % modulus,
                                 sequence + a.second.second));
    };
    auto old_mid_partnered =
        lower_bound(partnered.cbegin(), partnered.cend(),
                    make_pair(modulus - place2, make_pair(0, 0))),
         new_mid_partnered = lower_bound(partnered.cbegin(), partnered.cend(),
                                         make_pair(place2, make_pair(0, 0)));
    vector<pair<int, pair<int, int>>> next_partnered(partnered.size() * 2 + 1);
    auto i =
        set_union(partnered.cbegin(), new_mid_partnered,
                  make_transform_iterator(old_mid_partnered, offset_partnered),
                  make_transform_iterator(partnered.cend(), offset_partnered),
                  next_partnered.begin(), cmp_first_partnered);
    if (new_mid_partnered == partnered.cend() ||
        new_mid_partnered->first != place2)
      *i++ = make_pair(place2, make_pair(place, sequence));
    next_partnered.resize(
        set_union(new_mid_partnered, partnered.cend(),
                  make_transform_iterator(partnered.cbegin(), offset_partnered),
                  make_transform_iterator(old_mid_partnered, offset_partnered),
                  i, cmp_first_partnered) -
        next_partnered.begin());
    partnered.swap(next_partnered);

    sequence += previous.size();

    place = (place * 10LL) % modulus;

    mult(modulus, 0, 10, partnered.begin(), partnered.end());
    partnered.resize(
        unique(partnered.begin(), partnered.end(), eq_first_partnered) -
        partnered.begin());

    auto with_first = [](int a) { return make_pair(a, make_pair(a, 0)); };

    vector<pair<int, pair<int, int>>> hits;
    set_intersection(partnered.cbegin(), partnered.cend(),
                     make_transform_iterator(current.cbegin(), with_first),
                     make_transform_iterator(current.cend(), with_first),
                     back_inserter(hits), cmp_first_partnered);

    if (hits.size()) {
      pair<int, pair<int, int>> best = *min_element(
          hits.begin(), hits.end(),
          [](pair<int, pair<int, int>> a, pair<int, pair<int, int>> b) {
            return a.second.second < b.second.second;
          });
      string ret = "";
      pair<int, int> state =
          retrace(modulus, 1, make_pair(best.second.first, 0), v.begin(),
                  prev(v.end()), ret);
      retrace(modulus, 1, make_pair(best.first, state.second), v.begin(),
              prev(v.end()), ret);
      return ret;
    }
  }
}

int main(int argc, const char *argv[]) {
  ios_base::sync_with_stdio(false);
  if (argc >= 2) {
    ofstream ofs(argv[1]);
    for (int modulus = 1; modulus <= 10000; modulus++)
      ofs << go(modulus) << '\n';
  } else {
    int modulus;
    cin >> modulus;
    cout << go(modulus) << '\n';
  }
  return 0;
}

পাইথন, 280 বাইট (পিআইপি সহ 1999999998 এ 8.6 সেকেন্ড)

n=input()
if n<2:print 1;exit()
d={0:0}
l=[]
k=1
b=x=y=0
while 1:
 for a in[0]+l:
  m=(a+k)%n
  if m not in d:l.append(m);d[m]=b
 k=(k*10)%n;b+=1
 for a in l:
  if(-k*a)%n in d:
   while(a-x)%n:x+=10**d[(a-x)%n]
   while(-y-k*a)%n:y+=10**d[(-y-k*a)%n]
   print(10**b*x+y)/n;exit()

2
আমি বুঝতে পেরেছি যে আপনি অনুগ্রহের পরে, কিন্তু তবুও এটি একটি কোড-গল্ফ প্রশ্ন, এবং সাইটের বিধিগুলির জন্য আপনাকে প্রয়োজনীয় করা উচিত আপনার কোডটি গল্ফ করার কিছু প্রচেষ্টা করা ।
পিটার টেলর

1
@ পিটারটেলর, খুব ভাল, আমি পাইথনে একটি গল্ফযুক্ত সংস্করণ যুক্ত করেছি।
অ্যান্ডারস ক্যাসরগ

3

গাণিতিক 115 বাইট

p=Drop[Union[FromDigits/@Flatten[Table[Tuples[{0,1},{k}],{k,2,12}],1]],2];
i=Input[];FirstCase[p,x_/;Divisible[x,i]]

3

জাভা 156 বাইট

public class P{public static void main(String[]a){long x=Long.valueOf(a[0]),y;for(y=2;!(""+x*y).replaceAll("1|0","").isEmpty();y++);System.out.println(y);}}

আদিতসুকে প্রচুর ধন্যবাদ :)


আপনার পরে কোনও স্থানের দরকার নেই [], খুব বেশি yহতে longপারে, আপনি x*y+""২ য় প্রোগ্রামের কৌশলটি ভুলে গেছেন , isEmptyদৈর্ঘ্য পরীক্ষা করার ;পরিবর্তে ব্যবহার করুন, পরিবর্তে ব্যবহার করুন{}
aditsu

যাইহোক, কোড গল্ফে আপনাকে স্বাগতম :)
aditsu

আমি অবশ্যই বলতে পারি, আমি মুগ্ধ, তবে y longতৈরি করা কোডটি ছোট করে তুলবে না
জোবা

হ্যাঁ এটি long x=…,y;
হ'ল

y1 থেকে শুরু করতে হবে, আপনি ঘোষণায় এটি আরম্ভ করতে পারেন, আপনার বর্গ সর্বজনীন করা দরকার নেই, এবং আপনি স্থানান্তর করতে পারেন y++থেকে x*y(পার্ট x*y++)
aditsu

2

পাইথ - 12 11 বাইট

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

f!-j*QT10U2

টেস্ট স্যুট


স্ট্রিংয়ে রূপান্তর করুন এবং সরান "01। একটি চর সংরক্ষণ করে
জাকুব

2

আর, 45 বাইট

x=scan();y=2;while(grepl("[2-9]",x*y))y=y+1;y

ব্যবহার:

> x=scan();y=2;while(grepl("[2-9]",x*y))y=y+1;y
1: 2
2: 
Read 1 item
[1] 5
> x=scan();y=2;while(grepl("[2-9]",x*y))y=y+1;y
1: 21
2: 
Read 1 item
[1] 481
> x=scan();y=2;while(grepl("[2-9]",x*y))y=y+1;y
1: 42
2: 
Read 1 item
[1] 2405

2

জাভা, 198 193 181 বাইট

5 বাইট ছাঁটাই এবং পরীক্ষারযোগ্য সংখ্যার পরিসর বাড়িয়ে দেওয়ার জন্য @ অ্যাডিটসুকে ধন্যবাদ!

নোট করুন যে জাভা কীভাবে পূর্ণসংখ্যাকে পার্স করে তার কারণে কিছু মান negativeণাত্মকভাবে লুপ করে। এটি বিগইন্টিজার দ্বারা পরিবর্তিত হতে পারে, তবে বোনাসটি কেবল কম মূল্যবান ছিল না।

আমি জানি যে আমি জিততে যাচ্ছি না, তবে আমি আশা করি এটি অন্যান্য, সংক্ষিপ্ত, উত্তরগুলি অনুপ্রাণিত করে।

ক্লাস এ {পাবলিক স্ট্যাটিক অকার্যকর প্রধান (স্ট্রিং [] ক) {এর জন্য (দীর্ঘ আই = 1 ;; আই ++) {চেষ্টা করুন {দীর্ঘ বি = লং. পার্সলং (ক [0]); যদি (খ * আমি <0) বিরতি; Long.parseLong (b * i + "", 2); System.out.println (i);} ক্যাচ (ব্যতিক্রম ই) {}}}}

Ungofled:

শ্রেণীকক্ষে {
   পাবলিক স্ট্যাটিক শূন্য মূল (স্ট্রিং [] এ) {
      (দীর্ঘ i = 1 ;; i++) এর জন্য inf // অসীম লুপ 1 থেকে শুরু হবে
         বাইনারি হিসাবে পার্স করার চেষ্টা করে যদি কোনও ত্রুটি নিক্ষেপ করা হয় তবে চেষ্টা করুন {// আইতে 1 যুক্ত করার পরে পুনরায় চালু করুন
            লম্বা বি = লং.পার্সলং (ক [0]); // পরবর্তী সময়ের জন্য - এটি দু'বার ব্যবহারের চেয়ে কম খাটো ছিল
            যদি (খ * আমি <0) বিরতি; // আমরা লুপ করে থাকলে প্রোগ্রামটি ভেঙে দিন।
            Long.parseLong (খ * আমি + "", 2); // গুণিত করুন এবং দেখুন এটি বাইনারি নম্বর হিসাবে পাসযোগ্য, অন্যথায়, ত্রুটি নিক্ষেপ করুন এবং লুপের শীর্ষে ফিরে যান
            System.out.println (খ); // এটি মুদ্রণ কর
         } ধরা (ব্যতিক্রম ই) {} // ধরায় কিছুই করবেন না
      }
   }
}

2
এটা যে মজার Longচেয়ে খাটো Integer:)
anatolyg

3
সবচেয়ে আক্ষরিক বিড়ম্বনা হয়।
অ্যাডিসন ক্রম্প

2

সি, 107 101 বাইট ( 32-বিটের জন্য 105 99 বাইট)

কোড গল্ফের সি-তে উত্তরের স্বতন্ত্র অভাব রয়েছে। প্রকৃতপক্ষে, সবচেয়ে ছোট সম্ভাব্য প্রোগ্রামটি লেখার জন্য সি সেরা পছন্দ নয়, তবে এটি খুব খারাপ নয়:

main(d,b){char s[9];gets(s);for(b=atoi(s);sprintf(s,"%d",b*d),strspn(s,"01")[s];d++);printf("%d",d);}

আপনি # অন্তর্ভুক্ত ছাড়া করতে পারেন, তবে তারপরে সমস্ত ফাংশন সংজ্ঞা অন্তর্ভুক্ত থাকবে। প্রধান অসুবিধাটি হ'ল এটি এই ধারণাটি তৈরি করে যে সমস্ত ফাংশন ইনটগুলি ফেরত দেয়। এটি ফাংশনগুলির জন্য 64৪-বিট মেশিনে সমস্যা যা প্রকৃতপক্ষে একটি পয়েন্টার দেয়। আপনি যদি 32-বিট মেশিনে থাকেন তবে 2 বাইট উপরের সমাধানটি দিয়ে শেভ করা যায়:

main(d,b){char s[9];for(b=atoi(gets(s));sprintf(s,"%d",b*d),strspn(s,"01")[s];d++);printf("%d",d);}

কিছুটা বেশি পঠনযোগ্য সংস্করণ:

int main()
{
  char s[9];
  gets(s);
  int d = 1;
  int b = atoi(s);
  for (; sprintf(s, "%d", b * d), strspn(s, "01")[s]; d++);
  printf("%d", d);
}

2

সি # সময় 5 সেকেন্ডের কাছাকাছি (1 থেকে 10000)

অনুরোধ হিসাবে, এখানে একটি গল্ফ সি # প্রোগ্রামটি আসল চ্যালেঞ্জের উত্তর দিচ্ছে। কমান্ড লাইন আর্গুমেন্ট হিসাবে ইনপুট, কনসোল আউটপুট।

using System;using System.Collections.Generic;using System.Numerics;using System.Linq;
class P{static void Main(string[] a){int m,n=int.Parse(a[0]);var d=new Dictionary<int,long>();long b;int h;
for(d[n]=0,b=h=1;;b*=2,h=(h*10)%n)foreach(int k in d.Keys.Reverse())if(!d.ContainsKey(m=(h+k)%n)){
var w=d[k]|b;if(m==0){Console.Write(BigInteger.Parse(Convert.ToString(w,2))/n);return;}d.Add(m,w);}}}

তারপরে, অনুগ্রহের ক্ষেত্রে: অনুগ্রহটি অ্যাডিটসুর কাছে চলে যাওয়া উচিত, কারণ আমি মনে করি যে তার অ্যালগরিদম পারফরম্যান্সের ক্ষেত্রে মারতে পারে না। তবে আনাতোলিগের স্ব-উত্তরটিও আশ্চর্যজনক।

এখানে সি # তে আমার দ্রুত বাস্তবায়ন। আমি মনে করি যে সি ++ তে এটি আরও দ্রুত হতে পারে (সম্ভবত 2x)। সংকলিত এবং ভিজ্যুয়াল স্টুডিও ২০১০, .NET ফ্রেমওয়ার্ক 4, 64 বিট, আউটপুটটিকে নালায় ডাইরেক্ট করে পরীক্ষা করা হয়েছে। সময়: 00: 00: 05.2604315

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Numerics;
using System.Diagnostics;

class Program
{
   static BigInteger Find(int n)
   {
      var d = new Dictionary<int, long>();
      long kb;
      int km;
      d[n] = 0;
      for (kb = km = 1; ; kb *= 2, km = (km * 10) % n)
      {
         foreach (int key in d.Keys.Reverse())
         {
            int m = (km + key) % n;
            if (!d.ContainsKey(m))
            {
               long w = d[key] | kb;
               if (m == 0)
               {
                  return BigInteger.Parse(Convert.ToString(w, 2));
               }
               d.Add(m, w);
            }
         }
      }
   }

   static void Exec(int n, out string sq, out string sa)
   {
      var v = Find(n);
      sq = (v/n).ToString();
      sa = v.ToString();
   }  

   static void Main(string[] args)
   {
      // string n = Console.ReadLine();
      int limit = int.Parse(args[0]);
      string q ="", a = "";
      Stopwatch x = new Stopwatch();
      x.Start();
      for (int n = 1; n <= limit; n++)
      {
         Exec(n, out q, out a);
         Console.WriteLine("{0} {1} {2}", n, q, a);
      }
      x.Stop();
      Console.Error.WriteLine("{0}", x.Elapsed);
   }
}

টাইমস 4.1 এস। আমি অনুগ্রহে ভুল বানান। পাইপাইয়ের সর্বশেষতম সংস্করণ সহ, অ্যাডিটসুর দ্রুততম সংস্করণ প্রায় 8s গুণ বেশি, সুতরাং এটি দ্বিগুণ দ্রুত।
primo

আমি বুঝতে পারি যে আপনি অনুগ্রহের পরে, কিন্তু তবুও এটি একটি কোড-গল্ফ প্রশ্ন এবং সাইটের বিধিগুলির জন্য আপনার কোডটি গল্ফ করার জন্য কিছু প্রচেষ্টা করা প্রয়োজন ।
পিটার টেলর

আমি অনুগ্রহের পরে নই, এটি বাস্তবায়নের উদাহরণ মাত্র। তবে আপনি ঠিক বলেছেন, আমি একটি গল্ফ সংস্করণ যুক্ত করব।
edc65

@ পিটারটেলর এখন কি যেতে পারে?
edc65

যাইহোক, কেন Keys.Reverse? আদেশ কি গুরুত্বপূর্ণ? এটি যদি সামঞ্জস্য সমস্যাগুলি এড়াতে হয় তবে ToListতা খাটো।
পিটার টেলর

2

জিএমপি সহ সি (621 বাইট, দ্রুত)

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

হিসাবে সংরক্ষণ করুন pseudobinary.cএবং সাথে সংকলন gcc pseudobinary.c -lgmp -o pseudobinary। নোট করুন যে এটি বড় ইনপুটগুলির জন্য এত বেশি মেমরি বরাদ্দ করে যে আপনাকে এটি একটি 64-বিট প্ল্যাটফর্মের জন্য সঙ্কলন করতে হবে।

#include <gmp.h>
int main(int y,char*z[]){int i,n,b,c,e,f,m,*j,*k,*l,*r,*h;char *d,*s;mpz_t
B,I,Q;i=atoi(z[1]);n=i;for(b=0;n%10<1;++b)n/=10;for(;n%2<1;++b)n/=2;for(;n%5<1;++b)n/=5;if(n<2)--b;d=calloc(n,1);j=calloc(n,sizeof(int));r=calloc(99,sizeof(int));c=2;d[1]=1;*j=r[1]=e=1;l=j+1;for(s=0;!s;++c){r[c]=e=e*10%n;k=l;for(h=j;h<k;h++){f=*h;m=(e+f)%n;if(d[m]<1){*l++=m;if(m<1){s=malloc(99);memset(s,48,99);for(f=c;f;f=d[m=(m+n-r[f])%n])s[c-f]++;s[c]=0;h=k;}d[m]=c;}}}f=strlen(s);s[f]=48;s[f+b]=0;mpz_init_set_str(B,s,10);mpz_init_set_si(I,i);mpz_init(Q);mpz_divexact(Q,B,I);d=mpz_get_str(0,10,Q);printf("%s\n",d);return 0;}

টাইমিংয়ের জন্য লুপ সংস্করণ (751 বাইট)

#include <gmp.h>
char **v;int main(){int i,n,b,c,e,f,m,*j,*k,*l,*r,*h;char *d,*s;mpz_t
B,I,Q;v=calloc(10001,sizeof(char*));v[1]=s=malloc(99);memset(s,48,99);*s=49;s[1]=0;for(i=0;++i<10001;){n=i;for(b=0;n%10<1;++b)n/=10;for(;n%2<1;++b)n/=2;for(;n%5<1;++b)n/=5;d=calloc(n,1);j=calloc(n,sizeof(int));r=calloc(99,sizeof(int));c=2;d[1]=1;*j=r[1]=e=1;l=j+1;for(;!v[n];++c){r[c]=e=e*10%n;k=l;for(h=j;h<k;h++){f=*h;m=(e+f)%n;if(d[m]<1){*l++=m;if(m<1){v[n]=s=malloc(99);memset(s,48,99);for(f=c;f;f=d[m=(m+n-r[f])%n])s[c-f]++;s[c]=0;h=k;}d[m]=c;}}}free(d);free(j);free(r);s=v[n];f=strlen(s);s[f]=48;s[f+b]=0;mpz_init_set_str(B,s,10);mpz_init_set_si(I,i);mpz_init(Q);mpz_divexact(Q,B,I);d=mpz_get_str(0,10,Q);printf("%s\n",d);free(d);s[f+b]=48;s[f]=0;}return 0;}

অবহেলিত লুপ সংস্করণ

#include <gmp.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

char **cache;

int main() {
    int i,n,shift,_kb,km,key,m,*ks,*ksi,*nksi,*res,*ii;
    char *d,*s;
    mpz_t B,I,Q;

    cache = calloc(10001,sizeof(char*));
    if (!cache) { printf("Failed to malloc cache\n"); return 1; }
    cache[1]=s = malloc(99);
    memset(s,48,99);
    *s=49;
    s[1]=0;
    for (i=0;++i<10001;) {
        n=i;
        for(shift=0;n%10<1;++shift)n/=10;
        for(;n%2<1;++shift)n/=2;
        for(;n%5<1;++shift)n/=5;

        d = calloc(n,1);
        if (!d) { printf("Failed to malloc d\n"); return 1; }

        ks = calloc(n,sizeof(int));
        if (!ks) { printf("Failed to malloc ks\n"); return 1; }

        res = calloc(99,sizeof(int));
        if (!res) { printf("Failed to malloc res\n"); return 1; }

        _kb = 2;
        d[1] = 1;
        *ks = res[1] = km = 1;
        nksi = ks + 1;

        for(;!cache[n];++_kb) {
            res[_kb] = km = km*10%n;
            ksi = nksi;
            for (ii = ks; ii < ksi; ii++) {
                key = *ii;
                m = (km + key) % n;
                if (d[m] < 1) {
                    *nksi++ = m;
                    if (m < 1) {
                        cache[n] = s = malloc(99);
                        if (!s) { printf("Failed to malloc s\n"); return 1; }
                        memset(s,48,99);
                        for(key=_kb;key;key = d[m = (m + n - res[key]) % n])s[_kb-key]++;
                        s[_kb]=0;
                        ii = ksi; // break
                    }
                    d[m] = _kb;
                }
            }
        }

        free(d);
        free(ks);
        free(res);

        // Add shift * '0'
        s=cache[n];
        key=strlen(s);
        s[key]=48;
        s[key+shift]=0;

        // convert to big integer, divide, print
        mpz_init_set_str(B,s,10);
        mpz_init_set_si(I,i);
        mpz_init(Q);
        mpz_divexact(Q,B,I);
        d = mpz_get_str(0,10,Q);
        if (!s) { printf("Failed to malloc quotient\n"); return 1; }
        printf("%s\n", d);
        free(d);

        // Remove shift * '0'
        s[key+shift]=48;
        s[key]=0;
    }
    return 0;
}

2

সি + জিএমপি, 669

এটি ক্ষুদ্র সংখ্যাগুলির জন্য সত্যই দ্রুত; ফলাফলটি যখন 64৪ এর বেশি সংখ্যক থাকে তখন এটি শ্বাসরোধ করতে শুরু করে।

#include<gmp.h>
#define B(x)(int)((x*(long)k)%n);
int*M,*H,P[99],n,x,p,q=2,e=1,k=10,y,f,z;char*E,C[99];int b(int k,int t){int
j=E[k],a=1<<(j-2);if(j<2){C[t]=49;return 1;}x=(int)((k+n-P[j]*(long)H[k]%n)%n);if(x)b(x,t);return a+b(H[k],t-a);}int
main(){scanf("%d",&n);E=calloc(n+1,1);M=calloc(n+1,4);H=malloc(n*4);M[1]=E[1%n]=P[1]=1;while(!E[0]){P[++e]=k;p=q;for(x=0;++x<p;){y=B(M[x])if(E[n-y]){E[0]=e;H[0]=M[x];break;}}if(!E[x=0])while(++x<p){y=B(M[x])for(z=0;z<p;++z){f=y+M[z];if(f>=n)f-=n;if(!E[f]){E[f]=e;H[f]=M[x];M[q++]=f;}}}k=B(k)}memset(C,48,98);C[99]=0;x=b(0,97);mpz_t
m,r;mpz_init(r);mpz_init_set_str(m,C+98-x,10);mpz_fdiv_q_ui(r,m,n);puts(mpz_get_str(C,10,r));}

সংস্করণ যা 10000 (671 বাইট) এ লুপ করে:

#include<gmp.h>
#define B(x)(int)((x*(long)k)%n);
#define N 10001
int M[N],H[N],P[99],n=0,x,p,q,e,k,y,f,z;char E[N],C[99];int b(int k,int t){int
j=E[k],a=1<<(j-2);if(j<2){C[t]=49;return 1;}x=(int)((k+n-P[j]*(long)H[k]%n)%n);if(x)b(x,t);return a+b(H[k],t-a);}int
main(){while(++n<N){memset(E,M[0]=0,n);M[1]=E[1%n]=P[1]=e=1;q=2;k=10;while(!E[0]){P[++e]=k;p=q;for(x=0;++x<p;){y=B(M[x])if(E[n-y]){E[0]=e;H[0]=M[x];break;}}if(!E[x=0])while(++x<p){y=B(M[x])for(z=0;z<p;++z){f=y+M[z];if(f>=n)f-=n;if(!E[f]){E[f]=e;H[f]=M[x];M[q++]=f;}}}k=B(k)}memset(C,48,98);C[99]=0;x=b(0,97);mpz_t
m,r;mpz_init(r);mpz_init_set_str(m,C+98-x,10);mpz_fdiv_q_ui(r,m,n);puts(mpz_get_str(C,10,r));}}

আমার কোডটি পাশাপাশি আমার প্রতিযোগীদের 'এবং আমার ল্যাপটপে ফলাফলগুলি পরীক্ষা করার জন্য এখানে কয়েকটি আদেশ রয়েছে:

ls -l *.c*       
-rw-r--r-- 1 aditsu aditsu  669 Oct 27 15:01 mult-aditsu-single.c
-rw-r--r-- 1 aditsu aditsu  671 Oct 27 15:01 mult-aditsu.c
-rw-r--r-- 1 aditsu aditsu 3546 Oct 27 15:01 mult-anatoly.c
-rw-r--r-- 1 aditsu aditsu 6175 Oct 27 15:01 mult-anders.cpp
-rw-r--r-- 1 aditsu aditsu  621 Oct 27 15:01 mult-peter-single.c
-rw-r--r-- 1 aditsu aditsu  751 Oct 27 15:01 mult-peter.c

gcc -w -march=native -O3 mult-aditsu-single.c -lgmp -o mult-aditsu-single
gcc -w -march=native -O3 mult-aditsu.c -lgmp -o mult-aditsu
gcc -w -march=native -O3 mult-peter-single.c -lgmp -o mult-peter-single
gcc -w -march=native -O3 mult-peter.c -lgmp -o mult-peter
gcc -w -march=native -O3 --std=c99 mult-anatoly.c -o mult-anatoly
g++ --std=c++11 -march=native -O3 mult-anders.cpp -o mult-anders

for i in {1..5}; do time ./mult-anders mult-anders.txt; done
./mult-anders mult-anders.txt  0.34s user 0.00s system 99% cpu 0.344 total
./mult-anders mult-anders.txt  0.36s user 0.00s system 99% cpu 0.358 total
./mult-anders mult-anders.txt  0.34s user 0.00s system 99% cpu 0.346 total
./mult-anders mult-anders.txt  0.35s user 0.00s system 99% cpu 0.347 total
./mult-anders mult-anders.txt  0.34s user 0.00s system 99% cpu 0.344 total

for i in {1..5}; do ./mult-anatoly mult-anatoly.txt; done
Time: 0.254416
Time: 0.253555
Time: 0.245734
Time: 0.243129
Time: 0.243345

for i in {1..5}; do time ./mult-peter > mult-peter.txt; done
./mult-peter > mult-peter.txt  0.14s user 0.00s system 99% cpu 0.137 total
./mult-peter > mult-peter.txt  0.15s user 0.00s system 97% cpu 0.153 total
./mult-peter > mult-peter.txt  0.15s user 0.00s system 99% cpu 0.149 total
./mult-peter > mult-peter.txt  0.15s user 0.00s system 99% cpu 0.150 total
./mult-peter > mult-peter.txt  0.14s user 0.00s system 99% cpu 0.138 total

for i in {1..5}; do time ./mult-aditsu > mult-aditsu.txt; done
./mult-aditsu > mult-aditsu.txt  0.06s user 0.00s system 95% cpu 0.058 total
./mult-aditsu > mult-aditsu.txt  0.05s user 0.00s system 97% cpu 0.055 total
./mult-aditsu > mult-aditsu.txt  0.06s user 0.00s system 99% cpu 0.056 total
./mult-aditsu > mult-aditsu.txt  0.05s user 0.00s system 99% cpu 0.054 total
./mult-aditsu > mult-aditsu.txt  0.05s user 0.00s system 98% cpu 0.055 total

md5sum *.txt
6eef8511d3bc5769b5d9218be2e00028  mult-aditsu.txt
6eef8511d3bc5769b5d9218be2e00028  mult-anatoly.txt
6eef8511d3bc5769b5d9218be2e00028  mult-anders.txt
6eef8511d3bc5769b5d9218be2e00028  mult-peter.txt

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

@ প্রিমো আপনাকে ধন্যবাদ :) এখানে আমার দৃষ্টিভঙ্গি আলাদা - আমি প্রতিটি ধাপে কেবলমাত্র সংখ্যা বাড়ানোর চেয়ে দ্বিগুণকে দ্বিগুণ করি এবং নতুন সংখ্যাগুলির কোনও সমাধান হয় কিনা তাও আমি প্রথম (খুব তাড়াতাড়ি) পরীক্ষা করে দেখি, আসলে গণনা করার আগে তাদের। এবং আমি নিশ্চিত গল্ফ করার জন্য এখনও জায়গা আছে।
aditsu

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

@ পিটারটেলর এটি সম্ভব .. যাইহোক, আমি কিছুটা সময় পেলে আমার কোডটির একটি অদম্য সংস্করণ যুক্ত করতে চাই এবং বড় / ন্যাসটিয়ার সংখ্যার জন্য কীভাবে এটি আরও দ্রুত করা যায় সে সম্পর্কে আমার ধারণাও রয়েছে।
aditsu

2

টি-এসকিউএল, 164 156 155 154 159 বাইট

(-1 বাইট। ধন্যবাদ জোনাথন!)

(-1 আরও কারণ কেন লাইনে আমার পিছনে স্থান রয়েছে? এসএমএইচ)

(+5 বুঝতে পেরেছি আমার গল্ফিং ভেঙে গেছে)

create function b(@ int)
returns int
as begin
declare @b varchar(max)='',@i int=@
while @>0SELECT @b=cast(@%2 as varchar)+@b,@/=2
return cast(@b as int)/@i
end

আমি জানি না কেন আমি কেন এই প্রশ্নগুলিতে ফিরে আসছি যেখানে আমার বাইনারিতে রূপান্তরিত হওয়ার কথা ... টি-এসকিউএল সঠিকভাবে এটি কীভাবে করতে হয় তা জানে না।

যাই হোক না কেন, এখানে একটি এসকিউএলফিডাল

আন golfed:

create function binarySquare(@id int)
returns int 
as BEGIN

এই জিনিসগুলির বেশিরভাগটি টি-এসকিউএলে একটি ফাংশন লিখতে প্রয়োজন, যতদূর আমি সচেতন।

    declare @bin nvarchar(max) = ''

একটি খালি স্ট্রিং তৈরি করুন যা আমরা আমাদের বাইনারি নম্বর হিসাবে সঞ্চয় করতে যাচ্ছি।

    declare @id2 int = @id

শেষে ইনপুট মান সংরক্ষণ করুন। দেখে মনে হচ্ছে আসল ইনপুটটি ব্যবহার করার কোনও উপায় থাকা উচিত যদিও আমরা মানটি পরিবর্তন করি তবে আমি এটির সন্ধান করতে পারি না।

    while @id>0
      BEGIN
        SET @bin = cast(@id%2 as varchar(1)) + @bin

সুতরাং আমরা আমাদের মূল ইনপুটটি নিয়ে থাকি, বাকিটিকে সন্ধানের জন্য এটি 2 দিয়ে মোড করুন এবং এটি আমাদের পরবর্তী ক্ষুদ্রতম অঙ্ক হতে চলেছে। উদাহরণস্বরূপ, 5% 2 = 1

        SET @id = @id/2

তারপরে আমরা আমাদের নম্বরটি নিয়েছি এবং এটি অর্ধেকে ভাগ করব। এটি একটি intপ্রকারের কারণ এটি এটিকে নিকটতম পুরো সংখ্যায় গোল করে, সুতরাং 5/2 = 2. শেষ হয় তারপরে আমরা মান 0 না হওয়া পর্যন্ত এটিকে লুপ করব So সুতরাং আমরা 5% 2 = 1 5/2 = 2 2 দিয়ে শেষ করব % 2 = 0 2/2 = 1 1% 2 = 1 1/2 = 0 যা আমাদের 101 এর বাইনারি স্ট্রিংয়ের মান দেয়।

    declare @binNum int = (SELECT cast(@bin as int))

আমরা আমাদের বাইনারি স্ট্রিংটি নিয়ে intআবার এটিকে আবার রূপান্তর করি ।

    return @binNum/@id2

আমরা আমাদের বাইনারি স্ট্রিংটি intপ্রশ্নের মূল উত্স অনুসারে আমাদের মূল মান দ্বারা বিভক্ত করে ফিরি ।

END

স্থান কি @>0 SELECTবাদ দেওয়া যায় না?
জোনাথন ফ্রেচ

আমার স্নাতকের! কোন জায়গাগুলি বাদ দেওয়া সম্ভব তা আমি কখনই মনে করতে পারি না ...
phrereo

বেশিরভাগ সময় আপনি আক্ষরিক এবং ভেরিয়েবল / কীওয়ার্ডের মধ্যে ফাঁকা স্থান বাদ দিতে পারেন, কারণ তারা কোনও অঙ্ক দিয়ে শুরু করতে পারে না।
জোনাথন ফ্রেচ

1

রুবি, 46 বাইট

আমার সত্যিই বিকল্প লুপের সাথে লুপটি অপসারণ করা উচিত।

n,k=gets,0;$_="#{n.to_i*k+=1}"while/[^01]/;p k

সম্পাদনা: 1 বাইট বন্ধ শেভ করার জন্য @ মান্যাটওয়ার্ককে ধন্যবাদ!

সম্পাদনা 2: উন্মাদ 9 বাইটের জন্য @ হিস্টোক্রোকফটকে ধন্যবাদ!

সম্পাদনা করুন: 7 বাইট বন্ধ করে দেওয়ার জন্য আবার @ মান্যাটওয়ার্ককে ধন্যবাদ!


z!=z[/[01]+/]খাটো হয়। z[/[^01]/]আরও সংক্ষিপ্ত।
manatwork

@ মান্যাটওয়ার্ক ধন্যবাদ! 1 বাইট কম!
পিটার লেনকেফি

2
একক লাইন যখন লুপগুলি সবচেয়ে কম হতে থাকে:z="#{n.to_i*k+=1}"while z[/[^01]/]
হিস্টোক্র্যাট

@ হিস্টোক্র্যাট যে 9 বাইট! এবং আমি এমনকি জানতাম না যে রুবি এটি সক্ষম। ধন্যবাদ!
পিটার লেনকফি

আকর্ষণীয় যে আপনি দ্বিতীয়বারের মত প্রস্তাবিত হওয়ার পরেও পরীক্ষাকে অবহেলিত চরিত্রের সেটটিতে পরিবর্তন করেননি। কোন কারণে?
manatwork

1

স্কালা, 114 বাইট

val i=scala.io.StdIn.readInt;Stream.from(1).foreach{x=>if((i*x+"").map{_.asDigit}.max<2){print(x);System.exit(0)}}

পাঠযোগ্য সংস্করণ

val i=scala.io.StdIn.readInt
Stream.from(1).foreach{x => 
    if((i*x+"").map{_.asDigit}.max<2) {
        print(x)
        System.exit(0)
    }
}

1

gawk4 ব্রুট ফোর্স, 28 + 2 = 30 বাইট

{while(++n*$0~/[2-9]/);}$0=n

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

ব্যবহারের উদাহরণ (যদি আপনি সময় নষ্ট করতে চান ;))

echo 27 | awk -M '{while(++n*$0~/[2-9]/);}$0=n'

gawk4 অপ্টিমাইজড, 69 + 2 = 71 বাইট

{for(;!a[0];NR*=10)for(i in a)a[j=(s=a[i]+NR)%$0]?0:a[j]=s}$0=a[0]/$0

ঠিক আছে, এটি অ্যাডিটসুর উত্তরের ক্লোন হয়ে গেছে। দেখার পরও কি এই প্রশ্নের আমি এখনও figuring আউট ছিল, উপসেট-সমষ্টি অংশ কোড কিভাবে যখন আমি অন্য উত্তর এখানে খুঁজছেন না বিরোধিতা করতে পারে।

অজস্র অ্যারে উপাদানগুলির মধ্যে (অদ্ভুত?) আচরণ রয়েছে যে আপনি যদি কোনও অ-বিদ্যমান উপাদানকে কোনও কিছুর সাথে তুলনা করেন তবে তুলনা করার আগে এটি কোনওভাবে খালি হিসাবে শুরু করা হয় (আমি স্বীকার করব যে সেখানে কী ঘটছে সে সম্পর্কে আমি যথেষ্ট নিশ্চিত নই)। লুপ চেক !a[0]করার পরে for(i in a)এমনকি আরম্ভ না করে শুরু a[$0]হয়0 যেমন aditsu করেনি।

অবশ্যই -Mবিকল্পটি এর জন্যও ব্যবহার করতে হবে।

এটি বরং দ্রুত হলেও এটি পাইথনের চেয়ে এখনও উল্লেখযোগ্যভাবে ধীর। এর জন্য 79992আমার 2GHz কোর 2 ডুওতে প্রায় 14 সেকেন্ড সময় লাগে। এবং আমি এটি বলব না যে এটি 2 ^ 31 পর্যন্ত ইনপুটগুলির জন্য কাজ করে, কারণ সবচেয়ে খারাপ ক্ষেত্রে এটি বড় সংখ্যার একটি অ্যারে তৈরি করতে হয় (gawk4 এটির জন্য GMP ব্যবহার করে), যার ইনপুট সংখ্যার আকার রয়েছে। একটি 'বোনাস' হিসাবে বড় অ্যারেগুলি খুব খারাপভাবে খুব ধীরে ধীরে ...


1

ডায়ালগ এপিএল , 25

এটি একটি উপযুক্ত প্রোগ্রাম "পি" সংজ্ঞায়িত করে (কেবল একটি নামবিহীন ফাংশন নয়):

P←2∘{0::⍵∇⍨1+⍺⋄⍺⊣~⍎¨⍕⍺×⍵}

2∘
0::যদি কোনও ত্রুটি থাকে তবে বাম আর্গুমেন্ট হিসাবে 2 দিয়ে শুরু করুন ...
⍵∇⍨1+⍺বর্ধিত বাম আর্গুমেন্টের সাথে নিজেকে কল করুন
⍺×⍵বাম এবং ডান যুক্তিগুলিকে
স্ট্রিংয়ে পরিণত
⍎¨করুন প্রতিটি অক্ষরকে একটি সংখ্যা
~প্রয়াসকে লজিকাল নয় (যদি এটি ব্যর্থ হয় তবে ত্রুটি-পরিচালনা উপরের দিকে যান, অন্য ...)
⍺⊣বর্তমান বাম যুক্তি ফিরিয়ে দিন।

      P 2
50
      P 21
481
      P¨⍳8    ⍝ 1 through 8
10 5 37 25 2 185 143 125
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.