17

Considera la matrice infinita:

0  1  0  1  0  1  0  1  0  1  0  1  0  1  0  1
0  0  2  3  0  0  2  3  0  0  2  3  0  0  2  3
0  0  0  4  5  6  0  0  0  4  5  6  0  0  0  4 ...
0  0  0  0  7  8  9 10  0  0  0  0  7  8  9 10
0  0  0  0  0 11 12 13 14 15  0  0  0  0  0 11
              ...

Ogni nuova riga della matrice viene costruita iniziando con zzeri, dove zè la lunghezza delle cifre positive che stiamo usando in quella riga. Le cifre positive vengono costruite iniziando con 1e incrementando e aggiungendo una cifra aggiuntiva ogni volta che si ripetono le righe. Quel modello si ripete all'infinito a destra. Quindi, ad esempio, la prima riga inizia 0, 1, 0, 1...mentre inizia la seconda riga 0,0, 2,3, 0,0, 2,3.... Seguendo il modello, inizia la terza riga 0,0,0, 4,5,6, 0,0,0, 4,5,6....

Dati due numeri interi come input ne x, in output, i primi xnumeri (più in alto) della nth colonna della matrice sopra. (Puoi scegliere 0 o 1-indicizzazione per le colonne, basta specificare quale nella tua presentazione.)

Ad esempio, per l'input n = 0(indicizzato 0), la colonna è interamente 0s, quindi l'output sarebbe solo x 0s.

Per input n = 15e x = 6, l'output sarebbe [1, 3, 4, 10, 11, 0].

Per input n = 29e x = 15, l'output sarebbe [1, 0, 6, 8, 15, 0, 0, 34, 39, 0, 0, 0, 0, 0, 120].

Per input n = 99e x = 25, l'output sarebbe [1, 3, 4, 0, 15, 0, 0, 0, 37, 55, 56, 0, 87, 93, 0, 0, 151, 163, 176, 0, 0, 0, 0, 0, 325].

I / O e regole

L'input e l'output possono essere forniti con qualsiasi metodo conveniente .
Si può presumere che l'input e l'output si adattino al tipo di numero nativo della tua lingua.
È accettabile un programma completo o una funzione. Se una funzione, è possibile restituire l'output anziché stamparlo.
Sono vietate le scappatoie standard .
Si tratta di code-golf quindi si applicano tutte le normali regole del golf e vince il codice più breve (in byte).

code-golf matrix

— AdmBorkBork
fonte

4

JavaScript (ES6), 45 byte

Accetta input nella sintassi del curry (n)(x).

n=>g=x=>x?[...g(x-1),n/x&1&&n%x+x*~-x/2+1]:[]

Provalo online!

Come?

Usiamo una formula diretta per ottenere il valore della cella nella colonna n (0-indicizzata) e nella riga x (1-indicizzata):

n / x & 1 &&     // is this cell zero or non-zero?
n % x +          // column modulo row --> increment for a non-zero value at this position
x * ~-x / 2 + 1  // minimum value of non-zero values for this row:
                 // ∑(i=1...x-1)(i) + 1 = x(x - 1) / 2 + 1

— Arnauld
fonte

3

R , 80 76 byte

Grazie a @JayCe per aver segnalato un bug!

function(n,x)for(a in 1:x)print(rep(c(rep(0,a),((y=sum(1:a))-a+1):y),,n)[n])

Provalo online!

Utilizza l'indicizzazione basata su 1 per n. Molto probabilmente esiste un algoritmo golfista ma repè il fattore abilitante per la soluzione ingenua.

— Giuseppe
fonte

Errori n=1perché il risultato di sapply non è più una matrice. questa soluzione è costosa mi chiedo se ce n'è una più golfista?

— JayCe,

Oh sì, hai ragione. Bene, per fortuna ce n'è uno!

— Giuseppe,

Il ciclo for, sì! E hai giocato a golf 4 byte nel processo :)

— JayCe

@JayCe sì, il mio pensiero originale era di indicizzare il più esterno repcon un valore ninterno sapplyche salvasse un byte, ma poi mi sono ricordato che i forloop sono più brevi rispetto a sapplyquando non avrei dovuto definire una funzione.

— Giuseppe,

2

Python 2 , 69 byte

