Вы находитесь на странице: 1из 73

Maratona de Programao

Dicas

Sumrio
Programas Bsicos................................................................................................................................................................ 4 Cabealhos include............................................................................................................................................................... 5 Funes de Biblioteca ...................................................................................................................................................... 6 Estruturas de Dados ......................................................................................................................................................... 8 Vetores ............................................................................................................................................................................. 8 Mapas ............................................................................................................................................................................... 9 Pilha ................................................................................................................................................................................ 10 Fila .................................................................................................................................................................................. 10 Strings ............................................................................................................................................................................. 10 Funes .............................................................................................................................................................................. 21 Mximo Divisor Comum ............................................................................................................................................. 21 Teste de Primalidade .................................................................................................................................................. 21 Clculo da distncia entre 2 pontos no plano cartesiano .......................................................................................... 22 Determinar se 2 segmentos de retas se cruzam ........................................................................................................ 22 Tamanho de um lado do tringulo ............................................................................................................................. 24 rea do Crculo ........................................................................................................................................................... 24 Progresso Aritmtica ................................................................................................................................................ 25 PROGRAMAS ...................................................................................................................................................................... 26 programa que l 2 nmeros a e b e escreve a soma dos mesmos. ........................................................................... 26 WERTYU...................................................................................................................................................................... 26 Primo .......................................................................................................................................................................... 27 Primos Entre 2 Nmeros ............................................................................................................................................ 28 Movimentos da dama ................................................................................................................................................ 29 Cilindros no Elevador ................................................................................................................................................. 30 FatDiv escreve o fatorial se o nmero for impar ou a quantidade de divisores e os divisores se for par (Usando Fila) ............................................................................................................................................................................. 32 Criptografia................................................................................................................................................................. 33 Palndromo ................................................................................................................................................................. 34 Reviso de Contrato ................................................................................................................................................... 35 Referncia Bibliogrfica.............................................................................................................................................. 36 Somatrio ................................................................................................................................................................... 37 Prximos Nmeros Primos ......................................................................................................................................... 38 Vai Um ........................................................................................................................................................................ 39 Nmero invertido de Turing ....................................................................................................................................... 40 Avio ........................................................................................................................................................................... 41 Telefone...................................................................................................................................................................... 43

3 Dicionrio ................................................................................................................................................................... 44 Donativos ................................................................................................................................................................... 46 Nmeros Romanos ..................................................................................................................................................... 49 Retngulos .................................................................................................................................................................. 50 Determinar se a Soma das linhas e colunas so iguais .............................................................................................. 51 Dentista ...................................................................................................................................................................... 52 Ciclismo (uso de vector ordenado com estrutura)..................................................................................................... 54 rvore de extenso mnima ....................................................................................................................................... 55 Caminho mais curto ................................................................................................................................................... 57 Ver se todas cidades se conectam ............................................................................................................................. 61 Ver a maior distncia percorrida entre 2 cidades atravs do caminho mais curto ................................................... 62 O Guia Turstico .......................................................................................................................................................... 63 Caminho mais curto simples ...................................................................................................................................... 65 Rota mais curta com nomes de cidades e uso de pilha ............................................................................................. 68 Rota mais rpida com nomes de cidades e uso de pilha ........................................................................................... 71 LCD Display ................................................................................................................................................................. 73

Programas Bsicos
#include <iostream> using namespace std; int main() { int a, b; while (cin >> a >> b) { if (a==0 && b==0) break; cout << a << b << << endl; } return(0); } #include <iostream> using namespace std; #define MaxInt 2147483647; #define MinInt -2147483648; int main() { int a, maior, x; while (cin >> a) { if (a==0) break; maior = MinInt; for(int i=0;i<a;i++) { cin >> x; maior= max(maior,x); } cout << "maior " << maior << endl; } return(0); } #include <iostream> #include <iomanip> #include <cmath> using namespace std; int main() { int a; double r; while (cin >> a) { if (a<=0) break; r = sqrt(a); cout << setprecision(-1) << r << endl; cout << fixed << setprecision(2) << r << endl; } return(0); }

Cabealhos include
As bibliotecas da linguagem C++ fornecem um conjunto bsico de operaes matemticas, manipulao de cadeias de caracteres, converso de tipos de dados e entrada e sada de arquivo e da tela. Destacam-se: Containers Arquivo de Cabealho <bitset> <deque> <list> <map> <queue> <set> <stack> <vector> Arquivo de Cabealho <algorithm> <functional> <iterator> <locale> Algoritmos genricos. Funes-objeto. Declarao de iterator. Manipulao de diversas convenes culturais do utilizador, como a representao de nmeros, moeda e datas, para efeitos de internacionalizao. Funes para o gerenciamento de memria. Especializao de <exception>, fornece relatrios sobre excees. Operaes com pares de elementos (comparao e construo). Cadeia de caracteres Arquivo de Cabealho <string> <fstream> <ios> <iostream> <iosfwd> <iomanip> <istream> <ostream> <sstream> Descrio Manipulao de cadeia de caracteres streams e entrada/sada. Manipulao de fluxo de dados em arquivo. Declarao mais geral de fluxo de dados. Manipulao de fluxo de dados padro do sistema (entrada padro, sada padro e sada de erros padro). Declarao dos fluxos de dados presentes na linguagem. Manipulao da apresentao e do processamento de fluxos de dados. Manipulao de entrada de dados. Manipulao de sada de dados. Manipulao de fluxo de dados em cadeias de caracteres. Manipulao de lista duplamente ligada. Manipulao de lista simplesmente ligada. Manipulao de conjunto associativo ordenado (associao: chave valor) Manipulao de lista FIFO. Manipulao de conjunto. Manipulao de lista LIFO. Manipulao de arranjo. Uso geral Descrio Descrio Manipulao de arranjo de bits, algo parecido com vector<bool>.

<memory> <stdexcept> <utility>

6 <streambuf> <complex> <numeric> <valarray> Arquivo de Cabealho <exception> <limits> <new> <typeinfo> Manipulao de exceo. Manipulao de limites numricos dos tipos embutidos na linguagem. Manipulao de alocao e desalocao de memria. Auxlio para o RTTI (Run-Time Type Information) do C++. Manipulao de buffers de fluxo de dados. Manipulao de nmero complexo. Operaes com conjuntos numricos. Arranjo de valores mutveis. Cadeia de caracteres Descrio

Funes de Biblioteca
A linguagem C++ acompanhada por inmeras funes de biblioteca que executam vrias operaes e clculos comumente usados. Funes Matemticas Funo Arquivo de cabealho int abs (int) Valor absoluto para int. cstdlib long labs (long) Valor absoluto para long. cstdlib double fabs (double) Valor absoluto double. cstdlib double sqrt (double) Raiz quadrada cmath double pow (double, double) Fornece o primeiro argumento elevado potncia do segundo cmath argumento double exp (double) Fornece o argumento elevado a potncia cmath double log (double) Logaritmo natural cmath double log10 (double) Logaritmo na base 10 cmath double ceil (double) Fornece o menor inteiro que maior ou igual ao seu argumento cmath double floor (double) Fornece o maior inteiro que menor ou igual ao seu argumento cmath Funes de Caracteres Funo Finalidade Arquivo de cabealho boll isalpha (char) Retorna true se seu argumento for uma letra maiscula ou minscula. cctype Caso contrrio retorna false. boll isdigit (char) Retorna true se seu argumento for um dgito. Caso contrrio retorna cctype false. boll isalnum (char) Retorna true se seu argumento satisfaz isalpha ou isdigit. Caso contrrio cctype retorna false. boll ispunct (char) Retorna true se seu argumento for um caractere imprimvel que no cctype satisfaa isalmun e no seja um espao em branco. Caso contrrio retorna false. boll isspace (char) Retorna true se seu argumento for qualquer tipo de caractere de espao cctype em branco (espao em branco, tabulao ou a linha). Caso contrrio retorna false. Finalidade

7 boll iscntrl (char) boll islower (char) boll isupper (char) int tolower (char) int toupper (char) Retorna true se seu argumento for um caractere de controle. Caso contrrio retorna false. Retorna true se seu argumento for uma letra minscula. Caso contrrio retorna false. Retorna true se seu argumento for uma letra maiscula. Caso contrrio retorna false. Retorna a verso minscula de seu argumento. Se no houver verses minsculas, retorna o argumento inalterado. Retorna a verso maiscula de seu argumento. Se no houver verses maisculas, retorna o argumento inalterado. Funes String Finalidade cctype cctype cctype cctype cctype

Funo

Arquivo de cabealho int atoi (string) Converte uma string em um nmero inteiro. cstdlib long atol (string) Converte uma string em um nmero inteiro cstdlib longo. double atof (string) Converte uma string em um nmero double. cstdlib strcat (varivel_string, expresso_string) Anexa o valor da expresso_string ao final da cstring string varivel_string. strcmp (expresso_string1, Retorna true se os valores das duas expresses cstring expresso_string2) forem diferentes. Caso contrrio retorna false. strcpy (varivel_string, expresso_string) Altera o valor da varivel_string para o valor da cstring expresso_string. strlen (varivel_string) Retorna o comprimento da varivel_string. cstdlib strncat (varivel_string, expresso_string, Semelhante ao strncat, a no ser pelo fato de que cstring valor_limite) no mximo valor_limite caracteres so anexados. strncmp (expresso_string1, Semelhante ao strncmp, a no ser pelo fato de cstring expresso_string2, valor_limite) que no mximo valor_limite caracteres so comparados. strncpy (varivel_string, expresso_string, Semelhante ao strncpy, a no ser pelo fato de cstring valor_limite) que no mximo valor_limite caracteres so copiados. strstr (expresso_string, padro) Fornece um ponteiro para a primeira ocorrncia cstring da string padro em expresso_string. Retorna NULL se padro no for encontrado. strchr (expresso_string, caractere) Fornece um ponteiro para a primeira ocorrncia cstring de caractere em expresso_string. Retorna NULL se caractere no for encontrado. strrchr (expresso_string, caractere) Fornece um ponteiro para a ltima ocorrncia de cstring caractere em expresso_string. Retorna NULL se caractere no for encontrado. Funes Trigonomtricas Funo Finalidade Arquivo de cabealho double acos (double) Arco cosseno cmath double asin (double) Arco seno cmath double atam (double) Arco tangente cmath double cos (double) Cosseno cmath

8 double cosh (double) double sin (double) double sinh (double) double tan (double) double tanh (double) Funo int rand () Cosseno hiperblico Seno Seno hiperblico Tangente Tangente hiperblica Funes geradoras de nmeros aleatrios Finalidade Fornece um nmero inteiro aleatrio, maior ou igual a zero e menor que RAND_MAX (constante inteira predefinida em cstdlib). Reinicializa o gerador de nmeros aleatrios. cmath cmath cmath cmath cmath Arquivo de cabealho cstdlib

