27

आइए देखें कि चयनात्मक यादृच्छिकता में आपकी पसंद की भाषा कितनी अच्छी है।

यह देखते हुए 4 अक्षर, A, B, C, और D, या 4 वर्णों की स्ट्रिंग ABCD इनपुट के रूप में , निम्नलिखित संभावनाओं के साथ पात्रों में से उत्पादन एक:

A चुनने के लिए 1/8 (12.5%) मौका होना चाहिए
B चुने जाने के लिए 3/8 (37.5%) मौका होना चाहिए
C चुने जाने के लिए 2/8 (25%) मौका होना चाहिए
D चुने जाने के लिए 2/8 (25%) मौका होना चाहिए

यह निम्न प्लिन्को मशीन लेआउट के साथ इन-लाइन है :

   ^
  ^ ^
 ^ ^ ^
A B \ /
     ^
    C D

आपका उत्तर वर्णित संभावनाओं का सम्मान करने के लिए एक वास्तविक प्रयास करना चाहिए। आपके उत्तर में संभावनाओं की गणना कैसे की जाती है (और क्यों वे चश्मे का सम्मान करते हैं, छद्म यादृच्छिकता और बड़ी संख्या की समस्याओं की उपेक्षा करते हैं) की एक उचित व्याख्या पर्याप्त है।

स्कोरिंग

यह प्रत्येक भाषा की जीत में कोड-गोल्फ इतना कम बाइट्स है !

code-golf string random

— Skidsdev
स्रोत

क्या हम अपनी पसंद की भाषा में अंतर्निहित यादृच्छिक फ़ंक्शन को यादृच्छिक मान सकते हैं?

— श्री एक्सकोडर

@ Mr.Xcoder कारण के भीतर, हाँ।

— स्काइड्सदेव

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

— कामिल द्रकरी

1

@KamilDrakari सही है।

— स्काइड्सदेव

2

नहीं बहुत इसकी लंबाई की वजह से उपयोगी है, लेकिन मुझे पता चला है कि अभिव्यक्ति ceil(abs(i - 6)/ 2.0)से एक सूचकांक मैप कर देंगे 0-7से एक सूचकांक करने के लिए 0-3उचित वितरण (के साथ 0 111 22 33इस चुनौती के लिए) ...

— सुकराती फीनिक्स

14

लीन मीन बीन मशीन , 55 43 42 बाइट्स

-13 बाइट्स एलेक्स वरगा को धन्यवाद

  O
  i
  ^
 ^ ^
\ ^ ^
 i / U
 ii
 ^
i U
U

आशा है कि आप लोग मुझे केवल 2 घंटे के बाद अपने ही प्रश्न का उत्तर देने में कोई आपत्ति नहीं करेंगे, लेकिन मुझे बहुत संदेह है कि कोई अन्य व्यक्ति LMBM में उत्तर पोस्ट करने की योजना बना रहा था।

यह वस्तुतः ओपी में दिखाए गए प्लिन्को लेआउट को दर्शाता है, अनावश्यक व्हॉट्सएप पर कटौती करने के लिए क्षैतिज रूप से फ़्लिप किया।

— Skidsdev
स्रोत

मुझे नहीं पता कि यह कैसे परीक्षण करना है, लेकिन यह काम कर सकता है: gist.github.com/anonymous/e537edc8c89a72f3631ef765b352b98d

— Alex Varga

@AlexVarga ऊह कि काम करता है

— स्काइडदेव

-1 बाइट: gist.github.com/anonymous/5ae3b2529f1d981ac3b320eb330f32e3

— एलेक्स वर्गा

9

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

Ḋṁ7;ḢX

चार वर्णों की सूची लेने और वर्णित वितरण के साथ एक को लौटाने वाला एक विचित्र लिंक।

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

कैसे?

Ḋṁ7;ḢX - Link: list of characters, s  e.g. ABCD
Ḋ      - dequeue s                         BCD
 ṁ7    - mould like 7 (implicit range)     BCDBCDB
    Ḣ  - head s                            A
   ;   - concatenate                       BCDBCDBA
     X - random choice                     Note that the above has 1*A, 3*B, 2*C, and 2*D

— जोनाथन एलन
स्रोत

चतुर चाल ṁ!

— आउटगोल्फ जूल

9

क्यूबिक्स , 39 24 22 21 19 बाइट्स

.<.^iD>D|@oioi.\i;U

ऑनलाइन दुभाषिया में देखें!

यह निम्नलिखित घन जाल के लिए नक्शे:

    . <
    . ^
i D > D | @ o i
o i . \ i ; U .
    . .
    . .

रैंडम वितरण कार्यान्वयन स्पष्टीकरण

क्यूबिक्स एक भाषा है जिसमें एक निर्देश सूचक एक क्यूब के चेहरे के चारों ओर घूमता है, यह कमांड को निष्पादित करता है। यादृच्छिकता का एकमात्र रूप कमांड है D, जो आईपी को यादृच्छिक दिशा में भेजता है: 1/4प्रत्येक तरीके का एक समान मौका ।

