प्रतिस्थापन के बिना यादृच्छिक नमूनाकरण

Question

एक फ़ंक्शन बनाएँ जो एक श्रेणी से खींची गई अलग-अलग यादृच्छिक संख्याओं का एक सेट आउटपुट करेगा। सेट में तत्वों का क्रम महत्वहीन है (वे भी सॉर्ट किए जा सकते हैं), लेकिन यह संभव है कि सेट की सामग्री के लिए हर बार फ़ंक्शन को अलग-अलग कहा जाए।

फ़ंक्शन आपको जो भी क्रम में 3 पैरामीटर प्राप्त करेगा:

1. आउटपुट सेट में संख्याओं की गणना
2. निचली सीमा (समावेशी)
3. ऊपरी सीमा (समावेशी)

मान लें कि सभी संख्या 0 (समावेशी) से 2 ³¹ (अनन्य) में पूर्णांक हैं । आउटपुट को किसी भी तरह से वापस पारित किया जा सकता है जो आप चाहते हैं (कंसोल के रूप में लिखें, एक सरणी के रूप में, आदि)

आंकना

मानदंड में 3 आर शामिल हैं

1. रन-टाइम - जो कुछ भी संकलक स्वतंत्र रूप से या आसानी से उपलब्ध है, उसके साथ एक क्वाड-कोर विंडोज 7 मशीन पर परीक्षण किया गया है (यदि आवश्यक हो तो एक लिंक प्रदान करें)
2. मजबूतता - क्या फ़ंक्शन कोने के मामलों को संभालता है या क्या यह एक अनन्त लूप में आएगा या अमान्य परिणाम देगा - इनपुट पर कोई अपवाद या त्रुटि मान्य है
3. यादृच्छिकता - यह यादृच्छिक परिणाम उत्पन्न करना चाहिए जो यादृच्छिक वितरण के साथ आसानी से अनुमानित नहीं हैं। अंतर्निहित यादृच्छिक संख्या जनरेटर का उपयोग करना ठीक है। लेकिन कोई स्पष्ट पूर्वाग्रह या स्पष्ट पूर्वानुमान योग्य पैटर्न नहीं होना चाहिए। दिलबर्ट में लेखा विभाग द्वारा उपयोग किए जाने वाले यादृच्छिक संख्या जनरेटर से बेहतर होने की आवश्यकता है

यदि यह मजबूत और यादृच्छिक है तो यह रन-टाइम के लिए नीचे आता है। मजबूत या बेतरतीब होने के कारण इसके स्टैंड से बहुत नुकसान होता है।

Comments

क्या उत्पादन DIEHARD या TestU01 परीक्षणों की तरह कुछ करने के लिए माना जाता है , या आप इसकी यादृच्छिकता का न्याय कैसे करेंगे? ओह, और कोड को 32 या 64 बिट मोड में चलना चाहिए? (कि अनुकूलन के लिए एक बड़ा फर्क पड़ेगा।)

— इल्मरी करोनें

TestU01 शायद थोड़ा कठोर है, मुझे लगता है। क्या मानदंड 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उपसर्ग प्राप्त करने के लिए रेंज का आंशिक फिशर-येट्स फेरबदल है ।

बेशक, पूरी सीमा को स्टोर करना महंगा होगा, इसलिए मैं केवल उन स्थानों को संग्रहीत करता हूं जहां तत्वों की अदला-बदली हुई है।

इस तरह, एल्गोरिथ्म को उस स्थिति में अच्छा प्रदर्शन करना चाहिए जहाँ आप एक तंग सीमा से संख्याओं का नमूना ले रहे हैं (उदाहरण के लिए श्रेणी १.१००० में १००० संख्याएँ), और साथ ही उस मामले में जहाँ आप बड़ी संख्या से संख्याओं का नमूना ले रहे हैं। ।

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

Comments

पायथन मेर्सन ट्विस्टर का उपयोग करता है , इसलिए यह अपेक्षाकृत सभ्य है।

— ESultanik

Answer 2

अजगर 2.7

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

