첫 n 개의 소수의 합을 계산


15

이 도전이 아직 명확하지 않기 때문에 아직 여기에 없다는 것이 놀랍습니다. (또는 나는 그것을 찾을 수 없으며 아무도 그것을 복제본으로 표시 할 것입니다.

직무

음수가 아닌 정수 주어지면 처음 소수 의 합을 계산하여 출력하십시오.nnn

실시 예 # 1

들면 , 제 다섯 개 소수이다 :n=5

  • 2
  • 5
  • 7
  • 11

이 숫자의 합은 이므로 프로그램은 을 출력해야합니다 .282+3+5+7+11=2828

실시 예 # 2

내용 은 "제 제로"소수가 하나도 없다. 그리고 숫자가없는 합은 물론 입니다.0n=00

규칙

  • 예를 들어 숫자가 소수인지 확인하기 위해 내장 기능을 사용할 수 있습니다.
  • 이것은 이므로 각 언어에서 가장 적은 바이트 수가 이깁니다!



2
OEIS-A7504 (제외 : "a (n) = A033286 (n)-A152535 (n)."섹션의 LOL :
Jonathan Allan

@JonathanAllan : 관련이 있지만 동일하지는 않습니다. 범위 또는 소수의 소수를 확인하면 중요한 차이점이라고 생각합니다. 두 작업이 공통적으로 갖는 것은 a) 숫자가 소수인지 확인하고 b) 숫자를 요약합니다. 여기에서 많은 코드 골프 작업에 공통입니다.
xanoetux

답변:


15

6502 머신 코드 루틴, 75 바이트

A0 01 84 FD 88 84 FE C4 02 F0 32 E6 FD A0 00 A5 FD C9 04 90 1F 85 64 B1 FB 85
65 A9 00 A2 08 06 64 2A C5 65 90 02 E5 65 CA D0 F4 C9 00 F0 DC C8 C4 FE D0 DB
A5 FD A4 FE 91 FB C8 D0 C8 A9 00 18 A8 C4 FE F0 05 71 FB C8 D0 F7 60

$fb/의 일부 임시 저장소 $fc와 요약 할 소수 의 포인터를 예상합니다 $2. 합계를 A(아큐 레지스터) 반환합니다 .

6502 머신 코드에서 프라임 검사를 수행하지 않았으므로 여기에 마침내옵니다.)

입력> = 14이 때문에 오버 플로우의 인 코드는 8 비트 플랫폼의 "자연"번호 범위와 작동에 대한 잘못된 결과를 제공이 시작 주 0 - 255에 대한 서명을 .

주석 처리 된 분해

; function to sum the first n primes
;
; input:
;   $fb/$fc: pointer to a buffer for temporary storage of primes
;   $2:      number of primes to sum (n)
; output:
;   A:       sum of the first n primes
; clobbers:
;   $fd:     current number under primality test
;   $fe:     number of primes currently found
;   $64:     temporary numerator for modulo check
;   $65:     temporary divisor for modulo check
;   X, Y
 .primesum:
A0 01       LDY #$01            ; init variable for ...
84 FD       STY $FD             ; next prime number to test
88          DEY                 ; init number of found primes
 .mainloop:
84 FE       STY $FE             ; store current number of found primes
C4 02       CPY $02             ; compare with requested number
F0 32       BEQ .sum            ; enough primes -> calculate their sum
 .mainnext:
E6 FD       INC $FD             ; check next prime number
A0 00       LDY #$00            ; start check against first prime number
 .primecheckloop:
A5 FD       LDA $FD             ; load current number to check
C9 04       CMP #$04            ; smaller than 4?
90 1F       BCC .isprime        ; is a prime (shortcut to get list started)
85 64       STA $64             ; store to temp as numerator
B1 FB       LDA ($FB),Y         ; load from prime number table
85 65       STA $65             ; store to temp as divisor
A9 00       LDA #$00            ; init modulo to 0
A2 08       LDX #$08            ; iterate over 8 bits
 .bitloop:
