nibbles | A Javascript Snake game | Game Engine library

Well.... in simplest terms, base 2, 8, and 10 number could use the same pattern since their values are all numeric characters. BUT, you probably want an expression for each type. The problem is that you did not make clear your intent. I am going on the assumption that you want the expression to validate what base a particular value is.

Is # supposed to count the 0x as part of the width? (If I remove it, I get 8 nibbles as expected)

Yes. There is an example in [format.string.std]/13 which illustrates this. The whole string is 6 characters, including the 0x:

Try assigning the result of nibbleSwap and bitSwap calls to buffer[x], i.e. change your second for loop like so:

“Those who don't know history are doomed to repeat it.” by Edmund Burke

In the old days, when memory was scarce (20K was considered a lot), terminals were more like typewriters (think keypunch) there was the use of BCD (Binary Coded Decimal). Even the Wikipedia article on Nibble notes BCD.

Each nibble represented a decimal digit. The nibbles went from 0-9 and a byte could represent two decimal digits. Now when these bytes were printed in code dumps on Green-bar when your program crashed, you could look at the Hex dump portion and read the vales as straight up decimal digits, no need to do the binary conversion of the bits to decimal in your head.

So does that mean all code was written using BCD? No, if you had a problem with some values you would just add some lines to convert the values to BCD (think debug statements) then read the BDC in the dump instead of doing all of the conversions. You could try to do all of the work in BCD but as with many types, sometimes not all of the functions are present and so you need to change types. Same with BCD sometimes you could not do things with BCD that you could do with integers. Make sense?

Added question from comment

Is there any need for nibble right now in modern programming world? and if yes why ?

I would not expect to see nibbles used with code that is created using modern high level programming language compilers but with microcontrollers I would not be surprised to see nibbles being used.

Basically if a nibble is not hard coded as part of a set of instructions for a processor I would not expect to see a nibble being used.

It seems that setting data-price on all the divs and my button was leading to the update option function being called twice. Once where the option_id was being set, the second time it wasn't.

Another learning experience. Sigh.

Shift one of the digits by 8 bits, and OR them together.

There are two problems:

1. You're not parsing the string to get a number

2. You're using &&, which is a logical operator, not the bitwise operator &

Parse the number as hex (parseInt(hexString, 16)) and use the bitwise operator:

I would avoid constructing check_bytes, since that will consume unnecessary storage in memory when n is very large. So my approach would be to use a loop or an equivalent comprehension.

Additional considerations:

• I assume you don't want an exception if the string is too short, so I added some logic for that case. I think len(inp_bytes) is a constant time operation, so this should be fast.
• I'm using the fact that a byte y is "True" when non-zero, I'm pretty sure that's as fast a way as any, but benchmarking could confirm that if you're really after all the nanoseconds you can save.
• You can use bitwise operations to test the last nibble if n is odd. Note that in Python, bitwise operations are defined on bytes, but not in sequences of bytes. b'\xf0' is a sequence of bytes, so & b'\xf0' yields an exception. b'\xf0'[0] is the first (and only) byte in that sequence, and that's accepted as an operand of &.
• EDIT: you clarified in the comments you only want inp_bytes returned if the number of leading zeros exactly equals n--logic added to check that the next nibble is non-zero.

With all that in mind, this is my solution:

In AT&T syntax an unadorned number refers to an address. You are comparing %rdi to the value fetched from address 0x0, i.e. you are dereferencing a null pointer.

If you want an immediate, use $: cmpq $0x0, %rdi.

However if you are looking for a null character (i.e. zero byte), your code doesn't make sense because you are loading and comparing an 8-byte qword (%rdi is a 64-bit register). If you want a single byte, use an 8-bit register. If you like %rdi, its low 8 bits are the register %dil, but maybe you'd like something like %al instead. So: