Exercícios Feitos URI Online Judge ( C++ )

Estou postando aqui a resolução de alguns exercícios do portal http://www.urionlinejudge.com.br na linguagem C++ para quem está com dúvidas.

A intenção não é deixar exercícios prontos, por isto, para ver os scripts é necessário cadastrar-se no site.

Caso tenham dúvidas ou precisarem de outras listas prontas, comentem ai :D


==========================================================================================
==========================================================================================

1001 - Extremamente Básico

Código:

# include <iostream>
# include <cmath>
using namespace std;
int main (){
int A, B, X;
cin >> A >> B;
X = A + B;
cout << "X = " << X << endl;
return 0;
}

==========================================================================================
==========================================================================================

1002 - Área do circulo

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
double raio,A;
 cin >> raio;
 A = (raio * raio)*3.14159;
 cout << fixed << setprecision (4);
 cout << "A=" << A << endl;
 return 0;
}

==========================================================================================
==========================================================================================

1003 - Soma Simples

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
int A, B, SOMA;
cin >> A >> B;
SOMA = A + B;
cout << "SOMA = " << SOMA << endl;
return 0;
}

==========================================================================================
==========================================================================================

1004 - Produto Simples

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
int A, B, PROD;
cin >> A >> B;
PROD = A * B;
cout << "PROD = " << PROD << endl;
return 0;
}

==========================================================================================
==========================================================================================

1005 - Média 1

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
double A, B, MEDIA;
cin >> A >> B;
MEDIA = ((A * 3.5) + (B*7.5))/11;
cout << fixed << setprecision (5);
cout << "MEDIA = " << MEDIA << endl;
return 0;
}

==========================================================================================
==========================================================================================

1006 - Média 2

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
double A, B, C, MEDIA;
cin >> A >> B >> C;
MEDIA = ((A * 2.0) + (B * 3.0) + (C * 5.0))/10.0;
cout << fixed << setprecision (1);
cout << "MEDIA = " << MEDIA << endl;
return 0;
}

==========================================================================================
==========================================================================================


1007 - Diferença

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
int A, B, C, D, DIFERENCA;
cin >> A >> B >> C >> D;
DIFERENCA = (A * B - C * D);
cout << fixed << setprecision (4);
cout << "DIFERENCA = " << DIFERENCA << endl;
return 0;
}

==========================================================================================
==========================================================================================

1008 - Salário

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
int NUMBER,HorasDeTrabalho;
double ValorPorHora,SALARY;
cin >> NUMBER >> HorasDeTrabalho >> ValorPorHora;
SALARY = HorasDeTrabalho*ValorPorHora;
cout << "NUMBER = " << NUMBER << endl;
cout << fixed << setprecision (2);
cout << "SALARY = U$ " << SALARY << endl;
return 0;
}


==========================================================================================
==========================================================================================

1009 - Salário com Bônus

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main (){
string NomeVendedor;
double SalarioFixo,TotalDeVendas,TOTAL;
cin >> NomeVendedor >> SalarioFixo >> TotalDeVendas;
TOTAL = SalarioFixo + TotalDeVendas*0.15;
cout << fixed << setprecision(2);
cout << "TOTAL = R$ " << TOTAL << endl;
return 0;
}

==========================================================================================
==========================================================================================

1010 - Cálculo Simples

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main (){
int CodPeca,NumeroPeca,CodPeca2,NumeroPeca2;
double ValorPeca1,ValorPeca2,TotalASerPago;
cin >> CodPeca >> NumeroPeca >> ValorPeca1;
cin >> CodPeca2 >> NumeroPeca2 >> ValorPeca2;
TotalASerPago = NumeroPeca*ValorPeca1 + NumeroPeca2*ValorPeca2;
cout << fixed << setprecision(2);
cout << "VALOR A PAGAR: R$ " << TotalASerPago << endl;
return 0;
}


==========================================================================================
==========================================================================================

1011 - Esfera

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main (){
double volume,raio;
cin >> raio;
volume = (raio*raio*raio)*3.14159*(4/3.0);
cout << fixed << setprecision(3);
cout << "VOLUME = " << volume << endl;
return 0;
}

