//Prototipo tipo_de_dato_de_devolucion nombre_de_funcion( tipo_de_dato dato_1 , tipo_de_de_dato dato_2 , ... ); //Implementacion tipo_de_dato_de_devolucion nombre_de_funcion( tipo_de_dato dato_1 , tipo_de_de_dato dato_2 , ... ){ //codigo }

#include <iostream> #include <stdlib.h> #include <stdio.h> //en linux para el getchar() solamente #include <math.h> using namespace std; /* Prototipo */ double hipotenusa_del_triangulo( double catetoA, double catetoB); int main(){ int h = 5; cout<<hipotenusa_del_triangulo( 3.0 , 4.0 ) <<endl ; cout<<hipotenusa_del_triangulo( 3.0 , 5.0 ) <<endl ; cout<<hipotenusa_del_triangulo( 6.0 , 8.0 ) <<endl ; system("pause"); } /* implementacion*/ double hipotenusa_del_triangulo( double catetoA, double catetoB){ double multA = catetoA * catetoA; double multB = catetoB * catetoB; double suma = multA + multB; return sqrt ( suma ); //sqrt es la funcion de raiz cuadrada de math.h  }

5 5.83095 10 Presione alguna tecla para continuar ...

#include <iostream> #include <stdlib.h> #include <stdio.h> //en linux para el getchar() solamente #include <math.h> using namespace std; /*Creamos una variable global*/ int variable_global = 5; /* Prototipo */ void funcion_sumar(); int main(){ int variable_local = 5; /* variable local */ for (int x = 0;x < 5;x++){ funcion_sumar(); } cout<<variable_global<<endl; cout<<variable_local<<endl; system("pause"); } /* implementacion */ void funcion_sumar(){ int variable_local = 5; variable_local ++; variable_global += 1; }

10 5 Presione alguna tecla para continuar ...

tipo_de_dato nombre_array[cantidad_de_valores];

int lista[100];

#include <iostream> #include <stdlib.h> #include <stdio.h> //en linux para el getchar() solamente #include <math.h> using namespace std; /*Creamos un array global*/ int array_global[5]; /* Prototipo */ void mostrar_array_global(); int main(){ /*creamos un array local*/ double array_local[3]; for (int v = 0;v < 3;v++){ array_local[v] = 2-v; array_local[v] ++; } for (int x = 0;x < 5;x++){ array_global[x] = x * 2; } for (int j = 0;j < 3;j++){ cout<< array_local[j] << endl; } mostrar_array_global(); system("pause"); } /* implementacion */ void mostrar_array_global(){ cout<<"Array global:"<<endl; for (int w = 0;w < 5;w++){ cout<<array_global[w]<<endl; } }

3 2 1 Array global: 0 2 4 6 8 Presione una tecla para continuar . . .

vector <tipo_de_datos a almacenar> nombre_vector;

nombre_vector[numero_de_dato] = algo; o algo = nombre_vector[numero_de_dato]

nombre_vector.push_back ( dato ); //dato tiene que ser del tipo_de_datos_a_almacenar del vector

nombre_vector.erase( nombre_vector.begin() + numero_de_dato);

nombre_vector.pop_back();

variable = nombre_vector.back() //ultimo valor variable2 = nombre_vector.front() //primer valor //variable y variable2 son del tipo del vector

tamanio = nombre_vector.size(); //tamanio es un int.

nombre_vector.clear();

#include <iostream> #include <stdlib.h> #include <stdio.h> //en linux para el getchar() solamente #include <vector> //usaremos vectores! using namespace std; //En este programa vamos a hacer un vector donde almacenaremos los numeros primos del 1 al 100. y uno de los que no son primos vector <int> numeros_primos; vector <int> numeros_compuestos; bool es_primo(int numero); //Funcion para revisar si un numero es primo, devuelve 1 si es cierto, 0 si no lo es void mostrar_numeros_primos(); //Funcion que nos muestra el contenido del vector de primos en un momento determinado del programa void mostrar_numeros_compuestos(); //Funcion que nos muestra el contenido del vector de compuestos en un momento determinado del programa int main(){ for (int n = 2;n < 50;n++){ bool primo = es_primo(n); if (primo){ numeros_primos.push_back( n ); }else{ numeros_compuestos.push_back( n ); } } //mostramos los vectores mostrar_numeros_primos(); mostrar_numeros_compuestos(); system("pause"); //en linux es cout<<"Presione una tecla para continuar ..."<<endl; while (getchar() != '\n'){}; } bool es_primo(int numero){ //Esta funcion no tiene eficiencia maxima para no complicar, pero hay varias cosas que se pueden hacer para reducir el tiempo que demora for (int divido = 2;divido < numero;divido ++){ if (numero % divido == 0){ return false; //no es primo, se puede dividir por un numero != 1 y != a numero } } return true; //si es primo } void mostrar_numeros_primos(){ cout<<"Numeros primos :"<<endl; for (int v = 0;v < numeros_primos.size();v++){ //recorro todos los valores del vector, de 0 a el .size() del vector, es decir, su ultimo valor+1 cout << numeros_primos[v] << endl; } } void mostrar_numeros_compuestos(){ cout<<"Numeros compuestos :"<<endl; for (int v = 0;v < numeros_compuestos.size();v++){ //recorro todos los valores del vector, de 0 a el .size() del vector, es decir, su ultimo valor+1 cout << numeros_compuestos[v] << endl; } }

