How to generate an array with random values, without using a loop?

Question

How can I generate an array in Perl with 100 random values, without using a loop?

I have to avoid all kind of loops, like "for", foreach", while. This is my exercise, from my lab. I can't find a way to do solve this, because I am new in Perl.

In C, generating this array would by very easy, but I don't know how to do it in Perl.

Sinan Ünür · Answer 1 · 2015-08-13T17:24:41.520

61

For amusement value:

A method that works on systems where EOL is a single character:

#!/usr/bin/perl

use strict;
use warnings;

$/ = \1;

open 0;
my @r = map rand,<0>;

print "@r\n";

A possibly nondeterministic method that does not use `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";

Using regular expressions:

#!/usr/bin/perl
use strict; use warnings;

my $s = '-' x 100;
$s =~ s/(-)/rand() . $1/eg;
my @rand = $s=~ m/([^-]+)/g;

Copying and pasting 100 `rand` invocations by hand is really passé:

#!/usr/bin/perl
use strict; use warnings;

my $s = '(' . 'rand,' x 100 . ')';
my @rand = eval $s;

A file I/O based solution that does not require `/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__

No reason to use recursion with Perl's `goto`

#!/usr/bin/perl
use strict; use warnings;
use autodie;

$/ = \1;

open my $F, '<', \( 1 x 100 . 0 );

my @rand or &notloop;

sub notloop {
    my $t = <$F>;
    $t or return;
    push @rand, rand;
    goto \&notloop;
}

