Как я могу сгенерировать массив в Perl со 100 случайными значениями без использования цикла?
Мне нужно избегать всех типов циклов, например "for", foreach ", в то время как это мое упражнение из моей лаборатории. Я не могу найти способ решить эту проблему, потому что я новичок в Perl.
В C, создание этого массива будет очень простым, но я не знаю, как это сделать в Perl.
my @rand = map { rand } ( 1..100 );
Но карта - это всего лишь цикл с причудливым оформлением окон.
Если вам нужно сделать что-то 100 раз, вам понадобится использовать какую-то итеративную структуру.
Значение развлечения:
#!/usr/bin/perl
use strict;
use warnings;
$/ = \1;
open 0;
my @r = map rand,<0>;
print "@r\n";
for, while, until:#!/usr/bin/perl
use strict; use warnings;
my @rand;
NOTLOOP:
push @rand, rand;
sleep 1;
goto NOTLOOP if 100 > time - $^T;
print 0 + @rand, "\n";
#!/usr/bin/perl
use strict; use warnings;
my $s = '-' x 100;
$s =~ s/(-)/rand() . $1/eg;
my @rand = $s=~ m/([^-]+)/g;
rand вызовов вручную - это pass & eacute;:#!/usr/bin/perl
use strict; use warnings;
my $s = '(' . 'rand,' x 100 . ')';
my @rand = eval $s;
/dev/random:#!/usr/bin/perl
use strict; use warnings;
$/ = \1;
my @rand;
seek \*DATA, 0, 0;
NOTLOOP:
scalar <DATA>;
push @rand, rand;
goto NOTLOOP if $. < 100;
__DATA__
goto#!/usr/bin/perl
use strict; use warnings;
use autodie;
$/ = \1;
open my $F, '<', \( 1 x 100 . 0 );
my @rand or ¬loop;
sub notloop {
my $t = <$F>;
$t or return;
push @rand, rand;
goto \¬loop;
}
eval version:#!/usr/bin/perl
use strict; use warnings; use autodie;
local $/ = \1;
open my $F, '<', \( 1 x 100 . 0 );
my @rand;
eval <<'NOLOOP'
my $self = (caller(0))[6];
<$F> or die;
push @rand, rand;
eval $self;
NOLOOP
;
Конечно, все они действительно содержат циклы, но они не используют ключевые слова, которые вы запретили использовать.
NB: Этот вопрос вызвал у меня wacko, но я должен признать, что это забавно.
Ничто не может быть проще!
my @rands = (rand, rand, rand, rand, rand, rand, rand, rand, rand, rand,
rand, rand, rand, rand, rand, rand, rand, rand, rand, rand, rand,
rand, rand, rand, rand, rand, rand, rand, rand, rand, rand, rand,
rand, rand, rand, rand, rand, rand, rand, rand, rand, rand, rand,
rand, rand, rand, rand, rand, rand, rand, rand, rand, rand, rand,
rand, rand, rand, rand, rand, rand, rand, rand, rand, rand, rand,
rand, rand, rand, rand, rand, rand, rand, rand, rand, rand, rand,
rand, rand, rand, rand, rand, rand, rand, rand, rand, rand, rand,
rand, rand, rand, rand, rand, rand, rand, rand, rand, rand, rand,
rand, rand);
perl -E'say for&{sub{"\U\x{fb01}\x{fb03}"=~/.{0,2}.{0,3}.{0,3}.{0,4}+(?{$_[++$#_]=rand})(*FAIL)/||pop;@_}}'
/e Regex SolutionЭто:
($_=(120.44.32)x(2+2*2**2)**2)=~s/\170/114.97.110.100/gee;
s/(.*)/64.95.61.40.$1.41.35.89.65.78.69.84.85.84/ee;
print "@_\n";
looplessly производит это:
0.636939813223766 0.349175195300148 0.692949079946754 0.230945990743699 0.61873698433654 0.940179094890468 0.435165707624346 0.721205126535175 0.0322560847184015 0.91310500801842 0.31596325316222 0.788125484008084 0.802964232426337 0.417745170032291 0.155032810595454 0.146835982654117 0.181850358582611 0.932543988687968 0.143043972615896 0.415793094159206 0.576503681784647 0.996621492832261 0.382576007897708 0.090130958455255 0.39637315568709 0.928066985272665 0.190092542303415 0.518855656633185 0.797714758118492 0.130660731025571 0.534763929837762 0.136503767441518 0.346381958112605 0.391661401050982 0.498108766062398 0.478789295276393 0.882380841033143 0.852353540653993 0.90519922056134 0.197466335156797 0.820753004050889 0.732284103461893 0.738124358455405 0.250301496672911 0.88874926709342 0.0647566487704268 0.733226696403218 0.186469206795884 0.837423290530243 0.578047704593843 0.776140208497122 0.375268613243982 0.0128391627800006 0.872438613450569 0.636808174464274 0.676851978312946 0.192308731231467 0.401619465269903 0.977516959116411 0.358315250197542 0.726835710856381 0.688046044314845 0.870742340556202 0.58832098735666 0.552752229159754 0.170767637182252 0.683588677743852 0.0603160539059857 0.892022266162105 0.10206962926371 0.728253338154527 0.800910562860132 0.628613236438159 0.742591620029089 0.602839705915397 0.00926448179027517 0.182584549347883 0.53561587562946 0.416667072500555 0.479173194613729 0.78711818598828 0.017823873107119 0.824805088282755 0.302367196288522 0.0677539595682397 0.509467036447674 0.906839536492864 0.804383046648944 0.716848992363769 0.450693083312729 0.786925293921154 0.078886787987166 0.417139859647296 0.9574382550514 0.581196777508975 0.75882630076142 0.391754631502298 0.370189654004974 0.80290625532508 0.38016959549288
Как и в самом деле, делает это, если вы печатаете массив:
@_=(*100=sub{$_[0]?(rand,(*{--$_[0]}=*{$_[0]})->(@_)):()})->($==100);
Второе решение теперь позволяет получить различное количество случайных чисел достаточно легко, так как после выполнения вышеперечисленного вы можете сделать такие тонкости, как:
print for @42=42->($==42);
И да, это действительно функция с именем 42(). Предыдущее назначение @_ создало его вместе со 100 другими численно названными функциями.
Первое решение с регулярным выражением основывается на сложном корпусе Unicodes двух совпадающих символов. Он может (или не может) быть более понятным с помощью пробелов и добавленных комментариев:
use 5.010;
say for &{
sub { "\U\x{fb01}\x{fb03}" =~ m((?mix-poop)
#include <stdlib.h>
#include <unistd.h>
#include <regex.h>
#include "perl.h"
#include "utf8.h"
#ifndef BROKEN_UNICODE_CHARCLASS_MAPPINGS
.{0,2}
.{0,3} .{0,3}
.{0,4}
#define rand() (random()<<UTF_ACCUMULATION_SHIFT^random()&UTF_CONTINUATION_MASK)
+(?{ $_ [++$#_] = rand() || rand() || UTF8_TWO_BYTE_LO (*PERL_UNICODE)
#else (*PRUNE)
#define FAIL (*ACCEPT)
}) (*FAIL)
#endif (*COMMIT)
)poop || pop @{ (*_{ARRAY}) }
;#; @{ (*SKIP:REGEX) }
@{ (*_{ARRAY}) }
}
}
Способ понять, как работает второе решение регулярного выражения:
\170 - это "x".e до одного e в каждой подстановке, затем распечатайте то, что осталось в строке оба раза.Я уверен, что вы оцените комментарий.:)
Для рекурсивного решения добавление пробела может немного помочь:
(*100 = sub { $_[0]
? ( rand, ( *{ --$_[0] } = *{ $_[0] } )->(@_) )
: ( )
}
)->( $= = 100 );
Необходимость передать переменную в качестве аргумента обусловлена автоматическим декрементом, требующим lvalue. Я сделал это, потому что мне не нужно было дважды говорить $_[0] - 1 или иметь какие-либо именованные временные переменные. Это означает, что вы можете сделать это:
$N = 100;
print for $N->($N);
И когда вы сделали, $N == 0, из-за семантики pass-by-implicit-reference.
За счет небольшого количества повторений вы можете уменьшить потребность в аргументе lvalue.
(*100 = sub { $_[0]
? ( rand, ( *{ $_[0] - 1 } = *{ $_[0] } )->( $_[0] - 1 ) )
: ( )
}
)->( 100 );
Теперь вам больше не нужен аргумент lvalue, поэтому вы можете написать:
print for 100->(100);
чтобы получить все 100 случайных чисел. Конечно, у вас также есть еще сто число числовых функций, поэтому вы можете получать списки случайных чисел любым из следующих способов:
@vi = 6->(6);
@vi = &6( 6);
$dozen = 12;
@dozen = $dozen->($dozen);
@baker's_dozen = &$dozen(++$dozen);
@_ = 100;
print &0; # still a hundred of 'em
(Извините за глупые цвета. Должна быть ошибка SO.)
Я верю, что все очищает. ☺
# I rolled a die, honestly!
my @random = (5, 2, 1, 3, 4, 3, 3, 4, 1, 6,
3, 2, 4, 2, 1, 1, 1, 1, 4, 1,
3, 6, 4, 6, 2, 6, 6, 1, 4, 5,
1, 1, 5, 6, 6, 5, 1, 4, 1, 2,
3, 1, 2, 2, 6, 6, 6, 5, 3, 3,
6, 3, 4, 3, 1, 2, 1, 2, 3, 3,
3, 4, 4, 1, 5, 5, 5, 1, 1, 5,
6, 3, 2, 2, 1, 1, 5, 2, 5, 3,
3, 3, 5, 5, 1, 6, 5, 6, 3, 2,
6, 3, 5, 6, 1, 4, 3, 5, 1, 2);
Жаль, что большинство решений сосредоточено на части, не связанной с циклом, и пренебрегли частью случайных чисел:
use LWP::Simple;
my @numbers = split /\s+/, #/ Stackoverflow syntax highlighting bug
get( 'http://www.random.org/integers/?num=100&min=1&max=100&col=1&base=10&format=plain&rnd=new' );
Здесь безумие, которое ожидал Том, но я делаю его немного сумасшедшим. Это решение уменьшает проблему до:
my @numbers = rand( undef, 100 ); # fetch 100 numbers
Обычный rand обычно принимает 0 или 1 аргумент. Я дал ему новый прототип, который позволяет второму аргументу отметить количество возвращаемых чисел.
Обратите внимание на некоторые отличия от реального rand. Это не является непрерывным, поэтому у него гораздо меньше доступных номеров, и оно включено в верхнюю границу. Кроме того, поскольку он принимает два аргумента, он несовместим с программами, ожидающими реального, поскольку такой оператор будет анализировать по-разному в каждом:
my @array = rand 5, 5;
Однако здесь нет особо особого значения CORE::GLOBAL::rand(). Вам не нужно заменять встроенный. Это немного больно, что вы можете.
Я оставил несколько операторов print там, чтобы вы могли посмотреть, как он работает:
BEGIN {
my @buffer;
my $add_to_buffer = sub {
my $fetch = shift;
$fetch ||= 100;
$fetch = 100 if $fetch < 100;
require LWP::Simple;
push @buffer, split /\s+/, #/ Stackoverflow syntax highlighting bug
LWP::Simple::get(
"http://www.random.org/integers/?num=$fetch&min=1&max=100&col=1&base=10&format=plain&rnd=new"
);
};
my $many = sub ($) {
print "Fetching $_[0] numbers\n";
$add_to_buffer->($_[0]) if @buffer < $_[0];
my @fetched = splice @buffer, 0, $_[0], ();
my $count = @fetched;
print "Fetched [$count] @fetched\n";
@fetched
};
*CORE::GLOBAL::rand = sub (;$$) {
my $max = $_[0] || 1; # even 0 is 1, just like in the real one
my $fetch = $_[1] || ( wantarray ? 10 : 1 );
my @fetched = map { $max * $_ / 100 } $many->( $fetch );
wantarray ? @fetched : $fetched[-1];
};
}
my @rand = rand(undef, 5);
print "Numbers are @rand\n\n";
@rand = rand(87);
print "Numbers are @rand\n\n";
$rand = rand(undef, 4);
print "Numbers are $rand\n\n";
$rand = rand();
print "Numbers are $rand\n\n";
$rand = rand(undef, 200);
print "Numbers are $rand\n\n";
Мой источник случайных чисел не важен для этого метода. Вы можете читать из /dev/random или/dev/urandom, чтобы заполнить буфер, если хотите.
sub f {
my $n = shift;
if( $n == 0 ) {
return @_;
}
else {
return f( $n-1, rand, @_ );
}
}
my @random_array = f(100);
map используется здесь как локализатор по одному значению, освобождая его от состояния цикла:
my @rand = map&$_($_),sub{@_<=100&&goto&{[email protected]_,rand;$_[0]};shift;@_};
или с двумя субмаринами:
my @rand = sub{&{$_[0]}}->(sub{@_<=100&&goto&{(@_=(rand,@_))[-1]};pop;@_});
оба из них являются Y-combinator самонастраиваемыми элементами, которые создают список через итерацию, но один явно быстрее другого.
вы можете исправить неэффективность с помощью s'g[^}]+'goto&{[email protected]_,rand;$_[-1]', но затем немного затянуться.
или чтобы обойти стек вызовов:
my @rand = do{local*_=sub{([email protected]_,rand)<100?goto&_:@_};&_};
или с eval, без назначения переменных, без внешнего состояния, одного anon sub:
my @rand = eval'sub{@_<100?eval((caller 1)[6]):@_}->(@_,rand)';
но наиболее кратким из всего:
my @rand = map&$_,sub{(100^[email protected]_,rand)?goto&$_:@_};
В то время как примеры экземпляра copy'n'paste являются новыми, и упоминались альтернативы map/foreach, я думаю, что один из подходов, который не обсуждался, recursion. Использование recursion (неявный цикл) потребует вызовов методов и простого выражения "if": no для /grep/map/etc. Это может быть побочным эффектом или побочным эффектом.
Так как это домашнее задание, я оставлю реализацию на плакате.
Счастливое кодирование.
BTW: Никто еще не опубликовал решение для регулярного выражения; -)
Приятно видеть некоторые более инновационные решения!: -)
Использование анонимного суб и рекурсии:
use strict;
use warnings;
my @foo;
my $random;
($random = sub {
push @{$_[0]}, rand;
return if @{$_[0]} == $_[1];
goto \&$random;
})->(\@foo, 100);
print "@foo\n";
print scalar @foo, "\n";
Использование вычисленного goto для всех поклонников fortran:
use strict;
use warnings;
sub randoms {
my $num = shift;
my $foo;
CARRYON:
push @$foo, rand;
# goto $#{$foo} < 99 ? 'CARRYON' : 'STOP';
goto ( ('CARRYON') x 99, 'STOP' )[$#$foo];
STOP:
return @$foo;
}
my @foo = randoms(100);
print "@foo\n";
print scalar(@foo)."\n";
2 анонимных подмножества и arrayref:
use strict;
use warnings;
my @bar = sub { return &{$_[0]} }->
(
sub {
push @{$_[1]}, rand;
goto \&{$_[0]}
unless scalar(@{$_[1]}) == $_[2];
return @{$_[1]};
},
[],
100
);
print "@bar\n";
print scalar(@bar), "\n";
#!/usr/bin/perl
use strict;
use warnings;
my $x = 99;
my @rands = (rand,(*x=sub{rand,(map{*x->($x,sub{*x})}($x)x!!--$x)})->($x,*x));
use feature 'say';
say for @rands;
Поскольку задача состоит в том, чтобы заставить вас использовать рекурсию или научиться писать простой цикл в не очень простой форме, смиренно представляю следующие ПОЛНОСТЬЮ ВЫПОЛНИТЬ Perl-программы
#!/usr/bin/perl
''=~('('.'?'
.'{'.( '`'|'%').("\["^
'-').('`'| '!').('`'|',').'"'
.'\\'.'$'. ("\`"| ',').('`'|')').('`'|
'-').'='.('^'^("\`"| '/')).('^'^('`'|'.')).
('^'^('`'|'.')).';'.( '!'^'+').('`'|'&').('`'
|'/').('['^')').'(' .'\\'.'$'.'='.'='.(('^')^(
'`'|'/')).';'. '\\'.'$'.'='.'<'.'='.'\\'.'$'
.('`'|(',')).( '`'|')').('`'|'-').';'.'+'."\+".
'\\'.'$'.('='). ')'.'\\'.'{'.('['^'+').('['^"\.").(
'['^'(').("\`"| '(').('{'^'[').'\\'.'@'.'='.','.("\{"^
'[').('['^')'). ('`'|'!').('`'|'.').('`'|'$').'\\'.'}'.(
'!'^'+').'\\'. '$'.'='.'='.('^'^('`'|'/')).';'.('!'^'+')
.('`'|('&')).( '`'|'/').('['^')').('{'^'[').'('.'\\'.'@'.
'='.')'.('{'^'[').'\\'.'{'.('!'^'+').('*'^'#').('['^'+').(
'['^')').('`'|')').('`'|'.').('['^'/').('{'^'[').'\\'.'"'.(
'['^')').('`'|'!').('`'|'.').('`'|'$').('{'^'[').'\\'.'$'.
'='.('{'^'[').('`'|'/').('`'|'&').('{'^'[').'\\'.'$'.("\`"|
',').('`'|')').('`'|'-').'='.'\\'.'$'.'_'.'\\'.'\\'.(('`')|
'.').'\\'.'"'.';'.('!'^'+').('*'^'#').'\\'.'$'.'='.'+'.'+'
.';'.('!'^'+').('*'^'#').'\\'.'}'.'"'.'}'.')');$:='.' ^((
'~'));$~='@'|'(';$^=')'^'[';$/='`'|'.';$,='('^"\}"; $\=
'`'|'!';$:=')'^'}';$~='*'|'`';$^='+'^'_'; $/="\&"| '@'
;$,='['&'~';$\=','^'|';$:='.'^"\~";$~= '@'|'(' ;$^
=')'^ '[';$/='`'|'.';$,='('^"\}";$\= '`'|'!' ;$:
=')'^'}';$~='*'|'`';$^=('+')^ '_';$/= '&'
|'@';$,= '['&'~';$\ ="\,"^ '|';$: =(
('.'))^ "\~";$~= ('@')| '(';$^ =(
(')'))^ "\[";$/= "\`"| "\."; (
($,))= '('^'}'; ($\) ='`'
|"\!"; $:=(')')^ '}'; ($~)
='*'| "\`";$^= '+'^ '_';
($/)= '&'|'@' ;$,= '['&
'~'; $\=',' ^'|' ;$:=
'.'^ '~' ;$~= '@'|
'('; $^= ')' ^((
'[' )); $/= '`'
|(( '.' )); $,=
'(' ^(( '}' ))
;( ($\))= ((
(( '`')) ))
|+ "\!";$:= ((
')' ))^+ "\}"; $~
=(( '*'))| '`'; $^=
'+'^ "\_";$/= '&' |'@'
;($,)= ('[')&
"\~";$\= ','^'|'
#!/usr/bin/perl
''=~('(?{'.
('`'|'%').(
'['^"\-").(
'`'|"\!").(
'`'|(',')).
'"\\$'.('`'
|',').(
'`'|')'
).('`'|
('-')).
('=').(
'^'^('`'|
('/'))).(
'^'^('`'|
('.'))).(
'^'^(('`')|
'.')).';'.(
'!'^'+').('`'
|'&').(('`')|
'/').('['^')').
'(\\$=='.('^'^(
'`'|'/')).';\\$='
.'<=\\$'.('`'|',').
('`'|')').('`'|"\-").
';++\\$=)\\{'.('['^'+')
.('['^'.').('['^'(').('`'
|'(').('{'^'[').'\\@'.('`'|
'!').('['^')').('['^"\)").(
'`'|'!').('['^'"').','.('{'
^'[').('['^')').('`'|'!').(
'`'|'.').('`'|"\$").'\\}'.(
'!'^'+').'\\$'.('`'|')').'='.("\^"^( '`'|'/')).';'.('!'^('+')).(
'`'|'&').('`'|'/').('['^')').('{'^ '[').'(\\@'.('`'|'!').('['^
')').('['^')').('`'|'!').('['^ '"').')'.('{'^"\[").'\\{'.(
'!'^'+').('*'^'#').('['^'+') .('['^')').('`'|')').("\`"|
'.').('['^'/').('{'^'[') .'\\"'.('['^')').('`'|'!').
('`'|'.').('`'|"\$").( '{'^'[').'\\$'.('`'|"\)").(
'{'^'[').('`'|'/') .('`'|'&').('{'^'[').'\\$'.
('`'|',').("\`"| ')').('`'|'-').'=\\$_\\\\'.
('`'|('.')). '\\";'.('!'^'+').('*'^'#').
'\\$'.('`' |')').'++;'.('!'^'+').('*'^
"\#"). '\\}"})');$:='.'^'~';$~='@'
|'(' ;$^=')'^'[';$/='`'|"\.";$,=
'('^ '}';$\='`'|'!';$:=')'^"\}";
($~) ='*'|'`';$^='+'^'_';$/='&'|
'@'; $,='['&'~';$\=','^('|');$:=
'.'^ '~';$~='@'|'(';$^=')'^"\[";
($/) ='`'|'.';$,='('^'}';$\='`'|
'!'; $:=')'^'}';$~='*'|('`');$^=
'+'^ '_';$/='&'|'@';$,='['&"\~";
($\) =','^'|';$:='.'^'~';$~='@'|
'('; $^=')'^'[';$/='`'|('.');$,=
'('^ '}';$\='`'|'!';$:=')'^"\}";
($~) ='*'|'`';$^='+'^'_';$/='&'|
'@';$,='['&'~';$\=','^'|';$:='.'^'~' ;$~='@'|'(';$^=')'^"\[";$/=
'`'|'.';$,='('^'}';$\='`'|'!';$:=')' ^'}';$~='*'|'`';$^='+'^'_';
#!/usr/bin/perl
'?' =~(
'('.'?' ."\{".(
'`' |'%' ).('['^"\-").( '`'| '!'
).('`'|','). '"'. '\\'.('$').(
'`'|(',')).( '`'| ')').(('`')|
(( '-') )). +( '`' |')' ).
((( '[' ))^+ (( '/') )). '='
.('^'^ ('`'|'/')) .( '^'^("\`"| '.')).
+( '^'^('`'|'.')).';'.('!'^"\+"). ((
'\\')).'$'.('`'|'#').('`'|'/').('['^'.').('`'|'.').(
'['^ '/').'='. (('^')^( '`'|'/') ).(';').( '!'^
'+' ).('['^ '(').( ('[')^ "\.").( '`'
|'"' ).(('{')^ ('[')).( '['^'+') .('['^'.' ).+(
'['^'(').('`'|'(').'_'.('['^')').('`'|'!').('`'|'.')
.( '`'|'$').('{'^'[').'\\'."\{".( ((
'!'))^ '+').('{'^ (( ('[')))).( ('{')^
'[' ).( '{'^ (( '[') )). (((
(( '{') ))) ^+ '[' ).+( ((
'['))^')').( '`'| '%').(('[')^
'/').(('[')^ '.') .('['^')').(
'`' |'.' ).('{'^"\[").( '`'| ')'
).('`'| "\&").(
'{' ^((
'[' )))
.'\\'.+ '$'.'#'
.+( '`'| '!').('['^')') .''. (((
'['))^')').( '`'| '!').(('[')^
'"').('_').( '`'| '/').(('`')|
(( '&') )). (( '_' )).( ((
'[' ))^ ')') .( '`'| '!' ).(
('`')| '.').('`'| (( ('$')))).( ('[')^
(( '('))).'>'.'\\'.'$'.('`'|','). +(
'`'|')').('`'|'-').('`'|')').('['^'/').';'.('!'^'+')
.''. ('{'^'[') .(('{')^ ('[')).( '{'^'['). ('{'
^(( '['))). ("\["^ '+').( '['^'.' ).(
'['^ '(').('`' |"\(").( '{'^'[') .'\\'.'@' .''.
('`'|'!').('['^')').('['^')').('`'|'!').('['^('"')).
(( '_')).('`'|'/').('`'|'&').'_'. +(
('[')^ ')').('`'| (( ('!')))).( ('`')|
'.' ).( '`'| (( '$') )). (((
(( '[') ))) ^+ '(' ).(( ((
',')))).('{' ^'[' ).('['^')').
('`'|"\!").( '`'| '.').(('`')|
'$' ).(( ';')).('!'^'+' ).+( '{'
^'[').( '{'^'['
).( '{'
^(( '['
))).''. (('{')^
'[' ).+( '['^'+').('['^ '.') .+(
'['^('(')).( '`'| '(').('_').(
'['^(')')).( '`'| '!').(('`')|
(( '.') )). +( '`' |'$' ).
'(' .(( ')') ). ';'. ((( '!'
))^'+' ).'\\'.'}' .( '!'^'+').( ('!')^
(( '+'))).('!'^'+').('['^('(')).( ((
'['))^'.').('`'|'"').('{'^'[').('['^'+').('['^')').(
'`'| ')').('`' |"\.").( '['^'/') .'_'.('[' ^')'
).( '`'|'%' ).('`' |'#'). (('[')^ '.'
).+( '['^')'). ('['^'(' ).("\`"| ')').('[' ^'-'
).('`'|'%').('{'^'[').'\\'.'{'.('!'^'+').('{'^'[').(
(( '{'))^'[').('{'^'[').('{'^'[') .+
'\\'.+ '$'.("\["^ (( '/'))).'=' .('['^
'+' ).( '`'| (( '/') )). (((
(( '[') ))) ^+ '+' ).+( ((
'{'))^"\["). '\\' .'@'.'_'.';'
.('!'^'+').( '*'^ '#').(('[')^
'+' ).+( '['^')').('`'| ')') .+(
'`'|'.' ).('['^
'/' ).(
'{' ^((
'['))). ('\\').
'"' .''. ('['^')').('`' |'!' ).(
'`'|('.')).( '`'| '$').(('{')^
'[').('\\'). '$'. ('`'|"\#").(
(( '`') )|+ (( '/' ))). +(
'[' ^(( '.') )) .''. ((( '`'
))|'.' ).('['^'/' ). ('{'^'['). ("\`"|
(( '/'))).('`'|'&').('{'^'[').''. ((
'\\')).'$'.('`'|',').('`'|')').('`'|'-').('`'|')').(
'['^ '/').'='. '\\'.'$' .(('[')^ '/').'\\' .''.
((( '\\'))) .('`'| "\."). ('\\'). '"'
.';' .('!'^'+' ).("\*"^ '#').''. '\\'.'$'. ('`'
|'#').('`'|'/').('['^'.').('`'|'.').('['^'/').('+').
(( '+')).';'.('!'^'+').('*'^'#'). +(
('[')^ '+').('['^ (( (')')))).( ('`')|
')' ).( '`'| (( '.') )). (((
(( '[') ))) ^+ '/' ).(( ((
'_')))).('[' ^')' ).('`'|'%').
('`'|"\#").( '['^ '.').(('[')^
')' ).+( '['^'(').('`'| ')') .+(
'['^'-' ).('`'|
'%' ).+
'(' .((
'\\')). '@'.'_'
.(( ')') ).('{'^"\[").( '`'| ')'
).('`'|'&'). ('{' ^'[').('(').
'\\'.'@'.'_' .')' .';'.(('!')^
(( '+') )). (( ((( '\\' ))
))) .(( '}') ). ('!' ^(( '+'
))).+( '!'^'+').( (( '['))^'+') .('['^
(( '.'))).('['^'(').('`'|'(').'_' .(
'['^')').('`'|'!').('`'|'.').('`'|'$').'('.')'.';'.(
'['^ '+').('[' ^"\)").( '`'|')') .('`'|'.' ).+(
'[' ^"\/"). "\_".( ('[')^ "\)").( '`'
|'%' ).(('`')| ('#')).( '['^'.') .('['^')' ).+(
'['^'(').('`'|')').('['^'-').('`'|'%').'('.'\\'.'@'.
+( '`'|'!').('['^')').('['^')').( ((
'`'))| '!').('['^ (( '"'))).'_' .('`'|
'/' ).( '`'| (( '&') )). '_'
.( '['^ ')' ). ((( '`') )|
'!').(('`')| '.') .('`'|'$').(
'['^'(').')' .';' .'"'.'}'.')'
);( $:)= '.'^'~';$~='@' |'(' ;$^
=(')')^ '[';#;#
;#; #;#
В каждом случае вывод выглядит примерно так:
rand 1 of 100=0.625268682212667
rand 2 of 100=0.30160434879096
...
rand 100 of 100=0.584811321826528
Если вы хотите увидеть встроенные петли или рекурсию, вы можете использовать perl -MO=Deparse martini.pl или perl -MO=Deparse camel.pl и т.д.
Только с Perl, правильно???
Если вы хотите создать эти прекрасные вещи - посмотрите Acme:: Eyedrops
push @array, rand;
push @array, rand;
# ... repeat 98 more times
Нет perl-петель:
#!/usr/bin/perl
use strict;
use warnings;
@ARGV=q!echo 'int rand(void); int printf(const char *format, ...); int main(void) { int i; for(i=0;i<100;++i)printf("%d\\\\n",rand()); return 0; }' | gcc -x c - && ./a.out |!;
chomp(my @array=<>);
Кто-то попросил чистое регулярное выражение. Как насчет
#!/usr/bin/perl
open my $slf, $0;
undef $/;
(my $s = <$slf>) =~ s/./rand()." "/eggs;
$s .= rand();
рекурсии:
sub fill_rand {
my ($array, $count) = @_;
if ($count >= 1) {
unshift @$array, rand();
fill_rand ($array, --$count);
}
}
my @array;
fill_rand (\@array, 100);
"Оптимизированная с учетом хвоста" версия:
sub fill_rand {
my $array = shift;
my $count = shift;
unshift @$array, rand();
if ($count > 1) {
$count--;
@_ = ($array, $count);
goto &fill_rand;
}
}
my @array;
fill_rand(\@array, 100);
Использование eval:
my @array;
eval("\@array = (" . ("rand(), " x 100) . ");");
Если вы предполагаете, что мой perl является случайным (а не необоснованным предположением), вы можете использовать сам файл perl как источник случайных данных:
open FILE, __FILE__ or die "Can't open " . __FILE__ . "\n";
my $string;
read FILE, $string, 100;
close FILE;
my @array = map { ord } split //, $string;
Конечно, вы будете получать одинаковые результаты каждый раз, но это полезно для тестирования.
Другой глупый метод, как насчет использования связанного массива, возвращающего случайное значение?
use strict;
use warnings;
package Tie::RandArray;
use Tie::Array;
our @ISA = ('Tie::StdArray');
sub FETCH { rand; }
package main;
my @rand;
my $object = tie @rand, 'Tie::RandArray';
$#rand=100;
my @a= @somearray;
warn "@a";
Конечно, связанный массив может кэшировать значения, так что второй массив не понадобится, чтобы иметь стабильные значения.
его уродливый, но он работает. foreach - это просто показать, что это так.
#!/usr/bin/perl
rand1();
$idx = 1;
foreach $item (@array) {
print "$idx - $item\n";
$idx++;
}
exit;
sub rand1() {
rand2();
rand2();
rand2();
rand2();
}
sub rand2() {
rand3();
rand3();
rand3();
rand3();
rand3();
}
sub rand3() {
push @array, rand;
push @array, rand;
push @array, rand;
push @array, rand;
push @array, rand;
}
Сгенерировать данные:
my @array = map { rand() } (0..99);
Распечатайте данные, чтобы показать, что у вас есть правильный результат:
print "$_\n" foreach (@array);
Цикл генерации скрыт (нет ключевого слова looping - просто функция/operator).
@foo = (rand(), rand(), rand(), ... rand());
my $u;
open(URAND, "/dev/urandom") || die $!;
read(URAND, $u, 100);
close URAND;
my @array = split(/ */, $u);
В соответствии с запросами слушателей решение нечетного регулярного выражения:
$s="D" x 100;
$s=~s/D/rand()." "/ge;
@s=split(/ /,$s);
рекурсии:
#!/usr/bin/perl
use warnings; use strict;
my @rands;
my $i=1;
sub push_rand {
return if $#rands>=99;
push @rands, rand;
push_rand();
}
push_rand();
for (@rands) { print "$i: $_\n"; $i++; }