Foro de elhacker.net

Saludos tengo el siguiente programa que me pide que le ingrese un numero romano cualquiera, pero tengo que verificar que si sea romano y que no contenga letras que no sean I, V, X, L, M y es ahi donde tengo el problema

#include <stdio.h>
#include <stdlib.h>
#define TAM 7
 
int main()
{
    char romano[TAM];
    printf("Dame el primer numero: ");
    fgets(romano,TAM,stdin);
    while(*romano++ != '\0')
    {
        if(*romano!='I','V','X','L','C','M')
            printf("Error!! no es numero romano\n");
    }
    return 0;
}

el error esta en el if

de antemano gracias

Ese if no es correcto, no puedes intercalar condiciones con una ,.

Puedes crearte un array con todas las letras del alfabeto romano y recorrerlo.

Humilde consejo: K&R

gracias amchacon seria algo como esto???:

#include <stdio.h>
#include <stdlib.h>
#define TAM 7
 
int main()
{
    char romano[TAM],letras[]={'I','V','X','L','C','M'},*ptr,*p;
    printf("Dame el primer numero: ");
    fgets(romano,TAM,stdin);
    ptr = romano;
    p = letras;
    while(*ptr++ != '\0')
    {
        if(*ptr++ != *p++)
            printf("Error!! no es numero romano\n");
    }
    return 0;
}

y que significa k&r?

while(*ptr++ != '\0')
    {
        if(*ptr++ != *p++)
            printf("Error!! no es numero romano\n");
    }

Esto está mal... solo te va a funcionar si el caracter introducido es I ( el primero ).

Si metes una X, en cuanto llegue a esta línea la primera vez comparará I con  X y al no ser igual te va a lanzar un mensaje de error.

Tienes que comprobar TODOS los caracteres de 'letras' y si no coincide con ninguno entonces mostrar el mensaje de error.

Otra opción más sencilla podría ser:

if ( strchr( letras, *ptr ) == NULL ) printf("Error!! no es numero romano\n");

No, seria un bucle anidado.

Te lo hago con fors que me gustan más:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define TAM 7
 
int main()
{
    int i,j;
    char romano[TAM],letras[]={"IVXLCM"};
    printf("Dame el primer numero: ");
    fgets(romano,TAM,stdin);
 
    for (i = 0; romano[i] != '\n';i++)
    {
        for (j = 0;letras[j];j++)
        {
            if (romano[i] == letras[j]) break;
        }
 
        if (!letras[j]) { printf("Error! No es un numero romano: %c \n",romano[i],i);}
    }
 
    return 0;
}

Cuando se inicializan las posiciones de un array de carácteres de este modo hay que añadir manualmente el fin de cadena:

char romano[TAM],letras[]={'I','V','X','L','C','M'},*ptr,*p; //Este es tu código
char romano[TAM],letras[]={'I','V','X','L','C','M', '\0'},*ptr,*p; //Sería así

Si actualizas la variable de control en la condición del bucle (*ptr++) te estás saltando el primer elemento del array:

while(*ptr++ != '\0')

Debes de hacerlo antes de terminar el bucle:

while(*ptr != '\0') {
   ...
   ptr++;
}

Con ese condicional lo único que estás haciendo es comprobando si la entrada es igual a lo que hay en el array "letras[]", no si se trata de un número romano:

if(*ptr++ != *p++)
               printf("Error!! no es numero romano\n");

Si yo meto "IVXLM" sería correcto pero si introduzco "VII" me la daría por mala cuando si es un número romano.

El ejemplo de amchacon es genial para guiarte en tu código pero me parece que se la ha pasado indicar que solo es para que lo uses como esquema porque no se deben utilizar las instrucciones break/continue para modificar el curso de una iteración en los bucles.

if (romano[i] == letras[j]) break;

Un saludo.

aqui tengo algunas mejoras que le hice al codigo, aunque cuando le ingreso un numero romano cualquiera como: XVI, me imprime error!no es numero romano y no tengo idea de por que, ya van varias veces que lo checo

#include <stdio.h>
#include <stdlib.h>
#define TAM 7
 
int main()
{
    int i,j,bandera;
    char romano[TAM],letras[]={'I','V','X','L','C','M','\0'},*ptr,*p;
    printf("Dame el primer numero: ");
    fgets(romano,TAM,stdin);
    ptr = romano;
    p = letras;
    for(i=*ptr;*ptr!='\0';*ptr++)
    {
        bandera = 0;
        for(j=*p;((*p!='\0')&&(bandera==0));*p++)
        {
            if(*ptr == *p)
               bandera = 1;
        }
        if(bandera!=1)
        {
            printf("Error!No es numero romano\n");
            exit(1);
        }
    }
    return 0;
}

