Pesquisar neste blog

04/11/2019

Buscar elementos iguais em java

import javax.swing.JOptionPane;

/**
 *
 * @author HENRIQUE
 */
public class Lista {
    
    private Object[] objeto;
    private int tamanho;
    
    public Lista(){
    }
    public Lista(int capacidade){
        this.objeto = new Object[capacidade];
        this.tamanho = 0;
    }
    public boolean adicionar(Object elemento){
        if(tamanho < objeto.length){
            objeto[tamanho] = elemento;
            tamanho++;
            return true;
        }return false;
    }
    
    public int buscarElemento(Object elemento){
        for(int i = 0; i < this.tamanho; i++){
            if(this.objeto[i].equals(elemento)){
                return i;
            }
        }return -1;
    }
    
    public Object buscarElem(Object elemento){
        for(int i = 0; i < this.tamanho; i++){
            if(this.objeto[i].equals(elemento)){
                return elemento;
            }
        }return false;
    }
    
    public void erro(String elemento){
        JOptionPane.showMessageDialog(null,"ERRO SEMÂNTICO !", "inteiro "+elemento,JOptionPane.ERROR_MESSAGE);
        throw new IllegalArgumentException("Variável duplicata");
    }
       
    public boolean addIguais(Object elemento){
        if((tamanho < objeto.length)&& (this.contem(elemento)== false)){
            objeto[tamanho] = elemento;
            tamanho++;
            return true;
        }
        System.out.println(elemento+" => Variáveis iguais");
        this.erro((String) elemento);
        return false;
    }
    
    public boolean contem(Object elemento){
        return buscarElemento(elemento) >= 0;
    }
    public int tamanho(){
        return this.tamanho;
    }
    
    public void removerElemento(Object elemento){//esta removendo apenas um elemento
        for(int i = 0; i < this.tamanho -1; i++){
            this.objeto[i] = this.objeto[i+1];
        }
        tamanho--;
    }
    
    public void removerElemPosicao(int posicao){
        if(!(posicao >= 0 && posicao < tamanho)){//se a posição é válida
            throw new IllegalArgumentException("\n\nPOSIÇÃO DE REMOÇÃO INVÁLIDA");
        }else{
            for(int i =0; i < this.tamanho -1; i++){
                this.objeto[i] = this.objeto[i+1];//atualiza a posicao
            }
            tamanho--;
        }
    }
    
    public String toString(){
        StringBuilder s = new StringBuilder();
        
        for(int i =0; i < this.tamanho; i++){
            s.append(this.objeto[i]);
            s.append("\n");
        }
        return s.toString();
    }
}


EXEMPLO : 

/**
 *
 * @author HENRIQUE
 */
public class Main {
    public static void main(String[] args) throws Exception {
        
        Lista listar = new Lista(1000);

        listar.addIguais("palavras");
        listar.addIguais("abacaxi");
        listar.addIguais(9);
        listar.addIguais("FRASES");
        listar.addIguais("abacaxi"); // dará um erro aqui porque já existe este elemento
    }
}

25/10/2019

Gramática no Gals

Gramática 1
Clique aqui para fazer o download do arquivo feito no Gals
Autor: Tales - IFMT - Eng. da Computação

Gramática 2
Clique aqui para fazer o download do arquivo feito no Gals
Autor: Henrique - IFMT - Eng. da Computação

Gramática 3
Clique aqui para fazer o download do arquivo feito no Gals
Autor: Luis Fernando Sampaio - IFMT - Eng. da Computação
Arquivos disponível em: https://github.com/lsfs/compilador

Gramática 4
Clique aqui para fazer o download do arquivo feito no Gals

Gramática 5
Clique aqui para fazer o download do arquivo feito no Gals
Autor: Adriano - IFMT - Engenharia da Computação
Arquivos disponível em: https://drive.google.com/open?id=1w0kj_-NU27WJ_w6yTzLEIS-bOw0rFqED

Gramatica 6
Clique aqui para fazer o download do arquivo feito no Gals
Autor: Lucas  - IFMT - Engenharia da Computação
Arquivos disponivel em: https://drive.google.com/file/d/11VqWv7g5nSnwSKajY-bq7lFArNoGPNQi/view?usp=sharing

Arquitetura para Assembly



