Cuando se le da una lista de valores y un número entero positivo n, su código debe generar el producto cartesiano de la lista con las nveces.

Por ejemplo, en pseudocódigo su función podría ser similar a:

for x1 in list:
    for x2 in list:
        for x3 in list:
            ...
            for xn in list:
                print x1, x2, x3, ... , xn

Ejemplo:

repeated_cart([1,2,3], 3)

1 1 1  
1 1 2  
1 1 3  
1 2 1  
1 2 2  
1 2 3  
1 3 1  
1 3 2  
1 3 3  
2 1 1  
2 1 2  
2 1 3  
2 2 1  
2 2 2  
2 2 3  
2 3 1  
2 3 2  
2 3 3  
3 1 1  
3 1 2  
3 1 3  
3 2 1  
3 2 2  
3 2 3  
3 3 1  
3 3 2  
3 3 3

Las funciones integradas (o funciones de bibliotecas importadas) que computan el producto cartesiano (o potencia) no están permitidas debido a que el código resultante es algo aburrido.

Las entradas y salidas deben delimitarse pero pueden tomarse de cualquier forma razonable.

el orden de salida no importa, pero no se permiten duplicados.

Esta es la primera vez que publico una pregunta, así que si hice algo terriblemente mal, dígamelo.

Haskell , 21 bytes

l#n=mapM(\_->l)[1..n]

Pruébalo en línea!

Lisp común , 146 bytes

(defun f(l n)(if(< n 2)(loop for x in l collect(list x))(loop for a in l nconc(loop for b in(f l(1- n))collect(cons a b)))))(princ(f(read)(read)))

Pruébalo en línea!

sin golf

(defun nloops (lst n)
  (if (< n 1)
      '(())
      (if (< n 2)
          (loop for x in lst collect (list x))
          (loop for a in lst
                nconc (loop for b in (nloops lst (1- n))
                            collect (cons a b))))))

R , 41 bytes

function(l,n)unique(t(combn(rep(l,n),n)))

Pruébalo en línea!

combndefinitivamente no es un producto cartesiano incorporado, ya que calcula todas las ncombinaciones de su entrada.

R , 40 bytes

function(l,n)expand.grid(rep(list(l),n))

Pruébalo en línea!

expand.grid Es probablemente un producto cartesiano incorporado.

Perl 6 , 16 bytes

{[X,] $^a xx$^b}

Intentalo

Expnded:

{  # bare block lambda with placeholder parameters $a and $b

  [X,]         #reduce using Cross meta op combined with comma op

    $^a xx $^b # list repeat $a, by $b times
}

K (ngn / k) , 10 bytes