void srand (unsigned int)

cstdlib

Estruturas de Dados
Vetores
Em geral sabemos antecipadamente qual ser o nmero mximo de elementos no vetor. Ento, em C ou C++, basta fazer:
TIPO vetor[MAX_TAM];

Onde MAX_TAM uma constante que indica o nmero mximo de elementos que o vetor vai guardar. Se no soubermos o tamanho do vetor em tempo de compilao e o compilador utilizado for o gcc, podemos fazer:
TIPO vetor[n];

Onde n uma varivel que indica quantos elementos deve caber no vetor. O gcc gera cdigo para a alocao dinmica automaticamente. Um caso difcil de acontecer, mas que pode aparecer, quando temos que guardar dados em vetores antes de saber qual ser seu tamanho final. Isso pode acontecer, por exemplo, em um problema de grafos em que temos que usar listas de adjacncia e o grafo descrito por suas arestas. Nesse caso podemos utilizar o tipo vector de C++. Declaramos ele assim:
#include<vector> using namespace std; vector<TIPO> vetor;

Para adicionar um elemento elem ao seu fim:


vetor.push_back(elem);

Para saber seu tamanho:

9
vetor.size()

Podemos ordenar vetores em C utilizando a funo qsort da stdlib.h. Para isso necessria uma funo de comparao que recebe dois elementos e retorna um valor negativo, 0 ou positivo se o primeiro elemento menor, igual ou maior que o segundo, respectivamente. Para a ordenao de um vetor de inteiros, usamos:
#include<stdlib.h> ... int comp(void *a, void *b) { return *((int*)a)-*((int*)b); } int main() { int vetor[MAX_TAM]; ... qsort(vetor, n, sizeof(*vetor), comp); ... }

Onde n o nmero de elementos no vetor. Mas para qu fazer isso se temos C++? muito mais simples:
#include<algorithm> using namespace std; int main() { int vetor[MAX_TAM]; ... sort(&vetor[0],&vetor[n]); ... }

Para vector podemos utilizar tambm sort(vetor.begin(),vetor.end()).


#include <vector> vector<int> vetor; vetor.empty();//retorna true se estiver vazio vetor.size();//retorna o tamanho do vetor vetor[0] vetor.front(); //retorna o primeiro elemento do vetor vetor.back(); //retorna o ultimo elemento do vetor vetor.push_back (eu);//insere um novo elemento ao final do vetor vetor.pop_back(); //remove o ultimo elemento vetor.clear();//limpa o vetor

Mapas
Mapas so estruturas pouco utilizadas em competies, mas s vezes so necessrias. Quando eles aparecem normalmente so para mapear strings em inteiros.

10

A linguagem C no oferece um suporte especial para mapas. Em geral pode-se criar dois vetores. Um que guarda as chaves e outro que guarda os valores. Faz-se uma busca seqencial no vetor das chaves para encontrar o ndice e depois obtm-se o valor no outro vetor. O mais prtico usar C++:
#include <map> #include <string> using namespace std; ... map<string,int> mapa; mapa["teste"] = 10; string key = "teste"; int val = mapa[s]; // val recebe 10

bom lembrar que esse mapa implementado utilizando rvores, o que deixa a complexidade de consulta e alterao como O(log.n).

Pilha
#include <stack> stack <string> pilha; Mtodos: pilha.empty();//retorna true se a pilha estiver vazia pilha.pop();//remove o topo da pilha pilha.push(eu);//insere o argumento no topo da pilha pilha.size();//retorna o tamanho da pilha

Fila
#include <queue> queue <string> fila; Mtodos: fila.push("EU"); //adiciona no final da fila o argumento fila.empty();//retorna true se a fila estiver vazia fila.front();//retorna o primeiro elemento da fila fila.pop();//remove o primeiro elemento da fila

Strings
Cabealho:
C: C++ #include<strings.h> #include<string>

Declarao:
C: C++: char s[MAX_TAM]; string s;

Consulta:

11
C: C++: s[i] s[i];

Alterao:
C: C++: Java: s[i] = c; s[i] = c; s.setCharAt(i,c); (somente para StringBuffer)

Cpia:
C: C++: strcpy(dest, orig); dest = orig;

Concatenao:
C: C++: strcpy(dest,s1); strcat(dest, s2); dest = s1+s2;

Tamanho:
C: C++: strlen(s); s.size();

As strings em C++ possuem o mtodo c_str() que retorna um ponteiro para a string no formato de C (vetor de char terminado em '\0'). As strings em C++ e Java ainda possuem mtodos para encontrar uma string em outra, extrair substrings, inserir strings no meio de outras, inverter a cadeia, alm de outros.
Iterators: Iterators so as estruturas usadas para percorrer e/ou acessar os elementos contidos em um continer de maneira unificada. Estas estruturas escondem os detalhes da implementao. Dessa maneira, alm da programao ser facilitada fica menos propensa a erros. Um iterator deve permitir percorrer sobre o continer (++i, --i) e acesso (*i). So quatros os iterators: a) begin Retorna um iterator referindo-se ao primeiro caractere na string. b) end Retorna um iterator referindo-se ao elemento seguinte aps o ltimo caractere na string. Exemplo:
#include <iostream> #include <string> using namespace std; main () {

12
string str ("Teste de string"); string::iterator it; for ( it=str.begin() ; it < str.end() ; it++ ) cout << *it; cout << "\n"; }

c) rbegin
Retorna um iterator inverso, ou seja, o ltimo caractere na seqncia.

d) rend
Retorna um iterator inverso, ou seja, o primeiro caractere na seqncia. Exemplo: #include <iostream> #include <string> using namespace std; main () { string str ("Maratona de programao"); string::reverse_iterator rit; for ( rit=str.rbegin() ; rit < str.rend(); rit++ ) cout << *rit; cout << "\n"; }

Capacidade da string: a) size Retorna a quantidade de caracteres de uma string. Exemplo:


#include <iostream> #include <string> using namespace std; main () { string str ("Maratona de Programao"); cout << "A quantidade de caracteres da string : " << str.size() << "\n"; }

b) length Retorna a quantidade de caracteres de uma string. Igual a size. Exemplo:


#include <iostream> #include <string> using namespace std; main () { string str ("Maratona de Programao"); cout << "A quantidade de caracteres da string : " << str.length() << "\n"; }

c) max_size

13 Retorna o nmero mximo de caracteres que o objeto string pode conter. Exemplo:
#include <iostream> #include <string> using namespace std; main () { string str ("Manipulao de Strings"); cout << "max_size: " << str.max_size() << "\n"; }

d) resize Redimensiona o contedo da string de n caracteres. Se n for menor que o comprimento atual da seqncia, o contedo reduzido aos seus primeiros n caracteres, sendo o resto descartado. Se n for maior do que o comprimento atual da seqncia, o contedo ampliado para atingir um tamanho de n caracteres. Exemplo:
#include <iostream> #include <string> using namespace std; main () { size_t sz; string str ("Teste de string"); cout << str << endl; sz=str.size(); str.resize (sz+2,'!!'); //Resultado: Teste de string cout << str << endl << "\n"; str.resize (5); cout << str << endl << "\n"; //Resultado: Teste }

e) clear O contedo da string definido como uma seqncia vazia, apagando qualquer contedo anterior e deixando o seu tamanho em zero caractere. Exemplo:
#include <iostream> #include <string> using namespace std; main () { string str ("Contedo da string"); cout << str << "\n"; str.clear(); cout << "Contedo aps clear(): " << str << "\n"; }

f)

empty Retorna se a string est vazia, ou seja, se seu tamanho zero. Esta funo no modifica o contedo da string. Exemplo:
#include <iostream>

14
#include <string> using namespace std; int main () { string str ("Texto da String"); if (!str.empty()) cout << "A string no est vazia.\n"; else cout << "A string est vazia\n"; }

Elementos de Acesso: a) Operador [] Retorna o valor da string na posio informada. Exemplo:


#include <iostream> #include <string> using namespace std; main () { string str ("Teste de String"); cout << "Primeiro caractere: " << str[0] << "\n"; //Resultado: T cout << "Segundo caractere: " << str[1] << "\n"; //Resultado: e }

b) at Retorna o valor da string na posio informada. Esta funo se comporta como o operador [], exceto que a tambm executa uma verificao do intervalo, gerando uma exceo no caso da posio no existir na cadeia. Exemplo:
#include <iostream> #include <string> using namespace std; main () { string str ("Teste de String"); cout << "Primeiro caractere: " << str.at(0) << "\n"; //Resultado: T cout << "Segundo caractere: " << str.at(1) << "\n"; //Resultado: e }

Modificadores: a) Operador += Une o contedo existente a uma nova seqncia. Exemplo:


#include <iostream> #include <string> using namespace std; main () { string nome ("Fulano"); string sobrenome ("Tal"); nome += " de "; nome += sobrenome;

15
nome += "\n"; //Resultado: Fulano de Tal cout << nome; system("pause"); }

b) append O contedo da string atual estendido pela adio de uma seqncia de caracteres. Sintaxe: str.append(string, posio_inicial, numero_de_caracteres_a_incluir); Exemplo:
#include <iostream> #include <string> using namespace std; main () { string str; string str2="Maratona "; string str3="de Preparao"; str.append(str2); //Resultado: str = "Maratona " str.append(str3,0,3); //"de " str.append("Programao", 11); //Resultado: "Programao" str.append(1,'.'); //Resultado: "." cout << str << "\n"; system("pause"); }

c) push_back Acrescenta um carter nico para o contedo da string, aumentando seu tamanho por um. Exemplo:
#include <iostream> #include <string> using namespace std; main () { string str ("Maratona"); cout << "Antes: " << str << "\n"; str.push_back('x'); cout << "Depois: " << str << "\n"; //Resultado: Maratonax system("pause"); }

d) insert Insere uma string em outra a partir de uma determinada posio. Sintaxe: Sintaxe: str.insert(posicao, string_inserir, pos_inicial_str, pos_final_str); Exemplo:
#include <iostream.h> using namespace std; main () { string str1="nossa"; string str2="uri";

16
str1.insert(2,str2); //Resultado = nourissa str1.insert(2,"123456789",3,4); //Resultado = no4567urissa cout << str1 << "\n"; system("pause"); }

e) erase Apaga uma cadeia de caracteres a partir de uma posio inicial por uma determinada quantidade de caracteres. Sintaxe: Sintaxe: str.insert(posicao_inicial, quantidade_caracteres); Exemplo:
#include <iostream.h> using namespace std; main () { string str1="nossa"; str1.erase(3,1); //nosa cout << str1; system("pause"); }

f)