S → DB
D → final id “=“ [“-”] const”;” [1][5] |
Tipo id1 [6] [“=“ [“-”[15]] const [16][7]] [2] {“,” id2 [6][“=“ [-[15]] const[16][7]] [3]}* “;”
Tipo → int [8]| byte [9]| string [10]| boolean[11]
B → begin {C}* end
C → id[4] = Exp [12];” [15]| while [16] Exp [13] [17] ( C | B )[18] |
If [19]Exp [13] [20] ( C | B ) [else [21]( C | B ) ] [22]| “;” |
readln”,” id[4] [14];” | (write | writeln)”,” Exp [17]{“,” Exp [17] }* “;”
Exp → ExpS1 [18] [12] [ ( “<“ [20][13.1]| “>“ [20][13.2]| “<=“ [20][13.3]| “>=“ [20][13.4]| “==“ [21][13.5]| “!=“ [20][13.6]) ExpS2 [19] [22] [14]]
ExpS → [ “-”[8]] T1 [23][9]{ ( “+” [27][10.1]| “-” [28][10.2]| or [28][10.3]) T2 [24][30][11]}*
T → F1 [25][5]{ ( “*” [29][6.1]| “/” [29][36][6.2]| and [29][6.3]) F2 [26][31][7]}*
F → “(“ Exp [32])” [3]| not F1 [33][4] | const[34][2] | id [4][35][1]

[1] {se id.classe != vazio então ERRO
senao id.classe = classe_const }
[2] { se id1.classe != vazio então ERRO
senao id1.classe = classe_var}
[3] { se id2.classe != vazio então ERRO
senao id2.classe = classe_var}
[4] { se id.classe = vazio então ERRO}
[5] { id.tipo := const.tipo }
[6] { id.tipo = Tipo.t }
[7] { se id1.tipo != const.tipo E (id1.tipo != inteiro E const.tipo != byte OU id1.tipo != byte E const.tipo != inteiro) então ERRO }
[8] { Tipo.t = inteiro }
[9]{ Tipo.t = byte }
[10] { Tipo.t = string }
[11]{ Tipo.t = boolean }
[12] { se id1.tipo != exp.tipo E (id1.tipo != inteiro E exp.tipo != byte OU id1.tipo != byte E exp.tipo != inteiro) então ERRO }
[13] { se exp.tipo != logico então ERRO }
[14] { se id.tipo != inteiro E id.tipo != byte E id.tipo != string então ERRO }
[15] { D.neg = true }
[16] { se D.neg = true
então id.tipo = inteiro }
[17] { se exp.tipo != inteiro E exp.tipo != byte E exp.tipo != string então ERRO }
[18] { Exp.tipo = Exps.tipo }
[19] { se Exp.tipo != inteiro E ExpS.tipo != inteiro E Exp.tipo != byte E ExpS.tipo != byte E (Exp.tipo != inteiro E Exps.tipo != byte OU Exp.tipo != byte E Exps.tipo != inteiro)
então ERRO }
[20] { se Exps1.tipo = string então ERRO }
[21] { se Exps1.tipo != string E Exps1.tipo != inteiro E Exps1.tipo != byte então ERRO}
[22] { Exp.tipo = logico }
[23] { Exps.tipo = T1.tipo }
[24] { se Exps.tipo != T2.tipo E (Exps.tipo != inteiro E T2.tipo != byte OU Exps.tipo != byte E T2.tipo != inteiro) então ERRO }
[25] { T.tipo = F1.tipo }
[26] { se T.tipo != F2.tipo E (T.tipo != inteiro E F2.tipo != byte OU T.tipo != byte E F2.tipo != inteiro) então ERRO }
[27] { se T1.tipo != string E T1.tipo != inteiro E T1.tipo != byte então ERRO}
[28] { se T1.tipo = string então ERRO }
[29] { se F1.tipo = string então ERRO }
[30] { se T1.tipo = inteiro E T2.tipo = byte OU se T1.tipo = byte E T2.tipo = inteiro
então ExpS.tipo = inteiro }
[31] { se F1.tipo = inteiro E F2.tipo = byte OU se F1.tipo = byte E F2.tipo = inteiro
então T.tipo = inteiro }
[32] { F.tipo = Exp.tipo }
[33] { se F1.tipo = string então ERRO
senão F.tipo = F1.tipo}
[34] { F.tipo = const.tipo }
[35] { F.tipo = id.tipo }
[36] { se (F1.tipo != inteiro) então F1.tipo = inteiro
        se (F2.tipo != inteiro) então F2.tipo = inteiro }

[1] { F.end := id.end }
[2] {se const.tipo=string então
                dseg SEGMENT PUBLIC
                byte "const.lex$"
                dseg ENDS
                F.end := cont_dados
                cont_dados+= 256
senão
                F.end:=NovoTemp
                mov regA, const.lex
                mov F.end, regA }
