सरलीकृत लावा लैंप

18

परिचय:

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

यहाँ छवि विवरण दर्ज करें
(छवि स्रोत)

वे मूल रूप से कांच की नलियाँ हैं जिनमें पारभासी तरल में मोम होता है। दीपक चालू होने पर नीचे का हिस्सा गर्म हो जाता है, जिससे घनत्व में बदलाव होता है और इस तरह मोम ऊपर तैरता है। जब यह ठंडा हो जाता है, तो यह फिर से नीचे गिर जाता है, जिससे हमें ऊपर दिखाई देने वाला प्रभाव दिखाई देता है।

आमतौर पर तापमान में वृद्धि के लिए दीपक के आधार के बारे में 45-60 मिनट लगते हैं ठोस मोम को तरल मोम में बदलने के लिए (यदि दीपक कमरे के तापमान पर एक क्षेत्र में स्थित है)।

विकिपीडिया पर अधिक जानकारी, जिसका उपयोग ऊपर के कुछ पाठों के स्रोत के रूप में भी किया जाता है।

चुनौती:

एक सकारात्मक पूर्णांक को देखते हुए, जो nहमने लावा लैंप को चालू करने के बाद से मिनटों की मात्रा का संकेत दिया है, पांच स्तरों पर पूर्णांक के आधार पर लावा लैंप की एक यादृच्छिक स्थिति का उत्पादन करता है।

इस चुनौती के लिए हम कहेंगे कि लावा लैम्प में कुल 1000 इकाइयाँ होती हैं, और हमारे पास पाँच स्तर हैं जहाँ मोम हो सकता है।

1) अगर n45 से नीचे है, तो लावा लैंप अभी भी गर्म हो रहा है, इसलिए आउटपुट नीचे के साथ चार खाली लाइनें होगी 1000:





1000

2) अगर nरेंज [45, 60)में लावा लैंप तापमान में वृद्धि के लिए मोम के चारों ओर बढ़ने के लिए पर्याप्त है, लेकिन अभी तक बहुत अधिक नहीं है। मोम तीसरे स्तर तक पहुंच सकता है और इसमें शामिल है।
3) अगर nहै 60या अधिक, मोम पाँच स्तरों में से किसी में हो सकता है।

इसलिए nइनपुट के रूप में सकारात्मक पूर्णांक दिया गया है , हम तीन नियमों को ध्यान में रखते हुए एक यादृच्छिक स्थिति का उत्पादन करेंगे ।

यहाँ कुछ उदाहरण आउटपुट हैं:

किसी भी संभावित आउटपुट nजो है >= 45:



523
106
371


913

87

किसी भी संभावित आउटपुट nजो है >= 60:

73
113
312
5
497
284
55
637

24

nउस के लिए लगातार उत्पादन <= 44(और किसी के लिए संभव उत्पादन n) है:





1000

चुनौती नियम:

  • खाली लाइनें हो सकती हैं, भले ही इसके ऊपर का स्तर खाली न हो।
  • बस 0किसी भी लाइन पर अनुमति नहीं है। इसके बजाय खाली होना चाहिए।
  • आउटपुट कुछ लचीला है। आपको ऊपर की तरह एक नई-पंक्ति सीमांकित परिणाम के बजाय स्ट्रिंग / ऑब्जेक्ट की सूची / सरणी को आउटपुट करने की अनुमति है। मैं कहता हूं कि तार / वस्तुएं ऊपर दिए गए नियम के कारण हैं। एक खाली पंक्ति होना चाहिए "", null, [], आदि, लेकिन नहीं किया जा सकता 0है या एक नकारात्मक पूर्णांक (और न ही यह हो सकता है false) (Ie ["", "", 913, "", 87]के लिए n >= 45)। आपको आउटपुट रिवर्स करने की अनुमति है (यानी 1000\n\n\n\nइसके बजाय \n\n\n\n1000या [87, null, 913, null, null]इसके बजाय [null, null, 913, null, 87])।
  • संख्या सभी पूर्णांक होनी चाहिए। 0दशमलव मूल्य के रूप में दशमलव हो सकता है , लेकिन संख्याओं में से कोई भी दशमलव अंक नहीं होना चाहिए, और पूर्णांकों को हमेशा ठीक होना चाहिए 1000।
  • सभी संभावित रैंडम आउटपुट के आधार पर nगैर-शून्य होने की संभावना होनी चाहिए।
  • अनुगामी नई-पंक्ति (इसलिए आउटपुट की छह लाइनें हैं) की अनुमति है।

