Jako mały żart w biurze ktoś chciał skryptu, który losowo wybiera nazwisko, i powiedział, że ktoś zrobi drinka.

Nazwijmy ludzi John, Jeff, Emma, ​​Steve i Julie.

Pomyślałem, że fajnie byłoby stworzyć skrypt, który na pierwszy rzut oka wydaje się losowy, ale w rzeczywistości zawsze daje tę samą osobę co wynik (do ciebie, kogo wybierzesz).

Najwyżej głosowana odpowiedź wygrywa po tygodniu

A zwycięzcą jest....

Paul R z (obecnie) 158 głosami.

Odpowiedzi tutaj są świetne, a jeśli ktoś ma jeszcze jakieś pomysły, które nie zostały jeszcze opublikowane, dodaj je, uwielbiam je czytać.

do

Ważne jest, aby zdecydować, kto kupuje tak szybko, jak to możliwe, aby nie marnować cennego czasu na picie - dlatego C jest oczywistym wyborem, aby uzyskać maksymalną wydajność:

#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;
}

Wyjaśnienie:

To działałoby dobrze, gdyby break;w instrukcji switch znajdował się po każdym przypadku. Na razie jednak „przypadek” przechodzi do następnego, więc biedna Julie zawsze kupuje napoje.

PHP

Nie mogłem odpuścić, więc oto kolejny:

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

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

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

W rzeczywistości nie jest to gwarantowane, aby produkować Johna, ale szanse są bardzo dobre. PHP chętnie weźmie wszystko, co / dev / random ma do zaoferowania, aby zobaczyć, że (prawdopodobnie) nie może go przeanalizować i zamiast tego wymyśli bardzo rozsądną liczbę 0. W końcu powiadomienie programisty o potencjalnym błędzie jest uważane za śmiertelny grzech w PHP.

Haskell

Jest zbyt przezroczysty, jeśli zawsze zwraca tę samą nazwę, więc spróbuj wykonać następujące czynności

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

Ilekroć chcesz, aby był losowy:

[~]$ runghc prog.hs
Shuffling
Steve

[~]$ runghc prog.hs
Shuffling
Julie

A dla twojego niefortunnego celu:

[~]$ runhugs prog.hs
Shuffling
John

[~]$ runhugs prog.hs
Shuffling
John

Uściski implementują tylko wielozadaniowość kooperacyjną, więc rotatewątek nigdy się nie uruchomi

Bash - maksymalna prostota

Bardzo prosty przykład - unikajmy problemów, robiąc to w sposób podręcznikowy. Nie zapomnij zaszczepić generatora z zegara systemowego, aby uzyskać dobry wynik!

#!/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

Zależy to od tego, czy użytkownik nie wie, co $SECONDSwłaściwie robi wbudowane narzędzie; zwraca liczbę sekund od uruchomienia bieżącej powłoki. Jak jest w skrypcie, powłoka zawsze zaczynała się zero sekund temu, więc generator jest zawsze zaszczepiony, 0a Julie zawsze kupuje piwo.

Premia:

Ten dość dobrze radzi sobie z badaniem; Jeśli wpiszesz ten sam kod w wierszu poleceń zamiast w skrypcie, da on losowe wyniki, ponieważ $SECONDSzwróci czas działania interaktywnej powłoki użytkownika.

DO#

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]);
        }
    }
}

Może to nie zmylić osób zaznajomionych z interfejsem API .Net, ale osoby, które go nie znają, mogą wierzyć, że OrderBymodyfikują obiekt, do którego go wywołujesz, i jest to prawdopodobny błąd dla nowicjuszy interfejsu API.

PowerShell

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

To zawsze wyjdzie John.

$namesto taki, System.Collections.Hashtablektóry nie ma Lengthwłaściwości. Począwszy od programu PowerShell v3 Length(i również Count) można go użyć jako właściwości dowolnego obiektu. Jeśli obiekt nie ma właściwości, zwróci, 1gdy obiekt nie będzie miał wartości null, w przeciwnym razie zwróci 0. Tak więc w mojej odpowiedzi $names.Lengthocenia się jako 1 i random -maximum 1zawsze zwraca 0, ponieważ maksimum jest wyłączne.

Q

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

Q zawsze inicjuje ziarno liczby losowej o tej samej wartości.

Perl

use strict;

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

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

Wydruki: Person X is buying: Jeff(gdzie X jest od 0-4)

