Mensajes

[Leer 100 numeros.]

Algo que me ayuda a mi a programar es crear unas órdenes de exactamente lo que quiero hacer instrucción a instrucción independientemente de mis conocimientos en el lenguaje de programación. Después implemento cada instrucción en código.
En caso de no ser capaz de completar una de esas instrucciones me leo algún capítulo de un libro sobre esa temática. Te recomiendo descargar varios libros del lenguaje. Mínimo tener 10 libros descargados. Puedes ir leyéndolos todos a lo largo del tiempo. Mirarlos todos sin pararte mucho para usarlos como referencia y acordarte: "Ahh pues este tema de las funciones venía con muchos ejemplos sencillos en el libro Programación para principiantes y muy bien explicado en fundamentos de la programación en C++. Voy a revisar como era.

Entonces, según tu enunciado, las instrucciones que yo planteo de lo que tengo que hacer:
LEER 100 NÚMEROS QUE SEAN POSITIVOS,  CALCULAR Y MOSTRAR LA SUMA DE ESOS 100 NÚMEROS.

Leer 100 numeros.

Código (cpp) [Seleccionar] Expandir

cout << "Pon 100 numeros positivos" << endl;
int numero = 0;
for (short int i = 0; i != 100; ++i)
{
cin >> numero;
}

Que sean positivos:

Código (cpp) [Seleccionar] Expandir

cout << "Pon numeros" << endl;
int numero = 0;
for (short int i = 0; i != 100; ++i)
{
   if (numero > 0)
   {
   cin >> numero;
   }

   else
   {
   --i;
   }
}

Calcular la suma de esos 100 numeros:

Código (cpp) [Seleccionar] Expandir

cout << "Pon numeros" << endl;
int numero = 0;
int suma = 0;
for (short int i = 0; i != 100; ++i)
{
   if (numero > 0)
   {
   cin >> numero;
   suma = suma + numero;
   }

   else
   {
   --i;
   }
}

Mostrar la suma de esos 100 numeros:

Código (cpp) [Seleccionar] Expandir

cout << "Bienvenido, puede sumar 100 numeros positivos." << endl;
int numero = 0;
int suma = 0;
for (short int i = 0; i != 100; ++i)
{
   if (numero > 0)
   {
   cout << endl << "Introduce un número positivo ";
   cin >> numero;
   cout << endl << endl << "Realizando la suma número " << i << ":" << endl;
   cout << "Se suma el número " << numero << " y " << suma;
   suma = suma + numero;
   cout << " y el resultado es " << suma << endl;
   }

   else
   {
   cout << "El numero introducido no es positivo" << endl;
   --i;
   }
}


Librerías, funciones, comentarios...

Código (cpp) [Seleccionar] Expandir

#include <iostream>
/* Incluye la librería para entrada salida del sistema.
En concreto para cout, cin, endl y cin.get()
*/

using namespace std;
/* Utiliza el namespace standart
En concreto para no tener que especificarlo manualmente std::cout std:cin ... y así reducir el tamaño del código.
*/


int main() /* Función principal obligatoria del programa */
{ /* Inicio del cuerpo de la función principal */

cout << "Bienvenido, puede sumar 100 numeros positivos." << endl;
/* Imprime en pantalla (y hace 1 salto de linea al final):
Bienvenido, puede sumar 100 numeros positivos.


unsigned int numero = 0;
unsigned int suma = 0;
/* Se declaran dos variables de tipo entero sin signo y se inicializan asignándoles valor 0.
*/

   for (unsigned short int i = 0; i != 100; ++i) /* Bucle for:
Primer parámetro, inicialización de variables. Se declara una variable de tipo entero corto, sin signo y se le asigna valor 0.
Segundo parámetro, condición a cumplir para salida del bucle. Continua el bucle mientras la variable i no tenga el valor 0 al evaluar la condición.
Tercer parámetro, modificación para cumplir la condición. Se suma 1 a la variable i en cada iteración.
*/
   { /* Cuerpo del bucle for.

      if (numero >= 0) /* Condición: Si la variable número es mayor o igual a 0. */
      { /* Cuerpo del if.
      cout << endl << "Introduce un número positivo ";

      cin >> numero;
/* Se obtiene el numero introducido por el usuario */

      cout << endl << endl << "Realizando la suma número " << i << ":" << endl;
      cout << "Se suma el número " << numero << " y " << suma;

     suma = suma + numero;
/* Se suman la variable para guardar el resultado de la suma y el número del usuario.

    cout << " y el resultado es " << suma << endl;
/* Se imprime el resultado de la suma */
      }

      else /* Si el número es menor a 0 */
      {
      cout << "El numero introducido no es positivo" << endl;
      --i; /* Se resta 1 a i para no contabilizar esta iteración del bucle for */
      }
   }

cin.get(); /* Pausa la consola para que no se cierre automáticamente. */
return 0; /* Retorna el control a la función principal */
}

