Postęp kolumn macierzy

17

Rozważmy nieskończoną macierz:

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
              ...

Każdy nowy wiersz macierzy jest konstruowany od zzera, gdzie zjest liczbą cyfr dodatnich, których używamy w tym wierszu. Cyfry dodatnie są konstruowane przez rozpoczynanie 1i zwiększanie oraz dodawanie dodatkowej cyfry za każdym razem, gdy iterujesz wiersze. Ten wzór powtarza się nieskończenie w prawo. Na przykład pierwszy rząd zaczyna się, 0, 1, 0, 1...a zaczyna drugi rząd 0,0, 2,3, 0,0, 2,3.... Zgodnie ze wzorem rozpoczyna się trzeci rząd 0,0,0, 4,5,6, 0,0,0, 4,5,6....

Biorąc pod uwagę dwie liczby całkowite jako dane wejściowe ni xwyprowadzamy pierwsze (najwyższe) xliczby z nth kolumny powyższej macierzy. (Możesz wybrać indeksowanie 0 lub 1 dla kolumn, po prostu określ, które z nich.)

Na przykład dla danych wejściowych n = 0(indeksowanych 0) kolumna jest w całości 0s, więc wynik byłby po prostu x 0s.

Dla danych wejściowych n = 15i x = 6wyjściowych będzie to [1, 3, 4, 10, 11, 0].

Dla danych wejściowych n = 29i x = 15wyjściowych będzie to [1, 0, 6, 8, 15, 0, 0, 34, 39, 0, 0, 0, 0, 0, 120].

Dla danych wejściowych n = 99i x = 25wyjściowych będzie to [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 i reguły

  • Dane wejściowe i wyjściowe można podać dowolną dogodną metodą .
  • Można założyć, że dane wejściowe i wyjściowe pasują do rodzimego typu liczb w twoim języku.
  • Dopuszczalny jest pełny program lub funkcja. Jeśli funkcja, możesz zwrócić dane wyjściowe zamiast je drukować.
  • Standardowe luki są zabronione.
  • To jest więc obowiązują wszystkie zwykłe zasady gry w golfa, a wygrywa najkrótszy kod (w bajtach).
AdmBorkBork
źródło

Odpowiedzi:

4

JavaScript (ES6), 45 bajtów

Pobiera dane wejściowe w składni curry (n)(x).

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

Wypróbuj online!

W jaki sposób?

Używamy bezpośredniej formuły, aby uzyskać wartość komórki w kolumnie n (indeksowane 0) i wierszu x (indeksowane 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
źródło
3

R , 80 76 bajtów

Dzięki @JayCe za wskazanie błędu!

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

Wypróbuj online!

Używa indeksowania 1 n. Najprawdopodobniej istnieje algorytm golfiera, który jednak repumożliwia naiwne rozwiązanie.

Giuseppe
źródło
IT dla błędów n=1od wyniku sapply w żadnym dłużej matrycy. ta poprawka jest kosztowna Zastanawiam się, czy jest golfista?
JayCe
O tak, masz rację. Na szczęście jest jeden!
Giuseppe,
Pętla for, tak! I grałeś w golfa w tym czasie 4 bajty :)
JayCe
@JayCe tak, moją pierwotną myślą było zaindeksowanie tego, co zewnętrzne rep, nwewnątrz sapply, co pozwoliło zaoszczędzić bajt, ale potem przypomniałem sobie, że forpętle są krótsze niż, sapplyponieważ nie musiałbym definiować funkcji.
Giuseppe
2

MATL , 25 18 bajtów

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

Wypróbuj online!

Dzięki Luis Mendo za grę w golfa na 6 bajtów!

Jest to zasadniczo port MATL mojej odpowiedzi 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
źródło
1

Łuska , 14 bajtów

↑!Tzo¢+MRN0CNN

Argument n(pierwszy) jest indeksowany 1, spróbuj online!

Alternatywnie możemy użyć ↑!TṠzo¢+†K0CNNdla tej samej liczby bajtów.

Wyjaśnienie

↑!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]
ბიმო
źródło
1

Łuska , 21 19 bajtów

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

W takim przypadku przyjmuje argumenty jako n(indeksowane 1) x.
Zaoszczędzono 2 bajty dzięki BMO, ale wciąż nie jest tak krótki jak odpowiedź BMO.
Moja pierwsza próba użycia Łuski.
Wypróbuj online!


źródło
1

Python 2 , 55 bajtów

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

Wypróbuj online!

Opracowany niezależnie; ale zauważam, że ostatecznie jest to port odpowiedzi Javascript Arnaulda .

Chas Brown
źródło
1

Galaretka , 11 bajtów

ṖS+R¬;$)⁹ịⱮ

Wypróbuj online!

-1 dzięki Jonathanowi Allanowi .

Argument 1: x
Argument 2: n + 1

Erik the Outgolfer
źródło
0ṁ;Ɗ-> ¬;$zapisuje bajt.
Jonathan Allan
@JonathanAllan I podejrzewam, że to jeszcze nie wystarczy. Przynajmniej usunąłem upokarzające ’R... (to znaczy przynajmniej dla mnie) Dziwną rzeczą jest to, że w ciągu ostatnich kilku dni myślałem o sekwencji Thue-Morse (która w Galaretce zawiera ;¬$).
Erik the Outgolfer
1

05AB1E , 25 bajtów

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

Wypróbuj online!


05AB1E współpracuje z matrycami takimi jak pasta do zębów i sok pomarańczowy, ale nie jest to zły licznik bajtów, biorąc pod uwagę, jak złe jest moje wdrożenie. Nawet mój kod śmieje się ze mnie „ LO©L”.

Urna Magicznej Ośmiornicy
źródło
0

Węgiel drzewny , 19 bajtów

IE…·¹N§⁺Eι⁰EιL⊞Oυωη

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

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

Snippet EιL⊞Oυωgeneruje kolejne iliczby całkowite przez celowe wypychanie wartości fikcyjnej do tablicy, każda przechodzi przez pętlę i przyjmuje długość wynikowej tablicy.

Neil
źródło
0

Java 8, 65 63 60 bajtów

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

njest indeksowany 0, xjest indeksowany 1, generuje liczby rozdzielane i odwracane w nowym wierszu.

Port odpowiedzi @ Arnauld na JavaScript (ES6) .

Wypróbuj online.
Dość wydrukowany wynik w prawidłowej kolejności jest 8 6 bajtów dłuższy: Wypróbuj online.

Kevin Cruijssen
źródło
0

Haskell, 67 bajtów

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

Wypróbuj 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
źródło