यादृच्छिक स्क्रिप्ट जो वास्तव में यादृच्छिक नहीं है

106

कार्यालय में एक छोटे से मजाक के रूप में किसी को एक स्क्रिप्ट चाहिए थी जो बेतरतीब ढंग से एक नाम चुनती है, और कहा कि व्यक्ति पेय का एक चक्कर लगाएगा।

आइए लोग जॉन, जेफ, एम्मा, स्टीव और जूली को फोन करें।

मैंने सोचा था कि एक स्क्रिप्ट बनाना मज़ेदार होगा जो एक त्वरित नज़र में यादृच्छिक लगता है, लेकिन वास्तव में हमेशा एक ही व्यक्ति को आउटपुट के रूप में देता है (आपके लिए जो आप चुनते हैं)।

एक हफ्ते के बाद सबसे ज्यादा वोट देने वाली उत्तर जीत

और विजेता है....

पॉल आर (वर्तमान में) 158 मतों से।

यहाँ उत्तर बहुत अच्छे हैं, और अगर किसी और के पास कोई अन्य विचार है जो अभी तक पोस्ट नहीं किया गया है, तो कृपया उन्हें जोड़ें, मुझे उनके माध्यम से पढ़ना पसंद है।

popularity-contest  random  underhanded 
— टीएमएच
स्रोत
44
— एस्ट्रो बीसी
6
@AstroCB मेरे पसंदीदा में से एक। बॉबी टेबल के ठीक पीछे।
— क्रंचर
50
ऐसा लगता है जैसे यह यादृच्छिक होगा यदि यह यादृच्छिक था, सिवाय एक व्यक्ति को कभी नहीं चुनने के लिए।
— ब्रेंडन लॉन्ग
6
@AstroCB यह भी शानदार है: dilbert.com/strips/comic/2001-10-25
— गिल्बर्टोहासनोफ
3
मैं पहले पन्ने से गुज़रा: ज्यादातर जवाब हमेशा जॉन चुनते हैं, दूसरा सबसे ऊंचा जूली है, जेफ को शायद ही कभी चुना जाता है और स्टीव को 1. यहां तक ​​कि रे को भी एक द्वारा चुना जाता है लेकिन किसी ने एमा को नहीं चुना। कहानी का नैतिक: जब ड्रिंक्स खरीदने के लिए बेतरतीब ढंग से फैसला करने के लिए एक पंक्ति में खड़े हों, तो खुद को एम्मा नाम दें।
— दु: खद परिवर्तनीय

जवाबों:

171

सी

यह तय करना महत्वपूर्ण है कि कौन जल्दी से जल्दी खरीद रहा है, ताकि कीमती पीने का समय बर्बाद न हो - इसलिए अधिकतम प्रदर्शन प्राप्त करने के लिए सी स्पष्ट विकल्प है:

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void)
{
    const char *buyer;
    int n;

    srand(time(NULL)); // make sure we get a good random seed to make things fair !
    n = rand();
    switch (n % 5)
    {
        case 0: buyer = "John";
        case 1: buyer = "Jeff";
        case 2: buyer = "Emma";
        case 3: buyer = "Steve";
        case 4: buyer = "Julie";
    }
    printf("The person who is buying the drinks today is: %s !!!\n", buyer);
    return 0;
}

स्पष्टीकरण:

यह ठीक काम करेगा अगर break;स्विच स्टेटमेंट में प्रत्येक मामले के बाद था । हालांकि यह प्रत्येक मामले में अगले एक तक "गिर" जाता है, इसलिए गरीब जूली हमेशा पेय खरीदना बंद कर देती है।

— पॉल आर
स्रोत
17
प्रदर्शन के लिए +1 - शारीरिक मृत्यु को रोल करने की तुलना में बहुत तेज़! ;)
— जूनोस्टी
16
मैं इसे और अधिक अनुकूलित करने के बारे में सोच रहा हूं, शायद SIMD या GPGPU के साथ, बस थोड़ा और प्रदर्शन पाने के लिए। ;-)
— पॉल आर
7
बिल्कुल वास्तविक लाइव लागू। कोई भी कभी भी सवाल नहीं करेगा कि यह थोड़ी सी भी दुर्घटना थी।
— इरिलिचट
5
यह सिर्फ मुझे है या यह एक बहुत स्पष्ट करने के लिए हाजिर है?
— एल्विन वोंग
3
@ एल्विनगॉन्ग मैंने इसे तुरंत नोटिस नहीं किया। तो फिर, मैं नियमित रूप से C, या BCPL से उतरी किसी भी अन्य भाषा का उपयोग नहीं करता।
— राइमॉइड
164

पीएचपी

इसे जाने नहीं दे सकते, इसलिए यहां एक और है:

$f = fopen('/dev/random','r');
$s = fread($f, 4);
fclose($f);

$names = ['John', 'Jeff', 'Emma', 'Steve', 'Julie'];

echo $names[$s % count($names)];

यह वास्तव में जॉन के उत्पादन की गारंटी नहीं है, लेकिन संभावना बहुत अच्छी है। PHP ख़ुशी से जो कुछ भी लेगा / देव / यादृच्छिक को यह देखने की पेशकश करेगा कि यह (शायद) इसे पार्स नहीं कर सकता है और इसके बजाय बहुत ही उचित मूल्य 0 के साथ आ सकता है। आखिरकार, प्रोग्रामर को संभावित त्रुटि के लिए चेतावनी देना PHP में एक घातक पाप माना जाता है।

