প্রতিস্থাপন ছাড়া এলোমেলো নমুনা

Question

এমন একটি ফাংশন তৈরি করুন যা কোনও ব্যাপ্তি থেকে আঁকা পৃথক এলোমেলো সংখ্যার একটি সেট আউটপুট দেয়। সেটের উপাদানগুলির ক্রমটি গুরুত্বহীন (এগুলি এমনকি বাছাই করা যায়) তবে প্রতিটি বার যখন ফাংশন বলা হয় তখন সেটটির বিষয়বস্তু আলাদা হওয়া সম্ভব must

ফাংশনটি আপনি যেভাবে আদেশ করুন তাতে 3 পরামিতি পাবেন:

1. আউটপুট সেটে সংখ্যা গণনা
2. নিম্ন সীমা (অন্তর্ভুক্ত)
3. উচ্চ সীমা (অন্তর্ভুক্ত)

ধরুন সমস্ত সংখ্যা 0 (অন্তর্ভুক্ত) থেকে 2 ³¹ (একচেটিয়া) সীমাতে পূর্ণসংখ্যা । আউটপুটটি আপনার যে কোনও উপায়ে ফিরে যেতে পারে (কনসোলে লিখুন, অ্যারে হিসাবে, ইত্যাদি)

বিচার করা

মানদণ্ডে 3 টি আর অন্তর্ভুক্ত রয়েছে

1. রান-টাইম - যে কোনও সংকলক অবাধে বা সহজেই উপলব্ধ (যা প্রয়োজনে একটি লিঙ্ক সরবরাহ করুন) সহ কোয়াড-কোর উইন্ডোজ 7 মেশিনে পরীক্ষা করা হয়েছে
2. দৃust়তা - ফাংশনটি কর্নারের কেসগুলি পরিচালনা করে বা এটি অসীম লুপে পড়ে যাবে বা অবৈধ ফলাফল আনবে - অবৈধ ইনপুটটিতে ব্যতিক্রম বা ত্রুটি বৈধ
3. লক্ষ্যহীনতা - এটা র্যান্ডম ফলাফল সহজেই একটি র্যান্ডম ডিস্ট্রিবিউশনের সাথে আন্দাজের নয় উত্পাদন করা উচিত। এলোমেলো সংখ্যা জেনারেটর ব্যবহার করা ভাল। তবে কোনও সুস্পষ্ট পক্ষপাতিত্ব বা সুস্পষ্ট অনুমানযোগ্য নিদর্শন থাকা উচিত নয়। দিলবার্টে অ্যাকাউন্টিং বিভাগ দ্বারা ব্যবহৃত এলোমেলো নম্বর জেনারেটরের চেয়ে ভাল হওয়ার দরকার

যদি এটি দৃust় এবং এলোমেলো হয় তবে এটি রান-টাইমে নেমে আসে। দৃust় বা এলোমেলো হতে ব্যর্থতা এর স্ট্যান্ডিংগুলিকে প্রচুর ব্যথা করে।

Comments

আউটপুটটি ডিয়ারহার্ড বা টেস্টউ01 পরীক্ষার মতো কিছু পাস করার কথা , বা আপনি কীভাবে এর এলোমেলো বিচার করবেন? ওহ, এবং কোডটি 32 বা 64 বিট মোডে চালানো উচিত? (এটি অপ্টিমাইজেশনের জন্য একটি বড় পার্থক্য তৈরি করবে))

— ইলমারি করোনেন

আমার ধারণা, TestU01 সম্ভবত কিছুটা কঠোর is মানদণ্ড 3 কি অভিন্ন বন্টন বোঝায়? এছাড়াও, কেন পুনরাবৃত্তি প্রয়োজন? এটি তখন বিশেষভাবে এলোমেলো নয়।

— জোয়

@ জোয়ি, নিশ্চিত এটি এটি প্রতিস্থাপন ছাড়াই এলোমেলো নমুনা। যতক্ষণ না কেউ দাবি করেন যে তালিকার বিভিন্ন অবস্থানগুলি স্বতন্ত্র এলোমেলো পরিবর্তনশীল কোনও সমস্যা নেই।

— পিটার টেলর

আহ, সত্যিই। তবে আমি নিশ্চিত নই যে স্যাম্পলিংয়ের এলোমেলোতা পরিমাপের জন্য সু-প্রতিষ্ঠিত গ্রন্থাগার এবং সরঞ্জাম রয়েছে :-)

