One of the virtues of J is its conciseness; I think this is underrated in exploratory programming. Here I present some J one-liners alongside samples of other languages.

# GCD of Random Integers

Problem: pick two random integers between 1 and 1,000,000,000 and find their GCD.

This Python solution is from @MemeArcana:

>>> from random import randint
>>> from math import gcd
>>> gcd(*[randint(1, 1_000_000_000) for _ in range(2)])
1

Compare to J

+./ ?2#1000000000
1

(thanks to Randy MacDonald for a correction)

# Shuffle a 1-D Array

Python:

>>> import random
>>> random.shuffle(array)

J:

(?~@#{[)

This is characteristic of the APL family: it doesn't depend on a library but it still uses fewer characters!

This can be extended to an array of arbitrary dimension:

($ $ (?~@#{[)@,)

# Linear Regression

Python and R from Richard Dinga:

lm(y ~ x)

>>> import numpy as np
>>> from sklearn.linear_model import LinearRegression
>>> reg = LinearRegression().fit(x, y)

J:

y %. 1 ,. x

# Sample Without Replacement

To sample `x`

items from a 1-D array `y`

:

x {.?~# y

# Generate a Random Permutation and Find its Inverse

C example from the GSL manual:

#include <stdio.h>
#include <gsl/gsl_rng.h>
#include <gsl/gsl_randist.h>
#include <gsl/gsl_permutation.h>

int
main (void)
{
const size_t N = 10;
const gsl_rng_type * T;
gsl_rng * r;

gsl_permutation * p = gsl_permutation_alloc (N);
gsl_permutation * q = gsl_permutation_alloc (N);

gsl_rng_env_setup();
T = gsl_rng_default;
r = gsl_rng_alloc (T);

gsl_permutation_init (p);

gsl_ran_shuffle (r, p->data, N, sizeof(size_t));

gsl_permutation_inverse (q, p);

gsl_permutation_free (p);
gsl_permutation_free (q);
gsl_rng_free (r);

return 0;
}

In J:

/: ?~ 10