सामान्य नियम:

  • यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
    कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
  • मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति दी जाती है। तुम्हारा फोन।
  • डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
  • यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
  • साथ ही, आपके उत्तर के लिए स्पष्टीकरण जोड़ने की अत्यधिक अनुशंसा की जाती है।
code-golf  number  random  integer 
— केविन क्रूज़सेन
स्रोत
— स्टैण्डओवरफ़्लो
क्या खाली स्थान को एकल स्थान के साथ दर्शाया जा सकता है?
— अरनुलद
@ अरनुल ज़रूर 0एक नकारात्मक संख्या, या को छोड़कर , कुछ भी हो सकता है false।
— केविन क्रूज़सेन
क्या आउटपुट हमेशा 5 स्तर पर होता है, तब भी n < 60?
— एमिग्ना
@Emigna हाँ, आउटपुट हमेशा 5 स्तर का होता है। के लिए n < 45केवल 1 स्तर तथापि भर जाता है, जो (ऊपर या नीचे के क्रम में यह उत्पादन के आधार पर) 1000। साथ 45 <= n < 60पांच में से तीन, और साथ n >= 60सभी पांच। लेकिन आउटपुट में हमेशा पाँच 'लाइनें' होंगी।
— केविन क्रूज़सेन

जवाबों:

5

मैथॉल्फ , 21 20 बाइट्स

