Recent Forum Posts
Desde categorías:
page 1123...next »

Hola Juan, bienvenido al Foro CyM! El problema al que te referís es CyM99r3n1p1. Te invito a que nos cuentes qué pensaste hasta ahora para resolver el problema, y lo mandes al ConsultorioCyM para Nivel 1, que es otra de las secciones de este mismo foro. Antes hacía falta registrarse, pero ahora estamos probando cómo resulta si ya no hace falta: cualquier persona puede mandar/poner mensajes.

Por las dudas, algunas ideas:

  • ¿probaste hacer un dibujo o un esquema?
  • ¿intentaste probar con algunos valores para ver cómo da? por ejemplo imaginar que perdió 1 soldadito; cómo dan las cuentas? Si suponemos que perdió 2? 3?
  • ¿probaste expresarlo como ecuaciones o algún otro formalismo matemático?
por pablohpabloh, 21 Oct 2016 22:09
Juan (invitado) 22 Sep 2016 14:45
in discussion Foro CyM / Tema libre (casi) - Abierto » No hace falta login

Quiero resolver el problema del 11 Nov. del 1999 . Que dice :"pablito tenia 5040 soltadizos , se le perdieron algunos…etc…etc.."
No puedo resolverlo …si me pueden mandar la solución por favor

Desde ya , muchas gracias
Juan

por Juan (invitado), 22 Sep 2016 14:45

La Ronda Nacional del 17mo Torneo de Computación y Matemática, CyM 2014, está por comenzar. Desde mañana miércoles 15 de octubre, hasta el viernes, en la Universidad Abierta Interamericana, Ciudad Autónoma de Buenos Aires. Detalles en la página de CyM.

¡Mucha concentración!

Ronda Nacional de CyM 2014 por pablohpabloh, 14 Oct 2014 22:46

La Ronda Zonal del 17mo Torneo de Computación y Matemática es mañana martes 16 de septiembre de 2014, de 14:00 a 17:00. Más información: como siempre en la página web de CyM, http://www.oma.org.ar/nacional/cym/

Ronda Zonal de CyM 2014 por pablohpabloh, 15 Sep 2014 22:07

¡CyM 2014 ya comenzó!

La Ronda Intercolegial del 17mo Torneo de Computación y Matemática es el próximo viernes 22 de Agosto de 2014, de 14:00 a 17:00. Más información: como siempre en la página web de CyM, http://www.oma.org.ar/nacional/cym/

Disfruten el Torneo. :-)

Ronda Intercolegial de CyM 2014 por pablohpabloh, 21 Aug 2014 12:07

Este es el tutorial mas avanzado de c++ para olimpiadas. Si ya sabes c++ por ahi algunas cosas ya las conoces, si no sabes nada de c++ empeza por el tutorial basico en el otro tutorial.

Al igual que en el tutorial anterior me presento soy Ariel Nowik 5to año de ort almagro capital federal (son 6 años en ort), participe 2 veces en cym.

Al terminar el tutorial, tendras la teoria suficiente para resolver cualquier problema. (¡El resto son ideas!) Sin embargo, todo esto no es ni una minima parte del potencial total que el lenguaje c++ ofrece. Todos estos conocimientos además, no son solo validos para c++, si bien en en diferente forma, estan todos presentes en casi todos los lenguajes conocidos (python,php,java,javascript,c#,as3, y más). No obstante, los arrays de c++, segun mi experiencia solo los vi en c y c++ existir. (En los demas lenguajes se usan exclusivamente vectores en general)

Funciones

Una funcion es un conjunto de lineas de codigo archivados con un sobrenombre, que pueden ser llamadas todas en uno invocando al sobrenombre. Tiene dos caracteristicas fundamentales que son los valores de entrada a la funcion, que son variables del tipo correspondiente segun la funcion, pueden ser en cualquier cantidad y en cualquier tipo, con los que uno regula como quiere que la funcion ejecute los comandos, y uno o 0 valores de devolucion, que son los datos que la funcion nos da como respuesta y podemos almacenar en otra variable del tipo correspondiente. En tutoriales anteriores usamos funciones como pow(double a,double b), que era una funcion que se le entraba con valor a un double, como valor b un double y como resultado nos daba un double que era a elevado a la b, que podiamos almacenar en una variable de tipo double o int (aunque era redondeada si tenia coma al hacer esto).

Una funcion se crea 2 veces en c++ para ser utilizada. El prototipo y la implementacion, el prototipo es solo que entra y que sale de la funcion expresado en una linea (las funcioens siempre se declaran afuera del int main()!!!), mientras que la implementacion es lo mismo que el prototipo, pero con los comandos que contiene. Debe hacerse un prototipo para que el compilador de c++ pueda entender el programa bien, no porque sea mejor o de algun beneficio, en muchos lenguajes no son nescesarios, en c++ si.

//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
}

Siempre los prototipos se escriben antes del int main(){}, los comandos del programa, y la implementacion despues del int main(){}, no hay una razon real porque sea asi, es solo para que el compilador del c++ pueda entenderlo bien.
En la implementacion de la funcion, ademas de ejecutarse un codigo, debe tambien correrse el comando return seguido de una variable del tipo del dato que la funcion da como respuesta, como es la segunda caracteristica fundamental de la funcion que es el valor que la funcion dará como respuesta, cuando se corre el return la funcion termina inmediatamente y se da como resultado ese valor ignorando el codigo que pueda llegar a seguir. Hay una posiblidad de omitir ese return y es si la funcion devuelve 0 datos, que como dice arriba es posible. Para ese caso en vez de poner antes de hacer el prototipo y la implementacion un tipo de dato, se escribe simplemente void.
Pasemos a la practica, ejemplo de una funcion

#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 
}

SALIDA
5
5.83095
10
Presione alguna tecla para continuar ...