06 64       ASL $64             ; shift left numerator
2A          ROL A               ; shift carry into modulo
C5 65       CMP $65             ; compare with divisor
90 02       BCC .bitnext        ; smaller -> to next bit
E5 65       SBC $65             ; otherwise subtract divisor
 .bitnext:
CA          DEX                 ; next bit
D0 F4       BNE .bitloop
C9 00       CMP #$00            ; compare modulo with 0
F0 DC       BEQ .mainnext       ; equal? -> no prime number
C8          INY                 ; next index in prime number table
C4 FE       CPY $FE             ; checked against all prime numbers?
D0 DB       BNE .primecheckloop ; no -> check next
 .isprime:
A5 FD       LDA $FD             ; prime found
A4 FE       LDY $FE             ; then store in table
91 FB       STA ($FB),Y
C8          INY                 ; increment number of primes found
D0 C8       BNE .mainloop       ; and repeat whole process
 .sum:
A9 00       LDA #$00            ; initialize sum to 0
18          CLC
A8          TAY                 ; start adding table from position 0
 .sumloop:
C4 FE       CPY $FE             ; whole table added?
F0 05       BEQ .done           ; yes -> we're done
71 FB       ADC ($FB),Y         ; add current entry
C8          INY                 ; increment index
D0 F7       BNE .sumloop        ; and repeat
 .done:
60          RTS

루틴을 사용하는 예제 C64 어셈블러 프로그램 :

온라인 데모

ca65 구문의 코드 :

.import primesum   ; link with routine above

.segment "BHDR" ; BASIC header
                .word   $0801           ; load address
                .word   $080b           ; pointer next BASIC line
                .word   2018            ; line number
                .byte   $9e             ; BASIC token "SYS"
                .byte   "2061",$0,$0,$0 ; 2061 ($080d) and terminating 0 bytes

.bss
linebuf:        .res    4               ; maximum length of a valid unsigned
                                        ; 8-bit number input
convbuf:        .res    3               ; 3 BCD digits for unsigned 8-bit
                                        ; number conversion
primebuf:       .res    $100            ; buffer for primesum function

.data
prompt:         .byte   "> ", $0
errmsg:         .byte   "Error parsing number, try again.", $d, $0

.code
                lda     #$17            ; set upper/lower mode
                sta     $d018

input:
                lda     #<prompt        ; display prompt
                ldy     #>prompt
                jsr     $ab1e

                lda     #<linebuf       ; read string into buffer
                ldy     #>linebuf
                ldx     #4
                jsr     readline

                lda     linebuf         ; empty line?
                beq     input           ; try again

                lda     #<linebuf       ; convert input to int8
                ldy     #>linebuf
                jsr     touint8
                bcc     numok           ; successful -> start processing
                lda     #<errmsg        ; else show error message and repeat
                ldy     #>errmsg
                jsr     $ab1e
                bcs     input

numok:          
                sta     $2
                lda     #<primebuf
                sta     $fb
                lda     #>primebuf
                sta     $fc
                jsr     primesum        ; call function to sum primes
                tax                     ; and ...
                lda     #$0             ; 
                jmp     $bdcd           ; .. print result

; read a line of input from keyboard, terminate it with 0
; expects pointer to input buffer in A/Y, buffer length in X
.proc readline
                dex
                stx     $fb
                sta     $fc
                sty     $fd
                ldy     #$0
                sty     $cc             ; enable cursor blinking
                sty     $fe             ; temporary for loop variable
getkey:         jsr     $f142           ; get character from keyboard
                beq     getkey
                sta     $2              ; save to temporary
                and     #$7f
                cmp     #$20            ; check for control character
                bcs     checkout        ; no -> check buffer size
                cmp     #$d             ; was it enter/return?
                beq     prepout         ; -> normal flow
                cmp     #$14            ; was it backspace/delete?
                bne     getkey          ; if not, get next char
                lda     $fe             ; check current index
                beq     getkey          ; zero -> backspace not possible
                bne     prepout         ; skip checking buffer size for bs
