This is how I do it now:

int a[] = { 0, 1, 2, 3 };
shuffle(a, 4);
for (int i = 0; i < 4; i++) {
// do something with `a[i]'
}

where `shuffle' is a function that I copied from here: https://benpfaff.org/writings/clc/shuffle.html

It works fine, but since I have only four numbers to loop over and they are consequential, putting them into an array and shuffling it feels a bit overkill. Is there an easier way to do this (without using an array, preferably)?

On 2021-11-30, Oğuz <oguzismailuysal@gmail.com> wrote:
> This is how I do it now:
>
> int a[] = { 0, 1, 2, 3 };
> shuffle(a, 4);
> for (int i = 0; i < 4; i++) {
> // do something with `a[i]'
> }
>
> where `shuffle' is a function that I copied from here: https://benpfaff.org/writings/clc/shuffle.html
>
> It works fine, but since I have only four numbers to loop over and
> they are consequential, putting them into an array and shuffling it
> feels a bit overkill. Is there an easier way to do this (without using
> an array, preferably)?

There are 24 permutations; so for instance you could make a program that
uses a cascade of randomized selection statements to take one of 24
control flow pathways. That's not going to be compact compared to the
shuffled array.

The values 0-3 require only two bits, and so a permutation can fit into
a byte. In 24 bytes of space, you could save all 24 permutations,
and randomly select one, then extract the values.

What are the values:

4> (mapcar (op reduce-left (op + @2 (* @1 4))) (perm '(0 1 2 3) 4))
(27 30 39 45 54 57 75 78 99 108 114 120 135 141 147 156 177 180
198 201 210 216 225 228)

So we still have an array, but it's immutable; we aren't having to
shuffle it. Moreover, a single call to the PRNG gets us the permutation,
and we are done with the array after making one access to it:

static const unsigned char tab[24] = {
27, 30, 39, 45, 54, 57, 75, 78,
99, 108, 114, 120, 135, 141, 147, 156,
177, 180, 198, 201, 210, 216, 225, 228
};

int i;
unsigned char perm = tab[rand() % 24]; /* get a better PRNG */

/* do something with (perm >> 6) */
/* do something with (perm >> 4) & 3 */
/* do something with (perm >> 2) & 3 */
/* do something with perm & 3 */

/* or */

for (int i = 0; i < 4; i++) {
/* do something with perm & 3 */
perm >>= 2;
}

--
TXR Programming Language: http://nongnu.org/txr
Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

On Tuesday, November 30, 2021 at 11:32:54 AM UTC+3, Kaz Kylheku wrote:
> There are 24 permutations; so for instance you could make a program that
> uses a cascade of randomized selection statements to take one of 24
> control flow pathways. That's not going to be compact compared to the
> shuffled array.
>
> The values 0-3 require only two bits, and so a permutation can fit into
> a byte. In 24 bytes of space, you could save all 24 permutations,
> and randomly select one, then extract the values.
>
> What are the values:
>
> 4> (mapcar (op reduce-left (op + @2 (* @1 4))) (perm '(0 1 2 3) 4))
> (27 30 39 45 54 57 75 78 99 108 114 120 135 141 147 156 177 180
> 198 201 210 216 225 228)
>
> So we still have an array, but it's immutable; we aren't having to
> shuffle it. Moreover, a single call to the PRNG gets us the permutation,
> and we are done with the array after making one access to it:
>
> static const unsigned char tab[24] = {
> 27, 30, 39, 45, 54, 57, 75, 78,
> 99, 108, 114, 120, 135, 141, 147, 156,
> 177, 180, 198, 201, 210, 216, 225, 228
> };
>
> int i;
> unsigned char perm = tab[rand() % 24]; /* get a better PRNG */
>
> /* do something with (perm >> 6) */
> /* do something with (perm >> 4) & 3 */
> /* do something with (perm >> 2) & 3 */
> /* do something with perm & 3 */
>
> /* or */
> for (int i = 0; i < 4; i++) {
> /* do something with perm & 3 */
> perm >>= 2;
> }

This is great. I was wasting my time with a LCG algorithm I found online, trying to figure out why it gives me only four permutations... Thank you very much

>
> --
> TXR Programming Language: http://nongnu.org/txr
> Cygnal: Cygwin Native Application Library: http://kylheku.com/cygnal

Am 30.11.2021 um 08:39 schrieb Oğuz:
> This is how I do it now:
>
> int a[] = { 0, 1, 2, 3 };
> shuffle(a, 4);
> for (int i = 0; i < 4; i++) {
> // do something with `a[i]'
> }
>
> where `shuffle' is a function that I copied from here: https://benpfaff.org/writings/clc/shuffle.html
>
> It works fine, but since I have only four numbers to loop over and they are consequential, putting them into an array and shuffling it feels a bit overkill. Is there an easier way to do this (without using an array, preferably)?
>

Use a proper language:

#include <iostream>
#include <random>

using namespace std;

int main()
{ mt19937_64 mt( (random_device())() );
uniform_int_distribution<unsigned> uid( 0, 3 );
for( unsigned u = 0; i != 4; ++u )
cout << uid( mt ) << endl;
}

On Tuesday, November 30, 2021 at 4:39:18 AM UTC-3, oguzism...@gmail.com wrote:
> This is how I do it now:
>
> int a[] = { 0, 1, 2, 3 };
> shuffle(a, 4);
> for (int i = 0; i < 4; i++) {
> // do something with `a[i]'
> }
>
> where `shuffle' is a function that I copied from here: https://benpfaff.org/writings/clc/shuffle.html
>
> It works fine, but since I have only four numbers to loop over and they are consequential, putting them into an array and shuffling it feels a bit overkill. Is there an easier way to do this (without using an array, preferably)?

You need to mark in some way the number you already picked. You can use
bit set to have a compact representation. The bit means the position or
index of the number used. You can have 32 or 64 etc.. How many do you need?

Then you generate number from the range you want using rand and
in case rand gives you the number you already picked you can just skip.

#include <stdlib.h>
#include <stdio.h>
#include <time.h>

int main() {
srand((unsigned)time(NULL));

const int range_min = 0;
const int range_max = 32;

unsigned int bits = 0;

for (int i = 0; i < 32;) {
unsigned int u = range_min + rand() % (range_max - range_min);
if ((bits & (1 << u)) != 0) {
//skip
}
else {
bits |= (1 << u);
printf("%u ", u);
i++;
}
}
}

it saves a little memory but it costs some cpu skipping the random numbers
at the end.

Oğuz <oguzismailuysal@gmail.com> writes:

> On Tuesday, November 30, 2021 at 11:32:54 AM UTC+3, Kaz Kylheku wrote:
>> There are 24 permutations; so for instance you could make a program that
>> uses a cascade of randomized selection statements to take one of 24
>> control flow pathways. That's not going to be compact compared to the
>> shuffled array.
>>
>> The values 0-3 require only two bits, and so a permutation can fit into
>> a byte. In 24 bytes of space, you could save all 24 permutations,
>> and randomly select one, then extract the values.
>>
>> What are the values:
>>
>> 4> (mapcar (op reduce-left (op + @2 (* @1 4))) (perm '(0 1 2 3) 4))
>> (27 30 39 45 54 57 75 78 99 108 114 120 135 141 147 156 177 180
>> 198 201 210 216 225 228)
>>
>> So we still have an array, but it's immutable; we aren't having to
>> shuffle it. Moreover, a single call to the PRNG gets us the permutation,
>> and we are done with the array after making one access to it:
>>
>> static const unsigned char tab[24] = {
>> 27, 30, 39, 45, 54, 57, 75, 78,
>> 99, 108, 114, 120, 135, 141, 147, 156,
>> 177, 180, 198, 201, 210, 216, 225, 228
>> };
>>
>> int i;
>> unsigned char perm = tab[rand() % 24]; /* get a better PRNG */
>>
>> /* do something with (perm >> 6) */
>> /* do something with (perm >> 4) & 3 */
>> /* do something with (perm >> 2) & 3 */
>> /* do something with perm & 3 */
>>
>> /* or */
>> for (int i = 0; i < 4; i++) {
>> /* do something with perm & 3 */
>> perm >>= 2;
>> }
>
> This is great. I was wasting my time with a LCG algorithm I found
> online, trying to figure out why it gives me only four
> permutations... Thank you very much

You can also permute an array based on the "index" of the permutation:

void permute_from_index(long long unsigned idx, int n, int *a)
{
long long unsigned fact = factorial(n);
for (int i = 0; i < n; i++) {
fact /= n - i;
swap(i, i + idx / fact, a);
idx = idx % fact;
}
}

No extra storage needed. Just pick a number between 0 and n!-1 and call
the function. Of course, if you've already calculated n!, you don't
need to calculate it again, but it fast for the range of n that will be
practical (n <= 20).

--
Ben.