— জোয়

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

— জিম ম্যাককিথ

Answer 1

পাইথন

import random

def sample(n, lower, upper):
    result = []
    pool = {}
    for _ in xrange(n):
        i = random.randint(lower, upper)
        x = pool.get(i, i)
        pool[i] = pool.get(lower, lower)
        lower += 1
        result.append(x)
    return result

আমি সম্ভবত কিছু সুপরিচিত অ্যালগরিদম পুনরায় উদ্ভাবন করেছি, তবে ধারণাটি হ'ল (ধারণাগতভাবে) অভিন্ন শফলড পরিসরের lower..upperদৈর্ঘ্যের nউপসর্গ পেতে সীমার আংশিক ফিশার-ইয়েটস সাফল্য অর্জন করা।

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

এই পদ্ধতিতে, আপনি যখন আঁটসাঁট পরিসরের সংখ্যাগুলি নমুনা দিচ্ছেন (উদাহরণস্বরূপ, ১.১০০০০ পরিসরের 1000 সংখ্যা) যে ক্ষেত্রে আপনি বড় পরিসরের নম্বর থেকে নমুনা নিচ্ছেন সে ক্ষেত্রেও অ্যালগরিদম দুটি ভালই সম্পাদন করবে perform ।

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

Comments

পাইথন মার্সেন টুইস্টার ব্যবহার করে তাই এটি তুলনামূলকভাবে শালীন।

— সুলতানিক

Answer 2

অজগর 2.7

import random
print(lambda x,y,z:random.sample(xrange(y,z),x))(input(),input(),input())

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

সম্পাদনা: সবেমাত্র লক্ষ্য করা হয়েছে যে পরিসীমা () বড় তালিকা তৈরি করতে পছন্দ করে না। একটি স্মৃতি ত্রুটি ফলাফল। এটি করার অন্য কোনও উপায় আছে কিনা তা দেখতে পাবে ...

edit2: পরিসরটি ছিল ভুল ফাংশন, এক্সরঞ্জ কাজ করে। সর্বাধিক পূর্ণসংখ্যা আসলে 2**31-1অজগরটির জন্য

পরীক্ষা:

python sample.py
10
0
2**31-1
[786475923, 2087214992, 951609341, 1894308203, 173531663, 211170399, 426989602, 1909298419, 1424337410, 2090382873]

Answer 3

সি

সর্বনিম্ন এবং সর্বাধিকের মধ্যে x টি স্বতন্ত্র এলোমেলো ইনট রয়েছে এমন একটি অ্যারে প্রদান করে। (কলার অবশ্যই মুক্তি দিতে হবে)

#include <stdlib.h>
#include <stdint.h>
#define MAX_ALLOC ((uint32_t)0x40000000)  //max allocated bytes, fix per platform
#define MAX_SAMPLES (MAX_ALLOC/sizeof(uint32_t))

int* randsamp(uint32_t x, uint32_t min, uint32_t max)
{
   uint32_t r,i=x,*a;
   if (!x||x>MAX_SAMPLES||x>(max-min+1)) return NULL;
   a=malloc(x*sizeof(uint32_t));
   while (i--) {
      r= (max-min+1-i);
      a[i]=min+=(r ? rand()%r : 0);
      min++;
   }
   while (x>1) {
      r=a[i=rand()%x--];
      a[i]=a[x];
      a[x]=r;
   }
   return a;
}

পরিসরে এক্স সিক্যুয়ালাল এলোমেলো পূর্ণসংখ্যার উত্পাদন করে তারপরে এলোমেলো করে Works seed(time)আপনি যদি প্রতিটি রান একই ফলাফল না চান তবে কলারে কোথাও যুক্ত করুন ।

Answer 4

রুবি> = 1.8.7

def pick(num, min, max)
  (min..max).to_a.sample(num)
end

p pick(5, 10, 20) #=>[12, 18, 13, 11, 10]

Answer 5

আর

s <- function(n, lower, upper) sample(lower:upper,n); s(10,0,2^31-2)

Answer 6

প্রশ্নটি সঠিক নয়। আপনার ইউনিফর্ম নমুনা লাগবে নাকি? মামলা অভিন্ন স্যাম্পলিং প্রয়োজন হয় আমি আর নিম্নলিখিত কোড, যা হয়েছে গড় জটিলতা আছে হে ( গুলি লগ গুলি ), যেখানে গুলি নমুনা আকার।

