এলোমেলোতার অবিচ্ছিন্ন উত্স ব্যবহার করে 0 এবং n এর মধ্যে একটি এলোমেলো সংখ্যা চয়ন করুন

26

কার্য

আপনি যে কোনও উপায়ে বেছে নিলে ইনপুট হিসাবে নির্দিষ্ট nচেয়ে কম ধনাত্মক পূর্ণসংখ্যা দেওয়া হয়েছে 2^30, আপনার কোডটি অন্তর্ভুক্ত করে 0এবং এর মধ্যে একটি এলোমেলো পূর্ণসংখ্যার আউটপুট তৈরি করবে should nআপনার উত্পন্ন নম্বরটি এলোমেলোভাবে নির্বাচন করা উচিত । যে থেকে প্রতিটি মান 0থেকে n(বিধি ও আদেশ সহকারে দেখুন) সমান সম্ভাবনা থাকে ঘটতে উচিত নয়।

বিধি এবং গুহাত

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

  • আপনাকে এটি প্রতিষ্ঠিত করতে হবে যে আপনি যে র্যান্ডম উত্সটি ব্যবহার করছেন তা অভিন্ন হলে আপনার কোডটি সঠিকভাবে অভিন্ন র্যান্ডম পূর্ণসংখ্যাকে আউটপুট 0দেয় n।
  • বিল্ট ইন বা লাইব্রেরি এলোমেলো ফাংশন কল করার সময় কোনও যুক্তি অবশ্যই ধ্রুবক হতে হবে। এটি হ'ল তারা অবশ্যই ইনপুট মানের থেকে সম্পূর্ণ স্বতন্ত্র হতে হবে।
  • আপনার কোডটি সমাপ্তির গ্যারান্টি না দিয়ে সম্ভাব্যতা 1 দিয়ে শেষ হতে পারে ।

নোট

  • randInt(0,n) বৈধ বা বৈধ গ্রন্থাগারের ফাংশনে আর্গুমেন্ট হিসাবে ইনপুট গ্রহণ করায় এটি বৈধ নয়।
  • rand()%nহবে না সাধারণভাবে একটি অভিন্ন র্যান্ডম সংখ্যা দেব। Betseg দ্বারা প্রদত্ত উদাহরণ হিসাবে, intmax == 15এবং যদি n = 10, তবে আপনি এর 0-5চেয়ে বেশি পাওয়ার সম্ভাবনা পাবেন 6-10।
  • floor(randomfloat()*(n+1)) 0 এবং 1 এর মধ্যে বিভিন্ন সম্ভাব্য ভাসমান পয়েন্টের সীমাবদ্ধ সংখ্যার কারণে সাধারণভাবে অভিন্ন র্যান্ডম সংখ্যাও দেবে না।
code-golf  number  random  probability-theory 
— totallyhuman
সূত্র
আপনি কীভাবে নিশ্চিত করতে যাচ্ছেন যে আউটপুটটি অভিন্নভাবে এলোমেলো? এটি হতে পারে যে কোনও প্রদত্ত ভাষা / পাঠাগারটি অভিন্ন র্যান্ডম সংখ্যার আউটপুট দেয় তবে ম্যানিপুলেশনের ফলে অ-ইউনিফর্ম আউটপুট আসতে পারে। (যেমন rng()সরবরাহ করে 0- 100যদি n = 75, এবং ফাংশনটি হয় rng()%75তবে 0-25 আরও সাধারণ হবে ...)
— বাল্ড্রিক ১৮
1
@ বাল্ড্রিক জনতার বুদ্ধি দ্বারা :) আমরা কেবল কোডটি পড়তে পারি এবং এটি সম্পর্কে চিন্তা করতে পারি।
সহজতম সম্ভাব্যতা-তত্ত্বের প্রশ্ন জিজ্ঞাসার দুঃখজনক উপসংহার: এলোমেলোতা এবং সম্ভাবনা খুব খারাপভাবে বোঝা যায়। :( (এবং নিয়মগুলি পড়ার পক্ষে কঠোর, স্পষ্টতই)))
— মার্টিন এন্ডার
এটি মাথায় আসে: র‌্যান্ডম নম্বর
— বিজিআর ওয়ার্কার
যখন তিনটি সংক্ষিপ্ত উত্তর থাকবে তখন আপনি কেন x86 উত্তরটি গ্রহণ করলেন?
— ডেনিস

উত্তর:

25

rdrandনির্দেশ সহ x86 মেশিন , 10 বাইট

BITS 64

_try_again:

 rdrand eax
jnc _try_again

 cmp eax, edi
ja _try_again

 ret

মেশিন কোড

0FC7F0 73FB 39F8 77F7 C3

ইনপুটটি রেজিস্টারে rdiএবং আউটপুটটি ইন rax।
এটি এসওয়াইএস ভি এএমডি 64 এবিআইকে সম্মান করে তাই কোড কার্যকরভাবে একটি সি ফাংশন প্রয়োগ করে

unsigned int foo(unsigned int max);

32-বিট ints সহ।

নির্দেশটি rdrandইন্টেল দ্বারা বর্ণিত হয়েছে

RDRANDক্রিপ্টোগ্রাফিকভাবে সুরক্ষিত, ডিটারমিনিস্টিক এলোমেলো বিট জেনারেটর ডিআরবিজি সরবরাহ করে এমন এলোমেলো সংখ্যা দেয়। ডিআরবিজি এনআইএসটি এসপি 800-90A মান পূরণের জন্য ডিজাইন করা হয়েছে ।

সিএসআরএনজির সাথে ডিল করার বিষয়টি অন্তর্নিহিত যে বিতরণটি অভিন্ন, যাইহোক, এনআইএসপি এসপি 800-90A এর উদ্ধৃতি দিয়ে:

একটি এলোমেলো সংখ্যা হ'ল একটি নিরপেক্ষ র্যান্ডম ভেরিয়েবলের উদাহরণ, অর্থাৎ আউটপুটটি অভিন্ন বিতরণ করা এলোমেলো প্রক্রিয়া দ্বারা উত্পাদিত হয় ।

পদ্ধতিটি একটি এলোমেলো সংখ্যা উত্পন্ন করে এবং যদি ইনপুটটির চেয়ে এটি কঠোরভাবে বেশি হয় তবে তা ফেরত দেওয়া হয়।
অন্যথায়, প্রক্রিয়া পুনরাবৃত্তি করা হয়।

যেহেতু eax32-বিট, rdrand0 এবং 2 32 -1 এর মধ্যে একটি নম্বর প্রদান করে, সুতরাং প্রতিটি এন এর জন্য [0, 2 32 -1] প্রত্যাশিত পুনরাবৃত্তির সংখ্যা 2 32 / (n + 1) যা সমস্ত এন এর জন্য সংজ্ঞায়িত [0, 2 30 ) এ।

