संख्याओं को याद रखना आसान है


41

संख्याएँ जिन्हें याद रखना आसान है, फिर भी सैद्धांतिक रूप से आसानी से नहीं बनती

आपकी चुनौती किसी भी भाषा में एक कार्यक्रम / कार्य करना है जो समान रूप से यादृच्छिक संख्या उत्पन्न करता है जो इन मानदंडों को फिट करता है:

  1. लंबाई है 5 अंक

  2. दो अलग-अलग दोहराया अंक जोड़े हैं

  3. दोहराया अंकों का एक सेट शुरुआत या अंत में है और अंक एक दूसरे के बगल में हैं

  4. विषम संख्या अंक दूसरी जोड़ी अंकों से घिरा हुआ है

  5. दो अंकों की जोड़ी और दूसरी संख्या सभी अद्वितीय होनी चाहिए

  6. आपका कार्यक्रम आपके विवेक पर अग्रणी शून्य या नहीं के साथ संख्याओं का समर्थन कर सकता है। यदि अग्रणी शून्य का समर्थन किया जाता है, तो उन्हें आउटपुट में शामिल किया जाना चाहिए: 06088, 6088 नहीं। यदि अग्रणी शून्य समर्थित नहीं हैं, तो 06088 जैसे नंबर बिल्कुल भी उत्पन्न नहीं होने चाहिए।

परीक्षण के मामलों

स्वीकृत आउटपुट:

55373
55,494
67,611
61,633
09,033
99,757
95,944
22808
65,622
22,161

स्वीकृत आउटपुट नहीं:

55555
77,787
85,855
12345
99,233
12131
abcde
5033

इस पेस्टबिन लिंक पर अधिक स्वीकार्य परीक्षण मामले पाए जा सकते हैं ।

इस अजगर कार्यक्रम के साथ ये बनाए गए थे:

यादृच्छिक आयात करें
i for रेंज (100):

    अगर random.randint (0,100)> = 50: # सही जोड़ी शुरुआत में अगर सच है तो
        temp = [] #working सरणी
        temp.append (random.randint (0,9)) #append random डिजिट
        temp.append (अस्थायी [0]) # उसी अंक को फिर से भेजें

        x = random.randint (0,9)
        जबकि x == अस्थायी [0]:
            x = random.randint (0,9)
        temp.append (x) # दूसरा अनूठा अंक

        y = random.randint (0,9)
        जबकि y == अस्थायी [0] या y == अस्थायी [2]:
            y = random.randint (0,9)
        temp.append (y) #append एक और अद्वितीय अंक, और पिछले अद्वितीय अंक
        temp.append (एक्स)

    और: # अंत में जोड़ी को छूने
        temp = [] #working सरणी  
        temp.append (random.randint (0,9)) #append random डिजिट

        # अद्वितीय नहीं है, फिर से प्रयास करें
        x = random.randint (0,9)
        जबकि x == अस्थायी [0]:
            x = random.randint (0,9)
        temp.append (x) # दूसरा अनूठा अंक


        temp.append (अस्थायी [0]) # वही 0th अंक फिर से भेजें


        y = random.randint (0,9)
        जबकि y == अस्थायी [0] या y == अस्थायी [1]:
            y = random.randint (0,9)
        temp.append (y) # अद्वितीय दो बार एक और अंक
        temp.append (y)

    tempstr = ""
    मैं अस्थायी में:
        tempstr + = str (i)
    टेंपरेचर प्रिंट करें

यह , इसलिए बाइट्स में सबसे कम जवाब जीतता है!


5
मेरा सुझाव है कि "सत्यवादी" और "मिथ्या" की तुलना में "संभावित आउटपुट (संभावना> 0)" और "संभव नहीं है (संभावना = 0)" के बजाय - मुझे लगता है कि आप क्या पूछ रहे हैं (और पायथन के साथ) के अनुरूप अधिक लगता है )।
खुल्द्रेसथ न'बर्या

