Drehen Sie die Antidiagonalen

32

Hintergrund

In den meisten vernünftigen Programmiersprachen ist es sehr einfach, die Zeilen oder Spalten eines 2D-Arrays zu drehen. In dieser Herausforderung müssen Sie stattdessen die Antidiagonalen drehen . Denken Sie daran, dass die Antidiagonalen eines 2D-Arrays seine 1D-Schnitte sind, die in nordöstlicher Richtung ↗ aufgenommen wurden.

Eingang

Ein nicht leeres rechteckiges 2D-Array mit einstelligen Zahlen in einem beliebigen Format. Beachten Sie, dass das Array möglicherweise kein Quadrat ist.

Ausgabe

Das gleiche Array, aber mit jeder Antidiagonale einen Schritt nach rechts gedreht.

Beispiel

Betrachten Sie das 3x4Eingabearray

0 1 2 3
4 5 6 7
8 9 0 1

Die Antidiagonalen dieses Arrays sind

0
4 1
8 5 2
9 6 3
0 7
1

Ihre gedrehten Versionen sind

0
1 4
2 8 5
3 9 6
7 0
1

Somit ist die korrekte Ausgabe

0 4 5 6
1 8 9 0
2 3 7 1

Regeln und Wertung

Sie können ein vollständiges Programm oder eine Funktion schreiben. Es ist auch akzeptabel, eine Funktion zu schreiben, die das Eingabearray an Ort und Stelle ändert, wenn Ihre Sprache dies zulässt. Die niedrigste Byteanzahl gewinnt, und Standardlücken sind nicht zulässig.

Bestenliste

Hier ist ein Stack-Snippet, um sowohl eine reguläre Rangliste als auch eine Übersicht der Gewinner nach Sprache zu generieren.

Um sicherzustellen, dass Ihre Antwort angezeigt wird, beginnen Sie Ihre Antwort mit einer Überschrift. Verwenden Sie dazu die folgende Markdown-Vorlage:

## Language Name, N bytes

Wo Nist die Größe Ihres Beitrags? Wenn Sie mehrere Zahlen in Ihre Kopfzeile aufnehmen möchten (z. B. weil Ihre Punktzahl die Summe von zwei Dateien ist, oder wenn Sie die Strafen für Interpreter-Flags separat auflisten möchten oder wenn Sie alte, von Ihnen verbesserte Punktzahlen anzeigen möchten), stellen Sie sicher, dass die tatsächliche Punktzahl vorliegt ist die letzte Zahl in der Kopfzeile.

Code-Snippet anzeigen

Zusätzliche Testfälle

Input:
4
Output:
4

Input:
5 6 1
Output:
5 6 1

Input:
0 1
6 2
Output:
0 6
1 2

Input:
6 3 0 8
4 6 1 4
6 2 3 3
9 3 0 3
Output:
6 4 6 1
3 6 2 3
0 9 3 0
8 4 3 3

Input:
5 8 2
6 7 3
2 6 1
6 0 6
6 4 1
Output:
5 6 7
8 2 6
2 6 0
3 6 4
1 6 1

Input:
9 9 4 0 6 2
2 3 2 6 4 7
1 5 9 3 1 5
0 2 6 0 4 7
Output:
9 2 3 2 6 4
9 1 5 9 3 1
4 0 2 6 0 4
0 6 2 7 5 7
code-golf array-manipulation Zgarb
quelle

Antworten:

20

CJam, 20

{z_)\zLa+(@+\.+s\,/}

Als Funktionsblock geschrieben. Probieren Sie es online aus

Erläuterung:

Die Eingabe kann folgendermaßen angezeigt werden:

Eingabediagramm

Das heißt, wir trennen die obere Zeile und die rechte Spalte vom Rest der Matrix und betrachten diese Elemente in der durch den Pfeil angezeigten Reihenfolge.

Dann sieht die Ausgabe so aus:

Ausgabediagramm

Der verbleibende rechteckige Block wird als Ganzes diagonal verschoben, und die Randelemente werden in der durch den neuen Pfeil angegebenen Reihenfolge / Position neu angeordnet.

Der Code macht fast genau das, außer dass die Ausgabe zuerst mit dem Pfeil erzeugt wird, der gerade nach unten geht (die Matrix hat also einen Schwanz, wie der Buchstabe P), und dann korrigiert wird.

z      zip (transpose) the matrix
_      make a copy
)      take out the last row (right column before transposing)
\      swap with the rest of the matrix
z      transpose back
La+    append an empty row (needed for the single-column case,
        which leaves an empty matrix here)
