Un numero Cullen è qualsiasi numero contenuto nella sequenza generata utilizzando la formula:

C (n) = (n * 2 ^ n) +1.

Il tuo compito:

Scrivi un programma o una funzione che riceve un input e genera un valore di verità / falsa in base al fatto che l'input sia un numero Cullen.

Ingresso:

Un numero intero non negativo compreso tra 0 e 10 ^ 9 (incluso).

Produzione:

Un valore di verità / falsità che indica se l'input è un numero Cullen.

Casi test:

Input:    Output:
1   --->  truthy
3   --->  truthy
5   --->  falsy
9   --->  truthy
12  --->  falsy
25  --->  truthy

punteggio:

Questo è code-golf , quindi vince il punteggio più basso in byte.

Pyth, 6 5 byte

/mh.<

provalo online

codice macchina x86_64 ( System V ABI ), 28 27 byte

-1 byte grazie a @Cody Gray, grazie!

Un algoritmo a tempo costante!

_cullen:
   0:   0f bd cf    bsrl    %edi, %ecx
   3:   0f bd c1    bsrl    %ecx, %eax
   6:   89 ca       movl    %ecx, %edx
   8:   29 c2       subl    %eax, %edx
   a:   0f bd c2    bsrl    %edx, %eax
   d:   29 c1       subl    %eax, %ecx
   f:   d3 e1       shll    %cl, %ecx
  11:   ff c1       incl    %ecx
  13:   31 c0       xorl    %eax, %eax
  15:   39 f9       cmpl    %edi, %ecx
  17:   0f 94 c0    sete    %al
  1a:   c3          retq

Spiegazione:

Lascia y un numero intero e x=y*2^y + 1. Prendendo tronchi, abbiamo y + log2(y) = log2(x-1), quindi y=log2(x-1)-log2(y). Ricollegando il valore di y, otteniamo y=log2(x-1)-log2(log2(x-1)-log2(y)). In questo modo ancora una volta, si ottiene: y=log2(x-1)-log2[log2(x-1)-log2(log2(x-1)-log2(log2(x-1)-log2(y)))].

