Excel, 34 Bytes

Constructs a list of Cullen numbers, compares the input against all elements in this list, and outputs the or of all of these comparisons. Correct for inputs \$n<1,744,830,465\$.

Takes input from cell A1, and outputs to the calling cell.

=Let(n,Row(1:26)-1,Or(A1=n*2^n+1))

J, 11 bytes

e.1+i.*2^i.

Port of Adám's APL except the train is a monadic hook

Attempt This Online!

e.1+i.*2^i.
         i.   NB. [0..n)
       2^     NB. 2 to the power of ...
    i.        NB. [0..n)
      *       NB. multiplication
  1+          NB. add one
e.            NB. is the input a member of the result

Vyxal 3, 6 bytes

ʀ:E×ꜝc

Vyxal It Online!

Port of lyxal's v2 answer. Explanation:

ʀ       # ‎⁡For x in [0..n):
 :E×    # ‎⁢  Multiply x by 2**x
    ꜝ   # ‎⁣  Increment x
     c  # ‎⁤Is the input in this sequence?
💎

Created with the help of Luminespire.

Uiua, 9 bytes

∈+1×⟜ⁿ⇡,2

Try it!

∈+1×⟜ⁿ⇡,2
       ⇡,  # for x in [0...n-1]:
   ×⟜     #   multiply x by
      ⁿ ,2 #   2^x
 +1        #   and add 1
∈       ,  # is n a member of this sequence?

Husk, 11 bytes

€¹mλ→*^¹2)ŀ

Try it online!

Outputs 0 if the input number is NOT a Cullen Number. Otherwise the output is an integer value (the number's index in the sequence).

          ŀ # Make a range: 0 to input number
  m         # Map over the range
   λ     )  # Apply the following function:
      ^¹2   #  - calculate 2^n
     *      #  - multiply by n
    →      #  - increment by 1
€¹          # Check whether the input value is in the list

Julia 1.0, 23 bytes

~n=n∈0:n.|>x->x*2^x+1

Try it online!

Thunno 2 -c, 5 bytes

ĖıỴ;Ƈ

Try it online!

Port of user62131's Jelly answer.

Thunno 2, 6 bytes

ĖDO×⁺Ƈ

Try it online!

Explanation

ĖıỴ;Ƈ  # Implicit input
       # Decrement the input
Ė      # Push [0..input-1]
  Ỵ    # Left bit-shift each
 ı ;   # number by itself
    Ƈ  # Is (input - 1)
       # in this list?
       # Implicit output

ĖDO×⁺Ƈ  # Implicit input
Ė       # Push [0..input]
 D      # Duplicate it
  O     # Push 2 ** that
   ×    # Multiply together
    ⁺   # Increment each
     Ƈ  # Is the input
        # in this list?
        # Implicit output

Pyt, 8 bytes

Đ0⇹ŘĐ«⁺∈

Try it online!

Đ             implicit input; Đuplicate
 0⇹Ř          Řangify from 0 to n
    Đ         Đuplicate
     «        bitshift left
      ⁺       increment
       ∈      is input in list of Cullen numbers?; implicit print

Thunno D, \$ 11 \log_{256}(96) \approx \$ 9.05 bytes

RD2@z*s1-Aq

Attempt This Online!

Explanation

RD2@z*s1-Aq  # Implicit input
RD           # Push range(input) and duplicate
  2@         # Pop one copy and push 2 ** each
    z*       # Multiply elementwise
      s1-    # Push the input decremented
         Aq  # Is this in the list?

Nibbles, 5.5 bytes (11 nibbles)

?.`,$+~*^2

Returns 1-based index in list of Cullen numbers (truthy), or zero (falsy) if not a Cullen number.

?.`,$+~*^2      # full function
?.`,$+~*^2$$$   # (with implicit arguments shown):
 .              # map over
  `,$           # 0..input-1
                # with function:
     +          #   add
      ~         #   1 (default)
                #   to
        ^2      #   2 to the power of
          $     #   input
       *   $    #   multiplied by input
?           $   # and get the index of the input in this
                # (or zero if not found)

Vyxal, 6 bytes

ʀ:E*›c

Try it Online!

Explained

ʀ:E*›c
ʀ:     # push 2 copies of the range [0, input]
  E    # 2 ** x for x in ^
   *   # vectorised multiply with the other copy
    ›  # + 1
     c # contains the input?

Japt -d, 7 bytes

ÑpU ¶NÉ

Try it

ÑpU ¶NÉ     :Implicit map of each U in the range [0,input)
Ñ           :Multiply by 2
 pU         :Raised to the power of U
    ¶       :Is equal to
     N      :Array of all inputs
      É     :Minus 1
            :Implicit output of whether or not any U returns true

Raku, 30 bytes

{$_∈({1+$++*2**$++}...*>$_)}

Try it online!

The parenthesized expression is a list of generated Cullen numbers, taken up to the point where a number is greater than the input argument (* > $_). Then we just check that the input argument is a member of that list (∈).

Arturo, 29 bytes

