silva
/
aeds2
mirror of https://github.com/viniciusfdasilva/aeds2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #28 from nietus/improved 

Improved
This commit is contained in:
Felipe Domingos 2023-09-25 06:33:36 -03:00 committed by GitHub
parent ddd11b9ce1 3c65e7f245
commit 661bbb23e1
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
319 changed files with 12100 additions and 11853 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

182
fonte/ajuda/README.md → Codigos/ajuda/README.md
View File

@ -1,91 +1,91 @@
## ALGUNS ARQUIVOS INTERESSANTES ## ALGUNS ARQUIVOS INTERESSANTES
* ~/.bash_history - Lista de comandos executados * ~/.bash_history - Lista de comandos executados
* ~/.vimrc - Configuracoes do VIM * ~/.vimrc - Configuracoes do VIM
* ~/.profile - Configuracoes do seu Usuario * ~/.profile - Configuracoes do seu Usuario
## PRINCIPAIS COMANDOS NO VIM ## PRINCIPAIS COMANDOS NO VIM
* i - Abre o modo de insercao * i - Abre o modo de insercao
* ESC - Fecha o modo de insercao * ESC - Fecha o modo de insercao
* :w - Salvar * :w - Salvar
* :q - Sair * :q - Sair
* :q! - Forcar saida * :q! - Forcar saida
* :wq! - Salvar e forcar a saida * :wq! - Salvar e forcar a saida
* ? PALAVRA - Procurar as ocorrencias de PALAVRA * ? PALAVRA - Procurar as ocorrencias de PALAVRA
* :%s/STRING_OLD/STRING_NEW/gc - Substrituir a STRING_OLD pela STRING_NEW * :%s/STRING_OLD/STRING_NEW/gc - Substrituir a STRING_OLD pela STRING_NEW
* yy - Copiar linha * yy - Copiar linha
* NUMEROyy - Copiar NUMERO linhas * NUMEROyy - Copiar NUMERO linhas
* dd - Excluir linha * dd - Excluir linha
* NUMEROdd - Excluir NUMERO linhas * NUMEROdd - Excluir NUMERO linhas
* dw - Excluir palavra * dw - Excluir palavra
* NUMEROdw - Excluir NUMERO palavras * NUMEROdw - Excluir NUMERO palavras
* p - Colar * p - Colar
* :sp ARQUIVO - Abre o arquivo ARQUIVO * :sp ARQUIVO - Abre o arquivo ARQUIVO
* ww - Alternar entre os arquivos abertos * ww - Alternar entre os arquivos abertos
* CTRL+V - Abre o modo de visualizacao * CTRL+V - Abre o modo de visualizacao
## ALGUNS COMANDOS PARA O MODO SHELL DO LINUX ## ALGUNS COMANDOS PARA O MODO SHELL DO LINUX
* man * man
* exit * exit
* cd * cd
* ls * ls
* ls -l -t -h * ls -l -t -h
* rm * rm
* cp * cp
* mkdir * mkdir
* clear * clear
* grep * grep
* grep "PALAVRA" ARQUIVO * grep "PALAVRA" ARQUIVO
* diff * diff
* diff ARQUIVO1 ARQUIVO2 * diff ARQUIVO1 ARQUIVO2
* ssh * ssh
* sftp * sftp
* wget * wget
* chmod * chmod
* javac * javac
* java * java
* tar -zcvf arquivo.tar.gz pasta * tar -zcvf arquivo.tar.gz pasta
* tar -zxvf arquivo.tar.gz * tar -zxvf arquivo.tar.gz
## COMPILAR E EXECUTAR PROGRAMA JAVA EM LINHA DE COMANDO ## COMPILAR E EXECUTAR PROGRAMA JAVA EM LINHA DE COMANDO
1) Compilar: 1) Compilar:
> javac Programa.java > javac Programa.java
2) Executar: 2) Executar:
> java Programa > java Programa
3) Executar alterando entrada padrao: 3) Executar alterando entrada padrao:
> java Programa < entrada.in > java Programa < entrada.in
4) Executar alterando saida padrao: 4) Executar alterando saida padrao:
> java Programa > saida.in > java Programa > saida.in
5) Executar alterando entrada/saida padrao: 5) Executar alterando entrada/saida padrao:
> java Programa < entrada.in > saida.in > java Programa < entrada.in > saida.in
## COMPILAR E EXECUTAR PROGRAMA C++ EM LINHA DE COMANDO ## COMPILAR E EXECUTAR PROGRAMA C++ EM LINHA DE COMANDO
1) Compilar: 1) Compilar:
> g++ fonte.cc -o objeto > g++ fonte.cc -o objeto
2) Executar: 2) Executar:
> ./objeto > ./objeto
3) Executar alterando entrada padrao: 3) Executar alterando entrada padrao:
> ./objeto < entrada.in > ./objeto < entrada.in
4) Executar alterando saida padrao: 4) Executar alterando saida padrao:
> ./objeto > saida.in > ./objeto > saida.in
5) Executar alterando entrada/saida padrao: 5) Executar alterando entrada/saida padrao:
> ./objeto < entrada.in > saida.in > ./objeto < entrada.in > saida.in
## GDB ## GDB
1) Chamar o gdb 1) Chamar o gdb
> gdb objeto > gdb objeto
2) Executar no gdb 2) Executar no gdb
> run > run
3) Acessar a pilha de chamadas 3) Acessar a pilha de chamadas
> bt > bt

412
fonte/ajuda/java/Arq.java → Codigos/ajuda/java/Arq.java
View File

@ -1,206 +1,206 @@
import java.io.*; import java.io.*;
import java.util.Formatter; import java.util.Formatter;
import java.util.Scanner; import java.util.Scanner;
import java.io.File; import java.io.File;
import java.nio.charset.*; import java.nio.charset.*;
public class Arq public class Arq
{ {
private static String nomeArquivo = ""; private static String nomeArquivo = "";
private static String charsetArquivo = "ISO-8859-1"; private static String charsetArquivo = "ISO-8859-1";
private static boolean write = false, read = false; private static boolean write = false, read = false;
private static Formatter saida = null; private static Formatter saida = null;
private static Scanner entrada = null; private static Scanner entrada = null;
public static boolean openWrite(String nomeArq, String charset) { public static boolean openWrite(String nomeArq, String charset) {
boolean resp = false; boolean resp = false;
close(); close();
try{ try{
saida = new Formatter(nomeArq, charset); saida = new Formatter(nomeArq, charset);
nomeArquivo = nomeArq; nomeArquivo = nomeArq;
resp = write = true; resp = write = true;
} catch (Exception e) {} } catch (Exception e) {}
return resp; return resp;
} }
public static boolean openWrite(String nomeArq) { public static boolean openWrite(String nomeArq) {
return openWrite(nomeArq, charsetArquivo); return openWrite(nomeArq, charsetArquivo);
} }
public static boolean openWriteClose(String nomeArq, String charset, String conteudo) { public static boolean openWriteClose(String nomeArq, String charset, String conteudo) {
boolean resp = openWrite(nomeArq, charset); boolean resp = openWrite(nomeArq, charset);
if(resp == true){ if(resp == true){
println(conteudo); println(conteudo);
close(); close();
} }
return resp; return resp;
} }
public static boolean openWriteClose(String nomeArq, String conteudo) { public static boolean openWriteClose(String nomeArq, String conteudo) {
return openWriteClose(nomeArq, charsetArquivo, conteudo); return openWriteClose(nomeArq, charsetArquivo, conteudo);
} }
public static boolean openRead(String nomeArq) { public static boolean openRead(String nomeArq) {
return openRead(nomeArq, charsetArquivo); return openRead(nomeArq, charsetArquivo);
} }
public static boolean openRead(String nomeArq, String charset) { public static boolean openRead(String nomeArq, String charset) {
boolean resp = false; boolean resp = false;
close(); close();
try{ try{
entrada = new Scanner(new File(nomeArq), charset); entrada = new Scanner(new File(nomeArq), charset);
nomeArquivo = nomeArq; nomeArquivo = nomeArq;
resp = read = true; resp = read = true;
} catch (Exception e) {} } catch (Exception e) {}
return resp; return resp;
} }
public static String openReadClose(String nomeArq){ public static String openReadClose(String nomeArq){
openRead(nomeArq); openRead(nomeArq);
String resp = readAll(); String resp = readAll();
close(); close();
return resp; return resp;
} }
public static void close() { public static void close() {
if(write == true){ if(write == true){
saida.close(); saida.close();
} }
if(read == true){ if(read == true){
entrada.close(); entrada.close();
} }
write = read = false; write = read = false;
nomeArquivo = ""; nomeArquivo = "";
charsetArquivo = "ISO-8859-1"; charsetArquivo = "ISO-8859-1";
} }
public static long length(){ public static long length(){
long resp = -1; long resp = -1;
if(read != write){ if(read != write){
File file = new File(nomeArquivo); File file = new File(nomeArquivo);
resp = file.length(); resp = file.length();
} }
return resp; return resp;
} }
public static void print(int x){ public static void print(int x){
if(write == true){ if(write == true){
saida.format( "%d", x); saida.format( "%d", x);
} }
} }
public static void print(double x){ public static void print(double x){
if(write == true){ if(write == true){
saida.format( "%f", x); saida.format( "%f", x);
} }
} }
public static void print(String x){ public static void print(String x){
if(write == true){ if(write == true){
saida.format( "%s", x); saida.format( "%s", x);
} }
} }
public static void print(boolean x){ public static void print(boolean x){
if(write == true){ if(write == true){
saida.format( "%s", ((x) ? "true" : "false")); saida.format( "%s", ((x) ? "true" : "false"));
} }
} }
public static void print(char x){ public static void print(char x){
if(write == true){ if(write == true){
saida.format( "%c", x); saida.format( "%c", x);
} }
} }
public static void println(int x){ public static void println(int x){
if(write == true){ if(write == true){
saida.format( "%d\n", x); saida.format( "%d\n", x);
} }
} }
public static void println(double x){ public static void println(double x){
if(write == true){ if(write == true){
saida.format( "%f\n", x); saida.format( "%f\n", x);
} }
} }
public static void println(String x){ public static void println(String x){
if(write == true){ if(write == true){
saida.format( "%s\n", x); saida.format( "%s\n", x);
} }
} }
public static void println(boolean x){ public static void println(boolean x){
if(write == true){ if(write == true){
saida.format( "%s\n", ((x) ? "true" : "false")); saida.format( "%s\n", ((x) ? "true" : "false"));
} }
} }
public static void println(char x){ public static void println(char x){
if(write == true){ if(write == true){
saida.format( "%c\n", x); saida.format( "%c\n", x);
} }
} }
public static int readInt(){ public static int readInt(){
int resp = -1; int resp = -1;
try{ try{
resp = entrada.nextInt(); resp = entrada.nextInt();
} catch (Exception e) {} } catch (Exception e) {}
return resp; return resp;
} }
public static char readChar(){ public static char readChar(){
char resp = ' '; char resp = ' ';
try{ try{
resp = (char)entrada.nextByte(); resp = (char)entrada.nextByte();
} catch (Exception e) {} } catch (Exception e) {}
return resp; return resp;
} }
public static double readDouble(){ public static double readDouble(){
double resp = -1; double resp = -1;
try{ try{
resp = Double.parseDouble(readString().replace(",",".")); resp = Double.parseDouble(readString().replace(",","."));
} catch (Exception e) {} } catch (Exception e) {}
return resp; return resp;
} }
public static String readString(){ public static String readString(){
String resp = ""; String resp = "";
try{ try{
resp = entrada.next(); resp = entrada.next();
} catch (Exception e) { System.out.println(e.getMessage()); } } catch (Exception e) { System.out.println(e.getMessage()); }
return resp; return resp;
} }
public static boolean readBoolean(){ public static boolean readBoolean(){
boolean resp = false; boolean resp = false;
try{ try{
resp = (entrada.next().equals("true")) ? true : false; resp = (entrada.next().equals("true")) ? true : false;
} catch (Exception e) {} } catch (Exception e) {}
return resp; return resp;
} }
public static String readLine(){ public static String readLine(){
String resp = ""; String resp = "";
try{ try{
resp = entrada.nextLine(); resp = entrada.nextLine();
} catch (Exception e) { System.out.println(e.getMessage()); } } catch (Exception e) { System.out.println(e.getMessage()); }
return resp; return resp;
} }
public static boolean hasNext(){ public static boolean hasNext(){
return entrada.hasNext(); return entrada.hasNext();
} }
public static String readAll(){ public static String readAll(){
String resp = ""; String resp = "";
while(hasNext()){ while(hasNext()){
resp += (readLine() + "\n"); resp += (readLine() + "\n");
} }
return resp; return resp;
} }
} }

80
fonte/ajuda/java/ExemploURL.java → Codigos/ajuda/java/ExemploURL.java
View File

@ -1,40 +1,40 @@
import java.io.*; import java.io.*;
import java.net.*; import java.net.*;
class ExemploURL { class ExemploURL {
public static String getHtml(String endereco){ public static String getHtml(String endereco){
URL url; URL url;
InputStream is = null; InputStream is = null;
BufferedReader br; BufferedReader br;
String resp = "", line; String resp = "", line;
try { try {
url = new URL(endereco); url = new URL(endereco);
is = url.openStream(); // throws an IOException is = url.openStream(); // throws an IOException
br = new BufferedReader(new InputStreamReader(is)); br = new BufferedReader(new InputStreamReader(is));
while ((line = br.readLine()) != null) { while ((line = br.readLine()) != null) {
resp += line + "\n"; resp += line + "\n";
} }
} catch (MalformedURLException mue) { } catch (MalformedURLException mue) {
mue.printStackTrace(); mue.printStackTrace();
} catch (IOException ioe) { } catch (IOException ioe) {
ioe.printStackTrace(); ioe.printStackTrace();
} }
try { try {
is.close(); is.close();
} catch (IOException ioe) { } catch (IOException ioe) {
// nothing to see here // nothing to see here
} }
return resp; return resp;
} }
public static void main(String[] args) { public static void main(String[] args) {
String endereco, html; String endereco, html;
endereco = "http://maratona.crc.pucminas.br/series/Friends.html"; endereco = "http://maratona.crc.pucminas.br/series/Friends.html";
html = getHtml(endereco); html = getHtml(endereco);
System.out.print(html); System.out.print(html);
} }
} }

504
fonte/ajuda/java/MyIO.java → Codigos/ajuda/java/MyIO.java
View File

