Số Cullen là bất kỳ số nào có trong chuỗi được tạo bằng công thức:

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

Nhiệm vụ của bạn:

Viết chương trình hoặc hàm nhận đầu vào và xuất giá trị trung thực / giả dựa trên việc đầu vào có phải là Số Cullen hay không.

Đầu vào:

Một số nguyên không âm trong khoảng từ 0 đến 10 ^ 9 (đã bao gồm).

Đầu ra:

Giá trị trung thực / giả mạo cho biết liệu đầu vào có phải là Số Cullen hay không.

Các trường hợp thử nghiệm:

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

Ghi điểm:

Đây là môn đánh gôn , vì vậy điểm số thấp nhất tính bằng byte sẽ thắng.

Bình thường, 6 5 byte

/mh.<

thử trực tuyến

Mã máy x86_64 ( Hệ thống V ABI ), 28 27 byte

-1 byte nhờ @Cody Gray, cảm ơn!

Một thuật toán không đổi thời gian!

_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

Giải trình:

Đặt y một số nguyên và x=y*2^y + 1. Lấy nhật ký, chúng tôi có y + log2(y) = log2(x-1), do đó y=log2(x-1)-log2(y). Cắm lại giá trị của y, chúng tôi nhận được y=log2(x-1)-log2(log2(x-1)-log2(y)). Làm điều này một lần nữa, chúng tôi có được : y=log2(x-1)-log2[log2(x-1)-log2(log2(x-1)-log2(log2(x-1)-log2(y)))].

Hãy để chúng tôi xóa các điều khoản cuối cùng (theo thứ tự log2(log2(log2(log2(x)))), điều này sẽ an toàn!) Và giả sử rằng x-1≈x, chúng tôi có được: y≈log2(x)-log2[log2(x)-log2(log2(x))]

Bây giờ, cho phép f(n) = floor(log2(n)), nó có thể được xác minh bằng tay ycó thể được truy xuất chính xác bằng cách : y=f(x)-f[f(x)-f(f(x))], cho y <26 , và do đó x ⩽ 10 ^ 9 , như được chỉ định bởi thử thách ⁽¹⁾ .

Thuật toán sau đó chỉ đơn giản bao gồm tính toán y đã cho x và xác minh rằng x == y * 2 ^ y + 1 . Thủ thuật f(n)đơn giản là có thể được thực hiện như bsrhướng dẫn (quét ngược bit), trả về chỉ mục của 1 bit đầu tiên trong n và y*2^ynhư y << y.

Mã chi tiết:

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

⁽¹⁾ Trên thực tế, sự bình đẳng này dường như giữ giá trị của y lên tới 50000.

Thạch , 7 6 byte

