दिन के यादृच्छिक गोल्फ # 8: एक अनंत सूची को समेटना

Question

श्रृंखला के बारे में

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

छेद 8: एक अनंत सूची में फेरबदल करें

आपको एक फ़ंक्शन या प्रोग्राम लिखना चाहिए जो इनपुट के रूप में एक अनंत सूची लेता है और उस सूची का एक फेरबदल संस्करण लौटाता है।

अनंत I / O के बारे में

इस चुनौती के लिए आप इनपुट ले सकते हैं और आउटपुट प्राप्त कर सकते हैं:

• आप या तो सकारात्मक पूर्णांक की सूची, या उसके बाद एक स्ट्रिंग प्रतिनिधित्व, या एक स्ट्रिंग या मुद्रण योग्य ASCII वर्णों की सूची (0x20 से 0x7E, समावेशी) ले सकते हैं। आउटपुट स्वरूप को इनपुट प्रारूप से मेल खाना चाहिए। मैं अभी से डेटा को "सूची" के रूप में संदर्भित करूंगा, चाहे आप कोई भी विकल्प चुनें।
• आप सूची को अनंत मानक इनपुट स्ट्रीम से पढ़ सकते हैं और आउटपुट को अनंत मानक आउटपुट स्ट्रीम में लगातार लिख सकते हैं। समाधान किसी विशेष मूल्य या मूल्यों के अनुक्रम पर निर्भर नहीं होना चाहिए, यह सुनिश्चित करने के लिए कि आउटपुट स्ट्रीम नियमित रूप से लिखा और फ्लश किया जाता है (उदाहरण के लिए आप 5इनपुट सूची में जब भी आउटपुट लिख नहीं सकते हैं )। बेशक, यदि आप किसी सूची का स्ट्रिंग प्रतिनिधित्व पढ़ते हैं, तो सूची विभाजक का सामना करने तक इंतजार करना ठीक है।
• उन भाषाओं में जो उनका समर्थन करती हैं, आप एक फ़ंक्शन लिख सकते हैं जो एक आलसी अनंत सूची या स्ट्रिंग देता है।
• ऐसी भाषाओं में जो उनका समर्थन करती हैं आप एक अनंत जनरेटर को लागू कर सकते हैं जो इनपुट के रूप में एक और जनरेटर लेता है।
• वैकल्पिक रूप से, आप एक फ़ंक्शन लिख सकते हैं जो कोई तर्क नहीं लेता है और प्रत्येक बार इसे कहा जाता है एक आउटपुट मूल्य देता है। इस मामले में, आप मान सकते हैं कि एक फ़ंक्शन को परिभाषित किया गया है जो कोई तर्क नहीं लेता है और अगली इनपुट वैल्यू को हर बार इसे वापस लौटाता है। आप स्वतंत्र रूप से उस फ़ंक्शन का नाम चुन सकते हैं।

आप मान सकते हैं कि आपका कार्यक्रम हमेशा के लिए चलता है और वह अनंत स्मृति उपलब्ध है। (इसे हल करने के लिए एक सीमित मात्रा में मेमोरी संभव है, लेकिन इसका मतलब यह है कि आपको मेमोरी को लीक करने की अनुमति है।)

यादृच्छिकता के बारे में

किसी भी मूल्य v के लिए जिसे अनंत इनपुट की स्थिति i पर पढ़ा जाता है , इसके लिए कोई सकारात्मक संभावना होनी चाहिए कि यह अनंत आउटपुट के i-9 से i + 9 तक किसी भी स्थिति में समाप्त हो सकती है (जब तक कि स्थिति नकारात्मक नहीं होगी )। इन संभावनाओं को अलग-अलग आउटपुट स्थितियों या अलग-अलग इनपुट स्थितियों के लिए समान नहीं होना चाहिए। यह ठीक है अगर आपका समाधान उन मूल्यों को अन्य स्थिति में फेरबदल कर सकता है जो आगे दूर हैं।

इसलिए, यह आवश्यक नहीं है कि आपका समाधान सूची से पहले मूल्य को बहुत दूर कर सकता है, या यह पहली स्थिति तक बहुत देर के मूल्य को फेरबदल कर सकता है, हालांकि यह ठीक है अगर ऐसा होता है, जब तक कि सभी चरण 9 चरणों से नहीं हो जाते। इनपुट संभव हैं।

