The way which works for me is :

- Take the number, make a pair of two digits starting from right to left.
- Now, multiply each pair by two, and do remember the carry to the next i.e. left pair to it.
- In case the carry from right pair is zero, then it's fine, otherwise add the carry after multiplying this current pair by 2.

For example: here **c** stands for carry.

A simple example for a power of $2$.

$ 4096 \to \underline{40}\ \underline{96} $

$ (\underline{40}\ \underline{96}) *2 \to (\underline{40}\ *2+[c] , \underline{96} *2)$

$ (\underline{40}\ *2+[1] , \underline{92}) \to (\underline{81}\ \underline{92}) $

A simple example for a number with odd(5) length.

$ 98765 \to \underline{9}\ \underline{87}\ \underline{65} $

$ (\underline{9}\ \underline{87}\ \underline{65} \ )*2 \to (\underline{9}\ *2+[c] , \underline{87}\ *2+ [c], \underline{65} *2 ) $

$ (\underline{9}\ *2+[c] , \underline{87}\ *2+ [1], \underline{30} \to (\underline{9}\ *2+[1] , \underline{75}, \underline{30} )$

$ (\underline{18}+[1] , \underline{75}, \underline{30} ) \to (\underline{19} \ \underline{75}\ \underline{30} ) $

A (pseudo)number this time, using the following Python code

```
import random
n=random.randint(1,2**(random.randint(2,100)))
print(n)
```

266103712878030

length is $15$

$266103712878030 \to \underline{2}\ \underline{66}\ \underline{10}\ \underline{37}\ \underline{12}\ \underline{87}\ \underline{80}\ \underline{30})$

$(\underline{2}\ \underline{66}\ \underline{10}\ \underline{37}\ \underline{12}\ \underline{87}\ \underline{80}\ \underline{30}) *2 \to $
$ (\underline{2}\ *2+[c] , \underline{66}\ *2+[c] , \underline{10}\ *2+[c] , \underline{37}\ *2+[c] , \underline{12}\ *2+[c] , \underline{87}\ *2+[c] , \underline{80}\ *2+[c] , \underline{30}*2)$

$ (\underline{2}\ *2+[c] , \underline{66}\ *2+[c] , \underline{10}\ *2+[c] , \underline{37}\ *2+[c] , \underline{12}\ *2+[c] , \underline{87}\ *2+[c] , \underline{80}\ *2+[c] , \underline{30} *2) \to$
$ (\underline{2}\ *2+[c] , \underline{66}\ *2+[c] , \underline{10}\ *2+[c] , \underline{37}\ *2+[c] , \underline{12}\ *2+[c] , \underline{87}\ *2+[1] , \underline{60}\ *2+[0] , \underline{60})$

$ (\underline{2}\ *2+[c] , \underline{66}\ *2+[c] , \underline{10}\ *2+[c] , \underline{37}\ *2+[c] , \underline{12}\ *2+[1] , \underline{74}+[1] , \underline{60}\ *2 , \underline{60}) \to$
$ (\underline{2}\ *2+[c] , \underline{66}\ *2+[c] , \underline{10}\ *2+[c] , \underline{37}\ *2+[0] , \underline{24}\ +[1] , \underline{75}\ , \underline{60} , \underline{60})$

$ (\underline{2}\ *2+[c] , \underline{66}\ *2+[c] , \underline{10}\ *2+[0] , \underline{74}\ *2+[0] , \underline{25}\ , \underline{75}\ , \underline{60} , \underline{60}) \to$
$ (\underline{2}\ *2+[c] , \underline{66}\ *2+[0] , \underline{20}\ +[0] , \underline{74}\ , \underline{25}\ , \underline{75}\ , \underline{60} , \underline{60})$

$ (\underline{2}\ *2+[1] , \underline{32}\ +[0] , \underline{20}\ , \underline{74}\ , \underline{25}\ , \underline{75}\ , \underline{60} , \underline{60}) \to $
$ (\underline{2}\ *2+[1] , \underline{32}\ , \underline{20}\ , \underline{74}\ , \underline{25}\ , \underline{75}\ , \underline{60} , \underline{60}) $

$ (\underline{2}\ *2+[1] , \underline{32}\ , \underline{20}\ , \underline{74}\ , \underline{25}\ , \underline{75}\ , \underline{60} , \underline{60}) \to $
$ (\underline{4}\ +[1] , \underline{32}\ , \underline{20}\ , \underline{74}\ , \underline{25}\ , \underline{75}\ , \underline{60} , \underline{60}) $

$ (\underline{5} , \underline{32}\ , \underline{20}\ , \underline{74}\ , \underline{25}\ , \underline{75}\ , \underline{60} , \underline{60}) $

The reason i use this algorithm is that

- It's easier to multiply two digits at a time, also i happen to remember the multiplication easily for the numbers under 100.
- It is faster than to multiply single digit at a time (but slower than 3 or 4 at a time). We can negotiate this for simplicity as we are doing calculation in mind.
- Also, when you re-iterate and make the final number from left to right you can easily recall the numbers you have just calculated, if not then multiply upcoming pair again.