Eso no me parece que funcione debidamente... No puedes primero comprobar que el número sea positivo y después pedir el número y sumarlo ya que la comprobación de que el número sea positivo tienes que realizarla, de una manera u otra, entre la petición del número y la suma.

Para que tenga mas de un hijo debo implemenarlo con una lista enlazada.
struct node{
      struct node *padre;
      vector<node> hijos;
      void *dato; (Sustituir por el dato).
}

Bueno, lo primero es que para que cada nodo tenga más de un hijo no es necesario utilizar una lista enlazada. Los árboles binarios son los más extendidos en programación y cada nodo tiene dos punteros (hijoIzquierda e hijoDerecha) aunque puede tener tres para incluir otro puntero (padre) y poder ascender por el árbol. Depende de lo que tú necesites.
Sería más correcto decir que árboles de n hijos utilizan una lista enlazada y entonces te aviso que la lista enlazada de la STL es <list>, no <vector> aunque es una puntualización pequeña.
Debes estar seguro también de usar correctamente los punteros <void*>.

Quitando esos pequeños detalles, diría que la implementación no está mal.

[si no es mayor o igual que 0]

Bueno en lo que al enunciado respecta, leer 100 números suele referirse a pedir 100 números al usuario a no ser que se especifique leer números de un fichero u otra entrada diferente a la estándar (que es por teclado).
Lo de que sean números positivos puede interpretarse de dos maneras:

• Comprobar que los números introducidos sean positivos y contabilizar únicamente los que lo sean.
  
• Establecer la precondición de que sean positivos por lo que el programador/a (en este caso, tú) no tiene que tomar ninguna medida para asegurar que dicha condición se cumpla.
  En este caso que no se concreta ninguna de las dos interpretaciones supongo que dependerá de lo que sabes o no sabes hacer. Si sabes (o deberías saber) hacer un filtro (usando <do while> normalmente) pues mi recomendación es que lo implementes ya que te ayudará a practicar más que si no lo haces; en cambio, si es algo que todavía no has estudiado, no pasa nada, se presupone que los valores serán positivos y no tienes que hacer nada.
  Por último, mostrar la suma de los 100 números pues lógicamente es sumar los 100 valores positivos y mostrar el resultado final.
  
  En lo que a tu código respecta, primero para próximas consultas (puedes modificar tu mensaje para corregirlo) los códigos colócalos entre etiquetas de Código GeSHi seleccionando el lenguaje correspondiente (C++ en tu caso).
  
  Código (cpp) [Seleccionar] Expandir
  
#include <iostream>
// La libreria math.h no la utilizas ya que esta se usa para funciones como calcular potencias, raices cuadradas y otras funciones complejas
// Los operadores basicos (suma, resta, producto, division,...) no estan en esta libreria
#include <math.h>

using namespace std;

int main (){   
    int numeros;

    cout<<"Ingrese un numero:"<<endl; // Pedir un numero al usuario
    cin>>numeros; // Guardarlo

    if (numeros>=0){ // Si el numero es mayor o igual que 0...
        cout<<"La suma de los numeros es:"<<numeros + numeros; // ...mostrar el doble del numero introducido
    }
    else if (numeros<=100){ // si no es mayor o igual que 0 pero si es menor o igual que 100...
        cout<<numeros+numeros; // mostrar el doble del numero introducido
    }
    else cout<<"no puede ser negativo"; // Si no es mayor o igual que 0 y tampoco es menor o igual que 100...Avisar de que no puede ser negativo
   
    return 0;
}
  Te he comentado tu código para que veas lo que estás haciendo. Los problemas que hay son los siguientes:
  
