SF (n) เป็นฟังก์ชั่นซึ่งคำนวณหาค่าตัวประกอบนายกที่เล็กที่สุดของตัวเลขที่กำหนด

เราจะเรียก T (N) ผลรวมของทุก SF (n) ด้วย 2 <= n <= N

T (1) = 0 (ผลรวมมากกว่า 0 สรุป)

T (2) = 2 (2 เป็นนายกคนแรก)

T (3) = 5 = 2 + 3

T (4) = 7 = 2 + 3 + 2

T (5) = 12 = 2 + 3 + 2 + 5

...

T (10000) = 5786451

ผู้ชนะจะเป็นผู้ที่จัดการคำนวณ T (N) ที่ใหญ่ที่สุดใน 60 วินาทีบนแล็ปท็อปของฉัน (Toshiba Satellite L845, Intel Core i5, RAM 8GB)

Current top score: Nicolás Siplis - 3.6e13 points - Nim

นิมิต, 3.6e13

การกรองเพียงอย่างเดียวไม่ใช่คำตอบที่ดีที่สุดเมื่อพยายามคำนวณค่า N สูงสุดที่เป็นไปได้เนื่องจากข้อกำหนดด้านหน่วยความจำสูงเกินไป นี่เป็นวิธีการที่แตกต่างกัน (เริ่มจากนิ่มเมื่อสองสามวันก่อนและตกหลุมรักกับความเร็วและไวยากรณ์คำแนะนำใด ๆ ที่จะทำให้เร็วขึ้นหรืออ่านง่ายขึ้นยินดีต้อนรับ!)

import math
import sequtils
import nimlongint # https://bitbucket.org/behrends/nimlongint/

proc s(n : int) : int128 =
    var x = toInt128(n)
    (x * x + x) div 2 - 1

proc sum_pfactor(N : int) : int128 =    
    var
        root = int(sqrt(float(N)))
        u = newSeqWith(root+1,false)
        cntA,cntB,sumA,sumB = newSeq[int128](root+1)
        pcnt,psum,ret : int128
        interval,finish,d,q,t : int

    for i in 0..root:
        cntA[i] = i-1
        sumA[i] = s(i)

    for i in 1..root:
        cntB[i] = N div i - 1
        sumB[i] = s(N div i)

    for p in 2..root:
        if cntA[p] == cntA[p-1]:
            continue

        pcnt = cntA[p - 1]
        psum = sumA[p - 1]
        q = p * p
        ret = ret + p * (cntB[p] - pcnt)
        cntB[1] = cntB[1] - cntB[p] + pcnt
        sumB[1] = sumB[1] - (sumB[p] - psum) * p
        interval = (p and 1) + 1
        finish = min(root,N div q)

        for i in countup(p+interval,finish,interval):

            if u[i]:
                continue

            d = i * p

            if d <= root:
                cntB[i] = cntB[i] - cntB[d] + pcnt
                sumB[i] = sumB[i] - (sumB[d] - psum) * p
            else:
                t = N div d
                cntB[i] = cntB[i] - cntA[t] + pcnt
                sumB[i] = sumB[i] - (sumA[t] - psum) * p

        if q <= root:
            for i in countup(q,finish-1,p*interval):
                u[i] = true

        for i in countdown(root,q-1):
            t = i div p
            cntA[i] = cntA[i] - cntA[t] + pcnt
            sumA[i] = sumA[i] - (sumA[t] - psum) * p

    sumB[1] + ret

var time = cpuTime()
echo(sum_pfactor(int(3.6e13))," - ",cpuTime() - time)

C, Prime Sieve: 5e9

ผล:

$ time ./sieve 
Finding sum of lowest divisors of n = 2..5000000000
572843021990627911

real    0m57.144s
user    0m56.732s
sys 0m0.456s 

โปรแกรม:

ในขณะที่มันเป็นโปรแกรมที่ค่อนข้างตรงไปตรงมาฉันใช้เวลาสักครู่ในการหาวิธีการจัดการหน่วยความจำที่ถูกต้อง - ฉันมี RAM เพียงพอเพียง 1 ไบต์ต่อตัวเลขในช่วงดังนั้นฉันจึงต้องระวัง มันเป็นตะแกรงมาตรฐานของ Erasthones

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<assert.h>

