PDA

Visualizza la versione completa : [C] Ordinare 20 numeri in ordine crescente


21Edoardo96
17-10-2012, 21:19
Ciao,
devo fare un programma che dati in ingrsso 20 numeri li ordini in modo crescnte, solo che mi da problemi con lo switch in quanto non sapevo come indicar il maggiore nella switch. Inoltre sono convinto che si possa ottenere lo stesso risultato scrivendo molte meno righe di cdice però non so cosa fare per renderlo più corto


//Ordinare numeri in ordine crescente
#include <stdio.h>
int main()
{
int cnt;
float a=0, b=0, c=0, d=0, e=0, f=0, g=0, h=0, i=0, l=0, m=0, n=0, o=0, p=0, q=0, r=0, s=0, t=0, u=0, v=0, num[20]; //I numeri devno essere 20
for(cnt=0;cnt<20;cnt++)
{
printf("\nInsersci il %d %c numero: ", cnt+1, 167);
scanf("%s", &num[cnt]);
if(cnt=0)
v=num[cnt];
else
{
switch (num[cnt])
{
case >v:
v=num[cnt];
break;
case >u:
u=num[cnt];
break;
case >t:
t=num[cnt];
break;
case >s:
s=num[cnt];
break;
case >r:
r=num[cnt];
break;
case >q:
q=num[cnt];
break;
case >p:
p=num[cnt];
break;
case >o:
o=num[cnt];
break;
case >n:
n=num[cnt];
break;
case >m:
m=num[cnt];
break;
case >l:
l=num[cnt];
break;
case >i:
i=num[cnt];
case >h:
h=num[cnt];
break;
case >g:
g=num[cnt];
break;
case >f:
f=num[cnt];
break;
case >e:
e=num[cnt];
break;
case >d:
d=num[cnt];
break;
case >c:
c=num[cnt];
break;
case >b:
b=num[cnt];
break;
default:
a=num[cnt];
}
}
("\nIl 1%c numero e\': %d ", cnt+1, a);
("\nIl 2%c numero e\': %d ", cnt+1, b);
("\nIl 3%c numero e\': %d ", cnt+1, c);
("\nIl 4%c numero e\': %d ", cnt+1, d);
("\nIl 5%c numero e\': %d ", cnt+1, e);
("\nIl 6%c numero e\': %d ", cnt+1, f);
("\nIl 7%c numero e\': %d ", cnt+1, g);/
("\nIl 8%c numero e\': %d ", cnt+1, h);
("\nIl 9%c numero e\': %d ", cnt+1, i);
("\nIl 10%c numero e\': %d ", cnt+1, l);
("\nIl 11%c numero e\': %d ", cnt+1, m);
("\nIl 12%c numero e\': %d ", cnt+1, n);
("\nIl 13%c numero e\': %d ", cnt+1, o);
("\nIl 14%c numero e\': %d ", cnt+1, p);
("\nIl 15%c numero e\': %d ", cnt+1, q);
("\nIl 16%c numero e\': %d ", cnt+1, r);
("\nIl 17%c numero e\': %d ", cnt+1, s);
("\nIl 18%c numero e\': %d ", cnt+1, t);
("\nIl 19%c numero e\': %d ", cnt+1, u);
("\nIl 20%c numero e\': %d ", cnt+1, v);
printf("\n");
system("pause");
return 0;

}

MItaly
17-10-2012, 21:47
Mai sentito parlare di "algoritmi di ordinamento"? :stordita: Studiati, ad esempio, il bubble sort (http://it.wikipedia.org/wiki/Bubble_sort) (poco efficiente ma semplice da capire e implementare) e prova ad implementarlo in C; se hai problemi, posta pure. :)

torn24
18-10-2012, 08:19
Trova un codice e cerca di capirlo , poi per capire come funziona l'algoritmo guarda questo video , molto divertente , che ti chiarisce il funzionamento :D

Non riesco a farlo funzionare con i tag html , copialo e incollalo ! :bhò:

http://www.youtube.com/watch?feature=player_embedded&v=lyZQPjUT5B4#!

21Edoardo96
18-10-2012, 14:51
Ciao,
l'ho finito e funziona, grazie a tutti.


//Ordinamento numeri
#include <stdio.h>
int main()
{
float array[100], swap=0, num;
int n=0, c=0, d=0;
printf("Inserisci il numero degli elementi:\n");
scanf("%d", &n);
if(n==0)
printf("Nessun numero da ordinare");
else
{
printf("Inserisci %d numeri:\n", n);
for (c = 0; c < n; c++)
scanf("%f", &array[c]);

// Viene seguito il Bubble sort o bubblesort (letteralmente: ordinamento a bolle) è un semplice algoritmo di ordinamento dei dati.
// Il suo funzionamento è il seguente: ogni coppia di elementi adiacenti della lista viene comparata e se essi sono nell'ordine sbagliato vengono invertiti.
//L'algoritmo scorre poi tutta la lista finché non vengono più eseguiti scambi, situazione che indica che la lista è ordinata.
//Come tutti gli algoritmi di ordinamento, può essere usato per ordinare dati di un qualsiasi tipo su cui sia definita una relazione d'ordine.

for (c = 0 ; c < ( n - 1 ); c++)
{
for (d = 0 ; d < n - c - 1; d++)
{
if (array[d] > array[d+1]) // Per fare l'ordine decrescente basta cambiare il segno da > a <
{
swap = array[d];
array[d] = array[d+1];
array[d+1] = swap;
}
}
}
printf("Lista dei numeri in ordine crescente:\n");
for ( c = 0 ; c < n ; c++ )
printf("%4.2f\n", array[c]);
}
printf("\n");
system("pause");
return 0;
}

C-hild
18-10-2012, 15:59
Non ho dubbi che funzioni... ma mi chiedevo se hai veramente compreso quello che hai postato
Nel post chiedevi di ordinare "20 numeri" e in ordine "crescente".
Hai postato invece un codice in cui compare un vettore di dimensione 100 e inoltre prevedi sia l'ordinamento crescente che decrescente. :confused:
NON ti scrivo questo per criticarti ma, mi sembra di capire che la tua richiesta sia un quesito scolastico, perciò ti invito a comprendere meglio quello che "incolli"...
hai ad esempio compreso perchè abbiamo usato la variabile "swap" e perchè non potevi fare ad esempio:

array[d+1]=array[d]
array[d] = array[d+1];
o perchè hai usato 2 cicli "innestati" ? :old:
Sono domande banali ma per un principiante sono cose fondamentali da comprendere per poter affrontare situazioni future.
:ciauz:

Loading