• Viernes 8 de Noviembre de 2024, 16:12

Mostrar Mensajes

Esta sección te permite ver todos los posts escritos por este usuario. Ten en cuenta que sólo puedes ver los posts escritos en zonas a las que tienes acceso en este momento.


Mensajes - infonet

Páginas: [1]
1
Java / Re: Trabajar con Fechas en Java
« en: Lunes 2 de Noviembre de 2009, 16:17 »
Cita de: "gophlb"
Cita de: "infonet"
   switch (nMes){
         case 1: if ((ndia<=31) && (ndia>=1))
                 nRes = 2; break;
         case 2: if ((ndia<=29) && (ndia>=1))
                 nRes = 2; break;
         case 3: if ((ndia<=31) && (ndia>=1))
                 nRes = 2; break;
         case 4: if ((ndia<=30) && (ndia>=1))
                 nRes = 2; break;
         case 5: if ((ndia<=31) && (ndia>=1))
                 nRes = 2; break;
         case 6:  if ((ndia<=30) && (ndia>=1))
                 nRes = 2; break;
         case 7:  if ((ndia<=31) && (ndia>=1))
                 nRes = 2; break;
         case 8:  if ((ndia<=31) && (ndia>=1))
                 nRes = 2; break;
         case 9:  if ((ndia<=30) && (ndia>=1))
                 nRes = 2; break;
         case 10: if ((ndia<=31) && (ndia>=1))
                 nRes = 2; break;
         case 11: if ((ndia<=30) && (ndia>=1))
                 nRes = 2; break;
         case 12: if ((ndia<=31) && (ndia>=1))
                 nRes = 2; break;
            }
           
   
 [/code]
podrias mejorar este switch de la siguiente forma ->
case 1: case 3: case 7: case 8: case 10: case 12:
if ((ndia<=31) && (ndia>=1))  nRes = 2; break;

case2:
if ((ndia<=29) && (ndia>=1))  nRes = 2; break;

case 4: case 6: case 9: case 11:
if ((ndia<=30) && (ndia>=1))  nRes = 2; break;


asi, te ahorras el que si te confundes en lo que sea, solo tienes que cambiarlo una vez por grupo, no 12 veces :)


ademas, si lo que estas haciendo es validar, tu respuesta deberia ser SI o NO, no un 1 o un 2. Es decir, que esos metodos de validacion te deberian devolver un boolean en lugar de un int.

sobre por que funciona o deja de funcionar: ni idea, no tengo tiempo para ponerme a depurar codigo, pero toma nota de ese par de consejillos ;)
luego cuando llegue a casa si tengo tiempo y no te ha contestado nadie, lo vuelvo a echar un ojo

muchas gracias, tienes razon, pero aun estoy con el problema de calculos de años

Código: Java
  1.  
  2. int totalAños(Fecha f){
  3.        
  4.          int tot_año;
  5.        
  6.          GregorianCalendar date1 = new GregorianCalendar(obtenerAño(), obtenerMes(),obtenerDia());
  7.          GregorianCalendar date2 = new GregorianCalendar(f.obtenerAño(), f.obtenerMes(),f.obtenerDia());
  8.        
  9.          
  10.         if (date1.get(Calendar.YEAR) == date2.get(Calendar.YEAR))
  11.            tot_año=0;
  12.          else
  13.             tot_año = date2.get(Calendar.YEAR) - date1.get(Calendar.YEAR);
  14.             
  15.      return (tot_año); 
  16.     }
  17.  
  18.  

ya que a este codigo el resultado no es exacto

2
Java / Trabajar con Fechas en Java
« en: Lunes 2 de Noviembre de 2009, 15:09 »
Estimados, tengo estos codigos JAVA en donde realizo operaciones con Fechas, una es la Fecha del Sistema y la Otra es la Fecha ingresada por Teclado, pero al calcular los años entre fechas, este no me da exacto...

ej: si ingreso 30/11/2008 este me dice que es 1 y mi idea es que me diga 11 mese y 28 dias...

como lo puedo hacer
Código: Java
  1.  
  2.  
  3. import  java.io.*;
  4. import java.util.*;
  5. import java.text.*;
  6. import java.util.Calendar;
  7. import java.util.GregorianCalendar;
  8.  
  9. public class Fecha
  10. {
  11.     public int dia;
  12.     public int mes;
  13.     public int año;
  14.    
  15.     public Fecha()
  16.     {}
  17.     public Fecha(int d, int m, int a)
  18.     {
  19.         this.dia = d;
  20.         this.mes = m;
  21.         this.año = a;
  22.     }
  23.     public Fecha(int d, int m )
  24.     {
  25.         this.dia = d;
  26.         this.mes = m;
  27.     }
  28.     public Fecha(int d)
  29.     {
  30.         this.dia = d;
  31.     }
  32.     public Fecha(Fecha f)
  33.     {}
  34.     void AsignarFecha(int d, int m, int a)
  35.     {
  36.         AsignarDia (d);
  37.         AsignarMes (m);
  38.         AsignarAño (a);
  39.     }
  40.    
  41.     void AsignarDia(int n)
  42.     {
  43.         dia = n;
  44.     }
  45.     void AsignarMes(int n)
  46.     {
  47.         mes = n;
  48.     }
  49.     void AsignarAño(int n)
  50.     {
  51.         año =n;
  52.     }
  53.     int obtenerDia()
  54.     {
  55.         return(dia);
  56.     }
  57.    
  58.     int obtenerMes()
  59.     {
  60.         return(mes);
  61.     }
  62.     int obtenerAño()
  63.     {
  64.         return(año);
  65.     }
  66.    
  67.     int ValidaDia(int nMes, int ndia  )
  68.     {      
  69.      int nRes=1;
  70.      
  71.      if ((ndia<=31) && (ndia>=1))
  72.      { 
  73.        switch (nMes){
  74.          case 1: if ((ndia<=31) && (ndia>=1))
  75.                  nRes = 2; break;
  76.          case 2: if ((ndia<=29) && (ndia>=1))
  77.                  nRes = 2; break;
  78.          case 3: if ((ndia<=31) && (ndia>=1))
  79.                  nRes = 2; break;
  80.          case 4: if ((ndia<=30) && (ndia>=1))
  81.                  nRes = 2; break;
  82.          case 5: if ((ndia<=31) && (ndia>=1))
  83.                  nRes = 2; break;
  84.          case 6:  if ((ndia<=30) && (ndia>=1))
  85.                  nRes = 2; break;
  86.          case 7:  if ((ndia<=31) && (ndia>=1))
  87.                  nRes = 2; break;
  88.          case 8:  if ((ndia<=31) && (ndia>=1))
  89.                  nRes = 2; break;
  90.          case 9:  if ((ndia<=30) && (ndia>=1))
  91.                  nRes = 2; break;
  92.          case 10: if ((ndia<=31) && (ndia>=1))
  93.                  nRes = 2; break;
  94.          case 11: if ((ndia<=30) && (ndia>=1))
  95.                  nRes = 2; break;
  96.          case 12: if ((ndia<=31) && (ndia>=1))
  97.                  nRes = 2; break;
  98.             }
  99.            
  100.       }    
  101.      return (nRes);
  102.     }
  103.    
  104.     int ValidaMes(int m)
  105.     {
  106.        int nRes = 1;
  107.        if ((m<=12) && (m>=1))
  108.            nRes = 2;  
  109.      return (nRes);        
  110.     }
  111.  
  112.    
  113.    
  114.     int ValidaAño(int a)
  115.     {
  116.      int nRes = 1;
  117.        if (a>=1900)
  118.            nRes = 2;  
  119.      return (nRes);            
  120.      }
  121.    
  122.    
  123.     int ValidaFecha(int d, int m, int a)
  124.     {
  125.         int nRes = 1;
  126.         int nopp=0;
  127.        
  128.         System.out.println("");
  129.             
  130.          nopp=ValidaMes(m);
  131.          if (nopp==2)
  132.          { 
  133.             nopp=ValidaDia(m,d);   
  134.             if (nopp==2)
  135.              { 
  136.                  nopp=ValidaAño(a);
  137.                  if (nopp==2)   
  138.                     {
  139.                      if (m==2)
  140.                         {           
  141.                          if ((a % 4 == 0) && ((a % 100 != 0) || (a % 400 == 0)))
  142.                             if ((d<=29) && (d>=1))
  143.                                 nRes=2;
  144.                             else   
  145.                                System.out.println("Error el Año Ingreasado es bisiesto y su diabe debe estar en el rango 1 al 29, para el mes febrero");           
  146.                          }      
  147.                         else
  148.                           nRes=2;
  149.                       }      
  150.                       else
  151.                        System.out.println("Error en el Año Ingreasado debe ser mayor o igual 1900");        
  152.                }      
  153.               else
  154.                 System.out.println("Error en el Dia Ingreasado");        
  155.             }
  156.             else
  157.               System.out.println("Error en el Mes Ingreasado");
  158.                                  
  159.      return (nRes);            
  160.     }
  161.            
  162.     public void Listar()
  163.     {
  164.         System.out.println(obtenerDia()+"/"+obtenerMes() +"/"+obtenerAño());
  165.        
  166.     }
  167.     public void print()
  168.     {
  169.         System.out.println(dia+"/"+mes+"/"+año);
  170.     }
  171.  
  172.    
  173.     long totalDias(Fecha f)
  174.         {
  175.          
  176.          GregorianCalendar gc = new GregorianCalendar(obtenerAño(), obtenerMes(),obtenerDia());
  177.          GregorianCalendar gc1 = new GregorianCalendar(f.obtenerAño(), f.obtenerMes(),f.obtenerDia());
  178.                        
  179.          Date fec1 = gc.getTime();
  180.          Date fec2 = gc1.getTime();
  181.          
  182.          long time = fec2.getTime() - fec1.getTime();
  183.                  
  184.          long tot_dia=time / (3600*24*1000);
  185.          return (tot_dia)   ;
  186.          
  187.     }
  188.    
  189.     int totalAños(Fecha f){
  190.        
  191.          int tot_año;
  192.        
  193.          GregorianCalendar date1 = new GregorianCalendar(obtenerAño(), obtenerMes(),obtenerDia());
  194.          GregorianCalendar date2 = new GregorianCalendar(f.obtenerAño(), f.obtenerMes(),f.obtenerDia());
  195.        
  196.          
  197.         if (date1.get(Calendar.YEAR) == date2.get(Calendar.YEAR))
  198.            tot_año=0;
  199.          else
  200.             tot_año = date2.get(Calendar.YEAR) - date1.get(Calendar.YEAR);
  201.             
  202.      return (tot_año); 
  203.     }
  204.    
  205.     String esBisiesto (){
  206.         String result="NO es Bisiesto ";
  207.        
  208.         if ((obtenerAño() % 4 == 0) && ((obtenerAño() % 100 != 0) || (obtenerAño() % 400 == 0)))
  209.            result="es bisiesto";
  210.                
  211.     return (result);   
  212.     }
  213.    
  214.     public void listaFechaLarga (){
  215.        
  216.        Date today;
  217.        String output;
  218.        SimpleDateFormat ftr;
  219.        DateFormatSymbols symbols;
  220.        String[] defaultDays;
  221.        DateFormat dateFormatter;
  222.        Date sDate;
  223.  
  224.  
  225.        symbols = new DateFormatSymbols(new Locale("en","U"));
  226.        defaultDays = symbols.getShortWeekdays();
  227.        
  228.       try  
  229.       {
  230.      
  231.         String fec_str=String.valueOf(obtenerDia())+"/"+ String.valueOf(obtenerMes()) +"/"+String.valueOf(obtenerAño());
  232.         SimpleDateFormat dy = new SimpleDateFormat("dd/MM/yyyy");
  233.        
  234.         today =dy.parse(fec_str);
  235.        
  236.         SimpleDateFormat sd = new SimpleDateFormat("dd MMMMM yyyy,  hh:mm aaa");
  237.        
  238.         output = sd.format(today);
  239.        
  240.         System.out.println(output);
  241.       }  
  242.       catch (ParseException e)
  243.        {
  244.            
  245.          System.out.println("Error al asignar la fecha");  
  246.         }       
  247.   }
  248. }
  249.  
  250.  
 