Numeros primos : 2 3 5 7 11 13 17 19 23 29 31 37 41 43 47 Numeros compuestos : 4 6 8 9 10 12 14 15 16 18 20 21 22 24 25 26 27 28 30 32 33 34 35 36 38 39 40 42 44 45 46 48 49 Presione una tecla para continuar ...

tipo_de_dato nombre_de_matriz[ancho][alto]; //creamos matriz

nombre_de_matriz[columna][fila]; //este valor podemos o leerlo o escribirlo como querramos, de la misma forma que con los arrays de antes.

#include <iostream> #include <stdlib.h> //para el system("pause"); #include <stdio.h> //en linux para getchar() using namespace std; int mapa[11][11]; //creamos una matriz de 11x11, ya que la tabla de multiplicar va del 0 al 10, que son 0 1 2 3 4 5 6 7 8 9 10, que son 11 numeros contando el 0 /* Prototipo */ void mostrar_mapa(); int main(int argc, char** argv) { for (int columna = 0;columna < 11;columna ++){ //recorro desde la columna 0 hasta la columna 10 incluyendo for (int fila = 0;fila < 11;fila ++){ //por cada columna calculo el valor de la celda de la tabla, siempre es (por la definicion de la tabla de multiplicar), fila * columna. mapa [ columna ] [ fila ] = columna * fila; //asigno el valor de la columna columna, fila fila, el valor de fila*columna, eso entonces a cada celda particular de la tabla } } mostrar_mapa(); //mostramos la tabla generada system("pause"); } /* Implementacion */ void mostrar_mapa(){ for (int fila = 0;fila < 11;fila ++){ //por cada fila for (int columna = 0;columna < 11;columna ++){ //por cada columna de cada fila bool menor_100 = mapa[ columna ][ fila ] < 100; //guardo si es menor a 100 su valor bool menor_10 = mapa[ columna ][ fila ] < 10; //guardo si es menor a 10 su valor if (menor_10){ //para visualizar mejor si es menor a 10, agregamos dos espacios ( ej: estos 3 valores ocupan el mismo espacio 3 ,33 ,333 ) cout<< mapa[ columna ][ fila ]<<" "; //esto me imprime el valor de mapa[ columna ][ fila ] sumado a dos espacios (sin saltar de a la proxima linea en el proximo cout) }else if(menor_100){ //si es mejor a 100 agregamos solo un espacio (gastamos dos numeros, agregamos un solo espacio) cout<< mapa[ columna ][ fila ]<<" "; //esto me imprime el valor de mapa[ columna ][ fila ] sumado a un espacio (sin saltar de a la proxima linea en el proximo cout) }else{ //si es mayor o igual a 100 (3 cifras), no agregamos espacios cout<< mapa[ columna ][ fila ]; } //notar que como no usamos endl, el contenido se escribe todo en la misma linea } cout<<""<<endl; //pasamos a la proxima linea de escritura } }

0 0 0 0 0 0 0 0 0 0 0 0 1 2 3 4 5 6 7 8 9 10 0 2 4 6 8 10 12 14 16 18 20 0 3 6 9 12 15 18 21 24 27 30 0 4 8 12 16 20 24 28 32 36 40 0 5 10 15 20 25 30 35 40 45 50 0 6 12 18 24 30 36 42 48 54 60 0 7 14 21 28 35 42 49 56 63 70 0 8 16 24 32 40 48 56 64 72 80 0 9 18 27 36 45 54 63 72 81 90 0 10 20 30 40 50 60 70 80 90 100 Presione una tecla para continuar ...

vector <vector <int> > nombre_matriz;

vector <int> linea; linea.push_back( 5 ); //a la linea le agregamos un 5 linea.push_back( 2 ); //a la linea le agregamos un 2 nombre_matriz.push_back(linea); //a la tabla le agregamos la linea