9
क्या हमें एक प्रमुख शून्य के साथ 09033 जैसा आउटपुट प्रिंट करना है?
xnor

3
यदि संभावना एकसमान है, तो क्या आप इसे प्रश्न में निर्दिष्ट कर सकते हैं। डिफ़ॉल्ट रूप से, randomसमान रूप से इसका मतलब नहीं है
जो किंग

3
शायद 99233 को जोड़ने के लिए, संयोजक को समझने के लिए
l4m2

3
PPCG में आपका स्वागत है! अच्छी पहली चुनौती।
जोनाथन एलन

जवाबों:


21

05AB1E , 11 बाइट्स

žh.r3£ûÁÂ)Ω

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

व्याख्या

žh            # push "0123456789"
  .r          # random shuffle
    3£        # take the first 3
              # EX: 152
      û       # palendromize
              # EX: 15251
       Á      # rotate right
              # EX: 11525
        Â)    # pair with its reverse
              # EX: [11525, 52511]
          Ω   # pick one at random

मुझे आश्चर्य है कि अगर Emigna हा ... शीर्ष उत्तर +1 देखता है
मैजिक ऑक्टोपस Urn

9

CJam (16 बाइट्स)

YmrG*98+ZbA,mrf=

ऑनलाइन डेमो

नोट: मैंने माना है कि "अद्वितीय" ओपी से वास्तव में "अलग" का अर्थ है।

16 बाइट्स के लिए भी:

98ZbA,mrf=W2mr#%
98ZbA,mrf=_W%]mR

विच्छेदन

Ymr    e# Select a random number from [0 1]
G*98+  e# Multiply by 16 and add 98 to get 98 or 114
Zb     e# Base conversion in base 3 to get [1 0 1 2 2] or [1 1 0 2 0]
A,mr   e# Shuffle the numbers from 0 to 9
f=     e# Map "select the item at this index"

अन्य वेरिएंट का उपयोग करके उत्पन्न होता है [1 0 1 2 2]और फिर परिणाम या इसके रिवर्स का चयन करें।


9

पर्ल 5 , 81 63 56 बाइट्स

@DomHastings से प्रेरणा लेकर 7 बाइट्स काटें

उपयुक्त पैटर्न से संख्या का निर्माण।

@q{0..9}++;say+(keys%q)[.5>rand?(2,2,0,1,0):(0,1,0,2,2)]

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


पर्ल 5 , 89 बाइट्स

यादृच्छिक 5 अंकों की संख्या तब तक प्राप्त करता है जब तक कि यह एक ऐसा मानदंड नहीं मिल जाता है।

$_=sprintf'%05d',0|rand 1E5until(/(.)\1(.)(.)\2/||/(.)(.)\1(.)\3/)&&$1-$2&$2-$3&$1-$3;say

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


यादृच्छिकता के लिए हैश कुंजी का उपयोग करके अच्छी चाल! मुझे लगता है कि यह -8 के लिए बराबर है, हालांकि मैं एक किनारे के मामले को याद कर सकता हूं ... इसे ऑनलाइन आज़माएं!
डोम हेस्टिंग्स

1
हैश रैंडमाइजेशन। प्रतिभाशाली! छोटा
टन हास्पेल

सवाल यह है कि time%2उपयोगकर्ता के नियंत्रण में, एक अर्थ में, पर्याप्त रूप से यादृच्छिक है या नहीं ।
Xcali

@ एक्सकाली यह सर्वसम्मति प्रतीत होती है कि यह तब तक ठीक है जब तक आप केवल एक बार इसका उपयोग करते हैं, इसलिए मुझे लगता है कि आपको अच्छा होना चाहिए।
FryAmTheEggman

8

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

from random import*
a,b,c=sample(range(10),3)
print[a,a,b,c,b][::choice((-1,1))]

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