• El usuario sólo introduce un número, no 100.
  
• Si el número es 0 o mayor muestra su doble, si no es mayor o igual que 0 pero sí es menor o igual que 100 (cosa un poco rara), muestra el doble también y si no es mayor o igual que 0 y tampoco es menor o igual que 100 entonces no es válido. Ahora dime... habría algún número no válido?? Porque hasta donde yo sé contar, todos lo son...
  
  El algoritmo correcto en pseudocódigo sería algo así (sin el filtro de los números positivos):
  
  Código [Seleccionar] Expandir
  
INICIO
    numerosIntroducidos := 0
    suma := 0
    MIENTRAS numerosIntroducidos < 100 HACER
        PEDIR numero
        suma := suma + numero
        numerosIntroducidos := numerosIntroducidos + 1
    FIN MIENTRAS
    MOSTRAR suma
FIN

Bueno... antes de nada avisarte que este foro es específico para C/C++. Para cualquier otro tema como es el pseudocódigo, tienes el foro de "Programación General".

La segunda cosa a tratar es que entendía lo que querías decir hasta que has llegado al ejemplo... No puedes representar un ² como un 2 normal porque anda que no hay diferencia de 32 a 3²...

Y por último, la función en cuestión. La función tiene dos parámetros el número inicial y la cantidad de sumandos que tendrá la operación. Si te fijas, tienes (4,3) que significa sumar 4 números al cuadrado empezando por el 3. Cuando ya tengas sumado el 3² te quedarás por sumar 3 números más y el primero será el 4 porque el 3 ya está sumado. Por lo que empezaría siendo (4,3) y después sería (3,4), después (2,5), luego (1,6) y finalmente (0,7) que como con el 0 haces un break no se llegaría a sumar el 7² por lo que parece que de primeras está bien.

Sin embargo el valor de <res> en el último caso es desconocido por lo que te podría salir cualquier cosa y no te daría el resultado esperado. Tienes dos formas de solucionar esto, una es asignando el valor 0 a <res> al principio de la función para que así en el caso base (n == 0) se devuelva un 0 que no afecta a la suma o usar un <return> en vez de un <break>

Código [Seleccionar] Expandir


SI n == 0 ENTONCES
    return 0
FIN SI
return (d*d) + sum_squares(n-1, d+1)
Al usar <return> el <else> se vuelve innecesario y la creación de la variable <res> también.

Si de verdad me estás diciendo que tu profesor no te deja aplicar ninguno de los consejos y que por ende te está enseñando/obligando a no usar constantes, usar variables globales, repetir código, escribir código innecesario y no organizarlo en funciones... Siento decirte que tienes un pésimo profesor.

Pero bueno, tu duda era cómo generar un valor aleatorio para la máquina y en la función <elegirPosicion()> te he mostrado cómo hacerlo. Así que no sé si tienes alguna duda más.

Antes de nada, los códigos entre etiquetas de Código GeSHi.
Lo único que tienes que hacer es usar un bucle para "simular" la función <pow()>. Como la función <pow()> lo que hace es elevar la base a una potencia y las potencias no son otra cosa que sucesivos productos, lo que al final te piden es que calcules la potencia de un número usando un bucle que multiplique ese número x veces.
En pseudocódigo tu solución quedaría así:

Código [Seleccionar] Expandir


INICIO
    PEDIR numero
    digitos[LONGITUD_MAXIMA] // array de longitud igual al maximo numero de digitos que puede tener el numero
    numeroDigitos := calcularDigitos(numero, digitos)

    sumaTotal := 0
    PARA i := 0 HASTA numeroDigitos-1 HACER
        resultadoPotencia := 1
        PARA j := 0 HASTA numeroDigitos-1 HACER // Este es el bucle que simula la potencia
            resultadoPotencia := resultadoPotencia * digitos[i]
        FIN PARA
        sumaTotal := sumaTotal + resultadoPotencia
    FIN PARA

    SI sumaTotal == numero ENTONCES
        MOSTRAR "El numero es narcisista"
    SINO ENTONCES
        MOSTRAR "El numero no es narcisista"
    FIN SI