5º*♪{k[K∞╟(]m<Σ∞wΦ}σ

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

यह मेरी नई भाषा में मेरा पहला उत्तर है। मैंने Emigna के 05AB1E समाधान पर अपना समाधान आधारित किया, लेकिन इसे थोड़ा छोटा बनाने के लिए MathGolf की कुछ साफ-सुथरी विशेषताओं का उपयोग किया।

व्याख्या

5º*                   push 5, [0], multiply (yielding [0,0,0,0,0]
   ♪                  push 1000
    {                 start block
     k                push input as integer
      K∞              push 22 and double it, yielding 44
        ╟(            push 60 and decrease, yielding 59
          α           wrap last two elements in array, yielding [44,59]
           m<         map is less than, giving [0,0], [1,0] or [1,1]
             Σ        sum array, giving 0, 1 or 2
              ∞       double, giving 0, 2 or 4
               w      push random integer in range
                Φ     increase array element
                 }    execute for loop (loops 1000 times)
                  σ   convert to string and remove leading zeroes (implicit map)
— maxb
स्रोत
यदि इस चुनौती के लिए सुविधाएँ स्वयं निर्मित नहीं हैं, तो गैर-प्रतिस्पर्धी टैग आवश्यक नहीं होगा। पिछले साल के मध्य से गैर-प्रतिस्पर्धा अब कोई बात नहीं है। चूंकि यह बहुत नया है, इसलिए मुझे लगता है कि आपकी भाषा के लिए अभी तक कोई ऑनलाइन संकलक नहीं है? क्या आप शायद सत्यापन के रूप में कुछ स्क्रीनशॉट (या स्क्रीनशॉट के लिंक जोड़ सकते हैं अगर यह पोस्ट को बहुत अधिक अव्यवस्थित करेगा)? और मैं @Dennis से संपर्क करके पूछूंगा कि क्या आपकी भाषा TryItOnline में जोड़ी जा सकती है ।
— केविन क्रूज़सेन
2
@KevinCruijssen प्रतिक्रिया के लिए धन्यवाद! मैं कुछ स्क्रीनशॉट जोड़ूंगा, और मैं TIO को भाषा प्राप्त करने पर काम कर रहा हूं। मैं एक बार डेनिस से संपर्क करूँगा क्योंकि मुझे लगता है कि मैं लगातार नई सुविधाएँ नहीं जोड़ रहा हूँ।
— मैक्‍सब
क्या आपने अपनी भाषा के लिए एक कमरा बनाने पर विचार किया है ? मुझे इसे सीखने में बहुत दिलचस्पी है!
— जो किंग
@JoKing आप रुचि रखते हैं सुनने के लिए खुश! मैं इस सप्ताह के अंत में कुछ समय के लिए एक कमरा बनाने की कोशिश करूँगा। मुझे केवल डेनिस की बदौलत TIO पर भाषा मिली, मैं इसे सभी के लिए सुलभ बनाने पर काम कर रहा हूँ!
— अधिकतम
@ जोकिंग मैंने मठगोल्फ के लिए एक कमरा बनाया । मैं जितनी जल्दी हो सके किसी भी प्रश्न का उत्तर देने की कोशिश करूंगा, मुझे पता है कि दस्तावेज थोड़ा अधूरा है।
— अधिकतम
8

पायथन 2 , 117 113 108 107 106 105 बाइट्स

from random import*
def f(n):a=['']*5;exec"i=randint(0,(n>44)+(n>59)<<1);a[i]=(a[i]or 0)+1;"*1000;print a

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

एक उलटी सूची लौटाता है (पहले नीचे)

टिप्पणियों में स्टेगओवरफ़्लो उत्तर से प्रेरित संस्करण (edgecases अधिक होने की संभावना है):

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

from random import*
def f(n):a=sorted([1000]*5+sample(range(1001)*5,(n>44)+(n>59)<<1));print[y-x or''for x,y in zip([0]+a,a)[:5]]

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

— TFeld
स्रोत
मुझे नहीं पता कि आपका कोड कैसे काम करता है, लेकिन क्या हर राज्य में गैर-शून्य होने की संभावना है? आपकी सभी संख्याएँ क्रमशः 3 या 5 भागों के लिए 333या उसके पास मँडरा रही 200हैं। मैं किसी भी spikes / outliers की ओर 0या नहीं देखते हैं 1000। या पास के पूर्णांकों की तुलना में उन खगोलीय छोटे (लेकिन अभी भी गैर-शून्य) के लिए संभावनाएं हैं 333और 200?
— केविन क्रूज़सेन
1
@KevinCruijssen 1000 लावा-इकाइयों में से प्रत्येक को एक यादृच्छिक बिन ( 0या 0-2या 0-4) में रखा जाता है , और गिना जाता है। तब दोनों में से किसी के भी जाने की संभावना नहीं है, लेकिन बहुत कम है।
— 8
आह ठीक है, यह समझ में आता है। अब मैं भी आपके कोड को पहले से बेहतर समझ रहा हूं। धन्यवाद! मुझ से +1।
— केविन क्रूज़सेन
7

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

एक उलट सरणी देता है जहां खाली स्तर एक स्थान से भरा होता है।

t=>(a=[...'     '],g=k=>k?g(k-1,a[Math.random()*(t>59?5:t<45||3)|0]++):a)(1e3)

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

टिप्पणी की गई

t => (                      // t = input
  a = [...'     '],         // a[] = output array, initially filled with 5 spaces
  g = k =>                  // g = recursive function taking an iteration counter k
    k ?                     //   if k is not equal to zero:
      g(                    //     do a recursive call:
        k - 1,              //       decrement k
        a[                  //       update a[]:
          Math.random() * ( //         pick a random slot:
            t > 59 ? 5 :    //           among all 5 slots if t > 59
            t < 45          //           force the 1st slot if t < 45
            || 3            //           among the 3 first slots otherwise
          ) | 0             //         round the above result to an integer
        ]++                 //       increment the wax amount on this slot
      )                     //     end of recursive call
    :                       //   else:
      a                     //     stop recursion and return a[]
)(1e3)                      // initial call to g() with k = 1000
— Arnauld
स्रोत
मेरे पास वास्तव में वही सवाल है जो मैंने पायथन उत्तर के लिए की गई टिप्पणी के रूप में किया है : क्या हर राज्य में होने का एक गैर-शून्य मौका है?
— केविन क्रूज़सेन
1
1090
Rofl, उल्कापिंड के साथ अच्छा सादृश्य। ;) अब मैं वास्तव में देखता हूं कि आपकी विधि पाइथन के उत्तर के समान है कि यह सरणी में 3 या 5 स्पॉट में से एक में मान डालता है, 1000 की गिनती तक। अच्छा जवाब है, इसलिए मेरे से +1।
— केविन क्रूज़सेन
6

आर , 85 84 बाइट्स

function(n)write(ifelse(t<-table(cut(runif(1e3,2*(n<60)+3*(n<45),5),0:5)),t,""),1,1)

-1 बाइट @ @iuseppe के लिए धन्यवाद

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

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

function(n){
      # Generate 1000 random uniform numbers in [5,5] (if n<45),
      # in [2,5] (if 45<=n<60) and in [0,5] (if n>=60).
    x = runif(1e3,2*(n<60)+3*(n<45),5) 
      # Code each by the number of the interval it falls in (0,1],(1,2]...(4,5]
    cx = cut(x,0:5)
      # Tabulate the intervals. Because cut() returns a factor,
      # zero counts are included 
    t = table(cx)
      # Vector-wise replace zero elements with "" and cat out, 1 per line.
    t1 = ifelse(t,t,"")
    write(t1,1,1)
}
— J.Doe
स्रोत
यदि NAखाली लाइन / तत्व के रूप में अनुमति दी जाती है, तो यहां 77 बाइट समाधान ( ऑनलाइन प्रयास करें! ) या 80 बाइट समाधान है ( इसे ऑनलाइन आज़माएं! ) यदि तत्व नाम एक समस्या है
— duckmayr
6

सी (जीसीसी) , 131 , 116 , 90 , 89 , 87 बाइट्स

L(l,a,v,A){for(A=5,v=1e3;A--;v-=a)printf("%d\n"+!a*2,a=l>59|A<3&l>44?rand()%-~v:!A*v);}

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

अद्यतन : मूल में एक बग फिक्स्ड। अतिरिक्त 15 बाइट्स को कम करने, हेल्पर फ़ंक्शन में फ़्यूस्ड।

अद्यतन 2 : -25 बाइट्स ErikF के लिए धन्यवाद।

अद्यतन 3 : -1 बाइट सीक्रेट के लिए धन्यवाद।

Degolf

L(l,a,v,A){
    for(A=5,v=1e3;A--;v-=a)
        printf("%d\n"+!a*2, // No clue how this works anymore, but it'll advance the pointer 
                            // to the string constant when a number shouldn't be printed.
        a=l>59|A<3&l>44?rand()%-~v // Random integer to print in [0, v]
        :!A*v); // If bottom layer, return remaining volume
}
आप puts()मुद्रण को एकल में जोड़कर printf()और घटाव को लूप अंत में डालकर समाप्त कर सकते हैं। इसके अलावा, मुझे लगता है कि आपको srand()कॉलर में इनिशियलाइज़ेशन डालने की अनुमति है । इसे ऑनलाइन आज़माएं!
— ErikF
मुझे एहसास हुआ कि मैंने "नो जीरो" प्रतिबंध को याद किया। यहाँ निश्चित संस्करण है: इसे ऑनलाइन आज़माएं!
— ErikF
कुछ आखिरी ट्विस्ट! इसे ऑनलाइन आज़माएं!
— एरिकएफ
महान; मैंने इसे एक अतिरिक्त बाइट द्वारा नीचे गिरा दिया।
1
इसके अलावा, हम यह किया है! हमने अजगर को हराया!
5

05AB1E , 27 26 25 बाइट्स

अदनान को बाइट देकर धन्यवाद दिया । केविन क्रूज़सेन
को एक और बाइट धन्यवाद दिया ।

5Å0₄FD„,;ÇI‹O·ÝΩ©è>®ǝ]ε0Û

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

व्याख्या

5Å0                         # initialize with a list of 5 zeroes
   ₄F                       # 1000 times do:
     D                      # duplicate the list
      „,;ÇI‹                # check if the input is larger than 44 and/or 59
            O·              # sum and double, yielding (0,2 or 4)
             ÝΩ             # pick a random number between and 0 and the number above
               ©è           # get the count in that level
                 >          # increment it
                  ®ǝ        # insert it at the same position
                     ]      # end loop
                      ε0Û   # remove leading zeroes on each level
