17

अनंत मैट्रिक्स पर विचार करें:

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

मैट्रिक्स की प्रत्येक नई पंक्ति का निर्माण zशून्य से शुरू करके किया जाता है , जहां zउस पंक्ति में उपयोग किए जा रहे सकारात्मक अंकों की लंबाई होती है। पॉजिटिव अंक का निर्माण 1हर बार जब आप पंक्तियों को बढ़ाते हैं तो एक अतिरिक्त अंक जोड़ते हैं। यह पैटर्न दाईं ओर असीम रूप से दोहराया जाता है। इसलिए, उदाहरण के लिए, पहली पंक्ति शुरू होती है 0, 1, 0, 1...जबकि दूसरी पंक्ति शुरू होती है 0,0, 2,3, 0,0, 2,3...। पैटर्न के बाद, तीसरी पंक्ति शुरू होती है 0,0,0, 4,5,6, 0,0,0, 4,5,6...।

इनपुट के रूप में दो पूर्णांकों को देखते हुए, nऔर उपरोक्त मैट्रिक्स के वें कॉलम की xपहली (सबसे ऊपर) xसंख्याओं का उत्पादन करते हैं n। (आप कॉलम के लिए 0- या 1-इंडेक्सिंग चुन सकते हैं, बस इसे सबमिट करें जो आपके प्रस्तुतिकरण में है।)

उदाहरण के लिए, इनपुट n = 0(0-अनुक्रमित) के लिए, स्तंभ पूरी तरह से 0एस है, इसलिए आउटपुट बस होगाx 0 s होगा।

इनपुट के लिए n = 15और x = 6, आउटपुट होगा [1, 3, 4, 10, 11, 0]।

इनपुट के लिए n = 29और x = 15, आउटपुट होगा [1, 0, 6, 8, 15, 0, 0, 34, 39, 0, 0, 0, 0, 0, 120]।

इनपुट के लिए n = 99और x = 25, आउटपुट होगा [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 और नियम

इनपुट और आउटपुट द्वारा दिया जा सकता है किसी भी सुविधाजनक विधि ।
इनपुट और आउटपुट को आपकी भाषा के मूल संख्या प्रकार में फिट किया जा सकता है।
या तो एक पूर्ण कार्यक्रम या एक समारोह स्वीकार्य हैं। यदि कोई फ़ंक्शन है, तो आप इसे प्रिंट करने के बजाय आउटपुट वापस कर सकते हैं।
मानक कमियां को मना किया जाता है।
यह कोड-गोल्फ है इसलिए सभी सामान्य गोल्फिंग नियम लागू होते हैं, और सबसे छोटा कोड (बाइट्स में) जीतता है।

code-golf matrix

— AdmBorkBork
स्रोत

4

जावास्क्रिप्ट (ईएस 6), 45 बाइट्स

करी सिंटैक्स में इनपुट लेता है (n)(x)।

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

इसे ऑनलाइन आज़माएं!

कैसे?

हम स्तंभ n (0-अनुक्रमित) और पंक्ति x (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
स्रोत

3

आर , 80 76 बाइट्स

बग को इंगित करने के लिए @JayCe को धन्यवाद!

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

इसे ऑनलाइन आज़माएं!

के लिए 1-आधारित अनुक्रमण का उपयोग करता है n। बहुत संभावना है कि एक गोल्फ एल्गोरिथ्म मौजूद है, लेकिन repभोले समाधान के लिए प्रबल है ।

— ग्यूसेप
स्रोत

यह n=1अब मैट्रिक्स में नीलमणि के परिणाम के लिए त्रुटियों । यह फिक्स महंगा है मुझे आश्चर्य है कि क्या एक गोल्फ खिलाड़ी है?

— JayCe

ओह, हाँ, तुम सही हो। खैर, सौभाग्य से एक है!

— ग्यूसेप

पाश के लिए, हाँ! और आपने इस प्रक्रिया में 4 बाइट्स गायें :)

— JayCe

@JayCe हाँ, मेरा मूल विचार सबसे अंदर के repसाथ इंडेक्स करना था , जिसने एक बाइट को बचाया, लेकिन फिर मुझे याद आया कि छोरों की तुलना में कम है क्योंकि मुझे फ़ंक्शन को परिभाषित नहीं करना होगा। nsapplyforsapply

— ग्यूसेप

2

पायथन 2 , 69 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— छड़ी
स्रोत

2

APL (Dyalog Classic) , 27 24 23 बाइट्स

-1 धन्यवाद @FrownyFrog को

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

इसे ऑनलाइन आज़माएं!

— NGN
स्रोत

1 छोटा {+ \ _ ⍵ / 2} | F

— FrownyFrog

2

MATL , 25 18 बाइट्स

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

इसे ऑनलाइन आज़माएं!

6 बाइट से बाहर निकलने के लिए लुइस मेंडो का धन्यवाद!

यह अनिवार्य रूप से मेरे आर उत्तर का एक MATL पोर्ट है।

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

— ग्यूसेप
स्रोत

1

के (ngn / k) , ३३ ३१ बाइट्स

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

इसे ऑनलाइन आज़माएं!

— NGN
स्रोत

1

भूसी , 14 बाइट्स

↑!Tzo¢+MRN0CNN

बहस n (पहले) 1-अनुक्रमित है, इसे ऑनलाइन आज़माएं!

वैकल्पिक रूप से हम उपयोग कर सकते हैं ↑!TṠzo¢+†K0CNN समान संख्या में बाइट्स के लिए ।

व्याख्या

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

— ბიმო
स्रोत

1

हस्क , 21 19 बाइट्स

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

n(1-अनुक्रमित) के रूप में तर्क देता है , फिर x।
बीएमओ के लिए 2 बाइट्स की बचत की, लेकिन अभी भी बीएमओ के जवाब के रूप में कम नहीं है।
भूसी का उपयोग करने पर मेरा पहला प्रयास।
इसे ऑनलाइन आज़माएं!

1

हास्केल , 75 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— ბიმო
स्रोत

1

पायथन 2 , 55 बाइट्स

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

इसे ऑनलाइन आज़माएं!

स्वतंत्र रूप से विकसित; लेकिन मैं ध्यान देता हूं कि यह अरनल्ड के जावास्क्रिप्ट उत्तर का एक बंदरगाह है ।

— चास ब्राउन
स्रोत

1

पर्ल 5 `-n` , 52 बाइट्स

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

इसे ऑनलाइन आज़माएं!

— Xcali
स्रोत

1

जेली , 11 बाइट्स

ṖS+R¬;$)⁹ịⱮ

