इस ऐरे को मैट्रिक्स में बदल दें

Question

इनपुट के रूप में एक गैर नेस्टेड सरणी लें। निम्नलिखित विधि का उपयोग करके इसे मैट्रिक्स में बदलें:

मान लीजिए कि मेरी सरणी है [1, 2, 3, 4, 5]

सबसे पहले, मैं उस सरणी को 5 बार दोहराता हूं: (लंबाई)

[[1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5],
 [1, 2, 3, 4, 5]]

फिर, मैंने इसे विकर्णों के साथ पढ़ा:

[[1],
 [2, 1],
 [3, 2, 1],
 [4, 3, 2, 1],
 [5, 4, 3, 2, 1],
 [5, 4, 3, 2],
 [5, 4, 3],
 [5, 4],
 [5]]

मैं इस सरणी को समतल करता हूं और इसे पांच (लंबाई) के टुकड़ों में विभाजित करता हूं:

[[1, 2, 1, 3, 2],
 [1, 4, 3, 2, 1],
 [5, 4, 3, 2, 1],
 [5, 4, 3, 2, 5],
 [4, 3, 5, 4, 5]]

यह कोड गोल्फ है। सबसे कम बाइट्स जीतता है।

Comments

अगली बार, कृपया चीजों को कॉपी करें।

— ओलिवर नी

यदि मूल सरणी की लंबाई 5 से अधिक है, तो यह कैसे काम करता है?

@ ais523 मैं इसकी एक ही बात मान रहा हूं, आप सिर्फ 'पाँच' को लंबाई के साथ बदल देते हैं

— ओलिवर नी

क्या हम मान सकते हैं कि संख्या हमेशा धनात्मक पूर्णांक हो सकती है?

— लुइस मेंडो

@ जॉनकोना आपको पहले उत्तर को स्वीकार नहीं करना चाहिए, आपको कर्षण और कुछ और उत्तरों को प्राप्त करने के लिए कुछ समय देना होगा।

— केड

Answer 1

05AB1E, 13 बाइट्स

.p¹.sR¦«í˜¹gä

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

स्पष्टीकरण:

                # Implicit input
 .p             # Get prefixes
   ¹            # Get first input
    .s          # Get suffixes
      R         # Reverse
       ¦        # Remove first element
        «       # Concatenate
         í      # Reverse every one
          ˜     # Flatten
           ¹gä  # Split into pieces of the length
                # Implicit print

Comments

आपको इसे प्रिंट करने की आवश्यकता नहीं है

और आपने इनपुट का अनुरोध कैसे किया

इन गोल्फिंग भाषाओं में से कई, जैसे कि 05AB1E, ने इनपुट और उत्पादन आउटपुट का अनुरोध करने के लिए डिफ़ॉल्ट नियमों में बनाया है, ताकि प्रोग्रामर को उन पर बाइट बर्बाद न करना पड़े।

आउटपुट वास्तव में वांछित आउटपुट से मेल नहीं खाता है। यह कोई मैट्रिक्स नहीं है और संख्याएं मेल नहीं खाती हैं।

— कार्ल नेफ

खैर, यह एक मैट्रिक्स है, लेकिन संख्या सही नहीं है (या tryitonline.net गलत गणना करता है)

— कार्ल

Answer 2

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

WẋLŒDUṙLFsL

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

व्याख्या

               Input: array z
WẋL            length(z) copies of z
   ŒD          Diagonals (starting with main diagonal)
     U         Reverse each
      ṙL       Rotate left length(z) places
               (now the top-left diagonal is in front)
        F      Flatten
         sL    Split into chunks of size length(z)

Comments

हम्म जब मैंने इसके साथ कोशिश की, तो Lयह अजीब था, इसलिए मैंने रजिस्टर का उपयोग किया: / मैंने अभी इसे फिर से कोशिश की और यह काम करता है ... मूल रूप से एक ही तो मुझे लगता है कि मैं सिर्फ मेरा निकाल दूंगा।

— जोनाथन एलन

बेशक जेली में "विकर्ण" है .... :)

— ग्रेग मार्टिन

Answer 3

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

-1 और -4 और -4 बाइट्स Flp.Tkc की बदौलत

a=input()
n=len(a)
L,M=[],[]
for i in range(n):L+=a[i::-1];M+=a[:i:-1]
print zip(*[iter(L+M)]*n)

लूप के लिए विवरण में जैसे आइटम जोड़ता है, असली जादू उस ज़िप में होता है जो यहां से है

