Adding a value to an integer stored as a byte array - arrays

Question

What would be the best way to add (not append) a value to an array of bytes where the array is treated as a single integer?
For example:
let arr = [0xFF, 0x01, 0xC3, 0x43];
Assume arr may be of any length. If I add 350 to this, for example, the new array should be: [0xFF, 0x01, 0xC4, 0xA1]. The solution I've come up with only works if we're incrementing by 1, therefore I'd need to call the method in a loop amount times, which can be inefficient with large amount's (this example uses Vec's instead of an array):
fn increment_byte_vec(vec: Vec<u8>) -> Vec<u8> {
let mut done = false;
vec.iter().rev().map(|&v| {
if done {
v
} else if v == 0xFF {
0
} else {
done = true;
v + 1
}
}).rev().collect::<Vec<_>>()
}
How would I adapt the above so that the function can take an amount parameter?

Answer 1

Not much to say here; just add and carry along the vector, back to front.
It's possible for the number to overflow. I chose to return the carry; you might prefer to extend the vector. My solution uses mutation, since it's much more efficient than allocating a new vector, and since I wasn't changing the length I thought it was nicer to go generic over a mutable slice.
/// Increments the bytes, assuming the most significant
/// bit is first, and returns the carry.
fn increment_bytes(b256: &mut [u8], mut amount: u64) -> u64 {
let mut i = b256.len() - 1;
while amount > 0 {
amount += b256[i] as u64;
b256[i] = amount as u8;
amount /= 256;
if i == 0 { break; }
i -= 1;
}
amount
}
fn main() {
let mut input = vec![0xFF, 0x01, 0xC3, 0x43];
println!("{}", increment_bytes(&mut input, 350));
println!("{:?}", input);
}

Answer 2

You are basically implementing sum in base 256. One way of tackling this is to convert to decimal, add 350 and reconvert the result to base 256.
I.e. [0xFF, 0x01, 0xC3, 0x43] is:
255 (FF) * 256^3 +
1 * 256^2 +
195 (C3) * 256^1 +
67 (43) * 256^0 = 4,278,305,603 (base10)
4,278,305,603 + 350 = 4_278_305_953
Now you need to reconvert this to base 256. This last bit might look like this in Rust:
// warning, does not handle overflows
fn base10_to_256(n: u64) -> [u8; 4] {
let mut converted_number = [0u8; 4];
let mut number_to_convert = n;
let base = 256u64;
for index in 0.. {
converted_number[3-index] = (number_to_convert % base) as u8;
number_to_convert = number_to_convert / base;
if number_to_convert == 0 { break; }
}
converted_number
}
playground