Giới thiệu

Thử thách này yêu cầu bạn đặt các số 0 ở cuối của biểu diễn nhị phân số nguyên 010101…, điều này được giải thích tốt nhất với một ví dụ:

Cho số nguyên 400, bước đầu tiên là chuyển đổi nó thành nhị phân:

110010000

Như chúng ta có thể thấy bit thứ năm là bit có trọng số thấp nhất 1, vì vậy bắt đầu từ đó chúng ta thay thế các số 0 thấp hơn bằng cách 0101:

110010101

Cuối cùng, chúng tôi chuyển đổi trở lại thành thập phân: 405

Thử thách

Cho một số nguyên dương trả về / đầu ra giá trị kết quả tương ứng của quá trình được xác định ở trên.

Quy tắc

Chuỗi này chỉ được xác định cho các số nguyên có ít nhất một 1bit, vì vậy đầu vào sẽ luôn là ≥ 1
Thay vào đó, bạn có thể lấy đầu vào dưới dạng chuỗi, danh sách các chữ số (thập phân)
Bạn không phải xử lý đầu vào không hợp lệ

Tủ thử

Dưới đây là một số mẫu thử nghiệm khác với các bước trung gian (bạn không phải in / trả lại những mẫu này):

In -> … -> … -> Out
1 -> 1 -> 1 -> 1
2 -> 10 -> 10 -> 2
3 -> 11 -> 11 -> 3
4 -> 100 -> 101 -> 5
24 -> 11000 -> 11010 -> 26
29 -> 11101 -> 11101 -> 29
32 -> 100000 -> 101010 -> 42
192 -> 11000000 -> 11010101 -> 213
400 -> 110010000 -> 110010101 -> 405
298 -> 100101010 -> 100101010 -> 298

— ბიმო
nguồn

Chúng ta có thể giả sử một số nguyên 32 bit không?

— Arnauld

@Arnauld: Chắc chắn rồi!

— ბიმო

9

Một số ý tưởng chơi gôn: Nếu nlà sức mạnh tối đa của 2 phân chia đầu vào, thì câu trả lời chỉ đơn giản là(input) + ceil((2^n - 2)/3)

— JungHwan Min

12

Python 3 , 20 byte

lambda n:(n&-n)//3+n

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

Giải trình

Lấy 192một ví dụ. Dạng nhị phân của nó là 11000000, và chúng ta cần chuyển đổi nó thành 11010101.

Chúng tôi lưu ý rằng chúng tôi cần thêm 10101vào số. Đây là một loạt hình học ( 4^0 + 4^1 + 4^2), có dạng đóng như (4^3-1)/(4-1). Điều này giống như 4^3//3nơi //biểu thị sự phân chia số nguyên.

Nếu đúng như vậy 101010, thì nó vẫn sẽ là một loạt hình học ( 2×4^0 + 2×4^1 + 2×4^2), 2×4^3//3vì những lý do trên.

Dù sao, 4^3và 2×4^3sẽ chỉ là bit ít quan trọng nhất mà chúng ta có được bằng cách n&-n:

Chúng tôi nhận thấy rằng bổ sung nlà 00111111. Nếu chúng ta thêm một, nó sẽ trở thành 01000000và nó chỉ trùng lặp với n=11000000ít nhất là chữ số có nghĩa. Lưu ý rằng "bổ sung và thêm một" chỉ là phủ định.

— Nữ tu bị rò rỉ
nguồn

6

@ Mr.Xcoder thể thao đẹp

— Leaky Nun

1

Có thể lambda n:(n&-n)//3+nlàm việc quá? Vượt qua tất cả các trường hợp thử nghiệm mẫu , nhưng theo trực giác của tôi thì nó không hợp lệ, phải không?

— Ông Xcoder

@ Mr.Xcoder nó thực sự hợp lệ.

— Leaky Nun

1

Tại sao không sử dụng Python 2 để lưu một byte? TIO

— FlipTack

4

@FlipTack Tôi ghét trăn 2

— Leaky Nun

8

Thạch , 5 byte

&N:3+

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

Lần này là một cách tiếp cận của Leaky Nun (ít nhất là tôi đã giúp anh ta đánh golf xuống một chút: P)

Thạch , 7 byte

^N+4:6ạ

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

Sử dụng phương pháp tuyệt vời của JungHwan Min , với sự giúp đỡ gián tiếp từ Martin Ender .

— Ông Xcoder
nguồn

Dennis đã đăng, sau đó xóa, một giải pháp 5 byte rất giống nhau ngay sau khi bạn thực hiện chỉnh sửa đó. Một cái gì đó như &N:3|. Xin chúc mừng; bạn đánh bại Dennis trong Jelly! (Nhưng không hoàn toàn chơi gôn.)

