वैकल्पिक रूप से कॉलम और पंक्तियों को 2 डी सरणी में बदलें

Question

उद्देश्य

किसी भी आकार के 2 डी सरणी को देखते हुए, कॉलम और पंक्तियों को वैकल्पिक रूप से स्थानांतरित करने के लिए एक प्रोग्राम या फ़ंक्शन लिखें

उदाहरण

a b c d e
f g h i j
k l m n o

में सभी तत्वों को पहले स्तंभ पारी नीचे एक पंक्ति, दूसरे स्तंभ पारी ऊपर एक पंक्ति, तीसरे पारी नीचे एक पंक्ति और इतने पर, रैपिंग जब वे किनारे तक पहुँचते हैं।

k g m i o
a l c n e
f b h d j  

पहली पंक्ति में सभी तत्व दाईं ओर शिफ्ट होते हैं , दूसरे से बाएं , तीसरे से दाएं आदि, जब वे किनारे तक पहुंचते हैं तो लपेटते हैं।

o k g m i
l c n e a
j f b h d

मैं सबसे अच्छे उत्तर के रूप में सबसे कम काम करने वाले कोड को चुनने की परंपरा का पालन करूंगा

Comments

क्या सरणी किसी भी आकार या विशेष रूप से 3x5 हो सकती है?

— जो राजा

मैं किसी भी भरा 2 डी सरणी के लिए देख रहा था। इसका उल्लेख नहीं करने के लिए खेद है। बीमार एक संपादित जोड़ें

— करण शिशु

ईमानदार होने के लिए, अनुचित स्वरूपण प्रश्न को ऐसा दिखता है जैसे कि यह एक आलसी SO उपयोगकर्ता का एक ऑफ-टॉपिक प्रश्न था।

— user202729

(BTW, बहुत जल्द एक जवाब स्वीकार नहीं करते हैं)

— user202729

@kshishoo भविष्य की चुनौतियों के लिए आप सैंडबॉक्स का उपयोग डुप्लिकेट की जांच करने के लिए कर सकते हैं और / या मुख्य साइट पर पोस्ट करने से पहले कुछ प्रतिक्रिया इकट्ठा कर सकते हैं

— रॉड

Answer 1

भूसी , 7 बाइट्स

‼ozṙİ_T

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

व्याख्या

