#!C:/Perl/bin/perl.exe 
# 
# v0.96 makemeritch.pl by pax77 
# 
# Erzeugt zufällige Lotto-Zahlen 
# 12 Felder mit jeweils maximal $n Überschneidungen 
# 

use strict; 

my $n = 2; # Anzahl der erlaubten Überschneidungen (2 ist Minimalwert) 
my $DEBUG = 1; # Debug-Level 0, 1 
my $try = 0; 
my @sum; 
NOTE: while (@sum < 12) { # 12 Zahlenreihen werden erzeugt 
        my @lotto; 
        # push(@lotto, 7, 13); # Wenn es Lieblingszahlen gibt (Sollten nicht mehr als $n-2 sein ...) 
        LOTTO: while (@lotto < 6) { # Mit jeweils 6 Zahlen 
                my $zahl = &GetNum(); # Zufallszahl zwischen 1 und 49 
                foreach (@lotto) { 
                                next LOTTO if $_ == $zahl; # Jede Zahl nur ein mal 
                } 
                push(@lotto, $zahl); 
        } 
        # Wenn zu viele Zahlen doppelt mit einer alten Zahlenreihe -> redo 
        $try++, redo NOTE if &CheckDouble(\@lotto); 
        push(@sum, \@lotto); 
        print "($try)\t" if $DEBUG; 
        foreach (sort {$a <=> $b} @lotto) { # Sortierte und formatierte Ausgabe 
                print " " if $_ < 10; 
                print $_." "; 
        } 
        print "\n"; 
} 

sub CheckDouble { 
        my ($check) = @_; 
        my $suc; 
        MAIN: foreach (@sum) { # Jede bereits erzeugte Zahlenreihe 
                my $g = 0; 
                foreach (@$_) { # Jede Zahl der jeweiligen Zahlenreihe 
                        my $temp = $_; 
                        foreach (@$check) { # Vergleiche mit den neuen Zahlen 
                                $g++ if $_ == $temp; 
                                $suc = 1, last MAIN if $g == $n; # Wenn zu viele gleich -> return TRUE 
                        } 
                } 
        } 
        return $suc; 
} 

sub GetNum { 
        return int(rand 49) + 1; 
}

#!C:/Perl/bin/perl.exe
#
# v0.96 makemeritch.pl by pax77
#
# Erzeugt zufällige Lotto-Zahlen
# 12 Felder mit jeweils maximal $n Überschneidungen
#

use strict;
use warnings;

my $n = 2; # Anzahl der erlaubten Überschneidungen (2 ist Minimalwert)
my $DEBUG = 1; # Debug-Level 0, 1
my $try = 0;
my @sum;

NOTE: while (@sum < 12) { # 12 Zahlenreihen werden erzeugt
    my @lotto;
    # push(@lotto, 7, 13); # Wenn es Lieblingszahlen gibt (Sollten nicht mehr als $n-2 sein ...)
    LOTTO: while (@lotto < 6) { # Mit jeweils 6 Zahlen
        my $zahl = &GetNum(); # Zufallszahl zwischen 1 und 49
        foreach (@lotto) {
            next LOTTO if $_ == $zahl; # Jede Zahl nur ein mal
        }
        push(@lotto, $zahl);
    }
    # Wenn zu viele Zahlen doppelt mit einer alten Zahlenreihe -> redo

    $try++, redo NOTE if &CheckDouble(\@lotto);
    push(@sum, \@lotto);
    print "($try)\t" if $DEBUG;
    printf "%2d ", $_ for sort {$a <=> $b} @lotto; # Sortierte und formatierte Ausgabe
    print "\n";
}

sub CheckDouble {
    my ($check) = @_;
    my $suc;
    MAIN: foreach (@sum) { # Jede bereits erzeugte Zahlenreihe
        my $g = 0;
        foreach (@$_) { # Jede Zahl der jeweiligen Zahlenreihe
            my $temp = $_;
            foreach (@$check) { # Vergleiche mit den neuen Zahlen
                $g++ if $_ == $temp;
                $suc = 1, last MAIN if $g == $n; # Wenn zu viele gleich -> return TRUE
            }
        }
    }
    return $suc;
}

sub RandNum { int(rand 49) + 1 }

#!/usr/bin/perl

use strict;
use warnings;

#use Data::Dumper;
use List::Util qw/shuffle/;

my $cnt = shift @ARGV || 12;    # wir wollen 12 Ziehungen
my @fav = (7, 13);              # und die Zahlen 7 und 13 müssen drin sein

print join( ', ',               # fasse das zusammen zur Ausgabe
    sort { $a <=> $b } (        # numerisch sortiert 
        pick_numbers(6 - @fav, @fav)    # gezogene Nummern
    ) ) . "\n" for 1..$cnt;     # für $cnt Ziehungen

sub pick_numbers {              
    my $n           = shift || 6;       # ziehe $n Zahlen oder 6
    my @numbers     = shuffle (1..49);  # erstelle eine gemischte Liste der Zahlen 1..49
    return @_, @numbers[0..--$n];       # und gib diese zusammen mit evtl. Favoriten zurück
}

sub pick_numbers {
    my $n       = shift || 6;
    my @numbers = grep{ my $i = $_; not grep{ $i == $_ } @_ } 1..49;
    return @_, map{ splice @numbers, rand(@numbers), 1 } 1..$n;
}

use List::Util qw/sum min/;
use List::MoreUtils qw/pairwise/;

sub distance {
    my ($i, $j) = @_;
    no warnings;
    my $distance = sum pairwise { $a != $b } @$i, @$j;
    return $distance;
}

sub distance_to_any {
    my ($i, $l) = @_;
    return min ( map distance( $i, $_ ), @$l  );
}

print distance ([1, 2, 3, 4], [1, 8, 5, 7]) . "\n";
print distance_to_any ( [1, 2, 3, 4], [ [1, 8, 5, 7], [1, 2, 3, 9] ] )

#!/usr/bin/perl

use strict;
use warnings;

my @faf=(1,22);

my @z=(1..49);
for my $pos (sort{$b<=>$a}@faf)
{ splice(@z,($pos-1),1); }

for my $cnt (1..12)
{
 my @lotto=@z;
 splice(@lotto,int(rand($#lotto)+0.5),1) while(@lotto > (6-@faf) );
 @lotto=sort{$a<=>$b}(@faf,@lotto);
 printf("Ziehung: %2d -> %s\n", $cnt, join(',',@lotto));
}

my @num = 0..9;
my %res;

for ( 1 .. 1_000_000 ) {
    $res{ $num[ rand @num ] }++;
}
print "Test 1:\n";
print "$_ => $res{$_}\n" for @num;

print "\n";
%res = ();

for ( 1 .. 1_000_000 ) {
    $res{ int( rand($#num) + 0.5 ) }++;
}
print "Test 2:\n";
print "$_ => $res{$_}\n" for @num;

Test 1:
0 => 99890
1 => 99720
2 => 100091
3 => 99762
4 => 100083
5 => 99604
6 => 99967
7 => 100189
8 => 99925
9 => 100769

Test 2:
0 => 55212
1 => 110670
2 => 111032
3 => 111548
4 => 110812
5 => 111082
6 => 111016
7 => 111557
8 => 111592
9 => 55479