El beneficio de usar funciones es que podes ejecutar varias veces el mismo codigo escribiendo menos, como se ve en el ejemplo la hipotenusa de un triangulo de catetos 3 y 4 es 5, la de uno con 3 y 5 es 5.8 y la de uno con
6 y 8 es 10. Si no lo conoces la formula de la hipotenusa de triangulos rectangulos es la raiz cuadrada de la suma de cada cateto elevado al cuadrado, o sea multiplicado por si mismo. Cabe resaltar que la funcion creada, hipotenusa_del_triangulo solo tiene acceso a las variables que hayan sido reservadas (=creadas) dentro del contenido de las llaves de la funcion, no puede acceder a ninguna variable fuera de ese mundo, por ejemplo, no puede leer la variable h. Asimismo la funcion main tampoco puede leer las variables de hipotenusa_del_triangulo, como multA,multB y suma. Todas estas variables que fueron las que usamos en los tutoriales son locales, solo se pueden leer y escribir en el conjunto de llaves local. El proximo tema que veremos seran las variables globales, que, en contraste con las locales, pueden ser leidas y modificadas en cualquier lugar del programa, tanto en el int main(){} como en cualquier funcion. Esto justificaria por ejemplo que una funcion no devuelva nada y sea void a veces. Hay una discusion sobre si las variables globales son correctas usarlas. En estos programas de olimpiadas que no llegan a la complejidad extrema de proyectos gigantes, no habra problemas en usarlas y serviran para simplificar programas en muchos casos.

Variables locales y globales

En c++ hasta ahora vimos asignacion de variables a un tipo. Hasta ahora, todas las que vimos las creamos de manera local, es decir, solo podian ser leidas y escritas en codigo dentro de las {} donde fue asignada. Es decir, por ejemplo desde las funciones no podian ser accedidas. Las variables globales se pueden leer y escribir a lo largo de todo el programa cuando se desee. Ejemplo

#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;
}

SALIDA
10
5
Presione alguna tecla para continuar ...

Como vemos las variables globales se crean siempre antes de todo, antes de los protipos de las funciones. Como el objetivo de nuestra funcion es editar una variable global, tiene sentido hacer que no devuelva valores, con void. Con este programa se deberia notar la diferencia entre variables locales y globales.

Arrays

ahora aprenderemos un nuevo de estructura de c++. Imaginemos que queremos almacenar en un programa 100 numeros. ¿creamos 100 ints? por supuesto que no, se hace muy largo. C++ nos ofrece un tipo de dato array que sirve para hacer listas de datos con tamaño fijo (no se pueden agregar mas valores a la lista en el transcurso del programa).

Para crear un array (=reservar espacio en la memoria para el array) se escribe

tipo_de_dato nombre_array[cantidad_de_valores];

ejemplo:
int lista[100];

Con lo quie tenemos una lista con 100 valores tipo int. ¿Como leemos/escribimos estos valores?
escribiendo el_nombre_del_array[numero_de_variable_a_leer], donde numero_de_variable_a_leer es una variable entera que va de 0 a la longitud del array menos 1, en este caso 100. por ejemplo con un array de longitud 4, tenemos 4 valores a modificar o leer,
el valor 0, el 1, el 2, y el 3.

Ejemplo arrays:

#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;
     }
}

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

Como vemos creamos dos arrays, uno como variable local y uno como variable global. Al local le damos una longitud de 3. Luego en el primer for hacemos que el valor de cada item del array (que van del 0 al 2), y le aseigamos de valor 2-v y al item luego le sumamos 1. Para el indice 0 del array tenemos 2-0 + 1 = 3, para el segundo 2 - 1 + 1 = 2, y para el tercero 2 - 2 + 1 = 1 Por eso se muestra 3, 2 y 1. Para el array reservado (=creado) como variable global, le damos a cada uno de sus items, el valor de x*2, es decir el numero de indice * 2, entonces el item 0 del array tiene 0, el item 1 del array tiene 2, el item 2 tiene 6 y el item 8. Son 5 items del 0 al 5 como corresponde.
Con todo esto se deberia entender el funcionamiento de los arrays. Los arrays no son solo para ints, tambien sirven para double, string o cualquier otro tipo al igual que las funciones.

Vectores

Imaginemos que tenemos una cantidad de datos, pero, la cantidad de datos no esta definida. En tal caso se recurre a los vectores, que funcionan de la misma manera que los arrays, pero, su longitud puede variar mientras corre el programa. Uno tambien puede usar siempre vectores en vez de arrays, pero si uno solo usa arrays, la cantidad de memoria que utilizara el programa es fija y esta asegurado, en cambio con vectores, uno no sabe cuanta memoria (cantidad de variables) puede llegar a usar el programa. Para usar vectores se debe agregar al principio del programa, y el using namespace std debe estar tambien. En los vectores uno crea primero una lista de valores vacia, y le va agregando/eliminado valores y al mismo tiempo se leen cuando se desea. Ahora haremos una descripcion de las operaciones sobre vectorse que c++ nos ofrece. En c puro no hay vectores ni tampoco cout por lo tanto hay que asegurase que se guarda el archivo como .cpp

Un vector se crea como

vector <tipo_de_datos a almacenar> nombre_vector;

Para acceder a un dato de un vector se hace igual que con los arrays

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

pero cuidado, si accedemos a un numero_de_dato que no existe (mayor a la longitud), el programa en ese punto se cerrara. Si se debugea se puede ver en que punto crasheo sino no. De todas formas con un uso correcto de vectores no crasheara.

Para agregarle un valor al vector

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

Para eliminarle al vector un dato

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

Para borrar el ultimo dato del vector

nombre_vector.pop_back();

Para leer el ultimo/Primer valor de un vector

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

Para leer la longitud de un vector

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

Para eleminar todos los valores de un vector

nombre_vector.clear();

Y hay muchas mas funciones, en la pagina del c++ estan todas.

Ahora veremos un ejemplo donde calculamos los numeros primos del 2 al 50, y los compuestos. Mostramos primeros los primos y luego los compuestos. Ambos conjuntos los almacenamos en dos vectores

#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;
    }
}

SALIDA:

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 ...

Matrices

Imaginemos que queremos guardar un tablero de ajedrez en la memoria. Un array es una lista de valores, pero en una sola dimension, por lo tanto no nos sirve. Con las matrices, que en realidad son arrays de arrays podemos armar tablas de valores. Usando la misma logica tambien podemos hacer matrices de tres dimensiones, cuatro, cinco e infinito, usando la imaginacion, pero por ahora solo trabajaremos con matrices de 2 dimesiones.

¿Como creamos (=reservamos espacio en la memoria) para una matriz?

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

¿Como accedemos y/o editamos un valor de la matriz bidimensional (=de dos dimensiones)?

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

Ahora vemos un ejemplo donde almacenaremos una tabla de multiplicar clasica.