checkout:       lda     $fe             ; buffer index
                cmp     $fb             ; check against buffer size
                beq     getkey          ; if it would overflow, loop again
prepout:        sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
output:         lda     $2              ; load character
                jsr     $e716           ;   and output
                ldx     $cf             ; check cursor phase
                beq     store           ; invisible -> to store
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and show
                ora     #$80            ;   cursor in
                sta     ($d1),y         ;   current row
                lda     $2              ; load character
store:          cli                     ; enable interrupts
                cmp     #$14            ; was it backspace/delete?
                beq     backspace       ; to backspace handling code
                cmp     #$d             ; was it enter/return?
                beq     done            ; then we're done.
                ldy     $fe             ; load buffer index
                sta     ($fc),y         ; store character in buffer
                iny                     ; advance buffer index
                sty     $fe
                bne     getkey          ; not zero -> ok
done:           lda     #$0             ; terminate string in buffer with zero
                ldy     $fe             ; get buffer index
                sta     ($fc),y         ; store terminator in buffer
                sei                     ; no interrupts
                ldy     $d3             ; get current screen column
                lda     ($d1),y         ; and clear 
                and     #$7f            ;   cursor in
                sta     ($d1),y         ;   current row
                inc     $cc             ; disable cursor blinking
                cli                     ; enable interrupts
                rts                     ; return
backspace:      dec     $fe             ; decrement buffer index
                bcs     getkey          ; and get next key
.endproc

; parse / convert uint8 number using a BCD representation and double-dabble
.proc touint8
                sta     $fb
                sty     $fc
                ldy     #$0
                sty     convbuf
                sty     convbuf+1
                sty     convbuf+2
scanloop:       lda     ($fb),y
                beq     copy
                iny
                cmp     #$20
                beq     scanloop
                cmp     #$30
                bcc     error
                cmp     #$3a
                bcs     error
                bcc     scanloop
error:          sec
                rts
copy:           dey
                bmi     error
                ldx     #$2
copyloop:       lda     ($fb),y
                cmp     #$30
                bcc     copynext
                cmp     #$3a
                bcs     copynext
                sec
                sbc     #$30
                sta     convbuf,x
                dex
copynext:       dey
                bpl     copyloop
                lda     #$0
                sta     $fb
                ldx     #$8
loop:           lsr     convbuf
                lda     convbuf+1
                bcc     skipbit1
                ora     #$10
skipbit1:       lsr     a
                sta     convbuf+1
                lda     convbuf+2
                bcc     skipbit2
                ora     #$10
skipbit2:       lsr     a
                sta     convbuf+2
                ror     $fb
                dex
                beq     done
                lda     convbuf
                cmp     #$8
                bmi     nosub1
                sbc     #$3
                sta     convbuf
nosub1:         lda     convbuf+1
                cmp     #$8
                bmi     nosub2
                sbc     #$3
                sta     convbuf+1
nosub2:         lda     convbuf+2
                cmp     #$8
                bmi     loop
                sbc     #$3
                sta     convbuf+2
                bcs     loop
done:           lda     $fb
                clc
                rts
.endproc

4
나는 골프 언어의 끊임없는 흐름보다 훨씬 더 이것을 즐깁니다 (오늘 MOS 6502 티셔츠를 입었을 수도 있고 입지 않을 수도 있습니다).
Matt Lacey

1
@MattLacey thanks :) 나는이 모든 언어를 배우기에는 너무 게으르다. 그리고 6502 코드로 퍼즐을 만드는 것은 공간 절약이 실제로 그 칩의 표준 프로그래밍 관행이기 때문에 일종의 "자연 스러움"을 느낀다 :)
Felix Palmen

