Considere o programa apresentado abaixo:
#include <stdio.h>
#define N 4
int main() {
    int m[N][N] = { { 0, 1, 13, 8 }, { 14, -3, 17, -6 }, { 15, -1, 2, 0 }, { -7, 10, 12, -5 } };
    int i, j, aux;
    for ( i=0; i<N; i++ )
        for ( j=i; j<N; j++ )
            if ( i != j ) {
                aux = m[i][j];
                m[i][j] = m[j][i];
                m[j][i] = aux;
            }
    for ( i=0; i<N; i++ ) {
        for ( j=0; j<N; j++ )
            printf( "%3d", m[ i ][ j ] );
        printf( "\n" );
    }
    return 0;
}

Passo 1

O que o enunciado pede: determinar o que o programa imprime na tela quando executado.
Informações dadas pelo enunciado:
  • O programa define N=4.
  • A matriz inicial m é
m = \begin{pmatrix} 0 & 1 & 13 & 8\\[4pt] 14 & -3 & 17 & -6\\[4pt] 15 & -1 & 2 & 0\\[4pt] -7 & 10 & 12 & -5 \end{pmatrix}
  • O código tem dois laços aninhados: o laço externo varia i de 0 até N-1 e o laço interno varia j de i até N-1.
  • Dentro do laço interno há a condição \text{if }(i \neq j) e, quando verdadeira, o programa troca m[i][j] com m[j][i] usando uma variável auxiliar.
  • Depois das trocas, o programa imprime a matriz com o comando printf("%3d", m[i][j]) linha a linha.]

Passo 2

O que faz o trecho de trocas: como j começa em i, o par (i,j) percorre apenas a diagonal principal e a região acima dela (triângulo superior). Quando i\neq j a instrução troca m[i][j] com m[j][i]. Isso corresponde exatamente a trocar cada elemento da parte superior da matriz pelo elemento simétrico na parte inferior: é a operação de transposição in-place (sem criar outra matriz), deixando a diagonal inalterada. Em outras palavras, ao final teremos a matriz transposta, cuja definição é:
\text{se }m=(m_{ij})\text{ então a transposta }m^T\text{ tem }(m^T)_{ij}=m_{ji}.ã
Explicação rápida por que não duplica trocas: como j começa em i, cada par off-diagonal é tratado apenas uma vez (por exemplo (0,1) é trocado, mas (1,0) nunca entra no laço interno porque aí j nunca será menor que i naquele passo), evitando trocar de volta.

Passo 3

Vamos listar explicitamente os pares off-diagonais que são trocados e mostrar as trocas uma a uma. Mantemos a diagonal (0,0),(1,1),(2,2),(3,3) sem alteração:
m_{00}=0,\quad m_{11}=-3,\quad m_{22}=2,\quad m_{33}=-5.
Agora as trocas (vou mostrar antes \to depois para cada par (i,j) com i<j):

Passo 4

Trocas detalhadas:
  • Para (i=0,j=1): troca m[0][1] com m[1][0]. Antes: m[0][1]=1, m[1][0]=14. Depois: m[0][1]=14, m[1][0]=1.
  • Para (i=0,j=2): troca m[0][2] com m[2][0]. Antes: m[0][2]=13, m[2][0]=15. Depois: m[0][2]=15, m[2][0]=13.
  • Para (i=0,j=3): troca m[0][3] com m[3][0]. Antes: m[0][3]=8, m[3][0]=-7. Depois: m[0][3]=-7, m[3][0]=8.
  • Para (i=1,j=2): troca m[1][2] com m[2][1]. Antes: m[1][2]=17, m[2][1]=-1. Depois: m[1][2]=-1, m[2][1]=17.
  • Para (i=1,j=3): troca m[1][3] com m[3][1]. Antes: m[1][3]=-6, m[3][1]=10. Depois: m[1][3]=10, m[3][1]=-6.
  • Para (i=2,j=3): troca m[2][3] com m[3][2]. Antes: m[2][3]=0, m[3][2]=12. Depois: m[2][3]=12, m[3][2]=0.
Essas trocas transformam a matriz original na sua transposta. Se você preferir verificar elemento a elemento, lembre: o elemento na posição (i,j) final vale o elemento antigo de (j,i).

Passo 5

Matriz final após todas as trocas (a transposta de m):
m_{\text{final}} = \begin{pmatrix} 0 & 14 & 15 & -7\\[4pt] 1 & -3 & -1 & 10\\[4pt] 13 & 17 & 2 & 12\\[4pt] 8 & -6 & 0 & -5 \end{pmatrix}
O printf("%3d", m[i][j]) imprime cada elemento com largura mínima de 3 colunas, alinhado à direita, mas o conteúdo numérico é exatamente os valores acima, linha por linha.]

Resposta

0\;14\;15\;-7
1\;-3\;-1\;10
13\;17\;2\;12
8\;-6\;0\;-5

Exercícios relacionados