Để tìm độ cứng kỹ thuật số của một số nguyên, lấy biểu diễn nhị phân của nó và đếm số lần cả dẫn và theo dõi 1có thể được loại bỏ cho đến khi bắt đầu hoặc kết thúc bằng a 0. Tổng số bit bị loại bỏ là độ cứng kỹ thuật số của nó.

Đó là một lời giải thích khá dài dòng - vì vậy hãy phá vỡ nó bằng một ví dụ hoạt động.

Trong ví dụ này, chúng tôi sẽ sử dụng số 3167. Trong nhị phân, đây là:

110001011111

(Lưu ý rằng, trong quá trình chuyển đổi thành nhị phân, bạn nên đảm bảo loại bỏ các số 0 đứng đầu)

Nó không bắt đầu hoặc kết thúc 0, vì vậy chúng tôi xóa 1 cặp bit:

1  1000101111  1

Và một cái khác:

11  00010111  11

Nhưng bây giờ có 0 ở đầu, vì vậy chúng tôi không thể xóa 1các cặp nữa . Tổng cộng, 4 bit chúng tôi đã loại bỏ và 4 là độ cứng kỹ thuật số 3167.

Tuy nhiên, đối với các số có thể được viết là 2 ⁿ -1 cho n dương (nghĩa là chỉ chứa 1trong biểu diễn nhị phân), sẽ không bao giờ đạt được 0 và vì vậy tất cả các bit có thể bị xóa. Điều này có nghĩa là độ cứng chỉ đơn giản là độ dài bit của tích phân.

Các thách thức

Nhiệm vụ của bạn là viết một chương trình hoặc hàm, với một số nguyên không âm n >= 0, xác định độ cứng kỹ thuật số của nó.

Bạn có thể gửi một chương trình đầy đủ thực hiện I / O hoặc một hàm trả về kết quả. Việc gửi của bạn phải hoạt động đối với các giá trị ntrong phạm vi số nguyên tiêu chuẩn của ngôn ngữ của bạn.

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

Vui lòng thông báo cho tôi nếu bất kỳ điều nào trong số này không chính xác hoặc nếu bạn muốn đề xuất bất kỳ trường hợp cạnh nào cần thêm.

0     -> 0
1     -> 1
8     -> 0
23    -> 2
31    -> 5
103   -> 4
127   -> 7
1877  -> 2
2015  -> 10

Đây là giải pháp Python không được sử dụng mà tôi đã sử dụng để tạo các trường hợp thử nghiệm này (không được bảo đảm là không có lỗi):

def hardness(num) -> int:
    binary = bin(num)[2:]

    if binary.count('0') == 0:
        return num.bit_length()

    revbin = binary[::-1]

    return min(revbin.find('0'), binary.find('0')) * 2

Thạch , 11 10 byte

BµQL××Ṛa\S

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

Làm thế nào nó hoạt động

BµQL××Ṛa\S  Main link. Argument: n

B           Binary; convert n to base 2.
 µ          Begin a new, monadic chain. Argument: A (array of binary digits)
  Q         Unique; deduplicate the digits.
   L        Length; count the unique digits.
    ×       Multiply each digit by the result.
     ×Ṛ     Multiply the results by reversed A.
       a\   Cumulative reduce by logical AND.
            This zeroes out all elements after the first zero.
         S  Compute the sum of the result.

Python , 76 69 68 63 62 60 57 byte

f=lambda n,k=0:n>>k&(n&n>>k>n>>k+1)and(n&n+1>0)-~f(n,k+1)

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

Làm thế nào nó hoạt động

Đây là một giải pháp đệ quy lấy đầu vào n và tiếp tục tăng k - bắt đầu từ 0 - trong khi cả LSB _k (n) (bit tại chỉ số k từ bên phải) và MSB _k (n) (bit tại chỉ số k từ bên trái) được thiết lập. Sau khi hoàn thành, nó trả về k nếu tất cả bit của n được đặt và 2k nếu không.

Hãy bắt đầu bằng cách viết lại lambda f dưới dạng hàm F được đặt tên , với một biến phụ t .

