package main
func main() {
target := int64(600851475143)
arr := make([]bool, 10000)
prime := 3
var k int
for {
for k = 2 * prime; k < len(arr); k += prime {
arr[k] = true
}
for k = prime + 2; k < len(arr) && arr[k]; k += 2 {
}
if k < len(arr) {
prime = k
if target%int64(k) == 0 {
target = target / int64(k)
if target == 1 {
println(k)
return
}
}
} else {
break
//prevent infinite loop in case the answer
//is not less than 10000
}
}
}
package main
func main() {
primes := []int{2, 3, 5, 7, 11, 13, 17, 19}
result := 1
var divisor int
for i := range primes {
divisor = primes[i]
for divisor <= 20 {
divisor *= primes[i]
}
divisor /= primes[i]
result *= divisor
}
println(result)
}
package main
func main() {
arr := make([]bool, 105000)
arr[0], arr[1] = true, true
count, prime := 2, 3
var k int
for {
for k = 2 * prime; k < len(arr); k += prime {
arr[k] = true
}
for k = prime + 2; k < len(arr) && arr[k]; k += 2 {
}
if k < len(arr) {
prime = k
count++
if count == 10001 {
println(prime)
break
}
} else {
break
}
}
}
package main
func main() {
arr := make([]bool, 2000000)
arr[0], arr[1] = true, true
sum, prime := int64(5), 3
var k int
for {
for k = 2 * prime; k < len(arr); k += prime {
arr[k] = true
}
for k = prime + 2; k < len(arr) && arr[k]; k += 2 {
}
if k < len(arr) {
prime = k
sum += int64(k)
} else {
break
}
}
println(sum)
}
package main
import (
"math"
)
func main() {
var maxCounter, aInMax, bInMax int
maxCounter = 0
for a := -999; a < 1000; a++ {
for b := -999; b < 1000; b++ {
inner:
for n := 0; ; n++ {
if !isPrime(n*n + a*n + b) {
if n > maxCounter {
maxCounter, aInMax, bInMax = n, a, b
}
break inner
}
}
}
}
println(aInMax * bInMax)
}
func isPrime(in int) bool {
limit := int(math.Sqrt(float64(in)))
if in < 2 || in%2 == 0 {
return false
} else {
for i := 2; i < limit; i++ {
if in%i == 0 {
return false
}
}
}
return true
}
package main
import (
"strconv"
)
func main() {
arr := make([]bool, 1000000)
arr[1] = true
prime := 3
count := 13
var k, tmp, localCount int
var str string
primeloop:
for {
for k = prime * 2; k < len(arr); k += prime {
arr[k] = true
}
for k = prime + 2; k < len(arr) && arr[k]; k += 2 {
}
if k < len(arr) {
prime = k
str = strconv.Itoa(prime)
if prime > 100 {
localCount = 1
for i := 0; i < len(str)-1; i++ {
str = str[1:] + str[0:1]
tmp, _ = strconv.Atoi(str)
if tmp > prime {
continue primeloop
} else if !arr[tmp] && tmp%2 != 0 {
localCount++
} else {
continue primeloop
}
}
count += localCount
}
} else {
break
}
}
println(count)
}
package main
import (
"strconv"
)
func main() {
arr := make([]bool, 1000000)
left := make([]bool, 1000000)
right := make([]bool, 1000000)
//manuel setting for the values less than 10
left[2], left[3], left[5], left[7] = true, true, true, true
right[2], right[3], right[5], right[7] = true, true, true, true
arr[0], arr[1], arr[6], arr[9] = true, true, true, true
a := []int{3, 5, 7}
for i := range a {
for k := a[i] * 2; k < len(arr); k += a[i] {
arr[k] = true
}
}
//calculate other primes and check the condition.
var k, tmp int
prime, counter, sum := 11, 0, 0
for {
if right[prime/10] {
right[prime] = true
}
tmp, _ = strconv.Atoi(strconv.Itoa(prime)[1:])
if left[tmp] {
left[prime] = true
if right[prime] {
sum += prime
counter++
if counter == 11 {
println(sum)
return
}
}
}
for k = prime * 2; k < len(arr); k += prime {
arr[k] = true
}
for k = prime + 2; k < len(arr) && arr[k]; k += 2 {
}
if k < len(arr) {
prime = k
} else {
break
}
}
}
package main
import (
"strconv"
"strings"
)
func main() {
a := make([]bool, 87654322)
a[0], a[1] = true, true
prime := 3
var k int
finished := false
for !finished {
for k = 2 * prime; k < len(a); k += prime {
a[k] = true
}
for k = prime + 2; k < len(a) && a[k]; k += 2 {
}
if k < len(a) {
prime = k
} else {
finished = true
}
}
//a now has false values for the primes and multiples of 2
//but we skip even numbers in our iteration.
for i := int64(87654321); i > 0; i -= 2 {
if !a[i] && isPandigital(i) {
println(i)
return
}
}
}
func isPandigital(in int64) bool {
str := strconv.Itoa64(in)
n := len(str)
for i := 1; i <= n; i++ {
if !strings.Contains(str, strconv.Itoa(i)) {
return false
}
}
return true
}
package main
func main() {
arr := make([]bool, 1000000)
arr[0], arr[1] = true, true
count, prime := 2, 3
var k int
for {
for k = 2 * prime; k < len(arr); k += prime {
arr[k] = true
}
for k = prime + 2; k < len(arr) && arr[k]; k += 2 {
}
if k < len(arr) {
prime = k
count++
} else {
break
}
}
primes := make([]int, count)
primes[0] = 2
index := 1
for i := 3; i < len(arr); i += 2 {
if !arr[i] {
primes[index] = i
index++
}
}
var consecutiveCount, divisorCount, tmp int
outer:
for i := 646; i < 1000000; i++ {
consecutiveCount = 0
inner:
for j := i; j < i+4; j++ {
divisorCount = 0
//find divisors of j
if !arr[j] && j%2 != 0 {
//a quick check: if j is prime
continue outer
} else {
tmp = j
for k := 0; k < len(primes); k++ {
if (!arr[tmp] && tmp%2 != 0) || tmp%primes[k] == 0 {
divisorCount++
if divisorCount == 4 {
consecutiveCount++
if consecutiveCount == 4 {
println(i)
return
}
continue inner
} else if !arr[tmp] && tmp%2 != 0 {
//another quick check for prime tmp
continue outer
}
for tmp%primes[k] == 0 {
tmp /= primes[k]
}
}
}
}
}
}
}
package main
import (
"strings"
"strconv"
)
func main() {
arr := make([]bool, 10000)
prime := 2
finished := false
var i int
for !finished {
for i = 2 * prime; i < 10000; i += prime {
arr[i] = true
}
//next prime
for i = prime + 1; i < 10000 && arr[i]; i++ {
}
if i < 10000 {
prime = i
} else {
finished = true
}
}
outer:
for i := 1000; i < len(arr); i++ {
for j := i + 1; j < len(arr); j++ {
if i != 1487 && !arr[i] && !arr[j] && isPerm(i, j) && 2*j-i < 10000 && !arr[2*j-i] && isPerm(i, 2*j-i) {
print(i)
print(j)
print(2*j - i)
break outer
}
}
}
println()
}
func isPerm(i1, i2 int) bool {
s1, s2 := strconv.Itoa(i1), strconv.Itoa(i2)
for i := 0; i < len(s1); i++ {
//we need a cross check for repetition of numbers like in 1049 1499 comparison
if !strings.Contains(s1, s2[i:i+1]) || !strings.Contains(s2, s1[i:i+1]) {
return false
}
}
return true
}
package main
var primes []int
func main() {
arr := make([]bool, 1000000)
arr[0], arr[1] = true, true
count := 2
prime := 3
var k int
finished := false
for !finished {
for k = 2 * prime; k < len(arr); k += prime {
arr[k] = true
}
for k = prime + 2; k < len(arr) && arr[k]; k += 2 {
}
if k < len(arr) {
prime = k
count++
} else {
finished = true
}
}
primes = make([]int, count)
index := 1
primes[0] = 2
for i := 0; i < len(arr); i++ {
if !arr[i] && i%2 != 0 {
primes[index] = i
index++
}
}
answer := 0
maxCount := 0
var tmp int
for i := range primes {
tmp = primes[i]
count = 0
inner2:
for j := i + 1; j < len(primes); j++ {
tmp += primes[j]
count++
if tmp > len(arr)-1 {
break inner2
}
if tmp%2 != 0 && !arr[tmp] && count > maxCount { //is prime and better result
maxCount = count
answer = tmp
}
}
}
println(answer)
}
