अलग-अलग अंकों के साथ एक यादृच्छिक n अंक संख्या प्राप्त करें और पहले 0 नहीं

Question

मैंने इस सवाल को पढ़ा और सोचा कि यह एक अच्छी चुनौती होगी।

कार्य

एक इनपुट दें 0<n<10जिसके साथ एक यादृच्छिक संख्या उत्पन्न होती है

• बिल्कुल n अंक
• पहला नहीं 0
  • इसलिए f(n)>10**(n-1)-1
• अलग अंक

मानदंड जीतना

यह कोड-गोल्फ है इसलिए सबसे छोटा कोड जीतता है।

बिना सोचे समझे

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

उदाहरण

मानों की सूची बेतरतीब ढंग से से चुनने के लिए n=2है:

[10, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98]

Comments

वितरण को

— दोष

पूर्णांक के रूप में लौटें, स्ट्रिंग नहीं, हाँ?

— ग्यूसेप

@Giuseppe

— mbomb007

मुझे लगता है कि यह हर बार किसी को एक यादृच्छिक संख्या प्रश्न xkcd.com/221

— Thunda

@ ais523 "एक इनपुट दें 0 <n <10" के साथ एक यादृच्छिक संख्या उत्पन्न करें

— क्लीवलैंस

Answer 1

पायथन 2 , 77 बाइट्स

from random import*
r=range(10)
while[1]>r:shuffle(r)
print`r`[1:input()*3:3]

इसे ऑनलाइन आज़माएं!

जब तक यह 0 से शुरू नहीं होता है, तब तक 10 अंकों की सूची को फेरबदल करता है, फिर पहले nअंक के साथ एक नंबर बनाता है ।

Comments

निश्चित रूप से तेजी से और कम स्मृति के साथ 9या के इनपुट के लिए चलाता है 10।

— mbomb007

नीट समाधान! क्या आप बता सकते हैं कि [1::3]इसे सूची से स्ट्रिंग में बदलने के लिए कैसे काम करता है? मैंने ऐसा पहले कभी नहीं देखा।

— जूलियन वुल्फ

@ जूलियनवुल्फ यह तभी काम करता है जब सूची का प्रत्येक तत्व समान लंबाई का हो। यह वास्तव में सूची के स्ट्रिंग प्रतिनिधित्व को लेता है, फिर इसे पहले स्लीप करने के बाद हर 3 अक्षर को ले जाता है [।

— mbomb007

@ जूलियनवॉल्फ [1::3]को चरित्र 1, फिर हर तीसरे पर मिलता है। इसके लिए [1, 2, 3], 123कोष्ठक, अल्पविराम और रिक्त स्थान को छोड़ देता है ।

— डेनिस

गोली मारो, ठीक है - यह समझ में आता है। मैं भूल रहा था कि [1, 2, 3]पहले से ही कड़े हो गए थे और अल्पविराम और रिक्त स्थान की आवश्यकता थी। धन्यवाद!

— जूलियन वुल्फ

Answer 2

ब्रेकीलॉग , 9 10 बाइट्स

{~lℕ₁≜≠}ᶠṛ

इसे ऑनलाइन आज़माएं!

Brachylog के लिए हमेशा की तरह, यह एक फ़ंक्शन सबमिशन है। फ़ंक्शन को पूर्ण कार्यक्रम में बनाने के लिए ऊपर दिए गए TIO लिंक को कमांड-लाइन तर्क दिया गया है।

मैं इस के पहले संस्करण से एक अतिरिक्त बाइट जोड़ने के लिए बदल रहा था, ℕके लिए ℕ₁, उत्पादन 0 (कुछ है कि अब स्पष्ट किया गया है) की अनुमति नहीं देने के लिए।

व्याख्या

{~lℕ₁≜≠}ᶠṛ
{      }ᶠṛ  Pick a random value with these properties:
 ~l           it has length equal to the input;
   ℕ₁         it's a positive integer;
     ≜        it's a specific value (not a constraint);
      ≠       all its elements (digits in this case) are different.

उचित रूप से अक्षम, क्योंकि दुभाषिया सभी संभावित मूल्यों की एक सूची बनाता है और फिर यादृच्छिक पर एक चुनता है ( ᶠṛइसका मतलब है; इस प्रश्न के पूछे जाने के समय ब्रेकीग्लॉट के पास "एक यादृच्छिक समाधान चुनें" विकल्प नहीं था)।

यहाँ लेबलकरण पर कुछ टिप्पणियाँ: यदि ≜छोड़ दिया गया है, ब्रेसिज़ के भीतर का खंड केवल एक मूल्य पैदा करता है, एक बाधा जो हम चाहते हैं संपत्ति के साथ संख्या का प्रतिनिधित्व करते हैं; एक यादृच्छिक परिणाम लेने से हमें अड़चन होती है, और दुभाषिया न्यूनतम निरपेक्ष मूल्य का उत्पादन करता है जो बाधा (1, 10, 102, 1023, 10234, आदि) से मिलता है, जो कि हम नहीं चाहते हैं। इस प्रकार हमें एक स्पष्ट लेबल के माध्यम से सूची के निर्माण के लिए मजबूर करना होगा।

अधिकांश प्रोलॉग कार्यान्वयन मैंने देखा है कि एक बेतरतीब परिणाम को खोजने के लिए एक अवरोध है, लेकिन आमतौर पर समान संभावना के साथ नहीं; ब्रेकीलॉग के पास एक नहीं था, हालांकि (इस चुनौती के जवाब में एक जोड़ा गया था, लेकिन जाहिर है मैं लूपहोल नियमों के कारण इसका उपयोग नहीं कर सकता)। यदि यह किया गया था, और अगर यह इस समस्या पर एक समान संभावना देने के लिए हुआ, तो इस कार्यक्रम को ~lℕ₁≠6 बाइट्स की संभावित लंबाई के लिए उस बिलिन द्वारा पीछा किया जाएगा ।

Brachylog , 8 बाइट्स, @Fatalize के सहयोग से

~lℕ₁≠≜ᶠṛ

इसे ऑनलाइन आज़माएं!

यह जीनियस लो-लेवल ट्रिक है जो केवल उस तरह से समझ में आता है जिस तरह से प्रोलोग चीजों को करता है, और जब मैटिकली वर्णित किया जाता है तो यह बहुत मायने नहीं रखता है।

पहले की तरह, ~lℕ₁≠एक मान बनता है जो एक बाधा का वर्णन करता है ("इनपुट के बराबर लंबाई, प्राकृतिक संख्या, सभी तत्व अलग-अलग")। फिर ≜ᶠसभी संभावित मूल्यों को उत्पन्न करता है जो बाधा से मिलते हैं। यहाँ मुद्दा यह है कि ब्राचीग्लॉग के मूल्यांकन अनुक्रम के साथ, ≜प्रकट होने तक कोई वास्तविक विकल्प नहीं बनाया जाता है, इसलिए "सभी समाधानों को ढूंढें" ऑपरेशन के ᶠलिए कुछ भी नहीं बल्कि "विशिष्ट मूल्य जो एक बाधा को पूरा करता है" ऑपरेशन पर लागू होता है ≜। इसका मतलब है कि {…}2 बाइट्स बचाकर, इसके दायरे का चयन करने की कोई आवश्यकता नहीं है ।

Comments

मैं ≜₁इससे पहले कि मैं इस चुनौती की वजह से जोड़ा गया था के साथ एक समाधान पोस्ट करने जा रहा था

— असंबंधित स्ट्रिंग

Answer 3

जेली , 9 बाइट्स

⁵*ṖQL$€MX

इसे ऑनलाइन आज़माएं! (कार्यान्वयन की अक्षमता के कारण n> 6 के लिएTIO पर काम नहीं करेगा)

या एक ही बात का एक वैकल्पिक कार्यान्वयन:

⁵*ṖQL$ÐṀX

कैसे?

यह बहुत डरपोक है, और बहुत अक्षम है! जब एक परमाणु एक सूची की उम्मीद करता है लेकिन एक पूर्णांक प्राप्त करता है (यह डिजाइन द्वारा है) तो जेली कुछ उपयोगी चीजें करता है।
यह कोड इन उपयोगी निहित क्रियाओं के एक जोड़े का उपयोग करता है:

• मोनैडिक परमाणु Ṗ, "पॉप", जब एक पूर्णांक इनपुट के साथ बुलाया जाता है, तो स्पष्ट रूप से एक सीमा होती है, जिसमें से पॉप होता है, इसलिए n सबसे पहले एक इनपुट बनाता है [1, 2, ..., n] , फिर पॉप, उपज [1, 2] , ..., एन -1] ।

