정수 의 디지털 경도 를 찾으려면 이진 표현을 취하고으로 시작하거나 끝날 때까지 선행 및 후행 1을 제거 할 수있는 횟수를 계산하십시오 0. 제거 된 총 비트 수는 디지털 경도입니다.

그것은 꽤 간결한 설명입니다. 잘 작동하는 예를 들어 보겠습니다.

이 예에서는 숫자 3167을 사용합니다. 이진수로 다음과 같습니다.

110001011111

(이진수로 변환하는 동안 선행 0을 제거해야합니다.)

로 시작하거나 끝나지 0않으므로 1 쌍의 비트를 제거합니다.

1  1000101111  1

그리고 또 다른:

11  00010111  11

그러나 이제 시작 부분에 0이 있으므로 더 이상 1쌍을 제거 할 수 없습니다 . 총 4 비트를 제거 했으므로 4 는 3167 의 디지털 경도입니다 .

그러나 양수 n (즉 , 이진 표현 에만 포함)에 대해 2 ⁿ -1 로 쓸 수있는 숫자의 경우 0에 도달하지 않으므로 모든 비트를 제거 할 수 있습니다. 이것은 경도가 단순히 정수의 비트 길이라는 것을 의미합니다.1

도전

음수가 아닌 정수가 주어지면 n >= 0디지털 경도를 결정 하는 프로그램이나 함수를 작성해야합니다 .

I / O를 수행하는 전체 프로그램 또는 결과를 반환하는 함수를 제출할 수 있습니다. 귀하의 제출물은 n귀하의 언어의 표준 정수 범위 내의 값으로 작동해야 합니다.

테스트 사례

이 중 하나라도 부정확하거나 추가 할 엣지 케이스를 제안하려면 알려주십시오.

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

다음은 이러한 테스트 사례를 생성하는 데 사용 된 ungolfed Python 솔루션입니다 (버그가없는 것으로 보장되지는 않음).

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

젤리 , 11 10 바이트

BµQL××Ṛa\S

온라인으로 사용해보십시오!

작동 원리

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.

파이썬 , 76 69 68 63 62 60 57 바이트

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

온라인으로 사용해보십시오!

작동 원리

이것은 입력을 받아 재귀 해결책 N 및 증분 유지 K 에서 시작 - 0 - 동안 모두 LSB _K (N) (비트 인덱스에서 K 오른쪽)와 MSB의 _K (N) (인덱스의 비트 K 왼쪽) 설정됩니다. 완료되면 모든 n 비트가 설정 되면 k를 반환 하고 그렇지 않으면 2k를 반환합니다.

보조 변수 t를 사용 하여 람다 f 를 명명 된 함수 F 로 다시 작성해 봅시다 .

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

각 호출에 F , 첫번째 비트 시프트 우리 N 개의 케이 우측 부와의 결과 저장 t를 . 이런 식으로 LSB ₀ (t) = LSB _k (n) 이므로 LSB _k (n) 이 설정된 경우에만 t 가 홀수 입니다.

MSB _k (n)의 설정 여부를 결정하는 것은 약간 까다 롭습니다. 이것이 n & t > t >> 1달성하는 것입니다. 그것이 어떻게 작동하는지 설명하기 위해 비트 길이 8 의 정수 n = 1αβγδεζη ₂ 를 고려 하고 함수 호출 F (n, 3) , 즉 k = 3을 분석해 봅시다 .

우리는 비교의 진실 값 (n & t> t >> 1) = (1αβγδεζη ₂ & 1αβγδ ₂ > 1αβγ ₂ ) 을 조사하여 MSB ₃ (n) = γ 가 설정되어 있는지 확인하려고합니다 . 관련된 정수를 살펴 보자.

MSB-index  012k4567

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

t >> 1         1αβγ

n & t> t >> 1 인 경우에만 γ = 1 이라고 주장합니다 .

• 만약 γ = 1 다음, n은 t가 비트 길이 갖는 5 동안 t >> 1 비트 길이를 갖는 4 이므로 n은 t> t >> 1 .

  이는 γ = 1이 n & t> t >> 1 임을 의미 합니다.

• 경우 n은 t> t >> 1 , 두 가지가있다 : 하나 γ = 1 또는 γ = 0 . 첫 번째 경우에는 증명할 것이 없습니다.

  두 번째 경우에는 αβγδ ₂ ≥ n & t> t >> 1 = 1αβγ ₂ 입니다.

  이후 αβγδ ₂ > 1αβγ ₂ 우리가 있어야 MSB ₀ (αβγδ ₂ ) MSB ≥ ₀ (1αβγ ₂ ) , 즉 저 α = 1 .

  이런 식으로 1βγδ ₂ > 11βγ ₂ 이므로 MSB ₁ (1βγδ ₂ ) ≥ MSB ₁ (11βγ ₂ )을 가져야 합니다. 즉, β = 1 입니다.

  차례로, 이는 11γδ ₂ > 111γ _2를 의미합니다 . 두 번째 경우에 γ = 0 임을 기억 하면 부등식 110δ ₂ > 1110 _2를 얻습니다 . 이는 MSB ₂ (110δ ₂ ) = 0 <1 = MSB ₂ (1110 ₂ ) 이므로 false 입니다.

  따라서 첫 번째 경우 만 가능하며 n & t> t >> 1은 γ = 1을 의미 합니다.