n,x=input()
a=i=1
exec"print(([0]*i+range(a,a+i))*n)[n];a+=i;i+=1;"*x

Provalo online!

— asta
fonte

2

APL (Dyalog Classic) , 27 24 23 byte

-1 grazie a @FrownyFrog

⊢∘⍳(<×(+\⊣)--){+\⍵/2}|⊣

Provalo online!

— NGN
fonte

1 più corto {+ \ ⍵ / 2} | ⊣

— FrownyFrog

2

MATL , 25 18 byte

x:"@:t~ys:b@-)h1G)

Provalo online!

Grazie a Luis Mendo per il golf di 6 byte!

Questa è essenzialmente una porta MATL della mia risposta R.

x		 % implicit input, read n and delete
:		 % implicit input, read x and push [1..x]
"		 % for loop with i = 1..x
 @:		 % push [1..i]
   t		 % duplicate
    ~		 % logical negate, turn to array of zeros
		 % stack: [[1..i], [0 .. (i times)]]
     y		 % duplicate from below
		 % stack: [[1..i], [0 .. (i times)], [1..i]]
      s:	 % sum and range
		 % stack: [[1..i], [0 .. (i times)], [1..(i * (i + 1)/2)]]
	b	 % bubble up
		 % stack: [[0 .. (i times)], [1..(i * (i + 1)/2)], [1..i]]
	 @-	 % push i and subtract. This will be used as a modular index to get the last i elements
		 % stack: [[0 .. (i times)], [1..(i * (i + 1)/2)], [1-i..0]]
	   )	 % index into array modularly to get the last i elements
		 % stack: [[0 .. (i times)], [(i-1)*i/2 + 1, .. (i * (i + 1)/2)]]
	    h	 % horizontally concatenate the array
	     1G) % push n and index modularly, leaving the result on the stack
		 % implicit end of for loop. The stack now contains the appropriate elements in order
		 % implicit end. Print stack contents

— Giuseppe
fonte

1

K (ngn / k) , 33 31 byte