• मोनैडिक परमाणु Q, "डी-डुप्लिकेट" या "अद्वितीय", जब पूर्णांक इनपुट के साथ बुलाया जाता है, तो स्पष्ट रूप से डी-डुप्लिकेट के लिए एक दशमलव सूची बनाता है, इसलिए n का एक इनपुट जहां:
  n = d _k-1 × 10 ^k-1 + d _k-2 × 10 ^k-2 + ... + d ₁ × 10 + d ₀
  पहले बनाता है
  [d _k-1 , d _k-2 , ..., d ₁ , d ₀ ]
  और फिर अद्वितीय मानों को प्राप्त करता है पहली प्रस्तुति।
  तो, उदाहरण के लिए, एन = 5835518 प्राप्त होते हैं [5, 8, 3, 1] ।

इसके अलावा मोनैडिक परमाणु M, "मैक्सिमम एलिमेंट इंडेक्स", एक लिस्ट से मैक्सिमम आइटम्स के इंडेक्स को लौटाता है। यह इनपुट के साथ समानता के लिए परीक्षण के अधिक स्पष्ट विकल्प और सत्य इंडेक्स को खोजने के लिए दो बाइट्स को बचाता है ⁵*ṖQL$€=⁸TX, या⁵*ṖðQL⁼ð€TX

⁵*ṖQL$€MX - Main link: n                       e.g. 2
⁵         - literal 10
 *        - exponentiate: 10^n                      100
  Ṗ       - pop (make range 1 to 10^n, then pop)    [1  ,2  ,...,21   ,22 ,23   ,...,97   ,98   ,99]
     $€   - last two links as a monad for €ach:
   Q      -   unique (makes a decimal list first)   [[1],[2],...,[2,1],[2],[2,3],...,[9,7],[9,8],[9]]
    L     -   length                                [1  ,1  ,...,2    ,1  ,2    ,...,2    ,2    ,1  ]
       M  - indexes of maximal elements             [        ...,21       ,23,   ...,97   ,98       ]
          -                                         - i.e. all n-digit numbers with n-distinct digits.
        X - pick a random element from that list