FIN
Ahora te queda a ti ver cómo sería la función <calcularDigitos()> ya que no existe de manera predefinida y cómo traducir este pseudocódigo a C++. Bueno... Y lo más importante: entender el procedimiento.

Código (c) [Seleccionar] Expandir


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

int tablero[3][3];
int col, fila;
int modo, ban;
int win;
int pos;
int player;

void gotoxy(int x,int y){
   HANDLE hcon;
   hcon = GetStdHandle(STD_OUTPUT_HANDLE);
   COORD dwPos;
   dwPos.X = x;
   dwPos.Y= y;
   SetConsoleCursorPosition(hcon,dwPos);
}

void escenario(){
   gotoxy(33,2); printf("#############");
   gotoxy(33,3); printf("# 1 # 2 # 3 #"); //35,3 39,3 43,3
   gotoxy(33,4); printf("#############");
   gotoxy(33,5); printf("# 4 # 5 # 6 #"); //35,5 39,5 43,5
   gotoxy(33,6); printf("#############");
   gotoxy(33,7); printf("# 7 # 8 # 9 #"); //35,7 39,7 43,7
   gotoxy(33,8); printf("#############");
 
   gotoxy(33,10); printf("#############");
   gotoxy(33,11); printf("#   #   #   #"); //35,11 39,11 43,11
   gotoxy(33,12); printf("#############");
   gotoxy(33,13); printf("#   #   #   #"); //35,13 39,13 43,13
   gotoxy(33,14); printf("#############");
   gotoxy(33,15); printf("#   #   #   #"); //35,15 39,15 43,15
   gotoxy(33,16); printf("#############");
}


main(){
   for(col=0; col<3; col++){
       for(fila=0; fila<3; fila++){
           tablero[col][fila]=5;
       }
   }

   do{
       system("cls");
       printf("El juego del Gato\n");
       ban=0;
       gotoxy(1,18);printf("Elija la modalidad de juego: 1 Usuario1 vs Usuario2 - 2 Usuario vs Maquina");
       gotoxy(1,19);printf("Modalidad: ");
       scanf("%d",&modo);
       if(modo == 1){
           ban=1;
           if(modo==1){
               gotoxy(1,20);printf("Usuario1 <<X>> vs Maquina <<O>>");
               escenario();
               win=0;
               player=1;
           }
           do{
               gotoxy(1,21); printf("En que cuadro quiere tirar: ");
               scanf("%d",&pos);
               if(pos>=1 && pos<=9){
                   switch(pos){
                       case 1:
                           if(tablero[0][0]==5){
                               if(player==1){
                                   tablero[0][0]=1;
                                   player=2;
                                   gotoxy(35,11);printf("%d",tablero[0][0]);
                               }
                               else{
                                   tablero[0][0]=0;
                                   player=1;
                                   gotoxy(35,11);printf("%d",tablero[0][0]);
                               }
                           }
                           else{
                               printf("La Casilla ya esta ocupada, intente de nuevo");
                           }
                           break;

                       case 2:
                           if(tablero[0][1]==5){
                               if(player==1){
                                   tablero[0][1]=1;
                                   player=2;
                                   gotoxy(39,11);printf("%d",tablero[0][1]);
                               }
                               else{
                                   tablero[0][1]=0;
                                   player=1;
                                   gotoxy(39,11);printf("%d",tablero[0][1]);
                               }
                           }
                           else{
                               printf("La Casilla ya esta ocupada, intente de nuevo");
                           }
                           break;
                   }
               }

           }while(win!=1);

       }
       else{
           printf("La Opcion Seleccionada es Erronia intente nuevamente");
       }

       getch();
   }while(ban!=1);
   getch();
}
Esto era lo que estaba pidiendo que hicieras para poder leer tu código porque sino es realmente imposible saber hasta donde llega cada llave...

Deberías usar funciones y usar variables locales. Las variables globales hacen a los programas inconsistentes... Para algo existen los parámetros a funciones. Además si te das cuenta:

• Las líneas 55y 57 son lo mismo. Si entra en el primer <if> obviamente entrará en el segundo también.
  
