ন্যূনতমভাবে ম্যাট্রিক্সে একটি তালিকা সাজান

Question

অনন্য কঠোরভাবে ইতিবাচক পূর্ণসংখ্যার একটি অরসেটেড তালিকা দেওয়া হয়েছে, এটি 2D ম্যাট্রিক্সে ন্যূনতমভাবে সাজান। ইনপুট তালিকা যৌগিক দৈর্ঘ্য, যার মানে আউটপুট ম্যাট্রিক্স অগত্যা চতুর্ভুজ নয় এর হতে নিশ্চিত করা হয়, কিন্তু আকারের হয় n x mসঙ্গে n,m > 1।

"সর্বনিম্ন বাছাই করা" এর অর্থ এখানে নিম্নলিখিত:

• আরোহণ ক্রম অনুসারে তালিকাটি বাছাই করুন।
• আউটপুট ম্যাট্রিক্স যথাসম্ভব কমপ্যাক্ট করুন - ম্যাট্রিক্সের মাত্রাগুলির যোগফল ছোট করুন (উদাহরণস্বরূপ, 20ইনপুট হিসাবে ইনপুট উপাদানগুলির জন্য , একটি 5x4বা 4x5আউটপুট ম্যাট্রিক্স প্রয়োজন, এবং একটি নয় 2x10)।
• বাছাই করা তালিকার প্রথম উপাদানটির সাথে শুরু করে ম্যাট্রিক্সের উপরের-বামে যথাক্রমে বাছাই করা সংখ্যাগুলি সংক্ষিপ্ত করুন।
• এটিকে তালিকাটি বাছাই করার কথা ভাবা যেতে পারে, তারপরে এটিকে ম্যাট্রিক্সের অ্যান্টি-ডায়াগোনালগুলি দিয়ে টুকরো টুকরো করে উপরের-বাম থেকে শুরু করে।

উদাহরণ:

ইনপুট 1..20আউটপুট জন্য হয় হয় 5x4 বা 4x5 ম্যাট্রিক্স নীচে:

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

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

ইনপুট [3, 5, 12, 9, 6, 11]আউটপুট জন্য নিম্নলিখিত হিসাবে একটি 2x3 বা 3x2

3  5  9
6 11 12

 3  5
 6  9
11 12

ইনপুট জন্য [14, 20, 200, 33, 12, 1, 7, 99, 58], আউটপুট নিম্নলিখিত হিসাবে একটি 3x3

 1   7  14
12  20  58
33  99 200

ইনপুট করতে 1..10আউটপুট একটি 2x5 বা 5x2 নিম্নরূপ হওয়া উচিত

1 2 4 6  8
3 5 7 9 10

1  2
3  4
5  6
7  8
9 10

ইনপুট [5, 9, 33, 65, 12, 7, 80, 42, 48, 30, 11, 57, 69, 92, 91]আউটপুট জন্য নিম্নলিখিত 5x3 বা 3x5 হয়

 5  7 11 33 57
 9 12 42 65 80
30 48 69 91 92

 5  7 11
 9 12 33
30 42 57
48 65 80
69 91 92

বিধি

• ইনপুটটি আপনার ভাষার স্থানীয় সংখ্যার সাথে মানানসই করা যেতে পারে।
• ইনপুট এবং আউটপুট যে কোনও সুবিধাজনক পদ্ধতি দ্বারা দেওয়া যেতে পারে ।
• হয় একটি সম্পূর্ণ প্রোগ্রাম বা একটি ফাংশন গ্রহণযোগ্য। যদি কোনও ফাংশন হয় তবে আপনি আউটপুটটি মুদ্রণের পরিবর্তে ফিরিয়ে দিতে পারেন।
• স্ট্যান্ডার্ড লুফোলগুলি নিষিদ্ধ।
• এটি কোড-গল্ফ তাই সাধারণ গল্ফিংয়ের সমস্ত নিয়ম প্রয়োগ হয় এবং সংক্ষিপ্ততম কোড (বাইটে) জয়ী হয়।

Comments

ওহ, বাহ, এমন একটি শব্দ যা আমি লিনিয়ার বীজগণিতের পরে দেখিনি; সহজেই উপেক্ষিত আমার ক্ষমা।

— ম্যাজিক অক্টোপাস আরন

@ লুইসেমেন্ডো একটি 15উপাদান পরীক্ষার কেস যুক্ত করেছে।

— অ্যাডমবর্কবার্ক

Answer 1

জেলি , 24 22 20 বাইট

pS€ỤỤs
LÆDżṚ$SÞḢç/ịṢ

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

@ জোনাথন অ্যালানকে 2 বাইট সংরক্ষণ করা হয়েছে ।

ব্যাখ্যা