— monocell
स्रोत
25
आपको PHP से प्यार है - और इससे भी बेहतर, यह कभी-कभी शायद ही किसी और को चुनेगा। इसलिए अगर आप भाग्यशाली हैं तो यह पहली बार में थोड़ा सा पक्षपाती लगेगा
— फाल्को
142
+1000 के लिए "... प्रोग्रामर को संभावित त्रुटि के लिए चेतावनी देना PHP में एक घातक पाप माना जाता है।"
— जेदानो
— ताली
85

हास्केल

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

import Control.Monad
import System.Exit
import Control.Concurrent
import Control.Concurrent.MVar


data Person = John | Jeff | Emma | Steve | Julie deriving (Show, Enum)

next Julie = John
next p = succ p

rotate :: MVar Person -> IO ()
rotate mp = modifyMVar_ mp (return . next) >> rotate mp

main :: IO ()
main = do
    mp <- newMVar John
    forkIO $ rotate mp
    putStrLn "Shuffling"
    readMVar mp >>= print
    exitWith ExitSuccess

जब भी आप चाहते हैं कि यह यादृच्छिक हो:

[~]$ runghc prog.hs
Shuffling
Steve

[~]$ runghc prog.hs
Shuffling
Julie

और अपने दुर्भाग्यपूर्ण लक्ष्य के लिए:

[~]$ runhugs prog.hs
Shuffling
John

[~]$ runhugs prog.hs
Shuffling
John

हग केवल सहकारी मल्टीटास्किंग को लागू करता है, इसलिए rotateधागा कभी नहीं चलेगा

— monocell
स्रोत
24
यह शैतानी है!
— डेनिथ
8
ऐसा लगता है कि एक पासा की तस्वीर जो अभी तक हिलना बंद नहीं हुई है।
— वि।
1
@Vi। यह एक अच्छा सादृश्य है। सौभाग्य से एमवीआर के उपयोग की गारंटी है कि तस्वीर धुंधली नहीं होगी। :)
— मोनोकेल
@monocell खैर, तकनीकी रूप से, यहां तक ​​कि एक चलती वस्तु की एक तस्वीर स्पष्ट हो सकती है।
— भूत_न_थे_कोड
75

बैश - अधिकतम सादगी

एक बहुत ही सरल उदाहरण है - किसी भी समस्या को पाठ्यपुस्तक के तरीके से करने से बचें। अच्छे परिणाम के लिए सिस्टम क्लॉक से जनरेटर को सीड करना न भूलें!

#!/bin/bash

names=(John Jeff Emma Steve Julie)   # Create an array with the list of names
RANDOM=$SECONDS                      # Seed the random generator with seconds since epoch
number=$((RANDOM % 5))               # Pick a number from 0 to 4
echo ${names[number]}                # Pick a name

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

बोनस:

यह एक बहुत अच्छी तरह से जांच करने के लिए खड़ा है; यदि आप स्क्रिप्ट के बजाय कमांडलाइन पर समान कोड दर्ज करते हैं, तो यह यादृच्छिक परिणाम देगा, क्योंकि $SECONDSउपयोगकर्ता के इंटरेक्टिव शेल के चलने की अवधि वापस आ जाएगी।

— दंगा
स्रोत
9
\ o / मीन !!! वास्तव में अभिप्राय!!! $SECONDSFTW! \ o /
— यति
यदि आप sourceऐसा करते हैं, तो केवल इसे निष्पादित करने के बजाय क्या होता है? क्या शेबग अभी भी एक नया खोल या कुछ और ट्रिगर करेगा?
— jpmc26
1
@ jpmc26: यदि आप इसके साथ निष्पादित करते हैं, sourceतो यह बिल्कुल वैसा ही है जैसे कि आप कमांडलाइन पर कमांड टाइप करते हैं; #! / बिन / बैश एक टिप्पणी है इसलिए इसे अनदेखा किया गया है। यह किसी भी स्क्रिप्ट का सच है।
— दंगा
57

सी#

using System;
using System.Linq;

namespace PCCG {
    class PCCG31836 {
        public static void Main() {
            var names = new string[]{ "John", "Jeff", "Emma", "Steve", "Julie" };
            var rng = new Random();
            names.OrderBy(name => rng.Next());
            Console.WriteLine(names[0]);
        }
    }
}

यह उन लोगों को मूर्ख नहीं बना सकता है जो .Net API से परिचित हैं, लेकिन जो लोग इसे नहीं जानते हैं, वे शायद इस बात पर विश्वास न करें कि OrderByजिस वस्तु को आप इसे कहते हैं, उसे संशोधित करता है, और यह एपीआई बनाने के लिए एक नौसिखिया के लिए एक प्रशंसनीय त्रुटि है।

— पीटर टेलर
स्रोत
1
यहां तक ​​कि अगर ऑर्डरबाइट काल्पनिक रूप से ऑब्जेक्ट को संशोधित करता है, तो क्या वह कॉल वास्तव में सूची को यादृच्छिक रूप से सॉर्ट करेगा? जैसा कि किसी ने .NET से अपरिचित है, मेरा पहला अनुमान यह था कि चूंकि rng.Next()केवल एक बार कॉल किया जाता है, सरणी को एक निरंतर द्वारा सॉर्ट किया जाएगा, जिसके परिणामस्वरूप कोई परिवर्तन नहीं होगा (या एक परिवर्तन जो केवल सॉर्टिंग एल्गोरिदम पर निर्भर करता है)।
— ब्रिलियनड
1
@Brilliand ऑर्डरबी को दिया गया तर्क एक स्थिर मूल्य नहीं है, यह हर बार एक तत्व को छांटे जाने पर निष्पादित होता है, और इस मामले में किसी भी मूल्यों की तुलना किए बिना यादृच्छिक मान देता है। यह वास्तव में सही ढंग से काम करेगा अगर लाइन थीnames = names.OrderBy(name => rng.Next());
— user3188175
1
यह =>इंगित करता है कि यह एक सी # लैम्ब्डा अभिव्यक्ति (बंद) है।
— स्नोबो
44

