Como una pequeña broma en la oficina, alguien quería un guión que escogiera un nombre al azar, y dicha persona haría una ronda de bebidas.

Llamemos a las personas John, Jeff, Emma, ​​Steve y Julie.

Pensé que sería divertido hacer un guión que parezca aleatorio a simple vista, pero que en realidad siempre da a la misma persona que la salida (depende de ti quien elijas).

La respuesta más votada gana después de una semana

Y el ganador es....

Paul R con (actualmente) 158 votos.

Las respuestas aquí son geniales, y si alguien más tiene otras ideas que aún no se han publicado, agréguelas, me encanta leerlas.

C

Es importante decidir quién está comprando lo más rápido posible, para no perder el tiempo precioso de beber, por lo tanto, C es la opción obvia para obtener el máximo rendimiento:

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

Explicación:

Esto funcionaría bien si hubiera un break;después de cada caso en la declaración de cambio. Sin embargo, tal como están las cosas, cada caso "cae" al siguiente, por lo que la pobre Julie siempre termina comprando las bebidas.

PHP

No podía dejarlo pasar, así que aquí hay otro:

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

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

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

En realidad, esto no garantiza que produzca John, pero las posibilidades son muy buenas. PHP felizmente tomará lo que tenga que ofrecer / dev / random para ver que (probablemente) no pueda analizarlo y en su lugar obtendrá el número muy razonable 0. Después de todo, alertar al programador de un posible error se considera un pecado mortal en PHP.

Haskell

Es demasiado transparente si siempre devuelve el mismo nombre, así que intente lo siguiente

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

Siempre que quieras que sea aleatorio:

[~]$ runghc prog.hs
Shuffling
Steve

[~]$ runghc prog.hs
Shuffling
Julie

Y para tu objetivo desafortunado:

[~]$ runhugs prog.hs
Shuffling
John

[~]$ runhugs prog.hs
Shuffling
John

Los abrazos solo implementan la multitarea cooperativa, por lo que el rotatehilo nunca se ejecutará

Bash: máxima simplicidad

Un ejemplo muy simple: evitemos cualquier problema haciéndolo en forma de libro de texto. ¡No olvide sembrar el generador del reloj del sistema para obtener un buen resultado!

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

Esto depende de que el usuario no sepa lo $SECONDSque hace realmente el incorporado; devuelve el número de segundos desde que se inició el shell actual. Como está en un guión, el caparazón siempre comenzó hace cero segundos, por lo que el generador siempre está sembrado 0y Julie siempre compra la cerveza.

Prima:

Este se enfrenta bastante bien al escrutinio; Si ingresa el mismo código en la línea de comandos en lugar de en un script, dará resultados aleatorios, ya $SECONDSque devolverá el período de tiempo que el shell interactivo del usuario ha estado ejecutándose.

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

Es posible que esto no engañe a las personas que están familiarizadas con la API .Net, pero las personas que no lo saben pueden creer que OrderBymodifica el objeto al que lo llama, y ​​es un error plausible que cometa un novato en la API.

Potencia Shell

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

Esto siempre saldrá John.

$nameses un System.Collections.Hashtableque no tiene una Lengthpropiedad. A partir de PowerShell v3, Length(y también Count) se puede usar como una propiedad en cualquier objeto. Si un objeto no tiene la propiedad, regresará 1cuando el objeto no sea nulo, de lo contrario, regresará 0. Entonces, en mi respuesta, se $names.Lengthevalúa como 1 y random -maximum 1siempre devuelve 0 ya que el máximo es exclusivo.

Q

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

Q siempre inicializa su semilla de número aleatorio con el mismo valor.

Perl

use strict;

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

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

Imprime: Person X is buying: Jeff(donde X es de 0-4)

Abusar un poco del contexto escalar. @index = int(rand() * 5)coloca un número entero aleatorio de 0 a 4 en la posición 0 de la @indexlista. Al imprimir la matriz, imprime correctamente el entero aleatorio en @index, pero cuando se usa como índice de matriz en$people[@index] @index usa el contexto escalar, lo que le da el valor del tamaño de la lista, es decir 1.

Suficientemente interesante, @people[@index] hace que se indexe correctamente.

Curiosamente, @people[@index]hay un hash slice en Perl, por lo que @indexse evalúa en el contexto de la lista; en este caso, es una lista de entrada única y por eso funciona correctamente

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 siempre recoge Julie.

Tiene corchetes dentro de los corchetes, y el operador de coma devuelve el valor de su operando correcto.
También es muy fácil perderse. Lo he extrañado antes en código real .

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

El truco es que el método new Random().NextDouble()devuelve un doble entre 0 y 1. Al aplicar Math.Floor()este valor, siempre será 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]);

Insinuación:

Generar semilla desde GUID. Los guías tienen una probabilidad de colisión de 4 × 10−10. Súper aleatorio.

Responder:

Al menos cuando lo usas Guid.NewGuid(), ¡vaya! (Manera disimulada para hacer semilla siempre 0). También no tiene sentido (int) para la mala dirección.

bash / coreutils

Esto se toma casi al pie de la letra de un guión que escribí con un propósito similar.

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

Incluso olvidar usar una R mayúscula es un error que ocasionalmente cometí en los guiones de la vida real.

Rubí

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

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

Esto funcionaría correctamente con sort_by, pero sortespera una función de comparación que funcione como <=>. El resultado de rand () siempre será positivo, por lo que siempre producirá resultados equivalentes siempre que el sortalgoritmo de su implementación de Ruby sea ​​determinista. Mi Ruby 1.9.3 siempre saca a Julie.

Rubí

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