— Emigna
स्रोत
1
अच्छा उत्तर! मैं जिस तरह से आप का उपयोग किया है की तरह है 5Å0और ǝ, और ε0Ûअंत में। मैंने कुछ कम करने की कोशिश की, लेकिन मैं असमर्थ हूं। मुझे लगता है कि यह किसी भी तरह से अभी भी गोल्फ हो सकता है, लेकिन मैं वर्तमान में इसे नहीं देख रहा हूं (शायद यह नहीं हो सकता है और यह सिर्फ एक यादृच्छिक भावना है)। कम के बजाय •A–•60в1 बाइट लंबा है 44 59‚। और खाली तारों के साथ एस ε0Ûको बदलने के 0लिए भी सबसे कम संभव लगता है, क्योंकि 0Kबस 0-आइटम को पूरी तरह से 0мहटा देता है और 0सभी संख्याओं में किसी भी अंक को हटा देता है ।
— केविन क्रूज़सेन
1
@ केविनक्रूजसेन: हाँ मैंने देखा है और करने का एक छोटा तरीका ढूंढना है 44 59‚, लेकिन मैं इसे नहीं पा सकता ( •H|•2ôयह एक ही गिनती है)। मेरे पिछले समाधान (भी 27 बाइट्स) का उपयोग किया गया 45और 60जो अलग-अलग तरीकों से उत्पन्न करना आसान है, लेकिन मुझे लगता है कि यह अमान्य था क्योंकि यह इनपुट के आधार पर आउटपुट 1 , 3 या 5 स्तर था और हमेशा 5 नहीं ।
— एमिग्ना
आह, •H|•2ôवास्तव में एक स्मार्ट तरीका है, इस बारे में नहीं सोचा था। और यह वास्तव में 5 लाइनों का उत्पादन करना चाहिए। मैंने वास्तव में आपका पिछला उत्तर देखा था और यह टिप्पणी करने वाला था कि यह केवल 1 पंक्ति के लिए आउटपुट है n < 45, लेकिन तब आपने इसे हटा दिया था। खुशी है कि आपको एक और 27-बाइट समाधान मिला है। :)
— केविन क्रूज़सेन
2
मुझे लगता ŽH|2ôहै कि तुम क्या देख रहे हो?
— अदनान
2
@ केविनक्रूजसेन यह बिल्कुल उसी तरह काम करता है। क्या 05AB1E का उपयोग करके पिछले उत्तरों का उपयोग करके कुछ शोध किया गया था और यह उन चीजों में से एक था जिन्हें मैंने फिर से लिखा था। अभी इसके कोई अन्य उपयोग के मामले नहीं हैं।
— अदनान
4

