^{Z tego pytania dotyczącego przepływu stosu}

Biorąc pod uwagę tablicę 2D o rozmiarze $M \times N$ , wypisz wartości w kierunku przeciwnym do ruchu wskazówek zegara. Wyjście musi zaczynać się od zewnątrz do wewnątrz, a początkowy punkt zawsze będzie .$(0,0)$

Podany przykład :

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

Wartości krawędzi w kierunku przeciwnym do ruchu wskazówek zegara wynoszą wówczas .$1,5,9,13,14,15,16,12,8,4,3,2$

Teraz powtarzamy proces dla wewnętrznych wartości. To zakończy się macierzą podobną do poniższej

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

A wartości wewnętrzne wynoszą wtedy $6,10,11,7$

Ostateczny wynik to $1,5,9,13,14,15,16,12,8,4,3,2,6,10,11,7$

---

Zasady

• Załóżmy, że dane wejściowe są niepuste
• Przyjmij wartości macierzy jako dodatnie liczby całkowite
• Standardowe I / O Sposoby zastosowania
• Obowiązują standardowe zasady gry w golfa i kryteria wygranej

---

Niektóre przypadki testowe

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 bajty

Kilka bajtów zapisanych przez @Giuseppe i @ J.Doe.

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

Wypróbuj online!

Rekurencyjnie usuń pierwszą kolumnę i odwróć wiersz / transponuj (zmieniając dolny wiersz w nową pierwszą kolumnę) resztę macierzy, aż skończy się tylko jedna kolumna. Wersja „tradycyjna” bez golfisty:

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

Wskazano, że ncol(m)można zapisać w golfa, aby sum(m)zaoszczędzić kolejny bajt, ponieważ możemy przyjmować dodatnie wartości macierzy całkowitych. Ale zostawię to tak, ponieważ działa dla wszystkich macierzy (nawet macierzy ciągów!)

Python 2 , 52 bajty

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

Wypróbuj online!

Pyth , 9 bajtów

shMM.utC_

Wypróbuj tutaj!

W jaki sposób?

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 bajtów

ôQÖG·í<

Uruchom i debuguj

Pobiera tablicę wierszy w jednym wierszu i tworzy wynik oddzielony znakiem nowej linii.

Rozpakowane, niepolowane i skomentowane, wygląda to tak.

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

Uruchom ten

Pyth, 20 bajtów

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

Wypróbuj tutaj

Wyjaśnienie

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 bajtów

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

Wypróbuj online!

To narusza fakt, że ok nie wydaje się zbytnio dbać o kształt do transpozycji. W k byłoby to 13 bajtów : *:',/(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

Czysty , 69 bajtów

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

@o?

Wypróbuj online!

Przenosi następny wiersz / kolumnę na początek listy, aby mógł wzorować się na argumencie.

Dla pierwszego przykładu w wyzwaniu wygląda to następująco:

@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 bajtów

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

Wypróbuj online!

Julia ma wygodny wbudowany mechanizm obracania matrycy o 90 stopni, co eliminuje potrzebę operacji transpozycji do tyłu.

Jak widać z ostrzeżeń kompilatora, nalega, aby wszystkie składniki warunku trójskładnikowego były oddzielone spacjami, aw wersji 1.0 zostało to faktycznie wymuszone.

O dziwo, w tej sytuacji najkrótszym sposobem na wyjście z rekurencji było użycie bloku try-catch:

Julia 1.0 , 50 bajtów

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

Wypróbuj online!

JavaScript (Node.js) , 89 bajtów

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

Wypróbuj online!

Bierze pierwszą kolumnę, transponuje pozostałą, a następnie odwraca każdy wiersz (= obróć matrycę o 90 stopni CW), a następnie powtarzaj, aż do tablicy nie będzie już żadnych wpisów.

APL (Dyalog) , 24 22 bajtów

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

Wypróbuj online!

W jaki sposób?

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

ΔRøćRˆ}¯˜þ

-2 bajty dzięki @Emigna .

Wypróbuj online lub sprawdź wszystkie przypadki testowe .

Wyjaśnienie:

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

Galaretka , 9 bajtów

ZḊUƊƬḢ€€Ẏ

Wypróbuj online!

Węgiel , 25 bajtów

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

Wypróbuj online! Link jest do pełnej wersji kodu. Wyjaśnienie:

≔⮌ＥＡ⮌ιθ

Obróć wejście o 180 °. Wynika to z dwóch powodów: a) ostatni rząd jest najłatwiejszy do usunięcia, i b) łatwiej jest zapętlić, jeśli rząd zostanie usunięty na końcu pętli. (Próbowałem odzwierciedlać i generować zgodnie z ruchem wskazówek zegara, ale zajęło to dodatkowy bajt.)

Ｗθ«

Powtarzaj, aż tablica będzie pusta.

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

Obróć tablicę o 90 °.

Ｉ⊟θ

Usuń ostatni wiersz tablicy i wydrukuj element jako ciągi w osobnych wierszach.

Rubinowy , 65 bajtów

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

Wypróbuj online!

PowerShell , 266 bajtów

Tak .. PowerShell nie jest najlepszy do obsługi macierzy. Ale algorytm jest w zasadzie taki sam jak powyżej. Każdy wiersz jest reprezentowany jako ciąg oddzielony przecinkami, i zasadniczo wykonujemy obrót i transpozycję dla każdej warstwy. Prawdopodobnie mogę golić się więcej, ale ... ja jestem już w piżamie ...

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

Wypróbuj online!