16

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

एक अजीब सकारात्मक पूर्णांक n( n >= 1और n % 2 == 1) को देखते हुए , अनुकरण करें।

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

आप एक खाली कैनवस के साथ शुरू करेंगे और प्रत्येक फ्रेम प्रकाश का एक कण, स्लिट्स से होकर कैनवास पर आएगा। कण एक मौका पर अधिकतम के साथ उतरेगा:

n = 1:

+-----+
|     |
| 1/2 |
|     |
+-----+

n = 3:

+-----+ +-----+ +-----+
|     | |     | |     |
| 1/4 | | 1/2 | | 1/4 |
|     | |     | |     |
+-----+ +-----+ +-----+

n = 5:

+-----+ +-----+ +-----+ +-----+ +-----+
|     | |     | |     | |     | |     |
| 1/8 | | 1/4 | | 1/2 | | 1/4 | | 1/8 |
|     | |     | |     | |     | |     |
+-----+ +-----+ +-----+ +-----+ +-----+

आदि।

उदाहरण के लिए, n=5हम मध्य बॉक्स की जांच करते हैं, इसमें गिरने का 50% मौका है। यदि यह फ्रेम के अंत में गिरता है, यदि अगले दो पर नहीं जाता है, तो उन में गिरने का 25% मौका है। यदि यह फ्रेम के अंत में गिरता है, यदि अगले दो पर नहीं जाता है, तो उन में गिरने का 12.5% मौका है। यदि यह गिरता नहीं है तो कोई फर्क नहीं पड़ता, यह अभी भी फ्रेम का अंत है।

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

अधिकतम एक कण प्रति फ्रेम पर लेट जाएगा, इसका मतलब है कि एक कण उस फ्रेम पर बिल्कुल नहीं उतर सकता है।
एक कण को किसी भी मुद्रण योग्य चरित्र द्वारा दर्शाया जा सकता है।
कण एक यादृच्छिक मौका के साथ बॉक्स में कहीं भी उतर जाएगा।
बक्से की चौड़ाई 2n-1कैनवास के आकार की होनी चाहिए । तो n=5उनके 1/9लिए कैनवास की चौड़ाई का होना चाहिए ।
बक्से की ऊंचाई कैनवास की ऊंचाई होनी चाहिए।
कण को बक्सों के बाहर बिल्कुल नहीं उतरना चाहिए।
यदि एक कण पहले से ही एक ऐसे स्थान पर उतरा है जिसे चुना गया है तो कोई फर्क नहीं पड़ता कि यह फिर से वहां उतर सकता है।
उपरोक्त एससी बॉक्स स्पष्टता के लिए हैं, उन्हें खींचा नहीं जाना चाहिए।
जब तक यह उचित है आप अपने खुद के कैनवास का आकार चुन सकते हैं। उदाहरण के लिए, यह केवल कुछ पिक्सेल ऊंचा नहीं होना चाहिए। यह उस पर सभी बक्से को फिट करने में भी सक्षम होना चाहिए।
यदि आपका कोड तख्ते के बीच सोता है तो आपको इसे अपनी बाइट की गिनती में जोड़ने की आवश्यकता नहीं है।

प्रत्येक मैक्सिमा, एक मिनीमा के बीच अंतराल होना चाहिए। यह एक बॉक्स के समान चौड़ाई होनी चाहिए लेकिन कोई भी कण वहां नहीं जाएगा। निम्नलिखित चित्र देखें:

+---+---+---+---+---+
|   |   |   |   |   |
|max|min|max|min|max|
|   |   |   |   |   |
+---+---+---+---+---+

प्रोग्राम को तब तक चलना चाहिए जब तक कि इसे मैन्युअल रूप से बंद न कर दिया जाए।

नियम

एक छद्म यादृच्छिक संख्या जनरेटर (pRNG) ठीक है।
मानक खामियों को मना किया जाता है।
इनपुट किसी भी उचित प्रारूप द्वारा लिया जा सकता है।
आपको STDOUT पर आउटपुट देना चाहिए।
यह कोड-गोल्फ है इसलिए सबसे छोटा उत्तर जीतता है।

उदाहरण

निम्नलिखित GIF एक उदाहरण के लिए चलाया जाता है n = 5। मैंने केवल इसे जल्दी से खटखटाया ताकि संभावना थोड़ी दूर हो जाए।