अंकों की सूची को आउटपुट करता है।

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

from random import*
a,b,c=sample('0123456789',3)
print(a*2+b+c+b)[::choice((-1,1))]

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

आउटपुट एक संख्या है।


यदि डिफ़ॉल्ट रूप से गैर-समान यादृच्छिकता की अनुमति है (प्रश्न निर्दिष्ट नहीं करता है), तो आप उल्टेपन को भी नमूना करके बाइट्स को बचा सकते हैं: इसे ऑनलाइन आज़माएं! संपादित करें: कोई बात नहीं, मुझे लगता है कि एकरूपता कल्पना में संपादित की गई थी। मुझे आश्चर्य है कि अगर इस दृष्टिकोण को अभी भी बचाया जा सकता है।
xnor

7

एपीएल (डायलॉग यूनिकोड) , 22 21 20 18 17 बाइट्स

(3∨?2)⌽1↓,∘⌽⍨3?10

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

यदि यह हमेशा एक ही प्रारूप में संख्याओं को आउटपुट करने के लिए स्वीकार्य है, तो इसे 12 बाइट्स 1⌽1↓,∘⌽⍨3?10या तो छोटा किया जा सकता है या 3⌽1↓,∘⌽⍨3?10

अनावश्यक को हटाकर एक बाइट को बचाया

H.PWiz के लिए एक बाइट धन्यवाद सहेजा गया, और फिर उनके टिप के कारण 2 और बाइट्स।

Ngn के लिए एक बाइट धन्यवाद बचाया।

फ़ंक्शन मानता है ⎕IO←0( I ndex O rigin)।


कैसे?

(3∨?2)⌽1↓,∘⌽⍨3?10  Anonymous function.
              3?10   Deal 3 (distinct) random numbers from 0 to 9. (Assume 1 2 3)
                   Use that as both arguments for:
          ,∘⌽       Rotate (⌽), then concatenate (,).
                    Yields 3 2 1 1 2 3.
        1          Drop the first element. Our vector is now 2 1 1 2 3
                   Rotate the vector to the left using as argument:
(  ?2)              Roll 0 or 1 and...
 3                 Do the GCD between 3 and the result. (30=3; 31=1.)
                    This yields either 1 1 2 3 2 or 2 3 2 1 1.

इनपुट नहीं दिया जा सकता है
ड्राम

@drham फ़ंक्शन का कोई इनपुट नहीं है। इस स्थिति में, TIO फ़ील्ड Inputका उपयोग फ़ंक्शन को कॉल करने के लिए किया जाता है g। इसके अलावा, g←बाइट गिनती में नहीं गिना जाता है क्योंकि यह आवश्यक नहीं है, इसका उपयोग केवल फ़ंक्शन को कॉल करने के लिए किया जा रहा है।
जे। सेले

तथ्य यह gहै कि इनपुट अनुभाग में कहा जाता है कि एपीएल
टीआईओ

(4∨?2)एक बाइट बचाता है1 4[?2]
H.PWiz

1
fट्रेन से जाने और उपयोग न करने से भी आप बाइट बचा सकते हैं । मैं आपको छोड़ दूँगा, हालाँकि :)
H.PWiz

6

जावा 8, 145 136 125 119 बाइट्स

v->{String r;for(;!(r=(int)(Math.random()*1e5)+"").matches("((.).?\\2){2}")|r.chars().distinct().count()<3;);return r;}

-9 बाइट्स का धन्यवाद @ ओलिवियरग्रेगायर।
-11 बाइट्स @RickHitchcock की बदौलत
-6 के लिए धन्यवाद बाइट्स @Nevay

स्पष्टीकरण:

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

v->{            // Method with empty unused parameter and String return-type
  String r;     //  Result-String
  for(;!(r=(int)(Math.random()*1e5)+"")
                //  Generate a random number in the range [0; 100000) and set it to `r`
        .matches("(.).*\\1(.).*\\2")
                //   And continue doing this as long as it doesn't match the regex above,
       |r.chars().distinct().count()<3;);
                //   or doesn't have three distinct digits
  return r;}    //  Return the result


