C# algoritmo Numero M-Alternante plantear pseudocódigo y código

[edme2000]

Buenos días compañeros,

Tengo un problema el quiero solicitar su valiosa ayuda.  (solo busco un tip, idea que me pueda ayudar a resolver el problema)

El problema es el siguiente:

Un número entero positivo se dice M-alternante si : El primer dígito es par entonces los 2 dígitos siguientes deben ser impares, luego los tres siguientes dígitos deben ser pares y así sucesivamente.

Por ejemplo: 122357 es un número M-alternante de orden 3
Lo que no encuentro como hacer es para ir comparando si el primero es par, y luego los siguientes 2 de la cadena sean impares y luego los siguientes 3 de la cadena sean impares.

Lo que se me esta complicando es el procedimiento que vaya alternando 1 primero par, luego los siguientes 2 impares, luego los siguientes 3 pares, luego siguientes 4 impares, asi sucesivamente.

1 par
siguientes 2 posiciones impares
siguientes 3 posiciones pares
siguientes 4 posiciones impares
siguientes 5 posiciones pares
asi sucesivamente para Numeros de N posiciones.

Les agradezco mucho cualquier tip que me puedan dar,

[javi in the sky]

¿Lo estás haciendo sobre un lenguaje concreto o como planteamiento de algoritmia, digamos como pseudocódigo?

[edme2000]

Lo estoy haciendo en C#,

pero acepto ideas en pseudo codigo, algoritmo o algún otro lenguaje. 
Básicamente necesito poder entender la logica para poder programarlo.

De antemano gracias por tu ayuda,

Saludos,

[javi in the sky]

No es fácil de plantear y supongo que hay varias maneras de hacerlo. Aquí te dejo lo que he pensado como pseudocódigo:


fun dimeSiEsMAlternante (numero) {

   profundidadDeBusqueda = 2;

   cumpliendo = true;   


   Si EsPar (extraerDigito (1, numero)) Entonces comprobandoActualmente = Impar
   Si EsImpar (extraerDigito (1, numero)) Entonces comprobandoActualmente = Par


   contador = 1;

      mientras contador <= (CantidadDeDigitos(numero) - ProfundidadDeBusqueda)
         

   
         Desde j = 1 hasta profundidadDeBusqueda

         Si cumpliendo == true

            Si Comprobar(extraerDigito (contador+j, numero), comprobandoActualmente) == true

               cumpliendo = true;

            Sino
               cumpliendo = false;

            FinSi

         FinSi

         FinDesde
               
         contador = contador + profundidadDeBusqueda;

         profundidadDeBusqueda = profundidadDeBusqueda +1;

         comprobandoActualmente = opuestoDe(comprobandoActualmente)


      finMientras


Si cumpliendo == true Entonces Mostrar "El número es m-alternante" Sino Mostrar "El número no es m-alternante".


}



Supongamos que entramos con el número: 122357

La comprobación inicial devuelve que el primer dígito es impar, por lo que comprobandoActualmente = Par

Entramos en el bucle mientras con contador =1 , cantidadDeDigitos(numero) = 6

Entramos en bucle desde j =1 hasta 2

   extraemos el dígito contador+j = 2 y comprobamos que es par por lo que cumpliendo = true

   extraemos el dígito contador + j = 3 y comprobamos que es par lo que cumpliendo = true

Salidmos del bucle desde

contador ahora vale 1+2 = 3

profundidadDeBusqueda ahora vale 3

comprobandoActualmente ahora vale Impar

Entramos en bucle mientras con contador =3, cantidadDeDigitos(numero) = 6, profundidadDeBusqueda = 3

Entramos en bucle desde j = 1 hasta 3
   
Extraemos el dígito contador+1 = 4 y comprobamos si es impar, efectivamente lo es y cumpliendo = true

Extraemos el dígito contador + 2 = 5 y comprobamos si es impar, efectivamente lo es y cumpliendo = true

Extraemos el dígito contador + 3 = 6 y comprobamos si es impar, efectivamente lo es y cumpliendo = true

Salimos del bucle desde

Ahora contador = 3 + 3 = 6
Ahora profundidadDeBusqueda = 4
Ahora comprobandoActualmente vale Par