MOS 6502 티셔츠를 구매해야합니다.
Titus

8

파이썬 2 , 49 바이트

f=lambda n,t=1,p=1:n and p%t*t+f(n-p%t,t+1,p*t*t)

사용 윌슨의 정리 (XNOR에 의해 사이트에 소개로, 저는 믿습니다 여기 )

온라인으로 사용해보십시오!

이 함수 f는 재귀 적이며 초기 입력 이 0이고 n꼬리 n가 0에 도달하면 그 논리는 0이됩니다 and. n는를 t호출 할 때마다 증가하는 테스트 번호 f가 소수 일 때마다 감소 합니다. 프라임 테스트는 ( n - 1 ) 여부입니다 ! 1 대해 계승의 제곱을 추적합니다.(1)!  1(모드)p


Lynn의 일반적인 도우미 기능 중 하나를 수정 하고 똑같은 결과를 얻었습니다.
Mr. Xcoder

... 그래서 정리는 xnor에 의해 사이트에 소개되었습니다. 좋은 참고 게시물, 감사합니다!
Jonathan Allan



6

자바 8, 89 바이트

n->{int r=0,i=2,t,x;for(;n>0;r+=t>1?t+0*n--:0)for(t=i++,x=2;x<t;t=t%x++<1?0:t);return r;}

온라인으로 사용해보십시오.

설명:

n->{               // Method with integer as both parameter and return-type
  int r=0,         //  Result-sum, starting at 0
      i=2,         //  Prime-integer, starting at 2
      t,x;         //  Temp integers
  for(;n>0         //  Loop as long as `n` is still larger than 0
      ;            //    After every iteration:
       r+=t>1?     //     If `t` is larger than 1 (which means `t` is a prime):
           t       //      Increase `r` by `t`
           +0*n--  //      And decrease `n` by 1
          :        //     Else:
           0)      //      Both `r` and `n` remain the same
    for(t=i++,     //   Set `t` to the current `i`, and increase `i` by 1 afterwards
        x=2;       //   Set `x` to 2
        x<t;       //   Loop as long as `x` is still smaller than `t`
      t=t%x++<1?   //    If `t` is divisible by `x`:
         0         //     Set `t` to 0
        :          //    Else:
         t);       //     `t` remains the same
                   //   If `t` is still the same after this loop, it means it's a prime
  return r;}       //  Return the result-sum



5

Brachylog , 8 7 바이트

~lṗᵐ≠≜+

온라인으로 사용해보십시오!

@sundar 덕분에 1 바이트를 절약했습니다.

설명

~l        Create a list of length input
  ṗᵐ      Each element of the list must be prime
    ≠     All elements must be distinct
     ≜    Find values that match those constraints
      +   Sum

~lṗᵐ≠≜+7 바이트 동안 작동하는 것 같습니다 (또한 레이블링없이 실행하면 출력 2 * 입력 + 1을주는 이유가 궁금합니다.)
sundar-Reinstate Monica

2
@sundar 디버거를 사용하여 확인한 이유는 다음과 같습니다. 소수에 대한 값을 선택하지 않지만 모든 단일 값이 [2,+inf)분명히 있어야 함을 여전히 알고 있습니다 . 따라서 5 개의 소수 (입력이 5 인 경우)의 합은 적어도이어야하며 10부분적으로 요소가 달라야하므로 모두 2가 될 수 없으므로 적어도이어야한다는 것을 부분적으로 알고 있습니다 11. TL; 암시 적 라벨의 DR 구현은 충분히 강력하지 않습니다.
Fatalize

매우 흥미 롭습니다. 나는 그 이유가 구문의 문제 나 무작위 구현 실수가 아니라 제약 조건에 따라 의미가있는 방법을 좋아합니다. 확인해 주셔서 감사합니다!
sundar-복 직원 모니카



2

레티 나 , 41 바이트