# The Tree growing algorithm for uniform sampling without replacement
# by Pavel Ruzankin 
quicksample = function (n,size)
# n - the number of items to choose from
# size - the sample size
{
  s=as.integer(size)
  if (s>n) {
    stop("Sample size is greater than the number of items to choose from")
  }
  # upv=integer(s) #level up edge is pointing to
  leftv=integer(s) #left edge is poiting to; must be filled with zeros
  rightv=integer(s) #right edge is pointig to; must be filled with zeros
  samp=integer(s) #the sample
  ordn=integer(s) #relative ordinal number

  ordn[1L]=1L #initial value for the root vertex
  samp[1L]=sample(n,1L) 
  if (s > 1L) for (j in 2L:s) {
    curn=sample(n-j+1L,1L) #current number sampled
    curordn=0L #currend ordinal number
    v=1L #current vertice
    from=1L #how have come here: 0 - by left edge, 1 - by right edge
    repeat {
      curordn=curordn+ordn[v]
      if (curn+curordn>samp[v]) { #going down by the right edge
        if (from == 0L) {
          ordn[v]=ordn[v]-1L
        }
        if (rightv[v]!=0L) {
          v=rightv[v]
          from=1L
        } else { #creating a new vertex
          samp[j]=curn+curordn
          ordn[j]=1L
          # upv[j]=v
          rightv[v]=j
          break
        }
      } else { #going down by the left edge
        if (from==1L) {
          ordn[v]=ordn[v]+1L
        }
        if (leftv[v]!=0L) {
          v=leftv[v]
          from=0L
        } else { #creating a new vertex
          samp[j]=curn+curordn-1L
          ordn[j]=-1L
          # upv[j]=v
          leftv[v]=j
          break
        }
      }
    }
  }
  return(samp)  
}

অবশ্যই, আরও ভাল পারফরম্যান্সের জন্য কেউ এটি সিতে পুনরায় লিখতে পারে। এই অ্যালগরিদমের জটিলতা আলোচনা করা হয়েছে: রাউজানকিন, পিএস; ভয়েটিশেক, এভি এলোমেলো নির্বাচনের জন্য অ্যালগরিদমের ব্যয়। মন্টি কার্লো পদ্ধতিগুলি অ্যাপল। 5 (1999), না। 1, 39-54। http://dx.doi.org/10.1515/mcma.1999.5.1.39

আপনি একই কাগজের সাথে একই গড় জটিলতার সাথে অন্য অ্যালগরিদমের সন্ধান করতে পারেন।

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

অভিন্ন নমুনা দেওয়ার জন্য আরও দেখুন: পি। গুপ্ত, জিপি ভট্টাচার্জি। (1984) প্রতিস্থাপন ছাড়াই এলোমেলো নমুনার জন্য একটি কার্যকর অ্যালগরিদম। কম্পিউটার গণিতের আন্তর্জাতিক জার্নাল 16: 4, পৃষ্ঠা 201209 -20 ডিওআই: 10.1080 / 00207168408803438

টিউহোলা, জে এবং নেভালাইনেন, ও। 1982. প্রতিস্থাপন ছাড়াই এলোমেলো নমুনার জন্য দুটি দক্ষ অ্যালগরিদম। / আইজেসিএম /, 11 (2): 127–140। ডিওআই: 10.1080 / 00207168208803304

শেষ কাগজে লেখকরা হ্যাশ টেবিল ব্যবহার করেন এবং দাবি করেন যে তাদের অ্যালগোরিদমে ও ( গুলি ) জটিলতা রয়েছে। আরও একটি দ্রুত হ্যাশ টেবিল অ্যালগরিদম রয়েছে, যা শীঘ্রই pqR- এ কার্যকর করা হবে (বেশ দ্রুত আর): https://stat.ethz.ch/pipermail/r-devel/2017- অক্টোবর/075012.html

Answer 7

এপিএল, 18 22 বাইট

{⍵[0]+(1↑⍺)?⍵[1]-⍵[0]}

একটি অনামী ফাংশন ঘোষণা করে যা দুটি আর্গুমেন্ট গ্রহণ করে ⍺এবং ⍵। ⍺আপনি চান এলোমেলো সংখ্যার সংখ্যাটি ⍵, সেই ক্রমে নিম্ন এবং উপরের সীমানা যুক্ত ভেক্টর or