यह सुनिश्चित नहीं है कि बिलिन यादृच्छिक तरीकों का उपयोग करने पर आपका खड़ा क्या है, लेकिन यहां आप कहीं भी जाते हैं। अच्छा और छोटा

संपादित करें: बस उस सीमा () को बड़ी सूची बनाना पसंद नहीं है। एक स्मृति त्रुटि में परिणाम। देखेंगे कि क्या ऐसा करने का कोई और तरीका है ...

edit2: रेंज गलत फ़ंक्शन था, xrange काम करता है। अधिकतम पूर्णांक वास्तव 2**31-1में अजगर के लिए है

परीक्षा:

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

Answer 3

सी

मिनट और अधिकतम के बीच एक्स अद्वितीय यादृच्छिक ints युक्त एक सरणी देता है। (कॉलर मुक्त होना चाहिए)

#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;
}

रेंज में x अनुक्रमिक यादृच्छिक पूर्णांक बनाकर काम करता है, फिर उन्हें फेरबदल करता है। 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)  
}

बेशक, कोई इसे बेहतर प्रदर्शन के लिए सी में फिर से लिख सकता है। इस एल्गोरिथ्म की जटिलता में चर्चा की गई है: रोज़ंकिन, पीएस; वॉयटिशेक, एवी यादृच्छिक एल्गोरिदम के लिए एल्गोरिदम की लागत पर। मोंटे कार्लो तरीके Appl। 5 (1999), नहीं। 1, 39-54। http://dx.doi.org/10.1515/mcma.1999.5.1.39

आप इस पेपर के माध्यम से एक ही एल्गोरिथ्म के लिए एक ही औसत जटिलता के साथ देख सकते हैं।

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

वर्दी के नमूने के लिए भी देखें: पी। गुप्ता, जीपी भट्टाचार्जी। (1984) प्रतिस्थापन के बिना यादृच्छिक नमूने के लिए एक कुशल एल्गोरिथ्म। इंटरनेशनल जर्नल ऑफ़ कंप्यूटर मैथमेटिक्स 16: 4, पेज 201-209। DOI: 10.1080 / 00207168408803438

तेहोला, जे। और नेवलैनेन, ओ। 1982. प्रतिस्थापन के बिना यादृच्छिक नमूने के लिए दो कुशल एल्गोरिदम। / IJCM /, 11 (2): 127-140 DOI: 10.1080 / 00207168208803304

आखिरी पेपर में लेखक हैश टेबल का उपयोग करते हैं और दावा करते हैं कि उनके एल्गोरिदम में ओ ( ओं ) की जटिलता है। एक और तेज़ हैश टेबल एल्गोरिथ्म है, जिसे जल्द ही pqR (बहुत जल्दी आर) में लागू किया जाएगा: https://stat.ethz.ch/pipermail/r-devel/2017-October/075012.html

Answer 7

एपीएल, 18 22 बाइट्स

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

एक अनाम फ़ंक्शन की घोषणा करता है जो दो तर्क लेता है ⍺और ⍵। ⍺आप चाहते हैं यादृच्छिक संख्या की संख्या है ⍵, उस क्रम में निचले और ऊपरी सीमा वाले एक वेक्टर है।

a?bप्रतिस्थापन के बिना a0- के बीच यादृच्छिक संख्या चुनता है b। लेने से ⍵[1]-⍵[0]हमें रेंज का आकार मिलता है। फिर हम ⍺उस सीमा से संख्याएँ (नीचे देखें) उठाते हैं और निचली सीमा को जोड़ते हैं। सी में, यह होगा

lower + rand() * (upper - lower)

⍺प्रतिस्थापन के बिना समय। कोष्ठक की आवश्यकता नहीं है क्योंकि एपीएल दाएं-से-बाएं संचालित होता है।

यह मानते हुए कि मैंने शर्तों को सही ढंग से समझा है, यह 'मजबूती' मानदंडों को विफल करता है क्योंकि यदि अनुचित तर्क दिए गए हैं तो फ़ंक्शन विफल हो जाएगा (जैसे कि एक स्केलर के बजाय एक वेक्टर पास करना ⍺)।

