Faites pivoter les anti-diagonales

32

Contexte

Dans la plupart des langages de programmation raisonnables, il est très facile de faire pivoter les lignes ou les colonnes d'un tableau 2D. Dans ce défi, votre tâche consiste à faire pivoter les anti-diagonales à la place. Rappelons que les anti-diagonales d'un réseau 2D sont ses tranches 1D prises dans la direction nord-est ↗.

Contribution

Un tableau 2D rectangulaire non vide de nombres à un chiffre dans n'importe quel format raisonnable. Notez que le tableau peut ne pas être un carré.

Sortie

Le même tableau, mais avec chaque anti-diagonale tournée d'un pas vers la droite.

Exemple

Considérez le 3x4tableau d'entrée

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

Les anti-diagonales de ce tableau sont

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

Leurs versions tournées sont

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

Ainsi, la sortie correcte est

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

Règles et notation

Vous pouvez écrire un programme complet ou une fonction. Il est également acceptable d'écrire une fonction qui modifie le tableau d'entrée en place, si votre langue le permet. Le nombre d'octets le plus bas l'emporte et les failles standard sont interdites.

Classement

Voici un extrait de pile permettant de générer à la fois un classement régulier et un aperçu des gagnants par langue.

Pour vous assurer que votre réponse apparaît, commencez votre réponse par un titre, en utilisant le modèle Markdown suivant:

## Language Name, N bytes

où Nest la taille de votre soumission. Si vous souhaitez inclure plusieurs nombres dans votre en-tête (par exemple, parce que votre score est la somme de deux fichiers, ou si vous souhaitez répertorier les sanctions d'indicateur d'interprétation séparément, ou si vous souhaitez afficher les anciens scores que vous avez améliorés), assurez-vous que le score réel est le dernier chiffre de l'en-tête.

Afficher l'extrait de code

Cas de test supplémentaires

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
la source

Réponses:

20

CJam, 20

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

Écrit en tant que bloc fonctionnel. Essayez-le en ligne

Explication:

L'entrée peut être visualisée comme ceci:

diagramme d'entrée

Autrement dit, nous séparons la ligne supérieure et la colonne de droite du reste de la matrice, et considérons ces éléments dans l'ordre indiqué par la flèche.

Ensuite, la sortie est comme ceci:

diagramme de sortie

Le bloc rectangulaire restant est déplacé en diagonale dans son ensemble, et les éléments de bord sont réorganisés dans l'ordre / les positions indiqués par la nouvelle flèche.

Le code fait presque exactement cela, sauf que la sortie est d'abord générée avec la flèche descendante (donc la matrice a une queue, comme la lettre P), puis corrigée.

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
la source
La réponse Pyth est également de 20 octets, mais la vôtre était antérieure, donc je l'accepte.
Zgarb
9

CJam, 44 43 42 40 octets

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

Testez-le ici.

Hmm, bien mieux que ma première tentative, mais j'ai le sentiment que Dennis résoudra cela beaucoup moins de toute façon ...

L'entrée et la sortie sont des grilles ASCII:

0123
4567
8901

donne

0456
1890
2371
Martin Ender
la source
7
Barré 44 est toujours régulier 44; (
AdmBorkBork
3
@TimmyD J'aurais dû attendre la fin de la période de grâce pour le modifier de 47 à 43.: P
Martin Ender
Oui! C'est devenu un mème .
intrepidcoder
1
Je suis enfin allé et j'ai appris une langue de golf pour pouvoir jouer au golf de 4 octets à 3 et rejoindre la chaîne de liens :)
Khuldraeseth na'Barya
6

J, 24 caractères

Fonction prenant un argument.

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

J a un opérateur /.appelé Oblique . Il ne peut pas l'inverser, donc la reconstruction n'est pas anodine, mais vous pouvez envisager de "lister les obliques" comme une permutation des éléments du tableau. Nous inversons donc cette permutation avec /:( Tri dyadique ), en plaçant la permutation "listant les obliques" pour cette taille ( </.@i.@$) à droite et nos nouvelles valeurs obliques, correctement tournées, à gauche. Ensuite, nous remodelons cette liste dans l'ancien tableau rectangulaire en utilisant du bon vieux $$.

   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

Essayez-le en ligne.

algorithmeshark
la source
C'est le pic J ici. Bien joué.
Jonah
5

J, 38 30 octets

8 octets enregistrés grâce à @algorithmshark.

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

La fonction rassemble les bords supérieur et gauche dans une liste, coupe la liste en deux morceaux de tailles suffisantes et les coud à droite et en bas de la partie centrale.

Usage:

   ]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

Essayez-le en ligne ici.

randomra
la source
1
Jusqu'à 30 CHAR: {./.remplace }:@{.,{:"1, et vous pouvez économiser deux tildes en retournant le train autour de : {./.((}.~#),~({.~#),.])}:"1@}..
algorithmshark
4

Julia, 153 149 139 octets

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)

Cela crée une fonction sans nom qui accepte un tableau et renvoie le tableau d'entrée modifié sur place.

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

Merci à Martin Büttner pour ses conseils algorithmiques et pour avoir économisé 4 octets!

Alex A.
la source
3

ES6, 75 octets

Cela accepte un tableau de tableaux comme paramètre et le modifie en place.

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
}

Voir le diagramme de @ aditsu pour plus de précisions.

Neil
la source
Vous pourriez économiser 2 octets en changeant {t.push(r.pop());r.unshift(t.shift())}àt.push(r.pop())+r.unshift(t.shift())
user81655
3

Pyth, 20 octets

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

Utilise l'approche d'Adistu qui consiste à supprimer la ligne du haut et la colonne de droite, puis à les coller à gauche et en bas. Mais avec des structures de données mutables, pas des transpositions.

isaacg
la source
2

Octave, 85 octets

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

J'espère que je pourrais me débarrasser de l' endart.

Alephalpha
la source
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]

Essayez-le en ligne!

Il s'agit d'une interprétation assez littérale de la méthode de @ aditsu. La syntaxe de Python pour traiter les listes vides comme False a permis d'économiser 10 octets supplémentaires.

SmileAndNod
la source
enregistré 8 octets en supprimant les lignes au fur
mesure
Plus de cas de test
SmileAndNod
1
Vous n'avez probablement pas besoin de l' 0in[0:1]
Jo King