ESTE ES EL MAIN
Código: Java
  1.  
  2.  
  3. import  java.io.*;
  4. import  java.util.*;
  5. import java.text.*;
  6. import java.util.Calendar;
  7. import java.util.GregorianCalendar;
  8.  
  9. public class UsaFecha
  10. {
  11.  public static void main (String args[]) throws IOException, Exception
  12.     {
  13.         int dia=0, mes=0, año=0;
  14.         int d=0, m=0, a=0;
  15.         int res=0;
  16.        
  17.         String dateOut;
  18.         String string;
  19.         DateFormat dateFormatter;
  20.        
  21.        
  22.        
  23.        
  24.         BufferedReader tecla= new BufferedReader(new InputStreamReader(System.in) );
  25.         System.out.println("Operaciones para Fecha");
  26.         System.out.println(" ");
  27.         System.out.println("1. Total de Días a la fecha de hoy");
  28.         System.out.println("2. Total de Años a la fecha de hoy");
  29.         System.out.println("3. Es un año bisiesto");
  30.         System.out.println("4. Quiere Listar su fecha en formato largo");
  31.                                                                          
  32.         System.out.println("0. Salir");
  33.         System.out.println(" ");
  34.         System.out.print("selecciona una opcion: ");
  35.         int Respuesta = Integer.parseInt(tecla.readLine());
  36.         if(Respuesta==0){ res=2; System.exit(0);}
  37.         System.out.println(" ");
  38.        
  39.         Fecha Objeto1 = new Fecha();
  40.         Fecha Objeto2 = new Fecha();
  41.                
  42.         if (Respuesta==3)
  43.            {
  44.            System.out.print("Ingrese Año : ");
  45.            año=Integer.parseInt(tecla.readLine());
  46.            Objeto1.AsignarAño(año);   
  47.            res=Objeto1.ValidaAño(año);
  48.            if (res==1) System.out.println("Error en el Año debe ser mayor o igual a 1900");
  49.            }
  50.         else
  51.            {        
  52.            System.out.print("Ingrese dia : ");
  53.            dia=Integer.parseInt(tecla.readLine());
  54.        
  55.            System.out.print("Ingrese mes : ");
  56.            mes=Integer.parseInt(tecla.readLine());
  57.        
  58.            System.out.print("Ingrese Año : ");
  59.            año=Integer.parseInt(tecla.readLine());
  60.            
  61.            Objeto1.AsignarFecha(dia, mes, año);
  62.            res=Objeto1.ValidaFecha(dia, mes, año); 
  63.             
  64.            }
  65.            
  66.            
  67.        
  68.          
  69.         if (res == 2)
  70.         {
  71.           
  72.            java.util.Date hoy = new Date();
  73.         
  74.            dateFormatter = DateFormat.getDateInstance(DateFormat.DEFAULT);
  75.        
  76.            dateOut = dateFormatter.format(hoy);
  77.        
  78.            d=Integer.valueOf(dateOut.substring(0,2));
  79.            string = dateOut.substring(3);
  80.            m=Integer.valueOf(string.substring(0,2));
  81.            string = string.substring(3);
  82.            a=Integer.valueOf(string.substring(0,4));
  83.                    
  84.                 
  85.            Objeto2.AsignarDia(d);
  86.            Objeto2.AsignarMes(m);
  87.            Objeto2.AsignarAño(a);
  88.            
  89.                          
  90.            switch(Respuesta)
  91.                 {
  92.                 case 1: //Total de Días a la fecha de hoy
  93.                     System.out.println("Total de Días a la fecha de hoy "+Objeto1.totalDias(Objeto2));
  94.                 break;
  95.                 case 2://Total de Años a la fecha de hoy
  96.                     System.out.println("El Total de Años a la fecha de hoy "+  Objeto1.totalAños(Objeto2));
  97.                 break;
  98.                 case 3://Es un año bisiesto
  99.                     System.out.println("El año ingresado "+ Objeto1.esBisiesto());
  100.                 break;
  101.                 case 4://Quiere Listar su fecha en formato largo
  102.                 {
  103.                     System.out.println(" " );
  104.                     System.out.println("Su fecha en formato largo es " );
  105.                     Objeto1.listaFechaLarga();
  106.                  }      
  107.                     break;
  108.                 default:
  109.                    
  110.                     System.out.println("Selecciones una Operacion disponible");
  111.                 break; 
  112.                 }   
  113.    
  114.        }       
  115.                
  116. }   
  117.  
  118. }
  119.  
  120.  
  121.  

3
C/C++ / SOLUCIONADO
« en: Martes 15 de Septiembre de 2009, 22:34 »
Solucionado...
y Gracias por sus ayudas....