a?bপ্রতিস্থাপন ব্যতীত a0- এর মধ্যে এলোমেলো সংখ্যাগুলি বেছে নেয় bগ্রহণ করে ⍵[1]-⍵[0]আমরা পরিসীমা আকার পেতে। তারপরে আমরা ⍺সেই ব্যাপ্তিটি থেকে নম্বরগুলি (নীচে দেখুন) চয়ন করি এবং নীচের সীমাটি যুক্ত করি। সি, এই হবে

lower + rand() * (upper - lower)

⍺প্রতিস্থাপন ছাড়া বার। প্যারেন্টিসগুলির প্রয়োজন নেই কারণ এপিএল ডান থেকে বামে পরিচালনা করে।

ধরে নিলাম আমি শর্তগুলি সঠিকভাবে বুঝতে পেরেছি, এটি 'দৃust়তা' মানদণ্ডকে ব্যর্থ করে কারণ অনুপযুক্ত যুক্তি দেওয়া হলে (যেমন উদ্বোধকের পরিবর্তে কোনও ভেক্টর পাশ করা ⍺) যদি ফাংশনটি ব্যর্থ হয় ।

ঘটনা যে ⍺একটি ভেক্টর বদলে স্কালে হয়, 1↑⍺প্রথম উপাদান লাগে ⍺। একটি স্কেলারের জন্য, এটি নিজেই স্কেলার। কোনও ভেক্টরের জন্য, এটি প্রথম উপাদান। এটি ফাংশনটিকে 'দৃust়তা' মানদণ্ডের সাথে মিলিত করে তোলে।

উদাহরণ:

Input: 100 {⍵[0]+⍺?⍵[1]-⍵[0]} 0 100
Output: 34 10 85 2 46 56 32 8 36 79 77 24 90 70 99 61 0 21 86 50 83 5 23 27 26 98 88 66 58 54 76 20 91 72 71 65 63 15 33 11 96 60 43 55 30 48 73 75 31 13 19 3 45 44 95 57 97 37 68 78 89 14 51 47 74 9 67 18 12 92 6 49 41 4 80 29 82 16 94 52 59 28 17 87 25 84 35 22 38 1 93 81 42 40 69 53 7 39 64 62

Comments

এটি কোনও কোড গল্ফ নয় তবে একটি দ্রুততম কোস, সুতরাং লক্ষ্যটি সংক্ষিপ্ততমের চেয়ে কার্য সম্পাদনের জন্য দ্রুততম কোড তৈরি করছে। যাইহোক, আপনার এই জাতীয় যুক্তিগুলি থেকে সত্যই আইটেমগুলি বাছাই করার দরকার নেই এবং আপনি তাদের {⍵+⍺?⎕-⍵}ক্রমটি নির্ধারণ করতে পারেন, তাই যথেষ্ট হওয়া উচিত, যেখানে প্রম্পটটি উপরের বাউন্ডের জন্য এবং ডান দিকের আর্গুমেন্টটি নিম্ন সীমাবদ্ধ

— উরিয়েল

Answer 8

scala

object RandSet {
  val random = util.Random 

  def rand (count: Int, lower: Int, upper: Int, sofar: Set[Int] = Set.empty): Set[Int] =
    if (count == sofar.size) sofar else 
    rand (count, lower, upper, sofar + (random.nextInt (upper-lower) + lower)) 
}

object RandSetRunner {

  def main (args: Array [String]) : Unit = {
    if (args.length == 4) 
      (0 until args (0).toInt).foreach { unused => 
      println (RandSet.rand (args (1).toInt, args (2).toInt, args (3).toInt).mkString (" "))
    }
    else Console.err.println ("usage: scala RandSetRunner OUTERCOUNT COUNT MIN MAX")
  }
}

সংকলন এবং চালনা:

scalac RandSetRunner.scala 
scala RandSetRunner 200 15 0 100

দ্বিতীয় লাইনটি 0 থেকে 100 পর্যন্ত 15 টি মান সহ 200 টি পরীক্ষা চালাবে, কারণ স্কালা দ্রুত বাইটকোড উত্পাদন করে তবে কিছু শুরু করার সময় প্রয়োজন। সুতরাং 200 থেকে শুরু করে 15 টি মান থেকে শুরু করে 100 পর্যন্ত বেশি সময় লাগবে।