— মার্গারেট ব্লুম
সূত্র
উজ্জ্বলভাবে নিম্ন স্তর। ধন্যবাদ.
কিসের jncজন্য?
— l4m2
@ l4m2 rdrandসেট করে CFযদি ফিরিয়ে দেওয়া ডেটা বৈধ হয়। ডেটা অবৈধ হতে পারে কারণ অনেকগুলি অনুরোধ এনট্রপি পুলটি ড্রেন করে। Rtrand এবং এই জন্য ম্যানুয়াল এন্ট্রি দেখুন ।
— মার্গারেট ব্লুম
20

জেলি , 7 6 বাইট

⁴!!X%‘

@ জোনাথান অ্যালানকে 1 বাইট বন্ধ করে গল্ফ করার জন্য ধন্যবাদ!

টিআইও তে চালানো যায় না কারণ (16!)! একটি বিশাল সংখ্যা।

কিভাবে এটা কাজ করে

⁴!!X%‘  Main link. Argument: n

⁴       Set the return value to 16.
 !!     Compute (16!)!.
   X    Pseudo-randomly choose an integer between 1 and (16!)!.
        Since (16!)! is evenly divisible by any k ≤ 2**30, it is evenly divisible
        by n+1.
    %‘  Take the result modulo n+1.
— ডেনিস
সূত্র
এটি আমার মুছে দেওয়া উত্তর, একই ধারণার একটি স্থির সংস্করণ। যদিও আমি একটি অপ্রয়োজনীয় ক্ষয়ক্ষতি ছিল।
— orlp
দুঃখিত, আমি পোস্ট করার আগে এটি তাকান না।
— ডেনিস
ওহ ব্যাপার না, আমি যাইহোক এটি ঠিক করার পরিকল্পনা করছিলাম না। আমি জেলি এর সাথে সত্যই চারপাশে খেলতে অস্বস্তি বোধ করছি।
— orlp
1
"স্যার আমি জানি না আপনি পাগল কেন। অ্যালগরিদম ধ্রুবক সময়। এটি একটি ভাল জিনিস, তাই? কেন সুরক্ষা এবং এইচআর দরজার বাইরে?"
— কর্সিকা
1
একমত। একটি 8 ডিজিটের সংখ্যা এবং 417 পঞ্চম অঙ্কের সংখ্যার মধ্যে পার্থক্যের বিট: পি
— জোনাথন অ্যালান
11

গণিত, 29 বাইট

ডেনিসের জেলি উত্তরের উপর ভিত্তি করে ।

RandomInteger[2*^9!-1]~Mod~#&

আমি আসলে এটি চালানোর পরামর্শ দিচ্ছি না। 2e9!খুব সুন্দর একটি সংখ্যা ...

এটি সম্ভাব্য সমস্ত ইনপুট দ্বারা বিভাজ্য এমন একটি বিশাল সংখ্যা তৈরি করতে সংক্ষিপ্ততম রূপে পরিণত হয়েছে এবং একটি সাধারণ মডুলো সহ প্রয়োজনীয় পরিসরে ফলাফলকে ম্যাপ করে।

প্রত্যাখ্যান নমুনা, 34 বাইট

আমার পুরানো পদ্ধতির ফলে আরও কিছু আকর্ষণীয় কোড তৈরি হয়েছিল:

13!//.x_/;x>#:>RandomInteger[13!]&

বেসিক প্রত্যাখ্যান নমুনা। আমরা আউটপুট 13 এ আরম্ভ করি ! (যা সর্বোচ্চ ইনপুট 2 30 এর চেয়ে বড় ) এবং তারপরে 0 এবং 13 এর মধ্যে বারবার এলোমেলো পূর্ণসংখ্যার সাথে এটি প্রতিস্থাপন করুন ! যতক্ষণ মান ইনপুট চেয়ে বড় হয়।

— মার্টিন ইন্ডার
সূত্র
1
আপনি কি "ইনপুট এর চেয়ে ছোট বা সমান" বলতে চান?
1
@ ললেবিক নং আমরা মানটি যতক্ষণ পছন্দসই সীমার মধ্যে না পড়ে ততক্ষণ পুনরায় জন্মানো করতে চাই।
— মার্টিন এন্ডার
আচ্ছা বুঝলাম. কিছু কারণে আমি ভেবেছিলাম আমরা বারবার পছন্দসই পরিসর থেকে নমুনা নিচ্ছি। ধন্যবাদ।
1
পরের বারের সময়সীমা যুক্ত করতে আমাকে স্মরণ করিয়ে দিন :)
9

ব্র্যাচল্যাগ , 9 বাইট

≥.∧13ḟṙ|↰

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

এটি 13!মার্টিন ইন্ডারের উত্তরের মতো ব্যবহার করে (এর 13ḟচেয়ে এক বাইট কম 2^₃₀)।

ṙব্যবহার করে বাস্তবায়ন করা হয় random_between/3, যা, এর উত্স খনন করার সময়, এর random_float/0সাথে লিঙ্কযুক্ত random/1যা ব্যবহার করে যা মরসেন টুইস্টার অ্যালগরিদম ব্যবহার করে যা আমাদের উদ্দেশ্যগুলির জন্য অভিন্ন।

ব্যাখ্যা

≥.           Input ≥ Output
  ∧          And
   13ḟṙ      Output = rand(0, 13!)
       |     Else
        ↰    Call recursively with the same input
— Fatalize
সূত্র
7

প্রোলোগ (এসডাব্লুআই) , 38 বাইট

X*Y:-Z is 2^31,random(0,Z,Y),Y=<X;X*Y.

প্রত্যাখ্যান নমুনা দ্বারা কাজ করে।

0 থেকে 2 এর মধ্যে একটি এলোমেলো সংখ্যা তৈরি করুন ^ 31-1 = 2147483647 যতক্ষণ না ইনপুটের চেয়ে কম বা সমান একটি খুঁজে পাওয়া যায়।

আমার মনে হচ্ছে যেন অন্যটির পরিবর্তে আমার কাটা ব্যবহার করা উচিত তবে কীভাবে তা আমি দেখতে পাচ্ছি না।

— Emigna
সূত্র
1
আপনি অন্যটি ব্যবহার এড়াতে পারবেন repeat, তবে এটি 3 বাইট বেশি দীর্ঘ হওয়া শেষ করবে ... আমি নিশ্চিত নই যে পুনরাবৃত্তির চেয়ে অনন্ত পছন্দ পয়েন্টের একটি ছোট উপায় আছে কিনা।
— 14-17 এ ফ্যাটালাইজ করুন
@ ফ্যাটালাইজ: হ্যাঁ আমি আবারও চেষ্টা করেছি। ,!.ব্যাকট্র্যাকটি জোর করার মতো কিছু ব্যবহার করার স্মৃতি আমার ছিল , তবে হয় আমি এটি ভুল মনে করছি বা এটি এই সমাধানটির জন্য প্রযোজ্য নয়।
— এমিগিনা
7

