Exercícios Revisão

//1) Crie duas matrizes (A e B) de tamanho 5x3 do tipo inteiro. Construir uma matriz C, onde C = A + B. Liste as
//três matrizes.

package revisaoexs;

import java.util.Scanner;

public class RevisaoExs {

    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);

        int matA[][] = {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}, {1, 2, 3}, {1, 2, 3}};
        int matB[][] = {{1, 2, 3}, {1, 2, 3}, {1, 2, 3}, {1, 2, 3}, {1, 2, 3}};
        int matC[][] = new int[5][3];

        for (int i = 0; i < matA.length; i++) {
            for (int j = 0; j < matA[i].length; j++) {
                matC[i][j] = matA[i][j] + matB[i][j];

            }

        }

        for (int i = 0; i < matC.length; i++) {
            for (int j = 0; j < matC[i].length; j++) {
                System.out.print(matC[i][j] + "\t");
            }
            System.out.print("\n");
        }
    }

    }

______________________________________________________________________________________________________________________________

//2) Crie dois vetores (A e B) de tamanho 10 do tipo inteiro. Construir e apresentar uma matriz M onde:
//a) a primeira linha contenha o vetor A;
//b) a segunda linha contenha o vetor B;
//c) a terceira linha contenha A + B;
//d) a quarta linha contenha A * B;
package ex2;


public class Ex2 {

    public static void main(String[] args) {
        int A[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int B[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
        int M[][] = new int[4][10];


        for(int i = 0; i<A.length; i++){

            M[0][i] = A[i];
            M[1][i] = B[i];
            M[2][i] = A[i] + B[i];
            M[3][i] = A[i] * B[i];
        }
         for (int i = 0; i < M.length; i++) {
            for (int j = 0; j < M[i].length; j++) {
                System.out.print(M[i][j] + "\t");
            }
            System.out.print("\n");
    }
    }
}
_____________________________________________________________________________________________________________________________________

//) Faça um programa para cálculo da média final para 4 alunos de acordo com
//suas notas em 6 atividades. A média deverá ser guardada na última linha da
//matriz. O programa deverá ler e armazenar na matriz notas dos alunos, calcular
//e armazenar na matriz as médias dos alunos. Imprimir a matriz resultante na
//tela.
package ex3;

import java.util.Scanner;

public class Ex3 {

    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        double Media[][] = {{7.0, 9.1, 9.8, 9.1}, {9.0, 8.8, 8.7, 9.0},
        {7.4, 9.2, 9.9, 7.9}, {9.6, 8.2, 9.8, 8.5}, {8.8, 7.5, 9.9, 7.8},
        {9.2, 9.6, 8.7, 8.8}, {0.0, 0.0, 0.0, 0.0}};
        for (int j = 0; j < Media[6].length; j++) {
            for (int i = 0; i < Media.length-1; i++) {
                Media[6][j] = Media[i][j] + Media[6][j];
            }
            Media[6][j] = Media[6][j] / 6;
        }

        for (int i = 0; i < Media.length; i++) {
            for (int j = 0; j < Media[i].length; j++) {
                System.out.print(Media[i][j] + "\t");


            }
            System.out.println("\n");

        }
    }

}
_____________________________________________________________________________________________________________________________________

//4) Crie um programa para transpor uma matriz A em uma matriz B, ou seja,
//a primeira linha da matriz A será a primeira coluna da matriz B, e assim por
//diante. Crie a matriz A aleatoriamente, e liste as duas matrizes.

package ex4;

import java.util.Random;

public class Ex4 {


