Variáveis compostas - Parte 2

Relembrando

var

n1, n2, n3: inteiro

n: vetor[1..3] de inteiro

inicio

n[1] ← 3

n[2] ← 5

n[3] ← 1

n1
n2
n3
n 3 5 1
1 2 3

Mais Dimensões

var

m: vetor[ 1..3, 1..2 ] de inteiro

Incio

m[ 1, 2 ] ← 4

m[ 2, 2 ] ← 5

m[ 3, 1 ] ← 8
m
1 4
2 5
3 8
1 2

Variáveis Compostas Homogêneas Multidimensionais

var

m: vetor[ 1..3, 1..2 ] de inteiro

l, c: inteiro

Inicio

para l ← 1 ate 3 faca

para c ← 1 ate 2 faca

leia(m[l, c])

fimpara

fimpara

Prática 01: preencher uma matriz 3 x 2 com valores via teclado
m
1 ? ?
2 ? ?
3 ? ?
1 2 
algoritmo "lerMatriz"
var
  mat: vetor[1..3, 1..2] de Inteiro
  l, c: Inteiro
inicio
   Para l <- 1 ate 3 faca
      Para c <- 1 ate 2 faca
         Escreva ("Digite o valor da posicao [", l, ",", c, "]: ")
         Leia(mat[l,c])
      FimPara
   FimPara
   
   Para l <- 1 ate 3 faca
      Para c <- 1 ate 2 faca
         Escreva (mat[l,c]:5)
      FimPara
      EscrevaL()
   FimPara
   
fimalgoritmo

Prática 02: ler uma matriz 3 x 3 e mostrar os pares

algoritmo "matrizPar"
var
  valores: vetor[1..3, 1..3] de Inteiro
  l, c, totPar: Inteiro
inicio
   Para l <- 1 ate 3 faca
      Para c <- 1 ate 3 faca
         Escreva ("Digite o valor da posicao [", l, ",", c, "]: ")
         Leia(valores[l, c])
      FimPara
   FimPara
   
   EscrevaL()
   EscrevaL("MATRIZ:")
   EscrevaL("-------------")
   TotPar <- 0
   Para l <- 1 ate 3 faca
      Para c <- 1 ate 3 faca
         Se(valores[l,c] % 2 = 0) entao
             Escreva("{", valores[l, c]:2, "}")
             TotPar <- TotPar + 1
         senao
             Escreva(valores[l, c]:4)
         fimSe
      FimPara
      Escreval()
   FimPara
   
   EscrevaL("Ao todo foram digitados ", TotPar, " valores PARES")
fimalgoritmo

Prática 03: criar uma matriz identidade de 3ª ordem

algoritmo "matrizIdentidade"
var
  mID: vetor[1..3, 1..3] de Inteiro
  i, j: Inteiro
inicio
    Para i <- 1 ate 3 faca
       Para j <- 1 ate 3 faca
          Se (i = j) entao
             mID[i,j] <- 1
          senao
             mID[i,j] <- 0
          FimSe
       FimPara
    FimPara
    
    Para i <- 1 ate 3 faca
       Para j <- 1 ate 3 faca
          Escreva (mID[i,j]:3)
       FimPara
       EscrevaL()
    FimPara
    
fimalgoritmo

Prática 04: preencher uma matriz de 4ª ordem

algoritmo "valoresMatriz"
var
  m: vetor[1..4, 1..4] de Inteiro
  l, c, sDP, p2L, mai3C: Inteiro
inicio
   sDP <- 0
   p2L <- 1
   Para l <- 1 ate 4 faca
      Para c <- 1 ate 4 faca
         Escreva("Digite o valor da Posicao [", l, ",", c, "]: ")
         Leia(m[l,c])
         Se (l = c) entao
            sDP <- sDP + m[l,c]
         FimSe
      FimPara
   FimPara

   Para l <- 1 ate 4 faca
      Para c <- 1 ate 4 faca
         Escreva(m[l,c]:4)
      FimPara
      EscrevaL()
   FimPara

   Para c <- 1 ate 4 faca
      p2L <- p2L * m[2,c]
   FimPara
   
   Para l <- 1 ate 4 faca
      Se (m[l,3] > mai3C) entao
         mai3C <- m[l,3]
      FimSe
   FimPara

   EscrevaL("A soma dos valores da Diagonal Principal e ", sDP)
   EscrevaL("O produto dos valores da Segunda Linha e ", p2L)
   EscrevaL("O maior valor da Terceira Coluna e ", mai3C)
fimalgoritmo

Exercício 01: dissecando matrizes

algoritmo "dissecandoMatrizes"
var
  m: vetor[1..4, 1..4] de Inteiro
  l, c, op: Inteiro
  
Procedimento MostraMatriz()
inicio
   Para l <- 1 ate 4 faca
      Para c <- 1 ate 4 faca
         Escreva(m[l,c]:4)
      FimPara
      EscrevaL()
   FimPara
FimProcedimento

Procedimento DiagonalPrincipal()
var t: inteiro
inicio
   Para l <- 1 ate 4 faca
      EscrevaL(m[l,l]:4)
      Para t <- 1 ate l faca
         Escreva("    ")
      FimPara
   FimPara