Rimuoviamo gli ultimi termini (dell'ordine di log2(log2(log2(log2(x)))), questo dovrebbe essere sicuro!), E supponiamo che x-1≈xotteniamo: y≈log2(x)-log2[log2(x)-log2(log2(x))]

Ora, lasciando f(n) = floor(log2(n)), può essere verificato manualmente che ypuò essere esattamente recuperato da :,y=f(x)-f[f(x)-f(f(x))] per y <26 , e quindi x ⩽ 10 ^ 9 , come specificato dalla sfida ⁽¹⁾ .

L'algoritmo consiste quindi semplicemente nel calcolare y dato x , e verificare che x == y * 2 ^ y + 1 . Il trucco è che f(n)può essere semplicemente implementato come bsristruzione (inversione bit-scan), che restituisce l'indice del primo 1 bit in n , e y*2^yas y << y.

Codice dettagliato:

_cullen:                                 ; int cullen(int x) {
   0:   0f bd cf    bsrl    %edi, %ecx   ;  int fx = f(x);
   3:   0f bd c1    bsrl    %ecx, %eax   ;  int ffx = f(f(x));
   6:   89 ca       movl    %ecx, %edx   
   8:   29 c2       subl    %eax, %edx   ;  int a = fx - ffx;
   a:   0f bd c2    bsrl    %edx, %eax   ;  int ffxffx = f(a);
   d:   29 c1       subl    %eax, %ecx   ;  int y = fx - ffxffx;
   f:   d3 e1       shll    %cl, %ecx    ;  int x_ = y<<y;
  11:   ff c1       incl    %ecx         ;  x_++;
  13:   31 c0       xorl    %eax, %eax
  15:   39 f9       cmpl    %edi, %ecx
  17:   0f 94 c0    sete    %al
  1a:   c3          retq                 ;  return (x_ == x);
                                         ; }

⁽¹⁾ In effetti, questa uguaglianza sembra valere per valori fino a 50000 y .

Gelatina , 7 6 byte

Ḷæ«`i’

Provalo online!

Accetta input come argomento della riga di comando. Se viene dato un numero Cullen C ( n ), genera n +1 (che è vero in Jelly, essendo un numero intero diverso da zero; nota che abbiamo n ≥0 perché l'input è un numero intero, e i numeri Cullen con n negativo sono mai numeri interi) . Se viene assegnato un numero non Cullen, restituisce 0, che è false in Jelly.

Spiegazione

Ḷæ«`i’
Ḷ        Form a range from 0 to (the input minus 1)
 æ«      Left-shift each element in the range by 
   `       itself
    i’   Look for (the input minus 1) in the resulting array

Fondamentalmente, forma una matrice di numeri Cullen meno uno, quindi cerca l'input meno uno al suo interno. Se l'input è un numero Cullen, lo troveremo, altrimenti non lo faremo. Si noti che l'array è necessariamente abbastanza lungo da raggiungere l'input, poiché C ( n ) è sempre maggiore di n .

JavaScript (ES6), 37 35 byte

Salvato 2 byte grazie a Neil

f=(n,k,x=k<<k^1)=>x<n?f(n,-~k):x==n

dimostrazione

f=(n,k,x=k<<k^1)=>x<n?f(n,-~k):x==n

console.log(JSON.stringify([...Array(1000).keys()].filter(n => f(n))))

Haskell, 28 byte

f n=or[x*2^x+1==n|x<-[0..n]]

Provalo online!

Ohm , 8 byte

@Dº*≥Dlε

Provalo online!

           Implicit input
@          Range [1,...,Input]
 D         Duplicate
  º        2^n each element
   *       Multiply those two array
    ≥      Increment everything (now I have an array of all Cullen Numbers)
     Dl    Push array length (= get input again, can't get again implicitly or using a function because it would be a string so I'd waste a byte again)
       ε   Is input in array?

PHP , 43 byte

for(;$argn>$c=1+2**$n*$n++;);echo$argn==$c;

Provalo online!

05AB1E , 7 byte

ÝDo*¹<å

Provalo online!

Spiegazione:

ÝDo*¹<å Example input: 9. Stack: [9]
Ý       Range 0-input. Stack: [[0,1,2,3,4,5,6,7,8,9]]
 D      Duplicate. Stack: [[0,1,2,3,4,5,6,7,8,9],[0,1,2,3,4,5,6,7,8,9]]
  o     2** each item in the list. Stack: [[0,1,2,3,4,5,6,7,8,9], [1,2,4,8,16,32,64,128,256,512]]
   *    Multiply the two lists. Stack: [[0, 2, 8, 24, 64, 160, 384, 896, 2048, 4608]]
    ¹   Push input again. Stack: [[0, 2, 8, 24, 64, 160, 384, 896, 2048, 4608],9]
     <  Decrement. Stack: [[0, 2, 8, 24, 64, 160, 384, 896, 2048, 4608],8]
      å Is the first item of the stack in the second item? Stack: [1]
        Implicit print.

R , 53 51 46 byte

pryr::f(x%in%lapply(0:x,function(y)(y*2^y+1)))

Funzione anonima. Controlla sex viene generato nella sequenza C (n) per n in [0, x].

3 byte giocati a golf da Giuseppe.

Provalo online!

C, C ++, Java, C #, D: 70 byte

A causa delle somiglianze tra tutte queste lingue, questo codice funziona per ciascuna

int c(int n){for(int i=0;i<30;++i)if((1<<i)*i+1==n)return 1;return 0;}

Python, 40 byte

lambda n:any(x<<x==n-1for x in range(n))

Provalo online!

Python 2 , 36 byte

f=lambda n,i=0:i<<i!=n-1and f(n,i+1)

Provalo online!

Output non crash / crash, come attualmente consentito da questo meta consenso .

Python 2 , 42 byte

i=0
n=input()-1
while i<<i<n:i+=1
i<<i>n<c

Provalo online!

Uscite tramite codice di uscita

R , 26 byte

a=0:26;scan()%in%(1+a*2^a)

Provalo online!

Un approccio leggermente diverso rispetto all'altra risposta R ; legge da stdine poiché l'ingresso è garantito tra 0 e 10 ^ 9, dobbiamo solo controllare ntra 0 e 26.

APL (Dyalog) , 9 byte

Per coprire il caso di n = 1, richiede ⎕IO←0quale sia l'impostazione predefinita su molti sistemi.

⊢∊1+⍳×2*⍳

Provalo online!

⊢ [is] n (l'argomento)

∊ un membro di

1 uno

+ più

⍳ i i ntegers 0 ... ( n -1)

× volte

2 Due

* al potere di

⍳ i i ntegers 0 ... ( n -1)

Python 2 , 32 byte

[n<<n|1for n in range(26)].count

Provalo online!

Crea l'elenco di numeri Cullen fino a 10^9, quindi conta quante volte appare l'input in esso. Grazie a Vincent per aver sottolineato n<<n|1invece di (n<<n)+1aver salvato 2 byte.

D, 65 byte

Questa è una porta dell'algoritmo di @ HatsuPointerKun su D (l'originale era già codice D, ma questo è con trucchi specifici di D)

T c(T)(T n){for(T i;i<30;++i)if((1<<i)*i+1==n)return 1;return 0;}

Come? (D trucchi specifici)

Il sistema di template di D è più corto di quello di C ++ e può inferire i tipi. E D inoltre inizializza le sue variabili al valore predefinito al momento della dichiarazione.

Mathematica, 30 byte

MemberQ[(r=Range@#-1)2^r+1,#]&

Funzione pura che accetta un intero non negativo come input e return Trueo False. Se l'input è n, quindi (r=Range@#-1)imposta la variabile rcome {0, 1, ..., n-1}, quindi r2^r+1calcola in modo vettoriale i primi nnumeri di Cullen. MemberQ[...,#]quindi controlla se nè un elemento dell'elenco.

Mathematica, 32 byte

!Table[x*2^x+1,{x,0,#}]~FreeQ~#&

Excel VBA, 45 byte

Funzione di finestra immediata VBE anonima che accetta input dalla cella [A1]e uscite alla finestra immediata di VBE

Deve essere eseguito in un modulo pulito o avere valori per i, j reimpostato sul valore predefinito 0 tra le esecuzioni

While j<[A1]:j=(i*2 ^ i)+1:i=i+1:Wend:?j=[A1]

Input Output

I / O come si vede nella finestra immediata di VBE

[A1]=25
While j<[A1]:j=(i*2 ^ i)+1:i=i+1:Wend:?j=[A1]
True

[A1]=1: i=0:j=0 ''# clearing module values
While j<[A1]:j=(i*2 ^ i)+1:i=i+1:Wend:?j=[A1]
True    

[A1]=5: i=0:j=0 ''# clearing module values
While j<[A1]:j=(i*2 ^ i)+1:i=i+1:Wend:?j=[A1]
False 

Swi-Prolog, 69 byte

f(X)riesce se riesce a trovare un valore I dove X = I * 2 ^ I + 1. Il suggerimento intervallo lo interrompe a corto di spazio dello stack, ma è sufficiente per l'intervallo di numeri Cullen fino a 10 ^ 9 nelle specifiche della domanda.

:-use_module(library(clpfd)).
f(X):-I in 0..30,X#=I*2^I+1,label([I]).

per esempio

f(838860801).
true

cQuents , 9 byte

$0?1+$2^$

Provalo online!

Spiegazione

$0           n is 0-indexed
  ?          Mode query. Given input n, output true/false for if n is in the sequence.
   1+$2^$    Each item in the sequence equals `1+index*2^index`

TI-BASIC, 17 byte

max(Ans=seq(X2^X+1,X,0,25

Spiegazione

seq(X2^X+1,X,0,25 Generate a list of Cullen numbers in the range
Ans=              Compare the input to each element in the list, returning a list of 0 or 1
max(              Take the maximum of the list, which is 1 if any element matched

QBIC , 24 byte

[0,:|~a*(2^a)+1=b|_Xq}?0

Spiegazione

[0,:|           FOR a = 0 to b (input from cmd line)
~a*(2^a)+1=b    IF calculating this a results in b
|_Xq            THEN quit, printing 1
}               NEXT a
?0              We haven't quit early, so print 0 and end.

k , 19 byte

{&1=x-{x**/x#2}'!x}

Provalo online. Verità è un array con un numero al suo interno: ,3o ,0eccetera. Falsey è un array vuoto: ()o !0dipende dal tuo interprete.

Java (OpenJDK 8) , 56 byte

i->{int n,c;for(n=0;(c=n*(2<<n++-1)+1)<i;);return c==i;}

Provalo online!

Pari / GP , 25 byte

n->!prod(i=0,n,n-i*2^i-1)

Provalo online!