शक्ति कोशिका

$names = @{0='John'; 1='Jeff'; 2='Emma'; 3='Steve'; 4='Julie'}
$id = random -maximum $names.Length
$names[$id]

यह हमेशा आउटपुट देगा John।

$namesवह है System.Collections.Hashtableजिसके पास कोई Lengthसंपत्ति नहीं है । PowerShell v3 के साथ शुरू, Length(और भी Count) किसी भी वस्तु पर एक संपत्ति के रूप में इस्तेमाल किया जा सकता है। यदि किसी वस्तु में संपत्ति नहीं है, तो वह वापस आ जाएगी 1जब वस्तु अशक्त नहीं होगी, अन्यथा वह वापस आ जाएगी 0। तो मेरे जवाब में, $names.Length1 के रूप में मूल्यांकन करता है, और random -maximum 1हमेशा 0 रिटर्न करता है क्योंकि अधिकतम अनन्य है।

— Rynant
स्रोत
42

क्यू

show rand `John`Jeff`Emma`Steve`Julie;
exit 0;

Q हमेशा समान मूल्य के साथ अपने यादृच्छिक संख्या के बीज को इनिशियलाइज़ करता है।

— skeevey
स्रोत
8
इसलिए मूल रूप से यह यादृच्छिक नहीं है
— सैम क्रीमर
3
@SamCreamer आउटपुट को गैर-यादृच्छिक बनाने के लिए प्रश्न का उद्देश्य बहुत अधिक है। लेकिन यह बेतरतीब दिखता है, इसलिए यह निश्चित रूप से बिल फिट बैठता है
— क्रंचर
4
क्षमा करें, मेरा मतलब था कि क्यू की यादृच्छिक संख्याएं यादृच्छिक नहीं हैं, यह प्रश्न निश्चित रूप से मानदंडों को पूरा करता है। इस तरह से आने का मतलब नहीं था!
— सैम क्रेमर
हाँ, तो आपको रैंड का उपयोग करने के लिए हर बार एक यादृच्छिक बीज उत्पन्न करने के लिए अपना रास्ता खोजना होगा? लगता है ... उपयोगी।
— DLeh
1
यादृच्छिक बीज को बहुत आसानी से सेट कर सकते हैं ... दुभाषिया के साथ दुभाषिया शुरू करें -S 1234या \S 1234दुभाषिया से करें
— स्काईवे
34

पर्ल

use strict;

my @people = qw/John Jeff Emma Steve Julie/;
my @index = int(rand() * 5);

print "Person @index is buying: $people[@index]\n";

प्रिंट्स: Person X is buying: Jeff(जहां X 0-4 से है)

स्केलर संदर्भ का थोड़ा सा दुरुपयोग। सूची @index = int(rand() * 5)की 0 स्थिति में 0 - 4 से एक यादृच्छिक पूर्णांक रखता है @index। सरणी को प्रिंट करते समय, यह @index में यादृच्छिक पूर्णांक को ठीक से प्रिंट करता है, लेकिन जब @ सरणी इंडेक्स के रूप में $people[@index]@index स्केलर संदर्भ का उपयोग करता है, तो यह सूची आकार का मान देता है, अर्थात 1।

दिलचस्प रूप से पर्याप्त है, @people[@index]यह ठीक से सूचकांक बनाता है।

दिलचस्प रूप से पर्याप्त @people[@index]पर्ल में एक हैश स्लाइस है, इसलिए @indexसूची के संदर्भ में मूल्यांकन किया जाता है; इस मामले में, यह एकल प्रविष्टि सूची है और इसीलिए यह सही ढंग से काम करती है

— एलन जी
स्रोत
तो सी (++) शब्दों में, सूची से स्केलर होने का एक अंतर्निहित रूपांतरण है क्योंकि अनुक्रमण करते समय, एक स्केलर की अपेक्षा की जाती है?
— 14:फ्रिलिचट
@iFreilicht सही है। पर्ल में, अभिव्यक्तियों का मूल्यांकन एक सूची या एक अदिश के रूप में किया जा सकता है, जहां वे दिखाई देते हैं। नतीजतन, संदर्भ के आधार पर एक ही अभिव्यक्ति का मतलब अलग-अलग चीजें हो सकती हैं। एक सूची चर (अर्थात, @उपसर्ग के साथ एक चर ), "सूची के संदर्भ में," इसकी सभी तत्वों के रूप में व्याख्या की गई है, लेकिन "स्केलर संदर्भ में," सूची में तत्वों की कुल संख्या के बराबर एक स्केलर है। इसलिए, स्ट्रिंग के अंदर, सूची चर में सूची संदर्भ होता है और प्रक्षेपित होता है, और हम प्राप्त करते हैं Person X is buying। लेकिन एक सरणी सूचकांक के रूप में, इसे स्केलर संदर्भ मिलता है, और इसकी व्याख्या 1. के रूप में की जाती है
— एलन जी
3
इसके साथ समस्या यह है कि जब एक पर्ल प्रोग्रामर देखता है my @index = ..., तो वह तुरंत "डब्ल्यूटीएफ ?!"
— व्युत्पन्न
@derobert, आप क्यों आश्चर्य करेंगे? आप कोड को उस तरह से अक्सर देखते हैं ... my @letters = 'a' .. 'z'; my @squares = map $_**2, 1..20; my @sorted = sort { lc $a cmp lc $b } @words;आदि
— मत्तियस
@ मैथियास क्योंकि लाइन एक एकल मूल्य को लेने और संग्रहीत करने के लिए है, और एक स्केलर के बजाय इसे एक सरणी में संग्रहीत किया जा रहा है।
— व्युत्पन्न
23

ECMAScript

// Randomly pick a person on only one line!
var people = [('John', 'Jeff', 'Emma', 'Steve', 'Julie')];

console.log(people[new Date() % people.length | 0]);

यह हमेशा जूली को चुनता है।

इसमें वर्ग कोष्ठक के अंदर कोष्ठक होते हैं, और अल्पविराम ऑपरेटर इसके सही संचालन का मान लौटाता है।
इसे याद करना भी बहुत आसान है। मैं वास्तविक कोड में इससे पहले याद किया है ।

— टूथब्रश
स्रोत
यह रमणीय है। अंत में, उस भयानक, भयानक ऑपरेटर के लिए एक उपयोग।
— कीन
5
उस संदर्भ में अल्पविराम तकनीकी रूप से एक ऑपरेटर है, एक विभाजक के बजाय। ecma-international.org/ecma-262/5.1/#sec-11.14 और यह भयानक है। जब तक आप अपने कोड को पढ़ना मुश्किल नहीं चाहते। जैसा आप यहां करते हैं। तो, कुदोस।
— कीन
2
@ कॉरी हां, मैं सहमत हूं - हालांकि मैं फ़ंक्शन भाव (जैसे (a,b)=>(a=b[0],b)) के साथ कोड गोल्फ के लिए हर समय इसका उपयोग करता हूं । मैंने अपना उत्तर स्पष्ट कर दिया है।
— टूथब्रश
21

सी#

using System;

namespace LetsTroll {
    class Program {
        static void Main() {
            var names = new string[]{ "John", "Jeff", "Emma", "Steve", "Julie" };
            var random = new Random(5).NextDouble();
            var id = (int)Math.Floor(random);
            Console.WriteLine(names[id]);
        }
    }
}

चाल है, विधि new Random().NextDouble()0 और 1 के बीच एक डबल लौटाता है। Math.Floor()इस मूल्य पर आवेदन करने से , यह हमेशा 0 होगा।

— Knerd
स्रोत
24
यह मेरी त्वरित नज़र का सामना नहीं किया। ;)
— मार्टिन एंडर
1
@TimS। उसके जैसा? : पी
— Knerd
2
+1, बहुत बेहतर - मुझे पता है कि आप वास्तव में क्या कर रहे हैं, लेकिन यह किसी व्यक्ति को एपीआई से परिचित नहीं हो सकता है।
— टिम एस।
1
मैं इस बारे में नहीं जानता। यदि आप एक बीज निर्दिष्ट करने जा रहे हैं, तो क्यों न आप "यादृच्छिक" int प्राप्त करने के उचित तरीके का उपयोग करें:var random = new Random(5); var id = random.NextInt(5);
— clcto
2
@clcto मेरी राय में, इसमें दो बार शामिल होने की संभावना है कि कोई व्यक्ति डबल ले, क्यों पूछें, और समस्या को देखें। इसे एक बार शामिल करना, और फिर बाद में अनावश्यक कोड सहित, थोड़ा पुनर्निर्देशन / अंडरहेडनेस देता है। बोनस: यदि कोई बग्स में से एक को ठीक करता है, तो दूसरा मौजूद है।
— टिम एस।
18

सी#

var names = new string[] {"John", "Jeff", "Emma", "Steve", "Julie"};
var guidBasedSeed = BitConverter.ToInt32(new Guid().ToByteArray(), 0);
var prng = new Random(guidBasedSeed);
var rn = (int)prng.Next(0, names.Length);
Console.WriteLine(names[rn]);

सुझाव:

GUID से बीज उत्पन्न करें। गिड्स में 4 × 10−10 टकराने की संभावना है। सुपर यादृच्छिक।

उत्तर:

कम से कम जब आप उपयोग करते हैं Guid.NewGuid(), तो वूप्स! (हमेशा बीज बनाने के लिए डरपोक तरीका 0)। साथ ही गलत काम के लिए व्यर्थ (इंट)।

— नाथन कूपर
स्रोत
दूसरा तरीका जो मैं कर सकता हूं, वह है नाम के AddRangeसाथ Concatजोड़ते समय मैला हो जाना List<string>। मुझे एक डरपोक IEqualityComparer के साथ एक हैशसेट होने के लिए हुआ था, लेकिन यह अभी तक बहुत ही असामान्य होगा। जब मैंने इसे पोस्ट किया तो मेरे क्रेडिट में कई (यदि कोई हो) बीज आधारित उत्तर नहीं थे।
— नाथन कूपर
मुझे लगता है कि आपके पास मेरे जैसा ही विचार था, लेकिन आप थोड़ा तेज थे और इसे देखना थोड़ा कठिन था। +1!
— tsavinho
7
यादृच्छिक संख्या जनरेटर को सीडिंग करना एक स्पष्ट चाल है, लेकिन आपने इसे यहां शानदार ढंग से छिपाया है। प्यारा काम।
— TRIG
18

बैश / कोरुटिल्स

यह एक स्क्रिप्ट से लगभग मौखिक रूप से लिया जाता है जिसे मैंने एक समान उद्देश्य के लिए लिखा था।

#!/bin/bash
# Sort names in random order and print the first
printf '%s\n' John Jeff Emma Steve Julie | sort -r | head -1

यहां तक ​​कि एक ऊपरी मामले का उपयोग करने के लिए भूल जाना आर एक गलती है जो मैंने कभी-कभी वास्तविक जीवन लिपियों में की है।

— kasperd
स्रोत
3
क्या आप बेहतर स्पष्टीकरण दे सकते हैं? आपका वर्तमान एक बहुत छोटा है और किसी ऐसे व्यक्ति के लिए सहायक नहीं है जो वास्तव में बैश से परिचित नहीं है।
— 16फ्रिलिचट
6
-rरिवर्स (लेक्सिकोग्राफ़िक) सॉर्ट निर्दिष्ट करता है, इसलिए स्टीव को हमेशा चुना जाएगा। इसे -Rयादृच्छिक प्रकार के लिए एक निर्दोष टाइपो के रूप में देखा जा सकता है
— मैक्स
3
टिप्पणियों पर भरोसा नहीं करने के लिए, लेकिन कोड को ध्यान से पढ़ने के लिए यह एक अच्छा अनुस्मारक है!
— टेकब्रैट
16

माणिक

names = ["John", "Jeff", "Emma", "Steve", "Julie"]

puts names.sort{|x| rand()}.first

यह सही तरीके से काम करेगा sort_by, लेकिन sortएक तुलना फ़ंक्शन की अपेक्षा करता है जो काम करता है <=>। रैंड () का परिणाम हमेशा सकारात्मक रहेगा, इसलिए यह हमेशा बराबर परिणाम देगा, बशर्ते आपके रूबी कार्यान्वयन का sortएल्गोरिदम नियतात्मक हो। मेरी रूबी 1.9.3 हमेशा जूली का उत्पादन करती है।

— histocrat
स्रोत
12

माणिक

names = ["John", "Jeff", "Emma", "Steve", "Julie"]

puts names[rand() % 5]

rand() बिना किसी तर्क के 0 और 1 के बीच एक यादृच्छिक फ्लोट का उत्पादन होता है। इसलिए मोड्यूलो 5 कुछ भी नहीं करता है, और जब फ्लोट तर्क के साथ एक सरणी में कटा हुआ होता है तो रूबी बस इसे गोल कर देती है, इसलिए यह हमेशा जॉन को वापस कर देता है।

— histocrat
स्रोत
11

पर्ल

तीन srandएस इसे तीन गुना अधिक यादृच्छिक बना देगा! 

#!perl
use feature 'say';

sub random_person {
    my ($aref_people) = @_;
    srand; srand; srand;
    return $aref_people->[$RANDOM % scalar @$aref_people];
}

my @people = qw/John Jeff Emma Steve Julie/;
my $person = random_person(\@people);

say "$person makes next round of drinks!";

व्याख्या

पर्ल में कोई $ RANDOM नहीं है, यह एक अपरिभाषित चर है। कोड हमेशा सूची से पहला तत्व वापस करेगा - जॉन पर पेय :)

संपादित करें:

कोड के माध्यम से जाने के बाद, पांच लोगों में से एक ने स्पष्ट त्रुटि को ठीक करने का फैसला किया है, निम्नलिखित कार्यक्रम का उत्पादन: 

#!perl
use feature 'say';

sub random_person {
    my ($aref_people) = @_;
    return $aref_people->[rand $#$aref_people];
}

my @people = qw/John Jeff Emma Steve Julie/;
my $person = random_person(\@people);

say "$person buys next round of drinks!";

क्या आप बता सकते हैं कि कोड को देखकर ऐसा किसने किया?

स्पष्टीकरण:

पर्ल में, $#arrayअंतिम तत्व का सूचकांक लौटाता है; चूँकि सरणियाँ शून्य-आधारित हैं, पाँच तत्वों के साथ एक सरणी के संदर्भ में, दिया $#$aref_peopleजाएगा 4।
randएक यादृच्छिक संख्या को शून्य या उसके बराबर और उसके पैरामीटर से कम पर लौटाता है, इसलिए यह कभी नहीं लौटेगा 4, जिसका प्रभावी अर्थ है कि जूली कभी पेय नहीं खरीदेगी :)

— चीनी पर्ल गोथ
स्रोत
1
$RANDOMबैश, ksh और zsh (लेकिन पर्ल में नहीं) में एक वास्तविक विशेषता है।
— कर्णघट
10

अजगर

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

import random

def CHR (n):
    # Just easily convert a number between 0 and 25 into a corresponding letter
    return chr(n+ord('A'))

# Seed the RNG with a large prime number. And multiply it by 2 for good measure.
random.seed (86117*2)

# Now, let's see what COMPLETELY RANDOM name will be spelled out!
totallyRandomName = ''
for i in range(4) :
    totallyRandomName += CHR(int(random.random()*26))

print (totallyRandomName)

स्वाभाविक रूप से, मैंने यह सुनिश्चित करने के लिए कुछ तैयारी कार्य किया कि मैं सही बीज चुनूं।

— ताल
स्रोत
15
एक निरंतर के साथ यादृच्छिक संख्या उत्पन्न सीडिंग सिर्फ बहुत स्पष्ट है ..
— ब्रेंडन लांग
@BrendanLong यह निश्चित रूप से भौहें बढ़ाएगा। लोग इसे यादृच्छिक बनाने के लिए इसका परीक्षण करना चाहेंगे। और जब यह नहीं है, तो अनुमान लगाएं कि पेय कौन खरीद रहा है।
— JFA
10

सी

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main(void)
{
char *name[]={"John", "Jeff", "Emma", "Steeve", "Julie"};

int i;
int n=rand()%10000;
int r=3;

for (i=0; i<10000+n; i++) // random number of iteration
    {
    r=(r*r)%10000; // my own PRNG (square and mod)
    }

printf("%s", name[r%5] );
}

क्षमा करें, जेफ!

गणित के कारण कुछ पुनरावृति r == 1 आधुनिक 5 के बाद। नैतिकता: यदि आप गणित में खराब हैं तो अपना खुद का PRNG न लिखें। :)

— सीपीआरआई
स्रोत
10

सी ++ X11

#include <vector>
#include <iostream>

int main () {
  std::srand(time(NULL));
  std::vector<std::string> choice{("jen","moss","roy")};
  std::cout << choice[rand()%choice.size()] << std::endl;
}

वेक्टर का आकार वास्तव में इनिशियलाइज़र सूची में उपयोग किए गए कोष्ठक के कारण 1 है। कोमा ऑपरेटर सभी नामों को छोड़ देगा और अंतिम एक लौटाएगा, इसलिए खरीदार हमेशा रॉय है।

— Tomasz
स्रोत
10

स्काला

मुझे पता है कि मेरे उपयोगकर्ता संदेह करेंगे, इसलिए मैंने एक सबूत शामिल किया है कि मेरी यादृच्छिकता वास्तव में उचित है!

object DrinkChooser {

  def main(args: Array[String]): Unit = {
    proveRandomness()
    val names = List("John","Jeff","Emma","Steve","Julie")
    val buyer = names(randomChoice(names.size))
    println(s"$buyer will buy the drinks this time!")
  }

  def proveRandomness(): Unit = {
    val trials = 10000
    val n = 4
    val choices = for (_ <- 1 to 10000) yield randomChoice(n)
    (choices groupBy(identity)).toList.sortBy(_._1) foreach { case (a, x) =>
      println(a + " chosen " + (x.size * 100.0 / trials) + "%")
    }
  }

  def randomChoice(n: Int): Int = {
    var x = 1
    for (i <- 1 to 1000) { // don't trust random, add in more randomness!
      x = (x * randomInt(1, n)) % (n + 1)
    }
    x
  }

  // random int between min and max inclusive
  def randomInt(min: Int, max: Int) = {
    new scala.util.Random().nextInt(max - min + 1) + min
  }

}

एक उदाहरण रन:

1 chosen 25.31%
2 chosen 24.46%
3 chosen 24.83%
4 chosen 25.4%
John will buy the drinks this time!

जब तक किसी और को बहुत भाग्यशाली नहीं मिलेगा, जॉन हमेशा पेय खरीदेंगे।

यादृच्छिकता का "प्रमाण" इस तथ्य पर निर्भर करता है कि rand(1, 4) * rand(1, 4) % 5अभी भी 1 और 4 के बीच समान रूप से वितरित किया गया है, समावेशी। लेकिन rand(1, 5) * rand(1, 5) % 6पतित है। वहाँ संभावना है कि आप एक 0 प्राप्त करते हैं, जो तब "यादृच्छिकता" के बाकी हिस्सों की परवाह किए बिना अंतिम परिणाम 0 बना देगा।

— जो के
स्रोत
10

जावास्क्रिप्ट ( अंडरस्कोर के साथ )

चूंकि जावास्क्रिप्ट में एक फेरबदल नहीं है, हम अंडरस्कोर का उपयोग कर रहे हैं। जेएस

var people = ['John', 'Jeff', 'Emma', 'Steve', 'Julie'];
_.shuffle(people); // Shuffle the people array
console.log("Next round is on", people[0]);

_.shuffle फेरबदल सरणी देता है, यह Array.prototyp.sort () के रूप में जगह में संशोधित नहीं करता है , माफ करना जॉन

— क्रिस्टोफ़र साल्-स्टोर्गार्ड
स्रोत
9

जावास्क्रिप्ट

दूसरा प्रयास करें, यह थोड़ा मुश्किल है:

var getRandomEntry = function(args){
    return args[Math.floor(Math.random() * arguments.length)]; 
}

alert(getRandomEntry(["peter","julie","samantha","eddie","mark"]));

argumentsचर कार्यों के लिए स्थानीय स्तर पर पहुंचा जा सकता है और सभी तर्कों कार्य करने के लिए में पारित की एक सरणी है। सरल नामकरण का उपयोग करके और फ़ंक्शन को एक सरणी में पास करके, आप यह स्पूफ कर सकते हैं कि हम सरणी की लंबाई नहीं ले रहे हैं, लेकिन वास्तव में तर्क सूची की लंबाई (जो 1 है)। विशेष वर्ण या फ़ॉन्ट प्रकार का उपयोग करके इसे बेहतर तरीके से निष्पादित किया जा सकता है।

— thomaux
स्रोत
यह स्पॉट करना सबसे मुश्किल नहीं था। जिस किसी ने भी Nजावास्क्रिप्ट में मनमाने ढंग से कार्य का निर्माण किया है, वह argumentsचर के बारे में जानता है ।
— कॉनर ओ'ब्रायन
8

सी ++

निष्पक्ष होने के लिए हमें कई दौड़ना चाहिए, कई ट्रायल और पिकअप को सबसे अधिक बार चुना जाना चाहिए।

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <map>

static const char *names[] = { "John", "Jeff", "Emma", "Steve", "Julie" };

int main() {
    srand(time(NULL));
    std::map<int, int> counts;

    // run 2^31 trials to ensure we eliminate any biases in rand()
    for (int i = 0; i < (1<<31); i++) {
        counts[rand() % (sizeof(names)/sizeof(*names))]++;
    }

    // pick the winner by whomever has the most random votes
    int winner = 0;
    for (std::map<int, int>::const_iterator iter = counts.begin(); iter != counts.end(); ++iter) {
        if (iter->second > counts[winner]) {
            winner = iter->first;
        }
    }

    printf("%s\n", names[winner % (sizeof(names)/sizeof(*names))]);
}

का मूल्य क्या है 1<<31? क्षमा करें, जॉन।

— शराबी
स्रोत
आपके स्पॉइलर प्रश्न का उत्तर यूबी है। मैं अनिर्दिष्ट हूं कि क्या बेहतर या बुरा है।
— nwp
@ एनडब्ल्यूपी खैर, निश्चित रूप से, लेकिन यह कहीं भी है कि इंट 32-बिट 2 का पूरक है, जो 64-बिट (जीसीसी के साथ) पर भी ऐसा लगता है। मैं Clang पर परीक्षण नहीं किया है, यद्यपि।
— शराबी
नहीं, यह कहीं भी नहीं है जहां एक इंट 32-लेकिन 2 का पूरक है। 1 << 31 का मान अपरिभाषित है। आप भाग्यशाली हैं हालांकि, अपरिभाषित व्यवहार कंपाइलर को जो कुछ भी महसूस होता है उसे चुना और चूंकि यह गति के लिए बनाया गया है, यह सिर्फ कुछ भी नहीं करने का फैसला करेगा, जो होना चाहिए वही होगा।
— nwp
@ 1<<31 == 0x80000000कोई बात नहीं क्या, की परिभाषा से <<और 32-बिट 2 के पूरक पर, कि INT_MIN। क्या आप शायद सोच रहे हैं कि क्या 1<<32हो सकता है या नहीं == 0? (क्योंकि x86 पर, 1<<32आमतौर पर 1 का मूल्यांकन होता है ...)
— शराबी
@nwp यह वास्तव में कार्यान्वयन-परिभाषित है। अब अगर हम C के बारे में बात कर रहे हैं, तो यह अपरिभाषित होगा।
— स्टुअर्ट ऑलसेन
7

टी-एसक्यूएल (2008+)

SELECT TOP 1 name
FROM
 (VALUES('John'),('Jeff'),('Emma'),('Steve'),('Julie')) tbl(name)
ORDER BY RAND()

स्पष्टीकरण:

MS SQL सर्वर में, RAND()निष्पादन के अनुसार केवल एक बार मूल्यांकन होता है। हर नाम को हमेशा एक ही नंबर दिया जाता है, जिससे मूल ऑर्डर मिलता है। जॉन पहले है। जॉन के लिए बेकार है।

सुझाया गया सुधार:

T-SQL सभ्य गुणवत्ता, प्रति पंक्ति यादृच्छिक संख्या के साथ उत्पादन कर सकता है RAND(CHECKSUM(NEWID()))।

— comfortablydrei
स्रोत
मुझे लगता है कि NEWID () को पर्याप्त होगा (चेक की जरूरत नहीं)
— जैकब
7

लुआ

buyer={'John', 'Jeff', 'Emma', 'Steve', 'Julie'}
   -- use clock to set random seed
math.randomseed(os.clock())
   -- pick a random number between 1 and 5
i=math.random(5)
io.write("Today's buyer is ",buyer[i],".\n")

os.clock()समय प्रयोजनों के लिए है, os.time()क्या math.randomseedअच्छा आरएनजी के लिए इस्तेमाल किया जाना चाहिए । अफसोस की बात है, जूली हमेशा (कम से कम मेरे कंप्यूटर पर) खरीदती है।

— काइल कानोस
स्रोत
math.random()कोई तर्क भी सीमा में एक नंबर देता है [0,1)। -1 कि पकड़ने के लिए नहीं।
— मनिीप
@ मिनीप: सच में योग्य भी! मैंने अब इसे ठीक कर लिया है।
— काइल कानोस
6

मुहावरेदार C ++ 11

जब पेय शामिल होते हैं, तो विशेष रूप से नवीनतम मानकों और कोडिंग शैलियों के साथ अद्यतित होना महत्वपूर्ण है; यह एक अत्यधिक कुशल और मुहावरेदार-अनुरूप C ++ 11 नाम पिकर का एक शानदार उदाहरण है।

इसे सिस्टम क्लॉक से सीड किया जाता है, और हर बार वेरिफिकेशन के लिए नाम के साथ बीज को आउटपुट करता है।

#include <vector>
#include <chrono>
#include <random>
#include <iostream>

auto main()->int {
  std::vector<std::string> names;           // storage for the names
  names.reserve(5);                         // always reserve ahead, for top performance
  names.emplace_back("John");               // emplace instead of push to avoid copies
  names.emplace_back("Jeff");
  names.emplace_back("Emma");
  names.emplace_back("Steve");
  names.emplace_back("Julie");

  std::mt19937_64 engine;                   // make sure we use a high quality RNG engine
  auto seed((engine, std::chrono::system_clock::now().time_since_epoch().count()));  // seed from clock
  std::uniform_int_distribution<unsigned> dist(0, names.size() - 1);     // distribute linearly
  auto number(dist(engine));                // pick a number corresponding to a name
  std::string name(names.at(number));       // look up the name by number
  std::cout << "Seed: " << seed << ", name: " << name << std::endl;  // output the name & seed
  return EXIT_SUCCESS;                      // don't forget to exit politely
}

इस लाइव को आज़माएं: http://ideone.com/KOet5H

ठीक है तो यह वास्तव में बहुत अच्छा कोड है; स्पष्ट रूप से नोटिस करने के लिए आपको कोड पर बहुत बारीकी से देखने के लिए बहुत सारे लाल झुंड हैं - कि RNG वास्तव में कभी वरीयता प्राप्त नहीं है :) इस मामले seedमें सिर्फ एक पूर्णांक है, और ऐसा लगता engineहै कि एक पैरामीटर के रूप में पारित किया गया है बोने के कार्य, यह वास्तव में सिर्फ नजरअंदाज कर दिया है। बीज चर वास्तव में घड़ी से सेट किया गया है, इसलिए यह चोट के अपमान को जोड़ने के लिए नाम के साथ-साथ अंत में आउटपुट हो सकता है, लेकिन यह अभी भी हमेशा स्टीव होगा जो पेय खरीदता है।

— दंगा
स्रोत
1
यह मुझे मारता है कि यह नामों के लिए एक शुरुआती सूची का उपयोग नहीं करता है। बहुत कम से कम, आप निश्चित रूप से कोड प्रदान करने में सफल रहे हैं जो कि केवल इंजीनियर महसूस करता है । मैं नहीं बता सकता कि यह "अनुपालन" या शोर की सभी टिप्पणियों के कारण है: P
— vmrob
6

जावास्क्रिप्ट

console.log(["Jeff", "Emma", "Steve", "Julie"][Math.floor(Math.random(5))]);

ठीक है, क्षमा करें, Math.randomकोई पैरामीटर नहीं लेता है, और हमेशा [0, 1) से एक नंबर लौटाएगा। फिर भी, यह एक खुश चर समारोह है और तर्कों के बारे में शिकायत नहीं करता है!

— Bergi
स्रोत
5

अजगर

names=["John", "Jeff", "Emma", "Steve", "Julie"]
import random # Import random module
random.seed(str(random)) # Choose strictly random seed
print(random.choice(names)) # Print random choice

str (random) एक स्थिर स्ट्रिंग देता है; यादृच्छिक मूल्य नहीं

— QuadrExAtt
स्रोत
6
कुछ हद तक अप्रासंगिक नोट: यदि आप पाइथन 3.2 या बाद का उपयोग कर रहे हैं, तो दूसरा तर्क random.seed()होना चाहिए 2(डिफ़ॉल्ट)। यदि आप पास होते हैं version=1, तो hash()स्ट्रिंग का स्ट्रिंग पूरे स्ट्रिंग के बजाय एक बीज के रूप में उपयोग किया जाएगा, और क्योंकि पायथन यादृच्छिक रूप से 3.2 में शुरू होने वाले हैश मानों को तार करता है, आपको वास्तव में यादृच्छिक नाम मिलेगा।
— ब्लैकलाइट शाइनिंग
5

पर्ल

एम्मा ने अपने पर्स को नहीं भूलना बेहतर समझा! के तहत चलाता है strictऔर warnings।

use strict;
use warnings;

# Use a hash to store names since they're more extendible

my %people;
$people{$_}++ for qw/John Jeff Emma Steve Julie/;

print +(@_=%people)[rand@_];  # 'cos (keys %people)[rand( keys %people )]
                              # is just too long-winded.

यहाँ स्पष्टीकरण ।

— ज़ैद
स्रोत
पर्ल 5.18 ने हैश कुंजी यादृच्छिककरण (हैश टक्कर जटिलता हमलों से बचने के लिए) को शुरू करके इसे थोड़ा बदल दिया।
— कोनराड बोरोस्की
4

जावास्क्रिप्ट

function getDrinksBuyer(){ 
    var people = ["Jeff", "Emma", "Steve", "Julie"];
    var rand = Math.random(0,4)|0;
    return people[rand];
}

|00 हर समय में परिणाम है, लेकिन ऐसा लगता है कि कुछ अन्य पूर्णांकन कर रहा है।

— मैट
स्रोत
मुझें यह पसंद है। हालांकि मैं ऐसा करूंगा parseInt(Math.random(0, 4))और शायद इस तरह की टिप्पणी करूंगा - Math.randomएक डबल लौटाता है, इसलिए इसे एक पूर्णांक में परिवर्तित करें
— क्लाउडी
5
चाल वास्तव में है कि Math.randomहमारे मामूली मापदंडों के लिए कुछ भी परवाह नहीं है। यह संख्याओं को अपने तरीके से चुनता है। |0सही ढंग से अप्रत्याशित परिणाम गोलाई है, और इसलिए किसी भी प्रवंचना का एक स्रोत नहीं है।
— कीन
|0कुछ के लिए बहुत स्पष्ट है (हम में से सबसे अधिक संभावना है), लेकिन मैं शर्त लगा सकता हूं कि बहुत से लोग हैं जो यह नहीं जानते कि यह क्या करता है। वह समूह जिसे मैं छल पर निर्भर कर रहा था।
— मैट
3
@ मैट का मतलब है कि |0, यदि आप जानते हैं कि यह क्या करता है, ऐसा लगता है कि यह नीचे की ओर बढ़ रहा है, और यह नीचे की ओर बढ़ रहा है, इसलिए यह एक धोखा नहीं है। (और अगर किसी को पता नहीं है कि क्या |0करता है, तो भ्रामक कोड के लिए कोई उपयोग नहीं है; आप उन्हें सिर्फ उन्हें बता सकते हैं जो आप उन्हें विश्वास करते हैं।) इसके बजाय, आपके उत्तर में अप्रत्याशित व्यवहार इस तथ्य पर आधारित है जो Math.random(0,4)कार्यात्मक रूप से समान है Math.random()। क्योंकि Math.randomमापदंडों का उपयोग नहीं करता है।
— कीन
4

जे

;(?.5) { 'John'; 'Jeff'; 'Emma'; 'Steve'; 'Julie'

गरीब जूली ... सामान्य ज्ञान: यह सबसे साफ जम्मू मैं कभी लिखा गया है हो सकता है ...

यह कोड वास्तव में सही है, केवल एक चीज को छोड़कर। ?.एकसमान rng है: ?.5हमेशा लौटेगा 4. ?5सही हो गया होगा।

— ɐɔıʇǝɥʇuʎs
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.