DouKaku?

| bingo |
bingo := [:n | (1 to: n) asArray shuffled].
bingo value: 10   "=> #(6 9 3 4 2 1 10 5 8 7) "

using System;
using System.Text;
class Program
{
  static void Main()
  {
    Console.WriteLine(bingo(3));
  }
  static string bingo(int n)
  {
    Random r = new Random();
    int[] a = new int[n];
    for (int i = 0; i < n; ++i) a[i] = i + 1;
    for (int i = n; i > 1; --i)
    {
      int k = r.Next(i);
      int tmp = a[i - 1];
      a[i - 1] = a[k];
      a[k] = tmp;
    }
    StringBuilder sb = new StringBuilder("(");
    for (int i = 0; i < n; ++i)
    {
      if (i > 0) sb.Append(", ");
      sb.Append(a[i]);
    }
    sb.Append(")");
    return sb.ToString();
  }
}

def bingo(n):
	from random import shuffle
	result = range(1, n + 1)
	shuffle(result)
	return result

def bingo(n)
  (1..n).to_a.sort_by{rand}
end
bingo 10                        # => [4, 2, 1, 10, 8, 5, 3, 7, 6, 9]
bingo 3                         # => [3, 1, 2]
bingo 3                         # => [1, 3, 2]
bingo 3                         # => [2, 3, 1]
bingo 10                        # => [3, 2, 6, 5, 7, 4, 1, 8, 10, 9]

use List::Util qw/shuffle/;
sub bingo {shuffle(1..$_[0]);}

Number bingo := method(
    Range
    1 to(self) asList shuffle
}

10 bingo println

def bingo(num)
        raise ArgumentError.new("fixnum only") unless num.kind_of? Fixnum
        raise ArgumentError.new("1 ijyou de onegai simasu") unless num >= 1

        results = []

        ary=(1..num).to_a
        ary.size.times{
                index = (rand * ary.size).to_i
                results << ary.delete_at(index)
        }

        results
end

#include <stdio.h>
#include <stdlib.h>

static int cmp(const void *p1, const void *p2)
{
    return (rand() % 2)?1:-1;
}

void bingo(int num)
{
    int i;
    int *nums;

    if(num <= 0) return;
    nums = (int*)malloc(sizeof(int) * num);
    for(i=0; i<num; i++){
        nums[i] = i + 1;
    }
    qsort(nums, num, sizeof(int), (int (*)(const void*, const void*))cmp);
    for(i=0; i<num; i++){
        printf("%d\n", nums[i]);
    }
    free(nums);
}

int main(int argc, char *argv[])
{
    if(argc < 2){
        return EXIT_FAILURE;
    }
    srand(time(NULL));
    bingo(atoi(argv[1]));
    return EXIT_SUCCESS;
}

BEGIN {
	srand
}

{
	n = $1

	bingo(n,ar)
	show(n,ar)
}

function show(n,ar, i)
{
	printf "["
	for (i=1; i<n; i++) printf("%d, ", ar[i])
	printf("%d]\n", ar[n])
}

function rand_between_1_and_n(n, x)
{
	x = 1 + int(rand * n)
	return (x <= n)? x : rand_between_1_and_n(n)
}

function bingo(n,ar,  i,x,y,t)
{
	delete ar
	for (i=1; i<=n; i++) ar[i] = i

	for (i=n*2; i>0; i--) {
		x = rand_between_1_and_n(n)
		y = rand_between_1_and_n(n)
		if (x == y) continue

		t = ar[x] ; ar[x] = ar[y] ; ar[y] = t
	}
}

module RandList
import StdEnv, MersenneTwister

Start = bingo 10
bingo n  = map snd  (sort  (zip ((genRandInt n),[1..n])))

module Main (main) where

import System.Environment
import System.Random