@ -1,252 +1,252 @@
import java.io.*; import java.io.*;
import java.nio.charset.*; import java.nio.charset.*;
class MyIO { class MyIO {
private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in, Charset.forName("ISO-8859-1"))); private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in, Charset.forName("ISO-8859-1")));
private static String charset = "ISO-8859-1"; private static String charset = "ISO-8859-1";
public static void setCharset(String charset_){ public static void setCharset(String charset_){
charset = charset_; charset = charset_;
in = new BufferedReader(new InputStreamReader(System.in, Charset.forName(charset))); in = new BufferedReader(new InputStreamReader(System.in, Charset.forName(charset)));
} }
public static void print(){ public static void print(){
} }
public static void print(int x){ public static void print(int x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(x); out.print(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void print(float x){ public static void print(float x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(x); out.print(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void print(double x){ public static void print(double x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(x); out.print(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void print(String x){ public static void print(String x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(x); out.print(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void print(boolean x){ public static void print(boolean x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(x); out.print(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void print(char x){ public static void print(char x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(x); out.print(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void println(){ public static void println(){
} }
public static void println(int x){ public static void println(int x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.println(x); out.println(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void println(float x){ public static void println(float x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.println(x); out.println(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void println(double x){ public static void println(double x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.println(x); out.println(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void println(String x){ public static void println(String x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.println(x); out.println(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void println(boolean x){ public static void println(boolean x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.println(x); out.println(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void println(char x){ public static void println(char x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.println(x); out.println(x);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static void printf(String formato, double x){ public static void printf(String formato, double x){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.printf(formato, x);// "%.2f" out.printf(formato, x);// "%.2f"
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
} }
public static double readDouble(){ public static double readDouble(){
double d = -1; double d = -1;
try{ try{
d = Double.parseDouble(readString().trim().replace(",",".")); d = Double.parseDouble(readString().trim().replace(",","."));
}catch(Exception e){} }catch(Exception e){}
return d; return d;
} }
public static double readDouble(String str){ public static double readDouble(String str){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(str); out.print(str);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
return readDouble(); return readDouble();
} }
public static float readFloat(){ public static float readFloat(){
return (float) readDouble(); return (float) readDouble();
} }
public static float readFloat(String str){ public static float readFloat(String str){
return (float) readDouble(str); return (float) readDouble(str);
} }
public static int readInt(){ public static int readInt(){
int i = -1; int i = -1;
try{ try{
i = Integer.parseInt(readString().trim()); i = Integer.parseInt(readString().trim());
}catch(Exception e){} }catch(Exception e){}
return i; return i;
} }
public static int readInt(String str){ public static int readInt(String str){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(str); out.print(str);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
return readInt(); return readInt();
} }
public static String readString(){ public static String readString(){
String s = ""; String s = "";
char tmp; char tmp;
try{ try{
do{ do{
tmp = (char)in.read(); tmp = (char)in.read();
if(tmp != '\n' && tmp != ' ' && tmp != 13){ if(tmp != '\n' && tmp != ' ' && tmp != 13){
s += tmp; s += tmp;
} }
}while(tmp != '\n' && tmp != ' '); }while(tmp != '\n' && tmp != ' ');
}catch(IOException ioe){ }catch(IOException ioe){
System.out.println("lerPalavra: " + ioe.getMessage()); System.out.println("lerPalavra: " + ioe.getMessage());
} }
return s; return s;
} }
public static String readString(String str){ public static String readString(String str){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(str); out.print(str);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
return readString(); return readString();
} }
public static String readLine(){ public static String readLine(){
String s = ""; String s = "";
char tmp; char tmp;
try{ try{
do{ do{
tmp = (char)in.read(); tmp = (char)in.read();
if(tmp != '\n' && tmp != 13){ if(tmp != '\n' && tmp != 13){
s += tmp; s += tmp;
} }
}while(tmp != '\n'); }while(tmp != '\n');
}catch(IOException ioe){ }catch(IOException ioe){
System.out.println("lerPalavra: " + ioe.getMessage()); System.out.println("lerPalavra: " + ioe.getMessage());
} }
return s; return s;
} }
public static String readLine(String str){ public static String readLine(String str){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(str); out.print(str);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
return readLine(); return readLine();
} }
public static char readChar(){ public static char readChar(){
char resp = ' '; char resp = ' ';
try{ try{
resp = (char)in.read(); resp = (char)in.read();
}catch(Exception e){} }catch(Exception e){}
return resp; return resp;
} }
public static char readChar(String str){ public static char readChar(String str){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(str); out.print(str);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
return readChar(); return readChar();
} }
public static boolean readBoolean(){ public static boolean readBoolean(){
boolean resp = false; boolean resp = false;
String str = ""; String str = "";
try{ try{
str = readString(); str = readString();
}catch(Exception e){} }catch(Exception e){}
if(str.equals("true") || str.equals("TRUE") || str.equals("t") || str.equals("1") || if(str.equals("true") || str.equals("TRUE") || str.equals("t") || str.equals("1") ||
str.equals("verdadeiro") || str.equals("VERDADEIRO") || str.equals("V")){ str.equals("verdadeiro") || str.equals("VERDADEIRO") || str.equals("V")){
resp = true; resp = true;
} }
return resp; return resp;
} }
public static boolean readBoolean(String str){ public static boolean readBoolean(String str){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(str); out.print(str);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
return readBoolean(); return readBoolean();
} }
public static void pause(){ public static void pause(){
try{ try{
in.read(); in.read();
}catch(Exception e){} }catch(Exception e){}
} }
public static void pause(String str){ public static void pause(String str){
try { try {
PrintStream out = new PrintStream(System.out, true, charset); PrintStream out = new PrintStream(System.out, true, charset);
out.print(str); out.print(str);
}catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); } }catch(UnsupportedEncodingException e){ System.out.println("Erro: charset invalido"); }
pause(); pause();
} }
} }

36
fonte/u00 Nivelamento/c/aquivo/arq01.c → Codigos/u00 Nivelamento/c/aquivo/arq01.c
View File

@ -1,18 +1,18 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
FILE *p = fopen ("teste.txt", "r"); FILE *p = fopen ("teste.txt", "r");
// testa se o arquivo foi aberto com sucesso // testa se o arquivo foi aberto com sucesso
if (p != NULL) { if (p != NULL) {
printf ("Arquivo foi aberto com sucesso.\n\n"); printf ("Arquivo foi aberto com sucesso.\n\n");
fclose(p); fclose(p);
} else { } else {
printf ("Nao foi possivel abrir o arquivo.\n\n"); printf ("Nao foi possivel abrir o arquivo.\n\n");
} }
return 0; return 0;
} }

38
fonte/u00 Nivelamento/c/aquivo/arq02.c → Codigos/u00 Nivelamento/c/aquivo/arq02.c
View File

@ -1,19 +1,19 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
FILE *p = fopen ("teste.txt", "r"); FILE *p = fopen ("teste.txt", "r");
// testa se o arquivo foi aberto com sucesso // testa se o arquivo foi aberto com sucesso
if (p != NULL) { if (p != NULL) {
printf ("Arquivo foi aberto com sucesso.\n\n"); printf ("Arquivo foi aberto com sucesso.\n\n");
fclose(p); fclose(p);
} else { } else {
printf ("Nao foi possivel abrir o arquivo.\n\n"); printf ("Nao foi possivel abrir o arquivo.\n\n");
} }
return 0; return 0;
} }

42
fonte/u00 Nivelamento/c/aquivo/arq03.c → Codigos/u00 Nivelamento/c/aquivo/arq03.c
View File

@ -1,21 +1,21 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
FILE *p = fopen (argv[1], "r"); FILE *p = fopen (argv[1], "r");
int ch; int ch;
if (p != NULL) { if (p != NULL) {
do { do {
ch = fgetc(p); ch = fgetc(p);
if(ch != EOF){ if(ch != EOF){
printf( "%i %c\n", ch, (char)ch); printf( "%i %c\n", ch, (char)ch);
//printf( "%c", (char)ch); //printf( "%c", (char)ch);
} }
} while (ch != EOF); } while (ch != EOF);
fclose(p); fclose(p);
} }
return 0; return 0;
} }

46
fonte/u00 Nivelamento/c/aquivo/arq04.c → Codigos/u00 Nivelamento/c/aquivo/arq04.c
View File

@ -1,23 +1,23 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
FILE *p = fopen ("teste.txt", "r"); FILE *p = fopen ("teste.txt", "r");
char str[100+1]; char str[100+1];
char* resp; char* resp;
int i = 0; int i = 0;
if (p != NULL) { if (p != NULL) {
do { do {
resp = fgets(str, 100, p); resp = fgets(str, 100, p);
if(resp != NULL){ if(resp != NULL){
printf("(%d) %s", i, str); printf("(%d) %s", i, str);
i++; i++;
} }
} while (resp != NULL); } while (resp != NULL);
fclose(p); fclose(p);
} }
return 0; return 0;
} }

24
fonte/u00 Nivelamento/c/aquivo/arq05.c → Codigos/u00 Nivelamento/c/aquivo/arq05.c
View File

@ -1,12 +1,12 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
FILE *p = fopen ("teste.txt", "w"); FILE *p = fopen ("teste.txt", "w");
fputc('M', p); fputc('M', p);
fclose(p); fclose(p);
return 0; return 0;
} }

22
fonte/u00 Nivelamento/c/aquivo/arq06.c → Codigos/u00 Nivelamento/c/aquivo/arq06.c
View File

@ -1,11 +1,11 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
FILE *p = fopen ("teste.txt", "w"); FILE *p = fopen ("teste.txt", "w");
fputs("Algoritmos e Estruturas de Dados II", p); fputs("Algoritmos e Estruturas de Dados II", p);
fclose(p); fclose(p);
return 0; return 0;
} }

38
fonte/u00 Nivelamento/c/aquivo/arq07.c → Codigos/u00 Nivelamento/c/aquivo/arq07.c
View File

@ -1,19 +1,19 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
FILE *in = fopen ("teste.txt", "r"), FILE *in = fopen ("teste.txt", "r"),
*out = fopen ("copia.txt", "w"); *out = fopen ("copia.txt", "w");
while ( !feof(in) ) { while ( !feof(in) ) {
char ch = getc(in); char ch = getc(in);
if ( !feof(in)) { if ( !feof(in)) {
putc(ch, out); putc(ch, out);
} }
} }
fclose(in); fclose(in);
fclose(out); fclose(out);
return 0; return 0;
} }

48
fonte/u00 Nivelamento/c/aquivo/arq08.c → Codigos/u00 Nivelamento/c/aquivo/arq08.c
View File

@ -1,24 +1,24 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
FILE *p; FILE *p;
double d = 12.23; double d = 12.23;
int i = 101; int i = 101;
long l = 123023L; long l = 123023L;
if ((p = fopen("teste.txt", "wb")) == NULL) { if ((p = fopen("teste.txt", "wb")) == NULL) {
printf ("arquivo nao pode ser aberto\n"); printf ("arquivo nao pode ser aberto\n");
exit(1); exit(1);
} }
fwrite(&d, sizeof(double), 1, p); fwrite(&d, sizeof(double), 1, p);
fwrite(&i, sizeof(int), 1, p); fwrite(&i, sizeof(int), 1, p);
fwrite(&l, sizeof(long), 1, p); fwrite(&l, sizeof(long), 1, p);
fclose(p); fclose(p);
return 0; return 0;
} }

50
fonte/u00 Nivelamento/c/aquivo/arq09.c → Codigos/u00 Nivelamento/c/aquivo/arq09.c
View File

@ -1,25 +1,25 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
FILE *p; FILE *p;
double d; double d;
int i; int i;
long l; long l;
if ((p = fopen("teste.txt", "rb")) == NULL) { if ((p = fopen("teste.txt", "rb")) == NULL) {
printf ("arquivo nao pode ser aberto\n"); printf ("arquivo nao pode ser aberto\n");
exit(1); exit(1);
} }
fread(&d, sizeof(double), 1, p); fread(&d, sizeof(double), 1, p);
fread (&i, sizeof(int), 1, p); fread (&i, sizeof(int), 1, p);
fread (&l, sizeof(long), 1, p); fread (&l, sizeof(long), 1, p);
printf("%f %d %ld", d, i, l); printf("%f %d %ld", d, i, l);
fclose(p); fclose(p);
return 0; return 0;
} }

70
fonte/u00 Nivelamento/c/aquivo/arq10.c → Codigos/u00 Nivelamento/c/aquivo/arq10.c
View File

@ -1,35 +1,35 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
typedef struct cliente { typedef struct cliente {
char nome[100]; char nome[100];
int codigo; int codigo;
} cliente; } cliente;
void escrever(char*); void escrever(char*);
void ler(char*); void ler(char*);
void main(int argc, char** argv){ void main(int argc, char** argv){
escrever("teste.txt"); escrever("teste.txt");
ler("teste.txt"); ler("teste.txt");
} }
void escrever(char* nomeArq){ void escrever(char* nomeArq){
cliente c1, c2; cliente c1, c2;
strcat(c1.nome, "Ze da Silva"); c1.codigo = 1; strcat(c1.nome, "Ze da Silva"); c1.codigo = 1;
strcat(c2.nome, "Lele da Cuca"); c2.codigo = 11; strcat(c2.nome, "Lele da Cuca"); c2.codigo = 11;
FILE *p = fopen(nomeArq, "ab"); FILE *p = fopen(nomeArq, "ab");
fwrite(&c1, sizeof(cliente), 1, p); fwrite(&c1, sizeof(cliente), 1, p);
fwrite(&c2, sizeof(cliente), 1, p); fwrite(&c2, sizeof(cliente), 1, p);
fclose(p); fclose(p);
} }
void ler(char* nomeArq){ void ler(char* nomeArq){
cliente c1, c2; cliente c1, c2;
FILE *p = fopen(nomeArq, "rb"); FILE *p = fopen(nomeArq, "rb");
fread(&c1, sizeof(cliente), 1, p); fread(&c1, sizeof(cliente), 1, p);
fread(&c2, sizeof(cliente), 1, p); fread(&c2, sizeof(cliente), 1, p);
fclose(p); fclose(p);
printf("%s -- %d\n", c1.nome, c1.codigo); printf("%s -- %d\n", c1.nome, c1.codigo);
printf("%s -- %d\n", c2.nome, c2.codigo); printf("%s -- %d\n", c2.nome, c2.codigo);
} }

46
fonte/u00 Nivelamento/c/aquivo/arq11.c → Codigos/u00 Nivelamento/c/aquivo/arq11.c
View File

@ -1,23 +1,23 @@
#include <stdio.h> #include <stdio.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
FILE *p = fopen("teste.txt", "wb+"); FILE *p = fopen("teste.txt", "wb+");
double d = 12.23; int i = 101; long l = 123023L; double d = 12.23; int i = 101; long l = 123023L;
fwrite(&d, sizeof(double), 1, p); fwrite(&d, sizeof(double), 1, p);
fwrite(&i, sizeof(int), 1, p); fwrite(&i, sizeof(int), 1, p);
fwrite(&l, sizeof(long), 1, p); fwrite(&l, sizeof(long), 1, p);
rewind(p); rewind(p);
fread(&d, sizeof(double), 1, p); fread(&d, sizeof(double), 1, p);
fread (&i, sizeof(int), 1, p); fread (&i, sizeof(int), 1, p);
fread (&l, sizeof(long), 1, p); fread (&l, sizeof(long), 1, p);
printf("%f %d %ld", d, i, l); printf("%f %d %ld", d, i, l);
fclose(p); fclose(p);
return 0; return 0;
} }

44
fonte/u00 Nivelamento/c/aquivo/arq12.c → Codigos/u00 Nivelamento/c/aquivo/arq12.c
View File

@ -1,22 +1,22 @@
#include <stdio.h> #include <stdio.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
FILE *p = fopen("teste.txt", "wb+"); FILE *p = fopen("teste.txt", "wb+");
int registro, valor, i; int registro, valor, i;
for (i = valor = 0; i < 10; i++, valor = i * 10) fwrite(&valor, sizeof(int), 1, p); for (i = valor = 0; i < 10; i++, valor = i * 10) fwrite(&valor, sizeof(int), 1, p);
int numRegistro = ftell(p) / sizeof (int); int numRegistro = ftell(p) / sizeof (int);
do { do {
printf ("\nEscolha um numero entre zero e %i: ", numRegistro-1); printf ("\nEscolha um numero entre zero e %i: ", numRegistro-1);
scanf("%d", &registro); scanf("%d", &registro);
} while (registro < 0 || registro >= numRegistro); } while (registro < 0 || registro >= numRegistro);
fseek(p, registro * sizeof(int), SEEK_SET); fseek(p, registro * sizeof(int), SEEK_SET);
fread(&valor, sizeof(int), 1, p); fread(&valor, sizeof(int), 1, p);
fclose(p); fclose(p);
printf ("\nValor: %d\n\n", valor); printf ("\nValor: %d\n\n", valor);
return 0; return 0;
} }

232
fonte/u00 Nivelamento/c/aquivo/arquivos.c → Codigos/u00 Nivelamento/c/aquivo/arquivos.c
View File

@ -1,117 +1,117 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
//============================================================================= //=============================================================================
void gravar_arquivo_texto(){ void gravar_arquivo_texto(){
// ABRIR O ARQUIVO // ABRIR O ARQUIVO
FILE *arq = fopen("arquivo.txt", "w"); FILE *arq = fopen("arquivo.txt", "w");
if(arq == NULL){ if(arq == NULL){
printf("Erro ao tentar abrir o arquivo!\n"); printf("Erro ao tentar abrir o arquivo!\n");
return; return;
} }
// ESCREVER NO ARQUIVO // ESCREVER NO ARQUIVO
fprintf(arq, "%s\t", "Algoritmos"); fprintf(arq, "%s\t", "Algoritmos");
fprintf(arq, "%d\t", 1); fprintf(arq, "%d\t", 1);
fprintf(arq, "%f\t", 5.3); fprintf(arq, "%f\t", 5.3);
fprintf(arq, "%c\t", 'X'); fprintf(arq, "%c\t", 'X');
// FECHA O ARQUIVO // FECHA O ARQUIVO
fclose(arq); fclose(arq);
} }
//============================================================================= //=============================================================================
void ler_texto_texto(){ void ler_texto_texto(){
char texto[12], caracter; char texto[12], caracter;
int inteiro; int inteiro;
float real; float real;
// ABRIR O ARQUIVO // ABRIR O ARQUIVO
FILE *arq = fopen("arquivo.txt", "r"); FILE *arq = fopen("arquivo.txt", "r");
if(arq == NULL){ if(arq == NULL){
printf("Erro ao tentar abrir o arquivo!\n"); printf("Erro ao tentar abrir o arquivo!\n");
return; return;
} }
// LE O ARQUIVO // LE O ARQUIVO
fscanf(arq, "%99[^\t]\t", &texto); // LER STRING fscanf(arq, "%99[^\t]\t", &texto); // LER STRING
fscanf(arq, "%d\t", &inteiro); fscanf(arq, "%d\t", &inteiro);
fscanf(arq, "%f\t", &real); fscanf(arq, "%f\t", &real);
fscanf(arq, "%c\t", &caracter); fscanf(arq, "%c\t", &caracter);
// FECHA O ARQUIVO // FECHA O ARQUIVO
fclose(arq); fclose(arq);
printf("texto: %s\n", texto); printf("texto: %s\n", texto);
printf("inteiro: %d\n", inteiro); printf("inteiro: %d\n", inteiro);
printf("real: %f\n", real); printf("real: %f\n", real);
printf("caracter: %c\n", caracter); printf("caracter: %c\n", caracter);
} }
//============================================================================= //=============================================================================
void gravar_arquivo_binario(){ void gravar_arquivo_binario(){
char texto[12] = "Algoritmos", caracter = 'X'; char texto[12] = "Algoritmos", caracter = 'X';
int inteiro = 1; int inteiro = 1;
float real = 5.3; float real = 5.3;
// ABRIR O ARQUIVO // ABRIR O ARQUIVO
FILE *arq = fopen("arquivo.bin", "wb"); FILE *arq = fopen("arquivo.bin", "wb");
if(arq == NULL){ if(arq == NULL){
printf("Erro ao tentar abrir o arquivo!\n"); printf("Erro ao tentar abrir o arquivo!\n");
return; return;
} }
// ESCREVER NO ARQUIVO // ESCREVER NO ARQUIVO
fwrite(&texto, sizeof(char), 12, arq); fwrite(&texto, sizeof(char), 12, arq);
fwrite(&inteiro, sizeof(int), 1, arq); fwrite(&inteiro, sizeof(int), 1, arq);
fwrite(&real, sizeof(float), 1, arq); fwrite(&real, sizeof(float), 1, arq);
fwrite(&caracter,sizeof(char), 1, arq); fwrite(&caracter,sizeof(char), 1, arq);
// FECHA O ARQUIVO // FECHA O ARQUIVO
fclose(arq); fclose(arq);
} }
//============================================================================= //=============================================================================
void ler_texto_binario(){ void ler_texto_binario(){
char texto[12], caracter; char texto[12], caracter;
int inteiro; int inteiro;
float real; float real;
// ABRIR O ARQUIVO // ABRIR O ARQUIVO
FILE *arq = fopen("arquivo.bin", "rb"); FILE *arq = fopen("arquivo.bin", "rb");
if(arq == NULL){ if(arq == NULL){
printf("Erro ao tentar abrir o arquivo!\n"); printf("Erro ao tentar abrir o arquivo!\n");
return; return;
} }
// LE O ARQUIVO // LE O ARQUIVO
fread(&texto, sizeof(char), 12, arq); fread(&texto, sizeof(char), 12, arq);
fread(&inteiro, sizeof(int), 1, arq); fread(&inteiro, sizeof(int), 1, arq);
fread(&real, sizeof(float), 1, arq); fread(&real, sizeof(float), 1, arq);
fread(&caracter,sizeof(char), 1, arq); fread(&caracter,sizeof(char), 1, arq);
// FECHA O ARQUIVO // FECHA O ARQUIVO
fclose(arq); fclose(arq);
printf("texto: %s\n", texto); printf("texto: %s\n", texto);
printf("inteiro: %d\n", inteiro); printf("inteiro: %d\n", inteiro);
printf("real: %f\n", real); printf("real: %f\n", real);
printf("caracter: %c\n", caracter); printf("caracter: %c\n", caracter);
} }
//============================================================================= //=============================================================================
int main(){ int main(){
gravar_arquivo_texto(); gravar_arquivo_texto();
ler_texto_texto(); ler_texto_texto();
gravar_arquivo_binario(); gravar_arquivo_binario();
ler_texto_binario(); ler_texto_binario();
return 1; return 1;
} }

26
fonte/u00 Nivelamento/c/argumentos_main.c → Codigos/u00 Nivelamento/c/argumentos_main.c
View File

@ -1,14 +1,14 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
//============================================================================= //=============================================================================
// EXEMPLO DE UTILIZAÇÃO DOS ARGUMENTOS PASSADOS PARA O MAIN // EXEMPLO DE UTILIZAÇÃO DOS ARGUMENTOS PASSADOS PARA O MAIN
int main(int argc, char *argv[]){ int main(int argc, char *argv[]){
int i; int i;
for (i = 0; i < argc; i++) for (i = 0; i < argc; i++)
printf("%d Parametro: %s\n", i, argv[i]); printf("%d Parametro: %s\n", i, argv[i]);
return 0; return 0;
} }
//============================================================================= //=============================================================================

44
fonte/u00 Nivelamento/c/leituraescrita.c → Codigos/u00 Nivelamento/c/leituraescrita.c
View File

@ -1,22 +1,22 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main(int argc, char *argv[]){ int main(int argc, char *argv[]){
char c; char c;
char s[100]; char s[100];
int i; int i;
double d; double d;
printf("\nEntre com um caractere: "); printf("\nEntre com um caractere: ");
scanf("%c", &c); scanf("%c", &c);
printf("\nEntre com uma palavra: "); printf("\nEntre com uma palavra: ");
scanf("%s", s); scanf("%s", s);
printf("\nEntre com um inteiro e um real: "); printf("\nEntre com um inteiro e um real: ");
scanf("%i%lf", &i, &d); scanf("%i%lf", &i, &d);
printf("\ninteiro(%d) real(%f) char(%c) s(%s)", i, d, c, s); printf("\ninteiro(%d) real(%f) char(%c) s(%s)", i, d, c, s);
return 0; return 0;
} }

12
fonte/u00 Nivelamento/c/makefile/helloworld.c → Codigos/u00 Nivelamento/c/makefile/helloworld.c
View File

@ -1,6 +1,6 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
void helloWorld(void){ void helloWorld(void){
printf("Hello World!\n"); printf("Hello World!\n");
} }

12
fonte/u00 Nivelamento/c/makefile/helloworld.h → Codigos/u00 Nivelamento/c/makefile/helloworld.h
View File

@ -1,6 +1,6 @@
#ifndef _H_TESTE #ifndef _H_TESTE
#define _H_TESTE #define _H_TESTE
void helloWorld(void); void helloWorld(void);
#endif #endif

16
fonte/u00 Nivelamento/c/makefile/main.c → Codigos/u00 Nivelamento/c/makefile/main.c
View File

@ -1,8 +1,8 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include "helloworld.h" #include "helloworld.h"
int main(){ int main(){
helloWorld(); helloWorld();
return (0); return (0);
} }

30
fonte/u00 Nivelamento/c/makefile/makefile → Codigos/u00 Nivelamento/c/makefile/makefile
View File

@ -1,15 +1,15 @@
# My first makefile # My first makefile
all: printy all: printy
printy: main.o helloworld.o printy: main.o helloworld.o
gcc -o printy main.o helloworld.o gcc -o printy main.o helloworld.o
main.o: main.c helloworld.h main.o: main.c helloworld.h
gcc -o main.o main.c -c -W -Wall -ansi -pedantic gcc -o main.o main.c -c -W -Wall -ansi -pedantic
helloworld.o: helloworld.c helloworld.h helloworld.o: helloworld.c helloworld.h
gcc -o helloworld.o helloworld.c -c -W -Wall -ansi -pedantic gcc -o helloworld.o helloworld.c -c -W -Wall -ansi -pedantic
clean: clean:
rm -rf *.o *~ printy rm -rf *.o *~ printy

12
fonte/u00 Nivelamento/c/meuprimeiroprograma.c → Codigos/u00 Nivelamento/c/meuprimeiroprograma.c
View File

@ -1,6 +1,6 @@
#include <stdio.h> #include <stdio.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
printf ("Ola pessoal!!!\n\n"); printf ("Ola pessoal!!!\n\n");
return 0; return 0;
} }

26
fonte/u00 Nivelamento/c/ponteiro/ponteiro01.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro01.c
View File

@ -1,13 +1,13 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main (int argc, char** argv){ int main (int argc, char** argv){
int x = 10; int x = 10;
int * y = & x; int * y = & x;
printf("\n%i", x); printf("\n%i", x);
printf("\n%p", &x); printf("\n%p", &x);
printf("\n%p", y); printf("\n%p", y);
printf("\n%p", &y); printf("\n%p", &y);
printf("\n%i", *y); printf("\n%i", *y);
printf("\n"); printf("\n");
} }

38
fonte/u00 Nivelamento/c/ponteiro/ponteiro02.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro02.c
View File

@ -1,19 +1,19 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main (int argc, char** argv){ int main (int argc, char** argv){
int x1 = 11, int x1 = 11,
x2 = 22, x2 = 22,
x3 = 33; x3 = 33;
int *p; int *p;
p = &x1; //p <- o endereço de x1 p = &x1; //p <- o endereço de x1
x2 = *p; //x2 <- o cont. do addr apont. por p x2 = *p; //x2 <- o cont. do addr apont. por p
*p = x3; //o cont. do addr apont. por p <- x3 *p = x3; //o cont. do addr apont. por p <- x3
p = &x3; //p <- o endereço de x3 p = &x3; //p <- o endereço de x3
*p = 0; //o cont. do addr apont. por p <- x3 *p = 0; //o cont. do addr apont. por p <- x3
printf("\ncont:%d %d %d %d", x1, x2, x3, *p); printf("\ncont:%d %d %d %d", x1, x2, x3, *p);
printf("\naddr:%p %p %p %p", &x1, &x2, &x3, p); printf("\naddr:%p %p %p %p", &x1, &x2, &x3, p);
printf("\n"); printf("\n");
} }

54
fonte/u00 Nivelamento/c/ponteiro/ponteiro03.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro03.c
View File

@ -1,27 +1,27 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main (int argc, char** argv){ int main (int argc, char** argv){
int *x1; int *x1;
int x2; int x2;
int *x3; int *x3;
x1 = (int*) malloc (sizeof(int)); x1 = (int*) malloc (sizeof(int));
printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3); printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3);
*x1 = 20; *x1 = 20;
printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3); printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3);
x2 = *x1; x2 = *x1;
printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3); printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3);
*x3 = x2 * *x1; *x3 = x2 * *x1;
printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3); printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3);
x3 = &x2; x3 = &x2;
printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3); printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3);
x2 = 15; x2 = 15;
printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3); printf("\nx1(%p)(%i)(%p) x2(%i)(%p) x3(%p)(%i)(%p)", x1, *x1, &x1, x2, &x2, x3, *x3, &x3);
printf("\n"); printf("\n");
} }