हालाँकि, हम इसका उपयोग सही वज़न वाले संभावितों को उत्पन्न करने के लिए कर सकते हैं: Dदो बार उपयोग करके । पहले के Dपास 1/4एक सेकेण्ड का शीर्षक होता है D। Dहालांकि, इस दूसरी दिशा में तीर के साथ दो दिशाएं बंद हैं ( > D <) जो Dएक और दिशा चुनने के लिए निर्देश सूचक को वापस भेजती है । इसका मतलब यह है कि वहाँ से केवल दो संभावित दिशाएं हैं, प्रत्येक होने के 1/8समग्र अवसर के साथ । इसका उपयोग सही वर्ण उत्पन्न करने के लिए किया जा सकता है, जैसा कि नीचे दिए गए चित्र में दिखाया गया है:

(ध्यान दें, वास्तविक कोड में, दाईं ओर के तीर को दर्पण से बदल दिया गया है |)

कोड स्पष्टीकरण

        . <
        . ^
IP> i D > D | @ o i
    o i . \ i ; U .
        . .
        . .

निर्देश पॉइंटर दाईं ओर, चरित्र पर, दाईं ओर से शुरू होता है i। यह इसे निष्पादित करता है i, पहले चरित्र को इनपुट के रूप में लेता है, और फिर Dऊपर दिखाए गए यादृच्छिक प्रक्रिया की शुरुआत करता है।

चार ए: इस मामले में कि पहला Dहमें पूर्व में भेजता है, और दूसरा दक्षिण में, हमें चरित्र ए को प्रिंट करने की आवश्यकता है। यह पहले से ही स्टैक पर है i। निम्नलिखित निष्पादित किया गया है:
- \ - आईपी को प्रतिबिंबित करें ताकि यह पूर्व की ओर बढ़े
- i; - एक इनपुट लें, फिर उसे फिर से पॉप करें (नो-ऑप)
- U - यू-टर्न करें, आईपी को दो बार छोड़ दिया
- o आउटपुट टीओएस, चरित्र ए
- @ - कार्यक्रम समाप्त करें
चार बी: यदि या तो पहले या दूसरे Dसिर उत्तर में, हमें चरित्र बी उत्पन्न करने की आवश्यकता है, जो अगला इनपुट होगा। दोनों रास्तों पर अमल करते हैं:
- ^ - उत्तर की ओर जाएं
- < - हेड वेस्ट, रैपिंग राउंड टू ...
- i - एक और इनपुट लें, चरित्र बी
- o - आउटपुट टीओएस, चरित्र बी
- ; - टीओएस पॉप करें
- @ - कार्यक्रम समाप्त करें
चार सी: यदि पहला Dहमें पश्चिम भेजता है, तो निम्नलिखित को निष्पादित किया जाता है:
- i - एक और इनपुट लें, चरित्र बी
- i - एक और इनपुट, चरित्र सी लें
- o - आउटपुट टीओएस, चरित्र सी
- @ - कार्यक्रम समाप्त करें
चार डी: यदि पहला Dहमें दक्षिण भेजता है, तो निम्नलिखित को निष्पादित किया जाता है:
- i - एक और इनपुट लें, चरित्र बी
- .. - दो नो-ऑप्स
- i - एक और इनपुट, चरित्र सी लें
- | - यह दर्पण पूर्व-पश्चिम को दर्शाता है, लेकिन आईपी उत्तर की ओर बढ़ रहा है, इसलिए हम इससे गुजरते हैं।
- ^ - यह चरित्र बी के लिए उठाए गए मार्ग के साथ जुड़ जाता है। हालांकि, हमने पहले ही दो इनपुट ले लिए हैं, चौथा चरित्र (कैरेक्टर डी) समाप्त हो जाएगा।

— FlipTack
स्रोत

2

यह शानदार है! मैं विश्वास नहीं कर सकता कि आप एक आकार -2 क्यूब पर उचित संभावनाओं और सभी चार रास्तों को फिट करने में कामयाब रहे । मुझे आश्चर्य है कि अगर मैं

— क्यूबिक्स के

@ETHproductions धन्यवाद, मुझे यकीन है कि बाइट या दो को काटने का एक तरीका है, लेकिन मुझे इस जवाब पर भी गर्व है :)

— FlipTack

8

पायथन , 50 बाइट्स

lambda x:choice(x[:2]+x[1:]*2)
from random import*

एक अनाम फ़ंक्शन लेने और लौटने वाले तार (या वर्णों की सूची)।

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

कैसे?

random.choiceएक सूची से एक यादृच्छिक तत्व चुनता है, इसलिए फ़ंक्शन सही वितरण के साथ एक स्ट्रिंग बनाता है, अर्थात् "ABCD", दिया गया है , "ABCD"[:2] = "AB"और "ABCD"[1:]*2 = "BCD"*2 = "BCDBCD"जो है "ABBCDBCD"।

