function uniqRand($count=6, $from=1, $to=10, $maxInstances=1){
$count=abs($count);
$from=abs($from);
$to=abs($to);
$maxInstances=abs($maxInstances);
$extracted=array();
if(($to-$from+1)*$maxInstances=0){
$r=mt_rand($from, $to);
if(!isset($extracted[$r]) || $extracted[$r]<$maxInstances){$output[]=$r;}
else{++$count;};
++$extracted[$r];
};
return $output;
}

Your goal, when teaching programming, is to teach programming. You should not be teaching a specific language (although you need a language to teach in, the distinction is subtle but important) and you should not be teaching particular techniques except where they are important more generally.

With this in mind, you want a language that gets out of your way when you want it to but is flexible enough to demonstrate advanced concepts when necessary. Obrant: Java is not this language. Neither is Delphi. Python’s a reasonable choice. (Yes, this is a dig at the local education department.)

With this in mind, you probably don’t want to be teaching the One Right Way To Do It for pretty much anything. What methods you teach should depend on what concepts you are teaching. In this case, if the selection is incidental to the lesson, use the standard library function that does the hard work for you. If the implementation is central to the lesson for some reason, you need to cover that.

It is fairly important, in my opinion, to be able to ignore anything that isn’t central to the concept being taught. This will never be universally possible, but it is far easier in some cases than in others. To use an example I’m rather fond of, consider a student’s first introduction to a programming language.

In Python:

print "Hello World!"

In Pascal:

program HelloWorld;
begin
    writeln('Hello world!');
end.

In Java:

class HelloWorld {
    public static void main(String args[]) {
        System.out.println("Hello World!");
    }
}

The first two are fine. Neither contain more concepts than “this is a program” and “we want to print ‘Hello World!’”. Java, on the other hand, requires either explanation or glossing-over of classes, public/private methods, static methods, functions and parameters. All of these are important, to be sure, but the student should not have to deal with them all at once.

In conclusion, you need balance. Teach what it makes sense to teach. You don’t want to gloss over everything, but neither do you want to dive immediately into the details of everything.

I should actually turn this into a post on my blog. Prod me with something appropriately pointy if I forget…

1. Keep picking random numbers, discarding duplicates, until we have as many as we need.

2. Generate a list of all possible numbers, and throw away random ones until you have as many as you need.

3. Generate a list of all possible numbers, shuffle it, and throw away the first/last however many you don’t need.

Oh, four: 4. Use the builtin function to do what we need.

This is what I’d explain to the kid I was teaching to code, rather than showing him array_splice()s and samples().

$nums = array_keys(array_pad(array(),10,’nom’));
array_shift($nums);
shuffle($nums);
$nums = array_splice($nums,0,6);
print(implode(’ ‘,$nums));

I shall address the education question when I have more time to consider it, but here is the Erlang implementation you asked for. I specifically chose a method not yet used here:

uniquerandoms(Min, Max, Count) ->
    ShuffledList = shuffle(lists:seq(Min, Max)),
    lists:sublist(ShuffledList, Count).

%% The shuffling implementation below was found on the interwebs:
%% http://www.trapexit.org/RandomShuffle
shuffle(List) ->
    %% Determine the log n portion then randomize the list.
    randomize(round(math:log(length(List)) + 0.5), List).

randomize(1, List) ->
    randomize(List);
randomize(T, List) ->
    lists:foldl(fun(_E, Acc) ->
                        randomize(Acc)
                end, randomize(List), lists:seq(1, (T - 1))).

randomize(List) ->
    D = lists:map(fun(A) ->
                          {random:uniform(), A}
                  end, List),
    {_, D1} = lists:unzip(lists:keysort(1, D)),
    D1.

Printing out the answer is left as an exercise for the reader.

It’s still useful to know how to do it if your language doesn’t have a random.sample() equivalent.

$fu = array();
while (sizeof($fu)<6) {
$fu[rand(1,10)] = ‘nom’;
}
print_r(array_keys($fu));