Comments

स्पैम के लिए खेद है, लेकिन अब R का उपयोग केवल एक बार किया जाता है, आप इसे सीधे वहां रख सकते हैं: P

— FlipTack

@ Flp.Tkc कोई समस्या नहीं, मैं खुश हूँ :)

— कार्ल नेप

Answer 4

जावास्क्रिप्ट (ईएस 6) 100 101 105

a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

कम गोल्फ वाला

a => {
  u = 0
  for(r=[], i=l=a.length; i+l>0; i--)
    for(j=l; j--; )
    {
      v = a[j-i]
      if (v) 
      {
        u %= l
        if (u==0) r.push(s=[])
        s[u++] = v
      }
    }
  return r
}

परीक्षा

F=
a=>eval("for(u=r=[],i=l=a.length;i+l;i--)for(j=l;j--;v&&((u%=l)||r.push(s=[]),s[u++]=v))v=a[j-i];r")

function update() {
  var a=I.value.match(/\d+/g)
  if (a) {
    var r=F(a)
    O.textContent = r.join`\n`
  }
}

update()

<input id=I value='1 2 3 4 5' oninput='update()'>
<pre id=O></pre>

Comments

वाह, यह से बचने के लिए एक बहुत ही चालाक तरीका है return। आपको ईएस 6 टिप थ्रेड में एक टिप पोस्ट करना चाहिए।

— 22

@ETHproductions में इसका दायरा बहुत कम है। ज्यादातर बार, eval बेहतर है।

— edc65

@ETHproductions वास्तव evalमें इस बार भी बेहतर है :(

— edc65

@ETHproductions मैंने टिप पोस्ट की, भले ही यह शायद ही उपयोगी हो, बस मामले में

— edc65

Answer 5

MATL , 17 बाइट्स

!Gg*tRwZRhPXzGne!

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

यह काम किस प्रकार करता है

निम्नलिखित स्पष्टीकरण [1 2 3 4 5]उदाहरण के रूप में इनपुट का उपयोग करता है । मध्यवर्ती परिणामों की कल्पना करने के लिए, %कोड में किसी भी बयान के बाद (टिप्पणी प्रतीक) डालें ।

ध्यान दें कि ;मैट्रीस के लिए पंक्ति विभाजक है। तो [1 2]एक पंक्ति वेक्टर है, [1; 2]एक कॉलम वेक्टर है, और [1 0; 0 1]2 × 2 पहचान मैट्रिक्स है।

!     % Implicitly input a row vector. Transpose. Gives a column vector
      % STACK: [1; 2; 3; 4; 5]
Gg    % Push input with all (nonzero) values replaced by ones
      % STACK: [1; 2; 3; 4; 5], [1 1 1 1 1]
*     % Multiply, with broadcast. Gives a square matrix
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5]
tR    % Duplicate. Upper triangular part
      % STACK: [1 1 1 1 1;
                2 2 2 2 2;
                3 3 3 3 3;
                4 4 4 4 4;
                5 5 5 5 5],
               [1 1 1 1 1
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5]
wZR   % Swap. Lower triangular part, below main diagonal 
      % STACK: [1 1 1 1 1;
                0 2 2 2 2;
                0 0 3 3 3;
                0 0 0 4 4;
                0 0 0 0 5],
               [0 0 0 0 0;
                2 0 0 0 0;
                3 3 0 0 0;
                4 4 4 0 0;
                5 5 5 5 0]
h     % Concatenate horizontally
      % STACK: [1 1 1 1 1 0 0 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 0 0 5 5 5 5 5 0]
P     % Flip vertically
      % STACK: [0 0 0 0 5 5 5 5 5 0;
                0 0 0 4 4 4 4 4 0 0;
                0 0 3 3 3 3 3 0 0 0;
                0 2 2 2 2 2 0 0 0 0;
                1 1 1 1 1 0 0 0 0 0]
Xz    % Column vector of nonzeros, taken in column-major order
      % STACK: [1;2;1;3;2;1;4;3;2;1;5;4;3;2;1;5;4;3;2;5;4;3;5;4;5]
Gne   % Reshape into a matrix with as many rows as input size
      % STACK: [1 1 5 5 4;
                2 4 4 4 3;
                1 3 3 3 5;
                3 2 2 2 4;
                2 1 1 5 5]
 !    % Transpose. Implicitly display
      % STACK: [1 2 1 3 2;
                1 4 3 2 1;
                5 4 3 2 1;
                5 4 3 2 5;
                4 3 5 4 5]