def F(n, k = 0):
    t = n >> k
    return t & (n & t > t >> 1) and (n & (n + 1) > 0) + 1 + F(n, k + 1)

Trong mỗi lần gọi F , đầu tiên chúng ta thay đổi bit n tổng cộng k đơn vị sang phải và lưu kết quả theo t . Theo cách này, LSB ₀ (t) = LSB _k (n) , vì vậy t là số lẻ khi và chỉ khi LSB _k (n) được đặt.

Xác định xem MSB _k (n) có được đặt hơi phức tạp không; đây là những gì n & t > t >> 1đạt được. Để minh họa cách thức hoạt động của nó, chúng ta hãy xem xét một số nguyên n = 1αβγδεζη ₂ có độ dài bit 8 và phân tích hàm gọi F (n, 3) , tức là k = 3 .

Chúng tôi đang cố gắng xác định xem MSB ₃ (n) = có được đặt hay không bằng cách kiểm tra giá trị thật của phép so sánh (n & t> t >> 1) = (1αβγδεζη ₂ & 1αβγδ ₂ > 1αβγ ₂ ) . Hãy xem xét các số nguyên liên quan.

MSB-index  012k4567

n          1αβγδεζη
t             1αβγδ

t >> 1         1αβγ

Chúng tôi tuyên bố rằng γ = 1 khi và chỉ khi n & t> t >> 1 .

• Nếu = 1 , thì n & t có độ dài bit 5 trong khi t >> 1 có độ dài bit 4 , vì vậy n & t> t >> 1 .

  Điều này chứng tỏ rằng = 1 ngụ ý n & t> t >> 1 .

• Nếu n & t> t >> 1 , có hai tùy chọn: = 1 hoặc γ = 0 . Trong trường hợp đầu tiên, không còn gì để chứng minh.

  Trong trường hợp thứ hai, chúng ta có α ₂ ≥ n & t> t >> 1 = 1αβγ ₂ .

  Vì αβγδ ₂ > 1αβγ ₂ , chúng ta phải có MSB ₀ (αβγδ ₂ ) MSB ₀ (1αβγ ₂ ) , nghĩa là α = 1 .

  Theo cách này, 1βγδ ₂ > 11βγ ₂ , vì vậy chúng ta phải có MSB ₁ (1βγδ ₂ ) MSB ₁ (11βγ ₂ ) , nghĩa là β = 1 .

  Đổi lại, điều này ngụ ý rằng 11γδ ₂ > 111γ ₂ . Hãy nhớ rằng γ = 0 trong trường hợp thứ hai, chúng ta nhận được bất đẳng thức 110δ ₂ > 1110 ₂ , sai vì MSB ₂ (110δ ₂ ) = 0 <1 = MSB ₂ (1110 ₂ ) .

  Do đó, chỉ có trường hợp đầu tiên là có thể và n & t> t >> 1 ngụ ý γ = 1 .

Tóm tắt, nếu cả LSB _k (n) và MSB _k (n) được đặt, t sẽ là số lẻ và n & t> t >> 1 sẽ là True , vì vậy t & (n & t> t >> 1) sẽ năng suất 1 . Tuy nhiên, nếu LSB _k (n) hoặc MSB _k (n) không được đặt (hoặc nếu cả hai đều), t sẽ chẵn hoặc n & t> t >> 1 sẽ là Sai , vì vậy t & (n & t> t> > 1) sẽ mang lại 0 .

Gọi F với một đối số duy nhất khởi tạo k = 0 . Trong khi điều kiện chúng ta đã thảo luận giữ trước đó, mã sau andđược thực thi, mà (trong số những thứ khác) gọi đệ quy F với tăng k .

Khi LSB _k (n) hoặc MSB _k (n) không được đặt, điều kiện không thành công và F (n, k) trả về 0 . Mỗi lệnh gọi hàm k trước sẽ thêm (n & (n + 1)> 0) + 1 đến F (n, k) = 0 , do đó F (n) trả về ((n & (n + 1)> 0) + 1) k .