यह सभी काफी अकुशल है, समय और स्मृति दोनों में: पहले 10 ⁿ पूर्णांकों की एक सूची बनाई जाती है और एक को छोड़ दिया जाता है, फिर इनमें से प्रत्येक के लिए n पूर्णांकों की सूची (कुछ फैंसी 4-बिट ऑब्जेक्ट या एनम) नहीं बनाई जाती है और फिर डी-डुप्लिकेट किया गया। इस डी-डुप्लीकेशन की पूरी तरह से सूची-आधारित कार्यान्वयन है (कोई सेट, सॉर्ट-सेट, या शब्दकोशों में अंडर-द-हूड शामिल नहीं है, प्रत्येक अंक को उस सूची में अस्तित्व के लिए जांचा जाता है जो अंततः आउटपुट प्राप्त करता है)।
ऑफ़लाइन n = 7 उपयोग ~ 0.5GB और ~ 25 सेकंड लेता है, जबकि n = 8 ~ 4GB का उपयोग करता है और ~ 5 मिनट लेता है - मैंने n = 9 को चलाने की जहमत नहीं उठाई है क्योंकि मेरे पास केवल 16GB RAM है (मुझे लगता है कि इसे ~ 45 मिनट लगेगा )।

वैकल्पिक कार्यान्वयन केवल अंतर्निहित ÐṀत्वरित फ़िल्टर को न्यूनतम रखने का उपयोग करता है (जो यहां एक ही बाइट-काउंट के लिए प्रबंधन में थोड़ा उपरि जोड़ता है)।

Comments

ओह वाह। मैं इस तरह से कुछ करने की कोशिश कर रहा था, लेकिन अलग-अलग स्टोर करने की कोशिश करने के बजाय, सूची अनुक्रमित (सूची से उपयुक्त रूप से पैडिंग के माध्यम से) में वापस जाने के लिए मूल्यों को संग्रहीत करने की चाल से चूक गया। यह एक ट्रिक है जो अक्सर जेली में उपयोगी होती है और मैं हमेशा इसे मिस करने लगता हूं।

Answer 4

जेली , 11 बाइट्स

9Xœ|⁵ḶẊ¤ḣ¹Ḍ

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

9Xœ|⁵ḶẊ¤ḣ¹Ḍ  Main link. Argument: n

9            Set the return value to 9.
 X           Pick; pseudo-randomly select an integer from [1, ..., 9].
       ¤     Combine the three preceding links into a niladic chain.
    ⁵          Yield 10.
     Ḷ         Unlength; yield [0, ..., 9].
      Ẋ        Shuffle; pseudo-randomly select a permutation of [0, ..., 9].
  œ|         Multiset OR; prepend the selected integer to the selected permutation
             and remove the second occurrence of the first element.
         ¹   Identity; yield n.
        ḣ    Head; keep the first n digits of the permutation.
          Ḍ  Undecimal; convert from base 10 to integer.

Comments

डुप्लिकेट को हटाने का यह एक बहुत ही चालाक तरीका है ...

— लीक नून

Answer 5

जावास्क्रिप्ट (ईएस 6), 72 71 70 69 बाइट्स

f=(x,y="")=>x?!y.match(z=Math.random()*10|0)&&y|z?f(x-1,y+z):f(x,y):y

यह एक पुनरावर्ती कार्य है जो अंकों की संख्या x लेता है । दूसरा पैरामीटर y , शुरू में खाली स्ट्रिंग पर सेट होता है, अंक का ट्रैक रखता है क्योंकि हम इसे अंक द्वारा उत्पन्न करते हैं।

पहले हम साथ एक यादृच्छिक अंक z उत्पन्न करते हैं Math.random()*10|0। अब, हम यह जाँचना चाहते हैं कि y में z नहीं है और y और z दोनों 0 नहीं हैं ।

हम पहली शर्त के साथ गणना कर सकते हैं !y.match(z)। y.match(z)एक सरणी (हमेशा सत्य) देता है यदि y में z , null (झूठा) शामिल है अन्यथा; !यह एक बूलियन में धर्मान्तरित करता है और इसे निष्क्रिय कर देता है।

दूसरी स्थिति के साथ जाँच की जाती है y|z। यद्यपि y एक स्ट्रिंग है, JS उपयोग करते समय इसे एक पूर्णांक में रूपांतरित करता है |। यह एक सकारात्मक पूर्णांक है यदि y में पहले से ही अंक हैं, 0 अन्यथा। शुद्ध परिणाम यह है कि y|zरिटर्न 0 iff y खाली है और z है 0 , या एक सकारात्मक पूर्णांक अन्यथा।

यदि ये दोनों स्थितियां सत्य हैं, तो हम अंक को y , घटाव x से जोड़ते हैं , और फिर से प्रक्रिया शुरू करते हैं। अन्यथा, हम बस शुरुआत में लौटते हैं और आशा करते हैं कि अगला यादृच्छिक अंक काम करता है। जब x 0 पर पहुंचता है , तो हम पुनरावृत्ति को समाप्त करने के लिए खाली स्ट्रिंग लौटाते हैं।

---

पुराना वर्जन:

f=(x,y)=>x?~y>>(z=Math.random()*10|0)&1&&y|z?z+f(x-1,y|1<<z):f(x,y):""

यह एक पुनरावर्ती कार्य है जो अंकों की संख्या में होता है। शुरू में अपरिभाषित दूसरा पैरामीटर, y , एक 10-बिट लुकअप टेबल है, जो हमें बताती है कि हमारे पास कौन से अंक पहले से हैं, आसानी से एक पूर्णांक के रूप में संग्रहीत किया जाता है।

पहले हम साथ एक यादृच्छिक अंक z उत्पन्न करते हैं Math.random()*10|0। अब, हम यह जांचना चाहते हैं कि z 'का कम से कम महत्वपूर्ण बिट y सेट नहीं है, और यह y और z दोनों 0 नहीं हैं ।