En el bucle mientras contador vale 6, cantidadDeDigitos(numero) = 6, profundidadDeBusqueda = 4

No se cumple la condición y salimos del bucle

Se muestra "El número es m-alternante"

[edme2000]

Gracias por tu ayuda,
Lo hare en base a tu sugerencia y te comento el resultado,

nuevamente muchas gracias,

[javi in the sky]

Hola, dijiste que ibas a comentar el resultado... ¿cuál fue el resultado?

[edme2000]

Perdón,  se me pasó por alto publicar la solución,  les estoy muy agradecido por su ayuda.

Este problema lo solucioné de esta manera:

Código: [Seleccionar]

using System;

public class Clase_Alternante
{
    private String a;

    public String A
    {
        get { return a; }
        set { a = value; }
    }

    public int AlternantePar()
    {
        int fooInt;
        int fooVerificador;
        int i;
        int j;
        int cont;

        i = 0;
        j = 0;
        fooInt = 0;
        fooVerificador = 0;
        cont = 0;

        for (i = 0; i < a.Length; i = i + cont) 
        {
            for (j = i; j <= i + cont; j++)
            {
               
                    fooInt = Convert.ToInt32(Convert.ToString(a[j])); 

                    if (((cont % 2) == 1) && ((fooInt % 2) == 1))
                    {
                        fooVerificador = fooVerificador + 1;
                    }

                    else
                        if (((cont % 2) == 0) && ((fooInt % 2) == 0))
                        {
                            fooVerificador = fooVerificador + 1;
                        }

            }
           
            cont = cont + 1;
        }

        if (fooVerificador == a.Length) Console.WriteLine("El Número {0} Si es M-ALTERNANTE ", a);
        else Console.WriteLine("El Número {0} NO es M-ALTERNANTE", a);

            return 0;
    }


    //----------------------------------------------------------------------

    public int AlternanteImpar()
    {
        int fooInt;
        int fooVerificador;
        int i;
        int j;
        int cont;

        i = 0;
        j = 0;
        fooInt = 0;
        fooVerificador = 0;
        cont = 0;

        for (i = 0; i < a.Length; i = i + cont)
        {
            for (j = i; j <= i + cont; j++)
            {
                fooInt = Convert.ToInt32(Convert.ToString(a[j]));

                if (((cont % 2) == 1) && ((fooInt % 2) == 0))
                {
                    fooVerificador = fooVerificador + 1;
                }

                else
                    if (((cont % 2) == 0) && ((fooInt % 2) == 1))
                    {
                        fooVerificador = fooVerificador + 1;
                    }

            }

            cont = cont + 1;
        }

        if (fooVerificador == a.Length) Console.WriteLine("El Número {0} Si es M-ALTERNANTE ", a);
        else Console.WriteLine("El Número {0} NO es M-ALTERNANTE", a);

        return 0;
    }


}

=========================================

Código: [Seleccionar]

using System;

public class Clase_Control
{
    public void Control()
    {
        Clase_Alternante Numero;
        Numero = new Clase_Alternante();

        char op;

        do
        {
            Console.Clear();
            Console.WriteLine("Ingrese un Número");
            Numero.A = Console.ReadLine();

            if ((Numero.A[0] % 2) == 0)  // debe iniciar en par
            {
                Numero.AlternantePar();
            }
            else
            {
                Numero.AlternanteImpar();
            }

            Console.WriteLine();
            Console.WriteLine();
            Console.WriteLine("Desea ingresar otro Número S/N");
            op = Convert.ToChar(Console.ReadLine());

        } while (char.ToUpper(op) == 'S');
       
    }
}

===========================================

Código: [Seleccionar]


using System;

public class Alternante_Main
{
    public static void Main(string[] args)
    {
        Clase_Control Principal;    // Numero debe iniciar con par
        Principal = new Clase_Control();
        Principal.Control();
    }
}

Les estoy muy agradecido por su ayuda,

Saludos,

[javi in the sky]

Creí que habías desaparecido!!! Muchas gracias por compartir la solución, esto le podrá servir a más compañeros en el foro Gracias!!!

[edme2000]

No no,  muchas gracias a ustedes por el apoyo,

Saludos,