— जोनाथन एलन
स्रोत

मुझे अपना समाधान गोल्फ में करने का एक तरीका मिला और फिर एहसास हुआ कि यह आपके लिए समान है, बस रिवर्स ऑर्डर में: /

— मिस्टर एक्सकोडर

6

आर , 31 बाइट्स

sample(scan(,''),1,,c(1,3,2,2))

stdinरिक्त स्थान से वर्णों को अलग करता है। अंतिम तर्क द्वारा दिए गए भार के साथ sampleदूसरे इनपुट (तो 1), (वैकल्पिक प्रतिस्थापन तर्क) की मात्रा में अपने पहले इनपुट से यादृच्छिक नमूने खींचता है।

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

यह nसमय की कोशिश करो !

बाद वाले कोड के लिए, मैं रिप करने के लिए सेट रिप (यह डिफ़ॉल्ट रूप से गलत है ) के साथ nसमय ( nहेडर में सेट ) का नमूना देता हूं T, परिणामों को सारणीबद्ध करता nहूं , और इनपुट की सापेक्ष संभावनाओं को देखने के लिए विभाजित करता हूं।

— ग्यूसेप
स्रोत

6

PHP, 28 बाइट्स

<?=$argn[5551>>2*rand(0,7)];

साथ पाइप के रूप में चलाएँ -nR।

01112233आधार -4 5551में दशमलव में है ...

— टाइटस
स्रोत

एक ही लंबाई के साथ 108 संभव मूल्य ... 7030मेरे व्यक्तिगत पसंदीदा में से एक है।

— टाइटस

5

जावा 8, 53 44 बाइट्स

s->s[-~Math.abs((int)(Math.random()*8)-6)/2]

यह ए Function<char[], Character>।

इसे ऑनलाइन आज़माएं! (इस परीक्षण कार्यक्रम ऊपर समारोह 1,000,000 बार चलाता है और की प्रयोगात्मक संभावनाओं आउटपुट को चुनने A, B, C, और D)।

सामान्य विचार यहाँ किसी तरह मैप करने के लिए मिल रहा है 0-7करने के लिए 0-3, जैसे कि 0प्रकट होता है 1/8बार, 1प्रतीत होता है 3/8कई बार, 2प्रतीत होता है 2/8बार, और 3प्रतीत होता है 2/8कई बार। round(abs(k - 6) / 2.0))इसके लिए काम करता है, जहां kसीमा में एक यादृच्छिक पूर्णांक है [0,8)। इसका परिणाम निम्न मानचित्रण में होता है:

k -> k - 6 -> abs(k-6) -> abs(k-6)/2 -> round(abs(k-6)/2)

0 -> -6 -> 6 -> 3   -> 3
1 -> -5 -> 5 -> 2.5 -> 3
2 -> -4 -> 4 -> 2   -> 2
3 -> -3 -> 3 -> 1.5 -> 2
4 -> -2 -> 2 -> 1   -> 1
5 -> -1 -> 1 -> 0.5 -> 1
6 -> 0  -> 0 -> 0   -> 0 
7 -> 1  -> 1 -> 0.5 -> 1

जो, जैसा कि आप देख सकते हैं, सूचकांकों में परिणाम है 0 111 22 33, जो , और 1/8, की वांछित संभावनाएं पैदा करता है ।3/82/82/8

लेकिन रुकें! दुनिया में कैसे -~Math.abs(k-6)/2एक ही परिणाम प्राप्त होता है (फिर से, जहां kरेंज में एक यादृच्छिक पूर्णांक है [0,8])? यह वास्तव में बहुत आसान है ... (x+1)/2(पूर्णांक विभाजन) के रूप में एक ही बात है round(x/2), और के रूप x + 1में एक ही बात है -~x। हालांकि x+1और -~xसमान लंबाई है, उपरोक्त फ़ंक्शन में इसका उपयोग करना बेहतर है -~xक्योंकि यह -~पूर्ववर्तीता लेता है और इस प्रकार कोष्ठक की आवश्यकता नहीं होती है।

— सोक्रेटिक फीनिक्स
स्रोत

मुझे पता है कि यह एक समय हो गया है, लेकिन आप पूर्णांक-कास्ट के प्लेसमेंट को बदलकर दो बाइट्स को गोल्फ कर सकते हैं (चूंकि Math.absपैरामीटर के रूप में डबल्स को भी स्वीकार करता है): s->s[-~(int)Math.abs(Math.random()*8-6)/2]( 42 बाइट्स )।

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

5

एपीएल, 14 बाइट्स

(?8)⊃1 3 2 2\⊢

एक तार के रूप में इनपुट।

कैसे?

1 3 2 2\⊢- प्रत्येक अक्षर x को दोहराएं ( 'ABCD'→ 'ABBBCCDD')

⊃ - तत्व को सूचकांक पर ले जाएं ।।

(?8) - यादृच्छिक 1-8

— Uriel
स्रोत

