Progresión de columnas matriciales

17

Considere la 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 nueva fila de la matriz se construye comenzando con zceros, donde zes la longitud de los dígitos positivos que estamos usando en esa fila. Los dígitos positivos se construyen comenzando 1e incrementando y agregando un dígito adicional cada vez que itera filas. Ese patrón se repite infinitamente a la derecha. Entonces, por ejemplo, la primera fila comienza 0, 1, 0, 1...mientras que la segunda fila comienza 0,0, 2,3, 0,0, 2,3.... Siguiendo el patrón, comienza la tercera fila 0,0,0, 4,5,6, 0,0,0, 4,5,6....

Dados dos enteros como entrada ny xsalida, los primeros xnúmeros (más altos ) de la ncolumna th de la matriz anterior. (Puede elegir la indexación 0 o 1 para las columnas, solo especifique cuál en su envío).

Por ejemplo, para la entrada n = 0(indexada a 0), la columna es completamente 0s, por lo que la salida sería x 0s.

Para la entrada n = 15y x = 6, la salida sería [1, 3, 4, 10, 11, 0].

Para la entrada n = 29y x = 15, la salida sería [1, 0, 6, 8, 15, 0, 0, 34, 39, 0, 0, 0, 0, 0, 120].

Para la entrada n = 99y x = 25, la salida sería [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 y reglas

  • La entrada y salida se pueden dar por cualquier método conveniente .
  • Se puede suponer que la entrada y la salida encajan en el tipo de número nativo de su idioma.
  • Un programa completo o una función son aceptables. Si es una función, puede devolver el resultado en lugar de imprimirlo.
  • Las lagunas estándar están prohibidas.
  • Este es el código de golf, por lo que se aplican todas las reglas habituales de golf, y gana el código más corto (en bytes).
code-golf matrix AdmBorkBork
fuente

Respuestas:

4

JavaScript (ES6), 45 bytes

Toma entrada en la sintaxis de curry (n)(x).

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

Pruébalo en línea!

¿Cómo?

Usamos una fórmula directa para obtener el valor de la celda en la columna n (índice 0) y la fila x (índice 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
fuente
3

R , 80 76 bytes

¡Gracias a @JayCe por señalar un error!

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

Pruébalo en línea!

Utiliza indexación basada en 1 para n. Es muy probable que exista un algoritmo de golfista, pero repes el habilitador para la solución ingenua.

Giuseppe
fuente
Se equivoca n=1ya que el resultado de la aplicación ya no es una matriz. Esta solución es costosa. Me pregunto si hay una más golfista.
JayCe
Oh sí, tienes razón. Bueno, por suerte hay uno!
Giuseppe
El bucle for, sí! Y jugaste 4 bytes en el proceso :)
JayCe
@JayCe, sí, mi pensamiento original era indexar el exterior repcon un ninterior sapply, lo que salvó un byte, pero luego recordé que los forbucles son más cortos que sapplyya que no tendría que definir una función.
Giuseppe
2

MATL , 25 18 bytes

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

Pruébalo en línea!

¡Gracias a Luis Mendo por jugar 6 bytes!

Esto es esencialmente un puerto MATL de mi respuesta 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
fuente
1

Casco , 14 bytes

↑!Tzo¢+MRN0CNN

El argumento n(primero) está indexado en 1, ¡ pruébelo en línea!

Alternativamente, podríamos usar ↑!TṠzo¢+†K0CNNpara el mismo número de bytes.

Explicación

↑!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]
ბიმო
fuente
1

Casco , 21 19 bytes

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

Toma argumentos como n(1 indexado), entonces x.
Ahorró 2 bytes gracias a BMO, pero aún no es tan corto como la respuesta de BMO.
Mi primer intento de usar Husk.
Pruébalo en línea!


fuente
1

Python 2 , 55 bytes

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

Pruébalo en línea!

Desarrollado independientemente; pero noto que esto termina siendo un puerto de la respuesta Javascript de Arnauld .

Chas Brown
fuente
1

Jalea , 11 bytes

ṖS+R¬;$)⁹ịⱮ

Pruébalo en línea!

-1 gracias a Jonathan Allan .

Argumento 1: x
Argumento 2: n + 1

Erik el Outgolfer
fuente
0ṁ;Ɗ-> ¬;$guarda un byte.
Jonathan Allan
@JonathanAllan Y sospecho que aún no es suficiente. Al menos eliminé la humillante ’R... (es decir, al menos para mí) Lo extraño es que durante los últimos días he estado pensando en la secuencia Thue-Morse (que, en Jelly, contiene ;¬$).
Erik the Outgolfer
1

05AB1E , 25 bytes

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

Pruébalo en línea!

05AB1E va con matrices como pasta de dientes y jugo de naranja, pero no es un recuento de bytes malo lo malo que es mi implementación. Incluso mi código se está riendo de mí " LO©L".

Urna de pulpo mágico
fuente
0

Carbón de leña , 19 bytes

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

Pruébalo en línea! El enlace es a la versión detallada del código. Explicación:

    ¹               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

El fragmento ＥιＬ⊞Ｏυωgenera los siguientes ienteros por el recurso de empujar un valor ficticio a una matriz cada vez que pasa a través del bucle y tomar la longitud de la matriz resultante.

Neil
fuente
0

Haskell, 67 bytes

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

Pruébalo en línea!

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
fuente