$=>[in?&map 0..25'n->1+n*2^n]

Try it

D, 65 bytes

This is a port of @HatsuPointerKun's algorithm to D (the original was already D code, but this is with D-specific tricks)

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

How? (D specific tricks)

D's template system is shorter than C++'s, and can infer types. And D also initializes its variables to the default upon declaration.

TI-BASIC, 17 bytes

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

Explanation

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

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

Due to the similarities between all these languages, this code works for each

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

cQuents, 9 bytes

$0?1+$2^$

Try it online!

Explanation

$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`

Swi-Prolog, 69 bytes

f(X) succeeds if it can find a value I where X = I*2^I+1. The range hint stops it running out of stack space, but it's enough for the range of Cullen numbers up to 10^9 in the question spec.

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

e.g.

f(838860801).
true

Python 2, 32 bytes

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

Try it online!

Creates the list of Cullen numbers up to 10^9, then counts how many times the input appears in it. Thanks to Vincent for pointing out n<<n|1 instead of (n<<n)+1, saving 2 bytes.

x86_64 machine code (System V ABI), 28 27 bytes

-1 byte thanks to @Cody Gray, thanks!

A constant-time algorithm!

_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

Explanation:

Let y an integer and x=y*2^y + 1. Taking logs, we have y + log2(y) = log2(x-1), thus y=log2(x-1)-log2(y). Plugging back the value of y, we get y=log2(x-1)-log2(log2(x-1)-log2(y)). Doing this one more time, we obtain: y=log2(x-1)-log2[log2(x-1)-log2(log2(x-1)-log2(log2(x-1)-log2(y)))].

Let us remove the last terms (of the order of log2(log2(log2(log2(x)))), this should be safe!), and assume that x-1≈x, we obtain: y≈log2(x)-log2[log2(x)-log2(log2(x))]

Now, letting f(n) = floor(log2(n)), it can be verified manually that y can be exactly retrieved by: y=f(x)-f[f(x)-f(f(x))], for y < 26, and thus x ⩽ 10^9, as specified by the challenge⁽¹⁾.

The algorithm then simply consists of computing y given x, and verify that x == y*2^y + 1. The trick is that f(n) can simply be implemented as the bsr instruction (bit-scan reverse), which returns the index of the first 1-bit in n, and y*2^y as y << y.

Detailed code:

_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 fact, this equality seems to hold for values of y up to 50000.

Excel VBA, 45 Bytes

Anonymous VBE immediate window function that takes input from cell [A1] and ouputs to the VBE immediate window

Must be run in a clean module or have values for i,j be reset to default value of 0 between runs

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

Input / Output

I/O as seen in VBE immediate window

[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 

Mathematica, 32 bytes

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

Pari/GP, 25 bytes

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

Try it online!

Pyth, 6 5 bytes

/mh.<

try it online

Mathematica, 30 bytes

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

Pure function taking a nonnegative integer as input and returning True or False. If the input is n, then (r=Range@#-1) sets the variable r to be {0, 1, ..., n-1}, and then r2^r+1 vectorially computes the first n Cullen numbers. MemberQ[...,#] then checks whether n is an element of the list.

APL (Dyalog), 9 bytes

To cover the case of n = 1, it requires ⎕IO←0 which is default on many systems.

⊢∊1+⍳×2*⍳

Try it online!

⊢ [is] n (the argument)

∊ a member of

1 one

+ plus

⍳ the integers 0 … (n-1)

× times

2 two

* to the power of

⍳ the integers 0 … (n-1)

Java (OpenJDK 8), 56 bytes

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

Try it online!

R, 53 51 46 bytes

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

Anonymous function. Checks if x is generated in the sequence C(n) for n in [0,x].

3 bytes golfed by Giuseppe.

Try it online!

R, 26 bytes

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

Try it online!

A slightly different approach than the other R answer; reads from stdin and since the input is guaranteed to be between 0 and 10^9, we just have to check n between 0 and 26.

05AB1E, 7 bytes

ÝDo*¹<å

Try it online!

Explanation:

Ý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.

k, 19 bytes

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

Try it online. Truthy is an array with a number in it: ,3 or ,0 et cetera. Falsey is an empty array: () or !0 depending on your interpreter.

JavaScript (ES6), 37 35 bytes

Saved 2 bytes thanks to Neil

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

Demo

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))))

PHP, 43 bytes

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

Try it online!

Python 2, 36 bytes

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

Try it online!

Outputs by not crashing / crashing, as currently allowed by this meta concensus.

Python 2, 42 bytes

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

Try it online!

Outputs via exit code

Ohm, 8 bytes

@Dº*≥Dlε

Try it 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?

Jelly, 7 6 bytes

Ḷæ«`i’

Try it online!

Takes input as a command-line argument. If given a Cullen number C(n), outputs n+1 (which is truthy in Jelly, being an nonzero integer; note that we have n≥0 because the input is an integer, and Cullen numbers with negative n are never integers). If given a non-Cullen number, returns 0, which is falsey in Jelly.

Explanation

Ḷæ«`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

Basically, form an array of Cullen numbers minus one, then look for the input minus one in it. If the input is a Cullen number, we'll find it, otherwise we won't. Note that the array is necessarily long enough to reach to the input, because C(n) is always greater than n.

QBIC, 24 bytes

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

Explanation

[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.

Haskell, 28 bytes

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

Try it online!

Python, 40 bytes

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

Try it online!