हम पहली शर्त के साथ गणना कर सकते हैं ~y>>z&1; invert y , यह बदलाव z सही करने के लिए बिट्स, और केवल कम से कम महत्वपूर्ण बिट ले। यह 1 देता है यदि हमने अभी तक प्रश्न में अंक उत्पन्न नहीं किया है, या 0 अन्यथा।

दूसरी स्थिति शुरू में यह पता लगाना बहुत मुश्किल था (मैंने y/zपहली बार उपयोग करने की कोशिश की NaNअगर वे दोनों 0 हैं), लेकिन कुछ बिंदु पर मुझे एहसास हुआ कि बस y|zचाल चलेंगे। परिणाम है 0 दोनों iff y और z हैं 0 ; एक सकारात्मक पूर्णांक अन्यथा।

यदि ये दोनों स्थितियां सत्य हैं ( ~y>>z&1&&y|z), तो हम शेष संख्या और प्रीपेंड z उत्पन्न करते हैं । शेष संख्या को फ़ंक्शन को फिर से x-1और y|1<<z( y , लेकिन इंडेक्स z सेट 1 पर बिट के साथ) कॉल करके उत्पन्न किया जाता है । जब x 0 पर पहुंचता है , तो हम पुनरावृत्ति को समाप्त करने के लिए खाली स्ट्रिंग लौटाते हैं।

Answer 6

क्लोजुरस्क्रिप्ट, 81 79 बाइट्स

#(let[a(subvec(shuffle(range 10))0 %)](if(=(a 0)0)(recur %)(int(apply str a))))

यह एक अनाम फ़ंक्शन है, इसलिए आपको इसे इस तरह उपयोग करना होगा:

(#(...) {arguments})

जहां आप {arguments}अपने तर्कों से प्रतिस्थापित करते हैं।

आप यहाँ कोड (ClojureScript REPL) आज़मा सकते हैं ।

@cliffroot2 बाइट्स बंद करने के लिए धन्यवाद !

---

विस्तारित कोड:

(defn random-digits [n]
  (let [num-vector
        (subvec
          (shuffle (range 10))
          0 n)]
    (if (= (num-vector 0) 0)
      (recur n)
      (int (apply str num-vector)))))

---

स्पष्टीकरण:

मैं उदाहरण के इनपुट का उपयोग करके एक-एक करके लाइनों से गुजरने वाला हूं 8।

---

(defn random-digits [n] ...)

बहुत सरल, यह random-digitsएक तर्क के साथ फ़ंक्शन को परिभाषित करता है, जिसे कहा जाता है n। अपने उत्तर में मैंने #(...)बाइट्स को बचाने के लिए एक अनाम फ़ंक्शन ( ) का उपयोग किया ।

---

(let [num-vector ...] ...)

आइए अंदर से let, अंदर से बाहर की जाँच करें :

(shuffle (range 10))

ClojureScript (और Clojure) में, (range n)पायथन के लिए समान है range(n): यह आप से हर नंबर के साथ एक सूची प्रदान करती 0करने के लिए n - 1( 9इस मामले में)।

shuffleएक सूची लेता है, और अपने सभी तत्वों के फेरबदल के साथ एक वेक्टर (जो एक सूची से थोड़ा अलग होता है) देता है। इसलिए, हमारे उदाहरण का उपयोग करते हुए, हमें कुछ इस तरह मिलता है:

[1 0 8 3 6 7 9 2 4 5]

---

(subvec {see above} 0 n)

(subvec vector start end)एक वेक्टर (केवल एक वेक्टर) लेता है, और एक वेक्टर देता है जिसमें सूचकांक से सभी तत्व startहोते हैं end। इस मामले में, हम 0वें तत्व से दिए गए तर्क के लिए तत्व ले रहे हैं random-digits। यदि हम इसे हमारे उदाहरण पर लागू करते हैं, तो हमें यह मिलता है:

[1 0 8 3 6 7 9 2]

---

(if (= (num-vector 0) 0)
  (recur n)
  (int (apply str num-vector)))

यह ifकथन जाँचता है कि क्या पहला तत्व num-vectorए है 0।

यदि यह है 0, तो हम फ़ंक्शन को फिर से, तर्क के साथ n, उपयोग करके कॉल करते हैं recur।

यदि यह नहीं है 0:

---

(int (apply str num-vector))

(apply function list)एक सूची लेता है, और उन्हें तर्कों के रूप में कार्य करता है। उदाहरण के लिए:

(apply + [2 3 4])

में बदल जाता है:

(+ 2 3 4)

जो बराबरी का हो 9।

(str items)प्रत्येक आइटम itemsको एक स्ट्रिंग में बदल देता है , और फिर उन्हें संक्षिप्त करता है। intकिसी भी चीज को पूर्णांक में परिवर्तित करता है। इसलिए यदि हम इसे अपने उदाहरण पर लागू करते हैं, तो हमें यह मिलता है:

   (int (apply str [1 0 8 3 6 7 9 2]))
=> (int (str 1 0 8 3 6 7 9 2))
=> (int "10836792")
=> 10836792

जो हमारा अंतिम उत्तर है।

Comments

के (int string)बजाय अनुमति देने के लिए प्यार होगा ClojureScript (Integer/parseInt string):)

— cliffroot

@cliffroot मेरा मतलब है, आप क्लोजर में कर सकते हैं read-string, लेकिन यह ज्यादा बेहतर नहीं है ...

— क्लैसिकिक

2 बाइट्स बचाया #(let[a(subvec(shuffle(range 10))0 %)](if(=(a 0)0)(recur %)(int(apply str a))))चाल apply strअंत करने के लिए हिस्सा है, के लिए की तुलना कर सकते 0बजाय \0और का उपयोग करता है subvecके बजाय takeएक समारोह के रूप में उपयोग वेक्टर के लिए अनुमति देता है और इस तरह दूर करने के लिएfirst