Bây giờ, nếu tất cả các bit của n bằng nhau (nghĩa là, nếu n là 0 hoặc tất cả các bit của nó được đặt), n + 1 sẽ không có bất kỳ bit nào chung với n , vì vậy n & (n + 1) = 0 và F (n) trả về k . Tuy nhiên, nếu n có cả bit set và unset, n & (n + 1)> 0 và F (n) trả về 2k .

MATL , 13 12 byte

Btv`6L&)}x@q

Hãy thử trực tuyến! Hoặc xác minh tất cả các trường hợp thử nghiệm .

Giải trình

Mã lặp lại mỗi chữ số nhị phân và tính số lần có thể loại bỏ hai số bên ngoài.

B        % Input number (implicit). Horizontal vector of binary digits
tv       % Duplicate and concatenate vertically
`        % Do...while
  6L&)   %   Flatten the array if needed (in column-major order), and split it
         %   into two subarrays: one with the inner entries, and another
         %   with the two outer entries. The latter will be used for deciding
         %   if the loop continues or is exited
}        % Finally (execute before exiting the loop)
  x      %   Delete last subarray of inner entries
  @q     %   Push last iteration index minus 1
         % End (implicit). The next iterarion is executed if the array at the
         % top of the stack is non-empty and only contains nonzero values. 
         % Otherwise the loop is exited, executing the "finally" block first
         % Display (implicit)

Python, 82 byte

Tôi cảm thấy như nó vẫn có thể được chơi gôn, nhưng tôi đã dành một thời gian để thử các phương pháp khác nhau và đây là cách ngắn nhất.

def f(n):b=bin(n)[2:];x=min(b.find('0'),b[::-1].find('0'));print(x<0)*len(b)or x*2

Dùng thử trực tuyến

Mặc dù điều này hoạt động tương tự như chương trình Python của OP, tôi đã tạo nó trước khi câu hỏi được đăng, sau khi xem câu hỏi trong Hộp cát, không chứa chương trình như vậy.

Python 2, 66 byte

s=bin(input())[2:].split('0')
print len(min(s[-1],s[0]))<<1%len(s)

Chia đại diện nhị phân của đầu vào thành các phần của 1. Đếm số lượng 1 trong phần nhỏ hơn của phần đầu tiên và phần cuối cùng, sau đó nhân đôi số đó, trừ khi có một phần duy nhất mà số này sẽ nhân đôi.

PowerShell , 109 106 byte

$a=[convert]::ToString($args[0],2)-split0;(((($b=$a[0].length),$a[-1].length|sort)[0]*2),$b)[$a.count-eq1]

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

Nhận đầu vào $args[0], sử dụng lệnh gọi .NET với convertnó toStringvới cơ sở 2(nghĩa là biến nó thành nhị phân), sau đó -splits chuỗi đó trên 0s, lưu trữ nó vào $a. Điều quan trọng cần lưu ý: cuộc gọi .NET không trả về các số 0 đứng đầu, vì vậy chữ số đầu tiên luôn là a 1.

Do đó, có hai khả năng - chuỗi nhị phân là tất cả các khả năng, hoặc có ít nhất một số không. Chúng tôi phân biệt giữa những người có một giả ba chỉ số bởi $a.count-eq1. Nếu nhị phân có ít nhất một số 0, trường hợp bên trái, chúng ta lấy tối thiểu độ dài của [0]chuỗi đầu tiên của 1s và [-1]chuỗi cuối cùng (được tìm thấy bởi |sortvà sau đó [0]). Ngắn hơn trong số đó là hầu hết các cặp chúng tôi có thể loại bỏ, vì vậy chúng tôi nhân số đó với 2. Lưu ý rằng nếu chuỗi nhị phân ban đầu kết thúc bằng một 0, như đối với đầu vào 8, thì chuỗi [-1].lengthcũng sẽ là 0(vì đó là một chuỗi trống), khi nhân với 2vẫn là 0.

Mặt khác, với tất cả các chuỗi nhị phân, chúng ta chỉ lấy $b(trước đây được đặt là độ dài của [0]chuỗi đầu tiên , trong trường hợp này là toàn bộ chuỗi nhị phân).

Trong cả hai trường hợp, kết quả đó được để lại trên đường ống và đầu ra là ẩn.

JavaScript (ES6), 57 byte

