Ofiste küçük bir şaka olarak birisi rastgele bir isim seçen bir senaryo istedi ve söylenen kişi bir tur içki yapacak.

İnsanlara John, Jeff, Emma, ​​Steve ve Julie diyelim.

Hızlı bir bakışta rastgele görünen bir senaryo yazmanın komik olacağını düşünmüştüm, ama aslında her zaman çıktıyla aynı kişiyi verir (seçtiğiniz kime kadar).

En yüksek oyu alan cevap bir hafta sonra kazanır

Ve kazanan....

Paul R (şu anda) 158 oyla.

Buradaki cevaplar çok iyi ve eğer henüz bir başkası henüz yayınlanmayan başka bir fikri varsa, lütfen onları ekleyin, onlarla okumayı seviyorum.

C

Değerli içme zamanını boşa harcamamak için kimin mümkün olduğunca çabuk aldığına karar vermek önemlidir - bu nedenle en yüksek performansı elde etmek için C açık bir seçimdir:

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

Açıklama:

Bu break;, anahtar ifadesinde her davadan sonra olsaydı iyi sonuç verirdi . Bununla birlikte, her vaka bir diğerine “düştü” derken, fakir Julie her zaman içkileri satın alır.

PHP

Bunun gitmesine izin veremezdim, işte bir tane daha:

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

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

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

Bu aslında john üretmek için garanti edilmez, ancak şans çok iyi. PHP mutlu bir şekilde / dev / random 'un alacağı şeyi alacaktır (muhtemelen) onu çözümleyemez ve bunun yerine çok makul 0 rakamı bulur. Sonuçta, programlayıcıyı olası bir hataya karşı uyarmak PHP'de ölümcül bir günah olarak kabul edilir.

Haskell

Her zaman aynı adı döndürürse çok saydamdır, aşağıdakileri deneyin

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

Ne zaman rastgele olmasını istersen:

[~]$ runghc prog.hs
Shuffling
Steve

[~]$ runghc prog.hs
Shuffling
Julie

Ve talihsiz hedefiniz için:

[~]$ runhugs prog.hs
Shuffling
John

[~]$ runhugs prog.hs
Shuffling
John

Hugs sadece işbirlikçi çoklu görev gerçekleştirir, bu yüzden rotateiplik asla çalışmayacak

Bash - maksimum basitlik

Çok basit bir örnek - ders kitabı yoluyla yaparak herhangi bir problemden kaçınalım. İyi bir sonuç için jeneratörü sistem saatinden çekmeyi unutmayın!

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

Bu, kullanıcının $SECONDSaslında ne yaptığını bilmemesine dayanır ; Geçerli kabuğun başlamasından bu yana saniye sayısını döndürür. Bir komut dosyasında olduğu gibi, kabuk her zaman sıfır saniye önce başladı, bu nedenle jeneratör her zaman tohumlanır 0ve Julie her zaman bira satın alır.

Bonus:

Bu, oldukça iyi bir incelemeye dayanıyor; Aynı kodu bir komut dosyası yerine komut satırına girerseniz $SECONDS, kullanıcının etkileşimli kabuğunun çalıştığı sürenin uzunluğunu döndüreceğinden rasgele sonuçlar verir .

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

Bu, .Net API'sine aşina olan insanları kandıramaz, ancak bilmeyen insanlar OrderBy, üzerinde çağırdığınız nesneyi değiştirdiğine inanıyor olabilir ve bu, yeni başlayanlar için API'ye yapması gereken makul bir hata olabilir.

Güç kalkanı

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

Bu her zaman çıkacaktır John.

$namesBir olan System.Collections.Hashtablebir yok olan Lengthözellik. PowerShell v3 ile başlayarak, Length(ve ayrıca Count) herhangi bir nesne üzerinde özellik olarak kullanılabilir. Bir nesne özelliğe sahip değilse 1, nesne boş olmadığında geri dönecektir, aksi halde döndürecektir 0. Yani benim cevabımda, $names.Length1 olarak değerlendirir random -maximum 1ve maksimum seçkin olduğundan her zaman 0 döndürür.

S

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

Q her zaman rasgele sayı tohumunu aynı değerde başlatır.

Perl

use strict;

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

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

Çıktıları: Person X is buying: Jeff(X, 0-4 arasındadır)