Código: C++
  1.  
  2.  
  3. #include<stdio.h>
  4. #include<conio.h>
  5. #include<string.h>
  6. #include<stdlib.h>
  7. #include<ctype.h>
  8. #include <windows.h>
  9. #include <math.h>
  10. #include <dos.h>
  11.  
  12. int Sigue,Tamano,Cont,PosIni,i,PosVec,j,PosParen,Error,CanTonk,Tamano2,k,Opcion;
  13. char string[150],CadenaLeida[150],Bloques[50][150],SiFor[150],Tokens[50][150],NuevaCadena[150];
  14. int pIni;
  15.  
  16. int EsOperador(char QueAnalizar)
  17. {if (QueAnalizar=='+')
  18.  {return(1);}
  19.  else if (QueAnalizar=='-')
  20.  {return(1);}
  21.  else if (QueAnalizar=='*')
  22.  {return(1);}
  23.  else if (QueAnalizar=='/')
  24.  {return(1);}
  25.  else if (QueAnalizar=='(')
  26.  {return(2);}
  27.  else if (QueAnalizar==')')
  28.  {return(2);}
  29.  else if (QueAnalizar=='[')
  30.  {return(2);}
  31.  else if (QueAnalizar==']')
  32.  {return(2);}
  33.  else if (QueAnalizar=='<')
  34.  {return(3);}
  35.  else if (QueAnalizar=='>')
  36.  {return(3);}
  37.  else if (QueAnalizar=='=')
  38.  {return(3);}
  39.  else if (QueAnalizar=='!')
  40.  {return(3);}
  41.  else
  42.  {return(0);}
  43. }
  44.  
  45. void EsFor()
  46. {printf("nntDigite la sentencia que desea evaluar: ");
  47. //Leer la cadena de caracteres que se va a evaluar.
  48. // scanf("%s",CadenaLeida);
  49. gets(string);
  50.  printf("nCadena leida Completa: %s",string);
  51.  int i;
  52.   int j;
  53.  
  54.    for (i = j = 0; string[i] != ''; i++)
  55.       if (string[i] != ' ')
  56.      string[j++] = string[i];
  57.      string[j] = '';
  58.        printf("nCadena  sin  Espacios: %s", string);
  59. strcpy(CadenaLeida, string);
  60. //printf("n Cadena Final : %s ",CadenaLeida);
  61. //getche();
  62.  //Tomar el tama¤o de la cadena.
  63.  Tamano=strlen(CadenaLeida);
  64.  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  65.  //  Recorrer los caracteres de la cadena le¡da para reconocer si es una sentencia.
  66.  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  67.  PosParen=0;
  68.  for(i=0;i<=Tamano-1;i++)
  69.  {//Si el caracter es un '('.
  70.   if(CadenaLeida[i]=='(')
  71.   {PosVec=0;
  72.    for(j=0;j<=i-1;j++)
  73.    {SiFor[PosVec]=CadenaLeida[j];
  74.     PosVec=PosVec+1;
  75.    }
  76.    PosParen=i;
  77.    break;
  78.   }
  79.  }
  80.  //-------------------------------------------------------------------------------
  81.  //Si se han producido errores.
  82.  if(PosParen!=3)
  83.  {printf("ntLa cadena digitada no cumple con la s¡ntaxis de la intrucci¢n FOR");
  84.   printf("ntError: %s", SiFor);
  85.  }
  86.  else if (strcmp(SiFor,"for")!=0)
  87.  {printf("ntLa cadena digitada no cumple con la s¡ntaxis de la intrucci¢n FOR");
  88.   printf("ntError: %s", SiFor);
  89.  }
  90.  else if (CadenaLeida[Tamano-1]!=')')
  91.  {printf("ntLa cadena digitada no cumple con la s¡ntaxis de la intrucci¢n FOR");
  92.   printf("ntError: %c falta par‚ntesis de cierre final", CadenaLeida[Tamano-1]);
  93.  }
  94.  else
  95.  {Cont=0;
  96.   PosIni=4;
  97.   //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  98.   // Recorrer los car cteres de la cadena le¡da para reconocer los bloques del for.
  99.   //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  100.   for(i=4;i<=Tamano-2;i++)
  101.   {//Si el caracter es un ';'
  102.    if(CadenaLeida[i]==';')
  103.    {PosVec=0;
  104.     //Guardar parte de la cadena en otra variable.
  105.     for(j=PosIni;j<=i;j++)
  106.     {Bloques[Cont][PosVec]=CadenaLeida[j];
  107.      PosVec=PosVec+1;
  108.     }
  109.     Cont=Cont+1;
  110.     PosIni=i+1;
  111.    }
  112.   }
  113.   //Guardar parte de la cadena en otra variable.
  114.   PosVec=0;
  115.   for(j=PosIni;j<=Tamano-2;j++)
  116.   {Bloques[Cont][PosVec]=CadenaLeida[j];
  117.    PosVec=PosVec+1;
  118.   }
  119.   //---------------------------------------------------------------------------
  120.   //Si se han producido errores.
  121.   if (Cont<2)
  122.   {printf("ntLa cadena digitada no cumple con la s¡ntaxis de la intrucci¢n for");
  123.    printf("ntError: faltan bloques del for 'for([init-expr];[cond-expr];[loop-expr])'");
  124.   }
  125.   else if (Cont!=2)
  126.   {printf("ntLa cadena digitada no cumple con la s¡ntaxis de la intrucci¢n for");
  127.    printf("ntError: hay mas de 3 bloques para el for 'for([init-expr];[cond-expr];[loop-expr])'");
  128.   }
  129.   else
  130.   {//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  131.    //Identificar los tokens existentes dentro de los bloques del for.
  132.    //Almacenar los primero Tokens.
  133.    strcpy(Tokens[0],SiFor);
  134.    Tokens[1][0]=CadenaLeida[3];
  135.    CanTonk=1;
  136.    //Recorrer todos los Bloques.
  137.    for(i=0;i<=Cont;i++)
  138.    {//Limpiar la variable NuevaCadena.
  139.     PosVec=0;
  140.     for(k=0;k<=149;k++)
  141.     {NuevaCadena[k]=0;}
  142.     //Tomar el tamano del bloque actual.
  143.     Tamano2=strlen(Bloques[i])-1;
  144.     //Buscar los Tokens del Bloque Actual.
  145.     for(j=0;j<=Tamano2;j++)
  146.     {if(EsOperador(Bloques[i][j])==0 && Bloques[i][j]!=';')
  147.      {NuevaCadena[PosVec]=Bloques[i][j];
  148.       PosVec=PosVec+1;
  149.      }
  150.      else
  151.      {if (strlen(NuevaCadena)!=0)
  152.       {CanTonk=CanTonk+1;
  153.        for(k=0;k<=PosVec;k++)
  154.        {Tokens[CanTonk][k]=NuevaCadena[k];}
  155.        //Limpiar la variable NuevaCadena.
  156.        PosVec=0;
  157.        for(k=0;k<=149;k++)
  158.        {NuevaCadena[k]=0;}
  159.       }
  160.       CanTonk=CanTonk+1;
  161.       Tokens[CanTonk][0]=Bloques[i][j];
  162.      }
  163.     }
  164.    }
  165.    if (strlen(NuevaCadena)!=0)
  166.    {CanTonk=CanTonk+1;
  167.     for(k=0;k<=PosVec;k++)
  168.     {Tokens[CanTonk][k]=NuevaCadena[k];}
  169.     //Limpiar la variable NuevaCadena.
  170.     PosVec=0;
  171.     for(k=0;k<=149;k++)
  172.     {NuevaCadena[k]=0;}
  173.    }
  174.    CanTonk=CanTonk+1;
  175.    Tokens[CanTonk][0]=41; //Ascii=')'
  176.    //---------------------------------------------------------------
  177.    printf("nntNUMERO IDENTIFICADOS");
  178.    for(i=0;i<=CanTonk;i++)
  179.    {if (strlen(Tokens[i])>0)
  180.     {printf("nt%dt%s",i+1,Tokens[i]);}
  181.     else
  182.     {printf("nt%dt%c",i+1,Tokens[i]);}
  183.     {printf("ttOK VALIDADO..!!!");}
  184.    }
  185.   }
  186.  }
  187. }
  188.  
  189. main()
  190. {Sigue=0;
  191.  do
  192.  {
  193.   system("cls");
  194. // clrscr();
  195.   printf("nntttPROGRAMA    QUE    VALIDA");
  196.   printf("nntttCICLO FORnn");
  197.   printf("nnttt1.ANALIZAR CICLO FORnnn");
  198.   printf("nntttDIGITE OPCION: ");
  199.   scanf("%d", &Opcion);
  200. //  flushall();
  201. fflush(stdin);
  202.   for(i=0;i<=149;i++)
  203.   {CadenaLeida[i]=0;
  204.    SiFor[i]=0;
  205.   }
  206. //  for(i=0;i<=49;i++)
  207. //  {for(j=0;j<=149;j++)
  208. //   {Bloques[i][j]=0;
  209. //    Tokens[i][j]=0;
  210. //   }
  211. //  }
  212.   if(Opcion==1)
  213.   {EsFor();
  214.    printf("nnntEJECUTA EL PROGRAMA NUEVAMENTE?? [SI=1][NO=0]: ");
  215.    scanf("%d",&Sigue);
  216.   }
  217.   else
  218.   {printf("nnError digite una opci¢n valida.");}
  219.  }while(Sigue!=0);
  220. }
  221.  
  222.  
  223.  

4
C/C++ / Re: Validar un Ciclo EJ: For
« en: Domingo 13 de Septiembre de 2009, 08:12 »
TENGO ESTE CODIGO QUE ME DEJA EN "CadenaLeida" el ingreso de la sentencia sin espacio en blanco, pero al tomar esa "CadenaLeida" en el Programa anterio no me valida....
Código: C++
  1.  
  2. #include <iostream.h>
  3. #include <string.h>
  4. #include <conio.h>
  5. #include <dos.h>
  6.  
  7.  
  8. int main()
  9. {
  10.  
  11.  
  12. char string[150];
  13. char CadenaLeida[150];
  14. int pos, num_chars;
  15. for (pos = 0; pos < 80; pos++)
  16. {
  17. string[pos] =' '; //reset de string
  18. }
  19.  
  20. cout << "INGRESE UNA CADENA CON LOS CARACTERES DEL ARREGLO: ";
  21. cin.get(string,150,'n');
  22.  
  23.   int i;
  24.   int j;
  25.    
  26.    for (i = j = 0; string[i] != ''; i++)
  27.       if (string[i] != ' ')
  28.          string[j++] = string[i];
  29.          string[j] = '';
  30.          printf("texto sin espacios: %s", string);
  31.    
  32.  
  33.  
  34. strcpy(CadenaLeida, string);
  35.  
  36. printf("n Cadena Final : %s ",CadenaLeida);
  37.  
  38. getche();
  39. return 0;
  40. }
  41.  
  42.  

5
C/C++ / Validar un Ciclo EJ: For
« en: Domingo 13 de Septiembre de 2009, 08:12 »
Estimados tengo el siguiente código fuente, que me valida el ciclo for, pero lo único que me está faltando es que me considere los espacios en blanco, me podrían orientar como lo valido…
Estaba buscando y algo encontré con isspace

Pero no me resulta, tendré que guardarlo  en un vector???