Here is a recursive string `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
;

Of course, all of these actually do contain loops, but they do not use the keywords you were barred from using.

NB: This question has brought out the wacko in me, but I must admit it is amusing.

edited Aug 13 '15 at 17:24

answered Nov 03 '10 at 23:13

Sinan Ünür

116,958
15
196
339

I dunno. The tail recursion would have been cooler if it had been an anon `sub{}`. :) – tchrist Nov 04 '10 at 00:24
I'm waiting for something spooky to happen to *CORE::GLOBAL::rand. – tchrist Nov 04 '10 at 00:24
@tchrist I believe I need `Sub::Current` for the anon sub solution. However, I added one based on recursive string `eval`. – Sinan Ünür Nov 04 '10 at 01:02
Oh, I dunno about that: see my anon sub solution. :) – tchrist Nov 04 '10 at 01:04
Well, *ahem*, I actually voted that up but every time I look away I have to re-figure out what it's doing ;-) – Sinan Ünür Nov 04 '10 at 01:12
I think the second solution is one of those rare ones that becomes no clearer with whitespace added. – tchrist Nov 04 '10 at 06:38
@Sinan: Why the YAML? Is that left over from an old edit? You still get the eval text in caller[6] without that or autodie. No, don't edit again, you may be getting too close to 10. – tchrist Nov 04 '10 at 15:05
@tchrist: Yup, leftover stuff. I was editing the same file repeatedly. – Sinan Ünür Nov 04 '10 at 15:08

score 49 · Answer 2 · answered Nov 03 '10 at 22:51

49

Nothing could be simpler!

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

answered Nov 03 '10 at 22:51

Sean

29,130
4
80
105

20

Wow. That is so noisy. Clearly `my @rands = eval sprintf q[(%s)], join q[,] => ('rand') x 100;` is *much* more maintainable. – rafl Nov 03 '10 at 23:02
4

Copying and pasting 100 `rand` s by hand is so not Perl! ;-) – Sinan Ünür Nov 03 '10 at 23:26
2

Btw, I did this in Emacs: C-x ( rand, C-x ) C-u 99 C-x e. – Sean Nov 03 '10 at 23:29
2

In vim it's easy; `y 100p :wq` – Ether Nov 03 '10 at 23:39
3

":wq"? ITYM "ZZ". Much more efficient. – Sean Nov 04 '10 at 05:24
Copy and pasting 100 rands by hand might not be perl, but in perl theres more than one way to do it - and removing the 3 best ways is also not perl. – semi Nov 06 '10 at 17:33
1

`my @rands = eval 'rand, ' x 100;` – Axeman Oct 10 '14 at 17:44

tchrist · Answer 3 · 2010-11-05T17:51:36.297

Pure Regex Solution

perl -E'say for&{sub{"\U\x{fb01}\x{fb03}"=~/.{0,2}.{0,3}.{0,3}.{0,4}+(?{$_[++$#_]=rand})(*FAIL)/||pop;@_}}'

Double‐`/e` Regex Solution

This:

($_=(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 produces this:

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

Recursive Numeric Function Solution

As in fact, does this, if you print the array:

@_=(*100=sub{$_[0]?(rand,(*{--$_[0]}=*{$_[0]})->(@_)):()})->($==100);

The second solution now allows for getting different numbers of random numbers easily enough, since following the assignment above, you can do such niceties as:

 print for @42=42->($==42);

And yes, that is indeed a function named 42(). The previous assignment to @_ created it along with a hundred other numerically named functions.

Explanation

The first regex solution relies on Unicode’s tricky casing of the two characters matched against. It may (or may not) be more easily understood with whitespace and comments added:

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

The way to understand how the second regex solution works is:

First, reduce the compile-time constant expressions into their more customary forms so you can more easily read the literals. For example, \170 is "x".
Second, trim down the double e to a single e in each substitution, then print out what that leaves in the string both times.

I’m sure you’ll appreciate the comment. :)

For the recursive solution, adding whitespace may help a little:

(*100 = sub { $_[0]
                ? ( rand, ( *{ --$_[0] } = *{ $_[0] } )->(@_) )
                : ( )
            }
)->( $= = 100 );

The need to pass a variable as an argument is due to the auto-decrement requiring an lvalue. I did that because I didn’t want to have to say $_[0] - 1 twice, or have any named temporary variables. It means you can do this:

$N = 100;
print for $N->($N);

And when you’re done, $N == 0, because of pass‐by‐implicit‐reference semantics.

For the cost of a bit of repetition, you can relax the need of an lvalue argument.

(*100 = sub { $_[0]
                 ? ( rand, ( *{ $_[0] - 1 } = *{ $_[0] } )->( $_[0] - 1 ) )
                 : ( )
            }
)->( 100 );

Now you no longer need an lvalue argument, so you can write:

print for 100->(100);

to get all 100 random numbers. Of course, you also have a hundred other numeric functions, too, so you can get lists of random numbers in any of these ways:

@vi = 6->(6); 
@vi = &6( 6);

$dozen = 12;

@dozen         =  $dozen->($dozen);
@baker's_dozen = &$dozen(++$dozen);

@_ = 100;
print &0;  # still a hundred of 'em

(Sorry ’bout the silly colors. Must be an SO bug.)

I trust that clears everything up. ☺

Am I really the only one to include an informative comment in my solution to help out our hapless student? :) — tchrist, Nov 04 '10 at 00:33
You win the line noise award of the month/year :) Too bad I can't upvote twice :) — DVK, Nov 04 '10 at 02:00
@Zaid: That one's the easier to understand of my two solutions. But to answer your question, the second `e` does the same thing as the first `e`. Kinda. — tchrist, Nov 04 '10 at 06:41

score 33 · Accepted Answer · answered Nov 03 '10 at 22:50

33

my @rand = map { rand } ( 1..100 );

But a map is just a loop with fancy window-dressing.

If you need to do something 100 times, you're going to need to use some kind of iterative structure.

answered Nov 03 '10 at 22:50

friedo

65,762
16
114
184

6

Well... a "map is just a loop" seems to be a VERY debatable statement... literally. http://stackoverflow.com/questions/3019925/is-map-a-loop .I happen to agree with labelling it a lop, FWIW – DVK Nov 03 '10 at 23:17
2

I wouldn't call map "just a loop". It's main feature it that it's an expression, so it can be part of a statement. The other looping constructs require their own statements (even in the modifier form). – brian d foy Nov 04 '10 at 16:22
4

Recursion is the same as iteration. – friedo Nov 09 '10 at 18:35

score 29 · Answer 5 · answered Nov 04 '10 at 01:34

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

brian d foy · Answer 6 · 2022-12-16T21:44:56.457

Too bad most of the solutions focused on the non-looping part and neglected the random numbers part. Some of you may not be old enough to have a printed table of random values (or an appendix of logarithms) in the back of your engineering textbooks. It's all online now:

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' );

Here's the insanity that Tom was waiting to see, but I make it slightly more insane. This solution reduces the problem to a rand call:

my @numbers = rand( undef, 100 ); # fetch 100 numbers

Normal rand normally takes 0 or 1 arguments. I've given it a new prototype that allows a second argument to note how many numbers to return.

Notice some differences to the real rand though. This isn't continuous, so this has far fewer available numbers, and it's inclusive on the upper bound. Also, since this one takes two arguments, it's not compatible with programs expecting the real one since a statement like this would parse differently in each:

 my @array = rand 5, 5;

However, there's nothing particularly special about CORE::GLOBAL::rand() here. You don't have to replace the built-in. It's just a bit sick that you can.

I've left some print statements in there so you can watch it work:

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

My source of random numbers isn't important for this technique though. You could read from /dev/random or /dev/urandom to fill the buffer if you like.

Now I know the spooky thing that's going to happen to `*CORE::GLOBAL::rand`. — tchrist, Nov 04 '10 at 06:46
Thanks. Can’t upvote you again, though. :( At first I thought you could have used `&$add_to_buffer if @buffer < $_[0]` but I see now that that doesn’t always work quite right. — tchrist, Nov 04 '10 at 17:20
I tried that buffer trick too, but it messed with @_ up the chain. There's enough evil here already, anyway. — brian d foy, Nov 04 '10 at 17:37
Nice! Will this implementation make it into Perl 5.14 or 5.16? — Christopher Bottoms, Nov 09 '10 at 00:21
Why would any implementation be in Perl? It should be a module anyway. No one will agree on their method to get random numbers. — brian d foy, Nov 12 '10 at 18:51

score 14 · Answer 7 · answered Nov 03 '10 at 23:09

14

sub f {
    my $n = shift;
    if( $n == 0 ) {
        return @_;
    }
    else {
        return f( $n-1, rand, @_ );
    }
}

my @random_array = f(100);

answered Nov 03 '10 at 23:09

Peter G.

14,786
7
57
75

Dammit. You had to post a recursive solution after my answer :-) – Nov 03 '10 at 23:12
I saw it blinking but read it only afterwards, a pity to delete it then. I tested it before posting otherwise I would have been earlier. – Peter G. Nov 03 '10 at 23:17

score 8 · Answer 8 · answered Nov 17 '10 at 22:00

Since the task seems to be either to get you to use recursion or to learn how to write an easy loop in a not-so-easy form, humbly I submit the following FULLY EXECUTABLE Perl programs:

Camel:

#!/usr/bin/perl
                                      ''=~('('.'?'
           .'{'.(                   '`'|'%').("\["^
        '-').('`'|                '!').('`'|',').'"'
 .'\\'.'$'.  ("\`"|              ',').('`'|')').('`'|
'-').'='.('^'^("\`"|            '/')).('^'^('`'|'.')).
('^'^('`'|'.')).';'.(          '!'^'+').('`'|'&').('`'
  |'/').('['^')').'('        .'\\'.'$'.'='.'='.(('^')^(
       '`'|'/')).';'.      '\\'.'$'.'='.'<'.'='.'\\'.'$'
      .('`'|(',')).(     '`'|')').('`'|'-').';'.'+'."\+".
     '\\'.'$'.('=').   ')'.'\\'.'{'.('['^'+').('['^"\.").(
    '['^'(').("\`"|   '(').('{'^'[').'\\'.'@'.'='.','.("\{"^
    '[').('['^')').  ('`'|'!').('`'|'.').('`'|'$').'\\'.'}'.(
    '!'^'+').'\\'.  '$'.'='.'='.('^'^('`'|'/')).';'.('!'^'+')
    .('`'|('&')).(  '`'|'/').('['^')').('{'^'[').'('.'\\'.'@'.
    '='.')'.('{'^'[').'\\'.'{'.('!'^'+').('*'^'#').('['^'+').(
    '['^')').('`'|')').('`'|'.').('['^'/').('{'^'[').'\\'.'"'.(
     '['^')').('`'|'!').('`'|'.').('`'|'$').('{'^'[').'\\'.'$'.
     '='.('{'^'[').('`'|'/').('`'|'&').('{'^'[').'\\'.'$'.("\`"|
      ',').('`'|')').('`'|'-').'='.'\\'.'$'.'_'.'\\'.'\\'.(('`')|
       '.').'\\'.'"'.';'.('!'^'+').('*'^'#').'\\'.'$'.'='.'+'.'+'
        .';'.('!'^'+').('*'^'#').'\\'.'}'.'"'.'}'.')');$:='.' ^((
         '~'));$~='@'|'(';$^=')'^'[';$/='`'|'.';$,='('^"\}";  $\=
          '`'|'!';$:=')'^'}';$~='*'|'`';$^='+'^'_'; $/="\&"|  '@'
            ;$,='['&'~';$\=','^'|';$:='.'^"\~";$~=  '@'|'('   ;$^
             =')'^ '[';$/='`'|'.';$,='('^"\}";$\=   '`'|'!'   ;$:
                   =')'^'}';$~='*'|'`';$^=('+')^    '_';$/=   '&'
                   |'@';$,=    '['&'~';$\ ="\,"^     '|';$:   =(
                   ('.'))^     "\~";$~=   ('@')|     '(';$^  =(
                   (')'))^     "\[";$/=   "\`"|       "\.";  (
                   ($,))=      '('^'}';   ($\)         ='`'
                   |"\!";     $:=(')')^   '}';         ($~)
                    ='*'|     "\`";$^=    '+'^         '_';
                    ($/)=     '&'|'@'     ;$,=         '['&
                    '~';     $\=','       ^'|'         ;$:=
                    '.'^     '~'          ;$~=         '@'|
                    '(';      $^=         ')'          ^((
                    '['        ));       $/=           '`'
                    |((         '.'     ));            $,=
                    '('          ^((   '}'              ))
                    ;(             ($\))=               ((
                    ((              '`'))               ))
                    |+             "\!";$:=             ((
                   ')'            ))^+ "\}";            $~
                  =((           '*'))|  '`';           $^=
                 '+'^         "\_";$/=   '&'          |'@'
               ;($,)=                                ('[')&
             "\~";$\=                               ','^'|'