#include <iostream> #include <stdlib.h> //para el system pause #include <stdio.h> //en linux necesario para getchar(); #include <vector> //usaremos vectores! using namespace std; vector < vector <int> > datos_divisores; //creamos el vector donde almacenamos los datos de divisores /* Prototipos */ void mostrar_vector(); vector <int> obtener_divisores(int numero); //devuelve un vector<int>! int main(){ for (int n = 1;n <= 10;n++){ /* Calculamos los divisores desde 1 hasta 10 y los almacenamos en el vector */ vector <int> divisores = obtener_divisores( n ); //Esta funcion devuelve un vector<int> con los divisores datos_divisores.push_back( divisores ); //agregamos esa linea (=lista) a los datos de divisores } mostrar_vector(); //mostramos el vector system("pause"); //en linux el cout<<"Presione una tecla para continuar..."; while (getchar()!='\n'){}; } vector <int> obtener_divisores(int numero){ vector <int> divisores; //creamos el vector donde almacenaremos los divisores for (int d = 1;d <= numero;d++){ //revisamos todos los numeros de 1 al numero if (numero % d == 0){ //si el numero puede dividise por d divisores.push_back( d ); //lo agrego al vector el numero que divide. } } return divisores; //devuevlo el vector } void mostrar_vector(){ //funcion para mostrar graficamente el vector (la matriz) for (int v = 0;v < datos_divisores.size();v++){ //por cada linea de la matriz if (v+1 < 10){ //esto es para que si es menor que 10, que ocupe el mismo espacio, y se vea mejor cout<<v+1<<" : {"; }else{ cout<<v+1<<": {"; } //ej 10: y 9 :, ocupan el mismo espacio for (int vv = 0;vv < datos_divisores[v].size();vv++){ //por cada divisor almacenado en la linea cout<<datos_divisores[v][vv]; //lo muestro sin hacer espacio if (vv != datos_divisores[v].size() - 1){ //si no es el ultimo no agrego la coma para que se vea mejor cout<<" , "; } } cout<<"}"<<endl; } }

1 : {1} 2 : {1 , 2} 3 : {1 , 3} 4 : {1 , 2 , 4} 5 : {1 , 5} 6 : {1 , 2 , 3 , 6} 7 : {1 , 7} 8 : {1 , 2 , 4 , 8} 9 : {1 , 3 , 9} 10: {1 , 2 , 5 , 10} Presione una tecla para continuar . . .

El algoritmo de Ecluides es una forma de obtener el maximo comun divisor de dos numeros (es decir, el numero mas mas grande que divide sin resto dos numeros), que consiste en restar el mas grande de los dos numeros por el menor hasta que ambos numeros sean iguales. Realizar una solucion recursiva del problema fuente: ocw. udl. cat /enginyeria-i-arquitectura/programacio-2/problemes-2/2-problemas-de-recursividad.pdf (sin espacios)

#include <iostream> #include <stdlib.h> //para el system pause #include <stdio.h> //en linux necesario para getchar(); #include <vector> //usaremos vectores! using namespace std; /*** Prototipo ***/ int mcd(int A,int B); /*** Main ***/ int main(){ cout << mcd(412,184) << endl; cout << mcd( 12, 25) << endl; cout << mcd( 56, 34) << endl; system("pause"); } /*** Implementacion ***/ int mcd(int A,int B){ if (A > B){ //como a > b entonces le resto a A, B A = A - B; } if (B > A){ //como b > a entonces le resto a A, B B = B - A; } if (A == B){ //si son iguales ya consegui el mcd return A; //devuelvo A, pero tambien podria devolver B, son ambos iguales }else{ return mcd(A,B); //entonces devuelvo el resultado de los dos numeros que quedaron } }

4 1 2 Presione cualquier tecla para continuar ...

tipo_de_dato nombre_de_referencia;

#include <iostream> #include <string> using namespace std; int main(){ //con este codigo marcamos tres espacios de memoria ram en nuestra computadora. No les damos ningun valor, solo los reservamos para nuestro programa int altura; double cambio; string un_string; }

#include <iostream> #include <string> using namespace std; int main(){ //con este codigo marcamos tres espacios de memoria ram en nuestra computadora. No les damos ningun valor, solo los reservamos para nuestro programa int altura; double cambio; string un_string; //altura, cambio y un_string ya fueron reservadas en la memoria en el bloque de codigo de arriba) altura = 5; cambio = 7.34; un_string = "hola"; //con comillas }