একটি 2 গিগা হার্জ সিঙ্গল কোরের নমুনা:

time scala RandSetRunner 100000 10 0 1000000 > /dev/null

real    0m2.728s
user    0m2.416s
sys     0m0.168s

লজিক:

বিল্ট-ইন এলোমেলো ব্যবহার করে এবং পুনরাবৃত্তভাবে পরিসরে সংখ্যাগুলি সর্বাধিক পিক করা (সর্বাধিক-মিনিট), মিনিট যোগ করা এবং চেক করা, যদি সেটটির আকার প্রত্যাশিত আকার হয়।

সমালোচনা:

• বড় পরিসরের ছোট ছোট নমুনাগুলির জন্য এটি দ্রুত হবে, তবে যদি কাজটি কোনও নমুনার প্রায় সমস্ত উপাদান (1000 এর মধ্যে 999 সংখ্যা) বাছাই করে তবে এটি ইতিমধ্যে সেটে বারবার সংখ্যাগুলি বেছে নেবে।
• প্রশ্ন থেকে, আমি অনিশ্চিত, 4 বা 8 থেকে 10 স্বতন্ত্র সংখ্যা নেওয়ার মতো অসমাপ্ত অনুরোধের বিরুদ্ধে আমাকে স্যানিটাইজ করতে হবে কিনা তা এখনই একটি অন্তহীন লুপের দিকে পরিচালিত করবে, তবে সহজেই পূর্ববর্তী চেকটি এড়ানো যাবে যা আমি যুক্ত করব কিনা অনুরোধ.

Answer 9

পরিকল্পনা

আপনার কেন 3 টি প্যারামিটার উত্তীর্ণ হবে বা কেন আমাকে কোনও পরিসর ধরে নেওয়া দরকার তা নিশ্চিত নয় ...

(import srfi-1) ;; for iota
(import srfi-27) ;; randomness
(import srfi-43) ;; for vector-swap!

(define rand (random-source-make-integers
               default-random-source))

;; n: length, i: lower limit
(define (random-range n i)
  (let ([v (list->vector (iota n i))])
    (let f ([n n])
      (let* ([i (rand n)] [n (- n 1)])
        (if (zero? n) v
            (begin (vector-swap! v n i) (f n)))))))

Answer 10

আর

random <- function(count, from, to) {
  rand.range <- to - from

  vec <- c()

  for (i in 1:count) {
    t <- sample(rand.range, 1) + from
    while(i %in% vec) {
      t <- sample(rand.range, 1) + from
    }
    vec <- c(vec, t)
  }

  return(vec)
}

Answer 11

সি ++

ব্যাপ্তি থেকে অনেক নমুনা আঁকলে এই কোডটি সেরা।

#include <exception>
#include <stdexcept>
#include <cstdlib>

template<typename OutputIterator>
 void sample(OutputIterator out, int n, int min, int max)
{
  if (n < 0)
    throw std::runtime_error("negative sample size");
  if (max < min)
    throw std::runtime_error("invalid range");
  if (n > max-min+1)
    throw std::runtime_error("sample size larger than range");

  while (n>0)
  {
    double r = std::rand()/(RAND_MAX+1.0);
    if (r*(max-min+1) < n)
    {
      *out++ = min;
      --n;
    }
    ++min;
  }
}

Comments

এর max-minচেয়ে অনেক বড় না হলে এটি সহজেই অসীম লুপে আটকে যেতে পারে n। এছাড়াও, আউটপুট ক্রমটি একঘেয়েভাবে বৃদ্ধি পাচ্ছে, সুতরাং আপনি খুব নিম্নমানের এলোমেলোতা পাচ্ছেন তবে rand()ফলস্বরূপ একাধিকবার কল করার জন্য মূল্য প্রদান করছেন । অ্যারের একটি এলোমেলো পরিবর্তন সম্ভবত অতিরিক্ত রান-টাইমের জন্য উপযুক্ত হবে।

— পিটার কর্ডস

Answer 12

প্রশ্ন (19 টি অক্ষর)

f:{(neg x)?y+til z}

তারপরে f [x; y; z] টি হিসাবে [আউটপুট সেটে সংখ্যার গণনা; প্রারম্ভিক পয়েন্ট; পরিসরের আকার]