Código: C++
  1.  
  2. #include<stdio.h>
  3. #include<conio.h>
  4. #include<string.h>
  5. #include<stdlib.h>
  6. #include<ctype.h>
  7. #include <windows.h>
  8. #include <math.h>
  9. #include <dos.h>
  10. int pos, num_chars, Sigue,Tamano,Cont,PosIni,i,PosVec,j,PosParen,Error,CanTonk,Tamano2,k,Opcion;
  11. char string[150],CadenaLeida[150],Bloques[50][150],SiFor[150],Tokens[50][150],NuevaCadena[150];
  12. int EsOperador(char QueAnalizar)
  13. {if (QueAnalizar=='+')
  14.  {return(1);}
  15.  else if (QueAnalizar=='-')
  16.  {return(1);}
  17.  else if (QueAnalizar=='*')
  18.  {return(1);}
  19.  else if (QueAnalizar=='/')
  20.  {return(1);}
  21.  else if (QueAnalizar=='(')
  22.  {return(2);}
  23.  else if (QueAnalizar==')')
  24.  {return(2);}
  25.  else if (QueAnalizar=='[')
  26.  {return(2);}
  27.  else if (QueAnalizar==']')
  28.  {return(2);}
  29.  else if (QueAnalizar=='<')
  30.  {return(3);}
  31.  else if (QueAnalizar=='>')
  32.  {return(3);}
  33.  else if (QueAnalizar=='=')
  34.  {return(3);}
  35.  else if (QueAnalizar=='!')
  36.  {return(3);}
  37.  else
  38.  {return(0);}
  39. }
  40. void EsFor()
  41. {printf("nntDigite la sentencia que desea evaluar: ");
  42.  //Leer la cadena de caracteres que se va a evaluar.
  43.  scanf("%s",CadenaLeida);
  44.  //Tomar el tama¤o de la cadena.
  45.  Tamano=strlen(CadenaLeida);
  46.  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  47.  //  Recorrer los caracteres de la cadena le¡da para reconocer si es una sentencia.
  48.  //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  49.  PosParen=0;
  50.  for(i=0;i<=Tamano-1;i++)
  51.  {//Si el caracter es un '('.
  52.   if(CadenaLeida[i]=='(')
  53.   {PosVec=0;
  54.    for(j=0;j<=i-1;j++)
  55.    {SiFor[PosVec]=CadenaLeida[j];
  56.     PosVec=PosVec+1;
  57.    }
  58.    PosParen=i;
  59.    break;
  60.   }
  61.  }
  62.  //-------------------------------------------------------------------------------
  63.  //Si se han producido errores.
  64.  if(PosParen!=3)
  65.  {printf("ntLa cadena digitada no cumple con la s¡ntaxis de la intrucci¢n FOR");
  66.   printf("ntError: %s", SiFor);
  67.  }
  68.  else if (strcmp(SiFor,"for")!=0)
  69.  {printf("ntLa cadena digitada no cumple con la s¡ntaxis de la intrucci¢n FOR");
  70.   printf("ntError: %s", SiFor);
  71.  }
  72.  else if (CadenaLeida[Tamano-1]!=')')
  73.  {printf("ntLa cadena digitada no cumple con la s¡ntaxis de la intrucci¢n FOR");
  74.   printf("ntError: %c falta par‚ntesis de cierre final", CadenaLeida[Tamano-1]);
  75.  }
  76.  else
  77.  {Cont=0;
  78.   PosIni=4;
  79.   //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  80.   // Recorrer los car cteres de la cadena le¡da para reconocer los bloques del for.
  81.   //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  82.   for(i=4;i<=Tamano-2;i++)
  83.   {//Si el caracter es un ';'
  84.    if(CadenaLeida[i]==';')
  85.    {PosVec=0;
  86.     //Guardar parte de la cadena en otra variable.
  87.     for(j=PosIni;j<=i;j++)
  88.     {Bloques[Cont][PosVec]=CadenaLeida[j];
  89.      PosVec=PosVec+1;
  90.     }
  91.     Cont=Cont+1;
  92.     PosIni=i+1;
  93.    }
  94.   }
  95.   //Guardar parte de la cadena en otra variable.
  96.   PosVec=0;
  97.   for(j=PosIni;j<=Tamano-2;j++)
  98.   {Bloques[Cont][PosVec]=CadenaLeida[j];
  99.    PosVec=PosVec+1;
  100.   }
  101.   //---------------------------------------------------------------------------
  102.   //Si se han producido errores.
  103.   if (Cont<2)
  104.   {printf("ntLa cadena digitada no cumple con la s¡ntaxis de la intrucci¢n for");
  105.    printf("ntError: faltan bloques del for 'for([init-expr];[cond-expr];[loop-expr])'");
  106.   }
  107.   else if (Cont!=2)
  108.   {printf("ntLa cadena digitada no cumple con la s¡ntaxis de la intrucci¢n for");
  109.    printf("ntError: hay mas de 3 bloques para el for 'for([init-expr];[cond-expr];[loop-expr])'");
  110.   }
  111.   else
  112.   {//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
  113.    //Identificar los tokens existentes dentro de los bloques del for.
  114.    //Almacenar los primero Tokens.
  115.    strcpy(Tokens[0],SiFor);
  116.    Tokens[1][0]=CadenaLeida[3];
  117.    CanTonk=1;
  118.    //Recorrer todos los Bloques.
  119.    for(i=0;i<=Cont;i++)
  120.    {//Limpiar la variable NuevaCadena.
  121.     PosVec=0;
  122.     for(k=0;k<=149;k++)
  123.     {NuevaCadena[k]=0;}
  124.     //Tomar el tamano del bloque actual.
  125.     Tamano2=strlen(Bloques[i])-1;
  126.     //Buscar los Tokens del Bloque Actual.
  127.     for(j=0;j<=Tamano2;j++)
  128.     {if(EsOperador(Bloques[i][j])==0 && Bloques[i][j]!=';')
  129.      {NuevaCadena[PosVec]=Bloques[i][j];
  130.       PosVec=PosVec+1;
  131.      }
  132.      else
  133.      {if (strlen(NuevaCadena)!=0)
  134.       {CanTonk=CanTonk+1;
  135.        for(k=0;k<=PosVec;k++)
  136.        {Tokens[CanTonk][k]=NuevaCadena[k];}
  137.        //Limpiar la variable NuevaCadena.
  138.        PosVec=0;
  139.        for(k=0;k<=149;k++)
  140.        {NuevaCadena[k]=0;}
  141.       }
  142.       CanTonk=CanTonk+1;
  143.       Tokens[CanTonk][0]=Bloques[i][j];
  144.      }
  145.     }
  146.    }
  147.    if (strlen(NuevaCadena)!=0)
  148.    {CanTonk=CanTonk+1;
  149.     for(k=0;k<=PosVec;k++)
  150.     {Tokens[CanTonk][k]=NuevaCadena[k];}
  151.     //Limpiar la variable NuevaCadena.
  152.     PosVec=0;
  153.     for(k=0;k<=149;k++)
  154.     {NuevaCadena[k]=0;}
  155.    }
  156.    CanTonk=CanTonk+1;
  157.    Tokens[CanTonk][0]=41; //Ascii=')'
  158.    //---------------------------------------------------------------
  159.    printf("nntNUMERO IDENTIFICADOS");
  160.    for(i=0;i<=CanTonk;i++)
  161.    {if (strlen(Tokens[i])>0)
  162.     {printf("nt%dt%s",i+1,Tokens[i]);}
  163.     else
  164.     {printf("nt%dt%c",i+1,Tokens[i]);}
  165.     {printf("ttt OK VALIDADO..!!!");}
  166.    }
  167.   }
  168.  }
  169. }
  170. main()
  171. {Sigue=0;
  172.  do
  173.  {
  174.   system("cls");
  175.   printf("nnttttPROGRAMA    QUE    VALIDA");
  176.   printf("nntttttCICLO FORnn");
  177.   printf("nnttt1. ANALIZAR CICLO FORnnn");
  178.   printf("nnttttDIGITE OPCION: ");
  179.   scanf("%d", &Opcion);
  180.   for(i=0;i<=149;i++)
  181.   {CadenaLeida[i]=0;
  182.    SiFor[i]=0;
  183.   }
  184.   for(i=0;i<=49;i++)
  185.   {for(j=0;j<=149;j++)
  186.    {Bloques[i][j]=0;
  187.     Tokens[i][j]=0;
  188.    }
  189.   }
  190.   if(Opcion==1)
  191.   {EsFor();
  192.    printf("nnntEJECUTA EL PROGRAMA NUEVAMENTE?? [SI=1][NO=0]: ");
  193.    scanf("%d",&Sigue);
  194.   }
  195.   else
  196.   {printf("nnError digite una opci¢n valida.");}
  197.  }while(Sigue!=0);
  198. }
  199.  
  200.  
  201.  

