Tópico: Amostra de Programas - espaço dos programadores do CC

[Eleitor de Mário Oliveira]

Aí pessoal que programa em C, C++, Basic, Pascal, Java etc. Se vocês tiverem programado algo interessante e querem compartilhar com outras pessoas que possam apreciar (e compilar), aqui é o lugar.

[Eleitor de Mário Oliveira]

Algarismos Romanos e Indo-arábicos

Código: [Selecionar]

/*Autor: Dante Cardoso Pinto de Almeida
Licenca: Dominio Publico - Public Domain*/

#include <stdio.h>

int main(int argc, char *argv[])
{

 short int rodando;
 do    /*Este laco mantem o programa rodando enquanto o usuario desejar*/
 {
 unsigned int controle, controle2;
 char rom[10];
 short int opcao=0;

   while(opcao!=1&&opcao!=2) /*Este laco forca o usuario a entrar com 1 ou 2*/
  {
 printf("\nTecle 1 para converter um numero em algarismos indo-arabicos para algarismos \nromanos.\n");
 printf("Tecle 2 para converter um numero em algarismos romanos em numero para algarismos indo-arabicos. ");
  scanf("%d", &opcao);
  }

  if(opcao==1)
  {
   int numero;
   printf("\nVoce escolheu converter numeros em algarismos indo-arabicos para numeros em \nalgarismos romanos.\n");
   printf("\nEntre com o numero. ");

   scanf("%d", &numero);

  printf("O numero representado em algarismos indo-arabico por %d, em agarismos romanos \neh representado por ", numero);

            while(numero>0) /*Algoritmo para conversao de alg. indo-arabicos para romanos*/
            {
             while(numero-1000>-1)/*para cada milhar, imprimir um M*/
             {
             numero=numero-1000;
             printf("M");
             }

             while(numero-900>-1)/*para cada 9 centenas, imprimir um CM*/
             {
             numero=numero-900;
             printf("CM");
             }

             while(numero-500>-1) /*para cada 5 centenas, imprimir um D*/
             {
             numero=numero-500;
             printf("D");

             }

             while(numero-400>-1) /*para cada 4 centenas, imprimir um CD*/
             {
             numero=numero-400;
             printf("CD");

             }

             while(numero-100>-1)/*para cada centena, imprimir um C*/
             {
             numero=numero-100;
             printf("C");

             }

             while(numero-90>-1)/*para cada 9 dezenas, imprimir um XC*/
             {
             numero=numero-90;
             printf("XC");

             }

              while(numero-50>-1) /*para cada 5 dezenas, imprimir um L*/
              {
              numero=numero-50;
              printf("L");

              }

              while(numero-40>-1)/*para cada 4 dezenas, imprimir um XL*/
              {
              numero=numero-40;
              printf("XL");

              }

              while(numero-10>-1)/*para cada dezena, imprimir um X*/
              {
              numero=numero-10;
              printf("X");

              }

              while(numero-9>-1)/*para cada 9 unidades, imprimir um IX*/
              {
              numero=numero-9;
              printf("IX");

              }

              while(numero-5>-1)/*para cada 5 unidades, imprimir um V*/
              {
              numero=numero-5;
              printf("V");

              }

              while(numero-4>-1) /*para cada 4 unidades, imprimir um IV*/
              {

              numero=numero-4;
              printf("IV");

              }

              while(numero-1>-1)/*para cada unidade, imprimir um I*/
              {
              numero=numero-1;
              printf("I");

              }

       }
   }

  if(opcao==2)
     {
     int numero=0;
     printf("\nVoce escolheu converter numeros em algarismos romanos para numeros em algarismos indo-arabicos.\n");
     printf("Entre com os algarismos romanos em letra maiuscula, lembrando que:\n");
     printf("I=1, V=5, X=10, L=50, C=100, D=500 e M=100.\n");

     scanf("%s", rom);
                 /*Algoritmo para conversao de alg. romanos para indo-arabicos*/
                 for(controle=0; rom[controle]!='\0'; controle++)
                 {
                 controle2=controle-1;
                 /*para cada M nao antecedido de C, somar 1000*/
                 if(rom[controle]=='M'&&rom[controle2]!='C')
                 {
                 numero=numero+1000;
                 }
                 /*para cada M antecedido de C, somar 800*/
                 if(rom[controle]=='M'&&rom[controle2]=='C')
                 {
                 numero=numero+800;
                 }
                 /*para cada D nao antecedido de C, somar 500*/
                 if(rom[controle]=='D'&&rom[controle2]!='C')
                 {
                 numero=numero+500;
                 }
                 /*para cada D antecedido de C, somar 300*/
                 if(rom[controle]=='D'&&rom[controle2]=='C')
                 {
                 numero=numero+300;
                 }
                 /*para cada C nao antecedido de X, somar 100*/
                 if(rom[controle]=='C'&&rom[controle2]!='X')
                 {
                 numero=numero+100;
                 }
                 /*para cada C antecedido de X, somar 80*/
                 if(rom[controle]=='C'&&rom[controle2]=='X')
                 {
                 numero=numero+80;
                 }
                 /*para cada L nao antecedido de X, somar 50*/
                 if(rom[controle]=='L'&&rom[controle2]!='X')
                 {
                 numero=numero+50;
                 }
                 /*para cada L antecedido de X, somar 30*/
                 if(rom[controle]=='L'&&rom[controle2]=='X')
                 {
                 numero=numero+30;
                 }
                 /*para cada X nao antecedido de I, somar 10*/
                 if(rom[controle]=='X'&&rom[controle2]!='I')
                 {
                 numero=numero+10;
                 }
                 /*para cada X antecedido de I, somar 8*/
                 if(rom[controle]=='X'&&rom[controle2]=='I')
                 {
                 numero=numero+8;
                 }
                 /*para cada V nao antecedido de I, somar 5*/
                 if(rom[controle]=='V'&&rom[controle2]!='I')
                 {
                 numero=numero+5;
                 }
                 /*para cada V antecedido de I, somar 3*/
                 if(rom[controle]=='V'&&rom[controle2]=='I')
                 {
                 numero=numero+3;
                 }
                 /*para cada I, somar 1*/
                 if(rom[controle]=='I')
                 {
                 numero++;
                 }
                 }

 printf("O numero representado em algarismos romanos por ");

 for(controle=0; rom[controle]!='\0'; controle++)
 {
 printf("%c", rom[controle]);
 }

 printf(" eh representado por \nalgarismos indo-arabicos na base decimal por ");

printf("%d .\n", numero);
}


printf("\nDigite 1 para manter o programa rodando. ");
scanf("%d", &rodando);
}while(rodando==1);

  return 0;
}


