Проблема:

Найти число лидирующих нулей в 64-разрядном целом числе со знаком

Правила:

• Ввод не может рассматриваться как строка; это может быть что угодно, где математические и побитовые операции управляют алгоритмом
• Вывод должен быть проверен на соответствие 64-битному целому числу со знаком, независимо от языка
• Применяются правила игры в гольф по умолчанию
• Самый короткий код в байтах выигрывает

Тестовые случаи:

Эти тесты предполагают два дополненных числа со знаком. Если в вашем языке / решении отсутствует или используется другое представление целых чисел со знаком, сообщите об этом и предоставьте дополнительные тестовые примеры, которые могут иметь отношение к делу. Я включил несколько тестов, которые касаются двойной точности, но, пожалуйста, не стесняйтесь предлагать любые другие, которые должны быть перечислены.

input                output   64-bit binary representation of input (2's complement)
-1                   0        1111111111111111111111111111111111111111111111111111111111111111
-9223372036854775808 0        1000000000000000000000000000000000000000000000000000000000000000
9223372036854775807  1        0111111111111111111111111111111111111111111111111111111111111111
4611686018427387903  2        0011111111111111111111111111111111111111111111111111111111111111
1224979098644774911  3        0001000011111111111111111111111111111111111111111111111111111111
9007199254740992     10       0000000000100000000000000000000000000000000000000000000000000000
4503599627370496     11       0000000000010000000000000000000000000000000000000000000000000000
4503599627370495     12       0000000000001111111111111111111111111111111111111111111111111111
2147483648           32       0000000000000000000000000000000010000000000000000000000000000000
2147483647           33       0000000000000000000000000000000001111111111111111111111111111111
2                    62       0000000000000000000000000000000000000000000000000000000000000010
1                    63       0000000000000000000000000000000000000000000000000000000000000001
0                    64       0000000000000000000000000000000000000000000000000000000000000000

машинный язык x86_64 в Linux, 6 байт

0:       f3 48 0f bd c7          lzcnt  %rdi,%rax
5:       c3                      ret

Требуется процессор Haswell или K10 или выше с lzcntинструкцией.

Попробуйте онлайн!

Гексагония , 78 70 байт

2"1"\.}/{}A=<\?>(<$\*}[_(A\".{}."&.'\&=/.."!=\2'%<..(@.>._.\=\{}:"<><$

Попробуйте онлайн!

Разве этот вызов не слишком тривиален для практического языка? ;)

_{длина стороны 6. Я не могу вписать это в длину стороны 5 шестиугольников.}

объяснение

Python , 31 байт

lambda n:67-len(bin(-n))&~n>>64

Попробуйте онлайн!

Экспрессон является побитовым &из двух частей:

67-len(bin(-n)) & ~n>>64

Это 67-len(bin(-n))дает правильный ответ для неотрицательных входных данных. Он берет длину в битах и ​​вычитает из 67, что на 3 больше, чем 64, чтобы компенсировать -0bпрефикс. Отрицание - это трюк, который нужно приспособить для n==0использования того, что отрицание не производит -знак впереди.

& ~n>>64Делает ответ вместо этого 0для негатива n. Когда n<0, ~n>>64равно 0 (на 64-битных целых числах), то и с ним дает 0. Когда n>=0, ~n>>64оценивает -1, и выполнение не &-1имеет никакого эффекта.

Python 2 , 36 байт

f=lambda n:n>0and~-f(n/2)or(n==0)*64

Попробуйте онлайн!

Арифметическая альтернатива.

Ява 8, 32 26 байт.

Long::numberOfLeadingZeros

Встроенные FTW.

-6 байт благодаря Кевину Круйссену

Попробуйте онлайн!

C (gcc) , 14 байтов

__builtin_clzl

Отлично работает на тио

C (gcc) , 35 29 байт

f(long n){n=n<0?0:f(n-~n)+1;}

Попробуйте онлайн!

Чем Деннис за 6 байтов

Флаги компилятора C (gcc) , 29 байт, Дэвид Фёрстер

-Df(n)=n?__builtin_clzl(n):64

Попробуйте онлайн!

Perl 6 , 35 28 26 байт

-2 байта благодаря nwellnhof

{to .fmt("%064b")~~/^0*/:}

Попробуйте онлайн!

Блок анонимного кода, который принимает число и возвращает число. Это преобразует число в двоичную строку и считает начальные нули. Это работает для отрицательных чисел, потому что первый символ, -например -00000101, так что нет начальных нулей.

Объяснение:

{                        }  # Anonymous code block
    .fmt("%064b")           # Format as a binary string with 64 digits
                 ~~         # Smartmatch against
                   /^0*/    # A regex counting leading zeroes
 to                     :   # Return the index of the end of the match

JavaScript (Node.js) , 25 байт

Принимает входные данные как литерал BigInt.

f=x=>x<0?0:x?f(x/2n)-1:64

Попробуйте онлайн!

$0$

Python 3 , 34 байта

f=lambda n:-1<n<2**63and-~f(2*n|1)

Попробуйте онлайн!

J , 18 байт

0{[:I.1,~(64$2)#:]

Попробуйте онлайн!

J , 19 байт

1#.[:*/\0=(64$2)#:]

Попробуйте онлайн!

Объяснение:

                #:  - convert 
                  ] - the input to
          (64$2)    - 64 binary digits
         =          - check if each digit equals 
        0           - zero
   [:*/\            - find the running product
1#.                 - sum

Perl 6 , 18 байт

-2 байта благодаря Джо Кингу

64-(*%2**64*2).msb

Попробуйте онлайн!

Рубин , 22 байта

->n{/[^0]/=~"%064b"%n}

Попробуйте онлайн!

05AB1E , 10 9 байтов

·bg65αsd*

I / O оба целые

Попробуйте онлайн или проверьте все контрольные примеры .

Объяснение:

·         # Double the (implicit) input
          #  i.e. -1 → -2
          #  i.e. 4503599627370496 → 9007199254740992
 b        # Convert it to binary
          #  i.e. -2 → "ÿ0"
          #  i.e. 9007199254740992 → 100000000000000000000000000000000000000000000000000000
  g       # Take its length
          #  i.e. "ÿ0" → 2
          #  i.e. 100000000000000000000000000000000000000000000000000000 → 54
   65α    # Take the absolute different with 65
          #  i.e. 65 and 2 → 63
          #  i.e. 65 and 54 → 11
      s   # Swap to take the (implicit) input again
       d  # Check if it's non-negative (>= 0): 0 if negative; 1 if 0 or positive
          #  i.e. -1 → 0
          #  i.e. 4503599627370496 → 1
        * # Multiply them (and output implicitly)
          #  i.e. 63 and 0 → 0
          #  i.e. 11 and 1 → 11

Haskell , 56 байт

^{Спасибо xnor за обнаружение ошибки!}

f n|n<0=0|1>0=sum.fst.span(>0)$mapM(pure[1,0])[1..64]!!n

Выделите достаточно памяти, попробуйте онлайн!

Может быть, вы хотите проверить это с меньшей константой: попробуйте 8-бит!

объяснение

mapM(pure[0,1])[1..64]mapM(pure[1,0])[1..64]$\lbrace0,1\rbrace^{64}$$1$sum.fst.span(>0)

Powershell, 51 байт

param([long]$n)for(;$n-shl$i++-gt0){}($i,65)[!$n]-1

Тестовый скрипт:

$f = {

param([long]$n)for(;$n-shl$i++-gt0){}($i,65)[!$n]-1

}

@(
    ,(-1                   ,0 )
    ,(-9223372036854775808 ,0 )
    ,(9223372036854775807  ,1 )
    ,(4611686018427387903  ,2 )
    ,(1224979098644774911  ,3 )
    ,(9007199254740992     ,10)
    ,(4503599627370496     ,11)
    ,(4503599627370495     ,12)
    ,(2147483648           ,32)
    ,(2147483647           ,33)
    ,(2                    ,62)
    ,(1                    ,63)
    ,(0                    ,64)
) | % {
    $n,$expected = $_
    $result = &$f $n
    "$($result-eq$expected): $result"
}

Выход:

True: 0
True: 0
True: 1
True: 2
True: 3
True: 10
True: 11
True: 12
True: 32
True: 33
True: 62
True: 63
True: 64

Java 8, 38 байт

int f(long n){return n<0?0:f(n-~n)+1;}

Ввести как long(64-разрядное целое), вывести как int(32-разрядное целое).

Порт ответа @ l4m2 C (gcc) .

Попробуйте онлайн.

Объяснение:

 int f(long n){       // Recursive method with long parameter and integer return-type
   return n<0?        //  If the input is negative:
           0          //   Return 0
          :           //  Else:
           f(n-~n)    //   Do a recursive call with n+n+1
                  +1  //   And add 1

РЕДАКТИРОВАТЬ: может быть 26 байтов с помощью встроенного, Long::numberOfLeadingZerosкак показано в ответе @lukeg Java 8 .

APL + WIN, 34 байта

+/×\0=(0>n),(63⍴2)⊤((2*63)××n)+n←⎕

Объяснение:

n←⎕ Prompts for input of number as integer

((2*63)××n) If n is negative add 2 to power 63

(63⍴2)⊤ Convert to 63 bit binary

(0>n), Concatinate 1 to front of binary vector if n negative, 0 if positive

+/×\0= Identify zeros, isolate first contiguous group and sum if first element is zero

C # (интерактивный компилятор Visual C #) , 42 байта

x=>x!=0?64-Convert.ToString(x,2).Length:64

Попробуйте онлайн!

C # (интерактивный компилятор Visual C #) , 31 байт

int c(long x)=>x<0?0:c(x-~x)+1;

Еще короче, основываясь на ответе C (gcc) @ l4m2. Никогда не знал, что можно объявить такие функции, спасибо @Dana!

Попробуйте онлайн!

Желе ,  10  9 байт

-1 благодаря изящному трюку Эрика Аутгольфера (теперь он неотрицателен AƑ)

ḤBL65_×AƑ

Монадическая ссылка, принимающая целое число (в пределах диапазона), которое дает целое число.

Попробуйте онлайн! Или посмотрите набор тестов .

10 было ḤBL65_ɓ>-×

Вот еще одно 10-байтовое решение, которое мне нравится, так как оно говорит, что это «BOSS» ...

BoṠS»-~%65

Тест-сьют здесь

... BoṠS63r0¤i, BoṠS63ŻṚ¤iили BoṠS64ḶṚ¤iбудет также работать.

Еще 10 байтов (от Дениса) есть æ»64ḶṚ¤Äċ0(опять æ»63r0¤Äċ0и æ»63ŻṚ¤Äċ0тоже будет работать)

Perl 5 , 37 байт

sub{sprintf("%064b",@_)=~/^0*/;$+[0]}

Попробуйте онлайн!

Или это 46 байтов, если «stringification» не допускается: sub z

sub{my$i=0;$_[0]>>64-$_?last:$i++for 1..64;$i}

Swift (на 64-битной платформе), 41 байт

Объявляет вызванное замыкание, fкоторое принимает и возвращает Int. Это решение работает только правильно 64-разрядные платформы, где Intнаходится typealiasЭда Int64. (На 32-битной платформе Int64может использоваться явно для типа параметра замыкания, добавляя 2 байта.)

let f:(Int)->Int={$0.leadingZeroBitCount}

В Swift даже основной целочисленный тип является обычным объектом, объявленным в стандартной библиотеке. Это средство Intможет иметь методы и свойства, такие как leadingZeroBitCount(что требуется для всех типов, соответствующих FixedWidthIntegerпротоколу стандартной библиотеки ).

Haskell , 24 байта

f n|n<0=0
f n=1+f(2*n+1)

Попробуйте онлайн!

По сути, это то же самое, что и Java-решение Кевина Круйссена, но я нашел его независимо.

Аргумент должен иметь тип Intдля 64-битной сборки или Int64для чего угодно.

объяснение

Если аргумент отрицательный, результат сразу равен 0. В противном случае мы сдвигаемся влево, заполняя единицы , пока не достигнем отрицательного числа. Это заполнение позволяет нам избежать специального случая для 0.

Просто для справки, вот очевидный / эффективный способ:

34 байта

import Data.Bits
countLeadingZeros

Чистый , 103 байта

Использует то же «встроенное», что и потолочный ответ.

f::!Int->Int
f _=code {
instruction 243
instruction 72
instruction 15
instruction 189
instruction 192
}

Попробуйте онлайн!

Чистый , 58 байт

import StdEnv
$0=64
$i=until(\e=(2^63>>e)bitand i<>0)inc 0

Попробуйте онлайн!

Stax , 10 байт

în»╧3(∞┼⌠g

Запустите и отладьте его

Это порт решения Кевина 05AB1E.

Perl 5 -p , 42 байта

1while$_>0&&2**++$a-1<$_;$_=0|$_>=0&&64-$a

Попробуйте онлайн!

Больше, чем решение на основе цепочек, но достойное математическое решение.

APL (NARS), 15 символов, 30 байтов

{¯1+1⍳⍨⍵⊤⍨64⍴2}

проверить несколько номеров, чтобы увидеть, как использовать:

  f←{¯1+1⍳⍨⍵⊤⍨64⍴2}
  f ¯9223372036854775808
0
  f 9223372036854775807
1

Ржавчина, 18 байт

i64::leading_zeros

Попробуйте онлайн!

K (нгн / к) , 6 байтов

64-#2\

Попробуйте онлайн!

2\ закодировать аргумент в двоичном

# длина

64- вычесть из 64

PHP, 50 46 байт

for(;0<$n=&$argn;$n>>=1)$i++;echo$n<0?0:64-$i;

Запустите как трубу -Rили попробуйте онлайн ,

<?=$argn<0?0:0|64-log($argn+1,2);имеет проблемы с округлением; так что я прошел долгий путь.

Wolfram Language (Mathematica) , 41 байт

Формула для положительных чисел просто 63-Floor@Log2@#&. Правила замены используются для особых случаев нулевого и отрицательного ввода.

Входные данные не должны быть 64-разрядным целым числом со знаком. Это эффективно займет слово ввода, чтобы превратить его в целое число. Если вы введете число вне нормальных границ для 64-разрядного целого числа, оно сообщит, что возвращает отрицательное число, указывающее, сколько еще битов потребуется для хранения этого целого числа.

63-Floor@Log2[#/.{_?(#<0&):>2^63,0:>.5}]&

Попробуйте онлайн!

Решение @ LegionMammal978 немного короче - 28 байтов. Ввод должен быть целым числом. Согласно документации: « BitLength[n]эффективно эффективная версия Floor[Log[2,n]]+1». Он автоматически обрабатывает случай, когда 0вместо отчета правильно сообщается ноль -∞.

Wolfram Language (Mathematica) , 28 байт

Boole[#>=0](64-BitLength@#)&

Попробуйте онлайн!

bitNumber - math.ceil (math.log (number) / math.log (2))

например, 64-битный NUMBER: 9223372036854775807 math.ceil (math.log (9223372036854775807) / math.log (2)) ANS: 63