• No sé cuál es la utilidad de la variable <ban>.
  
• La línea 66 no es necesaria ya que puedes hacer el <switch> del 1 al 9 y un caso <default> para cualquier otro caso.
  
• No utilices números mágicos (es decir, número literales como para el tamaño de la matriz o los bucles for). Es mejor crear unas constantes por ejemplo así:
  
  Código (c) [Seleccionar] Expandir
  
#define TAM_COLS 3
#define TAM_FILAS 3
  
• En vez de inicializar toda la matriz a 5 (que entiendo que es un número al azar) sería mejor inicializarla a 0 y usar el 1 para el primer jugador y el 2 para el segundo.
  
• Cada <case> es prácticamente igual al resto y ocupa 15 líneas. Agrupar código en una función te ahorrará bastante.
  
  
  Yo haría lo siguiente: inicializar el tablero a 0, usar la variable <jugador> con valor {1,2} para determinar el jugador en cada momento, la variable <modo> con valor {1,2} para determinar 2 jugadores o 1 jugador vs máquina, respectivamente; y la variable <ganador> con valor {0,1,2} para representar ningún ganador, el primer jugador gana o el segundo jugador gana, respectivamente.
  
  El programa general sería algo así:
  
  Código (c) [Seleccionar] Expandir
  
// librerias

#define TAM_FILA 3
#define TAM_COL 3

// prototipos de funciones
// es mejor poner los prototipos antes del main y las funciones despues del main. Tambien se pueden poner las funciones completas antes del main

int main(){ // la funcion main es de tipo int. Es mejor ponerlo siempre
   int tablero[TAM_FILA][TAM_COL]; // tablero del juego
   int jugador = 1; // indica el jugador actual (por defecto el 1). valores = {1,2}
   int modo; // indica el modo de juego. valores = {1,2}
   int ganador = 0; // indica el ganador. valores = {0,1,2}

    inicializarTablero(tablero, 0);

   modo = elegirModo();

   while(!ganador && !tableroCompleto(tablero)){
       posicion = elegirPosicion(tablero, jugador, modo);
       actualizarTablero(tablero, jugador, posicion);
       ganador = comprobarGanador(tablero);
       jugador = (jugador + 1) % jugador; // intercambia el jugador de 1 a 2 y de 2 a 1
   }

   if(ganador)
       printf("Jugador %d gana!!", ganador);
   else
       printf("Empate...");
}
  Un código limpio, corto y sencillo... que con leer el <main> ya sabes lo que hace el programa. Si luego quieres ver cómo funciona una parte específica o quieres cambiar alguna parte, sólo tienes que ir a la función correspondiente.
  
  Con esto claro puedes hacer una función como esta para que un jugador elija una posición VÁLIDA del tablero:
  
  Código (c) [Seleccionar] Expandir
  
// como la variable tablero deberia ser declarada dentro del main, tendras que pasarla como parametro:
int elegirPosicion(int tablero[][TAM_COLS], int jugador, int modo){
   do{
       if(jugador == 2 && modo == 2) // si le toca a la maquina...
           posicion = 1 + rand() % (TAM_FILA * TAM_COL); // calcula una posicion aleatoria
       else{
           printf("Elige una posicion valida [%d, %d]: ", 1, TAM_FILA * TAM_COL);
           scanf("%d", posicion);
       }
       int fila = (posicion - 1) / TAM_COL; // calculas la fila segun la posicion
       int col = (posicion - 1) % TAM_COL; // calculas la columna segun la posicion
   }  while(fila >= TAM_FILA || col >= TAM_COL || tablero[fila][col]); // la tercera expresion solo funciona si inicializas la matriz a 0 como dije antes
   return posicion;
}
  
  El resto de funciones te las dejo a ti que yo creo que con esto ya te he hecho bastante. Te dejo como guía lo que debería hacer cada función:
  
  Código (c) [Seleccionar] Expandir
  
// Poner todas las casillas del tablero con el valor <valor>
void inicializarTablero(int tablero[][TAM_COL], int valor);

// Mostrar los modos, hacer un filtro para que el modo sea valido y devolverlo cuando lo sea
int elegirModo();