puts names[rand() % 5]

rand() sin argumentos produce un flotante aleatorio entre 0 y 1. Por lo tanto, el módulo 5 no hace nada, y cuando se divide en una matriz con un argumento flotante, Ruby simplemente lo redondea hacia abajo, por lo que esto siempre devuelve a John.

Perl

¡tres srands lo harán tres veces más aleatorio!

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

explicación

no hay $ RANDOM en perl, es una variable indefinida. el código siempre devolverá el primer elemento de la lista: bebidas en John :)

editar:

Después de revisar el código, uno de los cinco chicos decidió arreglar el error obvio, produciendo el siguiente programa:

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

¿Puedes decir quién lo hizo simplemente mirando el código?

explicación:

en Perl, $#arraydevuelve el índice del último elemento; ya que se basan en cero arrays, da una referencia a una matriz con cinco elementos, $#$aref_peopleserá 4.
randdevuelve un número aleatorio mayor o igual a cero y menor que su parámetro, por lo que nunca volverá 4, lo que significa que Julie nunca comprará bebidas :)

Pitón

Todo el mundo sabe que no puedes confiar en la aleatoriedad en un espacio de muestra tan pequeño; para hacerlo verdaderamente aleatorio, he abandonado el método anticuado de elegir un nombre de una lista, y en su lugar, mi programa deletreará un nombre completamente aleatorio. Como la mayoría de los nombres en la oficina tenían 4 letras, nos conformaremos con eso.

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)

Naturalmente, hice un trabajo de preparación para asegurarme de elegir la semilla correcta.

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

Lo siento Jeff!

Después de algunas iteraciones r == 1 mod 5, debido a las matemáticas. Moralidad: no escribas tu propio PRNG si eres malo en matemáticas. :)

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

El tamaño del vector es en realidad 1 debido al paréntesis utilizado en la lista de inicializadores. El operador de coma descartará todos los nombres y devolverá el último, por lo tanto, el comprador siempre es Roy.

Scala

Sé que mis usuarios serán escépticos, ¡así que he incluido una prueba de que mi aleatoriedad es realmente justa!

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
  }

}

Un ejemplo de ejecución:

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

A menos que alguien tenga mucha suerte, John siempre comprará las bebidas.

La "prueba" de aleatoriedad se basa en el hecho de que rand(1, 4) * rand(1, 4) % 5todavía se distribuye uniformemente entre 1 y 4, inclusive. Pero rand(1, 5) * rand(1, 5) % 6es degenerado. Existe la posibilidad de obtener un 0, que luego haría que el resultado final sea 0 independientemente del resto de la "aleatoriedad".

Javascript (con Underscore.js )

Como javascript no tiene un shuffle integrado, utilizaremos Underscore.js

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

_.shuffle devuelve la matriz aleatoria , no se modifica en su lugar como Array.prototype.sort () , lo siento John

JavaScript

Segundo intento, este es un poco más complicado:

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

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

La argumentsvariable es accesible localmente para las funciones y es una matriz de todos los argumentos pasados ​​a la función. Al usar nombres simples y pasar una matriz a la función en sí, puede suponer que no estamos tomando la longitud de la matriz, sino de hecho la longitud de la lista de argumentos (que es 1). Esto se puede ejecutar aún mejor utilizando caracteres especiales o un tipo de fuente.

C ++

Para ser justos, debemos realizar muchos, muchos ensayos y elegir a quien se seleccione con mayor frecuencia.

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

¿Cuál es el valor de 1<<31? Lo siento John

T-SQL (2008+)

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

Explicación:

En MS SQL Server, RAND()solo se evalúa una vez por ejecución. A cada nombre siempre se le asigna el mismo número, dejando el pedido original. John es el primero. Es una mierda para John.

Mejora sugerida:

T-SQL puede producir números aleatorios por fila de buena calidad con 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()es para propósitos de tiempo, os.time()es lo que se debe usar math.randomseedpara un buen RNG. Lamentablemente, Julie siempre compra (al menos en mi computadora).

Idiomatic C ++ 11

Cuando se trata de bebidas, es especialmente importante estar al día con los últimos estándares y estilos de codificación; Este es un gran ejemplo de un selector de nombres C ++ 11 altamente eficiente y compatible con modismos.

Se siembra desde el reloj del sistema y genera la semilla junto con el nombre para la verificación cada vez.

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

Prueba esto en vivo: http://ideone.com/KOet5H

Ok, este es un código bastante bueno en general; hay muchas pistas falsas para hacer que mires demasiado de cerca el código para notar lo obvio: que el RNG nunca se siembra :) En este caso seedes solo un número entero, y aunque parece que enginese pasa como un parámetro a un función de siembra, en realidad solo se ignora. La variable semilla realmente se establece desde el reloj, por lo que puede aparecer al final junto con el nombre para agregar insulto a la lesión, pero siempre será Steve quien compre las bebidas.

JavaScript

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

Bueno, lo siento, Math.randomno toma un parámetro y siempre devolverá un número de [0, 1). ¡Aún así, es una función variada feliz y no se queja de argumentos!

Pitón

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 (aleatorio) da una cadena constante; no es un valor aleatorio

Perl

¡Es mejor que Emma no olvide su bolso! Corre debajo stricty 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.

Explicación aquí .

JavaScript

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

Los |0resultados en 0 todo el tiempo, pero parece que está haciendo algún otro redondeo.

J

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

Pobre Julie ... Trivia: esta podría haber sido la J más limpia que he escrito ...

Este código es realmente correcto, excepto por una cosa. ?.es el rng uniforme: ?.5siempre devolverá 4. ?5habría sido correcto.