26
fonte/u00 Nivelamento/c/ponteiro/ponteiro04.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro04.c
View File

@ -1,13 +1,13 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <math.h> #include <math.h>
int main (int argc, char** argv){ int main (int argc, char** argv){
double M [3][3]; double M [3][3];
double *p = M[0]; double *p = M[0];
for (int i = 0; i < pow(3, 2); i++, p++){ for (int i = 0; i < pow(3, 2); i++, p++){
*p=0.0; *p=0.0;
} }
} }

52
fonte/u00 Nivelamento/c/ponteiro/ponteiro05.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro05.c
View File

@ -1,26 +1,26 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#define MAXTAM 10 #define MAXTAM 10
typedef struct Cliente { typedef struct Cliente {
int codigo; int codigo;
char nome[MAXTAM]; char nome[MAXTAM];
} Cliente; } Cliente;
int main (int argc, char** argv){ int main (int argc, char** argv){
char* p1 = (char*) malloc (sizeof(char)); char* p1 = (char*) malloc (sizeof(char));
int* p2 = (int*) malloc (sizeof(int)); int* p2 = (int*) malloc (sizeof(int));
float* p3 = (float*) malloc (sizeof(float)); float* p3 = (float*) malloc (sizeof(float));
Cliente* p4 = (Cliente*) malloc (sizeof(Cliente)); Cliente* p4 = (Cliente*) malloc (sizeof(Cliente));
int* p5 = (int*) malloc (MAXTAM * sizeof (int)); int* p5 = (int*) malloc (MAXTAM * sizeof (int));
Cliente* p6 =(Cliente*) malloc (MAXTAM * sizeof (Cliente)); Cliente* p6 =(Cliente*) malloc (MAXTAM * sizeof (Cliente));
free(p1); free(p1);
free(p2); free(p2);
free(p3); free(p3);
free(p4); free(p4);
free(p5); free(p5);
free(p6); free(p6);
} }

52
fonte/u00 Nivelamento/c/ponteiro/ponteiro05emCMaisMais.cc → Codigos/u00 Nivelamento/c/ponteiro/ponteiro05emCMaisMais.cc
View File

@ -1,26 +1,26 @@
#include <iostream> #include <iostream>
using namespace std; using namespace std;
#define MAXTAM 10 #define MAXTAM 10
typedef struct Cliente { typedef struct Cliente {
int codigo; int codigo;
char nome[MAXTAM]; char nome[MAXTAM];
} Cliente; } Cliente;
int main (int argc, char** argv){ int main (int argc, char** argv){
char* p1 = new char; char* p1 = new char;
int* p2 = new int; int* p2 = new int;
float* p3 = new float; float* p3 = new float;
Cliente* p4 = new Cliente; Cliente* p4 = new Cliente;
int* p5 = new int [MAXTAM]; int* p5 = new int [MAXTAM];
Cliente* p6 = new Cliente[MAXTAM]; Cliente* p6 = new Cliente[MAXTAM];
delete p1; delete p1;
delete p2; delete p2;
delete p3; delete p3;
delete p4; delete p4;
delete [] p5; delete [] p5;
delete [] p6; delete [] p6;
} }

48
fonte/u00 Nivelamento/c/ponteiro/ponteiro06.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro06.c
View File

@ -1,24 +1,24 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#define MAXTAM 100 #define MAXTAM 100
typedef struct Cliente { typedef struct Cliente {
int codigo; int codigo;
char nome[MAXTAM]; char nome[MAXTAM];
} Cliente; } Cliente;
int main (int argc, char** argv){ int main (int argc, char** argv){
Cliente registro; Cliente registro;
Cliente* ponteiro = (Cliente*) malloc (sizeof(Cliente)); Cliente* ponteiro = (Cliente*) malloc (sizeof(Cliente));
registro.codigo = 1; registro.codigo = 1;
strcpy(registro.nome, "AA"); strcpy(registro.nome, "AA");
printf("\nFuncionario (%i): %s", registro.codigo, registro.nome); printf("\nFuncionario (%i): %s", registro.codigo, registro.nome);
ponteiro->codigo = 2; ponteiro->codigo = 2;
strcpy(ponteiro->nome, "BB"); strcpy(ponteiro->nome, "BB");
printf("\nFuncionario (%i): %s", ponteiro->codigo, ponteiro->nome); printf("\nFuncionario (%i): %s", ponteiro->codigo, ponteiro->nome);
printf("\n"); printf("\n");
} }

60
fonte/u00 Nivelamento/c/ponteiro/ponteiro07.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro07.c
View File

@ -1,30 +1,30 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main (int argc, char** argv){ int main (int argc, char** argv){
double a; double a;
double *p, *q; double *p, *q;
a = 3.14; a = 3.14;
printf("%f\n", a); printf("%f\n", a);
p = &a; p = &a;
*p = 2.718; *p = 2.718;
printf("%f\n", a); printf("%f\n", a);
a = 5; a = 5;
printf("%f\n", *p); printf("%f\n", *p);
p = NULL; p = NULL;
p = (double*) malloc(sizeof(double)); p = (double*) malloc(sizeof(double));
*p = 20; *p = 20;
q = p; q = p;
printf("%f\n", *p); printf("%f\n", *p);
printf("%f\n", a); printf("%f\n", a);
free(p); free(p);
printf("%f\n", *q); printf("%f\n", *q);
printf("\n"); printf("\n");
return 0; return 0;
} }

38
fonte/u00 Nivelamento/c/ponteiro/ponteiro08.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro08.c
View File

@ -1,19 +1,19 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main (int argc, char** argv){ int main (int argc, char** argv){
int a[10], *b; int a[10], *b;
b = a; b = a;
b[5] = 100; b[5] = 100;
printf("\n%d -- %d", a[5], b[5]); printf("\n%d -- %d", a[5], b[5]);
b = (int*) malloc(10*sizeof(int)); b = (int*) malloc(10*sizeof(int));
b[7] = 100; b[7] = 100;
printf("\n%d -- %d", a[7], b[7]); printf("\n%d -- %d", a[7], b[7]);
printf("\n"); printf("\n");
//O comando a = b gera um erro de compilação //O comando a = b gera um erro de compilação
return 0; return 0;
} }

80
fonte/u00 Nivelamento/c/ponteiro/ponteiro09.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro09.c
View File

@ -1,40 +1,40 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int main (int argc, char** argv){ int main (int argc, char** argv){
int *x1; int *x1;
int x2; int x2;
int *x3; int *x3;
x1 = (int*) malloc(sizeof(int)); x1 = (int*) malloc(sizeof(int));
printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3); printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3);
*x1 = 20; *x1 = 20;
printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3); printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3);
x2 = *x1; x2 = *x1;
printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3); printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3);
*x3 = x2 * *x1; *x3 = x2 * *x1;
printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3); printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3);
x3 = &x2; x3 = &x2;
printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3); printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3);
x2 = 15; x2 = 15;
printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3); printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3);
x2 = 13 & 3; x2 = 13 & 3;
printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3); printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3);
x2 = 13 | 3; x2 = 13 | 3;
printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3); printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3);
x2 = 13 >> 1; x2 = 13 >> 1;
printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3); printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3);
x2 = 13 << 1; x2 = 13 << 1;
printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3); printf("\nx1(%p)(%p)(%i) x2(%p)(%i) x3(%p)(%p)(%i)", &x1, x1, *x1, &x2, x2, &x3, x3, *x3);
return 0; return 0;
} }

42
fonte/u00 Nivelamento/c/ponteiro/ponteiro10.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro10.c
View File

@ -1,21 +1,21 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#define MAXTAM 10 #define MAXTAM 10
typedef struct Cliente { typedef struct Cliente {
int codigo; int codigo;
char nome[MAXTAM]; char nome[MAXTAM];
} Cliente; } Cliente;
int main (int argc, char** argv){ int main (int argc, char** argv){
Cliente c; Cliente c;
c.codigo = 5; c.codigo = 5;
Cliente *p = NULL; Cliente *p = NULL;
p = (Cliente*) malloc (sizeof(Cliente)); p = (Cliente*) malloc (sizeof(Cliente));
p->codigo = 6; p->codigo = 6;
Cliente *p2 = &c; Cliente *p2 = &c;
p2->codigo = 7; p2->codigo = 7;
return 0; return 0;
} }

40
fonte/u00 Nivelamento/c/ponteiro/ponteiro11.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro11.c
View File

@ -1,20 +1,20 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
typedef struct Celula { typedef struct Celula {
int elemento; int elemento;
struct Celula *prox; struct Celula *prox;
} Celula; } Celula;
Celula *novaCelula(int elemento) { Celula *novaCelula(int elemento) {
Celula *nova = (Celula*) malloc(sizeof(Celula)); Celula *nova = (Celula*) malloc(sizeof(Celula));
nova->elemento = elemento; nova->elemento = elemento;
nova->prox = NULL; nova->prox = NULL;
return nova; return nova;
} }
int main (int argc, char** argv){ int main (int argc, char** argv){
Celula *tmp = novaCelula(3); Celula *tmp = novaCelula(3);
return 0; return 0;
} }

40
fonte/u00 Nivelamento/c/ponteiro/ponteiro12.c → Codigos/u00 Nivelamento/c/ponteiro/ponteiro12.c
View File

@ -1,20 +1,20 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
typedef struct Elemento { typedef struct Elemento {
int valor; int valor;
} Elemento; } Elemento;
int main (int argc, char** argv){ int main (int argc, char** argv){
Elemento e1; Elemento e1;
Elemento* e2 = (Elemento*) malloc (3 * sizeof (Elemento)); Elemento* e2 = (Elemento*) malloc (3 * sizeof (Elemento));
Elemento e3[3]; Elemento e3[3];
Elemento** e4 = (Elemento**) malloc(3 * sizeof(Elemento*)); Elemento** e4 = (Elemento**) malloc(3 * sizeof(Elemento*));
e4[0] = (Elemento*) malloc(sizeof(Elemento*)); e4[0] = (Elemento*) malloc(sizeof(Elemento*));
e4[2] = (Elemento*) malloc(sizeof(Elemento*)); e4[2] = (Elemento*) malloc(sizeof(Elemento*));
e4[0]->valor = 7; e4[0]->valor = 7;
printf("\n%i -- %i\n", e4[0]->valor, e4[2]->valor); printf("\n%i -- %i\n", e4[0]->valor, e4[2]->valor);
return 0; return 0;
} }

52
fonte/u00 Nivelamento/c/recursividade/chamandometodo.c → Codigos/u00 Nivelamento/c/recursividade/chamandometodo.c
View File

@ -1,26 +1,26 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
void terceiro(){ void terceiro(){
printf("3o - inicio e fim\n"); printf("3o - inicio e fim\n");
} }
void segundo(){ void segundo(){
printf("2o - inicio\n"); printf("2o - inicio\n");
terceiro(); terceiro();
printf("2o - fim\n"); printf("2o - fim\n");
} }
void primeiro(){ void primeiro(){
printf("1o - inicio\n"); printf("1o - inicio\n");
segundo(); segundo();
printf("1o - fim\n"); printf("1o - fim\n");
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
printf("main - inicio\n"); printf("main - inicio\n");
primeiro(); primeiro();
printf("main - fim\n"); printf("main - fim\n");
return 0; return 0;
} }

90
fonte/u00 Nivelamento/c/recursividade/contarmaiuscula.c → Codigos/u00 Nivelamento/c/recursividade/contarmaiuscula.c
View File

@ -1,45 +1,45 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#define bool int #define bool int
#define true 1 #define true 1
#define false 0 #define false 0
bool isUpper(char x){ bool isUpper(char x){
return (x >= 'A' && x <= 'Z'); return (x >= 'A' && x <= 'Z');
} }
int contMaiusculo(char* s){ int contMaiusculo(char* s){
int cont = 0; int cont = 0;
for(int i = 0; i < strlen(s); i++){ for(int i = 0; i < strlen(s); i++){
if(isUpper(s[i]) == true){ if(isUpper(s[i]) == true){
cont++; cont++;
} }
} }
return cont; return cont;
} }
int contMaiusculoRec(char* s, int i){ int contMaiusculoRec(char* s, int i){
int cont = 0; int cont = 0;
if(i < strlen(s)){ if(i < strlen(s)){
if(isUpper(s[i]) == true){ if(isUpper(s[i]) == true){
cont++; cont++;
} }
cont += contMaiusculoRec(s, i + 1); cont += contMaiusculoRec(s, i + 1);
} }
return cont; return cont;
} }
int contMaiusculoRecursivo(char* s){ int contMaiusculoRecursivo(char* s){
return contMaiusculoRec(s, 0); return contMaiusculoRec(s, 0);
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
printf("\nAlGoritmos e Estrutudas de Dados: %i", contMaiusculo("AlGoritmos e Estruturas de Dados")); printf("\nAlGoritmos e Estrutudas de Dados: %i", contMaiusculo("AlGoritmos e Estruturas de Dados"));
printf("\nAlGoritmos e Estruturas de Dados: %i", contMaiusculoRecursivo("AlGoritmos e Estruturas de Dados")); printf("\nAlGoritmos e Estruturas de Dados: %i", contMaiusculoRecursivo("AlGoritmos e Estruturas de Dados"));
return 0; return 0;
} }