উদাহরণস্বরূপ f [5; 10; 10] 10 এবং 19 সমেতের মধ্যে 5 স্বতন্ত্র এলোমেলো সংখ্যা নির্ধারণ করবে।

q)\ts do[100000;f[100;1;10000]]
2418 131456j

উপরের ফলাফলগুলি 1 ও 10,000 এর মধ্যে 100 টি এলোমেলো সংখ্যা বাছাইয়ের 100,000 পুনরাবৃত্তিতে কর্মক্ষমতা দেখায় show

Answer 13

আর, ৩১ বা ৪০ বাইট ("রেঞ্জ" শব্দের অর্থের উপর নির্ভর করে)

যদি ইনপুটটিতে 3 টি সংখ্যা থাকে a[1], a[2], a[3]এবং "রেঞ্জ" দ্বারা আপনি "একটি [2] থেকে একটি [3]" তে একটি পূর্ণসংখ্যার ক্রমটি বোঝেন তবে আপনার কাছে এটি রয়েছে:

a=scan();sample(a[2]:a[3],a[1])

আপনার যদি এমন একটি অ্যারে nথাকে যা থেকে আপনি পুনরায় নমুনা তৈরি করতে চলেছেন তবে নিম্ন এবং উচ্চতর সীমাবদ্ধতার অধীনে যেমন " nপরিসর থেকে প্রদত্ত অ্যারের পুনঃনির্মাণের মানগুলি a[1]...a[2]" রয়েছে তবে এটি ব্যবহার করুন:

a=scan();sample(n[n>=a[2]&n<=a[3]],a[1])

আমি বেশ অবাক হয়েছি কেন আগের ফলাফলটি প্রতিস্থাপনের সুবিধাগুলি সহ অন্তর্নির্মিত নমুনা বিবেচনা করে গল্ফ করা হয়নি! আমরা একটি ভেক্টর তৈরি করি যা পরিসীমা শর্তটি পূরণ করে এবং এটির পুনরায় নমুনা দেয়।

• দৃust়তা: কোণার কেসগুলি (নমুনা থেকে সীমা হিসাবে একই দৈর্ঘ্যের ক্রম) ডিফল্টরূপে পরিচালিত হয়।
• রান-টাইম: অত্যন্ত দ্রুত কারণ এটি অন্তর্নির্মিত।
• এলোমেলোতা: প্রতিবার আরএনজি চালানোর সময় বীজ স্বয়ংক্রিয়ভাবে পরিবর্তিত হয়।

Comments

আমার মেশিনে অন্তত 0:(2^31)একটি কারণError: cannot allocate a vector of size 16.0 Gb

— : Giuseppe

@ জিউসেপ্পে সম্প্রতি, আমি বড় মেমরির সমস্যা নিয়ে কাজ করছি এবং এর সমাধান আসলে ... আরও ভাল মেশিনে চালাচ্ছি। টাস্ক গঠনের ক্ষেত্রে বিধিনিষেধগুলি প্রসেসরের সাথে সম্পর্কিত, স্মৃতিশক্তি নয়, তাই ... নিয়মের অপব্যবহারের বিষয়টি কি? আহ, আমি একটা গাধা আমি ভেবেছিলাম এটি একটি কোড গল্ফ চ্যালেঞ্জ, তবে আসলে এটি ... দ্রুততম কোড। আমি কি অনুমান করি?

— Andreï Kostyrka

Answer 14

জাভাস্ক্রিপ্ট (বাহ্যিক গ্রন্থাগার ব্যবহার করে) (by৪ বাইট / ১০৪ বাইট ??)

(a,b,n)=>_.Range(0,n).Select(x=>Math.random()*(b-a)+a).ToArray()

লাইব লিঙ্ক: https://github.com/mvegh1/Eeumerable/

কোড ব্যাখ্যা: লাম্বদা এক্সপ্রেশন কমপক্ষে, সর্বাধিক, আরগ হিসাবে গণনা গ্রহণ করে। আকারের এন এর একটি সংগ্রহ তৈরি করুন এবং প্রতিটি উপাদানকে ন্যূনতম / সর্বোচ্চ মানদণ্ডের সাথে মানিয়ে মানিয়ে নিন a নেটিভ জেএস অ্যারেতে রূপান্তর করুন এবং এটি ফিরিয়ে দিন। আমি এটি 5,000,000 আকারের ইনপুটটিতেও চালিয়েছি এবং একটি স্বতন্ত্র রূপান্তর প্রয়োগের পরেও 5,000,000 উপাদান দেখিয়েছি। যদি এটির বিষয়ে একমত হয় যে এটি স্বতন্ত্রতার জন্য কোনও গ্যারান্টি যথেষ্ট নিরাপদ নয় তবে আমি উত্তরটি আপডেট করব

