17

Considere a matriz 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
              ...

Cada nova linha da matriz é construída começando com zzeros, onde zé o comprimento dos dígitos positivos que estamos usando nessa linha. Os dígitos positivos são construídos iniciando 1e incrementando e adicionando um dígito adicional cada vez que você itera as linhas. Esse padrão é repetido infinitamente para a direita. Assim, por exemplo, a primeira linha começa 0, 1, 0, 1...enquanto a segunda linha é iniciada 0,0, 2,3, 0,0, 2,3.... Seguindo o padrão, a terceira linha é iniciada 0,0,0, 4,5,6, 0,0,0, 4,5,6....

Dado dois números inteiros como entrada ne x, imprima os primeiros (mais xaltos ) números da ncoluna th da matriz acima. (Você pode escolher a indexação 0 ou 1 para as colunas, apenas especifique qual é o seu envio.)

Por exemplo, para entrada n = 0(indexada 0), a coluna é inteiramente 0s, portanto a saída seria apenas x 0s.

Para entrada n = 15e x = 6, a saída seria [1, 3, 4, 10, 11, 0].

Para entrada n = 29e x = 15, a saída seria [1, 0, 6, 8, 15, 0, 0, 34, 39, 0, 0, 0, 0, 0, 120].

Para entrada n = 99e x = 25, a saída seria [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].

E / S e regras

A entrada e saída podem ser fornecidas por qualquer método conveniente .
Pode-se presumir que a entrada e a saída cabem no tipo de número nativo do seu idioma.
Um programa completo ou uma função são aceitáveis. Se uma função, você pode retornar a saída em vez de imprimi-la.
As brechas padrão são proibidas.
Isso é código-golfe, portanto todas as regras usuais de golfe se aplicam e o código mais curto (em bytes) vence.

code-golf matrix

— AdmBorkBork
fonte

4

JavaScript (ES6), 45 bytes

Recebe entrada na sintaxe de currying (n)(x).

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

Experimente online!

Quão?

Usamos uma fórmula direta para obter o valor da célula na coluna n (indexada 0) e na linha x (indexada 1):

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 bytes 76

Obrigado a @JayCe por apontar um bug!

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

Experimente online!

Usa indexação baseada em 1 para n. Muito provavelmente, existe um algoritmo de golfista, mas repé o facilitador da solução ingênua.

— Giuseppe
fonte

Ele erro n=1desde que o resultado do sapply não é mais uma matriz. essa correção é cara Gostaria de saber se existe uma de golfista?

— 21418 JayCe

Ah, sim, você está certo. Bem, felizmente, há um!

— Giuseppe

O loop for, sim! E você golfed 4 bytes no processo :)

— Jayce

@ JayCe sim, meu pensamento original era indexar o mais externo repcom um ndentro do sapply, o que economizava um byte, mas lembrei que os forloops são mais curtos do que sapplyjá que eu não precisaria definir uma função.

— Giuseppe

2

Python 2 , 69 bytes

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

Experimente online!

— Cajado
fonte

2

APL (Dyalog Classic) , 27 24 23 bytes

-1 graças a @FrownyFrog

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

Experimente online!

— ngn
fonte

1 mais curto {+ \ ⍵ / 2} | ⊣

— FrownyFrog

2

MATL , 25 18 bytes

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

Experimente online!

Obrigado a Luis Mendo por jogar fora 6 bytes!

Esta é essencialmente uma porta MATL da minha resposta 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 bytes

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

Experimente online!

— ngn
fonte

1

Casca , 14 bytes

↑!Tzo¢+MRN0CNN

O argumento n(primeiro) é 1 indexado, tente online!

Como alternativa, poderíamos usar ↑!TṠzo¢+†K0CNNo mesmo número de bytes.

Explicação

↑!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

Husk , 21 19 bytes

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

Recebe argumentos como n(indexado em 1), então x.
Economizou 2 bytes graças ao BMO, mas ainda não é tão curto quanto a resposta do BMO.
Minha primeira tentativa de usar o Husk.
Experimente online!

1

Haskell , 75 bytes

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

Experimente online!

— ბიმო
fonte

1

Python 2 , 55 bytes

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

Experimente online!

Desenvolvido de forma independente; mas noto que isso acaba sendo uma porta da resposta Javascript de Arnauld .

— Chas Brown
fonte

1

Perl 5 `-n` , 52 bytes

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

Experimente online!

— Xcali
fonte

1

Gelatina , 11 bytes

ṖS+R¬;$)⁹ịⱮ

Experimente online!

-1 graças a Jonathan Allan .

Argumento 1: x
Argumento 2: n + 1

— Erik, o Outgolfer
fonte

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

— Jonathan Allan

@ JonathanAllan E eu suspeito que isso ainda não seja suficiente. Pelo menos eu removi a humilhante ’R... (isto é, pelo menos para mim) O estranho é que durante os últimos dias estive pensando na sequência Thue-Morse (que, em Jelly, contém ;¬$).

— Erik the Outgolfer

1

05AB1E , 25 bytes

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

Experimente online!

05AB1E acompanha matrizes como pasta de dente e suco de laranja, mas não uma contagem de bytes ruim, considerando o quão ruim é minha implementação. Até o meu código está rindo de mim " LO©L".

— Urna de polvo mágico
fonte

0

Carvão , 19 bytes

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

Experimente online! Link é a versão detalhada do código. Explicação:

    ¹               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

O trecho de código ＥιＬ⊞Ｏυωgera os próximos inúmeros inteiros pelo expediente de enviar um valor fictício para uma matriz a cada passagem pelo loop e obter o comprimento da matriz resultante.

— Neil
fonte

0

Java 8, 65 63 60 bytes

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

né indexado em 0, xé indexado em 1, gera os números delimitados e revertidos por nova linha.

Porto da resposta JavaScript (ES6) de @ Arnauld .

Experimente online.
Um resultado bem impresso na ordem correta tem 8 6 bytes a mais: Experimente online.

— Kevin Cruijssen
fonte

0

Haskell, 67 bytes

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

Experimente 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

— nimi
fonte

Progressão das colunas da matriz

E / S e regras

JavaScript (ES6), 45 bytes

Quão?

R , 80 bytes 76

Python 2 , 69 bytes

APL (Dyalog Classic) , 27 24 23 bytes

MATL , 25 18 bytes

K (ngn / k) , 33 31 bytes

Casca , 14 bytes

Explicação

Husk , 21 19 bytes

Haskell , 75 bytes

Python 2 , 55 bytes

Perl 5 -n , 52 bytes

Gelatina , 11 bytes

05AB1E , 25 bytes

Carvão , 19 bytes

Java 8, 65 63 60 bytes

Haskell, 67 bytes

Perl 5 `-n` , 52 bytes