— TheLethalCoder
स्रोत

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

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

4

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

इस पागलपन की एक विधि है, मैं वादा करता हूं। मैं ओपी में टिप्पणी की संभावना की व्याख्या का अनुसरण करता हूं।

संपादित करें: -कुछ चतुर आलसी मूल्यांकन के माध्यम से बाइट्स (और कुछ संकेतों को हटाकर)

import time  # not counted for byte total
import random as R,curses as C
r=R.randint
c=C.initscr()
h,w=c.getmaxyx()
n=input()
w/=2*n-1
while 1:
 all(r(0,1)or c.addch(r(0,h-1),(i*(2-4*r(0,1))+n)*w-r(1,w),42)for i in range(n/2+1))
 c.refresh()
 time.sleep(0.1)  # not counted for byte total

— algmyr
स्रोत

4

BASH, 396 - 11 = 385 बाइट्स

E='echo -en';$E "\e[2J\e[99A";while :;do sleep 0.01;for i in `seq $((($1+1)/2)) -1 1`;do p=$(((($1+1)/2 - $i)));[ $p -lt 0 ]&&p=$((-$p));p=$((2**(p+1)));if [ $RANDOM -lt $((32768/$p)) ];then [ $(($RANDOM%2)) -eq 1 ]&&i=$((($1+1)-i));sector=$(((i*2-1)-1));C=`tput cols`;R=`tput lines`;SS=$((C/($1*2-1)));SX=$((SS*sector));X=$((SX+(RANDOM%SS)));Y=$((RANDOM%R));$E "\e[$Y;${X}H*";break;fi;done;done

दुर्भाग्य से मैं इसे अंतहीन लूप और ANSI एस्केप सीक्वेंस के कारण ट्राय इटऑनलाइन पर प्रदर्शित नहीं कर सकता जो कर्सर ले जाते हैं, लेकिन आप अभी भी इसे अपने टर्मिनल में कॉपी-पेस्ट कर सकते हैं!

अनमनी संस्करण:

E='echo -en'
$E "\e[2J\e[99A"

while :
do
    sleep 0.01
    for i in `seq $((($1+1)/2)) -1 1`
    do
        p=$(((($1+1)/2 - $i)))
        [ $p -lt 0 ] && p=$((-$p));
        p=$((2**(p+1)))
        if [ $RANDOM -lt $((32768/$p)) ]
        then
            [ $(($RANDOM%2)) -eq 1 ] && i=$((($1+1)-i));
            sector=$(((i*2-1)-1))
            C=`tput cols`
            R=`tput lines`
            SS=$((C/($1*2-1)))
            SX=$((SS*sector))
            X=$((SX+(RANDOM%SS)))
            Y=$((RANDOM%R))
            $E "\e[$Y;${X}H*"
            break
        fi
    done
done

— एंड्रयू दुनाई
स्रोत

1

बैश में गोल्फ के लिए युक्तियाँ देखें । आपके लिए यहाँ फसल काटने के कुछ आसान कम फल हैं - जैसे $[ ]इसके बजाय $(( ))। इसके बजाय for i in `seq $((($1+1)/2)) -1 1`;do ...;done, प्रयास करें for((i=($1+1)/2;i>0;i--));{ ...;}। इसके बजाय [ $(($RANDOM%2)) -eq 1 ], प्रयास करें ((RANDOM%2))। sector, SSआदि को 1 चर चर नामों से बदला जाना चाहिए।

— डिजिटल ट्रामा

3

गणितज्ञ, 231 बाइट्स

