func Run() { var sieve euler.Sieve limit := 1000000 ps := sieve.PrimesUpto(limit) longestLen := 0 longestVal := 0 for a := 1; a < len(ps); a++ { total := 0 for b := a; b < len(ps); b++ { total += ps[b] if total >= limit { break } if b-a+1 > longestLen && sieve.IsPrime(total) { longestLen = b - a + 1 longestVal = total } } } fmt.Printf("%d\n", longestVal) }
func Run() { var s euler.Sieve p := 2 count := 0 // Move the closure out of the loop for efficiency. It does // save some time. circular := true pcheck := func(num int) { if !s.IsPrime(num) { circular = false } } for p < 1000000 { circular = true eachRotation(p, pcheck) if circular { // fmt.Printf("%d\n", p) count++ } p = s.NextPrime(p) } fmt.Printf("%d\n", count) }
func familySize(sieve *euler.Sieve, base, part int) (size int) { orig := euler.DigitsOf(base) work := make([]int, len(orig)) size = 0 found := false for _, d := range orig { if d == part { found = true break } } if !found { return } for value := part; value <= 9; value++ { copy(work, orig) for i := range orig { if work[i] == part { work[i] = value } } prime := euler.OfDigits(work) if sieve.IsPrime(prime) { size++ } } return }
func longestSeries(sieve *euler.Sieve, a, b int) int { for n := 0; ; n++ { c := n*n + a*n + b if c < 2 || !sieve.IsPrime(c) { return n } } panic("Not reached") }
func isRightPrime(s *euler.Sieve, num int) bool { for num > 0 { if !s.IsPrime(num) { return false } num /= 10 } return true }
func Run() { var s euler.Sieve n := 9 for ; ; n += 2 { if s.IsPrime(n) { continue } _, present := goldbach(&s, n) if !present { break } } fmt.Printf("%d\n", n) }
func isLeftPrime(s *euler.Sieve, num int) bool { mod := 1 for mod < num { mod *= 10 } for mod > 1 { num %= mod mod /= 10 if !s.IsPrime(num) { return false } } return true }
func TestMR(t *testing.T) { var sv euler.Sieve limit := 1000000 if testing.Short() { limit = 100000 } for i := 2; i < limit; i++ { b := sv.IsPrime(i) b2 := euler.IsPrime(i, 20) if b != b2 { t.Errorf("Mismatch: %d (%v!=%v)", i, b, b2) } } }
func Run() { var sieve euler.Sieve var result int64 // Check if this result is valid, and process it if it is. isValid := func(nums []int) { if nums[1]-nums[0] != nums[2]-nums[1] { return } for _, num := range nums { if !sieve.IsPrime(num) { return } } if nums[0] == 1487 { // Skip, per problem description. return } result = int64(nums[0])*100000000 + int64(nums[1])*10000 + int64(nums[0]) } // This isn't actually right, but it so happens that the // initial value of the result is prime. The first prime of // the result might not be the lowest permutation, and that // lowest permutation might not be prime. for base := 1009; base < 10000; base++ { if !isAscending(base) { continue } perms := allPermutations(base) selections(perms, isValid) } fmt.Printf("%d\n", result) }