#define LIMIT ((unsigned long long)5e9 +1)
#define ROOT_LIMIT floor(sqrt(LIMIT))

int main()
{
    printf("Finding sum of lowest divisors of n = 2..%llu\n", LIMIT - 1);
    char * found_divisor;
    found_divisor = malloc(LIMIT * sizeof(char));
    if (found_divisor == NULL) {
        printf("Error on malloc");
        return -1;
    }
    unsigned long long i;
    unsigned long long trial_div;
    unsigned long long multiple;
    unsigned long long sum = 0;

    for (i = 0; i < LIMIT; ++i) {
        found_divisor[i] = 0;
    }

    for (trial_div = 2; trial_div <= ROOT_LIMIT; ++trial_div) {
        if (found_divisor[trial_div] == 0) {
            for (multiple = trial_div * trial_div; multiple < LIMIT; multiple += trial_div) {
                if (found_divisor[multiple] == 0) {
                    found_divisor[multiple] = 1;
                    sum += trial_div;
                }
            }
        }
    }

    for (i = 2; i < LIMIT; ++i) {
        if (found_divisor[i] == 0) {
            sum += i;
        }
    }

    free(found_divisor);
    printf("%lld\n", sum);
    return 0;
}

Perl, แฟคตอริ่งกำลังดุร้าย

use ntheory ":all";
sub T {
  my $sum=0;
  for (1..$_[0]) {
    $sum += !($_%2) ? 2 : !($_%3) ? 3 : !($_%5) ? 5 : (factor($_))[0];
  }
  $sum
}
T(90_000_000);

ฉันสามารถไปถึง 9e7 ใน 25 วินาทีบนเครื่อง Linux ของฉัน มันอาจจะเร็วขึ้นโดยการขุดลงในรหัส C เนื่องจากมันบอกว่าหลังจากตรวจสอบ 2/3/5 แล้วให้คำนึงถึงจำนวนทั้งหมด

มีวิธีที่ฉลาดกว่านี้มากในการทำเช่นนี้โดยใช้การกรอง ฉันคิดว่าวิธีเดรัจฉานบังคับง่าย ๆ น่าจะเป็นการเริ่มต้น นี่เป็นปัญหาของโครงการออยเลอร์ 521 โดยวิธี

ไป 21e9

ไม่ตะแกรงเพื่อค้นหาปัจจัยขั้นต่ำของแต่ละหมายเลข <= N วางไข่ goroutines เพื่อนับส่วนของพื้นที่หมายเลข

เรียกใช้ด้วย "go run prime.go -P 4 -N 21000000000"

package main

import (
    "flag"
    "fmt"
    "runtime"
)

const S = 1 << 16

func main() {
    var N, P int
    flag.IntVar(&N, "N", 10000, "N")
    flag.IntVar(&P, "P", 4, "number of goroutines to use")
    flag.Parse()
    fmt.Printf("N = %d\n", N)
    fmt.Printf("P = %d\n", P)
    runtime.GOMAXPROCS(P)

    // Spawn goroutines to check sections of the number range.
    c := make(chan uint64, P)
    for i := 0; i < P; i++ {
        a := 2 + (N-1)*i/P
        b := 2 + (N-1)*(i+1)/P
        go process(a, b, c)
    }
    var sum uint64
    for i := 0; i < P; i++ {
        sum += <-c
    }
    fmt.Printf("T(%d) = %d\n", N, sum)
}

func process(a, b int, res chan uint64) {
    // Find primes up to sqrt(b).  Compute starting offsets.
    var primes []int
    var offsets []int
    for p := 2; p*p < b; p++ {
        if !prime(p) {
            continue
        }
        primes = append(primes, p)
        off := a % p
        if off != 0 {
            off = p - off
        }
        offsets = append(offsets, off)
    }

    // Allocate sieve array.
    composite := make([]bool, S)

    // Check factors of numbers up to b, a block of S at a time.
    var sum uint64
    for ; a < b; a += S {
        runtime.Gosched()
        // Check divisibility of [a,a+S) by our set of primes.
        for i, p := range primes {
            off := offsets[i]
            for ; off < S; off += p {
                if composite[off] {
                    continue // Divisible by a smaller prime.
                }
                composite[off] = true
                if a+off < b {
                    sum += uint64(p)
                }
            }
            // Remember offset for next block.
            offsets[i] = off - S
        }
        // Any remaining numbers are prime.
        for i := 0; i < S; i++ {
            if composite[i] {
                composite[i] = false // Reset for next block.
                continue
            }
            if a+i < b {
                sum += uint64(a + i)
            }
        }
    }
    res <- sum
}

