A4 2
A6 =SUM(A7:IP8)
A7 =MOD(A4*2,10)
B7 =MOD(B4*2,10)+INT(A4/5) fill into C7:IP7
A8 =MOD(A5*2,10)+INT(IP4/5)
B8 =MOD(B5*2,10)+INT(A5/5) fill into C8:IP8

Copy A6:IP8, paste into A9. Copy A6:IP11, paste into A12. That is, double the copy/paste range each time, so reach 2^1024 after 10 copy/paste operations.

The sum of the decimal digits of 2^N (1

Re: #97. Thank you. Taught me two things. 1. RIGHT() works on doubles. I thought it only worked on strings and variants. I’ve been doing some unnecessary type changes, and 2. RIGHT() and * are commutative. They never taught me that in arithmetic

…mrt

OK, I forgot that I did in fact write specific routines for those questions that in effect used large number arithmatic. I set up big arrays and did it one digit at a time. Not very efficient, but they worked well within the allotted time.

Here’s the code for the sum of the digits in 100! for instance (which takes less than a second):

Function SumFact(num)
Dim DigitA(1 To 1000) As Long, NumDigits As Long, i As Long, j As Long, carry As Long
Dim k As Long, x As Long, Facts As String

NumDigits = 1
DigitA(1) = 1

For i = 2 To num
carry = 0
For j = 1 To NumDigits
DigitA(j) = DigitA(j) * i + carry
If DigitA(j) .GT. 9 Then
carry = Int(DigitA(j) / 10)
DigitA(j) = DigitA(j) – carry * 10

If j = NumDigits Then
DigitA(j + 1) = carry
NumDigits = NumDigits + 1
If carry .GT. 9 Then
x = Int(Log(carry) / Log(10))
For k = j + 1 To j + x
DigitA(k) = carry – Int(carry / 10) * 10
carry = Int(carry / 10)
NumDigits = NumDigits + 1
Next k
DigitA(NumDigits) = carry
End If
End If
Else
carry = 0
End If
Next j
Next i
For i = NumDigits To 1 Step -1
SumFact = SumFact + DigitA(i)
Next i

End Function

The main problems for me have been in matrix operations where the precision is an issue.
Foxes bigmatrix operations solve this limitation.

I started off doing it in a spreadsheet (in XL 2007), in 7 stages. It works, but it’s very slow.

104 might be a bit more difficult, because you need the start digits of a long number. I’ll have a think about that one later.

The Fibonacci sequence is defined by the recurrence relation:

F_(n) = F_(n-1) + F_(n-2), where F_(1) = 1 and F_(2) = 1.

It turns out that F_(541), which contains 113 digits, is the first Fibonacci number for which the last nine digits are 1-9 pandigital (contain all the digits 1 to 9, but not necessarily in order). And F_(2749), which contains 575 digits, is the first Fibonacci number for which the first nine digits are 1-9 pandigital.

Given that F_(k) is the first Fibonacci number for which the first nine digits AND the last nine digits are 1-9 pandigital, find k.

…mrt

#97?

The first known prime found to exceed one million digits was discovered in 1999, and is a Mersenne prime of the form 2^(6972593)-1; it contains exactly 2,098,960 digits. Subsequently other Mersenne primes, of the form 2^(p)-1, have been found which contain more digits.

However, in 2004 there was found a massive non-Mersenne prime which contains 2,357,207 digits: 28433×2^(7830457)+1.

Find the last ten digits of this prime number.

…mrt