fgets coge también el retorno de carro en la cadena. Por eso puse != '\n en mi código.

Quizás lo más correcto sería:

*ptr != '\n' && *ptr!='\0'

Porque también puede pasar que no coja la cadena entera al ser muy larga, si no coje la cadena entera tampoco cogerá el retorno de carro.

Eso ya depende del profesor, pero break/continue son sentencias totalmente válidas en la vida real.

Generalmente suelen dejar códigos más claros que hacerlas con ellas.

Ya veo, no sabía que hubieran otras opiniones respecto a su uso. En mi facultad los profesores nos prohibían estas instrucciones debido a que utilizar un break/continue es equivalante a la instrucción goto: estás "saltando" desde un punto del bucle a otro modificando el curso de ejecución del programa. Teniendo en cuenta que los paradigmas heredan unos de otros: El paradigma orientado a objetos hereda del estructurado que a su vez hereda del secuencial, C++ es OO y Secuencial a la vez, se deben ejecutar las instrucciones sin saltos de línea.

Tú código queda claro porque hay un único break, pero si estuvieramos hablando de una aplicación un poco más compleja en la que, al permitirse el uso de break/continue, cada bucle tuviera 3 o 4, haría casi imposible su comprensión.

Cualquier opinión o debate es bienvenido. Un saludo.

break/continue representan saltos, pero son saltos estructurados y relativamente claros. Su mala fama se debe a que pongas un break donde no debes y se salte el bucle creando errores extraños. Eso hace que su abuso sea un gran problema, como programador debes decidir si queda claro o confuso su uso en el contexto actual. Como regla general, suelo poner un solo break/continue por bucle y intento que sea al principio, porque se ven más explícitos.

En el código que he propuesto, el uso de break me permite ahorrarme el uso de una variable bandera y se ve bastante claro. Por lo que lo considero adecuado.

Los continue me parecen bastante importantes, imaginate que estas usando un for anidado:

for (short i = 0; i < 100;i++)
   for (short j = 0; j < 100;j++)
   {
        // Codigo...
   }

Y quieres evitar que se haga una iteracion en la cual i = j. Podrías poner algo tal que asi:

for (short i = 0; i < 100;i++)
   for (short j = 0; j < 100;j++)
   {
        if (i != j)
        {
            // Codigo...
        }     
   }

Pero eso implica más llaves y más bloques de codigo. El uso de continue te permite saltarse la iteracion de una forma bastante explícita y clara:

for (short i = 0; i < 100;i++)
   for (short j = 0; j < 100;j++)
   {
        if (i == j) continue;
 
        // Codigo...
   }

Ojo con ese argumento, las llamadas a función también son saltos de ejecución del programa.

Si, pero no son saltos desde el punto de vista del programador sino del programa, cuando hablamos de la prohibición de break/continue/goto no nos referimos a que sea ineficiente realizar estos saltos sino que no son claros a la hora de trabajar el código. Si en mi programa escribo la función "dividir(..)" tanto yo como cualquier otro informático comprenderá qué estamos diviendo X entre Y independientemente de las veces que llame a esta función; sin embargo si en un bucle pongo 3 o 4 break/continue, por lo general otra persona que intente leerlo le va a costar bastante comprenderlo.

Por tanto considero que el argumento citado por los catedráticos es válido.

¿Deberíamos dejarlo en un punto intermedio y usar estas instrucciones con cabeza?, en teoría no habría problema pero igual que con el famoso goto veríamos mucho abuso, por eso gran parte de los informáticos no recomiendan incluirlas en el programa; pero por supuesto la instrucción está ahi y cada uno puede darle el uso que crea conveniente.

Un saludo.

amchacon ya le puse lo que me dijiste en la condicion *ptr!= '\n' && *ptr!='\0'
y no me funciona aun, sigo teniendo el mismo problema de que aunque le ponga un numero romano me imprime que no es

#include <stdio.h>
#include <stdlib.h>
#define TAM 10
 