replace Substitui uma string por outra. Sintaxe: str.replace(posio_inicial, quantidade_posicoes, str_substituir); Exemplo:
#include <string> #include <iostream> using namespace std; main() { string str = "Gosto de Java"; // vamos substituir Java por C str.replace(9, 4, "C"); cout << str << "\n\n"; }

Operadores sobre Strings a) copy Copia parte de uma string. Sintaxe: str.copy(string_destino, quantidade_caracteres, posio_inicial); Exemplo:
#include <iostream> #include <string> using namespace std; main () { string str1 ("Testando strings...."); char str2[10];

17
str1.copy(str2, 7, 9); cout << str2 << "\n"; //Resultado: strings system("pause"); }

b) find Localiza uma string dentro de outra string. Exemplo:


#include <string> #include <iostream> using namespace std; main() { string frase = "Maratona de Programao em C"; int pos = frase.find("Programao"); if(pos == string::npos) cout << "A substring nao foi encontrada.\n\n"; else cout << "A substring foi encontrada" << " na posicao " << pos << ".\n\n"; system("pause"); // pausa o programa }

c) rfind Localiza a ltima ocorrncia de uma string dentro de outra string. Exemplo:
#include <iostream> #include <string> using namespace std; main () { string str ("Teste de string teste para maratona"); string key ("teste"); int found; found=str.rfind(key); cout << found << "\n"; //Resultado: 16 system("pause"); }

d) substr Retorna uma seqncia de caracteres que comea em uma determinada posio e tem um comprimento de n caracteres. Sintaxe: resultado = str.substr(posicao_inicial, quantidade_caracteres); Exemplo:
#include <iostream> #include <string> using namespace std; main () { string str="Ns estamos trabalhando com strings"; string str2; str2 = str.substr (12,11); //Resultado: trabalhando

18
cout << str2 << "\n"; system("pause"); }

e) compare Compara duas strings. Retorna 0 se as strings comparadas so iguais, caso contrrio um nmero diferente de 0 retornado. Sintaxe: str.compare(posicao_inicial, quantidade, string); Exemplo:
#include <iostream> #include <string> using namespace std; main () { string str1 ("URI-FW"); string str2 ("URI"); if (str1.compare(str2) != 0) cout << str1 << " NO IGUAL A " << str2 << "\n"; if (str1.compare(0,3,"URI") == 0) cout << "So iguais\n"; system("pause"); }

Converses: a) toupper Converte o caractere para maisculo. Exemplo:


#include <iostream.h> main() { char tecla; cout << "Pressione qualquer tecla para converter em maisculo: "; cin >> tecla; cout << "O valor da tecla em maisculo : " << (char) toupper(tecla) << "\n"; system("pause"); } Para realizar a converso para minsculo basta alterar a funo toupper para tolower.

b) transform Converte todos os caracteres da cadeia para maisculo. Exemplo:


#include <iostream> #include <string> using namespace std; main() {

19
string str; cout << "Informe qualquer texto para converter em maisculo: "; cin >> str; transform(str.begin(), str.end(), str.begin(), ::toupper); cout << "O valor do texto em maisculo : " << str << "\n"; system("pause"); }

Para realizar a converso para minsculo basta alterar o parmetro ::toupper para ::tolower. c) atoi Converte uma string para um valor inteiro. A parte fracionria ser desconsiderada. Exemplo:
#include <iostream.h> main() { int valor; char caractere[] = "123455.233"; valor = atoi (caractere); cout << valor; cout << "\n"; system("pause"); }

d) atol Converte uma string para um valor inteiro longo. A parte fracionria ser desconsiderada. Exemplo:
#include <iostream.h> main() { long int valor; char caractere[] = "123455.233"; valor = atol (caractere); cout << valor; cout << "\n"; system("pause"); }

e) atof Converte uma string para um valor real (float). Exemplo:


#include <iostream.h> main() { double valor; char caractere[] = "123455.233"; valor = atof (caractere); cout << valor << "\n"; system("pause"); }

20

f)

strtod

Converte uma string para um valor numrico real. A varivel erro receber um valor diferente de null se algum erro ocorrer na converso. A varivel erro dever ser do tipo char. Exemplo:
#include <iostream.h> main() { char caracteres[] = "365.25 abc"; char * erro; double valor; valor = strtod(caracteres, &erro); cout << valor << "\n"; cout << erro << "\n"; system("pause"); }

g) strtol Converte a cadeia str para um valor numrico inteiro. A parte fracionria ser desprezada. A varivel erro receber um valor diferente de null se algum erro ocorrer na converso. A varivel erro dever ser do tipo char. O parmetro base significa em qual base o valor ser convertido (base = 10 decimal, base = 16 hexadecimal). Sintaxe: strtol(str, &erro, base); Exemplo:
#include <iostream.h> main() { char caracteres[] = "365.25 abc"; char * erro; long int valor; valor = strtol(caracteres, &erro, 10); cout << valor << "\n"; cout << erro << "\n"; system("pause"); }

21

Funes
Mximo Divisor Comum
Utiliza o algoritmo de Euclides. Entrada:

Inteiros a e b.

Sada:

Maior inteiro que divide a e b.

int mdc(int a, int b) { if(a<0) a = -a; if(b<0) b = -b; if(b == 0) return a; else return mdc(b, a%b); }

Teste de Primalidade
Entrada:

Inteiro n.

Sada:

Valor booleano que indica se n primo ou no.

Global:
int ehPrimo(int n) { if(n==2) return 1; if(n<=1 || n%2 == 0) return 0; for(int i=3; i*i<=n; i+=2) if(n%i == 0) return 0; return 1; }

22

Clculo da distncia entre 2 pontos no plano cartesiano


#include <cmath> double dist(int x1, int y1, int x2, int y2) { double d; d = sqrt( pow((double)x2-x1,2)+pow( (double)y2-y1,2)); return(d); }

Determinar se 2 segmentos de retas se cruzam


struct Ponto { int x; int y; }; int intersecReta(Ponto a, Ponto b, Ponto c, Ponto d, double &x, double &y) { double s, t; /* The two parameters of the parametric eqns. */ double num, denom; /* Numerator and denoninator of equations. */ char code; denom = a.x * (double)( d.y - c.y ) + b.x * (double)( c.y - d.y ) + d.x * (double)( b.y - a.y ) + c.x * (double)( a.y - b.y ); /* If denom is zero, then segments are parallel: handle separately. */ if (denom == 0.0) return 0; num = a.x * (double)( d.y - c.y ) + c.x d.x * (double)( c.y - a.y ); if ( (num == 0.0) || (num == denom) ) code s = num / denom; num = -( a.x * (double)( c.y - b.y ) + b.x c.x * (double)( b.y - a.y ) ); if ( (num == 0.0) || (num == denom) ) code t = num / denom; if ( (0.0 < s) && (s < 1.0) && (0.0 < else if ( (0.0 > s) || (s > 1.0) || (0.0 > * (double)( a.y - d.y ) + = 'v'; * (double)( a.y - c.y ) + = 'v'; t) && (t < 1.0) ) code = '1'; t) || (t > 1.0) ) code = '0';

x = a.x + s * ( b.x - a.x ); y = a.y + s * ( b.y - a.y ); if(x<min(a.x,b.x) || x>max(a.x,b.x) || x<min(c.x,d.x) || x>max(c.x,d.x)) return 0; if(y<min(a.y,b.y) || y>max(a.y,b.y) || y<min(c.y,d.y) || y>max(c.y,d.y)) return 0; return 1; }

Exemplo:
#include <iostream> #include <cmath> using namespace std; /* /* /* /* /* /* /* ********************************************************************** */ */ Calcula a interseccao entre 2 retas (no plano "XY" Z = 0) */ */ k : ponto inicial da reta 1 */ l : ponto final da reta 1 */ m : ponto inicial da reta 2 */

23
/* /* /* /* /* /* n : ponto final da reta 2 */ */ s: valor do parmetro no ponto de interseo (sobre a reta KL) */ t: valor do parmetro no ponto de interseo (sobre a reta MN) */ */ ********************************************************************** */

struct Ponto { int x; int y; }; int intersecReta(Ponto a, Ponto b, Ponto c, Ponto d, double &x, double &y) { double s, t; /* The two parameters of the parametric eqns. */ double num, denom; /* Numerator and denoninator of equations. */ char code; denom = a.x b.x d.x c.x * * * * (double)( (double)( (double)( (double)( d.y c.y b.y a.y c.y d.y a.y b.y ) + ) + ) + );

/* If denom is zero, then segments are parallel: handle separately. */ if (denom == 0.0) return 0; num = a.x * (double)( d.y - c.y ) + c.x * (double)( a.y - d.y ) + d.x * (double)( c.y - a.y ); if ( (num == 0.0) || (num == denom) ) code = 'v'; s = num / denom; num = -( a.x * (double)( c.y - b.y ) + b.x * (double)( a.y - c.y ) + c.x * (double)( b.y - a.y ) ); if ( (num == 0.0) || (num == denom) ) code = 'v'; t = num / denom; if ( (0.0 < s) && (s < 1.0) && (0.0 < t) && (t < 1.0) ) code = '1'; else if ( (0.0 > s) || (s > 1.0) || (0.0 > t) || (t > 1.0) ) code = '0'; x = a.x + s * ( b.x - a.x ); y = a.y + s * ( b.y - a.y ); if(x<min(a.x,b.x) || x>max(a.x,b.x) || x<min(c.x,d.x) || x>max(c.x,d.x)) return 0; if(y<min(a.y,b.y) || y>max(a.y,b.y) || y<min(c.y,d.y) || y>max(c.y,d.y)) return 0; return 1; } double distPontos(Ponto a, Ponto b) { return sqrt(pow((double)a.x-b.x,2)+pow((double)a.y-b.y,2)); } Ponto pIni, pFim; Ponto oIni, oFim; int quant; int main() { double x, y;

24
double d1, d2; pIni.x=0; pIni.y=0; while (cin >> pFim.x >> pFim.y) { if (pFim.x==0 && pFim.y==0) break; cin >> oIni.x >> oIni.y >> oFim.x >> oFim.y ; if (intersecReta(pIni,pFim,oIni,oFim,x,y)) { d1=distPontos(pIni, oIni)+ distPontos(oIni, pFim); d2=distPontos(pIni, oFim)+ distPontos(oFim, pFim); cout << min(d1, d2) << endl; } else cout << distPontos(pIni, pFim) << endl; } }

Tamanho de um lado do tringulo


O tamanho de um lado do tringulo, com lado c sendo a hipotenusa:

c = sqrt ( a*a + b*b ); a = sqrt ( c*c b*b ); b = sqrt (c*c a*a );

rea do Crculo
#include <cmath> areacirc = raio * raio * M_PI ;

25

Progresso Aritmtica
A frmula do termo geral de uma progresso aritmtica expressa da seguinte forma:

an = a1 + (n 1 ) * r; // onde an= termo n, a1 o primeiro termo e r a razo. A soma dos primeiros termos de uma progresso aritmtica finita, a partir do primeiro, calculada pela seguinte frmula:

somapa = (n * (a1 + an)) /2; A soma dos termos entre e :

26

PROGRAMAS
programa que l 2 nmeros a e b e escreve a soma dos mesmos.
Exemplo arquivo entrada 10 5 38 20 30 #include <iostream> using namespace std; Exemplo arquivo sada 10 + 5 = 15 3 + 8 = 11 20 + 30 = 50

int main() { int a, b; while (cin >> a >> b) { cout << a << " + " << b << " = " << a+b << endl; } return(0); }

WERTYU
#include <iostream> #include <map> #include <string> using namespace std; map<char, char> m; string linha, resultado; main() { //Primeira Linha m['=']='-'; m['-']='0'; m['0']='9'; m['9']='8'; m['8']='7'; m['7']='6'; m['6']='5'; m['5']='4'; m['4']='3'; m['3']='2'; m['2']='1'; m['1']='`'; m['Q']='Q'; m['A']='A'; m['Z']='Z'; //Segunda Linha m['W']='Q'; m['E']='W'; m['R']='E'; m['T']='R'; m['Y']='T'; m['U']='Y'; m['I']='U'; m['O']='I'; m['P']='O'; m['[']='P'; m[']']='['; m['\\']=']'; //Valores padro //Terceira linha m['\'']=';'; m[';']='L'; m['L']='K'; m['K']='J'; m['J']='H'; m['H']='G'; m['G']='F'; m['F']='D'; m['D']='S'; m['S']='A'; //Quarta linha m['/']='.'; m['.']=','; m[',']='M'; m['M']='N'; m['N']='B'; m['B']='V'; m['V']='C'; m['C']='X'; m['X']='Z';

while( getline(cin, linha)) { // Enquanto no for fim de arquivo resultado.clear(); for(int i=0;i<linha.length();i++) { resultado.push_back(m[linha[i]]); } cout << resultado << endl; //Escreve o resultado no arquivo de sada } }

27

Primo
#include <iostream> using namespace std; bool primo(int x) { int i; if (x<2) return(false); if (x==2) return(true); if (x%2==0) return(false); for(i=3;i*i<=x;i=i+2) if (x%i==0) return(false); return(true); } int main() { int a; while(cin >> a) { if (primo(a)) cout << "primo" << endl; else cout << "nao primo" << endl; } return(0); }

28

Primos Entre 2 Nmeros


Fazer um programa que gere os nmeros primos entre 2 nmeros fornecidos, incluindo os mesmos, se forem primos. Entrada A entrada consiste de diversos casos de teste, cada um em uma linha. Cada linha contm dois inteiros A e B (0 <= A, A <=B), representando o intervalo de nmeros primos Sada Para cada caso de teste da entrada o seu programa deve imprimir uma linha contendo todos os nmeros primos do intervalo, separados por vrgula. Se no tiver nenhum nmero, deve ser escrita a palavra NENHUM. Exemplo de Entrada Exemplo de Sada 1 10 2, 3, 5, 7 10 20 11, 13, 17, 19 20 50 23, 29, 31, 37, 41, 43, 47 200 210 NENHUM 5 25 5, 7, 11, 13, 17, 19, 23
#include<iostream> #include<string> int eprimo(int x) { int i; if (x<2) return(0); if (x==2 || x==3) return(1); for(i=2;i*i<=x;i++) { if (x%i==0) return(0); } return(1); } using namespace std; int a, b, i, cont; int main() { while(cin >> a >> b) { cont=0; for (i=a;i<=b;i++) { if (eprimo(i)) { cont++; if (cont>1) cout << ", "; cout << i; } } if (cont==0) cout << "NENHUM"; cout << endl; } return 0; }

29

Movimentos da dama

30
//Movimentos da Dama #include<iostream> using namespace std; int x1,y1, x2, y2; int main() { while(cin >> x1 >> y1 >> x2 >> y2) { if (x1== 0 && x2==0 && y1==0 && y2==0) break; if (x1> 0 && x2>0 && y1>0 && y2 >0 && x1<= 8 && x2<=8 && y1<=8 && y2 <=8) { if (x1==x2 && y1==y2)cout << "0" << endl; else if (x1==x2 || y1==y2) cout << "1" << endl; else if (y1-x1==y2-x2 || y1+x1==y2+x2) cout << "1" << endl; else cout << "2" << endl; } } return 0; }

Cilindros no Elevador

31

#include<iostream> #include<math.h> using namespace std; int l1, l2, r1, r2, l1b, l2b; int main() { while(cin >> l1 >> l2 >> r1 >> r2) { if (l1== 0 && l2==0 && r1==0 && r2==0) break; if (l1> 0 && l2>0 && r1>0 && r2 >0 && l1<= 100 && l2<=100 && r1<=100 && r2 <=100) { if (r1*2>l1 || r1*2>l2 || r2*2>l1 || r2*2>l2) { cout << "N" << endl; } else { l1b=l1-r1-r2; l2b=l2-r1-r2; if ( sqrt(l1b*l1b+l2b*l2b)>=(r1+r2)) cout << "S" << endl; else cout << "N" << endl; } } } return 0; }

32

FatDiv escreve o fatorial se o nmero for impar ou a quantidade de divisores e os divisores se for par (Usando Fila)
#include <iostream> #include <queue> using namespace std; queue <int> fila; long int fat(int x) { if (x<=1) return(1); else return(x * fat(x-1)); } int divisores(int x) { int i, cont; cont=2; fila.push(1); for(i=2;i*2<=x;i++) { if(x%i==0) { fila.push(i); cont++; } } fila.push(x); return(cont); } int main() { int a, cont; while(cin >> a) { if (a%2==0) { cout << a <<" possui " << divisores(a) << " divisores: "; cont = 0; while(!fila.empty()) { if (cont>0) cout << ","; cout << fila.front(); fila.pop(); cont++; } } else cout << a << "!=" << fat(a); cout << endl; } return(0); }

33

Criptografia
Ns precisamos de uma criptografia extremamente simples que substitui as letras do alfabeto pela letra imediatamente seguinte e substituindo o Z pelo A. Os nmeros, espaos em branco e sinais de pontuao e caracteres acentuados devem permanecer na frase, da mesma forma que as maisculas e minsculas devem ser preservadas. Entrada A entrada contm vrios casos de teste, sendo que cada linha contm uma letra C para criptografar ou uma letra D para descriptografar a frase que vem na sequncia, separada por um espao em branco. Sada Para cada caso de teste, o seu programa deve escrever a frase criptografada ou descriptografada, de acordo com a letra inicial da entrada. Exemplo de Entrada C Uma imagem vale mais do que mil palavras, mas ocupa 3 mil vezes mais espao em disco. C O problema do computador o USB (Usurio Super Burro). D Qsphsbnbepsft tp gfssbnfoubt qbsb dpowfsufs dbgfob fn dejhp. D Ibsexbsf b qbsuf ef vn dpnqvubeps rvf wpd divub; Tpguxbsf b qbsuf rvf wpd yjohb. Exemplo de Sada Vnb jnbhfn wbmf nbjt ep rvf njm qbmbwsbt, nbt pdvqb 3 njm wfaft nbjt ftqbp fn ejtdp. P qspcmfnb ep dpnqvubeps p VTC (Vtvsjp Tvqfs Cvssp). Programadores so ferramentas para converter cafena em cdigo. Hardware a parte de um computador que voc chuta; Software a parte que voc xinga.
#include <iostream> #include <string> using namespace std; string s; char o; int cont; int main() { while (getline(cin, s)) { o=toupper(s[0]); s.erase(0,2); for(int i=0;i<s.length();i++) if (isalpha(s[i])) { if (o=='C') { if (s[i]=='Z') s[i]='A'; else if (s[i]=='z') s[i]='a'; else s[i]=s[i]+1; } if (o=='D') { if (s[i]=='A') s[i]='Z'; else if (s[i]=='a') s[i]='z'; else s[i]=s[i]-1; } } cout << s << endl; } return(0); }

34

Palndromo
Um palndromo uma palavra, frase ou qualquer outra sequncia de unidades que tenha a propriedade de poder ser lida tanto da direita para a esquerda como da esquerda para a direita. Num palndromo, normalmente so desconsideradosos sinais ortogrficos (diacrticos ou de pontuao), assim como o espaos entre palavras. Entrada A entrada contm vrios casos de teste, sendo que cada linha contm uma frase que deve ser testada para verificar se palndromo ou no. Como os caracteres acentuados so diferentes no Windows e no Linux, nestas frases de teste nenhum caractere acentuado, contendo apenas os espaos em branco entre as palavras e os caracteres de pontuao. Sada Para cada caso de teste, o seu programa deve imprimir uma nica linha, contendo uma nica palavra: PALINDROMO, se a frase for um palndromo ou NAO, se a frase no um palndromo. Exemplo de Entrada O caso da droga da gorda do saco. A mala nada na lama. Cada macaco no seu galho. Exemplo de Sada PALINDROMO PALINDROMO NAO
#include #include #include #include <iostream> <string> <ctype.h> <stdio.h>

using namespace std; string s,s2; int cont; int main() { while (getline(cin, s)) { s2=""; for(int i=0;i<s.length();i++) if (isalpha(s[i])) s2=s2+(char)toupper(s[i]); cont=0; for(int i=0;i<s2.length()/2;i++) if (s2[i]!=s2[s2.length()-i-1])cont++; if (cont==0) cout << "PALINDROMO" << endl; else cout << "NAO" << endl; } return(0); }

35

Reviso de Contrato
Durante anos, todos os contratos foram datilografados em uma velha mquina de datilografia. Recentemente Sr. Miranda, um dos contadores da ACM, percebeu que a maquina apresentava falha em um, e apenas um, dos dgitos numericos.

Entrada
A entrada consiste de diversos casos de teste, cada um em uma linha. Cada linha contm dois inteiros D e N (1 D 9, 1 N < 10100), representando, respectivamente, o ddigito que esta apresentando problema na maquina e o numero que foi negociado originalmente no contrato (que podem ser grande, pois Modernolandia tem sido acometida por hiperinflao nas ultimas decadas). O ultimo caso de teste seguido por uma linha que contm apenas dois zeros separados por espaos em branco.

Sada
Para cada caso de teste da entrada o seu programa deve imprimir uma linha contendo um unico inteiro V , o valor numrico representado de fato no contrato. Exemplo de entrada 5 5000000 3 123456 9 23454324543423 9 99999999991999999 7 777 00 Exemplo de sada 0 12456 23454324543423 1 0

#include<iostream> #include<string> using namespace std; string c, s; int main() { while(cin >> c >> s) { if (c.compare("0")==0 && s.compare("0")==0) break; while(s.find(c) != string::npos) s.erase(s.find(c),1); while(s[0]=='0') s.erase(0,1); if (s.empty()) s="0"; cout << s << endl; } return 0; }

36

Referncia Bibliogrfica
As normas da ABNT determinam que as referncias bibliogrficas sejam escritas da seguinte maneira: Sobrenome, Nome do Autor abreviado Neste formato, na abreviao so tambm desconsideradas as palavras de, da, dos e das. Entrada A entrada contm vrios casos de teste, sendo que cada linha contm um nome que deve ser transformado na forma abreviada de referncias bibliogrficas. Sada Para cada caso de teste, o seu programa deve imprimir uma nica linha, contendo o nome no formato de acordo com as normas da ABNT. Exemplo de Entrada Pedro de Almeida Barros Evandro Preuss Dbora Regina Mattos de Oliveira Exemplo de Sada Barros, P. A. Preuss, E. Oliveira, D. R. M.
#include #include #include #include <iostream> <string> <ctype.h> <stdio.h>

using namespace std; string s,s2; int cont; int main() { while (getline(cin, s)) { s2=""; while (s.find(' ') != string::npos) { if (s[0]!='d') s2=s2+" "+s[0]+"."; s.erase(0, s.find(' ')+1); } s=s+","+s2; cout << s << endl ; } return(0); }

37

Somatrio
O problema do somatrio de nmeros consecutivos extremamente simples, porm nem sempre se consegue fazer a soma desses nmeros em tempo hbil. Para auxiliar nessa tarefa, foi permitido que se usasse o computador e fosse desenvolvido um programa que calcula a soma desses nmeros. Entrada A entrada contm vrios casos de teste. Cada caso de testes composto por uma linha com 2 nmeros inteiros A e B sendo 0 <= A, B <= 1000000000. A entrada termina com o final do arquivo. Sada A sada a soma dos nmeros inteiros entre A e B, para cada caso de teste Exemplo de Entrada 0 100 1 100 1 101 100 200 101 200 Exemplo de Sada 5050 5050 5151 15150 15050

#include<iostream> using namespace std; long long i, a, b, soma, nt; int main() { while(cin >> a >> b) { nt= b-a+1; soma = (nt * (a + b)) /2; cout << soma << endl; } return 0; }

38

Prximos Nmeros Primos


Fazer um programa que gere os prximos n nmeros primos a partir do nmero fornecido, incluindo o mesmo, se for primo. Entrada A entrada consiste de diversos casos de teste, cada um em uma linha. Cada linha contm dois inteiros A e B (0 <= A <= 100000000, 0 < B <= 50). A representa o nmero inicial e B representa a quantidade de nmeros primos que devem ser mostrados, a partir de A. Sada Para cada caso de teste da entrada o seu programa deve imprimir uma linha contendo os n nmeros primos a partir de A. Exemplo de Entrada 07 15 10 3 30 9 1000 5
#include<iostream> #include <cmath> using namespace std; long long i, a, b, cont; bool is_prime(int n) { if (n < 0) return is_prime(-n); if (n < 5 || n % 2 == 0 || n % 3 == 0) return (n == 2 || n == 3); int maxP = (int)(sqrt(n) + 2); for (int p = 5; p < maxP; p += 6) if (n % p == 0 || n % (p+2) == 0) return false; return true; } int main() { while(cin >> a >> b) { do { if (is_prime(a)) { cout << a; b--; if (b>0) cout << " "; } a++; } while(b>0); cout << endl; } return 0; }

Exemplo de Sada 2 3 5 7 11 13 17 2 3 5 7 11 11 13 17 31 37 41 43 47 53 59 61 67 1009 1013 1019 1021 1031

39

Vai Um
Fazer um programa que conta quantas operaes de "vai-um" ocorrem nos clculos

Exemplo de Entrada 123 456 555 555 123 594 00


#include<iostream> using namespace std; int a,b; int i,j,k,carry,carries;

Exemplo de Sada No carry operation. 3 carry operations. 1 carry operation.

int main(){ while (cin >> a >> b ){ if (a == 0 && b == 0) return(0); carries = carry = 0; for (i=9;i>=0;i--) { carry = (int)((a%10+b%10+carry)/10) ; carries = carries + carry; a = a/10; b = b/10; } if (carries == 0) cout << "No carry operation.\n"; else if (carries == 1) cout << "1 carry operation.\n"; else cout << carries << " carry operations.\n"; } return(0); }

40

Nmero invertido de Turing


Verificar se as somas esto corretas, levando em conta que os nmeros esto invertidos. Entrada Exemplo de Entrada 73+42=16 5+8=13 10+20=30 0001000+000200=00030 1234+5=1239
#include <string> using namespace std; string a,b,s; string e; int converte(string s) { int i, x, m; x=0; m=1; for(i=0;i<s.length();i++) { x=x+((s[i]-48)*m); m=m*10; } return(x); } int main(){ while (cin >> e){ a = e.substr(0,(int)e.find('+')); b = e.substr(e.find("+")+1,e.find("=")-1-e.find("+")); s = e.substr(e.find("=")+1,32); if (converte(a)+converte(b)==converte(s)) cout << "True" << endl; else cout << "False" << endl; if (converte(a)==0 && converte(b)==0) break; } return(0); }

Exemplo de Sada True False True True False

41

Avio

42

#include <iostream> using namespace std; int main () { int f, c, e, b; while (cin >> f >> c >> e >> b) { if (b+(e-1)*c > f*c) cout << "PROXIMO VOO" << endl; else cout << e + (b-1)/c << " " << char(((b-1)%c) + 'A') << endl; } return 0; }

43

Telefone
Mapear as letras para nmero no teclado do telefone.

#include <iostream> #include <map> #include <string> using namespace std; map<char,int> string s; int main() { mapa['A'] = mapa['D'] = mapa['G'] = mapa['J'] = mapa['M'] = mapa;

2; 3; 4; 5; 6;

mapa['B'] mapa['E'] mapa['H'] mapa['K'] mapa['N']

= = = = =

2; 3; 4; 5; 6;

mapa['C'] mapa['F'] mapa['I'] mapa['L'] mapa['O']

= = = = =

2; 3; 4; 5; 6;

44
mapa['P'] = 7; mapa['Q'] = 7; mapa['R'] = 7; mapa['S'] = 7; mapa['T'] = 8; mapa['U'] = 8; mapa['V'] = 8; mapa['W'] = 9; mapa['X'] = 9; mapa['Y'] = 9; mapa['Z'] = 9; while (cin >> s) { for(int i=0;i<s.length();i++) { if (isalpha(s[i])) cout << mapa[toupper(s[i])]; else cout << s[i]; } cout << endl; } return(0); }