==========================================================================================
==========================================================================================

1012 - Área

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main (){
double A,B,C,a,b,c,d,e;
cin >> A >> B >> C;
a = (A*C)/2;
b = (C*C)*3.14159;
c = ((A+B)*C)/2;
d = (B*B);
e = (A*B);
cout << fixed << setprecision(3);
cout << "TRIANGULO: " << a << endl;
cout << "CIRCULO: " << b << endl;
cout << "TRAPEZIO: " << c << endl;
cout << "QUADRADO: " << d << endl;
cout << "RETANGULO: " << e << endl;
return 0;
}

==========================================================================================
==========================================================================================

1013 - O Maior

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main (){
double A,B,C,MaiorAB,resultado;
cin >> A >> B >> C;
if(A > B){
    MaiorAB = A;
}else if(A < B){
    MaiorAB = B;
}
if(MaiorAB < C){
    resultado = C;
}else if(MaiorAB > C){
    if(A > B){
        resultado = A;
    }else if(A < B){
        resultado = B;
    }
}
cout << resultado << " eh o maior" << endl;
return 0;
}

==========================================================================================
==========================================================================================

1014 - Consumo

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
int km;
double combustivel,resultado;
cin >> km >> combustivel;
resultado = km/combustivel;
cout << fixed << setprecision(3);
cout << resultado << " km/l"<< endl;
return 0;
}


==========================================================================================
==========================================================================================

1015 - Distância entre dois pontos

Código:

#include <iostream>;
#include <cmath>;
#include <iomanip>;
using namespace std;
int main () {
double a1,a2,b1,b2,subtracao1,subtracao2,modulo;
cin >> a1 >> a2 >> b1 >> b2;
subtracao1 = b1-a1;
subtracao2 = b2-a2;
modulo = sqrt((subtracao1*subtracao1)+(subtracao2*subtracao2));
cout << fixed << setprecision (4);
cout << modulo << endl;
return 0;
}

==========================================================================================
==========================================================================================

1016 - Distância

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
int tempo;
double resultado;
cin >> tempo;
resultado = tempo*2;
cout << resultado << " minutos"<< endl;
return 0;
}

==========================================================================================
==========================================================================================

1017 - Gasto de Combustível

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
int velocidade,tempo;
double kilometrosRodados,consumo;
cin >> tempo >> velocidade;
kilometrosRodados = velocidade*tempo;
consumo = kilometrosRodados/12;
cout << fixed << setprecision(3);
cout << consumo << endl;
return 0;
}

==========================================================================================
==========================================================================================

1018 - Cédulas

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
  int dinheiro;
  int nota100,nota50,nota20,nota10,nota5,nota2,nota1;
  double calc100,calc50,calc20,calc10,calc5,calc2;
  cin >> dinheiro;
  calc100 = dinheiro/100;
  nota100 = calc100;
  calc50 = (dinheiro - (nota100*100))/50;
  nota50 = calc50;
  calc20 = (dinheiro - (nota100*100)-(nota50*50))/20;
  nota20 = calc20;
  calc10 = (dinheiro - (nota100*100)-(nota50*50)-(nota20*20))/10;
  nota10 = calc10;
  calc5 = (dinheiro - (nota100*100)-(nota50*50)-(nota20*20)-(nota10*10))/5;
  nota5 = calc5;
  calc2 = (dinheiro - (nota100*100)-(nota50*50)-(nota20*20)-(nota10*10)-(nota5*5))/2;
  nota2 = calc2;
  nota1 = (dinheiro - (nota100*100)-(nota50*50)-(nota20*20)-(nota10*10)-(nota5*5)-(nota2*2));
  cout << dinheiro << endl;
  cout << nota100 << " nota(s) de R$ 100,00" << endl;
  cout << nota50 << " nota(s) de R$ 50,00" << endl;
  cout << nota20 << " nota(s) de R$ 20,00" << endl;
  cout << nota10 << " nota(s) de R$ 10,00" << endl;
  cout << nota5 << " nota(s) de R$ 5,00" << endl;
  cout << nota2 << " nota(s) de R$ 2,00" << endl;
  cout << nota1 << " nota(s) de R$ 1,00" << endl;
  return 0;
}