[Eleitor de Mário Oliveira]

Código: [Selecionar]

/*Autor: Dante Cardoso Pinto de Almeida
Licenca: Dominio Publico - Public Domain*/

#include <stdio.h>
#include <stdlib.h>

void bnr(int m) /*funcao para impressao dos binarios*/
 {
 unsigned short int binario[20];
 int a, b, c;

     for(a=0; a<20; a++) /*limpa todo o vetor*/
     {
     binario[a]=0;
     }

 b=0;
 for(a=m; a>0; a=a/2) /*Algoritmo de conversao de decimal para binario*/
 {

  if (a%2==0)
  {
  binario[b]=0;
  }
  if(a%2==1)
  {
  binario[b]=1;
  }
  b++;
  }

  for(c=b; c>-1; c--)
  {
  printf("%d", binario[c]);
  }
 }


int main(int argc, char *argv[])  /*inicio do programa*/
{
 int runner;
 runner=1;
 while(runner!=0)    /*laco para encerrar o programa ou mantê-lo rodando*/
 {
 unsigned long int n, x;  /*n -> variavel do numero, x -> variavel de repeticao de laco*/
 int tabela[20];
 short int base=0;
 char basedois[20];  /*Variavel para entrar com um numero na base 2*/

 printf("Este programa faz uma tabela de n a n+20(dec) de conversao entre bases numericas\n");

 while((base!=2) && (base!=8) && (base!=10) && (base!=16)) /*laco para impedir entrada invalida*/
                 {
                 printf("Escolha a base do numero de entrada (2, 8, 10 ou 16).");
                 scanf ("%d", &base);
                 }

 if(base==2)
            {
            printf("\nEntre com um numero na base 2. ");

            scanf("%s", basedois);

            n=0;
            for(x=0; basedois[x]!='\0'; x++)
                     {
                     n=n*2+basedois[x]-48;
                     }
            }

 if(base==10)
             {
             printf("\nEntre com um numero na base 10. ");
             scanf ("%d", &n);
             }

 if(base==8)
            {
            printf("\nEntre com um numero na base 8. ");
            scanf ("%o", &n);
            }

 if(base==16)
             {
             printf("\nEntre com um numero na base 16. ");
             scanf ("%X", &n);
             }


 for (x=0; x<21; x++)
     {
     tabela[x]=(n+x);
     }


 printf("Dec.     Oct.     Hex.     Bin.\n");


 for (x=0; x<21; x++)
     {

     printf("%4d    %4o    %4X    ", tabela[x], tabela[x], tabela[x]);
     bnr(tabela[x]);
     printf("\n");
     }

 printf("\nDigite 0 para encerrar o programa.");
 printf("\nDigite qualquer outro numero para continuar rodando o programa.");
 scanf("%d", &runner);
 }


  return 0;}