Martini:

#!/usr/bin/perl
                                                  ''=~('(?{'.
                                                  ('`'|'%').(
                                                  '['^"\-").(
                                                  '`'|"\!").(
                                                  '`'|(',')).
                                                  '"\\$'.('`'
                                                    |',').(
                                                    '`'|')'
                                                    ).('`'|
                                                    ('-')).
                                                    ('=').(
                                                   '^'^('`'|
                                                   ('/'))).(
                                                   '^'^('`'|
                                                   ('.'))).(
                                                  '^'^(('`')|
                                                  '.')).';'.(
                                                 '!'^'+').('`'
                                                 |'&').(('`')|
                                                '/').('['^')').
                                                '(\\$=='.('^'^(
                                               '`'|'/')).';\\$='
                                              .'<=\\$'.('`'|',').
                                             ('`'|')').('`'|"\-").
                                            ';++\\$=)\\{'.('['^'+')
                                           .('['^'.').('['^'(').('`'
                                          |'(').('{'^'[').'\\@'.('`'|
                                          '!').('['^')').('['^"\)").(
                                          '`'|'!').('['^'"').','.('{'
                                          ^'[').('['^')').('`'|'!').(
                                          '`'|'.').('`'|"\$").'\\}'.(
'!'^'+').'\\$'.('`'|')').'='.("\^"^(      '`'|'/')).';'.('!'^('+')).(
 '`'|'&').('`'|'/').('['^')').('{'^       '[').'(\\@'.('`'|'!').('['^
   ')').('['^')').('`'|'!').('['^         '"').')'.('{'^"\[").'\\{'.(
    '!'^'+').('*'^'#').('['^'+')          .('['^')').('`'|')').("\`"|
      '.').('['^'/').('{'^'[')            .'\\"'.('['^')').('`'|'!').
       ('`'|'.').('`'|"\$").(             '{'^'[').'\\$'.('`'|"\)").(
         '{'^'[').('`'|'/')               .('`'|'&').('{'^'[').'\\$'.
          ('`'|',').("\`"|                ')').('`'|'-').'=\\$_\\\\'.
            ('`'|('.')).                  '\\";'.('!'^'+').('*'^'#').
             '\\$'.('`'                   |')').'++;'.('!'^'+').('*'^
               "\#").                     '\\}"})');$:='.'^'~';$~='@'
                |'('                      ;$^=')'^'[';$/='`'|"\.";$,=
                '('^                      '}';$\='`'|'!';$:=')'^"\}";
                ($~)                      ='*'|'`';$^='+'^'_';$/='&'|
                '@';                      $,='['&'~';$\=','^('|');$:=
                '.'^                      '~';$~='@'|'(';$^=')'^"\[";
                ($/)                      ='`'|'.';$,='('^'}';$\='`'|
                '!';                      $:=')'^'}';$~='*'|('`');$^=
                '+'^                      '_';$/='&'|'@';$,='['&"\~";
                ($\)                      =','^'|';$:='.'^'~';$~='@'|
                '(';                      $^=')'^'[';$/='`'|('.');$,=
                '('^                      '}';$\='`'|'!';$:=')'^"\}";
                ($~)                      ='*'|'`';$^='+'^'_';$/='&'|
