Als kleiner Scherz im Büro wollte jemand ein Skript, das zufällig einen Namen auswählt, und diese Person wird eine Runde Getränke machen.

Nennen wir die Leute John, Jeff, Emma, ​​Steve und Julie.

Ich dachte, es wäre lustig, ein Skript zu erstellen, das auf den ersten Blick zufällig erscheint, aber tatsächlich immer die gleiche Person wie die Ausgabe enthält (Sie entscheiden selbst, wen Sie wählen).

Die Antwort mit der höchsten Stimmenzahl gewinnt nach einer Woche

Und der Gewinner ist....

Paul R mit (derzeit) 158 Stimmen.

Die Antworten hier sind großartig, und wenn jemand andere Ideen hat, die noch nicht veröffentlicht wurden, fügen Sie sie bitte hinzu. Ich liebe es, sie durchzulesen.

C

Es ist wichtig zu entscheiden, wer so schnell wie möglich kauft, um keine kostbare Trinkzeit zu verschwenden - daher ist C die offensichtliche Wahl, um maximale Leistung zu erzielen:

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

Erläuterung:

Dies würde gut funktionieren, wenn break;in der switch-Anweisung nach jedem Fall eine steht . So wie es aussieht, "fällt" jeder Fall zum nächsten durch, so kauft die arme Julie am Ende immer die Getränke.

PHP

Konnte das nicht loslassen, also hier ist noch einer:

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

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

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

Dies ist eigentlich nicht garantiert, um John zu produzieren, aber die Chancen stehen sehr gut. PHP nimmt gerne das, was / dev / random zu bieten hat, um zu sehen, dass es es (wahrscheinlich) nicht analysieren kann und liefert stattdessen die sehr vernünftige Zahl 0. Schließlich wird es in PHP als tödliche Sünde angesehen, den Programmierer auf einen möglichen Fehler aufmerksam zu machen.

Haskell

Es ist zu transparent, wenn immer derselbe Name zurückgegeben wird. Versuchen Sie Folgendes

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

Wann immer Sie wollen, dass es zufällig ist:

[~]$ runghc prog.hs
Shuffling
Steve

[~]$ runghc prog.hs
Shuffling
Julie

Und für dein unglückliches Ziel:

[~]$ runhugs prog.hs
Shuffling
John

[~]$ runhugs prog.hs
Shuffling
John

Hugs implementiert nur kooperatives Multitasking, sodass der rotateThread niemals ausgeführt wird

Bash - maximale Einfachheit

Ein sehr einfaches Beispiel - lassen Sie uns Probleme vermeiden, indem Sie es wie im Lehrbuch machen. Vergessen Sie nicht, den Generator von der Systemuhr zu trennen, um ein gutes Ergebnis zu erzielen!

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

Dies setzt $SECONDSvoraus, dass der Benutzer nicht weiß, was das eingebaute Programm tatsächlich tut. Gibt die Anzahl der Sekunden seit dem Start der aktuellen Shell zurück. Wie es in einem Skript steht, hat die Shell immer vor null Sekunden begonnen, sodass der Generator immer voll ist 0und Julie immer das Bier kauft.

Bonus:

Dieser hält der Prüfung ziemlich gut stand; Wenn Sie denselben Code in der Befehlszeile anstatt in einem Skript eingeben, werden zufällige Ergebnisse ausgegeben, da $SECONDSdie Ausführungsdauer der interaktiven Shell des Benutzers zurückgegeben wird.

C #

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

Dies täuscht möglicherweise nicht diejenigen vor, die mit der .Net-API vertraut sind, aber diejenigen, die es nicht kennen, glauben möglicherweise, dass dies OrderBydas Objekt, für das Sie es aufrufen , ändert, und es ist ein plausibler Fehler für einen Neuling der API.

Power Shell

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

Dies wird immer ausgegeben John.

$namesist eine, System.Collections.Hashtabledie keine LengthEigenschaft hat. Ab PowerShell v3 kann Length(und Countkann) für jedes Objekt als Eigenschaft verwendet werden. Wenn ein Objekt nicht über die Eigenschaft verfügt, wird es zurückgegeben, 1wenn das Objekt nicht null ist, andernfalls wird es zurückgegeben 0. In meiner Antwort wird also $names.Length1 ausgewertet und es wird random -maximum 1immer 0 zurückgegeben, da das Maximum exklusiv ist.

Q.

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

Q initialisiert seinen Zufallszahlen-Startwert immer mit demselben Wert.

Perl

use strict;

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

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

Ausdrucke: Person X is buying: Jeff(wobei X von 0-4 ist)