#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
    }
}

SALIDA

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 ...

Si lees los comentarios y pensas se deberia entender. Creamos una matriz de 11x11 (es decir los indices de filas y columas van del 0 al 10), y a cada uno de los valores de la matriz (es decir a cada uno de los 121 valores), le asignamos de valor su numero de columna* su numero de final. De esta forma cumplimos con la definicion de tabla de multiplicar y generamos una. Despues mostramos la tabla de multiplicar. Usamos de manera diferente el cout tambien en esta ocasion. Cabe resaltar que si se usa el cout sin agregar el endl, el proximo cout mostrara el texto a mostrar en la misma linea, y si se agrega cout«algo«otra_cosa se muestra algo junto a otra cosa. Con todo eso se deberia entender como funciona el cout mas completamente.

Espero que hayas entendido el tema, el proximo tema son matrices con vectores. Luego vendran mas cosas, hay muchisimos temas mas que tengo para enseñar todavia!

Matrices con vectores

Ahora veremos otro tema parecido. La matriz que hicimos antes la hicimos con arrays, por lo tanto, su tamaño era estatico, todas las filas y columnas tenian tamaño fijo. Con matrices basadas en vectores.

Para crear una matriz de enteros usaremos, que nos crea un vector de tipo de dato vector para ints.

vector <vector <int> > nombre_matriz;

donde iniciamos una tabla (=matriz) de 0 filas y 0 columas.

Para agregarle una linea a la tabla hacemos, por ejemplo

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

Cabe resaltar que la matriz como todo vector tiene una funcion size (nombre_vector.size()) que nos da la cantidad de lineas que contiene (=longitud del vector), y cada uno de las lineas del vector, que como todo vector se accede como nombre_matrz[ numero_de_fila ], tiene tambien su .size() y tambien se puede accede a cada uno de sus valores con nombre_matrz[ numero_de_fila ][ numero_de_columna]. Al igual que cuando vimos antes vectores hay que recordar que si intentamos acceder a un numero_de_fila que no existe (numero_de_fila>=nombre_vector.size()), el programa se cerrara (un debugger marcaria esa linea como error), como tampoco podemos acceder a un valor de una de las lineas que no existe (numero_de_valor_de_la_fila>=nombre_vector[numero_de_fila].size().

Ahora veremos un ejemplo donde calculamos los divisores de los numeros 0 al 10, y los mostramos por cada numero

#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;
    }
}

SALIDA
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 . . .

Como vemos tenemos que el uno tiene de divisores el 1, el 2 tiene de divisores el 1 y el 2, el 3 el 1 y el 3, el 4 tiene de divisores 1, 2 y 4, y asi.
Si no entendiste bien lo del cout con y sin endl, proba vos para entenderlo, porque aqui lo volvi a usarlo, y de manera mas complicada. El programa consiste en crear un vector de vectores (=matriz de vectores), y por los numeros del 1 al 10, agregarle lineas (que son vectores), con los divisores del numero correspondiente, y luego mostrarlo. Considero importante que entiendan el algoritmo para mostrarlo masomenos lindo la matriz. En realidad en teoria solo con la teoria de vector se puede hacer este ejemplo, considerando que un vector es un tipo de dato tambien y se puede hacer un vector de cualquier tipo de dato (incluyendo de vectores). Tambien hay que notar que hicimos una funcion que no devuelve como dato ni un int, ni un void, devuelve un vector de enteros, esto tambien es posible. Si tienen otras dudas pueden preguntar en los comentarios.
Con todo esto se deberia haber entendio matrices con vectores (=vector de vectores), es imporante que tengan en cuenta que al igual que con los arrays, se pueden hacer vectores de mas de dos dimensiones, de 3,4,5, y mas (habria que escribir
vector <vector <vector <vector <int> > >, segun corresponda, (=vector de tipo dato vector de tipo dato vector de tipo de dato vector de tipo de dato int).

Recursividad

En programacion, y en la vida en general, una solucion de un problema con rescursividad, significa un procedmimiento de un problema, que se requiere llamarse a si mismo para funcionar. Es decir, una funcion que se llama a si misma (si, se puede). Sin embargo, si sucediece algo asi, nunca se terminaria de resolver el problema, porque se llamaria asi mismo indefinidamente. Por eso decimos, que siempre la recursividad tiene un limite, un punto en el cual una de las llamadas al procedimiento no vuelve a llamarlo a si mismo.
Hay muchos problemas que pueden ser resueltos con o sin recursividad, es decir poseen alternativas de ambos lados. Sin embargo, la solucion recursiva suele ser a veces más facil de idear.

Este será el problema que resolveremos mediante recursividad

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)

Nota: no vamos a demostrar porque se comple el algoritmo, solo vamos a "traducirlo" a lenguaje c. Buscandolo en internet probablemente habra muchos sitios que lo demuestren de diversas formas.

Es decir
-el numero mas grande, se convierte en la resta del mas grande y el mas chico
-el numero mas chico sigue igual
-si son iguales, ese es el maximo comun divisor, y la solucion
-si no, entonces repito el algoritmo con los dos numeros que me quedaron, y el resultado que me de la solucion

Entonces, el codigo para resolver el problema seria

#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
    }
}

SALIDA
4
1
2
Presione cualquier tecla para continuar ...

¿Como funciono? Seguiremos el primer caso. Tenemos 412 y 184.

Como 412 es mayor a 184, el 412 se transforma en 228 (412-184). Y como no son iguales, se devuelve la solucion de mcd(228,184).
Dentro de ese mcd, como 228 es mayor a 184, el 228 se transforma en 44 (448-184). Como no son iguales, se devuelve la solucion de mcd(44,184)
Dentro de ese mcd, como 184 es mayor a 44, el 184 se transforma en 104 (184-44). Como no son iguales se devuelve la solucion de mcd(44,104)
Dentro de ese mcd, como 104 es mayor a 44, el 104 se transorma en 60 (104-44). Como no son iguales se devuelve la solucion de mcd(44,60)
Dentro de ese mcd, como 60 es mayor a 44, el 60 se transforma en 16 (60-44). Como no son iguales se devuelve la solucion de mcd(44,16)
Dentro de ese mcd, como 44 es mayor a 16, el 44 se transforma en 28 (44-16). Como no son iguales se devuelve la solucion de mcd(28,16)
Dentro de ese mcd, como 28 es mayor a 16, el 28 se transforma en 12 (28-12). Como no son iguales se devuelve la solucion de mcd(12,16)
Dentro de ese mcd, como 16 es mayor a 12, el 16 se transforma en 4 (16-12). Como no son iguales se devuelve la solucion de mcd(12,4)
Dentro de ese mcd, como 12 es mayor a 4, el 12 se transforma en 8 (12-4). Como no son iguales se devuelve la solucion de mcd(8,4)
Dentro de ese mcd, como 8 es mayor a 4, el 8 se transforma en 4 (8-4). Son iguales! entonces esta es la solucion del problema, y devolvemos 4, que es la solucion del problema.