[Eleitor de Mário Oliveira]

Triângulo Aritmético

Código: [Selecionar]

/*Autor: Dante Cardoso Pinto de Almeida
Licenca: Dominio Publico - Public Domain*/

#include <stdio.h>

int main(int argc, char *argv[])
{

int rodando=1;
 while(rodando==1)/*Este laco mantem o programa rodando enquanto o usuario desejar*/
 {
 unsigned int linha1[20], linha2[20], linhas, n, m, p;

  for(n=0; n<20; n++) /*este laco limpa os vetores*/
  {
  linha1[n]=1;
  linha2[n]=1;
  }


  printf("Este programa cria um triangulo aritmetico ate a linha que o usuario desejar,\n com o limite de 20 linhas.\n");
  do /*Este laco impede a entrada de numeros maiores que 20*/
  {
  printf("Entre com o numero de linhas do triangulo. ");
  scanf("%d", &linhas);
  } while(linhas>20);

 for(n=0; n<linhas+1; n++)/*este laco imprime cada linha do triangulo*/
 {

  for(m=0; m<n; m++)/*este laco imprime cada elemento da linha*/
  {
  printf("%5d", linha1[m]);
  }
  printf("\n");

  for(m=1; m<n; m++)/*este laco cria a próxima linha com base na anterior*/
  {
   p=m-1;
   linha2[m]=linha1[p]+linha1[m];
  }

  for(m=0; m<n; m++)
  {
   linha1[m]=linha2[m];
  }
 }

 printf("\nDigite 1 para continuar rodando o programa.");
printf("\nDigite qualquer outro numero para encerrar o programa. ");
scanf("%d", &rodando);
 }


  return 0;
}

[SnowRaptor]

Código: [Selecionar]

/* Charset ISO-88591     */

/* Diagrama de bifurcação do Mapa Logísitco */
/* Elton Carvalho - Julho/2005 */


/* Armazena os pontos fixos do mapa x[i+1] = mi*x[i]*(1-x[i]) */
/* em função do parâmetro mi dentro dos intervalos definidos abaixo */
/* abaixo. O mapa diverge para mi negativo ou maior que 4. */

/* O arquivo de saída terá duas colunas: Uma com o valor de mi */
/* e outra com os valor do ponto fixo. Serão calculados sempre 1000 */
/* pontos entre mi_min e mi_max, com 1000 pontos fixos para cada  */
/* valor de mi. */

/* Coisas a observar: Gere gráficos das regiões de destaque */
/* - Auto-similaridade: observe que a estrutura se repete em diversas */
/* regiões. */
/* - Períodos 3, 5 e 7: Há regiões em que, para um dado valor de mi, */
/* existem apenas 3, 5, 7 etc. pontos fixos. A exist&encia de */
/* período 3 implica na existência de períodos de valores primos */
/* e seus múltiplos por potências de 2. */
/* - Crises: Logo depois dessas janelas, passam a aparecer pontos fixos */
/* que aparentemente não vêm das bifurcações anteriores, parecendo */
/* uma "parede" de pontos que surge do nada. Essas crises ocorrem */
/* pois além dos pontos fixos estáveis presentes do gráfico, exitem*/
/* pontos fixos instáveis que geram essas crises ao colidir com */
/* pontos estáveis. */


