Given an input value \$n\$, construct an array of \$n\$ random 128 bit (unsigned) integers. The integers should be uniformly random.
Your code can use any in built random number generation function it has or you can implement your own. Clearly this challenge is harder (and more fun) in lower level languages.
Fortunately, there is a built-in RNG. Requires the RDRAND instruction.
00000000: c1e1 020f c7f0 abe2 fac3 ..........
Disassembled:
shl ecx, 2
label:
rdrand eax
stosd
loop label
ret
Outputs to a pre-allocated buffer in rdi. n is passed in ecx (arrays with 2^30 elements and more are not supported).
Try it online! (a helper function is needed because of the unusual calling convention)
ES:RDI! Common modern operating systems use a flat segment model, but x86-64 doesn't require/guarantee that. For one byte extra, you can optimize the performance of the code by generating and storing 64-bit values (RDRAND rax; STOSQ). This also allows switching from SHL ecx, 2 (which is 3 bytes) to SHL ecx, 1 (which is 2 bytes), or even ADD ecx, ecx (still 2 bytes). Unfortunately, the 64-bit version of RDRAND is 1 byte larger, as is the 64-bit version of STOS, so it's a net change of +1 byte.
\$\endgroup\$
RDRAND instruction is an optional part of the x86-64 ISA. It is supported by Intel Ivy Bridge and later. This is not an issue for Code Golf, of course, but whenever I've used it, I've preferred to call out that requirement in the title, since that's a stipulation of what environment I'm targeting with my submission.
\$\endgroup\$
rdrand is an extremely slow instruction. On most CPUs the latency is somewhere between 1000 and 10000 clock cycles, per uops.info. That's not a typo. Also, due to information leak bugs, some CPUs have updated microcode which locks the bus while rdrand executes, so that other threads stall as well.
\$\endgroup\$
ƛ₇ƛ₀℅;B
ƛ # Map...
₇ƛ ; # Map 128 to...
₀℅ # Random choice from digits of 10
B # Convert to base 10
Or if it's allowed not to complete within the lifetime of the universe, 5 bytes:
ƛ₇Eʁ℅
ƛ # Map...
₇E # 2 ** 128
ʁ # Range (0...x)
℅ # Choose a random item
It's trying to generate a 2128-item array, do you think it's gonna finish any time soon?
₇E℅ gives you a random digit from the decimal value of 2¹²⁸?
\$\endgroup\$
Saved 2 bytes thanks to @RedwolfPrograms
The helper function g builds a 128-bit integer, one bit at a time. This seems a bit long...
n=>Array(n).fill(128n).map(g=k=>k--&&BigInt(Math.random()<.5)|2n*g(k))
f(n,a)char*a;{for(n*=16;n--;)a[n]=rand();}
takes an 0 array and the number requested as input
the array I taken as *char to be manipulated byte by byte so that we set every 8bit to rand() which is RAND_MAX e.g. At least 32767 and thus guaranteed to affect every bit
numbers printed as decimal thanks to this good answer on the topic I copy-pasted-adapted
f(n,a)int*a;{for(n*=4;n--;)a[n]=rand();}
\$\endgroup\$
&'wa+0> #;\1-:9j;+1?;#*2\_$.1-:!#@_1j
Try it online! Note that the input has to have a trailing space because of a bug in the interpreter.
The part generating a random 128-bit number bit by bit is explained below:
'wa+0> #;\1-:9j;+1?;#*2\_\.@
'wa+ push loop counter, initially 129
0 push initial number 0
> if the IP is coming from the right, turn it around
#; # skips the next instruction
\ swap to the loop counter
1-: decrement it and push an additional copy
9j skip over the next 9 instructions
_ if the loop counter is 0, go right:
\. swap to the number and print it
@ terminate the execution
_ else, go right:
*2\ swap to the number and multiply by 2
? go into a random direction, if up or down is selected, ? gets executed again
; ; if right is selected, jump to the next semicolon and continue with the next iteration
> #; ;+1 if left, increment the number and go to the next iteration
Animation with 9 instead of 128 bits:
54 53 bytes: Try it online!
lambda n:map(randrange,[4**64]*n)
from random import*
69 bytes: Try it online!
lambda n:[int(os.urandom(i).encode('hex'),i)for i in[16]*n]
import os
54 bytes: Try it online!
lambda n:[*map(randbits,[128]*n)]
from secrets import*
57 56 bytes: Try it online!
lambda n:[*map(randrange,[4**64]*n)]
from random import*
70 bytes: Try it online!
lambda n:[int.from_bytes(os.urandom(i),'big')for i in[16]*n]
import os
1<<128 can also be 4**64, which saves a byte.
\$\endgroup\$
eval('uuid.uuid4().int,'*n); it works in both versions of Python as far as I can tell.
\$\endgroup\$
@(1..$n|%{(Random 1.0)*("2*"*128+1|iex)})
Explanation: 1..$n enumerates integers from 1 to $n, % is an alias to ForEach-Object, Random decimal between 0 and 1.0, multiply by 2^128 through this clever obfuscation. @() encapsulates the result in an array, save 3 bytes if a actual array isn't needed.
Original (57 bytes):
@(1..$n|%{(Get-Random -Mi 0.0 -Ma 1)*[Math]::Pow(2,128)})
$n parameter as an argument. For example: Try it online!. I also changed the power calculation, and removed the @() that is not needed in this context
\$\endgroup\$
tb digits and less stuff after Random Try it online!
\$\endgroup\$
[ [ 128 2^ random ] replicate ]
replicate Create a sequence given a number of elements and a generating quotation.128 2^ 2128random Return a uniformly random number (via Factor's default Mersenne Twister PRNG) from 0 to whatever number is on top of the data stack minus one.–1 byte thanks to Bubbler!
RandomInteger[4^64-1,#]&
I wrote this and even I can't find anything interesting to say about it
2^128 to 4^64 to save a byte.
\$\endgroup\$
=MID(CONCAT((RANDARRAY(A1*128)>0.5)*1),SEQUENCE(A1,,,128),128)
Excel doesn't handle 128 bit integers. What this returns is technically n strings of 128 random 1s and 0s, which could be interpreted as n 128 bit binary integers. If Excel did handle 128 bit integers, then answer would be =RANDARRAY(A1,,,2^128-1,1) which is 26 bytes.
Edit: -1 byte thanks to pajonk
runif(scan())*4^64%/%1
Output is an integer uniformly selected from the range 0...2^128-1.
R does not natively support 128-bit inteters, so the data type of the output is a floating-point representation (click here for a TIO link that dispays all the digits, instead of displaying in scientific notation). Note though that although 128-bit numbers can be represented using floating-point variables, rounding inaccuracies can occur when more than 53 bits are required.
If floating point output (with its associated rounding inaccuracies) isn't Ok, we can output the exact value in the form of a vector of binary digits for 35 bytes (or flattened into a string of bits for 41 bytes).
If neither floating point nor binary output are Ok, then base-R will struggle a bit, but we can still manage by constructing string of random 0-9 digits (so including leading zeros), and checking that its lexicographically smaller than "340282366920938463463374607431768211456", for a whopping 117 113 bytes:
for(i in 1:scan())show({while((a=Reduce(paste0,sample(0:9,39,T)))>"340282366920938463463374607431768211456")0;a})
n=>crypto.getRandomValues(a=new BigUint64Array(n*2)).reduce((r,v,i)=>i&1?[v<<64n|a[i^1],...r]:r,[])
This feature is introduced eailer this month by this post. And it currently requires a recent version of Firefox / Chromium Nightly build to run.
It is a sad story that words crypto, getRandomValues, BigUint64Array are too long for golfing.
const f=
n=>crypto.getRandomValues(a=new BigUint64Array(n*2)).reduce((r,v,i)=>i&1?[v<<64n|a[i^1],...r]:r,[])
{
let len = 5;
let arr = f(len);
for (let i = 0; i < arr.length; i++) {
console.log(arr[i] + '')
}
}
crypto.getRandomValues only support (U)Int(8|16|32)Array but not Big(U)Int64Array before. Try to passing BigUint64Array to crypto.getRandomValues will cause an exception before.
\$\endgroup\$
window.crypto is only available in browsers. If you are using Node.js 15+, you may need to write require('crypto').webcrypto instead of crypto.
\$\endgroup\$
LεžyoÝΩ
No TIO, since it won't finish anyway.
Explanation:
L # Push a list in the range [1, (implicit) input-integer]
ε # Map each to:
žy # Push builtin 128
o # Pop and push 2 to the power this 128
Ý # Pop and push a list in the range [0, 2^128]
Ω # Pop and push a random item from this list
# (after which the result is output implicitly)
É♣ów]
Explanation:
É # Loop the (implicit) input amount of times,
# using the following three characters as inner code-block:
♣ # Push builtin 128
ó # Pop and push 2**128
w # Pop and push a random integer in the range [0,2**128)
] # After the loop, wrap the entire stack into an array
# (after which the entire stack is output implicitly as result)
{roll ^4**64: $_}
^4**64 is the range of numbers [0, 2¹²⁸). The roll method returns randomly selected numbers from that range, in the quantity of $_, the input argument.
srfi/27, 45 bytes"
\$\endgroup\$
lambda n:eval('randint(0,4**64),'*n)
from random import*
Doesn't work for n=0.
rand, 59 bytes|n|->Vec<u128>{vec![0;n].iter().map(|_|random()).collect()}
vec![0;n] is a built-in macro that generates a Vec of length n with all values initialized to 0. While this macro does accept an expression as the first argument, unfortunately it only evaluates it once, not for each item. Otherwise everything from .iter() to the end wouldn't be needed.
I was excited when I realised Rust has native support for 128-bit integer primitives through i128 and u128, but then I realised Rust's stdlib no longer includes RNG features, meaning we need the rand crate to handle RNG. random() is from the rand crate. Specifically random() is an alias for thread_rng().gen() and generates a random value of the given, or inferred type.
Thankfully, rust's type inference is good enough that, even though we only specify u128 in the return type of the closure, it figures it out and calls random::<u128>()
Ø⁷2*X’)
A monadic link taking a single argument and returning a list of random 128-bit unsigned integers of that length.
) | For each value from 1..n
Ø⁷ | 128
2* | 2 ** that
X | Random Int from 1 to that
’ | Subtract 1
If the output can be from 1 to \$2^{128}\$ rather than 0 to \$2^{128} - 1\$, which for practical purposes is almost the same given how unlikely it is to generate the extremes, I can shave off a byte.
sub{join('',map chr rand 256,1..16*pop)=~/.{16}/sg}
Creates n random 128 bit integers. Or n strings of 16 random 8 bit chars. How to print the array elements as decimal numbers can be seen by clicking the "Try it online" link.
ÇMq2pIÑ
Ç // Create the range [0..U) where U is the input, then map each value to
Mq // a random non-negative integer smaller than
2 // 2
p // to the power of
IÑ // 64 * 2.
ri{L{2mr+}128*2bN}*
ri{8,{G*YG#(mr\m<}%:+N}*
Edit: had a better idea using the "repeat N times" operator. Saved 3 characters.
Edit 2: tried a completely new algorithm. Saved 4 characters.
Edit 3: went for the string manipulation side of things. Saved 1 character.
ＩＥＮ‽Ｘ²¦¹²⁸
Try it online! Link is to verbose version of code. Explanation:
Ｎ Input integer
Ｅ Map over implicit range
Ｘ²¦¹²⁸ 2¹²⁸
‽ Random integer (0-indexed)
Ｉ Cast to string
Implicitly print
proc R t {time {puts [expr entier(rand()*4**64)]} $t}
proc R t {time {time {append x [expr rand()>.5]} 128
puts [expr 0b$x]
unset x} $t}
import System.Random
f::Int->IO[Integer]
f n=take n.randomRs(0,4^64-1)<$>getStdGen
Note that this returns a new set of random values every run, not every call! If we call the function twice without restarting our application, we won't update getStdGen so we will get the same values again.
This can be demonstrated by running:
main = do
l <- f 1
r <- f 1
print $ l ++ r
This will print [x,y] where x==y.
For something more practical (at 135 bytes):
import System.Random
h::StdGen->[(Integer,StdGen)]
h g|(v,r)<-randomR(0,4^64-1)g=(v,r):h r
f n=pure.((,)<$>map fst<*>snd.last).take n.h
This takes a generator and returns the new one, allowing it to be used more than once per run.
f is of type f::Int->StdGen->IO([Integer],StdGen) here.
