एक 2 डी सरणी के विरोधी दक्षिणावर्त आवक आउटपुट

Question

^{से इस stackoverflow सवाल}

$M \times N$ आकार के 2 डी सरणी को देखते हुए , एक एंटी-क्लॉकवाइज फैशन में मूल्यों का उत्पादन करते हैं। आउटपुट बाहर से अंदर की ओर शुरू होना चाहिए और प्रारंभिक बिंदु हमेशा $(0,0)$ ।

उदाहरण दिया:

$$\begin{bmatrix} \color{blue}1&\color{red}2&\color{red}3&\color{red}4 \\ \color{red}5&6&7&\color{red}8 \\ \color{red}9&10&11&\color{red}{12} \\ \color{red}{13}&\color{red}{14}&\color{red}{15}&\color{red}{16}\end{bmatrix}$$

वामावर्त में बढ़त मान $1,5,9,13,14,15,16,12,8,4,3,2$ ।

अब हम आंतरिक मूल्यों के लिए प्रक्रिया को दोहराते हैं। यह निम्नलिखित की तरह एक मैट्रिक्स के साथ समाप्त होगा

$$\begin{bmatrix} \color{blue}6&\color{red}7 \\ \color{red}{10}&\color{red}{11} \end{bmatrix}$$

और भीतर का मान $6,10,11,7$

अंतिम परिणाम तब $1,5,9,13,14,15,16,12,8,4,3,2,6,10,11,7$

---

नियम

• गैर-रिक्त इनपुट मान लें
• मैट्रिक्स मानों को सकारात्मक पूर्णांक मान लें
• मानक I / O विधियाँ लागू होती हैं
• मानक कोड-गोल्फ नियम और जीतने के मापदंड लागू होते हैं

---

कुछ परीक्षण मामले

Input
[
  [1, 2, 3, 4, 5, 6, 7],
  [8, 9, 10,11,12,13,14],
  [15,16,17,18,19,20,21]
]
Output
1,8,15,16,17,18,19,20,21,14,7,6,5,4,3,2,9,10,11,12,13

--------------------------------------------------------

Input
[
    [1,2,3],
    [3,2,1],
    [4,5,6],
    [6,5,4],
    [7,8,9],
    [9,8,7]
]
Output
1,3,4,6,7,9,8,7,9,4,6,1,3,2,2,5,5,8

-----------------------------------------------------
Input
[
    [1]
]
Output
1
-----------------------------------
Input
[
    [1, 2],
    [2, 1]
]
Output
1,2,1,2
-----------------------------------------------------
Input
[
    [1,2,3,6,7],
    [2,4,3,2,1],
    [3,2,4,5,6],
    [6,5,6,5,4],
    [10,4,7,8,9],
    [12,4,9,8,7]
]
Output
1,2,3,6,10,12,4,9,8,7,9,4,6,1,7,6,3,2,4,2,5,4,7,8,5,5,2,3,4,6

Comments

तो क्या हम दक्षिणावर्त या वामावर्त जा रहे हैं?

— लीजियनममाल 978

@ LegionMammal978 वामावर्त (हालांकि मैं इसे एंटी-क्लॉकवाइज कहा जाता था)

— लुइस फेलिप डी जीसस मुनोज

एंटी और काउंटर-क्लॉकवाइज दोनों सही हैं, क्रमशः ब्रूग और एंबे में प्रत्येक अधिक सामान्य के साथ। यदि आप वास्तव में भ्रमित करना चाहते हैं, तो आप विदरशिन का भी उपयोग कर सकते हैं ।

— डिजिटल ट्रामा

Answer 1

आर , 54 बाइट्स

@Giuseppe और @ J.Doe द्वारा सहेजे गए कई बाइट्स।

f=function(m)if(ncol(m))c(m[,1],f(t(m[nrow(m):1,-1])))

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

पुनरावर्ती रूप से पहले स्तंभ को बंद करें और पंक्ति-उल्टा / स्थानांतरित करें (नीचे की पंक्ति को नया पहला स्तंभ बनाते हुए) बाकी मैट्रिक्स तब तक दें जब तक आप केवल एक स्तंभ के साथ समाप्त नहीं हो जाते। Ungolfed "पारंपरिक" संस्करण:

f <- function(m) {
 if(ncol(m) == 1) {
    m
  } else {
    c(m[,1], f(t(m[nrow(m):1,-1])))
  }
}

यह इंगित किया गया था कि एक अन्य बाइट को बचाने के ncol(m)लिए गोल्फ हो सकता है sum(m)क्योंकि हमें सकारात्मक पूर्णांक मैट्रिक्स मूल्यों को मानने की अनुमति है। लेकिन मैं इसे इस तरह छोड़ दूंगा क्योंकि यह सभी मैट्रिसेस (स्ट्रिंग्स के मैट्रीस के लिए भी काम करता है!)

Comments

वाह! मैं प्यार करता हूँ कि कैसे के उपयोग t()को रोकता है drop=TRUEके लिए डिफ़ॉल्ट `[`पंगा लेना से ifहालत!

— Giuseppe

और पूर्ण प्रकटीकरण, मेरे पास लगभग 200 बाइट समाधान था जो काम भी नहीं करता था, इसलिए यदो को यस! मैं शायद इस बात के लिए आपको इनाम देने के लिए तैयार हो जाऊं कि यह सवाल एक बार इनाम के योग्य है।

— ग्यूसेप

@ 59 बाइट्स पर वापस जाएं! मुझे अपने मूल प्रयासों में परीक्षण t()का उपयोग न करने से सुखद आश्चर्य हुआ is.null।

— एनएमसी

क्या यह mकिसी भी तरह से अंतिम नहीं है , इसलिए आप 54 बाइट्स के लिए स्टेटमेंट बदल सकते हैं । परीक्षण मामलों के लिए काम करने लगता है।

— जे। डो।

Answer 2

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

f=lambda a:a and zip(*a)[0]+f(zip(*a[::-1])[1:])or()

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

Answer 3

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

shMM.utC_

यहाँ यह कोशिश करो!

कैसे?

shMM.utC_     Full program. Takes a 2D array (matrix) from STDIN.
    .u        Until a result that has occurred before is found, loop and collect...
        _     Reverse the matrix (reverse the order of its rows).
       C      Transpose.
      t       Remove first element.
 hMM          For each element in the resulting 3D array, get the heads of its elements.
s             Flatten.

Comments

यह अच्छा है। एक पायनियर शुरुआत के रूप में अब मुझे पता है कि मुझे बहुत कुछ सीखना है,

— ElPedro

Answer 4

स्टैक्स , 7 बाइट्स

ôQÖG·í<

इसे चलाएं और डीबग करें

यह एक पंक्ति में पंक्तियों की एक सरणी लेता है, और newline- अलग आउटपुट का उत्पादन करता है।

अनपैक्ड, अनगुल्फेड और टिप्पणी की गई, यह इस तरह दिखता है।

W       repeat the rest of the program until cancelled explicitly
  rM    rotate matrix *clock-wise* (yes, this is the opposite of the challenge)
  |c    assert matrix is truthy. (has rows) cancel otherwise.
  B     remove the top row of the matrix, and push separately to main stack
  rm    reverse the top row (this fixes the rotation direction), and print each value

इसको चलाओ

Answer 5

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

J.TQWJ=+YhJ=J_.TtJ)Y

इसे यहाँ आज़माएँ

व्याख्या

J.TQWJ=+YhJ=J_.TtJ)Y
J.TQ                    Call the transposed input J.
    WJ            )     While J is not empty...
      =+YhJ             ... put the top row into Y (initially [])...
           =J   tJ      ... remove the top row...
             _.T        ... reverse and transpose (rotate clockwise).
                   Y    Output the result.

Answer 6

ओ.के. , 12 बाइट्स

*+,/(1_+|:)\

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