// En la funcion <elegirPosicion(...) ya hemos comprobado que la casilla no este ocupada por lo que aqui
// solo tienes que calcular la fila y columna correspondiente y asignarle el valor <jugador>
void actualizarTablero(int tablero[][TAM_COL], int jugador, int posicion);

// Recorrer todo el tablero mientras no encuentres un 0 (valor por defecto de las casillas)
// Si encuentras un 0 devuelves el 0 y si no devuelves un numero distinto de 0 (la opcion habitual es 1 para asemejarlo a un true/false).
int tableroCompleto(tablero);

// Recorrer todo el tablero. Devolver el numero del jugador que ha ganado y si ninguno ha ganado, devolver un 0.
int comprobarGanador(tablero)

Siempre que los objetos que se pasan como parámetro no se van a modificar es recomendable pasarlos constantes para asegurar que pase lo que pase no se va a modificar (como decirle al compilador "no me dejes modificar este objeto ni por error") y por referencia para que así se pase la dirección de memoria del objeto original y no se cree una copia local (ya que si no se pasa por referencia, se pasa por valor y entonces lo que se hace es crear una copia del objeto con su consiguiente gasto de memoria).

El constructor de copia tiene un problema y es que le asignas 10 a <max> en vez de asignarle <p.max> ya que la longitud del nuevo tiene que ser la misma que la del que copias.
Y la función <Copiar()> tiene otro problema y es que estás incrementando <cima> pero en ningún momento la pones a -1 antes de empezar a incrementar y tampoco actualizas el valor de <max>. Además como ya no estás usando las funciones <Apilar()> y <Desapilar()> en la función <Copiar()> (y por tanto ya no estás modificando la original) ahora sí puedes (y debes) pasar el parámetro constante y por referencia.

Lo que estás haciendo es generar dos números aleatorios: el primero en el intervalo [0,4] para la i y el segundo en el intervalo [0,9] para la j.
Luego estás haciendo un bucle para recorrer toda la matriz (empezando i y j en 0 por lo que los valores aleatorios ya los has perdido) y estás asignando una "E" a cada casilla de la matriz.

Como lo que quieres es generar 3 posiciones aleatorias y supongo que no sirve que la misma posición se repita 3 veces, deberás primero generar un valor aleatorio para i y para j, poner una "E" en esa posición y después volver a generar un valor aleatorio para cada variable y comprobar que esa posición no tenga ya una "E".

Lo primero: si no asignas ningún valor a la matriz te saldrá "basura" es decir caracteres aleatorios. Lo mejor es que inicialices toda la matriz con el mismo carácter (el que prefieras... un 0, un -, un *,... lo único importante es que sea un carácter, es decir, entre comillas simples y que no sea la E lógicamente).

Después de eso puedes hacer un bucle que se repita mientras no se hayan generado 3 posiciones aleatorias diferentes. Y eso cómo se sabe? Bueno pues en pseudocódigo sería algo así (el pseudocódigo no es lenguaje C, sirve para que entiendas el proceso que has de seguir pero una vez que lo entiendas debes implementar el mismo comportamiento en C).

Código [Seleccionar] Expandir


INICIO
   MIENTRAS posicionesGeneradas < 3 HACER
       i := generarAleatorio(0,4) // creas una i aleatoria entre 0 y 4
       j := generarAleatorio(0,9) // creas una j aleatoria entre 0 y 9
       SI matriz[i][j] != 'E' ENTONCES // si esa posicion aleatoria no tiene una E...
           matriz[i][j] = 'E' // se la pones
           posicionesGeneradas := posicionesGeneradas + 1 // e incrementas el numero de posiciones en las que ya has puesto una E
       FIN SI
   FIN MIENTRAS
FIN
De esta manera si se genera una i y una j aleatorias pero ya habías asignado una 'E' ahí, no cuenta entonces y vuelve a calcularlo otra vez hasta que tengas 3 posiciones de la matriz con una 'E'.

EDIT: Repito, lo que está escrito en pseudocódigo no funciona si lo copias y lo pegas tal cual. La función <generarAleatorio(0,4)> por ejemplo no existe en C. Es para que entiendas lo que tienes que hacer y luego lo hagas como se hace en C (que en este caso es usando <rand() % 5>.