Ir para conteúdo
Fórum Script Brasil

jotâo

Membros
  • Total de itens

    15
  • Registro em

  • Última visita

Sobre jotâo

  • Data de Nascimento 05/04/1970

Contatos

  • MSN
    jpm.777sys@hotmal.com.br
  • Website URL
    http://
  • ICQ
    0

Perfil

  • Gender
    Male
  • Location
    Planeta Terra
  • Interests
    Guitar..............

jotâo's Achievements

0

Reputação

  1. Tabuada Simples na Linguagem de Programação C++ Programa da Tabuada Simples no Contexto do Matriz do Tipo Vetor. Desenvolvimento do Código em C++ #include<conio.h> #include<iomanip> using std::setiosflags; using std::setprecision; using std::setw; #include<iostream> using namespace std; using std::cin; using std::cout; using std::endl; #include<cstdlib> //************** #if !defined( z ) #define z 0 #endif #if !defined( u ) #define u 1 #endif #if !defined(fase_inicial) #define fase_inicial z #endif #if !defined(fase_teste) #define fase_teste 10 #endif //********************* unsigned long int main() { system("CLS"); unsigned long int multiplicador = ( 2 ); unsigned long int factors = ( z ); unsigned long int array_multiplicador[fase_teste] = { z }; unsigned long int array_multiplicando[fase_teste] = { z }; unsigned long int array_produto[fase_teste] = { z }; for(factors = (fase_inicial); factors <=(fase_teste); factors = (factors + u )) { array_multiplicador[factors] = (multiplicador); } for(factors = (fase_inicial); factors <= (fase_teste); factors = (factors + u)) { array_multiplicando[factors] = (factors); } for(factors = (fase_inicial); factors <= (fase_teste); factors = (factors + u)) { array_produto[factors] = (array_multiplicador[factors] * array_multiplicando[factors]); } cout <<"\nExibindo a Tabuada Simples do Fator Informado : " <<multiplicador <<endl; for(factors = (fase_inicial); factors <= (fase_teste); factors = (factors + u)) { cout <<array_multiplicador[factors] <<" X " <<array_multiplicando[factors] <<" = " <<array_produto[factors] <<endl; cout <<'\n'; } system("PAUSE"); return(NULL); } :P Usem a imaginação, construíndo, modificando, alterando, estudando, ficando a vontade para criar. Enxugar o código!!!!!!!!!!!!!!!!!!!!!!!!
  2. Dica Valiosa do mJi, sempre com um macetim para enxugar o código. Se captamos bem o raciocionio lógico, segue abaixo o desenvolvimento do fragmento do Problema.Desenvolvido em C++ #include<conio.h> #include<iostream> using namespace std; using std::cin; using std::cout; using std::endl; #include<cstdlib> #if !defined( z ) #define z 0 #endif #if !defined( u ) #define u 1 #endif #if !defined(fator_inicial) #define fator_inicial z #endif #if !defined(fator_de_teste) #define fator_de_teste 5 #endif #if !defined(fator_incremento) #define fator_incremento #endif unsigned long int main() { system("CLS"); unsigned long int subs_x = ( z ); unsigned long int subs_y = ( z ); unsigned long int vetor_A[fator_de_teste]; unsigned long int vetor_auxiliar[fator_de_teste]; unsigned long int inversao_VetorA[fator_de_teste]; for(subs_x = (fator_inicial); subs_x < (fator_de_teste); subs_x = (subs_x + u)) { cout <<"\nInforme no campo abaixo o valor do " <<(subs_x + u) <<" º Inteiro: "; cout <<"\nFator: "; cin >>vetor_A[subs_x]; } /*Aqui esta a ideia do Sobe/Desce: "Os Ultimos serão os Primeiros e os Primeiros serão os Ultimos". o salario dos Deputados sobem enquanto do trabalhador desce.*/ for(subs_x = (fator_inicial), subs_y = (4); subs_x < (fator_de_teste); subs_x++, subs_y--) { vetor_auxiliar[subs_y] = (vetor_A([subs_x]); } /*Atribuição dos Valores invertidos minisgaymente a um vetor auxiliar*/ for(subs_x = (fator_inicial); subs_x < (fator_de_teste); subs_x++) { inversaoA[subs_x] = (vetor_auxiliar([subs_x]); } cout <<endl; cout <<"\nValores de A invertido:"; for(subs_x = (fator_inicial); subs_x < (fator_de_teste); subs_x++) { cout <<inversaoA[subs_x] <<endl; cout <<'\n'; } system("PAUSE"); return(NULL); } Esta é uma idéia........Dá pra resolver em cima dela o problema proposto.
  3. :blush: Estruturas de Repetição. Definição do Termo: Estrutura de Repetição - Laço - Loop, são comandos da Linguagem C++ úteis sempre que uma ou mis instrução(es) devam ser repetidas enquanto uma certa condição estiver sendo satisfeita. Na Linguagem de Programação C++ existem três(03) formatos de estruturas de repetição e/ou laço. Estrutura de Repetição: FOR, WHILE DO - WHILE. A príncipio vamos nos focar na Estrutura de Repetição:"FOR". É geralmente utilizado quando queremos executar a repetição de alguma instrução(es) em uma determinada quantidade fixa por vezes. Isto significa que ao utilizarmos uma Estrutura de Repetição do Tipo:"FOR" já sabemos de antemão a quantidade de vezes a repetir. Abaixo segue o desenvolvimento Alghoritimico e logo a seguir a Implementação na Linguagem C++. Alghorithmo{Utilização da Estrutura For forma Simples} | declare: numerico: numero; Para(numero = ( 0 ); ate numero <= ( 10 ); de Passo numero <- (numero + 1))Faça | escreva: numero; | fim Para | fim Alghorithmo. Abaixo a Implementação do Alghorithmo na Linguagem C++ #include<conio.h> #include<iostream> using namespace std; using std::cin; using std::cout; using std::endl; #include<stdlib> unsigned long int main() { system("CLS"); unsigned long int numero; for(numero = ( 0 ); numero <= ( 10 ); numero = (numero + 1)) { cout <<numero <<endl; cout <<'\n'; } /*E caso prefira: for(numero = 0; numero <= 10; numero++) */ system("PAUSE"); return(NULL); } Entendendo a Sintaxe da Estrutura de Repetição: "FOR". A estrutura de repetiçao for consiste na palavra-chave for seguida de parênteses que contêm três(03) expressões separadas por pontos-e-virgulas.Classificaremos a primeira instrução de: expressão de inicialização, a segunda instrução de teste, e a terceira de incrementação. Qualquer uma das tres expressoes pode conter qualquer instruçao valida em C++. Em sua forma mais simples, a inicialização é uma instrução de atribuição( numero = 0) e é sempre executada uma única vez antes de o Laço ser iniciado. A expressão de Teste é uma condição avaliada como verdadeira ou falsa e controla o desenvolvimento do Laço( numero <= 10 ). Esta expressão é avaliada toda vez que o Laço é iniciado ou reiniciado. Se verdadeira (diferente de zero), a instrução do corpo laço é encerrado e o controle passa para a instrução seguinte ao Laço. A expressão de incremento geralmente define a maneira pela qual a variável de controle será alterada cada vez que o Laço for repetido(numero++).Essa expressão é executada sempre imediatamente após a execução do corpo do Laço. No nosso exemplo acima, o desenvolvimento do Laco For é executado 10 vezes. Na primeira vez, a inicialização assegura que a variável numero vale zero.Na última vez, numero vale 9; a informação é dada no teste (numero < 10). Em seguida numero passa a valer 10 e o laço termina. O Corpo do Laço não é executado quando numero vale 10. Abaixo segue mais um exemplo simples do desenvolvimento da Estrutura For, Imprimindo uma tabuada de Adição simples Primeiro Exemplo: Alghorithmo{Tabuada Simples - Adiçao} | declare: numerico: parcela_a, parcela_b; escreva:"Informe o valor da primeira parcela:"; leia: parcela_a; Para:(parcela_b <- ( 0 ); ate parcela_b <= ( 10 ); de Passo parcela_b <- (parcela_b + 1))Faça | escreva:parcela_a : " + " :parcela_b : " = " :(parcela_a + parcela_b); | | Abaixo a Implementação do Alghorithmo em C++ #include<conio.h> #include<iostream> using namespace std; using std::cin; using std::cout; using std::endl; #include<stdlib> unsigned long int main() { system("CLS"); unsigned long int parcela_a, parcela_b; cout <<"\nInforme abaixao o valor da Primeira Parcela:"; cin >>parcela_a; cout <<"Tabuada do Inteiro Positivo Informado pelo usuario: " <<parcela_a <<endl; for(parcela_b = (0); parcela_b <= (10); parcela_b = (parcela_b + 1)) { cout <<parcela_a <<" + " <<parcela_b <<" = " <<(parcela_a + parcela_b) <<endl; cout <<'\n'; } system("PAUSE"); return(NULL); } Variáveis declaradas na Estrutura da Instruçao For: A variável parcela_b pode ser declarada no interior da expressão de inicialização do loop FOR do programa anterior. for( unsigned long int parcela_b = ( 0 ); parcela_b <= ( 10 ); parcela_b++) Flexibilidade da Estrutura de Repetiçao "FOR". Nos exemplos anteriores, utilizamos o laço FOR na sua forma mais simples. Isto é,a primeira expressão para inicializar a variável, a segunda para expressar um limite e a terceira para incrementar ou decrementar a variável. Entretanto, elas não estão restritas apenas a estas formas. Exemplos de outras possibilidades são mostradas a seguir. O Operador Vírgula. Qualquer uma das expressões de um laço FOR pode conter várias instruções separadas por virgulas. A virgula, neste caso, é um operador C++ que significa "faça isto e depois isto". Um par de expressões separadas por virgulas é avaliado da esquerda para a direita. include<iostream.h> void main() { unsigned long int parcela_a = ( 2 ); for(unsigned long int parcela_b = ( 0 ); parcela_b <= ( 10 ); parcela_b = (parcela_b + 1)) { cout <<parcela_a <<" + " <<parcela_b <<" = " <<(parcela_a + parcela_b) <<endl; cout <<'\n'; } } Complicando um pouco. Dentro do mesmo contexto. #include<conio.h> #include<iomanip> using std::setiosflags; using std::setprecision; using std::setw; #include<iostream> using namespace std; using std::cin; using std::cout; using std::endl; #include<cstdlib> #if !defined( z ) #define z 0 #endif #if !defined( u ) #define u 1 #endif #if !defined(fase_inicial) #define fase_inicial z #endif #if !defined(fase_teste) #define fase_teste 5 #endif unsigned long int main() { system("CLS"); unsigned long int fator_incremento = ( u ); unsigned long int subs_f = ( z ); unsigned long int parcela_b = ( z ); unsigned long int parcela_a = ( z ); unsigned long int resultado_soma = ( z ); cout <<"\nInforme no campo abaixo o numero inteiro:"; cout <<"\nFator: "; cin >>parcela_a; for(subs_f = (fase_inicial); subs_f <= (fase_teste);subs_f = (subs_f + fator_incremento),(parcela_b = subs_f),resultado_soma = (parcela_a + parcela_b)) { cout <<parcela_a <<" + " <<parcela_b <<" = " <<resultado_soma <<endl; cout <<'\n'; } system("PAUSE"); return(NULL); } :wub:
  4. :blink: Colega Boa Noite!!!! Se eu entendi bem sobre o enunciado do problema proposto...... Inserção de valores inteiros em dois vetores de forma que logo a seguir fariamos a permuta entre os vetores na ordem que o vetor inteiro A exibirá o inverso de B, e o vetor inteiro B exibirá o inverso do vetor A. A ideia a principio permanece identica ao raciocinio desenvolvido por você no algoritimo acima, só que para tornar o codigo um pouco mais funcional alem do subscrito i que você utilizou na estrutura for para os dois vetores; que tal escrevermos mais um subscrito j para o vetor B. Segue abaixo o desenvolvimento algoritimico da ideia: Algoritimo{Povoar dois Vetores do Tipo inteiro de indice superior 5 e apresenta-los de minisgay com os elementos de A em B, e de B em A} Declare: contante inteiro: intervalo_inferior <- ( 0 ); constante nteiro: intervalo_superior <- ( 5 ); Literal:vetor_A[intervalo_superior], vetor[intervalo_superior]; inteiro: trocador_de_posicao <- ( 0 ); inteiro: i,j; /*Segundo alguns cabeçudo da área é sempre bem-vindo a inicialização das variaveis. Inicializando os vetores: A & B*/ Para:(i = (intervalo_inferior); ate i <= (intervalo_superior); de Passo i = ( i + 1))Faça { vetor_A[i] <- ( 0 ); } Para:(j <- (intervalo_inferior); até j <- (intervalo_superior); de Passo j <- (j + 1))Faça { vetor_B[j] <- ( 0 ); } /*Povoando as casinhas do vetor com valores informados pelo teclado*/ Para:(i <- (intervalo_inferior); i <- (intervalo_superior); de Passo i <- (i + 1))Faça { escreva:"Informe o valor do" :(i + 1) : "º Inteiro Positivo:"; leia: vetor_A[i]; } Para:(j <- (intervalo_inferior); j <- (intervalo_superior); de Passo j <- (j+1)Faça { escreva:"Informe o valor do:(j + 1)" :" º Inteiro Positivo:"; Leia : vetor_B[j]; } /*Agora aqui é que reside o segredo do Minisgay.A idéia é quase semelhante à ordenação de Vetores*/ j <- (intervalo_superior); Para:(i <- (intervalo_inferior); ate i <- (intervalo_superior); de Passo i <- (i + 1))Faca { trocador_de_posicao <- (vetor_A[i]); vetor_A[i] <- (vetor_B[j]); vetor_B[j] <- (trocador_de_posicao); /*Decrementando o subscrito e/ou indice j */ j <- ( j - 1 ); } /*Imprimindo na Tela o Resultado Final da Operação.*/ escreva:"O Valores que estavam em A e passou para B de forma minisgay:"; Para:(i <- (intervalo_inferior); i <= (intervalo_superior); de Passo i <- (i + 1)) { escreva: vetor_A[i]; } escreva:"Os Valores que estavam em B e passou para A de forma minisgay:"; Para:(j <- (intervalo_inferior); j <- (intervalo_superior); de Passo j <- (j + 1)) { escreva: vetor_B[j]; } :wub: Ai Jesuis!!!! quero ser um hacker com práticas p/a o Beimmm!!!!!!!!!!!!!!!!!
  5. :wacko: Programinha da Tabuada Simples! Nota de Esclarecimento: //Entendendo a sintaxe da estrutura for......... /*A estrutura for consiste em primeira instância da palavra chave da linguagem "for" seguida de parênteses q. contêm três(3) expressões separadas por pontos-e-virgulas. Iremos classificar a primeira(1º) dessas expressões de fase de inicialização, a segun_ da(2º) fase de teste e a terceira(3º) e última das fases:fase de incremento. Qualquer uma das três expressões citadas acima pode conter qualquer instrução válida na linguagem C++ Desenvolvimento da Estrutura For: Fase de Inicialização: é apenas uma instrução de atribuição,neste caso iremos estabelecer a variável indicada acima como a váriavel q. receberá os valores a cada incremento ou contagem do loop na estrutura for, ficando assim multiplicando <- (fase_inicial) definida na estrutura das diretivas do pre-processador macros. Fase de Teste: é uma condição avaliada como verdadeira ou falsa e controla a desenvoltura do laço e/ou loop ou seja( multiplicando <= (fase_de_teste)variável também definida na estrutura das diretivas do pre-processador Fase de Incremento: geralmente define a maneira pela qual a variável de controle que neste caso torna-se também a variável "multiplicando" q. será alterada cada vez q. o loop for repetido multipli_ cando <- (multiplicando + incrementador)também definida na estrutura da diretiva do pre-processador. Lógicamente a escrita da estrutura For ficaria assim: Alghorithmicamente: Para:multiplicando de (fase_inicial); até multiplicando <= (fase_de_teste);de Passo multiplicando + incrementador; Faça for(multiplicando = (fase_inicial); multiplicando <= (fase_de_teste); multiplicando = (multiplicando + incrementador))*/ #include<conio.h> #include<iomanip> using std::setiosflags; using std::setprecision; using std::setw; #include<iostream> using namespace std; using std::cin; using std::cout; using std::endl; #if !defined( z ) #define z 0 #endif #if !defined( incrementador ) #define incrementador 1 #endif #if !defined(fase_inicial) #define fase_inicial z #endif #if !defined(fase_de_teste) #define fase_de_teste 10 #endif unsigned long int main() { system("CLS"); unsigned long int multiplicador = ( z ); unsigned long int multiplicando = ( z ); unsigned long int produto = ( z ); cout <<"\nDigite no campo abaixo o valor inteiro do numero multiplicador:"; cout <<'\n'; cout <<"\nNumero Multiplicador ?: "; cin >>multiplicador; //Entendendo a sintaxe da estrutura for......... /*A estrutura for consiste em primeira instância da palavra chave da linguagem "for" seguida de parênteses q. contêm três(3) expressões separadas por pontos-e-virgulas. Iremos classificar a primeira(1º) dessas expressões de fase de inicialização, a segun_ da(2º) fase de teste e a terceira(3º) e última das fases:fase de incremento. Qualquer uma das três expressões citadas acima pode conter qualquer instrução válida na linguagem C++ Desenvolvimento da Estrutura For: Fase de Inicialização: é apenas uma instrução de atribuição,neste caso iremos estabelecer a variável indicada acima como a váriavel q. receberá os valores a cada incremento ou contagem do loop na estrutura for, ficando assim multiplicando <- (fase_inicial) definida na estrutura das diretivas do pre-processador macros. Fase de Teste: é uma condição avaliada como verdadeira ou falsa e controla a desenvoltura do laço e/ou loop ou seja( multiplicando <= (fase_de_teste)variável também definida na estrutura das diretivas do pre-processador Fase de Incremento: geralmente define a maneira pela qual a variável de controle que neste caso torna-se também a variável "multiplicando" q. será alterada cada vez q. o loop for repetido multipli_ cando <- (multiplicando + incrementador)também definida na estrutura da diretiva do pre-processador. Lógicamente a escrita da estrutura For ficaria assim: Alghorithmicamente: Para:multiplicando de (fase_inicial); até multiplicando <= (fase_de_teste);de Passo multiplicando + incrementador; Faça for(multiplicando = (fase_inicial); multiplicando <= (fase_de_teste); multiplicando = (multiplicando + incrementador))*/ //Ambiente de Desenvolvimento da Estrutura For: cout <<"\nA Tabuada do Numero inteiro Digitado: "; cout <<'\n'; cout <<"\nInteiro:" <<multiplicador <<endl; for(multiplicando = (fase_inicial); multiplicando <= (fase_de_teste); multiplicando = (multiplicando + incrementador)) { produto = (multiplicador * multiplicando); cout << '\n' <<setw(3) <<multiplicador <<" * " <<setw(2) <<multiplicando <<" = " <<setw(3) <<produto <<endl; } system("PAUSE"); return(NULL); } :rolleyes: Neste exercicio/exemplo, o laço FOR: é executado 10 vezes. Na primeira execução do laço a inicialização assegura q. a variavel de controle multiplicando vale zero. Na ultima execução do loop, multiplicando vale 10; a informação é assegurada na estrutura da fase do teste(multiplicando <= fase_de_teste -> q.é 10).Quando na fase de teste a variável alcança o valor final de 10 comparando com o fator testador multiplicando = fase_de_teste o laço termina sua execução, onde não será mais executado. Obsº: Pode-se enxugar bem o código acima, com poucas variáveis chega-se ao mesmo resultado. Use a imaginação!!!!!!!!!!!!!!!
  6. :wacko: Ordenação de matriz do tipo Vetor. Observação Algorítmica: Fazer a ordenação(ou seja, colocar os dados e/ou valores segundo uma determinada classificação: ascendente ou descendente é uma das aplicações no campo da ciência da computação mais importante. Praticamente todas as organizações devem classificar algum dado e/ou algum valor de dado e, em muitas ocasiões, quantidades extremas de Dados. Neste contexto,segue abaixo a análise e desen volvimento do que talvez seja o esquema mais simples de classificação de uma matriz/vetor unidimensional. O Programa abaixo classifica os valores inseridos nas casinhas e/ou endereços de um array de forma crescente e descrescente. A técnica empregada é denominada de bubble sort, ou sinking sort porque os valores menores contidos no array "sobem" ou "descem" gradualmente ou se movimentam pela estrutura do array. Inicialmente, o programa irá comparar o valor do inteiro no endereço array_inteiros[0], com array_inteiros[1] em cada interação do loop, assim sucessivamente. #include<conio.h> #include<iomanip> using std::setiosflags; using std::setprecision; using std::setw; #include<iostream> using namespace std; using std::cin; using std::cout; using std::endl; #if !defined( z ) #define z 0 #endif #if !defined( u ) #define u 1 #endif #if !defined(inf) //Intervalo inferior para inicializar o loop da estrutura for. #define inf z #endif #if !defined(sup) //Intervalo superior para determinar o comprimento da estrutura do array. #define sup 5 #endif unsigned long int main() { system("CLS"); unsigned long int subs_x = ( z ); unsigned long int subs_y = ( z ); unsigned long int entrar_inteiro = ( z ); unsigned long int trocar_elemento = ( z ); unsigned long int array_inteiros[sup]; //Habitando as casinhas do array_inteiros com o valor 0. for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u)) { array_inteiros[subs_x] = ( z ); } //Habitando as casinhas do array_inteiros com valores digitados. for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u)) { cout <<"\nInforme no campo abaixo o valor do: " <<(subs_x + u) <<"º Inteiro: " <<endl; cout <<"\nValor: "; cin >>entrar_inteiro; array_inteiros[subs_x] = (entrar_inteiro); } //Colocando os valores dos elementos do array em ordem crescente. for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u)) { for(subs_y = (subs_x + u); subs_y < (sup + u); subs_y++) { if(array_inteiros[subs_x] > array_inteiros[subs_y]) { trocar_elemento = (array_inteiros[subs_x]); array_inteiros[subs_x] = (array_inteiros[subs_y]); array_inteiros[subs_y] = (trocar_elemento); } } } //Exibindo o array crescente. for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u)) { cout <<array_inteiros[subs_x]; cout <<endl; } cout <<endl; //Colocando os valores dos elementos do array em ordem decrescente. for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u)) { for(subs_y = (subs_x + u); subs_y < (sup); subs_y++) { if(array_inteiros[subs_x] < array_inteiros[subs_y]) { trocar_elemento = (array_inteiros[subs_x]); array_inteiros[subs_x] = (array_inteiros[subs_y]); array_inteiros[subs_y] = (trocar_elemento); } } } //Exibindo o array decrescente. for(subs_x = (inf); subs_x < (sup); subs_x = (subs_x + u)) { cout <<array_inteiros[subs_x]; cout <<endl; } system("PAUSE"); return(NULL); }
  7. :wacko: Segue abaixo um desenvolvimento meio psicodelico da estrutura de um código para o "progremia". subs_x -> subscrito da estrutura for( para girar o loop),q. mais adiante no desenvolver do programa passar a fazer parte da estrutura de repetição aninhada p/a classificar os valores dos elementos do vetor passar -> subscrito da primeira estrutura aninhada para auxiliar nas passagens dos valores dos elementos. int_superior -> variavel para armazenar o tamanho do vetor que no caso é ( 5 ), entrar_valor -> variavel para capturar e atribuir o valor numerico digitado pelo usuario. Desenvolvimento do Alghorithmo: #include<conio.h> #include<iomanip> using std::setiosflags; using std::setprecision; using std::setw; #include<iostream> using namespace std; using std::cin; using std::cout; using std::endl; #if !defined( z ) #define z 0 #endif #if !defined( u ) #define u 1 #endif #if !defined(int_inferior) #define int_inferior 0 #endif #if !defined(int_superior) #define int_superior 5 #endif unsigned long int main() { system("CLS"); unsigned long int subs_x = ( z ); unsigned long int passar = ( z ); unsigned long int entrar_valor = ( z ); unsigned long int troca_valor = ( z ); unsigned long int vetor_numeros[int_superior]; //Habitando as casinhas do vetor_numeros inicialmente com o valor Null( 0 ) for(subs_x = (int_inferior);subs_x <= (int_superior);subs_x = (subs_x + u))//Obsº: A incrementação do loop também pode ser escrita e executa conforme " subs_x++ ". { vetor_numeros[subs_x] = ( z ); } //Agora habitando as casinhas do vetor com os valores digitados pelo usuario. for(subs_x = (int_inferior); subs_x <= (int_superior); subs_x++) { cout <<"\nInforme o valor do: " <<subs_x <<"º Numero Inteiro: "; cin >>entrar_valor; vetor_numeros[subs_x] = (entrar_valor); } //Visualizando os valores informados pelo usuario no vetor. for(subs_x = (int_inferior); subs_x <= (int_superior); subs_x++) { cout <<setw( 5 ) <<vetor_numeros[subs_x]; cout <<'\n'; } //Colocando o vetor em forma crescente for(passar = (int_inferior); passar <= (int_superior - u); passar++) { for(subs_x = (int_inferior); subs_x <= (int_superior - u); subs_x++) { if(vetor_numeros[subs_x] > vetor_numeros[subs_x + u]) { troca_valor = (vetor_numeros[subs_x]); vetor_numeros[subs_x] = (vetor_numeros[subs_x + u]); vetor_numeros[subs_x + u] = troca_valor; } } } cout <<endl; cout <<"\nOs Valores em Ordem Crescente do Vetor:"; cout <<'\n'; //Imprimindo os Valores Ordenados do Vetor for(subs_x = (int_inferior); subs_x <= (int_superior); subs_x++) { cout <<setw( 5 ) <<vetor_numeros[subs_x]; cout <<'\n'; } //Colocando o vetor em forma decrescente for(passar = (int_inferior); passar <= (int_superior - u); passar++) { for(subs_x = (int_inferior); subs_x <= (int_superior - u); subs_x++) { if(vetor_numeros[subs_x] < vetor_numeros[subs_x + u]) { troca_valor = (vetor_numeros[subs_x]); vetor_numeros[subs_x] = (vetor_numeros[subs_x + u]); vetor_numeros[subs_x + u] = troca_valor; } } } cout <<endl; cout <<"\nOs Valores em Ordem Decrescente do Vetor:"; cout <<'\n'; //Imprimindo os Valores em Ordem Descrecente do Vetor for(subs_x = (int_inferior); subs_x <= (int_superior); subs_x++) { cout <<setw( 5 ) <<vetor_numeros[subs_x]; cout <<'\n'; } system("PAUSE"); return(NULL); } A classificação dos valores dos numeros inteiros inseridos na estrutura de um vetor em ordem crescente e/ou decrescente neste contexto pode ser denominada de "bubble sort, ou sinking sort, porque os valores menores e/ou maiores "sobem ou descem gradualmente para o topo ou final da estrutura do array. Mais tarde dê uma olhadinha na net sobre o assunto acima citado. obsº: Pode usar nome para as variaveis um pouco menor!................... :rolleyes:
  8. Aproveitando a levada: :D Escrevendo o mesmo programinha em C plus plus #include<conio.h> #include<iostream> using namespace std; using std::cin; using std::cout; using std::endl; unsigned long int main() { system("CLS"); unsigned long int a,x,somatorio = 0; cout <<"\nInforme no campo abaixo um numero inteiro:"; cout <<endl; cout <<"\nQual e o numero: ";cin >>x; for(a = 0; a <= x; a++) { somatorio = (somatorio + a); } cout <<"\nOResultado do Somatorio foi: " <<somatorio <<endl; system("PAUSE"); return(NULL); } :rolleyes:
  9. Dan!.... Eu tenho por hora a terceira edição dos Deitel(s), e estou me aventurando estudar por ele,muitas dúvidas tem surgido,porém tenho também obtido exito em algumas situações/problemas do livro estou disposto trocar figurinhas..... MSN: jpm777.sys@hotmail.com.br Jotão.
  10. B) Desenvolvimento da Primeira Operação: Calculo do Factorial. Segundo Fragmento do exercicio/Problema Proposto. #include<conio.h> #include<iostream> using namespace std; using std::cout; using std::cin; using std::endl; #if !defined( z ) #define z 0 #endif #if !defined( u ) #define u 1 #endif #if !defined(int_inferior) #define int_inferior 1 #endif #if !defined(int_superior) #define int_superior 20 #endif unsigned long int function_calcularFactorial(unsigned long int,unsigned long int); unsigned long int main() { system("CLS"); unsigned long int subs_x = ( z ); unsigned long int input_value_factor = ( z ); unsigned long int array_factors[int_superior]; unsigned long int array_factorials[int_superior]; unsigned long int elemento_factorial = ( z ); unsigned long int calcular_factorial = ( z ); unsigned long int resposta_calculo_factorial = ( z ); for(subs_x = (int_inferior);subs_x < (int_superior);subs_x = (subs_x + u)) { array_factors[subs_x] = ( z ); } for(subs_x = (int_inferior);subs_x < (int_superior);subs_x = (subs_x + u)) { array_factorials[subs_x] = ( z ); } for(subs_x = (int_inferior);subs_x < (int_superior);subs_x = (subs_x + u)) { cout <<"\nInforme no campo abaixo o valor do: " <<subs_x <<"º Inteiro Numerico: " <<endl; cout <<"\nValor Numerico: "; cin >>input_value_factor; array_factors[subs_x] = (input_value_factor); cout <<endl; } for(subs_x = (int_inferior);subs_x < (int_superior);subs_x = (subs_x + u)) { elemento_factorial = (array_factors[subs_x]); resposta_calculo_factorial = function_calcularFactorial(elemento_factorial,calcular_factorial); array_factorials[subs_x] = (resposta_calculo_factorial); } cout <<"\nResultado do Calculo do Factorial:" <<endl; for(subs_x = (int_inferior);subs_x < (int_superior);subs_x = (subs_x + u)) { cout <<"!"<<array_factors[subs_x] <<" = " <<array_factorials[subs_x] <<endl; } system("PAUSE"); return(NULL); } unsigned long int function_calcularFactorial(unsigned long int elemento,unsigned long int calculo_factorial) { unsigned long int subs_f = ( z ); unsigned long int elemento_factorial = ( z ); unsigned long int factorial = ( u ); if(elemento <= u ) { calculo_factorial = ( u ); return(calculo_factorial); } else if(elemento > u ) { for(subs_f = (elemento);subs_f >= (int_inferior); (subs_f = subs_f - u)) { elemento_factorial = (subs_f); factorial = (factorial * elemento_factorial); } } calculo_factorial = (factorial); return(calculo_factorial); } Apenas uma pequena idéia.
  11. :D Olá Galera!!!! Eu também sou iniciante no aprendizado de Programação de Computadores, tenho apanhado um pouco nesse assunto, mas o que esta em evidencia é a insistencia pois acho divertida a coisa. Comecei também atraves dos Livros dos Deitel(s),tenho a Terceira e Quinta Edição, estou interessado em participar do Grupo de Estudo. Deixo aqui o meu MSN para contatos jpm.777sys@hotmail.com.br, me informando as datas,horas,exercicios pretendidos,capitulos do livro coisas assim; e se por acaso podemos postar aleatoriamente algum exercicio resolvido e entendido. Sucesso a todos!!!!!
  12. :ninja: Pesquisar valores dos elementos de um Vetor Unidimensional Pesquisa Linear e Pesquisa Binaria de Dados de um Determinado Vetor. Nota de Info:"O processo de encontrar um determinado valor/elemento de um vetor/matriz é chamado de Pesquisa. Pesquisa Linear: consiste numa simples técnica que compara cada elemento de um vetor/matriz atraves da informação de uma elemento definido a priori como chave de pesquisa,este método funciona bem na estrutura de vetores que possui uma baixa grandeza dimensional ou com vetores não-ordenados.Entretanto, para realizar pesquisas em vetores q. possui um alto indice em sua grandeza dimensional, a pesquisa linear já se torna um pouco ineficiente.Como o problema proposto se trata de um indice superior na ordem de quinze( 15 ) elementos, então poderemos utilizar a Pesquisar Linear a principio. :o Desenvolvimento do Alghoritmo: Alghorithmo {pesquisa_linear_K_noVetor_V} /*Definição das variaveis do programa. inteiro: sub_x; //Subscrito do Vetor. constante inteiro: dim_inferior = ( 1 );///intervalo inicial do Vetor; constante inteiro: dim_superior = ( 16 );//intervalo superior: indice de 15 elementos, inteiro:vetor_inteiros[dim_superior], multiplo_de_quatro = ( 0 );//Identificação do Vetor e uma variavel para calcular os valores dos 15 primeiros multiplos de 4 utilizando o proprio valor do subscrito do vetor inteiro: valor_da_chave = ( 0 )//Variavel para capturar do usuario o valor do numero sendo ele multiplo de quatro ou não para subsequentemente realizar a pesquisa. inteiro: indice_do_elemento = ( 0 );//Variavel para receber atraves de uma funçao definida pelo programador o valor do inidice do vetor. inteiro:achar_valor_indice = ( 0 ); /*Ambiente de construçao do Vetor*/ Para:(sub_x = (dim_inferior); ate(sub_x < dim_superior); de Passo (sub_x + 1))Faça { multiplo_de_quatro(sub_x * 4); vetor_inteiros[sub_x] = (multiplo_de_quatro); } //Povoamos o vetor com os primeiros quinze multiplos de quatro. Agora construiremos uma instrução q. solicite do usuario do programa a digitalização do suposto valor pretendido. escreva:"Informe o Valor Inteiro:"; leia: valor_da_chave; //Neste instante iremos desenvolver uma função para comparar o valor digitado e capturar do vetor o valor do indice caso o numero seja igual ao do vetor. indice_do_elemento = funcao_pesquisaLinear(array_inteiros,valor_da_chave,dim_superior,achar_valor_indice); //A variaveil:achar_valor_indice ira receber atraves da funçao o valor do indice logicamente devolvendo o seu respectivo valor para a variavel indice_do_elemento. se(indice_do_elemento for diferente de ( <> ) -1)então { escreva:"O Valor encontrado no indice do vetor foi: " ::indice_do_elemento; } senão escreva:"Não foi possivel encontrar valores iguais entre a chave e o vetor!"; } //******************************************************** //Ambiente de Definicão da Função pesquisaLinear inteiro: funcao_pesquisaLinear(constante inteiro: array_Inteiros[],inteiro: valor_da_chave,inteiro:dim_superior,inteiro:achar_valor_indice) /*Observe que estamos passando o vetor em sua totalidade p/a a funçao*/ //Desenvolvemos aqui uma estrutura condicional para comparar os valores dos m.de 4 e o valor chave. inteiro: sub_n; se(vetor_Inteiros[sub_n] for igual ( == ) ao valor da chave (valor_da_chave)então { achar_valor_indice = (sub_n);//Recebendo o endereço do valores comparados,sendo verdadeiro a comparação condicional. retornar(achar_valor_indice); } senão achar_valor_indice = ( -1 ); retornar(achar_valor_indice); }//Termino da definiçao da funçao. Postei essa idéia algorithimica p/a dar uma luz quando ao desenvolvimento da lógica do negocio, caso tenha alguma dúvida no raciocinio acima poste sua dúvida, eu também estou iniciando os meus primeiros passos na programação, o que tiver ao meu alcance t......... Eu utilizo a IDE da Microsoft Visual Studio 2010 Express. Acho q. dá para desenvolver o Código e C++. Sucessos!!!!!!!!!!!!!!!!!!! Obs:Caso queira utilizar nomes identificadores para as variáveis conforme citado no seu post:" Vetor - V, Numero Inteiro como K", fique a critério; tomei a liberdade p/a facilitar ao entendimento.
  13. :wub: Amigão, Boa Noite!!!! A ideia consiste no respectivo desenvolvimento: Vamos contemplar um vetor dentro do conceito - dicotomia classe/objeto,onde primeiramente entenderemos os fragmentos do problema propostos Um vetor possui: * um intervalo inicial( que geralmente inicializa com o fator zero( 0 ) ou um( 1 ),conforme for o caso; * um intervalo final( que estabelecerá o limite minimo ou maximo pretendido, no caso 10 a 20, obº quantidade de numeros de elementos do vetor/matriz; * uma variável do tipo subscrito, que por convenção geralmente e representado pela letra ( x ); * e finalmente um nome identificador do suposto vetor, qualquer coisa que seja vetorA, vtA, do tipo inteiro; Algoritimamente falando essa parte ficaria assim: inteiro: intervalo_inicial <- 0; inteiro: intervalo_final <- 0; inteiro: x; inteiro: vetorA[intervalo_final]; "Aqui estamos estabelecendo apenas que o vetor não contém ou recebe nenhum elemento ainda" O Vetor passará a existir e será povoado apartir deste fragmento, onde iremos declarar uma variavel para que possa capturar a quantidade especifica pelo usuario: inteiro quantidade_de_elementos; A instrução de comando ficaria dessa forma: escreva:"Informe a quantidade de elementos pretendida:"; leia: quantidade_de_elementos; Feito isto, aí é que faremos o teste condicional do se, senão....blá, blá, blá, faça alguma coisa. se(quantidade_de_elemento for menor ( > ) que 10) E (quantidade_de_elementos for maior que ( < ) 20) então escreva:"Limite digitalizado fora de faixa digite um valor que esteja entre 10 e 20"; senão se(quantidade_de_elementos for maior igual a 10 ( <= ) E (quantidade_de_elementos for menor igual a 20 ( >= ) então intervalo_final <- quantidade_de_elementos; Aqui determinamos o limite final para o vetor; iremos povoa-lo neste momento, eu tenho costume de desenvolver o laço ou loop do vetor com uma variavel fator para receber o valor do elemento. inteiro fator <- 0; Laço For algoritimicamente falando: Para: ( x <- intervalo_inicial; ate x < (intervalo_final); de x Passo x + 1) Faça escreva:"Informe o valor do elemento:" leia: fator; vetorA[x] <- fator; Imprimindo o vetor: Para:( x <- (intervalo_inicial); até x < (intervalo_final); de x Passo (x+1) Faça escreva: vetorA[x]; Efetuando o Primeiro calculo do Fatorial variaveis: inteiro: y; inteiro:fatorial; inteiro: vetorFatorial[intervalo_final]; Para(x <- (intervalo_inicial); ate x < (intervalo_final); de x Passo(x+1) Faca fatorial <- 1; Para( y <- (intervalo_inicial + 1) ate y (vetorA[x]); de y Passo(y + 1) Faca; fatorial <- (fatorial * y); vetorFatorial[x] <- fatorial; Imprimindo o Vetor com o Calculo do Fatorial: Para(x <-(intervalo_inicial); ate x < (intervalo_final); de x Passo(x+1)Faca; escreva: vetorFatorial[x]; Quanto ao numero primo, é considerado numero primo aquelo q. e divido por 1 e por ele mesmo e resulte como resto 0, pelo que sabemos que o unico numero primo par é o 2, que é divisivel por 1 e por ele mesmo, então logicamente que a maior parte dos numeros impares seriam primos. Tente dentro deste contexto desenvolver a sua logica baseado nos fragmentos da resolução do problema acima. Amanhã te passo o código em C++ e o restante do problema resolvido. Jotão!
  14. :unsure: Amigão Miguel!!! Good Night!!! Gostaria de saber qual é o grau de conhecimento que voce tem, se porventura adotaste algum livro e/ou tutorial?!!! Pois eu tambem encontro talvez no patamar de conhecimento igual ao seu, caso queira juntar as nossas forças, tenho adotado por hora como livro-texto a Terceira Ediçao de C++ como programar dos Deitel(s) que eu xeroquei da biblioteca da escola,são aproximadamente 1088 páginas, e ontem consegui dowloadiar a edição (5), pena que ela não veio com aquelas figurinhas bonitinhas dos smilinguidos carregando os prospectos de projectos, e/ou surfando numa onda, mas tá valendo. Eu já consegui durante este tempo aproximadamente uns dois anos ir ate o capitulo VI, resolvi alguns exercicios,alguns caiu um big ben na cabeça e fundiu a cuca,"mas veras que um filho teu não foge a luta", vamos tentando daqui dali ate conseguir chegar lá. Só pra se ter uma ideia estudei no ano passado o capitulo III Sobre Desenvolviemento de Funções(Pre-definidas pela linguagem, e outras, definidas pelo programador), estou novamente repetindo o estudo, caracas é desafiador, mas tamos nessa; agora que estou começando a entender um pouco sobre algumas funçoes da linguagem tipo a funçao rand -> rand(); para gerar numeros e ou sequencia de numeros aleatorios, muito utilizada em jogos. Caso ce queira contar comigo,estou disposto naquilo que estiver ao nosso alcance.............................. hotmail: jpm.777sys@hotmail.com No mais um grande abraço :D
  15. /*Encontrar o maior de tres inteiros positivos digitado pelo usuario. Utilizando o conceito de Função*/ #include<conio.h> #include<iostream> using namespace std; using std::cin; using std::cout; using std::endl; !if !defined(z) !define z 0 #endif /*Geralmente eu gosto de particionar utilizando os sinais de comentários para organizar os Ambientes do Programa*/ //********************************************************************************************* //Ambiente para escrever os Prototipos das Funçoes do Programa. void funcao_paraExibirMensagemSobreOProblema(void); void funcao_paraEscreverAsVariaveis(void); unsigned long int funcao_paraDigitarOValorAtravesDoTeclado(unsigned long int); void funcao_paraEncontrarOMaiorValor(unsigned long int, unsigned long int, unsigned long int); void funcao_paraImprimirResultado(unsigned long int); //Ambiente do Programa Principal unsigned long int main() { system("CLS"); //Ambiente para execução das Chamadas das Funçoes. funcao_paraExibirMensagemSobreOProblema(); funcao_paraEscreverAsVariaveis(); system("PAUSE"); return(NULL); } //Ambiente para Especificar o Comportamento das Funções. void funcao_paraExibirMensagemSobreOProblema(void) { cout <<"\nEste exercicio consiste em encontrar o maior valor numerico de Tres inteiros positivos digitado pelo usuario."; cout <<endl; system("CLS"); } void funcao_paraEscreverAsVariaveis(void) { unsigned long int nm_a,nm_b,num_c,input_value; //Inicializando as variaveis para que elas não carreguem por hora nenhum valor lixo da memória. nm_a = nm_b = nm_c = input_value = ( z ); //Funcao para carregar as variaveis com algum valor digitado pelo usuario. nm_a = funcao_paraDigitarValorDoTeclado( input_value ); nm_b = funcao_paraDigitarValorDoTeclado( input_value ); nm_c = funcao_paraDigitarValorAtravesDoTeclado( input_value ); //Depois dos Valores carregados nas variaveis,Iremos agora construir uma função para Pesquisar/Encontrar o maior valor e nos devolver o resultado. funcao_paraEncontrarOMaiorValor(nm_a, nm_b, nm_c); } unsigned long int funcao_paraDigitarValorAtravesDoTeclado(unsigned long int value) { unsigned long int factor = ( z ); cout <<"\nInforme no campo abaixo o Valor do Fator:"; cout <<"Fator :"; cin >>factor; value = (factor); return(value); } void funcao_paraEncontrarOMaiorValor(unsigned long int a, unsigned long int b, unsigned long int c) { unsigned long int maior_valor = ( z ); if(( a > b ) && ( a > c )) { maior_valor = ( a ); } else if(( b > a ) && ( b > c)) { maior_valor = ( b ); } else if(( c > a ) && ( c > b )) { maior_valor = ( c ); } funcao_paraImprimirResultado( maior_valor ); } void funcao_paraImprimirResultado(unsigned long int maior_valor) { cout <<"\nO Maior Valor Encontrado foi : " <<maior_valor <<endl; system("PAUSE"); } :huh: :wub:
×
×
  • Criar Novo...