यह इस तथ्य का दुरुपयोग करता है कि ओके ट्रांसपोज़िशन के लिए आकार के बारे में बहुत अधिक परवाह नहीं करता है। कश्मीर में इस होगा 13 बाइट्स : *:',/(1_+|:)\।

       +|:   /reverse, then transpose (rotate right)
     1_      /remove first line
    (     )\ /fixpoint of the above, keeping intermediate results (scan)
  ,/         /concatenate all the rows
*+           /get the first element of each row

Answer 7

साफ , 69 बाइट्स

import StdEnv,StdLib
? =transpose
@[h:t]=h++ @(reverse(?t))
@_=[]

@o?

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

अगली पंक्ति / स्तंभ को सूची के प्रमुख पर ले जाता है ताकि यह तर्क में मिलान हो सके।

चुनौती में पहले उदाहरण के लिए, ऐसा दिखता है:

@o? [[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12], [13, 14, 15, 16]]
@ h=:[1, 5, 9, 13] t=:[[2, 6, 10, 14], [3, 7, 11, 15], [4, 8, 12, 16]]
[1, 5, 9, 13] ++ @ h=:[14, 15, 16] t=:[[10, 11, 12], [6, 7, 8], [2, 3, 4]]
[1, 6, 9, 13, 14, 15, 16] ++ @ h=:[12, 8, 4] t=:[[11, 7, 3], [10, 6, 2]]
[1, 6, 9, 13, 14, 15, 16, 12, 8, 4] ++ @ h=:[3, 2] t=:[[7, 6], [11, 10]]
[1, 6, 9, 13, 14, 15, 16, 12, 8, 4, 3, 2] ++ @ h=:[6, 10] t=:[[7, 11]]
[1, 6, 9, 13, 14, 15, 16, 12, 8, 4, 3, 2, 6, 10] ++ @ h=:[11, 7] t=:[]
[1, 6, 9, 13, 14, 15, 16, 12, 8, 4, 3, 2, 6, 10, 11, 7] ++ @ []

Answer 8

जूलिया 0.7 , 47 बाइट्स

f(m)=[m[:,1];sum(m)<1?[]:f(rotr90(m[:,2:end]))]

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

जूलिया में मैट्रिक्स को घुमाने के लिए एक सुविधाजनक अंतर्निहित 90 डिग्री है, जो ट्रांसपोज़-रिवर्स ऑपरेशन की आवश्यकता को समाप्त करता है।

जैसा कि आप कंपाइलर चेतावनियों से देख सकते हैं, यह जोर देता है कि टर्नरी सशर्त के सभी घटकों को रिक्त स्थान द्वारा अलग किया जाना चाहिए, और v। 1.0 में यह वास्तव में लागू किया गया है।

विचित्र रूप से पर्याप्त है, इस स्थिति में मुझे पुनरावृत्ति से बाहर निकलने का सबसे छोटा तरीका एक कोशिश-ब्लॉक का उपयोग करना था:

जूलिया 1.0 , 50 बाइट्स

f(m)=[m[:,1];try f(rotr90(m[:,2:end]))catch;[]end]

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

Answer 9

जावास्क्रिप्ट (Node.js) , 89 बाइट्स

f=a=>a>[]?[...a.map(x=>x[0]),...f(a[0].map((_,i)=>a.map(y=>y[i]).reverse()).slice(1))]:[]

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

पहले स्तंभ को ले जाता है, शेष को फिर से स्थानांतरित करता है, फिर प्रत्येक पंक्ति को उल्टा करता है (= मैट्रिक्स 90 डिग्री सीडब्ल्यू घुमाएं), और तब तक दोहराएं जब तक कि सरणी में अधिक प्रविष्टियां न हों।

Answer 10

APL (Dyalog) , 24 22 बाइट्स

{×≢⍵:⍵[;1],∇⍉⊖0 1↓⍵⋄⍬}

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

कैसे?

{×≢⍵:⍵[;1],∇⍉⊖0 1↓⍵⋄⍬}
{                    } - a function
 ×≢⍵:                  - if non-empty:
     ⍵[;1]             - the left column
          ,∇⍉⊖0 1↓⍵    - repeat this function without the left column, rotated counter clockwise
                   ⋄⍬  - otherwise, return an empty vector