{x@+!y##x}

Pruébalo en línea!

{ }es una función con argumentos xyy

#x el largo de x

y##xla duración de los tiempos xrepetidosy

!y##x todas las tuplas de longitud y superior a 0,1, ..., longitud (x) -1 como matriz transpuesta

+ transponer

x@elementos de xen esos índices

APL (Dyalog Classic) , 18 12 bytes

{⍺[↑,⍳⍵⍴≢⍺]}

Pruébalo en línea!

-6 bytes gracias a @ngn!

Perl 5 , 33 bytes

say for glob(join',',("{$_}")x<>)

Pruébalo en línea!

Python 2 , 69 58 bytes

f=lambda a,n:n and[v+[i]for v in f(a,n-1)for i in a]or[[]]

Pruébalo en línea!

Toma una lista ay un número entero n; devuelve una lista de listas.

Ruby , 53 bytes

f=->l,n{n<2?l:l.flat_map{|i|f[l,n-1].map{|j|[i,*j]}}}

Pruébalo en línea!

Enfoque recursivo, no tan corto, pero garantizado que estará libre de elementos integrados.

Es tentador usar métodos de permutación, pero esto probablemente no cuenta, y los documentos en realidad no ofrecen garantías de la corrección del orden, aunque parece funcionar en la práctica:

Ruby , 35 bytes

->l,n{[*l.repeated_permutation(n)]}

Pruébalo en línea!

Prólogo (SWI) , 72 bytes

R-1-R.
L-N-R:-O is N-1,L-O-M,findall([H|T],(member(H,L),member(T,M)),R).

Pruébalo en línea!

Raqueta, 92 bytes

(define(f l n)(if(> n 0)(apply append(map(λ(r)(map(λ(e)(cons e r))l))(f l(- n 1))))'(())))

Pruébalo en línea

Sin golf

(define (f l n)
    (if (> n 0)
        (apply append
            (map
                (λ (r)
                    (map (λ (e) (cons e r)) l)
                )
                (f l (- n 1))
            )
        )
        '(())
    )
)

Gelatina , 11 9 7 bytes

³;þẎƊ’¡

Pruébalo en línea!

Explicación

³;þẎƊ’¡
³;þẎ    **Implements** the cartesian product of a value with the input
    Ɗ   Groups those together
     ’¡ Repeat (n-1) times

Pure Bash (sin utilidades externas), 57

printf -vn %0$1d
a=${n//0/{$2\}}
eval echo ${a//\}{/\},{}

La entrada se proporciona como parámetros de línea de comandos; Primero es n, segundo es una lista separada por comas.

printf -vn %0$1d         ;# Create a string of n "0"s in the variable v
a=${n//0/{$2\}}          ;# Replace each "0" with "{a,b,...m}"
eval echo ${a//\}{/\},{} ;# Replace each "}{" with "},{" and evaluate the resulting brace expansion

Pruébalo en línea!

Java 10, 19 + 135 = 154 bytes

import java.util.*;

List<List>f(Set l,int n){var o=new Stack();if(n<1)o.add(new Stack());else for(var t:l)for(var i:f(l,n-1)){i.add(t);o.add(i);}return o;}

Pruébalo en línea

Sin golf

List<List> f(Set l, int n) {
    var o = new Stack();
    if (n < 1)
        o.add(new Stack());
    else
        for (var t : l)
            for (var i : f(l, n - 1)) {
                i.add(t);
                o.add(i);
            }
    return o;
}

Expresiones de gratitud

• puerto a Java 10 gracias a Kevin Cruijssen

Oracle SQL, 177 bytes

Cree un tipo de colección (31 bytes):

CREATE TYPE t IS TABLE OF INT;

Luego use la consulta (146 bytes):

WITH n(a,b,c)AS(SELECT a,b,t()FROM i UNION ALL SELECT a,b-1,c MULTISET UNION t(COLUMN_VALUE)FROM n,TABLE(n.a)WHERE b>=0)SELECT c FROM n WHERE b=0

Suponiendo que los parámetros de entrada están en la tabla icon columnas ay b:

CREATE TABLE i (a t,b INT) NESTED TABLE a STORE AS t_a;
INSERT INTO i VALUES ( t(1,2,3), 3 );

Violín de SQL

Resultados :

|     C |
|-------|
| 1,1,1 |
| 1,1,2 |
| 1,1,3 |
| 1,2,1 |
| 1,2,2 |
| 1,2,3 |
| 1,3,1 |
| 1,3,2 |
| 1,3,3 |
| 2,1,1 |
| 2,1,2 |
| 2,1,3 |
| 2,2,1 |
| 2,2,2 |
| 2,2,3 |
| 2,3,1 |
| 2,3,2 |
| 2,3,3 |
| 3,1,1 |
| 3,1,2 |
| 3,1,3 |
| 3,2,1 |
| 3,2,2 |
| 3,2,3 |
| 3,3,1 |
| 3,3,2 |
| 3,3,3 |

Bash , 61 bytes

N=$1
shift
IFS=,
printf echo\\t%${N}s ""|sed "s/ /{$*},/g"|sh

Pruébalo en línea! Encontré repetidamente cadenas y uniendo listas con comas sorprendentemente difíciles de hacer en bash.

Javascript (Nodo) , 75 bytes

c=(m,n,a,i)=>a.length-n?m.map((_,j)=>c(m,n,[...a,m[j]],i+1)):console.log(a)

Función recursiva que envía la lista a la consola. Donde ahay una matriz vacía y ies 0 (no estoy seguro si esto aún califica)

c([1,2,3], 3, [], 0);

Pruébalo en línea!

JavaScript (SpiderMonkey) , 52 bytes

c=>g=(n,...l)=>n?c.map(w=>g(n-1,...l,w)):print(...l)

Pruébalo en línea!

J , 17 bytes

]{~(##)#:#@]i.@^[

¿Cómo funciona?

nEnumero todos los números de dígitos en un sistema de números con base en la longitud de la lista.

            i.         - creates a list from zero to (not including)
         #@]           - the length of the list 
              @^       - to the power of
                [      - n (left argument)
   (##)                - creates a list of n times the length of the list (for the bases)
       #:              - converts all the numbers into lists of digits in the new base
]{~                    - use the digits as indices into the list

Pruébalo en línea!

CJam , 26 bytes

q~(_"m*:e_"*\'_*@\~W$~:p];

Pruébalo en línea!

Si solo CJam tuviera comandos de un carácter para el producto cartesiano y el aplanamiento.

Octava , 38 bytes

@(x,n)x(dec2base(0:n^numel(x)-1,n)-47)

Función anónima que toma un vector de fila de valores y un número entero.

Pruébalo en línea!

Pari / GP , 46 bytes

(l,n)->matrix(#l^n,n,i,j,l[i--\#l^(n-j)%#l+1])

Pruébalo en línea!