ল্যাবরেথ , 63 বাইট

 ?
 #00}__""*_
 ;    #"  _
{-{=  } "><)
!{ : ;"({ +
@  }}:  >`#

(এখানে কিছু ভারী গল্ফিংয়ের জন্য সহায়তার জন্য @ মার্টিন ইন্ডারকে ধন্যবাদ))

ল্যাবরেথ 2 ডি ভাষা এবং এটির এলোমেলোতার একমাত্র উত্স নীচের মতো পরিস্থিতিতে রয়েছে:

   x
  "<)
 " "
 " "

ধরুন নির্দেশ পয়েন্টারটি xচলছে এবং নীচের দিকে চলছে। এটি পরবর্তী স্থলে নেমে আসে <, যা যদি স্ট্যাকের শীর্ষটি 0 হয় (যা প্রকৃত প্রোগ্রামে সর্বদা ক্ষেত্রে থাকে) বর্তমান সারিকে 1 দ্বারা বামে স্থানান্তরিত করে:

   "
 "<)
 " "
 " "

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

মূলত উপরের প্রোগ্রামটি যা করে তা হ'ল 100-বিট সংখ্যা তৈরি করতে এলোমেলো বৈশিষ্ট্যটি ব্যবহার করা হয় ( #00এখানে 100 দ্বারা নির্দিষ্ট করা ) এবং এটি একটি সংখ্যা তৈরি না করা অবধি লুপিং অবিরত রাখবে <= n।

পরীক্ষার জন্য, সম্ভবত এটি কোনও অপ-পাথ থাকার কারণে #0"10-বিট সংখ্যার পরিবর্তে সম্ভবত ব্যবহার করতে সহায়তা "করবে। এটি অনলাইন চেষ্টা করুন!

রুক্ষ ব্যাখ্যা:

 ?            <--- ? is input and starting point
 #0"}__""*_   <--- * here: first run is *0, after that is *2 to double
 ;    #"  _
{-{=  } "><)  <--- Randomness section, +0 or +1 depending on path.
!{ : ;"({ +        After <, the >s reset the row for the next inner loop.
@  }}:  >`#

 ^    ^
 |    |
 |    The " junction in this column checks whether the
 |    100-bit number has been generated, and if not then
 |    continue by turning right into }.
 |
 Minus sign junction here checks whether the generated number <= n.
 If so, head into the output area (! is output as num, @ is terminate).
 Otherwise, head up and do the outer loop all over again.
— Sp3000
সূত্র
7

পাইথন, 61 বাইট

from random import*
lambda n,x=2.**30:int(randrange(x)*-~n/x)

সম্পাদনা: নিষিদ্ধ ফর্ম এড়ানোর জন্য আপডেট করা হয়েছে

সম্পাদনা 2: 2 বাইট সংরক্ষিত, ধন্যবাদ জোনাথন অ্যালান

সম্পাদনা 3: সম্পূর্ণ কার্যকরী সমাধানের জন্য 2 বাইট প্রদান করা হয়েছে - আবার ধন্যবাদ জনাথন অ্যালান

সম্পাদনা 4: f=2 বাইট সংরক্ষণ করে, সরানো হয়েছে

সম্পাদনা 5: @ জোনাথন অ্যালানকে আরও 1 টি বাইট সংরক্ষণ করা হয়েছে

সম্পাদনা 6: @ জোনাথন অ্যালানকে আরও 2 টি বাইট সংরক্ষণ করা হয়েছে

এতক্ষণে, গিট দোষ আমার পক্ষে খারাপ জিনিসগুলির জন্য এবং জোনাথন অ্যালান যে জিনিসগুলিতে সহায়তা করে তার দিকে লক্ষ্য করবে।

সম্পাদনা 7: যখন বৃষ্টি হয় তখন তা oursেলে দেয় - আরও 2 বাইট

সম্পাদনা 8: এবং আরও 2 বাইট

— iwaseatenbyagrue
সূত্র
1
এই অভ্যাসটি কখনই আউটপুট দেয় না n, তবে আপনি এটি ব্যবহার করে from random import*এবং বাদ দিয়ে ঠিক করতে গিয়ে দুটি বাইট সংরক্ষণ করতে পারেন r.।
— জোনাথন অ্যালান
1
হ্যাঁ, অন্যথায় প্রয়োজনীয় বন্ধনীগুলি এড়াতে আপনি "ট্যাডপোল অপারেটর" ব্যবহার করতে পারেন, ...*(-~n*1.0/2**30))তার চেয়ে...*((n+1)*1.0/2**30))
— জোনাথন অ্যালান
1
সত্যি? খুব সুন্দর! 70 নম্বরটির বিরুদ্ধে আপনার কি দীর্ঘকালীন বিচক্ষণতা রয়েছে? আপনাদের সহায়তার জন্য অনেক ধন্যবাদ
— iwaseatenbyagrue
1
প্রকৃতপক্ষে randrangeমনে হয় একটি ভাসাটি গ্রহণ করে, তাই lambda n,x=2.**30:int(randrange(x)*-~n/x)অন্য দু'টিকে [সম্পাদনা ...] চারটি বাঁচায়!
— জোনাথন অ্যালান
1
there সেখানে আরও দুটি বন্ধনী অপসারণ সহ। খালি আপনার গুণ দেখাতে গিয়েছিল উপায়!
— জোনাথন অ্যালান
6

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

from random import*
lambda n:map(randrange,range(1,2**31))[n]

ছদ্ম-এলোমেলোভাবে মধ্যে পূর্ণসংখ্যার বেছে 0 এবং ট সব মানের জন্য ট মধ্যে 0 এবং 2 31 - 2 , তারপর পূর্ণসংখ্যা সংশ্লিষ্ট লাগে ট = ঢ ।

— ডেনিস
সূত্র
5

ব্যাচ, 64 বাইট

@set/ar=%random%*32768+%random%
@if %r% gtr %1 %0 %1
@echo %r%

%random%কেবল এলোমেলোভাবে 15 বিট দেয়, তাই আমাকে দুটি এলোমেলো সংখ্যা সংযুক্ত করতে হবে। এলোমেলো মান অবধি কাঙ্ক্ষিত সীমার মধ্যে থাকা পর্যন্ত লুপগুলি এত কম n; দ্রুত সংস্করণের জন্য 98 বাইট:

@set/a"n=%1+1,m=~(3<<30)/n*n,r=%random%*32768+%random%
@if %r% geq %m% %0 %1
@cmd/cset/a%r%%%%n%
— নিল
সূত্র
কোডটি ধীর হতে পারে তবে আপনার উত্তরটি দ্রুত ছিল!
3
@ ললেবিকের কাছে আপনার মুছে ফেলা প্রশ্নে যাওয়ার উত্তর আমার কাছে প্রস্তুত ছিল ...
— নিল
এটি কি প্রথমে পছন্দসই সংখ্যাটি প্রতিধ্বনিত করবে না এবং তারপরে অন্য সমস্ত সংখ্যা যা এর চেয়ে বড় হয়ে উঠবে n?
— এরিক দি আউটগল্ফার
পুনঃটুইট আপনি যদি না ব্যবহার না করেন call, কোনও ব্যাচের স্ক্রিপ্ট চাওয়া বর্তমান স্ক্রিপ্টটি সমাপ্ত করে।
— নিল
5