'@';$,='['&'~';$\=','^'|';$:='.'^'~'      ;$~='@'|'(';$^=')'^"\[";$/=
'`'|'.';$,='('^'}';$\='`'|'!';$:=')'      ^'}';$~='*'|'`';$^='+'^'_';

For the Holidays, snowflakes with recursion rather than iteration inside:

#!/usr/bin/perl
           '?'                          =~(
         '('.'?'                      ."\{".(
        '`'   |'%'  ).('['^"\-").(  '`'|   '!'
         ).('`'|',').    '"'.    '\\'.('$').(
         '`'|(',')).(    '`'|    ')').(('`')|
        ((  '-')   )).    +(    '`'   |')'  ).
       (((    '['   ))^+  ((  '/')   )).    '='
      .('^'^   ('`'|'/')) .( '^'^("\`"|   '.')).
     +(     '^'^('`'|'.')).';'.('!'^"\+").     ((
 '\\')).'$'.('`'|'#').('`'|'/').('['^'.').('`'|'.').(
'['^  '/').'='.  (('^')^(    '`'|'/')  ).(';').(  '!'^
'+'    ).('['^    '(').(      ('[')^    "\.").(    '`'
|'"'  ).(('{')^  ('[')).(    '['^'+')  .('['^'.'  ).+(
 '['^'(').('`'|'(').'_'.('['^')').('`'|'!').('`'|'.')
     .(     '`'|'$').('{'^'[').'\\'."\{".(     ((
      '!'))^   '+').('{'^ (( ('[')))).(   ('{')^
       '['    ).(   '{'^  ((  '[')   )).    (((
        ((  '{')   )))    ^+    '['   ).+(  ((
         '['))^')').(    '`'|    '%').(('[')^
         '/').(('[')^    '.')    .('['^')').(
        '`'   |'.'  ).('{'^"\[").(  '`'|   ')'
         ).('`'|                      "\&").(
           '{'                          ^((
           '['                          )))
         .'\\'.+                      '$'.'#'
        .+(   '`'|  '!').('['^')')  .''.   (((
         '['))^')').(    '`'|    '!').(('[')^
         '"').('_').(    '`'|    '/').(('`')|
        ((  '&')   )).    ((    '_'   )).(  ((
       '['    ))^   ')')  .(  '`'|   '!'    ).(
      ('`')|   '.').('`'| (( ('$')))).(   ('[')^
     ((     '('))).'>'.'\\'.'$'.('`'|',').     +(
 '`'|')').('`'|'-').('`'|')').('['^'/').';'.('!'^'+')
.''.  ('{'^'[')  .(('{')^    ('[')).(  '{'^'[').  ('{'
^((    '['))).    ("\["^      '+').(    '['^'.'    ).(
'['^  '(').('`'  |"\(").(    '{'^'[')  .'\\'.'@'  .''.
 ('`'|'!').('['^')').('['^')').('`'|'!').('['^('"')).
     ((     '_')).('`'|'/').('`'|'&').'_'.     +(
      ('[')^   ')').('`'| (( ('!')))).(   ('`')|
       '.'    ).(   '`'|  ((  '$')   )).    (((
        ((  '[')   )))    ^+    '('   ).((  ((
         ',')))).('{'    ^'['    ).('['^')').
         ('`'|"\!").(    '`'|    '.').(('`')|
        '$'   ).((  ';')).('!'^'+'  ).+(   '{'
         ^'[').(                      '{'^'['
           ).(                          '{'
           ^((                          '['
         ))).''.                      (('{')^
        '['   ).+(  '['^'+').('['^  '.')   .+(
         '['^('(')).(    '`'|    '(').('_').(
         '['^(')')).(    '`'|    '!').(('`')|
        ((  '.')   )).    +(    '`'   |'$'  ).
       '('    .((   ')')  ).  ';'.   (((    '!'
      ))^'+'   ).'\\'.'}' .( '!'^'+').(   ('!')^
     ((     '+'))).('!'^'+').('['^('(')).(     ((
 '['))^'.').('`'|'"').('{'^'[').('['^'+').('['^')').(
'`'|  ')').('`'  |"\.").(    '['^'/')  .'_'.('['  ^')'
).(    '`'|'%'    ).('`'      |'#').    (('[')^    '.'
).+(  '['^')').  ('['^'('    ).("\`"|  ')').('['  ^'-'
 ).('`'|'%').('{'^'[').'\\'.'{'.('!'^'+').('{'^'[').(
     ((     '{'))^'[').('{'^'[').('{'^'[')     .+
      '\\'.+   '$'.("\["^ (( '/'))).'='   .('['^
       '+'    ).(   '`'|  ((  '/')   )).    (((
        ((  '[')   )))    ^+    '+'   ).+(  ((
         '{'))^"\[").    '\\'    .'@'.'_'.';'
         .('!'^'+').(    '*'^    '#').(('[')^
        '+'   ).+(  '['^')').('`'|  ')')   .+(
         '`'|'.'                      ).('['^
           '/'                          ).(
           '{'                          ^((
         '['))).                      ('\\').
        '"'   .''.  ('['^')').('`'  |'!'   ).(
         '`'|('.')).(    '`'|    '$').(('{')^
         '[').('\\').    '$'.    ('`'|"\#").(
        ((  '`')   )|+    ((    '/'   ))).  +(
       '['    ^((   '.')  ))  .''.   (((    '`'
      ))|'.'   ).('['^'/' ). ('{'^'[').   ("\`"|
     ((     '/'))).('`'|'&').('{'^'[').''.     ((
 '\\')).'$'.('`'|',').('`'|')').('`'|'-').('`'|')').(
'['^  '/').'='.  '\\'.'$'    .(('[')^  '/').'\\'  .''.
(((    '\\')))    .('`'|      "\.").    ('\\').    '"'
.';'  .('!'^'+'  ).("\*"^    '#').''.  '\\'.'$'.  ('`'
 |'#').('`'|'/').('['^'.').('`'|'.').('['^'/').('+').
     ((     '+')).';'.('!'^'+').('*'^'#').     +(
      ('[')^   '+').('['^ (( (')')))).(   ('`')|
       ')'    ).(   '`'|  ((  '.')   )).    (((
        ((  '[')   )))    ^+    '/'   ).((  ((
         '_')))).('['    ^')'    ).('`'|'%').
         ('`'|"\#").(    '['^    '.').(('[')^
        ')'   ).+(  '['^'(').('`'|  ')')   .+(
         '['^'-'                      ).('`'|
           '%'                          ).+
           '('                          .((
         '\\')).                      '@'.'_'
        .((   ')')  ).('{'^"\[").(  '`'|   ')'
         ).('`'|'&').    ('{'    ^'[').('(').
         '\\'.'@'.'_'    .')'    .';'.(('!')^
        ((  '+')   )).    ((    (((   '\\'  ))
       )))    .((   '}')  ).  ('!'   ^((    '+'
      ))).+(   '!'^'+').( (( '['))^'+')   .('['^
     ((     '.'))).('['^'(').('`'|'(').'_'     .(
 '['^')').('`'|'!').('`'|'.').('`'|'$').'('.')'.';'.(
'['^  '+').('['  ^"\)").(    '`'|')')  .('`'|'.'  ).+(
'['    ^"\/").    "\_".(      ('[')^    "\)").(    '`'
|'%'  ).(('`')|  ('#')).(    '['^'.')  .('['^')'  ).+(
 '['^'(').('`'|')').('['^'-').('`'|'%').'('.'\\'.'@'.
     +(     '`'|'!').('['^')').('['^')').(     ((
      '`'))|   '!').('['^ (( '"'))).'_'   .('`'|
       '/'    ).(   '`'|  ((  '&')   )).    '_'
        .(  '['^   ')'    ).    (((   '`')  )|
         '!').(('`')|    '.')    .('`'|'$').(
         '['^'(').')'    .';'    .'"'.'}'.')'
        );(   $:)=  '.'^'~';$~='@'  |'('   ;$^
         =(')')^                      '[';#;#
           ;#;                          #;#

