Prime binari binari


19

Stiamo cercando una sequenza

Prendi i numeri naturali
1,2,3,4,5,6,7,8,9,10,11,12,13,14...

Converti in base-2
1,10,11,100,101,110,111,1000,1001,1010,1011,1100,1101,1110...

Concatena i numeri precedenti
110111001011101111000100110101011110011011110...

Suddividere questo numero in Prime-Chunks
(blocchi contenenti un numero primo di cifre) I
primi sono presi in ordine crescente2,3,5,7,11,13,17...

[11][011][10010][1110111][10001001101][0101111001101][1110...]

e trova la somma delle cifre di ogni blocco

Primes 2 3 5 7 11 13 17
Chunks [11][011][10010][1110111][10001001101][0101111001101][1110...]
SumOfDigits 2 2 2 6 5 8

La sequenza

2, 2, 2, 6, 5, 8, 9, 10, 14, 22, 11, 18, 25, 27, 32, 21, 28, 32, 40, 40, 49, 49, 32, 41, 49, 53, 63, 55, 63, 70, 87, 73, 51, 63, 71, 78, 78, 90, 107, 86, 96, 108, 115, 128, 138, 92, 83, 95, 102, 110, 130, 106, 122, 141, 149, 163, 130, 140, 151, 165, 181, 165, 204, 200, 234, 100, 130, 138, 167, 149, 169, 180, 209, 166, 189, 194, 222, 205, 234, 260, 216, 206, 217, 241, 240, 267, 289, 242, 274, 308, 286, 329, 338, 155, 189, 225, 197, 240, 272, 217, 254, 282, 287, 317, 281, 256, 299, 286, 331, 337, 316, 350, 354, 391, 367, 282, 327, 313, 364, 358, 348, 397, 406, 466 ...

La sfida

Trova il nthtermine della sequenza sopra

Ingresso

Un numero intero n>0

Casi test

1->2   
3->2    
6->8    
36->78 
60->165    
160->581     
260->1099    
350->1345

Questo è Vince la risposta più breve in byte!


2
Correlati (i primi tre passi sono gli stessi)
Laikoni,

4
Sottovalutato perché sembra troppo un mucchio di sfide unite.
Esolanging Fruit,

Risposte:


14

Buccia , 8 byte

Σ!CİpṁḋN

Provalo online!

Spiegazione

Σ!CİpṁḋN
       N   Start with the infinite list of natural numbers.
     ṁḋ    Convert each to its binary representation and join them all together. (A)
   İp      Get the infinite list of primes. (B)
  C        Split (A) into chunks of lengths (B).
 !         Retrieve the nth chunk (where n is the input).
Σ          Sum the bits in this chunk.

6

Gelatina , 12 byte

RÆNµSRBFṁRṪS

Provalo online!

Come funziona

RÆNµSRBFṁRṪS  Main link. Argument: n

R             Range; yield [1, ..., n].
 ÆN           N-th prime; yield P := [p(1), ..., p(n)].
   µ          Begin a new, monadic chain with argument P.
    S         Take the sum of P, yielding s := p(1) + ... + p(n).
     R        Range; yield [1, ..., s].
      B       Binary; convert all integers from 1 to s to base 2.
       F      Flatten the resulting array.
         R    Range; yield [[1, ..., p(1)], ..., [1, ..., p(n)]].
        ṁ     Mold; reshape the result to the left like the result to the right.
          Ṫ   Tail; take the last chunk.
           S  Take the sum, counting the set digits.

5

05AB1E , 12 byte

Codice

Può diventare piuttosto lento per grandi numeri:

ÅpDOLbJs£`SO

Utilizza la codifica 05AB1E . Provalo online!

Spiegazione

Åp              # Get a list of the first <input> primes
  DO            # Duplicate and sum the primes
    L           # Create the list [1, .., <sum>]
     bJ         # Convert to binary and join into a single string
       s£       # Get the slices [a[0:2], a[2:2+3], a[2+3:2+3+5], a[2+3+5:2+3+5+7], ...] 
                  corresponding to the list of primes
         `SO    # Get the last one and sum up it's digits



2

Gelatina , 16 byte

RBFṁ
RÆNSÇṫÆNC$S

Provalo online!

Spiegazione

RBFṁ  Helper link. Input: integer k
R     Range, [1, 2, ..., k]
 B    Convert each to a list of its binary digits
  F   Flatten
   ṁ  Shape it to length k

RÆNSÇṫÆNC$S  Main link. Input: integer n
R            Range, [1, 2, ..., n]
 ÆN          Get i'th prime for each
   S         Sum
    Ç        Call helper link
         $   Monadic chain
      ÆN       Get n'th prime
        C      Complement, 1 - n'th prime
     ṫ       Tail, take the last n'th prime digits
          S  Sum

2

R , 206 200 byte

function(n){a=p=j=y=2
for(i in 2:n-1){while(sum(y)<4*a){x=as.double(rev(intToBits(j)))
y=c(y,x[cumsum(x)>0])
j=j+1}
b=1:a
y=y[-b]
z=outer(k<-b+a,p,'%%')
p=c(a<-k[!apply(z<1,1,sum)][1],p)}
sum(y[1:a])}

Provalo online!

L'algoritmo tenta anche di "salvare" sullo spazio rimuovendo iterativamente i bit mentre scorre i numeri primi. Sento che la conversione da decimale a bit potrebbe probabilmente essere più breve, ma non sono riuscito a capire altre alternative.

6 byte salvati grazie al francese Jonathan.


1
Penso che R supporti l'incarico incatenato; p=j=2è due byte più breve di p=2;j=2.
Jonathan Frech,