— cliffroot

@cliffroot हुह, नहीं जानता था कि shuffleसंग्रह को एक में बदल दिया vec। धन्यवाद! हालांकि, एक नया स्पष्टीकरण लिखना होगा ...

— clismique

Answer 7

पायथन 2, 89 81 80 बाइट्स

from random import*
lambda n:choice([i for i in range(10**n)if`set(`i`)`[5*n:]])

इसे ऑनलाइन आज़माएं

Comments

मुझे नहीं लगता कि आपको रेंज के लिए स्टार्ट वैल्यू चाहिए।

— डेनिस

अच्छा! वह इसे धीमा कर देगा। : D बहुत बुरा मैं एक सूची के बजाय एक जनरेटर का उपयोग नहीं कर सकता।

— mbomb007

केवल 11% से। कोड गोल्फ के लिए एक बाल्टी में गिराएं।

— डेनिस

हाँ, मुझे उपयोग करना चाहिए 99**n, बस यह सुनिश्चित करने के लिए कि मैं उन सभी को प्राप्त कर लूँ। : D

— mbomb007

मैंने इसे इस तरह से भी देखा, लेकिन 80 का उपयोग करके मिला if`set(`i`)`[5*n:]]।

— जोनाथन एलन

Answer 8

आर, 45 बाइट्स

k=0
i=scan()
while(!k[1])k=sample(0:9)[1:i]
k

Comments

मुझे लगता है कि आप बस सेट कर सकते हैं k=0क्योंकि यह लंबाई का एक अंतर्निहित वेक्टर है, और आप एक नंबर के रूप में स्टैड से इनपुट लेने के लिए i = स्कैन () का उपयोग कर सकते हैं। मुझे यह भी यकीन नहीं है कि अंकों की एक सूची एक "सही" सबमिशन है, लेकिन मैं जज नहीं हूं।

— Giuseppe

@Giuseppe इनपुट के लिए धन्यवाद, आपके दोनों सुझाव (दोनों पदों पर) अपडेट किए, धन्यवाद।

— नील

while(!k[1])2 बाइट्स बचाने के लिए काम करेगा ?

— BLT

@BLT अपडेट किया गया, धन्यवाद।

— नील

Answer 9

बाश + GNU बर्तन, 46

seq 1e$[$1-1] 1e$1|egrep -v '(.).*\1'|shuf -n1

इसे ऑनलाइन आज़माएं ।

यह बड़े n के लिए एक लंबा समय लेता है - n = 7 के लिए लगभग 30s, और प्रत्येक वेतन वृद्धि के लिए 10 गुना बढ़ जाता है, इसलिए शायद n = 10 के लिए 8-9 घंटे।

Comments

प्रश्न के अनुसार, n = 10 को भी काम करने की आवश्यकता नहीं है, बहुत कम तेजी से हो

— ysth

Answer 10

जावा 7, 150 147 145 134 बाइट्स

String c(int n){String r="";for(int l,x;(l=r.length())<n;)if(l<1&(x=(int)(Math.random()*10))>0|(l>0&!r.contains(""+x)))r+=x;return r;}

-2 बाइट्स के लिए धन्यवाद @TheLethalCoder

(पुराना) स्पष्टीकरण:

String c(int n){                           // Method with integer parameter and String return-type
  String r="";                             //  Result-String
  for(int l=0,x;l<n;l=r.length()){         //  Loop until the length of the result-String is equal to the parameter integer
    x=new java.util.Random().nextInt(10);  //   Random digit
    if((l<1&x>0)                           //   If the length is zero and the random digit is not zero
       |(l>0&!r.contains(""+x)))           //     or the length is at least 1, and the result-String does not contain this random digit yet
      r+=x;                                //    Append the random digit to the result-String
  }                                        //  End of for-loop
  return r;                                //  Return result-String
}                                          // End of method

टेस्ट कोड:

इसे यहाँ आज़माएँ।

class M{
  String c(int n){String r="";for(int l,x;(l=r.length())<n;)if(l<1&(x=(int)(Math.random()*10))>0|(l>0&!r.contains(""+x)))r+=x;return r;}

  public static void main(String[] a){
    M m = new M();
    System.out.println(m.c(4));
    System.out.println(m.c(10));
  }
}

उदाहरण आउटपुट:

7194
8672953041

Comments

क्या आप यहां लंबोदर अभिव्यक्ति का उपयोग नहीं कर सकते ? यानी n->...या कि जावा 8+?

— TheLethalCoder

आप मेरे द्वारा उपयोग किए गए ट्रिक को भी उधार ले सकते हैं, तुलना चेक में लंबाई सेट करें for(int l,x;(l=r.length())<n;)और आपको एक बाइट बचानी चाहिए।

— TheLethalCoder

@TheLethalCoder आह, धन्यवाद। महान टीम वर्क! ;) और हाँ, n->...जावा 8 है। व्यक्तिगत रूप से मैं जावा 7 में कोडगोल्फ को पसंद करता हूं, भले ही 8 हमेशा छोटा हो।

— केविन क्रूज़सेन

Answer 11

पर्ल 6 , 44 बाइट्स

{(->{+[~] (^10).pick($_)}...*>9 x$_-1).tail}

कोशिश करो

विस्तारित:

{  # bare block with implicit parameter ｢$_｣
  (

    ->{  # pointy block lambda with no parameters

      +                # turn the following into a numeric
      [~]              # concatenate the following

        (^10).pick($_) # grab $_ digits at random from 0..9
    }

    ...                # keep doing that until

    * > 9 x $_-1       # one of them is big enough

  ).tail # return the last one (only valid one)
}