36
fonte/u00 Nivelamento/c/recursividade/fatorialrecursivo.c → Codigos/u00 Nivelamento/c/recursividade/fatorialrecursivo.c
View File

@ -1,18 +1,18 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int fatorial(int n){ int fatorial(int n){
int resp; int resp;
printf("\nfat (%i)", n); printf("\nfat (%i)", n);
resp = (n == 1) ? 1 : n * fatorial(n-1); resp = (n == 1) ? 1 : n * fatorial(n-1);
printf("\nfat n(%i): %i", n, resp); printf("\nfat n(%i): %i", n, resp);
return resp; return resp;
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
int n = 5; int n = 5;
printf("\nFATORIAL RECURSIVO(%i): %i", n, fatorial(n)); printf("\nFATORIAL RECURSIVO(%i): %i", n, fatorial(n));
return 0; return 0;
} }

36
fonte/u00 Nivelamento/c/recursividade/fibonaccirecursivo.c → Codigos/u00 Nivelamento/c/recursividade/fibonaccirecursivo.c
View File

@ -1,18 +1,18 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int fibonacci(int n){ int fibonacci(int n){
int resp; int resp;
printf("\nfib (%i)", n); printf("\nfib (%i)", n);
resp = (n == 0 || n == 1) ? 1 : fibonacci(n-1) + fibonacci(n-2); resp = (n == 0 || n == 1) ? 1 : fibonacci(n-1) + fibonacci(n-2);
printf("\nfib n(%i): %i", n, resp); printf("\nfib n(%i): %i", n, resp);
return resp; return resp;
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
int n = 5; int n = 5;
printf("\nFIBONACCI RECURSIVO(%i): %i", n, fibonacci(n)); printf("\nFIBONACCI RECURSIVO(%i): %i", n, fibonacci(n));
return 0; return 0;
} }

68
fonte/u00 Nivelamento/c/recursividade/multiplicacao.c → Codigos/u00 Nivelamento/c/recursividade/multiplicacao.c
View File

@ -1,34 +1,34 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
int multiplicacaoRec(int a, int b, int i){ int multiplicacaoRec(int a, int b, int i){
int resp = 0; int resp = 0;
if(i < b){ if(i < b){
resp = a + multiplicacaoRec(a, b, i+1); resp = a + multiplicacaoRec(a, b, i+1);
} }
return resp; return resp;
} }
int multiplicacao(int a, int b){ int multiplicacao(int a, int b){
return multiplicacaoRec(a, b, 0); return multiplicacaoRec(a, b, 0);
} }
int multiplicacaoIt(int a, int b){ int multiplicacaoIt(int a, int b){
int resp = 0; int resp = 0;
for(int i = 0; i < b; i++){ for(int i = 0; i < b; i++){
resp = a + resp; resp = a + resp;
} }
return resp; return resp;
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
int mult = multiplicacaoIt(4, 3); int mult = multiplicacaoIt(4, 3);
printf("\nRESPOSTA IT: %i", mult); printf("\nRESPOSTA IT: %i", mult);
mult = multiplicacao(4, 3); mult = multiplicacao(4, 3);
printf("\nRESPOSTA REC: %i", mult); printf("\nRESPOSTA REC: %i", mult);
return 0; return 0;
} }

34
fonte/u00 Nivelamento/c/recursividade/printrecursivo.c → Codigos/u00 Nivelamento/c/recursividade/printrecursivo.c
View File

@ -1,17 +1,17 @@
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
void printRecursivo(int i){ void printRecursivo(int i){
printf("\nvalor de i: %i", i); printf("\nvalor de i: %i", i);
if(i > 0){ if(i > 0){
printRecursivo(i-1); printRecursivo(i-1);
} }
printf("\nvalor de i: %i", i); printf("\nvalor de i: %i", i);
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
int n = 3; int n = 3;
printRecursivo(n); printRecursivo(n);
return 0; return 0;
} }

48
fonte/u00 Nivelamento/c/registro/registro01.c → Codigos/u00 Nivelamento/c/registro/registro01.c
View File

@ -1,24 +1,24 @@
#include <stdio.h> #include <stdio.h>
#define MAXTAM 100 #define MAXTAM 100
struct Funcionario { struct Funcionario {
int matricula; int matricula;
char nome[MAXTAM]; char nome[MAXTAM];
}; };
void main (){ void main (){
struct Funcionario f; struct Funcionario f;
printf("\nEntre com a matricula: "); printf("\nEntre com a matricula: ");
scanf("%d", &f.matricula); scanf("%d", &f.matricula);
printf("\nEntre com o nome: "); printf("\nEntre com o nome: ");
scanf("%s", f.nome); scanf("%s", f.nome);
printf("\nMatricula: %d", f.matricula); printf("\nMatricula: %d", f.matricula);
printf("\nNome: %s", f.nome); printf("\nNome: %s", f.nome);
printf("\n\n"); printf("\n\n");
} }

48
fonte/u00 Nivelamento/c/registro/registro02.c → Codigos/u00 Nivelamento/c/registro/registro02.c
View File

@ -1,24 +1,24 @@
#include <stdio.h> #include <stdio.h>
#define MAXTAM 100 #define MAXTAM 100
struct Funcionario { struct Funcionario {
int matricula; int matricula;
char nome[MAXTAM]; char nome[MAXTAM];
}; };
typedef struct Funcionario Funcionario; typedef struct Funcionario Funcionario;
void main (){ void main (){
Funcionario f; Funcionario f;
printf("\nEntre com a matricula: "); printf("\nEntre com a matricula: ");
scanf("%d", &f.matricula); scanf("%d", &f.matricula);
printf("\nEntre com o nome: "); printf("\nEntre com o nome: ");
scanf("%s", f.nome); scanf("%s", f.nome);
printf("\nMatricula: %d", f.matricula); printf("\nMatricula: %d", f.matricula);
printf("\nNome: %s", f.nome); printf("\nNome: %s", f.nome);
printf("\n\n"); printf("\n\n");
} }

44
fonte/u00 Nivelamento/c/registro/registro03.c → Codigos/u00 Nivelamento/c/registro/registro03.c
View File

@ -1,22 +1,22 @@
#include <stdio.h> #include <stdio.h>
#define MAXTAM 100 #define MAXTAM 100
typedef struct Funcionario { typedef struct Funcionario {
int matricula; int matricula;
char nome[MAXTAM]; char nome[MAXTAM];
} Funcionario; } Funcionario;
void main (){ void main (){
Funcionario f; Funcionario f;
printf("\nEntre com a matricula: "); printf("\nEntre com a matricula: ");
scanf("%d", &f.matricula); scanf("%d", &f.matricula);
printf("\nEntre com o nome: "); printf("\nEntre com o nome: ");
scanf("%s", f.nome); scanf("%s", f.nome);
printf("\nMatricula: %d", f.matricula); printf("\nMatricula: %d", f.matricula);
printf("\nNome: %s", f.nome); printf("\nNome: %s", f.nome);
printf("\n\n"); printf("\n\n");
} }

58
fonte/u00 Nivelamento/c/registro/registro04.c → Codigos/u00 Nivelamento/c/registro/registro04.c
View File

@ -1,29 +1,29 @@
#include <stdio.h> #include <stdio.h>
#define MAXTAM 100 #define MAXTAM 100
struct Funcionario { struct Funcionario {
int matricula; int matricula;
char nome[MAXTAM]; char nome[MAXTAM];
}; };
typedef struct Funcionario Funcionario; typedef struct Funcionario Funcionario;
void main (){ void main (){
Funcionario vet[MAXTAM]; Funcionario vet[MAXTAM];
int n = 3; int n = 3;
for(int i = 0; i < n; i++){ for(int i = 0; i < n; i++){
printf("\nEntre com a matricula do funcionario %d: ", (i+1)); printf("\nEntre com a matricula do funcionario %d: ", (i+1));
scanf("%d", &vet[i].matricula); scanf("%d", &vet[i].matricula);
printf("\nEntre com o nome do funcionario %d: ", (i+1)); printf("\nEntre com o nome do funcionario %d: ", (i+1));
scanf("%s", vet[i].nome); scanf("%s", vet[i].nome);
} }
for(int i = 0; i < n; i++){ for(int i = 0; i < n; i++){
printf("\nMatricula do funcionario %d: %d", (i+1), vet[i].matricula); printf("\nMatricula do funcionario %d: %d", (i+1), vet[i].matricula);
printf("\nNome do funcionario %d: %s\n", (i+1), vet[i].nome); printf("\nNome do funcionario %d: %s\n", (i+1), vet[i].nome);
} }
printf("\n\n"); printf("\n\n");
} }

28
fonte/u00 Nivelamento/c/sizeof.c → Codigos/u00 Nivelamento/c/sizeof.c
View File

@ -1,14 +1,14 @@
#include <stdio.h> #include <stdio.h>
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {
int a = sizeof(char), int a = sizeof(char),
b = sizeof(int), b = sizeof(int),
c = sizeof(double), c = sizeof(double),
d = sizeof(float); d = sizeof(float);
printf ("Tamanho do char: %i\n", a); printf ("Tamanho do char: %i\n", a);
printf ("Tamanho do int: %i\n", b); printf ("Tamanho do int: %i\n", b);
printf ("Tamanho do double: %i\n", c); printf ("Tamanho do double: %i\n", c);
printf ("Tamanho do float: %i\n", d); printf ("Tamanho do float: %i\n", d);
return 0; return 0;
} }

66
fonte/u00 Nivelamento/c/string.c → Codigos/u00 Nivelamento/c/string.c
View File

@ -1,33 +1,33 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
int main(int argc, char *argv[]){ int main(int argc, char *argv[]){
char s1[80], s2[80]; char s1[80], s2[80];
strcpy(s1, "Algoritmos"); strcpy(s1, "Algoritmos");
strcpy(s2, " e Estruturas de Dados II"); strcpy(s2, " e Estruturas de Dados II");
printf("\nTamanho s1(%i)", (int)strlen(s1)); printf("\nTamanho s1(%i)", (int)strlen(s1));
printf("\nTamanho s2(%i)", (int)strlen(s2)); printf("\nTamanho s2(%i)", (int)strlen(s2));
if(!strcmp(s1, s2)) printf("\nIguais!!!"); if(!strcmp(s1, s2)) printf("\nIguais!!!");
else printf("\nDiferentes!!!"); else printf("\nDiferentes!!!");
strcat(s1, s2); strcat(s1, s2);
printf("\nNova s1 (%s)", s1); printf("\nNova s1 (%s)", s1);
strcpy(s2, s1); strcpy(s2, s1);
printf("\nNova s2 (%s)", s2); printf("\nNova s2 (%s)", s2);
if(!strcmp(s1, s2)) printf("\nIguais!!!"); if(!strcmp(s1, s2)) printf("\nIguais!!!");
else printf("\nDiferentes!!!"); else printf("\nDiferentes!!!");
s1[10] = s2[10] = '\0'; s1[11] = 'a'; s2[11] = 'b'; s1[10] = s2[10] = '\0'; s1[11] = 'a'; s2[11] = 'b';
printf("\nNova s1 (%s)", s1); printf("\nNova s1 (%s)", s1);
printf("\nNova s2 (%s)", s2); printf("\nNova s2 (%s)", s2);
if(!strcmp(s1, s2)) printf("\nIguais!!!"); if(!strcmp(s1, s2)) printf("\nIguais!!!");
else printf("\nDiferentes!!!"); else printf("\nDiferentes!!!");
return 0; return 0;
} }

12
fonte/u00 Nivelamento/java/argumentoMain/ArgumentoMain.java → Codigos/u00 Nivelamento/java/argumentoMain/ArgumentoMain.java
View File

@ -1,6 +1,6 @@
class ArgumentoMain { class ArgumentoMain {
public static void main (String[] args){ public static void main (String[] args){
System.out.println("Primeiro parametro: " + args[0]); System.out.println("Primeiro parametro: " + args[0]);
System.out.println("Numero de parametros: " + args.length); System.out.println("Numero de parametros: " + args.length);
} }
} }

42
fonte/u00 Nivelamento/java/arquivo/ExemploArq01Escrita.java → Codigos/u00 Nivelamento/java/arquivo/ExemploArq01Escrita.java
View File