shuffle :: [a] -> StdGen -> Int -> [a] -> [a]
shuffle acc _ 0 _  = acc
shuffle acc g n xs = case randomR (0,n-1) g of
 (i,g') -> case splitAt i xs of
             (ys,z:zs) -> shuffle (z:acc) g' (n-1) (ys++zs)

main :: IO ()
main = do { x:_ <- getArgs
          ; g0  <- getStdGen
          ; let n = read x
          ; putStrLn $ show $ shuffle [] g0 n [1..n]
          }

{-
% ./bingo 10
[4,10,3,2,9,5,7,8,6,1]
% ./bingo 10
[2,7,6,8,4,1,9,5,3,10]
% ./bingo 10
[1,7,3,10,6,4,8,2,5,9]
% ./bingo 10
[6,8,9,3,10,4,1,5,2,7]
-}

import scala.util.Sorting.stableSort
def bingo(n:int) = stableSort[int,double](1 to n,{x=>Math.random})

Array.prototype.$huffle = function(){
  for(var $, r, i = this.length; i;)
    $ = this[r = Math.random() * i-- | 0], this[r] = this[i], this[i] = $;
  return this;
}
function bingo(n){
  for(var a = []; n > 0;) a[a.length] = n--;
  return a.$huffle();
}

#include <stdio.h>
#include <stdlib.h>

void _bingo(int num, int *result, int num_max){
	int temp;
	int swap_point;

	result[num] = num + 1;
	swap_point = rand() % (num+1);
	temp = result[swap_point];
	result[swap_point] = result[num];
	result[num] = temp;

	if (num + 1 == num_max){
		return;
	}
	_bingo(num+1, result, num_max);
	return;
}

void bingo(int num, int** result)
{
	*result = (int*)malloc(num * sizeof(int));
	_bingo(0, *result,num);
}


int main(void)
{
	int *result;
	int num;
	int i;

	num = 100;
	bingo(num, &result);
	
	for(i = 0; i < num; i++){
		printf("%d,", result[i]);
	}
}

#light
let shuffle ls =
    let rnd = new System.Random() in
    List.sort (fun x y-> rnd.Next(-1,2)) ls;;

let bingo n = shuffle [1..n]

bingo[n_] := RandomSample[Range[n]];

Public Sub bingo(ByVal n As Integer)
    Dim list As New List(Of Integer)
    For i As Integer = 1 To n
        list.Add(i)
    Next
    Dim r As New Random
    For i As Integer = 1 To n
        Dim index As Integer = r.Next(0, n)
        list.Add(list(index))
        list.RemoveAt(index)
    Next

    For Each i As Integer In list
        Console.Write(i.ToString & ", ")
    Next
End Sub

#include <iostream>
#include <vector>
#include <algorithm>
#include <iterator>
#include <cstdlib>

#ifdef _WIN32
# include <windows.h>
# define seed() ::GetCurrentTime()
#else
# include <ctime>
# define seed() std::time(NULL)
#endif

struct RandomGenerator
{
    RandomGenerator()
    {
        std::srand(static_cast<unsigned>(seed()));
    }

    int operator()(int n) const
    {
        return std::rand() % n;
    }
};

void bingo(size_t n)
{
    std::vector<size_t> v;

    for (size_t i = 0; i < n; ++i)
    {
        v.push_back(i);
    }

    static RandomGenerator gen;

    std::random_shuffle(v.begin(), v.end(), gen);

    std::copy(v.begin(), v.end(), std::ostream_iterator<size_t>(std::cout, " "));

    std::cout << std::endl;
}

int main()
{
    bingo(10);
    bingo(3);
    bingo(3);
    bingo(3);
    bingo(10);
}

function r = bingo(n)
[m r] = sort(rand(1,n));

--- main.orig	Sat Aug 18 00:35:58 2007
+++ main.cpp	Sat Aug 18 00:41:24 2007
@@ -21,7 +21,9 @@ struct RandomGenerator
 
     int operator()(int n) const
     {
-        return std::rand() % n;
+        const int i = static_cast<int>(static_cast<double>(std::rand()) * n / RAND_MAX);
+
+        return std::max(0, std::min(i, n - 1));
     }
 };

(defun bingo (n)
  (loop repeat n
        for rand = (loop 
                     (let* ((*random-state* (make-random-state t))
                            (rand (1+ (random n))))
                       (if (not (member rand lst))
                         (return rand))))
        collect rand into lst
        finally (return lst)))

bingo <- sample

function r = bingo(n,k)
% r = bingo(n) retruns a random permutation of 1:n.
% r = bingo(n,k) returns a k-by-n array, each row of which is a random
% permutation of 1:n.
% (ja.doukaku.org Q46)
if nargin<2
    k = 1;
end
[m r] = sort(rand([k n]),2);

import java.util.*;

public class Sample {
    public static List<Integer> bingo(int num) {
        Integer[] deck = new Integer[num];
        for (int i = 0; i < num; i++) {
            deck[i] = i + 1;
        }
        List<Integer> nums = (List<Integer>) Arrays.asList(deck);
        Collections.shuffle(nums);
        return nums;
    }

