For this to solve we need to cut it down into three steps:

1. Converting the hexadecimal number digit by digit. This leads into solving how to
2. multiply decimal numbers, which in turn needs us being able to
3. add decimal numbers digit by digit.

As tiny helpers which are needed in the other functions let me have these:

type TArrayString= Array of String; // In case it doesn't exist already // Fill a text with leading zeroes up to the desired length procedure MinLen( var s: String; iLen: Integer ); begin while Length( s )< iLen do s:= '0'+ s; end; 

Addition

We all learnt written addition in school: write all numbers in one row, then add each row's digits and carry that sum's additional digits over to the next row of digits of the summands. This can also be done easily:

// Addition of multiple long numbers function Summe( aSummand: TArrayString ): String; var iLenMax, iA, iPos, iSum, iAdvance: Integer; c: Char; begin result:= '0'; case Length( aSummand ) of 0: exit; // Nothing to add at all 1: begin result:= aSummand[Low( aSummand )]; // Sum equals the only summand exit; end; end; // Find the longest text, then make all texts as long as the longest, // so we can simply access an existing character at that position. iLenMax:= 0; for iA:= Low( aSummand ) to High( aSummand ) do begin if Length( aSummand[iA] )> iLenMax then iLenMax:= Length( aSummand[iA] ); end; for iA:= Low( aSummand ) to High( aSummand ) do MinLen( aSummand[iA], iLenMax ); MinLen( result, iLenMax ); // All have the same length: process from the least significant digit // (right) to the most significant digit (left). for iPos:= iLenMax downto 1 do begin // Manual addition: write all numbers in one row, then add single // digits per row. Nobody will ever give this function so many // summands that the sum of single digits will come near the Integer // capacity. iSum:= 0; for iA:= Low( aSummand ) to High( aSummand ) do begin Inc( iSum, Ord( aSummand[iA][iPos] )- $30 ); // Add digit from each number end; Inc( iSum, Ord( result[iPos] )- $30 ); // Also add result's digit from potential previous carry // Turn that Integer sum into text again, digit by digit iAdvance:= 0; // Exceeding the current position if we need to carry while iSum> 0 do begin c:= Chr( (iSum mod 10)+ $30 ); // Only the rightmost digit if iPos- iAdvance< 1 then begin // Outside the String? result:= c+ result; // Prepend end else begin result[iPos- iAdvance]:= c; // Set new digit in overall sum end; iSum:= iSum div 10; // This digit has been process, go to next one Inc( iAdvance ); // Not in the current position anymore, but processing potential carries end; end; end; 

I did not restrict it to always 2 summands for the following reasons:

• Dealing with an unknown amount of summands needs virtually no extra work.
• Adding multiple summands (instead of always 2) in one go is more efficient than calling this function again and again.
• Later with multiplication we can lazily call this function once with f.e. 6 times the same summand to simulate multiplication by 6.

$30 is the ASCII code for the character '0' - subtracting the potential character '0' to '9' by that of '0' gives us the value 0 to 9.

Multiplication

We all learnt written multiplication in school, too: for each digit of one factor calculate that product (which can only be an "easy" multiplication by 0 to 9), write down all those products in a row as per digit position (optionally with trailing zeroes), then add all those products into a sum (referencing written addition). This can also be done easily, since we now have solved addition already:

// Multiplication of two long numbers function Produkt( s1, s2: String ): String; var iPos, iStep, iA, iNine: Integer; aSummand, aStep: TArrayString; begin // For each digit of one factor we will make a separate multiplication SetLength( aSummand, Length( s1 ) ); // This time it doesn't matter how long both numbers are: just again go // from least significant digit (right) to most significant digit (left). for iPos:= Length( s1 ) downto 1 do begin iA:= Length( s1 )- iPos; // Array index per digit // As per our position the sum must be shifted by 10: first (rightmost) // digit needs no shift (0), second needs one (10), third needs two (100)... MinLen( aSummand[iA], iA ); // Current digit iStep:= Ord( s1[iPos] )- $30; case iStep of 0: ; // Multiplication by 0 always results in 0, an empty summand equals one of "0" 1: aSummand[iA]:= s2+ aSummand[iA]; // No multiplication needed, just prepend with factor else // Cheap multiplication: use addition with 2 to 9 times the same summand SetLength( aStep, iStep ); for iNine:= 0 to iStep- 1 do aStep[iNine]:= s2; aSummand[iA]:= Summe( aStep )+ aSummand[iA]; // Prepend sum, zeroes must be trailing end; end; // Now just add all sums that we got per digit result:= Summe( aSummand ); end; 

It could have been even shorter, since Summe() can already deal with 0 and 1 summands - I don't really need to treat that differently. As previously told: the easy multiplication is done by simple addition - not very performance efficient, but easy to comprehend.

Hexadecimal to decimal conversion

Since we can now add and multiply, we're also able to convert each digit of a non-decimal-base number and increase the outcome to the overall result:

// Convert base 2..36 long number into base 10 long number function ConvertToDecimal( sFrom: String; sBase: String= '16' ): String; var sStep, sPos: String; cFrom: Char; a: TArrayString; begin SetLength( a, 2 ); a[0]:= '0'; // Overall sum = result sPos:= '1'; // Current digit's power while Length( sFrom )> 0 do begin // Process least significant digit (right) cFrom:= sFrom[Length( sFrom )]; case cFrom of // For now at max base 36 is supported, which includes hexadecimal '0'.. '9': sStep:= cFrom; // Same as text 'A'.. 'Z': sStep:= IntToStr( Ord( cFrom )- $41+ 10 ); // Turn "B" into "11" end; a[1]:= Produkt( sPos, sStep ); // Multiply current digit's value by current position's power a[0]:= Summe( a ); // Add both product and current overall result sPos:= Produkt( sPos, sBase ); // Increase power to next digit position Delete( sFrom, Length( sFrom ), 1 ); // Remove rightmost digit end; result:= a[0]; end; 

It even works not only for hexadecimal (base 16) input, but also for others. $41 is the ASCII value for 'A' - subtracting the potential characters 'A' to 'Z' by that of 'A' gives us the value 0 to 25, to which we then just add 10.

Tests

Strings are implied. Spaces are just for optical reasons.

Summary

• This is a good exercise on turning basic/existing skills (arithmetics) into program code in the sense of needing more understanding in logics than in programming/the language, making it appealing to both beginners (still struggling with programming) and experts (mostly focusing on task automation).
• Performance wise this is surely far from optimal, but should be rather easy to understand/comprehend/follow instead of being difficult to read. Likewise it should be easy to translate into other languages.
• A bonus exercise would be to also add subtraction and division.
• A few tiny details are omitted, f.e. numbers are always expected to not have leading zeroes - the results may then also have unneeded leading zeroes. Empty Strings are interpreted as 0, but a result of 0 is not reduced to an empty String either.
• It works with any String type, because we only operate on ASCII anyway - there's no need to distinguish between AnsiString, UnicodeString, WideString and so on. However, Char is used as type, which is bound to that choice. But the functions Chr() and Ord() should support everything again.