Dicionrio
Andy deseja ampliar o seu dicionrio. Ele quer criar um programa que extraia palavras de um texto e listar todas as palavras encontradas no texto em ordem alfabtica, com a inicial maiscula e as demais em minscula, sem pontuao, sem nmeros e sem repetio de palavras. A entrada para o programa seria um texto com no mximo 500 palavras. Teste esse exemplo voc mesmo. Exemplo Entrada Andy, agora com 9 anos de idade, deseja ampliar o seu dicionrio. Ele quer criar um programa que extraia palavras de um texto e listar todas as palavras encontradas no texto em ordem alfabtica, com a inicial maiscula e as demais em minscula, sem pontuao e sem repetio de palavras. A entrada para o programa seria um texto com no mximo 500 palavras. Teste esse exemplo voc mesmo. Exemplo Sada A Agora Alfabtica Ampliar Andy Anos As Com Criar De Demais Deseja Dicionrio E Ele Em Encontradas Entrada Esse Exemplo Extraia Idade Inicial Listar Maiscula Mesmo Minscula Mximo No O

45 Ordem Palavras Para Pontuao Programa Que Quer Repetio Sem Seria Seu Teste Texto Todas Um Voc
#include #include #include #include <iostream> <algorithm> <list> <string>

using namespace std; string s; char c; list <string> v; int i; int main() { while(cin >> s) { transform(s.begin(), s.end(), s.begin(), ::tolower); transform(s.begin(), s.begin()+1, s.begin(), ::toupper); c=s.at(s.size()-1); if (ispunct(c)) s.erase(s.size()-1,1); c=s.at(0); if (! isdigit (c)) v.push_back(s); } v.sort(); v.unique(); for (list<string>::iterator it= v.begin(); it!=v.end(); ++it) { cout << *it << endl; } }

46

Donativos
No Natal as pessoas ficam mais sensveis e resolveram doar presentes para as crianas carentes. Cada um que doava um presente o mesmo era colocado numa das trs pilhas de presentes: para meninos, para meninas ou para ambos. As crianas iam chegando e ficavam organizadas numa fila nica para receber o respectivo presente. Entrada O arquivo de entrada consiste de vrios casos de teste. Em cada teste, a primeira linha contm 4 nmeros (A, B, C, D) menores que 100, representando respectivamente (A) a quantidade de brinquedos de meninos; (B) a quantidade de brinquedos de meninas; (C) a quantidade de brinquedos que pode ser doado tanto para meninos quanto para meninas; (D) a quantidade de crianas. Na sequncia, esto os A nomes dos brinquedos que devem ser colocados na pilha de brinquedos para meninos; os nomes dos B brinquedos que devem ser colocados na pilha de brinquedos para meninas; os nomes dos C brinquedos que devem ser colocados na pilha de brinquedos para meninos; os nomes das D crianas que entraro na fila, precedidos pela letra G (guri) ou M (menina). Sada A sada consiste da escrita da palavra Teste seguida do nmero do teste e na sequncia, os nomes das crianas de acordo com a ordem na fila, seguida do nome do brinquedo retirado do topo da pilha de acordo com o sexo, e no havendo mais brinquedo para menino ou menina, da pilha de brinquedos para ambos os sexos. Se no tiver brinquedo na pilha do seu brinquedo de acordo com seu sexo, nem da pilha de ambos, escrever a palavra "sem presente". Ao final, escrever o total brinquedos sobraram nas pilhas de brinquedos. Exemplo do arquivo de Entrada: 5439 carregadeira rolo patrola trator caminhao barbie moranguinho ken polly bola cara-a-cara xadrez GJoao GPedro MMaria MAna MIsabel MMara GJoel GAndre GPaulo 2 1 3 10 ben10 maxsteel ursinho supertrunfo damas Exemplo do arquivo de Sada: Teste 1 Joao caminhao Pedro trator Maria polly Ana ken Isabel moranguinho Mara barbie Joel patrola Andre rolo Paulo carregadeira sobraram 3 presentes Teste 2 Abel maxsteel Beto ben10 Carlos varetas Daniel damas Eduardo supertrunfo Fabio sem presente Gabriel sem presente Henrique sem presente Ivo sem presente Joao sem presente sobrou 1 presente

