Mensajes

Jajaja! Pues si que lo tenia bien descifrado y la respuesta era la que pensaba, pero no se porque, ayer no me la aceptaba y hoy si.

Es posible que sea por algun porblema que tengo con la conexion, pero por si acaso doy el aviso. Introduciendo la resppuesta correcta, la respuesta que recibi ayer fue: Muahahaha! (o algo asi)

Saludos!

Hola a todos!

La respuesta a criptografia-basico es el mensaje descifrado, o algo que tiene que ver con numero o palabra descrito en el mensaje descifrado?

¿O lo he descifrado mal?

Estoy desorientado, no pido la resolucion, solo saber si voy por buen camino...

Saludos!

En este momento lo tengo en 28 (de la 0 hasta la 27) lineas, y creo que puedo rebajar una mas de momento, pero me estoy volviendo loco con los saltos  ,

Despues de cuadrarlo en 27 lineas a ver si puedo seguir haciendo pinitos con el code.

Por cierto, podiais poner una instruccion mul [registro] [registro] asi si que me cuadraria todo.

Jajajaja.

Un saludo y un ejercicio magnifico. Felicidades al que lo haya ideado.

PD: Este es mi mensaje 101... Por el culo te la h**co... Jajajajaja!

Buenas, tengo un pseudocodigo que traducido al codigo ensamblador de la maquina virtual me da resultado que se quiere, pero como no tenia ni idea de ASM, usando el sentido comun me sale un codigo de mas de 25 lineas de codigo.

No pongo aqqui el code, porque seria ponoer "la solucion" para todo el mundo. Solo queria preguntar si hay algunas pautas basicas que se puedan seguir para compactar el codigo.

Si hace falta enviaros el codigo a algun sitio oficial para tratar estos temas, me lo decis y lo envio, (se que he visto por ahi alguna direccion de correo electronico...)

¡¡¡¡Saludos!!!!

[el-pollo]

el-pollo, no sea malo con los nuevos, que luego dejan el maravilloso mundo de la programacion por lad facilidades de conseguir porno que hay en internet...

La 1 es obviamente C.

Un saludo!

Ok. Pues, de momento asi lo dejo. Ahora me queda algun detalle sobre la presentacion (alineacion delos textos) y pulir los flags, que los puse a ultima hora.

Hasta luego!

Bueno, creo que mas o menos ya esta. Si hay alguna idea, bienvenida sea.

Hasta luego!

EI: juntando mensajes.

¡Hola a todos!

Despues de la ultima modificacion, la funcion mostrarMenu, producia un error en tiempo de ejecucion, devido a un error que cometi. Ya esta corregido, y el codigo es funcional.

¡Hasta luego!

[system]

bueno, ya estan los cambios, he incluido un header y un fichero fuente mas, porque ahi esta la funcion que evita el fflush(stdin) antes de la lectura de un dato entero. (a parte creo que tambien hay funciones que pueden resultar utiles...) Tambien he eliminado las llamadas a system, ahora no queda tan bonito, pero esportable.

EI, si quieres completar el codigo con la compilacion condicional... yo desconozco las ordenes equivalentes en otros systemas operativos, asi que sirectamente evito utilizarlas, y tampoco he utilizado la compilacion condicional mas que para comprobar errores con printf's para ver los valores de las variables.

Asi contribuimos a mejorar el codigo un poco entre todos.

¡Hasta luego!

He eliminado los dos ficheros añadidos. (por una sola funcion era meter demasiado codigo que no venia a cuento)

Ultima modificacion:

Código (c) [Seleccionar] Expandir


#ifdef WINDOWS
  system("CLS");
#elif defined UNIX
  system("clear");
#endif


¿Es correcto?

Para los mac's y otros sistemas operativos no conozco analogos, pero sigo buscando.

Jajajaja!

Lo de la portabilidad ya lo estaba pensando, al codigo ya tiene algunos mesecillos y ultimamente he estado pensando en la portabilidad.

Lo de system("PAUSE"), tiene facil solucion, para lo del fflush(stdin) ya tengo una alternativa y una solucion, pero lo de limpiar la pantalla... me parece que no hay ningun equivalente estandar para limpiarla, ¿no?

Le hecho un vistazo y a ver que sale.

¡Hasta luego!

MODIFICADO

Añadido:
----------
- portabilidad
- texto centrado


Ya se que todo el codigo que viene a continuacion es una morcilla de las de Burgos, pero si mirais el ejemplo que hay al final, vereis como se simplifica todo a la hora de utilizar los menus.

Menu.h

Código (c) [Seleccionar] Expandir