Skalarkontext ein wenig missbrauchen. @index = int(rand() * 5)Setzt eine zufällige Ganzzahl von 0 bis 4 an die 0-te Stelle der @indexListe. Beim Drucken des Arrays wird die zufällige Ganzzahl in @index ordnungsgemäß gedruckt. Bei Verwendung als Array-Index in $people[@index]@index wird jedoch ein skalarer Kontext verwendet, der den Wert der Listengröße angibt, d 1. H.

Interessanterweise @people[@index]macht es richtig indizieren.

Interessanterweise @people[@index]ist ein Hash-Slice in Perl und wird daher im Listenkontext @indexausgewertet. In diesem Fall handelt es sich um eine einzelne Eintragsliste, weshalb sie ordnungsgemäß funktioniert

ECMAScript

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

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

Es nimmt immer Julie.

Es enthält eckige Klammern, und der Kommaoperator gibt den Wert seines rechten Operanden zurück.
Es ist auch sehr leicht zu übersehen. Ich habe es schon mal in echtem Code vermisst .

C #

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

Der Trick ist, dass die Methode new Random().NextDouble()ein Double zwischen 0 und 1 zurückgibt. Wenn Sie Math.Floor()diesen Wert anwenden , ist er immer 0.

C #

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

Hinweis:

Startwert aus GUID generieren. Guids haben eine Kollisionswahrscheinlichkeit von 4 × 10−10. Super zufällig.

Antworten:

Zumindest wenn du benutzt Guid.NewGuid(), whoops! (Sneaky Weg, um Samen immer 0 zu machen). Auch sinnlos (int) für Fehlleitungen.

Bash / Coreutils

Dies ist fast wörtlich aus einem Skript entnommen, das ich für einen ähnlichen Zweck geschrieben habe.

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

Selbst das Vergessen, ein R in Großbuchstaben zu schreiben, ist ein Fehler, den ich gelegentlich in echten Skripten gemacht habe.

Rubin

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

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

Dies würde funktionieren richtig mit sort_by, abersort erwartet , dass eine Vergleichsfunktion , die wie funktioniert <=>. Das Ergebnis von rand () ist immer positiv, sodass es immer äquivalente Ergebnisse liefert, vorausgesetzt, der sortAlgorithmus Ihrer Ruby-Implementierung ist deterministisch. Mein Ruby 1.9.3 gibt immer Julie aus.

Rubin

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

puts names[rand() % 5]

rand() Ohne Argumente wird ein zufälliger Gleitkommawert zwischen 0 und 1 erzeugt. Modulo 5 führt also nichts aus, und wenn Ruby in ein Array mit einem Gleitkomma-Argument zerlegt, rundet es einfach ab, sodass dies immer John zurückgibt.

Perl

drei srands machen es dreimal zufälliger!

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

Erläuterung

In Perl gibt es kein $ RANDOM, sondern eine undefinierte Variable. Der Code gibt immer das erste Element aus der Liste zurück - Getränke auf John :)

bearbeiten:

Nachdem einer der fünf Entwickler den Code durchgearbeitet hat, hat er beschlossen, den offensichtlichen Fehler zu beheben, und das folgende Programm erstellt:

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

Kannst du sagen, wer es getan hat, indem du dir den Code ansiehst?

Erläuterung:

Gibt in Perl $#arrayden Index des letzten Elements zurück. da Arrays Null-Basis wird, einen Verweis auf ein Feld mit fünf Elementen gegeben $#$aref_peoplewerden 4.
randgibt eine Zufallszahl zurück, die größer oder gleich Null und kleiner als ihr Parameter ist, daher wird sie niemals zurückgegeben 4, was effektiv bedeutet, dass Julie niemals Getränke kauft :)

Python

Jeder weiß, dass man in einem so kleinen Probenraum der Zufälligkeit nicht trauen kann; Um es wirklich zufällig zu machen, habe ich die veraltete Methode zum Auswählen eines Namens aus einer Liste aufgegeben. Stattdessen schreibt mein Programm einen vollständig zufälligen Namen. Da die meisten Namen im Büro 4 Buchstaben hatten, werden wir uns damit abfinden.

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)

Natürlich habe ich einige Vorbereitungsarbeiten durchgeführt, um sicherzustellen, dass ich den richtigen Samen auswähle.

C

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

Entschuldigung, Jeff!

Nach ein paar Iterationen ist r == 1 mod 5, aus mathematischen Gründen. Moral: Schreiben Sie kein eigenes PRNG, wenn Sie schlecht in Mathe sind. :)

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