जावास्क्रिप्ट (Node.js) , 87 86 बाइट्स

f=(n,w=1e3,s=5,r=n<45|n<60&s<4|s<2?w:Math.random()*w|0)=>s?`${r||""}
`+f(n,w-r,s-1):""

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

83-बाइट समाधान ( (n/15-2|0)*s<4) पहले आरक्षित है क्योंकि मुझे बड़े की जांच करने की आवश्यकता है n।

अद्यतन करें: हाँ, (n/15-2|0)*s<4बड़ा nहोने के कारण काम नहीं किया क्योंकि nकाफी बड़ा योग 1000 तक पहुंचने में विफल रहता है।

— शायरु असकोतो
स्रोत
3

क्लीन , 215 बाइट्स

import StdEnv,Math.Random,Text
? ::!Int->Int
?_=code{ccall time "I:I"
}
$n#l=take(max(2*min(n/15-2)2)0+1)(genRandReal(?0))
#l=map toInt[1E3*e/sum l\\e<-l]
|sum l==1000=map(\v|v>0=v<+"\n"="\n")(l++repeat 0)%(0,4)= $n

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

इसलिए मैंने आखिरकार आयात करने की तुलना में एक यादृच्छिक बीज प्राप्त करने के लिए एक छोटा रास्ता ढूंढ लिया है System._Unsafe, System.Timeऔर उपयोग कर रहा है toInt(accUnsafe time)...
और यह लड़का वास्तव में कोडगुल्फ़ की भावना में है - सी को कॉल एम्बेड करना, सामान्य रूप से मूल्यांकन सुनिश्चित करने के लिए उपयोग किए जाने वाले विश्व राज्य प्रकार की अनदेखी करना। ऐसी चीजों का क्रम।

— Οurous
स्रोत
3

जावा (JDK 10) , 121 117 113 111 बाइट्स

m->{for(int w=1000,j,i=5;i-->0;w-=j=i>0?j*=Math.random():w,System.out.println(j<1?"":j))j=m>59|m>44&i<3?w+1:0;}

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

यह शीर्ष के पास अधिक मोम लगाने के लिए पक्षपाती है, लेकिन यह सैद्धांतिक रूप से मोम की किसी भी कानूनी व्यवस्था के लिए संभव है।

संपादित करें: 4 बाइट्स @ केविनक्रूजसेन द्वारा बचाए गए थे

मानव-पठनीय जावा में:

