Scrivere un programma, dato un input n , genererà tutte le possibili n-tuple usando numeri naturali.

n=1
(1),(2),(3),(4),(5),(6)...

n=2
(1,1),(1,2),(2,1),(2,2),(1,3),(3,1),(2,3),(3,2),(3,3)...

n=6
(1,1,1,1,1,1) (1,1,1,1,2,1) (1,1,1,2,1,1)... 

• L'output può essere in qualsiasi ordine che non infrange altre regole.
• Il programma deve essere scritto per funzionare per sempre ed elencare tutte le tuple applicabili esattamente una volta, in teoria.
  • In realtà, il tuo programma raggiungerà il limite e il crash del tuo tipo intero. Questo è accettabile purché il programma sarebbe eseguire infinitamente lungo se solo il tipo integer era illimitata.
  • Ogni tupla valida deve essere elencata entro un tempo finito, se solo il programma fosse autorizzato a funzionare così a lungo.
• L'output può, a tua discrezione, includere zeri oltre ai numeri naturali.
• Puoi scegliere il formato di output del tuo programma per tua comodità, purché la separazione tra tuple e numeri all'interno di ciascuna tupla sia chiara e coerente. (Ad esempio, una tupla per riga.)
• L'input (n) è un numero intero compreso tra uno e sei. Il comportamento richiesto non è definito per gli input al di fuori di questo intervallo.
• Si applicano le regole del code-golf, vince il programma più breve.

Grazie a "Artemis Fowl" per il feedback durante la fase sandbox.

Buccia , 2 byte

πN

Provalo online!

Spiegazione

Nè l'elenco infinito di numeri naturali [1,2,3,4,... πè il potere cartesiano. Il risultato è un elenco infinito di elenchi. Ogni elenco della lunghezza desiderata si presenta esattamente una volta perché πè bello così. Input e output sono impliciti.

Haskell , 62 byte

([1..]>>=).(!)
0!s=[[]|s<1]
n!s=[a:p|a<-[1..s],p<-(n-1)!(s-a)]

Provalo online!

n!sgenera tutte le n-tuple che sommano s.

Quindi la risposta è ([1..]>>=).(!), cioè \n -> [t | s<-[1..], t<-n!s].

Questa è una funzione che associa un numero intero na un elenco infinito di tuple (elenchi di numeri interi).

Haskell , 50 byte

f n=[l|k<-[0..],l<-mapM([0..k]<$f)[0..n],sum l==k]

Provalo online!

Elenchi n-tuple ordinati per somma. mapMfa il sollevamento pesante per generare tutte le ntuple di numeri da 0 a k. Il <$ftrucco è spiegato qui .

Haskell , 51 byte

f 1=pure<$>[0..]
f n=[a-k:k:t|a:t<-f$n-1,k<-[0..a]]

Provalo online!

n-1Allunga ricorsivamente tutte le tuple in tutte le ntuple dividendo il primo numero adi ciascuna n-1tupla in due numeri a-k,kche lo sommano, in ogni modo possibile.

Pyth - 9 byte

Grazie a @FryAmTheEggman per il golf

Passa attraverso tutte le x e prende [1..x] ^ n. Questo crea duplicati, quindi conserva solo quelli che sono nuovi a quella x, ovvero contiene x in essi. La formattazione è un po 'strana, ma può essere resa standard con un altro byte,.V1j}#b^Sb

.V1}#b^Sb

Provalo online .

Brachylog (v2), 9 byte

~l.ℕᵐ+≜∧≜

Provalo online!

Questo è un generatore infinito che genera tutte le possibili tuple. Il collegamento TIO ha un'intestazione che utilizza il generatore per generare 1000 elementi e li stampa (ma il generatore potrebbe continuare indefinitamente se glielo chiedessi; gli interi di Brachylog sono illimitati).

Sembra che ci dovrebbe essere un modo più semplice, ma ci sono molti vincoli e questo è il più semplice che posso inserirli in un singolo programma.

Spiegazione

~l.ℕᵐ+≜∧≜
  .        Generate
        ≜  all explicit
~l         lists whose length is {the input}
    ᵐ      for which every element
   ℕ       is non-negative
     +     and whose sum
      ≜    is used to order the lists (closest to zero first)
       ∧   [remove unwanted implicit constraint]