#include <iostream> //para poder usar cout #include <stdlib.h> //para poder usar system pause #include <stdio.h> //solo es nescesario en linux, si se usa getchar(), para el comando que arriba puse, si usas windows ignoralo podes borrar esta linea #include <string> //para poder usar string, no interesa pero siempre que usemos strings agregamos esta linea using namespace std; int main(){ //con este codigo marcamos tres espacios de memoria ram en nuestra computadora. No les damos ningun valor, solo los reservamos para nuestro programa int altura; double cambio; string un_string; //altura, cambio y un_string ya fueron reservadas en la memoria en el bloque de codigo de arriba) altura = 5; cambio = 7.34; un_string = "hola"; //con comillas //mostramos los valores cout<<altura<<endl; cout<<cambio<<endl; cout<<un_string<<endl; //frenamos el programa system("pause"); //en linux seria cout<<"presione una tecla para continuar..."<<endl; while (getchar()!='\n'){}; }

#include <iostream> #include <stdlib.h> #include <math.h> //vamos a usar pow!  //en linux iria stdio.h using namespace std; int main(){ //con este codigo marcamos tres espacios de memoria ram en nuestra computadora. No les damos ningun valor, solo los reservamos para nuestro programa int altura; double cambio; int operacion; double operacion2; //altura, cambio y un_string ya fueron reservadas en la memoria en el bloque de codigo de arriba) altura = 5; cambio = 7.34; operacion = (altura + cambio) * 2; //o sorpresa, ¡podemos usar parentesis y hacer expresiones matematicas! operacion2 = pow(double(altura),double(cambio)) //se nos antojo elevar altura a cambio y guardar ese valor en la variable (=espacio de memoria) operacion2 //en pow se debe a cualquier variable ponerle un double(nombre_de_variable) en vez de poner nombre_de_variable directamente. puedo explicar proque pero se va a hacer muy largo //mostramos cout<<operacion<<endl; cout<<operacion2<<endl; system("pause"); //en linux se remplaza por el otro comando  }

int variable; variable = 5;

int variable = 5; //mas rapido

int A; int B; int C; A = 5; B = 5; C = 5;

int A; int B; int C; A = B = C = 5; //esto es equivalente a lo de arriba

#include <iostream> #include <stdlib.h> //en linux iria stdio.h using namespace std; int main(){ bool variableA = true; bool variableB = 0; cout<<variableA<<endl; cout<<variableB<<endl; system("pause"); //en linux se remplaza por el otro comando  }

#include <iostream> #include <stdlib.h> //en linux iria stdio.h using namespace std; int main(){ bool variableA = 1; bool variableB = 0; bool rtaA = (variableA and variableB); bool rtaB = (variableA || variableB); bool rtaC = (!variableA); bool rtaD = ( ! ( (not variableA) or (variableB) ) ); //o magia podemos usar parentesis como con las operaciones matematicas. //mostramos cout<<rtaA<<endl; cout<<rtaB<<endl; cout<<rtaC<<endl; cout<<rtaD<<endl; system("pause"); //en linux se remplaza por el otro comando  }

#include <iostream> #include <stdlib.h> //en linux iria stdio.h using namespace std; int main(){ bool variableA; bool variableB; int numero = 6; double otro_numero = numero + 2; variableA = (numero >= 4); //almacenamos el resultado de la condicion en variableA, siempre en C++ las condiciones van entre () variableB = (otro_numero != numero); //almacenamos el resultado de la condicion en variableB cout<<variableA<<endl; cout<<variableB<<endl; cout<<(variableA and variableB)<<endl; //se puede escribir directamente esto mas facil system("pause"); //en linux se remplaza por el otro comando  }

#include <iostream> #include <stdlib.h> #include <string> //en linux iria stdio.h using namespace std; int main(){ //creamos variables y guardamos un espacio de memoria string int variable1 = 34; int variable2 = 32; string informacion; bool condicion1 = (variable1 == variable2); bool condicion2 = (variable1 >= variable2); if (condicion1){ //se corren estos comandos si condicion1 = 1 informacion = "la condicion 1 es cierta"; }else if(condicion2){ //se corren estos comandos si condicion1 = 0 y condicion2 = 1 informacion = "la condicion 2 es cierta"; }else{ //se corre si condicion1 = 0 y condicion2 = 0 informacion = "ninguna condicion es cierta"; } //mostramos cout<<informacion<<endl; //cout no es solo para enteros sino que tambien puede mostrar strings o sea cadenas de texto.  system("pause"); //en linux se remplaza por el otro comando  }

#include <iostream> #include <stdlib.h> #include <string> //en linux iria stdio.h using namespace std; int main(){ //creamos variables y guardamos un espacio de memoria string int variable1 = 34; int variable2 = 32; string informacion; if ( (variable1 == variable2)){ informacion = "la condicion 1 es cierta"; }else if((variable1 >= variable2)){ informacion = "la condicion 2 es cierta"; }else{ //se corre si condicion1 = 0 y condicion2 = 0 informacion = "ninguna condicion es cierta"; } //mostramos cout<<informacion<<endl; //cout no es solo para enteros sino que tambien puede mostrar strings o sea cadenas de texto.  system("pause"); //en linux se remplaza por el otro comando  }