6
C/C++ / Re: Como Valido un Ciclo???
« en: Lunes 7 de Septiembre de 2009, 12:55 »
LISTO.
Código: C++
  1.  
  2.  
  3. int Sigue,Tamano,Cont,PosIni,i,PosVec,j,PosParen,Error,CanTonk,Tamano2,k,Opcion;
  4. char CadenaLeida[150],Bloques[50][150],SiFor[150],Tokens[50][150],NuevaCadena[150];
  5. int pIni;
  6. char wh[10],od[10];
  7.  
  8. int EsOperador(char QueAnalizar)
  9. {if (QueAnalizar=='+')
  10.  {return(1);}
  11.  else if (QueAnalizar=='-')
  12.  {return(1);}
  13.  else if (QueAnalizar=='*')
  14.  {return(1);}
  15.  else if (QueAnalizar=='/')
  16.  {return(1);}
  17.  else if (QueAnalizar=='(')
  18.  {return(2);}
  19.  else if (QueAnalizar==')')
  20.  {return(2);}
  21.  else if (QueAnalizar=='[')
  22.  {return(2);}
  23.  else if (QueAnalizar==']')
  24.  {return(2);}
  25.  else if (QueAnalizar=='<')
  26.  {return(3);}
  27.  else if (QueAnalizar=='>')
  28.  {return(3);}
  29.  else if (QueAnalizar=='=')
  30.  {return(3);}
  31.  else if (QueAnalizar=='!')
  32.  {return(3);}
  33.  else
  34.  {return(0);}
  35. }
  36.  
  37. void EsFor()
  38. {printf("nntDIGITE LA SENTENCIA: ");
  39.  scanf("%s",CadenaLeida);
  40.  
  41.  Tamano=strlen(CadenaLeida);
  42.  PosParen=0;
  43.  for(i=0;i<=Tamano-1;i++)
  44.  {
  45.   if(CadenaLeida[i]=='(')
  46.   {PosVec=0;
  47.    for(j=0;j<=i-1;j++)
  48.    {SiFor[PosVec]=CadenaLeida[j];
  49.     PosVec=PosVec+1;
  50.    }
  51.    PosParen=i;
  52.    break;
  53.   }
  54.  }
  55.  if(PosParen!=3)
  56.  {printf("ntLA SENTENCIA DIGITADANO NO CUMPLE CON LA SINTAXIS DEL FOR");
  57.   printf("ntERROR: %s", SiFor);
  58.  }
  59.  else
  60.   if(strcmp(SiFor,"for")!=0 && strcmp(SiFor,"For")!=0 && strcmp(SiFor,"FOR")!=0)
  61.   {printf("ntLA SENTENCIA DIGITADANO NO CUMPLE CON LA SINTAXIS DEL FOR");
  62.   printf("ntERROR: %s", SiFor);
  63.  }
  64.  else if (CadenaLeida[Tamano-1]!=')')
  65.  {printf("ntLA SENTENCIA DIGITADANO CUMPLE CON LA SINTAXIS DEL FOR");
  66.   printf("ntERROR: %c FALTA PARENTESIS DE CIERRE FINAL", CadenaLeida[Tamano-1]);
  67.  }
  68.  else
  69.  {Cont=0;
  70.   PosIni=4;
  71.   for(i=4;i<=Tamano-2;i++)
  72.   {
  73.    if(CadenaLeida[i]==';')
  74.    {PosVec=0;
  75.     for(j=PosIni;j<=i;j++)
  76.     {Bloques[Cont][PosVec]=CadenaLeida[j];
  77.      PosVec=PosVec+1;
  78.     }
  79.     Cont=Cont+1;
  80.     PosIni=i+1;
  81.    }
  82.   }
  83.  
  84.   PosVec=0;
  85.   for(j=PosIni;j<=Tamano-2;j++)
  86.   {Bloques[Cont][PosVec]=CadenaLeida[j];
  87.    PosVec=PosVec+1;
  88.   }
  89.   if (Cont<2)
  90.   {printf("ntLA SENTENCIA DIGITADANO CUMPLE CON LA SINTAXIS DEL FOR");
  91.    printf("ntERROR: FALTAN BLOQUES DEL FOR 'for([init-expr];[cond-expr];[loop-expr])'");
  92.   }
  93.   else if (Cont!=2)
  94.   {printf("ntLA SENTENCIA DIGITADANO CUMPLE CON LA SINTAXIS DEL FOR");
  95.    printf("ntERROR: HAY 3 BLOQUES PARA EL FOR 'for([init-expr];[cond-expr];[loop-expr])'");
  96.   }
  97.   else
  98.   {
  99.    strcpy(Tokens[0],SiFor);
  100.    Tokens[1][0]=CadenaLeida[3];
  101.    CanTonk=1;
  102.      for(i=0;i<=Cont;i++)
  103.    {
  104.     PosVec=0;
  105.     for(k=0;k<=149;k++)
  106.     {NuevaCadena[k]=0;}
  107.     Tamano2=strlen(Bloques[i])-1;
  108.      for(j=0;j<=Tamano2;j++)
  109.     {if(EsOperador(Bloques[i][j])==0 && Bloques[i][j]!=';')
  110.      {NuevaCadena[PosVec]=Bloques[i][j];
  111.       PosVec=PosVec+1;
  112.      }
  113.      else
  114.      {if (strlen(NuevaCadena)!=0)
  115.       {CanTonk=CanTonk+1;
  116.        for(k=0;k<=PosVec;k++)
  117.        {Tokens[CanTonk][k]=NuevaCadena[k];}
  118.              PosVec=0;
  119.        for(k=0;k<=149;k++)
  120.        {NuevaCadena[k]=0;}
  121.       }
  122.       CanTonk=CanTonk+1;
  123.       Tokens[CanTonk][0]=Bloques[i][j];
  124.      }
  125.     }
  126.    }
  127.    if (strlen(NuevaCadena)!=0)
  128.    {CanTonk=CanTonk+1;
  129.     for(k=0;k<=PosVec;k++)
  130.     {Tokens[CanTonk][k]=NuevaCadena[k];}
  131.     PosVec=0;
  132.     for(k=0;k<=149;k++)
  133.     {NuevaCadena[k]=0;}
  134.    }
  135.    CanTonk=CanTonk+1;
  136.    Tokens[CanTonk][0]=41; //Ascii=')'
  137.    printf("nntTOKENS IDENTIFICADOS");
  138.    for(i=0;i<=CanTonk;i++)
  139.    {if (strlen(Tokens[i])>0)
  140.     {printf("nt%dt%s",i+1,Tokens[i]);}
  141.     else
  142.     {printf("nt%dt%c",i+1,Tokens[i]);}
  143.     {printf("ttTOKENS OK VALIDADO..!!!");}
  144.     }
  145.    }
  146.   }
  147. }
  148. main()
  149. {Sigue=0;
  150.  do
  151.  {
  152.   system("cls");
  153.   printf("nnttttPROGRAMA    QUE    VALIDA");
  154.   printf("nntttttCICLO FORnn");
  155.   printf("nnttt1. ANALIZAR CICLO FORnnn");
  156.   printf("nnttttDIGITE OPCION: ");
  157.   scanf("%d", &Opcion);
  158.   for(i=0;i<=149;i++)
  159.   {CadenaLeida[i]=0;
  160.    SiFor[i]=0;
  161.   }
  162.   for(i=0;i<=49;i++)
  163.   {for(j=0;j<=149;j++)
  164.    {Bloques[i][j]=0;
  165.     Tokens[i][j]=0;
  166.    }
  167.   }
  168.   if(Opcion==1)
  169.   {EsFor();
  170.    printf("nnntEJECUTA EL PROGRAMA NUEVAMENTE?? [SI=1][NO=0]: ");
  171.    scanf("%d",&Sigue);
  172.   }
  173.   else
  174.   {printf("nnERROE DIGITE UNA OPCION VALIDA.");}
  175.  }while(Sigue!=0);
  176. }
  177.  
  178.  

7
C/C++ / Re: Consulta Programa
« en: Lunes 7 de Septiembre de 2009, 12:48 »
con quie estas programando?????
Cargaste simpson.h a la bibloteca de tu compilador, generalmente se llama la carpeta include??

8
C/C++ / Re: Como Valido un Ciclo???
« en: Miércoles 2 de Septiembre de 2009, 04:35 »
También estaba pensando en dejar en una variable el largo de la sentencia y con  otro for validar…
Que Opinan

9
C/C++ / Como Valido un Ciclo???
« en: Martes 1 de Septiembre de 2009, 20:50 »
Estimados tengo la dura tare de Validar en C++ con DEV C++ el Cliclo For y tengo una vaga ide, plis si me pueden apoyar gracias

les adjunto el codigo realizado hasta el momento

Por ejemplo que me valide esta instruccion:

for(x=1;x<=10;x=x+1)


