Prodotto cartesiano di un elenco con se stesso n volte

10

Quando viene fornito un elenco di valori e un numero intero positivo n, il codice dovrebbe generare il prodotto cartesiano dell'elenco con i ntempi stessi .

Ad esempio, nello pseudocodice la tua funzione potrebbe essere simile a:

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

Esempio: 

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

Le funzioni incorporate (o le funzioni delle librerie importate) che calcolano il prodotto (o la potenza) cartesiana non sono consentite a causa del codice risultante piuttosto noioso.

Ingressi e uscite dovrebbero essere delimitati ma possono essere presi in qualsiasi metodo ragionevole.

l'ordine in cui viene fornito l'output non ha importanza, ma i duplicati non sono consentiti.

Questa è la prima volta che inserisco una domanda, quindi se ho fatto qualcosa di orribilmente sbagliato, per favore dimmelo.

code-golf  math  array-manipulation  combinatorics 
— JoshM
fonte
5
Benvenuti in PPCG! Niente di terribilmente sbagliato, ma prenditi del tempo per guardare questo meta post e le risposte. Cose da evitare quando si scrivono sfide
— JayCe
4
e per seguire il punto di @JayCe, potresti (dovresti) pubblicare su The Sandbox per ottenere feedback prima di pubblicare una domanda :-)
— Giuseppe,
@Giuseppe Ok, lo farò d'ora in poi, grazie :)
— JoshM,
1
— Peter Taylor,
1
I set di
— @Jakob

Risposte:

6

Lisp comune , 146 byte

(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)))

Provalo online!

ungolfed

(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))))))
— JoshM
fonte
2
in genere ti consigliamo di attendere altri invii prima di pubblicarne uno tuo :-)
— Giuseppe
1
@Giuseppe Ok, grazie per il consiglio :)
— JoshM
1
non è necessario avere l'istruzione print nell'invio, poiché una funzione è consentita
— solo ASCII
1
quindi: 96
— ASCII
1
90
— ASCII,
6

R , 41 byte

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

Provalo online!

combnnon è sicuramente un prodotto cartesiano incorporato, poiché calcola tutte le ncombinazioni del suo input.

R , 40 byte

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

Provalo online!

expand.grid è probabilmente un prodotto cartesiano incorporato.

— Giuseppe
fonte
Sembra che l'ordine delle permutazioni nella presentazione principale sia errato.
— Kirill L.,
@KirillL. c'è un motivo particolare per cui l'ordine è importante? Ho interpretato le specifiche di output come abbastanza flessibili da consentirle in qualsiasi ordine.
— Giuseppe,
c'è il commento di OP "assicurarsi che l'output sia nell'ordine giusto", presumo che "giusto" significhi lo stesso dell'esempio.
— Kirill L.,
@KirillL. Ah. Non l'ho visto; non è nel corpo della domanda, quindi non sapevo che esistesse! Chiederò che venga messo lì per chiarimenti.
— Giuseppe,
4

Perl 6 , 16 byte

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

Provalo

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
}
— Brad Gilbert b2gills
fonte
3

K (ngn / k) , 10 byte