pS€ỤỤs  Helper link. Input: integer a (LHS), integer b (RHS)
p       Cartesian product between [1, 2, ..., a] and [1, 2, ..., b]
 S€     Sum each pair
   Ụ    Grade up
    Ụ   Grade up again (Obtains the rank)
     s  Split into slices of length b

LÆDżṚ$SÞḢç/ịṢ  Main link. Input: list A
L              Length
 ÆD            Divisors
     $         Monadic pair
    Ṛ            Reverse
   ż             Interleave
                 Now contains all pairs [a, b] where a*b = len(A)
      SÞ       Sort by sum
        Ḣ      Head (Select the pair with smallest sum)
         ç/    Call helper link
            Ṣ  Sort A
           ị   Index into sorted(A)

Comments

L%J¬TżṚ$-> LÆDżṚ$আমার মনে হয় এমন দুটি সংরক্ষণ করা উচিত

— জোনাথন অ্যালান

প্রথম লিঙ্কটি হয়ে উঠতে পারে pSÞỤs।

— ডেনিস

Answer 2

পাইথন 2 , 160 158 153 151 বাইট

^{-২ বাইটস এরিক দি আউটগল্ফারকে
ধন্যবাদ -২ বাইটস মিঃ এক্সকোডারকে ধন্যবাদ}

s=sorted(input())
l=len(s)
x=int(l**.5)
while l%x:x+=1
n=1
o=eval(`l/x*[[]]`)
while s:
 for i in range(l/x)[max(0,n-x):n]:o[i]+=s.pop(0),
 n+=1
print o

এটি অনলাইন চেষ্টা করুন! বা সমস্ত পরীক্ষার কেস চেষ্টা করে দেখুন

Comments

আমি বিশ্বাস করি আপনি max(0,n-x)-২ বাইট ব্যবহার করতে পারেন ।

— মিঃ এক্সকোডার

Answer 3

আর 110 95 বাইট

function(x){n=sum(x|1)
X=matrix(x,max(which(!n%%1:n^.5)))
X[order(col(X)+row(X))]=sort(x)
t(X)}

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

কিভাবে এটা কাজ করে

f <- function(x) {
  n <- sum(x|1)                           # length
  p <- max(which(!n%%1:n^.5))             # height of matrix
  X <- matrix(x, p)                       # initialize matrix
  X[order(col(X) + row(X))] <- sort(x)    # filling the matrix using position distance to the top left corner
  t(X)                                    # probably required by OP
}

জিউসেপ নিম্নলিখিত কৌশলগুলি দ্বারা একটি বৃহত 15 (!) বাইট সংরক্ষণ করেছে

• (-1 বাইট) length(x)দ্বারা প্রতিস্থাপনsum(x|1)
• floor():যাইহোক রাউন্ড ডাউন হিসাবে প্রয়োজন হয় না (-7)
• ^.5sqrt()(-3) এর চেয়ে কম
• এর col(X) + row(X)পরিবর্তে outer(চমৎকার!) ব্যবহার করা হচ্ছে
• t(X)যদিও নিরাশ করতে পারিনি - হতাশাব্যঞ্জক;)

আসল সমাধান

function(x){
n=length(x)
p=max(which(!n%%1:floor(sqrt(n))))
X=outer(1:p,1:(n/p),`+`)
X[order(X)]=sort(x)
t(X)}

এটি outerপ্রতিস্থাপিত হওয়ার সাথে আরও অভিনব দেখায় row(X)+col(X), তবে এটির জন্য Xপ্রথমে আউটপুট ম্যাট্রিক্স শুরু করতে হবে ।

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

Comments

খুব সুন্দর! আপনি 95 বাইটে

— জিউসেপ

আমার সমাধান থেকে এখানে সহায়তা করার জন্য সম্পর্কিত চ্যালেঞ্জ থেকে কিছু ব্যবহার করতে সক্ষম হতে পারে ।

— জিউসেপে

এটি আসলে নিবিড়ভাবে সম্পর্কিত। খুব সুন্দর পদ্ধতির!

— মাইকেল এম

Answer 4

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

l=>(n=l.sort((a,b)=>b-a).length,w=l.findIndex((_,i)=>!(i*i<n|n%i)),a=l=>[...Array(l)],r=a(n/w).map(_=>a(w)),a(w+n/w).map((_,x)=>r.map((s,y)=>x-y in s&&(s[x-y]=l.pop()))),r)

ব্যাখ্যা

