Programação e Desenvolvimento

Projetos, softwares, sites, blogs e trabalhos conforme sua necessidade e com os melhores preços.
Tecnologia do Blogger.

Text Widget

Search (Don't Edit)

Sample Text

Colaboradores

Formulir Kontak

Nome

E-mail *

Mensagem *

Full-Width Version (true/false)

Flickr

Arquivo do blog

Facebook

Translate

Video of the Day

Slider (Add Label Name Here!) (Documentation Required)

Teste Teste Teste

Know us

Teste Teste Teste Teste

Popular Posts

Featured


24 de jan. de 2020

Algoritmo em C, Informar um preço de um produto e calcular novo preço com desconto de 9%.

Algoritmo em C, Informar um preço de um produto e calcular novo preço com desconto de 9%.

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>
int main()
{
 float precoatual;
 printf("Informe o preco atual do produto: ");
 scanf("%f",&precoatual);
 printf("\n\nNovo preco com desconto de 9%% e: %3.2f\n\n",precoatual * 0.91);
 system("PAUSE");
 return 0;
}

Trabalhos.: 
E-mail: mvf5system@gmail.com 
Blog: http://mvf5-system.blogspot.com.br/ 
Facebook: https://www.facebook.com/mvf5systems

Algoritmo em C, Calcule e imprima o valor em reais de cada kw.

Algoritmo em C, Calcule e imprima o valor em reais de cada kw o valor em reais a ser pago o novo valor a ser pago por essa residencia com um desconto de 10%. Dado: 100 kilowatts custa 1/7 do salario minimo. quantidade de kw gasto por residencia.

#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
#include <math.h>
int main()
{
 float SM, kwgasto, umkw;
 printf("Informe o valor do salario minimo: ");
 scanf("%f",&SM);
 printf("\n\nInforme total Kw gasto na residencia: ");
 scanf("%f",&kwgasto);
 umkw = SM/7/100;
 printf("\n\nO valor de 1 Kw e: %3.2f\n\n",umkw);
 printf("\nO valor a ser pago pela residencia e: %4.2f",kwgasto * umkw);
 printf("\n\nNovo valor a ser pago com desconto de 10%% e: %3.2f\n\n",(kwgasto * umkw) * 0.90);
 system("PAUSE");
 return 0;
}


Trabalhos.: 
E-mail: mvf5system@gmail.com 
Blog: http://mvf5-system.blogspot.com.br/ 
Facebook: https://www.facebook.com/mvf5systems

14 de mar. de 2019

Algoritmo em C utilizando Pilha e Fila

Algoritmo em C simulando um porto onde existam 10 pilhas com capacidade de 10 containers por pilha. O porto recebe navios cargueiros em fila e eles descarregam ou carregam os containers.



#include <stdio.h>
#include <string.h>

#define T 10
#define P 10



typedef struct{
        int topo;
}PILHA;


typedef struct {
       int cod, qtd;
}NAVIO;
typedef struct{
        int n, ini;
        NAVIO navio[T];
}FILA;

typedef struct{
        int n, ini;
        NAVIO navio[T];
}FILASaida;

int menuPrincipal();//função com as opções do menu prinicipal...
void iniciarPilha(PILHA *p);
int overflow(PILHA *p);
int underflow(PILHA *p);
void push(PILHA *p, FILA *f );
void pop(PILHA *p);
void imprimirPilha(PILHA *p);


void iniciarFila(FILA *f);
int vazia(FILA *f);
int cheia(FILA *f);
void inserir(FILA *f,NAVIO *nav);
void imprimirFila(FILA *f);
void imprimirFilaTotal(FILA *f);
void remover(FILA *f);

int main(){

    PILHA pilha[T];

    FILA fila;
    FILASaida filaS;
    NAVIO nav;

    int menu, x, codNavio = 0, pilhaCont, codNavioS = 0, qtd, qtdSoma, aux = 0;

    for(x = 0; x < 10; x++){
        iniciarPilha(&pilha[x]);
    }

    iniciarFila(&fila);
    iniciarFila(&filaS);

    do{

        menu = menuPrincipal();

        switch(menu){
            case 1:
                if(!cheia(&fila)){
                    codNavio++;
                    nav.cod = codNavio;
                    printf("Informe a quantidade de containers, que tem no Navio: ");
                    scanf("%d", &nav.qtd);

                    inserir(&fila, &nav);
                    
                    printf("\n\nNavio inserido com sucesso:\n\n");

                }
                else{
                    printf("A fila de navio esta cheia: \n");
                }
            break;
            case 2:
                if(!vazia(&fila)){
                    system("cls");
                    
                    do{
                    imprimirFila(&fila);
                    printf("Informe a pilha que vai desgarregar 1 - 10: \n");
                    scanf("%d", &pilhaCont);
                   
                    if(pilhaCont < 1 || pilhaCont > 10 ){
                    printf("\nOpcao invalida\n");
                   
}
if(!overflow(&pilha[pilhaCont-1])){
 push(&pilha[pilhaCont-1], &fila );
 printf("\nColocado na pilha\n");
}
else{
printf("\nEssa Pilha esta cheia\n");
}
                   
}while(pilhaCont < 1 || pilhaCont > 10 );
                }
                else{
                    printf("Não existe nenhum navio na fila\n");
                }
            break;
            case 3:
            if(!vazia(&fila)){
                    system("cls");
                   
                    imprimirFilaTotal(&fila);
                   
                }
                else{
                    printf("Não existe nenhum navio na fila\n");
                }
            break;
            case 4:
            
            for(x = 0; x < 10; x++){
            printf("Pilha %d - qtd %d\n", x+1, pilha[x].topo+1);
}
printf("\n\n");
            break;
            case 5:
               qtd = 0;
               qtdSoma = 0;
                    codNavio++;
                    nav.cod = codNavio;
                    nav.qtd = 0;
                    aux = 0;
           
           
            do{
                    for(x = 0; x < 10; x++){
            printf("Pilha %d - qtd %d\n", x+1, pilha[x].topo+1);
            }
            printf("Informe a pilha: ");
                    scanf("%d", &pilhaCont);                    
                    printf("A quantidade de containers, que vai carregar no Navio: \n");
                    scanf("%d", &qtd);
                   
                    if(pilhaCont < 1 || pilhaCont > 10 ){
                    printf("\nOpcao invalida\n");                    
}
if(!underflow(&pilha[pilhaCont-1])){
if(qtd > 10 || qtd < 0){
printf("\nValor invalido\n");
}
else{
if(pilha[pilhaCont-1].topo <= qtd ){
nav.qtd += pilha[pilhaCont-1].topo + 1;
pilha[pilhaCont-1].topo = -1;
printf("\nteste: %d\n", pilha[pilhaCont-1].topo);
}
else{
nav.qtd += qtd;
pilha[pilhaCont-1].topo -= qtd;
}
}
aux = 1;
}
else{
printf("\nEssa Pilha esta vazia\n");
}
printf("\nDeseja continuar: 1-sim/2-nao\n");
scanf("%d", &qtd);
if(qtd == 1){
pilhaCont = 2;
}
else{
pilhaCont = -2;
}
                   
}while(pilhaCont < 1 || pilhaCont > 10 );
if(aux == 1){
inserir(&filaS, &nav);
}
       

                
            break;
            case 6:
            if(!vazia(&filaS)){
                    system("cls");
                   
                    imprimirFilaTotal(&filaS);
                   
                }
                else{
                    printf("Não existe nenhum navio na fila\n");
                }
            break;

        }

    }while(menu != 0);

    return 0;
}

int menuPrincipal(){

    int opc;

    printf("1-Colocar Navio na Fila\n"
           "2-Desgarregar containers\n"
           "3-Imprimir Fila de navios para descarregar\n"
           "4-Imprimir as pilhas\n"
           "5-Carregar Navios: \n"
           "6-imprimir fila de Navios carregados: \n"
           "0-sair\n\nopcao:");
    scanf("%d", &opc);
    system("cls");

    if(opc >= 0 && opc <= 10){
        return opc;
    }
    else{
        return menuPrincipal();
    }
}

void iniciarPilha(PILHA *p){
     p->topo = -1;
}


void iniciarFila(FILA *f){
     f->n =0;
     f->ini = 0;
}
int overflow(PILHA *p){
    return p->topo == T-1;
}
int underflow(PILHA *p){
    return p->topo == -1;
}

int vazia(FILA *f){
    return f-> n == 0;
}
int cheia(FILA *f){
    return f-> n == P;
}

void inserir(FILA *f,NAVIO *nav){
     int fim;
     fim = (f-> ini + f-> n) % P;
     f->navio[fim] = *nav;
     f->n++;

}

void imprimirFila(FILA *f){
    int aux, fim, x = 0;
     fim = (f->ini + f-> n-1)% T;

     if(f->ini == 0 || f-> ini <= fim || fim == T -1){
       for(aux = f-> ini; aux<= fim; aux++){
         if(x == 0){
          printf("Posicao na fila: [%d] - Codigo: %d - qtd: %d\n",aux+1,f->navio[aux].cod, f->navio[aux].qtd);
          x = 1;
}
           
           }
       }
     else{
          for(aux = f->ini; aux < T; aux ++)
             printf("Posicao na fila: [%d] - Codigo: %d\n",aux+1,f->navio[aux].cod);

          for(aux = 0; aux <=fim; aux++)
             printf("Posicao na fila: [%d] - Codigo: %d\n",aux+1,f->navio[aux].cod);
     }
     printf("\n\n");
}
void imprimirFilaTotal(FILA *f){
    int aux, fim, x = 0;
     fim = (f->ini + f-> n-1)% T;

     if(f->ini == 0 || f-> ini <= fim || fim == T -1){
       for(aux = f-> ini; aux<= fim; aux++){
         
          printf("Posicao na fila: [%d] - Codigo: %d - qtd: %d\n",aux+1,f->navio[aux].cod, f->navio[aux].qtd);
         
           
           }
       }
     else{
          for(aux = f->ini; aux < T; aux ++)
             printf("Posicao na fila: [%d] - Codigo: %d\n",aux+1,f->navio[aux].cod);

          for(aux = 0; aux <=fim; aux++)
             printf("Posicao na fila: [%d] - Codigo: %d\n",aux+1,f->navio[aux].cod);
     }
     printf("\n\n");
}
void remover(FILA *f){
f->ini  =(f->ini +1) % T;
     f->n--;
}


void push(PILHA *p, FILA *f ){
int aux, fim, x = 0, y = 0;
     fim = (f->ini + f-> n-1)% T;

     if(f->ini == 0 || f-> ini <= fim || fim == T -1){
       for(aux = f-> ini; aux<= fim; aux++){
         if(x == 0){
          printf("Posicao na fila: [%d] - Codigo: %d - qtd: %d\n",aux+1,f->navio[aux].cod, f->navio[aux].qtd);
          x = 1;
          for(y = 0; y < 10; y++ ){
         

          p->topo++;
f->navio[aux].qtd--;
          if(f->navio[aux].qtd == 0){
          remover(f);
          break;
   }
   if(p->topo == 9){
    break;
}
}
}
           
           }
       }
     else{
          for(aux = f->ini; aux < T; aux ++)
             printf("Posicao na fila: [%d] - Codigo: %d\n",aux+1,f->navio[aux].cod);

          for(aux = 0; aux <=fim; aux++)
             printf("Posicao na fila: [%d] - Codigo: %d\n",aux+1,f->navio[aux].cod);
     }
     printf("\n\n");
}
Trabalhos.: 
E-mail: mvf5system@gmail.com 
Blog: http://mvf5-system.blogspot.com.br/ 
Facebook: https://www.facebook.com/mvf5systems



Algoritmo em C de ordenação de vetor pela função Selection Sort.

Algoritmo em C de ordenação de vetor pela função Selection Sort.
Algoritmo em C que preenche um vetor de 6 posições e ordena de forma crescente e decrescente pela função Selection Sort, utilizando ponteiros para implementação do algoritmo.

#include <stdio.h>

void selection_sort_decrescente(int * num, int tam) {
 
    int i, j, swap, min;
        for (i = 0; i < (tam-1); i++){
            min = i;
         
            for (j = (i+1); j < tam; j++) {
                if(*(num+j) > *(num+min)){
                    min = j;
                }
            }
            if (i != min) {
              swap = *(num + i);
              *(num + i ) = *(num + min);
              *(num + min ) = swap;
            }
         
        }
     
}
void selection_sort_crescente(int * num, int tam) {
 
    int i, j, swap, min;
        for (i = 0; i < (tam-1); i++){
            min = i;
         
            for (j = (i+1); j < tam; j++) {
                if(*(num+j) < *(num+min)){
                    min = j;
                }
            }
            if (i != min) {
              swap = *(num + i);
              *(num + i ) = *(num + min);
              *(num + min ) = swap;
            }
         
        }
     
}
int main() {

    int x[6], n=6, i;  

     for (i=0; i<n; i++) {

            printf("\ninforme um numero: ");

            scanf("%d",&x[i]);

    }

    printf("\nVetor original\n");

    for (i=0; i<n; i++)

        printf("\t%d", x[i]);

        selection_sort_decrescente(x, n);

        printf("\n\nVetor ordenado Decrescente\n");

    for (i=0; i<n; i++)

        printf("\t%d", x[i]);

        printf("\n");

selection_sort_crescente(x, n);
printf("\n\nVetor ordenado Crescente\n");

    for (i=0; i<n; i++)

        printf("\t%d", x[i]);

        printf("\n");
    return 0;

}
Trabalhos.: 
E-mail: mvf5system@gmail.com 
Blog: http://mvf5-system.blogspot.com.br/ 
Facebook: https://www.facebook.com/mvf5systems

Saídas Simples usando print, println, printf e format em Java

Saídas Simples usando print, println, printf e format


Vamos demostrar as maneiras de mostrar mensagens na tela, que incluem:

System.out.println, System.out.print, System.out.printf e System.out.format
System.out - Objeto de saída em Java padrão, que permite exibir as Strings no console (terminal) de comando quando o aplicativo de Java é executado. Dentro desse objeto existem métodos para gerar
saídas de Strings, entre elas são: println, print e o printf.
O método System.out.println()
A instrução System.out.println(), gera uma saída de texto entre aspas duplas significando uma String, criando uma nova linha e posicionando o cursor na linha abaixo, o que é identificado pela terminação “ln”. Veja no exemplo.Saída de uma String com System.out.println

Postagem em destaque

MVF5 System - SOLUÇÕES EM TI!

          Desenvolvimento de projetos, softwares, sites, blogs e trabalhos conforme sua necessidade e com os melhores preços. Entre em c...

Seguidores

Total de visualizações

Postagens populares