@ OlivierGrégoire क्या आपने इसे सही चुनौती पर पोस्ट किया? ..: S यह परिचित दिखता है, लेकिन यह निश्चित रूप से यह चुनौती नहीं है ..
केविन क्रूज़सेन

थोड़ी सी बात ने मेरा लिंक तोड़ दिया ... वैसे भी, यहाँ गोल्फ है:v->{String r="";for(;!r.matches("(.)\\1(.).\\2|(.).\\3(.)\\4")|r.chars().distinct().count()!=3;r=(int)(Math.random()*1e5)+"");return r;}
ओलिवियर ग्राईगोइरे

1
मुझे लगता है कि (.).*\\1(.).*\\211 बाइट की बचत से आपके रेगेक्स को छोटा किया जा सकता है ।
रिक हिचकॉक

1
119 बाइट्स:v->{String r;for(;!(r=(int)(Math.random()*1e5)+"").matches("((.).?\\2){2}")|r.chars().distinct().count()<3;);return r;}
नेवय

5

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

⁵Ḷṗ3⁼Q$ÐfXµḢ;`;ŒBW;U$µX

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


अच्छा, मैं upvote, लेकिन मैं नहीं कर सकता
ड्राम

7
@ दधम :) धन्यवाद। आपको जल्द ही सक्षम होना चाहिए, एक बार जब अधिकांश सक्रिय सदस्य आपके प्रश्न को जगाते हैं, तो शायद आपको बहुत अधिक उत्थान मिलेगा। अच्छी पहली चुनौती और वैसे PPCG में आपका स्वागत है!
हाइपरनेत्रिनो

5

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

ØDẊ⁽0yṃ,U$X

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


व्याख्या


ØDẊ⁽0yṃ,U$X    Niladic link, generate a random string.
ØD             List of digits, ['0','1','2',...,'9'].
  Ẋ            Random shuffle.
   ⁽0y         Number 13122.
      ṃ        Base decompression. (*)
       ,U$     Pair with its upend (reverse).
          X    Choose one (it or its reversed) randomly.

(*) का सही तर्क है सूची ['0','1','2',...,'9'], बेतरतीब ढंग से फेरबदल, 10 तत्व हैं। इसलिए संख्या 13122को जीवनात्मक आधार 10 ( [1,3,1,2,2]) और सूची में अनुक्रमित किया जाएगा (इसलिए यदि सूची है l, तो परमाणु का वापसी मूल्य है [l[1],l[3],l[1],l[2],l[2]], जहां जेली 1-आधारित अनुक्रमण का उपयोग करती है)


(05AB1E उत्तर के रूप में एक ही विचार, स्वतंत्र रूप से सामने आया)
user202729

... 05AB1E जेली को टाई करने में सक्षम होने के कारण 6 अपवोट्स प्राप्त करता है, 05AB1E जीतने में असमर्थ होने के कारण जेली केवल 2 अपवोट प्राप्त करता है?
user202729

2
मैंने आपके उत्तर को गलत बताया। -> SPEECH 100 <---
L_Church

4

जावास्क्रिप्ट (ईएस 6), 79 बाइट्स

f=([,,d,a,b,c]=[...Math.random()+f])=>a-b&&a-c&&b-c?d&1?a+a+b+c+b:b+c+b+a+a:f()

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

कैसे?

Math.random()[0..1) में एक यादृच्छिक फ्लोट देता है । हम +fएक स्ट्रिंग के लिए जबरदस्ती का उपयोग करते हैं । हम अग्रणी शून्य और दशमलव बिंदु को अनदेखा करते हैं [,,( कुछ भी नहीं करने के लिए पहले दो वर्णों के विनाशकारी कार्य ) और पहले 4 दशमलव अंकों को डी , , बी और सी में इकट्ठा करते हैं ।

यदि a , b और c 3 अलग-अलग पूर्णांक हैं, तो हम AABCB या BCBAA प्रारूप में अंतिम आउटपुट का निर्माण करते हैं ( निर्णय लेने के लिए d की समता का उपयोग करके )। अन्यथा, हम फिर से कोशिश करते हैं जब तक वे हैं।

Math.random()पर्याप्त दशमलव स्थानों के बिना एक मूल्य वापस करने की अत्यधिक अनुचित घटना में , कम से कम सी को एक गैर-अंक वर्ण पर सेट किया जाएगा, जिससे परीक्षण विफल हो जाएगा और पुनरावर्ती कॉल हो सकती है। यदि a , b और c मान्य पूर्णांक हैं, तो d को एक मान्य पूर्णांक होने की गारंटी है, इसलिए इस परीक्षण की आवश्यकता नहीं है।


दोनों &&हो सकते हैं &। इसके अलावा, कैसे [,,a,b,c,d]काम करता है ? मैंने पहले जैसा इनपुट कभी नहीं देखा है [,,
केविन क्रूज़सेन

1
@KevinCruijssen एक बिटवाइज़ और a=4, b=2, c=1क्योंकि इसके लिए उदाहरण के लिए असफल होगा 4-2&4-1&2-1 == 2&3&1 == 0। मैंने चर असाइनमेंट के बारे में एक संक्षिप्त विवरण जोड़ा है।
अरनौलद

आह। मैं बस की कोशिश की &&करने के लिए &TIO में और यह सही आउटपुट दे दी है, तो मैं मान लिया है यह संभव था। के &बजाय एहसास नहीं था &&बाहर फिल्टर होगा अन्यथा वैध आउटपुट। और विनाशकारी असाइनमेंट के बारे में अतिरिक्त स्पष्टीकरण के लिए धन्यवाद, इसे पहले कभी नहीं देखा।
केविन क्रूज़सेन

यह सिर्फ भयानक +1 है
लुइस फेलिप डी जीसस मुनोज


2

गंदा , 33 बाइट्स

--numeric-outputध्वज का उपयोग करता है, इसलिए यह पठनीय है, अन्यथा यह अंकों के अनुरूप कोड-पॉइंट के साथ नियंत्रण वर्णों की एक स्ट्रिंग को आउटपुट करेगा।

10⭧[1w#%D⅋№3⤱≠1ẅ&]1wẂ⭿⭣1u∅#1∧◌ŪW‼

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

व्याख्या की:

10⭧              put 10 on the right stack
[1w#%D⅋№3⤱≠1ẅ&] loop until there are 3 distinct positive numbers below 10 in the top stack
1wẂ              clean-up the right and top stacks
⭿               copy the top and bottom of the top stack to each-other
⭣                swap the first two elements of the top stack
1u               rotate the top stack by 1
∅#1∧◌ŪW          reverse the top stack half of the time
‼                print the top stack

2

चारकोल , 34 बाइट्स

≔‽χθ≔‽Φχ⁻ιθη↑I⟦θθη‽Φχ×⁻ιθ⁻ιηη⟧¿‽²‖

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

  χ                                 Predefined variable 10
 ‽                                  Random element from implicit range
≔  θ                                Assign to variable `q`
       χ                            Predefined variable 10
      Φ                             Filter on implicit range
         ι                          Current value
          θ                         Variable `q`
        ⁻                           Subtract
     ‽                              Random element
    ≔      η                        Assign to variable `h`
                    χ               Predefined variable 10
                   Φ                Filter on implicit range
                       ι  ι         Current value
                        θ           Variable `q`
                           η        Variable `h`
                      ⁻  ⁻          Subtract
                     ×              Multiply
                  ‽                 Random element
               θθ                   Variable `q`
                 η          η       Variable `h`
              ⟦              ⟧      Wrap 5 values into array
             I                      Cast array elements to string
            ↑                       Make array print horizontally
                                ²   Literal 2
                               ‽    Random element from implicit range
                              ¿     If
                                 ‖  Reflect

2

रेटिना , 40 बाइट्स


10*
Y`w`d
V?`
Lv$7`.(.)
$1$<'$'
O?`...?

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