for ( creo una variable y le asigno un valor ; una condicion a revisar, el for se mantendra mientras su resultado sea 1 o true ; que hago cada vez que las lineas de codigo dentro de las {} se corren){ //codigo a repetir n veces }

#include <iostream> #include <stdlib.h> //en linux iria stdio.h using namespace std; int main(){ for (int una_variable = 1;una_variable + 1 < 10;una_variable = una_variable + 2){ cout<<"se corrio el for"<<endl; cout<<una_variable<<endl; } system("pause"); //en linux el otro que vimos }

se corrio el for 1 se corrio el for 3 se corrio el for 5 se corrio el for 7 Presione una tecla para continuar...

#include <iostream> #include <stdlib.h> //en linux iria stdio.h using namespace std; int main(){ int variable = 1; while (variable < 100){ cout<<variable<<endl; variable += variable; //esto es nuevo, pero es sencillo, es equivalemte a escribir variable = variable + variable. += significa incrementar el valor de la variable en tanto. } system("pause"); //en linux el otro comando }

#include <iostream> #include <stdlib.h> //en linux iria stdio.h using namespace std; int main(){ int variable = 10; switch (variable){ case 5: cout<<"la variable es 5"<<endl; break; case 3: cout<<"la variable es 3"<<endl; break; case 10: cout<<"la variable es 10"<<endl; break; default: cout<<"la variable no es ni 5, ni 3, ni 10"<<endl; break; } system("pause"); //en linux el otro comando }

la variable es 10

#include <iostream> #include <stdlib.h> //en linux iria stdio.h using namespace std; int main(){ bool condicion = false; int variable = condicion ? 5 : 2; cout<<variable<<endl; system("pause") //en linux el otro comando }

2

#include <iostream> #include <stdlib.h> //en linux iria stdio.h using namespace std; int main(){ int variable = 5; cout<<(variable > 4 ? "hola" : "chau")<<endl; system("pause"); }

hola

if (condA){ if (condB){ } }

if (condA){ if (condB){ for (int a = 0;a < 100;a++){ int b = 0; while (b < 100){ for (int j = 0;j < 100;j++){ } } for (int w = 0;w <= 234;w+=3){ if (w == 244){ cout<<"hola"<<endl; } } } } }

/* * File: main.cpp * Author: ariel * * Created on June 27, 2014, 8:19 PM */ #include <iostream> using namespace std; const int cantidad_numeros = 9; //cantidad de numeros const int cantidad_primos = 6; //cantidad de primos que usamos int numeros[cantidad_numeros] = {5, 22, 91, 455, 2002, 19945, 87758, 438790, 48266900}; //numeros int primos[cantidad_primos] = {2,5,7,11,13,3989}; //almaceno dichos primos int numeros_por_primo[cantidad_numeros][cantidad_primos]; //los primos son 2, 5, 7, 11, 13 y 3989 para formar los numeros, guardamos a que numero se eleva cada integrante de la factorizacion bool resultados_multiplicacion[7][7][4][7][4][5]; //el maximo numero que podemos obtener es 2^6*5^6*7^3*11^6*13^3*3989^4.  //Estoy almacenando una supermatriz de 6 dimensiones donde guardo para cada numero true si ya lo marque y es uno de los productos posibles y false si no //De esta forma gasto mas memoria, pero mejoro eficiencia ya que recorrer un vector del 0 al n es mucho mas lento que revisar directamente un lugar del mismo //Como no hay limite de memoria optamos por esta solucion bool selected[cantidad_numeros] = { false,false,false,false,false,false,false,false,false }; //los numeros que estoy revisando multiplicar. false si no, true si si int profundidad = 0; //la profundidad de la iteracion de la recursiva, para el problema en si no interesa, es solo para el metodo de generar los binarios desde 000... hasta 111... int cantidad = 0; //cantidad de soluciones /* Prototipos */ void recall(); //La funcion recursiva nescesariaa para los binarios de 000.... a 111... bool todos_cero(); //Revisamos si todos los binarios son 00000 que no vale void calcular_primos(); //Calculamos la factorizacion de primos de cada numero y la almacenamos en el array numeros_por_primo void calcular_primo(int x); //calcular la factorizacion de un primo del numero x (es solo para organizar) void revisar_multiplicacion(); //hacemos la multiplicacion, revisamos si existe si no existe la marcamos como true el numero y sumamos 1 a la cantidad void setear_0(); //inicializamos la supermatriz para guardar todos los resultados que puede dar la multiplicacion int main(int argc, char** argv) { setear_0(); //inicializo la supermatriz calcular_primos(); //calculam os los primos  recall(); //invocamos la recursiva cout<<cantidad<<endl; //mostramos la respuesta } void recall(){ if (profundidad == cantidad_numeros){ if (todos_cero()){ return; //ignoro } revisar_multiplicacion(); //reviso la multiplicacion si se repite y sumo a cantidad }else{ for (int it = 0;it < 2;it++){ profundidad ++; recall(); //entro un nivel de profundidad y rellamo profundidad --; selected[profundidad] = !selected[profundidad]; //paso de 0 a 1. Para entender se debe tener el conocimiento basico de recursiva, si lo explico de 0 es muy largo } } } bool todos_cero(){ //algoritmo sencillo for (int x = 0;x < cantidad_numeros;x++){ if (selected[x] != false){ return false; } } return true; } void calcular_primos(){ for (int x = 0;x < cantidad_numeros;x++){ //por cada numero calcular_primo(x); //calculo primos } } void calcular_primo(int numero){ int valor_numero = numeros[numero]; for (int p = 0;p < cantidad_primos;p++){ int primo_actual = primos[p]; while (valor_numero % primo_actual == 0){ valor_numero /= primo_actual; //divido por el primo actual numeros_por_primo[ numero ] [ p ] ++; //elevo en la factorizacion de primos al numero por 1 mas, ej /****** procedimiento de factorizacion en los 6 primos posibles 48266900 /2 24133450 * 2^1 /2 12066725 * 2^2 /5 2413345 * 2^2 * 5^1 /5 482669 * 2^2 * 5^2 /7 no puedo /11 43879 * 2^2 * 5^2 * 7^0 * 11^1 /11 3989 * 2^2 * 5^2 * 7^0 * 11^2 /3989 1 * 2^2 * 5^2 * 7^0 * 11^2 * 13^0 * 3989 ^ 1 entonces mi arreglo tiene { 2 , 2 , 0 , 2 , 0 , 1 } *******/ } } } void revisar_multiplicacion(){ //multiplico sumando los exponentes int multiplicacion[cantidad_primos]; for (int v = 0;v < cantidad_primos;v++){ multiplicacion[v] = 0; //inicializo en 0 } for (int x = 0;x < cantidad_numeros;x++){ if (selected[x] == false){ //si no es uno de los numeros que multiplico continue; } for (int y = 0;y < cantidad_primos;y++){ multiplicacion[y] += numeros_por_primo[x][y]; //sumo cada uno de los exponentes primos individualmente } } if ( !resultados_multiplicacion[ multiplicacion[0] ][ multiplicacion[1] ][ multiplicacion[2] ][ multiplicacion[3] ][ multiplicacion[4] ][ multiplicacion[5] ] ){ //si no lo marque resultados_multiplicacion[ multiplicacion[0] ][ multiplicacion[1] ][ multiplicacion[2] ][ multiplicacion[3] ][ multiplicacion[4] ][ multiplicacion[5] ] = true; //lo marco y sumo cantidad++; } } void setear_0(){ for (int a = 0;a < 7;a++){ for (int b = 0;b < 7;b++){ for (int c = 0;c < 4;c++){ for (int d = 0;d < 7;d++){ for (int e = 0;e < 4;e++){ for (int f = 0;f < 5;f++){ resultados_multiplicacion[a][b][c][d][e][f] = false; //inicializo en false } } } } } } }

#include <iostream> #include <vector> #include <stdlib.h> #include <stdio.h> #include <time.h> #include <cmath> using namespace std; vector <int> cifras(int numero){ //funcion para sacar digitos de un numero y almacenarlos en una lista vector <int> ci; for (int m = 10; m < numero*10;m = m*10){ int n = numero % m; int n2 = numero % (m / 10); int n3 = n - n2; n3 = n3 / (m/10); ci.push_back(n3); } return ci; }

#include <iostream> #include <vector> #include <stdlib.h> #include <stdio.h> #include <time.h> #include <cmath> using namespace std; /*solucion de Ariel Nowik */ //Encontrar todos los números N de cuatro cifras, tales que de las cifras que aparecen en N² no haya ninguna que aparece en N. vector <int> cifras(int numero){ //funcion para sacar digitos de un numero y almacenarlos en una lista vector <int> ci; for (int m = 10; m < numero*10;m = m*10){ int n = numero % m; int n2 = numero % (m / 10); int n3 = n - n2; n3 = n3 / (m/10); ci.push_back(n3); } return ci; } int aparecen(int n,int nn){ //funcion para revisar lo que pide el problema con cada numero vector <int> cn = cifras(n); vector <int> cnn = cifras(nn); for (int x = 0;x < cnn.size();x++){ for (int y = 0;y < cn.size();y++){ if (cnn[x] == cn[y]){ break; } if (y == cn.size()-1){ return false; } } } return true; } int main(){ vector <int> soluciones; for (int n = 1000;n < 10000;n++){ if (aparecen(n,n*n) == true){ //si se cumplen las condiciones del problema se almacena la solucion en una lista soluciones.push_back(n); } } for (int x = 0;x < soluciones.size();x++){ //se imprimen las soluciones cout<<"------------------------------------"<<endl; cout<<"SOLUCION "<<x<<":"<<endl; cout<<"N = "<<soluciones[x]<<endl; cout<<"N * N = "<<soluciones[x]*soluciones[x]<<endl; cout<<"------------------------------------"<<endl; } cout<<"RTA: Hay "<<soluciones.size()<<" soluciones"<<endl; cout<<"------------------------------------"<<endl; }

#include <iostream> #include <vector> #include <stdlib.h> #include <stdio.h> #include <time.h> #include <cmath> using namespace std; //solucion de Ariel Nowik //Gastón escribe para cada numero N entero positivo la //tira de numeros 1³+N, 2³+N, 3³+N, 4³+N, 5³+N, 6³+N, ...,1000³+N. //Encontrar los 10 valores mas chicos de N para //los cuales su correspondiente tira con tiene ningun numero primo. vector <int> divisores(int numero){ //funcion para obtener los divisores de un numero vector <int> divi; for (int p = 1;p*p-1 < numero;p++){ if (numero % p == 0){ int np = numero / p; divi.push_back(p); divi.push_back(np); } } return divi; } int primo(int numero){ //funcion para averiguar si un numero es primo vector <int> div = divisores(numero); if (div.size() == 2){ return true; } return false; } int hacer_tira(int numero){ //funcion para revisar las condiciones del enunciado for (int s = 1;s < 1001;s++){ if (primo(s*s*s+numero) == true){ return false; } } return true; } int main(){ int n = 0; bool resuelto = false; vector <int> soluciones; //hacemos que se pruebe n hasta que se hallen 10 valores que cumplan con las condiciones while (resuelto != true){ if (hacer_tira(n) == true){ //si se cumplen se imprime y almacena n en un vector soluciones.push_back(n); cout<<"------------------------------------"<<endl; cout<<"SOLUCION "<<soluciones.size()<<":"<<endl; cout<<"N = "<<n<<endl; cout<<"------------------------------------"<<endl; if (soluciones.size() > 9){ resuelto = true; // si ya se imprimieron 10 soluciones se termina } } n++; } cout<<"escriba algo y presione enter para continuar . . ."<<endl; int h; cin>>h; }

#include <iostream> #include <vector> #include <stdlib.h> #include <stdio.h> #include <time.h> using namespace std; //solucion de Ariel Nowik */ //¿Cuántas ternas de numeros enteros positivos (X,Y,Z), todos menores que 1000,  //hay tales que X² + Y² + Z² es un numero que termina en por lo menos seis ceros?*/ int random(int start = 0,int stop = 1){ //funcion para generar numeros al azar stop = stop - 1; unsigned int iseed = (unsigned int)time(NULL); srand (iseed); int ran = rand(); return float(ran) / float(RAND_MAX) * (stop-start) + start; } int main(){ vector < vector <int> > sols; //for para x y z for (int x = 0;x < 1000;x++){ for (int y = 0;y < 1000;y++){ for (int z = 0;z < 1000;z++){ //se revisa si termina en 6 ceros x*x + y*y + z*z if ((x*x+y*y+z*z) % 1000000 == 0){ //se almacena la solucion vector <int> xyz; xyz.push_back(x); xyz.push_back(y); xyz.push_back(z); sols.push_back(xyz); } } } //para imprimir el porcentaje actual del progreso del programa int porc = x / 10; if (porc % 4 == 0){ for (int a = 0;a < 30;a++){ cout<<""<<endl; } for (int x = 0;x < porc;x++){ cout<<"#"; } cout<<""<<endl; cout<<porc<<"%"<<endl; } } //se imprime una solucion al azar y la cantidad de soluciones int num = random(0,sols.size()); cout<<"------------------------------------"<<endl; cout<<"SOLUCION DE PRUEBA AL AZAR (ID = "<<num<<") :"<<endl; cout<<"X = "<<sols[num][0]<<endl; cout<<"Y = "<<sols[num][1]<<endl; cout<<"Z = "<<sols[num][2]<<endl; cout<<"X * X + Y * Y + Z * Z = "<<sols[num][0]*sols[num][0]+sols[num][1]*sols[num][1]+sols[num][2]*sols[num][2]<<endl; cout<<"------------------------------------"<<endl; cout<<"RTA: Hay unas "<<sols.size()<<" soluciones"<<endl; cout<<"------------------------------------"<<endl; cout<<"escriba algo y presione enter para continuar . . ."<<endl; int h; cin>>h; }

#include <iostream> #include <vector> #include <stdlib.h> #include <stdio.h> #include <time.h> using namespace std; //solucion de Ariel Nowik //Consideramos las ternas de numeros enteros positivos (P; Q;R) tales que P,Q,R y P² + Q² + R² sean primos. //A) Encontrar 9 de ellas //B) ¿Cuantas de ellas hay tales que P, Q, R son menores de 10000? bool es_primo(int k){ //funcion para sacar numeros primos int a,b; if(k>1){ for(a=2;a*a<=k;a++){ if(k%a==0){ return false; } } return true; }else{ return false; } } //funcion para generar numeros al azar int random(int start = 0,int stop = 1){ stop = stop - 1; unsigned int iseed = (unsigned int)time(NULL); srand (iseed); int ran = rand(); return float(ran) / float(RAND_MAX) * (stop-start) + start; } //funcion para no repetir un numero al azar ya generado (se usará mas adelante) int get_rand(vector <int> v,vector <vector <int> > nums){ int num = random(0,nums.size()); for (int x = 0;x < v.size();x++){ if (num == v[x]){ return get_rand(v,nums); } } return num; } int main(){ int soluciones = 0; //creamos vector que almacena los numeros primos entre 1 y 10000 vector <int> ya_primos; //creamos vector para guardar las soluciones vector < vector <int> > sols; for (int x = 2;x < 10000;x++){ if (es_primo(x) == true){ ya_primos.push_back(x); } } // para poder mostrar en pantalla el porcentaje que va del prosceso int porc = 0; int l_porc = 0; // for para p que solo va por los numeros primos for (int p = 0;p < ya_primos.size();p++){ porc = ya_primos[p] / 100; if (porc != l_porc){ if (porc % 4 == 0){ for (int x = 0;x < 30;x++){ cout<<""<<endl; } for (int x = 0;x < porc;x++){ cout<<"#"; } cout<<""<<endl; cout<<porc<<"%"<<endl; } l_porc = porc; } // for de q que solo va de 0 a q por los numeros primos for (int q = 0;q <= p;q++){ // for de r que va de 0 a q por los numeros primos solamente for (int r = 0;r <= q;r++){ // si p*p + q*q + r*r es primo se suman las 6 soluciones posibles combinado // R,Q y P. Y se almacenan if (es_primo(ya_primos[p]*ya_primos[p]+ya_primos[q]*ya_primos[q]+ya_primos[r]*ya_primos[r]) == true){ soluciones += 6; vector <int> sol1; sol1.push_back(ya_primos[p]); sol1.push_back(ya_primos[q]); sol1.push_back(ya_primos[r]); vector <int> sol2; sol2.push_back(ya_primos[q]); sol2.push_back(ya_primos[r]); sol2.push_back(ya_primos[p]); vector <int> sol3; sol3.push_back(ya_primos[p]); sol3.push_back(ya_primos[q]); sol3.push_back(ya_primos[r]); vector <int> sol4; sol4.push_back(ya_primos[p]); sol4.push_back(ya_primos[r]); sol4.push_back(ya_primos[q]); vector <int> sol5; sol5.push_back(ya_primos[r]); sol5.push_back(ya_primos[p]); sol5.push_back(ya_primos[q]); vector <int> sol6; sol6.push_back(ya_primos[r]); sol6.push_back(ya_primos[q]); sol6.push_back(ya_primos[p]); sols.push_back(sol1); sols.push_back(sol2); sols.push_back(sol3); sols.push_back(sol4); sols.push_back(sol5); sols.push_back(sol6); } } } } //imprimimos cantidad de soluciones int cant = sols.size(); vector <int> dis; // imprimimos 9 soluciones al azar for (int x = 0;x < 9;x++){ //usamos la esta funcion para evitar numeros al azar ya generados int num = get_rand(dis,sols); cout<<"------------------------------------"<<endl; cout<<"SOLUCION AL AZAR "<<x<<" (ID = "<<num<<") : "<<endl; cout<<"P = "<<sols[num][0]<<endl; cout<<"Q = "<<sols[num][1]<<endl; cout<<"R = "<<sols[num][2]<<endl; dis.push_back(num); } cout<<"------------------------------------"<<endl; cout<<"RTA: Hay unas "<<cant<<" soluciones posibles"<<endl; cout<<"------------------------------------"<<endl; cout<<"escriba algo y presione enter para continuar . . ."<<endl; int h; cin>>h; }