क्या आप मेरे J उत्तर की समीक्षा करेंगे और मुझे बताएंगे कि क्या इसमें सुधार किया जा सकता है?

— योना

17 बाइट्स

— Adám

@ एरियल इसे ऑनलाइन आज़माएं!

— एडम जूल

@ एरियल ऐसी कोई एन्कोडिंग नहीं है। या तो आप पूर्ण UTF-8 पर जाते हैं, या आप प्रत्येक वर्ण को दो बाइट्स (UTF-16) के रूप में गिनते हैं, या आप 5 बाइट्स जोड़ते हैं ⎕U2378।

— 22

@ Adám ओह, मैं देख रहा हूँ। फिर बाइल को बचाने के लिए नए प्रतीकों के लिए इन अनावश्यक यूरोपीय उच्चारण पत्रों में से कुछ को बदलने के लिए डायलाग प्राप्त करें! ;)

— यूरिल

4

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

‽⟦εεζζηηηθ⟧

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है, हालांकि आपको शायद ही इसकी आवश्यकता है; ‽एक यादृच्छिक तत्व चुनता है, ⟦⟧एक सूची बनाता है, और चर वे हैं जो उचित इनपुट पत्र प्राप्त करते हैं (रिवर्स ऑर्डर में क्योंकि मुझे ऐसा लगता था)।

— नील
स्रोत

4

पायथ , 8 7 बाइट्स

O+@Q1t+

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

यहाँ कोशिश करो!

अजगर , 10 8 बाइट्स

O+<Q2*2t

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

यहाँ कोशिश करो!

व्याख्या

O- (साथ +) जोड़कर किए गए स्ट्रिंग का एक यादृच्छिक तत्व लेता है :
- <Q2 - स्ट्रिंग के पहले दो अक्षर।
- *2t*2पहले चरित्र को छोड़कर पूर्ण स्ट्रिंग ( ) को डबल करें t।

इस एल्गोरिथ्म के लिए आवेदन ABCD:

<Q2लेता है AB।
*2tBCDइसे लेता है और दोगुना करता है BCDBCD:।
+दो स्ट्रिंग्स में शामिल होता है ABBCDBCD:।
O एक यादृच्छिक चरित्र लेता है।

-2 लीक नून (दूसरा समाधान) के लिए धन्यवाद

-1 मेनेमोनिक (पहला समाधान) के लिए धन्यवाद

— श्री एक्सकोडर
स्रोत

>Q1बन जाता है tQ, जो बन जाता है t।

— लीक नून

आप दूसरे समाधान पर एक बाइट को दो बार निहित इनपुट के *2साथ बदलकर +और उपयोग करके बचा सकते हैं ।

@ मेनोनिक धन्यवाद, मुझे लगता है कि मैंने इसका इस्तेमाल नहीं किया है क्योंकि मैंने yइसके बजाय सोचा था , जो स्ट्रिंग्स के लिए काम नहीं करता है ...

— श्री एक्सकोडर

3

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

122b4⁸xX

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

Xदेखने के लिए निकालें "ABBBCCDD"। Xएक यादृच्छिक तत्व चुनता है।

— लीक नन
स्रोत

3

सी # (.NET कोर) , 76 55 बाइट्स

s=>(s+s[1]+s[1]+s[2]+s[3])[new System.Random().Next(8)]

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

मेरा पहला उत्तर सीधे अपने मोबाइल फोन का उपयोग करके टीआईओ पर लिखा गया है। ऊपर का स्तर!

स्पष्टीकरण: यदि मूल स्ट्रिंग "एबीसीडी" है, तो फ़ंक्शन स्ट्रिंग "एबीसीडीबीबीसीडी" बनाता है और इसके साथ एक यादृच्छिक तत्व लेता है।

— चार्ली
स्रोत

आपके कार्यक्रम में पात्रों को इनपुट के रूप में लिया जाना चाहिए

— स्किड्सदेव

@ मैय्यूब ने तय किया, हालांकि यह अभी भी गोल्फ हो सकता है ...

— चार्ली

3

जावास्क्रिप्ट 35 बाइट्स

ABCDइनपुट के रूप में एक स्ट्रिंग लेता है , Aसमय का 1 / 8th , आउटपुट समय का B3 / 8th, समय का C1 / 4th, और D1 / 4th का आउटपुट देता है ।

x=>x[5551>>2*~~(Math.random()*8)&3]

व्याख्या

x=>x[                     // return character at index
    5551                  // 5551 is 0001010110101111 in binary
                          // each pair of digits is a binary number 0-3
                          // represented x times
                          // where x/8 is the probability of selecting
                          // the character at the index 
    >>                    // bitshift right by
    2 *                   // two times
    ~~(                   // double-bitwise negate (convert to int, then 
                          // bitwise negate twice to get the floor for
                          // positive numbers)
        Math.random() * 8 // select a random number from [0, 8)
    )                     // total bitshift is a multiple of 2 from [0, 14]
    &3                    // bitwise and with 3 (111 in binary)
                          // to select a number from [0, 3]
]