/*

IMPORTANTE: Cuando el menu ya no sea util, ultilizar siempre la funcion finalizarMenu

*/

#ifndef MENU_H
#define MENU_H

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

/*
* Para compilar en UNIX desactivar la definicion de WINDOWS y activar la de UNIX
* Para otros SO desactivar ambas.
*/

#ifndef WINDOWS
   #define WINDOWS
#endif
/*
#ifndef UNIX
   #define UNIX
#endif
*/

#define MENU_OK                   0L
#define MENU_ERROR                1L
#define MENU_MEMORIA_INSUFICIENTE 2L

#define MENU_MODO_NORMAL      0L
#define MENU_MODO_ULTIMA_CERO 1L

struct Menu
{
   char*         titulo;
   char*         texto;
   char**        opciones;
   int           numOpciones; /* numero de opciones */
   int           maxlen;
   unsigned long lFlags;
};
typedef struct Menu Menu;

void inicializarMenu(Menu* menu,char* titulo, char* texto, char* opciones[]);
int mostrarMenu(Menu* menu,int modo);
void finalizarMenu(Menu* menu);

#endif /* MENU_H */


menu.c

Código (c) [Seleccionar] Expandir


#include "menu.h"

void inicializarMenu(Menu* menu, char* titulo, char* texto, char* opciones[])
{
  menu->lFlags = MENU_OK;

  if(titulo == NULL)
     menu->titulo = NULL;
  else
  {
      if((menu->titulo = (char*) malloc(strlen(titulo) * sizeof(char) + 1)))
          strcpy(menu->titulo,titulo);
     else
     {
        menu->lFlags |= MENU_ERROR | MENU_MEMORIA_INSUFICIENTE;
        menu->texto = NULL;
     }
  }

  if(texto == NULL)
     menu->texto = NULL;
  else
  {
     if((menu->texto = (char*) malloc(strlen(texto) * sizeof(char) + 1)))
        strcpy(menu->texto,texto);
     else
     {
        menu->lFlags |= MENU_ERROR | MENU_MEMORIA_INSUFICIENTE;
        menu->texto = NULL;

         if(menu->titulo)
         {
            free(menu->titulo);
            menu->titulo = NULL;
         }
     }
  }

  if(opciones == NULL)
     menu->opciones = NULL;
  else
  {
     menu->numOpciones = -1;

     while(opciones[ ++(menu->numOpciones) ][0]);

     if((menu->opciones = (char**) malloc(menu->numOpciones * sizeof(char*))))
     {
        int i=0;

        menu->maxlen = 0;

        for(i=0 ; i < menu->numOpciones ; i++)
        {
           if
           (
              (menu->opciones[i] =
              (char*) malloc(strlen(opciones[i]) * sizeof(char) + 1))
           )
           {
              strcpy(menu->opciones[i],opciones[i]);

              if(strlen(menu->opciones[i]) > menu->maxlen)
                 menu->maxlen = strlen(menu->opciones[i]);
           }
           else
           {
              int j;

              for(j=0 ; j<i ; j++)
                 free(menu->opciones[j]);

              free(menu->opciones);

              menu->opciones = NULL;
              menu->numOpciones = 0;

              if(menu->texto)
              {
                 free(menu->texto);
                 menu->texto = NULL;
              }

              if(menu->titulo)
              {
                 free(menu->titulo);
                 menu->titulo = NULL;
              }

              menu->lFlags |= MENU_ERROR | MENU_MEMORIA_INSUFICIENTE;
           }
        }
     }
     else
     {
        menu->lFlags |= MENU_ERROR | MENU_MEMORIA_INSUFICIENTE;
        menu->opciones = NULL;

        if(menu->texto)
        {
           free(menu->texto);
           menu->texto = NULL;
        }

        if(menu->titulo)
        {
           free(menu->titulo);
           menu->titulo = NULL;
        }
     }
  }
}