— wizzwizz4

@ wizzwizz4 Tôi thực sự không làm được gì nhiều, ngoài việc gợi ý một sân golf nhỏ theo cách tiếp cận của Leaky và sau đó chuyển nó. Nhưng eh :-)

— Ông Xcoder

Đây là câu trả lời Jelly duy nhất của ASCII mà tôi từng thấy.

— MD XF

6

Ngôn ngữ Wolfram (Mathicala) , 36 28 26 24 byte

^{-8 byte nhờ @MartinEnder và -2 byte nhờ @ Mr.Xcoder}

#+⌊(#~BitAnd~-#)/3⌋&

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

Chúng ta chỉ cần tìm số lượng các số 0 ở đầu vào và tìm số có 0s và s xen kẽ 1với độ dài nhỏ hơn số đó và thêm nó vào đầu vào.

Vì thế, 400 -> 11001000 -> 110010000 + 0000 -> 110010101 + 101 -> 405

Công thức rõ ràng cho nsố thứ tự với 1s và s xen kẽ 0được đưa ra trong A000975 trên OEIS. Chúng ta có thể sử dụng nsố thứ tự vì không có hai số khác nhau có thể có cùng độ dài trong nhị phân và có các chữ số xen kẽ.

— JungHwan Min
nguồn

1

2^#~IntegerExponent~2là(BitXor[#,#-1]+1)/2

— Martin Ender

@MartinEnder wow! Và sau đó tôi chỉ có thể kết hợp các phân số để giảm thêm byte

— JungHwan Min

1

24 byte . Bạn có thể sử dụng #+⌊(#~BitAnd~-#)/3⌋&thay thế.

— Ông Xcoder

@ Mr.Xcoder đã chỉnh sửa :)

— JungHwan Min

5

J , ₁₉ 18 byte