उदाहरण के लिए यदि आपने निम्न स्ट्रिंग को इनपुट के रूप में लिया है, तो ___उन सभी पदों को इंगित करता Xहै जो आउटपुट में समाप्त होने में सक्षम होने चाहिए:

                  ___________________
 abcdefghijklmnopqrstuvwxyzXabcdefghijklmnopqrstuvwxyz...

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

वास्तविक समाधान के बावजूद आपका समाधान उपयोग करता है, यह निश्चित रूप से परिमित (लेकिन मनमाना) समय के बाद अगले मूल्य का उत्पादन करना चाहिए ।

कृपया इस बारे में एक संक्षिप्त विवरण शामिल करें कि आपका कार्यान्वयन इन आवश्यकताओं को कैसे पूरा करता है।

स्कोरिंग

यह कोड-गोल्फ है , इसलिए सबसे छोटा वैध उत्तर - बाइट्स में मापा जाता है - जीतता है।

लीडरबोर्ड

श्रृंखला की पहली पोस्ट एक लीडरबोर्ड उत्पन्न करती है।

यह सुनिश्चित करने के लिए कि आपके उत्तर दिखाए गए हैं, कृपया प्रत्येक मार्कलाइन के साथ निम्नलिखित मार्कडाउन टेम्प्लेट का उपयोग करके प्रत्येक उत्तर को शुरू करें:

# Language Name, N bytes

Nआपके प्रस्तुत करने का आकार कहां है। यदि आप अपने स्कोर में सुधार करते हैं, तो आप पुराने अंकों को हेडलाइन में रख सकते हैं , उनके माध्यम से स्ट्राइक करके। उदाहरण के लिए:

# Ruby, <s>104</s> <s>101</s> 96 bytes

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

Comments

क्या हम अनंत समय / स्मृति को उपलब्ध मान सकते हैं?

— मेगो

यदि भाषा में कुछ यादृच्छिक संख्या जनरेटर कहा जाता है, तो क्या हमें वास्तव में इसका उपयोग करने की आवश्यकता है?

— फेरेसम

@Mego अनंत समय, जाहिर है। और अनंत स्मृति, हाँ हमेशा की तरह चुनौतियों के लिए जिन्हें प्रोग्राम को हमेशा के लिए डेटा संसाधित करने की आवश्यकता होती है (यह परिमित मेमोरी में इसे हल करना संभव है, लेकिन मैं उन भाषाओं को दंडित नहीं करना चाहता जो मेमोरी को लीक करने के लिए मजबूर हैं)।

— मार्टिन एंडर

@ फैरसुम मुझे शायद स्व-निर्मित यादृच्छिक संख्या जनरेटर की आवश्यकताओं को थोड़ा अधिक सटीक रूप से निर्दिष्ट करना चाहिए, लेकिन मैं ज्यादातर मामलों में एक अंतर्निहित आरएनजी से कम होने के लिए अपने स्वयं के कार्यान्वयन की कल्पना नहीं कर सकता हूं?

— मार्टिन एंडर

@ Faersum मैंने उस हिस्से को थोड़ा स्पष्ट किया है और यादृच्छिकता के लिए हमारी मानक परिभाषा से जुड़ा हुआ है।

— मार्टिन एंडर

Answer 1

पायथन 3 , 78 बाइट्स

from random import*
l=[]
while[shuffle(l)]:l[9:]and print(l.pop());l+=input(),

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

STDIN (एक प्रति पंक्ति) से इनपुट लेता है, STDOUT पर प्रिंट करता है।

l10 तत्वों तक का एक बफर रखता है । बफर को प्रत्येक चरण के साथ बदल दिया जाता है। जब इसकी लंबाई 10 होती है, तो अंतिम तत्व मुद्रित और हटा दिया जाता है।

यदि कोई तत्व डाला जाता है जैसे ही इसे डाला गया था, यह बफर में प्रतीक्षा कर रहे 9 अन्य तत्वों के आगे छोड़ दिया गया है, इसलिए यह 9 स्थानों को छोड़ दिया दिखाई देता है। एक तत्व बफर में लंबे समय तक इंतजार कर सकता है, इसलिए इसकी स्थिति किसी भी राशि को सही तरीके से स्थानांतरित कर सकती है।

