पहले n अभाज्य संख्याओं के योग की गणना कीजिए

16

मुझे आश्चर्य है कि यह चुनौती पहले से ही यहाँ नहीं है, क्योंकि यह इतना स्पष्ट है। (या मुझे आश्चर्य है कि मैं इसे नहीं ढूंढ सका और कोई भी इसे डुप्लिकेट के रूप में चिह्नित करेगा।)

कार्य

एक गैर-नकारात्मक पूर्णांक को देखते हुए n, पहले n के योग की गणना करेंn primes और इसे आउटपुट करें।

उदाहरण 1

के लिए n=5 , पहले पांच अभाज्य संख्या हैं:

  • 2
  • 3
  • 5
  • 7
  • 1 1

इन संख्याओं का योग 2+3+5+7+11=28 , इसलिए कार्यक्रम को आउटपुट करना है 28।

उदाहरण # 2

के लिए , "पहले शून्य" अभाज्य संख्या से कोई भी कर रहे हैं। और बिना संख्या का योग निश्चित रूप से है - 0n=00 ।

नियम

  • अगर नंबर प्राइम है तो आप यह जांचने के लिए बिल्ट-इन का उपयोग कर सकते हैं।
  • यह कोड-गोल्फ है , इसलिए प्रत्येक भाषा में सबसे कम बाइट्स जीतती है!
code-golf  primes 
— xanoetux
स्रोत
— केविन क्रूज़सेन
4
— जोनाथन एलन
2
OEIS - A7504 (एक तरफ: LOL इस पर सूत्र अनुभाग में, "n (n) = A033286 (n) - A152535 (n)।")
— जोनाथन एलन
@JonathanAllan: संबंधित, लेकिन समकक्ष नहीं। मुझे लगता है कि अगर आप रेंज में primes या कई primes की जांच करते हैं तो यह एक महत्वपूर्ण अंतर है। यदि दोनों कार्यों में आम बात है तो) अगर कोई संख्या प्रधान है और b) संख्याओं की जाँच करें - जो कि कई कोड-गोल्फ कार्यों के लिए सामान्य है।
— xanoetux
3
— लकोनी

जवाबों:

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(Accu रजिस्टर) में राशि लौटाता है ।

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
मुझे गोल्फ भाषाओं की निरंतर धारा से इतना अधिक आनंद मिलता है (मैं आज एमओएस 6502 टी-शर्ट नहीं पहन सकता हूं या नहीं भी कर सकता हूं)।
— मैट लेसी
1
@MattLacey धन्यवाद :) मैं इन सभी भाषाओं को सीखने के लिए बहुत आलसी हूँ ... और 6502 कोड में कुछ पहेलियां करना "स्वाभाविक" लगता है क्योंकि अंतरिक्ष को बचाना वास्तव में उस चिप पर एक मानक प्रोग्रामिंग अभ्यास है :)
— फेलिक्स पाम्स
मुझे MOS 6502 टी-शर्ट खरीदने की जरूरत है।
— टाइटस
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पुनरावर्ती है, एक प्रारंभिक इनपुट के साथ nऔर एक पूंछ जब nशून्य तक पहुंचती है, तो उस शून्य को उपजती है (तार्किक के कारण and); nजब भी t, एक परीक्षण संख्या जो प्रत्येक कॉल के साथ वृद्धि होती है f, तो यह प्रमुख है। मुख्य परीक्षण तो यह है कि क्या जिसके लिए हम गुट के एक वर्ग का ट्रैक रखते हैं।(n-1)! ≡ -1(आधुनिकn)p

— जोनाथन एलन
स्रोत
मैं लिन के सामान्य सहायक कार्यों में से एक को अपना रहा था और ठीक उसी चीज को हासिल किया।
— श्री Xcoder
... आह तो प्रमेय xnor द्वारा साइट के लिए पेश किया गया था। अच्छा संदर्भ पोस्ट, धन्यवाद!
— जोनाथन एलन
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

ब्रेकीलॉग , 8 7 बाइट्स

~lṗᵐ≠≜+

इसे ऑनलाइन आज़माएं!

@ बन्दर को 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
— Fatalize
स्रोत
~lṗᵐ≠≜+7 बाइट्स के लिए काम करने लगता है (इसके अलावा, मैं उत्सुक हूं कि यह आउटपुट 2 * इनपुट + 1 देता है यदि लेबलिंग के बिना चलाया जाता है।)
— sundar -
2
@sundar मैंने डिबगर का उपयोग करके जाँच की और पाया कि क्यों: यह primes के लिए मूल्यों का चयन नहीं करता है, लेकिन यह अभी भी जानता है कि हर एक को [2,+inf)स्पष्ट रूप से होना चाहिए । इसलिए, यह जानता है कि 5 primes (यदि इनपुट 5 है) का योग कम से कम होना चाहिए 10, और यह आंशिक रूप से जानता है कि क्योंकि तत्वों को अलग होना चाहिए, वे सभी 2 नहीं हो सकते हैं इसलिए यह कम से कम है 11। टीएल; डीआर के कार्यान्वयन निहित labellization काफी मजबूत नहीं है।
— घातक
यह तो बहुत ही मज़ेदार है। मुझे पसंद है कि कैसे कारण कुछ वाक्यविन्यास या कार्यान्वयन की यादृच्छिक दुर्घटना नहीं है, लेकिन कुछ ऐसा है जो बाधाओं के आधार पर समझ में आता है। इसे देखने के लिए धन्यवाद!
— सूंदर -
2