==========================================================================================
==========================================================================================

1019 - Conversão de tempo

Código:

#include <iostream>
#include <cmath>
using namespace std;
int main() {
int N,horas,minutos,segundos;
double calcHoras,calcMinutos;
cin >> N;
calcHoras = N / 3600;
horas = calcHoras;
calcMinutos = (N - (horas*3600))/ 60;
minutos = calcMinutos;
segundos = N - (horas*3600) - (minutos * 60);
cout << horas << ":" << minutos << ":" << segundos << endl;
return 0;
}

==========================================================================================
==========================================================================================

1020 - Idade em dias

Código:

#include <iostream>
#include <cmath>
#include <iostream>
using namespace std;
int main() {
int EntradaDeDias,valorAno,valorMes,valorDia;
double calculoAnos,calculoMes;
cin >> EntradaDeDias;
calculoAnos = EntradaDeDias/350;
valorAno = calculoAnos;
calculoMes = (EntradaDeDias - (valorAno*365))/30;
valorMes = calculoMes;
valorDia = EntradaDeDias-((valorAno*365)+(valorMes*30));
cout << valorAno << " ano(s)" <<endl;
cout << valorMes << " mes(es)" <<endl;
cout << valorDia << " dia(s)" <<endl;
return 0;
}

==========================================================================================
==========================================================================================

1021-Notas e Moedas.

Código:

#include<iostream>
#include<cmath>
#include<iomanip>
using namespace std;
int main (){
// variaveis
double ValorEmDinheiro,calc100,calc50,calc20,calc10,calc5,calc2,calcMoeda1,calcMoeda50,calcMoeda25,calcMoeda10,calcMoeda5,calcMoeda01;
int valor100,valor50,valor20,valor10,valor5,valor2,valorMoeda1,valorMoeda50,valorMoeda25,valorMoeda10,valorMoeda5,valorMoeda01;
// entrada de dados
cin >> ValorEmDinheiro;
// processamento dos dados
calc100 = ValorEmDinheiro/100;
valor100 = calc100;
calc50 = (ValorEmDinheiro - (valor100*100))/50.00;
valor50 = calc50;
calc20 = (ValorEmDinheiro - (valor100*100)-(valor50*50))/20.00;
valor20 = calc20;
calc10 = (ValorEmDinheiro - (valor100*100)-(valor50*50)-(valor20*20))/10.00;
valor10 = calc10;
calc5 = (ValorEmDinheiro - (valor100*100)-(valor50*50)-(valor20*20)-(valor10*10))/5.00;
valor5 = calc5;
calc2 = (ValorEmDinheiro - (valor100*100)-(valor50*50)-(valor20*20)-(valor10*10)-(valor5*5))/2.00;
valor2 = calc2;
//calculo das moedas
calcMoeda1 = (ValorEmDinheiro - (valor100*100.00)-(valor50*50.00)-(valor20*20.00)-(valor10*10.00)-(valor5*5.00)-(valor2*2.00))/1.00;
valorMoeda1 = calcMoeda1;
calcMoeda50 = (ValorEmDinheiro - (valor100*100.00)-(valor50*50.00)-(valor20*20.00)-(valor10*10.00)-(valor5*5.00)-(valor2*2.00)- (valorMoeda1*1.00))/0.50;
valorMoeda50 = calcMoeda50;
calcMoeda25 = (ValorEmDinheiro - (valor100*100.00)-(valor50*50.00)-(valor20*20.00)-(valor10*10.00)-(valor5*5.00)-(valor2*2.00)- (valorMoeda1*1.00)-(valorMoeda50*0.50)) /0.25;
valorMoeda25 = calcMoeda25;
calcMoeda10 = (ValorEmDinheiro - (valor100*100.00)-(valor50*50.00)-(valor20*20.00)-(valor10*10.00)-(valor5*5.00)-(valor2*2.00)- (valorMoeda1*1.00)-(valorMoeda50*0.50)-(valorMoeda25*0.25)) /0.10;
valorMoeda10 = calcMoeda10;
calcMoeda5 = (ValorEmDinheiro - (valor100*100.00)-(valor50*50.00)-(valor20*20.00)-(valor10*10.00)-(valor5*5.00)-(valor2*2.00)- (valorMoeda1*1.00)-(valorMoeda50*0.50)-(valorMoeda25*0.25)-(valorMoeda10*0.1)) /0.05;
valorMoeda5 = calcMoeda5;
calcMoeda01 = (ValorEmDinheiro - (valor100*100.00)-(valor50*50.00)-(valor20*20.00)-(valor10*10.00)-(valor5*5.00)-(valor2*2.00)- (valorMoeda1*1.00)-(valorMoeda50*0.50)-(valorMoeda25*0.25)-(valorMoeda10*0.1)-(valorMoeda5*0.05)) /0.01;
valorMoeda01 = calcMoeda01;
//mostrar dados
cout << fixed << setprecision(2);
cout << "NOTAS:" << endl;
cout << valor100 << " nota(s) de R$ 100.00" << endl;
cout << valor50 << " nota(s) de R$ 50.00" << endl;
cout << valor20 << " nota(s) de R$ 20.00" << endl;
cout << valor10 << " nota(s) de R$ 10.00" << endl;
cout << valor5 << " nota(s) de R$ 5.00" << endl;
cout << valor2 << " nota(s) de R$ 2.00" << endl;
cout << "MOEDAS:" << endl;
cout << valorMoeda1 << " moeda(s) de R$ 1.00" << endl;
cout << valorMoeda50 << " moeda(s) de R$ 0.50" << endl;
cout << valorMoeda25 << " moeda(s) de R$ 0.25" << endl;
cout << valorMoeda10 << " moeda(s) de R$ 0.10" << endl;
cout << valorMoeda5 << " moeda(s) de R$ 0.05" << endl;
cout << valorMoeda01 << " moeda(s) de R$ 0.01" << endl;
return 0;
}