f=
n=>n.toString(2).replace(/^(1*)(.*(\1))?$/,'$1$3').length

<input oninput=o.value=1/this.value?f(+this.value):''><input id=o readonly>

Lấy nhị phân và cố gắng khớp tất cả 1shoặc không thành công với số lượng dẫn và dấu bằng nhau 1s.

Võng mạc , 48 byte

.+
$*
+`(1+)\1
$1o
o1
1
m(+`^1(.*)1$
xx¶$1
x|^1$

Dùng thử trực tuyến

Giải trình:

.+              # Convert to unary
$*
+`(1+)\1        # Convert to binary (but with `o` instead of `0` -- it's shorter)
$1o
o1
1
m(+`^1(.*)1$    # Replace pairs of surrounding ones with `xx`
xx¶$1
x|^1$,          # Count x's, including the possibility of a single remaining `1`

C #, 133 byte

Chức năng trả về độ cứng. Lấy số nguyên từ đối số.

int h(int b){var n=Convert.ToString(b,2);for(b=0;;){if(n[0]+n[n.Length-1]==98)n=n.Substring(1,n.Length-2);else break;b+=2;}return b;}

Chà, hôm nay tôi phát hiện ra '1' + '1' = 98trong C #.

C, 89 88 85 byte

Đã lưu hai byte do @FlipTack chỉ ra một tuyên bố vô dụng.

Gọi f()với số để kiểm tra, đầu ra được trả về từ hàm.

t,h;f(l){for(t=l;t&&~t&1<<30;t*=2);for(h=0;t&1<<30&&l&1;t*=2,l/=2)++h;return h<<!!l;}

Hãy thử nó trên ideone .

JavaScript (ES6), 59 58 byte

f=(n,m=1<<30)=>m>n?f(n,m/2):m>1?n&m&&n&1&&2+f(n/2,m/4):n&1

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

f=(n,m=1<<30)=>m>n?f(n,m/2):m>1?n&m&&n&1&&2+f(n/2,m/4):n&1

console.log(
  [0, 1, 8, 23, 31, 103, 127, 1877, 2015].map(
    n => n + ' -> ' + f(n)
  ).join('\n')
)

Thạch , 14 byte

Eo2
BµŒg.ịṂS×Ç

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

C, 137 132 122 119 117 114 98 94 92 87 85 byte

Thời gian bắt đầu chơi golf B-)

i,j;f(n){for(i=1<<30;i&~n;i/=2);for(j=0;n&i;n/=2,i/=4)j+=~n&1?i=0:2;return j-=n<1*j;}

Đây là bằng chứng

main()
{
  printf("%d %d\n", 0, f(0));
  printf("%d %d\n", 1, f(1));
  printf("%d %d\n", 8, f(8));
  printf("%d %d\n", 23, f(23));
  printf("%d %d\n", 31, f(31));
  printf("%d %d\n", 103, f(103));
  printf("%d %d\n", 127, f(127));
  printf("%d %d\n", 1877, f(1877));
  printf("%d %d\n", 2015, f(2015));
  printf("%d %d\n", 3167, f(3167));
} 

và đầu ra;

0 0
1 1
8 0
23 2
31 5
103 4
127 7
1877 2
2015 10
3167 4 

Java (OpenJDK) , 181 156 150 byte

n->{int i=0;String s=n.toString(n,2);if(s.matches("1*"))i=s.length();else for(;!s.matches("(.*0)|(0.*)");s=s.substring(1,s.length()-1))i+=2;return i;}

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

Toán học, 63 56 byte