Cabe resaltar que tambien se puede resolver el problema con un for, es verdad, pero hay problemas mucho mas rebuscados, que es mejor encararlos con recursividad.

Aun no se ha terminado el articulo, falta mostrar ejemplos mas complejos de recursividad, pero la base esta!

Otro problema con recursividad

Este es otro problema interesante y mas complicado, que ademas a mi parecer la solucion recursiva es la más sencilla de pensar.

En el ajedrez un caballo se mueve en L (dos casillas en un eje, y una casilla en el restante). Un tablero de ajedrez mide 8x8. Dar todos los lugares a donde un caballo puede estar en 5 movimientos.

[[html]]
Insert any HTML code, including widgets and video or audio players
[[/html]]

Buenas, bienvenidos al tutorial, para empezar me presento soy Ariel Nowik de ORT almagro y estoy en 5to año (es hasta 6to ort). Participe 2 veces de cym (en la 2da sali 3ro) y por desgracia en general tuve que entrenarme solo y muchos temas los aprendi casi por casualidad. Como no quiero que le suceda eso a otras personas voy a explicar los conceptos importantes del lenguaje C++.

¿Que programas nescesito?

Para correr un programa en c++ (que consiste en dos procesos, compilar, y ejecutar) nescesitas dos herramientas, un editor de texto y un compilador.
Para no complicarnos muestro los progarmas que podes usar (y he utilizado):
-Codeblocks (linux y windows), viene con todo para correr directo no hay nada aparte si se baja la version codeblocks-13.12mingw-setup.exe, en linux con sudo apt-get install codeblocks ya se lo instala sin naa extra. Es muy facil de usar.

-Visual c++ (para windows)
-xcode (para mac)
-appcode (para mac, pago)
-dev c++ (para windows)
-netbeans (linux,windows) gratis y potentisimo, es el que uso, aunque en windows es dificil instalar los compiladores
-qtcreator (windows,linux) va mas rapido que netbeans, pero pesa muchisimo (en el orden de los GBs)
-borland rhide (dos, windows) es el que se usa en la olimpiada, es un editor historico que se corre en terminal y para la epoca fue muy potente, es importante bajarselo para el dia de la olimpiada poder adaptarse rapido (no como me paso a mi ;) ), por ejemplo no tiene los control -c control-v control-x, sino que tiene otras teclas para el copy paste
y varios mas, tambien se puede usar block de notas, gedit o sublime text, pero hay que compilar por terminal lo que hace perder mucho tiempo.

Yo recomiendo usar codeblocks si es la primera vez, seguido de dev c++. si queres un mejor editor y tenes compu lenta bajas qtcreator y si no bajas netbeans. Si tenes mac te bajas xcode y si estas dispuesto a pagar appcode. Son gustos. Tanto sublime text como appcode traen un plugin llamado floobits que permite editar codigo de manera colaborativa estilo google docs, pero, es muy dificil adaptarse a sublime text que solo compila c++ de manera manual.

Como empiezo un programa

Lo primero que se hace es crear un archivo .cpp, como por ejemplo main.cpp, y ahi va el contenido del codigo. Con build and run, usualmente se corre el codigo.

"#include"

Se trata de el comando basico de un programa, donde especificamos que clase de cosas nuestro programa va a utilizar. Tenemos por ejemplo
#include <iostream> que siempre en olimpiadas ira, que es para poder mostrar texto en la consola nera
#include <math.h> que es para poder hacer potencias, raices, seno, coseno en nuestro programa, mas adelante lo veremos
#include <stdlib.h> que incluye el comando "system" para poder correr comandos del sistema.
#include <stdio.h> que incluye el comando getchar() para linux y otras cosas utiles. por las dudas lo incluiremos
#include <string> que incluye para poder usar cadenas de texto en el programa

Y por ahora ninguno mas nescesitamos.

"using namespace std"

Ahora sera muy dificil entenderlo sin saber nada, pero sirve para en vez de escribir std::cout std::endl; pones cout y std. Si lo explico bien se complica mucho.

int main(){
//codigo
}

Todo lo que se corra en el programa estara en codigo. // es un comentario, todo lo que este en esa linea no se tendra en cuenta al correr el programa. Entonces dentro de las {} de main ponemos los comandos de programa a ejecutar.

Variables

Se trata de espacio de memoria de la computadora que se reserva para guardar valores, en general numericos (de 0 a 2^ algo segun que clase de dato guardemos), aunque tambien hay strings (para texto), double o float, para numeros con coma, y tambien es posible crear nuestros propios tipos de datos, pero se explicara despues.

¿Como reservamos un espacio de memoria para variables?

tipo_de_dato nombre_de_referencia;

donde tipo de dato es el nombre del tipo de dato (int , double, string , float , long int, long long int, (hay mas) o algun tipo que inventemos nosotros), y en nombre de referencia con que nombre nosotros leeremos, o alteraremos dicho valor. No puede tener espacios ni * / + - ni tampoco nombres reservados por el c++ (si falla el codigo pueden probar cambiar el nombre de la variable, a veces es el problema.
ejemplo:

#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;
}

¿Como le damos valor a un espacio de memoria ya creado?

Cuando trabajamos con int, o cualquier otro tipo numerico, y con strings utilizamos el = para asignar un numero (como son variables su valor puede cambiar a lo largo del programa), ejemplo

#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
}

¿Como mostramos el valor de variables con el programa?