==========================================================================================
==========================================================================================

1037 - INTERVALO

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
 
using namespace std;
 
int main() {
 
    double Valor;
 
    cin >> Valor;
 
    if(Valor < 0 || Valor > 100){
        cout << "Fora de intervalo" << endl;
    }else if(Valor >= 0 && Valor <= 25){
        cout << "Intervalo [0,25]" << endl;
    }else if(Valor > 25 && Valor <= 50){
        cout << "Intervalo (25,50]" << endl;
    }else if(Valor > 50 && Valor <= 75){
        cout << "Intervalo [50,75]" << endl;
    }else if(Valor > 75 && Valor <= 100){
        cout << "Intervalo (75,100]" << endl;
    }
 
    return 0;
}

==========================================================================================
==========================================================================================

1042 - Sort Simples.

Código:

#include<iostream>
#include<cmath>
#include<iomanip>
 
using namespace std;
 
int main (){
 
int A,B,C,AUX,inicA,inicB,inicC;
 
cin >> A >> B >> C;
 
inicA = A;
inicB = B;
inicC = C;
 
if(A>B){
   AUX = A;
   A = B;
   B = AUX;
}
if(B>C){
   AUX = B;
   B = C;
   C = AUX;
}
if(A>B){
   AUX = A;
   A = B;
   B = AUX;
}
cout << A << endl;
cout << B << endl;
cout << C << endl << endl;
cout << inicA << endl;
cout << inicB << endl;
cout << inicC << endl;
 
return 0;
}


==========================================================================================
==========================================================================================

1046-Tempo de Jogo Seleção 

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
 
using namespace std;
 