요약하면 LSB _k (n) 과 MSB _k (n) 이 모두 설정되면 t 는 홀수이고 n & t> t >> 1 은 True 가되므로 t & (n & t> t >> 1) 은 수율 1 . 그러나 LSB _k (n) 또는 MSB _k (n) 이 설정되지 않은 경우 (또는 둘 다인 경우), t 는 짝수이거나 n & t> t >> 1 은 False 이므로 t & (n & t> t> > 1) 은 0이 됩니다.

단일 인수로 F 를 호출 하면 k = 0이 초기화 됩니다. 앞에서 논의한 조건이 유지되는 동안, 이후의 코드 and가 실행되는데 ,이 코드 는 (다른 것들 중에서) 증가 된 k로 F 를 재귀 적으로 호출합니다 .

일단 LSB _K (N) 또는 MSB의 _K (N)가 해제되면, 조건이 실패하고 F가 (N, K)를 반환 0 . 앞의 k 함수 호출 각각은 (n & (n + 1)> 0) + 1 을 F (n, k) = 0 을 더하므로 F (n) 은 ((n & (n + 1)> 0) + 1) k .

이제 n의 모든 비트 가 같으면 (즉, n 이 0 이거나 모든 비트가 설정된 경우) n + 1 은 n 과 공통 인 비트를 가지지 않으므로 n & (n + 1) = 0 이고 F (n) 은 k를 반환합니다 . 그러나 n 에 설정 및 설정 해제 비트가 모두 있으면 n & (n + 1)> 0 이고 F (n) 은 2k를 반환합니다 .

MATL , 13 12 바이트