In each case, the output is something like this:

rand 1 of 100=0.625268682212667
rand 2 of 100=0.30160434879096
...
rand 100 of 100=0.584811321826528

If you want to see the loops or recursion embedded within, you can use perl -MO=Deparse martini.pl or perl -MO=Deparse camel.pl etc.

Only with Perl, right???

If you want to generate these lovely things -- check out Acme::Eyedrops

This is the best answer to any question ever. – Anthony Nov 13 '16 at 18:30 — Anthony, Nov 13 '16 at 18:30

Eric Strom · Answer 9 · 2010-11-05T13:26:13.087

map is used here as a topicalizer over a single value, exempting it from loop status:

my @rand = map&$_($_),sub{@_<=100&&goto&{push@_,rand;$_[0]};shift;@_};

or with two subs:

my @rand = sub{&{$_[0]}}->(sub{@_<=100&&goto&{(@_=(rand,@_))[-1]};pop;@_});

both of these are Y-combinator style self-passed subs that build up the list via iteration but one is clearly faster than the other.

you can fix the inefficiency with s'g[^}]+'goto&{unshift@_,rand;$_[-1]' but then its getting a bit long.

or to sidestep the call stack:

my @rand = do{local*_=sub{(push@_,rand)<100?goto&_:@_};&_};

or with eval, no variable assignment, no external state, one anon sub:

my @rand = eval'sub{@_<100?eval((caller 1)[6]):@_}->(@_,rand)';

but most concise of all is:

my @rand = map&$_,sub{(100^push@_,rand)?goto&$_:@_};

score 5 · Answer 10 · 2010-11-04T00:05:36.823

While the copy'n'paste examples are novel and the map/foreach alternatives have also been mentioned, I think one approach that has not been discussed is recursion. Using recursion (an implicit loop) would need method calls and a simple 'if' statement: no for/grep/map/etc. It could be side-effecting or side-effect free.

Since this is homework, I will leave the implementation to the poster.

Happy coding.

~~BTW: Nobody has posted a regular expression solution yet ;-)~~