int main (){
 
int Hora1,Hora2;
 
cin >> Hora1 >> Hora2;
 
if(Hora1 > Hora2){
    int horasDia1 = 24-Hora1;
    int horasDia2 = Hora2;
     cout << "O JOGO DUROU " << horasDia1+horasDia2 << " HORA(S)" << endl;
}else if(Hora1 < Hora2){
    int horasDoJogo = Hora2 - Hora1;
    cout << "O JOGO DUROU " << horasDoJogo << " HORA(S)" << endl;
}else if(Hora1 == Hora2){
    cout << "O JOGO DUROU 24 HORA(S)" << endl;
}
return 0;
}


==========================================================================================
==========================================================================================

1047 - Tempo de Jogo com Minutos

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
 
double hora1,minuto1,hora2,minuto2;
cin >> hora1 >> minuto1 >> hora2 >> minuto2;
 
if((hora1*60 + minuto1) < (hora2*60 + minuto2)){
    int duracao = ((hora2*60 + minuto2)-(hora1*60 + minuto1));
    int horasJogo = duracao/60;
    int minutosJogo = duracao - horasJogo*60;
    cout << "O JOGO DUROU " <<  horasJogo << " HORA(S) E " << minutosJogo << " MINUTO(S)" << endl;
}
else if((hora1*60 + minuto1) > (hora2*60 + minuto2)){
    //dia1
    int horasDia1 = (24*60 - (hora1*60 + minuto1))/60;
    int minutosDia1 = (24*60 - (hora1*60 + minuto1)) - horasDia1*60;
    //dia 2
    int horasDia2 = (hora2*60 + minuto2)/60;
    int minutosDia2 = (hora2*60 + minuto2) - horasDia2*60;
    //soma
    int soma = horasDia1*60 + minutosDia1 + horasDia2*60 + minutosDia2;
    int horasTotais = soma/60;
    int minutosTotais = soma - horasTotais*60;
    cout << "O JOGO DUROU " <<  horasTotais << " HORA(S) E " << minutosTotais << " MINUTO(S)" << endl;
}
else if((hora1*60 + minuto1) == (hora2*60 + minuto2)){
    cout << "O JOGO DUROU 24 HORA(S) E 0 MINUTO(S)" << endl;
}
    return 0;
}


==========================================================================================
==========================================================================================

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
  
using namespace std;
  
int main() {    
  
for(int x = 2; x < 101; x++){
    if(x%2 == 0){
        cout << x << endl;
    }
}
  
return 0;
}

==========================================================================================
==========================================================================================

Código:

#include <iostream>
#include <cmath>
#include <iomanip>

using namespace std;

int main() {
double valor, positivos=0;
for(int x = 0; x < 6; x++){
    cin >> valor;
    if(valor > 0){
        positivos++;
    }
}
cout << positivos << " valores positivos" << endl;
return 0;
}

==========================================================================================
==========================================================================================

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main() {
int elemento;
int par = 0, impar = 0, positivo = 0, negativo = 0;
for(int x = 0; x < 5; x++){
    cin >> elemento;
    if(elemento%2 == 0){
        par = par +1;
    }
    if(elemento%2 != 0){
        impar = impar +1;
    }
    if(elemento < 0){
        negativo = negativo +1;
    }
    if(elemento > 0){
        positivo = positivo +1;
    }
}
    cout << par << " valor(es) par(es)" << endl;
    cout << impar << " valor(es) impar(es)" << endl;
    cout << positivo << " valor(es) positivo(s)" << endl;
    cout << negativo << " valor(es) negativo(s)" << endl;
    return 0;
}

==========================================================================================
==========================================================================================

1073 - Quadrado de Pares

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
  
using namespace std;
  
int main() {
  
    int N;
    cin >> N;
  
    for (int x = 1; x <= N; x++){
        if(x%2 == 0){
            cout << x << "^2 = " << x*x << endl;
        }
    }
    return 0;
}

==========================================================================================
==========================================================================================

1074 - Par ou Ímpar

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
  
using namespace std;
  