किसी सूची से एक यादृच्छिक तत्व का उत्पादन और निकालने का एक अच्छा तरीका नहीं लगता है। फेरबदल की तरह लगता है। यह 2 बाइट्स का उपयोग करने के लिए लंबा है l.pop(randint(0,9))(जो उपयोग करता है कि सूची में 10 तत्व हैं)।

from random import*
l=[]
while 1:l+=input(),;l[9:]and print(l.pop(randint(0,9)))

यह करने के लिए बेहतर नहीं है x=choice(l);l.remove(x)। एक भाषा poprandomजैसी

poprandom = lambda l:l.pop(randrange(len(l)))

बहुत सफाई से कर सकता था

from random import*
l=[]
while 1:l+=input(),;l[9:]and print(poprandom(l))

Answer 2

Befunge ( quirkster स्वाद ), 4 बाइट्स

?,?~

,धारा से एक चरित्र को पढ़ता है और इसे स्टैक पर धकेलता है। ~स्टैक से शीर्ष वर्ण (यदि मौजूद है) और इसे प्रिंट करता है। ?यादृच्छिकता है कि कौन सी कमांड अगले निष्पादित की गई है। इसलिए यहाँ एल्गोरिथ्म है "एक अनंत लूप में, समान संभावना के साथ या तो एक चरित्र को धक्का देते हैं या एक चरित्र को पॉप करते हैं।" मुझे लगता है कि यह आवश्यकताओं को संतुष्ट करता है: एक चरित्र मनमाने ढंग से ढेर में इसके ऊपर जोड़े गए कई पात्रों को देख सकता है, इसलिए यह मनमाने ढंग से दाईं ओर जा सकता है, और इसे तब मुद्रित किया जा सकता है जब स्टैक मनमाने ढंग से बड़ा हो, इसलिए यह मनमाने ढंग से आगे बढ़ सकता है छोडा।

Comments

क्या यह आउटपुट शून्य बाइट्स नहीं है यदि स्टैक खाली है?

— फेरेसम

मैं जिस कार्यान्वयन से जुड़ा था वह नहीं करता है; मैं Befunge कल्पना से सहमत होना चाहिए।

— हिस्टोक्रेट

मजेदार, ब्राउज़र अशक्त बाइट खाता है। यह पुटचर के अपने कार्यान्वयन को बुलाता है ("\ 0"), लेकिन FF इसे HTML से >> document.getElementById("output").innerHTML = "a\0b" >> document.getElementById("output").innerHTML "ab"

— शुद्ध करता है

अहा, मुझे आश्चर्य हुआ कि क्या ब्राउज़र में कुछ अजीब हो रहा था। मुझे लगता है कि मेरा क्रोम भी ऐसा करता है। ठीक है, तो यह एक तकनीकी की एक बिल्ली है, लेकिन मुझे लगता है कि यह एक समाधान पोस्ट करने के लिए साइट की भावना में अधिक या कम है जो केवल कुछ व्याख्याताओं में काम करता है जो कुछ वातावरणों में चलते हैं।

— हिस्टोक्रेट

Answer 3

सी (जीसीसी) , 94 बाइट्स

L;i;f(s){srand(s);int B[9]={0};for(L=0;;)L>9&&putchar(B[i=rand()%10]),B[L>9?i:L++]=getchar();}

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

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

#include <stdlib.h>
#include <stdio.h>
#include <time.h>
int main(int argc, char** argv){
    srand(time(NULL));
    if(argc < 1) {
        for(;;){
            printf("%c", rand() % 95 + 32);
        }
    } else {
        char* s = argv[1];
        int i = 0;
        for(;;){
            if(s[i] == 0)
                i = 0;
            printf("%c", s[i++]);
        }
    }
}

इस कार्यक्रम के रूप में जाना जाएगा iro।

कार्यक्रम की शुद्धता

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

Answer 4

एसआईओएस , 149 बाइट्स

b=1
lbla
x=15+b*15
b=1
lblb
readIO
queue 0 i
x-1
if x b
a=0
lblx
x=rand*2
queuePop 0
if x X
printInt m
a+1
b=15-a
if b x
GOTO a
lblX
queue 0 m
GOTO x

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