(2-Min[l=#~IntegerDigits~2])Min[Tr/@Split[l][[{1,-1}]]]&

Giải trình

l=#~IntegerDigits~2

Tạo đại diện cơ sở-2 của đầu vào, được bọc bằng a List. Lưu trữ trongl

(2-Min[...])

Nếu phần tử tối thiểu llà 1, đầu ra 1. Nếu không, đầu ra 2. Nhân số này với ...

Split[l]

Chia lthành chạy.

... [[{1,-1}]]

Lấy yếu tố đầu tiên và cuối cùng.

Tr/@ ...

Lấy tổng số của cả hai.

Min[ ... ]

Tìm cái nhỏ hơn giữa hai cái.

(Nhân kết quả đầu tiên (1 hoặc 2) với kết quả này).

Octave, 56 54 byte

 @(n)cummin(d=dec2bin(n)-48)*cummin(flip(d))'*2^!all(d)

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

Giải trình:

d=dec2bin(n)-48

đại diện nhị phân của n

cumd= cummin(d);
cumfd = cummin(flip(d));

Lấy tối thiểu tích lũy d và tích lũy tối thiểu của lậtd

res = cumd * cumfd ';

nhân ma trận

out = res*2^!all(d)

nhân với 2 nếu tất cả các chữ số là 1;

Bình thường, 18 byte

?*FJjQ2lJyhSxR0_BJ

Một chương trình lấy đầu vào của một số nguyên và in kết quả.

Bộ kiểm tra (Dòng đầu tiên để định dạng)

Làm thế nào nó hoạt động

?*FJjQ2lJyhSxR0_BJ  Program. Input: Q
?                   If
  F                 reducing
    jQ2             the binary representation of Q as a list
   J                (store in J)
 *                  by multiplication is truthy:
       lJ            Yield len(J)
                    Else:
          hS         Yield the minimum
            xR0      of the first index of zero
               _BJ   in J and its reverse
         y           * 2
                    Implicitly print

APL, 26 byte

+/∘(∧\≢↑(∊⊢(,∧∧)¨⌽))2⊥⍣¯1⊢

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

      ( +/∘(∧\≢↑(∊⊢(,∧∧)¨⌽))2⊥⍣¯1⊢ ) ¨ 0 1 8 23 31 103 127 1877 2015    
0 1 0 2 5 4 7 2 10

Giải trình:

+ / ∘ (∧ \ ≢ ↑ (∊⊢ (, ∧∧)))) 2⊥⍣¯1⊢

                         Đầu vào
                    2⊥⍣¯1 chuyển đổi sang biểu diễn nhị phân
   ()
        (¨⌽) cho mỗi bit và bit khớp của nó ở phía bên kia
            (∧) lấy logic và của cả hai bit,
             , tạo một danh sách của cả hai bit,
              Sau đó lấy và của danh sách và
         Làm phẳng mảng kết quả
      ≢ chỉ lấy N bit đầu tiên, trong đó N là
                                độ dài của danh sách bit gốc
    ∧ \ chạy logic và (chỉ để lại
                                bắt đầu)
+ / Tổng hợp những

J, 22 byte

(#<.2*(<.&(#.~)|.))@#:

Điều này dựa trên thủ thuật gọn gàng học được từ thử thách này .

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

Giải trình

(#<.2*(<.&(#.~)|.))@#:  Input: integer n
                    #:  Binary digits of n
(                 )@    Operate on those digits D
               |.         Reverse D
       <.                 Take the minimum of
         &(#.~)           the "trailing truths" of D and reverse(D)
    2*                    Multiply by 2
 #                        The length of D
  <.                      Minimum of length and the previous result

PHP, 83 74 byte

3 + 6 byte được lưu bởi Jörg

<?=(~$s=decbin($argn))[$a=strspn($s,1)]?min($a,strspn(strrev($s),1))*2:$a;

lấy đầu vào từ STDIN; chạy với -nR.

phá vỡ

<?=                     # print ...
(~
    $s=decbin($argn)        # $s = binary representation of input
)[
    $a=strspn($s,1)         # $a = number of leading `1`s
]                           # if $s has more than $a digits,
?   min($a,                     # 2. minimum of $a and
        strspn(strrev($s),1)    # 1. number of trailing `1`s
    )*2                         # 3. *2
:   $a                      # else $a (==strlen)

JavaScript (ES6), 83 byte

f=x=>(y=x.toString(2),y.match(/^1*$/)?y:([s,e]=y.match(/^1*|1*$/g),s<e?s:e)).length

Ung dung:

function f(n) {
    var binStr = n.toString(2);
    if(binStr.match(/^1*$/)) {
        // If binary representation is all 1s, return length of binary
        return binStr.length;
    } else {
        // Grab the starting and ending 1s in the binary representation
        var [start1s, end1s] = binStr.match(/^1*|1*$/g);
        var startHardness = start1s.length;
        var endHardness = end1s.length;
        return Math.min(startHardness, endHardness);
    }
}

Toán học, 62 byte

(h=0;#~IntegerDigits~2//.{{1,m___,1}:>(h+=2;{m}),{1}:>h++};h)&

Hàm thuần túy #đại diện cho đối số đầu tiên.

(h=0;...;h)&thiết lập h=0, thực hiện một loạt các công cụ ..., sau đó trả về h(độ cứng). Hãy nhìn vào đống thứ:

#~IntegerDigits~2                                     Binary representation of the input
                 //.                                  Apply the following list of rules repeatedly until there is no change
                    {                                 Start of the list of rules
                     {1,m___,1}                       If you see a list starting and ending with 1 with the sequence m (possibly empty) in between
                               :>(h+=2;{m}),            replace it with just {m} after incrementing h twice.
                                            {1}       If you see the singleton list {1}
                                               :>h++    replace it with h, then increment h.
                                                    } End of the list of rules

Cảm ơn Greg Martin đã giới thiệu cho tôi thủ thuật này .

Haskell , 94 92 byte

b 0=[]
b n=mod n 2:b(div n 2)
h n|(c,_:_)<-span(>0)$zipWith(*)n$reverse n=c++c|1<3=n
sum.h.b

Hãy thử trực tuyến! Sử dụng:

Prelude> sum.h.b $ 3167
4

Giải thích:
b chuyển đổi một số thành nhị phân và trả về một danh sách 0 và các số có bit ít quan trọng nhất trước tiên. Trong đó h, danh sách này được đảo ngược và nhân phần tử nhân với danh sách ban đầu, sau đó span(>0)phân tách sau 1s ban đầu :

       b 3167 = [1,1,1,1,1,0,1,0,0,0,1,1] = n
    reverse n = [1,1,0,0,0,1,0,1,1,1,1,1] = m
zipWith(*)n m = [1,1,0,0,0,0,0,0,0,0,1,1] = z
   span(>0) z = ([1,1],[0,0,0,0,0,0,0,0,1,1])

Bộ dữ liệu kết quả là mẫu phù hợp với (c,_:_)nơi _:_khớp với bất kỳ danh sách không trống nào, vì vậy c = [1,1]. Bởi vì các byte được loại bỏ ở phía trước và phía sau, c++c = [1,1,1,1]được trả lại và cuối cùng được tổng hợp để mang lại độ cứng kỹ thuật số .

Nếu danh sách thứ hai của tuple trống, thì biểu diễn nhị phân chỉ chứa những cái và số lượng là độ cứng kỹ thuật số. Với mô hình khớp lệnh htrả về thất bại chỉ n, một lần nữa được tóm tắt.

Perl, 61 byte

sub f{$_=sprintf('%b',pop);length(/0/?/^(1+).*\1$/&&$1x2:$_)}

Trung tâm của điều này là regex /^(1+).*\1$/trong đó 2 lần độ dài $1là câu trả lời. Phần còn lại của mã là chi phí chung và xử lý trường hợp đặc biệt của tất cả 1.

PHP, 65 byte

<?=strlen(preg_filter('#^(1*)(.*(\1))?$#',"$1$3",decbin($argn)));

Phiên bản trực tuyến

CJam, 14 byte

ri2b_0#\W%0#e<

Giải trình:

ri e# Read integer:      | 3167
2b e# Convert to binary: | [1 1 0 0 0 1 0 1 1 1 1 1]
_  e# Duplicate:         | [1 1 0 0 0 1 0 1 1 1 1 1] [1 1 0 0 0 1 0 1 1 1 1 1]
0# e# Index of first 0:  | [1 1 0 0 0 1 0 1 1 1 1 1] 2
\  e# Swap:              | 2 [1 1 0 0 0 1 0 1 1 1 1 1]
W% e# Reverse:           | 2 [1 1 1 1 1 0 1 0 0 0 1 1]
0# e# Index of first 0:  | 2 5
e< e# Minimum:           | 2