47 varetas GAbel GBeto GCarlos GDaniel GEduardo GFabio GGabriel GHenrique GIvo GJoao
#include <stack> #include <queue> #include <iostream> #include <string> using namespace std; stack stack stack queue <string> <string> <string> <string> pdg; pdm; pdx; f;

int dg, dm, dx, c; string s; int cont, teste; int main() { teste=0; while(cin >> dg >> dm >> dx >> c) { cont=0; teste++; cout << "Teste "<<teste<<endl; for (int i=0;i<dg;i++) { cin >> s; pdg.push(s); } for (int i=0;i<dm;i++) { cin >> s; pdm.push(s); } for (int i=0;i<dx;i++) { cin >> s; pdx.push(s); } for (int i=0;i<c;i++) { cin >> s; f.push(s); } while(!f.empty()) { s=f.front(); f.pop(); if (s[0]=='G') { s.erase(0,1);

48
cout << s << " "; if (!pdg.empty()) { cout << pdg.top() << endl; pdg.pop(); } else if (!pdx.empty()) { cout << pdx.top() << endl; pdx.pop(); } else cout << "sem presente" << endl; } else { s.erase(0,1); cout << s << " "; if (!pdm.empty()) { cout << pdm.top() << endl; pdm.pop(); } else if (!pdx.empty()) { cout << pdx.top() << endl; pdx.pop(); } else cout << "sem presente" << endl; } } while (!pdg.empty()) { cont++; pdg.pop(); } while (!pdm.empty()) { cont++; pdm.pop(); } while (!pdx.empty()) { cont++; pdx.pop(); } if (cont==1) cout << "sobrou 1 presente" << endl; if (cont>1) cout << "sobraram " << cont << " presentes" << endl; } return(0); }

49

Nmeros Romanos
Os romanos desconheciam o zero, introduzido posteriormente pelos rabes, de forma que no existia nenhuma forma de representao deste valor. Alguns valores inteiros so representados por letras romanas especficas. So eles: I=1, V=5, X=10, L=50, C=100, D=500, M=1000 Os demais valores so formados a partir da combinao destes, sendo que no mximo podem ser repetidos 3 nmeros romanos e o prximo um menos o prximo, como por exemplo os nmeros de 1 a 10: I, II, III, IV, V, VI, VII, VIII, IX, X. Fazer um programa que escreva o nmero romano, menor ou igual a 3000 a partir do nmero informado. Entrada A entrada consiste de diversos casos de teste, cada um em uma linha. Cada linha contm um nmero (arbico) inteiro maior que 0 e menor ou igual a 3000. O nmero 0 indica o fim das entradas de teste. Sada Para cada caso de teste da entrada o seu programa deve escrever uma linha contendo o nmero romano correspondente. Exemplo de Entrada 1 40 9 49 32 88 89 90 91 110 0 Exemplo de Sada I XL IX XLIX XXXII LXXXVIII LXXXIX XC XCI CX

#include <iostream> #include <string> using namespace std; string s; int x; int arabicos[13] = {1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000}; string romanos[13] = {"I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M" }; int main() { while(cin >> x) { if (x==0) break; for (int i=12;i>=0;i--) { while ( x >= arabicos[i] ) { x = x - arabicos[i]; cout << romanos[i]; } } cout << endl; } }

50

Retngulos

#include <iostream> #include <string> using namespace std; long int a, b, c; int main() { while (cin >> a >> b >> c) { if ((a == 0) && (b == 0) && (c == 0)) break; //area = comprimento X algura if (c == 0) { cout << a << " " << b << " " << a * b << endl; } else { if (a == 0) cout << (c / b) << " " << b << " " << c << endl; else if (b == 0) cout << a << " " << (c / a) << " " << c << endl; } } return(0); }

51

Determinar se a Soma das linhas e colunas so iguais


#include<iostream> #include<string> using namespace std; int q [10][10]; int main () { int i, j, n, s, p; while (cin >> n) { if (n == 0) break; for (i = 0; i < n; i++) { for (j = 0; j < n; j++) { cin >> q[i][j]; } } //soma a 1 linha s = 0; for (i = 0; i < n; i++) { s += q[0][i]; } //Soma das prximas linhas if (s != -1) { for (i = 1; i < n; i++) { p = 0; for (j = 0; j < n; j++) { p += q[i][j]; } if (p != s) s = -1; } } //Soma das colunas if (s != -1) { for (j = 0; j < n; j++) { p = 0; for (i = 0; i < n; i++) { p += q[i][j]; } if (p != s) s = -1; } } //Diagonal principal if (s != -1) { p = 0; for (i = 0; i < n; i++) { p += q[i][i]; } if (p != s) s = -1; } //Diagonal secundria if (s != -1) { p = 0; for (i = 0; i < n; i++) { p += q[i][n - 1 - i]; } } if (p != s) s = -1; cout << s << endl; } return (0); }

52

Dentista

53
#include<iostream> #include<string> #include<vector> #include<algorithm> using namespace std; int main() { int n, a, b, i, j, consultas; vector<pair<int, int> > agenda; while (cin >> n) { if (n == 0) break; agenda.clear(); for(i = 0; i < n; i++) { cin >> a >> b; agenda.push_back(make_pair(b,a)); } sort(agenda.begin(),agenda.end()); consultas = 1; j = 0; for(i = 1; i < n; i++) { if (agenda[i].second >= agenda[j].first) { consultas++; j = i; } } cout << consultas << endl; } return(0); }

54

Ciclismo (uso de vector ordenado com estrutura)


A equipe de ciclismo estava se preparando para a competio e resolveu instalar um sensor nas rodas das bicicletas dos membros da equipe durante o treinamento. O sensor registra a quantidade de voltas dadas pela roda.Desta forma, pode-se saber qual atleta percorreu a maior distncia durante o perodo de treinamento. Porm, o que a equipe no se deu conta que os participantes usam bicicletas com diferentes tamanhos de rodas e por isso precisa da sua ajuda para fazer um programa que calcule e escreva o ranking dos atletas que percorreram a maior distncia em ordem decrescente. Entrada: A entrada contm um nico caso de teste, composto por vrias linhas com 3 nmeros inteiros A, B e C sendo o A o nmero de identificao do ciclista, o B um nmero inteiro representando o dimetro da roda da bicicleta (em polegadas) e o C um nmero inteiro que representa a quantidade de voltas dadas pela roda. A entrada termina com os trs nmeros iguais a 0. Sada: A sada o ranking dos ciclistas que percorreram a maior distncia, com o nmero de identificao e a distncia percorrida (em metros, com 2 casas de preciso). Exemplo de Entrada 10 20 6780 20 22 6560 13 26 6120 15 27 5997 000
#include <iostream> #include <iomanip> #include <algorithm> #include <vector> #include <cmath> using namespace std; struct dados { int nro; float dist; }d; bool compara (dados i, dados j) { return (i.dist > j.dist); } vector<dados> v; vector<dados>::iterator it; int nro, roda, voltas; int main () { while(cin >> nro >> roda >> voltas) { if (nro==0 && roda==0 && voltas==0) break; d.nro=nro; d.dist=(float)((int)(roda*2.54*M_PI*voltas))/100; v.push_back(d); } sort(v.begin(), v.end(), compara); for (it=v.begin(); it!=v.end(); ++it) cout << it->nro << " " << fixed << setprecision (2) << return 0; }

Exemplo de Sada 15 12920.56 13 12697.21 20 11516.22 10 10820.39

it->dist << endl;

55

rvore de extenso mnima


Uma rvore de extenso mnima (rvore de extenso de peso mnimo ou rvore geradora mnima) deste grafo um subgrafo que conecta todos os vrtices. Um exemplo de uso de uma rvore de extenso mnima seria a instalao de fibras ticas num campus de uma faculdade. Cada trecho de fibra tica entre os prdios possui um custo associado (isto , o custo da fibra, somado ao custo da instalao da fibra, mo de obra, etc). Com esses dados em mos (os prdios e os custos de cada trecho de fibra tica entre todos os prdios), podemos construir uma rvore de extenso que nos diria um jeito de conectarmos todos os prdios sem redundncia. Uma rvore geradora mnima desse grafo nos daria uma rvore com o menor custo para fazer essa ligao.
1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. Ira Frederico Westphalen Vicente Dutra Caiara Palmitinho Taquaruu do Sul Vista Alegre Pinheirinho do Vale Ametista do Sul Planalto Alpestre Seberi Rodeio Bonito 14. Cristal do Sul

Dadas a rotas entre as cidades, o arquivo possui como entrada: 1 Linha: quantidade de cidades (N) quantidade de estradas que ligam estas cidades (M) M Linhas seguintes: Cidade Incio da estrada Cidade final da estrada Extenso da estrada Exemplo de Entrada Exemplo de Sada 14 17 1 2 30 1 10 34 1 11 36 2 4 10 2 12 15 269 2 9 28 3 4 27 4 8 31 5 8 18 577 675 9 10 17 198

56 9 13 19 10 11 12 12 14 21 13 14 8 #include <iostream> #include <cstdio> #include <cstdlib> #include <algorithm> using namespace std; #define MAXN 1000 #define MAXM 10000 typedef pair<int, int> aresta; typedef pair<int, aresta> estrada; int N, M; int conj[MAXN]; estrada v[MAXM]; int mst(){ sort(v,v+M); /* Minimum Spanning Tree */