— asgallant
स्रोत

3

05AB1E , 5 बाइट्स

¦Ćì.R

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

व्याख्या

¦Ćì.R   Argument s                      "ABCD"
¦       Push s[1:]                      "BCD"
 Ć      Enclose: Pop a, Push a + a[0]   "BCDB"
  ì     Pop a, Concatenate a and s      "ABCDBCDB"
   .R   Random pick

— kalsowerus
स्रोत

3

> <> , 25 22 19 बाइट्स

i_ixio;o
ox</;
;\$o

इसे ऑनलाइन आज़माएं! , या मछली के खेल के मैदान में इसे देखो !

> <> का संक्षिप्त अवलोकन: यह एक मछली के साथ एक 2 डी भाषा है जो कोड के माध्यम से तैरती है, निर्देशों को निष्पादित करती है जैसा कि यह जाता है। यदि यह कोड के किनारे तक पहुंचता है, तो यह दूसरी तरफ जाता है। मछली दाएं घूमते हुए, ऊपरी बाएं कोने में शुरू होती है। यादृच्छिकता> <> में मुश्किल है: एकमात्र यादृच्छिक निर्देश है x, जो मछली की दिशा को यादृच्छिक रूप से ऊपर, नीचे, बाएं और दाएं (समान संभावना के साथ) सेट करता है।

कार्यक्रम की शुरुआत में, मछली इनपुट के दो पात्रों में पढ़ती है i_i(प्रत्येक iस्टैडिन से स्टैक के एक चरित्र को पढ़ती है, और _एक क्षैतिज दर्पण है, जिसे मछली अब अनदेखा करती है)। यह तब एक तक पहुँचता है x।

यदि xमछली सही तरीके से भेजता है, तो यह एक और चरित्र (तीसरे) में पढ़ता है, इसे प्रिंट करता है oऔर इसके साथ रुकता है ;। बाईं दिशा समान है: मछली दो और अक्षर पढ़ती है (इसलिए हम चौथे तक हैं), दाईं ओर लपेटता है, चौथा वर्ण और हाल्ट प्रिंट करता है। यदि मछली तैरती है, तो वह दूसरे पात्र को लपेटती है और प्रिंट करती है, इससे पहले कि वह सही /और परावर्तित हो जाए । यदि यह नीचे तैरता है, तो यह परिलक्षित होता है /और दूसरे से टकराता है x।

इस बार, दो दिशाएं मछली को वापस x(एक तीर के साथ सही <, और एक दर्पण के साथ _) वापस भेजती हैं । इसलिए मछली xको अन्य दो दिशाओं में से प्रत्येक में बचने का 1/2 मौका है । बाईं ओर स्टैक पर शीर्ष चरित्र को प्रिंट करता है, जो दूसरा है, लेकिन नीचे की ओर पहले स्टैक पर दो तत्वों को स्वैप करता है $, इसलिए यह दिशा पहले वर्ण को प्रिंट करती है।

सारांश में, तीसरा और चौथा वर्ण प्रायिकता 1/4 प्रत्येक के साथ छपा है; पहले पात्र में प्रायिकता 1/2 x 1/4 = 1/8 है; और दूसरे वर्ण में प्रायिकता 1/4 + 1/2 x 1/4 = 3/8 है।

— पेड़ नहीं
स्रोत

2

05AB1E , 8 बाइट्स

ìD1è0ǝ.R

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

         # Implicit input                            | [A,B,C,D]
ì        # Prepend the input to itself               | [A,B,C,D,A,B,C,D]
 D1è     # Get the second character                  | [A,B,C,D,A,B,C,D], B
    0ǝ   # Replace the first character with this one | [B,B,C,D,A,B,C,D]
      .R # Pick a random character from this array   | D

— रिले
स्रोत

2

MATL , 12 10 बाइट्स

l3HHvY"1Zr

इसे ऑनलाइन आज़माएं! या इसे 1000 बार (थोड़ा संशोधित कोड) चलाएं और प्रत्येक चार बार दिखाई देने वाली संख्या की जांच करें।

व्याख्या

l3HH   % Push 1, 3, 2, 2
v      % Concatenate all stack contents into a column vector: [1; 3; 2; 2]
Y"     % Implicit input. Run-length decode (repeat chars specified number of times)
1Zr    % Pick an entry with uniform probability. Implicit display

संशोधित कोड में परिवर्तन: 1000:"Gl3HH4$vY"1Zr]vSY'

1000:"...]1000बार दोहराने के लिए एक लूप है ।
G यह सुनिश्चित करता है कि इनपुट को प्रत्येक पुनरावृत्ति की शुरुआत में धकेल दिया जाए।
परिणाम पुनरावृत्तियों पर ढेर पर जमा होते हैं। इसलिए केवल शीर्ष संख्याओं को vबदलने के लिए प्रतिस्थापित करने की आवश्यकता है ।4$v4
पाश के अंत में, vconcatenates 1000एक वेक्टर में परिणाम है, Sयह सॉर्ट करता है, और Y'रन-लंबाई वह कूटबद्ध। यह चार अक्षर और उनके प्रकट होने की संख्या को बताता है।