इसे ऑनलाइन आज़माएं!

-1 को धन्यवाद जोनाथन एलन ।

तर्क 1: x
तर्क 2: n + 1

— आउटगोल्फ को एरिक करें
स्रोत

0ṁ;Ɗ-> ¬;$एक बाइट बचाता है।

— जोनाथन एलन

@JonathanAllan और मुझे संदेह है कि यह अभी तक पर्याप्त नहीं है। कम से कम मैंने अपमानजनक को हटा दिया ’R... (जो कि कम से कम मेरे लिए है) अजीब बात यह है कि पिछले कुछ दिनों के दौरान मैं थु-मोर्स अनुक्रम के बारे में सोच रहा हूं (जो कि, जेली में शामिल है ;¬$)।

— एरिक आउटोलॉफ़र

1

05AB1E , 25 बाइट्स

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

इसे ऑनलाइन आज़माएं!

05AB1E टूथपेस्ट और संतरे के रस जैसे मैट्रीस के साथ जाता है, लेकिन एक बुरा बाइट-काउंट नहीं माना जाता है कि मेरा कार्यान्वयन कितना बुरा है। यहां तक कि मेरा कोड मुझ पर " LO©L" हंस रहा है ।

— जादू ऑक्टोपस Urn
स्रोत

0

चारकोल , 19 बाइट्स

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

इसे ऑनलाइन आज़माएं!लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

    ¹               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

टुकड़ा ＥιＬ⊞Ｏυωअगले उत्पन्न करता है iपाश के माध्यम से एक पास एक सरणी के लिए एक डमी मूल्य धक्का और जिसके परिणामस्वरूप सरणी की लंबाई लेने के समीचीन द्वारा पूर्णांकों।

— नील
स्रोत

0

जावा 8, 65 63 60 बाइट्स

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

n 0-अनुक्रमित है, x 1-अनुक्रमित है, संख्याओं को नई-पंक्तिबद्ध और उलट-पुलट कर देता है।

पोर्ट ऑफ @ अरनौलड्स जावास्क्रिप्ट (ईएस 6) उत्तर ।

इसे ऑनलाइन आज़माएं।
सही क्रम में एक सुंदर-मुद्रित परिणाम 8 6 बाइट्स लंबा है: इसे ऑनलाइन आज़माएं।

— केविन क्रूज़सेन
स्रोत

0

हास्केल, 67 बाइट्स

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

इसे ऑनलाइन आज़माएं!

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
स्रोत

मैट्रिक्स कॉलम की प्रगति

I / O और नियम

जावास्क्रिप्ट (ईएस 6), 45 बाइट्स

कैसे?

आर , 80 76 बाइट्स

पायथन 2 , 69 बाइट्स

APL (Dyalog Classic) , 27 24 23 बाइट्स

MATL , 25 18 बाइट्स

के (ngn / k) , ३३ ३१ बाइट्स

भूसी , 14 बाइट्स

व्याख्या

हस्क , 21 19 बाइट्स

हास्केल , 75 बाइट्स

पायथन 2 , 55 बाइट्स

पर्ल 5 -n , 52 बाइट्स

जेली , 11 बाइट्स

05AB1E , 25 बाइट्स

चारकोल , 19 बाइट्स

जावा 8, 65 63 60 बाइट्स

हास्केल, 67 बाइट्स

पर्ल 5 `-n` , 52 बाइट्स