{x@+!y##x}

Provalo online!

{ }è una funzione con argomenti xey

#x la lunghezza di x

y##xla lunghezza dei tempi xripetutiy

!y##x tutte le tuple a lunghezza superiore a 0,1, ..., lunghezza (x) -1 come matrice trasposta

+ trasporre

x@elementi di xquegli indici

— NGN
fonte
3

APL (Dyalog Classic) , 18 12 byte

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

Provalo online!

-6 byte grazie a @ngn!

— Zaccaria
fonte
si può usare⍳ con un argomento vettore per generare indici e quindi ⍺[ ]per ottenere i valori corrispondenti
— NGN
Ho avuto un RANK ERRORmomento in cui ho provato a farlo.
— Zacharý,
— ngn,
l'unica cattura è con ⍵ = 1, in quel caso ⍳ restituisce un vettore semplice, non un vettore di vettori nidificati di lunghezza 1 come ci si aspetterebbe; è uno di quei bug che non vengono mai corretti, per motivi di retrocompatibilità
— ngn
3

Rubino , 53 byte

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

Provalo online!

Approccio ricorsivo, non così breve, ma garantito per essere privo di qualsiasi built-in.

È allettante utilizzare metodi di permutazione, ma questo probabilmente non conta, e i documenti in realtà non forniscono garanzie sulla correttezza dell'ordine, anche se sembra funzionare nella pratica:

Rubino , 35 byte

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

Provalo online!

— Kirill L.
fonte
2

Racchetta, 92 byte

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

Provalo online

Ungolfed

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

Gelatina , 11 9 7 byte

³;þẎƊ’¡

Provalo online!

Spiegazione

³;þẎƊ’¡
³;þẎ    **Implements** the cartesian product of a value with the input
    Ɗ   Groups those together
     ’¡ Repeat (n-1) times
— Zaccaria
fonte
Guarda il commento di OP: p
— Zacharý,
Il mio commento al quale l'ho sollevato è: "Sto anche supponendo che i builtin per l'intera sfida siano anch'essi non approvati", quindi ho solo pensato che andasse bene.
— Zacharý,
Bene, allora aspettiamo OP
— Zacharý
@ Zacharý scusa, la funzione di potenza cartesiana non è consentita
— JoshM,
3
Non lo so, due nidificati per loop come quello sono fondamentalmente la definizione di un prodotto cartesiano. Non sto dicendo che dovresti cambiarlo però, penso solo che vietare il built-in in questa sfida non sia chiaro.
— dylnan,
2

Pure Bash (nessuna utility esterna), 57

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

L'input viene fornito come parametro della riga di comando; 1o è n, 2o è un elenco separato da virgole.

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

Provalo online!

— Trauma digitale
fonte
2

Java 10, 19 + 135 = 154 byte

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;}

Provalo online

Ungolfed

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;
}

Ringraziamenti

  • porta a Java 10 grazie a Kevin Cruijssen
— Jakob
fonte
Se si utilizza Java 10 anziché 8, è possibile modificare Objecte Listnei cicli for-each in var-4 byte. Inoltre, si può quindi cambiare Set<List>fper List<List>fe Set o=new HashSet();per var o=new Stack();un ulteriore -1 byte. Provalo online.
— Kevin Cruijssen,
Hmm. sta lasciando fuori i tipi per lambda non più validi
— ASCII-solo
@ Solo ASCII No, sono ammessi lambda non tipizzati. Non ho potuto usare un lambda qui perché la soluzione utilizza la ricorsione.
— Jakob,
@Jakob ah, è vero> _>
— ASCII
2

Oracle SQL, 177 byte

Crea un tipo di raccolta (31 byte):

CREATE TYPE t IS TABLE OF INT;

Quindi utilizzare la query (146 byte):

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

Supponendo che i parametri di input siano nella tabella icon colonne ae b:

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

SQL Fiddle

Risultati :

|     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 |
— MT0
fonte
1

Bash , 61 byte

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

Provalo online! Ho trovato stringhe ripetute e unire liste con virgole sorprendentemente difficili da fare in bash.

— Neil
fonte
1

Javascript (nodo) , 75 byte

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

Funzione ricorsiva che invia l'elenco alla console. Dove aè un array vuoto ed iè 0 (non sono sicuro se questo è ancora valido):

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

Provalo online!

— Asleepace
fonte
1
Penso che dovresti farlo(m,n,a=[],i=0)=>
— Artyer
1

J , 17 byte

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

Come funziona?

nElenco tutti i numeri -digit in un sistema numerico con base per la lunghezza dell'elenco.

            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

Provalo online!

— Galen Ivanov
fonte
1

CJam , 26 byte

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

Provalo online!

Se solo CJam avesse un comando di carattere per il prodotto cartesiano e l'appiattimento.

— maxb
fonte
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.