(int minutes /* golfed variable m */) -> {
  int waxRemaining = 1000; // golfed variable w

  // golfed version goes from index 4 to 0 in a bit of a roundabout way
  // starting at 5 but decrementing right away
  for (int level = 4 /* golfed variable i */; level <= 0; level--) {
    // golfed variable j
    // the golfed version initializes this to (waxRemaining + 1)
    // in order to juice out some extra bytes during the Math.random() call
    int waxAtLevel = 0;

    // the golfed version does all of these ifs as ternary operations
    // and avoids using 2-character operators wherever possible
    // so e.g. "a == 0" becomes "a<1" and "a && b" becomes "a&b"
    // since here we are certain things can't be negative,
    // and took a good look at the Java operator precedence cheat-sheet
    // to make sure "&" and "|" would work properly to give a truthy value
    if (level == 0) {
      // if we are at the bottom level, just put the rest of the wax there
      waxAtLevel = waxRemaining;
    } else if (minutes >= 60 || (minutes >= 45 && level < 3)) {
      // otherwise if we are at a legal level put a random portion of the remaining wax there
      // note: the random portion can be between 0 and waxRemaining inclusive
      waxAtLevel = (int) (Math.random() * (waxRemaining + 1));
    }

    if (waxAtLevel > 0) {
      // only print the amount of way at this level if its greater than 0
      System.out.print(waxAtLevel);
    }
    System.out.println();

    waxRemaining -= waxAtLevel;
  }
}
— SamYonnou
स्रोत
2
Math.random()*(w+1)Math.random()*-~w-2 बाइट्स के लिए हो सकता है । यहाँ प्रासंगिक टिप क्यों संदर्भ के रूप में। । अच्छा उत्तर! मुझ से +1। संपादित करें: वास्तव में, 2 और बाइट्स jअस्थायी रूप से चर के रूप में उपयोग करके बचाए जा सकते हैं w+1(क्योंकि यह वैसे भी प्रिंट के बाद राइट राइट हो जाएगा) और j*=Math.random()इसके बजाय उपयोग करें ताकि आपको (int)( 117 बाइट्स ) कलाकारों की आवश्यकता न हो ।
— केविन क्रूज़सेन
@KevinCruijssen अच्छा है! इसके अलावा, मैंने सिर्फ यह देखा कि &i>2हालत जरूरी नहीं है
— SamYonnou
3

पॉवर्सशैल , 188 162 बाइट्स

param($m);$t=0;$a=,0*5;$s=if($m-lt45){4}elseif($m-lt60){2}else{0};$s..4|%{$t+=$a[$_]=if($_-eq4){1e3-$t}elseif($t-ne1e3){Random(1000-$t)}}$a|%{if($_){$_}else{''}}

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


वैकल्पिक बाय- वर्ब
-20 बाइट्स को लूप को हटाकर और रिक्त स्थान को हटाकर @ केविन क्रूज़सेन -4 बाइट्स द्वारा -2 बाइट्स

— एडविन
स्रोत
नमस्ते, PPCG में आपका स्वागत है! शानदार पहला जवाब! मैंने कुछ बुनियादी परीक्षण किए, और सब कुछ बहुत अच्छा काम करने लगता है। मुझे पॉवरशेल के बारे में बमुश्किल कुछ पता है, लेकिन क्या इसे बदलना संभव else{if($t-ne 1e3){Get-Random(1000-$t)}}है elseif($t-ne 1e3){Get-Random(1000-$t)}? मुझे लगता है कि आपने elseifअपने कोड में पहले उपयोग किया है , इसलिए इससे आपको 2 बाइट बचनी चाहिए। इसके अलावा, शायद पॉवरशेल में गोल्फिंग के लिए टिप्स या गोल्फिंग के लिए टिप्स <सभी भाषाओं में> अधिक के लिए कुछ प्रेरणा दे सकते हैं? यहां रहने का आनंद! :)
— केविन क्रूज़सेन
1
Ifelse के बारे में पूरी तरह से सही है। प्रक्रिया में पहले इसके दूसरे समकक्ष को हटा दिया। लिंक ने कुछ प्रेरणा भी दी!
— एडविन
2

पास्कल (एफपीसी) , 192 190 बाइट्स

var n,a:word;z:array[0..4]of word;begin read(n);if n>44then a:=a+3;if n>59then a:=a+2;Randomize;for n:=0to 999do inc(z[random(a)]);for n:=0to 4do if z[n]>0then writeln(z[n])else writeln end.

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

TFeld द्वारा डिब्बे विधि में पैकिंग का उपयोग करना । एक अनुगामी न्यूलाइन के साथ पहली पंक्ति के नीचे प्रिंट।

ऐसा लगता है कि एफपीसी के साथ समस्याएं नहीं हैं random(0), इसलिए मुझे वहां कुछ असामान्य जोड़ना है।

मेरा मूल सबमिशन, 209 बाइट्स के लिए नीचे गोल्फ:

