idiomatic C for an int to const string map - c

Question

How can I express in C a map like this one?
{
{1, "One"},
{1000, "One thousand"},
{1000000, "One million"}
}
The key is an int and can be a big int, the value is a constant string and it is known at compile time.
The map will contain some 20 or 30 elements.
I would write this function:
const char* numbers( const int i )
{
switch( i ) {
case 1: return "One";
case 1000: return "One thousand";
case 1000000: return "One million";
default: return "";
}
}
is there any better (more idiomatic) way of doing it?

Answer 1

Using a switch is entirely idiomatic C, there's a separate style consideration (that would apply in pretty much any language) whether you want to separate the key/value data out of the program logic.
You could use an array of const struct { int key; const char *value; };, but then you'll start worrying about whether you should use a linear search, binary search, perfect hash, etc. With a switch, the compiler takes it out of your hands.
If you have some kind of associative container (tree or hashmap) that you use for other things in this project then you could use that, but it's not really worth writing one for a 30-item collection.

Answer 2

Just like you did:
typedef struct {
long long key;
char *val;
} Item;
const Item mydict[] = {
{1, "One"},
{1000, "One thousand"},
{1000000, "One million"}
};
I leave as an exercise the body of numbers() function.
The alternate solution suggested by Steve Jessop is perfectly valid as well.

Answer 3

If all is statically known, I would go with something like this:
char strings[][] = {"One", "One thousand", "One million", /* whatever */};
int map[] = {1, 1000, 1000000};
const char *numbers(const int i)
{
position = search(map, i);// if the array is too small, just linear search
// if it is big, you can binary search
// if there is a relation use a formula
// although a formula is not extendable.
// In this case, it is log(i) in base 1000.
return strings[position];
}
This method can be extended for non-static data. You just have to make sure you correctly fill the strings array and keep the map sorted.
Note: Obviously, you should add sufficient error-checking etc. For example in the case where search couldn't find i.

Answer 4

This could be one solution.
Basically create sorted array of key-value pairs and then just use bsearch-function (performs binary search) to quickly find the correct value. It might make sense to implement your own binary search to make searching more convinient.
#include <stdlib.h>
#include <stdio.h>
typedef struct mapping
{
int key;
char* value;
} Mapping;
int mappingCompare(const void* a, const void* b)
{
const Mapping* first = (const Mapping*)a;
const Mapping* second = (const Mapping*)b;
return second->key - first->key;
}
int main()
{
Mapping map[3];
Mapping search;
Mapping* result;
map[0].key = 1;
map[0].value = "One";
map[1].key = 1000;
map[1].value = "One thousand";
map[2].key = 1000000;
map[2].value = "One million";
//qsort is only needed if the map is not already in order
qsort(map, 3, sizeof(Mapping), mappingCompare);
search.key = 1000;
result = (Mapping*)bsearch(&search, map, 3, sizeof(Mapping), mappingCompare);
printf("value for key 1000 is %s\n", result->value);
}