আমি নীচের চিত্রটিতে কিছু পরিসংখ্যান অন্তর্ভুক্ত করেছি ...

সম্পাদনা: নীচের চিত্রটি কোড / সম্পাদন দেখায় যা প্রতিটি উপাদান পৃথক হবে তার গ্যারান্টি দেয় এটি অনেক ধীরে ধীরে (50,000 উপাদানের জন্য 6.65 সেকেন্ড) একই আরোগুলির জন্য উপরের মূল কোডটি বনাম (0.012 সেকেন্ড)

Answer 15

কে (ওকে) , 14 বাইট

সমাধান:

{y+(-x)?1+z-y}

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

উদাহরণ:

> {y+(-x)?1+z-y}. 10 10 20      / note: there are two ways to provide input, dot or
13 20 16 17 19 10 14 12 11 18
> {y+(-x)?1+z-y}[10;10;20]      / explicitly with [x;y;z]
12 11 13 19 15 17 18 20 14 10

ব্যাখ্যা:

প্রতি অনুমান 3 টি অন্তর্নিহিত ইনপুট লাগে:

• x, আউটপুট সেট সংখ্যা সংখ্যা,
• y, নিম্ন সীমা (অন্তর্ভুক্ত)
• z, উপরের সীমা (অন্তর্ভুক্ত)

---

{y+(-x)?1+z-y} / the solution
{            } / lambda function with x, y and z as implicit inputs
          z-y  / subtract lower limit from upper limit
        1+     / add 1
   (-x)?       / take x many distinct items from 0..(1+z=y)
 y+            / add lower limit

মন্তব্য:

এছাড়াও একটি বহুভাষিক q/kdb+বন্ধনী একটি অতিরিক্ত সেট দিয়ে: {y+((-)x)?1+z-y}(16 বাইট)।

Answer 16

এক্সিয়াম + এটির গ্রন্থাগার

f(n:PI,a:INT,b:INT):List INT==
    r:List INT:=[]
    a>b or n>99999999 =>r
    d:=1+b-a
    for i in 1..n repeat
          r:=concat(r,a+random(d)$INT)
    r

উপরের চ () ফাংশনটি খ> তালিকার ত্রুটি হিসাবে ফিরে আসে, ক্ষেত্রে ক্ষেত্রে एफ (এন, এ, বি) এ> বি দিয়ে। অবৈধ ইনপুট সংক্রান্ত অন্যান্য ক্ষেত্রে, এটি এক্সিয়াম উইন্ডোতে একটি ত্রুটি বার্তা দিয়ে চলবে না কারণ যুক্তিটি সঠিক ধরণের হবে না। উদাহরণ

(6) -> f(1,1,5)
   (6)  [2]
                                                       Type: List Integer
(7) -> f(1,1,1)
   (7)  [1]
                                                       Type: List Integer
(10) -> f(10,1,1)
   (10)  [1,1,1,1,1,1,1,1,1,1]
                                                       Type: List Integer
(11) -> f(10,-20,-1)
   (11)  [- 10,- 4,- 18,- 5,- 5,- 11,- 15,- 1,- 20,- 1]
                                                       Type: List Integer
(12) -> f(10,-20,-1)
   (12)  [- 4,- 5,- 3,- 4,- 18,- 1,- 2,- 14,- 19,- 8]
                                                       Type: List Integer
(13) -> f(10,-20,-1)
   (13)  [- 18,- 12,- 12,- 19,- 19,- 15,- 5,- 17,- 19,- 4]
                                                       Type: List Integer
(14) -> f(10,-20,-1)
   (14)  [- 8,- 11,- 20,- 10,- 4,- 8,- 11,- 3,- 10,- 16]
                                                       Type: List Integer
(15) -> f(10,9,-1)
   (15)  []
                                                       Type: List Integer
(16) -> f(10,0,100)
   (16)  [72,83,41,35,27,0,33,18,60,38]
                                                       Type: List Integer