K`_
"$+"{`$
$%"_
)/¶(__+)\1+$/+`$
_
^_

_

온라인으로 사용해보십시오! 나는 n소수를 찾을 때까지 1을 계속 추가하고 싶었지만 Retina에서 그렇게하는 방법을 찾지 못하여 중첩 루프에 의지했습니다. 설명:

K`_

1부터 시작하십시오.

"$+"{`

루프 n타임.

$
$%"_

이전 값의 사본을 작성하고 늘리십시오.

)/¶(__+)\1+$/+`$
_

합성하는 동안 계속 증가 시키십시오. ( )외부 루프가 닫힙니다.)

^_

원본을 삭제하십시오 1.

_

합계하고 10 진수로 변환합니다.



2

PHP, 66 바이트

내 자신의 주요 기능을 다시 사용하여 ...

for(;$k<$argn;$i-1||$s+=$n+!++$k)for($i=++$n;--$i&&$n%$i;);echo$s;

파이프로 실행 -nr하거나 온라인으로 사용해보십시오 .

고장

for(;$k<$argn;      # while counter < argument
    $i-1||              # 3. if divisor is 1 (e.g. $n is prime)
        $s+=$n              # add $n to sum
        +!++$k              # and increment counter
    )
    for($i=++$n;        # 1. increment $n
        --$i&&$n%$i;);  # 2. find largest divisor of $n smaller than $n:
echo$s;             # print sum

같은 길이, 하나의 변수 적은 :for(;$argn;$i-1||$s+=$n+!$argn--)for($i=++$n;--$i&&$n%$i;);echo$s;
Titus



2

C, C ++, D : 147142 바이트

int p(int a){if(a<4)return 1;for(int i=2;i<a;++i)if(!(a%i))return 0;return 1;}int f(int n){int c=0,v=1;while(n)if(p(++v)){c+=v;--n;}return c;}

C 및 C ++에 대한 5 바이트 최적화 :

Zacharý 덕분에 -2 바이트

#define R return
int p(int a){if(a<4)R 1;for(int i=2;i<a;++i)if(!(a%i))R 0;R 1;}int f(int n){int c=0,v=1;while(n)if(p(++v))c+=v,--n;R c;}

p숫자가 소수인지 테스트 f하고 n첫 번째 숫자를 합합니다.

테스트에 사용되는 코드 :

C / C ++ :

for (int i = 0; i < 10; ++i)
    printf("%d => %d\n", i, f(i));

재커리 의해 D 최적화 된 응답 , 133 131 바이트

D는 골프 템플릿 시스템을 가지고 있습니다

T p(T)(T a){if(a<4)return 1;for(T i=2;i<a;)if(!(a%i++))return 0;return 1;}T f(T)(T n){T c,v=1;while(n)if(p(++v))c+=v,--n;return c;}

1
T p(T)(T a){if(a<4)return 1;for(T i=2;i<a;)if(!(a%i++))return 0;return 1;}T f(T)(T n){T c,v=1;while(n)if(p(++v)){c+=v;--n;}return c;}. 또한 C / C ++ / D는 다음 int p(int a){if(a<4)return 1;for(int i=2;i<a;++i)if(!(a%i))return 0;return 1;}int f(int n){int c=0,v=1;while(n)if(p(++v)){c+=v;--n;}return c;}과 같습니다 (C / C ++ 최적화와 동일, 그냥 알고리즘을 조정)
Zacharý

어쩌면 모든 대답에 대해 쉼표를 사용하여 만들 {c+=v;--n;}c+=v,--n;있습니까?
Zacharý

다음은 D에 대한 또 하나입니다 int.T p(T)(T a){T r=1,i=2;for(;i<a;)r=a%i++?r:0;return r;}T f(T)(T n){T c,v=1;while(n)if(p(++v))c+=v,--n;return c;}
Zacharý

a>3&i<a대신 추천 i<a및 제거if(a<4)...
ceilingcat

2

Japt -x , 11 바이트