[3] { F.end := Exp.end }
[4] { F.end := NovoTemp }
{ mov regA, Fi.end }
{ not regA }
{ mov F.end, regA}
[5] { T.end := F1.end }
[6.1] {T.op = *}
[6.2] {T.op = /}
[6.3] {T.op = and}
[7] { mov ax, DS:[T.end] }
{mov bx, DS:[F2.end] }
{ se T.tipo != inteiro então
         cwd
se F2.tipo != inteiro entao
         mov cx, DS:[ax]
         mov ax, DS:[bx]
         cwd
         mov DS:[bx], ax
         mov DS:[ax], cx}
{se T.op = “*” então
         imul bx
senao se T.op = “/” então
         idiv bx
senao
       and ax, bx}
{ T.end := NovoTemp }
{ mov DS:[T.end], ax }
[8] { Exps.neg = true }
[9] { se Exps.neg = true
        Exps.end = NovoTemp
        mov ax, DS:[T1.end]
                neg ax
                mov DS:[Exps.end], ax}
{ ExpS.end := T1.end }
[10.1] { Exps.op =  + }
[10.2] { Exps.op =  - }
[10.3] { Exps.op =  or }
[11]  { mov ax, DS:[Exps .end] }
{ mov bx, DS:[T2.end] }
{ se Exps.tipo != inteiro então
    cwd
se T2.tipo != inteiro entao
    mov cx, DS:[ax]
         mov ax, DS:[bx]
         cwd
         mov DS:[bx], ax
         mov DS:[ax], cx}
{se Exps.op = “+” então
         imul bx
senao se Exps.op = “-” entao
         idiv bx
senao
         and ax, bx}
{ Exps.end := NovoTemp }
{ mov DS:[Exps.end], ax }
[12] { Exp.end = Exps1.end }
[13.1] { Exp.op = “<” }
[13.2] { Exp.op = “>” }
[13.3] { Exp.op = “<=” }
[13.4] { Exp.op = “>=” }
[13.5] { Exp.op = “==” }
[13.6] { Exp.op = “!=” }
[14] { mov ax, DS:[Exp.end]
mov bx, DS:{Exps2.end]
cwd
mov cx, DS:[ax]
mov ax, DS[bx]
cwd
mov DS:[bx],ax
mov DS:[ax],cx }
{ cmp ax, bx }
{ RotVerdadeiro = NovoRot }
{ se Exp.op = “=” então
      je RotVerdadeiro
senao se Exp.op = “!=” então
      jne RotVerdadeiro
senao se Exp.op = “<” então
      jl RotVerdadeiro
senao se Exp.op = “>” então
      jg RotVerdadeiro
senao se Exp.op = “>=” então
      jge RotVerdadeiro
senao
      jle RotVerdadeiro }
{ mov al, 0 }
{ RotFim = NovoRot }
{ jmp RotFim }
{ RotVerdadeiro: }
{ mov AL, 0FFh }
{ RotFim: }
{ Exp.end:=NovoTemp }
{ Exp.tipo:=TIPOLÓGICO }
{ mov Exp.end, AL }
[15] { mov ax, DS:[Exp.end] }
{ se id.tipo != Exp.tipo então
      cwd }
{ mov DS:[id.end], ax }
[16] { RotInicio:=NovoRot }
{ RotFim:=NovoRot }
{ RotInicio: }
[17] { mov ax, DS:[Exp.end] }
{ cmp ax, 0
      je RotFim }
[18] { jmp RotInicio }
{ RotFim: }
[19] { RotFalso:=NovoRot }
{ RotFim:=NovoRot }
[20] { mov ax, DS:[Exp.end] }
{ cmp ax, 0
      je RotFalso }
[21] { jmp RotFim }
{ RotFalso: }
[22] { RotFim: }

10/10/2019

Encontrar Strings em Java


package lexica;
import java.util.ArrayList;
public class Main{
    public static void main(String[] args ){
     
        ArrayList<String> al = new ArrayList<String>();
     
        al.add("Java");
        al.add("linguagem C");
        al.add("Networking");
     
        if(al.contains("Networking")){//string procurada
            System.out.println("Networking encontrado na Lista");
        }else{
            System.out.println("Não encontrado");
        }
     
        String str = "   www.Voleichut-dow+Carlin~ klk ";//nova string
        char[] s = str.toCharArray();
        boolean t = false;
        for (char c : s){
            if(str.contains("ei")== true){//se verdadeiro
                t = true;
                System.out.println("achei: ei");
                break;//para o loop, senao imprimi muitas vezes
            }
            System.out.println(c);
        }
        System.out.println("____//____");
        System.out.println(str);
        System.out.println("indexOf [lei] = "+str.indexOf("lei", 0));//lei procurada, retorna a posição inicial que se encontra
        System.out.println("substring1 [8] = "+str.substring(8));//trunca a string a partir da posição 8
        System.out.println("substring2 [2,10] = "+str.substring(2, 10));//trunca a string a partir da pos 2 até a 10
        System.out.println("substring3 subSequence[0,5] = "+str.subSequence(0, 5));//trunca .. 0 ate 5
        System.out.println("Removendo i , o: "+str.replace('i', 'o'));//remove i e o
        System.out.println("Trim   : "+str.trim());
        StringBuilder a = new StringBuilder(str);
        System.out.println("Reverso: "+a.reverse());//string invertida
    }
}
saída gerada


