এমএটিএল , 12 বাইট

কীভাবে টিআইও ক্যাশে অক্ষম করবেন তা বলার জন্য @ অ্যাডমবর্কবার্ক এবং @ স্যুভারকে ধন্যবাদ জানাই

`30WYrqG>}2M

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

এই ব্যবহার প্রত্যাখ্যান পদ্ধতি থেকে একটি র্যান্ডম পূর্ণসংখ্যা উৎপন্ন: 0থেকে 2^30-1যখন এটি ইনপুট অতিক্রম করে এবং পুনরাবৃত্তি n। এটি সম্ভাবনার সাথে সমাপ্তির গ্যারান্টিযুক্ত 1, তবে পুনরাবৃত্তির গড় সংখ্যা হ'ল 2^30/n, এবং এর nচেয়ে উল্লেখযোগ্যভাবে ছোট হওয়ার জন্য এটি খুব দীর্ঘ সময় নেয় 2^30।

`         % Do...while
  30W     %   Push 2^30
  Yr      %   Random integer from 1 to 2^30
  q       %   Subtract 1
  G>      %   Does it exceed the input? If so: next iteration. Else: exit
}         % Finally (execute right before exiting the loop)
  2M      %   Push the last generated integer
          % End (implicit). Display (implicit)
— লুইস মেন্ডো
সূত্র
4

জাভাস্ক্রিপ্ট (ES6), 55 54 বাইট

f=(n,m=1)=>m>n?(x=Math.random()*m|0)>n?f(n):x:f(n,m*2)

[0 ... 2 কে - 1] সীমাতে পূর্ণসংখ্যা উত্পন্ন করে , যেখানে k হল সবচেয়ে ছোট পূর্ণসংখ্যা যেমন 2 কে এন এর চেয়ে বড় । ফলাফল [0 ... এন] এ না হওয়া পর্যন্ত পুনরাবৃত্তি করে ।

কেন?

এটি নিম্নলিখিত অনুমানের উপর ভিত্তি করে:

  • অভ্যন্তরীণভাবে, জেএস ইঞ্জিন দ্বারা খাওয়ানোর Math.random()জন্য উত্পন্ন সিউডো-এলোমেলো পূর্ণসংখ্যার মানগুলি যে কোনও ব্যবধানে [0 ... 2 কে -1] ( কে <32 সহ ) একরকম ।

  • একবার যথাযথ পাওয়ার 2 দিয়ে গুণ করলে, আইইইই 754 এর ফ্লোট মানগুলি Math.random()এরূপ বিরতিতে এখনও অভিন্ন।

যদি কেউ এই অনুমানগুলি নিশ্চিত বা খণ্ডন করতে পারে তবে দয়া করে আমাকে মন্তব্যগুলিতে জানান।

ডেমো

[0 ... 2] এ 1 মিলিয়ন মান উত্পন্ন করে এবং ফলাফলের পরিসংখ্যান প্রদর্শন করে।

কোড স্নিপেট দেখান

— Arnauld
সূত্র
ম্যাথ.ফ্লুর (ম্যাথআর্যান্ডম () * (এন + 1)) আমার জন্য কম অভিন্ন বিতরণ করা ফলাফল উত্পন্ন করে, তাই দেখে মনে হবে যে কোনও বাস্তবসম্মত এন <2 ^ 30 রয়েছে, যা কোনও বিতরণ বিবিধতা আনবে মোটেই
— জেপেলিন
1
@ এজেপেলিন যে কোনও ব্যতিক্রমতা চিহ্নিত করতে আপনাকে অনেকগুলি ট্রায়াল রান দরকার রয়েছে যেহেতু সেই পরিসরে একটি এলোমেলো ভাসমানের 2 ^ 53 টির মধ্যে একটির 2 টি থাকবে যা 2 ^ 30 ফলাফলের হিসাবে যথাসম্ভব সমানভাবে বিতরণ করা হবে। এমনকি বিস্তৃত বৃহত সংখ্যার জন্যও ত্রুটিটি 1 2 2 ^ 23 এর মতো কিছু হবে যার অর্থ আপনার একটি হাস্যকর সংখ্যার বিচার দরকার। আপনি সম্ভবত প্রাথমিক নমুনার সংখ্যার চেয়ে 2 ডিগ্রী মাত্রার আরও কয়েকটি আদেশ চান (2 ^ 53)। তবুও, এটি পুরোপুরি সমান হতে পারে না যদি গুণক সমানভাবে নমুনার সংখ্যাকে ভাগ করে না দেয় যার কারণেই আরনাউল্ড দুটি শক্তি ব্যবহার করে।
— মার্টিন ইন্ডার
4

বাশ (+ কোর্টিল), 44 বাইট

/ dev / ইউরানডম ভিত্তিক সমাধান

od -w4 -vtu4</d*/ur*|awk '($0=$2)<='$1|sed q

স্বাক্ষরবিহীন 32 বিট ইন্টিজারগুলি পড়বে /dev/urandomএবং awkকোনও নির্দিষ্ট রেঞ্জের মধ্যে এটি না পাওয়া পর্যন্ত এগুলি ফিল্টার করে ফেলবে , তারপরে sed qপাইপটি বাতিল করতে হবে ort

— জেপেলীন্
সূত্র
বাশ এর জন্য
4

হাস্কেল, 70 বাইট

import System.Random
g n=head.filter(<=n).randomRs(0,2^30)<$>getStdGen

খুব দক্ষ অ্যালগরিদম নয় তবে এটি কাজ করে। এটি [0,2 ^ 30] দ্বারা আবদ্ধ সংখ্যার পূর্ণসংখ্যার (অথবা প্রয়োজনে ভাসমান, হাসেল এর ধরণের সিস্টেমের কারণে ভাসমান) উত্পন্ন করে এবং প্রথমটিকে n এর চেয়ে কম বা সমান করে takes ছোট এন এর জন্য এটি একটি দীর্ঘ সময় নিতে পারে। র্যান্ডম সংখ্যা অবিশেষে, বিতরণ করা উচিত দস্তাবেজের মধ্যে উল্লিখিত হিসাবে randomR ব্যবধান [0,2 ^ 30] (1 / (2 ^ 30 + 1)) সেইজন্য সমস্ত সংখ্যা একই সম্ভাবনা থাকা উচিত সব সংখ্যার তাই [ 0, n] একই সম্ভাবনা রয়েছে।

বিকল্প সংস্করণ:

import System.Random
g n=head.filter(<=n).map abs.randoms<$>getStdGen

