1 2 3 4 5
my @a = ("a", "b", "c", "d"); splice(@a, 2, 0, "nanu"); foreach (@a) { print "$_\n"; }
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32
#!/usr/bin/perl use strict; use warnings; use Data::Dumper; # Basis-Liste my $o = tie my @base, 'Merge'; @base = ('a'..'z'); push @base, 'eins'; # beim ersten push, landet der Wert in den Mitte print Dumper \@base; package Merge; use strict; use warnings; use Tie::Array; use base qw(Tie::StdArray); use integer; sub PUSH{ my $self = shift; my $val = shift; my $i = scalar @$self; my $offset = $i/2; splice @$self, $offset, 0, $val; } 1;#########################################################################
2012-02-15T10:01:33 biancaHabe ein Array mit 500 Werten.
Nun sollen weitere 200 Werte jeweils mittig eingefügt werden.
Also Wert 1 genau mittig, also hinter das 250. Element.
Wert 2 in die vordere Mitte, also hinter das 125. Element.
Wert 3 in die hintere Mitte, also hinter das 375. Element.
Dann wieder weiter in die Mitte zwischen 1 und 125, also hinter das 62. Element. Danach die zweite Mitte zwischen 125 und 250, also hinter das 187. Element und so weiter und so weiter, bis die 200 völlig verteilt sind.
Sollte keine Mitte mehr vorhanden sein wieder von vorne in der Mitte der dann neuen Gesamtmenge.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18
#!/usr/bin/perl use warnings; use strict; use vars qw($a $b $c $d $x); $a = 500; $x = 0; while ($x < 10) { $b = $a; $a = $a / 2; $c = ($b - $a) / 2; $d = ($b + $a) / 2; print "$c\n$d\n"; $x ++; }
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
125
375
62.5
187.5
31.25
93.75
15.625
46.875
7.8125
23.4375
3.90625
11.71875
1.953125
5.859375
0.9765625
2.9296875
0.48828125
1.46484375
0.244140625
0.732421875
0.1220703125
0.3662109375
0.06103515625
0.18310546875
0.030517578125
if ($c < 1 || $d < 1) {...}
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19
#!/usr/bin/perl use warnings; use strict; use vars qw($a $b $c $d $x); $a = 500; $x = 0; while ($x < 30) { $b = $a; $a = $a / 2; $c = ($b - $a) / 2; $d = ($b + $a) / 2; print "$c\n$d\n"; $a += 2; $x ++; }
2012-02-15T22:05:54 hlubenowAber was genau meinst Du, mit "von vorne anfangen"?
2012-02-16T13:38:26 bianca2012-02-15T22:05:54 hlubenowAber was genau meinst Du, mit "von vorne anfangen"?
...
Mit von vorne anfangen meine ich den Fall, dass die einzufügenden Elemente mehr sind als die vorhandenen.
Wenn also in eine 10er Reihe 20 Elemente rein sollen läßt sich die 10er Reihe im ersten Durchlauf ja maximal 9 mal halbieren. Das heißt, nach dem ersten Durchlauf wurden 9 Elemente eingefügt, die Ausgangsmenge beträgt 19 und es sind noch 11 nicht eingefügt.
Und jetzt soll der selbe Algorithums also die 11 Elemente in die bestehende 19er Menge jeweils wieder schön hälftig vorne/hinten/vorne/hinten einfügen.
And so on bis alle einzufügenden Elemente weg sind und am Ende die Menge 30 beträgt.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
#!/usr/bin/perl use warnings; use strict; use vars qw($b $c $d $e $i $x); sub insert { my $valuetoinsert = pop; my $position = pop; my @thelist = @_; splice(@thelist, $position, 0, $valuetoinsert); return @thelist; } my $nrlist = 500; my $nrin = 200; my @l = (1 .. $nrlist); my @in = (1 ..$nrin); $x = 0; $b = $nrlist; @l = insert(@l, int($b / 2), $in[$x]); while ($x < $nrin) { $c = $b / 2; $d = int(($b - $c) / 2); $e = int(($b + $c) / 2); if ($d == 0 || $e == 0) { $b = $#l + 1; next; } @l = insert(@l, $d, $in[$x]); $x ++; @l = insert(@l, $e, $in[$x]); $x ++; $b = $c; } for($i = 0; $i <= $#l; $i++) { print "$i\t$l[$i]\n"; }
2012-02-19T14:33:50 biancaIch löse es jetzt doch anders.
Bei ungeraden Mengen bekommt man es ja doch nie "gleichmäßig" aufgeteilt.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
Vorbereitung: Ausgangsarray nach @in kopieren.
Loop über @in
Erstes Array von @in holen
next wenn Länge 0
Array halbieren
Nächsten Wert an 1. Hälfte anhängen
Beide Hälften an @out anhängen
Wenn kein Wert mehr da
Rest von @in an @out anhängen
Alle Arrays in @out aneinander hängen
Fertig
Nach Loop-Ende:
Wenn nichts eingefügt
Alle Arrays in @out aneinander hängen
@in und @out vertauschen
Das Ganze von vorn
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Vorbereitung: Ausgangsarray nach @in kopieren.
Fehler wenn Länge <= 1
Loop über alle Arrays in @in
last wenn Länge 1
Nächsten Wert in der Mitte einfügen
Wenn kein weiterer Wert da
Alle Arrays in @in aneinander hängen
Fertig
Nach Loop-Ende:
Wenn Ende wegen Länge 1
Alle Arrays in @in aneinander hängen
sonst
Alle Arrays in @in halbieren, Hälften in @out sammeln
@in durch @out ersetzen
Das Ganze von vorn