Ruota le anti-diagonali


32

sfondo

Nei linguaggi di programmazione più ragionevoli, è molto facile ruotare le righe o le colonne di un array 2D. In questa sfida, il tuo compito è quello di ruotare le anti-diagonali . Ricordiamo che le anti-diagonali di un array 2D sono le sue sezioni 1D prese nella direzione nord-est ↗.

Ingresso

Un array 2D rettangolare non vuoto di numeri a una cifra in qualsiasi formato ragionevole. Si noti che l'array potrebbe non essere un quadrato.

Produzione

Lo stesso array, ma con ogni anti-diagonale ruotava di un passo verso destra.

Esempio

Considera l' 3x4array di input

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

Le anti-diagonali di questo array sono

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

Le loro versioni ruotate sono

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

Quindi l'output corretto è

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

Regole e punteggio

È possibile scrivere un programma completo o una funzione. È anche accettabile scrivere una funzione che modifica l'array di input in atto, se la tua lingua lo consente. Vince il conteggio di byte più basso e non sono consentite scappatoie standard.

Classifica

Ecco uno snippet di stack per generare sia una classifica regolare che una panoramica dei vincitori per lingua.

Per assicurarti che la tua risposta venga visualizzata, ti preghiamo di iniziare la risposta con un titolo, utilizzando il seguente modello Markdown:

## Language Name, N bytes

dov'è Nla dimensione del tuo invio. Se si desidera includere più numeri nell'intestazione (ad es. Perché il punteggio è la somma di due file o si desidera elencare separatamente le penalità di flag dell'interprete o si desidera mostrare i punteggi precedenti migliorati), assicurarsi che il punteggio effettivo è l' ultimo numero nell'intestazione.

Casi di prova aggiuntivi

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 

Risposte:


20

CJam, 20

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

Scritto come blocco funzionale. Provalo online

Spiegazione:

L'ingresso può essere visualizzato in questo modo:

diagramma di input

Cioè, separiamo la riga superiore e la colonna destra dal resto della matrice e consideriamo quegli elementi nell'ordine mostrato dalla freccia.

Quindi l'output è così:

diagramma di uscita

Il blocco rettangolare rimanente viene spostato in diagonale nel suo insieme e gli elementi del bordo vengono riorganizzati nell'ordine / posizioni mostrati dalla nuova freccia.

Il codice fa quasi esattamente questo, tranne per il fatto che l'output viene prima generato con la freccia rivolta verso il basso (quindi la matrice ha una coda, come la lettera P), quindi corretta.

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

Anche la risposta di Pyth è di 20 byte, ma la tua era precedente, quindi la accetto.
Zgarb,

9

CJam, 44 43 42 40 byte

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

Provalo qui.

Hmm, molto meglio del mio primo tentativo, ma ho la sensazione che Dennis lo risolverà in modo molto meno ...

Input e output sono come griglie ASCII:

0123
4567
8901

0456
1890
2371


3
@TimmyD Avrei dovuto aspettare fino alla fine del periodo di grazia per modificarlo da 47 fino a 43.: P
Martin Ender

Sì! È diventato un meme .
intrepidcoder

1
FINALMENTE sono andato e ho imparato una lingua da golf, così ho potuto giocare a golf da 4 byte a 3 e unirmi alla catena di collegamenti :)
Khuldraeseth na'Barya

6

J, 24 caratteri

Funzione che accetta un argomento.

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

J ha un operatore /.chiamato Oblique . Non può invertirlo, quindi la ricostruzione non è banale, ma puoi considerare "elencare gli obliqui" come una permutazione degli elementi dell'array. Quindi invertiamo quella permutazione con /:( Ordinamento diadico ), mettendo la permutazione "elenco obliqui" per quella dimensione ( </.@i.@$) a destra e i nostri nuovi valori obliqui, ruotati correttamente, a sinistra. Quindi rimodelliamo questo elenco nel vecchio array rettangolare usando good old $$.

   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

Provalo online.


Questo è il picco J proprio qui. Molto bene.
Giona

5

J, 38 30 byte

8 byte salvati grazie a @algorithmshark.

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

La funzione raccoglie i bordi superiore e sinistro in un elenco, taglia l'elenco in due pezzi di dimensioni sufficienti e li ricama a destra e in fondo alla parte centrale.

Uso:

   ]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

Provalo online qui.


1
Giù per 30 char: {./.sostituisce }:@{.,{:"1, e si può risparmiare due tilde lanciando il treno in giro: {./.((}.~#),~({.~#),.])}:"1@}..
algoritmo

4

Julia, 153 149 139 byte

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)

Ciò crea una funzione senza nome che accetta un array e restituisce l'array di input modificato in posizione.

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

Grazie a Martin Büttner per la consulenza algoritmica e per il risparmio di 4 byte!


3

ES6, 75 byte

Ciò accetta un array di matrici come parametro e lo modifica in posizione.

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
}

Vedi il diagramma di @aditsu per ulteriori chiarimenti.


È possibile salvare 2 byte cambiando {t.push(r.pop());r.unshift(t.shift())}int.push(r.pop())+r.unshift(t.shift())
user81655

3

Pyth, 20 byte

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

Utilizza l'approccio di Adistu per rimuovere la riga superiore e la colonna di destra, quindi incollarle a sinistra e in basso. Ma con strutture di dati mutabili, non trasposizioni.


2

Ottava, 85 byte

@(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)]]

Spero di potermi liberare della ends.


1

Python 2 , 113 104 94 byte

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]

Provalo online!

Questa è un'interpretazione abbastanza letterale del metodo di @aditsu. La sintassi di Python per il trattamento di elenchi vuoti come False ha contribuito a salvare altri 10 byte.


salvato 8 byte scartando le righe mentre vado
SmileAndNod


1
Probabilmente non avrai bisogno del 0in[0:1]
Jo King il
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.