Btv`6L&)}x@q

온라인으로 사용해보십시오! 또는 모든 테스트 사례를 확인하십시오 .

설명

이 코드는 각 이진수를 반복하고 두 개의 외부 숫자를 제거 할 수있는 횟수를 계산합니다.

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)

파이썬, 82 바이트

나는 아직도 골프를 칠 수 있다고 생각하지만 다른 방법을 시도하는 데 시간을 보냈으며 이것이 가장 짧았습니다.

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

온라인으로 사용해보십시오

이것은 OP의 Python 프로그램과 유사하게 작동하지만 Sandbox에서 질문을 본 후에 그러한 프로그램이 포함되지 않은 질문을 게시하기 전에 이것을 만들었습니다.

파이썬 2, 66 바이트

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

입력의 이진 표현을 1의 청크로 나눕니다. 첫 번째 청크와 마지막 청크 중 작은 것에서 1의 수를 세고 두 번 계산하는 단일 청크가 없으면 두 배로합니다.

PowerShell , 109106 바이트

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

온라인으로 사용해보십시오!

input $args[0]을 가져 convert와서 .NET 호출을 toStringbase 2(즉, 이진으로)로 사용 한 다음 -split해당 문자열을 0s에 저장합니다 $a. 주의 사항 : .NET 호출은 선행 0을 반환하지 않으므로 첫 번째 숫자는 항상입니다 1.

따라서 이진 문자열은 모두 1이거나 적어도 하나의 0이 있습니다. 우리는에 의해 의사 의사 삼진을 가진 사람들을 구별합니다 $a.count-eq1. 진 하나 이상의 제로, 왼쪽 케이스가있는 경우, 우리는 첫 번째의 길이의 최소 걸릴 [0]문자열 1의 마지막 [-1]문자열을 (발견 |sort후 [0]). 그 중 더 짧은 것은 우리가 제거 할 수있는 가장 많은 쌍이므로, 우리는 그것을 곱합니다 2. A의 원래 바이너리 문자열 끝이 경우주의 0, 입력처럼 8, 다음은 [-1].length도있을 것입니다 0곱한 (가 빈 문자열을 이후) 2아직 0.

그렇지 않으면 이진 문자열을 모두 사용하면 방금 가져 $b옵니다 (이전에 첫 번째 [0]문자열 의 길이 ,이 경우 이진 문자열의 전체 길이로 설정 됨 ).

두 경우 모두 해당 결과가 파이프 라인에 남아 있고 출력이 암시 적입니다.

자바 스크립트 (ES6), 57 바이트

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>

이진을 취하여 1s같은 수의 선행 및 후행과 일치 하거나 모두 실패합니다 1s.

레티 나 , 48 바이트

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

온라인으로 사용해보십시오

설명:

.+              # 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 바이트

경도를 반환하는 기능. 인수에서 정수를 가져옵니다.

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

글쎄, 오늘 나는 '1' + '1' = 98C #에서 발견했다 .

C, 89 88 85 바이트

@FlipTack이 쓸모없는 선언을 지적하여 2 바이트를 절약했습니다.

f()테스트 할 번호로 호출 하면 출력이 함수에서 반환됩니다.

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

ideone에서 사용해보십시오 .

자바 스크립트 (ES6), 59 58 바이트

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

테스트 사례

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

젤리 , 14 바이트

Eo2
BµŒg.ịṂS×Ç

온라인으로 사용해보십시오!

C, 137 132 122 119 117 114 98 94 92 87 85 바이트

골프를 시작할 시간 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;}

여기 증거가 있습니다

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

그리고 출력;

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

자바 (오픈 JDK) , 181 (156) 150 바이트

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

온라인으로 사용해보십시오!

Mathematica, 63 56 바이트

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

설명

l=#~IntegerDigits~2

로 감싸 진 입력의 기본 -2 표현을 생성하십시오 List. 저장l

(2-Min[...])

의 최소 ​​요소 l가 1이면 1을 출력합니다. 그렇지 않으면 2를 출력합니다.

Split[l]

분할 l실행에.

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

첫 번째 요소와 마지막 요소를 가져옵니다.

Tr/@ ...

두 가지를 모두 취하십시오.

Min[ ... ]

둘 사이에서 더 작은 것을 찾으십시오.

(첫 번째 결과 (1 또는 2)에이 결과를 곱하십시오).

옥타브, 56 54 바이트

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

온라인으로 사용해보십시오!

설명:

d=dec2bin(n)-48

이진 표현 n

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

누적 분을 취하십시오 d 와 반전의 누적 분d

res = cumd * cumfd ';

행렬 곱셈을하다

out = res*2^!all(d)

모든 자릿수가 1이면 2를 곱하십시오.

Pyth, 18 바이트

?*FJjQ2lJyhSxR0_BJ

정수를 입력 받아 결과를 출력하는 프로그램입니다.

테스트 스위트 (포맷을위한 첫 번째 라인)

작동 원리

?*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 바이트

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

테스트 사례 :

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

설명:

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

                         ⊢ 입력
                    2⊥⍣¯1 이진 표현으로 변환
   ()
        각 비트 및 반대편의 해당 비트에 대한 (⊢ ¨⌽)
            (∧) 논리 비트와 두 비트를 모두 취합니다.
             두 비트의 목록을 작성하십시오.
              ∧ 그런 다음 목록의 and를 가져와
         array 결과 배열을 평평하게
      ≢ ↑ 첫 N 비트 만 취합니다. 여기서 N은
                                원래 비트 목록의 길이
    logical \ 실행중인 논리를 취하고 (
                                시작하는 것)
+ / ∘ 합산

J, 22 바이트

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

이것은이 도전 에서 배운 깔끔한 트릭을 기반으로합니다 .

온라인으로 사용해보십시오!

설명

(#<.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 바이트

Jörg가 저장 한 3 + 6 바이트

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

STDIN에서 입력을받습니다. 로 실행하십시오 -nR.

고장

<?=                     # 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)

자바 스크립트 (ES6), 83 바이트

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

언 골프 드 :

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

수학, 62 바이트

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

순수한 기능 #첫 번째 인수를 나타내는 .

(h=0;...;h)&set h=0, 여러 가지 작업 ...을 수행 한 다음 h(경도) 를 반환합니다 . 많은 것들을 보자.

#~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

이 트릭 을 소개해 준 Greg Martin에게 감사합니다 .

하스켈 , 94 92 바이트

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

온라인으로 사용해보십시오!용법:

Prelude> sum.h.b $ 3167
4

설명 :
b 숫자를 이진으로 변환하고 0과 가장 중요도가 낮은 비트가 먼저있는 목록을 리턴합니다. 에서 h그리고,이 목록은 반전 소자는 와이즈 원래 목록 곱span(>0) 초기 분할 후 1S :

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

결과 튜플은 비어 있지 않은 목록과 일치하는 (c,_:_)위치 _:_와 패턴이 일치 하므로c = [1,1] . 바이트가 앞뒤로 제거되기 때문에 c++c = [1,1,1,1]반환되고 마지막으로 합산되어 디지털 경도 를 얻습니다. .

튜플의 두 번째 목록이 비어있는 경우 이진 표현에는 1 만 포함되며 1은 디지털 경도입니다. 패턴 일치에 실패하면을 h반환하고 n다시 요약합니다.

펄, 61 바이트

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

이것의 핵심은 /^(1+).*\1$/길이의 2 배가 답인 정규식 $1입니다. 나머지 코드는 오버 헤드이며 모든 1의 특별한 경우를 처리합니다.

PHP, 65 바이트

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

온라인 버전

CJam, 14 바이트

ri2b_0#\W%0#e<

설명:

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