Ḷæ«`i’

Hãy thử trực tuyến!

Đưa đầu vào làm đối số dòng lệnh. Nếu được cấp số Cullen C ( n ), xuất ra n +1 (là số thật trong Jelly, là số nguyên khác không; lưu ý rằng chúng ta có n ≥0 vì đầu vào là số nguyên và số Cullen có n âm không bao giờ là số nguyên) . Nếu được cung cấp một số không phải Cullen, trả về 0, đó là falsey trong Jelly.

Giải trình

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

Về cơ bản, tạo thành một mảng các số Cullen trừ đi một, sau đó tìm đầu vào trừ một số trong đó. Nếu đầu vào là số Cullen, chúng tôi sẽ tìm thấy nó, nếu không chúng tôi sẽ không. Lưu ý rằng mảng nhất thiết phải đủ dài để tiếp cận đầu vào, bởi vì C ( n ) luôn lớn hơn n .

JavaScript (ES6), 37 35 byte

Đã lưu 2 byte nhờ Neil

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

Bản giới thiệu

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

Hãy thử trực tuyến!

Ồ , 8 byte

@Dº*≥Dlε

Hãy thử trực tuyến!

           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;

Hãy thử trực tuyến!

05AB1E , 7 byte

ÝDo*¹<å

Hãy thử trực tuyến!

Giải trình:

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

Chức năng ẩn danh. Kiểm tra nếu xđược tạo trong chuỗi C (n) cho n trong [0, x].

3 byte được chơi bởi Giuseppe.

Hãy thử trực tuyến!

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

Do sự tương đồng giữa tất cả các ngôn ngữ này, mã này hoạt động cho từng ngôn ngữ

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

Hãy thử trực tuyến!

Python 2 , 36 byte

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

Hãy thử trực tuyến!

Đầu ra bằng cách không sụp đổ / sụp đổ, như hiện tại được cho phép bởi sự đồng thuận meta này .

Python 2 , 42 byte

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

Hãy thử trực tuyến!

Đầu ra thông qua mã thoát

R , 26 byte

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

Hãy thử trực tuyến!

Một cách tiếp cận hơi khác so với câu trả lời R khác ; đọc từ stdinvà vì đầu vào được đảm bảo trong khoảng từ 0 đến 10 ^ 9, chúng ta chỉ cần kiểm tra ntừ 0 đến 26.

APL (Dyalog) , 9 byte

Để bao gồm trường hợp n = 1, nó yêu cầu ⎕IO←0mặc định trên nhiều hệ thống.

⊢∊1+⍳×2*⍳

Hãy thử trực tuyến!

⊢ [là] n (đối số)

∊ một thành viên của

1 một

+ thêm

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

× lần

2 hai

* với sức mạnh của

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

Python 2 , 32 byte

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

Hãy thử trực tuyến!

Tạo danh sách các số Cullen tối đa 10^9, sau đó đếm số lần đầu vào xuất hiện trong đó. Cảm ơn Vincent đã chỉ ra n<<n|1thay vì (n<<n)+1, tiết kiệm 2 byte.

D, 65 byte

Đây là một cổng của thuật toán @ HatsuPulumKun đến D (bản gốc đã là mã D, nhưng đây là với các thủ thuật dành riêng cho D)

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

Làm sao? (D thủ thuật cụ thể)

Hệ thống mẫu của D ngắn hơn C ++ và có thể suy ra các loại. Và D cũng khởi tạo các biến của nó thành mặc định khi khai báo.

Toán học, 30 byte

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

Hàm thuần túy lấy một số nguyên không âm làm đầu vào và trả về Truehoặc False. Nếu đầu vào là n, sau đó (r=Range@#-1)đặt biến rthành {0, 1, ..., n-1}, và sau đó r2^r+1tính toán một cách hợp lý các nsố Cullen đầu tiên . MemberQ[...,#]sau đó kiểm tra xem có phải nlà một thành phần của danh sách hay không.

Toán học, 32 byte

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

VBA Excel, 45 byte

Chức năng cửa sổ ngay lập tức VBE ẩn danh đưa đầu vào từ ô [A1]và xuất ra cửa sổ ngay lập tức VBE

Phải được chạy trong một mô-đun sạch hoặc có các giá trị cho i, j được đặt lại về giá trị mặc định là 0 giữa các lần chạy

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

Đầu ra đầu vào

I / O như đã thấy trong cửa sổ VBE ngay lập tức

[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)thành công nếu nó có thể tìm thấy giá trị I trong đó X = I * 2 ^ I + 1. Gợi ý phạm vi ngăn không cho nó hết dung lượng ngăn xếp, nhưng nó đủ cho phạm vi số Cullen lên tới 10 ^ 9 trong thông số câu hỏi.

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

ví dụ

f(838860801).
true

cQuents , 9 byte

$0?1+$2^$

Hãy thử trực tuyến!

Giải trình

$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

Giải trình

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

Giải trình

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

Hãy thử trực tuyến. Truthy là một mảng có một số trong đó: ,3hoặc ,0et cetera. Falsey là một mảng trống: ()hoặc !0tùy thuộc vào thông dịch viên của bạn.

Java (OpenJDK 8) , 56 byte

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

Hãy thử trực tuyến!

Pari / GP , 25 byte

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

Hãy thử trực tuyến!