/*     Plote os dados em seu programa de gráficos favorito */
/* ******(ATENÇÃO: UM MILHÃO DE PONTOS!)****** */

/* Espere por um arquivo de saída de 20 MB. */


#include<stdio.h>
#include<stdlib.h>
#include<math.h>

#define MI_MIN 2.8
#define MI_MAX 4
#define XMIN 0
#define XMAX 1

#define TRANSIENTE 20000 /* numero de passos do transiente */
#define ARMAZENA 1000 /* numero de passos a armazenar */

typedef struct mapa_logi
{
double x; /* valor da populacao */
double x_min; /* limite inferior do intervalo de x */
double x_max; /* limite superior do intervalo de x */
double mi; /* parâmetro da relacao de recorrencia */
double delta_mi; /* incremento no parametro de recorrencia */
double mi_min; /* limite esquerdo do intervalo de mi */
double mi_max; /* limite direito do intervalo de mi  */
} mapa_logistico;

typedef mapa_logistico *mapa;

void mapeia_atratores(FILE *saida_mapa, mapa pop);
double mapeia(const double mi, double x);

int main()
{
mapa_logistico populacao; /* Declaracao da estrutura que contem
   as informacoes sobre o mapa */
mapa pop = &populacao; /* Associacao de ponteiro para as info.
   sobre o mapa. */
FILE * saida_mapa;       /* Ponteiro apra o arquivo onde serao
   armazenados os pontos do mapa.    */

pop->mi_min = MI_MIN;
pop->mi_max = MI_MAX;
pop->x_min = XMIN;
pop->x_max = XMAX;

printf("%g < mi < %g \n %g < x < %g\n\n"
"Iterando mapa. Pode levar alguns minutos se o intervalo de x for pequeno. . .\n",
pop->mi_min, pop->mi_max, pop->x_min, pop->x_max);

        saida_mapa = fopen("diagrama.dat", "w");



/* Escolher delta_mi para ter 1000 valores de mi no intervalo*/
pop->delta_mi=(pop->mi_max - pop->mi_min) * 1e-3;

for(pop->mi = pop->mi_min + pop->delta_mi;
    pop->mi < pop->mi_max;
    pop->mi += pop->delta_mi)
mapeia_atratores(saida_mapa, pop);

fclose(saida_mapa);

printf("\nConcluido. Enjoy your diagrams.\n");
return 0;
}

void mapeia_atratores(FILE *saida_mapa, mapa pop)
{
int i; /* Contador, desculpe, nao resisti */

/* Estabelecendo uma condicao inicial qualquer, digamos x0 = 0.1: */
pop->x = 0.1;

/* iterando o transiente:       */
for (i = 0; i < TRANSIENTE; i++)
pop->x = mapeia(pop->mi, pop->x);

i=0;
/* imprimindo os pontos do mapa:     */
while (i < ARMAZENA)
{
pop->x = mapeia(pop->mi, pop->x);
if(pop->x < pop->x_max  && pop->x > pop->x_min)
{
fprintf(saida_mapa, "%1.10g\t%1.10g\n", pop->mi,
pop->x);
i++;
}
}

}

double mapeia(const double mi, double x)
{
return (mi * x *(1 - x));
}



[Alegra]

Putz!  isso pra mim é conversa de grego com baiano....doidera...

[Rodion]

*Este laco mantem o programa rodando enquanto o usuario desejar*

dante, o que é isso? tem mais uma função didática, né?
e esse aí é qual língua de programação?

[Oceanos]

Vou ver se acho meus trabalhos de pesquisa operacional do ano passado e mando aqui.

[Oceanos]

dante, o que é isso? tem mais uma função didática, né?
e esse aí é qual língua de programação?

É um comentário. Tudo que está entre /* e */, e a frente de // o compilador ignora; e serve para isso mesmo que você falou. A linguagem é C.

[SnowRaptor]

*Este laco mantem o programa rodando enquanto o usuario desejar*

dante, o que é isso? tem mais uma função didática, né?
e esse aí é qual língua de programação?

Como asism função didática?

Isso é C

[Mussain!]

Que diabo é isso....?   E eu pensando que iriam falar de nomes de programas para testes....  

[SnowRaptor]

Que diabo é isso…?  E eu pensando que iriam falar de nomes de programas para testes… 

