[baavgai]

Skydiver, on 27 July 2012 - 01:29 PM, said:

I'm curious which compiler you are using that has 64-bit integers as its default.

Using gcc.

This is the behavior:

[baavgai@DIC]$ cat > a.cc
#include <iostream>

int main() {
	int n = 0x800000000;
	std::cout << "n = " << n << std::endl;
	return 0;
}
[baavgai@DIC]$ g++ -Wall a.cc
a.cc: In function ‘int main()’:
a.cc:4: warning: overflow in implicit constant conversion
[baavgai@DIC]$ ./a.out 
n = 0
[baavgai@DIC]$

[ishkabible]

I was bound and determined to fit this into 1 line so here it is.

Spoiler

int hex2bin(const char* h) {
    int i=0;
    for(;*h;++h)(i*=16)+=(*h|32)-((*h>'9')?('a'-10):'0');
    return i;
}

the real trick here is *h|32 which normalizes the digit to either a lower case letter or leaves it as a number. after that you only need 1 conditional. I'm looking at getting rid of the ?: operator right now

here's the code golf/obfuscated version with all those yummy magic numbers

int hex2bin(const char* h) {
	int i=0;
	for(;*h;++h)(i<<=4)+=(*h|32)-(*h>57?87:48);
	return i;
}

wouldn't you love to maintain my code all day?

This post has been edited by ishkabible: 27 July 2012 - 12:45 PM

[Skydiver]

Here's a different approach that does things the slow way. The approach is better suited for Base64 unencoding rather than hex2bin:

Spoiler

int hex2bin(const char *hexString)
{
    static const char digits[] = "0123456789abcdef";
    static const char * digitsEnd = &digits[sizeof(digits) / sizeof(digits[0])];
    int value = 0;
    int digitsInInt = sizeof(int) * 2;

    while (*hexString)
    {
        char lower = *hexString++ | 0x20;   // make lowercase
        const char * match = digits;

        while(match < digitsEnd && *match != lower)
            match++;
        if (match >= digitsEnd)
            break;          // invalid digit
        if (digitsInInt-- <= 0)
            return -1;      // overflow detected
        value = value * 16 + match - digits;
    }
    return value;
}

[ishkabible]

here's the clean version of mine; I think the bitwise OR trick is really helpful even for serious code...serious code is just more boring

Spoiler