अनिवार्य रूप से यह इनपुट लेती रहती है (ऑनलाइन दुभाषिया पर तर्कों के माध्यम से, लेकिन ऑफ़लाइन आधिकारिक दुभाषिया पर यह आपको एक समय में 15 (30 पहले ब्लॉक) के ब्लॉक में कंसोल (असीम रूप से) में टाइप करने की अनुमति देगा।

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

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

---

परिणामों को बेहतर तरीके से देखने के लिए मेरे पास एक गैर-अनुपालन संस्करण है जो एक स्ट्रिंग के रूप में इनपुट लेता है (हालांकि यह केवल 8,000 या अन्य वर्णों में ले सकता है)।

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

बस मज़े के लिए, यहाँ इस पोस्ट को स्ट्रिंग संस्करण के माध्यम से खिलाया गया है।

 [.L.Ooy "9beS.IS]," 14 ts b1
 केवल तभी

  = डालूँगा
   x = 1b 15 1
5 बी ए * बी = एलबी आरडी # + एलबी ईआईआई ओ ई 
 एक्स
 ifquu   
1 0x बी
   =

    ई
0
   मैं लब्सा -d * २
    quu x = rn 
   x Xea p0
   pnInt ओरा
   mf = iePit
  बा १
   जीटीओ 1 एफबी एक्स + ओए


 क्यूई -ब्लाक्स u0 m GOOue  
[RLT 

 tnn5! I.STii] [S.LO यानी

htpsgthyx]: iub.om/jhujh .. tcraa.IOo /TytonieSu:wl/.L lnn!: tt / iS!
[Hsto.un में / nuslprxRUCoDsio /]: e#NzZn6j4c/2xNQFnF7y0aLzkrosd9Dov2yxJNx774HBrgPUdi9CySI09sCLw5TJwB7jlB1XVeQFE7m1VMsIQvDOjBmdtME3umNzYXs9unFbqRamVDfUDw@RT3NHoL7/i04bz16DCoP4eulOU7jPD8OmYjATpynkuMDuBPYmtnIJzseyyhaNkMyQgXG2R782vqMDIiUm6Kq4Q3mJkxlUsR1rrldPw./l28Z SL.XS - IONuscOT "
senallyxMz.stiitkp ingN "
 heeInliinrprt (oe e toghr tetgpnmntuon eruEuut rh ofi off, bhenecil inretea.atr ialoks tirilweeitfleptly ty honso (e oote cenfine iwllbc) नाइटी नाइटी 15 से 15 वर्ष की उम्र में शिशु की मृत्यु हो सकती है।
एचएस 0 इट ते 
 लॉडशिपो अलॉटेट। प्रेमपुरा क्वेट आई रीनेक्स ए लिक ईओय डी रैंडम पी 15 (यूओ एकुल, अनबेटी ड्रबटेंटेनिस्टिनिम्स ऑफ टोटली ऑर्डिस्रप्रो बीमार एबिशन एचआईबेटमिन.टेट री)
 a nwit u ree nusfil th queusen 
pte ftip, ae uldsfuesis ob hl rlelth weual t tc hdyoend, f tbaaly thi a elnkhecarcthe (sc ho noreiItrolwaaldibtio bmiru.t 'iereaf) tsng tetntiottssht prasun hogIms केवल योगासन के योग हैं।
 tte s / "जी.टी. 
obterelIe tsvea गैर- omhTrehs rwvritcaw aa g (hoee n onl kein n00 orscat, 0 cter) पर एक तख्ती hcahihk ine teuts sriprics।

[त्यउआस यह ओनियन! रथ्रस:।आरयू] ​​पी // ओ / lsslo # JVD (tinnexi3E @ KDpit / LrhtwXwVEUuscxPmJjFFCaNimMzlHiQEcMmdVIT7vqs8mNgxU3mD / J1AwXक्यू / ivbao1j @ nb4I6 / m93655bThmb4cy5TUX3xvI018cZzrXItuO5B @ NX5JD / HzyE @ जी @ D5eqrGem3l0HPGRutZfpi2PzVA @ d3CVRTm4zJxnZdcFSTEO0JOT9KhDI6byjnLhS0cNmGz7hJrTdAgORT8Ndvv7DgZSbJdkp9v5al8qMyNCb9tXe0ChrShXRTOt @ 7fFgV3zTkbVbsD @ JpKina2oKgNVakjsjLCpD29u7l0XVRWalVTyArF1FqypQAxXb / BedqUqpJGOPVyxOjLj0jXup8cE277L2I6 @ lSowK5pA7nGldRBiJwyKxF6z2c3kW / sJ4EYBbbpSuBxs55nyI9sdnu @ nJJeGqtKprGEUbc6NDGMjjO2tN / KuKTWh2WWbbRRLVaq / P6KqkoMNWGRgTQZLlbXfQI050bY0rz0xmzCVZ4vowjpV0dCmkDFq0VNa5GSDzVn5Qw7idwPTxu5xTAtLQCDN / YIApfAn4dsDmYksCqUU27sRggpzRK4SmdjmPUPQO4j5FmgHMFRWS2eI1CfA2YIcf7JlylFjdZypVTH0IJu4ZJHiUviyBFKqhrkCjgXAAB8d710NhHgDwcJksuvPPprcfzHPTaJGFX8OIExW / cBZjaPiY7a4WD6rTYmOouBVucROlwvuBJiHWdJQjjbobNGTd7M1P6z8dw / ए @ GU02hgjCcrjjQHkAdS6r7UjQ6wAPqB @ sIgxkKcbZDixeWS6mn160CKQpn7aUwGLK22u9I0oX6YIwPMhFVaX5uYon0AyoNTCZvnmtilVhV3 / pgTGc7r39lIS5PmqM / NGnUSLnTw9eTJ7qqrNQKsJHz @ Tt8mDZVWKCKTkBro1PuQAksDdN1yaVGiVXElRW9i5M11cINmxNGYAg9TD7sxtEDI2OkKMaBXgvO5dOplUQQIdpb2w66NePBScMmEnAX8ydGSiiHlss @ hOLZzInnIoTevRtEm / TGHWOkly5ljMK4FkgDDSWCWBW3YwmEVYCIBV @ GMIg3TZtGwMFWXVxQwBb5iD6PfS7h7Sric1ib5ZYIvW6n3tlaK7 / 6 @ 3OAHy4LjOuW @ tzaBP3 @ mFbJpHsVsQKPfeui / O1 @ aBcbZ4TK96T8tp3QjeA1vDXMKBIqdK @ HZs2vsMlQE36YmrBEnVRUvAGNuCt44e0RB0sL0MkNu1Q5wOwliTT2JQzVrOnHAmSXIU // sqjdG6jdT2r1v @@ lGjouzkGWoD4zhnzJBxo0OT6OTbBDgeDFRnY8TMXZbMPdxsCtbXeUxIBqST4VRwkpbgwChBcJxMx6hLIVZhfuylDvF1l26Nbl3xRLgQnatSCMigx @ PCT6lcG1ebdk / 86UBUFp9UkxjoCGSJnlxMtUdHf6IjkMnil5aua9L @ xXsdHEKW @ 8JpVqlgKsr12bAKG2Typfv @ Yy4CkUydETWphcdmdpWq7egtxqP8pYI2rSaSuYBwW0tNTdXn4qcjnZ9JKhuVwaWRycwCWt247LSflsCHsB3u0KoLTQJzL1uMl0duij / IF7LCc5FSpIPW7gcjOYj @ jQdpQHv0WUz / IbMhS0XmFiWm1i0cTbxXjsjLxt6nGmQNQoKfREklc8pTFyHub7jUg8TR4QrZ2w3YjaLWNi @ FFerCnNgY0LqgrA6qkWg8H / 7Pv6YhtqeZzvoB0yD5Wm1eLL1Vf / SouI0Q / fox7eQlXieZB1F1v2 / में / btqyVPtubWhDIKH8WaTlry43N6HgOEzX5HOjv1 @ lamBeZlJpqJnG3B2LZe8sXUafdAcVvVjBBlqxbEThCdjpelc7YVuYXOqM8MyVV3iPxbqYu @ nmbHnoKpK1Eww11sA9aiwN8kMe0ioVO7qnucL1A8wHJ4wTsdltrm3CC4bpCd5hMhyDGXSdGgdKvnCKUpNB9nH @ wXLgu5iUEcfJbDKZFjx6gI9i8fCcUFiQXxeSbKnwhT6 @ v / I6yS / Ew9k @ tgI68 / LO @ 4jjx0PZBpSo5vWLCDi4zb @ TJejQQPtvlgde98MDGJ4vUW3T @ iJTA89gGhUJIgy @ MDBpaz3s7PT2ZIwStVANsxpCmhghh68huncD0VdumQt0lT / Su6HW3kMLFfo / FphQ0QhtoZ5iRN / @ हर्ट्ज / DmHq8UZEgiblprekkw1I366fMhePmDclSxirOlYH2Hwe3fom3aoe1 @ yaQYwi5ZPd2FcITXO7cu9 @ 6tiHZJc7lKSB8e3 / mXx34xYH / 8F @ TUxx / 5vs5yHsYBL4ekscycqT1BnuV19 / "SFE / iRAIL.O NqUXAm। T3zDreu) .S -IOxs। "dघघ

Comments

आपका हेडर लीडरबोर्ड को तोड़ सकता है - यदि आप रैंडम गोल्फ ऑफ द डे प्रतियोगिता में भाग लेना चाहते हैं तो मानक प्रारूप का उपयोग करना एक अच्छा विचार होगा।

— wizzwizz4

@ wizzwizz4 तय

— रोहन झुनझुनवाला

Answer 5

एसीटो , 24 बाइट्स, गैर-प्रतिस्पर्धात्मक

गैर-प्रतिस्पर्धा क्योंकि मुझे दुभाषिया में एक बग को ठीक करना था।

^




OYpO
r^`!
?d0=   >

लाइनों की एक अनंत धारा लेता है और एक यादृच्छिक क्रम में उन्हें पैदावार देता है। प्रत्येक तत्व को किसी भी यादृच्छिक बिंदु पर होने का मौका मिलता है।

हम ?नीचे बाएं कोने में एक के साथ शुरू करते हैं , जो हमें एक यादृच्छिक दिशा में ले जाता है। यदि वह नीचे है या बायीं ओर है, तो हम दाएं पीछे धकेलते हैं।

यदि हम ऊपर की ओर बढ़े हैं, तो हम rएक मान लेते हैं , स्टैक को फेरबदल करते हैं ( Y), और Oरिगिन पर वापस जाएं।

यदि हम दाईं ओर चले गए हैं, तो हम dशीर्ष स्टैक मान को बढ़ाते हैं, a 0और समानता के लिए परीक्षण करते हैं (क्योंकि हम स्ट्रिंग्स पढ़ रहे हैं, हमारे पास पूर्णांक 0 कभी नहीं हो सकता है)। यदि मान समान हैं, तो इसका मतलब है कि हम स्टैक के निचले भाग पर पहुँच गए हैं (जहाँ से हम प्रिंट नहीं करना चाहते हैं)। हम नकारते हैं तुलना की करते हैं ( !), और pकेवल तभी (यदि `चीजें बराबर नहीं थीं)। फिर हम भी Oरिगिन में वापस कूद जाते हैं।

Answer 6

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

l=[];loop{l<<gets;l[9]&&$><<l.shuffle!.pop}

मेरे मूल उत्तर ने एक आलसी-मूल्यांकन वाली अनंत सूची का उपयोग किया, लेकिन यह कम है। ओह अच्छा।

Answer 7

MATL , 11 बाइट्स

`rEkN*?D}iT

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

पोर्ट ऑफ़ हिस्टोक्रेट्स बीफुन्ग उत्तर ।

स्पष्टीकरण: (लुइस मेंडू के लिए धन्यवाद -1 बाइट के लिए)

`         T % Start do-while (`) .... true (T)
 rEk        % 50-50 chance of outputting or inputting:
            %   Random number between 0...1, multiplied by 2 and converted to logical. 
    N       % Check if there is anything on the stack to output
     *?     % If there is anything on the stack and (*) we want to output:
       D    % Output. Sadly, D errors when the stack is empty, requiring the N*
        }i  % Else, input.

यह परिमित समय में लगभग निश्चित रूप से आउटपुट करता है, और लगभग निश्चित रूप से केवल परिमित मेमोरी की आवश्यकता होती है ।

पूर्णता के लिए, यहां एक 15-बाइट संस्करण है जो 10-तत्व बफर रखता है और उससे एक यादृच्छिक तत्व उत्पन्न करता है:

`htnt9>?Yr&)wDT

मुझे बहुत ही मुहावरेदार (जहाँ तक गोल्फ भाषाएँ मुहावरेदार हो सकती हैं) के लिए यह संस्करण पसंद है tn...Yr&), जो सूची से एक यादृच्छिक तत्व पॉप करता है और उस तत्व के बिना सूची लौटाता है। हालांकि, इस चुनौती के विशेष लॉजिस्टिक्स में बहुत सारे बाइट्स ( wप्रदर्शन के लिए आवश्यक , यह t9>?जांचने के लिए कि सूची पूरी तरह से पर्याप्त है ...) जोड़ें।

Answer 8

ऐलिस , 7 बाइट्स

a&IdU,O

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

यह अनंत समय और स्मृति के साथ एक अनंत इनपुट पर काम करना चाहिए, लेकिन अभ्यास में परीक्षण करना इतना आसान नहीं है :)

व्याख्या

a&I         Push 10 characters from the input to the stack.
     d        Push the depth of the stack.
      U       Pop a number (d), push a random number in [0,d)
        ,       Pop a number (n), move the element which is n elements below the top to the top of the stack.
         O    Output the character on top of the stack.

                Execution loops back to the beginning of the line.

प्रत्येक पुनरावृत्ति में 10 वर्ण इनपुट से पढ़े जाते हैं और केवल एक आउटपुट पर जाता है, इसलिए मेमोरी उपयोग निष्पादन के दौरान रैखिक रूप से बढ़ता है। एक परिमित इनपुट के साथ यह तेजी से ईओएफ तक पहुंचता है, जिसमें से दस -1 को प्रत्येक पुनरावृत्ति पर स्टैक पर धकेल दिया जाएगा। एक चरित्र के रूप में आउटपुट -1 की कोशिश का कोई प्रभाव नहीं पड़ता है, लेकिन यह संभावना नहीं है कि इनपुट के सभी वर्ण उचित समय में मुद्रित होंगे।

आउटपुट की स्थिति i को 10i की स्थिति तक इनपुट में किसी भी पात्र द्वारा लिया जा सकता है , यह चुनौती का अनुपालन करता है, जिसके लिए i-9 से i + 9 तक कम से कम रेंज की आवश्यकता होती है ।

Answer 9

सी, 214 बाइट्स

c;i;char B[19]={0};char*I;
S(p,q){if(B[p]-B[q])B[p]^=(B[q]^=(B[p]^=B[q]));}
R(n){while(n--)putchar(B[c]),B[c]=*I,c=++i%19,I++;}
main(c,v)char**v;{srand(time(0));I=v[1];R(19);i=9;for(;;){S(i,rand()%19);R(1);i=++i%19;}}

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

ऑनलाइन प्रयास करें (UNIX)

#include <stdio.h>
#include <unistd.h>

// animation speed
#define ANIMATION_SLOW 600000
#define ANIMATION_NORMAL 400000
#define ANIMATION_FAST 200000

c;i;char Buffer[19]={0};char*input;
Swap(p,q){if(Buffer[p]!=Buffer[q])Buffer[p]^=(Buffer[q]^=(Buffer[p]^=Buffer[q]));}
Read(n){while(n-->0)putchar(Buffer[c]),Buffer[c]=*input,c=++i%19,input++;}

main(int argc, char**argv)
{
    // initialization
    srand(time(0));
    input=argv[1];
    Read(19);i=9;

    // shuffle machine
    while(1)
    {
        usleep(ANIMATION_NORMAL);
        Swap(i,rand()%19);
        Read(1);
        i=++i%19;
    }
}

Comments

आपके आरेख में "स्वैप" का क्या अर्थ है?

— मार्टिन एंडर

@MartinEnder का अर्थ यह है कि प्रश्न मानदंड को पूरा करने के लिए कहां से Viस्वैप किया जाता है Vjj = RAND [ i-9, i+9 ]v which is read at a position i of the infinite input, there must be a positive probability for it to end up in any of the positions i-9 to i+9 of the infinite output

— खालेद

आह कि समझ में आता है, धन्यवाद।

— मार्टिन एंडर

क्या मैं पूछ सकता हूं कि आपने अपना आरेख बनाने के लिए किस उपकरण का उपयोग किया था?

— दादा

@Dada Gliffy

— Khaled.K

Answer 10

05AB1E , 13 बाइट्स

[I)˜¼¾T›i.rć,

इसे ऑनलाइन आज़माएं! (20 तत्वों को लेने के लिए संशोधित)

[             # Infinite loop
 I)˜          # Add the next element from input to the array
    ¼         # Increment the counter variable
     ¾T›i     # If the counter variable is greater than 10...
         .r   #   Get a random permutation of the array
           ć, #   Print and remove the first element 

Answer 11

बैश , 17 बाइट्स

xargs -n9 shuf -e

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

xargs लगातार STDIN से 9 पत्र लेता है और उन्हें फेरबदल करने के लिए भेजता है

एक अनंत सूची द्वारा उत्पन्न किया जा सकता है:

yes {a..z}

जो प्रिंट करता है abcde .. z अनंत बार।

परीक्षण द्वारा किया जा सकता है:

yes {a..z} | xargs -n9 shuf -e 

Comments

नहीं यकीन है कि अगर xargs shuf -eसंतुष्ट आवश्यकताओं

— marcosm

Answer 12

आर, 70 बाइट्स

x=NULL;repeat{x=sample(c(x,scan()));if(sum(x|1)>9){cat(x[1]);x=x[-1]}}

एक खाली वेक्टर के साथ शुरू होता है x। एक अनंत लूप में, यह STDIN से एक नया मूल्य लेता है, फिर वेक्टर को फेरबदल करता है। फिर यह जांचता है कि निर्मित सूची की लंबाई 10 या अधिक है या नहीं। यदि यह है, तो यह मुद्रण शुरू कर सकता है। इस तरह वेक्टर में 10 इनपुट का बफर होता है, प्रत्येक को प्रत्येक पुनरावृत्ति में फेरबदल किया जाता है। तो यह संभव है कि इनपुट के लिए पहले 10 स्थानों को मुद्रित किया जाए, और बाद में कई स्थानों पर (बाद में एक ज्यामितीय वितरण के बाद p=1/10)। जब बफर काफी लंबा होता है, तो पहला तत्व वेक्टर से मुद्रित और हटा दिया जाता है।

Answer 13

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

for(l=[];;){l.push(prompt());l.length==10&&alert(l.splice(Math.random()*9,1))};x.sort(()=>Math.random()<0.5);alert(x)}