रेटिना , 41 बाइट्स

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

_

इसे ऑनलाइन आज़माएं! मैं 1 जोड़ना चाहता था जब तक कि मुझे nप्राइम्स नहीं मिला था, लेकिन मैं यह काम नहीं कर सकता था कि रेटिना में ऐसा कैसे करूं, इसलिए मैंने एक नटखट लूप का सहारा लिया। स्पष्टीकरण:

K`_

1 से शुरू करें।

"$+"{`

लूप nसमय।

$
$%"_

पिछले मूल्य की एक प्रति बनाएँ, और इसे बढ़ाएँ।

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

समग्र होने पर इसे बढ़ाते रहें। ( )बाहरी लूप को बंद कर देता है।)

^_

मूल को हटाएं 1 ।

_

योग करें और दशमलव में परिवर्तित करें।

— नील
स्रोत
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;
— टाइटस
2

हास्केल , 48 बाइट्स

sum.(`take`[p|p<-[2..],all((>0).mod p)[2..p-1]])

इसे ऑनलाइन आज़माएं!

ध्यान दें: \p-> all((>0).mod p)[2..p-1] एक वैध प्रधानमंत्री की जांच नहीं है, क्योंकि यह है Trueके लिए0,1भी। लेकिन हम शुरुआत से ही इसके आसपास काम कर सकते हैं2, तो इस मामले में यह पर्याप्त है।

— ბიმო
स्रोत
2

सी, सी ++, डी: 147 142 बाइट्स

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

सी और सी ++ के लिए 5 बाइट्स अनुकूलन:

-2 बाइट्स Zacharý की बदौलत

#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 पहले संख्याओं को जमा करता है

परीक्षण के लिए प्रयुक्त कोड:

सी / सी ++:

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

D जचार्जी , 133 द्वारा अनुकूलित उत्तर 131 बाइट्स

डी में एक गोल्फ टेम्प्लेट सिस्टम है

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;}
— HatsuPointerKun
स्रोत
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 ++ ऑप्टिमाइज़ेशन के साथ ही, बस एल्गोरिथ्म
— एबिट को
हो सकता है कि सभी उत्तर के लिए, आप अल्पविराम का उपयोग करने के लिए कर सकता है {c+=v;--n;}हो सकता है c+=v,--n;?
— 15
यहाँ D के लिए एक और एक है (और संभवतः C / C ++ के लिए भी, यदि वापस ints पर वापस लौटा जाए ):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)...
— छत
1

एपीएल (डायलॉग यूनिकोड) , 7 + 9 = 16 बाइट्स

+/pco∘⍳

इसे ऑनलाइन आज़माएं!

pco(और हर दूसरे) Dfn आयात करने के लिए 9 अतिरिक्त बाइट्स :⎕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()साथ गिना जाता है।
— ज़ाचारि
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

अजगर २ , 63 59 56 51 बाइट्स

f=lambda n:n and prime(n)+f(n-1)
from sympy import*

इसे ऑनलाइन आज़माएं!

बचाया:

  • -5 बाइट्स, जोनाथन एलन के लिए धन्यवाद

लिबास के बिना:

पायथन 2 , 83 बाइट्स

n,s=input(),0
x=2
while n:
 if all(x%i for i in range(2,x)):n-=1;s+=x
 x+=1
print s

इसे ऑनलाइन आज़माएं!

— TFeld
स्रोत
f=lambda n:n and prime(n)+f(n-1)पाँच बचाता है (यह आगे भी गोल्फ हो सकता है)
— जोनाथन एलन
0

सीजेएम , 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

इसे ऑनलाइन आज़माएं!

— lolad
स्रोत
0

एफ #, 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 ।

Seq.filter केवल उन अनुक्रमों का चयन करता है जो अनंत अनुक्रम द्वारा बनाए गए होते हैं, जो अभाज्य होते हैं।

Seq.take पहले लेता है nउस क्रम में तत्व ।

और अंत में, Seq.sumउन्हें रकम देता है।

— Ciaran_McCarthy
स्रोत
0

MY , 4 बाइट्स

⎕ṀΣ↵

इसे ऑनलाइन आज़माएं!

फिर भी इस कचरा भाषा में कोई निहित इनपुट / आउटपुट पछतावा नहीं है, अन्यथा दो बाइट होगा।

  • ⎕ = इनपुट
  • Ṁ = प्रथम ... nth प्रधान समावेशी
  • Σ = योग
  • ↵ = आउटपुट
— जाकारी
स्रोत
0

एपीएल (एनएआरएस), 27 चार्ट, 54 बाइट्स

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

{{2 from} यहाँ n प्रधानमंत्री को 2 से अलग लौटाएगा। इसलिए {1 = 1: 2⋄¯2π⍵-1} n 2 को इसमें गिनकर लौटाएगा ...

— RosLuP
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.