— लुइस मेंडो
स्रोत

हां, अब तय लग रहा है

— स्काइडदेव

@ मेयूब नोटिंग के लिए धन्यवाद!

— लुइस मेंडू

2

05AB1E , 6 बाइट्स

«À¨Ć.R

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

व्याख्या

सूची और तार दोनों के लिए काम करता है।

«       # concatenate input with itself
 À      # rotate left
  ¨     # remove the last character/element
   Ć    # enclose, append the head
    .R  # pick a character/element at random

— Emigna
स्रोत

2

सी (जीसीसी) , 50 49 बाइट्स

i[8]={1,1,1,2,2,3,3};f(char*m){m=m[i[rand()%8]];}

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

— cleblanc
स्रोत

1

ABCDउदाहरण इनपुट है, आपके कोड को इनपुट के रूप में 4 अक्षर (या लंबाई 4 की एक स्ट्रिंग) लेना चाहिए

— स्किड्सदेव

2

रूबी, 34 33 29 27 बाइट्स

सहेजे गए 2 बाइट @ वेल्यू इंक का धन्यवाद

चार वर्णों के रूप में इनपुट

a=$**2
a[0]=a[1]
p a.sample

एक सरणी का निर्माण करें [B,B,C,D,A,B,C,D]और उसका नमूना लें।

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

nबार कोशिश करो ! (मैंने इसे अधिक आसानी से दोहराने के लिए एक फ़ंक्शन में बदल दिया, लेकिन एल्गोरिथ्म समान है)

— alexanderbird
स्रोत

$*के लिए एक उपनाम है ARGV।

— वैल्यू इंक

2

पायथ, 7 बाइट्स

@z|O8 1

परीक्षण सूट

O80 से 7. तक एक यादृच्छिक संख्या उत्पन्न करता है और | ... 1एक तार्किक या 1 के साथ लागू होता है, 0 को 1 में परिवर्तित करता है और बाकी सब समान छोड़ देता है। इस स्तर पर संख्या समय का 1 2/8 वां है, और समय का 2, 3, 4, 5, 6, 7 या 8 1/8।

@zउस स्थिति में इनपुट स्ट्रिंग में अनुक्रमित करता है। अनुक्रमणिका को स्ट्रिंग की लंबाई मोडुलो के रूप में प्रदर्शित किया जाता है, इसलिए स्थिति 4 पर 4 अनुक्रमणिका, स्थिति 1 पर 5, और इसी तरह।

संभावनाएं हैं:

स्थिति 0: समय की रैंडम संख्या 4. 1/8।
स्थिति 1: समय की यादृच्छिक संख्या 0, 1 या 5. 3/8।
स्थिति 2: समय की यादृच्छिक संख्या 2 या 6. 2/8।
स्थिति 3: समय की यादृच्छिक संख्या 3 या 7. 2/8।

— isaacg
स्रोत

2

जावास्क्रिप्ट, 31 30 बाइट्स / 23 बाइट्स

असग्लंट के पहले के जावास्क्रिप्ट उत्तर को देखकर मुझे जेएस के बारे में सोचने का मौका मिला। जैसे उसने कहा:

ABCDइनपुट के रूप में एक स्ट्रिंग लेता है , Aसमय का 1 / 8th , आउटपुट समय का B 3 / 8th, समय का C1 / 4th, और D1 / 4th का आउटपुट देता है ।

मेरा है:

x=>(x+x)[Math.random()*8&7||1]

स्पष्टीकरण:

x=>(x+x)[                 // return character at index of doubled string ('ABCDABCD')
         Math.random()*8  // select a random number from [0, 8]
         &7               // bitwise-and to force to integer (0 to 7)
         ||1              // use it except if 0, then use 1 instead
        ]

Math.random()*8&7इस प्रकार से यह टूट जाता है:

A from 4      = 12.5% (1/8)
B from 0,1,5  = 37.5% (3/8)
C from 2,6    = 25%   (1/4)
D from 3,7    = 25%   (1/4)

संस्करण 2, 23 बाइट्स

लेकिन तब अरनौल का धन्यवाद, जिन्होंने मेरे बाद पोस्ट किया, जब उन्होंने कहा:

यदि समय-निर्भर सूत्र की अनुमति है, तो हम कर सकते हैं:

जो, अगर यह वास्तव में अनुमति दी है, मुझे करने के लिए नेतृत्व:

x=>(x+x)[new Date%8||1]

जिसमें new Date%8ऊपर की तरह एक ही ब्रेक-डाउन तालिका का उपयोग किया जाता है।

और %8भी हो सकता है &7; अपना चयन ले लो। धन्यवाद फिर से, Arnauld।

— एलन चूहा
स्रोत