l=>(                                // Take a list l as input
 l.sort((a,b)=>b-a),                // Sort it
 n=l.length,                        // Get the length n
 w=l.findIndex((_,i)=>!(i*i<n|n%i)),// Find the first integer w where w >= √n and n % w = 0
 a=l=>[...Array(l)],                // Helper function a
 r=a(n/w).map(_=>a(w)),             // Create the grid r of size w, n/w
 a(w+n/w).map((_,x)=>               // For every x from 0 to w + n/w:
  r.map((s,y)=>                     //  For every row s in r:
   x-y in s&&(                      //   If the index x-y is in s:
    s[x-y]=l.pop()))),              //    Set s[x-y] to the next element of l
 r)                                 // Return r

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

f=l=>(n=l.sort((a,b)=>b-a).length,w=l.findIndex((_,i)=>!(i*i<n|n%i)),a=l=>[...Array(l)],r=a(n/w).map(_=>a(w)),a(w+n/w).map((_,x)=>r.map((s,y)=>x-y in s&&(s[x-y]=l.pop()))),r)

l=m=>console.log(JSON.stringify(m))

l(f([1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20]))
l(f([3,5,12,9,6,11]))
l(f([14,20,200,33,12,1,7,99,58]))
l(f([1,2,3,4,5,6,7,8,9,10]))

Answer 5

পার্ল 5 , 132 বাইট

sub d{$,=0|sqrt(@_=sort{$a-$b}@_);--$,while@_%$,;map{$r++,$c--for@_/$,..$c;$a[$r++][$c--]=$_;$c=++$i,$r=0if$r<0||$c<0||$r>=$,}@_;@a}

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

সাব্রুটিন একটি 2-ডি অ্যারে প্রদান করে। টিআইও লিঙ্কটিতে পরীক্ষার ফলাফল প্রদর্শনের জন্য ফুটার কোড অন্তর্ভুক্ত।

Answer 6

অক্টাভা , 151 বাইট

function f(v)n=floor(sqrt(l=nnz(v)));while i=mod(l,n);++n;end;A=nan(m=l/n,n);for k=[1:m 2*m:m:l];do A(k)=sort(v)(++i);until~mod(k+=m-1,m)|k>l;end;A'end

লুপ তিনটি বিভিন্ন ধরণের ব্যবহার করে।

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

Unrolled:

function f(v)
    n = floor(sqrt(l=nnz(v)));

    while i = mod(l,n);
        ++n;
    end;

    A = nan(m=l/n, n);

    for k = [1:m 2*m:m:l];
        do
            A(k) = sort(v)(++i);
        until ~mod(k+=m-1, m) | k>l;
    end;

    A'
end

Comments

চমৎকার উত্তর! কেন 'এ nnz(v') প্রয়োজনীয়?

— লুইস মেন্ডো

@ লুইস মেন্ডো ধন্যবাদ! সক্রিয় আউট 'যদি আমি সীমার অভিব্যক্তি, যেমন মোড়ানো প্রয়োজন হয় না 1:20, বন্ধনী কাছাকাছি ( [1:20]) কলের সাইট এ (এটা প্রকৃত ভেক্টর করতে)। স্পষ্টতই অষ্টাভে, কোলন অপারেটর একটি ভেক্টর তৈরি করে না , তবে একটি পরিসর ধ্রুবক যা মেমরিতে অনেক কম জায়গা নেয়। কোনও কারণে, nnz()এই ধরণের সাথে কাজ করে না, তবে পরিসর স্থির করে স্থানান্তর করা একটি ভেক্টর দেয়, তাই এটি অ্যাস্টোস্ট্রোফের সাথে কাজ করে। প্রকৃত ভেক্টরের সাথে ফাংশনটি কল করা প্রয়োজনীয়তার জন্য সরিয়ে দেয় '।

— স্টেডিবক্স

বর্নানার জন্য ধন্যবাদ. আমি জানতাম না যে একটি পরিসীমা অভিব্যক্তির অষ্টাটভে সেই বিশেষ চিকিত্সা রয়েছে। যাইহোক, এটি মেমরির দক্ষতার জন্য ভেক্টর তৈরি করে না তা প্রোগ্রামারটির কাছে স্বচ্ছ হওয়া উচিত। অর্থাৎ যে nnz(1:20)কাজ করে না সম্ভবত একটি বাগ (হয় max(1:20), sum(1:20)ইত্যাদি হয় বৈধ)।

— লুইস মেন্ডো

আমাদের এটি রিপোর্ট করা উচিত । এটি ছাড়াও অন্যান্য কার্যগুলিতে প্রভাব ফেলতে পারে nnz। আপনি নিজে এটি করতে চান, বা আমি করব?

— লুইস মেন্ডো

রিপোর্ট করা হয়েছে । এটি এমএটিএলকেও প্রভাবিত করেছিল; এখন সমাধান । এটি লক্ষ্য করার জন্য ধন্যবাদ!

— লুইস মেন্ডো

Answer 7

হুশ , 15 বাইট