Decimos que un programa es un conjunto de instrucciones que se corren en secuencia. Por lo tanto si seguimos la linea del programa anterior primero guardamos espacios (= reservamos espacio para variables) para altura, cambio y un_string y luego les asignamos los valores 5, 7.34 y "hola" respectivamente. Lo que va a seguir al correr el programa sera mostrar los valores, para verificar que todo anda bien. Con iostream disponemos de el comando cout « variable « endl; donde variable sera la variable (= espacio de memoria) la cual queremos ver el valor que le asignamos. Ademas, agregaremos el comando system("pause"), porque el programa al correr y terminar todos sus comandos por defecto se cierra. Entonces con system("pause"), hacemos que para que el programa pueda salir de ese comando que lo trabo, se puse enter. En linux se usa en vez del system pause, este comando: cout«"presione una tecla para continuar…"«endl; while (getchar()!='\n'){};

#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'){};
}

SALIDA al correr el programa:
5
7.34
hola
Presione una tecla para continuar...

Se mostraron las tres variables como corresponde y luego se frena esperando que presionemos enter.

¿Como hacemos operaciones matematicas entre variables?

Atencion: a partir de ahora int, double son variables numericas, o numeros, o espacio de memoria asignado para numeros, son lo mismo.

tenemos 5 operadores clasicos para operar numeros int,double, o otros, que son el +(mas) el -(menos) el /(dividido) el *(multiplicado) y el %(resto de la division), ademas de los que nos brinda math.h (que para poder ser usados debe estar puesto en el principio del programa #include <math.h>, como por ejemplo pow(numeroA,numeroB); donde numeroA y numeroB son variables numericas ya creadas previamente o directamente numeros escritos, y en lenguaje normal es numeroA elevado a la numeroB. Seguro te parece dificil ahora pero cuando lo veas en la practica se va a entender bien.

se operan igual que en la calculadora.
Por ejemplo

#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 
}

SALIDA
24
135033
Presione una tecla para continuar...

24 es (5 + 7.34)*2=24.68, pero como vimos lo guardamos en operacion, que es int, por lo tanto como no puede tener numeros con coma se redondea al menor entero posible, es decir 24. 135033 es 5 elevado a la 7.34. Como quizas no lo viste en la escuela pero se puede elevar a numeros con coma. si queremos hacer raiz cuadrada se hace usualmente un truco que es poner pow(numero, 1.0 / indice_de_raiz), ej pow(5,1.0/3.0) para raiz cubica, que es elevar al reciproco (resultado de 1 / numero), que es la propiedad (si lo viste en la escuela podes saltearlo) que dice que "la raiz de indice x de un numero, es el resultado de ese numero elevado al 1/el indice de raiz"

El "2x1"

Es una utilidad que cabe resaltar, si escribimos en vez de

int variable;
variable = 5;

podemos hacer directamente en una sola linea
int variable = 5; //mas rapido

para ahorrar pasos y hacer todo mas corto, inicializamos (=guardar espacio de memoria para una variable) y asignamos un valor con el = en una sola linea

Tambien otra cosa que se usa es en vez de

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

Se usa mucho

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

Con todo esto, doy por concluido el tema de variables. Con lo que saben pueden operar cualquier tipo de variables enteras como quieran, saben los comandos basicos para eso. El siguinte tema son las instrucciones de control del programa, que son las instruccdiones que regulan cuando correr cada una de las lineas del programa y de que forma, repitiendolas, o corriendolas ante una condicion, o repitiendolas mientras alguna condicion.
Suena dificil, asi que pasaremos al primer concepto basico que se relaciona con todo lo anterior.

bool

Bool es un tipo de dato, parecido al int, pero que en vez de guardar numeros, guarda solo 1 o 0. tiene dos estados posibles contra los 2^32 estados posibles del int. ¿Suena facil?
Desde ahora true equivale a 1, y false equivale a 0, son sinonimos y puedo usarlos a los dos. Al mostrar un bool con cout, se mostrara 0 o 1, pero al escribir el programa puedo usar false o true tambien.

Ej:

#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 
}

SALIDA
1
0
Presione una tecla para continuar...

Se muestran como corresponde los dos valores, no hay mucho que explicar.

Operaciones Binarias

Al igual que en la electronica (si alguno estudia electronica le sonara conocido, sino, no importa) existen en c++ 3 operaciones binarias para operar variables de tipo bool. Estas son
-and o &&
-or o ||
-not o !

funcionan igual que los otros operadores que vimos pero estas operan mas sencillamente.
ejemplos
variableA and variableB
variableA or variableB
not variableA
and da como resultado un 1 si variableA y variableB son 1, or da como resultado 1 si variableA o variableB son 1, y not da sencillamente como resultado el contrario de variableA (si variableA es 0 da 1, si variableB es 1 da 0).

Ejemplo:

#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 
}

SALIDA
0
1
0
1
Presione una tecla para continuar...

Como se supone, rtaA es 0 porque variableB es 0, ambas deben ser 1 para que sea 1
rtaB es 1 porque variableA es 1, y con cualquiera de las dos en 1 da 1
rtaC es 0 porque es el contrario de rtaA
rtaD es 1 porque el contrario de variableA (0) y variableB son 0 por lo tanto el resultado es 1, pero como hay un not a todo eso, el resultado final es el opuesto, como es 1 se vuelve 0.

Expresiones condicionales

se tratan de operadores, como por ejemplo == (si son iguales) o != (si son desiguales) o > (mayor) o = (igual) o >= (mayor o igual, en ese orden el < e =), o <= (menor o igual), donde se pueden comparar dos variables y da como resultado un bool que podemos almacenar y es un 1 (si es cierta la condicion) y un 0 si no lo es.
ejemplo:

#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 
}

SALIDA
1
0
0
Presione una tecla para continuar...

como numero, que es 6 es >= 4, la variableA es 1, (true), en cambio variableB es 0 porque otro_numero, que es numero+2, que es 8, es desigual a numero, que es 6 (8 != 6)
el tercer resultado es 0 porque no son las dos variables 1.
Si se entendio esto ya se tiene una gran base sobre condiciones.

El if

Esta es la primera instruccion de control que veremos. El if se trata de una instruccion que corre un codigo entre {} particular cuando una variable tipo bool que le pongamos sea 1, de lo contrario no se corre. Tiene dos hermanos llamados else y else if. Else es otro bloqeu de codigo entre {} que se corre cuando la bool original no es 1, y else if() sirve para que si no es 1 la condicion original pero otra nueva condicion=variable tipo bool es 1 se corra un bloque nuevo de codigo. Veremos en la practica como se usa.