Answer 6

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

a=>a.map(_=>b.splice(0,a.length),b=[].concat(...a.map((_,i)=>a.slice(~i)),...a.map((_,i)=>a.slice(0,~i))).reverse())

खैर, यह एक शुरुआत है ...

Answer 7

आर, 84 बाइट्स

t(matrix(unlist(split(m<-t(matrix(rev(x<-scan()),l<-sum(1|x),l)),row(m)-col(m))),l))

स्टडिन और आउटपुट से इनपुट पढ़ता है / एक आर-मैट्रिक्स लौटाता है।

reversed_x <- rev(x<-scan())                # Read input from stdin and reverse
m <- t(matrix(reversed_x,l<-sum(1|x),l))    # Repeat and fit into matrix
diag_list <- split(m,row(m)-col(m))         # Split into ragged list of diagonals
t(matrix(unlist(diag_list),l))              # Flatten and transform back to matrix

व्याख्या की

इस उत्तर के बारे में सबसे दिलचस्प पहलू यह है कि विकर्णों को कैसे पुनर्प्राप्त किया जाता है। सामान्य रूप से किसी ऑब्जेक्ट को splitफंक्शन का उपयोग करके विभाजित किया जा सकता है यदि किसी ऑब्जेक्ट को उन कारकों की आपूर्ति की जाए जिस पर ऑब्जेक्ट विभाजित होता है। इन कारकों हम उपयोग कर सकते हैं बनाने के लिए colऔर rowजो एक मैट्रिक्स क्रमशः स्तंभ और पंक्ति सूचकांक लौटाएगा। अंतर लेने से: row(m)-col(m)हमें एक मैट्रिक्स मिलता है जैसे:

     [,1] [,2] [,3] [,4] [,5]
[1,]    0   -1   -2   -3   -4
[2,]    1    0   -1   -2   -3
[3,]    2    1    0   -1   -2
[4,]    3    2    1    0   -1
[5,]    4    3    2    1    0

जिसमें प्रत्येक विकर्ण की विशिष्ट पहचान की गई है। अब हम इस मैट्रिक्स के आधार पर विभाजित कर सकते हैं और इसे लागू करके एक रैग्ड सूची में बदल सकते हैं split:

$`-4`
[1] 1
$`-3`
[1] 2 1 
$`-2`
[1] 3 2 1
$`-1`
[1] 4 3 2 1
$`0`
[1] 5 4 3 2 1
$`1`
[1] 5 4 3 2
$`2`
[1] 5 4 3
$`3`
[1] 5 4
$`4`
[1] 5

(ध्यान दें कि प्रत्येक वेक्टर का नाम ऊपर मैट्रिक्स में विकर्ण मूल्यों के अनुरूप है)।

अंतिम चरण बस समतल करना है और इसे फ़ॉर्म के मैट्रिक्स में बदलना है:

     [,1] [,2] [,3] [,4] [,5]
[1,]    1    2    1    3    2
[2,]    1    4    3    2    1
[3,]    5    4    3    2    1
[4,]    5    4    3    2    5
[5,]    4    3    5    4    5

Answer 8

गणितज्ञ 93 बाइट्स