int main() {
  
int quantidade;
cin >> quantidade;
  
int lista [quantidade];
for(int x = 0; x < quantidade; x++){
    cin >> lista[x];
}
for(int x = 0; x < quantidade; x++){
    if(lista[x]%2 == 0 && lista[x] > 0){
        cout << "EVEN POSITIVE" << endl;
    }
    else if(lista[x]%2 == 0 && lista[x] < 0){
        cout << "EVEN NEGATIVE" << endl;
    }
    else if(lista[x]%2 != 0 && lista[x] > 0){
        cout << "ODD POSITIVE" << endl;
    }
    else if(lista[x]%2 != 0 && lista[x] < 0){
        cout << "ODD NEGATIVE" << endl;
    }
    else if(lista[x] == 0){
        cout << "NULL" << endl;
    }  
}
return 0;
}

==========================================================================================
==========================================================================================

1075 - Resto 2

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
  
using namespace std;
  
int main (){
  
int N;
  
cin >> N;
  
for(int x = 1; x < 10001; x++){
    if(x%N == 2){
        cout << x << endl;
    }
}

return 0;
}

==========================================================================================
==========================================================================================

1078 - Tabuada

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
  
using namespace std;
  
int main (){
  
int N;
cin >> N;
  
for(int x = 1; x < 11; x++){
    cout << x << " x " << N << " = " << N*x << endl;
}
  
return 0;
}

==========================================================================================
==========================================================================================


==========================================================================================
==========================================================================================


1145 - Sequência Lógica 2

Código:

#include <iostream>
#include <cmath>

using namespace std;
 
int main() {
    
    int numElementos=0,numFinal=0,aux=0;
    cin >> numElementos >> numFinal;
    
    for(int x = 1; x <= numFinal; x++){
        cout << x;
        aux++;
        if(aux >= numElementos){
         aux = 0;
         cout << endl;
        }else{
            cout << " ";
        }
    }
    return 0;
}


==========================================================================================
==========================================================================================


1154 - Idades

Código:

#include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main (){
    double somaIdades = 0,Idade = 1,quantidadeIdades = 0;
    while(Idade > 0){
        cin >> Idade;
        if(Idade > 0){
            somaIdades = somaIdades + Idade;
            quantidadeIdades++;
        }
    }
    cout << fixed << setprecision(2);
    cout << (somaIdades/quantidadeIdades) << endl;
return 0;
}

==========================================================================================
==========================================================================================

1165 - Número Primo

Código:

#include <iostream>
using namespace std;
int main(){
 int testes;
 cin >> testes;
 while(testes--){
 int num;
 int sum=0;
 cin >> num;
 for (int i =1; i < num/2+1; i++){
 if (num%i == 0){
 sum += i;
 }
 }
 if (sum == 1){
 cout << num << " eh primo" << endl;
     }else{
 cout << num << " nao eh primo" << endl;
        }
 }
}

==========================================================================================
==========================================================================================
1051 - Imposto de Renda.

Código:

#include <iostream>
#include <cmath>
#include <iomanip>

using namespace std;

int main() {   

double salario;
cin >> salario;

cout << fixed << setprecision(2);
if(salario <= 2000){
   cout << "Isento" << endl;
}
else if(salario > 2000 && salario <= 3000){
   double valor = salario - 2000;
   cout << "R$ " << (valor/100)*8 << endl;
}
else if(salario > 3000 && salario <= 4500){
   double valor = salario - 3000;
   cout << "R$ " << 80 + (valor/100)*18 << endl;
}
else if(salario > 4500){
   double valor = salario - 4500;
   cout << "R$ " << 350 + (valor/100)*28 << endl;
}

return 0;
}

==========================================================================================
==========================================================================================
1049 - Animal

Código:

#include <iostream>
#include <cmath>
#include <iomanip>

using namespace std;