Answer 12

PHP, 67 बाइट्स

ऑनलाइन संस्करण

सभी संस्करण 0-9 से अंकों में फेरबदल करते हैं

for($a=range(0,9);!$a[0];)shuffle($a);for(;$i<$argn;)echo$a[+$i++];

71 बाइट्स

for($s="0123456789";!$s[0];)$s=str_shuffle($s);echo substr($s,0,$argn);

73 बाइट्स

for($a=range(0,9);!$a[0];)shuffle($a);echo join(array_slice($a,0,$argn));

Answer 13

MATL , 15 बाइट्स

`4Y2GZr1)48=]8M

MATL ऑनलाइन पर यह कोशिश करो !

व्याख्या

`        % Do...while
  4Y2    %   Push predefined literal '0123456789'
  G      %   Push input n
  Zr     %   Random sample of n unique characters from that string
  1)     %   Pick the first
  48=    %   Is it 48? This is the loop condition
]        % End. If top of the stack evaluates to true: next iteration
8M       % Push the latest random sample. Implicitly display

Answer 14

जेली , 12 बाइट्स

9×!X+!Œ?’ḣƓḌ

वर्तमान में मेरे अन्य जेली उत्तर के पीछे एक बाइट, लेकिन मुझे वास्तव में यह पसंद है।

इसे ऑनलाइन आज़माएं!

यह काम किस प्रकार करता है

9×!X+!Œ?’ḣƓḌ  Main link. No arguments.

9             Set the argument and the return value to 9.
  !           Yield 9!
 ×            Compute 9 × 9!.
   X          Pick; pseudo-randomly select an integer j from [1, ..., 9 × 9!].
     !        Yield 9!
    +         Compute k := j + 9!.
              The result will belong to [9! + 1, 10!].
      Œ?      Get the permutation P of R := [1, ..., r], with minimal r, such that
              P is the lexicographically k-th permutation of R.
              Since k belongs to [9! + 1, 10!], r = 10 and this generates a per-
              mutation between [2,1,3,4,5,6,7,8,9,10] and [10,9,8,7,6,5,4,3,2,1].
        ’     Subtract 1 from all integers in P.
          Ɠ   Read an integer n from STDIN and yield it.
         ḣ    Head; keep the first n digits of the permutation.
           Ḍ  Undecimal; convert from base 10 to integer.

Answer 15

एपीएल (डायलॉग) , 27 19 17 बाइट्स

⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है।

10⊥⊢↑{?⍨10}⍣{×⊃⍺}

इसे ऑनलाइन आज़माएं!

मान्य होने तक अंकों को फेरबदल करें:

10⊥ आधार -10 अंकों से नियमित संख्या तक डिकोड,

⊢ फिर

↑ के पहले तत्व

{... }⍣{... } फ़ंक्शन को दोहराते हुए ...
 ?⍨10 पहले दस पॉजिटिव पूर्णांक
तक फेरबदल करें ...
 ⊃⍺ आखिरी प्रयास
 × का पहला अंक पॉजिटिव है

Answer 16

पायथन 2 , 100 93 92 90 बाइट्स

2 बाइट्स बंद करने के लिए @ mbomb007 का धन्यवाद

from random import*
def f(n):k=randint(10**~-n,10**n-1);return(n==len(set(`k`)))*k or f(n)

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

Comments

return(n==len(set(`k`)))*k or f(n)। इसे ऑनलाइन आज़माएं

— mbomb007

Answer 17

अजगर , 11 बाइट्स