Per inciso, mi sembra interessante quanto siano diverse le mie spiegazioni dei due ≜, nonostante facciano esattamente la stessa cosa dal punto di vista di Brachylog. Il primo ≜è il primo predicato non deterministico nel programma, quindi imposta l'ordine dei risultati; in questo caso, calcola tutti i possibili valori espliciti per la somma dell'elenco nell'ordine 0, 1, 2, 3 ... e viene utilizzato per garantire che gli elenchi vengano emessi nell'ordine della loro somma (ciò garantisce che ogni possibile l'elenco appare dopo una quantità finita di output). Il secondo ≜è usato per calcolare tutte le possibilità esplicite per l'elenco (piuttosto che emettere una formula che specifica come gli elementi dell'elenco si relazionano tra loro).

Perl 6 , 37 byte

{$++.polymod(1+$++ xx $_-1).say xx *}

Provalo online!

Funziona essenzialmente polymodcon tutte le voci necessarie, in cui il modulo è sempre maggiore dell'input, ovvero 0.polymod (1,1,1), 1.polymod (2,2,2) ecc. In questo modo la cifra è sempre all'interno la gamma. Perl6 non mi lascia modulo infinito ...

Wolfram Language (Mathematica) , 62 byte

Do[Print/@Permutations@#&/@n~IntegerPartitions~{#},{n,#,∞}]&

Provalo online!

-3 byte con separazione incoerente (elimina @#&)

Provalo online!

C # (compilatore interattivo Visual C #) , 148 byte

n=>{var a=new int[n];int j=0;void g(int k){if(k<n)for(int i=0;i++<j;g(k+1))a[k]=i;else if(a.Sum()==j)WriteLine(string.Join(' ',a));}for(;;j++)g(0);}

Provalo online!

-3 byte grazie a @ASCIIOnly!

// n: size of tuples to generate
n=>{
  // a: current tuple workspace
  var a=new int[n];
  // j: target sum value
  int j=0;
  // recursive function that works on slot k
  void g(int k){

    // tuple is not fully generated,
    if(k<n)

      // try all values from (0,j]
      for(int i=0;i++<j;
        // recursive call - generates all
        // values from (0,j] in the next slot
        g(k+1)
      )
        // update the kth slot
        a[k]=i;

    // tuple is fully generated, however
    // we should only display if the sum
    // is equal to the target sum. tuples
    // are generated many times, this
    // let's us enforce that they are only
    // displayed once.
    else if(a.Sum()==j)
      WriteLine(string.Join(' ',a));
  }
  // increment the high value forever
  // while continually starting the
  // recursive function at slot 0
  for(;;j++)
    g(0);
}

Gelatina , 10 (9?) Byte

^{9 se potessimo produrre usando una separazione non coerente (di cui ho chiesto informazioni) - rimozione del file €.}

‘ɼṗ³ċƇ®Ṅ€ß

Provalo online!

Come?

‘ɼṗ³ċƇ®Ṅ€ß - Main Link: some argument, x (initially equal to n, but unused)
 ɼ         - recall v from the register (initially 0), then set register to, and yield, f(v)
‘          -   f = increment
           - (i.e. v=v+1)
   ³       - program's third command line argument (1st program argument) = n
  ṗ        - (implicit range of [1..v]) Cartesian power (n)
           - (i.e. all tuples of length n with items in [1..v])
     Ƈ     - filter keep those for which:
    ċ      -   count
      ®    -   recall from register
           - (i.e. keep only those containing v)
       Ṅ€  - print €ach
         ß - call this Link with the same arity
           - (i.e. call Main(theFilteredList), again the argument is not actually used)

05AB1E , 15 11 byte

[¼¾LIãvy¾å—

-4 byte con la creazione di un porto di @Maltysen Pyth risposta s' .

Provalo online.

Spiegazione:

[             # Start an infinite loop:
 ¼            #  Increase the counter_variable by 1 (0 by default)
  ¾L          #  Create a list in the range [1, counter_variable]
    Iã        #  Take the cartesian power of this list with the input
      v       #  Loop over each list `y` in this list of lists:
       y¾å    #   If list `y` contains the counter_variable:
          —   #    Print list `y` with trailing newline

MATL , 16 byte

`@:GZ^t!Xs@=Y)DT

Le tuple sono ordinate aumentando la somma e all'interno di una data somma sono ordinate lessicograficamente.

Provalo online!

Python 2 , 126 112 106 101 101 100 83 byte

n=input()
i=1
while 1:
 b=map(len,bin(i)[3:].split('0'));i+=1
 if len(b)==n:print b

Provalo online!

5 byte thx a mypetlion ; 1 byte dall'occhio d'aquila di ArBo ; 17 byte da xnor !

Costruire le partizioni ordinate di min nbidoni, per m = 0,1,2,3,...selezionando i numeri binari con n-1 0s e m 1s.

C # (.NET Core) , 608 570 567 byte

using C=System.Console;using L=System.Collections.Generic.List<int[]>;class A{static void Main(){L x=new L(),y=new L(),z=new L();int i=int.Parse(C.ReadLine()),j=0,k,l,m;x.Add(new int[i]);while(i>0){j++;for(m=0;m++<i;){foreach(var a in y)x.Add(a);y=new L();foreach(var a in x){for(k=0;k<i;){int[] t=new int[i];System.Array.Copy(a,t,i);t[k++]=j;var b=true;z.AddRange(x);z.AddRange(y);foreach(var c in z){for(l=0;l<i;l++)if(c[l]!=t[l])break;if(l==i)b=false;}if(b)y.Add(t);}}}}for(k=0;k<x.Count;k++){C.Write("[ ");for(l=0;l<i;l++)C.Write(x[k][l]+" ");C.WriteLine("]");}}}

Provalo online!

mio dio cosa ho fatto (così tanti loop, è quello che ho fatto)

Dovrebbe funzionare, però!

Se si sposta il ciclo di stampa indietro di una parentesi, verrà visualizzato l'elenco man mano che viene creato, ogni volta che viene eseguito il ciclo. (Ti consiglio di aggiungere una nuova riga o qualcosa per distinguere ogni ciclo, se lo fai.)

Onestamente, ho trascorso molto del mio tempo a combattere con la lingua ... senza matrici piuttosto carine, comportamenti assortiti == ...

Speriamo che questa versione sia più facile da leggere.

using C=System.Console;
using L=System.Collections.Generic.List<int[]>;
class A{
    static void Main(){
        L x=new L(),y=new L(),z=new L();
        int i=int.Parse(C.ReadLine()),j=0,k,l,m;
        x.Add(new int[i]);
        while(i>0){
            j++;
            for(m=0;m++<i;){
                foreach(var a in y) x.Add(a);
                y=new L();
                foreach(var a in x){
                    for(k=0;k<i;){
                        int[] t=new int[i];
                        System.Array.Copy(a,t,i);
                        t[k++]=j;
                        var b=true;
                        z.AddRange(x);
                        z.AddRange(y);
                        foreach(var c in z){
                            for(l=0;l<i;l++) if(c[l]!=t[l])break;
                            if(l==i)b=false;
                        }
                        if(b)y.Add(t);
                    }
                }
            }
        }
        for(k=0;k<x.Count;k++){
            C.Write("[ ");
            for(l=0;l<i;l++)C.Write(x[k][l]+" ");
            C.WriteLine("]");
        }
    }
}

Perl 6 , 50 byte

{grep $_,{S/.//.split(0)>>.chars}($++.base(2))xx*}

Provalo online!

Blocco di codice anonimo che restituisce un elenco infinito pigro. Questo utilizza la stessa strategia della risposta di Chas Brown .

Spiegazione:

{grep $_,{S/.//.split(0)>>.chars}($++.base(2))xx*}
{                                                } # Anonymous code block
                                              xx*  # Repeat indefinitely
                                 ($++        )     # From the current index
                                     .base(2)      # Get the binary form
         {S/.//                 }   # Remove the first digit
               .split(0)            # And split by zeroes
                        >>.chars    # And get the length of each section
 grep   ,   # From this infinite list, filter:
      $_      # The groups with length the same as the input

VDM-SL , 51 byte

g(i)==if i=0then{}else{[x]^y|x:nat,y in set g(i-1)}

Comprensione ricorsiva dell'insieme con concatenazione di sequenze.

Non su TIO, potresti eseguire un programma (se attivi i limiti per il tipo nat o non terminerà):

functions 
g:nat->set of ?
g(i)==if i=0then{}else{[x]^y|x:nat,y in set g(i-1)}

Include gli 0 opzionali in risposta altrimenti sarebbe 52 byte vincolanti su nat1

Wolfram Language (Mathematica) , 131 byte

While[0<1,If[a~FreeQ~#,Print@#]&/@(b=Table[Select[Range@t~Tuples~{s},Tr@#==k&],{k,t,t(s=#)}]~Flatten~1);a={a}~Join~b;t++]&
t=1
a={}

Provalo online!

perl -M5,010 122 byte

$n=shift;
$s.="for\$x$_(1..\$m){"for 1..$n;
$t.="\$x$_ "for 1..$n;
$u.='}'x$n;
eval"{\$m++;$s\$_=qq' $t';/ \$m /&&say$u;redo}"

Aggiunte alcune nuove righe per motivi di leggibilità (non conteggiate nel conteggio dei byte)

Python 2 , 120 byte

from random import*
m=n=input()
a=()
while 1:
 m+=len(a)==m**n;t=[randint(1,m)for _ in[1]*n]
 if(t in a)<1:a+=t,;print t

Provalo online!

Un po 'più lungo della maggior parte delle altre risposte, ma mi è piaciuta l'idea alla base.

Stax , 6 byte

£ƒ$↔┬ï

Esegui ed esegui il debug

Per input nla procedura è approssimativamente

for i in [0..infinity]:
    get all the distinct n length arrays of positive integers that sum to i
    for each
        join with spaces
        implicitly output

JavaScript (V8) , 98 byte

n=>{for(a=[],b=[j=1];;b.push(++j))(g=k=>k<n?b.map(i=>(a[k]=i)|g(k+1)):a.includes(j)&&print(a))(0)}

Provalo online!

Evviva! Finalmente ottenuto sotto 100 :) Fondamentalmente una porta della mia risposta C # .

// n: length of tuples to generate
n=>{
  // a: workspace for current tuple
  // b: range of numbers that grows
  //     - iteration 1: [1]
  //     - iteration 2: [1,2]
  //     - iteration 3: [1,2,3]
  // j: largest number in b
  for(a=[],b=[j=1];;b.push(++j))
    // g: recursive function to build tuples
    // k: index of slot for current recursive call
    (g=k=>
       // current slot less than the tuple size? 
       k<n?
         // tuple generation not complete
         // try all values in current slot and
         // recurse to the next slot
         b.map(i=>(a[k]=i)|g(k+1)):
         // tuple generation complete
         // print tuple if it contains the
         // current high value
         a.includes(j)&&print(a)
    // start recursive function at slot 0
    )(0)
}