Trochę nadużywa kontekstu skalarnego. @index = int(rand() * 5)umieszcza losową liczbę całkowitą od 0 do 4 na 0 pozycji @indexlisty. Podczas drukowania tablicy poprawnie drukuje losową liczbę całkowitą w @index, ale przy użyciu jako indeksu tablicy w $people[@index]@index używa kontekstu skalarnego, nadając mu wartość wielkości listy, tj 1.

Co ciekawe, @people[@index]sprawia, że ​​indeks jest poprawnie.

Co ciekawe, @people[@index]w Perlu jest wystarczający plasterek, więc @indexjest oceniany w kontekście listy; w tym przypadku jest to lista pojedynczych wpisów i dlatego działa poprawnie

ECMAScript

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

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

To zawsze podnosi Julie.

Ma nawiasy kwadratowe, a przecinek operator zwraca wartość swojego prawego operandu.
Bardzo łatwo go przeoczyć. Wcześniej tęskniłem za prawdziwym kodem.

DO#

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]);
        }
    }
}

Sztuczka polega na tym, że metoda new Random().NextDouble()zwraca podwójną wartość od 0 do 1. Po zastosowaniu Math.Floor()tej wartości zawsze będzie to 0.

DO#

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]);

Wskazówka:

Wygeneruj seed z GUID. Prowadnice mają szansę na kolizję 4 × 10–10. Super losowy.

Odpowiedź:

Przynajmniej kiedy używasz Guid.NewGuid(), ups! (Podstępny sposób na zrobienie nasion zawsze 0). Również bezcelowe (int) dla błędnego przekierowania.

bash / coreutils

Zostało to zaczerpnięte niemal dosłownie ze skryptu, który napisałem w podobnym celu.

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

Nawet zapominanie o użyciu dużej litery R jest błędem, który czasami popełniam w skryptach z prawdziwego życia.

Rubin

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

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

Działa to poprawnie sort_by, ale sortoczekuje, że działa funkcja porównania <=>. Wynik rand () zawsze będzie dodatni, więc zawsze będzie generował równoważne wyniki, pod warunkiem, że sortalgorytm twojej implementacji Ruby jest deterministyczny. Mój Ruby 1.9.3 zawsze wyświetla Julie.

Rubin

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

puts names[rand() % 5]

rand() bez argumentów tworzy losową liczbę zmiennoprzecinkową od 0 do 1. Tak więc modulo 5 nic nie robi, a podczas krojenia w tablicę z argumentem zmiennoprzecinkowym Ruby zaokrągla ją w dół, więc zawsze zwraca John.

Perl

trzy srands sprawią, że będzie trzy razy bardziej losowy!

#!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!";

wyjaśnienie

w perlu nie ma $ RANDOM, jest to niezdefiniowana zmienna. kod zawsze zwróci pierwszy element z listy - napoje na Johnie :)

edytować:

po przejrzeniu kodu jeden z pięciu gości postanowił naprawić oczywisty błąd, tworząc następujący program:

#!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!";

czy możesz powiedzieć, kto to zrobił, patrząc na kod?

wyjaśnienie:

w Perlu $#arrayzwraca indeks ostatniego elementu; ponieważ tablice są zerowe, odniesienie do tablicy z pięcioma elementami $#$aref_peoplebędzie 4.
randzwraca liczbę losową większą lub równą zero i mniejszą niż jej parametr, więc nigdy nie zwróci 4, co w rzeczywistości oznacza, że ​​Julie nigdy nie kupi napojów :)

Pyton

Wszyscy wiedzą, że nie można ufać przypadkowości w tak małej próbce; aby było naprawdę losowe, zrezygnowałem z przestarzałej metody wybierania nazwy z listy, a zamiast tego mój program wypisze całkowicie losową nazwę. Ponieważ większość nazwisk w biurze ma 4 litery, zadowolimy się tym.

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)

Oczywiście wykonałem pewne prace przygotowawcze, aby upewnić się, że wybrałem właściwe ziarno.

do

#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] );
}

Przepraszam, Jeff!

Po kilku iteracjach r == 1 mod 5 z powodu matematyki. Moralność: nie pisz własnego PRNG, jeśli jesteś kiepski z matematyki. :)

C ++ 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;
}

Rozmiar wektora wynosi w rzeczywistości 1 ze względu na nawiasy użyte na liście inicjalizatora. Operator przecinka odrzuci wszystkie nazwiska i zwróci ostatnie, dlatego nabywcą jest zawsze Roy.