... che probabilmente può essere fatto anche per a=p, risparmiando ancora altri due byte.
Jonathan Frech,

1
... e - non so perché - sembra funzionare anche y=1, sostituito con y=2, risultante in 200 byte .
Jonathan Frech,

Grazie. Y = 2 sostituisce il bit per il numero 1. Funziona perché per n> 1, viene eliminato alla prima iterazione e per n = 1, il ciclo for si sposta indietro, fornendo così la risposta per n = 3, che è ancora 2 (non così sfortunato).
NofP,

2

JavaScript (ES6), 144 byte

n=>eval("s=o=j=0;for(i=p=1;n;d>p&&(n--,s+=p))for(p++,d=2;p%d++;);while(b=Math.log2(++j)+1|0,i<=s)for(x=0;x++<b&i<=s;)o+=i++>s-p&&j<<x&1<<b?1:0")

Ungolfed

n=>{
    s=o=j=0;
    for(i=p=1;n;d>p&&(n--,s+=p))
        for(p++,d=2;p%d++;);
    while(b=Math.log2(++j)+1|0,i<=s)
        for(x=0;x++<b&i<=s;)
            o+=i++>s-p&&j<<x&1<<b?1:0
    return o
}

Casi test



2

JavaScript (ES6), 138 132 123 byte

N=>(n=k=1,g=s=>N?g((P=n=>n%--x?P(n):x<2)(x=++n)?s[n]?s.slice(--N&&n,n/!N):s+(n--,k++).toString(2):s):s.split`1`.length-1)``

Casi test

Provalo online!

dimostrazione

NB: qui sono inclusi solo casi di test "sicuri" (garantiti per funzionare su Chrome, Firefox e Edge). Potrebbe essere necessario aumentare le dimensioni dello stack di chiamate del motore per passare gli altri.

Formattato e commentato

N => (                            // given N = index of the expected term
  n = k = 1,                      // n = current prime, k = current natural number
  g = s =>                        // g = recursive function taking s = binary string
    N ?                           //   if we haven't reached the correct chunk yet:
      g(                          //     do a recursive call to g():
        (P = n =>                 //       P() returns: true for prime
          n % --x ? P(n) : x < 2) //                    false for composite
        (x = ++n) ?               //       increment n; if n is prime:
          s[n] ?                  //         if s is long enough:
            s.slice(--N && n,     //           either remove this chunk (if N > 0)
                    n / !N)       //           or truncate it to the correct size (if N = 0)
          :                       //         else:
            s + (n--, k++)        //           append the next natural number to s
                .toString(2)      //           in binary format
        :                         //       else:
          s                       //         just look for the next prime
      )                           //     end of recursive call
    :                             //   else:
      s.split`1`.length - 1       //     return the number of 1's in the last chunk
)``                               // initial call to g() with an empty string

1

Perl 6 , 67 byte

{(1..*).map(|*.base(2).comb).rotor(grep *.is-prime,2..*)[$_-1].sum}

Provalo

Allargato:

{  # bare block lambda with implicit parameter 「$_」

  (

    1 .. *                # Range of all numbers starting with 1

  ).map(

    # WhateverCode lambda
    |                     # Slip each of these values into the outer list individually
      *                   # this is the parameter
      .base(2)            # convert base
      .comb               # split into digits


  ).rotor(                # split into chunks

    grep *.is-prime, 2..* # the sequence of prime numbers


  )[ $_ - 1]              # index into it using 1 based indexing

  .sum                    # find the sum
}

1

Python 2 , 143 139 133 byte

-4 byte grazie a @ErikTheOutgolfer

s='1';i=x=1
exec"s=s[i:];i+=1\nwhile~-all(i%x for x in range(2,i)):i+=1\nexec's+=bin(x)[2:];x+=1;'*i;"*input()
print s[:i].count('1')

Provalo online!


-2 byte rimuovendo il cablaggio di prova incompatibile. Un altro -2 riorganizzando alcune cose.
Erik the Outgolfer,

@EriktheOutgolfer grazie mille. Sono stato ancora in grado di aggiungere nuovamente i miei vecchi test.
Ovs,

1

J, 48 byte

([:+/-@{:{.+/{.[:}:[:(#:@[,])/1+[:i.1++/)@:p:@i.

ha spiegato

(                                                         )@:p:@i.  the first n primes, passed to...
       -@{: {.                    ...                               take "nth prime" elements from the tail of...
               +/                                                   sum the first n primes and...
                  {.                                                take that number of elements from...
                     [: }:                                          all but the last element of...   <----------------<
                                          1 + [: i. 1 + +/          sum first n primes, add 1 (so we have enough      |
                                                                    for case n=1) -- make that many natural numbers   |
                           [: (#:@[ , ])/                           reduce them by turning into lists of binary       |
                                                                    digits and catting, however the rightmost number  |
                                                                    won't get reduced, hence the need for ------------^
([: +/                                                              and sum those digits

Provalo online!


30 byte usando il tasto ( /.):_1({]+//.$$&;<@#:@#\)[:#~p:@i.
miglia

super intelligente. grazie miglia.
Giona

0

JavaScript 1+ + substr, 135 byte

for(n=prompt(s=P=0),i=n*n*n*8;--i;)s=i.toString(2)+s;for(p=1;n;e=j?s:--n?P+=p:s.substr(P,p))for(j=p++;p%j--;);eval([].join.call(e,'+'))

Cosa intendi con "4?" non sei sicuro della versione? Espandere ciò che intendi nel corpo contribuirebbe a migliorare questo post.
FryAmTheEggman,

So che funziona quando JS5 non è venuto, ma non sono sicuro esattamente quando
l4m2
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.