    public static void main(String[] args) {
        int A[][] = new int[5][5];
        int B[][] = new int[5][5];

        Random gerador = new Random();

        for(int i = 0; i<A.length; i++){
            for(int j = 0; j<A[i].length;j++){
                A[i][j] = gerador.nextInt(10);

            }

        }
        for(int i = 0; i<A.length; i++){
            for(int j = 0; j<A[i].length;j++){
                B[j][i] = A[i][j];

            }

        }
        System.out.println("MATRIZ A");
        for(int i = 0; i<A.length; i++){
            for(int j = 0; j<A[i].length;j++){
                System.out.print(A[i][j] + "\t");

            }
            System.out.println("\n");
        }
        System.out.println("MATRIZ B");
        for(int i = 0; i<A.length; i++){
            for(int j = 0; j<A[i].length;j++){
                System.out.print(B[i][j] + "\t");

            }
            System.out.println("\n");
        }



    }

}
_______________________________________________________________________________________________________________________________________
//5) Escreva um programa que leia uma String, com pelo menos 20 caracteres
//do teclado e faça as seguintes operações:
//a) Informe a quantidade de caracteres da String
//b) Informe qual é o quarto caractere da String
//c) Gere uma segunda String, sendo que ela terá 10 caracteres, sendo formada
//a partir do terceiro caractere da String lida do teclado
//d) Informe quantos símbolos ‘a’, a String possui
package ex5;

import java.util.Scanner;


public class Ex5 {


    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        String A;
        String B;
        int cont = 0;
        System.out.println("Digite uma palavra com no mínimo 20 caracteres: ");
        A = entrada.nextLine();

        System.out.println("Quantidade de caracteres: " + A.length());
        System.out.println("Quarto caractere: " + A.charAt(3));

        B = A.substring(2, 12);
        System.out.println("Segunda String: " + B);

        for(int i = 0; i<A.length(); i++){
            if(A.charAt(i) == 'a' || A.charAt(i) == 'A'){
             cont++;

            }
        }
        System.out.println("Quantidade de A: " + cont);






    }

}
_______________________________________________________________________________________________________________________________________
//6) Escreva um programa que leia duas Strings do teclado e faça as seguintes operações:
//a) Verifique se elas são iguais
//b) Caso elas sejam diferentes, informe qual é maior alfabeticamente
//c) Informe qual String tem mais símbolos ‘o’
//d) Na primeira String, altere todas as vogais para maiúscula
//e) Inverta a segunda String, do fim para o início
//f) Verifique se as Strings iniciam ou terminam com “da”.
package ex6;

import java.util.Scanner;

public class Ex6 {

    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        String A, B;

        System.out.println("Digite uma palavra:");
        A = entrada.nextLine();
        System.out.println("Digite uma palavra: ");
        B = entrada.nextLine();

        if (A.equalsIgnoreCase(B)) {
            System.out.println("As palavras são iguais!");
        } else {
            System.out.println("As palavras são diferentes!");
            if (A.compareToIgnoreCase(B) > 0) {
                System.out.println("A primeira palavra é maior.");
            } else {
                System.out.println("A segunda palavra é maior.");
            }

        }
        int cont = 0;
        for (int i = 0; i < A.length(); i++) {
            if (A.charAt(i) == 'o' || A.charAt(i) == 'O') {
                cont++;

            }
        }
        int cont2 = 0;
        for (int i = 0; i < B.length(); i++) {
            if (B.charAt(i) == 'o' || B.charAt(i) == 'O') {
                cont2++;

            }
        }
        if (cont > cont2) {
            System.out.println("A primeira String possui mais símbolos 'O'.");
        } else if (cont == cont2) {
            System.out.println("As Strings possuem a mesma quantidade de Símbolos 'O'.");
        } else {
            System.out.println("A segunda String possui mais símbolos 'O'.");
        }
        A = A.replace('a', 'A');
        A = A.replace('e', 'E');
        A = A.replace('i', 'I');
        A = A.replace('o', 'O');
        A = A.replace('u', 'U');

        System.out.println("Vogais maiúsculas: " + A);

        String strA = "";
        for (int i = A.length(); i > 0; i--) {
            strA = strA + A.charAt(i - 1);
        }

        System.out.println("Palavra inversa: " + strA);