अग्रणी शून्य के साथ तार प्रिंट कर सकते हैं।

व्याख्या


10*

स्ट्रिंग को 10 अंडरस्कोर तक आरंभ करें।

Y`w`d

साइक्लीअली ट्रांसलेटेड शब्द वर्णों को अंकों के लिए। यह थोड़ा अजीब है। wऔर dनिम्नलिखित तार, क्रमशः के लिए कम कर रहे हैं:

w: _0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz
d: 0123456789

चक्रीय लिप्यंतरण का अर्थ है कि पहले, दोनों तारों को उनके LCM की लंबाई में दोहराया जाता है:

_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_012345...
0123456789012345678901234567890123456789012345678901234567890123456789...

चूंकि स्ट्रिंग की लंबाई 53 और 10 है, जो प्रतिरूप है, प्रत्येक कॉपी को _एक अलग अंक के साथ जोड़ा जाता है। और अब चक्रीय लिप्यंतरण i वें प्रति के _साथ उस विस्तारित सूची में i वें युग्मन की जगह लेगा । तो हम निम्नलिखित स्ट्रिंग के साथ समाप्त होते हैं:

0369258147

यह सब शाब्दिक स्ट्रिंग पर एक बाइट को बचाने के लिए है 0369258147, इसलिए मुझे लगता है? : डी

