Converting Letters to Numbers in C

Question

I'm trying to write a code that would convert letters into numbers. For example A ==> 0 B ==> 1 C ==> 2 and so on. Im thinking of writing 26 if statements. I'm wondering if there's a better way to do this...

Thank you!

Answer 1

This is a way that I feel is better than the switch method, and yet is standards compliant (does not assume ASCII):

#include <string.h>
#include <ctype.h>

/* returns -1 if c is not an alphabetic character */
int c_to_n(char c)
{
    int n = -1;
    static const char * const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
    char *p = strchr(alphabet, toupper((unsigned char)c));

    if (p)
    {
        n = p - alphabet;
    }

    return n;
}

Answer 2

If you need to deal with upper-case and lower-case then you may want to do something like:

if (letter >= 'A' && letter <= 'Z')
  num = letter - 'A';
else if (letter >= 'a' && letter <= 'z')
  num = letter - 'a';

If you want to display these, then you will want to convert the number into an ascii value by adding a '0' to it:

  asciinumber = num + '0';

Answer 3

The C standard does not guarantee that the characters of the alphabet will be numbered sequentially. Hence, portable code cannot assume, for example, that 'B'-'A' is equal to 1.

The relevant section of the C specification is section 5.2.1 which describes the character sets:

3 Both the basic source and basic execution character sets shall have the following members: the 26 uppercase letters of the Latin alphabet

    ABCDEFGHIJKLM   
    NOPQRSTUVWXYZ

the 26 lowercase letters of the Latin alphabet

    abcdefghijklm
    nopqrstuvwxyz

the 10 decimal digits

    0123456789

the following 29 graphic characters

    !"#%&'()*+,-./: 
    ;<=>?[\]^_{|}~ 

the space character, and control characters representing horizontal tab, vertical tab, and form feed. The representation of each member of the source and execution basic character sets shall fit in a byte. In both the source and execution basic character sets, the value of each character after 0 in the above list of decimal digits shall be one greater than the value of the previous.

So the specification only guarantees that the digits will have sequential encodings. There is absolutely no restriction on how the alphabetic characters are encoded.

---

Fortunately, there is an easy and efficient way to convert A to 0, B to 1, etc. Here's the code

char letter = 'E';                  // could be any upper or lower case letter
char str[2] = { letter };           // make a string out of the letter
int num = strtol( str, NULL, 36 ) - 10;  // convert the letter to a number

The reason this works can be found in the man page for strtol which states:

(In bases above 10, the letter 'A' in either upper or lower case represents 10, 'B' represents 11, and so forth, with 'Z' representing 35.)

So passing 36 to strtol as the base tells strtol to convert 'A' or 'a' to 10, 'B' or 'b' to 11, and so on. All you need to do is subtract 10 to get the final answer.

Answer 4

Another, far worse (but still better than 26 if statements) alternative is to use switch/case:

switch(letter)
{
case 'A':
case 'a': // don't use this line if you want only capital letters
    num = 0;
    break;
case 'B':
case 'b': // same as above about 'a'
    num = 1;
    break;
/* and so on and so on */
default:
    fprintf(stderr, "WTF?\n");
}

Consider this only if there is absolutely no relationship between the letter and its code. Since there is a clear sequential relationship between the letter and the code in your case, using this is rather silly and going to be awful to maintain, but if you had to encode random characters to random values, this would be the way to avoid writing a zillion if()/else if()/else if()/else statements.

Answer 5

There is a much better way.

In ASCII (www.asciitable.com) you can know the numerical values of these characters.

'A' is 0x41.

So you can simply minus 0x41 from them, to get the numbers. I don't know c very well, but something like:

int num = 'A' - 0x41;

should work.

Answer 6

In most programming and scripting languages there is a means to get the "ordinal" value of any character. (Think of it as an offset from the beginning of the character set).

Thus you can usually do something like:

for ch in somestring:
    if lowercase(ch):
        n = ord(ch) - ord ('a')
    elif uppercase(ch):
        n = ord(ch) - ord('A')
    else:
        n = -1  # Sentinel error value
        # (or raise an exception as appropriate to your programming
        #  environment and to the assignment specification)

Of course this wouldn't work for an EBCDIC based system (and might not work for some other exotic character sets). I suppose a reasonable sanity check would be to test of this function returned monotonically increasing values in the range 0..26 for the strings "abc...xzy" and "ABC...XYZ").

A whole different approach would be to create an associative array (dictionary, table, hash) of your letters and their values (one or two simple loops). Then use that. (Most modern programming languages include support for associative arrays.

Naturally I'm not "doing your homework." You'll have to do that for yourself. I'm simply explaining that those are the obvious approaches that would be used by any professional programmer. (Okay, an assembly language hack might also just mask out one bit for each byte, too).

Answer 7

Since the char data type is treated similar to an int data type in C and C++, you could go with some thing like:

char c = 'A';   // just some character

int urValue = c - 65;

If you are worried about case senstivity:

#include <ctype.h> // if using C++ #include <cctype>
int urValue = toupper(c) - 65;

Answer 8

Aww if you had C++

For unicode definition of how to map characters to values

typedef std::map<wchar_t, int> WCharValueMap;
WCharValueMap myConversion = fillMap();

WCharValueMap fillMap() {
  WCharValueMap result;
  result[L'A']=0;
  result[L'Â']=0;
  result[L'B']=1;
  result[L'C']=2;
  return result;
}

usage

int value = myConversion[L'Â'];

Answer 9

I wrote this bit of code for a project, and I was wondering how naive this approach was.

The benefit here is that is seems to be adherent to the standard, and my guess is that the runtime is approx. O(k) where k is the size of the alphabet.

int ctoi(char c)
{
    int index;
    char* alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";

    c = toupper(c);

    // avoid doing strlen here to juice some efficiency.
    for(index = 0; index != 26; index++)
    {
        if(c == alphabet[index])
        {
            return index;
        }
    }

    return -1;
}

Answer 10

#include<stdio.h>
#include<ctype.h>
int val(char a);
int main()
{
    char r;
    scanf("%c",&r);
    printf("\n%d\n",val(r));
}
int val(char a)
{
    int i=0;
    char k;
    for(k='A';k<=toupper(a);k++)
    i++;
    return i;
}//enter code here