उस घटना में जो ⍺एक स्केलर के बजाय एक वेक्टर है, 1↑⍺का पहला तत्व लेता है ⍺। एक स्केलर के लिए, यह स्केलर ही है। एक वेक्टर के लिए, यह पहला तत्व है। इससे समारोह को 'मजबूती' के मानदंडों को पूरा करना चाहिए।

उदाहरण:

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

यह एक कोड गोल्फ नहीं है, बल्कि एक सबसे तेज़ कोस है, इसलिए लक्ष्य सबसे कम समय के बजाय कार्य करने के लिए सबसे तेज़ कोड का उत्पादन कर रहा है। वैसे भी, आपको वास्तव में उस तरह के तर्कों से आइटम लेने की आवश्यकता नहीं है, और आप उनके आदेश का निर्धारण कर सकते हैं, इसलिए {⍵+⍺?⎕-⍵}पर्याप्त होना चाहिए, जहां शीघ्र ऊपरी सीमा के लिए है और दायां arg कम है

— Uriel

Answer 8

स्काला

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 0 से 100 के 15 मानों से शुरू होता है और अधिक समय लगता है।

2 Ghz सिंगल कोर पर नमूना:

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 पुनरावृत्तियों पर प्रदर्शन करते हैं।

Answer 13

आर, 31 या 40 बाइट्स (शब्द "रेंज" के अर्थ के आधार पर)

यदि इनपुट में 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])

मैं काफी हैरान हूं कि पिछले परिणाम को प्रतिस्थापन सुविधाओं के साथ अंतर्निहित नमूने पर विचार क्यों नहीं किया गया था! हम एक वेक्टर बनाते हैं जो सीमा की स्थिति को संतुष्ट करता है और इसे फिर से नमूना करता है।

• मजबूतता: कोने के मामले (क्रम से एक ही लंबाई के अनुक्रम) डिफ़ॉल्ट रूप से नियंत्रित किए जाते हैं।
• रन-टाइम: बेहद तेज क्योंकि इसमें बनाया गया है।
• यादृच्छिकता: RNG लागू होने पर बीज को हर बार स्वचालित रूप से बदल दिया जाता है।

Comments

कम से कम मेरी मशीन पर, 0:(2^31)कारणError: cannot allocate a vector of size 16.0 Gb

— Giuseppe

@Giuseppe हाल ही में, मैं बड़ी मेमोरी समस्याओं के साथ काम कर रहा हूं, और इसका समाधान वास्तव में है ... इसे एक बेहतर मशीन पर चलाना। कार्य के निर्माण में प्रतिबंध प्रोसेसर से संबंधित है, स्मृति के लिए नहीं, तो क्या यह है ... नियम का दुरुपयोग? आह, मैं एक गधा हूँ। मैंने सोचा था कि यह एक कोड गोल्फ चुनौती थी, लेकिन वास्तव में यह है ... सबसे तेज़-कोड। मुझे लगता है मैं खो?

— आंद्रे

Answer 14

जावास्क्रिप्ट (बाहरी पुस्तकालय का उपयोग करके) (64 बाइट्स / 104 बाइट्स ??)

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

लिंक से संबंधित: https://github.com/mvegh1/Enumerable/

कोड स्पष्टीकरण: लैम्ब्डा अभिव्यक्ति न्यूनतम, अधिकतम, आर्ग्स के रूप में गिना जाता है। आकार n का एक संग्रह बनाएं, और प्रत्येक तत्व को न्यूनतम / अधिकतम मानदंड के अनुसार यादृच्छिक संख्या में मैप करें। देशी JS सरणी में कनवर्ट करें और इसे वापस करें। मैंने इसे 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

Axiom + इसकी लाइब्रेरी है

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

उपरोक्त f () फ़ंक्शन खाली सूची के रूप में त्रुटि लौटाता है, मामले में f (n, b) a> b के साथ। अमान्य इनपुट के अन्य मामलों में, यह Axiom विंडो में एक त्रुटि संदेश के साथ नहीं चलता है, क्योंकि तर्क सही प्रकार का नहीं होगा। उदाहरण

(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