Ayuda Con el siguiente ejercicio


14 de Marzo del 2016

Cordial saludo, les quiero pedir ayuda con el siguiente ejercicio de antemano gracias :

Elaborar un algoritmo que lea una lista de números enteros positivos y ejecute las
siguientes operaciones:
1. Mostrar los números de la lista en orden creciente.
2. Calcular e imprimir la mediana (valor central).
3. Determinar el número que ocurre más frecuentemente.
4. Imprimir una lista que contenga:
4.1. Números menores que 30.
4.2. Números mayores que 70.
4.3. Números que no pertenezcan ni al grupo 4.1 ni al 4.2.

 

Es en C++


Samuel Garcia
13 de Abril del 2016
Aquí tengo un programa para ordenar en orden ascendente y descendente:


Video del funcionamiento y compilación:
http://www.youtube.com/watch?v=682Dspo_PqQ


Video de cómo se escribió el código:
http://devel.archefire.org/snippets/C/es/Obtener%20N%c3%bameros%20en%20Orden%20Ascendente.html


Para compilar:
gcc num_ascendentes.c -o num_ascendentes.exe


Para correr:
num_ascendentes 5634 3267 -9 5674 244 51 3 87




#include <stdio.h> //printf()
#include <stdlib.h> //malloc(), free()


void int_obtener_min_max(int *arreglo_numeros, int numElems, int *min, int *idx_min, int *max, int *idx_max);
void int_ordenar_ascendente(int *arreglo_numeros, int numElems);


//Tomar los números directamente de la línea de comandos:
///
int main(int argc, char *argv[])
{
//Preparar un número dinámico de enteros:
///
int *numeros; // Arreglo de enteros de tamaño dinámico
int cuenta_numeros=0; // Cuántos números están presentes realmente
int x=0; // Variable general para bucles


//Descontamos el primer parámetro que es el nombre del
//programa mismo, de la cuente de parámetros (argc == "arg count"):
///
argc--;


//Indicar si hay suficientes parámetros:
///
if(argc<2)
{
printf("ERROR: Por favor ingrese números enteros separados por espacios.n");
printf(" Se necesitan por lo menos dos números.nn");
return -1;
}


//Reservar memoria para el número indicado de enteros
//por los parámetros de línea de comandos.
//
//Necesitamos obtener el tamaño de un entero en memoria
//y multiplicarlo por el número de argumentos.
//
//Siempre reservar un valor más para poder maniobrar siempre
//aunque sea entre 2 elementos. Lo correcto sería poner a cero
//el último elemento para que haya coherencia:
///
numeros = (int *)malloc(sizeof(int)*argc+1);
numeros[sizeof(int)*argc]=0;

//Recorremos cada uno de los valores separados por espacios.
//Los convertimos de cadena de caracteres a número y vemos
//si ya está en el arreglo:
///
for(x=0; x<argc; x++)
{
//Obtenemos el parámetro actual de la línea de comandos.
//Le sumamos 1 a x ya que anteriormente le restamos 1 y el
//parámetro 0 es el nombre del programa mismo, así que si
//si no hacemos esto perderíamos un número:
///
numeros[cuenta_numeros++]=atoi(argv[x+1]);
}


//Ordenamos el arreglo del menor al mayor:
///
int_ordenar_ascendente(numeros, cuenta_numeros);



//Ahora simplemente mostramos el arreglo en pantalla:
///
printf("Lista de números ordenados ascendentes: ");
for(x=0; x<cuenta_numeros; x++)
{
printf("%d ", numeros[x]);
}
printf("n");

printf("Lista de números ordenados descendentes: ");
for(x=cuenta_numeros-1; x>=0; x--)
{
printf("%d ", numeros[x]);
}
printf("n");





//Liberamos la memoria reservada para el arreglo numérico
//en tiempo de ejecución, ya que llegamos al final del programa:
///
free(numeros);


return 0;
}






void int_obtener_min_max(int *arreglo_numeros, int numElems, int *min, int *idx_min, int *max, int *idx_max)
{
int x=0;

//Tratar de poner el número máximo con el negativo más pequeño
//para intentar detectar cualquier máximo subsiguiente.
//Con este método pretendemos obtener el valor con sign más pequeño
//para este tipo de datos:
///
*max = ~(unsigned int)0; //Obtenemos máximo número de bits a 1
*max = (unsigned int)(*max<<1)>>1; //Deshacernos del bit de mayor peso
*max = (unsigned int)~*max; //Poner solo el bit de mayor peso a 1


//Para el mínimo, simplemente obtenemos el valor máximo de bits
//con signo, y nos deshacemos del bit de mayor peso (el del signo
//para tipos de datos que interpretan negativos y positivos).
//Con esto lo ponemos al valor positivo más grande de bits
//y así podemos detectar cualquier valor máximo subsiguiente:
///
*min = ~(unsigned int)0;
*min = (unsigned int)(*min<<1)>>1;


x=numElems;
while(x--)
{
if(arreglo_numeros[x]>*max)
{
*max=arreglo_numeros[x];
*idx_max=x;
}

if(arreglo_numeros[x]<*min)
{
*min=arreglo_numeros[x];
*idx_min=x;
}
}


return;
}






void int_ordenar_ascendente(int *arreglo_numeros, int numElems)
{
int x=0;
int cuenta_desordenados = numElems;

int minimo_actual = 0;
int indice_minimo = 0;
int maximo_actual = 0;
int indice_maximo = 0;

//Aquí recorreremos todos los elementos del arreglo,
//buscando el elemento máximo actual, sobreescribiéndolo
//y moviéndolo al final del arreglo mismo, para que tenga
//el efecto de ordenar de forma ascendente:
///
while(cuenta_desordenados--)
{
//Aquí obtendremos repetidamente el máximo actual entre los
//elementos del arreglo que todavía no hemos procesado.
//Obtendremos tanto su valor como su índice para recopiar el
//resto de elementos desordenados y mover el valor máximo
//actual al sobreescribilo estando este normalmente enmedio
//del arreglo.
//
//Usamos cuenta_desordenados+1 para poder usar la cuenta numérica
//basada en 1 a pesar de haber descontado ya ese elemento particular:
///
int_obtener_min_max(arreglo_numeros, cuenta_desordenados+1, &minimo_actual, &indice_minimo, &maximo_actual, &indice_maximo);

//Aquí sobreescribiremos el máximo actual, copiaremos desde ahí
//los valores de 1 posición adelante y pondremos el valor
//máximo actual al final de la posición indicada por x
//al terminar este bucle:
///
for(x=indice_maximo; x<cuenta_desordenados; x++)
{
arreglo_numeros[x]=arreglo_numeros[x+1];
}
arreglo_numeros[x]=maximo_actual;
}



return;
}