func prime(n int) bool {
    for i := 2; i*i <= n; i++ {
        if n%i == 0 {
            return false
        }
    }
    return true
}

โปรดทราบว่าคำตอบสำหรับ N = 21e9 อยู่ระหว่าง 2 ^ 63 และ 2 ^ 64 ดังนั้นฉันต้องใช้ int 64- บิตที่ไม่ได้ลงชื่อเพื่อนับอย่างถูกต้อง ...

C ++, 1 << 34 ~ 1.7e10

Intel(R) Core(TM) i5-2410M CPU @ 2.30GHz

$ g++ -O2 test3.cpp 
$ time ./a.out 
6400765038917999291

real    0m49.640s
user    0m49.610s
sys 0m0.000s

#include <iostream>
#include <vector>

using namespace std;

const long long root = 1 << 17; // must be a power of two to simplify modulo operation
const long long rootd2 = root >> 1;
const long long rootd2m1 = rootd2 - 1;
const long long mult = root; // must be less than or equal to root
const long long n = root * mult; // unused constant (function argument)

int main() {
  vector < int > sieve(rootd2, 0);
  vector < int > primes;
  vector < long long > nexts;
  primes.reserve(root);
  nexts.reserve(root);
  // initialize sum with result for even numbers
  long long sum = n / 2 * 2;
  // sieve of Erathosthenes for numbers less than root
  // all even numbers are skipped
  for(long long i = 1; i < rootd2; ++i){
    if(sieve[i]){
      sieve[i] = 0;
      continue;
    }
    const long long val = i * 2 + 1;
    primes.push_back(val);
    sum += val;
    long long j;
    for(j = (val + 1) * i; j < rootd2; j += val){
      sum += val * (1 - sieve[j]); // conditionals replaced by multiplication
      sieve[j] = 1;
    }
    nexts.push_back(j);
  }
  int k = primes.size();
  long long last = rootd2;
  // segmented sieve of Erathosthenes
  // all even numbers are skipped
  for(int segment = 2; segment <= mult; ++segment){
    last += rootd2;
    for(int i = 0; i < k; ++i){
      long long next = nexts[i];
      long long prime = primes[i];
      if(next < last){
        long long ptr = next & rootd2m1; // modulo replaced by bitmasking
        while(ptr < rootd2){
          sum += prime * (1 - sieve[ptr]); // conditionals replaced by multiplication
          sieve[ptr] = 1;
          ptr += prime;
        }
        nexts[i] = (next & ~rootd2m1) + ptr;
      }
    }
    for(int i = 0; i < rootd2; ++i){
      sum += ((segment - 1) * root + i * 2 + 1) * (1 - sieve[i]);
      sieve[i] = 0;
    }
  }
  cout << sum << endl;
}

Java 8: 1.8e8 2.4e8

รายการนี้ไม่ได้เปรียบเทียบกับคนอื่น ๆ หลายคนแล้ว แต่ฉันต้องการที่จะโพสต์คำตอบของฉันเพราะฉันสนุกกับการทำงานนี้

การเพิ่มประสิทธิภาพหลักของวิธีการของฉันมีดังนี้:

• เลขคู่ทุกตัวมีตัวคูณที่เล็กที่สุด 2 ดังนั้นสามารถเพิ่มได้ฟรีหลังจากประมวลผลทุกเลขคู่ โดยทั่วไปถ้าคุณได้ทำผลงานในการคำนวณT(N)เมื่อคุณรู้ว่าN % 2 == 1 T(N + 1) == T(N) + 2สิ่งนี้ทำให้ฉันเริ่มนับที่สามและเพิ่มขึ้นซ้ำสองครั้ง
• ฉันเก็บหมายเลขเฉพาะของฉันไว้ในอาร์เรย์เมื่อเทียบกับCollectionประเภท นี่มากกว่าสองเท่าที่Nฉันสามารถเข้าถึงได้
• ฉันใช้ตัวเลขเฉพาะเพื่อแยกแยะตัวเลขแทนการแสดง Sieve of Eratosthenes ซึ่งหมายความว่าที่เก็บข้อมูลหน่วยความจำของฉันถูก จำกัด เกือบทั้งหมดในอาร์เรย์ช่วงเวลาของฉัน
• ฉันเก็บสแควร์รูทของจำนวนที่ฉันพยายามหาปัจจัยที่เล็กที่สุด ฉันได้ลองวิธีการของ @ user1354678 ในการหาปัจจัยสำคัญในแต่ละครั้ง แต่สิ่งนี้ทำให้ฉันเสียค่าใช้จ่ายประมาณ 1e7 จากคะแนนของฉัน