वैसे भी, हमें अब सभी 10 अंकों की एक स्ट्रिंग मिल गई है।

V?`

इससे अंकों में फेरबदल होता है। तो पहले तीन अंक तीन अलग अंकों के एक समान यादृच्छिक चयन होंगे।

Lv$7`.(.)
$1$<'$'

हम स्ट्रिंग से मेल खाते हैं ...ABCऔर इसे चालू करते हैं BABCC। जिस तरह से हम ऐसा करते हैं वह थोड़े पागल होते हैं और फिर से अधिक सरल दृष्टिकोण की तुलना में केवल एक बाइट बचाता है। हम पहले सभी अतिव्यापी ( v) पात्रों के जोड़े से मेल खाते हैं , दूसरे को कैप्चर करते हुए ( .(.))। फिर हम केवल 8 वें मैच ( 7, शून्य-आधारित) को बनाए रखते हैं , जो कि ABअंदर है ...ABC। फिर हम $इसे ( ) के साथ प्रतिस्थापित करते हैं: B( $1), ABC( $<'जो मैच का प्रत्यय है- मैच के विभाजक को छोड़ दिया), C( $'जो कि मैच का प्रत्यय है)।

O?`...?

अंत में, हम या तो 3 या 2 वर्णों से मेल और मैचों शफ़ल, हमें या तो दे रही है BABCCया CCBABयादृच्छिक पर।


2

आर , 78 बाइट्स

z=sample(0:9,3)[c(2,1:3,3)];cat(paste(`if`(runif(1)>.5,z,rev(z)),collapse=''))

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

sampleसे 3 यादृच्छिक मान चुनता है 0:9, जिन्हें वेक्टर में रखा जाता है जैसे a b a c c:। अब हमारे पास इस वेक्टर को उलटने के लिए 50/50 का मौका है, और फिर संक्षिप्त और प्रिंट करें।


बहुत अच्छा! 62 बाइट्स ; ऐसा लगता है कि आप अभ्यास से थोड़ा बाहर हैं;)
Giuseppe

मैंने उपयोग करते हुए देखा rt, लेकिन किसी कारण से मुझे लगा कि यह अधिक लंबा है ....
JAD

और (जैसा कि नो-ओप एक अच्छी खोज है :)
JAD

@Giuseppe अपने asnwer को 55 बाइट्स के लिए आगे बढ़ाया जा सकता है ... TIO
JayCe

2

PHP, 73 72 66 बाइट्स

<?=strtr(rand()%2?AABCB:BCBAA,ABC,join(array_rand(range(0,9),3)));

संपादित करें: @David के सुझाव के लिए 66 बाइट्स धन्यवाद।

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


आप इसे 65 के साथ प्राप्त कर सकते हैं:<?=strtr(rand()%2?AABCB:BCBAA,ABC,rand(0,9).rand(0,9).rand(0,9));
दाव

@ डेविड दुर्भाग्य से आपका समाधान नियम 5 का उल्लंघन करता है। यह पसंद किया जा सकता है rand(0,3).rand(4,6).rand(7,9), लेकिन फिर "समान रूप से यादृच्छिक" नहीं है। Btw। मैं इससे परिचित नहीं था rand()%2, इसलिए आपकी टिप्पणी ने मुझे वैसे भी अपने समाधान में थोड़ा सुधार करने में मदद की।
22

1
आह, हाँ, तुम सही हो। मैंने वह नियम नहीं देखा। मुझे एक मिल गया है जो अब 66 बाइट्स पर काम करता है <?=strtr(rand()%2?AABCB:BCBAA,ABC,join(array_rand(range(0,9),3)));:। आप परीक्षण कर सकते हैं कि array_randदूसरा पैरामीटर केवल यहाँ अद्वितीय परिणाम देता है (10000 से अधिक पुनरावृत्तियों का परीक्षण)।
डेविएड

@ डेविड धन्यवाद, बस मेरी पोस्ट अपडेट हुई!
रिट्रोवर

1

लाल , 147, 146 125 बाइट्स

func[][b: copy[]d:[1 1 2 3 2]if 1 = random 2[d: reverse d]while[4 > length? b][alter b(random 10)- 1]foreach a d[prin b/(a)]]

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

Ungolfed:

f: func[] [                       function with no arguments
    b: copy []                    an empty list
    d: [1 1 2 3 2]                preset digits at positons
    if 1 = random 2 [             generate 1 or 2 
        d: reverse d]             based on this choose to reverse the positions list
    while [4 > length? b] [       while we haven't chosen 3 different digits
        alter b (random 10) - 1   pick a random digit, if it's not in the list already
                                  append it to the list, otherwise remove it
    ]
    foreach a d [                 for each position
       prin b/(a)]                print the corresponding digit 
]



1

पायथन 3 + सुन्न, 69 बाइट्स

from pylab import*
r=choice
i=r(2)
print(r(10,3,0)[[1-i,0,1,2,-1-i]])

व्याख्या

from pylab import*     
r=choice               # `choice` takes a range, number of samples, and wether repetition is allowed
i=r(2)                 # Single value in [0,1] to specify if repeated digits come on right or left
print(r(10,3,0)[[1-i,0,1,2,-1-i]])    # Construct output using index list and 3 random integers


0

जे , 35 बाइट्स

[:u:48+[:|.^:(?&2:)2 2 1 0 1{3?10"_

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

मुझे यकीन है कि इसे और आगे बढ़ाया जा सकता है।

स्पष्टीकरण:

  3?10             - generates 3 different digits
7 0 3

  2 2 1 0 1{       - constructs a list using digits positions 0, 1 and 2

  2 2 1 0 1{3?10   
3 3 0 7 0

  |.^:(?&2:)       - generates 0 or 1 and if 1, reverses the list 

  |.^:(?&2:)2 2 1 0 1{3?10
0 7 0 3 3

   u:48+              - converts to char by adding 48 to each digit
   u:48+|.^:(?&2:)2 2 1 0 1{3?10
07033
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.