2

ngn / apl, 10 बाइट्स

⎕a [⎕ /? २ ४]

?2 4 यादृच्छिक रूप से संख्याओं की एक जोड़ी चुनता है - पहला 0 1 के बीच और दूसरा 0 1 2 3 के बीच

⌈/ "अधिकतम कम" है - बड़ी संख्या खोजें

⎕a अपरकेस वर्णमाला है

[ ] अनुक्रमण

अधिकतम के लिए चार्ट पर ध्यान दें (ए, बी) जब a, {0,1} और b 0 {0,1,2,3}:

    ┏━━━┯━━━┯━━━┯━━━┓
    ┃b=0│b=1│b=2│b=3┃
┏━━━╋━━━┿━━━┿━━━┿━━━┫
┃a=0┃ 0 │ 1 │ 2 │ 3 ┃
┠───╂───┼───┼───┼───┨
┃a=1┃ 1 │ 1 │ 2 │ 3 ┃
┗━━━┻━━━┷━━━┷━━━┷━━━┛

यदि a और b को यादृच्छिक रूप से और स्वतंत्र रूप से चुना जाता है, तो हम वांछित संभाव्यता वितरण प्राप्त करने के लिए 0123 = ABCD स्थानापन्न कर सकते हैं

— NGN
स्रोत

1

पायथन 3 , 64 55 51 बाइट्स

-9 बाइट्स थैंक्स टू @ovs

lambda s:choice((s*2)[1:]+s[1])
from random import*

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

व्याख्या

random.choice()स्ट्रिंग का एक यादृच्छिक चरित्र मिलता है, जबकि एक इनपुट के लिए (s*2)[1:]+s[1]बनाता BCDABCDBहै ABCD, जिसमें 1/8 As, 2/8 Cs, 2/8 Ds और 3/8 Bs है।

— श्री एक्सकोडर
स्रोत

random.choice55 बाइट्स के लिए उपयोग करें :lambda s:choice((s[0]+s[1:]*3)[:8])

— 15

@ovs को एक छोटा रास्ता ^ मिला। choice()हालांकि इसके लिए धन्यवाद ।

— श्री Xcoder

1

QBIC , 27 बाइट्स

?_s;+;+B+B+;+C+;+D,_r1,8|,1

व्याख्या

?           PRINT
 _s         A substring of
   ;+       A plus
   ;+B+B+   3 instances of B plus
   ;+C+     2 instances of C plus
   ;+D      2 instances of D plus
   ,_r1,8|  from position x randomly chosen between 1 and 8
   ,1       running for 1 character

— steenbergh
स्रोत

1

> <>, 56 बाइट्स

v
!

"
D
C
B
A ;
" o
! @
! ^<
x!^xv!
@  v<
@  o
o  ;
;
o

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

— KSmarts
स्रोत

1