এই সংস্করণটি ভয়ানক তবে এটি পুরো বাইট সংরক্ষণ করে। randomsসংখ্যার অসীম তালিকা তৈরি করতে টাইপ দ্বারা নির্ধারিত একটি স্বেচ্ছাসেবী ব্যাপ্তি ব্যবহার করে। এটিতে নেতিবাচকতা থাকতে পারে তাই absতাদেরকে ইতিবাচক (বা শূন্য) জোর করার জন্য আমাদের এটির মানচিত্র তৈরি করতে হবে । এটি n এর যে কোনও মানের জন্য অত্যন্ত ধীর, যা অযৌক্তিকভাবে বড় নয়। সম্পাদনা : আমি পরে বুঝতে পারি যে এই সংস্করণটি অভিন্নভাবে বিতরণ করা হয়নি কারণ 0 পাওয়ার সম্ভাবনা অন্যান্য সংখ্যার চেয়ে খারাপ কারণ abs। কিছু সংখ্যক উত্পাদন করার জন্য mজেনারেটর উত্পাদন করতে পারে mবা -m0 এর ক্ষেত্রে কেবল 0 নিজেই কাজ করবে, সুতরাং এর সম্ভাব্যতা অন্যান্য সংখ্যার অর্ধেক।

— user1472751
সূত্র
হ্যাসেলের পক্ষেও (খুব)!
4

জেলি , 9 বাইট

⁴!Ẋ’>Ðḟ⁸Ṫ

এটি অনলাইন চেষ্টা করুন! - উপরের কোডটি টিআইওতে 16 মাপের ব্যাপ্তির পরে চলবে না! প্রথমে অবশ্যই তৈরি করা উচিত (তাদের পরে এলোমেলো করে ফিল্টার লাগানো দরকার তা এই কথাটি উল্লেখ না করে!), সুতরাং এটি অনেক ছোট স্কেলে একই জিনিস, 10 এর গণ্ডি দিয়ে 3 এর ইনপুট জন্য 30 বার পুনরাবৃত্তি হয়েছিল।

কিভাবে?

⁴!Ẋ’>Ðḟ⁸Ṫ - Main link: n
⁴         - 16
 !        - factorial: 20922789888000
  Ẋ       - shuffle random: builds a list of the integers 1 through to 16! inclusive and
          - returns a random permutation via Python's random.shuffle (pretty resource hungry)
   ’      - decrement (vectorises - a whole pass of this huge list!)
     Ðḟ   - filter out if: (yep, yet another pass of this huge list!)
    >     -     greater than
       ⁸  -     left argument, n
        Ṫ - tail: return the rightmost remaining entry.

দ্রষ্টব্য: একই বাইট-কাউন্টের জন্য এক হাজারেরও বেশি সময় কার্যকর ȷ⁵হবে যদি কেউ নির্দ্বিধায় প্রত্যাশা করে এবং দশকে দশে ফিরিয়ে দেয় তবে এটি এমন নয় যেহেতু এটি ⁵আক্ষরিক দশ হিসাবে ব্যবহৃত হবে বলে মূল্যায়ন করা হয়নি আক্ষরিক সংখ্যার দ্বারা ȷ...বরং দুটি পৃথক আক্ষরিক পার্স করা হয়েছে, ȷএটির তিনটি এক হাজারের ⁵ফলনকারী এবং দশটি উপার্জনকারী এর ডিফল্ট প্রকাশক রয়েছে ।

— জোনাথন অ্যালান
সূত্র
হুঁ, 9 টি অক্ষর রয়েছে তবে 22 বাইট রয়েছে
— ক্রিস্টোফার সল-স্টোরগার্ড
@ ক্রিস্টোফারসল-স্টোরগার্ড প্রতিটি চরিত্রই জেলি কোড পৃষ্ঠাতে 256 বাইটের মধ্যে একটি , আমি বাইট শব্দের সাথে একটি লিঙ্ক তৈরি করতে ভুলে যাই যা আমি সাধারণত করি।
— জোনাথন অ্যালান
1
বছর, আমি এটি সন্ধান করেছি এবং এটির সন্ধান করলাম
— ক্রিস্টোফার সল-স্টোরগার্ড
4

JDK 9 জেসেল, 75 59 বাইট

n->(new Random()).ints(0,1<<30).dropWhile(x->x>n).findAny()

ব্যবহার

((IntFunction)(n->(new Random()).ints(0,1<<30).dropWhile(x->x>n).findAny())).apply(<n>)
  • -16 বাইট: ধন্যবাদ জাকোব!
  • ধরে নেওয়া যায় যে আমরা ঝেহেলকে একটি বৈধ রানটাইম পরিবেশ হিসাবে বিবেচনা করি।
  • ঝাল নিজেই, একটি রানটাইম পরিবেশ হিসাবে, মূল লাইব্রেরির জন্য সুস্পষ্ট আমদানির প্রয়োজন হয় না এবং সেমিকোলনগুলির প্রয়োজন হয় না।
  • একটি ফেরত পাঠায় OptionalInt। বিধিগুলি উল্লেখ করে না যে রিটার্নের ধরণ অবশ্যই আদিম হতে হবে এবং আমি ফলাফলটির OptionalIntবৈধ উপস্থাপনা হিসাবে বিবেচনা করছি ।
— পিট টেরলেপ
সূত্র
1
অনুপ্রেরণার জন্য @ কেভিন-ক্রুজসেনকে ধন্যবাদ। আমার প্রথম কোড গল্ফ!
— পিট টেরলেপ
বক্সযুক্ত আউটপুট গ্রহণযোগ্য কিনা Optionalতা গ্রহণযোগ্য কিনা ভিন্ন is আমি আপনি হলে আমি পোস্টার দিয়ে নিশ্চিত করতে হবে। এছাড়াও, সম্পূর্ণ অ্যাসাইনমেন্ট গণনা করার প্রয়োজন নেই; শুধু ল্যাম্বডা এক্সপ্রেশন যথেষ্ট।
— Jakob
1
আপনি ল্যামডা পরামিতি প্রায় প্রথম বন্ধনী সরিয়ে 4 বাইট সংরক্ষণ করতে পারবেন nএবং new Random()।
— Jakob
3

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

    while($argn<$n=rand());echo$n;

সাথে চালাও echo <N> | php -Rn '<code>'।

0 এবং getrandmax()(2 ** 31-1 আমার 64 বিট মেশিনে) এর মধ্যে একটি এলোমেলো সংখ্যা বেছে নেয় ;
ইনপুটটির চেয়ে বড় হওয়ার পরে পুনরাবৃত্তি করে।

এটি কিছুটা সময় নিতে পারে ... আমার এএমডি সি -50 (1 গিগাহার্টজ) এর জন্য 0.3 থেকে 130 সেকেন্ডের মধ্যে প্রয়োজন N=15।

