Як маленький жарт в офісі, хтось захотів сценарій, який випадковим чином вибирає ім’я, і сказана людина зробить випивку.

Давайте назвемо людей Джона, Джеффа, Емми, Стіва та Джулі.

Я думав, що було б смішно зробити сценарій, який здається випадковим на швидкому погляді, але насправді завжди дає ту саму людину, що і результат (Ви, кого ви обираєте).

Найвищий проголосований відповідь виграє через тиждень

А переможець -….

Пол Р. (наразі) 158 голосів.

Відповіді тут чудові, і якщо хтось ще має інші ідеї, які ще не були опубліковані, додайте їх, я люблю їх читати.

С

Важливо вирішити, хто купує якомога швидше, щоб не витрачати дорогоцінний питний час - отже, C - це очевидний вибір для отримання максимальної продуктивності:

#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;після кожного випадку в операторі перемикання було після. Однак, однак, кожен випадок "проникає" до наступного, тому бідна Джулі завжди закінчує купувати напої.

PHP

Не можна цього відпустити, ось ось ще один:

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

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

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

Це насправді не гарантує виробництва Джона, але шанси дуже хороші. PHP з радістю візьме все, що / dev / random може запропонувати, побачивши, що він (ймовірно) не може його розібрати, і придумає дуже розумне число 0. Зрештою, попередження програміста про потенційну помилку вважається смертельним гріхом у PHP.

Хаскелл

Це занадто прозоро, якщо він завжди повертає те саме ім'я, тому спробуйте наступне

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

Hugs реалізує лише кооперативний багатозадачність, тому rotateнитка ніколи не запускається

Bash - максимальна простота

Дуже простий приклад - давайте уникати будь-яких проблем, роблячи це підручником способом. Не забудьте посадити генератор з системного годинника для хорошого результату!

#!/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поверне тривалість часу, коли інтерактивна оболонка користувача працювала.

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

Це може не обдурити людей, які знайомі з API .Net, але люди, які його не знають, можуть повірити, що це OrderByзмінює об’єкт, на який ви його викликаєте, і це правдоподібна помилка для новачка в API, який він може зробити.

PowerShell

$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.Lengthоцінюється як 1, і random -maximum 1завжди повертає 0, оскільки максимум є виключним.

Q

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

Q завжди ініціалізує насіння випадкових чисел з однаковим значенням.

Perl

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 - 4 до 0-ї позиції @indexсписку. Друкуючи масив, він належним чином друкує випадкове ціле число в @index, але при використанні в якості індексу масиву в $people[@index]@index використовує скалярний контекст, надаючи йому значення розміру списку, тобто 1.

Цікаво, що @people[@index]він індексує належним чином.

Цікаво, @people[@index]що хеш-фрагмент у Perl @indexє таким, що його оцінюють у контексті списку; у цьому випадку це єдиний список записів, і тому він працює правильно

ECMAScript

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

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

Це завжди бере Джулі.

Він має дужки всередині квадратних дужок, і оператор комами повертає значення свого правого операнда.
Це також дуже легко пропустити. Я раніше її пропускав у реальному коді.

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

Хитрість полягає в тому, що метод new Random().NextDouble()повертає вдвічі між 0 і 1. Застосовуючи Math.Floor()це значення, воно завжди буде 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]);

Підказка:

Зробіть насіння з GUID. У путівників можливе зіткнення 4 × 10-10. Супер випадковий.

Відповідь:

Принаймні, коли ви використовуєте Guid.NewGuid(), ого! (Підлий спосіб зробити насіння завжди 0). Також безглуздо (int) для неправильного спрямування.

bash / coreutils

Це взято майже дослівно зі сценарію, який я написав для подібної мети.

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

Навіть забути використовувати верхній регістр R - це помилка, яку я періодично робив у сценаріях реального життя.

Рубін

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

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

З цим було б правильно працювати sort_by, але sortочікується, що функція порівняння працює так <=>. Результат rand () завжди буде позитивним, тому він завжди буде отримувати рівноцінні результати за умови sortдетермінації алгоритму вашої реалізації Ruby . Мій Ruby 1.9.3 завжди видає Джулі.