    public static void main(String[] args) {
        System.out.println(bingo(Integer.parseInt(args[0])));
    }
}

sub bingo($;)
{
    my $x = shift ;
    my @num = (1 .. $x);
    my $r;
    for( my $n = $x; $n>0; $n --)
    {
        $r = rand; $r *= 1000;
        push(@num, splice(@num, $r % $n, 1) );
    }
    print "[$x] => " . join(",", @num) . "\n";
}
srand;

bingo(10);
bingo(3);
bingo(2);

function r = bingo(n,k)
% r = bingo(n) retruns a random permutation of 1:n.
% r = bingo(n,k) returns a k-by-n array, each row of which is a random
% permutation of 1:n.
% (ja.doukaku.org Q46)
if nargin<2
    k = 1;
end
[s r] = meshgrid(1:k,1:n);
% q = zeros(k,2);
for p = n:-1:2
    q(:,1) = ceil(rand(k,1)*p);
    q(:,2) = p;
    q = q+s(1:2,:)'*n-n;
    r(q) = r(q(:,[2 1]));
end
r = r';

import java.util.*
function bingo(n) {Collections.shuffle(x = list(range(1,n))); x}

println(bingo(10))

def bingo(n)
  [*1..n].shuffle
end

def bingo( n )
  ary = (1..n).to_a
  n.downto(1) {| i |
    e = ary.delete_at( rand( i ) )
    ary.push( e )
  }
  ary
end

import Random (randomRIO)
import Data.List ((\\))

bingo :: Int -> IO [Int]
bingo n = b [1..n] n []
  where b [] n     ret = return ret
        b xs (n+1) ret = do
          r <- randomRIO (0,n)
          let m = xs !! r in b (xs \\ [m]) n (ret ++ [m])

<?php
function bingo($n) {
	$rtn = range(1,$n);
	shuffle($rtn);
	return $rtn;
}

print_r(bingo(25));
?>