It's nice to see some even more innovative solutions! :-)

MkV · Answer 11 · 2010-11-04T15:52:09.123

5

Using an anonymous sub and recursion:

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

Using computed goto, for all the fortran fans:

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 anonymous subs and an 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";

edited Nov 04 '10 at 15:52

answered Nov 04 '10 at 01:20

MkV

3,046
22
16

1

It's trivial if you keep a reference to it in a variable. What I wanted to do was to find a way to do everything in a solitary `sub { }` without storing the ref in a variable. – Sinan Ünür Nov 04 '10 at 01:28
Devel::Caller / callee seemed a bit much for the OP's question – MkV Nov 04 '10 at 13:14
1

@Sinan: bless the closure and invoke it against itself as a method. – tchrist Nov 04 '10 at 14:23
1

That `x99` token doesn’t look right: it needs to be two tokens. Also, `$#{$foo}` can always be rewritten as `$#$foo` due to the rule that dereferencing braces can be omitted whenever they contain nothing but a bareword symbol with **zero or more** leading dollar signs. I *do* like the double-closure solution. – tchrist Nov 04 '10 at 15:22
tchrist: I always find myself being explicit about the {} with *$#* and keeping the *VALxNUMBER* as close together as possible. Changes made. – MkV Nov 04 '10 at 15:57
@tcrist - there are plenty of people who consider the "always use {} when dereferencing" rule to be extremely conductive to better maintainability, even if the character count increases. – DVK Nov 04 '10 at 18:10
@DVK: Depends what counts as dereferencing then, eh? `${foo}` is seldom written outside of interpolated strings. But yeah, you’re right: I cannot count how many times I’ve seen someone confused because they’ve written `$$foo[0]` and thinking they’re getting `${$foo[0]}` but getting `${$foo}[0]` instead. I think it’s due to C precedence, like in `*argv[0] == '‑'`. Note that `B::Deparse` does show `$foo‑>[0]` as the unshortcutted `$$foo[0]`. I advise people to *always* write that the first way—with the deref arrow— *unless* they’re doing slices like `@{$some_aref}[2,3]`, when you’ve no choice. – tchrist Nov 05 '10 at 02:02
1

The world would be a better place if more Perl hackers knew about the Y combinator. – Porculus Nov 06 '10 at 17:11

score 5 · Answer 12 · edited Dec 04 '17 at 22:10

5

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

edited Dec 04 '17 at 22:10

brian d foy

129,424
31
207
592

answered Nov 05 '10 at 00:43

Daniel Holz

148
5

Nice work! It’s always nice to see people play with their symbol tables. Been a while since I’ve had to explain perl4’s pass-by-name semantics using `*x` parameters to anybody. Ah, but I see you’ve used a *lexical* `$x`, which sidesteps that issue. – tchrist Nov 05 '10 at 03:39
Thanks Tom, I originally used positional parameters before realising I could keep the recursion count in a lexical and add another meaning for 'x' to the script. Wish I could have removed the map (even if it is just a glorified 'if')... – Daniel Holz Nov 05 '10 at 11:07

score 5 · Answer 13 · answered Nov 07 '10 at 18:28

5

Another silly method, how about using a tied array that return a random value ?

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

Of course the tied array could cache the values, so that a second array would not be needed to have stable values.

answered Nov 07 '10 at 18:28

squentin

51
1

Brilliant! "Generate an array with 100 random values" this array has 100 random values, and then another hundred -- and they're so random they aren't even the same between fetches! Brilliant! – Never Sleep Again Mar 02 '18 at 22:39
but also -- array assignment implies a loop! – Never Sleep Again Mar 02 '18 at 22:41

score 4 · Answer 14 · answered Nov 03 '10 at 22:51

4

    push @array, rand;
    push @array, rand;
    # ... repeat 98 more times

answered Nov 03 '10 at 22:51

mob

117,087
18
149
283

8

You have taken the wimp's way out with your `# ... repeat 98 more times` ! – Andy Lester Nov 03 '10 at 23:06
3

No, he's just being managerial and delegated the boring work to the readers :) – DVK Nov 03 '10 at 23:18

score 4 · Answer 15 · answered Nov 04 '10 at 03:56