(      take out the first row (top row without the corner)
@+     bring the right column to the top of the stack and concatenate
        obtaining an array of the edge elements (marked with the blue arrow)
\      swap with the remaining part (big white block in the diagrams)
.+     concatenate element by element
        each edge element is concatenated with a row of the white block
        after the white block runs out, the remaining elements form new rows
s      convert the whole thing to a string (concatenating all rows)
\      swap with the copy of the transposed matrix
,      get its length (number of original columns)
/      split the string into rows of that length
aditsu
quelle
Die Pyth-Antwort ist ebenfalls 20 Bytes, aber deine war früher, also akzeptiere ich sie.
Zgarb
9

CJam, 44 43 42 40 Bytes

qN/:ReeSf.*:sz1fm<{Rz,{(S-(o\}*~]{},No}h

Teste es hier.

Hmm, viel besser als mein erster Versuch, aber ich habe das Gefühl, Dennis wird das sowieso in viel weniger lösen ...

Ein- und Ausgabe erfolgen als ASCII-Gitter:

0123
4567
8901

gibt

0456
1890
2371
Martin Ender
quelle
7
Die durchgestrichene 44 ist immer noch die reguläre 44; (
AdmBorkBork 13.11.15
3
@TimmyD Ich hätte bis zum Ende der Kulanzfrist warten sollen, um es von 47 bis 43 zu bearbeiten.: P
Martin Ender
Ja! Es ist ein Mem geworden .
intrepidcoder
1
Ich ging schließlich und lernte eine Golfsprache, so dass ich 4 Bytes bis 3 Golf spielen und der Gliederkette beitreten konnte :)
Khuldraeseth na'Barya
6

J, 24 char

Funktion mit einem Argument.

$$<@(1&|.)/./:&;</.@i.@$

J hat einen Operator /.namens Oblique . Es kann nicht invertiert werden, so dass die Rekonstruktion nicht trivial ist, aber Sie können das Auflisten von Obliques als eine Permutation der Elemente des Arrays betrachten. Also kehren wir diese Permutation mit /:(dyadic Sort ) um, indem wir die Permutation "Listing obliques" für diese Größe ( </.@i.@$) rechts und unsere neuen Werte für oblique, richtig gedreht, links setzen. Dann formen wir diese Liste mit good old in das alte rechteckige Array um $$.

   3 4$i.10
0 1 2 3
4 5 6 7
8 9 0 1
   ($$<@(1&|.)/./:&;</.@i.@$) 3 4$i.10
0 4 5 6
1 8 9 0
2 3 7 1

Probieren Sie es online aus.

algorithmshark
quelle
Dies ist Peak J hier. Gut gemacht.
Jonah,
5

J, 38-30 Bytes

8 Bytes gespart dank @algorithmshark.

{./.((}.~#),~({.~#),.])}:"1@}.

Die Funktion sammelt die oberen und linken Ränder in einer Liste, schneidet die Liste in zwei Teile mit ausreichender Größe und näht sie rechts und unten im Kernteil.

Verwendung:

   ]input=.0 1 2 3, 4 5 6 7,: 8 9 0 1
0 1 2 3
4 5 6 7
8 9 0 1
   ({./.((}.~#),~({.~#),.])}:"1@}.) input
0 4 5 6
1 8 9 0
2 3 7 1

Probieren Sie es hier online aus.

randomra
quelle
1
Down to 30 Zeichen: {./.ersetzt }:@{.,{:"1, und Sie können um durch Umklappen des Zuges zwei Tilden sparen: {./.((}.~#),~({.~#),.])}:"1@}..
Algorithmushai
4

Julia, 153 149 139 Bytes

A->(length(A)>1&&((m,n)=size(A);r(X)=for i=1:n X[:,i]=reverse(X[:,i])end;r(A);for i=-m:m A[diagind(A,i)]=circshift(diag(A,i),1)end;r(A));A)

Dadurch wird eine unbenannte Funktion erstellt, die ein Array akzeptiert und das an Ort und Stelle geänderte Eingabearray zurückgibt.

Ungolfed:

# Create a function to reverse the columns of a matrix
function revcols!(X)
    for = 1:size(X, 2)
        X[:,i] = reverse(X[:,i])
    end
    return X
end

# Our main function
function zgarb!(A)
    # Only perform operations if the array isn't one element
    if length(A) > 1
        # Record the number of rows
        m = size(A, 1)

        # Reverse the columns in place
        revcols!(A)

        # Shift each diagonal
        for i = -m:m
            A[diagind(A, i)] = circshift(diag(A, i), 1)
        end

        # Reverse the columns back
        revcols!(A)
    end
    return A
end

Vielen Dank an Martin Büttner für die algorithmische Beratung und die Einsparung von 4 Bytes!

Alex A.
quelle
3

ES6, 75 Bytes

Dies akzeptiert ein Array von Arrays als Parameter und ändert es an Ort und Stelle.

a=>{t=a.shift();a.map(r=>{t.push(r.pop());r.unshift(t.shift())});a.push(t)}

Ungolfed:

function anti_diagonal(array) {
    var temp = array.shift(); // strip off the first row
    array.forEach(row => temp.push(row.pop())); // strip off the last elements of each row
    array.forEach(row => row.unshift(temp.shift())); // distribute the elements to the beginning of each row
    array.push(temp); // the remaining elements become the last row
}

Weitere Erläuterungen finden Sie im @ aditsu-Diagramm.

Neil
quelle
Sie könnten 2 Bytes sparen, indem Sie {t.push(r.pop());r.unshift(t.shift())}zut.push(r.pop())+r.unshift(t.shift())
user81655
3

Pyth, 20 Bytes

J+PhQ.)MQ++L.(J0tQ]J

Verwendet Adistus Ansatz, die obere Reihe und die rechte Spalte zu entfernen und sie dann links und unten anzubringen. Aber mit veränderlichen Datenstrukturen, nicht mit Transpositionen.

isaacg
quelle
2

Oktave, 85 Bytes

@(a)[(b=[a(1,1:end),a(2:end,end)'])(1:(s=size(a)(1)))',[a(2:end,1:end-1);b(s+1:end)]]

Ich hoffe ich konnte das ends loswerden .

Alephalpha
quelle
1

Python 2 , 113 104 94 Bytes

f=lambda i,b=[]:i and[b and b[:1]+i[0][:-1]]+f(i[1:],b[1:]or i[0][:-1]+[l[-1]for l in i])or[b]

Probieren Sie es online!

Dies ist eine ziemlich wörtliche Interpretation der @ aditsu-Methode. Die Syntax von Python für die Behandlung leerer Listen als "Falsch" hat dazu beigetragen, zusätzliche 10 Byte zu sparen.

SmileAndNod
quelle
8 Bytes durch
Löschen
Weitere Testfälle
SmileAndNod
1
Sie brauchen wahrscheinlich nicht die 0in[0:1]
Jo King