Skaler bağlamı biraz kötüye kullanmak. @index = int(rand() * 5)0 - 4 arasında rastgele bir tamsayıyı @indexlistenin 0'a yerleştirir . Diziyi yazdırırken, rasgele tamsayıyı @index'te düzgün bir şekilde yazdırır, ancak içinde bir dizi indeksi olarak kullanıldığında $people[@index], @index, skalar bağlamı kullanır, yani liste boyutunun değerini verir 1.

İlginçtir ki, @people[@index]düzgün bir şekilde endekslenir.

İlginçtir ki @people[@index], Perl'de bir karma dilimdir, dolayısıyla @indexliste bağlamında değerlendirilir; Bu durumda, tek bir giriş listesi ve bu yüzden doğru çalışıyor

ECMAScript

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

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

Her zaman Julie'yi seçer.

Köşeli parantez içinde parantez vardır ve virgül operatörü sağ işlenenin değerini döndürür.
Ayrıca kaçırması çok kolay. Daha önce gerçek kodda özledim .

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

İşin püf noktası, yöntem new Random().NextDouble()0 ile 1 arasında bir ikiye katlanır Math.Floor(). Bu değere uygulandığında , her zaman 0 olur.

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

İpucu:

GUID'den tohum üret. Kılavuzların 4 × 10−10 çarpışma şansı var. Süper rastgele.

Cevap:

En azından ne zaman kullanıyorsun Guid.NewGuid(), boğmaca! (Her zaman 0 tohum yapmak için sinsi yolu). Ayrıca yanlış yönlendirme için anlamsız (int).

bash / coreutils

Bu neredeyse benzer bir amaç için yazdığım bir senaryodan yazılı olarak alınmıştır.

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

Büyük harf kullanmayı unutmayı bile R, zaman zaman gerçek hayattaki senaryolarda yaptığım bir hatadır.

Yakut

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

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

Bu, doğru şekilde çalışır sort_by, ancak sortbunun gibi çalışan bir karşılaştırma işlevi bekler <=>. rand () 'ın sonucu her zaman pozitif olacaktır, bu nedenle Ruby uygulamanızın sortalgoritmasının deterministik olması şartıyla her zaman eşdeğer sonuçlar üretecektir . Benim Ruby 1.9.3 her zaman Julie'nin çıktısını alır.

Yakut

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

puts names[rand() % 5]

rand() hiçbir argüman olmadan 0 ile 1 arasında rasgele bir float üretir. Böylece modulo 5 hiçbir şey yapmaz ve bir float argümanına sahip bir diziye dilimleme yapılırken Ruby sadece onu yuvarlar, bu yüzden bu her zaman John'a döner.

Perl

üç srands üç kat daha rastgele yapacaktır!

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

açıklama

perl'de $ RANDOM yoktur, tanımsız bir değişkendir. Kod her zaman listedeki ilk elemanı döndürür - John’daki içecekler :)

Düzenle:

Kodun üzerinden geçtikten sonra, beş kişiden biri, aşağıdaki hatayı üreten bariz hatayı düzeltmeye karar verdi:

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

Sadece koda bakarak kimin yaptığını söyleyebilir misin?

açıklama:

Perl'de $#arrayson elemanın dizinini döndürür; diziler sıfır tabanlı olduğundan, beş öğeli bir diziye referans verildiğinde, $#$aref_peopleolacaktır 4.
randparametresinden sıfıra eşit veya daha küçük veya daha büyük bir rasgele sayı döndürür, böylece hiçbir zaman geri dönmez 4, bu da Julie'nin asla içecek almayacağı anlamına gelir.

piton

Herkes bu kadar küçük bir örnek alanda rastgeleliğe güvenemeyeceğinizi bilir; Gerçekten rastgele yapmak için listeden bir isim seçmenin modası geçmiş yöntemini bıraktım ve bunun yerine programım tamamen rastgele bir isim yapacak. Ofisteki isimlerin çoğunun 4 harfi olduğundan, bunun için karar vereceğiz.

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)

Doğal olarak, doğru tohumu seçtiğimden emin olmak için bazı hazırlık çalışmaları yaptım.

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

Üzgünüm Jeff!

Birkaç yinelemeden sonra r == 1 mod 5, matematikten dolayı. Ahlak: Eğer matematikte kötüyseniz kendi PRNG'nizi yazmayın. :)

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