Рубін

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

puts names[rand() % 5]

rand() без аргументів створюється випадковий проміжок між 0 і 1. Отже, модуль 5 нічого не робить, а при нарізанні масиву з аргументом float Ruby просто округляє його вниз, тому це завжди повертає Джона.

Perl

три srands зроблять це втричі більш випадковим!

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

пояснення

у perl немає $ 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!";

ви можете сказати, хто це зробив, просто подивившись на код?

пояснення:

у Perl $#arrayповертає індекс останнього елемента; так як масиви нуля, дали посилання на масив з п'ятьма елементами, $#$aref_peopleбуде 4.
randповертає випадкове число більше або рівне нулю і менше його параметра, тому воно ніколи не повернеться 4, що фактично означає, що Джулі ніколи не купуватиме напої :)

Пітон

Всім відомо, що ви не можете довіряти випадковості в такому невеликому зразковому просторі; щоб зробити це по-справжньому випадковим, я відмовився від застарілого методу вибору імені зі списку, і замість цього моя програма викладе зовсім випадкове ім’я. Оскільки в більшості імен в офісі було 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)

Природно, я зробив деякі підготовчі роботи, щоб переконатися, що я підбираю потрібне насіння.

С

#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, якщо ви погано займаєтесь математикою. :)

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

Розмір вектора фактично дорівнює 1 завдяки дужкам, які використовуються у списку ініціалізатора. Оператор Comma відкине всі імена та поверне останнє, отже, покупець завжди Рой.

Скала

Я знаю, що мої користувачі будуть скептично налаштовані, тому я включив доказ того, що моя випадковість справді справедлива!

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 незалежно від решти "випадковості".

Javascript (з Underscore.js )

Оскільки у JavaScript немає вбудованої перетасовки, ми будемо використовувати Underscore.js

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

_.shuffle повертає перетасований масив, він не змінюється на місці, як Array.prototype.sort () , вибачте Джон

JavaScript

Друга спроба, ця трохи складніше:

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

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

argumentsЗмінна локально доступні для функцій і являє собою масив з усіх аргументів , переданих у функцію. Використовуючи просте іменування та передаючи масив до самої функції, ви можете підробити те, що ми приймаємо не довжину масиву, а насправді довжину списку аргументів (що становить 1). Це можна ще краще виконати за допомогою спеціальних символів або типу шрифту.

C ++

Для справедливості нам слід проводити багато, багато випробувань і обирати того, кого обирають найчастіше.

#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? Вибач, Джон.

T-SQL (2008+)

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

Пояснення:

У MS SQL Server RAND()оцінюється лише один раз за виконання. Кожному імені завжди присвоюється однаковий номер, залишаючи початкове замовлення. Іван перший. Відстій для Джона.

Пропоноване вдосконалення:

T-SQL може створювати пристойну якість, за рядком випадкових чисел за допомогою RAND(CHECKSUM(NEWID())).

Луа

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для гарної RNG. На жаль, Джулі завжди купує (принаймні, на моєму комп’ютері).

Ідіоматичний 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, передається як параметр a функцію висіву, вона насправді просто ігнорується. Насінна змінна дійсно встановлюється з годинника, тому її можна виводити в кінці разом з назвою, щоб нанести шкоду травмі, але все одно завжди буде Стів, який купує напої.

JavaScript

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

Ну, вибачте, Math.randomне приймає параметр і завжди повертає число з [0, 1). І все-таки це щаслива варіативна функція і не скаржиться на аргументи!

Пітон

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 (випадковий) дає постійний рядок; не випадкове значення

Perl

Еммі краще не забути гаманець! Працює під 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.

Пояснення тут .

JavaScript

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

В |0результати в 0 весь час , але схоже , що це роблять деякі інші округлення.

J

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

Бідна Джулі ... Дрібниці: це, можливо, було найчистішим J, що я коли-небудь писав ...

Цей код насправді правильний, за винятком однієї речі. ?.- це рівномірний rng: ?.5завжди повертається 4. ?5було б правильно.