var n,i,a,r:int32;begin read(n);if n>44then a:=a-2;if n>59then a:=a-2;r:=1000;Randomize;for i:=-3to-0do begin if i>a then begin n:=random(r+1);if n>0then write(n);r:=r-n;end;writeln;end;if r>0then write(r)end.

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

— AlexRacer
स्रोत
2

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

Ｆ²Ｆ²⊞υ∧‹³⁺ι÷Ｉθ¹⁵‽⊕⁻φΣ∨υω⊞υ⁻φΣυＥυ⎇ιＩιω

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

Ｆ²Ｆ²

दो बार लूप, दो बार। वैकल्पिक रूप से मैं एक ही बाइट गणना के लिए लूप इंडेक्स को 2 से विभाजित कर सकता था।

‹³⁺ι÷Ｉθ¹⁵

यदि बाहरी सूचकांक प्लस तापमान का पंद्रहवाँ भाग तीन से अधिक है ...

⊞υ∧...‽⊕⁻φΣ∨υω

... तो 1000 तक एक यादृच्छिक पूर्णांक को शामिल करें - अब तक का योग। दुर्भाग्य से चारकोल एक खाली सूची के योग की गणना नहीं कर सकता है इसलिए मुझे इसके बजाय खाली स्ट्रिंग स्थानापन्न करना होगा।

⊞υ⁻φΣυ

सूची में बचे हुए राशि को पुश करें।

Ｅυ⎇ιＩιω

सूची को स्ट्रिंग में बदलें, लेकिन शून्य के बजाय खाली स्ट्रिंग का उपयोग करें।

— नील
स्रोत
2

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

>“,;‘SḤ‘µȷŻṗS⁼¥ƇȷX;0ẋ5¤ḣ5Yḟ0

एक पूर्ण कार्यक्रम परिणाम को प्रिंट करता है (उल्टा, जैसा कि अनुमति दी गई है)।

इसे ऑनलाइन आज़माएं! - यह(1000) के7बजायउपयोग करने के लिए बदल दिया गया हैȷक्योंकि कार्यान्वयन गोल्फ की तरह धीमा है! (...के लियेn>59 सूची 1015 5-टुपल्स बनाया गया है और फिर फ़िल्टर किया गया है, जिसमें से चुनना है)

कैसे?

>“,;‘SḤ‘µȷŻṗS⁼¥ƇȷX;0ẋ5¤ḣ5Yḟ0 - Main Link: integer, n
 “,;‘                        - list of code-page indices = [44,59]
>                            - greater than? (vectorises)
     S                       - sum (i.e. 0, 1 or 2)
      Ḥ                      - double (i.e 0, 2 or 4)
       ‘                     - increment (i.e. 1, 3 or 5)
        µ                    - start a new monadic link, call that x (i.e. f(x))
         ȷ                   - literal 1000
          Ż                  - zero-range = [0,1,2,...,1000]
           ṗ                 - Cartesian power (all tuples of length x using those numbers)
               Ƈ             - filter keep if:
              ¥              -   last two links as a dyad:
            S                -     sum
             ⁼  ȷ            -     equals 1000? (i.e. only valid tuples)
                 X           - random choice (get one of these tuples)
                      ¤      - nilad followed by link(s) as a nilad:
                   0         -   zero
                    ẋ5       -   repeat five times = [0,0,0,0,0]
                  ;          - concatenate     (e.g. [354,388,258,0,0,0,0,0])
                       ḣ5    - head to index 5 (e.g. [354,388,258,0,0])
                         Y   - join with newlines
                          ḟ0 - filter out zeros
                             - implicit print
— जोनाथन एलन
स्रोत
1
" आपको आउटपुट को उलटने की अनुमति है (यानी 1000\n\n\n\nइसके बजाय \n\n\n\n1000या [87, null, 913, null, null]इसके बजाय [null, null, 913, null, 87])। " तो हाँ, आपको 28-बाइट संस्करण को बिना उपयोग करने की अनुमति है Ṛ।
— केविन क्रूज़सेन
2

टहनी , 126 बाइट्स

यह वास्तव में एक मजेदार चुनौती थी!

यह कोड एक मैक्रो बनाता है जिसे आयात करना पड़ता है।

{%macro a(s,z=1000)%}{%for _ in 4..1%}{%set t=s>59or(s>44and _<3)?random(z):''%}{%set z=z-t%}{{t}}
{%endfor%}{{z}}{%endmacro%}

इसे आयात करने के लिए, बस यह करें:

{%- import 'macro.twig' as a -%}
{{- a.a(50) -}}