นั่นคือทั้งหมดที่เกี่ยวกับมัน รหัสของฉันวนซ้ำจาก 3 วันโดย twos จนกว่าจะตรวจพบว่ามีการกดหรือเกินขีด จำกัด เวลา ณ จุดนั้นมันจะแยกคำตอบออก

package sum_of_smallest_factors;

public final class SumOfSmallestFactors {
    private static class Result {
        private final int number;
        int getNumber() {
            return number;
        }

        private final long sum;
        long getSum() {
            return sum;
        }


        Result(int number, long sum) {
            this.number = number;
            this.sum = sum;
        }
    }


    private static final long TIME_LIMIT = 60_000_000_000L; // 60 seconds x 1e9 nanoseconds / second


    public static void main(String[] args) {
        SumOfSmallestFactors main = new SumOfSmallestFactors();
        Result result = main.run();
        int number = result.getNumber();
        long sum = result.getSum();
        System.out.format("T(%,d) = %,d\n", number, sum);
    }


    private int[] primes = new int[16_777_216];
    private int primeCount = 0;
    private long startTime;


    private SumOfSmallestFactors() {}

    private Result run() {
        startClock();
        int number;
        long sumOfSmallestFactors = 2;
        for (number = 3; mayContinue(); number += 2) {
            int smallestFactor = getSmallestFactor(number);
            if (smallestFactor == number) {
                addPrime(number);
            }
            sumOfSmallestFactors += smallestFactor + 2;
        }
        --number;

        Result result = new Result(number, sumOfSmallestFactors);
        return result;
    }

    private void startClock() {
        startTime = System.nanoTime();
    }

    private boolean mayContinue() {
        long currentTime = System.nanoTime();
        long elapsedTime = currentTime - startTime;
        boolean result = (elapsedTime < TIME_LIMIT);
        return result;
    }

    private int getSmallestFactor(int number) {
        int smallestFactor = number;
        int squareRoot = (int) Math.ceil(Math.sqrt(number));

        int index;
        int prime = 3;
        for (index = 0; index < primeCount; ++index) {
            prime = primes[index];

            if (prime > squareRoot) {
                break;
            }

            int remainder = number % prime;
            if (remainder == 0) {
                smallestFactor = prime;
                break;
            }
        }

        return smallestFactor;
    }

    private void addPrime(int prime) {
        primes[primeCount] = prime;
        ++primeCount;
    }
}

ทำงานบนระบบที่แตกต่างกัน (Windows 8.1, Intel core i7 @ 2.5 GHz, 8 GB RAM) ด้วย Java 8 รุ่นล่าสุดมีผลลัพธ์ที่ดีกว่าอย่างเห็นได้ชัดโดยไม่มีการเปลี่ยนแปลงรหัส:

T(240,308,208) = 1,537,216,753,010,879

R, 2.5e7

ตะแกรงที่เรียบง่ายที่มีใจรักของ Eratosthenes, vectorised ให้มากที่สุด R ไม่ได้ออกแบบมาสำหรับปัญหาแบบนี้จริง ๆ และฉันค่อนข้างมั่นใจว่าสามารถทำได้เร็วขึ้น

MAX <- 2.5e7
Tot <- 0
vec <- 2:MAX 
while(TRUE) {
    if (vec[1]*vec[1] > vec[length(vec)]) {
        Tot <- Tot + sum(as.numeric(vec))
        break
    }

    fact <- which(vec %% vec[1] == 0)
    Tot <- Tot + vec[1]*length(vec[fact])
    vec <- vec[-fact]
}
Tot

Python ~ 7e8