4

No perl loops:

#!/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=<>);

answered Nov 04 '10 at 03:56

ysth

96,171
6
121
214

1

I double dog dare you to implement a Lisp interpreter in Perl without loops and then call the Lisp code :) – DVK Nov 04 '10 at 18:08
CHICKEN, McFly?!?!?! – DVK Nov 05 '10 at 16:38

score 4 · Answer 16 · edited May 23 '17 at 10:30

4

Someone asked for a pure regex solution. How about

#!/usr/bin/perl
open my $slf, $0;
undef $/;
(my $s = <$slf>) =~ s/./rand()." "/eggs;
$s .= rand();

edited May 23 '17 at 10:30

Community

1
1

answered Nov 04 '10 at 22:53

LSpice

141
1
6

@JadeNB: Why open `$0` when it’s already open with `__END__` and `seek(DATA,0,0)`? :) – tchrist Nov 04 '10 at 23:12
Oh for goodness sake, self-modifying code! It will only produce 99 of them unless you insert a `#` at byte 0. That or another `/g` in your omelette. :) – tchrist Nov 04 '10 at 23:17
IMHO it's NOT pure regex in a sense of you're still hard-coding a 100 char string, only as your own code (and need to fudge the code to get to 100 at that). Outside of "cool" value, I don't see it as any different than taking my original regex solution and replacing "Dx100" with a hardcoded string of 100 "D" characters. – DVK Nov 05 '10 at 16:27
My idea of a pure regex solution was to have the counting-to-100 done via some regex magic WITHOUT having 100-char string to do the implicit looping for you. – DVK Nov 05 '10 at 16:28
@DVK: Mine has no 100-char string, but good luck at catching it counting. :) – tchrist Nov 05 '10 at 20:19
In order: tchrist, good point!—I didn't think of that; tchrist, of course you're right (sloppy cut-and-pasting), and I've now added the #; DVK, yes, I know what you meant, and was just joking—sorry. – LSpice Nov 06 '10 at 16:36

score 3 · Answer 17 · 2010-11-05T14:57:17.043

Recursion:

sub fill_rand {
 my ($array, $count) = @_;
   if ($count >= 1) {
   unshift @$array, rand();
   fill_rand ($array, --$count);
 }
}

my @array;
fill_rand (\@array, 100);

"Tail-call optimised" version:

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

Using eval:

my @array;
eval("\@array = (" . ("rand(), " x 100) . ");");

If you assume that my perl is random (not an unwarranted assumption), you could use the perl file itself as a source of random data:

open FILE, __FILE__ or die "Can't open " . __FILE__ . "\n";
my $string;
read FILE, $string, 100;
close FILE;
my @array = map { ord } split //, $string;

Of course, you'll get the same results every time, but this is useful for testing.

Instead of using `goto &fill_rand` you could use [Sub::Call::Recur](http://search.cpan.org/perldoc/Sub::Call::Recur) or [Sub::Call::Tail](http://search.cpan.org/perldoc/Sub::Call::Tail) — Brad Gilbert, Nov 05 '10 at 14:39

score 3 · Answer 18 · answered Nov 09 '10 at 19:32

its ugly, but it works. the foreach is just to show that it does.

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

That’s more like my first regex solution than most people realize. — tchrist, Nov 10 '10 at 04:15

Jonathan Leffler · Answer 19 · 2010-11-03T23:02:16.840

2

Generate the data:

my @array = map { rand() } (0..99);

Print the data to show that you have the right result:

print "$_\n" foreach (@array);

The generation loop is hidden (there's no looping keyword visible - just a function/operator).

edited Nov 03 '10 at 23:02

answered Nov 03 '10 at 22:51

Jonathan Leffler

730,956
141
904
1,278

@rafl: You've got better eyesight than me. I see no while, for, foreach, until (did I miss any?) in the generation line. – Jonathan Leffler Nov 03 '10 at 22:56
A map is debatably a kind of magic loop :) http://stackoverflow.com/questions/3019925/is-map-a-loop – DVK Nov 03 '10 at 23:19
@DVK, @rafl: yes, of course map is iterating over a list; yes, there is is a loop-like effect; that's how you end up with 100 values. – Jonathan Leffler Nov 04 '10 at 02:52
how does `..` know when to stop? It uses a loop! – Never Sleep Again Mar 02 '18 at 22:34

score 2 · Answer 20 · answered Nov 03 '10 at 22:51

2

@foo = (rand(), rand(), rand(), ... rand());

answered Nov 03 '10 at 22:51

Oliver Charlesworth

267,707
33
569
680

score 2 · Answer 21 · edited Nov 03 '10 at 23:24

2

my $u;

open(URAND, "/dev/urandom") || die $!;

read(URAND, $u, 100);

close URAND;

my @array = split(/ */, $u);

edited Nov 03 '10 at 23:24

Sinan Ünür

116,958
15
196
339

answered Nov 03 '10 at 23:21

elwood

29
1

That doesn’t work properly. You need to `read(URAND, $u, 100 * length pack("I")` and then `@array = unpack("I*", $u)`. Or `$/ = \length pack "I"; @array = unpack("I*", )`. – tchrist Nov 04 '10 at 15:14
1

Dunno whether elwood’s ever coming back, but a proper urandom solution is just `perl -le '$/ = \\(100*length pack "L"); print for unpack "L*" => <>' /dev/urandom`. – tchrist Nov 04 '10 at 17:11

score 1 · Answer 22 · answered Nov 03 '10 at 23:25

1

As per requests from the listeners, a non-pure-regex solution:

$s="D" x 100; 
$s=~s/D/rand()." "/ge; 
@s=split(/ /,$s);

answered Nov 03 '10 at 23:25

DVK

126,886
32
213
327

Come on now, you can do better than that. – tchrist Nov 03 '10 at 23:57
1

Meh. Why bother when Sinan's having so much fun and my brain's a total mush from 4 hours fighting with Eclipse. I literally ONLY did it because pst asked in his answer :) – DVK Nov 04 '10 at 01:58
2