(R=RandomInteger;p=20(#+1)+10;s=Array[0&,{20,6p-3}];i=(#+1)/2;Monitor[While[1<2,y=RandomChoice[Join[q=Riffle[Array[2^#&,i,0],Table[0,i-1]],Reverse@Most@q]->Array[Range[4#+1]&,i,0][[i]]];s[[R@19+1,10y-R@9]]=1;s],Grid[s//. 0->" "]])&

इनपुट

[5]

उत्पादन

— J42161217
स्रोत

यह अमान्य प्रतीत होता है, n = 5 के लिए केवल 5 बॉक्स होने चाहिए, आपके पास 9 हैं

— TheLethalCoder

मुझे एहसास हुआ कि मेरी गिनती {... 3,2,1,2,3 ...} है। अगर इसे स्वीकार नहीं किया गया तो मैं इसे ठीक कर सकता हूं

— J2716117

2

@ लॉथलॉकर फिक्स्ड! बेहतर! Golfed!

— J42161217

अच्छा लग रहा है, मुझ से ऊपर

— उठना

2

सी # (.NET 4.5), 319 254 बाइट्स

TheLethalCoder की बदौलत 65 बाइट्स बचाए!

namespace System{using static Console;n=>{for(var r=new Random();;)for(int w=WindowWidth/(2*n-1),i=(n-1)/2,c=0,m=2,l;i>-1;i--,c+=2)if((l=r.Next(0,(m*=2+1)*2))<2){SetCursorPosition((i+(l<1?c:0))*2*w+r.Next(0,w),r.Next(0,WindowHeight));Write('*');break;}}}

काहे, यह बहुत काम था, लेकिन यह किसी भी तरह काम करता है।

चूंकि यह Consoleविशिष्ट कार्यों और थ्रेड स्लीपिंग का उपयोग करता है, इसलिए यह टीआईओ पर दुख की बात नहीं है।

— इयान एच।
स्रोत

एक करने के लिए संकलित Action<int>बाइट्स को बचाने के लिए, while(true)-> ( while(1>0)-> for(;;)। using C=Console;या using static Console;।

— TheLethalCoder

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

— इयान एच।

प्रोग्राम / फ़ंक्शंस की अनुमति डिफ़ॉल्ट और अनाम लैंबडास द्वारा फ़ंक्शंस के रूप में दी जाती है (हालाँकि जब आपको कॉल करने की आवश्यकता होती है तो उन पर नियम थोड़े गहरे हो जाते हैं)।

— TheLethalCoder

255 बाइट्स

namespace System{using static Console;n=>{for(var r=new Random();;)for(int w=WindowWidth/(2*n-1),i=(n-1)/2,c=0,m=2,l;i>-1;i--,c+=2)if((l =r.Next(0,(m*=2+1)*2))<2){SetCursorPosition((i+(l<1?c:0))*2*w+r.Next(0,w),r.Next(0,WindowHeight));Write('*');break;}}}

— TheLethalCoder

@ TheLethalCoder कोड काम नहीं करता है: / बस Variable is not existing in the current contextत्रुटियों का एक बहुत देता है ।

— इयान एच।

1

क्लोजर + क्विल, 394 बाइट्स

(use '[quil.core])(defn -main[n](let[w 999 h 100 c(/ w(-(* n 2)1))s(range 0 w c)a(vec(take-nth 2 s))v(fn[x](<(rand)x))q(fn[a b](+ a(rand-int(- b a))))g(for[i(range(int(/ n 2))-1 -1)][i(- n 1 i)])z(for[[j i](map vector(range 1(inc(count g)))g)][(/ 1(Math/pow 2 j))i])](defsketch m :size[w h]:draw #(loop[[[p i]& r]z](when p(if(v p)(let[o(a(rand-nth i))](point(q o(+ o c))(q 0 h)))(recur r)))))))

खैर, मैं निश्चित रूप से नहीं जीता, लेकिन यह एक अच्छा मस्तिष्क कसरत था! हो सकता है कि मैंने ऐसा करने के लिए एक अत्यधिक गोल चक्कर रास्ता चुना हो, लेकिन यह काम करता है! असल में, यह कैसे काम करता है:

प्रत्येक स्तंभ के x-मानों की गणना के आधार पर की जाती है n । फिर, "सक्रिय कॉलम्स" जिसमें डॉट्स होंगे फ़िल्टर किए गए हैं। फिर स्तंभों को उन संभावनाओं के साथ जोड़ दिया जाता है जिन्हें वे चुना जाएगा।
एनीमेशन शुरू होता है, और प्रत्येक फ्रेम, एक लूप दर्ज किया जाता है। मध्य से शुरू होकर, प्रत्येक जोड़ी स्तंभों की कोशिश की जाती है। एक बार कॉलम की एक जोड़ी चुने जाने के बाद, जोड़ी से एक कॉलम को यादृच्छिक रूप से चुना जाता है।
एक डॉट चुने हुए कॉलम के भीतर एक यादृच्छिक स्थिति में खींचा जाता है, आंतरिक लूप बाहर निकलता है, और एक नया फ्रेम शुरू होता है।

क्विल ग्राफिक्स लाइब्रेरी का उपयोग करता है, जो अनिवार्य रूप से क्लोजर के लिए एक प्रसंस्करण आवरण है।

ध्यान दें, गोल्फ कोड एक ही एनीमेशन का उत्पादन नहीं करता जैसा कि GIF में दिखाया गया है। गोल्फ कोड में, पृष्ठभूमि ग्रे है, और खिड़की और डॉट्स छोटे हैं। इसका एक ही प्रभाव है, यह उतना सुंदर नहीं है।

इन-डेप्थ स्पष्टीकरण के लिए ungolfed कोड देखें:

(ns bits.golf.interference.interference
  (:require [quil.core :as q]))

; Canvas size
(def width 1800)
(def height 800)

(defn -main [n]
  (let [col-width (/ width (- (* n 2) 1))
        ; The left-most x of each column
        col-starts (range 0 width col-width)

        ; The columns that need to be drawn. Need "vec" so I can index it later.
        active-cols (vec (take-nth 2 col-starts))

        ; Function taking a decimal percentage, and returning whether or not it's satisfied.
        ; (chance? 0.5) would be used to simulate a coin toss.
        chance? (fn [perc] (< (rand) perc))

        ; Function that returns a random int between a and b
        r-int (fn [a b] (+ a (rand-int (- b a))))

        ; Generates index pairs for each complimentary column.
        indices (for [i (range (int (/ n 2)) -1 -1)]
                  [i (- n 1 i)])

        ; Zips each index pair from above with the chance that it will be" chosen"
        zipped-perc (for [[j i] (map vector (range 1 (inc (count indices))) indices)]
                      [(/ 1 (Math/pow 2 j)) i])]

    ; Animation boilerplate
    (q/defsketch Interference
      :size [width height]
      :draw
      ; The animation loop. It contains a loop over each complimentary column. It tries each column pair starting
      ;  from the middle, and works outward. Once it picks a pair of columns, it randomly chooses one of them.
      #(loop [[[p i] & r] zipped-perc]
         (when p
           ; Pick this column?
           (if (chance? p)
             ; Pick one of the column pairs
             (let [col (active-cols (rand-nth i))]
               ; Set the coloring and dot size
               (q/fill 0 0 0)
               (q/stroke-weight 5)
               ; And finally draw the dot
               (q/point (r-int col (+ col col-width))
                        (r-int 0 height)))

             ; If the column wasn't chosen, loop again to try the next one
             (recur r)))))))

— Carcigenicate
स्रोत

0

सी #, 238 बाइट्स

namespace System{using static Console;n=>{for(var r=new Random();;)for(int i=0,p=1,w=WindowWidth/(2*n-1),x;i<n+1;i+=2)if(r.Next(p*=2)<1){SetCursorPosition(r.Next(x=(n-1+(r.Next(2)<1?i:-i))*w,x+w),r.Next(WindowHeight));Write("*");break;}}}

इसे ऑनलाइन आज़माएं! (यह काम नहीं करेगा लेकिन y'know)।

पूर्ण / स्वरूपित संस्करण:

namespace System
{
    using static Console;

    class P
    {
        static void Main()
        {
            Action<int> f = n =>
            {
                for (var r = new Random(); ;)
                {
                    for (int i = 0, p = 1, w = WindowWidth / (2 * n - 1), x; i < n + 1; i += 2)
                        if (r.Next(p *= 2) < 1)
                        {
                            SetCursorPosition(r.Next(x = (n - 1 + (r.Next(2) < 1 ? i : -i)) * w, x + w), r.Next(WindowHeight));
                            Write("*");
                            break;
                        }

                    Threading.Thread.Sleep(25);
                }
            };

            f(5);
        }
    }
}

— TheLethalCoder
स्रोत

डबल भट्ठा प्रयोग

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

BASH, 396 - 11 = 385 बाइट्स

गणितज्ञ, 231 बाइट्स

सी # (.NET 4.5), 319 254 बाइट्स

क्लोजर + क्विल, 394 बाइट्स

सी #, 238 बाइट्स