গড়ের জন্য একটি দ্রুততর উপায় N( 46 বাইট ):

for(;++$i<$x=1+$argn;)$n+=rand()%$x;echo$n%$x;

অথবা

for(;++$i<$x=1+$argn;$n%=$x)$n+=rand();echo$n;

N+1এলোমেলো পূর্ণসংখ্যা নেয় , তাদের যোগফল দেয় এবং সাথে মডুলো নেয় N+1।
সি -50 এর প্রায় প্রয়োজন। 1 মিলিয়ন রান জন্য 8 সেকেন্ড।

19 বাইটের জন্য একটি অবৈধ সমাধান :

echo rand(0,$argn);
— তিতাস
সূত্র
3

পাওয়ারশেল , 35 বাইট

for(;($a=Random 1gb)-gt"$args"){}$a

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

আর একটি প্রত্যাখ্যান নমুনা পদ্ধতি। এটি একটি অসীম for, লুপ এর মান নির্ধারণের $aএকটি হতে Randomপূর্ণসংখ্যা মধ্যে 0এবং 1gb( = 1073741824 = 2^30), এবং তাই যতদিন যে পূর্ণসংখ্যা লুপিং রাখে -greater tহান ইনপুট $args। লুপটি সম্পূর্ণ হয়ে গেলে, আমরা কেবল $aপাইপলাইনটি রেখেছি এবং আউটপুট অন্তর্ভুক্ত।

দ্রষ্টব্য: ইনপুটটি স্বল্প সংখ্যার হলে এটি দীর্ঘ সময় নিতে পারে ।

— AdmBorkBork
সূত্র
3

পাইথন 2 , 72 69 বাইট

-3 বাইট ধন্যবাদ xnor ( idবিল্ট- ইনটি ভেরিয়েবল হিসাবে ওভাররাইড )

from random import*
n=input()
while id>n:id=randrange(2**30)
print id

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

randrange(2**30)[0,2 30 ) পরিসীমা থেকে সিউডো-অভিন্ন বিতরণকারী সংখ্যা ( মার্সেন টুইস্টার 2 19937-1 ) উত্পাদন করে । যেহেতু 2 30 এর নীচে থাকার গ্যারান্টিযুক্ত তাই এটি কেবল বারবার বলা যেতে পারে যতক্ষণ না এটি ইনপুটটির চেয়ে বড় না হয়। এটির খুব কম মানগুলির জন্য একটি দীর্ঘ প্রত্যাশিত সময় লাগবে , তবে সাধারণত এক মিনিটের মধ্যে এমনকি 50 এর নিচে ইনপুটগুলির জন্যও কাজ করে।nn

— জোনাথন অ্যালান
সূত্র
2
আপনি r=''"অনন্ত" হিসাবে আরম্ভ করতে পারেন । অথবা, আরও ভাল, আরম্ভ না করে rপরিবর্তে idসর্বত্র ব্যবহার করুন r।
— xnor
2

পার্ল 6 , 29 বাইট

{first 0..$_,^2**30 .roll(*)}

মার্টিন ইন্ডারের ম্যাথমেটিকা ​​সমাধান দ্বারা অনুপ্রাণিত ।

0 এবং 2 ^ 30-1 এর মধ্যে এলোমেলো পূর্ণসংখ্যার একটি অলস অসীম অনুক্রম তৈরি করে এবং 0 এবং ইনপুটটির মধ্যে প্রথমটি নেয়।

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

— smls
সূত্র
2

05 এ বি 1 ই , 11 বাইট

žIÝ.rDI›_Ϥ

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

ব্যাখ্যা

žIÝ          # push the inclusive range [0 ... 2^31]
   .r        # get a random permutation (pythons random.shuffle)
     D       # duplicate this list
      I      # push input
       ›_Ï   # keep only elements from the list not greater than input
          ¤  # take the last one

[0 ... 2147483648]টিআইওর জন্য তালিকাটি খুব বড় হওয়ায় লিঙ্কটি 1.000.000পরিবর্তে ব্যবহার করে।

বিকল্প (গড়) অনেক দ্রুত 11 বাইট সমাধান

