// Crea y devuelve un array de tamaño n = lsup-linf+1
// con los números enteros comprendidos entre los límites 
// linf y lsup, asignados al array de forma aleatoria entre los 
// índices 1 y n. El array contendrá finalmente una 
// permutación con los números enteros comprendidos entre
// dichos límites.
// Req: linf<=lsup
struct Array {int *v; int n;};

Array ArrayCreaAleatorio(int linf, int lsup;)
{
      Array a;
      a.n=lsup-linf+1;
      a.v=malloc(sizeof(Array)*a.n);
      for (int i=0; i<a.n;i++)
          a.v[i]=linf+i;
      for (int j=0;j<=a.n-2;j++)
      {
          int k=EnteroAleatorio(j+1,a.n-1);
          int aux=a.v[j];
          a.v[j]=a.v[k];
          a.v[k]=aux;
      }
      return a;       
}

int EnteroAleatorio(int linf, int lsup)
{
    return linf+rand()%(lsup-linf+1);
}

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


// Lee por teclado dos enteros linf y lsup, 
// tales que linf<=lsup.

void LimitesLee(int * linf, int * lsup)
{
     printf("Introduzca dos enteros para los límites inferior y superior: \n");
     scanf ("%d %d",linf,lsup);
     while (*linf>*lsup) 
     {
           printf("El limite inferior no puede ser mayor que el superior\n");
           printf("Por favor, vuelva a introducir los límites\n");
           scanf("%d %d",linf,lsup);
     }
}
// Imprime por pantalla los enteros linf y lsup con formato:
// Limites: [linf,lsup]
void LimitesImprime(int linf, int lsup)
{
     printf("Los límites inferior y superior son:[%d,%d]\n",linf,lsup);
}
// Genera y devuelve un entero aleatorio entre los límites 
// linf y lsup.
int EnteroAleatorio(int linf, int lsup)
{
    return linf+rand()%(lsup-linf+1);
}
// Imprime por pantalla un entero e con formato:
// Entero: e
void EnteroImprime(int e)
{
     printf("Entero: %d \n",e);
}



// Crea y devuelve un array de tamaño n = lsup-linf+1
// con los números enteros comprendidos entre los límites 
// linf y lsup, asignados al array de forma aleatoria entre los 
// índices 1 y n. El array contendrá finalmente una 
// permutación con los números enteros comprendidos entre
// dichos límites.
// Req: linf<=lsup
struct Array {int *v; int n;}

Array ArrayCreaAleatorio(int linf, int lsup)
{
      Array a;
      a.n=lsup-linf+1;
      a.v=malloc(sizeof(Array)*(a.n));
      for (int i=0; i<a.n;i++)
          a.v[i]=linf+i;
      for (int j=0;j<=a.n-2;j++)
      {
          int k=EnteroAleatorio(j+1,a.n-1);
          int aux=a.v[j];
          a.v[j]=a.v[k];
          a.v[k]=aux;
      }
      return a;       
}



int main()
{
    char nombre[10];
    int  edad;
    printf ("Hola mundo\n");
    printf ("Dime tu nombre: ");
    scanf  ("%s",nombre);
    printf ("Dime tu edad: ");
    scanf  ("%d",&edad);
    while(edad<0)
              {
              printf("Edad erronea, introduce edad: ");
              scanf("%d",&edad);
              }
    printf ("Hola %s tienes %d tacos\n",nombre,edad);
    
    int linf=0;
    int lsup=0;
    int ernd=0;
    int opcion=0;
    Array a=ArrayCreaAleatorio(linf,lsup);
    while (opcion!=7)
    {
          printf("1. Imprimir en pantalla los límites actuales.\n");
          printf("2. Imprimir en pantalla el entero aleatorio actual.\n");
          printf("3. Imprimir en pantalla el array actual.\n");
          printf("4. Leer desde teclado nuevos límites.\n");
          printf("5. Generar un nuevo entero aleatorio dentro de los límites actuales.\n");
          printf("6. Generar un nuevo array aleatorio dentro de los limites actuales.\n");
          printf("7. Salir.\n");
          printf("Introducir opción (1-5):\n");
          scanf("%d",&opcion);
          switch(opcion)
          {
              case 1:LimitesImprime(linf,lsup);break;
              case 2:EnteroImprime(ernd);break;
              case 3:break;
              case 4:LimitesLee(&linf,&lsup);
                     LimitesImprime(linf,lsup);break;
              case 5:ernd=EnteroAleatorio(linf,lsup);
                     EnteroImprime(ernd);break;
              case 6:break;
              case 7:break;
              default: printf("Error, la opción ha de estar comprendida entre 1-5\n");
          }
                      
                        
    }
        system("pause");
    return 0;
}