+(2|-.i.@#.-.)&.#:

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

Giải thích nhanh

Đây là một câu trả lời cũ, nhưng về bản chất nó rất giống với câu trả lời hiện tại, nó chỉ đếm các số 0 khác nhau. Xem các ý kiến cho một liên kết giải thích làm thế nào nó hoạt động.

+(2|i.@i.&1@|.)&.#:
                 #:  Convert to binary list
       i.&1@|.       Index of last 1 from right
            |.         Reverse
       i.&1            Index of first 1
    i.               Range [0, index of last 1 from right)
  2|                 That range mod 2
               &.    Convert back to decimal number
+                    Add to the input

Câu trả lời khác:

Câu trả lời trước (19 byte).

+(2|i.@i.&1@|.)&.#:

Dài hơn nó nên bởi vì \đi từ phải sang trái.

+(2|#*-.#.-.)\&.(|.@#:)

— cole
nguồn

1

18 byte+(2|-.i.@#.-.)&.#:

— dặm

@miles tâm giải thích những gì đang xảy ra với chuyển đổi cơ sở ở đó? Tôi đoán nó có liên quan đến số không nhưng tôi không chắc.

— cole

#.~ đếm số lượng những sự thật trailing , vì vậy những gì chúng ta cần là #.~ -. #:để đếm số trailing zero

— dặm

@miles ơi! Điều đó rất, rất thông minh.

— cole

4

Julia 0,6 , 12 byte

!n=n|n&-n÷3

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

— Dennis
nguồn

Điều này trông giống như một phương pháp hiệu quả, bạn có thể giải thích quyền ưu tiên của nhà điều hành? Ví dụ: tôi không thể biết liệu nó được đánh giá là ((!n=(n|n))&-n)/3, hay !n=(((n|n)&(-n))/3), v.v.

— MD XF

Trong Julia, các toán tử bitwise có các ưu tiên giống như các đối tác số học của chúng, vì vậy |là như thế +và &là như thế *. Do đó, n|n&-n÷3được phân tích cú pháp như n | ((n&-n) ÷3).

— Dennis

3

JavaScript (ES6), 40 39 byte

Lấy đầu vào là số nguyên 32 bit.

n=>n|((n&=-n)&(m=0xAAAAAAAA)?m:m/2)&--n

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

Hiển thị đoạn mã

let f =

n=>n|((n&=-n)&(m=0xAAAAAAAA)?m:m/2)&--n

console.log(f(1))   // 1 -> 1 -> 1
console.log(f(2))   // 10 -> 10 -> 2
console.log(f(3))   // 11 -> 11 -> 3
console.log(f(4))   // 100 -> 101 -> 5
console.log(f(24))  // 11000 -> 11010 -> 26
console.log(f(29))  // 11101 -> 11101 -> 29
console.log(f(32))  // 100000 -> 101010 -> 42
console.log(f(192)) // 11000000 -> 11010101 -> 213
console.log(f(400)) // 110010000 -> 110010101 -> 405
console.log(f(298)) // 100101010 -> 100101010 -> 298

Expand snippet

— Arnauld
nguồn

2

05AB1E , 13 8 5 byte

Đã lưu 5 byte nhờ vào công thức gọn gàng của ông Xcoder và JungHwan Min
Đã lưu thêm 3 nhờ vào ông Xcoder

(&3÷+

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

Giải trình

(      # negate input
 &     # AND with input
  3÷   # integer divide by 3
    +  # add to input

— Biểu tượng
nguồn

1

Có lẽ đáng nói đến việc chuyển câu trả lời Mathicala mang lại cho bạn 8 byte

— Ông Xcoder

@ Mr.Xcoder: Ồ, đó là một công thức gọn gàng.

— Emigna

1

Liệu 05ab1e có bitwise VÀ? Nếu vậy, (<bitwise and here>3÷+nên làm việc cho ~ 5 byte.

— Ông Xcoder

2

R , 71 58 byte

cảm ơn NofP cho -6 byte

function(n){n=n%/%(x=2^(0:31))%%2
n[!cumsum(n)]=1:0
n%*%x}

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

Giả sử đầu vào là số nguyên 32 bit. R chỉ ký số nguyên 32 bit (truyền tới doublekhi số nguyên tràn) dù sao và không có số nguyên 64 bit hoặc không dấu.

— Giuseppe
nguồn

Bạn có thể chuyển đổi which.max(n):1-1để !cumsum(n)để có được một giải pháp 65 byte

— NofP

@NofP cảm ơn! Đó là một ý tưởng tuyệt vời.

— Giuseppe

2

Brainfuck , 120 byte

>+<[[>-]++>[[>]>]<[>+>]<[<]>-]>[-<+>[-<[<]<]>]>[>]<[>+<[->+<]<[->+<]<]>>[<]+>[-[-<[->+<<+>]>[-<+>]]<[->++<]<[->+<]>>>]<<

Dùng thử trực tuyến!

Bắt đầu với giá trị trong ô hiện tại và kết thúc trên ô có giá trị đầu ra. Rõ ràng là sẽ không hoạt động trên các số trên 255 vì đó là giới hạn tế bào cho bộ não thông thường, nhưng sẽ hoạt động nếu bạn giả sử kích thước ô vô hạn.

— Jo vua
nguồn

1

PowerShell , 168 byte

param($n)$a=($c=[convert])::ToString($n,2);if(($x=[regex]::Match($a,'0+$').index)-gt0){$c::ToInt32(-join($a[0..($x-1)]+($a[$x..$a.length]|%{(0,1)[$i++%2]})),2)}else{$n}

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

Ôi. Chuyển đổi sang / từ cắt nhị phân và cắt mảng không thực sự phù hợp với PowerShell.

Lấy đầu vào $nlà một số. Chúng tôi ngay lập tức convertđể cơ sở nhị phân 2và lưu trữ mà vào $a. Tiếp theo chúng ta có một cấu trúc if / other. Mệnh đề if kiểm tra xem a regex Matchso với 1 hoặc nhiều 0s ở cuối chuỗi ( '0+$') có indextại vị trí lớn hơn 0(nghĩa là bắt đầu của chuỗi nhị phân) hay không. Nếu có, chúng ta có một cái gì đó để làm việc với,else chúng tôi chỉ cần xuất số.

Bên trong if, chúng ta cắt các xchữ số thứ nhất và ghép +các mảng với các chữ số còn lại. Tuy nhiên, đối với các chữ số còn lại, chúng tôi lặp qua chúng và chọn một 0hoặc 1là đầu ra thay vào đó, sử dụng $i++%2để chọn. Điều này cho chúng ta 010101...mô hình thay vì 0s ở cuối. Sau đó chúng tôi-join quay lại với nhau thành một chuỗi và chuyển $cnó trở lại thành một Int32cơ sở 2.

Trong cả hai trường hợp, số còn lại trên đường ống và đầu ra là ẩn.

— AdBorkBork
nguồn

1

APL + THẮNG, 43 byte

p←+/^\⌽~n←((⌊1+2⍟n)⍴2)⊤n←⎕⋄2⊥((-p)↓n),p⍴0 1

Lời nhắc cho màn hình nhập

— Graham
nguồn

1

PowerShell, 41 36 bytes

param($n)$n+(($x=$n-band-$n)-$x%3)/3

Try it online! or Verify all test cases

Port of Leaky Nun's Python answer.

Saved 5 bytes thanks to Leaky Nun

— AdmBorkBork
nguồn

1

PHP, 47 bytes

<?php function b($a){echo(int)(($a&-$a)/3)+$a;}

Try it online!

Really just another port of @Leaky Nun's solution

— NK1406
nguồn

1

Perl 5, 54 bytes

$_=sprintf'%b',<>;1while s/00(0*)$/01$1/;say oct"0b$_"

Try it online!

— Xcali
nguồn

1

Python 3, 56 bytes

lambda n:eval((bin(n).rstrip("0")+"01"*n)[:len(bin(n))])

Try it online!

Not really happy with this yet, but I really didn't want to use the formula... -2 thanks to Rod. -1 thanks to Jonathan Frech.

— Mr. Xcoder
nguồn

eval(...) instead of int(...,2) could save a byte.

— Jonathan Frech

1

Ruby, 15 bytes

Another port of Leaky Nun's approach.

->k{(k&-k)/3+k}

Try it online!

— Tom Lazar
nguồn

1

Rust, 18 bytes

A port of Leaky Nun's approach

|n:i32|(n&-n)/3+n;

Try it online!

— Noskcaj
nguồn

1

AWK, 24 bytes

A port of JungHwan Min's Mathmatica answer

$0=int(and($0,-$0)/3+$0)

Try it online!

— Noskcaj
nguồn

1

JavaScript ES6, 13 bytes

n=>(n&-n)/3|n

f = 
n=>(n&-n)/3|n
;
console.log (f(8));
console.log (f(243));
console.log (f(1048576));
console.log (f(33554432));

Expand snippet

— l4m2
nguồn

1

C, 56 bytes

i,k;f(n){for(k=i=1;n>>i<<i==n;k+=++i&1)k*=2;return n|k;}

Try it online!

C (gcc), 50 bytes

i,k;f(n){for(k=i=1;n>>i<<i==n;k+=++i&1)k*=2;k|=n;}

Try it online!

51 48 bytes using Arnauld's solution:

Thanks to @l4m2 for saving three bytes!

m;f(n){return n|((n&-n)&(m=-1u/3*2)?m:m/2)&n-1;}

Try it online!

43 with gcc:

m;f(n){m=n|((n&-n)&(m=-1u/3*2)?m:m/2)&n-1;}

Try it online!

— Steadybox
nguồn

0xAAAAAAAA => -1u/3*2

— l4m2

1

Pari/GP, 19 bytes

A port of Leaky Nun's approach.

n->n+bitand(n,-n)\3

Try it online!

— alephalpha
nguồn

0

Jelly, 13 bytes

BŒgṪµ2Ḷṁ×CḄ+³

Try it online!

Explanation

Take 24 as an example input.

BŒgṪµ2Ḷṁ×CḄ+³
B                Binary representation of the input → 11000
 Œg              Group runs of equal length → [[1,1],[0,0,0]]
   Ṫ             Tail → [0,0,0]
    µ            New monadic link
     2Ḷ          [0,1] constant
       ṁ         Mold [0,1] to the shape of [0,0,0] → [0,1,0]
        ×        Multiply [0,1,0] by...
         C       1-[0,0,0]. If last bit(s) of the original input are 1 this will add nothing to the original input
          Ḅ      Convert to decimal from binary → 2
           +³    Add this with the original input → 26

— dylnan
nguồn

Xen kẽ chút bôi nhọ

Giới thiệu

Thử thách

Quy tắc

Tủ thử

Python 3 , 20 byte

Giải trình

Thạch , 5 byte

Thạch , 7 byte

Ngôn ngữ Wolfram (Mathicala) , 36 28 26 24 byte

J , 19 18 byte

Giải thích nhanh

Câu trả lời khác:

Julia 0,6 , 12 byte

JavaScript (ES6), 40 39 byte

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

05AB1E , 13 8 5 byte

R , 71 58 byte

Brainfuck , 120 byte

PowerShell , 168 byte

APL + THẮNG, 43 byte

PowerShell, 41 36 bytes

PHP, 47 bytes

Perl 5, 54 bytes

Python 3, 56 bytes

Ruby, 15 bytes

Rust, 18 bytes

AWK, 24 bytes

JavaScript ES6, 13 bytes

C, 56 bytes

C (gcc), 50 bytes

Pari/GP, 19 bytes

Jelly, 13 bytes

J , ₁₉ 18 byte