Başlatıcı listesinde kullanılan parantez nedeniyle vektörün boyutu aslında 1'dir. Comma operatörü tüm isimleri atacak ve sonuncuyu geri döndürecek, bu nedenle alıcı her zaman Roy.

Scala

Kullanıcılarımın şüpheci olacağını biliyorum, bu yüzden rastlantısallığımın gerçekten adil olduğunu kanıtladım!

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
  }

}

Bir örnek çalıştırma:

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

Başkası çok şanslı olmadığı sürece, John içkileri daima satın alır.

Rasgeleliğin "kanıtı" rand(1, 4) * rand(1, 4) % 5, hala dahil olmak üzere hala 1 ile 4 arasında eşit dağılmış olmasına dayanır . Fakat rand(1, 5) * rand(1, 5) % 6yozlaşmış. 0 alma olasılığı vardır, bu da "rastgele" nin geri kalanından bağımsız olarak nihai sonucu 0 yapar.

Javascript ( Underscore.js ile )

Javascript yerleşik bir karışıklığa sahip olmadığı için Underscore.js kullanacağız

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

_.shuffle karıştırılan diziyi döndürür, Array.prototype.sort () yerine yerinde değişmez , üzgünüm John

JavaScript

İkincisi, bu biraz daha zor:

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

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

argumentsDeğişken işlevleri için lokal olarak erişilebilir ve işleve geçirilen tüm bağımsız değişkenler bir dizidir. Basit isimlendirmeyi kullanarak ve bir diziyi fonksiyonun kendisine geçirerek, dizinin uzunluğunu değil, gerçekte argümanlar listesinin uzunluğunu (1 olan) aldığımızı taklit edebilirsiniz. Bu, özel karakterler veya yazı tipi kullanılarak daha da iyi gerçekleştirilebilir.

C ++

Adil olmak gerekirse, pek çok deneme yapmalı ve en çok kimin seçildiğini seçmeliyiz.

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

Değeri nedir 1<<31? Üzgünüm John.

T-SQL (2008+)

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

Açıklama:

MS SQL Server'da, RAND()yürütme başına yalnızca bir kez değerlendirir. Her isme her zaman aynı numara verilir ve orijinal sıralamayı bırakır. John ilk. John için berbat.

Önerilen gelişme:

T-SQL iyi kalitede, sıra başına rastgele sayılarla üretebilir 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()zamanlama amaçlıdır, iyi RNG için os.time()kullanılması gereken şeydir math.randomseed. Ne yazık ki, Julie her zaman satın alır (en azından bilgisayarımda).

Deyimsel C ++ 11

İçecekler söz konusu olduğunda, en son standartlara ve kodlama stillerine ayak uydurmak özellikle önemlidir; bu, oldukça verimli ve deyim uyumlu bir C ++ 11 isim seçicinin harika bir örneğidir.

Sistem saatinden tohumlanır ve her seferinde doğrulama için adı ile birlikte tohum çıkarır.

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

Bunu canlı dene: http://ideone.com/KOet5H

Tamam, bu aslında genel olarak oldukça iyi bir kod; bariz olduğunu farketmek için çok yakından bakmak için kırmızı ringa balığı vardır - RNG'nin aslında hiç ekilmediğini gösterir :) Bu durumda seedsadece bir tamsayıdır ve görünüşe göre enginebir parametre olarak geçirilir. tohumlama fonksiyonu, aslında sadece göz ardı edilir. Tohum değişkeni gerçekten zamandan ayarlanır, bu yüzden en sonunda yaralanmaya hakaret eklemek için adla birlikte çıkarılabilir, ancak yine de içecekleri alan Steve yine de olacaktır.

JavaScript

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

Üzgünüm, Math.randombir parametre almaz ve her zaman [0, 1) 'den bir sayı döndürür. Yine de, mutlu bir değişken işlevdir ve tartışmalardan şikayet etmez!

piton

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) sabit bir dize verir; rastgele bir değer değil

Perl

Emma çantasını unutmadı! Altında çalışır strictve 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.

Burada açıklama .

JavaScript

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

Her |0zaman 0 sonuçları var ama sanki başka bir yuvarlama yapıyor gibi görünüyor.

J

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

Zavallı Julie ... Trivia: Bu yazdığım en temiz J olabilirdi ...

Bu kod aslında bir şey dışında doğrudur. ?.tek tip rng: ?.5her zaman geri döner 4. ?5doğru olurdu.