Eclipse and I are not on speaking terms. – tchrist Nov 04 '10 at 11:47
I don't understand why anyone uses Eclipse with Perl. I've never heard anyone have a good time with it while trying to do Perl. – brian d foy Nov 04 '10 at 17:08
@brian - I was fighting in the Java territory :) – DVK Nov 04 '10 at 17:58
@DVK: Same here. I refuse to use Eclipse unless forced to. For my own stuff I develop in Bostic’s vi with makefiles or sometimes ant files. I have supergiant vi-style tags files built for both the Java6 and Java7 distributions/stdlibs. Java is often stupid, sometimes evil, and always *always* a royal PITFA nonpareil. I do have the Perl plugin but that’s more for demo purposes. I can’t imagine using it. – tchrist Nov 04 '10 at 18:06
BTW, I didn't notice, did anyone post a PURE regex solution? (defined as not needing a string multiplication operator)? – DVK Nov 04 '10 at 18:11
Eclipse has its positive points (compared to my main IDE of choice), but i'm not convinced they are worth either the 1GB memory footprint or the aggravation of its painful ways – DVK Nov 04 '10 at 18:12
@DVK: “A **PURE** regex solution defined as not needing a string repetition operator”... Well, sure, I can think of two or three ways instantly, one silly and one slick. But it’ll take me a bit to dink around to get the number of backtracks right; that or use (*PRUNE). – tchrist Nov 04 '10 at 23:08
2

@DVK: Oh, it’s perfectly credible, being a sort of its own existence proof. It works just fine, as does the expanded version, with or without *cpp* (1) installed—curiously enough. :) – tchrist Nov 05 '10 at 20:17
the `x` operator here is a loop – Never Sleep Again Mar 02 '18 at 22:30

score 1 · Answer 23 · answered Nov 04 '10 at 14:32

1

Recursion:

#!/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++; }

answered Nov 04 '10 at 14:32

dawg

98,345
23
131
206

exiting on the degenerate case makes recursion a loop – Never Sleep Again Mar 02 '18 at 22:31

score 0 · Answer 24 · answered Mar 02 '18 at 22:25

The question: do something (and something happens to be call rand()) a bunch of times without using a loop. Implied is, and without just repeating the source. None of the above answers actually answer this. They either repeat the source, or hide the looping. Here is a general approach that mitigates the repetition and does not hide looping (by implementing it using computed goto, or a regex, or recursion, etc). I call this approach "managed repetition."

100 has four prime factors: 2*2*5*5 == 100. So we need two repetition managers, five and two:

sub two{ my $y=shift; ($y->(), $y->()) }
sub five{my $y=shift; ($y->(), $y->(), $y->(), $y->(), $y->()) }

then call them -- we're not recursing, because the recursion degenerate case constitutes a loop test -- just calling them:

my @array = five(sub{five(sub{two(sub{two(sub{rand()})})})});

There you are, a general way to call something a predetermined number of times without using a loop, rather, by delegating the repetition in an efficient and controlled way.

Discussion question: which order should the fives and twos be in and why?

writing a `ten` and stacking it twice would be shorter, wouldn't it. Is this a golf hole? — Never Sleep Again, Mar 02 '18 at 22:27

How to generate an array with random values, without using a loop?

24 Answers24

A method that works on systems where EOL is a single character:

A possibly nondeterministic method that does not use `for`, `while`, `until`:

Using regular expressions:

Copying and pasting 100 `rand` invocations by hand is really passé:

A file I/O based solution that does not require `/dev/random`:

No reason to use recursion with Perl's `goto`

Here is a recursive string `eval` version:

Pure Regex Solution

Double‐`/e` Regex Solution

Recursive Numeric Function Solution

Explanation

Camel:

Martini:

For the Holidays, snowflakes with recursion rather than iteration inside:

Linked

How to generate an array with random values, without using a loop?

24 Answers24

A method that works on systems where EOL is a single character:

A possibly nondeterministic method that does not use for, while, until:

Using regular expressions:

Copying and pasting 100 rand invocations by hand is really passé:

A file I/O based solution that does not require /dev/random:

No reason to use recursion with Perl's goto

Here is a recursive string eval version:

Pure Regex Solution

Double‐/e Regex Solution

Recursive Numeric Function Solution

Explanation

Camel:

Martini:

For the Holidays, snowflakes with recursion rather than iteration inside:

Linked

A possibly nondeterministic method that does not use `for`, `while`, `until`:

Copying and pasting 100 `rand` invocations by hand is really passé:

A file I/O based solution that does not require `/dev/random`:

No reason to use recursion with Perl's `goto`

Here is a recursive string `eval` version:

Double‐`/e` Regex Solution