रेंज में मैट्रिक्स

18

चुनौती

एक पूर्णांक को देखते हुए n>0उत्पादन एक n+1 X n+1मैट्रिक्स से सभी पूर्णांकों युक्त 1करने के लिए 2nके रूप में परीक्षण मामलों में दिखाया गया bellow

परीक्षण के मामलों

n=1  

1  2  
2  2

n=2

1   2   4  
2   3   4  
4   4   4

n=5  

1   2   3   4   5   10  
2   3   4   5   6   10  
3   4   5   6   7   10   
4   5   6   7   8   10  
5   6   7   8   9   10  
10  10  10  10  10  10  

n=10  

1   2   3   4   5   6   7   8   9   10  20  
2   3   4   5   6   7   8   9   10  11  20  
3   4   5   6   7   8   9   10  11  12  20  
4   5   6   7   8   9   10  11  12  13  20  
5   6   7   8   9   10  11  12  13  14  20  
6   7   8   9   10  11  12  13  14  15  20  
7   8   9   10  11  12  13  14  15  16  20  
8   9   10  11  12  13  14  15  16  17  20  
9   10  11  12  13  14  15  16  17  18  20  
10  11  12  13  14  15  16  17  18  19  20  
20  20  20  20  20  20  20  20  20  20  20

मुझे लगता है कि पैटर्न बहुत आसान है, तो चलिए देखते हैं कि बाइट्स में सबसे छोटा जवाब कौन देगा।
यह कोड-गोल्फ है

नियम

इनपुट पूर्णांक होना चाहिए ( 1-अनुक्रमित )

आउटपुट एक मैट्रिक्स हो सकता है (जैसा कि परीक्षण मामलों में दिखाया गया है) या सूचियों की सूची

code-golf  array-manipulation  matrix 

जवाबों:

10

आर , 53 बाइट्स

function(n)rbind(cbind(outer(1:n,1:n,`+`)-1,2*n),2*n)

का उपयोग करता है outerरेंज के सभी रकम उत्पन्न करने के लिए "उत्पाद" 1,...,nएक मैट्रिक्स, घटाता के रूप में 1, प्रत्येक से तो bindहै 2*nसही पर एक कॉलम और तल पर एक पंक्ति के रूप में, जरूरत के रूप में रीसाइक्लिंग, और रिटर्न परिणाम के रूप में एक मैट्रिक्स।

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

आर , 78 बाइट्स

अधिक भोली कार्यान्वयन।

function(n){m=matrix(2*n,n+1,n+1)
for(i in seq(n))m[1:n,i]=(0:(2*n))[1:n+i]
m}

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

— ग्यूसेप
स्रोत
+1 अच्छा, मैं बाहरी के बारे में सोच रहा था, लेकिन वहाँ नहीं मिला
— मिकी
7

गणितज्ञ, ६१ ४६ बाइट्स