int res = 0; for(int i = 0; i < N; i++) conj[i] = i; for(int i = 0; i < M; i++){ estrada e = v[i]; int p,q,u; p = e.second.first; q = e.second.second; u = e.first; if(conj[p] == conj[q]) continue; int c = conj[p]; for(int j = 0; j < N; j++) if(conj[j] == c) conj[j] = conj[q]; res += u; // cout << "i: " << i << "u: " << u << endl; // trechos que sero somados } return res; } int main(void){ int o, d; while (cin >> N >> M) { for(int i = 0; i < M; i++){ int p,q,u; scanf("%d %d %d", &p, &q, &u); v[i] = estrada(u, aresta(p,q)); } cout << mst() << endl; } return 0; }

57

Caminho mais curto


1. 2. 3. 4. 5. 6. 7. 8. 9. 10. 11. 12. 13. Ira Frederico Westphalen Vicente Dutra Caiara Palmitinho Taquaruu do Sul Vista Alegre Pinheirinho do Vale Ametista do Sul Planalto Alpestre Seberi Rodeio Bonito 14. Cristal do Sul

Dadas a rotas entre as cidades, o arquivo possui como entrada: 1 Linha: quantidade de cidades (N) quantidade de estradas que ligam estas cidades (M) quantidade de casos de testes menor distncia entre duas cidades (Q) M Linhas seguintes: Cidade Incio da estrada Cidade final da estrada Extenso da estrada Q Linhas seguintes: Cidade de origem Cidade de destino Exemplo de Entrada 14 17 2 1 2 30 1 10 34 1 11 36 2 4 10 2 12 15 269 2 9 28 3 4 27 4 8 31 5 8 18 577 675 9 10 17 9 13 19 10 11 12 12 14 21 13 14 8 89 19 Exemplo de Sada 67 51

//Caminho mais curto Floyd-Warshall #include <cstdio>

58 #include <iostream> #include <algorithm> using namespace std; const int INF = 1000000000; int main() { int n, m, ori, des, quant; while(cin >> n >> m >> quant) { if (n==0&&m==0)break; int dist[n+1][n+1]; for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) dist[i][j] = INF; /* A menor distncia entre uma cidade e ela mesma zero. */ for(int i = 1; i <= n; i++) dist[i][i] = 0; for(int i = 0; i < m; i++) { int u, v, w; cin >> u >> v >> w; dist[u][v] = min(dist[u][v], w); dist[v][u] = dist[u][v]; // remover esta linha se a via no de mo dupla } for(int k = 1; k <= n; k++) // preenche a tabela com a distancia entre cidades for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]); for(int i=0;i<quant;i++) { cin >> ori >> des; cout << dist[ori][des] << endl; } } return 0; } //Caminho mais curto Dijkstra #include <iostream> using namespace std; #define #define #define #define MAXNODES 50 // Verificar se o tamanho est adequado INFINITY 32768 MEMBER 1 NONMEMBER 0

struct arc { int adj; // se adj=1 ento ADJACENTE; se adj=0 ento NO ADJACENTE int weight; // peso da aresta }; struct graph { struct arc arcs[MAXNODES][MAXNODES]; }g; // matriz de adjacncias

59

void init_graph () { // inicializa matriz de adjacncia que representa o grafo for (int i = 0; i < MAXNODES; i++) { for (int j = 0; j < MAXNODES; j ++) { g.arcs[i][j].adj = 0; g.arcs[i][j].weight = INFINITY; } } } // cria uma aresta que "liga" (incide) em dois ns e atribui o respectivo peso; // recebe dois ns (node1 e node2) e o peso (wt) da aresta void joinwt (int node1, int node2, int wt) { g.arcs[node1][node2].adj = 1; g.arcs[node1][node2].weight = wt; } // remove uma aresta do grafo; // recebe o grafo e os dois ns (node1 e node2); void remove (int node1, int node2) { g.arcs[node1][node2].adj = 0; g.arcs[node1][node2].weight = INFINITY; } void dijkstra (int s, int t) // s=origem e t=destino { int dist[MAXNODES], perm[MAXNODES], path[MAXNODES]; int current, i, k, dc; int smalldist, newdist; /* Inicializa todos os ndices de 'perm' como 0 e de 'dist' como INFINITY */ for (i = 0; i < MAXNODES; i++) { perm[i] = NONMEMBER; dist[i] = INFINITY; } /* Inclui 's' em perm (perm[s]=1) e configura(armazena) sua distancia como sendo zero */ perm[s] = MEMBER; dist[s] = 0; /* define 's' como origem (fonte) da busca */ current = s; k = current; while (current != t) { smalldist = INFINITY; dc = dist[current]; for (i = 0; i < MAXNODES; i++) { if (perm[i] == NONMEMBER) { newdist = dc + g.arcs[current][i].weight; if (newdist < dist[i]) { dist[i] = newdist; path[i] = current; } if (dist[i] < smalldist) { smalldist = dist[i]; k = i; } }

60 } if (current == k) { cout << "CAMINHO NAO EXISTE" << endl; return; } current = k; perm[current] = MEMBER; } /* impressao do resultado ****************/ //cout << s << " a " << t <<": "; int caminho = t; //cout << t <<", "; while (caminho != s) { //cout << path[caminho]; // aqui mostra o trajeto caminho = path[caminho]; //if (caminho != s) cout << ", "; } cout << dist[t] << endl; /****************************************/ } /* fim dijkstra */ int main() { int a, b, c, d, n, ori, des, quant; init_graph (); while (cin >> n >> c >> quant) { for(int i=0;i<c;i++) { cin >> a >> b >> d; joinwt (a, b, d); joinwt (b, a, d); } for(int i=0;i<quant;i++) { cin >> ori >> des; dijkstra (ori, des); } } return 0; }

61

Ver se todas cidades se conectam


Aplica o caminho mais curto de Floyd-Warshall e verifica a tabela de distncias no final: #include <cstdio> #include <iostream> #include <algorithm> using namespace std; const int INF = 1000000000; int main() { int n, m, ori, des, quant; while(cin >> n >> m) { if (n==0&&m==0)break; int dist[n+1][n+1]; for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) dist[i][j] = INF; /* A menor distncia entre uma cidade e ela mesma zero. */ for(int i = 1; i <= n; i++) dist[i][i] = 0; for(int i = 0; i < m; i++) { int u, v, w; cin >> u >> v >> w; dist[u][v] = min(dist[u][v], w); dist[v][u] = dist[u][v]; // remover esta linha se a via no de mo dupla } for(int k = 1; k <= n; k++) // preenche a tabela com a distancia entre cidades for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]); int cont=0; for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++)

if(dist[i][j] == INF) { cont++; break; } if(cont==0)cout << "Todas se conectam" <<endl; else cout << "Nem Todas se conectam" <<endl;
} return 0; }

62

Ver a maior distncia percorrida entre 2 cidades atravs do caminho mais curto
Aplica o caminho mais curto de Floyd-Warshall e verifica a tabela de distncias no final: #include <cstdio> #include <iostream> #include <algorithm> using namespace std; const int INF = 1000000000; int main() { int n, m, ori, des, quant; while(cin >> n >> m) { if (n==0&&m==0)break; int dist[n+1][n+1]; for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) dist[i][j] = INF; /* A menor distncia entre uma cidade e ela mesma zero. */ for(int i = 1; i <= n; i++) dist[i][i] = 0; for(int i = 0; i < m; i++) { int u, v, w; cin >> u >> v >> w; dist[u][v] = min(dist[u][v], w); dist[v][u] = dist[u][v]; // remover esta linha se a via no de mo dupla } for(int k = 1; k <= n; k++) // preenche a tabela com a distancia entre cidades for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++) dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]); int maior=0; for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++)

if(dist[i][j] < INF && dist[i][j]>maior) { maior = dist[i][j]; } cout << maior <<endl;
} return 0; }

63

O Guia Turstico
Sr. G. trabalha como um guia turstico. Sua misso atual a de levar alguns turistas de uma cidade para outra. Algumas estradas de duas vias ligam as cidades. Para cada par de cidades vizinhas, h um servio de nibus que funciona apenas entre as duas cidades e utiliza a estrada entre elas. Cada servio de nibus tem um limite no nmero mximo de passageiros que pode transportar. Sr. G. entende que nem sempre pode ser possvel para ele levar todos os turistas para a cidade de destino em uma nica viagem. Por exemplo, considere o seguinte roteiro de 7 cidades. As arestas ligando as cidades representam as estradas e o nmero escrito em cada extremidade indica o limite de passageiros do servio de nibus naquele trecho.

Agora, se ele quer levar 99 turistas da cidade de 1 a 7 da cidade, ele vai exigir pelo menos cinco viagens, uma vez que ele tem que andar de nibus com cada grupo, e o caminho que ele deve tomar : 1 - 2 - 4-7. Mas, o Sr. G. acha difcil encontrar o melhor caminho sozinho, para que ele possa ser capaz de tomar todos os turistas para a cidade de destino em nmero mnimo de viagens. Ento, ele procura a sua ajuda. Entrada A entrada ir conter um ou mais casos de teste. A primeira linha de cada caso de teste ir conter dois nmeros inteiros: N (N <= 100) e R representam, respectivamente, o nmero de cidades e o nmero de segmentos de estrada. Ento linhas R seguir cada um contendo trs inteiros: C1, C2 e P. C1 e C2 so os nmeros da cidade e P (P> 1) o limite para o nmero mximo de passageiros a ser transportado pelo servio de nibus entre as duas cidades. Nmeros da cidade so inteiros positivos variando de 1 a N. A (R + 1) linha conter trs inteiros: S, D e T, respectivamente, representando a cidade de partida, a cidade de destino e o nmero de turistas para ser guiado. A entrada termina com dois zeros para N e R. Sada Para cada caso de teste na sada primeiro mostra o nmero do cenrio. Ento a sada deve ter o nmero mnimo de viagens necessrias para este caso em uma linha separada. Imprimir uma linha em branco aps a sada de cada caso de teste. Exemplo de Entrada 7 1 1 1 2 2 3 3 4 5 6 10 2 30 3 15 4 10 4 25 5 60 4 40 6 20 7 35 7 20 7 30 Exemplo de Sada Scenario #1 Minimum Number of Trips = 5

64 1 7 99 0 0 //utiliza o agortimo de Floyd-Warshall com as linhas em negrito alteradas #include <iostream> #include <cstdio> #include <algorithm> using namespace std; const int INF = -1000000000; int cont; int dist[110][110]; int main() { int n, m, ori, dest, pas; cont=0; while(scanf("%d %d", &n, &m)!=EOF) { if (n==0&&m==0)break; for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++)

dist[i][j] = INF;
for(int i = 1; i <= n; i++)

dist[i][i] = INF * -1;


for(int i = 1; i <= m; i++) { int u, v, w; scanf("%d %d %d", &u, &v, &w); w--; // diminui a capacidade do onibus em 1 passageiro para o guia poder ir junto dist[u][v] = max(dist[u][v], w); dist[v][u] = dist[u][v]; } for(int k = 1; k <= n; k++) for(int i = 1; i <= n; i++) for(int j = 1; j <= n; j++)

dist[i][j] = max(min(dist[i][k], dist[j][k]), dist[i][j]);


scanf("%d %d %d", &ori, &dest, &pas); cont++; printf("Scenario #%d\n",cont); int viagens, sobra; viagens=(int)(pas / dist[ori][dest]); sobra= pas % dist[ori][dest]; if (sobra>0) viagens++; printf("Minimum Number of Trips = %d\n\n",viagens); } }

65

Caminho mais curto simples


#include <iostream> using namespace std; #define MAXNODES 50 // Verificar se o tamanho est adequado

#define INFINITY 32768 #define MEMBER 1 #define NONMEMBER 0 struct arc { int adj; // se adj=1 ento ADJACENTE; se adj=0 ento NO ADJACENTE int weight; // peso da aresta }; struct graph { struct arc arcs[MAXNODES][MAXNODES]; }g; // matriz de adjacncias