Partition[Flatten[Table[If[i>n,#[[n;;(i-n+1);;-1]],#[[i;;1;;-1]]],{i,1,2(n=Length@#)-1}]],n]&

यहाँ बताया गया है कि मैं इस कोड को कैसे लिखूँ (109 बाइट्स):

Partition[Reverse@Flatten[Table[Reverse@Diagonal[ConstantArray[Reverse@#,n],k],{k,-(n=Length@#)+1,n-1}]],n]&

यह मैट्रिक्स प्लॉट एक क्रमिक रूप से बढ़ते इनपुट वेक्टर के कारण संरचना से एक अच्छा विचार देता है।

यहां एक यादृच्छिक इनपुट वेक्टर के साथ मैट्रिक्स प्लॉट है। जाहिर है कि कुछ संरचना अभी भी मौजूद है।

Answer 9

गणितज्ञ, 92 बाइट्स

n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&;{Most@r[#~n~Rest],#~n~Most}~ArrayReshape~{l,l}&

अपने तर्क के रूप में एक सूची लेने का कार्य करें। ऐसे फ़ंक्शन के लिए अन्य संरचनाएं हो सकती हैं, लेकिन उम्मीद है कि मैंने इस संरचना को बहुत अच्छा बनाया है ...।

पहला भाग दो तर्कों के n=NestList[#2,(r=Reverse)@#,(l=Length@#)-1]&एक फ़ंक्शन nको परिभाषित करता है : पहला लंबाई की एक सूची है l, और दूसरा सूची में लागू करने के लिए एक फ़ंक्शन है। nउस फ़ंक्शन l-1समय को उलटी तर्क सूची में लागू करता है , जिसके परिणाम सूची में सभी परिणाम सहेजते हैं। (परिभाषित करना rऔर lरास्ते में सिर्फ गोल्फ करना है।)

nमूल सूची पर दो बार कहा जाता है, एक बार फ़ंक्शन के साथ Rest(सूची के पहले तत्व को छोड़ दें) और एक बार फ़ंक्शन के होने के साथ Most(अंतिम तत्व को छोड़ दें)। यह सभी वांछित सब्लिस्ट पैदा करता है, लेकिन पूरी सूची दो बार है (इसलिए अतिरिक्त Most) और पीछे की ओर (इसलिए r[...]) पहली छमाही है । अंत में, ~ArrayReshape~{l,l}वर्तमान सूची संरचना को भूल जाता है और इसे lएक्स lसरणी होने के लिए मजबूर करता है ।

Answer 10

गणितज्ञ, 85 बाइट्स

वास्तव में सुझाए गए चरणों का प्रदर्शन:

(l=Length@#;Partition[Flatten@Table[Reverse@Diagonal[Table[#,l],i],{i,-l+1,l-1}],l])&

मेरी आंत कहती है कि Partइस छोटे को करने के लिए उपयोग करने का एक चतुर तरीका होना चाहिए , लेकिन मैंने जो भी प्रयास किया है वह 85 बाइट्स से अधिक लंबा है।

Answer 11

रूबी (110 बाइट्स)

n=a.size
b=[*(0...n)]
b.product(b).group_by{|i,j|i+j}.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}.each_slice(n).to_a
  #=> [[1, 2, 1, 3, 2],
  #    [1, 4, 3, 2, 1],
  #    [5, 4, 3, 2, 1],
  #    [5, 4, 3, 2, 5],
  #    [4, 3, 5, 4, 5]]

sortआपरेशन की आवश्यकता नहीं किया जा सकता है, लेकिन Enumerable # group_by के लिए डॉक हैश मान में मूल्यों के आदेश (जो सरणियों कर रहे हैं) की गारंटी नहीं है, लेकिन रूबी के वर्तमान संस्करण आदेश एक उम्मीद होती है प्रदान करते हैं और आदेश मैं अगर आवश्यकता होगी sortथे मेरे कोड से निकाल दिया गया।

चरण इस प्रकार हैं।

n=a.size 
  #=> 5 
b=[*(0...n)]
  #=> [0, 1, 2, 3, 4] 
c = b.product(b)
  #=> [[0, 0], [0, 1], [0, 2], [0, 3], [0, 4], [1, 0], [1, 1], [1, 2], [1, 3],
  #    [1, 4], [2, 0], [2, 1], [2, 2], [2, 3], [2, 4], [3, 0], [3, 1], [3, 2],
  #    [3, 3], [3, 4], [4, 0], [4, 1], [4, 2], [4, 3], [4, 4]] 
d=c.group_by{|i,j|i+j}
  #=> {0=>[[0, 0]],
  #    1=>[[0, 1], [1, 0]],
  #    2=>[[0, 2], [1, 1], [2, 0]],
  #    3=>[[0, 3], [1, 2], [2, 1], [3, 0]],
  #    4=>[[0, 4], [1, 3], [2, 2], [3, 1], [4, 0]],
  #    5=>[[1, 4], [2, 3], [3, 2], [4, 1]],
  #    6=>[[2, 4], [3, 3], [4, 2]],
  #    7=>[[3, 4], [4, 3]],
  #    8=>[[4, 4]]} 
e=d.flat_map{|_,f|f.sort.map{|i,j|a[i][j]}}
  #=> [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 5, 4, 3, 5, 4, 5] 
f=e.each_slice(n)
  #=> #<Enumerator: [1, 2, 1, 3, 2, 1, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2,
  #                  5, 4, 3, 5, 4, 5]:each_slice(5)>

अंत में, f.to_aपहले दिखाए गए सरणी को लौटाता है।