(defun bingo (n)
  (let ((r '#1=(nil . #1#)))
    (do ((i 1 (1+ i)))
        ((> i n))
      (push i (cdr r)))
    (let (buf)
      (do ((i n (1- i))
           (st (make-random-state t)))
          ((= i 0))
        (push (pop (cdr (nthcdr (random i st) r)))
              buf)
        ;; (write r :circle t) (terpri)
        )
      (write buf))))

--- doukaku46.pl.org    2007-08-23 00:40:42.921875000 +0900
+++ doukaku46.pl        2007-08-23 00:41:49.203125000 +0900
@@ -5,8 +5,7 @@
     my $r;
     for( my $n = $x; $n>0; $n --)
     {
-        $r = rand; $r *= 1000;
-        push(@num, splice(@num, $r % $n, 1) );
+        push(@num, splice(@num, rand() * $n, 1) );
     }
     print "[$x] => " . join(",", @num) . "\n";
 }

#!/usr/local/bin/perl -w
use strict;
package hoge;

my $piyo = (*1000);
print $piyo, "\n";

my $fuga = (*N);
print $fuga, "\n";

# 出力結果 ( Perlのバージョンは5.8.8 )
# Name "hoge::N" used only once: possible typo at ./test.pl line 9.
# *main::1000
# *hoge::N

def bingo(n)
  xs = *1..n
  n.times {|i| xs << xs.slice!(rand(n - i)) }
  xs
end

    # fisher_yates_shuffle( \@array ) : 
    # generate a random permutation of @array in place
    sub fisher_yates_shuffle {
        my $array = shift;
        my $i;
        for ($i = @$array; --$i; ) {
            my $j = int rand ($i+1);
            @$array[$i,$j] = @$array[$j,$i];
        }
    }
    fisher_yates_shuffle( \@array );    # @array そのものを入れ替える

(defun iota (n &optional a step)
  (setq step (or step 1))
  (do ((n n (- n 1))
       (ret '() (cons a ret))
       (a (or a 0) (+ a step)))
      ((<= n 0) (nreverse ret))))
(defun bingo (a &optional b)
  (let* ((ret (vconcat (mapcar '1+ (iota a b))))
	 (num (length ret))
	 val rnd)
    (dotimes (x  num ret)
      (setq rnd (random num)
	    val (aref ret x))
      (aset ret x (aref ret rnd))
      (aset ret rnd val))))

x = bingo(25,1000,1);
rho = corr((1:size(x,2))',x(1:size(x,1),:)','type','Kendall');
figure(1); hist(rho,-1:0.1:1); axis([-1 1 0 300])
fprintf('Mean = %f, skewness = %f\n', mean(rho), skewness(rho));

function r = bingo(n,k,p)
% r = bingo(n,k) returns a k-by-n array, each row of which is a random
% permutation of 1:n, using random numbers with p significant digits .
[m r] = sort(randr([k n],p),2);

function r = randr(M,p)
r = floor(rand(M).*10^p)./10^p;

function bingo([int] $n)
{
     $r = new-object system.random
     $a = 0..($n-1)
     0..($n-1) | %{ $i = $r.next($n-1); $a[$_],$a[$i] = $a[$i],$a[$_] }
     $a
}

(use srfi-1)
(use srfi-27)

(define (bingo n)
  (define (%bingo lst)
    (if (null? lst)
        '()
        (receive (head tail) (split-at lst (random-integer (length lst)))
          (cons (car tail) (%bingo (append head (cdr tail)))))))
  (%bingo (iota n 1)))

shuffle([],[]).
shuffle(X,[R|Y]) :- length(X, XL), N is random(XL),
	nth0(N, X, R), select(R, X, X1), shuffle(X1, Y).

bingo(N) :- findall(X, between(1, N, X), L), shuffle(L, S), write(S).

implement Bingo;

include "sys.m";
	sys: Sys;
include "draw.m";
include "keyring.m";
include "security.m";
	random: Random;

argv0: string;

Bingo: module
{
	init: fn(nil: ref Draw->Context, argv: list of string);
};

usage()
{
	sys->fprint(sys->fildes(2), "usage: %s n\n", argv0);
	raise "fail:usage";
}

init(nil: ref Draw->Context, argv: list of string)
{
	sys = load Sys Sys->PATH;
	random = load Random Random->PATH;
	argv0 = hd argv;
	argv = tl argv;

	n := 10;
	if(argv != nil)
		n = int hd argv;

	a := array[n] of int;
	for(i := 0; i < n; i++)
		a[i] = i+1;

	while(n > 0){
		p := rand() % n;
		sys->print("%d\n", a[p]);
		a[p] = a[--n];
	}
}

rand(): int
{
	r := random->randomint(Random->ReallyRandom);
	if(r < 0)
		r = -r;
	return r;
}

sub bingo()
{
    my @array = ( 1 .. shift );
    my @out   = ();
    while ( my $x = splice( @array, int(rand(scalar @array)) , 1 ) )
    {
        push @out , $x ;
    }
    return [ @out ];
}

print join "," , @{ &bingo(10) };

foo <- function(n) (1:n)[order(runif(n))]

BEGIN {
    srand()
    for (i = 1; i <= n; i++) x[i] = i
    for (i = 1; i <= n; i++) {
        j = int(rand()*n)+1
        t = x[i]
        x[i] = x[j]
        x[j] = t
    }
    for (i = 1; i <= n; i++) printf " %i", x[i]
    print ""
}

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

void bingo( int n ){
   int tmp;
   int i,j;
   int *deck = (int*)malloc(sizeof(int)*n);
   for( i = 0; i < n; i++ )
      deck[i] = i+1;

   for( i = 0; i < n; i++ ){
      j = rand() % (n-i);
      tmp = deck[j];
      deck[j] = deck[ n-i-1 ];
      deck[ n-i-1 ] = tmp;
   }
   for( i = 0; i < n; i++)
      printf("%d ", deck[i] );
   free(deck);
}

int main ( void ){
   srand(time(NULL));
   bingo(10);
   printf("\n");
   bingo(15);
   printf("\n");
   return 0;
}

static string bingo(int num)
{
        //ランダムな配列を作成
        System.Collections.ArrayList al= new System.Collections.ArrayList(num);
        Random r= new Random();
        for(int i=1; i<= num; i++)
                al.Insert(r.Next(i), i);

        //文字列で出力
        System.Text.StringBuilder sb= new System.Text.StringBuilder();
        for(int i=0; i< al.Count; i++)
                sb.Append(al[i].ToString()+",");
        return sb.ToString().Trim(',');
}

bingo(10)を" "で配列結合して表示
●bingo(n)
　　rとは配列
　　(n)回
　　　　rに回数を配列追加
　　rを配列シャッフル
　　rで戻る

#import <Foundation/Foundation.h>

@interface NSArray (Bingo)
+ (NSArray*)bingo:(int)n;
@end

@implementation NSArray (Bingo)

+ (NSArray*)bingo:(int)n
{
  NSMutableArray* array = [NSMutableArray array];
  int i;
  for (i=1; i<=n; i++) [array addObject:[NSNumber numberWithInteger:i]];

  NSMutableArray* result = [NSMutableArray array];
  for (i=1; i<=n; i++) {
    int size = n - i + 1;
    int index = rand() % size;
    [result addObject:[array objectAtIndex:index]];
    [array removeObjectAtIndex:index];
  }
  return result;
}

@end

int main(int argc, char** argv)
{
  NSAutoreleasePool* pool = [NSAutoreleasePool new];

  srand(time(0));
  NSLog(@"%@", [NSArray bingo:3]);
  NSLog(@"%@", [NSArray bingo:10]);
  
  [pool release];
  return 0;
}

#module
#deffunc bingo int n
    dim dest, n
    repeat n
        dest.cnt = cnt+1
    loop
    repeat n
        r = rnd( n - cnt ) + cnt
        tmp = dest.r
        dest.r = dest.cnt
        dest.cnt = tmp
    loop
    buf = ""
    repeat n
        if ( cnt > 0 ) {
            buf += " "
        }
        buf += str( dest.cnt )
    loop
    mes buf
    return
#global
randomize
bingo 10
bingo 3
bingo 3
bingo 10

    call srand tickcount;
    call bingo 10;
    call bingo 3;
    call bingo 3;
    call bingo 10;
    endmacro;

bingo:
    ##i = 0;
    while( ##i < ##1 ) {
        ##dest[##i] = ##i + 1;
        ##i = ##i + 1;
    }
    ##i = 0;
    while( ##i < ##1 ) {
        call rand;
        ##r = ##return % ( ##1 - ##i ) + ##i;
        ##tmp = ##dest[##r];
        ##dest[##r] = ##dest[##i];
        ##dest[##i] = ##tmp;
        ##i = ##i + 1;
    }
    ##i = 0;
    while( ##i < ##1 ) {
        if ( ##i > 0 ) {
            insert " ";
        }
        insert str( ##dest[##i] );
        ##i = ##i + 1;
    }
    insert "\n";
    return;

rand:
    #rand_x = #rand_x * 214013 + 2531011;
    if ( #rand_x < 0 ) {
        return ( ( #rand_x + 1 ) / 65536 - 1 ) & 32767;
    }
    return #rand_x / 65536 & 32767;

srand:
    #rand_x = ##1;
    return;

def bingo(n)
  pool, ret = (1..n).to_a, []
  ret << (pool.delete_at(rand(pool.size))) until pool.empty?
  ret
end

import std.random;

int[] bingo(int x)
{
        int[] xs;
        for (int i = 1; i <= x; ++i) {
                xs ~= i;
        }
        for (int i = 0; i < x; ++i) {
                uint r = rand() % x;
                int tmp = xs[r];
                xs[r] = xs[i];
                xs[i] = tmp;
        }
        return xs;
}

/*
import std.stdio;
import std.string;

void main(char[][] args)
{
        for (int i = 1; i <= 10; ++i) {
                int[] xs = bingo(i);
                string s = "[";
                foreach (j; xs) {
                        s ~= toString(j) ~ ",";
                }
                s = s[0 .. $ - 1] ~ "]";
                writef("%s\n", s);
        }
}
*/

-module(bingo).
-export([bingo/1]).

bingo(Num) -> bingo_sub(lists:seq(1, Num), Num).

bingo_sub(List, 0) -> List;
bingo_sub(List, Num) ->
    R = lists:nth(random:uniform(length(List)), List),
    L = [R | [X || X <- List, X =/= R]],
    bingo_sub(L, Num - 1).

bingo=.3 :'>:y?y'

module Array = struct
  include Array
  let bury arr n len =
    Array.blit arr (n+1) arr n (len-(n+1))
    
  let shuffle arr =
    let len = Array.length arr in
    for i = len downto 1 do
      let v = Random.int i in
      let value = arr.(v) in
      bury arr v i;
      Array.set arr (i-1) value;
    done
end;;

let bingo n =
  let res = Array.init n (fun i -> i+1) in
  Array.shuffle res;
  res;;

def bingo(n)
  ary = Array.new(n){|i| i+1}
  Array.new(n){|i| ary.delete_at(rand(n-i).modulo(n-i))}
end

import std.stdio;
import std.random;

void bingo(uint n){
    uint[] a;
    a.length = n;
    foreach(i, ref e; a){
        e = i + 1;
    }
    randomShuffle(a, Random(unpredictableSeed()));
    writefln(a);
}

void main(){
    bingo(10);
}

(def bingo (n)
  (let lst (iota n 1)
    (for i 0 (- n 1)
      (swap (lst i) (lst (rand n))))
    lst))

(def iota (n (o start 0) (o step 1))
  (let res ()
    (repeat n
      (push start res)
      (++ start step))
    (rev res)))

:: bingo.bat
@echo off
  setlocal enabledelayedexpansion
    set i=0
    set j=0
    set t=
    set v=0

    echo %1|findstr /r "[^0-9]" >NUL 2>&1
    if %ERRORLEVEL% equ 0 (echo %0 [NUMBER] & goto :EOF)

    :: 擬似配列を生成
    for /l %%i in (1,1,%1) do set v_%%i=%%i

    :: 値をシャッフル
    set i=1
    :loop
      set /a j=%RANDOM:~-1%%%%1+1
      set v=!v_%i%!
      set v_%i%=!v_%j%!
      set v_%j%=%v%
      set /a i+=1
    if %i% lss %1 goto loop

    for /l %%i in (1,1,%1) do (
      set t=!t!!v_%%i!
      if %%i lss %1 set t=!t!, 
    )
  endlocal & echo [ %t% ]
goto :EOF

(defun bingo(max)
  (let ((vec (make-array 0 :fill-pointer t)))
    (loop for i from 1 to max do
     (vector-push-extend i vec))
    (loop for i from max downto 1 collect
     (if (equal i 1)
         (vector-pop vec)
         (let ((loc (random i)))
           (rotatef (aref vec (1- i))
            (aref vec loc))
           (vector-pop vec))))))

(defun bingo-v2(max)
  (let ((vec (make-array max)))
    (loop for i from 1 to max do
     (setf (svref vec (1- i)) i))
    (loop for i from max downto 1 collect
     (if (equal i 1)
         (svref vec (1- i))
         (let ((loc (random i))
           (ii (1- i)))
           (rotatef (svref vec ii) (svref vec loc))
           (svref vec ii))))))

(defun bingo-v3(max)
  (declare (optimize (speed 3) (debug 0) (safety 0)))
  (declare (fixnum max))
  (let ((vec (make-array max)))
    (declare (simple-vector vec))
    (loop for i from 1 to max do
     (setf (svref vec (1- i)) i))
    (loop for i from max downto 1 collect
     (if (equal i 1)
         (svref vec (1- i))
         (let ((loc (random i)) (ii (1- i)))
           (rotatef (svref vec ii) (svref vec loc))
           (svref vec ii))))))

def bingo(n) {
    def list = (1..n).toList()
    Collections.shuffle(list)
    println list
}

bingo(10)
bingo(3)  
bingo(3)
bingo(10)

function bingo() {
    local n=$1
    local -a array
    local -i i j tmp

    for ((i = 0; i < n; i++)) {
        array[i]=$((i+1))
    }

    for ((i = 0; i < n; i++)) {
        ((j = RANDOM % (i + 1),
          tmp = array[i], array[i] = array[j], array[j] = tmp))
    }

    echo ${array[@]}
}

int[] bingo(int n)
{
    Random r = new Random();
    return Enumerable.Range(1, n).OrderBy(a => r.Next()).ToArray();
}

import Random
import List

randomN :: Int->StdGen ->  (StdGen,[Int])
randomN n stdGen = mapAccumL (\r lim->swapTuple (randomR (0,lim) r)) stdGen [n-1,n-2..0]
  where swapTuple (a,b) = (b,a)

bingo ::Int->StdGen->[Int]
bingo n stdGen = snd $ mapAccumL f [1..n] $ snd (randomN n stdGen)
  where f xs x = (deleteAt x xs,xs !! x)
        deleteAt i xs = take i xs ++ tail (drop i xs)

#!/bin/sh
bingo() {
    seq $1 | shuf
}

def bingo(n) {
   (1..n).toList().sort{ Math.random() }
}
println bingo(10)
println bingo(3)
println bingo(3)
println bingo(10)