न्यूनतम सूची को मैट्रिक्स में क्रमबद्ध करें

Question

अद्वितीय कड़ाई से सकारात्मक पूर्णांकों की एक अनसुलझी सूची को देखते हुए, इसे न्यूनतम रूप से 2 डी मैट्रिक्स में क्रमबद्ध करें। इनपुट सूची को समग्र लंबाई की गारंटी दी गई है, जिसका अर्थ है कि आउटपुट मैट्रिक्स आवश्यक रूप से चौकोर नहीं है, लेकिन आकार के 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

ओह, वाह, एक शब्द जो मैंने रैखिक बीजगणित के बाद से नहीं देखा है; आसानी से अनदेखा। मैं क्षमाप्रार्थी हूं।

— मैजिक ऑक्टोपस Urn

@LuisMendo ने एक 15तत्व परीक्षण मामला जोड़ा ।

— AdmBorkBork

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 बाइट्स

^{-2 बाइट्स का शुक्रिया एरिक आउटगोल्फर
-2 बाइट्स मिस्टर एक्सकोडर की बदौलत}

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)-2 बाइट्स के लिए उपयोग कर सकते हैं ।

— मिस्टर एक्सकोडर

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
}

Giuseppe ने निम्न चाल से 15 (!) बाइट्स को बचाया

• length(x)द्वारा प्रतिस्थापित sum(x|1)(-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 बाइट्स

— Giuseppe

मेरे समाधान से संबंधित चुनौती के लिए कुछ उपयोग करने में सक्षम हो सकता है यहाँ भी मदद करने के लिए।

— Giuseppe

यह वास्तव में बारीकी से संबंधित है। बहुत अच्छा तरीका!

— माइकल एम

Answer 4

जावास्क्रिप्ट (ईएस 6), 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-डी सरणी देता है। TIO लिंक में परीक्षा परिणाम प्रदर्शित करने के लिए पाद लेख कोड शामिल है।

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') आवश्यक है?

— लुइस मेंडो

@LuisMendo धन्यवाद! 'अगर मैं सीमा अभिव्यक्ति (जैसे कि वास्तविक साइट बनाने के लिए) को कॉल साइट पर 1:20कोष्ठक ( [1:20]) के आसपास श्रेणी अभिव्यक्ति को लपेटता हूं, तो टर्न आउट की आवश्यकता नहीं है । स्पष्ट रूप से ऑक्टेव में, कोलन ऑपरेटर एक वेक्टर नहीं बनाता है , लेकिन एक ऐसी सीमा जो स्मृति में बहुत कम जगह लेती है। किसी कारण के लिए, nnz()उस प्रकार के साथ काम नहीं करता है, लेकिन सीमा को लगातार स्थानांतरित करने से एक वेक्टर उपज होता है, इसलिए यह एपोस्ट्रोफ के साथ काम करता है। वास्तविक वेक्टर के साथ फ़ंक्शन को कॉल करने से इसकी आवश्यकता दूर हो जाती है '।

— स्टेडीबॉक्स

स्पष्टीकरण के लिए धन्यवाद। मुझे नहीं पता था कि एक सीमा अभिव्यक्ति का ऑक्टेव में विशेष उपचार था। वैसे भी, यह तथ्य यह है कि यह मेमोरी दक्षता के लिए एक वेक्टर नहीं बनाता है, प्रोग्रामर के लिए पारदर्शी होना चाहिए। है यही कारण है, तथ्य यह है कि nnz(1:20)काम नहीं करता है शायद एक बग (है max(1:20), sum(1:20)आदि कर रहे हैं वैध)।

— लुइस मेंडो

हम चाहिए उसकी रिपोर्ट । यह अन्य कार्यों को प्रभावित कर सकता है nnz। क्या आप इसे स्वयं करना चाहते हैं, या मैं करूंगा?

— लुइस मेंडो

रिपोर्ट की गई । इससे MATL भी प्रभावित हुआ; अब हल हो गया है । यह ध्यान देने के लिए धन्यवाद!

— लुइस मेंडो

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

जावास्क्रिप्ट (ईएस 6), 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