#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 
}

SALIDA
la condicion 2 es cierta
Presione una tecla para continuar...

Sale el string la condicion 2 es cierta ya que se corre la linea que le asigna ese valor a informacion, porque la condicion1 es 0, entonces se revisa la segunda condicion, como la segunda condicion si es 1 se corre el codigo de esas llaves. Si ninguna fuera cierta se correria el tercer bloque de codigo.

Uso simplificado del if

si bien hasta ahora hacemos condiciones y almacenamos su resultado en una variable tipo bool como 1 o 0 (true o false) y luego con el if decimos que se ejecute un codigo si ese bool es 1, para condiciones sencillas se puede poner la condicion con la que obtenemos el bool dentro del if para ocupar menos lineasd de codigo. Sin embargo, cuando trabajamos con condiciones muy largas, es mejor crear primero las variables tipos bool y luego llamar a los if para simplificar como se ve el codigo. Sin importar si entendimos esto, el ultimo codigo de arriba se puede escribir tambien como (y su resultado es el mismo):

#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 
}

SALIDA
la condicion 2 es cierta
Presione una tecla para continuar...

y es equivalente. Cuando las condiciones son sencillas (1 o 2 terminos) conviene mas usar los if de esta forma.

For

Esta es una de los comandos mas importantes del lenguaje, y uno de los mas usados en particular en olimpiadas.
Sirve para repetir un conjunto de lineas de codigo una determinada cantidad de veces, que configurandolo correctamente puede ser la cantidad que querramos.
se usa como

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
}

es decir si digo for(a,b,c){ codigo }

a, es un codigo donde creo una variable (asigno memoria) de cualquier tipo numerico (si o si),
b, es un codigo de una condicion (las que usan == != <= >= < < y tambien puede tener los and or y not y () que vimos ante). y es revisada, si es 1 continua el for, de lo contrario no
c, es un codigo que se corre cada vez que se corren una vez todos los comandos dentro de las {} del for
codigo, es el codigo a correr cada vez que se corre el for.

En un ejemplo practico se entendera mejor

#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
}

y la salida es
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...

¿Que fue lo que paso?
1- se inicio el for, y una_variable se reservo en la memoria (=se creo), como tipo int, y se le dio el valor de 1.
2- se reviso la condicion, como una_variable + 1 < 10 es verdadero, ya que 2 < 10, c++ decide continuar el for
3- se llamo a todo el codigo dentro de las {}, como una_variable es 1, se mostro un 1 abajo de lo otro

4- se corre el tercer dato del for, que dice una_variable = una_variable + 2. por lo tanto una_variable = 1 + 2 = 3, se le asigna 3 a una_variable
5- se reviso la condicion, como una_variable + 1 < 10 es verdadero, ya que 4 < 10, c++ decide continuar el for
6- se llamo a todo el codigo dentro de las {}, como una_variable es 3, se mostro un 3 abajo de lo otro

7- se corre el tercer dato del for, que dice una_variable = una_variable + 2. por lo tanto una_variable = 3 + 2 = 5, se le asigna 5 a una_variable
8- se reviso la condicion, como una_variable + 1 < 10 es verdadero, ya que 6 < 10, c++ decide continuar el for
9- se llamo a todo el codigo dentro de las {}, como una_variable es 5, se mostro un 5 abajo de lo otro

10- se corre el tercer dato del for, que dice una_variable = una_variable + 2. por lo tanto una_variable = 5 + 2 = 7, se le asigna 7 a una_variable
11- se reviso la condicion, como una_variable + 1 < 10 es verdadero, ya que 8 < 10, c++ decide continuar el for
12- se llamo a todo el codigo dentro de las {}, como una_variable es 7, se mostro un 7 abajo de lo otro

13- se corre el tercer dato del for, que dice una_variable = una_variable + 2. por lo tanto una_variable = 7 + 2 = 9, se le asigna 9 a una_variable
14- se reviso la condicion, como una_variable + 1 < 10 es falso (0), ya que no es cierto que 10 < 10, c++ decide finalizar el for.

Con esta secuencia espero que entiendas como funciona el for. Tiene un potencial enorme en las cosas que permite hacer y es la estructura fundamental que se usa en cym.

While

El while tambien es un comando de c++ importantisimo y es el que usan por ejemplo todos los programas como el navegador o cualquier juego, absolutamente todo programa que tenga una duracion no definida de tiempo que corre. En cym en general los programas corren y terminan en tiempo relativamente corto (mas corto es mejor), por lo que no hay programas donde haya que apretar una cruz para cerrarlos, pero aun asi el while es de mucha utilidad y tambien lo he usado. Su funcionamiento es algo mas sencillo que el del for

while (codicion) { 
    //codigo a correr 
}

condicion es un tipo de dato bool, que puede ser tambien una codicion puesta directamente como en el for.
El funcionamiento consiste que en codigo a correr que esta entre {} que es un conjunto de comandos que mientras la condicion sea true (1), que es revisada siempre antes de correr el codigo a correr, se corra el codigo dentro del programa

Ejemplo:

#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
}

SALIDA del programa
1
2
4
8
16
32
64
Presione una tecla para continuar...

¿Que sucedio? Hacemos el mismo analisis que con el for
1- inicializamos variable en 1
2- empieza el while. es true (1) que variable < 100, 1 < 100 entonces continuamos con el for
3- se corre el codigo dentro del while. se muestra variable (se muestra un 1 en la pantalla), y luego se hace variable += variable, que equivale a escribir variable = variable + variable. Para escribir menos codigo es. += significa incrementar en tanto el valor de una variable. entonces variable = 1+1 = 2. variable ahora es 2.
4- es true (1) que variable < 100, 2 < 100 entonces continuamos con el while
5- se corre el codigo dentro del while. se muestra variable (se muestra un 2 en la pantalla),y se hace variable += variable, variable = 2 + 2 = 4, variable ahora es 4
6- es true (1) que variable < 100, 4 < 100 entonces continuamos con el while
7- se corre el codigo dentro del while. se muestra variable (se muestra un 4 en la pantalla),y se hace variable += variable, variable = 4 + 4 = 8, variable ahora es 8
8- es true (1) que variable < 100, 8 < 100 entonces continuamos con el while
9- se corre el codigo dentro del while. se muestra variable (se muestra un 8 en la pantalla),y se hace variable += variable, variable = 8 + 8 = 16, variable ahora es 16
10- es true (1) que variable < 100, 16 < 100 entonces continuamos con el while
11- se corre el codigo dentro del while. se muestra variable (se muestra un 16 en la pantalla),y se hace variable += variable, variable = 16 + 16 = 32, variable ahora es 32
12- es true (1) que variable < 100, 32 < 100 entonces continuamos con el while
13- se corre el codigo dentro del while. se muestra variable (se muestra un 32 en la pantalla),y se hace variable += variable, variable = 32 + 32 = 64, variable ahora es 64
14- es true (1) que variable < 100, 64 < 100 entonces continuamos con el while
15- se corre el codigo dentro del while. se muestra variable (se muestra un 64 en la pantalla),y se hace variable += variable, variable = 64 + 64 = 128, variable ahora es 128
14- es false (0) que variable < 100, 128 < 100 entonces finalizamos con el while