यह काम कर जाना चाहिए।

आप इसे https://twigfiddle.com/t4dfgy
नोटिस पर आज़मा सकते हैं : व्हाट्सएप हटाने वाले पेज के कारण, मुझे -यह साबित करने के लिए मजबूर किया गया कि लाइन के अंत में यह साबित करना है कि यह सही संख्या में लाइनों को आउटपुट कर रहा है।

एक नियमित इंस्टॉलेशन पर, आप मुद्दों के बिना केवल नई रूपरेखाएँ देखेंगे।

— इस्माइल मिगुएल
स्रोत
2

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

{($!=1e3)||@,|((+$!-($!-=$!.rand+|0)||@)xx($_/15+|0)*2-4)[^4]}

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

एक अनाम कोड ब्लॉक जो एक स्ट्रिंग लेता है और पूर्णांक की सूची देता है, एस के स्थान पर Nilया एक खाली सूची ( []) के साथ 0।

स्पष्टीकरण:

{($!=1e3)||@,|((+$!-($!-=$!.rand+|0)||@)xx($_/15+|0)*2-4)[^4]}
{                                                            }  # Anonymous code block
 ($!=1e3)  # Initialise $! to 1000
                +$!-($!-=$!.rand+|0)     # Pick a random value from 0 to $!
                                    ||@  # Or an empty array if it is zero
            ,  (                       )xx  # Repeat this
                                          ($_/15+|0)*2-4  # The given value mapped to 0,2,4
             |(                                         )[^4] # Get the first four values
 ($!    )||@  # Where the first value is the leftover number in $! or an empty array
— मजाक कर रहा है
स्रोत
2

जे , 56 55 54 48 43 40 बाइट्स

5{.1e3(2<@-/\[,0,~[:\:~?@$~)2*1#.>&44 59

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

-3 बाइट्स FrownyFrog के लिए धन्यवाद

एक और वैचारिक रूप से अच्छा तरीका जो थोड़ा लंबा है, लेकिन सभी संभावनाओं पर पूरी तरह से समान वितरण की गारंटी देता है यहां की विधि के है :

जे , 53 बाइट्स

5$!.a:[:<@(+/);._1 0:,(1e3#1)({~#?#)@,0$~2*1#.>&44 59

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

— जोनाह
स्रोत
$!.a:बस नहीं है {.?
— FrownyFrog
@FrownyFrog धन्यवाद मैं यह भूल गया था कि "शून्य" भरण में उपलब्ध तत्वों की तुलना में अधिक तत्व लेना।
— जोनाह
2

पॉवरशेल , 115 105 98 बाइट्स

-17 बाइट्स mazzy के लिए धन्यवाद

$a=,0*5
45,60-ge"$args"|%{$i+=2}
$i..4|%{$t+=$a[$_]=random(1001-$t)}
$a[4]+=1e3-$t
$a|%{"$_"*!!$_}

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

एडविन के प्यारे जवाब का एक गोल्फ । यदि आप इसे पसंद करते हैं, तो उसे उभारें।

— Veskah
स्रोत
1
अच्छा। थोड़ा और अधिक गोल्फ ऑनलाइन यह कोशिश करो!
— माज़ी
1
गोल्फ फिर से 98 बाइट्स
— mazzy
1

रूबी , 62 55 बाइट्स

->n{w=1000;[4,4,3,3].map{|r|r*15>n||w-=q=rand(w);q}<<w}

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

परीक्षण 0-99 डिग्री तक सीमित हैं, क्योंकि लावा उच्च तापमान पर खतरनाक हो सकता है :

— जीबी
स्रोत
नमस्ते। मुझे डर है कि आपका उत्तर अमान्य है। यह वर्तमान में 0खाली लाइनों के लिए है। सरणी में खाली लाइनें कुछ भी हो सकती हैं 0, falseया एक नकारात्मक संख्या को छोड़कर । तो यह हो सकता है null, "", [], आदि, लेकिन नहीं 0। यकीन नहीं होता है कि अगर रूबी के पास ऑब्जेक्ट-एरे / लिस्ट है तो आप 0एस को कुछ और में बदल सकते हैं , लेकिन अगर आपको एरे / लिस्ट को वापस करने के बजाय उन्हें प्रिंट नहीं करना है।
— केविन क्रूज़सेन
फिक्स्ड, लेकिन मुझे लगता है कि यह थोड़ा बहुत मनमाना है।
— जीबी
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.