Die Größe des Vektors ist aufgrund der in der Initialisierungsliste verwendeten Klammer 1. Der Kommaoperator verwirft alle Namen und gibt den letzten zurück, daher ist der Käufer immer Roy.

Scala

Ich weiß, dass meine Benutzer skeptisch sind, daher habe ich einen Beweis dafür beigelegt, dass meine Zufälligkeit wirklich fair ist!

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
  }

}

Ein Beispiellauf:

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

John kauft immer die Getränke, es sei denn, jemand anderes hat großes Glück.

Der "Beweis" der Zufälligkeit beruht auf der Tatsache, dass er rand(1, 4) * rand(1, 4) % 5immer noch gleichmäßig zwischen 1 und 4 einschließlich verteilt ist. Ist rand(1, 5) * rand(1, 5) % 6aber entartet. Es besteht die Möglichkeit, dass Sie eine 0 erhalten, die dann das Endergebnis 0 ergibt, unabhängig vom Rest der "Zufälligkeit".

Javascript (mit Underscore.js )

Da in Javascript kein Shuffle integriert ist, verwenden wir Underscore.js

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

_.shuffle gibt das gemischte Array zurück, es wird nicht als Array.prototype.sort () geändert , sorry John

JavaScript

Zweiter Versuch, dies ist ein bisschen kniffliger:

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

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

Die argumentsVariable ist für Funktionen lokal zugänglich und ein Array aller an die Funktion übergebenen Argumente. Indem Sie eine einfache Benennung verwenden und ein Array an die Funktion selbst übergeben, können Sie darauf hinweisen, dass nicht die Länge des Arrays, sondern die Länge der Argumentliste (1) verwendet wird. Dies kann noch besser ausgeführt werden, indem spezielle Zeichen oder eine Schriftart verwendet werden.

C ++

Um fair zu sein, sollten wir viele, viele Versuche durchführen und auswählen, wer am häufigsten ausgewählt wird.

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

Was ist der Wert von 1<<31? Entschuldigung, John.

T-SQL (2008+)

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

Erläuterung:

In MS SQL Server wird RAND()nur einmal pro Ausführung ausgewertet. Jeder Name erhält immer die gleiche Nummer, so dass die ursprüngliche Bestellung erhalten bleibt. John ist der Erste. Saugt für John.

Verbesserungsvorschlag:

T-SQL kann ordentliche, zeilenweise Zufallszahlen mit erzeugen 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()ist für Timing-Zwecke, os.time()ist das , was math.randomseedfür eine gute RNG verwendet werden sollte. Leider kauft Julie immer (zumindest auf meinem Computer).

Idiomatisches C ++ 11

Wenn es um Getränke geht, ist es besonders wichtig, mit den neuesten Standards und Codierungsstilen auf dem Laufenden zu sein. Dies ist ein großartiges Beispiel für eine hocheffiziente und idiomkompatible C ++ 11-Namensauswahl.

Es wird von der Systemuhr geimpft und gibt den Startwert zusammen mit dem Namen jedes Mal zur Überprüfung aus.

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

Versuchen Sie dies live: http://ideone.com/KOet5H

Ok, das ist eigentlich ein ziemlich guter Code. es gibt eine Menge von falschen Fährten Sie schauen zu dicht auf dem Code , um das Offensichtliche zu bemerken - , dass die RNG eigentlich nie :) ausgesät in diesem Fall seednur eine ganze Zahl ist, und während es sieht aus wie engineals Parameter an einem übergeben wird Seeding-Funktion, es ist eigentlich nur ignoriert. Die Saatvariable wird wirklich von der Uhr aus eingestellt, sodass sie am Ende zusammen mit dem Namen ausgegeben werden kann, um die Verletzung zu beleidigen, aber es wird immer Steve sein, der die Getränke kauft.

JavaScript

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

Tut mir leid, Math.randomnimmt keinen Parameter und gibt immer eine Zahl von [0, 1) zurück. Trotzdem ist es eine glückliche Variadic-Funktion und beschwert sich nicht über Argumente!

Python

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) ergibt eine konstante Zeichenkette; kein zufälliger Wert

Perl

Emma sollte ihren Geldbeutel besser nicht vergessen! Läuft unter strictund 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.

Erklärung hier .

JavaScript

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

Das |0Ergebnis ist die ganze Zeit 0, sieht aber so aus, als würde es eine andere Rundung machen.

J

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

Die arme Julie ... Trivia: Das war vielleicht das sauberste J, das ich je geschrieben habe ...

Dieser Code ist bis auf eines richtig. ?.is the uniform rng: ?.5wird immer zurückkehren 4. ?5wäre richtig gewesen.