How to take in digits 0-255 from a file with no delimeters

Question

I have a plaintext file that has only numerical digits in it (no spaces, commas, newlines, etc.) which contains n digits which range from 0 to 255. I want to take it in and store these values in an array.

Example

---

Let's say we have this sequence in the file:

581060100962552569

I want to take it in like this, where in.read is the file input stream, tempArray is a local array of at most 3 variables that is wiped every time something is stored in endArray, which is where I want the final values to go:

in.read     tempArray     endArray
5           [5][ ][ ]     [] //It reads in "5", sees single-digit number X guarantees that "5X" is less than or equal to 255, and continues
8           [5][8][ ]     [58] //It reads in "8", realizes that there's no number X that could make "58X" smaller than or equal to "255", so it stores "58" in endArray
1           [1][ ][ ]     [58] //It wipes tempArray and reads the next value into it, repeating the logic of the first step
0           [1][0][ ]     [58] //It realizes that all single-digit numbers X guarantee that "10X" is less than or equal to "255", so it continues
6           [1][0][6]     [58][106] //It reads "6" and adds "106" to the endArray
0           [0][ ][ ]     [58][106] //It wipes tempArray and stores the next value in it
1           [0][1][ ]     [58][106]
0           [0][1][0]     [58][106][10] //Even though all single-digit numbers X guarantee that "010X" is less than or equal to "255", tempArray is full, so it stores its contents in endArray as "10".
0           [0][ ][ ]     [58][106][10]
9           [0][9][ ]     [58][106][10]
6           [0][9][6]     [58][106][10][96] //Not only can "96" not have another number appended to it, but tempArray is full
2           [2][ ][ ]     [58][106][10][96]
5           [2][5][ ]     [58][106][10][96] //There are numbers that can be appended to "25" to make a number less than or equal to "255", so continue
5           [2][5][5]     [58][106][10][96][255] //"5" can be appended to "25" and still be less than or equal to "255", so it stores it in tempArray, finds tempArray is full, so it stores tempArray's values in endArray as "255"
2           [2][ ][ ]     [58][106][10][96][255][37]
5           [2][5][ ]     [58][106][10][96][255][37] //There are numbers that can be appended to "25" to make a number less than or equal to "255", so continue
6           [6][ ][ ]     [58][106][10][96][255][37][25] //It sees that adding "6" to "25" would make a number that's larger than 255, so it stores "25" in the endArray and remembers "6" in the tempArray
9           [6][9][ ]     [58][106][10][96][255][37][25][69] //It sees that there is no number X such that "69X" is less than "255", so it stores "69" in endArray

Does anyone know how I can accomplish this behavior? Please try to keep your answers in pseudocode, so it can be translated to many programming langauges

Answer 1

I would not use the temp array for holding the intermediate numbers - for the CPU numbers are stored in binary format and you are reading decimal numbers.

Something like this could solve your problem:

array = []
accumulator = 0
count = 0
while not EOF:
    n = readDigit()
    if accumulator*10 + n > 256 or count == 2:
         array.push(accumulator)
         accumulator = n
         count = 0
    else:
         accumulator = accumulator*10 + n
         count = count + 1

The results are appended to the array called array.

Edit: Thanks to DeanOC for noticing the missing counter. But DeanOC's solution initializes the counter for the first iteration to 0 instead of 1.

Answer 2

antiguru's response is nearly there.

The main problem is that it doesn't take into consideration that the numbers can only have 3 digits. This modification should work for you.

array = []
accumulator = 0
digitCounter = 0

while not EOF
    n = readDigit()

    if accumulator*10 + n > 255 or digitcounter = 3:
         array.push(accumulator)
         accumulator = n
         digitCounter = 1
    else:
         accumulator = accumulator*10 + n
         digitCounter = DigitCounter + 1