• Python

random.choice(x)

• Python

if x: z = choice(x)

• Ada

subtype Element_Type is Integer;
type List_Type is array (Positive range <>) of Element_Type;

function Pick_Random (X : List_Type) return Element_Type is
   subtype Index_Range  is Positive range X'Range;
   package Random_Index is new
     Ada.Numerics.Discrete_Random (Index_Range);
   Generator : Random_Index.Generator;
begin
   Random_Index.Reset (Generator);
   return X (Random_Index.Random (Generator));
end Pick_Random;

• C

x[rand() % x_length];

• Clojure

(rand-nth x)

• C++

std::ranges::sample(x, &result, 1, std::mt19937{std::random_device{}()});

• C++

std::mt19937 gen;
std::uniform_int_distribution<size_t> uid (0, x.size () - 1);
x[uid (gen)];

• C#

x[Random.Shared.Next(x.Count)]

• C#

x[new Random().Next(x.Count)]

• D

x.randomSample(1);

• Dart

x[new Random().nextInt(x.length)];

• Elixir

Enum.random(x)

• Erlang

ktn_random:pick(X)

• Erlang

lists:nth(rand:uniform(length(X)), X).

• Fortran

call random_number (a)
x(lbound(x) + int(a*ubound(x))

• Go

func pickT(x []T) T {
	return x[rand.Intn(len(x))]
}

• Go

x[rand.Intn(len(x))]

• Go

func pick[T any](x []T) T {
	return x[rand.Intn(len(x))]
}

• Groovy

x.shuffled().first()

• Haskell

(\l g -> l !! fst (randomR (0, length l) g))

• Haskell

(l !!) <$> randomRIO (0, length l - 1)

• JS

x[~~(Math.random() * x.length)];

• JS

x[Math.floor(Math.random() * x.length)]

• Java

x.get(ThreadLocalRandom.current().nextInt(0, x.size()))

• Java

x.get((int)(Math.random()*x.size()))

• Java

if (!x.isEmpty()) {
    Random r = new Random();
    T t = x.get(r.nextInt(x.size()));
}

• Kotlin

list.random()

• Lisp

(nth (random (length x)) x)

• Lua

x[math.random(#x)]

• Obj-C

x[arc4random_uniform(x.count)]

• PHP

$x[ array_rand($x) ]

• Pascal

element := x.Items[random(x.count)];

• Pascal

element := x[random(length(x))];

• Perl

my @x = ('a', 'list', 'of', 'random', 'items');
print $x[rand @x];

• Ruby

x.sample

• Rust

let mut rng = rand::thread_rng();
let choice = x.choose(&mut rng).unwrap();

• Rust

x[rand::thread_rng().gen_range(0..x.len())]

• Scala

val x = List(1, 2, 3, 4)
x.apply(Random.nextInt(x.size))

• Scheme

(list-ref x (random (length x)))

• Smalltalk

x atRandom

• VB

x(Random.Shared.Next(x.Count))

• VB

x(New Random().Next(x.Count))