ḟȯΛ≤Σ∂MCP¹→←½ḊL

এটি নিষ্ঠুর শক্তি দ্বারা কাজ করে, সুতরাং আর পরীক্ষার কেসগুলি সময় শেষ হতে পারে। এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা

ḟȯΛ≤Σ∂MCP¹→←½ḊL  Implicit input, a list of integers x.
              L  Length of x (call it n).
             Ḋ   List of divisors.
            ½    Split at the middle.
          →←     Take last element of first part.
                 This is a divisor d that minimizes d + n/d.
        P¹       List of permutations of x.
      MC         Cut each into slices of length d.
ḟ                Find the first of these matrices that satisfies this:
     ∂            Take anti-diagonals,
    Σ             flatten them,
 ȯΛ≤              check that the result is sorted (each adjacent pair is non-decreasing).

Answer 8

সি (জিসিসি) , 269 বাইট

j,w,h,x,y;f(A,l)int*A;{int B[l];for(w=l;w-->1;)for(j=0;j<w;)if(A[j++]>A[j]){h=A[~-j];A[~-j]=A[j];A[j]=h;}for(w=h=j=2;w*h-l;j++)l%j||(w=h,h=j),h*h-l||(w=j);for(x=0;x<w*h;x++)for(y=0;y<=x;y++)x-y<w&y<h&&(B[x-y+y*w]=*A++);for(j=0;j<l;j++)j%w||puts(""),printf("%d ",B[j]);}

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

Answer 9

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

f=s=>{l=s.length;i=Math.sqrt(l)|0;for(;l%++i;);p=(x)=>(x/i|0+x%i)*l+x%i;m=[...Array(l).keys()].sort((x,y)=>p(x)-p(y));return s.sort((a,b)=>a-b).map((x,i)=>m.indexOf(i)).reduce((a,b,d,g)=>!(d%i)?a.concat([g.slice(d,d+i)]):a,[])}

ব্যাখ্যা

f=s=>{                         // Take array `s` of numbers as input
  l=s.length                   // short-hand for length
  i=Math.sqrt(l)|0             // = Math.floor(Math.sqrt(l))
  for(;l%++i;);                // i = width           
  j=l/i                        // j = height

  p=(x)=>(x/i|0+x%i)*l+x%i     // helper to calculate (sort-of) ~manhattan
                                 // distance (horizontal distance weighted
                                 // slightly stronger), from top-left corner
                                 // to the number x, if numbers 0,...,l are
                                 // arranged left-to-right, top-to-bottom
                                 // in an l=i*j grid

  m=[...Array(l).keys()]         // range array
  .sort((x,y)=>p(x)-p(y)),       // manhatten-sorted, sort-of...

  return s.sort((a,b)=>a-b)      // sort input array by numbers,
    .map((x,i,w)=>w[m.indexOf(i)])    // then apply inverse permutation of the
                                 // range-grid manhatten-sort mapping.
    .reduce(                     // slice result into rows
      (a,b,d,g)=>!(d%i)?a.concat([g.slice(d,d+i)]):a
      ,[]
     )
}

Answer 10

জাভা 10, 199 188 186 বাইট

a->{int j=a.length,m=0,n,i=0,k=0;for(n=m+=Math.sqrt(j);m*n<j;n=j/++m);var R=new int[m][n];for(java.util.Arrays.sort(a);i<m+n;i++)for(j=0;j<=i;j++)if(i-j<n&j<m)R[j][i-j]=a[k++];return R;}

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

আমার উত্তর উপর ভিত্তি করে এখানে ।

ব্যাখ্যা:

a->{                        // Method with int-array parameter and int-matrix return-type
  int j=a.length,           //  Length of the input-array
      m=0,n,                //  Amount of rows and columns
      i=0,k=0;              //  Index integers
   for(n=m+=Math.sqrt(j);   //  Set both `m` and `n` to floor(√ `j`)
       m*n<j;               //  Loop as long as `m` multiplied by `n` is not `j`
       n=j/++m);            //   Increase `m` by 1 first with `++m`
                            //   and then set `n` to `j` integer-divided by this new `m`
   var R=new int[m][n];     //  Result-matrix of size `m` by `n`
   for(java.util.Arrays.sort(a);
                            //  Sort the input-array
       i<m+n;)              //  Loop as long as `i` is smaller than `m+n`
     for(j=0;j<=i;j++)      //   Inner loop `j` in range [0,`i`]
       if(i-j<n&j<m)        //    If `i-j` is smaller than `n`, and `j` smaller than `m`
                            //    (So basically check if they are still within bounds)
         R[j][i-j]=a[k++];  //     Add the number of the input array at index `k`,
                            //     to the matrix in the current cell at `[j,i-j]`
  return R;}                //  Return the result-matrix