Buat daftar bilangan prima dengan faktor prima hingga N dalam urutan menaik

8

Untuk ndaftar yang diberikan, faktorisasi utama dari semua bilangan asli antara 1dan ndalam urutan menaik. Misalnya, untuk n= 10 hasilnya adalah:

1:
2: 2^1
3: 3^1
4: 2^2
5: 5^1
6: 2^1 3^1
7: 7^1
8: 2^3
9: 3^2
10: 2^1 5^1

Persyaratan:

  • Anda tidak bisa hanya mengulangi angka dan faktor masing-masing. (Kecuali jika Anda tahu bagaimana faktor angka dalam waktu logaritmik, dan kemudian saya ragu Anda akan membuang-buang waktu Anda memecahkan teka-teki.) Ini terlalu tidak efisien.
  • Outputnya harus seperti pada contoh di atas: Pada setiap baris nomor dan daftar faktor prima.
  • Pertimbangkan itu nbisa sangat besar, jadi mungkin tidak mungkin untuk menghasilkan semua faktorisasi ke dalam memori dan kemudian mengurutkannya di akhir. (Tetapi jika Anda memiliki solusi cerdas yang melanggar ini, posting juga.)
Petr Pudlák
sumber

Jawaban:

4

C ++

Menerapkan ayakan menggunakan bilangan prima hingga sqrt(n). Menyimpan daftar daftar tertaut untuk melacak bilangan prima mana yang membagi angka yang akan datang. Setiap kali prime pdigunakan, Factorstrukturnya akan dipindahkan pslot ke bawah daftar.

Sebagian besar waktu dihabiskan hanya printfdengan menjawab.

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

// lists of Factors represent known prime factors of a number                                                                                              
struct Factor {
  Factor(int p) : prime(p), next(NULL) { }
  int prime;
  Factor *next;
};

int main(int argc, char *argv[]) {
  long long n = atoll(argv[1]);

  // figure out the maximum prime we need to sieve with                                                                                                    
  int maxp = 1;
  while ((long long)maxp * maxp < n) maxp++;
  maxp--;

  // find next power of two up from that for our circular buffer size                                                                                      
  int size = 1;
  while (size < maxp) size *= 2;
  int mask = size - 1;

  // allocate circular buffer of lists of sieving prime factors for upcoming numbers                                                                       
  Factor **factors = new Factor*[size]();

  printf("1:\n");

  for (long long x = 2; x < n; x++) {
    Factor *list = factors[x & mask];
    factors[x & mask] = NULL; // reset so it can hold the list for x + size                                                                                

    if (!list && x <= maxp) { // x is a prime we need to sieve with - make new list with just itself                                                       
      list = new Factor(x);
    }

    // print factor list, push each Factor along to the next list.                                                                                         
    printf("%lld:", x);
    long long y = x;
    while (list) {
      Factor *f = list;
      list = f->next;
      int p = f->prime;

      // count how many factors of p are in x                                                                                                              
      int k = 1;
      y /= p;
      while (y % p == 0) {
        k++;
        y /= p;
      }
      printf(" %d^%d", p, k);

      // splice f into the list for the next number it divides                                                                                             
      long long z = x + f->prime;
      f->next = factors[z & mask];
      factors[z & mask] = f;
    }
    // remaining part of x must be prime                                                                                                                   
    if (y != 1) printf(" %lld^1", y);
    printf("\n");
  }
}
Keith Randall
sumber
4

Di bawah ini adalah usaha saya, dalam skema R5RS (disclaimer: Saya sebenarnya bukan Schemer (belum!), Jadi maafkan kode (mungkin) yang mengerikan).

(define count 10)