Código: C++
  1.  
  2. #include <stdio.h>
  3. #include <stdlib.h>
  4. #include <string.h>
  5. #include <conio.h>
  6. #include <windows.h>
  7. #include <math.h>
  8.  
  9. void gotoxy(short x, short y)
  10. { HANDLE hConsoleOutput; COORD Cursor_Pos = {x, y};
  11. hConsoleOutput = GetStdHandle(STD_OUTPUT_HANDLE);
  12. SetConsoleCursorPosition(hConsoleOutput, Cursor_Pos); }
  13.  
  14.  
  15. void carga_caracteres()
  16. {
  17.  int i  ;  
  18.  
  19.  char car_mayusculas[100];
  20.  char car_minusculas[100];
  21.  char car_letras[100];
  22.  
  23.  
  24.  
  25. // for ( i=65; 90; i++);  // mayusculas
  26. //  car_mayusculas[i]=i;
  27.  
  28. // for (i=97; 122; i++);  // minusculas
  29. //  car_minusculas[i]=i;
  30.  
  31. //return;
  32.  }
  33.  
  34.  
  35.  
  36. void  est_exit(int num)
  37. {
  38.  switch(num)
  39.    {
  40.      case 0 :gotoxy(10,10);printf("Debe ingresar una f, en la primera posicion ");break;
  41.      case 1 :gotoxy(10,11);printf("Debe ingresar una o, en la segunda posicion");break;
  42.      case 1 :gotoxy(10,12);printf("Debe ingresar una r, en la tercera posicion");break;
  43.      case 2 :gotoxy(10,13);printf("Debe ingresar parentecis (");break;
  44.      case 3 :gotoxy(10,14);printf("Debe ingresar parentecis )");break;
  45.      case 4 :gotoxy(10,15);printf("Debe ingresar un blanco");break;
  46.      case 5 :gotoxy(10,16);printf("Debe ingresar una condición");break;
  47.      case 6 :gotoxy(10,17);printf("Debe ingresar una una llave {");break;
  48.      case 7 :gotoxy(10,18);printf("Debe ingresar una una llave }");break;
  49. }
  50.  getch();
  51. }
  52.  
  53.    
  54. main()
  55. {
  56. char sentencia [100];
  57. int n;
  58. int i;
  59. int cont=0;
  60. char validos[11];
  61.  validos[0]='(';
  62.  validos[1]=')';
  63.  validos[2]='{';
  64.  validos[3]='}';
  65.  validos[4]='<';
  66.  validos[5]='>';
  67.  validos[6]='=';
  68.  validos[7]='!';
  69.  validos[8]='&';
  70.  validos[9]='|';
  71.  validos[10]=char(32);
  72.  
  73.  
  74.       system("cls");            
  75.       gotoxy(5,5);printf(" Ingrese sentencia--> ");scanf("%s",sentencia);
  76.      
  77.       n=strlen(sentencia);
  78.      
  79.       i=0;
  80.      
  81. //      do {
  82.           if (sentencia[i] != 'f')
  83.              est_exit(i);
  84.           else
  85.             {          
  86.               i=i+1;
  87.               if (sentencia[i]!= 'o')
  88.                   est_exit(i);
  89.               else
  90.                  {          
  91.               i=i+1;
  92.               if (sentencia[i]!= 'r')
  93.                   est_exit(i);
  94.               else
  95.              {
  96.                 i=i+1;
  97.                 printf("%d",i);
  98.                 if ( sentencia[i] !=  ' ' )
  99.                    est_exit(4);
  100.                 else;
  101.                   do {
  102.                      cont=cont+1;
  103.                      i=i+1;
  104.                     } while ( sentencia[i]= '(') ;
  105.                 }    
  106.              }    
  107.            
  108. //         } while ( i != n);  
  109.            
  110.      
  111. }
  112.  
  113.  
  114.  

10
C/C++ / Re: FUNCIONES Y ARREGLOS???
« en: Martes 25 de Agosto de 2009, 21:40 »
LISTO Y FUNCIONANDO EN DEV C++
Código: C++
  1.  
  2. #include<stdio.h>
  3. #include<conio.h>
  4. #include<string.h>
  5. #include<stdlib.h>
  6. #include<ctype.h>
  7. #define MAX 100
  8. int longitud;//LONGITUD DE LA CADENA ENTRADA
  9. int salgo;//BANDERA Q HACE ACABAR EL PROGRAMA SI EL USUARIO HA INSERTADO UNA MALA ENTRADA
  10. char entrada[MAX];//ENTRADA DEL USUARIO
  11. char salida[MAX];//SALIDA YA CONVERTIDA A LETRAS
  12. char actual[MAX];//VALOR DEL NUMERO ACTUAL
  13. char actualposterior[MAX];//VALOR DEL NUMERO POSTERIOR
  14. char revisada[MAX]; //LA ENTRADA UNA VEZ REVISADA PARA Q EL USUARIO NO ENTRE LETRAS
  15. char opcio[MAX]; //OPCION SELECCIONADA 1 CASTELLANO 2 ROMANO
  16. int p;
  17. int aux;
  18. int revisaelnumero(char a_revisar[]);//MIRA Q LA LONGITUD DEL TEXTO SEA MENOR DE 9 Y Q NO HAYAN LETRAS
  19. void traduce_a_Cas(char revisada[]); //FUNCION Q "TRADUCE" AL CASTELLANO
  20. void traduce_a_Rom(int); //FUNCION Q "TRADUCE" AL ROMANO
  21. void interface(); //FUNCION Q PRINTA EL MENSAJE DE BIENVENIDA Y LAS OPCIONES
  22. void Bienvenida(); //TAMBIEN ES LA Q SE ENCARGA DE RECOGER LA ENTRADA DEL USUARIO
  23.  
  24. /*********************************MAIN DEL PROGRAMA**************************************/
  25. int main()
  26. {
  27.     while (salgo != 2)// 0. MIENTRAS NO DECIDAN SALIR...
  28.     {              
  29.         Bienvenida();// LLAMA A LA FUNCION BIENBENIDA...
  30.         getche();
  31.         interface();//1. MUESTRA EL TEXTO EN PANTALLA Y ESPERA ENTRADA
  32.         salgo = revisaelnumero(entrada);//2. REVISA Q LA ENTRADA ESTE BIEN
  33.         if (salgo  == 0)
  34.         {
  35.             system("cls");
  36.             printf("n_______________________________________________________________nn");
  37.             printf("La entrada ha sido erronea! Vuelva a intentarlo!n");
  38.             printf("nRecuerde que la longitud maxima son 3 numeros y no ponga letras!!");
  39.             printf("n_______________________________________________________________nn");
  40.             getche();
  41.             main();
  42.         }
  43.         if (salgo  == 3)
  44.         {
  45.             system("cls");
  46.             printf("n_______________________________________________________________nn");
  47.             printf("La entrada ha sido erronea! Vuelva a intentarlo!n");
  48.             printf("nSolo el Numero 100 es soportado para 3 digitos!!");
  49.             printf("n_______________________________________________________________nn");
  50.             getche();
  51.             main();
  52.         }
  53.         if (salgo == 2)
  54.         {
  55.             printf("nAdios!!!n");//3.5 EL USUARIO HA DECIDIDO SALIR
  56.         }
  57.         else //4. SI LA ENTRADA ESTA BIEN LO TRADUCE AL IDIOMA SELECCIONADO
  58.         {  
  59.              if (strcmp(opcio,"1") == 0)
  60.             {
  61.                 system("cls");
  62.                 printf("n__________________________________________________________nn");                    
  63.                 printf("nSU NUMERO EN PALABRAS:n");
  64.                 printf("n__________________________________________________________nn");  
  65.                 traduce_a_Cas(entrada);
  66.             }
  67.             else
  68.             {
  69.                 system("cls");
  70.                 printf("n__________________________________________________________nn");                    
  71.                 printf("nSU NUMERO EN ROMANO:n");
  72.                 printf("n__________________________________________________________nn");  
  73.                                traduce_a_Rom(p);
  74.             }
  75.                 printf("nn");
  76.                 printf("%sn  ",salida);//5. MUESTRA LA SALIDA
  77.                 printf("nn");
  78.                 strcpy(salida,"");//6. VACIO LA SALIDA PARA NO CONCATENAR
  79.                 getche();
  80.         }
  81.     }
  82. }
  83. /*************************************FUNCIONES*******************************************/
  84. // FUNCION QUE "TRADUCE" EL NUMERO A EL CASTELLANO
  85. void traduce_a_Cas(char revisada[])
  86. {
  87.     char unidades[MAX][MAX]={"uno ","dos ","tres ","cuatro ","cinco ","seis ","siete ","ocho ","nueve "};
  88.     char decenas[MAX][MAX]={"diez ","veinte ","treinta ","cuarenta ","cincuenta ","sesenta ","setenta ","ochenta ","noventa "};
  89.     char centenas[MAX][MAX]={"ciento ","doscientos ","trescientos ","cuatrocientos ","quinientos ","seiscientos ","setecientos ","ochocientos ","novecientos "};
  90.     char decenasespeciales[MAX][MAX]={"diez ","once ","doce ","trece ","catorce ","quince ","dieciseis ","diecisiete ","dieciocho ","diecinueve "};
  91.     int numerito;
  92.     int numeritoposterior;
  93.     int i;
  94.     int bandera;
  95.     int posicionactual;
  96.     longitud = strlen(revisada);
  97.     for (i=longitud;i >= 1 ;i--)
  98.     {
  99.         bandera = longitud - i;
  100.         posicionactual = longitud - bandera;
  101.         switch(posicionactual)
  102.         {
  103.             case 1:case 4:case 7: //unidades
  104.                 actual[0] = revisada[bandera];actual[1] = '';
  105.                 numerito = atoi(actual);
  106.                     if (numerito != 1)
  107.                     {
  108.                         strcat(salida,unidades[numerito-1]);
  109.                     }
  110.                     else
  111.                     {
  112.                         if (longitud == 4 && posicionactual == 4)
  113.                         {
  114.                         }
  115.                         else if(longitud == 7 && posicionactual == 7)
  116.                         {
  117.                             strcat(salida,"un ");
  118.                         }
  119.                         else
  120.                         {
  121.                             strcat(salida,unidades[numerito-1]);
  122.                         }
  123.                     }
  124.             break;
  125.             case 2:case 5:case 8: //decenas
  126.                 actual[0] = revisada[bandera];actual[1] = '';
  127.                 numerito = atoi(actual);
  128.                 actualposterior[0] = revisada[bandera+1];actualposterior[1] = '';
  129.                 numeritoposterior = atoi(actualposterior);
  130.                     if (numerito == 1)
  131.                     {
  132.                         if (numeritoposterior != 0)
  133.                         {
  134.                             strcat(salida,decenasespeciales[numeritoposterior]);
  135.                             i--;
  136.                         }
  137.                         else
  138.                         {
  139.                             strcat(salida,decenas[numerito-1]);
  140.                         }
  141.                     }
  142.                     else
  143.                     {
  144.                         strcat(salida,decenas[numerito-1]);
  145.                         if (numeritoposterior !=0 && numerito != 0) strcat(salida,"y ");
  146.                     }
  147.             break;
  148.             case 3:case 6: //centenas
  149.                 actual[0] = revisada[bandera];actual[1] = '';
  150.                 numerito = atoi(actual);
  151.                 if (posicionactual == 6 && longitud > 6)
  152.                 {
  153.                     if (longitud == 7 && revisada[bandera-1] == '1')
  154.                     {
  155.                         strcat(salida,"millon ");
  156.                     }
  157.                     else
  158.                     {
  159.                         strcat(salida,"millones ");
  160.                     }
  161.                 }
  162.                 else
  163.                 if (posicionactual == 3 && longitud > 3)
  164.                 {
  165.                     if(revisada[bandera-1] =='0' && revisada[bandera-2] == '0' && revisada[bandera-3] == '0')
  166.                     {
  167.                     }
  168.                     else
  169.                     {
  170.                         strcat(salida,"mil ");
  171.                     }
  172.                 }
  173.                 if (numerito == 1 && revisada[bandera+1] == '0' && revisada[bandera+2] == '0')
  174.                 {
  175.                     strcat(salida,"cien ");
  176.                 }
  177.                 else
  178.                 {
  179.                     strcat(salida,centenas[numerito - 1]);
  180.                 }
  181.             break;
  182.         }//fin del switch
  183.     }//fin del for
  184. } //fin de funcion
  185.  
  186. /*******************************************/
  187. // FUNCION QUE "TRADUCE" EL NUMERO AL ROMANO
  188. void traduce_a_Rom(int x)
  189. {
  190.     while(x>=1000){x-=1000;printf("M");}
  191.     while(x>=900){x-=900;printf("CM");}
  192.     while(x>=500){x-=500;printf("D");}
  193.     while(x>=400){x-=400;printf("CD");}
  194.     while(x>=100){x-=100;printf("C");}
  195.     while(x>=90){x-=90;printf("XC");}
  196.     while(x>=50){x-=50;printf("L");}
  197.     while(x>=40){x-=40;printf("XL");}
  198.     while(x>=10){x-=10;printf("X");}
  199.     while(x>=9){x-=9;printf("IX");}
  200.     while(x>=5){x-=5;printf("V");}
  201.     while(x>=4){x-=4;printf("IV");}
  202.     while(x>=1){x-=1;printf("I");}
  203. } //fin de funcion
  204.  
  205. /***********************/
  206. // FUNCION DE BIENVENIDA  
  207. void Bienvenida()
  208. {
  209.     system("cls");
  210.     printf("n________________________________________________________________________________nn");
  211.     printf("BIENVENIDO SR USUARIOn");
  212.     printf("ESTA APLICACION LE PERMITE TRADUCIR NUMEROS A PALABRAS O NUMEROS ROMANOS.n");
  213.     printf("n________________________________________________________________________________nn");
  214.     printf("presione la tecla ENTERn");
  215. }
  216.              
  217. /******************/
  218. //FUNCION  OPCIONES
  219. void interface()
  220. {
  221.     system("cls");
  222.     printf("n__________________________________________________________nn");
  223.     printf("  Digite un numero entre 1 y 100 , luego presione ENTER.n");
  224.     printf("   Si desea salir pulse * y ENTER.n");
  225.     printf("n__________________________________________________________nn");
  226.     printf("nNumero : ");
  227.     scanf("%s",entrada);
  228.     p=atoi(entrada);
  229.     if (entrada[0] != '*')
  230.     {
  231.         system("cls");      
  232.         printf("n__________________________________________________________nn");
  233.         printf("nSELECCIONE UN TIPO DE TRADUCCION:n");
  234.         printf("n__________________________________________________________nn");
  235.         printf("nn");
  236.         printf("n[1] - TRADUCIR A PALABRAS.n");
  237.         printf("nn");
  238.         printf("n[2] - TRADUIR A NUMERO ROMANO.n");
  239.         printf("nn");
  240.         printf("nOpcion : ");
  241.         scanf("n%s",opcio);
  242.     }
  243. }
  244.  
  245. /*********************************************************************************/
  246. //FUNCION Q REVISA EL NUMERO EN BUSCA DE UNA LONGITUD INCORRECTA O CARACTERES ALFA
  247. int revisaelnumero(char a_revisar[])
  248. {
  249.     int decision = 1;
  250.     int largo;
  251.     int i;
  252.     largo = strlen(a_revisar);
  253.     aux=atoi(a_revisar);
  254.     if (aux>100)
  255.     {
  256.         decision = 3;
  257.     }
  258.        
  259.     if ((largo > 3) || (largo < 1)) //MIRO Q LA LONGITUD SEA CORRECTA
  260.     {
  261.         decision = 0;
  262.     }
  263.     else if(a_revisar[0] == '*')
  264.     {
  265.         decision = 2;
  266.     }
  267.     else
  268.     {
  269.         for(i=0;i<largo;i++)
  270.         {
  271.             if(isalpha(a_revisar[i]) != 0) //MIRO Q NO HAYA LETRAS INTRODUCIDAS
  272.             {
  273.                 decision = 0;
  274.             }
  275.         }
  276.     }
  277.     return decision;
  278. }
  279.  
  280.  
  281.  

11
C/C++ / FUNCIONES Y ARREGLOS???
« en: Lunes 24 de Agosto de 2009, 17:48 »
ESTIMADOS TENGO ESTE CODIGO QUE LA IDEA ES INGRESAR UN NUMERO Y ESTE PREGUNTE POR UN MENU SI LO QUIERO EN LETRAS O ROMANO, PERO AL INGRESAR LA FUNCION A ROMANO NO ME TOMA, PLIS AYUDA....

Código: C++
  1.  
  2. /****************************DECLARACIONES*********************************************/
  3. #include<stdio.h>
  4. #include<string.h>
  5. #include<stdlib.h>
  6. #include<ctype.h>
  7. #define MAX 100
  8.  
  9. int longitud;//LONGITUD DE LA CADENA ENTRADA
  10. int salgo;//BANDERA Q HACE ACABAR EL PROGRAMA SI EL USUARIO HA INSERTADO UNA MALA ENTRADA
  11. char entrada[MAX];//ENTRADA DEL USUARIO
  12. char salida[MAX];//SALIDA YA CONVERTIDA A LETRAS
  13. char actual[MAX];//VALOR DEL NUMERO ACTUAL
  14. char actualposterior[MAX];//VALOR DEL NUMERO POSTERIOR
  15. char revisada[MAX]; //LA ENTRADA UNA VEZ REVISADA PARA Q EL USUARIO NO ENTRE LETRAS
  16. char opcio[MAX]; //OPCION SELECCIONADA 1 CASTELLANO 2 ROMANO
  17.  
  18. int revisaelnumero(char a_revisar[]);//MIRA Q LA LONGITUD DEL TEXTO SEA MENOR DE 9 Y Q NO HAYAN LETRAS
  19. void traduce_a_Let(char revisada[]); //FUNCION Q "TRADUCE" AL CASTELLANO
  20. void traduce_a_Rom(char revisada[]); //FUNCION Q "TRADUCE" AL ROMANO
  21. void interface(); //FUNCION Q MUESTRA EL MENSAJE DE BIENVENIDA Y LAS OPCIONES
  22. void romanos(int); //FUNCION QUE VALIDA NUMERO ROMANO
  23.  
  24.  
  25.  
  26. /*********************************MAIN DEL PROGRAMA**************************************/
  27.  
  28. main()
  29. {
  30.  
  31.     while (salgo != 2){ // 0. MIENTRAS NO DECIDAN SALIR...
  32.  
  33.         interface();                        //1. MUESTRA EL TEXTO EN PANTALLA Y ESPERA ENTRADA
  34.  
  35.         salgo = revisaelnumero(entrada);    //2. REVISA Q LA ENTRADA ESTE BIEN
  36.  
  37.         if (salgo  == 0){                   //3. SI LA ENTRADA NO ESTA BIEN SE QUEJA
  38.             printf("INCORRECTO!! INTENTELO NUEVAMENTE!!!n");
  39.             printf("nLOMGITUD MAXIMA 3!!");
  40.             printf(" ");
  41.         }
  42.         else{
  43.         if (strcmp(opcio,"1") == 0){
  44.                 traduce_a_Let(entrada);
  45.             }
  46.         else{
  47.                 traduce_a_Rom(entrada);
  48.             }
  49.             printf("nSU NUMERO ES :n");
  50.             printf("%sn",salida);      //5. MUESTRA LA SALIDA
  51.             printf("---n");
  52.             strcpy(salida,"");              //6. VACIO LA SALIDA PARA NO CONCATENAR
  53.         }
  54.     }
  55. }
  56.  
  57.  
  58.  
  59.  
  60. /*************************************FUNCIONES*******************************************/
  61.  
  62. // FUNCION QUE "TRADUCE" EL NUMERO A LETRA
  63. void traduce_a_Let(char revisada[]){
  64.  
  65.     char unidades[MAX][MAX]={"UNO","DOS","TRES","CUATRO","CINCO","SEIS","SIETE","OCHO","NUEVE"};
  66.     char decenas[MAX][MAX]={"DIEZ","VEINTE","TRINTA","CUARENTA","CINCUENTA","SESENTA","SETENTA","OCHENTA","NOVENTA"};
  67.     char centenas[MAX][MAX]={"CIENTO"};
  68.     char decenasespeciales[MAX][MAX]={"DIEZ","ONCE","DOCE","TRECE","CATORCE","QUINCE","DIECISEIS","DIECISIETE","DIECIOCHO","DIECINUEVE"};
  69.  
  70.     int numerito;
  71.     int numeritoposterior;
  72.     int i;
  73.     int bandera;
  74.     int posicionactual;
  75.  
  76.     longitud = strlen(revisada);
  77.  
  78.     for (i=longitud;i >= 1 ;i--){
  79.         bandera = longitud - i;
  80.         posicionactual = longitud - bandera;
  81.  
  82.         switch(posicionactual){
  83.             case 1:case 4:case 7: //unidades
  84.  
  85.                 actual[0] = revisada[bandera];actual[1] = '';
  86.                 numerito = atoi(actual);
  87.                 if (numerito != 1){
  88.                     strcat(salida,unidades[numerito-1]);
  89.                 }
  90.                 else{
  91.                     if (longitud == 4 && posicionactual == 4){
  92.                     }
  93.                     else if(longitud == 7 && posicionactual == 7){
  94.                         strcat(salida," UN ");
  95.                     }else{
  96.                         strcat(salida,unidades[numerito-1]);
  97.                     }
  98.                 }
  99.                 break;
  100.  
  101.             case 2:case 5:case 8: //decenas
  102.  
  103.                 actual[0] = revisada[bandera];actual[1] = '';
  104.                 numerito = atoi(actual);
  105.                 actualposterior[0] = revisada[bandera+1];actualposterior[1] = '';
  106.                 numeritoposterior = atoi(actualposterior);
  107.                 if (numerito == 1){
  108.                     if (numeritoposterior != 0){
  109.                         strcat(salida,decenasespeciales[numeritoposterior]);
  110.                         i--;
  111.                     }else{
  112.                         strcat(salida,decenas[numerito-1]);
  113.                     }
  114.                 }
  115.                 else{
  116.                     strcat(salida,decenas[numerito-1]);
  117.                     if (numeritoposterior !=0 && numerito != 0) strcat(salida," Y ");
  118.                 }
  119.  
  120.                 break;
  121.  
  122.             case 3:case 6: //centenas
  123.  
  124.                 actual[0] = revisada[bandera];actual[1] = '';
  125.                 numerito = atoi(actual);
  126.                 if (numerito == 1 && revisada[bandera+1] == '0' && revisada[bandera+2] == '0'){
  127.                     strcat(salida,"CIEN");
  128.                 }else{
  129.                     strcat(salida,centenas[numerito - 1]);
  130.                 }
  131.                 break;
  132.  
  133.         }//fin del switch
  134.  
  135.     }//fin del for
  136.  
  137. } //fin de funcion
  138.  
  139.  
  140.  
  141. //FUNCION QUE "TRADUCE" EL NUMERO ROMANO
  142. void traduce_a_Rom(char revisada[])
  143. {
  144. /*
  145. void traduce_a_Rom(int);
  146.  
  147. {
  148.     int p;
  149.     do
  150.     {
  151.        printf("Inserte un numero: ");
  152.        scanf("%d",&p);
  153.        if(p<1)
  154.        printf("Deben ser mayores a ceron");
  155.        else
  156.        {
  157.             if(p<4000)
  158.             traduce_a_Rom(p);
  159.             else
  160.             {
  161.             if((p/1000)>3)
  162.                 printf("®"); traduce_a_Rom((p/1000)); printf("¯");
  163.                 traduce_a_Rom(p%1000);
  164.             }
  165.        }
  166.     }
  167.     while(p<1);
  168.     getchar();
  169.     getchar();
  170.     return 0;
  171. }
  172. void traduce_a_Rom(int x)
  173. {
  174.    while(x>=1000){x-=1000;printf("M");}
  175.    while(x>=900){x-=900;printf("CM");}
  176.    while(x>=500){x-=500;printf("D");}
  177.    while(x>=400){x-=400;printf("CD");}
  178.    while(x>=100){x-=100;printf("C");}
  179.    while(x>=90){x-=90;printf("XC");}
  180.    while(x>=50){x-=50;printf("L");}
  181.    while(x>=40){x-=40;printf("XL");}
  182.    while(x>=10){x-=10;printf("X");}
  183.    while(x>=9){x-=9;printf("IX");}
  184.    while(x>=5){x-=5;printf("V");}
  185.    while(x>=4){x-=4;printf("IV");}
  186.    while(x>=1){x-=1;printf("I");}
  187. }
  188. */
  189. } //fin de funcion
  190.  
  191.  
  192. //FUNCION QUE MUESTRA EL MENSAJE DE BIENVENIDA Y LAS OPCIONES
  193. void interface(){
  194.     printf("nEscriba un numero de 1 a 100 : n");
  195.     printf("* Para Salir.n");
  196.     scanf("%s",entrada);
  197.     if (entrada[0] != '*'){
  198.         printf("nSELECCIONE UNA OPCION:n");
  199.         printf("n1 - TRADUCIR AL LETRAS.n");
  200.         printf("n2 - TRADUIR A NUM. ROMANO.n");
  201.         scanf("n%s",opcio);
  202.     }
  203. }
  204.  
  205.  
  206. //FUNCION Q REVISA EL NUMERO EN BUSCA DE UNA LONGITUD INCORRECTA O CARACTERES ALFA
  207. int revisaelnumero(char a_revisar[]){
  208.     int decision = 1;
  209.     int largo;
  210.     int i;
  211.     largo = strlen(a_revisar);
  212.     if ((largo > 3) || (largo < 1)){ //MIRO Q LA LONGITUD SEA CORRECTA
  213.         decision = 0;
  214.     }
  215.     else if(a_revisar[0] == '*'){
  216.         decision = 2;
  217.     }
  218.     else{
  219.         for(i=0;i<largo;i++){
  220.             if(isalpha(a_revisar[i]) != 0){ //MIRO Q NO HAYA LETRAS INTRODUCIDAS
  221.                 decision = 0;
  222.             }
  223.         }
  224.     }
  225. return decision;
  226. }
  227.  
  228.  
  229.  
  230.  

ESTE ES EL QUE VALIDA A NUMERO ROMANO

Código: C++
  1.  
  2.  
  3. //FUNCION QUE "TRADUCE" EL NUMERO ROMANO
  4. //void traduce_a_Rom(int);
  5.  
  6. #include<stdio.h>
  7. void traduce_a_Rom(int);
  8. main()
  9. {
  10.     int p;
  11.     do
  12.     {
  13.        printf("Inserte un numero: ");
  14.        scanf("%d",&p);
  15.        if(p<1)
  16.        printf("Deben ser mayores a ceron");
  17.        else
  18.        {
  19.    if(p<4000)
  20.       traduce_a_Rom(p);
  21.    else
  22.    {
  23.       if((p/1000)>3)
  24.         printf("®"); traduce_a_Rom((p/1000)); printf("¯");
  25.         traduce_a_Rom(p%1000);
  26.    }
  27.        }
  28.     }while(p<1);
  29.     getchar();
  30.     getchar();
  31.     return 0;
  32. }
  33. void traduce_a_Rom(int x)
  34. {
  35.    while(x>=1000){x-=1000;printf("M");}
  36.    while(x>=900){x-=900;printf("CM");}
  37.    while(x>=500){x-=500;printf("D");}
  38.    while(x>=400){x-=400;printf("CD");}
  39.    while(x>=100){x-=100;printf("C");}
  40.    while(x>=90){x-=90;printf("XC");}
  41.    while(x>=50){x-=50;printf("L");}
  42.    while(x>=40){x-=40;printf("XL");}
  43.    while(x>=10){x-=10;printf("X");}
  44.    while(x>=9){x-=9;printf("IX");}
  45.    while(x>=5){x-=5;printf("V");}
  46.    while(x>=4){x-=4;printf("IV");}
  47.    while(x>=1){x-=1;printf("I");}
  48. }
  49.  

12
C/C++ / Re: Validar Un Valor Decimal
« en: Martes 18 de Agosto de 2009, 23:12 »
a ver probraremos con el float....
Muchas Gracias estimado....

13
C/C++ / Re: Validar Un Valor Decimal
« en: Martes 18 de Agosto de 2009, 22:28 »
SOLUCIONADO......
Código: C++
  1.  
  2.  
  3. # include <stdio.h>
  4. # include <conio.h>
  5. # include <string.h>
  6. # include <stdlib.h>
  7. char cadena[100];
  8. int estado=0;
  9. int i=0;
  10.  
  11. main ()
  12.  
  13. {
  14.     printf("INGRESE UN VALOR DECIMAL  :");
  15.     gets(cadena);
  16.     for
  17.  (i=0;((i<strlen(cadena))&&(estado!=3));i++)
  18.  {
  19.      if (estado==0)
  20.      {
  21.       if ((cadena[i]>=48)&&(cadena[i]<=57))
  22.    estado=1;
  23.  
  24.       else
  25.  
  26.          if (cadena[i]=='.')
  27.       estado=2;
  28.          else estado=4;
  29.      }
  30.  
  31.      else //else1
  32.  
  33.      {
  34.         if (estado==1)
  35.         {
  36.      if ((cadena[i] >=48)&&(cadena[i]<=57))
  37.    estado=1;
  38.  
  39.      else
  40.  
  41.          if (cadena[i]=='.')
  42.       estado=2;
  43.          else estado=5;
  44.         }
  45.  
  46.         else //else2
  47.  
  48.         {
  49.      if (estado==2)
  50.      {
  51.        if ((cadena[i] >=48)&&(cadena[i]<=57))
  52.      estado=3;
  53.        else estado=6;
  54.      }
  55.  
  56.      else //else3
  57.      {
  58.  
  59.         if (estado==3)
  60.         {
  61.    if ((cadena[i] >=48)&&(cadena[i]<=57))
  62.         estado=3;
  63.    else estado=7;
  64.         }
  65.  
  66.      }//else3
  67.   }//else2
  68.     }//else1
  69.  }// for
  70.      if (estado==1)
  71.   printf("EL NUMERO ES DECIMAL");
  72.      if (estado==2)
  73.   printf("EL NUMERO CONTIENE PUNTO");
  74.      if (estado==3)
  75.   printf("EL NUMERO DECIMAL ES CORRECTO");
  76.      if (estado==4)
  77.   printf("ERROR: DEBE EMPEZAR CON NUMERO O PUNTO");
  78.      if (estado==5)
  79.   printf("ERROR: SOLO SE ACEPTAN NUMEROS");
  80.      if (estado==6)
  81.   printf("DEBE INGRESAR PUNTO DECIMAL");
  82.      if (estado==7)
  83.   printf("SOLO SE HACEPTAN NUMEROS");
  84.  
  85.      getch();
  86. }
  87.  
  88.  
  89.  

14
C/C++ / Validar Un Valor Decimal
« en: Martes 18 de Agosto de 2009, 06:41 »
ENCUAENTRAN ALGUN ERROR EN ESTE CODIGO....
NO ME CORRE OK...

Código: C++
  1.  
  2. # include <stdio.h>
  3. # include <conio.h>
  4. # include <string.h>
  5. # include <stdlib.h>
  6. char cadena[100];
  7. int estado=0;
  8. int i=0;
  9. main ()
  10. {
  11.     printf("INGRESE UN VALOR DECIMAL  :");
  12.     gets(cadena);
  13.    
  14.     for
  15.         (i=0;((i<strlen(cadena))&&(estado!=3));i++)
  16.         {
  17.             if (estado==0)
  18.                 {
  19.                     if ((cadena[i]>=48)&&(cadena[i]<=57))
  20.                         estado=1;
  21.                     if (cadena[i]=='.')
  22.                         estado=2;
  23.                     else estado=4;
  24.                 }
  25.             else
  26.             if (estado==1)
  27.                 {
  28.                     if ((cadena[i] >=48)&&(cadena[i]<=57))
  29.                         estado=1;
  30.                     if (cadena[i]=='.')
  31.                         estado=2;
  32.                     else estado=5;
  33.                 }
  34.             else
  35.             if (estado==2)
  36.                 {
  37.                     if ((cadena[i] >=48)&&(cadena[i]<=57))
  38.                         estado=3;
  39.                     else estado=6;
  40.                 }
  41.             else  
  42.             if (estado==3)
  43.                 {
  44.                     if ((cadena[i] >=48)&&(cadena[i]<=57))
  45.                         estado=3;
  46.                     else estado=7;
  47.                 }
  48.         }
  49.             if (estado==1)
  50.                 printf("EL NUMERO ES DECIMAL");  
  51.         {
  52.             if (estado==2)
  53.                 printf("EL NUMERO CONTIENE PUNTO");  
  54.                 {
  55.                     if (estado==3)
  56.                         printf("EL NUMERO DECIMAL ES CORRECTO");
  57.                     {
  58.                         if (estado==4)
  59.                             printf("ERROR: DEBE EMPEZAR CON NUMERO O PUNTO");
  60.                         {
  61.                             if (estado==5)
  62.                                 printf("ERROR: SOLO SE ACEPTAN NUMEROS");
  63.                             {
  64.                                 if (estado==6)
  65.                                     printf("DEBE INGRESAR PUNTO DECIMAL");
  66.                                 {
  67.                                     if (estado==7)
  68.                                         printf("SOLO SE HACEPTAN NUMEROS");  
  69.                                 }
  70.                             }
  71.                         }
  72.                     }
  73.                 }
  74.             getch();   
  75.         }
  76. }
  77.  
  78.  

Páginas: [1]