jk<{+OS9.ST
jk<{+OS9.STQ implicit Q

       9     9
      S      [1,2,3,4,5,6,7,8,9]
     O       random element

          T  10
        .S   random permutation of [0,1,2,3,4,5,6,7,8,9]

    +        add the results from the previous two paragraphs together
   {         deduplicate
  <        Q first (input) elements
jk           join by empty string

डेनिस के उत्तर के समान एल्गोरिथ्म का उपयोग करता है ।

इसे ऑनलाइन आज़माएं!

Answer 18

पर्ल, 48 बाइट्स

1until$_=1+int rand 10**$n-1,/.{$n}/&&!/(.).*\1/

स्पष्टीकरण:

बार-बार 1 से 10 ** $ n-1 से यादृच्छिक पूर्णांक उत्पन्न करते हैं, जब तक कि कोई दोहराया अंकों के साथ सही लंबाई (इसलिए कम से कम 10 ** ($ n-1)) में से एक होने तक उन्हें अस्वीकार न करें।

Answer 19

बैच, 156 बाइट्स

@set/af=9,r=x=0
@for /l %%i in (1,1,%1)do @call:c
@echo %r%
@exit/b
:c
@set/a"d=9-%random%%%f,e=x>>d&1
@if %e%==1 goto c
@set/a"r=r*10+d,f=10,x|=1<<d

xउपयोग किए गए अंकों का एक बिटमैप बनाए रखता है। fउपलब्ध अंकों की संख्या (9 से नीचे की गिनती) को इंगित करता है। जब तक अप्रयुक्त अंक नहीं मिलता है, तब तक यादृच्छिक अंक उत्पन्न होते हैं। n=10165 बाइट्स के लिए समर्थित किया जा सकता है:

@set/af=9,r=x=0
@for /l %%i in (1,1,%1)do @call:c
@echo %r:~1%
@exit/b
:c
@set/a"d=9-%random%%%f,e=x>>d&1
@if %e%==1 goto c
@set r=%r%%d%
@set/a"f=10,x|=1<<d

( rइसमें एक अतिरिक्त अग्रणी शून्य होता है क्योंकि यह इस तरह से गोल्फर है।) 165 बाइट्स के लिए पिछला दृष्टिकोण विशेष अंकन के लिए पहला अंक है, और इसके साथ काम करने के लिए भी हुआ n=10(संख्यात्मक संस्करण वास्तव में 166 बाइट्स लिया है!):

@set/ar=%random%%%9+1,x=0
@for /l %%i in (2,1,%1)do @set/a"x|=1<<d"&call:c
@echo %r%
@exit/b
:c
@set/a"d=%random%%%10,e=x>>d&1
@if %e%==1 goto c
@set r=%r%%d%

170 बाइट्स के लिए मूल दृष्टिकोण के लिए भी काम किया n=10:

@set/ar=%random%%%9+1
@for /l %%i in (2,1,%1)do @call:c
@echo %r%
@exit/b
:c
@set/ad=%random%%%10
@call set s=%%r:%d%=%%
@if not "%s%"=="%r%" goto c
@set r=%r%%d%

डुप्लिकेट अंकों का पता लगाने के लिए स्ट्रिंग हेरफेर का उपयोग करता है।

Answer 20

बैश , 66 बाइट्स

a=0;while [[ $a == 0* ]];do a=`shuf -i0-9 -n$1|xargs`;done;echo $a

इसे ऑनलाइन आज़माएं!

सीधे आगे, सूफों का उपयोग करता है, xargs का उपयोग लाइनों में शामिल होने के लिए किया जाता है और प्रयास करना जारी रखता है जबकि संयोजन 0 से शुरू होता है।

खिचड़ी भाषा ने अन्य उत्तर से ४६ चार को हरा दिया, लेकिन इस प्रकार वह तेज़ है!

Answer 21

पायथ, 15 28 बाइट्स

=+YhO9VtQ#KOTI!hxYK=+YKB;jkY

इसे यहाँ आज़माएँ

Comments

PPCG में आपका स्वागत है, और अच्छा काम सही बल्ले से एक गोल्फ भाषा का प्रयोग :-) मैं 2 छोटे मुद्दों देखें: 1) ऐसा लगता है कि दूसरा अंक हमेशा होता है 0, इसलिए मुझे लगता आप परिवर्तन करना चाहते हैं ^TttQके लिए ^TtQ(-1 बाइट, बोनस!)। 2) आउटपुट में सभी अंक अद्वितीय होने चाहिए, ताकि आपको किसी भी तरह से मजबूर होना पड़े।

— ETHproductions

@ETHproductions अर्ग !! यह बात बताने के लिए धन्यवाद। मैंने इसे ठीक कर लिया है।

— मारिया

Answer 22

सी #, 127 132 128 126 126 125 बाइट्स

n=>{var s="";for(int l,r;(l=s.Length)<n;)if((l<1&(r=new System.Random().Next(10))>0)|(l>0&!s.Contains(r+"")))s+=r;return s;};

यह ऑनलाइन की कोशिश करो!

2 बाइट्स बचाने के लिए , बयान में @ केविनक्रूजसेन के यादृच्छिक को शुरू करने के जवाब से विचार को उधार लिया गया ।rif

बहुत यकीन है कि यह आगे गोल्फ हो सकता है लेकिन मेरे पास इस समय नहीं है।

---

एक whileलूप का उपयोग करके पुराना संस्करण :

n=>{var s="";while(s.Length<n){int r=new System.Random().Next(10);if(s.Length<1&r>0)s+=r;else if(!s.Contains(r+""))s+=r;}return s;};

Comments

मुझे नहीं लगता कि यह सही है। चलो का कहना है कि पहले यादृच्छिक पूर्णांक है 0, यह पहली कोशिश करेंगे if(s.Length<1&r>0)जो गलत है, लेकिन फिर यह करना होगा if(!s.Contains(r+""))जो सच है और अभी भी संलग्न "0"करने के लिए sप्रथम अंक के रूप।

— केविन क्रूज़सेन

@KevinCruijssen फिक्स्ड और आगे गोल्फ

— TheLethalCoder

@KevinCruijssen आह मैंने इसे बाहर काम किया है, आपके उदाहरण में आप .Next(10)एक के साथ ... अंत नहीं करते हैं ;। तो वहाँ कोई और सुधार, लेकिन अच्छा विचार है।

— TheLethalCoder

मैंने अभी इसे पोस्ट किया है। और उफ़, आप सही कह रहे हैं कि मैं अर्ध- n=>{var s="";for(int l=0,r;l<n;l=s.Length)if((l<1&(r=new System.Random().Next(10))>0)|(l>0&!s.Contains(r+"")))r+=x;return s;};

— उपनिवेश से

@ केविनक्रूजसेन मैंने आपके उत्तर से विचार उधार लिया था जैसा कि आप उस टिप्पणी को लिख रहे थे! अच्छा सुधार धन्यवाद

— TheLethalCoder

Answer 23

C (gcc) , 123 122 100 95 104 103 99 97 बाइट्स

यह एक वास्तविक यादृच्छिक संख्या उत्पन्न करता है

j;f(n){for(int i,k=n,s[10]={j=0};n;s[i+=i?0:k==n]=!s[i]?j+=i*pow(10,--n):1)i=rand()%10;return j;}

इसे ऑनलाइन आज़माएं!

सी (जीसीसी) , 87 85 बाइट्स

यहाँ यह अंकों की एक स्ट्रिंग छाप रहा है।

f(n){for(int i,k=n,s[10]={0};n;s[i+=i?0:k==n]=!s[i]?--n,putchar(48+i):1)i=rand()%10;}