int hex2bin(const char* hexString) {
    int value = 0;
    for(;*hexString;++hexString) {
       value *= 16;
       char digit = *value;
       digit |= ('a' - 'A'); //normalize 'digit'
       if(digit > '9') {
          value += digit - '0';
       else {
          value += digit - 'a' + 10;
       }
    }
    return value;
}

This post has been edited by ishkabible: 27 July 2012 - 07:36 PM

[Aphex19]

I modified the style a bit and added a small "mystrlen" utility function. Seems that all tests pass.

Spoiler

#include <iostream>

int hex2bin(const char *hexString);

void TestIt(char * inputs[], const int check[]) {
    for(int i = 0; inputs[i] != 0; i++) {
        int value = hex2bin(inputs[i]);
        std::cout << "Hex string: " << inputs[i]
                  << " is " << value << " in decimal. "
                  << ( value == check[i] ? "Correct" : "Incorrect" )
                  << std::endl;
    }
}

void BasicTest() {
    char * inputs[] = { "0", "C", "9A", "71", "FFFF", "bad", "CAFE", "f00d", 0 };
    int check[] = { 0, 0xC, 0x9A, 0x71, 0xFFFF, 0xbad, 0xCAFE, 0xf00d, -1 };

    std::cout << "Basic tests: " << std::endl;
    TestIt(inputs, check);
}

void ExtraCreditTest() {
    char * inputs[] = { "", "C0FFEE", "0110 65", "edge", "0x12", "$29", "800000000", 0 };
    int check[] = { 0, 0xC0FFEE, 0x0110, 0xed, 0, 0, -1, -1 };

    std::cout << "Extra credit tests: " << std::endl;
    TestIt(inputs, check);
}

int main() {
    BasicTest();
    // Uncomment the line below for an extra challenge.
    ExtraCreditTest();
    return 0;
}

int mystrlen(const char *str) {
	int i = 0;
	while (str[i] != '\0') i++;
	return i;
}

int hex2bin(const char *hexString) {
    int value = 0;
    unsigned int pow = 1;
    if (!hexString) return -1;
	int length = mystrlen(hexString);

    if (length == 0) return 0;
	if (length > 8) return -1;
	
    for (int i = length-1; i >= 0; i--) {
        if (hexString[i] >= '0' && hexString[i] <= '9') {
            value += (hexString[i] - '0') * pow;   
        } else if (hexString[i] >= 'a' && hexString[i] <= 'f') {
			value += ((hexString[i] - 'a') + 0xa) * pow; 
		} else if (hexString[i] >= 'A' && hexString[i] <= 'F') {
			value += ((hexString[i] - 'A') + 0xa) * pow; 
		} else {
			pow = 1;
			value = 0;
			continue;
		}
        pow *= 0x10;
    }
	
    return value;
}

The method I use is the positional notation method. Conceptually, it starts at the least significant position (right-most character) and moves left, adding the weights of each character as it goes.

edit:
checked if "hexString" was null BEFORE dereferencing it!

This post has been edited by Aphex19: 28 July 2012 - 06:29 PM

[auch]

How about that:

int hex2bin(const char *hexString)
{
   return strtol(hexString, (char **)NULL, 16);
}

[Skydiver]

Unfortunately, stdlib.h or cstdlib was not included in the template program as shown in post #1, so strtol() would not be declared.

[Xupicor]

I had to correct the OP code to get it to compile without warnings. const correctness!
Here's my - probably most unoriginal - implementation.

Spoiler

int hex2bin(const char *hexString)
{
    int value = 0;
    // Write your implementation here.
	const int BAD_VALUE = -1; // BAH, it is a valid value, but whatever ;P
	if (hexString == nullptr) { return BAD_VALUE; }

	bool valid_values = true;
	unsigned int i = 1;
	for (const char* c = hexString; *c; ++c) {
		int current = 0;
		if (*c >= '0' && *c <= '9') {
			current = *c - '0';
		} else if (*c >= 'a' && *c <= 'f') {
			current = *c - 'a' + 10; 
		} else if (*c >= 'A' && *c <= 'F') {
			current = *c - 'A' + 10;
		} else {
			valid_values = false;
			break;
		}
		if (current == 0 && value == 0) {
			continue;
		} 

		if (i++ > 8) { // 8 * 4 = 32
			return BAD_VALUE;
		}
		value = value << 4;
		value |= current;
	}

	if (!valid_values) {
		// handle it, the user should know that input was crappy
	}
    return value;
}

Fixed a small bug, it wasn't tested by the OP code, but it was there nonetheless. />

This post has been edited by Xupicor: 10 November 2012 - 03:08 PM

[jjl]

Here's mine, I decided to do it in C />/>

Spoiler

#define HEX_TO_NUM 55

int hex2bin(const char *str) {
   char *end = str + strlen(str) - 1;
   int hex = 0, power = 1;
   char temp;
   for(; end - str + 1 && (temp = toupper(*end)) != 'X'; end--, power *= 16) {
      if(temp >= 'A' && temp <= 'F') 
         hex += (temp - HEX_TO_NUM) * power;
      else if(temp >= '0' && temp <= '9') 
         hex += (temp - '0') * power;
      else 
         return -1;
   }
   return hex;
}

This post has been edited by jimblumberg: 10 November 2012 - 07:13 PM
Reason for edit:: Added spoiler tags

[JDX]

I know this isn't efficient but it was good practice for using chars.

Spoiler

int hex2bin(const char *hexString)
{
	int value = 0;
	char* hexValues[]={"F","E","D","C","B","A","9","8","7","6","5","4","3","2","1","0"};
	int len = strlen(hexString);
	char* buffer = new char[2];
	buffer[1] = '\0';
	
	for(int i=0; i<len; i++)
	{
		memcpy(buffer,hexString+i,1);
		buffer[0] = (char)toupper(buffer[0]);
		for(int j=0; j<16; j++)
		{
			if (strcmp(buffer, hexValues[j])==0)
			{
				value += (15-j)*pow(16,len-1-i);				
				
			}
		}
		
	}		
	
	return value;
}

[Skydiver]

On your line 6, you have no guarantee that buffer[1] is zero, so you have no guarantees that the string in buffer is null terminated.