;@_j}a°X}hA

온라인으로 사용해보십시오!

새로운 언어 기능 덕분에 몇 바이트를 절약했습니다.

설명:

;@      }hA    :Get the first n numbers in the sequence:
     a         : Get the smallest number
      °X       : Which is greater than the previous result
  _j}          : And is prime
               :Implicitly output the sum



1

APL (Dyalog Unicode) , 7 + 9 = 16 바이트

+/pco∘⍳

온라인으로 사용해보십시오!

9 개의 추가 바이트 pco(및 기타) Dfn 을 가져 오기 :⎕CY'dfns'

어떻게:

+/pco∘⍳
        Generate the range from 1 to the argument
        Compose
  pco    P-colon (p:); without a left argument, it generates the first <right_arg> primes.
+/       Sum

또 다른 바이트를 추가하지 않아도됩니까? 파이썬의 import X(줄 바꿈) X.something()은 줄 바꿈 으로 계산됩니다.
Zacharý

1

루비, 22 + 7 = 29 바이트

다음으로 실행 ruby -rprime(+7)

->n{Prime.take(n).sum}


1

JAEL , 5 바이트

#&kȦ

설명 (자동 생성) :

./jael --explain '#&kȦ'
ORIGINAL CODE:  #&kȦ

EXPANDING EXPLANATION:
Ȧ => .a!

EXPANDED CODE:  #&k.a!,

#     ,                 repeat (p1) times:
 &                              push number of iterations of this loop
  k                             push nth prime
   .                            push the value under the tape head
    a                           push p1 + p2
     !                          write p1 to the tape head
       ␄                print machine state



0

CJam , 21 바이트

0{{T1+:Tmp!}gT}li*]:+


Explanation:
0{{T1+:Tmp!}gT}li*]:+ Original code

 {            }li*    Repeat n times
  {        }          Block
   T                  Get variable T | stack: T
    1+                Add one | Stack: T+1 
      :T              Store in variable T | Stack: T+1
        mp!           Is T not prime?     | Stack: !(isprime(T))
            g         Do while condition at top of stack is true, pop condition
             T        Push T onto the stack | Stack: Primes so far
0                 ]   Make everything on stack into an array, starting with 0 (to not throw error if n = 0)| Stack: array with 0 and all primes up to n
                   :+ Add everything in array

온라인으로 사용해보십시오!


0

F #, 111 바이트

let f n=Seq.initInfinite id|>Seq.filter(fun p->p>1&&Seq.exists(fun x->p%x=0){2..p-1}|>not)|>Seq.take n|>Seq.sum

온라인으로 사용해보십시오!

Seq.initInfinite항목 인덱스를 매개 변수로 사용하는 생성기 함수를 사용하여 무한 길이의 시퀀스를 만듭니다. 이 경우 생성기 함수는 ID 함수일뿐 id입니다.

Seq.filter 무한 시퀀스에 의해 생성 된 소수 인 숫자 만 선택합니다.

Seq.take 첫 걸음 n그 순서에서 요소를 .

그리고 마지막으로 Seq.sum그것들을 요약합니다.



0

MY , 4 바이트

⎕ṀΣ↵

온라인으로 사용해보십시오!

이 가비지 언어에서 암시 적 입력 / 출력이 여전히 유감 스럽지만 그렇지 않으면 2 바이트였습니다.

  • = 입력
  • = 첫 번째 ... n 번째 소수 포함
  • Σ = 합
  • = 출력

0

APL (NARS), 27 자, 54 바이트

{⍵=0:0⋄+/{⍵=1:2⋄¯2π⍵-1}¨⍳⍵}

{¯2π⍵}은 여기서 n과 2의 n 소수를 반환합니다. 따라서 {⍵ = 1 : 2⋄¯2π⍵-1}은 n의 소수 2를 카운트로 반환합니다 ...

당사 사이트를 사용함과 동시에 당사의 쿠키 정책개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.