Xnor के उत्तर के समान विधि का उपयोग करता है।

Answer 14

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

कोड + -nध्वज के 38 बाइट्स ।

print splice@F,rand 10,1if 9<push@F,$_

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

@Fसरणी (के साथ push@F,$_) में प्रत्येक तत्व जोड़ें । जब @F10 तत्व होते हैं ( pushसरणी में तत्वों की संख्या लौटाते हैं, इसलिए 9<push...), एक यादृच्छिक तत्व हटा दिया जाता है और मुद्रित किया जाता है ( splice@F,rand 10,1तत्व को निकालने के लिए, printइसे प्रिंट करने के लिए)।
उत्पादन तब शुरू होता है जब 10 वें तत्व को पढ़ा जाता है। इसलिए, प्रत्येक तत्व अपने मूल एक से पहले कम से कम 9 पदों को प्रदर्शित करना शुरू कर सकता है, और असीम रूप से सही पर स्थानांतरित किया जा सकता है।

Answer 15

स्माइलबासिक, 61 58 बाइट्स

@L
B$=B$+R()IF I>8THEN R=RND(9)?B$[R];:B$[R]="
I=I+1GOTO@L

अनंत सूची के प्रत्येक वर्ण को बफर के अंत में जोड़ा जाता है। जब बफर की लंबाई 11 होती है, तो एक यादृच्छिक चरित्र मुद्रित और हटा दिया जाता है।

फंक्शन Rअगला चरित्र उत्पन्न करता है।

Answer 16

प्रोलॉग, 70 बाइट्स

s(L):-get0(C),(length(L,9)->random_select(H,L,R),put(H);L=R),s([C|R]).

Comments

क्षमा करें, मैंने यह नहीं कहा कि इसे कैसे बुलाया जाए: s ([])। जैसे खाली सूची के साथ।

— पीटर रिंटजेस

PPCG में आपका स्वागत है! क्या आप बता सकते हैं कि यह कैसे काम करता है? मुझे यकीन नहीं है कि आप "एक खाली सूची के साथ जैसे" से क्या मतलब है। समाधानों को अनंत सूचियों के साथ काम करना चाहिए (और केवल काम करने की आवश्यकता है)।

— मार्टिन एंडर