ArrayFlatten@{{##-1&~Array~{#,#},2#},{2#,2#}}&

thanx @alephalpha -15 बाइट्स के लिए

— J42161217
स्रोत
ArrayFlatten@{{Array[+##-1&,{#,#}],2#},{2#,2#}}&
— alephalpha
+##-1&बस हो सकता है ##-1&और आप infix का उपयोग कर सकते हैं Array:ArrayFlatten@{{##-1&~Array~{#,#},2#},{2#,2#}}&
— ngenisis
4

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

+þḶ;€Ḥ;ḤzḤG

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

— लीक नन
स्रोत
सिर्फ बाइट के लिए बाइट पोस्ट करने के बारे में था, Gजो आवश्यकताओं के लिए बहुत ही शानदार है
— जोनाथन एलन
बाहरी उत्पाद का अच्छा उपयोग
— Zacharý
@JonathanAllan एक अन्य समाधान का उपयोग करता है ;€ḤZ;€Ḥ...
— लीक नून
... और अभी तक एक और है Ḷ;Ḥ©µ+þ‘«®, पी
— जोनाथन एलन
1
@ +€Ḷ;Ḥṁ€;€Ḥ
— जोनाथनअल्लन
4

जावा 8, 99 बाइट्स

से लैम्ब्डा Integerके लिए int[][](उदाहरण के लिए Function<Integer, int[][]>)। आश्चर्यजनक रूप से गोल्फ के लिए प्रतिरोधी।

n->{int p=n+1,o[][]=new int[p][p],i=0,r,c;while(i<p*p)o[r=i/p][c=i++%p]=r<n&c<n?r-~c:2*n;return o;}

यह ऑनलाइन की कोशिश करो

अघोषित लंबोदर

n -> {
    int
        p = n + 1,
        o[][] = new int[p][p],
        i = 0,
        r, c
    ;
    while (i < p * p)
        o[r = i / p][c = i++ % p] =
            r < n & c < n ?
                r - ~c
                : 2 * n
        ;
    return o;
}

स्वीकृतियाँ

  • केविन क्रूज़सेन के लिए धन्यवाद
— जेकब
स्रोत
आप एक बाइट को गोल्फ में शुरू i=0और डालकर कर सकते ++हैं [c=i++%p]।
— केविन क्रूज़सेन
3

पायथन 2 , 64 62 61 बाइट्स

-3 बाइट्स मिस्टर एक्सकोडर की बदौलत।

lambda n:[range(i+1,i-~n)+[n*2]for i in range(n)]+[[n*2]*-~n]

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

मैं शायद एक महत्वपूर्ण पैटर्न याद कर रहा हूँ।

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

lambda n:[[[n*2,i-~j][n-i and n-j>0]for j in range(n+1)]for i in range(n+1)]

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

— totallyhuman
स्रोत
1
हमेशा की तरह, *(n+1)है *-~n।
— मिस्टर एक्सकोडर
1
— ऑबफैक्शन
यदि आप पायथन 3 संस्करण को भी अपनाना चाहते हैं, तो सबसे कम मैं 64 बाइट्स प्राप्त कर सकता हूं
— श्री एक्सकोडर
76 बाइट्स संस्करण को 72 बाइट्स
— Halvard Wil
2

आर , 54 63 67 बाइट्स

function(n)cbind(rbind(sapply(1:n-1,'+',1:n),2*n),2*n)

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

सैप्ली और 9 बाइट्स के लिए पॉइंटर के लिए @Guiseppe का धन्यवाद

— MickyT
स्रोत
वास्तव में, इस दृष्टिकोण में भी सुधार किया जा सकता है: sapply(1:n-1,'+',1:n)लेकिन फिर यह एक मात्र 1 बाइट का उपयोग करने से अधिक है outer(उद्धरण स्पष्ट रूप से बैकटिक्स हैं)
— Giuseppe
1
\` backticks @Giuseppe द्वारा सीमांकित ब्लॉक कोड में बैकटिक्स से बचने के लिए कार्य करता है
— Cyoce
2

रिकर्सिवा , 50 बाइट्स

  • केवल 10 बाइट्स अजगर से छोटी होती हैं और इस तरह यह आधिकारिक है, रिकर्सिवा गोल्फिंग-लैंग्वेज बिल्कुल भी नहीं है ... हालांकि यह एक इसोलंग है। : डी
|{Ba+++++'PJ"	"W+Z~}B+~}'Va'+}'Va'AD'VaJ"	"W*;aADa

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

— officialaimm
स्रोत
1

रोड़ा , 44 बाइट्स

f n{seq 1,n|[[seq(_,_1+n-1)]+2*n];[[2*n]*n]}

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

स्पष्टीकरण:

f n{seq 1,n|[[seq(_,_1+n-1)]+2*n];[[2*n]*n]}
f n{                                       } /* Function f(n)         */
    seq 1,n                                  /* Sequence 1..n         */
           |                                 /* For each _1:          */
              seq(_,_1+n-1)                  /*   Sequence _1.._1+n-1 */
             [             ]                 /*   As list             */
                            +2*n             /*   Append 2*n          */
            [                   ]            /*   Push to the stream  */
                                   [2*n]     /* List [2*n]            */
                                        *n   /* Multiplied by n       */
                                  [       ]  /* Push to the stream    */
— fergusq
स्रोत
1

> <>, 84 + 2 बाइट्स

+2 -v ध्वज के लिए

मूल्यों के बीच टैब के साथ प्रिंट, और पंक्तियों के बीच नई रूपरेखा। अंतिम पंक्ति पर एक अनुगामी टैब प्रिंट करता है।

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

1:r:&r&)?\0:r:&r&(?\~$:@2*nao1+!
a0./:r:0~<.17+1o9\ \$:@$:@+n9o1+
   \&r&)?;$:@2*n /

पूर्व गोल्फ

1>:r:&r&)?\0>    :r:&r&(?\~$:@2*nao1+\
            \+1o9n+@:$@:$/
 \                                   /
          \~0>:r:&r&)?;$:@2*n9o1+\
             \                   /
— साशा
स्रोत
0

Clojure, 153 135 बाइट्स

सूचियों की सूची? याय, लिस्प

(fn[n](loop[r[] i 0 d (* 2 n)](if(= i n)(conj r(conj(repeat n d)d))(recur(conj r(conj(vec(map #(+ i %)(range 1(inc n))))d))(inc i)d))))

Ungolfed:

(defn a[n]
  (loop [r[] i 0 d (* 2 n)]
    (if(= i n)
      (conj r(conj(repeat n d)d))
      (recur
        (conj r
            (conj (vec (map #(+ i %)(range 1(inc n)))) d))
        (inc i)
        d))))

अनाम फ़ंक्शन जो इनपुट को तर्क के रूप में लेता है और सूचियों की एक सूची देता है।

N = 5 का आउटपुट:

[[1 2 3 4 5 10] [2 3 4 5 6 10] [3 4 5 6 7 10] [4 5 6 7 8 10] [5 6 7 8 9 10] (10 10 10 10 10 10)]
— यहोशू
स्रोत
0

05AB1E , 17 बाइट्स

FLN+I·¸«ˆ}·¸I>.׈

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

व्याख्या

F                   # for N in [0 ... input-1]
 L                  # push range [1 ... input]
  N+                # add N to each
    I·¸«            # append input*2
        ˆ           # add to global list
         }          # end loop
          ·¸        # push [input*2]
            I>.×    # repeat it input+1 times
                ˆ   # add to global list
                    # implicitly output global list
— Emigna
स्रोत
0

जे, 29 बाइट्स

(}:@(][\1+i.@+:),]#+:),.>:#+:

ungolfed

(}:@(] [\ 1+i.@+:) , ]#+:) ,. >:#+:

व्याख्या

(}:@(] [\ 1+i.@+:)                   NB. make the inner part of the matrix
          1+i.@+:                      NB. 1..2*n, where n is the input
    (] [\ 1+i.@+:)                     NB. fork: infixes (sliding window) of length n, over 1..2*n
(}:@                                   NB. remove last element
                   , ]#+:)           NB. add a row of 2*n to the end
                           ,. >:#+:  NB. add a column of 2*n to entire result above

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

— जोनाह
स्रोत
हे, मेरे एपीएल जवाब और आपके जवाब में एक ही बाइट गिनती है! क्या आप कृपया स्पष्टीकरण जोड़ सकते हैं?
— 2
@ Zacharý, अपडेट किया गया। fwiw, यह संभवतः अपने जैसे किसी व्यक्ति द्वारा कम से कम थोड़ा और आगे बढ़ाया जा सकता है , और शायद J विशेषज्ञ द्वारा अतिरिक्त 10+ बाइट्स द्वारा।
— जोनाह
0

दरअसल , 23 बाइट्स

;;Rnkp@;r♀+@;τ;(♀q)@α@q

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

स्पष्टीकरण:

;;Rnkp@;r♀+@;τ;(♀q)@α@q
;;                       two copies of input
  R                      range(1, input+1)
   n                     copy input times
    kp@                  push stack to list, remove first element
       ;r                push range(input)
         ♀+              pairwise addition (add the value in the range to each value in the corresponding list)
           @;            duplicate input again
             τ;          input*2, duplicate that
               (♀q)      append input*2 to each list
                   @α@q  append a row of input*2
— मै जाऊं
स्रोत
0

क्लोजर v1.8, 97 बाइट्स

#(conj(mapv(fn[i](conj(vec(range i(+ % i)))(* 2 %)))(range 1(inc %)))(vec(repeat(inc %)(* 2 %))))

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

व्याख्या

(range 1(inc %))                           Numbers from 1 to 'n'
(mapv ... (range 1(inc %)))                For each one of these numbers
(fn[i](conj(vec(range i(+ % i)))(* 2 %)))  Create the numbers from 'i' to (n+i-1), convert to vector and insert '2*n' to the vector
#(conj ... (vec(repeat(inc %)(* 2 %))))    Insert to the previous vector a vector of repeated '2*n's
— क्रिस
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.