^{Aus dieser Stackoverflow-Frage}

Bei einem 2D-Array der Größe werden die Werte gegen den Uhrzeigersinn ausgegeben. Die Ausgabe muss von außen nach innen beginnen und der Anfangspunkt wird immer .$M \times N$$(0,0)$

Beispiel gegeben:

$$\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}$$

Die im Gegenuhrzeigersinn sind dann .$1,5,9,13,14,15,16,12,8,4,3,2$

Nun wiederholen wir den Vorgang für die inneren Werte. Dies ergibt eine Matrix wie die folgende

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

Und die inneren Werte sind dann$6,10,11,7$

Das Endergebnis wird dann$1,5,9,13,14,15,16,12,8,4,3,2,6,10,11,7$

---

Regeln

• Nehmen Sie eine nicht leere Eingabe an
• Nehmen Sie Matrixwerte als positive ganze Zahlen an
• Es gelten Standard- E / A-Methoden
• Es gelten die Standardregeln für Code-Golf und die Gewinnkriterien

---

Einige Testfälle

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

R , 54 Bytes

Mehrere Bytes, die von @ Giuseppe und @ J.Doe gespeichert wurden.

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

Probieren Sie es online!

Entfernen Sie die erste Spalte rekursiv und vertauschen Sie den Rest der Matrix in umgekehrter Reihenfolge bzw. transponieren Sie ihn (wobei die unterste Zeile zur neuen ersten Spalte wird), bis Sie nur noch eine Spalte haben. Ungolfed "traditionelle" Version:

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

Es wurde darauf hingewiesen, dass ncol(m)man Golf spielen könnte sum(m), um ein weiteres Byte zu sparen, da wir positive ganzzahlige Matrixwerte annehmen dürfen. Aber ich lasse es so, da es für alle Matrizen funktioniert (auch für Matrizen von Strings!)

Python 2 , 52 Bytes

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

Probieren Sie es online!

Pyth , 9 Bytes

shMM.utC_

Probieren Sie es hier aus!

Wie?

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.

Stax , 7 Bytes

ôQÖG·í<

Führen Sie es aus und debuggen Sie es

Es nimmt ein Array von Zeilen in einer Zeile und erzeugt eine durch Zeilenumbrüche getrennte Ausgabe.

Ausgepackt, ungolfed und kommentiert sieht es so aus.

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

Führen Sie dieses aus

Pyth, 20 Bytes

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

Probieren Sie es hier aus

Erläuterung

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.

ok , 12 bytes

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

Probieren Sie es online!

Dies missbraucht die tatsache, dass oK sich nicht allzu sehr um die umsetzungsform zu kümmern scheint. In k wäre dies 13 Byte : *:',/(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

Sauber , 69 Bytes

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

@o?

Probieren Sie es online!

Verschiebt die nächste Zeile / Spalte an den Anfang der Liste, damit das Muster im Argument übereinstimmt.

Für das erste Beispiel in der Challenge sieht das so aus:

@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] ++ @ []

Julia 0,7 , 47 Bytes

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

Probieren Sie es online!

Julia verfügt über eine praktische Funktion, mit der die Matrix um 90 Grad gedreht werden kann, sodass keine Umkehroperationen erforderlich sind.

Wie Sie den Compiler-Warnungen entnehmen können, müssen alle Komponenten der ternären Bedingung durch Leerzeichen getrennt sein. In Version 1.0 wurde dies tatsächlich erzwungen.

Seltsamerweise bestand in dieser Situation der kürzeste Weg, den ich fand, um aus der Rekursion auszubrechen, darin, einen Try-Catch-Block zu verwenden:

Julia 1.0 , 50 Bytes

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

Probieren Sie es online!

JavaScript (Node.js) , 89 Byte

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

Probieren Sie es online!

Nimmt die erste Spalte, transponiert die verbleibende, kehrt dann jede Zeile um (= dreht die Matrix um 90 Grad im Uhrzeigersinn) und wiederholt sie, bis das Array keine Einträge mehr enthält.

APL (Dyalog) , 24 22 Bytes

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

Probieren Sie es online!

Wie?

{×≢⍵:⍵[;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

05AB1E , 13 11 10 Bytes

ΔRøćRˆ}¯˜þ

-2 Bytes dank @Emigna .

Probieren Sie es online aus oder überprüfen Sie alle Testfälle .

Erläuterung:

Δ         # 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)

Gelee , 9 Bytes

ZḊUƊƬḢ€€Ẏ

Probieren Sie es online!

Holzkohle , 25 Bytes

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

Probieren Sie es online! Link ist eine ausführliche Version des Codes. Erläuterung:

≔⮌ＥＡ⮌ιθ

Drehen Sie den Eingang um 180 °. Dies hat zwei Gründe: a) Die letzte Reihe ist am einfachsten zu entfernen, und b) die Schleife ist einfacher, wenn die Reihe am Ende der Schleife entfernt wird. (Ich habe versucht, im Uhrzeigersinn zu reflektieren und auszugeben, aber das hat ein zusätzliches Byte gekostet.)

Ｗθ«

Wiederholen, bis das Array leer ist.

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

Drehen Sie das Array um 90 °.

Ｉ⊟θ

Entfernen Sie die letzte Zeile des Arrays und drucken Sie das Element als Zeichenfolge in separaten Zeilen.

Ruby , 65 Bytes

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

Probieren Sie es online!

PowerShell , 266 Byte

Ja. PowerShell ist nicht das Beste für den Umgang mit Matrizen. Der Algorithmus ist jedoch im Grunde derselbe wie oben. Jede Zeile wird als durch Kommas getrennte Zeichenfolge dargestellt, und wir führen im Grunde eine Rotation und Transposition für jede Ebene durch. Ich kann mich wahrscheinlich mehr rasieren, aber ... ich bin schon im Schlafanzug ...

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','}

Probieren Sie es online!