@ -1,21 +1,21 @@
class ExemploArq01Escrita class ExemploArq01Escrita
{ {
public static void main(String[] args) public static void main(String[] args)
{ {
//Abrir o arquivo texto //Abrir o arquivo texto
Arq.openWrite("exemplo.txt"); Arq.openWrite("exemplo.txt");
//Escrever no arquivo texto //Escrever no arquivo texto
Arq.println(1); Arq.println(1);
Arq.println(5.3); Arq.println(5.3);
Arq.println('X'); Arq.println('X');
Arq.println(true); Arq.println(true);
Arq.println("Algoritmos"); Arq.println("Algoritmos");
//Fechar o arquivo texto //Fechar o arquivo texto
Arq.close(); Arq.close();
} // Fim main() } // Fim main()
} // Fim class } // Fim class

56
fonte/u00 Nivelamento/java/arquivo/ExemploArq02Leitura.java → Codigos/u00 Nivelamento/java/arquivo/ExemploArq02Leitura.java
View File

@ -1,28 +1,28 @@
class ExemploArq02Leitura class ExemploArq02Leitura
{ {
public static void main(String[] args) public static void main(String[] args)
{ {
//Abrir o arquivo texto //Abrir o arquivo texto
Arq.openRead("exemplo.txt"); Arq.openRead("exemplo.txt");
//Ler o arquivo texto //Ler o arquivo texto
int inteiro = Arq.readInt(); int inteiro = Arq.readInt();
double real = Arq.readDouble(); double real = Arq.readDouble();
char caractere = Arq.readChar(); char caractere = Arq.readChar();
boolean boleano = Arq.readBoolean(); boolean boleano = Arq.readBoolean();
String str = Arq.readString(); String str = Arq.readString();
//Fechar o arquivo texto //Fechar o arquivo texto
Arq.close(); Arq.close();
//Mostrar os valores lidos na tela //Mostrar os valores lidos na tela
MyIO.println("inteiro: " + inteiro); MyIO.println("inteiro: " + inteiro);
MyIO.println("real: " + real); MyIO.println("real: " + real);
MyIO.println("caractere: " + caractere); MyIO.println("caractere: " + caractere);
MyIO.println("boleano: " + boleano); MyIO.println("boleano: " + boleano);
MyIO.println("str: " + str); MyIO.println("str: " + str);
} // Fim main() } // Fim main()
} // Fim class } // Fim class

56
fonte/u00 Nivelamento/java/arquivo/ExemploArq02bLeitura.java → Codigos/u00 Nivelamento/java/arquivo/ExemploArq02bLeitura.java
View File

@ -1,28 +1,28 @@
class ExemploArq02bLeitura class ExemploArq02bLeitura
{ {
public static void main(String[] args) public static void main(String[] args)
{ {
//Abrir o arquivo texto //Abrir o arquivo texto
Arq.openRead("exemplo.txt"); Arq.openRead("exemplo.txt");
//Ler o arquivo texto //Ler o arquivo texto
int inteiro = Integer.parseInt(Arq.readLine()); int inteiro = Integer.parseInt(Arq.readLine());
double real = Double.parseDouble(Arq.readLine().replace(",",".")); double real = Double.parseDouble(Arq.readLine().replace(",","."));
char caractere = Arq.readLine().charAt(0); char caractere = Arq.readLine().charAt(0);
boolean boleano = Boolean.parseBoolean(Arq.readLine()); boolean boleano = Boolean.parseBoolean(Arq.readLine());
String str = Arq.readLine(); String str = Arq.readLine();
//Fechar o arquivo texto //Fechar o arquivo texto
Arq.close(); Arq.close();
//Mostrar os valores lidos na tela //Mostrar os valores lidos na tela
MyIO.println("inteiro: " + inteiro); MyIO.println("inteiro: " + inteiro);
MyIO.println("real: " + real); MyIO.println("real: " + real);
MyIO.println("caractere: " + caractere); MyIO.println("caractere: " + caractere);
MyIO.println("boleano: " + boleano); MyIO.println("boleano: " + boleano);
MyIO.println("str: " + str); MyIO.println("str: " + str);
} // Fim main() } // Fim main()
} // Fim class } // Fim class

32
fonte/u00 Nivelamento/java/arquivo/ExemploArq03Exercicio.java → Codigos/u00 Nivelamento/java/arquivo/ExemploArq03Exercicio.java
View File

@ -1,16 +1,16 @@
class ExemploArq03Exercicio { class ExemploArq03Exercicio {
public static void main (String[] args){ public static void main (String[] args){
Arq.openRead("exemplo.txt"); Arq.openRead("exemplo.txt");
String str = ""; String str = "";
while (Arq.hasNext() == true){ while (Arq.hasNext() == true){
str += Arq.readChar(); str += Arq.readChar();
} }
Arq.close(); Arq.close();
Arq.openWrite("copia.txt"); Arq.openWrite("copia.txt");
Arq.print(str); Arq.print(str);
Arq.close(); Arq.close();
} }
} }

32
fonte/u00 Nivelamento/java/arquivo/ExemploRAF01Escrita.java → Codigos/u00 Nivelamento/java/arquivo/ExemploRAF01Escrita.java
View File

@ -1,16 +1,16 @@
import java.io.*; import java.io.*;
public class ExemploRAF01Escrita { public class ExemploRAF01Escrita {
public static void main(String args[]) throws Exception { public static void main(String args[]) throws Exception {
RandomAccessFile raf = new RandomAccessFile("exemplo.txt","rw"); RandomAccessFile raf = new RandomAccessFile("exemplo.txt","rw");
raf.writeInt(1); raf.writeInt(1);
raf.writeDouble(5.3); raf.writeDouble(5.3);
raf.writeChar('X'); raf.writeChar('X');
raf.writeBoolean(true); raf.writeBoolean(true);
raf.writeBytes("Algoritmos"); raf.writeBytes("Algoritmos");
raf.close(); raf.close();
} }
} }

44
fonte/u00 Nivelamento/java/arquivo/ExemploRAF02Leitura.java → Codigos/u00 Nivelamento/java/arquivo/ExemploRAF02Leitura.java
View File

@ -1,22 +1,22 @@
import java.io.*; import java.io.*;
class ExemploRAF02Leitura { class ExemploRAF02Leitura {
public static void main (String[] args) throws Exception{ public static void main (String[] args) throws Exception{
RandomAccessFile raf = new RandomAccessFile("exemplo.txt", "rw"); RandomAccessFile raf = new RandomAccessFile("exemplo.txt", "rw");
int inteiro = raf.readInt(); int inteiro = raf.readInt();
double real = raf.readDouble(); double real = raf.readDouble();
char caractere = raf.readChar(); char caractere = raf.readChar();
boolean boleano = raf.readBoolean(); boolean boleano = raf.readBoolean();
String str = raf.readLine(); String str = raf.readLine();
raf.close(); raf.close();
System.out.println("inteiro: " + inteiro); System.out.println("inteiro: " + inteiro);
System.out.println("real: " + real); System.out.println("real: " + real);
System.out.println("caractere: " + caractere); System.out.println("caractere: " + caractere);
System.out.println("boleano: " + boleano); System.out.println("boleano: " + boleano);
System.out.println("str: " + str); System.out.println("str: " + str);
} }
} }

58
fonte/u00 Nivelamento/java/arquivo/ExemploRAF03Cabecote.java → Codigos/u00 Nivelamento/java/arquivo/ExemploRAF03Cabecote.java
View File

@ -1,29 +1,29 @@
import java.io.*; import java.io.*;
public class ExemploRAF03Cabecote { public class ExemploRAF03Cabecote {
public static void main(String args[]) throws Exception { public static void main(String args[]) throws Exception {
RandomAccessFile raf = new RandomAccessFile("exemplo.txt","rw"); RandomAccessFile raf = new RandomAccessFile("exemplo.txt","rw");
raf.writeInt(1); raf.writeInt(1);
raf.writeDouble(5.3); raf.writeDouble(5.3);
raf.writeChar('X'); raf.writeChar('X');
raf.writeBoolean(true); raf.writeBoolean(true);
raf.writeBytes("Algoritmos"); raf.writeBytes("Algoritmos");
raf.seek(0); //Retornando o cabecote para a posicao 0 raf.seek(0); //Retornando o cabecote para a posicao 0
System.out.println(raf.readInt()); //imprimindo o inteiro System.out.println(raf.readInt()); //imprimindo o inteiro
raf.seek(12); //Setando o cabecote na posicao 12 (do caractere, raf.seek(12); //Setando o cabecote na posicao 12 (do caractere,
//12 = 4 do int + 8 do double) //12 = 4 do int + 8 do double)
System.out.println(raf.readChar()); System.out.println(raf.readChar());
raf.seek(12); //Setando o cabecote novamente na posicao 12 raf.seek(12); //Setando o cabecote novamente na posicao 12
raf.writeChar('@'); //Substituindo o caractere raf.writeChar('@'); //Substituindo o caractere
raf.seek(12); raf.seek(12);
System.out.println(raf.readChar()); System.out.println(raf.readChar());
raf.close(); raf.close();
} }
} }

0
fonte/u00 Nivelamento/java/classeObjeto/ExemploOO.java → Codigos/u00 Nivelamento/java/classeObjeto/ExemploOO.java
View File

86
fonte/u00 Nivelamento/java/classeObjeto/classeMatriz/Lixao.java → Codigos/u00 Nivelamento/java/classeObjeto/classeMatriz/Lixao.java
View File

@ -1,48 +1,48 @@
import java.util.*; import java.util.*;
class Lixao{ class Lixao{
public static Scanner sc = new Scanner(System.in); public static Scanner sc = new Scanner(System.in);
public static void main(String[] args){ public static void main(String[] args){
int linha, coluna; int linha, coluna;
Matriz m1, m2; Matriz m1, m2;
//Leitura do numero de linhas das matrizes //Leitura do numero de linhas das matrizes
System.out.println("Digite o numero de linhas:"); System.out.println("Digite o numero de linhas:");
linha = sc.nextInt(); linha = sc.nextInt();
//Leitura do numero de coluna das matrizes //Leitura do numero de coluna das matrizes
System.out.println("Digite o numero de colunas:"); System.out.println("Digite o numero de colunas:");
coluna = sc.nextInt(); coluna = sc.nextInt();
//Definicao do tamanho das matrizes //Definicao do tamanho das matrizes
m1 = new Matriz(linha,coluna); m1 = new Matriz(linha,coluna);
m2 = new Matriz(linha, coluna); m2 = new Matriz(linha, coluna);
//Leitura de cada elemento da matriz 1 //Leitura de cada elemento da matriz 1
m1.ler(); m1.ler();
//Leitura de cada elemento da matriz 2 //Leitura de cada elemento da matriz 2
m2.ler(); m2.ler();
//Somar as duas matrizes e salvar o resultado na matriz 3 //Somar as duas matrizes e salvar o resultado na matriz 3
Matriz m3 = m1.soma(m2); Matriz m3 = m1.soma(m2);
//Imprimir a matriz 1 //Imprimir a matriz 1
m1.imprimir(); m1.imprimir();
//Imprimir a matriz 2 //Imprimir a matriz 2
m2.imprimir(); m2.imprimir();
//Imprimir a matriz 3 //Imprimir a matriz 3
m3.imprimir(); m3.imprimir();
//Imprimir a matriz 1 em formato de grid //Imprimir a matriz 1 em formato de grid
m1.imprimirEmGrid(); m1.imprimirEmGrid();
//Imprimir a matriz 2 em formato de grid //Imprimir a matriz 2 em formato de grid
m2.imprimirEmGrid(); m2.imprimirEmGrid();
//Imprimir a matriz 3 em formato de grid //Imprimir a matriz 3 em formato de grid
m3.imprimirEmGrid(); m3.imprimirEmGrid();
} }
} }

122
fonte/u00 Nivelamento/java/classeObjeto/classeMatriz/Matriz.java → Codigos/u00 Nivelamento/java/classeObjeto/classeMatriz/Matriz.java
View File

@ -1,65 +1,65 @@
import java.util.*; import java.util.*;
class Matriz{ class Matriz{
private int linha; private int linha;
private int coluna; private int coluna;
private int[][] mat; private int[][] mat;
public static Scanner sc = new Scanner(System.in); public static Scanner sc = new Scanner(System.in);
public Matriz(){ public Matriz(){
linha = coluna = 10; linha = coluna = 10;
mat = new int[linha][coluna]; mat = new int[linha][coluna];
} }
public Matriz(int linha_, int coluna_){ public Matriz(int linha_, int coluna_){
linha = linha_; linha = linha_;
coluna = coluna_; coluna = coluna_;
mat = new int[linha][coluna]; mat = new int[linha][coluna];
} }
public int getElemento(int i, int j){ public int getElemento(int i, int j){
return mat[i][j]; return mat[i][j];
} }
public void setElemento(int i, int j, int valor){ public void setElemento(int i, int j, int valor){
mat[i][j] = valor; mat[i][j] = valor;
} }
public void ler(){ public void ler(){
for (int i = 0; i < linha; i++){ for (int i = 0; i < linha; i++){
for (int j = 0; j < coluna; j++){ for (int j = 0; j < coluna; j++){
System.out.println("Digite o elemento [" + i + "," + j + "]: "); System.out.println("Digite o elemento [" + i + "," + j + "]: ");
mat[i][j] = sc.nextInt(); mat[i][j] = sc.nextInt();
} }
} }
System.out.println(); System.out.println();
} }
public Matriz soma(Matriz outra){ public Matriz soma(Matriz outra){
Matriz resp = new Matriz(linha, coluna); Matriz resp = new Matriz(linha, coluna);
for (int i = 0; i < linha; i++){ for (int i = 0; i < linha; i++){
for (int j = 0; j < coluna; j++){ for (int j = 0; j < coluna; j++){
resp.mat[i][j] = mat[i][j] + outra.mat[i][j]; resp.mat[i][j] = mat[i][j] + outra.mat[i][j];
} }
} }
return resp; return resp;
} }
public void imprimir(){ public void imprimir(){
for (int i = 0; i < linha; i++){ for (int i = 0; i < linha; i++){
for (int j = 0; j < coluna; j++){ for (int j = 0; j < coluna; j++){
System.out.println("Mat[" + i + "," + j + "]: " + mat[i][j]); System.out.println("Mat[" + i + "," + j + "]: " + mat[i][j]);
} }
} }
System.out.println(); System.out.println();
} }
public void imprimirEmGrid(){ public void imprimirEmGrid(){
for (int i = 0; i < linha; i++){ for (int i = 0; i < linha; i++){
for (int j = 0; j < coluna; j++){ for (int j = 0; j < coluna; j++){
System.out.print(" " + mat[i][j]); System.out.print(" " + mat[i][j]);
} }
System.out.println(); System.out.println();
} }
System.out.println(); System.out.println();
} }
} }

0
fonte/u00 Nivelamento/java/classeObjeto/classeRetangulo/Lixao.java → Codigos/u00 Nivelamento/java/classeObjeto/classeRetangulo/Lixao.java
View File

88
fonte/u00 Nivelamento/java/classeObjeto/classeRetangulo/Principal.java → Codigos/u00 Nivelamento/java/classeObjeto/classeRetangulo/Principal.java
View File

@ -1,44 +1,44 @@
/** /**
* Introducao a programacao orientada por objetos * Introducao a programacao orientada por objetos
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
class Principal class Principal
{ {
public static void main(String[] args) public static void main(String[] args)
{ {
Retangulo r1 = new Retangulo(); Retangulo r1 = new Retangulo();
Retangulo r2 = new Retangulo(); Retangulo r2 = new Retangulo();
r1.lerTudo(); r1.lerTudo();
r1.escreverTudo(); r1.escreverTudo();
r2.lerTudo(); r2.lerTudo();
r2.escreverTudo(); r2.escreverTudo();
if (r1.comparar(r2.getB(), r2.getH()) == true){ if (r1.comparar(r2.getB(), r2.getH()) == true){
System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao iguais!"); System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao iguais!");
}else{ }else{
System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao diferentes!"); System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao diferentes!");
} }
if (r1.comparar(r2) == true){ if (r1.comparar(r2) == true){
System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao iguais!"); System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao iguais!");
}else{ }else{
System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao diferentes!"); System.out.println("Os retangulos " + r1.getNome() + " e " + r2.getNome() + "sao diferentes!");
} }
if (r1.comparar(r1) == true){ if (r1.comparar(r1) == true){
System.out.println("Os retangulos " + r1.getNome() + " e " + r1.getNome() + "sao iguais!"); System.out.println("Os retangulos " + r1.getNome() + " e " + r1.getNome() + "sao iguais!");
}else{ }else{
System.out.println("Os retangulos " + r1.getNome() + " e " + r1.getNome() + "sao diferentes!"); System.out.println("Os retangulos " + r1.getNome() + " e " + r1.getNome() + "sao diferentes!");
} }
if (r2.comparar(r1) == true){ if (r2.comparar(r1) == true){
System.out.println("Os retangulos " + r2.getNome() + " e " + r1.getNome() + "sao iguais!"); System.out.println("Os retangulos " + r2.getNome() + " e " + r1.getNome() + "sao iguais!");
}else{ }else{
System.out.println("Os retangulos " + r2.getNome() + " e " + r1.getNome() + "sao diferentes!"); System.out.println("Os retangulos " + r2.getNome() + " e " + r1.getNome() + "sao diferentes!");
} }
} }
} }

204
fonte/u00 Nivelamento/java/classeObjeto/classeRetangulo/Retangulo.java → Codigos/u00 Nivelamento/java/classeObjeto/classeRetangulo/Retangulo.java
View File

@ -1,102 +1,102 @@
/** /**
* Introducao a programacao orientada por objetos * Introducao a programacao orientada por objetos
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
class Retangulo{ class Retangulo{
//Declaracao de variaveis //Declaracao de variaveis
private double b, h; private double b, h;
private String nome; private String nome;
//Construtor vazio //Construtor vazio
public Retangulo(){ public Retangulo(){
this.b = this.h = 0; this.b = this.h = 0;
this.nome = ""; this.nome = "";
} }
//Construtor que recebe parametros //Construtor que recebe parametros
public Retangulo(double b, double h, String nome){ public Retangulo(double b, double h, String nome){
this.b = b; this.b = b;
this.h = h; this.h = h;
this.nome = nome; this.nome = nome;
} }
public double getB(){ public double getB(){
return this.b; return this.b;
} }
public void setB(double b){ public void setB(double b){
this.b = b; this.b = b;
} }
public double getH(){ public double getH(){
return this.h; return this.h;
} }
public void setH(double h){ public void setH(double h){
this.h = h; this.h = h;
} }
public String getNome(){ public String getNome(){
return this.nome; return this.nome;
} }
public void setNome(String nome){ public void setNome(String nome){
this.nome = nome; this.nome = nome;
} }
public void lerTudo(){ public void lerTudo(){
b = MyIO.readDouble("Entre com a base: "); b = MyIO.readDouble("Entre com a base: ");
h = MyIO.readDouble("Entre com a altura: "); h = MyIO.readDouble("Entre com a altura: ");
nome = MyIO.readString("Entre com o nome: "); nome = MyIO.readString("Entre com o nome: ");
} }
public void escreverTudo(){ public void escreverTudo(){
System.out.println("NOME: " + nome); System.out.println("NOME: " + nome);
System.out.println("Base: " + b); System.out.println("Base: " + b);
System.out.println("Altura: " + h); System.out.println("Altura: " + h);
System.out.println("Area: " + getArea()); System.out.println("Area: " + getArea());
System.out.println("Diagonal: " + getDiagonal()); System.out.println("Diagonal: " + getDiagonal());
System.out.println("Perimetro: " + getPerimetro()); System.out.println("Perimetro: " + getPerimetro());
} }
//Retornar a area //Retornar a area
public double getArea(){ public double getArea(){
return (b * h); return (b * h);
} }
//Retornar o perimetro //Retornar o perimetro
public double getPerimetro(){ public double getPerimetro(){
return ((b + h) * 2); return ((b + h) * 2);
} }
//Retornar a diagonal //Retornar a diagonal
public double getDiagonal(){ public double getDiagonal(){
return Math.sqrt(b * b + h * h); return Math.sqrt(b * b + h * h);
} }
//Comparar //Comparar
public boolean comparar(double outraB, double outraH){ public boolean comparar(double outraB, double outraH){
boolean resp; boolean resp;
if (this.b == outraB && this.h == outraH){ if (this.b == outraB && this.h == outraH){
resp = true; resp = true;
}else{ }else{
resp = false; resp = false;
} }
return resp; return resp;
} }
//Comparar //Comparar
//public boolean comparar(double outraB, double outraH){ //public boolean comparar(double outraB, double outraH){
// return (this.b == outraB && this.h == outraH); // return (this.b == outraB && this.h == outraH);
//} //}
//Comparar //Comparar
public boolean comparar(Retangulo x){ public boolean comparar(Retangulo x){
return (this.b == x.b && this.h == x.h); return (this.b == x.b && this.h == x.h);
} }
} }

38
fonte/u00 Nivelamento/java/classeObjeto/estatico/Estatico.java → Codigos/u00 Nivelamento/java/classeObjeto/estatico/Estatico.java
View File

@ -1,19 +1,19 @@
class Estatico { class Estatico {
public static int numeroEstatico; public static int numeroEstatico;
public int numeroNaoEstatico; public int numeroNaoEstatico;
public Estatico(){ public Estatico(){
numeroEstatico = 0; numeroEstatico = 0;
} }
public static void metodoEstatico(){ public static void metodoEstatico(){
System.out.println("Metodo Estatico: " + numeroEstatico); System.out.println("Metodo Estatico: " + numeroEstatico);
} }
public void metodoNaoEstatico(){ public void metodoNaoEstatico(){
System.out.println("Metodo Nao Estatico: " + numeroEstatico + " / " + numeroNaoEstatico); System.out.println("Metodo Nao Estatico: " + numeroEstatico + " / " + numeroNaoEstatico);
} }
public void setEstatico(int valor){ public void setEstatico(int valor){
numeroEstatico = valor; numeroEstatico = valor;
} }
} }

52
fonte/u00 Nivelamento/java/classeObjeto/estatico/Lixao.java → Codigos/u00 Nivelamento/java/classeObjeto/estatico/Lixao.java
View File

@ -1,26 +1,26 @@
class Lixao{ class Lixao{
public static void main(String[] args){ public static void main(String[] args){
Estatico e1 = new Estatico(); Estatico e1 = new Estatico();
Estatico e2 = new Estatico(); Estatico e2 = new Estatico();
System.out.println("(1) =================================="); System.out.println("(1) ==================================");
Estatico.numeroEstatico = 1; Estatico.numeroEstatico = 1;
System.out.println(Estatico.numeroEstatico); System.out.println(Estatico.numeroEstatico);
System.out.println(e1.numeroEstatico); System.out.println(e1.numeroEstatico);
e1.numeroEstatico = 3; e1.numeroEstatico = 3;
System.out.println(e2.numeroEstatico); System.out.println(e2.numeroEstatico);
e1.numeroNaoEstatico = 2; e1.numeroNaoEstatico = 2;
e2.numeroNaoEstatico = 4; e2.numeroNaoEstatico = 4;
System.out.println(e1.numeroNaoEstatico); System.out.println(e1.numeroNaoEstatico);
//Error non-static variable numeroNaoEstatico cannot be referenced from a static context //Error non-static variable numeroNaoEstatico cannot be referenced from a static context
//Estatico.numeroNaoEstatico = 10; //Estatico.numeroNaoEstatico = 10;
System.out.println("(2) =================================="); System.out.println("(2) ==================================");
Estatico.metodoEstatico(); Estatico.metodoEstatico();
e1.metodoNaoEstatico(); e1.metodoNaoEstatico();
//Estatico.metodoNaoEstatico(); //Estatico.metodoNaoEstatico();
} }
} }

0
fonte/u00 Nivelamento/java/classeObjeto/primeiraClasse/Funcionario.java → Codigos/u00 Nivelamento/java/classeObjeto/primeiraClasse/Funcionario.java
View File

0
fonte/u00 Nivelamento/java/classeObjeto/primeiraClasse/Lixao.java → Codigos/u00 Nivelamento/java/classeObjeto/primeiraClasse/Lixao.java
View File

54
fonte/u00 Nivelamento/java/classeObjeto/visibilidade/Lixao.java → Codigos/u00 Nivelamento/java/classeObjeto/visibilidade/Lixao.java
View File

@ -1,27 +1,27 @@
class Lixao{ class Lixao{
public static void main(String[] args){ public static void main(String[] args){
Visibilidade v = new Visibilidade(); Visibilidade v = new Visibilidade();
System.out.println("(1) =================================="); System.out.println("(1) ==================================");
v.numeroPublico = 1; v.numeroPublico = 1;
System.out.println(v.numeroPublico); System.out.println(v.numeroPublico);
//Error numeroPrivado has private access in Visibilidade //Error numeroPrivado has private access in Visibilidade
//v.numeroPrivado = 2; //v.numeroPrivado = 2;
//Error numeroPrivado has private access in Visibilidade //Error numeroPrivado has private access in Visibilidade
//System.out.println(v.numeroPrivado); //System.out.println(v.numeroPrivado);
v.setNumeroPrivado(3); v.setNumeroPrivado(3);
System.out.println(v.getNumeroPrivado()); System.out.println(v.getNumeroPrivado());
System.out.println("(2) =================================="); System.out.println("(2) ==================================");
v.metodoPublico(); v.metodoPublico();
//Error metodoPrivado() has private access in Visibilidade //Error metodoPrivado() has private access in Visibilidade
//v.metodoPrivado(); //v.metodoPrivado();
v.chamaPrivado(); v.chamaPrivado();
} } } }

0
fonte/u00 Nivelamento/java/classeObjeto/visibilidade/Visibilidade.java → Codigos/u00 Nivelamento/java/classeObjeto/visibilidade/Visibilidade.java
View File

86
fonte/u00 Nivelamento/java/entradaSaida/ExemploBufferedReader.java → Codigos/u00 Nivelamento/java/entradaSaida/ExemploBufferedReader.java
View File

@ -1,43 +1,43 @@
import java.io.*; import java.io.*;
import java.nio.charset.*; import java.nio.charset.*;
class ExemploBufferedReader { class ExemploBufferedReader {
//Declaracao da classe BufferedReader //Declaracao da classe BufferedReader
private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in, Charset.forName("ISO-8859-1"))); private static BufferedReader in = new BufferedReader(new InputStreamReader(System.in, Charset.forName("ISO-8859-1")));
public static String readString(){ public static String readString(){
String s = ""; String s = "";
char tmp; char tmp;
try{ try{
do{ do{
tmp = (char)in.read(); tmp = (char)in.read();
if(tmp != '\n' && tmp != ' ' && tmp != 13){ if(tmp != '\n' && tmp != ' ' && tmp != 13){
s += tmp; s += tmp;
} }
}while(tmp != '\n' && tmp != ' '); }while(tmp != '\n' && tmp != ' ');
}catch(IOException ioe){} }catch(IOException ioe){}
return s; return s;
} }
public static void main(String [] args) throws Exception { public static void main(String [] args) throws Exception {
System.out.printf("Entre com uma palavra: "); System.out.printf("Entre com uma palavra: ");
String str = readString(); String str = readString();
System.out.printf("Entre com um numero inteiro: "); System.out.printf("Entre com um numero inteiro: ");
int inteiro = Integer.parseInt(readString().trim()); int inteiro = Integer.parseInt(readString().trim());
System.out.printf("Entre com um numero real: "); System.out.printf("Entre com um numero real: ");
double real = Double.parseDouble(readString().trim().replace(",",".")); double real = Double.parseDouble(readString().trim().replace(",","."));
System.out.printf("Entre com um caractere: "); System.out.printf("Entre com um caractere: ");
char caractere = (char)in.read(); char caractere = (char)in.read();
System.out.println("Sua str: " + str); System.out.println("Sua str: " + str);
System.out.println("Seu inteiro: " + inteiro); System.out.println("Seu inteiro: " + inteiro);
System.out.println("Seu real: " + real); System.out.println("Seu real: " + real);
System.out.println("Seu caractere: " + caractere); System.out.println("Seu caractere: " + caractere);
} // fim main () } // fim main ()
} // fim class } // fim class

26
fonte/u00 Nivelamento/java/entradaSaida/ExemploMyIO.java → Codigos/u00 Nivelamento/java/entradaSaida/ExemploMyIO.java
View File

@ -1,13 +1,13 @@
class ExemploMyIO { class ExemploMyIO {
public static void main (String[] args){ public static void main (String[] args){
String str = MyIO.readString("Entre com uma palavra: "); String str = MyIO.readString("Entre com uma palavra: ");
int inteiro = MyIO.readInt("Entre com um inteiro: "); int inteiro = MyIO.readInt("Entre com um inteiro: ");
double real = MyIO.readDouble("Entre com um real: "); double real = MyIO.readDouble("Entre com um real: ");
char caractere = MyIO.readChar("Entre com um caractere: "); char caractere = MyIO.readChar("Entre com um caractere: ");
MyIO.println("Sua string: " + str); MyIO.println("Sua string: " + str);
MyIO.println("Seu inteiro: " + inteiro); MyIO.println("Seu inteiro: " + inteiro);
MyIO.println("Seu real: " + real); MyIO.println("Seu real: " + real);
MyIO.println("Seu caractere: " + caractere); MyIO.println("Seu caractere: " + caractere);
} }
} }

56
fonte/u00 Nivelamento/java/entradaSaida/ExemploScanner.java → Codigos/u00 Nivelamento/java/entradaSaida/ExemploScanner.java
View File

@ -1,28 +1,28 @@
import java.util.*; import java.util.*;
class ExemploScanner { class ExemploScanner {
public static void main(String [] args){ public static void main(String [] args){
//Declaracao da classe scanner //Declaracao da classe scanner
Scanner scanner = new Scanner (System.in); Scanner scanner = new Scanner (System.in);
System.out.printf("Entre com uma palavra: "); System.out.printf("Entre com uma palavra: ");
String str = scanner.nextLine(); String str = scanner.nextLine();
System.out.printf("Entre com um caractere: "); System.out.printf("Entre com um caractere: ");
char caractere = scanner.nextLine().charAt(0); char caractere = scanner.nextLine().charAt(0);
System.out.printf("Entre com um numero inteiro: "); System.out.printf("Entre com um numero inteiro: ");
int inteiro = scanner.nextInt(); int inteiro = scanner.nextInt();
System.out.printf("Entre com um numero real: "); System.out.printf("Entre com um numero real: ");
double real = scanner.nextDouble(); double real = scanner.nextDouble();
System.out.println("Sua str: " + str); System.out.println("Sua str: " + str);
System.out.println("Seu inteiro: " + inteiro); System.out.println("Seu inteiro: " + inteiro);
System.out.println("Seu real: " + real); System.out.println("Seu real: " + real);
System.out.println("Seu caractere: " + caractere); System.out.println("Seu caractere: " + caractere);
} // fim main () } // fim main ()
} // fim class } // fim class

10
fonte/u00 Nivelamento/java/entradaSaida/entrada.txt → Codigos/u00 Nivelamento/java/entradaSaida/entrada.txt
View File

@ -1,5 +1,5 @@
hoje hoje
3000000 3000000
12.3 12.3
a a

0
fonte/u00 Nivelamento/java/ponteiro/Cliente.java → Codigos/u00 Nivelamento/java/ponteiro/Cliente.java
View File

28
fonte/u00 Nivelamento/java/ponteiro/Ponteiro01Array.java → Codigos/u00 Nivelamento/java/ponteiro/Ponteiro01Array.java
View File

@ -1,14 +1,14 @@
/** /**
* Ponteiro * Ponteiro
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
class Ponteiro01Array { class Ponteiro01Array {
public static void main (String[] args) { public static void main (String[] args) {
int[] vet = new int [5]; int[] vet = new int [5];
System.out.println(vet); System.out.println(vet);
vet = new int [5]; vet = new int [5];
System.out.println(vet); System.out.println(vet);
} }
} }

38
fonte/u00 Nivelamento/java/ponteiro/Ponteiro02PassagemTipoPrimitivo.java → Codigos/u00 Nivelamento/java/ponteiro/Ponteiro02PassagemTipoPrimitivo.java
View File

@ -1,19 +1,19 @@
/** /**
* Ponteiro * Ponteiro
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
class Ponteiro02PassagemTipoPrimitivo { class Ponteiro02PassagemTipoPrimitivo {
public static void passagemDeTipoPrimitivo(int a){ public static void passagemDeTipoPrimitivo(int a){
System.out.println("a: " + a); System.out.println("a: " + a);
a = 10; a = 10;
System.out.println("a: " + a); System.out.println("a: " + a);
} }
public static void main(String[] args) { public static void main(String[] args) {
int x = 5; int x = 5;
System.out.println("x: " + x); System.out.println("x: " + x);
passagemDeTipoPrimitivo(x); passagemDeTipoPrimitivo(x);
System.out.println("x: " + x); System.out.println("x: " + x);
} }
} }

62
fonte/u00 Nivelamento/java/ponteiro/Ponteiro03PassagemArray.java → Codigos/u00 Nivelamento/java/ponteiro/Ponteiro03PassagemArray.java
View File

@ -1,31 +1,31 @@
/** /**
* Ponteiro * Ponteiro
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
class Ponteiro03PassagemArray { class Ponteiro03PassagemArray {
public static void passangemDeArray(int[] b){ public static void passangemDeArray(int[] b){
for(int i = 0; i < 5; i++){ for(int i = 0; i < 5; i++){
b[i] *= 5; b[i] *= 5;
System.out.println("b[" + i + "]: " + b[i]); System.out.println("b[" + i + "]: " + b[i]);
} }
b = new int[5]; b = new int[5];
for(int i = 0; i < 5; i++){ for(int i = 0; i < 5; i++){
b[i] = i; b[i] = i;
System.out.println("b[" + i + "]: " + b[i]); System.out.println("b[" + i + "]: " + b[i]);
} }
} }
public static void main(String[] args) { public static void main(String[] args) {
int[] y = new int [5]; int[] y = new int [5];
for(int i = 0; i < 5; i++){ for(int i = 0; i < 5; i++){
y[i] = i; y[i] = i;
System.out.println("y[" + i + "]: " + y[i]); System.out.println("y[" + i + "]: " + y[i]);
} }
passangemDeArray(y); passangemDeArray(y);
for(int i = 0; i < 5; i++){ for(int i = 0; i < 5; i++){
System.out.println("y[" + i + "]: " + y[i]); System.out.println("y[" + i + "]: " + y[i]);
} }
} }
} }

110
fonte/u00 Nivelamento/java/ponteiro/Ponteiro04Objeto.java → Codigos/u00 Nivelamento/java/ponteiro/Ponteiro04Objeto.java
View File

@ -1,55 +1,55 @@
/** /**
* Ponteiro * Ponteiro
* @author Max do Val Machado * @author Max do Val Machado
* @version 3 01/2016 * @version 3 01/2016
*/ */
class Cliente{ class Cliente{
private int codigo; private int codigo;
private String nome; private String nome;
public Cliente(){ public Cliente(){
this(0, ""); this(0, "");
} }
public Cliente(int codigo){ public Cliente(int codigo){
this(codigo, ""); this(codigo, "");
} }
public Cliente(int codigo, String nome){ public Cliente(int codigo, String nome){
this.codigo = codigo; this.codigo = codigo;
this.nome = nome; this.nome = nome;
} }
public int getCodigo(){ public int getCodigo(){
return codigo; return codigo;
} }
public void setCodigo(int codigo){ public void setCodigo(int codigo){
this.codigo = codigo; this.codigo = codigo;
} }
public String getNome(){ public String getNome(){
return nome; return nome;
} }
public void setNome(String nome){ public void setNome(String nome){
this.nome = nome; this.nome = nome;
} }
} }
class Ponteiro04Objeto { class Ponteiro04Objeto {
public static void main (String[] args){ public static void main (String[] args){
//Declarando tres ponteiros //Declarando tres ponteiros
Cliente c1 = null, c2 = null, c3 = null; Cliente c1 = null, c2 = null, c3 = null;
System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
//Alocando areas de memoria (ou inicializando objetos) e apontando os ponteiros para tais areas //Alocando areas de memoria (ou inicializando objetos) e apontando os ponteiros para tais areas
c1 = new Cliente(1, "aa"); c1 = new Cliente(1, "aa");
c2 = c1; c2 = c1;
c3 = new Cliente(2, "bb"); c3 = new Cliente(2, "bb");
System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
//Setando o codigo apontado por c1 e c2 //Setando o codigo apontado por c1 e c2
c2.setCodigo(3); c2.setCodigo(3);
System.out.println("ATRIBUTOs:"); System.out.println("ATRIBUTOs:");
System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
} }
} }

192
fonte/u00 Nivelamento/java/ponteiro/Ponteiro05PassagemObjeto.java → Codigos/u00 Nivelamento/java/ponteiro/Ponteiro05PassagemObjeto.java
View File

@ -1,96 +1,96 @@
/** /**
* Ponteiro * Ponteiro
* @author Max do Val Machado * @author Max do Val Machado
* @version 3 01/2016 * @version 3 01/2016
*/ */
class Cliente{ class Cliente{
private int codigo; private int codigo;
private String nome; private String nome;
public Cliente(){ public Cliente(){
this(0, ""); this(0, "");
} }
public Cliente(int codigo){ public Cliente(int codigo){
this(codigo, ""); this(codigo, "");
} }
public Cliente(int codigo, String nome){ public Cliente(int codigo, String nome){
this.codigo = codigo; this.codigo = codigo;
this.nome = nome; this.nome = nome;
} }
public int getCodigo(){ public int getCodigo(){
return codigo; return codigo;
} }
public void setCodigo(int codigo){ public void setCodigo(int codigo){
this.codigo = codigo; this.codigo = codigo;
} }
public String getNome(){ public String getNome(){
return nome; return nome;
} }
public void setNome(String nome){ public void setNome(String nome){
this.nome = nome; this.nome = nome;
} }
} }
class Ponteiro05PassagemObjeto { class Ponteiro05PassagemObjeto {
/** /**
* Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o
* conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal).
* Depois, o metodo retorna o conteudo do nosso ponteiro (endereco recebido como parametro). * Depois, o metodo retorna o conteudo do nosso ponteiro (endereco recebido como parametro).
*/ */
public static Cliente setar2(Cliente y){ public static Cliente setar2(Cliente y){
y.setCodigo(6); y.setCodigo(6);
y.setNome("ff"); y.setNome("ff");
System.out.println("ADDRs: y(" + y + ")"); System.out.println("ADDRs: y(" + y + ")");
System.out.println("ATRIBUTOs: y(" + y.getCodigo() + " / " + y.getNome()+")"); System.out.println("ATRIBUTOs: y(" + y.getCodigo() + " / " + y.getNome()+")");
return y; return y;
} }
/** /**
* Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o
* conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal).
* Depois, o metodo faz com que o ponteiro corrente aponte para outro objeto (veja que c1 do metodo * Depois, o metodo faz com que o ponteiro corrente aponte para outro objeto (veja que c1 do metodo
* princial continua apontando para o primeiro objeto). No final, a coleta de lixo do java libera a * princial continua apontando para o primeiro objeto). No final, a coleta de lixo do java libera a
* area de memoria que continha o ponteiro e o objeto criados neste metodo. * area de memoria que continha o ponteiro e o objeto criados neste metodo.
*/ */
public static void setar1(Cliente x){ public static void setar1(Cliente x){
x.setCodigo(4); x.setCodigo(4);
x.setNome("dd"); x.setNome("dd");
System.out.println("ADDRs: x(" + x + ")"); System.out.println("ADDRs: x(" + x + ")");
System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")"); System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")");
x = new Cliente (5, "ee"); x = new Cliente (5, "ee");
System.out.println("ADDRs: x(" + x + ")"); System.out.println("ADDRs: x(" + x + ")");
System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")"); System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")");
} }
public static void main (String[] args){ public static void main (String[] args){
//Declarando tres ponteiros //Declarando tres ponteiros
Cliente c1 = new Cliente(1, "aa"); Cliente c1 = new Cliente(1, "aa");
Cliente c2 = c1; Cliente c2 = c1;
Cliente c3 = new Cliente(2, "bb"); Cliente c3 = new Cliente(2, "bb");
System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
System.out.println("ATRIBUTOs:"); System.out.println("ATRIBUTOs:");
System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
//Chamando o metodo setar1 e passando POR VALOR O ADDR de c1 //Chamando o metodo setar1 e passando POR VALOR O ADDR de c1
setar1(c1); setar1(c1);
System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
System.out.println("ATRIBUTOs:"); System.out.println("ATRIBUTOs:");
System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
//Chamando o metodo setar2, passando POR VALOR O ADDR DE c2 e retornando um novo endereco para C3 //Chamando o metodo setar2, passando POR VALOR O ADDR DE c2 e retornando um novo endereco para C3
c3 = setar2(c2); c3 = setar2(c2);
System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
System.out.println("ATRIBUTOs:"); System.out.println("ATRIBUTOs:");
System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
} }
} }

198
fonte/u00 Nivelamento/java/ponteiro/Ponteiro06PassagemObjetoClone.java → Codigos/u00 Nivelamento/java/ponteiro/Ponteiro06PassagemObjetoClone.java
View File

@ -1,99 +1,99 @@
/** /**
* Ponteiro * Ponteiro
* @author Max do Val Machado * @author Max do Val Machado
* @version 3 01/2016 * @version 3 01/2016
*/ */
class Cliente{ class Cliente{
private int codigo; private int codigo;
private String nome; private String nome;
public Cliente(){ public Cliente(){
this(0, ""); this(0, "");
} }
public Cliente(int codigo){ public Cliente(int codigo){
this(codigo, ""); this(codigo, "");
} }
public Cliente(int codigo, String nome){ public Cliente(int codigo, String nome){
this.codigo = codigo; this.codigo = codigo;
this.nome = nome; this.nome = nome;
} }
public int getCodigo(){ public int getCodigo(){
return codigo; return codigo;
} }
public void setCodigo(int codigo){ public void setCodigo(int codigo){
this.codigo = codigo; this.codigo = codigo;
} }
public String getNome(){ public String getNome(){
return nome; return nome;
} }
public void setNome(String nome){ public void setNome(String nome){
this.nome = nome; this.nome = nome;
} }
public Cliente clone(){ public Cliente clone(){
return new Cliente(this.codigo, this.nome); return new Cliente(this.codigo, this.nome);
} }
} }
class Ponteiro06PassagemObjetoClone { class Ponteiro06PassagemObjetoClone {
/** /**
* Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o
* conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal).
* Depois, o metodo retorna o conteudo do nosso ponteiro (endereco recebido como parametro). * Depois, o metodo retorna o conteudo do nosso ponteiro (endereco recebido como parametro).
*/ */
public static Cliente setar2(Cliente y){ public static Cliente setar2(Cliente y){
y.setCodigo(6); y.setCodigo(6);
y.setNome("ff"); y.setNome("ff");
System.out.println("ADDRs: y(" + y + ")"); System.out.println("ADDRs: y(" + y + ")");
System.out.println("ATRIBUTOs: y(" + y.getCodigo() + " / " + y.getNome()+")"); System.out.println("ATRIBUTOs: y(" + y.getCodigo() + " / " + y.getNome()+")");
return y; return y;
} }
/** /**
* Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o * Metodo que recebe um ponteiro contendo o endereco de um objeto. Em seguida, o metodo altera o
* conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal). * conteudo do objeto apontado pelo ponteiro (o mesmo objeto apontado por c1 no metodo principal).
* Depois, o metodo faz com que o ponteiro corrente aponte para outro objeto (veja que c1 do metodo * Depois, o metodo faz com que o ponteiro corrente aponte para outro objeto (veja que c1 do metodo
* princial continua apontando para o primeiro objeto). No final, a coleta de lixo do java libera a * princial continua apontando para o primeiro objeto). No final, a coleta de lixo do java libera a
* area de memoria que continha o ponteiro e o objeto criados neste metodo. * area de memoria que continha o ponteiro e o objeto criados neste metodo.
*/ */
public static void setar1(Cliente x){ public static void setar1(Cliente x){
x.setCodigo(4); x.setCodigo(4);
x.setNome("dd"); x.setNome("dd");
System.out.println("ADDRs: x(" + x + ")"); System.out.println("ADDRs: x(" + x + ")");
System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")"); System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")");
x = new Cliente (5, "ee"); x = new Cliente (5, "ee");
System.out.println("ADDRs: x(" + x + ")"); System.out.println("ADDRs: x(" + x + ")");
System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")"); System.out.println("ATRIBUTOs: x(" + x.getCodigo() + " / " + x.getNome()+")");
} }
public static void main (String[] args){ public static void main (String[] args){
//Declarando tres ponteiros //Declarando tres ponteiros
Cliente c1 = new Cliente(1, "aa"); Cliente c1 = new Cliente(1, "aa");
Cliente c2 = c1.clone(); Cliente c2 = c1.clone();
Cliente c3 = new Cliente(2, "bb"); Cliente c3 = new Cliente(2, "bb");
System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
System.out.println("ATRIBUTOs:"); System.out.println("ATRIBUTOs:");
System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
//Chamando o metodo setar1 e passando POR VALOR O ADDR de c1 //Chamando o metodo setar1 e passando POR VALOR O ADDR de c1
setar1(c1); setar1(c1);
System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
System.out.println("ATRIBUTOs:"); System.out.println("ATRIBUTOs:");
System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
//Chamando o metodo setar2, passando POR VALOR O ADDR DE c2 e retornando um novo endereco para C3 //Chamando o metodo setar2, passando POR VALOR O ADDR DE c2 e retornando um novo endereco para C3
c3 = setar2(c2); c3 = setar2(c2);
System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
System.out.println("ATRIBUTOs:"); System.out.println("ATRIBUTOs:");
System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
} }
} }