void init_graph () { // inicializa matriz de adjacncia que representa o grafo for (int i = 0; i < MAXNODES; i++) { for (int j = 0; j < MAXNODES; j ++) { g.arcs[i][j].adj = 0; g.arcs[i][j].weight = INFINITY; } } } // cria uma aresta que "liga" (incide) em dois ns e atribui o respectivo peso; // recebe dois ns (node1 e node2) e o peso (wt) da aresta void joinwt (int node1, int node2, int wt) { g.arcs[node1][node2].adj = 1; g.arcs[node1][node2].weight = wt; } // remove uma aresta do grafo; // recebe o grafo e os dois ns (node1 e node2); void remove (int node1, int node2) { g.arcs[node1][node2].adj = 0; g.arcs[node1][node2].weight = INFINITY; } void dijkstra (int s, int t) // s=origem e t=destino { int dist[MAXNODES], perm[MAXNODES], path[MAXNODES]; int current, i, k, dc; int smalldist, newdist; /* Inicializa for (i = 0; i perm[i] = dist[i] = } todos os ndices de 'perm' como 0 e de 'dist' como INFINITY */ < MAXNODES; i++) { NONMEMBER; INFINITY;

66 /* Inclui 's' em perm (perm[s]=1) e configura(armazena) sua distancia como sendo zero */ perm[s] = MEMBER; dist[s] = 0; /* define 's' como origem (fonte) da busca */ current = s; k = current; while (current != t) { smalldist = INFINITY; dc = dist[current]; for (i = 0; i < MAXNODES; i++) { //se o elemento NO est em perm if (perm[i] == NONMEMBER) { //calcula distncia a partir do vrtice corrente ao vrtice adjacente i newdist = dc + g.arcs[current][i].weight; //se a distncia partindo do vrtice corrente for menor, atualiza o vetor //de distncias e de precedncia if (newdist < dist[i]) { dist[i] = newdist; path[i] = current; } //determina o vrtice (entre todos os no pertencentes a perm) com menor distncia if (dist[i] < smalldist) { smalldist = dist[i]; k = i; } } } /* fim for */ /* embora estamos assumindo grafos ponderados e conexos, este if garante que em caso de no existncia de um caminho o programa no entre em loop infinito */ if (current == k) { printf("\n\nCAMINHO NAO EXISTE\n\n"); return; } current = k; perm[current] = MEMBER; } /* fim while */ /* impressao do resultado ****************/ cout << s << " a " << t <<": "; int caminho = t; cout << t; while (caminho != s) { cout << path[caminho];

67 caminho = path[caminho]; if (caminho != s) cout << ", "; } printf("\n\ncusto: %d\n\n", dist[t]); /****************************************/ } /* fim dijkstra */ int main() { int a, b, c; init_graph (); while (cin >> a >> b >> c) { if (a==0 && b==0 && c==0) break; joinwt (a, b, c); joinwt (b, a, c); // incluir se o caminho bidirecional } while (cin >> a >> b) { dijkstra (b, a); } return 0; }

68

Rota mais curta com nomes de cidades e uso de pilha


#include <iostream> #include <string> #include <stack> using namespace std; #define MAXNODES 50 // Verificar se o tamanho est adequado

#define INFINITY 32768 #define MEMBER 1 #define NONMEMBER 0 string nome[50]; int cont; stack<string> pilha; struct arc { int adj; // se adj=1 ento ADJACENTE; se adj=0 ento NO ADJACENTE int weight; // peso da aresta }; struct graph { struct arc arcs[MAXNODES][MAXNODES]; }g; // matriz de adjacncias

void init_graph () { // inicializa matriz de adjacncia que representa o grafo for (int i = 0; i < MAXNODES; i++) { for (int j = 0; j < MAXNODES; j ++) { g.arcs[i][j].adj = 0; g.arcs[i][j].weight = INFINITY; } } } void joinwt (int node1, int node2, int wt) { g.arcs[node1][node2].adj = 1; g.arcs[node1][node2].weight = wt; } void remove (int node1, int node2) { g.arcs[node1][node2].adj = 0; g.arcs[node1][node2].weight = INFINITY; } void dijkstra (int s, int t) // s=origem e t=destino { int dist[MAXNODES], perm[MAXNODES], path[MAXNODES]; int current, i, k, dc; int smalldist, newdist; for (i = 0; i < MAXNODES; i++) { perm[i] = NONMEMBER; dist[i] = INFINITY;

69 } perm[s] = MEMBER; dist[s] = 0; /* define 's' como origem (fonte) da busca */ current = s; k = current; while (current != t) { smalldist = INFINITY; dc = dist[current]; for (i = 0; i < MAXNODES; i++) { if (perm[i] == NONMEMBER) { newdist = dc + g.arcs[current][i].weight; if (newdist < dist[i]) { dist[i] = newdist; path[i] = current; } if (dist[i] < smalldist) { smalldist = dist[i]; k = i; } } } if (current == k) { printf("\n\nCAMINHO NAO EXISTE\n\n"); return; } current = k; perm[current] = MEMBER; } /* fim while */ /* impressao do resultado ****************/ // cout << dist[t] << ": "; cout << nome[s] << " a " << nome[t] <<": "; int caminho = t; pilha.push(nome[t]); while (caminho != s) { pilha.push(nome[path[caminho]]); caminho = path[caminho]; } //printf("\n\ncusto: %d\n\n", dist[t]); /****************************************/ cont =0; while(!pilha.empty()) { if (cont>0) cout << ", "; cout << pilha.top(); pilha.pop() ; cont++; }

70 cout << endl; } /* fim dijkstra */ int main() { char s[100]; int qcidades, a, b, c; init_graph (); cin >> qcidades; gets(s); for (int i=1;i<=qcidades;i++) { gets(s); nome[i]=s; } while (cin >> a >> b >> c) { if (a==0 && b==0 && c==0) break; joinwt (a, b, c); joinwt (b, a, c); } while (cin >> a >> b) { dijkstra (a, b); } return 0; }

71

Rota mais rpida com nomes de cidades e uso de pilha


#include <iostream> #include <string> #include <stack> using namespace std; #define #define #define #define MAXNODES 50 INFINITY 32768 MEMBER 1 NONMEMBER 0

string nome[50]; int cont; stack<string> pilha; struct arc { int adj; int weight; }; struct graph { struct arc arcs[MAXNODES][MAXNODES]; }g; void init_graph () { for (int i = 0; i < MAXNODES; i++) { for (int j = 0; j < MAXNODES; j ++) { g.arcs[i][j].adj = 0; g.arcs[i][j].weight = INFINITY; } } } void joinwt (int node1, int node2, int wt) { g.arcs[node1][node2].adj = 1; g.arcs[node1][node2].weight = wt; } void remove (int node1, int node2) { g.arcs[node1][node2].adj = 0; g.arcs[node1][node2].weight = INFINITY; } void dijkstra (int s, int t) // s=origem e t=destino { int dist[MAXNODES], perm[MAXNODES], path[MAXNODES]; int current, i, k, dc; int smalldist, newdist; for (i = 0; i < MAXNODES; i++) { perm[i] = NONMEMBER; dist[i] = INFINITY; } perm[s] = MEMBER; dist[s] = 0;

72 current = s; k = current; while (current != t) { smalldist = INFINITY; dc = dist[current]; for (i = 0; i < MAXNODES; i++) { if (perm[i] == NONMEMBER) { newdist = dc + g.arcs[current][i].weight; if (newdist < dist[i]) { dist[i] = newdist; path[i] = current; } if (dist[i] < smalldist) { smalldist = dist[i]; k = i; } } } if (current == k) { printf("\n\nCAMINHO NAO EXISTE\n\n"); return; } current = k; perm[current] = MEMBER; } /* impressao do resultado ****************/ cout << dist[t] << ": "; // cout << nome[s] << " a " << nome[t] <<": "; int caminho = t; pilha.push(nome[t]); while (caminho != s) { pilha.push(nome[path[caminho]]); caminho = path[caminho]; } //printf("\n\ncusto: %d\n\n", dist[t]); /****************************************/ cont =0; while(!pilha.empty()) { if (cont>0) cout << ", "; cout << pilha.top(); pilha.pop() ; cont++; } cout << endl; } /* fim dijkstra */ int main() { char s[100]; int qcidades, a, b, c, d, tempo; init_graph (); cin >> qcidades; gets(s); for (int i=1;i<=qcidades;i++) {

73 gets(s); nome[i]=s; } while (cin >> a >> b >> c >> d) { if (a==0 && b==0 && c==0) break; tempo = (int)(((float)c / d)*60); joinwt (a, b, tempo); joinwt (b, a, tempo); } while (cin >> a >> b) { dijkstra (a, b); } return 0; }

LCD Display
#include <string> #include <iostream> using namespace std;
char {{{' {{' {{' {{' {{' {{' {{' {{' {{' {{' a[10][5][3] ','-',' '}, ',' ',' '}, ','-',' '}, ','-',' '}, ',' ',' '}, ','-',' '}, ','-',' '}, ','-',' '}, ','-',' '}, ','-',' '}, = {'|',' {' ',' {' ',' {' ',' {'|',' {'|',' {'|',' {' ',' {'|',' {'|',' ','|'}, ','|'}, ','|'}, ','|'}, ','|'}, ',' '}, ',' '}, ','|'}, ','|'}, ','|'}, {' {' {' {' {' {' {' {' {' {' ',' ',' ',' ',' ','-',' ','-',' ','-',' ','-',' ','-',' ',' ',' ','-',' ','-',' '}, '}, '}, '}, '}, '}, '}, '}, '}, '}, {'|',' {' ',' {'|',' {' ',' {' ',' {' ',' {'|',' {' ',' {'|',' {' ',' ','|'}, ','|'}, ',' '}, ','|'}, ','|'}, ','|'}, ','|'}, ','|'}, ','|'}, ','|'}, {' {' {' {' {' {' {' {' {' {' ','-',' ',' ',' ','-',' ','-',' ',' ',' ','-',' ','-',' ',' ',' ','-',' ','-',' '}}, //0 '}}, //1 '}}, //2 '}}, //3 '}}, //4 '}}, //5 '}}, //6 '}}, //7 '}}, //8 '}}}; //9

int main(){ int s; string n; while(1){ cin >> s >> n; if ((s == 0) && (n == '0')) break; for (int linha = 0; linha < 5; linha++){ //vare as linhas int p = 1; if ((linha == 1) || (linha == 3)) p = s; for (int y = 0; y < p; y++){ for (int j = 0; j < n.size(); j++){ //percore o valor a ser impresso int num = (n[j]-48); for (int coluna = 0; coluna < 3; coluna++){ //varre as colunas int q = 1; if (coluna == 1) q = s; for (int x = 0; x < q; x++) cout << a[num][linha][coluna]; } cout << ' '; } cout << endl; } } } return 0; }