[žIÝ.RD¹›_#

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

ব্যাখ্যা

[             # start loop
 žIÝ          # push the inclusive range [0 ... 2^31]
    .R        # pick a random integer (pythons random.chiose)
      D       # duplicate
       ¹      # push input
        ›_#   # break if random number is not greater than input
              # implicitly output top of stack (the random number)
— Emigna
সূত্র
žJL.R%6 জন্য যদি না আমি কিছু বিশাল মিস করছি। 2 ^ 32 টিপুন, 0 থেকে 2 ^ 32 পর্যন্ত তালিকা, এলোমেলো বাছাই। মডিউল ইনপুট। আপনার যে দক্ষতা আছে তা পুরোপুরি স্ক্রু করবে।
— ম্যাজিক অক্টোপাস উরন 14
@ carusocomputing I. সঠিক ক্রমে মডুলাসের জন্য যুক্তিগুলি পেতে (এবং সম্ভবত এটির Ýপরিবর্তে L) পেতে আপনার সেখানে 7 বাইটের দরকার পড়বে , তবে অন্যথায় এটি অবশ্যই একটি সংক্ষিপ্ত সমাধান। আমি ডেনিসকে তার জেলি উত্তরে এটি করতে দেখেছি, তবে এটি আমার প্রথম ধারণা হিসাবে আমি এটি রেখেছিলাম। যেহেতু এই পদ্ধতির থেকে পৃথক হয় আপনি এটি পৃথক উত্তর হিসাবে পোস্ট করতে পারেন।
— এমিলিগা
DI‹Ïলুপ এড়ানো হবে।
— ম্যাজিক অক্টোপাস উরান
এছাড়াও, যেমনটি রয়েছে, এটি সমাপ্তির গ্যারান্টিযুক্ত নয়; যদি আমি ভুল না হয়ে থাকি তবে একটি ইনপুট 0প্রায় সর্বদা নিকট-অসীম লুপের ফলস্বরূপ হয়, এটি শেষ করা শক্ত করে তোলে। যদিও সমাধানটি সমস্ত পরিস্থিতিতে শেষ হওয়ার সম্ভাবনাটিকে মঞ্জুরি দেয় তবে এলোমেলোতার কারণে এটি গ্যারান্টিযুক্ত নয়।
— যাদু অক্টোপাস উরান
@ কারাসোকম্পিউটিং: খুব ছোট ইনপুটটির জন্য দ্বিতীয় সংস্করণে হ্যাঁ শেষ করতে গড়পড়তাভাবে সময় লাগবে, তবে যথেষ্ট সময় দেওয়া হবে।
— এমিগিনা
2

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

l=range(2**31)
import random
random.shuffle(l)
n=input()
print filter(lambda x:x<=n,l)[0]

ব্যাখ্যা

L=range(2**31)      # Create a list from 0 to 2^31 exclusive. Call it <L>.
import random       # Import the module <random>.
random.shuffle(L)   # Use 'shuffle' function from <random> module,
                    # to shuffle the list <L>.
n=input()           # Take the input -> <n>.

print
    filter(         # Create a new sequence,
    lambda x:x<=n   # where each element is less than or equal to <n>.
    ,L)             # from the list <L>.
    [0]             # Take the first element.

এটি খুব অদক্ষ, কারণ এটি 2 ^ 31 পূর্ণসংখ্যার তৈরি করে , এগুলি পরিবর্তন করে এবং ফিল্টার করে।

আমি টিআইও লিঙ্কটি ভাগ করে নেওয়ার কোনও অর্থ দেখছি না, যেখানে এটি এত বড় তালিকাগুলি তৈরি করছে, তাই এখানে n= 100 এর জন্য একটি টিআইও লিঙ্ক রয়েছে ।

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

— Yytsi
সূত্র
2

জাভা 8, 84 83 80 71 62 বাইট

n->{int r;for(;(r=(int)(Math.random()*(1<<30)))>n;);return r;}

-1 বাইট @ অলিভারগ্রাগোয়ারকে ধন্যবাদ ।
-3 ধন্যবাদ বাইট @Jakob ।
-9 জাভা 8. জাভা 7 রূপান্তর বাইট
-9 পরিবর্তন করে বাইট java.util.Random().nextInt(1<<30)থেকে (int)(Math.random()*(1<<30))।

ব্যাখ্যা:

এখানে চেষ্টা করুন।

n->{        // Method with integer parameter and integer return-type
  int r;    //  Result-integer
  for(;(r=(int)(Math.random()*(1<<30)))>n;);
            //  Loop as long as the random integer is larger than the input
            //  (the random integer is in the range of 0 - 1,073,741,824 (2^30))
  return r; //  Return the random integer that is within specified range
}           // End method

দ্রষ্টব্য: ছোট ইনপুটগুলির জন্য অবশ্যই খুব দীর্ঘ সময় লাগতে পারে।

উদাহরণ আউটপুট:

407594936
— কেভিন ক্রুইজসেন
সূত্র
2
অ্যারোন আমি এটিও প্রশ্নবিদ্ধ করেছি কিন্তু দ্বিতীয় বুলেট পয়েন্টটি দেখুন: "বিল্ট ইন বা লাইব্রেরি র্যান্ডম ফাংশনটি কল করার সময় যে কোনও যুক্তি অবশ্যই স্থির থাকতে হবে That এগুলি অবশ্যই ইনপুট মান থেকে সম্পূর্ণ স্বতন্ত্র থাকতে হবে।" এই কারণেই ম্যাক্স ইনট ব্যবহৃত হয়।
— পোকে
1
2^30= 1073741824। আপনি -1>>>1(= 2147483647) ব্যবহার পছন্দ করেছেন । তবে এটি বিদ্যমান: 1<<30যা হুবহু সমান 2^30; এবং 1 বাইট সংক্ষিপ্ত।
— অলিভিয়ার
1
কীভাবে int c(int n){int r;for(;(r=new java.util.Random().nextInt(1<<30))>n;);return r;}?
— জাকব
@ জাকব ধন্যবাদ আমি এমনকি জাভা 8 পরিবর্তে 7 ব্যবহার, এবং ব্যবহার করে 18 আরো বাইট দ্বারা এটি সংক্ষিপ্ত Math.random()পরিবর্তে java.util.Random().nextInt।
— কেভিন ক্রুইজসেন
2

পাইথন 3, 51 বাইট

এখানে অপ্রচলিত র্যান্ডম উত্স সহ অজগর সমাধান রয়েছে।

print(list(set(map(str,range(int(input())+1))))[0])

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

সুতরাং এটি ভেঙে।

int(input())+1

ইনপুট নম্বর পায় এবং এতে যুক্ত 1হয়।

set(range(...))

{0, 1, 2, 3, 4, ... n}সমস্ত সম্ভাব্য ফলাফলের জন্য সেট তৈরি করে ।

print(list(...)[0])

সেটটি নেয়, এটিকে তালিকায় রূপান্তর করে এবং প্রথম আইটেমটি আঁকড়ে ধরে।

এটি কাজ করে কারণ পাইথন 3-তে, অর্ডার পাইথনহ্যাসিডset() দ্বারা প্রতিষ্ঠিত হয় ( প্রাপ্ত হতে পারে না তবে স্ক্রিপ্ট প্রয়োগের ক্ষেত্রে প্রতিষ্ঠিত হয়)।

স্বীকারযোগ্যভাবে, আমি অনুমান করছি যে এটি একটি অভিন্ন বিতরণ, কারণ hash()মানটি এলোমেলোভাবে নির্ধারিত হয় এবং আমি এলোমেলোভাবে একটি নির্দিষ্ট সাথে মানটি তুলতে দেখছি hash(), তারপরে কেবল নিজেরটি ফিরে আসছি hash(input())।

এটি যদি একটি অভিন্ন বিতরণ, বা আমি কীভাবে এটি পরীক্ষা করতে পারি তা যদি কেউ জানেন তবে মন্তব্য করুন।

— ম্যাট
সূত্র
1

সি #, 57 বাইট

n=>{int x=n+1;while(x>n)x=new Random().Next();return x;};

বেনামে ফাংশন যা 0 এবং n এর মধ্যে পূর্ণসংখ্যা প্রদান করে।

ইনপুট নম্বরটি যত ছোট হবে, এলোমেলো মান ফেরানোর সময় আর বেশি।

সম্পূর্ণ প্রোগ্রাম:

using System;

class RandomNumber
{
    static void Main()
    {
        Func<int, int> f =
        n=>{int x=n+1;while(x>n)x=new Random().Next();return x;};

        // example
        Console.WriteLine(f(100000));
    }
}
— adrianmp
সূত্র
2
"বিল্ট ইন বা লাইব্রেরি এলোমেলো ফাংশন কল করার সময় যে কোনও যুক্তি অবশ্যই স্থির থাকতে হবে That এগুলি অবশ্যই ইনপুট মানের থেকে সম্পূর্ণ স্বতন্ত্র হওয়া উচিত" " যুক্তি Nextস্থির নয়।
— Yytsi
1

বাশ + কোর্টিলস, 20 বাইট

Golfed

seq 0 $ 1 | shuf | সেড 1 কি

shuf - এলোমেলো ক্রম উত্পাদন

শুফ নিম্নলিখিত কোডগুলি ব্যবহার করবে: অনুমানের উত্পন্ন করতে:

permutation = randperm_new (randint_source, head_lines, n_lines);

যা শেষ হয় randint_genmax

/* Consume random data from *S to generate a random number in the range
0 .. GENMAX.  */

randint
randint_genmax (struct randint_source *s, randint genmax) 
{
      ...

      randread (source, buf, i);

      /* Increase RANDMAX by appending random bytes to RANDNUM and
         UCHAR_MAX to RANDMAX until RANDMAX is no less than
         GENMAX.  This may lose up to CHAR_BIT bits of information
         if shift_right (RANDINT_MAX) < GENMAX, but it is not
         worth the programming hassle of saving these bits since
         GENMAX is rarely that large in practice.  */
      ...
}

যা ঘুরেফিরে এলোমেলোতার নিম্ন-স্তরের উত্স থেকে এলোমেলো তথ্যগুলির কয়েকটি বাইট পড়বে :

/* Consume random data from *S to generate a random buffer BUF of size
   SIZE.  */

void
randread (struct randread_source *s, void *buf, size_t size)
{
  if (s->source)
    readsource (s, buf, size);
  else
    readisaac (&s->buf.isaac, buf, size);
}

অর্থাত্ নিম্ন-স্তরে, shufএলোমেলো উত্স থেকে প্রাপ্ত প্রয়োজনীয় ইনপুট মান এবং ডেটার মধ্যে সরাসরি নির্ভরতা নেই (প্রয়োজনীয় বাইট বাফার ক্ষমতা গণনা করা বাদে)।

— জেপেলীন্
সূত্র
6
এটি কি আপনার এলোমেলো নম্বর জেনারেটরের পক্ষে আর্গুমেন্ট হিসাবে দিচ্ছে না?
— মার্টিন এন্ডার
এটি বৈধ না হলেও, দয়া করে অন্য একটি বাশ উত্তর জমা দিন!
@ মার্টিনএন্ডার ভাল, সরাসরি নয়, এটি উত্পন্ন পূর্ণসংখ্যার পরিসীমা এবং jot will arrange for all the values in the range to appear in the output with an equal probabilityসম্ভবত এটি সীমান্তরেখা, তবে এখনও) জন্য উপরের সীমাটি নির্ধারণ করতে ইনপুটটি ব্যবহার করে ।
— জেপেলিন
2
যদি আমি কোনও এলোমেলো সংখ্যা জেনারেটরের কাছে গভীরভাবে খনন করি তবে আমি নিশ্চিত যে আমি নিম্ন স্তরের আরএনজি-তে একটি কল পেয়ে যাবো যা মূল যুক্তিটি সরাসরি ব্যবহার করে না। চ্যালেঞ্জের বিষয়টি হ'ল স্থির আকারের বিতরণ থেকে একটি স্বেচ্ছাকৃতির আকারের ইউনিফর্ম বিতরণ অর্জন করা, যা আপনি এখনও করছেন না।
— মার্টিন ইন্ডার
1

স্মাইলব্যাসিক, 38 বাইট

INPUT N@L
R=RND(1<<30)ON N<=R GOTO@L?R

যতক্ষণ না এটি ইনপুট থেকে ছোট সেটিকে এ পর্যন্ত এলোমেলো সংখ্যা তৈরি করে।

— 12Me21
সূত্র
1

রুবি, 23 15 23 32 29 বাইট

->n{1while n<q=rand(2**30);q}

কিভাবে এটা কাজ করে:

  • 1while [...];কমপক্ষে একবারে বিবৃতিটি কার্যকর করে: 1আগে whileকোনও ন্যাপ হিসাবে কাজ করে
  • 0..2 ^ 30-1 পরিসীমাটিতে একটি এলোমেলো নম্বর পান ( নির্দিষ্ট হিসাবে 2 ^ 30 এর চেয়ে কম )
  • সংখ্যাটি ইনপুট প্যারামিটারের চেয়ে বেশি হলে পুনরাবৃত্তি করুন (n ছোট হলে কিছুটা সময় নিতে পারে)
— গিগাবাইট
সূত্র
1

ওহম, 26 বাইট

IΩ
D31º#╬D0[>?D-+∞;,

ব্যাখ্যা:

IΩ                 ■Main wire
IΩ                 ■Call wire below

D31º#╬D0[>?D-+∞;,  ■"Real main" wire
D                  ■Duplicate input
 31º#╬D            ■Push random_int in [0..2^31] twice
       0[          ■Push input again
         >?    ;   ■If(random_int > input){
           D-+     ■  remove the random_int
              ∞    ■  recursion
               ;   ■}
                ,  ■Print random_int
— রোমান গ্রাফ
সূত্র
এই ভাষার জন্য কোন দোভাষী আছে? এবং কোড-পৃষ্ঠা সম্পর্কে কি?
— এ্যাটাকো
@ এ্যাটাকো: দোভাষী , কোড-পৃষ্ঠা: সিপি
— -৩77
1

যান, 63 61 বাইট

import."math/rand"
var n=0;func R(){q:=n;for;q<n+1;n=Int(){}}

এটি এর মতো ব্যবহার করুন:

func main() {
    n = 5000
    R()
    print(n)
}

এটি খেলার মাঠে লাইভ পরীক্ষা করুন

— ক্রিস্টোফার স্যাল স্টারগার্ড
সূত্র
— ডেনিস
1

গোলং, 84 78 71 বাইট

import."math/rand"
func R(n int)int{q:=n+1;for;q>=n;q=Int(){};return q}

সাধারণ প্রত্যাখ্যানের নমুনা।

দ্রষ্টব্য: যেহেতু গণিত / র‌্যান্ড বীজ একটি ধ্রুবক 1, ধ্রুবক ফলাফল না চাইলে কলকারীকে বীজ বজায় রাখতে হবে।

পরীক্ষা: https://play.golang.org/p/FBB4LKXo1r এখন 64৪-বিট সিস্টেমে ব্যবহারিকভাবে পরীক্ষাযোগ্য নয়, যেহেতু এটি 64৪-বিট এলোমেলোভাবে ফিরে আসছে এবং প্রত্যাখ্যান পরীক্ষার ব্যবহার করে।

package main

import "fmt"
import "time"

/* solution here *//* end solution */

func main() {
    Seed(time.Now().Unix())
    fmt.Println(R(1073741823))
}
— Riking
সূত্র
1
আপনি যদি ব্যবহার করেন import."math/rand"তবে Int31এটি বিশ্বব্যাপী নেমস্পেসে উপলভ্য এবং আপনি 4 বাইট সংরক্ষণ করতে পারবেন, intকমপক্ষে 32 বিট থাকার নিশ্চয়তাও রয়েছে, আপনাকে আরও 6 বাইট সাশ্রয় করবে
— ক্রিস্টোফার সল-স্টোরগার্ড
:=আরও 3 বাইটের সিনট্যাক্স ব্যবহার করুন
— ক্রিস্টোফার সল-স্টোরগার্ড
Int32 এর পরিবর্তে int ব্যবহার করা কোনও বাইট সংরক্ষণ করে না যেহেতু আমাদের Int31 () - 3 * int + () = 11 বাইট বনাম 2 * int32 = 10 বাইটের ফলাফল দিতে হবে।
— রিকিং
1
Cast Int()import
— ালাই
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.