Que testes, cara-pálida?

[Dr. Manhattan]

Sei um pouco de C++, mas só sou fluente mesmo é em Fortran… 
Meus programas são específicos demais para interessarem a alguem daqui.

Ei, só por curiosidade, alguem aqui usa Povray? 

[SnowRaptor]

Sei um pouco de C++, mas só sou fluente mesmo é em Fortran… 
Meus programas são específicos demais para interessarem a alguem daqui.

Os meus também.

Ei, só por curiosidade, alguem aqui usa Povray? 

Quero aprender, tenho umas trajetórias de dinâmica molecular que quero transformar em filminho

[Dr. Manhattan]

Aprendi um pouco, só por diversão. Lembra um pouco C++. É interessante que é possível "plotar" funções em Povray, usando loops.
Também fiz umas "imagens astronômicas" usando umas texturas de fotos das luas de Júpiter.
Até pretendo "renderizar" umas ilustrações de redes cristalinas, assim que tiver tempo.

[SnowRaptor]

Legal! Você trabalha com o quê?

[Dr. Manhattan]

Com matéria condensada (teoria): filmes magnéticos e sistemas de baixa dimensionalidade de um modo geral. Em um
dos meus trabalhos tive que usar um modelo de cristal daqueles com bolinhas de madeira e arame, para poder visualizar os
planos cristalinos (fiz as ilustrações com o Paint! [1]). Com imagens 3D fica muito mais fácil.

[1] Faz teeempo.

[SnowRaptor]

Divertido! Eu mexo com nanotubos de carbono.

[Dr. Manhattan]

Legal! Olha só:
../forum/topic=8611.0.html

[Nyx]

  Acho que está na hora de estudar um pouco de programação.

 

[Guinevere]

Os programas que faço são secretos...

[Andre]

E os que eu faço são avançados demais.

[Guinevere]

Mas eu até fiz um que poderia ser livre... mas é em Delphi, como colar os dfms?

[Mussain!]

Que testes, cara-pálida?

Deixa pra lá....

[modo Severino Cavalcante]
“Eu me recolho a minha insignificância”....
[/modo Severino Cavalcante]

 

[ByteCode]

Tenho um aqui feito em Java onde usei Threads sincronizadas para simular uma conta corrente com saques e depósitos. As operações de saque e depósito só são interrompidas quando os métodos são rodados completamente, para não haver discrepâncias quanto ao saldo atual, como por exemplo alguém tentar sacar uma quantia que já não existe mais na conta.
Usei funções de espera (sleep) e randomica (random) para simularem tempo de processamento e aleatoriedade de quantia e de revezamento entre saques e depósitos.

Código: [Selecionar]

CLASSE CONTA CORRENTE

public class ContaCorrente {

private float saldo;

public synchronized void depositar(float deposito) {
try {
Thread.sleep((int)(Math.random()*300));
} catch (InterruptedException e) {
e.printStackTrace();
}
this.saldo += deposito;
System.out.println(Thread.currentThread().getName()+"\tdepositou: "+deposito+
"\tSaldo: "+this.saldo);
}

public synchronized void sacar(float valorSaque){
if(this.saldo >= valorSaque){
try {
Thread.sleep((int) (Math.random()*300));
} catch (InterruptedException e) {
e.printStackTrace();
}
this.saldo -= valorSaque;
System.out.println(Thread.currentThread().getName()+"\tSacou: "+valorSaque+
"\tSaldo: "+this.saldo);
}
}

}


CLASSE CORRENTISTA

public class Correntista extends Thread {

private ContaCorrente conta;
private int contador;

public Correntista(String nome, ContaCorrente conta){
super(nome);
this.conta = conta;
this.contador = 0;
}

public void run(){
int operacao;
while(contador<30){
operacao = (int) (Math.random()*3);
if (operacao == 2)
conta.depositar((int) (Math.random()*1000));
else
conta.sacar((int)(Math.random()*1000));

contador++;
}
}

}


MÉTODO MAIN

public class Aplicacao {

public static void main(String[] args) {

ContaCorrente conta = new ContaCorrente();

Correntista joao = new Correntista("Joao", conta);
Correntista maria = new Correntista("Maria", conta);

joao.start();
maria.start();

}

}