ใช้ตะแกรงที่เพิ่มขึ้นของ Erathostenes การดูแลบางอย่างจำเป็นต้องดำเนินการว่าค่าที่ทำเครื่องหมายไว้นั้นถูกทำเครื่องหมายด้วยตัวหารต่ำสุด แต่การดำเนินการนั้นค่อนข้างตรงไปตรงมา

กำหนดเวลาถ่ายด้วย PyPy 2.6.0 อินพุตยอมรับว่าเป็นอาร์กิวเมนต์บรรทัดคำสั่ง

from sys import argv
from math import sqrt

n = int(argv[1])
sieve = {}
imax = int(sqrt(n))

t = n & -2
i = 3
while i <= n:
  divs = sieve.pop(i, [])
  if divs:
    t += divs[-1]
    for v in divs:
      sieve.setdefault(i+v+v, []).append(v)
  else:
    t += i
    if i <= imax: sieve[i*i] = [i]
  i += 2

print t

ตัวอย่างการใช้งาน

$ pypy sum-lpf.py 10000
5786451

$ pypy sum-lpf.py 100000000
279218813374515

Julia, 5e7

แน่นอนจูเลียทำได้ดีกว่านี้ แต่นี่คือสิ่งที่ฉันมีในตอนนี้ นี่ใช้เวลา 5e7 ในเวลาประมาณ 60 วินาทีบน JuliaBox แต่ฉันยังไม่สามารถทดสอบในพื้นที่ได้ หวังว่าในตอนนั้นฉันจะนึกถึงวิธีที่ฉลาดกว่านี้

const PRIMES = primes(2^16)

function lpf(n::Int64)
    isprime(n) && return n
    for p in PRIMES
        n % p == 0 && return p
    end
end

function T(N::Int64)
    local x::Int64
    x = @parallel (+) for i = 2:N
        lpf(i)
    end
    x
end

ที่นี่เรากำลังสร้างฟังก์ชั่นlpfที่วนซ้ำตามลำดับและตรวจสอบอินพุตสำหรับการหารโดยแต่ละอัน ฟังก์ชั่นส่งกลับตัวหารแรกที่พบดังนั้นจึงได้รับปัจจัยสำคัญอย่างน้อยที่สุด

ฟังก์ชั่นหลักคำนวณlpfจำนวนเต็มตั้งแต่ 2 ถึงอินพุตแบบขนานและลดผลลัพธ์ด้วยการรวม

เสียงกระเพื่อมสามัญ, 1e7

(defvar input 10000000)
(defvar numbers (loop for i from 2 to input collect i))
(defvar counter)
(defvar primes)

(setf primes (loop for i from 2 to (floor (sqrt input))
    when (loop for j in primes
        do (if (eq (mod i j) 0) (return nil))
        finally (return t))
    collect i into primes
    finally (return primes)))

