how to sort numbers alphabetically? [closed] - c

Question

Closed. This question needs details or clarity. It is not currently accepting answers.
Want to improve this question? Add details and clarify the problem by editing this post.
Closed 6 years ago.
Improve this question
I'm trying to write a program that sorts numbers alphabetically in C.
Example Input:
2 35 6 8 4
Example Output:
8 4 6 35 2
Digits should be sorted corresponding to the words representing them, like:
1-one
2-two
3-three
4-four
5-five
6-six
7-seven
8-eight
9-nine
I'm able to sort single digits using switch cases. What is the best way to sort two or more digits?

Answer 1

One way, not most efficient would be: (Will give you just hints to solve the problem and not complete solution)
Use sprintf to convert numbers to string and store in an array of string. If you want to convert numbers to spelling, use this excellent tutorial. (pops on top of the google search)
Sort the string using qsort with below comparision function. Use a struct with number tagged with string if you want the number back.
Comparision function
static int
cmpstringp(const void *p1, const void *p2)
{
return strcmp(* (char * const *) p1, * (char * const *) p2);
}
[Optional] Extract the numbers back from the tag.

Answer 2

Any time you need to sort collections of related data by one value or another, you should be thinking struct. A structure holding each of the various values, (int value, char * of integer, and char * word for integer), can be sorted on any of them and provide you a way to correlate your values regardless of the sort order.
You basic challenge is to fill an array of struct with each of the values, sort on the char * word for integer, and then use it as you need. The various conversions are fairly straight forward, (1) convert the int to its char * equivalent (basically the opposite of itoa); and (2) use the lookup table to concatenate your word equivalents based on each digit in (1). (no need to leave a space between the word digits, unless you just feel like it)
Look over the following example. It is just one way to do what you are trying to do. Let me know if you have an questions:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
enum {MAXC = 32, MAXW = 64};
/* struct holding both integer and number strings */
typedef struct bs {
int v;
char buf[MAXC];
char str[MAXW];
} bs;
const char *numbers[] = { "zero", /* string lookup */
"one",
"two",
"three",
"four",
"five",
"six",
"seven",
"eight",
"nine" };
char *l2str (long v, char *str, size_t *l);
static int cmpbsp (const void *p1, const void *p2);
int main (void) {
int array[] = {2, 35, 6, 8, 4};
int i, n = sizeof array/sizeof *array;
bs bufstr[n]; /* array of struct */
size_t len = 0;
memset (bufstr, 0, n * sizeof *bufstr); /* initialize to zero */
for (i = 0; i < n; i++) { /* for each in array */
bufstr[i].v = array[i]; /* fill integer val */
l2str (array[i], bufstr[i].buf, &len); /* convert to str */
char *p = bufstr[i].buf;
for (; *p; p++) /* concatenate number for each digit */
strcat (bufstr[i].str, numbers[*p - '0']);
}
for (i = 0; i < n; i++) /* print original sort order */
printf (" bufstr[%d] v : %2d buf : %2s str : %s\n",
i, bufstr[i].v, bufstr[i].buf, bufstr[i].str);
putchar ('\n');
qsort (bufstr, n, sizeof *bufstr, cmpbsp); /* qsort on str */
for (i = 0; i < n; i++) /* print integers alpha-sorted on numbers */
printf (" bufstr[%d] v : %2d buf : %2s str : %s\n",
i, bufstr[i].v, bufstr[i].buf, bufstr[i].str);
putchar ('\n');
return 0;
}
/** convert long to string reversing digits in place.
* base 10 conversion of long value 'v' to string 'str'
* with string length returned through 'l'. 'd' is a
* pointer to the first digit in 'str' used to reverse
* the order of the digits in 'str' in place.
*/
char *l2str (long v, char *str, size_t *l)
{
if (!str) return NULL;
char *d, *p;
char tmp;
/* initialize pointers & length */
d = p = str;
*l = 0;
/* handle negative */
if (v < 0) {
*p++ = '-';
v = -v;
d++;
}
/* convert to char, terminate */
while (v > 0) {
*p++ = (v % 10) + '0';
v /= 10;
}
*p = 0;
*l = (size_t)(p - str);
/* reverse digits in place */
while (--p > d) {
tmp = *p;
*p-- = *d;
*d++ = tmp;
}
return str;
}
/* simple struct compare based on str */
static int cmpbsp (const void *p1, const void *p2)
{
return strcmp (((bs *)p1)->str, ((bs *)p2)->str);
}
Output
The original order and then alpha-sorted order (based on one, two, ...) are shown below.
$ ./bin/alphasortintarray
bufstr[0] v : 2 buf : 2 str : two
bufstr[1] v : 35 buf : 35 str : threefive
bufstr[2] v : 6 buf : 6 str : six
bufstr[3] v : 8 buf : 8 str : eight
bufstr[4] v : 4 buf : 4 str : four
bufstr[0] v : 8 buf : 8 str : eight
bufstr[1] v : 4 buf : 4 str : four
bufstr[2] v : 6 buf : 6 str : six
bufstr[3] v : 35 buf : 35 str : threefive
bufstr[4] v : 2 buf : 2 str : two
note: as mentioned in the comment where you are provided a link to convert numbers to words, you can improve the conversion by adding teens, and tens powers (e.g. thirteen, thirty, etc..) with just a bit of additional effort.