चिप , 60 बाइट्स

)//Z
)/\Z
)\/^.
)\x/Z
)\\\+t
|???`~S
|z*
`{'AabBCcdDEefFGghH

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

तीन ?प्रत्येक एक यादृच्छिक बिट का उत्पादन। पहले चक्र पर, इन बिट्स को स्विच के माध्यम से चलाया जाता है ( /'s और \' s) यह निर्धारित करने के लिए कि हम इस तालिका के आउटपुट के लिए किस मूल्य पर जा रहे हैं:

000 a
01_ b
0_1 b
10_ c
11_ d

(जहां या _तो हो सकता है )। हम तब इनपुट के साथ चलते हैं, जब सही मूल्य तक पहुँचते हैं, मुद्रण और समाप्त कर देते हैं।01

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

— Phlarx
स्रोत

1

रूबी, 32 बाइट्स

बहुत सीधा..?

->s{s[[0,1,1,1,2,2,3,3].sample]}

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

— daniero
स्रोत

1

अप्लेसॉफ्ट, 29 उफ़, 32 बाइट्स

थोड़ा "रेट्रोकोम्प्यूटिंग" उदाहरण। मेरे साथ, मैं इस पर बिल्कुल नया हूँ। मैं इकट्ठा करता हूं कि "इनपुट" के रूप में जो निर्दिष्ट किया गया है, उसे बाइट-काउंट की आवश्यकता नहीं है। जैसा कि ओपी में कहा गया है, इनपुट "एबीसीडी" के रूप में दिया जाएगा। (मुझे शुरू में इस बात का आभास नहीं था कि मुझे इनपुट प्राप्त करने की आवश्यकता है, जिसमें 4 बाइट्स शामिल हैं, जबकि मैंने बाइट को नीचे रखा है।)

INPUTI$:X=RND(1)*4:PRINTMID$(I$,(X<.5)+X+1,1)

INPUT, RND, PRINT और MID $ सभी एक-बाइट टोकन के रूप में आंतरिक रूप से एन्कोडेड हैं।

सबसे पहले, X को 0 <X <4 रेंज में यादृच्छिक मान सौंपा गया है। इसका उपयोग I $ से किसी एक अक्षर को चुनने के लिए किया जाता है, (X <.5) + X + 1. वर्ण-स्थिति मान के रूप में लिया जाता है। अभिव्यक्ति का छोटा मूल्यांकन। X <.5 1 जोड़ता है यदि X, 5 से कम था, अन्यथा 0. जोड़ एक्स के परिणाम नीचे दिए गए हैं:

A from .5 ≤ X < 1           = 12.5%
B from X < .5 or 1 ≤ X < 2  = 37.5%
C from 2 ≤ X < 3            = 25%
D from 3 ≤ X < 4            = 25%

— एलन चूहा
स्रोत

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ में आपका स्वागत है! हमें यहां कम से कम तुच्छ रूप से जितना संभव हो उतना सबमिशन करने की आवश्यकता है, ताकि अनावश्यक व्हाट्सएप को हटाना शामिल हो (यदि यहां व्हाट्सएप आवश्यक है तो मैं माफी चाहता हूं)। इसके अतिरिक्त, मैं एपल्सॉफ्ट के बारे में मानकों के बारे में निश्चित नहीं हूं, लेकिन मेरा मानना है कि आपको यह मानने की अनुमति नहीं है कि वे ऑपरेटर सिंगल-बाइट टोकन हैं जब तक कि आंतरिक प्रतिनिधित्व एकल बाइट नहीं है। इसके अलावा, आप यह नहीं मान सकते हैं कि इनपुट एक चर में संग्रहीत है; बल्कि, आपको वास्तव में इसे इनपुट, कमांड लाइन तर्क या फ़ंक्शन पैरामीटर के रूप में लेना चाहिए। धन्यवाद!

— हाइपरन्यूट्रिनो 23

@HyperNeutrino व्हॉट्सएप में से कोई भी आवश्यक नहीं था, हालांकि "INPUT" और "प्रिंट" के बाद अंतरिक्ष में पठनीयता में सुधार होगा। ऐसा हुआ कि इस एंटीक साइबरबॉन्ग स्पेस में पारंपरिक रूप से उन जगहों पर प्रदर्शित किया गया था जो मेरे पास थे। टोकन के लिए मैंने उल्लेख किया यह वास्तव में सच है कि "आंतरिक प्रतिनिधित्व एक एकल बाइट है"। इस बीच, मैंने एक बाइट को नीचे दिए गए कोड को गॉकेट किया।

— एलन चूहा

1

आम लिस्प , 198 बाइट्स

(setf *random-state*(make-random-state t))(defun f(L)(setf n(random 8))(cond((< n 1)(char L 0))((and(>= n 1)(< n 4))(char L 1))((and(>= n 4)(< n 6))(char L 2))((>= n 6)(char L 3))))(princ(f "ABCD"))

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

पठनीय:

(setf *random-state* (make-random-state t))
(defun f(L)
    (setf n (random 8))
    (cond 
            ((< n 1) 
                (char L 0))
            ((and (>= n 1)(< n 4))
                (char L 1))
            ((and (>= n 4)(< n 6))
                (char L 2))
            ((>= n 6)
                (char L 3))
    )
)
(princ (f "abcd"))

— Cheldon
स्रोत

बेतरतीब ढंग से एक चरित्र का चयन करें, प्लिन्को-शैली

स्कोरिंग

लीन मीन बीन मशीन , 55 43 42 बाइट्स

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

कैसे?

क्यूबिक्स , 39 24 22 21 19 बाइट्स

रैंडम वितरण कार्यान्वयन स्पष्टीकरण

कोड स्पष्टीकरण

पायथन , 50 बाइट्स

कैसे?

आर , 31 बाइट्स

PHP, 28 बाइट्स

जावा 8, 53 44 बाइट्स

एपीएल, 14 बाइट्स

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

पायथ , 8 7 बाइट्स

अजगर , 10 8 बाइट्स

व्याख्या

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

सी # (.NET कोर) , 76 55 बाइट्स

जावास्क्रिप्ट 35 बाइट्स

व्याख्या

05AB1E , 5 बाइट्स

व्याख्या

> <> , 25 22 19 बाइट्स

05AB1E , 8 बाइट्स

MATL , 12 10 बाइट्स

व्याख्या

05AB1E , 6 बाइट्स

सी (जीसीसी) , 50 49 बाइट्स

रूबी, 34 33 29 27 बाइट्स

पायथ, 7 बाइट्स

जावास्क्रिप्ट, 31 30 बाइट्स / 23 बाइट्स

संस्करण 2, 23 बाइट्स

ngn / apl, 10 बाइट्स

पायथन 3 , 64 55 51 बाइट्स

व्याख्या

QBIC , 27 बाइट्स

व्याख्या

> <>, 56 बाइट्स

चिप , 60 बाइट्स

रूबी, 32 बाइट्स

अप्लेसॉफ्ट, 29 उफ़, 32 बाइट्स

आम लिस्प , 198 बाइट्स