de casualidad dieron las potencias de 2, puede ser algo trivial pero si no se te ocurre porque podes hacer tu primer razonamiento interesante en cym, porque este programa da justo las potencias de dos? Es para pensarlo un ratito :)

con esto ya se debio haber entendido el while. Esperemos ;)

Switch (case)

el switch es la ultima estructura de control que veremos. consiste en un simplificador de ifs, por lo que si ya entendes el if, sera algo muy sencillo.
consiste en poner una variable como foco (pensalo abstractamente no concretamente sino se hace lio), y poner que si esa variable enfocada es algo, correr un codigo, si esa variable enfocada es otra cosa, ejecutar otro codigo y si esa variable no es ninguna de las cosas anteriores (default) hacer otra cosa mas

Tiene una sintaxis muy particular que es una de las pocas que rompe la estructura de c++ de las llaves ({})

#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
}

SALIDA
la variable es 10

muy raro seguramente. bueno, primero enfoco variable. si variable es 5, se va a correr el codigo desde case (caso) 5 hasta el break; , si es 3 se va a correr desde case (caso) 3 hasta el siguiente break; si es 10 se va a correr desde el case 10 hasta el break; y si no es ninguno de esos se va a correr el default hasta el ultimo break;
como variable es 10, se corrio el codigo desde case 10 hasta el break siguiente. Si variable hubiera sido 8 por ejemplo se hubera corrido el codigo del default, la variable no es ni 5, ni 3, ni 10, y si hubiera sido 5, se hubiera corrido el codigo del case 5, que es mostrar la variable es 5. Esto se podria haber hecho con ifs poniendo que

if (variable == 5){
    cout<<"la variable es 5"<<endl; 
}else if(variable == 3){
    cout<<"la variable es 3"<<endl; 
}else if(variable == 10){
    cout<<"la variable es 10"<<endl; 
}else{
    cout<<"la variable no es ni 5, ni 3, ni 10"<<endl;
}

que es lo mismo, pero, son gustos y el switch ahorra escribir todo el tiepo if (tanto == tal valor), ya que enfocas una variable y directamente pones los valores que tiene que tener para que pase una cosa

Operadores ternarios

Son ifs, pero puestos de otra manera. Lo explico porque despues van a ver codigos de otras personas que los usen y si no saben como se les va a costar entenderlos. No corren codigo como el if sino que sirven para asignar un valor u otro a una variable con una codicion si tener que escribir el nombre de la variable 2 veces
Se escribe como

( tipo bool (o condicion directamente) ) ? (si es 1) : (si es 0)

solo sirve para asignar valores es decir se usa como
variable = condicional ? valor si es 1 condicional : valor si es 0 condicional

si la condicional da como resultado 1, variable es el valor que esta despues del ? sino, variable es el valor puesto despues del :
Ejemplo

#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
}

SALIDA
2

como condicion es false se le asigna a variable el valor despues del :, el 2

tambien se puede usar con el cout

#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");
}

SALIDA
hola

como variable > 4, se procede a mostrar el valor despues del ?, si variable no fuera > 4 se mostraria el chau.

La programacion es libertad

Ultimo concepto que es para que todos hagan click. El c++ y la programacion en general no se limita a permitir un for o un while por separado. Uno puede combinarlos poner uno adentro del otro o uno despues del otro, un while adentro de un for adentro de un if, adentro de otro if. Por ejemplo en vez de hacer condA && condB en un if se puede hacer

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

o incluso
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;
                  } 
             } 
        } 
    }
}

son lineas sin sentido pero se tiene que entender la idea de que cualquier cosa puede ir dentro de cualquier otra para resolver problemas, si es necesario

Con todo esto explicado, ya tenes el conocimiento basico para resolver los ejercicios de olimpiadas mas faciles. Faltan todavia muchos temas, y en la semana viene el tutorial intermedio/avanzado de c++, pero con esto explicado ya sabes todas los comandos de variables de c++, y de control del flujo del programa. Suerte y a probar resolver ejercicios.

saludos

Mi solucion con la que tuve en cuenta todo lo que dijieron arriba sobre todo lo de guardar solo los numeros a los que se elevava los primos de la factorizacion. Muchos comentarios. Como use solo iostream ninguna otra libreria, solo arreglos se me hizo algo largo algunas partes pero esta todo lleno de comentarios, no se nescesita ningun conocimiento de ninguna libreria especial para entenderlo, con saber arreglos basta, no use gmp porque se que en la competencia no lo dejan usar. Mi solucion privilegia gastar menos proscesador pero requiere mas memoria, por ejemplo para los numeros marados guardo una matriz con todos los numeros y los que ya me dieron los marco con true, lo que gasta mas memoria pero menos ciclos de trabajo.
Por otro lado elopez93 que programaste la solucion en python, yo por mucho tiempo ame python y fue mi lenguaje principal, pero a la larga me di cuenta que todas la cosas de python tienen un equivalente en c, aunque tenga algo mas de burocracia, a la larga los dos tienen exactamente las mismas estructuras, aunque c por alguna razon es mucho mas veloz que python en iteraciones basicas como el for y otras cosa en general. saludos cualquier duda del programa o algo que pueda mejorar, o algo mal hecho me dicen ;) No se si seria capaz de hacer un programa asi en la ronda nacional de cym es muy dificil editar mucho codigo con el rhide voy a ver si me lo bajo para aclimatarme, las dos competencias en las que participe me costo mucho.