int mostrarMenu(Menu* menu,int modo)
{
  int i=0, opcion=0;

  if(menu->numOpciones)
  {
      do{

         #ifdef WINDOWS
            system("CLS");
         #elif defined UNIX
            system("clear");
         #endif

         if(menu->titulo)
         {
            for(i=0 ; i<80 ; i++)
                printf("=");

            printf("%*s\n", 40 + strlen(menu->titulo) / 2, , menu->titulo);

            for(i=0 ; i<80 ; i++)
                printf("=");
         }

         if(menu->texto)
             printf("%-*s%s\n\n",40 - menu->maxlen / 2 - 8, " ", menu->texto);
             
         for(i=0 ; i < menu->numOpciones ; i++)
         {
            if(modo == MENU_MODO_ULTIMA_CERO && i == menu->numOpciones - 1)
            {
               if(menu->numOpciones > 10)
                  printf("%*s 0. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", 40 + menu->maxlen / 2,
                                           menu->opciones[i]);
               else
                  printf("%*s0. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", 40 + menu->maxlen / 2,
                                          menu->opciones[i]);
            }
            else
            {
               if(modo != MENU_MODO_ULTIMA_CERO)
               {
                  if(menu->numOpciones >= 10)
                  {
                     printf("%*s%2d. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", i+1,
                                               40 + menu->maxlen / 2, menu->opciones[i]);
                  }
                  else
                  {
                     printf("%*s%d. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", i+1,
                                              40 + menu->maxlen / 2, menu->opciones[i]);
                  }
               }
               else
               {
                  if(menu->numOpciones > 10)
                  {
                     printf("%*s%2d. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", i+1,
                                               40 + menu->maxlen / 2, menu->opciones[i]);
                  }
                  else
                  {
                     printf("%*s%d. %-*s\n", 40 - menu->maxlen / 2 - 4, " ", i+1,
                                              40 + menu->maxlen / 2, menu->opciones[i]);
                  }
               }
            }
         }
         printf("%-*s>", 40 - menu->maxlen / 2 - 8, " ");

        if(!scanf("%d", &opcion))
        {
           while(getchar() != '\n');
           scanf("%d", &opcion);
        }        

      }while
      (
         (
            (modo != MENU_MODO_ULTIMA_CERO) ? (opcion < 1) : (opcion < 0)
         )
         ||
         (
            (modo != MENU_MODO_ULTIMA_CERO) ?
               (opcion >  menu->numOpciones)
               :
               (opcion >= menu->numOpciones)
         )
      );

      return opcion;
  }
 
  return -1;
}

void finalizarMenu(Menu* menu)
{
  if(menu->texto)
  {
     free(menu->texto);
     menu->texto = NULL;
  }

  if(menu->opciones)
  {
      int i=0;

      for(i=0 ; i < menu->numOpciones ; i++)
      {
          if(menu->opciones[i])
          {
              free(menu->opciones[i]);
              menu->opciones[i] = NULL;
          }
      }
      free(menu->opciones);
      menu->opciones = NULL;
  }

  menu->numOpciones = 0;
}


ejemplo: (tener en cuenta que menu.h y menu.c tienen que estar en el mismo directorio donde este el fichero con la funcion principal)

Código (c) [Seleccionar] Expandir


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

#include "menu.h"
#include "menu.c" /* solo si no se va crear un proyecto*/

int main(int argc, char *argv[])
{
   Menu menu;
   char *opciones[] = {"Continuar","Salir",""}; /* la ultima opcion siempre es una cadena vacia*/
   int opcion;

   inicializarMenu(&menu,"MENU DE PRUEBA","Escoger una opcion:",opciones);

   do{
       opcion=mostrarMenu(&menu,MENU_MODO_ULTIMA_CERO);
       
       switch(opcion)
       {
           case 1:
               printf("Has escogido continuar.\n");
               break;
           case 0:
               printf("Has escogido salir.\n");
               break;
       }
   }while(opcion!=0);

   /* ¡¡¡¡¡IMPORTANTE!!!!! */
   finalizarMenu(&menu);

   return 0;
}


En lo que es el menu, me gustaria completar alguna opcion mas, pero el codigo ya es funcional.

Si el codigo no funciona, avisad, ya que es una adaptacion del codigo que realmente tengo guardado. Lo he puesto asi para evitar incluir mas headers y mas codigo.

El codigo de ejemplo lo he imprivosado sobre la marcha. Si hubiese algun error revisad el codigo, que no creo que haya darle muchas vueltas.

Hola.

Si tienes que a = x mod(n) tendras que a^k = x^k mod(n), ya que el conjunto de valores mod(n) de los enteros forma un anillo.

Ahora si tienes a^k donde k=p^m, tendras que:

si x^k = y mod(n) -> a^k = x^k mod(n) = x^(p^m) mod(n) = (x^p)^m mod(n)

Ahora obtendras que x^p = y mod(n), por lo tanto: x^k = y^m mod(n), y solo tendras que calcular y^m mod(n) = z

resumiendo:

a^(p^m) -> los datos son a,p y m.

calculas x = a mod(n) (Asi reduces la base)
calculas x^p (como la base esta reducida, tardara menos (supongo))
calculas y = x^p mod(n) (Vuelves a reducir la base)
calculas z = y^m mod(n)

y z es el resultado que buscabas.

Espero que esto te simplifique las cosas.

Hasta luego!