FimProcedimento

Procedimento TrianguloSuperior()
var t: Inteiro
inicio
   Para l <- 1 ate 3 faca
      Escreva("    ")
      Para c <- l+1 ate 4 faca
         Escreva(m[l,c]:4)
      FimPara
      EscrevaL()
      Para t <- 1 ate l faca
         Escreva("    ")
      FimPara
   FimPara
   EscrevaL()
FimProcedimento

Procedimento TrianguloInferior()
inicio
   Para l <- 2 ate 4 faca
      EscrevaL()
      Para c <- 1 ate l-1 faca
         Escreva(m[l,c]:4)
      FimPara
   FimPara
   EscrevaL()
FimProcedimento

inicio
   Para l <- 1 ate 4 faca
      Para c <- 1 ate 4 faca
          Escreva("Digite valor para a posicao [", l, ",", c, "]: ")
          Leia(m[l,c])
      FimPara
   FimPara
   LimpaTela
   Repita
      EscrevaL()
      EscrevaL("MENU DE OPCOES")
      EscrevaL("====================")
      EscrevaL("[1] Mostrar a Matriz")
      EscrevaL("[2] Diagonal Principal")
      EscrevaL("[3] Triangulo Superior")
      EscrevaL("[4] Triangulo Inferior")
      EscrevaL("[5] Sair")
      Repita
         EscrevaL("===== OPCAO: ")
         Leia(op)
      Ate (op >=1) e (op <=5)
      LimpaTela
      Escolha op
         Caso 1
            MostraMatriz()
         Caso 2
            DiagonalPrincipal()
         Caso 3
            TrianguloSuperior()
         Caso 4
            TrianguloInferior()
         Caso 5
            EscrevaL("ENCERRANDO...")
      FimEscolha
   Ate (op = 5)
fimalgoritmo

Exercício 02: jogo da velha

algoritmo "jogoVelha"
var
  v: vetor[1..3, 1..3] de Caractere
  L, C, Cont, Po: Inteiro
  Simb : Caractere
  R: Logico
  
Procedimento mostraVelha()
Inicio
   EscrevaL("+---+---+---+")
   Para L <- 1 ate 3 faca
      Para C <- 1 ate 3 faca
         Escreva("|  ", v[L,C]:1)
      FimPara
      Escreva("|")
      EscrevaL()
      EscrevaL("+---+---+---+")
   FimPara
FimProcedimento

Procedimento mudaJogador()
inicio
   Se (Simb = "X") entao
      Simb <- "O"
   senao
      Simb <- "X"
   FimSe
FimProcedimento

Funcao Jogar(S: Caractere; P: Inteiro): Logico
Var mudou: logico
inicio
   mudou <- falso
   Para L <- 1 ate 3 faca
      Para C <- 1 ate 3 faca
         Se(v[L,C] = NumpCarac(P)) entao
            v[L,C] <- S
            mudou <- verdadeiro
         FimSe
      FimPara
   FimPara
   Retorne mudou
FimFuncao

Funcao TerminouVelha(): Logico
Var
  terminou: Logico
  ocorr: Inteiro
inicio
   terminou <- falso
   // Jogos em linha
   Para L <- 1 ate 3 faca
      Se (v[L,1] = v[L,2]) e (v[L,2] = v[L,3]) entao
         terminou <- verdadeiro
      FimSe
   FimPara
   // Jogos em coluna
   Para C <- 1 ate 3 faca
      Se (v[1,C] = v[2,C]) e (v[2,C] = v[3,C]) entao
         terminou <- verdadeiro
      FimSe
   FimPara
   // Jogos em diagonal
   Se (v[1,1] = v[2,2]) e (v[2,2] = v[3,3]) entao
      terminou <- verdadeiro
   FimSe
   Se (v[1,3] = v[2,2]) e (v[2,2] = v[3,1]) entao
      terminou <- verdadeiro
   FimSe
   
   // Jogos em VELHA
   ocorr <- 0
   Para L <- 1 ate 3 faca
      Para C <- 1 ate 3 faca
         Se (v[L,C] <> "X") e (v[L,C] <> "O") entao
            ocorr <- ocorr + 1
         FimSe
      FimPara
   FimPara
   Se (ocorr = 0) entao
      terminou <- verdadeiro
   FimSe
   
   // Retorna se o jogo acabou ou nao
   Retorne terminou
FimFuncao

inicio
   Cont <- 1
   Simb <- "X"
   Para L <- 1 ate 3 faca
      Para C <- 1 ate 3 faca
         v[L,C] <- NumpCarac(Cont)
         Cont <- Cont + 1
      FimPara
   FimPara
   MostraVelha()
   Repita
      Repita
         EscrevaL("Vai jogar [", simb:1, "] em qual posicao? ")
         Leia(Po)
         R <- Jogar(Simb, Po))
         Se (R = falso) entao
            EscrevaL("JOGADA INVALIDA!")
         FimSe
      Ate (R = verdadeiro)
      MudaJogador()
      LimpaTela
      MostraVelha()
   Ate (terminouVelha() = verdadeiro)
   EscrevaL("JOGO FINALIZADO!!!")
fimalgoritmo