‼ozṙİ_T  Implicit input: a list of lists.
‼        Do this twice:
      T   Transpose,
 oz       then zip with
    İ_    the infinite list [-1,1,-1,1,-1,1,..
   ṙ      using rotation. This rotates the rows in alternating directions.

Answer 2

MATL , 13 बाइट्स

,!tZy:oEq2&YS

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

व्याख्या

,        % Do twice
  !      %   Transpose. Takes input implicitly the first time
  t      %   Duplicate
  Zy     %   Size. Gives a vector with numbers of rows and of columns
  :      %   Range from 1 to the first entry of the vector (number of rows)
  o      %   Parity: gives 0 or 1 for eacn entry
  Eq     %   Times 2, minus 1: transforms 0 into -1
  2      %   Push 2
  &YS    %   Circularly shift along the second dimension. This shifts the
         %   first row by 1 (that is, to the right), the second by -1 (to
         %   the left), etc.
         % End (implicit). Display (implicit)

Answer 3

जे , 26, 21 19 बाइट्स

-5 बाइट मील के लिए धन्यवाद

(|."_1~_1^#\)@|:^:2

स्पष्टीकरण:

^:2 - निम्नलिखित दो बार दोहराएं:

@|: - संक्रमण और

#\ - उपसर्गों की लंबाई (1, 2, 3 ... पंक्तियों) को खोजें

_1^ - उपर्युक्त शक्तियों के लिए -1 बढ़ाएँ, वैकल्पिक -1 -1 -1 1 की सूची बनाते हुए ...

|."_1~ - उपरोक्त सूची से ऑफसेट के साथ इनपुट सरणी की प्रत्येक पंक्ति को घुमाएं

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

मूल संस्करण:

(($_1 1"0)@#|."0 1])@|:^:2

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

^:2 - निम्नलिखित दो बार दोहराएं:

|: - संक्रमण और

|."0 1] - सूची में इनपुट सरणी, ऑफसेट की प्रत्येक पंक्ति को घुमाएं:

@# - सरणी में पंक्तियों की संख्या

($_1 1"0) - वैकल्पिक _1 1 (3 -> _1 1 _1)

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

Comments

आप उत्पन्न कर सकते हैं _1 1..का उपयोग कर (|."_1~_1^2|#\)@|:^:2भी

— मील की दूरी पर

@ मीलों धन्यवाद, यह कोड का एक बड़ा टुकड़ा है!

— गैलेन इवानोव

@ मीलों वास्तव में मुझे 2|भाग की आवश्यकता नहीं है

— गैलेन इवानोव

हां, आप वास्तव में नहीं हैं, यह एक और 2 बाइट्स बचा है।

— मील

Answer 4

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 55 बाइट्स

Nest[MapIndexed[RotateLeft[#,(-1)^#2]&,Thread@#]&,#,2]&

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

Answer 5

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

x=input()
exec'x=[l[i%2*2-1:]+l[:i%2*2-1]for i,l in enumerate(zip(*x))];'*2
print x

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

Answer 6

एपीएल + विन, 30 बाइट्स

एक 2d सरणी के स्क्रीन इनपुट के लिए संकेत

((↑⍴m)⍴¯1 1)⌽((1↓⍴m)⍴¯1 1)⊖m←⎕

Answer 7

एपीएल (डायलॉग यूनिकोड) , 26 बाइट्स

{(¯1 1⍴⍨≢⍵)⌽(¯1 1⍴⍨≢⍉⍵)⊖⍵}

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

उपसर्ग Dfn।

कैसे?

{(¯1 1⍴⍨≢⍵)⌽(¯1 1⍴⍨≢⍉⍵)⊖⍵}⍝ Main function, prefix. Input matrix is ⍵.
                        ⊖⍵}⍝ Rotate the columns of ⍵ according to the left arg:
            (       ⍉⍵)    ⍝ Transpose ⍵ (makes a 3x5 matrix become 5x3)
                   ≢       ⍝ Tally (yields the number of rows of the matrix)
                  ⍨        ⍝ Swap arguments of the following fn/op
                 ⍴         ⍝ Shape
             ¯1 1          ⍝ This vector. This yields a vector of ¯1 1 with size = number of columns of ⍵.
          ⌽                ⍝ Rotate the rows of ⍵ according to the left arg:
{(¯1 1⍴⍨≢⍵)                ⍝ Does the same as the preceding expression, without transposing ⍵.

Answer 8

एपीएल (डायलॉग यूनिकोड) , 15 बाइट्स (SBCS)

{⍵⌽⍨¯1*⍳≢⍵}∘⍉⍣2

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

Answer 9

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

a=>(g=a=>a[0].map((_,i)=>(b=a.map(a=>a[i]),i%2?[...b.slice(1),b[0]]:[b.pop(),...b])))(g(a))

वहाँ शायद एक गोल्फ का रास्ता रोटेशन करना है ...

Answer 10

अजगर, 15 बाइट्स

L.e.>b^_1k.Tbyy

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

व्याख्या

L.e.>b^_1k.Tbyy
L           b      Define a function on a list...
          .T       ... which transposes it...
 .e.>b^_1k         ... and rotates each row alternating left and right.
             yyQ   Apply twice to the (implicit) input array.

Answer 11

क्यू / केडीबी + , ३२ बाइट्स

समाधान:

{rotate'[#:[x+:]#-1 1](+)x}/[2;]

उदाहरण:

q)3 5#.Q.a / reshape "a..o" into 3 row, 5 column grid
"abcde"
"fghij"
"klmno"
q){rotate'[#:[(+)x]#-1 1](+)x}/[2;]3 5#.Q.a
"okgmi"
"lcnea"
"jfbhd"

स्पष्टीकरण:

स्तंभों के रोटेशन को लागू करने के लिए ग्रिड को पलटें , दूसरा पुनरावृति एक बार फिर से फ़्लिप करता है इस प्रकार घुमाव दूसरे पास पर पंक्तियों पर लागू होता है ।

रोटेशन -1 1 -1 1..पंक्ति / स्तंभ की लंबाई की सूची पर आधारित होता है ।

एक स्वस्थ 9 बाइट्स को आसानी से पढ़े जाने वाले संस्करण से अलग कर दिया गया है

{rotate'[count[flip x]#-1 1;flip x]}/[2;] / ungolfed solution
{                                  }/[2;] / perform lambda 2 times
 rotate'[                  ;      ]       / perform rotate on each-both
                            flip x        / flip x<->y of grid
                      #-1 1               / take from list -1 1
         count[flip x]                    / the length of the flipped grid

Answer 12

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

m=>(g=m=>m[0].map((_,x)=>m.map(_=>m[y++%h][x],h=m.length,y=x&1||h-1)))(g(m))

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

टिप्पणी की गई

m => (                 // m[] = input matrix
  g = m =>             // g is the main helper function taking a matrix m[]
    m[0].map((_, x) => // for each column at position x in m[]:
      m.map(_ =>       //   for each row of m[]:
        m[y++ % h][x], //     yield the x-th value of the row (y mod h) and increment y
        h = m.length,  //     h = number of rows
        y = x & 1      //     start with y = 1 if x is odd,
            || h - 1   //     or h - 1 if x is even
      )                //   end of inner map()
  )                    // end of outer map()
)(g(m))                // invoke g twice on the input matrix

Answer 13

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

ZJ-*ṙ"@Zµ⁺

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

Answer 14

क्लीन , 93 बाइट्स

import StdEnv,StdLib
k=[0,1:k]
^l=[[[last a:init a],tl a++[hd a]]!!b\\a<-transpose l&b<-k]

^o^

आंशिक कार्य शाब्दिक के रूप में, यह चेहरे की तरह दिखने के लिए होता है।

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

Answer 15

05AB1E , 14 बाइट्स

2FøvyNÉiÀëÁ}})

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

व्याख्या

2F               # 2 times do:
  ø              # zip
   vy            # for each row(y), index(N) do:
     NÉiÀ        # if N is odd, rotate left
         ëÁ      # else rotate right
           }}    # end if and inner loop
             )   # wrap in list

Answer 16

एपीएल नार, 36 बाइट्स, 18 चार्ट

c←b∘b←{⍵⌽⍨-×-\⍳≢⍵}∘⍉

यह {rotate- × - \ ⍳≢⍵} मैट्रिक्स की प्रत्येक पंक्ति को घुमाएगा- वेक्टर -1 1 -1 1 आदि का अनुसरण करें (जिसमें इसकी वेक्टर लंबाई तर्क मैट्रिक्स पंक्तियों की लंबाई हो)। परीक्षा:

  ⎕←a←3 5⍴⎕A
ABCDE
FGHIJ
KLMNO
  ⎕←c a
OKGMI
LCNEA
JFBHD

Comments

आइए हम इस चर्चा को चैट में जारी रखते हैं ।

— आउटगोल्फ़र

Answer 17

बाश एट अल, 84

गैर-प्रतिस्पर्धी शेल समाधान।

यह एक फ़ंक्शन के आसपास आधारित है जो पंक्तियों के रोटेशन की दिशा को वैकल्पिक करता है। ट्रांसपोज़्ड सरणी पर की गई समान प्रक्रिया कॉलम को घुमाएगी। उदाहरण के लिएtranspose | rotate | transpose | rotate ।

बारी बारी से sedइस तरह के साथ एकल चरित्र सरणियों पर किया जा सकता है :

sed -E 's/(.*) (.)$/\2 \1/; n; s/^(.) (.*)/\2 \1/'

ट्रांसपोज़िशन के साथ rsया किया जा सकता है datamash:

rs -g1 -T
datamash -t' ' transpose

एक साथ लिया:

r() { sed -E 's/(.*) (.)$/\2 \1/; n; s/^(.) (.*)/\2 \1/'; }
t() { rs -g1 -T; }
<f t | r | t | r

आउटपुट:

o k g m i
l c n e a
j f b h d