(format t "~A~%"    
    (loop for i in primes
        do (setf counter 0)
        summing (progn (setf numbers (remove-if #'(lambda (x) (if (eq (mod x i) 0) (progn (incf counter) t))) numbers))
                (* i counter)) into total
        finally (return (+ total (reduce #'+ numbers)))))

ฉันเลือกที่จะสร้างรายการหมายเลขเฉพาะตั้งแต่แรกถึง 2 (sqrt input)จากนั้นทดสอบทุกค่าด้วยจำนวนเฉพาะในขณะที่ก่อนหน้านี้ฉันจะทดสอบกับทุกหมายเลขจนถึง(sqrt input)ซึ่งจะไม่มีจุดหมาย (เช่นถ้าจำนวนหารด้วย 4 มันหารด้วย 2 ได้ดังนั้นจึงเป็นสัดส่วนแล้ว)

ขอบคุณพระเจ้าสำหรับผลข้างเคียงในขณะที่ฉันอยู่ที่นี่ การลบถ้าทั้งคู่ลดขนาดของรายการและนับจำนวนองค์ประกอบที่ถูกลบออกไปดังนั้นฉันต้องคูณมันด้วยค่าอะไรก็ตามที่ลูปเปิดอยู่และเพิ่มเข้าไปในผลรวมสะสม

(ความจริงสนุก: deleteมันเทียบเท่าได้กับการทำลายล้างremoveแต่ไม่ว่าด้วยเหตุผลใดก็ตามdeleteจะช้ากว่าremoveในทุกกรณี)

สนิม 1.5e9

Eratosthene ที่ไร้เดียงสามาก แต่ฉันรู้สึกว่า Rust ไม่ได้รับความรักใด ๆ ที่นี่!

// Expected (approximate) number of primes
fn hint(n:usize) -> usize {
    if n < 2 { 
        1
    } else {
        n / ((n as f64).ln() as usize) + 1
    }
}

fn main() {
    let n:usize = match std::env::args().nth(1) {
        Some(s) => s.parse().ok().expect("Please enter a number !"),
        None => 10000,
    };
    let mut primes = Vec::with_capacity(hint(n));
    let mut sqrt = 2;
    let s = (2..).map(|n:u32| -> u32 {
        if (sqrt * sqrt) < n {
            sqrt += 1;
        }
        let (div, unseen) = match primes.iter().take_while(|&p| *p <= sqrt).filter(|&p| n % p == 0).next() {
            Some(p) => (*p, false),
            None => (n, true),
        };
        if unseen {
            primes.push(div);
        }
        div
    }).take(n-1).fold(0, |acc, p| acc + p);
    println!("{}", s);
}

Java 2.14e9

ตะแกรงบริสุทธิ์ของ Eratosthenes พร้อมประโยชน์จาก BitSet

ผมได้คำนวณผลรวมขนาดเล็กที่สุดในปัจจัยที่นายกรัฐมนตรีไม่เกินเพียงแค่ในInteger.MAX_VALUE - 1 33.89 sแต่ฉันไม่สามารถดำเนินการใด ๆ ที่มีขนาดใหญ่กว่าได้อีกเพราะจะนำไปสู่การรวมตัวเกินจำนวนเต็มบนขนาดของบิตเซ็ต ดังนั้นฉันจึงพยายามสร้าง Bitset อีกชุดสำหรับ Ranges ชุดถัดไป จนถึงตอนนี้เป็นวิธีที่เร็วที่สุดที่ฉันสามารถสร้างได้

T(214,74,83,646) = 109931450137817286 in 33.89 s
aka
T(2,147,483,646) = 109931450137817286 in 33.89 s

import java.util.BitSet;

public class SmallPrimeFactorSum {

    static int    limit     = Integer.MAX_VALUE - 1;

    // BitSet is highly efficient against boolean[] when Billion numbers were involved
    // BitSet uses only 1 bit for each number
    // boolean[] uses 8 bits aka 1 byte for each number which will produce memory issues for large numbers
    static BitSet primes    = new BitSet(limit + 1);
    static int    limitSqrt = (int) Math.ceil(Math.sqrt(limit));

    static long   start     = System.nanoTime();

    static long   sum       = 0;

    public static void main(String[] args) {
        genPrimes();
    }

    // Generate Primes by Sieve of Eratosthenes
    // Sieve of Eratosthenes is much efficient than Sieve of Atkins as
    // Sieve of Atkins involes Division, Modulus, Multiplication, Subtraction, Addition but
    // Sieve of Eratosthenes involves only addition
    static void genPrimes() {

        // Inverse the Bit values
        primes.flip(0, limit + 1);

        // Now all Values in primes will now be true,
        // True  represents     prime number 
        // False represents not prime number

        // Set 0 and 1 as not Prime number
        primes.clear(0, 2);

        // Set all multiples of each Prime as not Prime;
        for ( int prime = 2; prime > 0 && prime <= limit && prime > 0; prime = primes.nextSetBit(prime + 1) ) {
            // Add Current Prime as its Prime factor
            sum += prime;
            // Skip marking if Current Prime > SQRT(limit)
            if ( prime > limitSqrt ) {
                continue;
            }
            // Mark Every multiple of current Prime as not Prime
            for ( int multiple = prime + prime; multiple <= limit && multiple > 0; multiple += prime ) {
                // Mark as not Prime only if it's true already
                if ( primes.get(multiple) ) {
                    // Add Current Prime as multiple's Prime factor
                    sum += prime;
                    primes.clear(multiple);
                }
            }
        }

        System.out.printf("T(%d) = %d in %.2f s", limit, sum, (System.nanoTime() - start) / 1000000000.0);
        //System.out.printf("Total Primes upto %d : %d\n", limit, primes.cardinality());
    }

}