রেঞ্জের ম্যাট্রিক্স

18

চ্যালেঞ্জ

একটি পূর্ণসংখ্যা n>0আউটপুট n+1 X n+1দেওয়া 1হয়েছে 2nযেমন পরীক্ষার ক্ষেত্রে নমুনা হিসাবে দেখানো হয়েছে সমস্ত পূর্ণসংখ্যা সমেত একটি ম্যাট্রিক্স

পরীক্ষার মামলা

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একটি ম্যাট্রিক্স, subtracts যেমন 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}

এটি অনলাইন চেষ্টা করুন!

— : Giuseppe
সূত্র
+1 সুন্দর, আমি বাহ্যিক সম্পর্কে ভাবছিলাম কিন্তু সেখানে খুব একটা পেলাম না
— মিকিটি
7

গণিত, 61 46 বাইট

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

-15 বাইটের জন্য থ্যানেক্স @ এ্যালাফালফা

— J42161217
সূত্র
ArrayFlatten@{{Array[+##-1&,{#,#}],2#},{2#,2#}}&
— আলেফালফা
+##-1&কেবলমাত্র হতে পারে ##-1&এবং আপনি ইনফিক্স ব্যবহার করতে পারেন Array:ArrayFlatten@{{##-1&~Array~{#,#},2#},{2#,2#}}&
— নেজিনিসিস
4

জেলি , 11 বাইট

+þḶ;€Ḥ;ḤzḤG

এটি অনলাইন চেষ্টা করুন!

— ফুটো নুন
সূত্র
শুধু ছাড়া বাইট জন্য পোস্ট বাইট সম্পর্কে ছিল Gযা প্রয়োজনীয়তা প্রযোজন নেই
— জনাথন অ্যালান
বাহ্যিক পণ্যটির দুর্দান্ত ব্যবহার
— Zacharý
@ জোনাথন অ্যালান আরও একটি সমাধান ব্যবহার করে ;€ḤZ;€Ḥ...
— লিকি নুন
... এবং আর একটি হ'ল Ḷ;Ḥ©µ+þ‘«®পি
— জোনাথন অ্যালান
1
@ +€Ḷ;Ḥṁ€;€Ḥ
— জোনাথন অ্যালান
4

জাভাস্ক্রিপ্ট (ES6), 64 বাইট

f=
n=>[...Array(n+1)].map((_,i,a)=>a.map((_,j)=>n-i&&n-j?i-~j:n+n))
<input type=number min=0 oninput="t.innerHTML=f(+this.value).map(a=>`<tr>${a.map(b=>`<td>${b}</td>`).join``}</tr>`).join``"><table id=t>
স্নিপেট প্রসারিত করুন

— নিল
সূত্র
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;
}

প্রাপ্তি স্বীকার

  • -1 বাইট কেভিন ক্রুইজসেনকে ধন্যবাদ
— জ্যাকব
সূত্র
আপনি শুরু করে গলফ একটি বাইট করতে পারেন i=0এবং নির্বাণ ++এ [c=i++%p]।
— কেভিন ক্রুইজসেন
3

পাইথন 2 , 64 62 61 বাইট

-৩ বাইটস মিঃ এক্সকোডারকে ধন্যবাদ।

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 বাইটে
— হল্ভার্ড হুমেল
2

আর , 54 63 67 বাইট

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

এটি অনলাইন চেষ্টা করুন!

সাপলি এবং 9 বাইটের জন্য পয়েন্টারটির জন্য @ গুইস্প্পকে ধন্যবাদ জানাই

— MickyT
সূত্র
আসলে, এই পদ্ধতির পাশাপাশি উন্নতি করা যেতে পারে: sapply(1:n-1,'+',1:n)তবে তারপরে এটি ব্যবহারের চেয়ে মাত্র 1 বাইট বেশি outer(উদ্ধৃতিগুলি স্পষ্টত ব্যাকটিকস)
— জিউসেপ
1
\`ব্যাকটিক্স @ জিউসেপ্পে সীমাবদ্ধ একটি কোড ব্লকে ব্যাকটিক্স পলায়নের জন্য কাজ করে
— সাইয়েস
1

Röda , 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 বাইট

-V পতাকাটির জন্য +2

মানগুলির মধ্যে ট্যাবগুলি এবং সারিগুলির মধ্যে নতুন লাইনগুলি প্রিন্ট করে। শেষ লাইনে একটি অনুসরণযোগ্য ট্যাবও মুদ্রণ করে।

এটি অনলাইনে চেষ্টা করুন

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

প্রি-golfing

1>:r:&r&)?\0>    :r:&r&(?\~$:@2*nao1+\
            \+1o9n+@:$@:$/
 \                                   /
          \~0>:r:&r&)?;$:@2*n9o1+\
             \                   /
— বিদেশে
সূত্র
0

ক্লোজার, 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))))

বেনামে ফাংশন যা ইনপুটটিকে আর্গুমেন্ট হিসাবে গ্রহণ করে এবং তালিকাগুলির একটি তালিকা প্রদান করে।

এন = 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

জে, 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

এটি অনলাইন চেষ্টা করুন!

— দুর্ভাগ্যআনয়নকারী
সূত্র
হেই, আমার এপিএল উত্তর এবং আপনার উত্তর একই বাইট গণনা আছে! আপনি একটি ব্যাখ্যা যোগ করতে পারেন দয়া করে?
— Zachar
@ জাকারি, আপডেট হয়েছে। তবে, এটি সম্ভবত আমার মতো আরও কিছুটা এবং সম্ভবত জে বিশেষজ্ঞ দ্বারা অতিরিক্ত 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

ক্লোজার ভি 1.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
— ক্রিস
সূত্র
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.