116
fonte/u00 Nivelamento/java/ponteiro/Ponteiro07ObjetoClone.java → Codigos/u00 Nivelamento/java/ponteiro/Ponteiro07ObjetoClone.java
View File

@ -1,58 +1,58 @@
/** /**
* Ponteiro * Ponteiro
* @author Max do Val Machado * @author Max do Val Machado
* @version 3 01/2016 * @version 3 01/2016
*/ */
class Cliente{ class Cliente{
private int codigo; private int codigo;
private String nome; private String nome;
public Cliente(){ public Cliente(){
this(0, ""); this(0, "");
} }
public Cliente(int codigo){ public Cliente(int codigo){
this(codigo, ""); this(codigo, "");
} }
public Cliente(int codigo, String nome){ public Cliente(int codigo, String nome){
this.codigo = codigo; this.codigo = codigo;
this.nome = nome; this.nome = nome;
} }
public int getCodigo(){ public int getCodigo(){
return codigo; return codigo;
} }
public void setCodigo(int codigo){ public void setCodigo(int codigo){
this.codigo = codigo; this.codigo = codigo;
} }
public String getNome(){ public String getNome(){
return nome; return nome;
} }
public void setNome(String nome){ public void setNome(String nome){
this.nome = nome; this.nome = nome;
} }
public Cliente clone(){ public Cliente clone(){
return new Cliente(this.codigo, this.nome); return new Cliente(this.codigo, this.nome);
} }
} }
class Ponteiro07ObjetoClone { class Ponteiro07ObjetoClone {
public static void main (String[] args){ public static void main (String[] args){
//Declarando tres ponteiros //Declarando tres ponteiros
Cliente c1 = null, c2 = null, c3 = null; Cliente c1 = null, c2 = null, c3 = null;
System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
//Alocando areas de memoria (ou inicializando objetos) e apontando os ponteiros para tais areas //Alocando areas de memoria (ou inicializando objetos) e apontando os ponteiros para tais areas
c1 = new Cliente(1, "aa"); c1 = new Cliente(1, "aa");
c2 = c1; c2 = c1;
c3 = new Cliente(2, "bb"); c3 = new Cliente(2, "bb");
System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")"); System.out.println("ADDRs: c1(" + c1 + ")\tc2(" + c2 + ")\tc3(" + c3 + ")");
//Setando o codigo apontado por c1 e c2 //Setando o codigo apontado por c1 e c2
c2.setCodigo(3); c2.setCodigo(3);
System.out.println("ATRIBUTOs:"); System.out.println("ATRIBUTOs:");
System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")"); System.out.println("c1(" + c1.getCodigo() + " / " + c1.getNome()+")");
System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")"); System.out.println("c2(" + c2.getCodigo() + " / " + c2.getNome()+")");
System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")"); System.out.println("c3(" + c3.getCodigo() + " / " + c3.getNome()+")");
} }
} }