        if (A.substring(0, 2).equalsIgnoreCase("da")) {
            System.out.println("A primeira palavra inicia com 'da'");

        } else {
            System.out.println("A primeira palavra não inicia com 'da'");
        }
        if (A.substring(A.length() - 2, A.length()).equalsIgnoreCase("da")) {
            System.out.println("A primeira palavra termina com 'da'");
        } else {
            System.out.println("A primeira palavra não termina com 'da'");
        }
        if (B.substring(0, 2).equalsIgnoreCase("da")) {
            System.out.println("A segunda palavra inicia com 'da'");

        } else {
            System.out.println("A segunda palavra não inicia com 'da'");

        }
        if (B.substring(B.length() - 2, B.length()).equalsIgnoreCase("da")) {
            System.out.println("A segunda palavra termina com 'da'");
        } else {
            System.out.println("A segunda palavra não termina com 'da'");

        }

    }

}
_______________________________________________________________________________________________________________________________________
//7) Implemente um programa que possua dois objetos do tipo StringBuffer, e
//inicie-os com uma String. Faça as seguintes operações:
//a) Verifique se as duas Strings são palíndromos. Após a verificação, mantenha
//estavam antes da verificação.
//b) Concatene a primeira String com a segunda, colocando o resultado na primeira String.
//c) Faça a inversão da primeira String.
//d) Faça a inversão da segunda String.
//e) Insira a String “Teste” na segunda String, a partir do terceiro caractere.
package ex7;

import java.util.Scanner;

public class Ex7 {


    public static void main(String[] args) {
        Scanner entrada = new Scanner(System.in);
        StringBuffer A = new StringBuffer("Rodrigo");
        StringBuffer B = new StringBuffer("Aranha");

        System.out.println("Primeira palavra: " + A);
        System.out.println("Segunda palavra: " + B);

        if(A.toString().equals(A.reverse().toString())){
            System.out.println("A palavra " + A.reverse() +" é palíndromo.");
        }else {
            System.out.println("A palavra " + A.reverse() +" não é palíndromo");
        }
        if(B.toString().equals(B.reverse().toString())){
            System.out.println("A palavra " + B.reverse() +" é palíndromo.");
        }else {
            System.out.println("A palavra " + B.reverse() +" não é palíndromo");
        }
        A.insert(A.length(), B);
        System.out.println("Concatenação: " +A);

        A.reverse();
        System.out.println("Inversão: " + A);

        B.reverse();
        System.out.println("Inversão: " + B);

        B.insert(3, "TESTE");
        System.out.println("E) " + B);

    }

}
_______________________________________________________________________________________________________________________________________//8) Implemente um programa que, dadas duas Strings, a primeira contendo uma
//frase e a segunda uma palavra, determine quantas vezes a palavra aparece na frase
package ex8;

import java.util.Scanner;
import java.util.StringTokenizer;

public class Ex8 {

    public static void main(String[] args) {
        String A = "Eu amo ver o meu mozao amo amor amo lindo te amo";
        String B = "amo";
        StringTokenizer str = new StringTokenizer(A);
        int cont = 0;
        while (str.hasMoreTokens())
            if(str.nextToken().equals(B)){
                cont++;
            }
        System.out.println(" A palavra " + B + " aparece "+ cont + " vez(es) na frase.");


    }
}
_______________________________________________________________________________________________________________________________________package ex10.pkg1;

import java.io.*;

public class Ex101 {

    public static void main(String[] args) throws IOException {
        int A[][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}, {13, 14, 15}};
        int B[][] = {{15, 14, 13}, {12, 11, 10}, {9, 8, 7}, {6, 5, 4}, {3, 2, 1}};
        int C[][] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}, {10, 11, 12}, {13, 14, 15}};

        File arquivo = new File("arquivo.txt");
        try (FileWriter fw = new FileWriter(arquivo)) {
            BufferedWriter bw = new BufferedWriter(fw);
            for (int i = 0; i < A.length; i++) {
                for (int j = 0; j < A[i].length; j++) {
                    bw.write(A[i][j] + "\t");

                    bw.flush();
                }
                 bw.newLine();
                System.out.println("\n");
            }
            bw.newLine();
            for (int i = 0; i < B.length; i++) {
                for (int j = 0; j < B[i].length; j++) {
                    bw.write(B[i][j] + "\t");

                    bw.flush();
                }
                 bw.newLine();
                System.out.println("\n");
            }
            bw.newLine();
            for (int i = 0; i < C.length; i++) {
                for (int j = 0; j < C[i].length; j++) {
                    bw.write(C[i][j] + "\t");

                    bw.flush();
                }
                 bw.newLine();
                System.out.println("\n");
            }

        } catch (IOException ex) {
            ex.printStackTrace();

        }


    }

}