Palavras chave:

contains no Java
indexOf no Java
substring no Java
subSequence no Java
trim no Java
reverse no Java

30/09/2019

Somador, subtrator, divisor e multiplicador no Logisim



Circuito de um microprocessador e seus comandos com mmemônico

CPU de uma ULA no Logisim 2.7














CI_Ula_Nova


















CPU_Ev2




















































Créditos para o professor Giuliano - IFMT - Microprocessadores

Clique aqui para fazer o download do arquivo feito no Logism

Palavras chave:

Adder, subtractor, divisor and multiplier in Logisim
Opteller, aftrekker, verdeler en vermenigvuldiger in Logisim
Bộ cộng, phép trừ, số chia và số nhân trong Logisim
Логисим дахь холбогч, хасагч, хуваагч ба үржүүлэгч
ตัวบวก, ตัวหาร, ตัวหารและตัวคูณใน Logisim
Adder, subtraherare, divisor och multiplikator i Logisim
Logisim'de toplayıcı, çıkartıcı, bölen ve çarpan
Sommatore, sottrattore, divisore e moltiplicatore in Logisim
Adder, изваждане, делител и умножител в Logisim

16/09/2019

Divisão binária no Logisim

Objetivo:
Fazer um circuito de divisão binária, onde para fazer a divisão é subtraído n vezes o divisor até chegar no resultado. Se n vezes subtraído e o resto = 0 então divisão binária OK.
Divisão no Logisim 2.7


10/09/2019

Importar um arquivo txt e transferir para um ArrayList em Java

/*
 * To change this license header, choose License Headers in Project Properties.
 * To change this template file, choose Tools | Templates
 * and open the template in the editor.
 */
package lexica;
import java.io.*;
import java.util.ArrayList;
/**
 *
 * @author HENRIQUE
 */
public class Main1 {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws FileNotFoundException{
     
        FileReader arquivo = new FileReader("C:\\Users\\HENRIQUE\\Desktop\\lexico.txt");
        BufferedReader learq = new BufferedReader(arquivo);
     
        ArrayList<String> linhas = new ArrayList<>();
        ArrayList<String[]> palavras = new ArrayList<>();
        try{
            String linha = learq.readLine();
            while (linha != null){
                linhas.add(linha);
                linha = learq.readLine();
             
            }
        }catch (IOException e){
            System.out.println(e.getMessage());
        }
        for(String s : linhas){
            palavras.add(s.split(" "));//melhor para visualizar a impressão
            //palavras.add(s.split(""));//ou se preferir
        }
        for(int i= 0; i < palavras.size(); i++){
            for(int j= 0; j< palavras.get(i).length; j++){
                if(!palavras.get(i)[j].trim().isEmpty()){
                    System.out.println(palavras.get(i)[j]);
                }
            }
        }
        System.out.println("____//___");
    }
}

07/09/2019

Gramática no emulador Gals


Gerador de análise Léxica e Sintática no Gals
gramatica no Gals


Exemplo de fatorial no Gals

Saída do analisador


Clique aqui para fazer o download do arquivo feito no Gals

Palavras chave:

Generator Analisis Leksikal lan Sintaktis
Генератор лексического и синтаксического анализа Галса
Генератор лексико-синтаксичного аналізу Галса
מחולל ניתוחים לקסיקליים ותחביריים
Generatore di analisi lessicale e sintattica di Gals
Gals Gineadóir Anailíse Lexical agus Syntactic
Gals Lexikální a syntaktická generátorová analýza
የጌዝስ ሌክሲካል እና የሕዋሳዊ ትንታኔ ጄኔሬተር።
Gals Lexical at Syntactic Analysis Generator
加爾斯詞彙和句法分析生成器

04/09/2019

Fluxo de dados

Fluxo de dados no Logisim 2.7




























Palavras chave:

Logisim data flow
זרימת נתונים של לוגיסים
Ροή δεδομένων Logisim
Data est in fluxus Logisim
Logisim data diherike
Потік даних Logisim
Логисим поток данных
Aliran data logisim

02/09/2019

Registradores via barramento

Esta é uma atividade sobre interligação e operação inter-registradores via barramento (DCE).

Objetivo: Fazer operações posteriormente através de leitura de dados por  entrada, troca de dados inter-registradores e escrever dados dos registradores.



























Palavras chave:

बस रेकॉर्डर
Registratori di autobus
Bussinspelare
बस रेकर्डरहरू
د بس ریکارډر
Rikodin bas
Rikodin bas
公交車記錄儀
Linja-autojen nauhurit
Zolemba mabasi
Máy ghi âm xe buýt
Busopnemers