; `factors` is our vector of linked-lists of factors.  We're adding to these
; as we go on.
(define factors (make-vector count 'not-found))
(vector-set! factors 0 '())

; `primes-so-far` contains all the prime numbers we've discovered thus far.
; We use this list to speed up the dividing of numbers.
;   `primes-so-far-last` is a ref to the last entry in the `primes-so-far`
; list, for O(1) appending to the list.
(define primes-so-far '(dummy))
(define primes-so-far-last primes-so-far)

;; Helpers
(define (factor-ref n)
  (vector-ref factors (- n 1)))

(define (factor-cached? n)
  (not (eq? (vector-ref factors (- n 1)) 'not-found)))

(define (factor-put n factor)
  (let* ((rest        (/ n factor))
         (factor-cell (cons factor (factor-ref rest))))
    (vector-set! factors (- n 1) factor-cell)
    factor-cell))

(define (prime-append n)
  (let ((new-prime-cell (cons n '())))
    (set-cdr! primes-so-far-last new-prime-cell)
    (set!     primes-so-far-last new-prime-cell)
    new-prime-cell))

;; The factor procedure (assumes that `[1..n-1]` have already been factorized).
(define (factor n)
  (define (divides? m n)
    (= (modulo n m) 0))

  ; n       the number to factor.
  ; primes  the list of primes to try to divide with.
  (define (iter n primes)
    (cond ((factor-cached? n)
           (factor-ref n))

          ((null? primes)
           ; no primes left to divide with; n is prime.
           (prime-append n)
           (factor-put n n)) ; the only prime factor in a prime is itself

          ((divides? (car primes) n)
           (factor-put n (car primes))
           (factor-ref n))

          (else
           (iter n (cdr primes)))))

  (iter n (cdr primes-so-far)))

(define (print-loop i)
  (if (<= i count)
      (begin
        (display i)
        (display ": ")
        (display (factor i))
        (newline)
        (print-loop (+ i 1)))))

(print-loop 1)

Mencetak sebagai:

1: ()
2: (2)
3: (3)
4: (2 2)
5: (5)
6: (2 3)
7: (7)
8: (2 2 2)
9: (3 3)
10: (2 5)

(Tidak persis seperti dalam deskripsi tugas, tetapi yang harus Anda lakukan untuk mendapatkan output adalah melipat daftar dan menggabungkan pengulangan dari nomor yang sama, selama bagian output dari kode. Representasi / algoritma internal masih akan menjadi sama.)

Idenya adalah untuk menembolok nilai yang dihitung sebelumnya, tetapi menggunakan fakta bahwa faktor nadalah faktor prima pertama ndan faktor prima (n / faktor pertama). Tetapi yang terakhir sudah diketahui, jadi kami hanya menggunakan kembali daftar faktor yang sudah ada untuk jumlah yang lebih kecil. Jadi, untuk setiap angka [1..n]yang tidak prima, satu sel kontra tunggal disimpan.

Untuk setiap nomor, satu sel kontra dibuat dan disimpan. Dengan demikian, pendekatan ini harus dijalankan dengan O(n)penggunaan penyimpanan. Saya tidak tahu apakah mungkin untuk mengekspresikan kompleksitas waktu dengan rapi.

FireFly
sumber
0

C (gcc)

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

#define true 1
#define false 0

int square(int a){
	return a * a;
}

void prime_factors(int n){
	// this is an array of n elements, which will contain all found primes.
	// curprime stores the index of the last found prime, which saves us searching for where to insert the next one and things.
	int* primes = calloc(sizeof(int), n);
	int curprime = 0;

	printf("1:\n"); // Micro optimization, and rids me of the messing around that is 1.
	for(int i=2; i<=n; i++){
		// Print the current i.
		printf("%i: ",i);

		// Define val, which we'll slowly make smaller and smaller. Mwahaha.
		int val = i;
		int isprime = true;	// This will be set to false if it's divisible by any primes, which of course, means it's also not a prime.

		// Loop through primes, this loop stops if we've reached either more than sqrt(count) primes, or val is equal to zero (as such, it's fully prime factorized).
		for(int*prime_pointer = primes; val && square((int)(prime_pointer-primes)) < curprime; prime_pointer++){
			int prime = *prime_pointer;
			// if the current val is divisible by the current prime.
			while(val%prime == 0){
				isprime = false; 	// We know that this number isn't prime.
				val = val / prime;	// Divide val by it.
				printf("%i ",prime);// And write this prime.
			}
		}
		if(isprime){	// If this number is a prime.
			printf("%i ",i);	// Append it to its own list.
			primes[curprime++] = i;	// And append this new prime to our list of primes.
		}
		printf("\n");	// Terminate the line with a newline. Duh...
	}
}

int main(int argc, char** argv){
	prime_factors(1000);
}

Menentukan fungsi prime_factorsyang mengambil integer ndan output melalui printf dalam format berikut:

1:
2: 2 
3: 3 
4: 2 2 
5: 5 
6: 2 3 
7: 7 
8: 2 2 2 
9: 3 3 
10: 2 

Ini menggunakan O (n) memori tambahan, dan saya tidak yakin kompleksitas waktunya.

Cobalah online!

ATaco
sumber