Scala

Wiem, że moi użytkownicy będą sceptyczni, dlatego dołączyłem dowód, że moja losowość jest naprawdę sprawiedliwa!

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
  }

}

Jeden przykładowy przebieg:

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

O ile ktoś nie będzie miał szczęścia, John zawsze kupuje napoje.

„Dowód” losowości polega na tym, że rand(1, 4) * rand(1, 4) % 5nadal jest równomiernie rozłożony między 1 a 4 włącznie. Ale rand(1, 5) * rand(1, 5) % 6jest zdegenerowany. Istnieje możliwość uzyskania 0, co w efekcie dałoby wynik końcowy 0 niezależnie od reszty „losowości”.

JavaScript (z Underscore.js )

Ponieważ javascript nie ma wbudowanego odtwarzania losowego, będziemy używać Underscore.js

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

_.shuffle zwraca przetasowaną tablicę, nie zmienia się ona jako Array.prototype.sort () , przepraszam John

JavaScript

Druga próba, ta jest trochę trudniejsza:

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

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

argumentsZmienna jest dostępny lokalnie dla funkcji i jest tablicą wszystkich argumentów przekazywanych do funkcji. Używając prostej nazewnictwa i przekazując tablicę do samej funkcji, możesz sfałszować, że nie bierzemy długości tablicy, ale w rzeczywistości długości listy argumentów (która wynosi 1). Można to jeszcze lepiej wykonać za pomocą specjalnych znaków lub typu czcionki.

C ++

Aby być uczciwym, powinniśmy przeprowadzić wiele, wiele prób i wybrać tego, który jest najczęściej wybierany.

#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))]);
}

Jaka jest wartość 1<<31? Przepraszam, John.

T-SQL (2008+)

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

Wyjaśnienie:

W MS SQL Server RAND()ocenia tylko raz na wykonanie. Każde imię ma zawsze przypisany ten sam numer, pozostawiając oryginalne zamówienie. John jest pierwszy. Bani dla Johna.

Sugerowana poprawa:

T-SQL może generować przyzwoite jakości losowe liczby w wierszu RAND(CHECKSUM(NEWID())).

Lua

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()służy do pomiaru czasu, os.time()to jest to , co powinno być używane math.randomseeddo dobrego RNG. Niestety Julie zawsze kupuje (przynajmniej na moim komputerze).

Idiomatic C ++ 11

Gdy chodzi o napoje, szczególnie ważne jest, aby być na bieżąco z najnowszymi standardami i stylami kodowania; jest to świetny przykład bardzo wydajnego i zgodnego z idiomem selektora nazw C ++ 11.

Jest on wysyłany z zegara systemowego i za każdym razem wysyła nasiona wraz z nazwą do weryfikacji.

#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
}

Wypróbuj to na żywo: http://ideone.com/KOet5H

Ok, więc ogólnie jest to całkiem niezły kod; jest wiele czerwonych śledzi, które sprawiają, że zbyt uważnie patrzysz na kod, aby zauważyć oczywiste - że RNG nigdy nie jest faktycznie zaszczepiony :) W tym przypadku seedjest to tylko liczba całkowita i chociaż wygląda na to, że enginejest przekazywana jako parametr do parametru funkcja wysiewania, w rzeczywistości jest po prostu ignorowana. Zmienna nasion naprawdę jest ustawiana na podstawie zegara, więc może być wyprowadzana na końcu wraz z nazwą, aby dodać obrażenia do obrażeń, ale wciąż to Steve kupuje napoje.

JavaScript

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

Przykro nam, Math.randomnie przyjmuje parametru i zawsze zwraca liczbę z [0, 1). Mimo to jest to szczęśliwa funkcja variadyczna i nie narzeka na argumenty!

Pyton

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 (losowy) daje stały ciąg; nie losowa wartość

Perl

Emma nie powinna zapomnieć o swojej torebce! Działa pod stricti 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.

Wyjaśnienie tutaj .

JavaScript

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

Te |0wyniki w 0 cały czas, ale wygląda to robi jakąś inną zaokrąglenia.

jot

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

Biedna Julie ... Ciekawostki: to mógł być najczystszy J, jaki kiedykolwiek napisałem ...

Ten kod jest właściwie poprawny, z wyjątkiem jednej rzeczy. ?.jest jednolity rng: ?.5zawsze zwróci 4. ?5byłoby poprawne.