int main()
{
    int i,j,bandera;
    char romano[TAM],letras[]={'I','V','X','L','C','D','M','\0'},*ptr,*p;
    printf("Dame el primer numero: ");
    fgets(romano,TAM,stdin);
    ptr = romano;
    p = letras;
    for(i=*ptr;((*ptr!='\0')&&(*ptr!= '\n'));*ptr++)
    {
        bandera = 0;
        for(j=*p;(((*p!='\0')&&(*ptr!='\n'))&&(bandera==0));*p++)
        {
            if(*ptr == *p)
               bandera = 1;
        }
        if(!bandera)
        {
            printf("Error!No es numero romano\n");
            exit(1);
        }
    }
    return 0;
}

Tiene un par de errores, te lo pongo corregido:

#include <stdio.h>
#include <stdlib.h>
 
#define TAM 10
 
int main () {
 
    char alfRomano[] = {'I','V','X','L','C','D','M','\0'}, entrada[TAM], *pAlfRomano, *pEntrada;
    bool encontrado;
 
    printf("Introduce un numero: ");
    fgets(entrada, TAM, stdin);
 
    for(pEntrada = entrada; *pEntrada != '\n'; pEntrada++) { //Bucle exterior: recorre la entrada letra por letra
 
        encontrado = false;
        for(pAlfRomano = alfRomano; ((*pAlfRomano != '\0') && !encontrado); pAlfRomano++) { //Bucle interior: comprueba si el siguiente carácter es romano
            if(*pEntrada == *pAlfRomano) encontrado = true;
        }
 
        if(!encontrado) {
            printf("No es un numero romano.\n");
            exit(1);
        }
    }
 
    printf("Es un numero romano.\n");
 
    return 0;
}
 

Casos especiales:

-Si introduces la cadena vacía te la da por correcta y eso no es un número romano.
-Si introduces un número romano correcto y al final un espacio te la da por incorrecta cuando si es válida.

Esto es muy sencillo de manejar pero ya corre por tu cuenta.

Además puedes mejorar el código y añadirle reglas de la sintáxis romana como por ejemplo que no se puedan escribir más de tres carácteres iguales consecutivos: VIIII -> mal

Saludos.

Saludos Alien-Z ya por fin pude encontrar el error, estaba en el puntero del segundo for, cada vez que entraba de nuevo al 2do ciclo el puntero no se reiniciaba  a la primera posicion, pero ya lo pude corregir

int main()
{
    int i,j,bandera;
    char romano[TAM],letras[]={'I','V','X','L','C','D','M','\0'},*ptr,*p;
    printf("Dame el primer numero: ");
    gets(romano);
    ptr = romano;
    p = letras;
    for(i=*ptr;*ptr!='\0';*ptr++)
    {
        bandera = 0;
        for(j=0;((j<7)&&(bandera==0));j++)
        {
            if(*ptr == *(p+j))
               bandera = 1;
        }
        if(!bandera)
        {
            printf("Error!No es numero romano\n");
            exit(1);
        }
    }
    return 0;
}

muchas gracias

Algunos comentarios sobre ese programa:

* Faltan los encabezados.
* Si vas a imprimir una cadena en la salida estándar y esta no termina con el carácter '\n' debes vaciar su bufer de forma explicita mediante la llamada "fflush(stdout);".
* No utilices gets, la razón de ello se explica en el tema |Lo que no hay que hacer en C/C++. Nivel basico| (http://foro.elhacker.net/programacion_cc/lo_que_no_hay_que_hacer_en_cc_nivel_basico-t277729.0.html).
* Para terminar la función principal no es necesario llamar a la función exit, puedes utilizar la sentencia "return N;" con el mismo efecto.

Por ultimo como ya comento eferion se puede utilizar la función strchr (prototipo en <string.h>) para acortar el programa a un solo bucle. Mas o menos así:

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define NUM_CHARS  7
 
int main(void)
{
   char num[NUM_CHARS];
   int i;
 
   printf("Dame el primer numero: ");
   fflush(stdout);
   if (fgets(num, NUM_CHARS, stdin) == NULL)
      return EXIT_FAILURE;
 
   for (i = 0; strchr("IVXLCDM", num[i]) != NULL; i++)
      ;
   if (i > 0 && (num[i] == '\n' || num[i] == '\0'))
      puts("OK");
   else
      puts("Entrada no valida");
 
   return EXIT_SUCCESS;
}

Con la limitante de indicar una entrada no valida si la linea empieza con espacio blanco.

Otra opción consiste en sustituir el bucle basado en strchr por una llamada a strspn.

Un saludo