0
fonte/u00 Nivelamento/java/ponteiro/Ponteiro08Objeto.java → Codigos/u00 Nivelamento/java/ponteiro/Ponteiro08Objeto.java
View File

40
fonte/u00 Nivelamento/java/recursividade/ChamandoMetodo.java → Codigos/u00 Nivelamento/java/recursividade/ChamandoMetodo.java
View File

@ -1,20 +1,20 @@
class ChamandoMetodo { class ChamandoMetodo {
public static void primeiro(){ public static void primeiro(){
System.out.println("1o - inicio"); System.out.println("1o - inicio");
segundo(); segundo();
System.out.println("1o - fim"); System.out.println("1o - fim");
} }
public static void segundo(){ public static void segundo(){
System.out.println("2o - inicio"); System.out.println("2o - inicio");
terceiro(); terceiro();
System.out.println("2o - fim"); System.out.println("2o - fim");
} }
public static void terceiro(){ public static void terceiro(){
System.out.println("3o - inicio e fim"); System.out.println("3o - inicio e fim");
} }
public static void main (String[] args){ public static void main (String[] args){
System.out.println("main - inicio"); System.out.println("main - inicio");
primeiro(); primeiro();
System.out.println("main - fim"); System.out.println("main - fim");
} }
} }

80
fonte/u00 Nivelamento/java/recursividade/ContarMaiuscula.java → Codigos/u00 Nivelamento/java/recursividade/ContarMaiuscula.java
View File

@ -1,40 +1,40 @@
/** /**
* Recursividade * Recursividade
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
class ContarMaiuscula { class ContarMaiuscula {
public static boolean isUpper(char x){ public static boolean isUpper(char x){
return (x >= 'A' && x <= 'Z'); return (x >= 'A' && x <= 'Z');
} }
public static int contMaiusculo(String s){ public static int contMaiusculo(String s){
int cont = 0; int cont = 0;
for(int i = 0; i < s.length(); i++){ for(int i = 0; i < s.length(); i++){
if(isUpper(s.charAt(i)) == true){ if(isUpper(s.charAt(i)) == true){
cont++; cont++;
} }
} }
return cont; return cont;
} }
public static int contMaiusculo2(String s){ public static int contMaiusculo2(String s){
return contMaiusculo2(s, 0); return contMaiusculo2(s, 0);
} }
public static int contMaiusculo2(String s, int i){ public static int contMaiusculo2(String s, int i){
int cont = 0; int cont = 0;
if(i < s.length()){ if(i < s.length()){
if(isUpper(s.charAt(i)) == true){ if(isUpper(s.charAt(i)) == true){
cont++; cont++;
} }
cont += contMaiusculo2(s, i + 1); cont += contMaiusculo2(s, i + 1);
} }
return cont; return cont;
} }
public static void main (String[] args){ public static void main (String[] args){
System.out.println("AlGoritmos e Estruturas de Dados: " + contMaiusculo("AlGoritmos e Estruturas de Dados")); System.out.println("AlGoritmos e Estruturas de Dados: " + contMaiusculo("AlGoritmos e Estruturas de Dados"));
System.out.println("AlGoritmos e Estruturas de Dados: " + contMaiusculo2("AlGoritmos e Estruturas de Dados")); System.out.println("AlGoritmos e Estruturas de Dados: " + contMaiusculo2("AlGoritmos e Estruturas de Dados"));
} }
} }

40
fonte/u00 Nivelamento/java/recursividade/FatorialRecursivo.java → Codigos/u00 Nivelamento/java/recursividade/FatorialRecursivo.java
View File

@ -1,20 +1,20 @@
/** /**
* Recursividade * Recursividade
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
class FatorialRecursivo{ class FatorialRecursivo{
public static int fatorial(int n){ public static int fatorial(int n){
int resp; int resp;
System.out.println("fat (" + n + ")"); System.out.println("fat (" + n + ")");
resp = (n == 1) ? 1 : n * fatorial(n-1); resp = (n == 1) ? 1 : n * fatorial(n-1);
System.out.println("fat n(" + n + "): " + resp); System.out.println("fat n(" + n + "): " + resp);
return resp; return resp;
} }
public static void main(String[] args){ public static void main(String[] args){
int n = Integer.parseInt(args[0]); int n = Integer.parseInt(args[0]);
System.out.println("FATORIAL RECURSIVO(" + n + "): " + fatorial(n)); System.out.println("FATORIAL RECURSIVO(" + n + "): " + fatorial(n));
} }
} }

36
fonte/u00 Nivelamento/java/recursividade/FibonacciRecursivo.java → Codigos/u00 Nivelamento/java/recursividade/FibonacciRecursivo.java
View File

@ -1,18 +1,18 @@
/** /**
* Recursividade * Recursividade
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
class FibonacciRecursivo { class FibonacciRecursivo {
public static int fibRec (int n){ public static int fibRec (int n){
int resp; int resp;
System.out.println("fib (" + n + ")"); System.out.println("fib (" + n + ")");
resp = (n == 0 || n == 1) ? 1 : fibRec(n-1) + fibRec(n-2); resp = (n == 0 || n == 1) ? 1 : fibRec(n-1) + fibRec(n-2);
System.out.println("fib (" + n + "): " + resp); System.out.println("fib (" + n + "): " + resp);
return resp; return resp;
} }
public static void main (String[] args){ public static void main (String[] args){
int n = Integer.parseInt(args[0]); int n = Integer.parseInt(args[0]);
System.out.println("FIBONACCI RECURSIVO(" + n + "): " + fibRec(n)); System.out.println("FIBONACCI RECURSIVO(" + n + "): " + fibRec(n));
} }
} }

62
fonte/u00 Nivelamento/java/recursividade/Multiplicacao.java → Codigos/u00 Nivelamento/java/recursividade/Multiplicacao.java
View File

@ -1,31 +1,31 @@
class Multiplicacao { class Multiplicacao {
public static int multiplicacao(int a, int b){ public static int multiplicacao(int a, int b){
return multiplicacao(a, b, 0); return multiplicacao(a, b, 0);
} }
public static int multiplicacao(int a, int b, int i){ public static int multiplicacao(int a, int b, int i){
int resp = 0; int resp = 0;
if(i < b){ if(i < b){
resp = a + multiplicacao(a, b, i+1); resp = a + multiplicacao(a, b, i+1);
} }
return resp; return resp;
} }
public static int multiplicacaoInt(int a, int b){ public static int multiplicacaoInt(int a, int b){
int resp = 0; int resp = 0;
for(int i = 0; i < b; i++){ for(int i = 0; i < b; i++){
resp = a + resp; resp = a + resp;
} }
return resp; return resp;
} }
public static void main (String[] args){ public static void main (String[] args){
int mult = multiplicacaoInt(4, 3); int mult = multiplicacaoInt(4, 3);
System.out.println("RESPOSTA INT: " + mult); System.out.println("RESPOSTA INT: " + mult);
mult = multiplicacao(4, 3); mult = multiplicacao(4, 3);
System.out.println("RESPOSTA REC: " + mult); System.out.println("RESPOSTA REC: " + mult);
} }
} }

36
fonte/u00 Nivelamento/java/recursividade/PrintRecursivo.java → Codigos/u00 Nivelamento/java/recursividade/PrintRecursivo.java
View File

@ -1,18 +1,18 @@
/** /**
* Recursividade * Recursividade
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
class PrintRecursivo{ class PrintRecursivo{
public static void printRecursivo(int i){ public static void printRecursivo(int i){
System.out.println("valor de i: " + i); System.out.println("valor de i: " + i);
if(i > 0){ if(i > 0){
printRecursivo(i-1); printRecursivo(i-1);
} }
System.out.println("valor de i: " + i); System.out.println("valor de i: " + i);
} }
public static void main(String[] args){ public static void main(String[] args){
int n = Integer.parseInt(args[0]); int n = Integer.parseInt(args[0]);
printRecursivo(n); printRecursivo(n);
} }
} }

24
fonte/u00 Nivelamento/java/tratamentoExcecao/TratamentoExcecao01.java → Codigos/u00 Nivelamento/java/tratamentoExcecao/TratamentoExcecao01.java
View File

@ -1,12 +1,12 @@
/** /**
* Tratamento de excecao * Tratamento de excecao
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
public class TratamentoExcecao01 { public class TratamentoExcecao01 {
public static void main(String[] args) { public static void main(String[] args) {
Integer i = new Integer(args[0]); Integer i = new Integer(args[0]);
MyIO.println("A variavel i vale " + i); MyIO.println("A variavel i vale " + i);
MyIO.println("FIM DE PROGRAMA!!!"); MyIO.println("FIM DE PROGRAMA!!!");
} }
} }

38
fonte/u00 Nivelamento/java/tratamentoExcecao/TratamentoExcecao02.java → Codigos/u00 Nivelamento/java/tratamentoExcecao/TratamentoExcecao02.java
View File

@ -1,19 +1,19 @@
/** /**
* Tratamento de excecao * Tratamento de excecao
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
public class TratamentoExcecao02 { public class TratamentoExcecao02 {
public static void main(String[] args) { public static void main(String[] args) {
try { try {
Integer i = new Integer(args[0]); Integer i = new Integer(args[0]);
MyIO.println("A variavel i vale " + i); MyIO.println("A variavel i vale " + i);
} catch (ArrayIndexOutOfBoundsException e){ } catch (ArrayIndexOutOfBoundsException e){
MyIO.println("Erro na passagem de parametros!!!"); MyIO.println("Erro na passagem de parametros!!!");
} finally { } finally {
MyIO.println("FIM DE PROGRAMA!!!"); MyIO.println("FIM DE PROGRAMA!!!");
} }
} }
} }

44
fonte/u00 Nivelamento/java/tratamentoExcecao/TratamentoExcecao03.java → Codigos/u00 Nivelamento/java/tratamentoExcecao/TratamentoExcecao03.java
View File

@ -1,22 +1,22 @@
/** /**
* Tratamento de excecao * Tratamento de excecao
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
public class TratamentoExcecao03 { public class TratamentoExcecao03 {
public static void main(String[] args) { public static void main(String[] args) {
try { try {
Integer i = new Integer(args[0]); Integer i = new Integer(args[0]);
MyIO.println("A variavel i vale " + i); MyIO.println("A variavel i vale " + i);
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
MyIO.println("Erro de formatacao!!!"); MyIO.println("Erro de formatacao!!!");
} catch (ArrayIndexOutOfBoundsException e){ } catch (ArrayIndexOutOfBoundsException e){
MyIO.println("Erro na passagem de parametros!!!"); MyIO.println("Erro na passagem de parametros!!!");
} finally { } finally {
MyIO.println("FIM DE PROGRAMA!!!"); MyIO.println("FIM DE PROGRAMA!!!");
} }
} }
} }

74
fonte/u00 Nivelamento/java/tratamentoExcecao/TratamentoExcecao04.java → Codigos/u00 Nivelamento/java/tratamentoExcecao/TratamentoExcecao04.java
View File

@ -1,37 +1,37 @@
/** /**
* Tratamento de excecao * Tratamento de excecao
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
public class TratamentoExcecao04 { public class TratamentoExcecao04 {
public static void metodo1(String s) throws NumberFormatException, ArrayIndexOutOfBoundsException { public static void metodo1(String s) throws NumberFormatException, ArrayIndexOutOfBoundsException {
Integer i = new Integer(s); Integer i = new Integer(s);
MyIO.println("A variavel i vale " + i); MyIO.println("A variavel i vale " + i);
} }
public static void metodo2(String s) throws NumberFormatException { public static void metodo2(String s) throws NumberFormatException {
Integer i = new Integer(s); Integer i = new Integer(s);
MyIO.println("A variavel i vale " + i); MyIO.println("A variavel i vale " + i);
} }
public static void main(String[] args) { public static void main(String[] args) {
try { try {
metodo1(args[0]); metodo1(args[0]);
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
MyIO.println("Erro!!!"); MyIO.println("Erro!!!");
} catch (ArrayIndexOutOfBoundsException e){ } catch (ArrayIndexOutOfBoundsException e){
MyIO.println("Erro!!!"); MyIO.println("Erro!!!");
} }
MyIO.println("-------------->>>>>>>> <<<<<<<<--------------"); MyIO.println("-------------->>>>>>>> <<<<<<<<--------------");
try { try {
metodo2(args[0]); metodo2(args[0]);
} catch (NumberFormatException e) { } catch (NumberFormatException e) {
MyIO.println("Erro!!!"); MyIO.println("Erro!!!");
} }
MyIO.println("-------------->>>>>>>> <<<<<<<<--------------"); MyIO.println("-------------->>>>>>>> <<<<<<<<--------------");
} }
} }

44
fonte/u00 Nivelamento/java/tratamentoExcecao/TratamentoExcecao05.java → Codigos/u00 Nivelamento/java/tratamentoExcecao/TratamentoExcecao05.java
View File

@ -1,22 +1,22 @@
/** /**
* Tratamento de excecao * Tratamento de excecao
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
public class TratamentoExcecao05 { public class TratamentoExcecao05 {
public static void metodo(int i) throws Exception { public static void metodo(int i) throws Exception {
if(i % 2 == 1){ if(i % 2 == 1){
throw new Exception ("Valor impar"); throw new Exception ("Valor impar");
} }
} }
public static void main(String[] args) throws Exception { public static void main(String[] args) throws Exception {
int i = 2; int i = 2;
MyIO.println("-------------->>>>>>>> <<<<<<<<--------------"); MyIO.println("-------------->>>>>>>> <<<<<<<<--------------");
metodo(i); metodo(i);
MyIO.println("-------------->>>>>>>> <<<<<<<<--------------"); MyIO.println("-------------->>>>>>>> <<<<<<<<--------------");
metodo(++i); metodo(++i);
MyIO.println("-------------->>>>>>>> <<<<<<<<--------------"); MyIO.println("-------------->>>>>>>> <<<<<<<<--------------");
} }
} }

4
fonte/u01 Fundamentos de análise de algoritmos/README.md → Codigos/u01 Fundamentos de análise de algoritmos/README.md
View File

@ -1,2 +1,2 @@
# U1 - Introdução # U1 - Introdução
Repositório de códigos da disciplina de Algoritmos e Estrutura de Dados II Repositório de códigos da disciplina de Algoritmos e Estrutura de Dados II

38
fonte/u01 Fundamentos de análise de algoritmos/java/AND_OR.java → Codigos/u01 Fundamentos de análise de algoritmos/java/AND_OR.java
View File

@ -1,19 +1,19 @@
class AND_OR { class AND_OR {
public static boolean m1(){ public static boolean m1(){
System.out.println("m1"); System.out.println("m1");
return true; return true;
} }
public static boolean m2(){ public static boolean m2(){
System.out.println("m2"); System.out.println("m2");
return false; return false;
} }
public static void main (String[] args) { public static void main (String[] args) {
System.out.println("====================="); System.out.println("=====================");
boolean or = m1() || m2(); boolean or = m1() || m2();
System.out.println("OR: " + or); System.out.println("OR: " + or);
System.out.println("====================="); System.out.println("=====================");
boolean and = m2() && m1(); boolean and = m2() && m1();
System.out.println("AND: " + and); System.out.println("AND: " + and);
System.out.println("====================="); System.out.println("=====================");
} }
} }

34
fonte/u01 Fundamentos de análise de algoritmos/java/Log.java → Codigos/u01 Fundamentos de análise de algoritmos/java/Log.java
View File

@ -1,17 +1,17 @@
class Log { class Log {
public static void main (String[] args) { public static void main (String[] args) {
int[] n = {4,5,6,7,8,9,10,11,12,13,14,15,16,17,31,32,33,63,64,65}; int[] n = {4,5,6,7,8,9,10,11,12,13,14,15,16,17,31,32,33,63,64,65};
int cont; int cont;
for(int k = 0; k < n.length; k++){ for(int k = 0; k < n.length; k++){
System.out.print("\n[n = " + n[k] + "] => "); System.out.print("\n[n = " + n[k] + "] => ");
cont = 0; cont = 0;
for(int i = n[k]; i > 0; i /= 2){ for(int i = n[k]; i > 0; i /= 2){
System.out.print(" " + i); System.out.print(" " + i);
cont++; cont++;
} }
System.out.print(" (" + cont + " vezes)"); System.out.print(" (" + cont + " vezes)");
} }
System.out.print("\n"); System.out.print("\n");
} }
} }

122
fonte/u01 Fundamentos de análise de algoritmos/java/Pesquisa.java → Codigos/u01 Fundamentos de análise de algoritmos/java/Pesquisa.java
View File

@ -1,61 +1,61 @@
class Pesquisa { class Pesquisa {
public static boolean pesqSeq(int[] vet, int x){ public static boolean pesqSeq(int[] vet, int x){
boolean resp = false; boolean resp = false;
int n = vet.length; int n = vet.length;
for(int i = 0; i < n; i++){ for(int i = 0; i < n; i++){
if(vet[i] == x){ if(vet[i] == x){
resp = true; resp = true;
i = n; i = n;
} }
} }
return resp; return resp;
} }
public static boolean pesqBin(int[] vet, int x){ public static boolean pesqBin(int[] vet, int x){
boolean resp = false; boolean resp = false;
int dir = (vet.length - 1), esq = 0, meio; int dir = (vet.length - 1), esq = 0, meio;
while (esq <= dir){ while (esq <= dir){
meio = (esq + dir) / 2; meio = (esq + dir) / 2;
if(x == vet[meio]){ if(x == vet[meio]){
resp = true; resp = true;
esq = dir + 1; esq = dir + 1;
} else if (x > vet[meio]) { } else if (x > vet[meio]) {
esq = meio + 1; esq = meio + 1;
} else { } else {
dir = meio - 1; dir = meio - 1;
} }
} }
return resp; return resp;
} }
public static boolean pesqBinRec(int[] vet, int x){ public static boolean pesqBinRec(int[] vet, int x){
return pesqBinRec(vet, x, 0, (vet.length - 1)); return pesqBinRec(vet, x, 0, (vet.length - 1));
} }
public static boolean pesqBinRec(int[] vet, int x, int esq, int dir){ public static boolean pesqBinRec(int[] vet, int x, int esq, int dir){
boolean resp; boolean resp;
int meio = (esq + dir) / 2; int meio = (esq + dir) / 2;
if(esq > dir) { if(esq > dir) {
resp = false; resp = false;
} else if(x == vet[meio]){ } else if(x == vet[meio]){
resp = true; resp = true;
} else if (x > vet[meio]) { } else if (x > vet[meio]) {
resp = pesqBinRec(vet, x, meio + 1, dir); resp = pesqBinRec(vet, x, meio + 1, dir);
} else { } else {
resp = pesqBinRec(vet, x, esq, meio - 1); resp = pesqBinRec(vet, x, esq, meio - 1);
} }
return resp; return resp;
} }
public static void main (String[] args){ public static void main (String[] args){
int[] vet = {2, 3, 5, 7, 9, 11, 15, 17, 20, 21, 30, 43, 49, 70, 71, 82}; int[] vet = {2, 3, 5, 7, 9, 11, 15, 17, 20, 21, 30, 43, 49, 70, 71, 82};
int x = 35; int x = 35;
System.out.println("Pesquisa Sequencial: " + pesqSeq(vet, x)); System.out.println("Pesquisa Sequencial: " + pesqSeq(vet, x));
System.out.println("Pesquisa Binária: " + pesqBin(vet, x)); System.out.println("Pesquisa Binária: " + pesqBin(vet, x));
System.out.println("Pesquisa Binária Recursiva: " + pesqBinRec(vet, x)); System.out.println("Pesquisa Binária Recursiva: " + pesqBinRec(vet, x));
} }
} }

4
fonte/u02 Estruturas de dados basicas lineares/README.md → Codigos/u02 Estruturas de dados basicas lineares/README.md
View File

@ -1,2 +1,2 @@
# AEDII # AEDII
Repositório de códigos da disciplina de Algoritmos e Estrutura de Dados II Repositório de códigos da disciplina de Algoritmos e Estrutura de Dados II

288
fonte/u02 Estruturas de dados basicas lineares/c/fila.c → Codigos/u02 Estruturas de dados basicas lineares/c/fila.c
View File

@ -1,144 +1,144 @@
/** /**
* Lista estatica * Lista estatica
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#define MAXTAM 6 #define MAXTAM 6
#define bool short #define bool short
#define true 1 #define true 1
#define false 0 #define false 0
int array[MAXTAM+1]; // Elementos da pilha int array[MAXTAM+1]; // Elementos da pilha
int primeiro; // Remove do indice "primeiro". int primeiro; // Remove do indice "primeiro".
int ultimo; // Insere no indice "ultimo". int ultimo; // Insere no indice "ultimo".
/** /**
* Inicializacoes * Inicializacoes
*/ */
void start(){ void start(){
primeiro = ultimo = 0; primeiro = ultimo = 0;
} }
/** /**
* Insere um elemento na ultima posicao da * Insere um elemento na ultima posicao da
* @param x int elemento a ser inserido. * @param x int elemento a ser inserido.
* @Se a fila estiver cheia. * @Se a fila estiver cheia.
*/ */
void inserir(int x) { void inserir(int x) {
//validar insercao //validar insercao
if (((ultimo + 1) % MAXTAM) == primeiro) { if (((ultimo + 1) % MAXTAM) == primeiro) {
printf("Erro ao inserir!"); printf("Erro ao inserir!");
exit(1); exit(1);
} }
array[ultimo] = x; array[ultimo] = x;
ultimo = (ultimo + 1) % MAXTAM; ultimo = (ultimo + 1) % MAXTAM;
} }
/** /**
* Remove um elemento da primeira posicao da fila e movimenta * Remove um elemento da primeira posicao da fila e movimenta
* os demais elementos para o primeiro da mesma. * os demais elementos para o primeiro da mesma.
* @return resp int elemento a ser removido. * @return resp int elemento a ser removido.
* @Se a fila estiver vazia. * @Se a fila estiver vazia.
*/ */
int remover() { int remover() {
//validar remocao //validar remocao
if (primeiro == ultimo) { if (primeiro == ultimo) {
printf("Erro ao remover!"); printf("Erro ao remover!");
exit(1); exit(1);
} }
int resp = array[primeiro]; int resp = array[primeiro];
primeiro = (primeiro + 1) % MAXTAM; primeiro = (primeiro + 1) % MAXTAM;
return resp; return resp;
} }
/** /**
* Mostra os array separados por espacos. * Mostra os array separados por espacos.
*/ */
void mostrar (){ void mostrar (){
int i; int i;
printf("\n["); printf("\n[");
for(i = primeiro; i != ultimo; i = ((i + 1) % MAXTAM)) { for(i = primeiro; i != ultimo; i = ((i + 1) % MAXTAM)) {
printf(" %d", array[i]); printf(" %d", array[i]);
} }
printf(" ]"); printf(" ]");
} }
/** /**
* Retorna um bool indicando se a fila esta vazia * Retorna um bool indicando se a fila esta vazia
* @return bool indicando se a fila esta vazia * @return bool indicando se a fila esta vazia
*/ */
bool isVazia() { bool isVazia() {
return (primeiro == ultimo); return (primeiro == ultimo);
} }
int main(int argc, char** argv){ int main(int argc, char** argv){
int x1, x2, x3; int x1, x2, x3;
printf("\n==== FILA ESTATICA ===="); printf("\n==== FILA ESTATICA ====");
start(); start();
inserir(5); inserir(5);
inserir(7); inserir(7);
inserir(8); inserir(8);
inserir(9); inserir(9);
printf("\nApos insercoes(5, 7, 8, 9): "); printf("\nApos insercoes(5, 7, 8, 9): ");
mostrar(); mostrar();
x1 = remover(); x1 = remover();
x2 = remover(); x2 = remover();
printf("\nApos remocoes (%d, %d):", x1, x2); printf("\nApos remocoes (%d, %d):", x1, x2);
mostrar(); mostrar();
inserir(3); inserir(3);
inserir(4); inserir(4);
printf("\nApos insercoes(3, 4): "); printf("\nApos insercoes(3, 4): ");
mostrar(); mostrar();
x1 = remover(); x1 = remover();
x2 = remover(); x2 = remover();
x3 = remover(); x3 = remover();
printf("\nApos remocoes (%d, %d, %d):", x1, x2, x3); printf("\nApos remocoes (%d, %d, %d):", x1, x2, x3);
mostrar(); mostrar();
inserir(4); inserir(4);
inserir(5); inserir(5);
printf("\nApos insercoes(4, 5): "); printf("\nApos insercoes(4, 5): ");
mostrar(); mostrar();
x1 = remover(); x1 = remover();
x2 = remover(); x2 = remover();
printf("\nApos remocoes (%d, %d):", x1, x2); printf("\nApos remocoes (%d, %d):", x1, x2);
mostrar(); mostrar();
inserir(6); inserir(6);
inserir(7); inserir(7);
printf("\nApos insercoes(6, 7): "); printf("\nApos insercoes(6, 7): ");
mostrar(); mostrar();
x1 = remover(); x1 = remover();
printf("\nApos remocao (%d):", x1); printf("\nApos remocao (%d):", x1);
mostrar(); mostrar();
} }

