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)
}