इसे ऑनलाइन आज़माएं!

Answer 24

PHP, 65 63 बाइट्स

while(count(count_chars($x=rand(1,10**$argn),1))<$argn);echo$x;

STDIN से इनपुट लेता है; साथ चलाना -nR।

1और 10^Nसमावेशी के बीच यादृच्छिक संख्या बनाएं ;
अलग-अलग वर्णों की गिनती करते हुए दोहराएं < N।

Comments

while(count(count_chars($x=rand(1,10**$argn),1))<$argn);echo$x;-2 बाइट्स

— जॉर्ग हुल्सरमैन

Answer 25

गणितज्ञ 65 60 बाइट्स

0For[a=11,Max@DigitCount@a>1,a=RandomInteger[10^{#-1,#}]]+a&

यहाँ एक तेज़ संस्करण है लेकिन 9 बाइट्स जोड़ता है:

FromDigits@Join[f=(s=RandomSample)[r=Range@9,1],s[r/.f[[1]]->0,#-1]]&

Answer 26

जावा 9 JShell, 86 बाइट्स

n->new Random().longs(0,10).limit(n-1).reduce(new Random().nextInt(9)+1,(a,b)->a*10+b)

इसे ऑनलाइन आज़माएं!

ध्यान दें: मैं उन आयातों की गिनती नहीं कर रहा हूँ, क्योंकि उन पैकेजों को JShell में डिफ़ॉल्ट रूप से आयात किया जाता है, लेकिन कोई भी ऐसा ऑनलाइन प्रयास नहीं है जो मुझे JShell के लिए पता हो, इसलिए मैंने शीर्ष लेख और पाद लेख कोड के साथ Java 9 के लिए एक प्रदान किया है उस संदर्भ में काम करें। JShell में आप बस कर सकते हैं:

jshell> Function<Integer,Long> f =
   ...> n->new Random().longs(0,10).limit(n-1).reduce(new Random().nextInt(9)+1,(a,b)->a*10+b)
f ==> $Lambda$27/633070006@5702b3b1

और तब:

jshell> f.apply(6)
$26 ==> 746202

यह काम किस प्रकार करता है:

हम इंटगर से लॉन्ग तक के एक फंक्शन को परिभाषित करते हैं और 0-9 से रेंज में रैंडम लॉन्ग की अनंत धारा बनाते हैं, इसे पहले n-1 आइटम तक सीमित करते हैं, फिर प्रारंभिक मान के रूप में इसे 1-9 से रैंडम इंट के साथ घटाते हैं और एक फ़ंक्शन जो मान को 10 से गुणा करता है और स्ट्रीम से अगला मान जोड़ता है।

मैंने लोंगो का उपयोग किया इसलिए यह लगभग 18 अंकों (n = 18) तक काम करना चाहिए।

Answer 27

सी, 96 93 बाइट्स

f(n){char d[11],i=0,r;for(;i++^10;d[i-1]=d[r=rand()%i],d[r]=47+i);*d^48?d[n]=0,puts(d):f(n);}

फिशर-येट्स ने शुरुआती अंक शून्य होने तक फेरबदल किया।

एकसमान है, मान rand()%iलेना एकसमान है। (चूंकि अधिकांश के लिए मैं RAND_MAX/iएक छोटे से शेष को छोड़ता हूं , एक बहुत छोटा पूर्वाग्रह है। यह पूर्वाग्रह RAND_AX के बड़े होने से छोटा होता है।)

इसे ऑनलाइन देखें ।

जब यह प्रश्न में दिखाया गया है, तो n 2 के बराबर होने पर सही संख्या उत्पन्न करना देखें ।

Answer 28

Axiom, 191 बाइट्स

g(a:NNI):Complex INT==(a<1 or a>9=>%i;r:List NNI:=[];b:=a;repeat(a=0=>break;d:=random()$INT rem 10;a=b and d=0=>0;~member?(d,r)=>(a:=a-1;r:=cons(d,r)));reduce(+,[r.i*10^(i-1)for i in 1..#r]))

यह ungolf, परीक्षा परिणाम

-- Return one number of 'a' different random digits if 0<a<10
f(a:NNI):Complex INT==
    a<1 or a>9=>%i
    r:List NNI:=[];b:=a
    repeat
       a=0=>break
       d:=random()$INT rem 10
       a=b and d=0  =>0
       ~member?(d,r)=>(a:=a-1;r:=cons(d,r))
    reduce(+,[r.i*10^(i-1)for i in 1..#r])

(4) -> [[i,g(i)] for i in 0..10]
   (4)
   [[0,%i], [1,9], [2,76], [3,135], [4,6810], [5,48675], [6,415768],
    [7,7461539], [8,98421537], [9,825046739], [10,%i]]
                                          Type: List List Complex Integer
(5) -> [[i,g(i)] for i in [3,3,3,3,3,3,3,3,3]]
   (5)
   [[3,653],[3,128],[3,254],[3,268],[3,914],[3,594],[3,276],[3,240],[3,398]]

Answer 29

जेलिफ़िश , 17 बाइट्स

p
d^u ?
 j?r10
10

इसे ऑनलाइन आज़माएं!

डेनिस के जेली का जवाब फोर्क ।

Answer 30

रूबी, 53 52 बाइट्स

जब तक पहला अंक 0 न हो, तब तक फेरबदल करें, फिर अंकों को मिलाएं और पूर्णांक में बदलें।

->n{a=*0..9;a.shuffle!while a[0]==0;eval a[0,n]*''}

इसे ऑनलाइन आज़माएं!