int main() {   

string A,B,C;
cin >> A >> B >> C;

if(A == "vertebrado"){
   if(B == "ave"){
      if(C == "carnivoro"){
         cout << "aguia" << endl;
      }
      if(C == "onivoro"){
         cout << "pomba" << endl;
      }
   }
   if(B == "mamifero"){
      if(C == "onivoro"){
         cout << "homem" << endl;
      }
      if(C == "herbivoro"){
         cout << "vaca" << endl;
      }
   }
}
if(A == "invertebrado"){
   if(B == "inseto"){
      if(C == "hematofago"){
         cout << "pulga" << endl;
      }
      if(C == "herbivoro"){
         cout << "lagarta" << endl;
      }
   }
   if(B == "anelideo"){
      if(C == "hematofago"){
         cout << "sanguessuga" << endl;
      }
      if(C == "onivoro"){
         cout << "minhoca" << endl;
      }
   }
}


return 0;

}

==========================================================================================
==========================================================================================
1157 - Divisores I

Código:

#include <iostream>
#include <iomanip>
#include <cmath>

using namespace std;

int main (){

int Numero;
cin >> Numero;

for(int x = 1; x <= Numero; x++){
    if(Numero%x == 0){
        cout << x << endl;
    }
}
return 0;
}


==========================================================================================
==========================================================================================
1191 - Recuperação da Árvore

Código:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
typedef struct tipoArvore {
    char valor;
    int peso;
    struct tipoArvore *esquerdo;
    struct tipoArvore *direito;
} tipoArvore;
typedef struct pesoLetras {
    int peso;
    char letra;
} tipoPeso;
tipoArvore *alocaElemento ( char valor, int peso ) {
    tipoArvore *novo = NULL;
    novo = (tipoArvore* ) malloc ( sizeof ( tipoArvore ) );
    novo->esquerdo = NULL;
    novo->valor = valor;
    novo->peso = peso;
    novo->direito = NULL;
    return novo;
}
void inserirArvore ( tipoArvore **arvore, char valor, int peso ) {
    if ( *arvore == NULL ) {
        *arvore = alocaElemento ( valor, peso );
    }
    else {
        if ( peso < (*arvore)->peso ) {
            inserirArvore ( &(*arvore)->esquerdo, valor, peso );
        }
        else {
            inserirArvore ( &(*arvore)->direito, valor, peso );
        }
    }
}
void imprimePosOrdem ( tipoArvore *arvore ) {
    if ( arvore != NULL ) {
        imprimePosOrdem ( arvore->esquerdo );
        imprimePosOrdem ( arvore->direito );
        printf ( "%c", arvore->valor );
    }
}
int retornaPeso ( tipoPeso pesoE[], char letra, int len ) {
    int i, peso;
    for ( i=0; i<len; i++ ) {
        if ( pesoE[i].letra == letra ) {
            peso = i;
            break;
        }
    }
    return peso;
}
int main ( int argc, char *argv[] ) {
    tipoArvore *arvore;
    tipoPeso pesoE[28];
    char preordem[27], ordem[27];
    int len, i, ps;
    while ( scanf ( "%s %s", preordem, ordem ) != EOF ) {
        arvore = NULL;
        len = strlen ( ordem );
        for ( i=0; i<len; i++ ) {
            pesoE[i].letra = ordem[i];
            pesoE[i].peso = i;
        }
        for ( i=0; i<len; i++ ) {
                ps = retornaPeso ( pesoE, preordem[i], len );
                inserirArvore ( &arvore, preordem[i], ps );
        }
        imprimePosOrdem ( arvore );
        printf( "\n" );
    }
    return 0;
}


Detalhe, este 1191 não é de minha autoria... minha sintaxe e modo de trabalhar são um pouco diferentes...

Ok..
Meu programa no DEV C++ apresenta o mesmo resultado que o seu Marcos....
Mas não tem jeito não consigo resolver o problema do PRESENTATION ERROR, que no site da Uri apresenta a seguinte descrição abaixo...
____________________________________________________________________________
PRESENTATION ERROR
Se a sua solução receber "Presentation  Error", isto é, erro de apresentação, na verdade ela já está praticamente correta, apenas há erro na quantidade de espaços ou letras inversão de letras maiúsculas / minúsculas. 
Por exemplo, se a saída correta para o problema for:
"X = 5" 
E seu programa apresentar qualquer uma das saídas abaixo: 
"X =  5"
"x = 5"
"x  =  5"
"X=5"
"X = 5 "
A resposta será "Presentation Error"...