430
fonte/u02 Estruturas de dados basicas lineares/c/lista.c → Codigos/u02 Estruturas de dados basicas lineares/c/lista.c
View File

@ -1,215 +1,215 @@
/** /**
* Lista estatica * Lista estatica
* @author Max do Val Machado * @author Max do Val Machado
* @version 2 01/2015 * @version 2 01/2015
*/ */
#include <stdio.h> #include <stdio.h>
#include <stdlib.h> #include <stdlib.h>
#define MAXTAM 6 #define MAXTAM 6
#define bool short #define bool short
#define true 1 #define true 1
#define false 0 #define false 0
int array[MAXTAM]; // Elementos da pilha int array[MAXTAM]; // Elementos da pilha
int n; // Quantidade de array. int n; // Quantidade de array.
/** /**
* Inicializacoes * Inicializacoes
*/ */
void start(){ void start(){
n = 0; n = 0;
} }
/** /**
* Insere um elemento na primeira posicao da lista e move os demais * Insere um elemento na primeira posicao da lista e move os demais
* elementos para o fim da * elementos para o fim da
* @param x int elemento a ser inserido. * @param x int elemento a ser inserido.
*/ */
void inserirInicio(int x) { void inserirInicio(int x) {
int i; int i;
//validar insercao //validar insercao
if(n >= MAXTAM){ if(n >= MAXTAM){
printf("Erro ao inserir!"); printf("Erro ao inserir!");
exit(1); exit(1);
} }
//levar elementos para o fim do array //levar elementos para o fim do array
for(i = n; i > 0; i--){ for(i = n; i > 0; i--){
array[i] = array[i-1]; array[i] = array[i-1];
} }
array[0] = x; array[0] = x;
n++; n++;
} }
/** /**
* Insere um elemento na ultima posicao da * Insere um elemento na ultima posicao da
* @param x int elemento a ser inserido. * @param x int elemento a ser inserido.
*/ */
void inserirFim(int x) { void inserirFim(int x) {
//validar insercao //validar insercao
if(n >= MAXTAM){ if(n >= MAXTAM){
printf("Erro ao inserir!"); printf("Erro ao inserir!");
exit(1); exit(1);
} }
array[n] = x; array[n] = x;
n++; n++;
} }
/** /**
* Insere um elemento em uma posicao especifica e move os demais * Insere um elemento em uma posicao especifica e move os demais
* elementos para o fim da * elementos para o fim da
* @param x int elemento a ser inserido. * @param x int elemento a ser inserido.
* @param pos Posicao de insercao. * @param pos Posicao de insercao.
*/ */
void inserir(int x, int pos) { void inserir(int x, int pos) {
int i; int i;
//validar insercao //validar insercao
if(n >= MAXTAM || pos < 0 || pos > n){ if(n >= MAXTAM || pos < 0 || pos > n){
printf("Erro ao inserir!"); printf("Erro ao inserir!");
exit(1); exit(1);
} }
//levar elementos para o fim do array //levar elementos para o fim do array
for(i = n; i > pos; i--){ for(i = n; i > pos; i--){
array[i] = array[i-1]; array[i] = array[i-1];
} }
array[pos] = x; array[pos] = x;
n++; n++;
} }
/** /**
* Remove um elemento da primeira posicao da lista e movimenta * Remove um elemento da primeira posicao da lista e movimenta
* os demais elementos para o inicio da mesma. * os demais elementos para o inicio da mesma.
* @return resp int elemento a ser removido. * @return resp int elemento a ser removido.
*/ */
int removerInicio() { int removerInicio() {
int i, resp; int i, resp;
//validar remocao //validar remocao
if (n == 0) { if (n == 0) {
printf("Erro ao remover!"); printf("Erro ao remover!");
exit(1); exit(1);
} }
resp = array[0]; resp = array[0];
n--; n--;
for(i = 0; i < n; i++){ for(i = 0; i < n; i++){
array[i] = array[i+1]; array[i] = array[i+1];
} }
return resp; return resp;
} }
/** /**
* Remove um elemento da ultima posicao da * Remove um elemento da ultima posicao da
* @return resp int elemento a ser removido. * @return resp int elemento a ser removido.
*/ */
int removerFim() { int removerFim() {
//validar remocao //validar remocao
if (n == 0) { if (n == 0) {
printf("Erro ao remover!"); printf("Erro ao remover!");
exit(1); exit(1);
} }
return array[--n]; return array[--n];
} }
/** /**
* Remove um elemento de uma posicao especifica da lista e * Remove um elemento de uma posicao especifica da lista e
* movimenta os demais elementos para o inicio da mesma. * movimenta os demais elementos para o inicio da mesma.
* @param pos Posicao de remocao. * @param pos Posicao de remocao.
* @return resp int elemento a ser removido. * @return resp int elemento a ser removido.
*/ */
int remover(int pos) { int remover(int pos) {
int i, resp; int i, resp;
//validar remocao //validar remocao
if (n == 0 || pos < 0 || pos >= n) { if (n == 0 || pos < 0 || pos >= n) {
printf("Erro ao remover!"); printf("Erro ao remover!");
exit(1); exit(1);
} }
resp = array[pos]; resp = array[pos];
n--; n--;
for(i = pos; i < n; i++){ for(i = pos; i < n; i++){
array[i] = array[i+1]; array[i] = array[i+1];
} }
return resp; return resp;
} }
/** /**
* Mostra os array separados por espacos. * Mostra os array separados por espacos.
*/ */
void mostrar (){ void mostrar (){
int i; int i;
printf("[ "); printf("[ ");
for(i = 0; i < n; i++){ for(i = 0; i < n; i++){
printf("%d ", array[i]); printf("%d ", array[i]);
} }
printf("]\n"); printf("]\n");
} }
/** /**
* Procura um array e retorna se ele existe. * Procura um array e retorna se ele existe.
* @param x int elemento a ser pesquisado. * @param x int elemento a ser pesquisado.
* @return <code>true</code> se o array existir, * @return <code>true</code> se o array existir,
* <code>false</code> em caso contrario. * <code>false</code> em caso contrario.
*/ */
bool pesquisar(int x) { bool pesquisar(int x) {
bool retorno = false; bool retorno = false;
int i; int i;
for (i = 0; i < n && retorno == false; i++) { for (i = 0; i < n && retorno == false; i++) {
retorno = (array[i] == x); retorno = (array[i] == x);
} }
return retorno; return retorno;
} }
int main(int argc, char** argv){ int main(int argc, char** argv){
int x1, x2, x3; int x1, x2, x3;
printf("==== LISTA ESTATICA ====\n"); printf("==== LISTA ESTATICA ====\n");
start(); start();
inserirInicio(1); inserirInicio(1);
inserirInicio(0); inserirInicio(0);
inserirFim(2); inserirFim(2);
inserirFim(3); inserirFim(3);
inserir(4, 3); inserir(4, 3);
inserir(5, 2); inserir(5, 2);
printf("Apos insercoes: "); printf("Apos insercoes: ");
mostrar(); mostrar();
x1 = removerInicio(); x1 = removerInicio();
x2 = removerFim(); x2 = removerFim();
x3 = remover(2); x3 = remover(2);
printf("Apos remocoes (%d, %d, %d): ", x1, x2, x3); printf("Apos remocoes (%d, %d, %d): ", x1, x2, x3);
mostrar(); mostrar();
} }

Some files were not shown because too many files have changed in this diff Show More