/* 
 * 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
                        }
                    }
                }
            }
        }
    }
}
237
RUN FINISHED; exit value 0; real time: 0ms; user: 0ms; system: 0ms
Programar
pablohpabloh 28 Dec 2013 20:25
in discussion Foro CyM / Tema libre (casi) » Programar

Program.AR (http://www.programar.gob.ar/) es un sitio web que tiene material y herramientas para aprender los rudimentos de la programación. ¡Puede servirte para animarte a participar en CyM!

Programar por pablohpabloh, 28 Dec 2013 20:25

La Ronda Nacional de CyM 2013 es esta semana: del 6 al 8 de noviembre. Ya están disponibles los detalles, en la página de CyM.

¡Nos vemos!

Ronda Nacional de CyM 2013 por pablohpabloh, 04 Nov 2013 11:31

La Ronda Zonal se postergó por problemas con feriados y asuetos. :-(

Re: Ronda Zonal de CyM 2013 por pablohpabloh, 04 Nov 2013 11:27

La Ronda Zonal del 16to Torneo de Computación y Matemática es el viernes 20 de septiembre de 2013, de 14:00 a 17:00. Más información: como siempre en la página web de CyM, http://www.oma.org.ar/nacional/cym/

Ronda Zonal de CyM 2013 por pablohpabloh, 02 Sep 2013 20:58

¡CyM 2013 ya comenzó!

La Ronda Intercolegial del 16to Torneo de Computación y Matemática fue el viernes 23 de Agosto de 2013.

Disfruten el Torneo. :-)

Ronda Intercolegial de CyM 2013 por pablohpabloh, 02 Sep 2013 20:54

Bueno, ese codigo lo que hace es generar por cada digito del numero un M que esta formado por un 1 y la cantidad de ceros segun el digito que sea, ej:

123456
se forman m que son

1000000 para el 1
100000 para el 2
10000 para el 3
1000 para el 4
100 para el 5
10 para el 6

y luego se saca el modulo del numero con todos los m (formando N1) y tambien con todos los m/10 (formando N2) ej:

123456 % 1000000 = 123456 y 123456 % (1000000/10) = 23456
123456 % 100000 = 23456 y 123456 % (100000/10) = 3456
123456 % 10000 = 3456 y 123456 % (10000/10) = 456
123456 % 1000 = 456 y 123456 % (1000/10) = 56
123456 % 100 = 56 y 123456 % (100/10) = 6
123456 % 10 = 6 y 123456 % (10/10) = 0

el siguiente paso es restar N1 y N2 y formamos los N3
123456 - 23456 = 100000
23456 - 3456 = 20000
3456 - 456 = 3000
456 - 56 = 400
56 - 6 = 50
6 - 0 = 6

y lo ultimo dividimos N3 con (M/10) obteniendo las cifras y almacenandolas en la lista CI

100000 / 100000 = 1
20000 / 10000 = 2
3000 / 1000 = 3
400 / 100 = 4
50 / 10 = 5
6 / 1 = 6

y la lista queda asi [6,5,4,3,2,1]

para mejorarlo se me ocurre en vez de dividir M en todos los casos por 10, primero formar todos los M y despues crear todos los modulos del numero y m, almacenarlos en una lista, y en vez de volver a crear de nuevo M/10 Hacer que se saque el modulo de la cifra y el m de un lugar de la lista y despues el modulo de la cifra y el m que sigue en la lista y restarlos, en vez de volver a dividir por 10. esto lo haria mas rapido o es lo mismo? ahora igual lo subo de esa forma.

por otro lado sin usar m por el momento no se me ocurre nada …

Ya están disponibles en la página de CyM los campeones del 15to Torneo de Computación y Matemática (CyM 2012).

Campeones 2012 por pablohpabloh, 30 Oct 2012 19:44

si. a mi me impacto mucho porque en las rondas anteriores usabamos otro entorno en bloodshead C/C++, y en mi casa el codeblocks C/C++, y no son entornos estilo DOS. En mi casa como tengo Linux para usar el RHIDE tengo que usar el emulador de DOS (DOSBOX). Es muy extraño el RHIDE porque usa combinaciones diferentes de teclas para copiar y pegar. Otra diferencia que note fue entre el compilador que usamos en la competencia y el que usamos en las rondas anteriores, el que usamos en mi escuela cuando ponias un FOR o un WHILE, algo (no se si era por el compilador o alguna otra cosa del windows que usabamos) administraba la memoria de la maquina y la misma no estaba desesperada por gastar todo el proscesador en el programa ejecutandose, sino que tenia cierto limite en la velocidad. En cambio con lo que usamos en CyM mientras ejecutabas un programa C/C++ y el programa habia entrado en un ciclo FOR o WHILE no podias hacer otra cosa con la computadora porque se trababa todo hasta que se terminaba de ejecutar, no podias ni mover la ventana e incluso se me colgo completamente la mquina virtual una vez y la tuve que resetear.

mas usuarios en linea :D. hay que lograr que tenga mas trafico porque parece muy abandonado lamentablemente

Sí, es muy viejo. En los primeros torneos usábamos el entorno del Borland C/C++ o Turbo C/C++, el Turbo Pascal, y el QuickBasic (QB). Luego los reemplazamos por el Rhide y el Freepascal, que tienen entornos casi idénticos a aquellos, pero son software libre.

En cuanto podamos vamos a reemplazar todo por cosas más nuevas…

Re: Voy por buen camino? por pablohpabloh, 28 Oct 2012 22:41

Es una primera aproximación. :-)

Este código tiene varias cosas para mejorar. Además de que le vendrían bien unas explicaciones. Y mucho mejor, una demostración de que es correcto. :-D

Para empezar a mejorarlo:

  • sacá todos los includes que no son estrictamente necesarios
  • el código hace trabajo de más: por ejemplo m no hace falta ¿se te ocurre cómo eliminarlo?

¡Y mandalo de nuevo!

Codigo para poner todas las cifras de un numero en un vector ordenado:

#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;
}
page 1123...next »
Si no se indica lo contrario, el contenido de esta página se ofrece bajo Creative Commons Attribution-Noncommercial-Share Alike 2.5 License.