O Presentation Error não ocorre somente por isto, ele também ocorre por erro de lógica para valores extremos. 

O criador do Uri Online Judge é da minha cidade ( da minha faculdade até, que é a URI )... Para ler os códigos enviados, ele criou um algoritmo que testa diversas sequências de entrada, com valores extremos ou improváveis, e se para algum destes valores estiver dando um resultado diferente daquele que está tabelado, também dará "Presentation Error"...

Como eu disse antes, ainda não entendi o motivo de você por este trecho de código no seu script:

cout << " \n ";


 Visto que o exercício não pede este Cout

Olá pessoal, sobre o exercício 1564 "Vai Ter Copa", gostaria de saber o que significa ''A entrada contém vários casos de teste e termina com EOF.'' O que seria terminar com EOF? Eu sei que EOF é uma abreviação para end-of-line, mas mesmo assim, como terminar um algoritmo sem uma quantidade específica de entradas com um EOF?

No próprio UriOnlijeJudge, se você clica em Submissão>Ajuda, tem uma explicação do que é cada coisa...

O QUE É UMA ENTRADA QUE TERMINA COM EOF?

Neste tipo de entrada não é especificada a quantidade de casos de teste. Pode ser 1,2 ou mais de 1 milhão.
Normalmente um arquivo de entrada com três casos de teste poderia ser assim:
7123
32
125

Em C++, esta leitura pode ser resolvida da seguinte forma:
int N;
while (cin >> N) {
...
}

Em Python, esta leitura pode ser resolvida da seguinte forma:
while True:
try:
...
except:
break

Isto significa que enquanto houver valores inteiros no arquivo de entrada, eles serão lidos para a variável N.

1187 e 1578?

1187 - Área Superior:

Código:

#include <iostream>
#include <stdio.h>

using namespace std;

int main() {

   double m[12][12];
   char ope;
   cin >> ope;
   double result=0;
   int qtd = 0;

   for(int i = 0; i<12; i++)
      for(int j = 0; j < 12; j++)
         cin >> m[i][j];

   for(int i = 0; i < 12; i++)
      for(int j = 0; j <12; j++)
         if( i + j < 11 && j > i){
            result += m[i][j];
            qtd++;
         }
   if(ope == 'M')
      result /= qtd;

   printf("%.1f\n",result);
}

Alguem pode me ajudar a fazer os exercicios do URI iniciante do 1005 ao 1015? eu também gostaria de saber como usar o printf e scanf no c++ ainda não consegui entender muito bem

Exercícios do 1001 a 1020 foram adicionados ao tópico.

Aguem fez as atividades do URI Online Judge na linguagem c++, os números 1036 e 1041 ? não to dando conta de faze-los por favor me ajudem

No 1036 não esquece da regra do Delta.
Eu fiz assim:
https://ibb.co/8DGkZkd

E o 1041:

https://ibb.co/KxWT0pX

eu coloquei a linguagem errada xD, e linguagem C++17 la do URI Online Judge, esses negocio de printf no grupo de onde eu participo da facul nao aceita, o 1036 tem ser igual esse 1041. se tiver como me mandar o 1036 sem os printf e scarf.

eu fiz o 1036 assim: Não sei o q ta faltando, ta dando Wrong answer (40%), a linguagem e C++17 (g++ 7.3.0, -std=c++17 -O2 -lm) [+0s].


não sei e biblioteca 


#include <iostream>
#include <math.h>
#include <iomanip>
using namespace std;

int main()
{
double A,B,C;
double delta,R1,R2;

cin>>A>>B>>C;

delta= pow (B,2-4*A*C);

R1= (-B + sqrt(delta))/(2*A);
R2= (-B-sqrt(delta))/(2*A);

if (B==0||delta==0)
{
cout<<"Impossivel calcular"<<"\n";
}
else 
{
cout<<"R1 = "<<fixed<<setprecision(5) << R1 <<"\n" <<"R2 = "<<fixed<<setprecision(5) <<R2;
}
return 0;
}