Comments

ऑपरेटरों का स्पष्टीकरण अच्छा होगा।

— Arc676

@ Arc676, जोड़ा!

— Zacharý

Answer 11

05AB1E , 13 11 10 बाइट्स

ΔRøćRˆ}¯˜þ

-2 बाइट्स को धन्यवाद @Emigna की बदौलत ।

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

Δ         # Loop until the stack no longer changes:
 R        #  Reverse the order of the rows
          #   i.e. [[1,2,3,4],[5,6,7,8],[9,10,11,12],[13,14,15,16]]
          #    → [[13,14,15,16],[9,10,11,12],[5,6,7,8],[1,2,3,4]]
  ø       #  Zip, swapping rows and column
          #   → [[13,9,5,1],[14,10,6,2],[15,11,7,3],[16,12,8,4]]
   ć      #  Head extracted
          #   → [[14,10,6,2],[15,11,7,3],[16,12,8,4]] and [13,9,5,1]
    R     #  Reverse this row
          #   → [1,5,9,13]
     ˆ    #  Pop and push it to the global array
}         # After the loop:
 ¯        #  Push the global array
          #   i.e. [[1,5,9,13],[14,15,16],[12,8,4],[3,2],[6,10],[11],[7],"",""]
  ˜       #  Flatten it
          #   → [1,5,9,13,14,15,16,12,8,4,3,2,6,10,11,7,"",""]
   þ      #  Remove all empty string by only leaving all digits
          #   → ["1","5","9","13","14","15","16","12","8","4","3","2","6","10","11","7"]
          # (and output it implicitly)

Answer 12

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

ZḊUƊƬḢ€€Ẏ

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

Answer 13

चारकोल , 25 बाइट्स

≔⮌ＥＡ⮌ιθＷθ«≔Ｅ§θ⁰⮌Ｅθ§μλθＩ⊟θ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

≔⮌ＥＡ⮌ιθ

180 ° से इनपुट घुमाएँ। यह दो कारणों से है: ए) अंतिम पंक्ति को हटाना सबसे आसान है, और बी) यदि लूप के अंत में पंक्ति को हटा दिया जाता है तो यह लूप करना आसान है। (मैंने दक्षिणावर्त को प्रतिबिंबित करने और आउटपुट करने की कोशिश की, लेकिन यह एक अतिरिक्त बाइट लिया।)

Ｗθ«

सरणी खाली होने तक दोहराएं।

≔Ｅ§θ⁰⮌Ｅθ§μλθ

सरणी को 90 ° से घुमाएं।

Ｉ⊟θ

सरणी की अंतिम पंक्ति निकालें और तत्व को अलग-अलग लाइनों पर स्ट्रिंग्स के रूप में प्रिंट करें।

Answer 14

रूबी , 65 बाइट्स

->a{x,*a=a.transpose;(w,*a=a.transpose.reverse;x+=w)while a[0];x}

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

Answer 15

पॉवरशेल , 266 बाइट्स

हाँ .. मैट्रिस से निपटने के लिए PowerShell सबसे अच्छा नहीं है। लेकिन, एल्गोरिथ्म मूल रूप से ऊपर के समान है .. प्रत्येक पंक्ति को अल्पविराम से अलग स्ट्रिंग के रूप में दर्शाया गया है, और हम मूल रूप से प्रत्येक परत के लिए एक रोटेशन और ट्रांसपोज़ेशन करते हैं। मैं शायद और अधिक बंद दाढ़ी कर सकते हैं, लेकिन ... मैं कर रहा हूँ पहले से ही अपने पजामा में ...

Filter F{$a=$_-replace"],|]|\s",''-split'\['|?{$_-ne''};$b=@();while($a-ne $null){$N=($a[0]-split',').Count-1;$a=0..$N|%{$i=$_;($a|%{($_-split',')[$i]})-join','};if($d){[array]::Reverse($a)}if($N-gt0){$b+=$a[0];$a=$a[1..$N]}else{$b+=$a;$a=$null};$d=$true}$b-join','}

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