Gire as antiagonais

32

fundo

Nas linguagens de programação mais razoáveis, é muito fácil girar as linhas ou colunas de uma matriz 2D. Nesse desafio, sua tarefa é girar as antiagonais . Lembre-se de que as antiagonais de uma matriz 2D são suas fatias 1D tiradas na direção nordeste ↗.

Entrada

Uma matriz 2D retangular não vazia de números de um dígito em qualquer formato razoável. Observe que a matriz pode não ser um quadrado.

Saída

A mesma matriz, mas com cada anti-diagonal girado um passo para a direita.

Exemplo

Considere a 3x4matriz de entrada

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

As antiagonais dessa matriz são

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

Suas versões rotacionadas são

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

Assim, a saída correta é

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

Regras e pontuação

Você pode escrever um programa completo ou uma função. Também é aceitável escrever uma função que modifique a matriz de entrada, se o seu idioma permitir. A menor contagem de bytes vence e as brechas padrão não são permitidas.

Entre os melhores

Aqui está um snippet de pilha para gerar uma classificação regular e uma visão geral dos vencedores por idioma.

Para garantir que sua resposta seja exibida, inicie-a com um título, usando o seguinte modelo de remarcação:

## Language Name, N bytes

onde Nestá o tamanho do seu envio. Se você deseja incluir vários números no seu cabeçalho (por exemplo, porque sua pontuação é a soma de dois arquivos, ou você deseja listar as penalidades do sinalizador de intérpretes separadamente ou deseja mostrar as pontuações antigas que melhorou), verifique se a pontuação real é o último número no cabeçalho.

Mostrar snippet de código

Casos de teste adicionais

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
fonte

Respostas:

20

CJam, 20

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

Escrito como um bloco de funções. Experimente online

Explicação:

A entrada pode ser visualizada assim:

diagrama de entrada

Ou seja, separamos a linha superior e a coluna direita do restante da matriz e consideramos esses elementos na ordem mostrada pela seta.

Então a saída é assim:

diagrama de saída

O bloco retangular restante é movido na diagonal como um todo, e os elementos da aresta são reorganizados na ordem / posições mostradas pela nova seta.

O código faz quase exatamente isso, exceto que a saída é gerada primeiro com a seta indo para baixo (para que a matriz tenha uma cauda, ​​como a letra P), e depois corrigida.

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
fonte
A resposta Pyth também é de 20 bytes, mas a sua era anterior, então estou aceitando.
Zgarb
9

CJam, 44 43 42 40 bytes

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

Teste aqui.

Hmm, muito melhor do que minha primeira tentativa, mas tenho a sensação de que Dennis resolverá isso em muito menos de qualquer maneira ...

Entrada e saída são como grades ASCII:

0123
4567
8901

dá

0456
1890
2371
Martin Ender
fonte
7
Cruzado fora 44 ainda é regular 44; (
AdmBorkBork 13/11
3
@ TimmyD Eu deveria ter esperado até o final do período de cortesia para editá-lo de 47 até 43.: P
Martin Ender
Sim! Tornou-se um meme .
Intrepidcoder
11
Eu finalmente fui e aprendi uma linguagem de golfe para que eu pudesse golf 4 bytes a 3 e faça parte da cadeia de ligação :)
Khuldraeseth na'Barya
6

J, 24 caracteres

Função tendo um argumento.

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

J tem um operador /.chamado Oblique . Ele não pode invertê-lo, portanto a reconstrução não é trivial, mas você pode considerar "listar oblíquos" como uma permutação dos elementos da matriz. Portanto, invertemos essa permutação com /:( Classificação diádica ), colocando a permutação "listando oblíquos" para esse tamanho ( </.@i.@$) à direita e nossos novos valores oblíquos, rotacionados adequadamente, à esquerda. Em seguida, reformulamos essa lista na matriz retangular antiga usando boa e velha $$.

   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

Experimente online.

algoritmshark
fonte
Este é o pico J aqui. Bem feito.
Jonah
5

J, 38 30 bytes

8 bytes salvos graças a @algorithmshark.

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

A função coleta as bordas superior e esquerda em uma lista, corta a lista em duas partes de tamanhos suficientes e as costura na parte direita e inferior da peça principal.

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

Experimente online aqui.

randomra
fonte
11
Down to 30 de Caracteres: {./.substitui }:@{.,{:"1, e você pode salvar o til duas vezes por lançando o trem em torno de: {./.((}.~#),~({.~#),.])}:"1@}..
algorithmshark
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)

Isso cria uma função sem nome que aceita uma matriz e retorna a matriz de entrada modificada no local.

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

Agradecemos a Martin Büttner pelo aconselhamento algorítmico e por salvar 4 bytes!

Alex A.
fonte
3

ES6, 75 bytes

Isso aceita uma matriz de matrizes como parâmetro e a modifica no local.

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
}

Veja o diagrama do @ aditsu para mais esclarecimentos.

Neil
fonte
Você pode salvar 2 bytes mudando {t.push(r.pop());r.unshift(t.shift())}parat.push(r.pop())+r.unshift(t.shift())
user81655 14/11
3

Pitão, 20 bytes

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

Utiliza a abordagem do Adistu de remover a linha superior e a coluna direita e colá-las à esquerda e à parte inferior. Mas com estruturas de dados mutáveis, não transposições.

isaacg
fonte
2

Oitava, 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)]]

Espero poder me livrar dos ends.

alefalpha
fonte
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]

Experimente online!

Esta é uma interpretação literal do método do @ aditsu. A sintaxe do Python para tratar listas vazias como False ajudou a economizar 10 bytes extras.

SmileAndNod
fonte
economizei 8 bytes descartando linhas enquanto eu vou
SmileAndNod
Mais casos de teste
SmileAndNod
11
Você provavelmente não precisa do 0em[0:1]
Jo rei