{(a>i)*(+\i)-i-a:(2*1+i:!y)!'x}

Provalo online!

— NGN
fonte

1

Buccia , 14 byte

↑!Tzo¢+MRN0CNN

L'argomento n(primo) è 1-indicizzato, provalo online!

In alternativa, potremmo utilizzare ↑!TṠzo¢+†K0CNNper lo stesso numero di byte.

Spiegazione

↑!Tz(¢+)MRN0CNN -- example inputs n=4, x=3
            C N -- cut the natural numbers: [1,2,3,4,…]
             N  -- | using the natural numbers
                -- : [[1],[2,3],[4,5,6],[7,8,9,10],…]
        M N     -- map over the naturals
         R 0    -- | replicate 0 that many times
                -- : [[0],[0,0],[0,0,0],[0,0,0,0],…]
   z(  )        -- zip these two lists
      +         -- | concatenate
     ¢          -- | cycle
                -- : [[0,1,0,1,…],[0,0,2,3,0,0,2,3,…],…]
  T             -- transpose: [[0,0,0,0,…],[1,0,0,0,…],[0,1,0,0,…],[1,3,4,0,…],…]
 !              -- index into that list using n: [1,3,4,0,…]
↑               -- take x: [1,3,4]

— ბიმო
fonte

1

Buccia , 21 19 byte

↑mȯ!⁰¢§+`R0§…ȯ→Σ←ΣN

Prende gli argomenti come n(1-indicizzati), quindi x.
Salvato 2 byte grazie a BMO, ma non è così breve come la risposta di BMO.
Il mio primo tentativo di usare Husk.
Provalo online!

1

Haskell , 75 byte

u!v=take v[cycle((0<$l)++l)!!u|n<-[1..],l<-[take n$drop(sum[1..n-1])[1..]]]

Provalo online!

— ბიმო
fonte

1

Python 2 , 55 byte

lambda n,x:[n/y%2*(n%y+y*~-y/2+1)for y in range(1,x+1)]

Provalo online!

Sviluppato in modo indipendente; ma noto che questo finisce per essere una porta della risposta Javascript di Arnauld .

— Chas Brown
fonte

1

Perl 5 `-n` , 52 byte

/ /;say+(((0)x$_,($.+=--$_)..$.+$_)x$`)[$`]for 1..$'

Provalo online!

— Xcali
fonte

1

Gelatina , 11 byte

ṖS+R¬;$)⁹ịⱮ

Provalo online!

-1 grazie a Jonathan Allan .

Argomento 1: x
Argomento 2: n + 1

— Erik the Outgolfer
fonte

0ṁ;Ɗ-> ¬;$salva un byte.

— Jonathan Allan,

@JonathanAllan E sospetto che non sia ancora abbastanza. Almeno ho rimosso l'umiliante ’R... (cioè, almeno per me) La cosa strana è che negli ultimi giorni ho pensato alla sequenza Thue-Morse (che, in Jelly, contiene ;¬$).

— Erik the Outgolfer,

1

05AB1E , 25 byte

LO©LsL£¹£¹LÅ0s)øε˜®Ì∍}ø¹è

Provalo online!

05AB1E si accompagna a matrici come dentifricio e succo d'arancia, ma non un cattivo conteggio dei byte considerato quanto sia cattiva la mia implementazione. Anche il mio codice mi sta ridendo " LO©L".

— Urna di polpo magico
fonte

0

Carbone , 19 byte

ＩＥ…·¹Ｎ§⁺Ｅι⁰ＥιＬ⊞Ｏυωη

Provalo online! Il collegamento è alla versione dettagliata del codice. Spiegazione:

    ¹               Literal 1
     Ｎ              First input (`x`) as a number
  …·                Inclusive range
 Ｅ                  Map (value `i`, 0-indexed counter `k`)
         ι          Current value
        Ｅ           Map over implicit range
          ⁰         Literal 0 (i.e. create array of `i` zeros)
            ι       Current value
           Ｅ        Map over implicit range
                 ω  Arbitrary variable
                υ   Predefined array
              ⊞Ｏ    Push
             Ｌ      Length
       ⁺            Concatenate arrays
      §           η Index by second input (`n`)
Ｉ                   Cast to string and implicitly print on separate lines

Lo snippet ＥιＬ⊞Ｏυωgenera i inumeri interi successivi con l'espediente di spingere un valore fittizio in un array ogni passaggio attraverso il ciclo e prendendo la lunghezza dell'array risultante.

— Neil
fonte

0

Java 8, 65 63 60 byte

n->x->{for(;x>0;)System.out.println(n/x%2*(n%x+x*--x/2+1));}

nè 0-indicizzato, x1-indicizzato, genera i numeri delimitati da nuova riga e invertiti.

Port of @ Arnauld's JavaScript (ES6) answer .

Provalo online.
Un risultato piuttosto stampato nell'ordine corretto è più lungo di 8 6 byte: provalo online.

— Kevin Cruijssen
fonte

0

Haskell, 67 byte

i#l=cycle((++)=<<(0<$)$[i..l-1]):l#(l+l-i+1)
n!x=take x$(!!n)<$>1#2

Provalo online!

i#l                  -- function # builds the infinite matrix
                     -- input: i and l are lowest and highest+1 non-zero number of
                     -- the current line
   = cycle           -- for the current line, repeat infinitely
           [i..l-1]  --   the non-zero numbers of the line appended 
     (++)=<<(0<$)    --   to a list of 0s with the same length
   :                 -- append next row of the matrix
     l#(l+l-i+1)     --   which is a recursive call with i and l adjusted

n!x =                -- main function
              1#2    -- create matrix
      (!!n)<$>       -- pick nth element of each row
  take x             -- take the first x numbers thereof

— Nome del modello
fonte

Progressione delle colonne di matrice

I / O e regole

JavaScript (ES6), 45 byte

Come?

R , 80 76 byte

Python 2 , 69 byte

APL (Dyalog Classic) , 27 24 23 byte

MATL , 25 18 byte

K (ngn / k) , 33 31 byte

Buccia , 14 byte

Spiegazione

Buccia , 21 19 byte

Haskell , 75 byte

Python 2 , 55 byte

Perl 5 -n , 52 byte

Gelatina , 11 byte

05AB1E , 25 byte

Carbone , 19 byte

Java 8, 65 63 60 byte

Haskell, 67 byte

Perl 5 `-n` , 52 byte