По заданному числу определите, является ли оно складным числом.

Складываемое число - это число, такое, что если вы возьмете его в двоичное представление и «сложите» его пополам, то есть возьмете результат умножения XNOR первой половины числа и второй половины на цифры, обратные, вы получите нуль.

Если число имеет нечетное число цифр в двоичном виде, его средняя цифра должна быть 1 и игнорируется при свертывании.

Поскольку это может немного сбивать с толку, я приведу несколько примеров:

178

Двоичное представление 178

10110010

Чтобы сложить это, мы сначала разделим это пополам

1011 0010

Перевернем вторую половину

1011
0100

И мы XNOR две половинки:

0000

Это ноль, так что это складное число.

1644

Двоичное представление 1644

11001101100

Чтобы сложить это, мы сначала разделим это пополам

11001 1 01100

Средний бит равен 1, поэтому мы выбрасываем его.

11001 01100

Перевернем вторую половину

11001
00110

И мы XNOR две половинки:

00000

Это ноль, так что это складное число.

4254

Двоичное представление 4254

1000010011110

Чтобы сложить это, мы сначала разделим это пополам

100001 0 011110

Средний бит равен 0, так что это не число сгиба.

задача

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

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

Вот первые 99 складных чисел:

[1, 2, 6, 10, 12, 22, 28, 38, 42, 52, 56, 78, 90, 108, 120, 142, 150, 170, 178, 204, 212, 232, 240, 286, 310, 346, 370, 412, 436, 472, 496, 542, 558, 598, 614, 666, 682, 722, 738, 796, 812, 852, 868, 920, 936, 976, 992, 1086, 1134, 1206, 1254, 1338, 1386, 1458, 1506, 1596, 1644, 1716, 1764, 1848, 1896, 1968, 2016, 2110, 2142, 2222, 2254, 2358, 2390, 2470, 2502, 2618, 2650, 2730, 2762, 2866, 2898, 2978, 3010, 3132, 3164, 3244, 3276, 3380, 3412, 3492, 3524, 3640, 3672, 3752, 3784, 3888, 3920, 4000, 4032, 4222, 4318, 4462, 4558]

Желе , 9 байт

Bœs2µḢ^UȦ

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

Как это работает

Bœs2µḢ^UȦ  Main link. Argument: n

B          Binary; convert n to base 2.
 œs2       Evenly split 2; split the base 2 array into chunks of equal-ish length.
           For an odd amount of digits, the middle digit will form part of the
           first chunk.
    µ      Begin a new, monadic chain. Argument: [A, B] (first and second half)
     Ḣ     Head; remove and yield A.
       U   Upend; reverse the digits in [B].
      ^    Perform vectorized bitwise XOR of the results to both sides.
           If A is longer than B, the last digit will remain untouched.
           n is a folding number iff the result contains only 1's.
        Ȧ  Octave-style all; yield 1 iff the result does not contain a 0.

05AB1E , 13 12 байт

Код:

bS2ä`R0¸«s^P

Использует кодировку CP-1252 . Попробуйте онлайн!

Объяснение:

Сначала мы конвертируем число в двоичное, используя b. 1644 становится 11001101100 . Мы разделили это на две части 2ä. Например, 11001101100 станет:

[1, 1, 0, 0, 1, 1]
[0, 1, 1, 0, 0]

Если число битов различно, первая часть получит дополнительный бит. Мы Rпереворачиваем последнюю строку и добавляем ноль, используя 0¸«. Причина этого заключается в том, чтобы давать достоверные результаты только тогда, когда средний бит равен 1 ( 1 XOR 0 = 1 и 0 XOR 0 = 0 ). Если среднего бита нет, 05AB1E просто проигнорирует последний бит (добавленный ноль):

[1, 1, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 0]

Последнее, что нам нужно сделать, это сделать XOR поэлементно и взять результат результата. Если одного элемента слишком много, программа просто пропустит последний элемент ( [1, 0, 0] XOR [0, 1] = [1, 1]). Например:

[1, 1, 0, 0, 1, 1]
[0, 0, 1, 1, 0, 0] XOR

становится:

[1, 1, 1, 1, 1, 1]

И продукт этого равен 1 , что является правдой.

Java 7, 152, 145, 142, 138, 134 байта.

boolean f(Long a){byte[]b=a.toString(a,2).getBytes();int i=0,l=b.length,z=l%2<1?1:b[l/2]-48;for(;i<l/2;)z*=b[i]-b[l-++i];return z!=0;}

Зацикливается на нити, как для палиндрома, в поисках нулей. Отслеживает путем многократного умножения, поэтому все, что вам нужно сделать, это проверить, что он не равен нулю в конце.

Без полос прокрутки:

boolean f(Long a){
    byte[]b=a.toString(a,2).getBytes();
    int i=0,l=b.length,z=l%2<1?1:b[l/2]-48;
    for(;i<l/2;)
        z*=b[i]-b[l-++i];
    return z!=0;
}

JavaScript (ES6), 61 57 52 байта

Рекурсивно вычисляет:

(bit(N) XOR bit(0)) AND (bit(N-1) XOR bit(1)) AND (bit(N-2) XOR bit(2)) etc.

где Nранг старшего бита, установленного на входе.

Если вход имеет нечетное количество битов, средний бит XOR 'с неопределенным (значение, возвращаемое pop()в пустом массиве), что позволяет его неизменным. Таким образом, 0средний бит очищает вывод, а 1средний бит не изменяет результат других операций - что согласуется с определением задачи для складывающегося числа.

f=(n,[a,...b]=n.toString(2))=>a?(a^b.pop())&f(n,b):1

// testing integers in [1 .. 99]
for(var i = 1; i < 100; i++) {
  f(i) && console.log(i);
}

Python 2, 57 байт

s=bin(input())[2:]
while''<s!='1':s[-1]==s[0]<_;s=s[1:-1]

Выходы через код выхода : ошибка для Falsey, и нет ошибки для Truthy.

Преобразует ввод в двоичный файл. Проверяет, являются ли первый и последний символы неравными, сохраняет и повторяет это после удаления этих символов.

Сравнение s[-1]==s[0]<_дает ошибку, если первый и последний символ не равны, пытаясь оценить неназначенную переменную с именем _. Если они равны, цепочка неравенств вместо этого замыкается. Когда мы добираемся до среднего элемента 1, whileцикл завершается в специальном случае как ОК.

Я подозреваю, что чисто арифметический подход будет короче с рекурсией, например, f=lambda n,r=0:...f(n/2,2*r+~n%2)...чтобы отломать двоичные цифры от конца, перевернутого и перевернутого, и определить, когда nи rравны ли они центру 1. Хотя есть тонкости с ведущими нулями и центром.

Python 2, 94 79 72 67 байт

F=lambda s:s in'1'or(s[0]!=s[-1])*F(s[1:-1])
lambda n:F(bin(n)[2:])

Сохранено 12 байтов благодаря @xnor

Определяет неназванную функцию во второй строке.

Пояснение (с некоторыми добавленными пробелами):

F = lambda s:                                        # We define a function, F, which takes one argument, the string s, which returns the following:
             s in'1'                                 # Gives true if s is '' or s is '1', the first case is a base case and the second is for the middle bit case.
                     or(s[0] != s[-1])               # Or the first and last are different
                                      * F(s[1:-1])   # And check if s, without the first and last element is also foldable.
lambda n: F(bin(n)[:-2])                             # The main function, which calls F with the argument in binary form.

Попробуй это здесь!

Haskell, 89 88 86 байт

f n|n<2=[n]|1>0=mod n 2:f(div n 2)
g n=elem(product$zipWith(+)(f n)$reverse$f n)[1,2]

Работает, суммируя побитовое представление с обратным и получая произведение. Если это 1 или 2, число является складывающимся числом (1, если есть четные биты, которые складываются, 2, если есть нечетные биты, и один в середине).

Python 2, 100 99 95 94 байт

Это кажется немного длинным, но я буду продолжать над этим работать :) Печатает, 1если число можно сложить,0 противном случае.

a=bin(input())[2:]
b=len(a)
print(a[b/2]>=`b%2`)*all(c!=d for c,d in zip(a[:b/2],a[:~b/2:-1]))

^{Попробуй это здесь!}

^{спасибо Wheat Wizard за 1-байтовое сохранение :)}

^{спасибо Роду за 5-байтовое сохранение! :)}

> <> , 37 + 3 = 40 байт

<,2-@:%2:v!?:
=2lrv?=1l<+={$r0?
0=n;>

Ожидается, что вход будет присутствовать в стеке при запуске программы, поэтому +3 байта для -v флага.

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

Желе , 13 байт

Bœs2U0¦z0^/€Ạ

TryItOnline
или соответствующие термины до 4558

Как?

Bœs2U0¦z0^/€Ạ - Main link: n
B             - binary
 œs2          - split into 2 slices (odd length will have first longer than second)
     0¦       - apply to index 0 (the right hand one)
    U         - reverse
       z0     - zip together with filler 0 (thus central 1 or 0 will pair with 0)
          /€  - reduce with for each
         ^    -     XOR
            Ạ - All truthy?

Perl, 46 байт

Включает +1 для -p

Запустить с номером на STDIN

folding.pl <<< 178

folding.pl:

#!/usr/bin/perl -p
$_=($_=sprintf"%b",$_)<s%.%!/\G1$/^$&^chop%eg

Я считаю, это ошибка Perl, что это даже работает. Внутренний $_не должен получать обновления позиции совпадения после его изменения. В этой программе позиция матча фактически выходит за пределы$_

Брахилог , 16 байт

ḃḍ{↔|h1&b↔}ᵗz₂≠ᵐ

Это не совсем работает в Интернете ...

Принимает ввод через входную переменную и выводит через успех или неудачу. Он сильно зависит от языка z₂, который существует в языке с 30 апреля, но мы забыли попросить включить его в TIO, поэтому пока он работает только при локальной установке языка. В любом случае это, вероятно, слишком наивный подход.

                    The input
ḃ                   's binary representation
 ḍ                  split in half
  {       }ᵗ        with its second half
   ↔|               either reversed, or
     h1             if it starts with 1
       &b           relieved of its first element
         ↔          and then reversed
              ≠     has no duplicate elements
            z  ᵐ    in any pair of elements zipped from the two halves
             ₂      which are equal in length.

Брахилог (на TIO), 19 байт

ḃḍ{↔|h1&b↔}ᵗlᵛ↖Lz≠ᵐ

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

lᵛ↖Lzфункционально эквивалентно z₂(если вы не используете переменную L где-либо еще), но это также на три байта длиннее.

Python 2, 76 71 69 байт

-5 байт благодаря @Dennis ( ''присутствует '1', поэтому замените in('','1')на in'1')
-2 байта благодаря @xnor (используйте умножение (...)*вместо and)

f=lambda n:f(bin(n)[2:])if n<''else n in'1'or(n[0]!=n[-1])*f(n[1:-1])

Ideone

Рекурсивная функция при первом вызове nявляется числом, поэтому она оценивается как меньшая, чем пустая строка, с if n<'', и функция вызывается снова, но с nприведением к двоичной строке; хвост - это либо пустая строка (даже длина в битах), либо средний бит, который возвращает true для пустого или a '1'; на его пути вниз он проверяет внешние биты для неравенства (эквивалент XOR) и рекурсивны на внутренних битах n[1:-1].

Python 2, 63 байта

s=bin(input())[2:]
while s[0]!=s[-1]:s=s[1:-1]or'1'
print'1'==s

Отпечатки Trueили False. Принимает двоичное представление sи многократно удаляет первый и последний символы, если они неравны. Проверяет, является ли то, что осталось, пустой строкой или центральным 1. Это делается путем преобразования ''в '1'и проверки, равен ли результат '1', что также позволяет избежать ошибки индекса в пустой строке.

PowerShell v2 +, 143 байта

Два возможных подхода, оба байта одинаковы.

Способ 1:

param($n)if($n-eq1){$n++}$o=1;0..(($b=($n=[convert]::ToString($n,2)).length-1)/2-!($b%2))|%{$o*=$n[$_]-ne$n[$b-$_]};$o*(+"$($n[$b/2])",1)[$b%2]

Принимает ввод $n, если это -eqнеобходимо 1(особый случай для этого алгоритма), увеличивает его. Установите $output равным 1(т. Е. Предположите правдивость), затем перейдите к средней 0точке входного числа, которое было [convert]преобразовано в двоичный код. Обратите внимание-!($b%2) учет нечетных двоичных чисел.

На каждой итерации мы сравниваем текущую цифру $n[$_]с цифрой одинаковой длины от конца $n[$b-$_]и умножаем логический результат на $o(по сути, выполняя -andвсе из них). Как только цикл завершен, нам необходимо учесть среднюю двоичную цифру, то есть псевдо-троичную в конце (массив, индексированный через $b%2). Что 1или0 остается на конвейере, а вывод неявным.

Способ 2:

param($n)for($n=[convert]::ToString($n,2);$n.Length-gt2){if($n[0]-ne$n[-1]){$n=$n[1..($n.Length-2)]}else{0;exit}}($n-join'+'|iex)-eq1-or$n-eq10

Принимает ввод и выполняет тот же процесс для [convert]числа в двоичном формате. Тогда мы находимся в forцикле, пока .lengthбинарная строка - -greater than 2. Когда мы находимся в цикле, если первая $n[0]и последняя $n[-1]цифры -nOT eкаче, нарежьте эти две цифры прочь $nи повторно хранить его в $n. В противном случае выведите 0и exit. После того, как мы из цикла, либо мы имеем (массив 1, 1,0, 0,1, 1,1, или 0,0), или двоичная строка для двух 10или 3 11. Итак, нам нужно проверить эти две возможности. Для первого, мы-join $n вместе с+ и оцениваем результат и проверяем, что это1(это верно для массивов 1,1,0 и0,1, но $falseдля массивов или строк или ). Другая половина проверяет, является ли она полезной (т. Е. Ввод ). Это логическое значение остается в конвейере, а вывод неявным.0,0 и1,11011-or$n-eq102

CJam , 13 байтов

ri2b_W%.+:*3&

Попробуйте онлайн! или создать список складных чисел до заданного числа.

ri2b   e# convert input to binary
_W%.+  e# flip and sum (if folding all bits are 1 except middle)
:*     e# product is 0 or power of 2 (2 if middle folds)
3&     e# keep only 1 or 2, everything else becomes 0 (false)

MATL , 16 байт

tBn2/kW&\hBZ}P=~

Правда это массив со всеми. Проверьте правдивые / ложные критерии здесь .

Попробуйте онлайн! Или проверьте первые 20 тестовых случаев .

объяснение

Давайте использовать вход 1644в качестве примера.

t     % Imolicitly take input. Duplicate
      %   STACK: 1644, 1644
Bn    % Number of digits of binary expansion
      %   STACK: 1644, 11
2/k   % Divide by 2 and round down
      %   STACK: 1644, 5
W     % 2 raised to that
      %   STACK: 1644, 32
&\    % Divmod
      %   STACK: 12, 51
h     % Concatenate horizontally
      %   STACK: [12 51]
B     % Binary expansion. Each numnber gives a row, left-padded with zeros if needed
      %   STACK: [0 0 1 1 0 0; 1 1 0 0 1 1]
Z}    % Split into rows
      %   STACK: [0 0 1 1 0 0], [1 1 0 0 1 1]
P     % Reverse
      %   STACK: [0 0 1 1 0 0], [1 1 0 0 1 1]
=~    % True for entries that have different elements
      %   STACK: [1 1 1 1 1 1]
      % Implicitly display

PHP, 101 байт

for($r=1;$i<($l=strlen($b=decbin($argv[1])))>>1;)$r*=$b[$i]^1^$b[$l-++$i]^1;$r*=$l%2?$b[$i]:1;echo$r;

или с журналом

for($r=1,$s=log($n=$argv[1],2)^0;2*$i<$s;)$r*=($n>>$i)%2^($n>>$s-$i++)%2;$s%2?:$r*=($n>>$i)%2;echo$r;

108 байт с массивом

for($r=1,$a=str_split(decbin($argv[1]));$a;)$r*=array_pop($a)!=($a?array_shift($a):0);$r*=$a?$a[0]:1;echo$r;

Истинные значения <10000

1,2,6,10,12,22,28,38,42,52,56,78,90,108,120,142,150,170,178,204,212,232,240,286,310,346,370,412,436,472,496,542,558,598,614,666,682,722,738,796,812,852,868,920,936,976,992,1086,1134,1206,1254,1338,1386,1458,1506,1596,1644,1716,1764,1848,1896,1968,2016,2110,2142,2222,2254,2358,2390,2470,2502,2618,2650,2730,2762,2866,2898,2978,3010,3132,3164,3244,3276,3380,3412,3492,3524,3640,3672,3752,3784,3888,3920,4000,4032,4222,4318,4462,4558,4726,4822,4966,5062,5242,5338,5482,5578,5746,5842,5986,6082,6268,6364,6508,6604,6772,6868,7012,7108,7288,7384,7528,7624,7792,7888,8032,8128,8318,8382,8542,8606,8814,8878,9038,9102,9334,9398,9558,9622,9830,9894

Юлия , 66 байт

c(s)=s==""||s=="1"||(s[1]!=s[end]&&c(s[2:end-1]))
f(x)=c(bin(x))

Мой первый гольф! работает так же, как и решение Python той же длины, незначительные различия из-за языка (хотя я придумал его самостоятельно, хотя ...).

Объяснение:

c(s) = s == "" || # Base case, we compared all the digits from 
                  # both halves.
       s == "1" || # We compared everything but left a 1 in the middle
       (s[1] != s[end] &&  # First digit neq last digit (XNOR gives 0).
        c(s[2:end-1]))     # AND the XNOR condition is satisfied for the  
                           # 2nd to 2nd to last digit substring.
f(x) = c(bin(x))  # Instead of a string f takes an integer now.

C 223 201 189 194 178 байт

i,j,m,l,r;f(n){for(m=j=1,i=n;i/=2;++j);for(l=r=i=0;i<j/2;i++)r|=n&m?1<<j/2-i-1:0,m*=2;i=(j&1&&n&m)?i+1:(j&1)?l=r:i;n>>=i;for(m=1;i<j;i++)l|=n&m,m*=2;return !(~(l^r)&(1<<j/2)-1);}

Алгоритм грубой силы. Давайте посмотрим, как далеко это может быть в гольфе.

Исправлены ошибки при настройке теста ...

 main()
 {
    int t, s, u, testSet[] = 
    {
    1, 2, 6, 10, 12, 22, 28, 38, 42, 52, 56, 78, 90, 108, 120,
    142, 150, 170, 178, 204, 212, 232, 240, 286, 310, 346, 370,
    412, 436, 472, 496, 542, 558, 598, 614, 666, 682, 722, 738,
    796, 812, 852, 868, 920, 936, 976, 992, 1086, 1134, 1206,
    1254, 1338, 1386, 1458, 1506, 1596, 1644, 1716, 1764, 1848,
    1896, 1968, 2016, 2110, 2142, 2222, 2254, 2358, 2390, 2470,
    2502, 2618, 2650, 2730, 2762, 2866, 2898, 2978, 3010, 3132,
    3164, 3244, 3276, 3380, 3412, 3492, 3524, 3640, 3672, 3752,
    3784, 3888, 3920, 4000, 4032, 4222, 4318, 4462, 4558
    };


    for (u=s=0,t=1;t<=4558;t++)
    {
        if (f(t))
        {
          u++;            
          if (testSet[s++]!=t)
              printf("BAD VALUE %d %d\n", testSet[s-1], t);
        }
    }

    printf("%d == %d Success\n", u,
           sizeof(testSet)/sizeof(testSet[0]));

}

MATL , 13 байт

BttP=<~5Ms2<*

Правда это массив со всеми. Проверьте правдивые / ложные критерии здесь .

Попробуйте онлайн! Или проверьте первые 20 тестовых случаев .

объяснение

Используя вход 1644в качестве примера:

B     % Implicit input. Convert to binary
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0]
t     % Duplicate
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0], [1 1 0 0 1 1 0 1 1 0 0]
tP=   % Element-wise compare each entry with that of the reversed array
      %   STACK: [1 1 0 0 1 1 0 1 1 0 0], [0 0 0 0 0 1 0 0 0 0 0]
<~    % True (1) if matching entries are equal or greater
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1]
5M    % Push array of equality comparisons again
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], [0 0 0 0 0 1 0 0 0 0 0]
s     % Sum of array
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], 1
2<    % True (1) if less than 2
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1], 1
*     % Multiply
      %   STACK: [1 1 1 1 1 1 1 1 1 1 1]
      % Implicitly display

JavaScript, 71 байт

(i,n=i.toString(2))=>/^(1*)2?\1$/.test(+n+ +n.split``.reverse().join``)

Определяет анонимную функцию.

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

Сетчатка, 92 байта

Число байтов предполагает кодировку ISO 8859-1.

.+
$*
+`(1+)\1
${1}0
01
1
^((.)*?)1??((?<-2>.)*$.*)
$1¶$3
O$^`.(?=.*¶)

T`01`10`^.*
^(.*)¶\1

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

Преобразовать в одинарный. Преобразуйте это в двоичный файл. Разрежьте число пополам и удалите середину, 1если есть. Обратный первый тайм. Поменяйте его нулями и нулями. Матч, если обе половины равны.

Сетчатка, 71 70 60 байт

.+
$*
+`^(1*)\1(1?)\b
$1 $.2
+`^ (.)(.*) (?!\1).$
$2
^( 1)?$

Мне, наверное, еще многое предстоит узнать о Retina (например, рекурсивное регулярное выражение?). Пояснение: Шаг 1 преобразует из десятичной в унарную. Шаг 2 преобразует из одинарного в псевдобинарный. Шаг 3 удаляет цифры с обоих концов, если они не совпадают. Шаг четвертый соответствует необязательному последнему центральному 1, если необходимо. Редактировать: 1 байт сохранен благодаря @ mbomb007. Сохранено 10 байт за счет улучшения моего унарного преобразования в двоичное.

Python 2, 61 59 байт

Сохранение двух байтов для преобразования сдвигов в умножения

m=n=input()
i=0
while m:i*=2;i+=m&1;m/=2
print(n+i+1)&(n+i)

Возвращает 0для складного номера и все остальное для не складывания. Использует битовый подход.

C 65 63 байта

Два байта для преобразования сдвигов в умножения

i,m;
f(n){
 m=n;i=0;
 while(m)i*=2,i+=m&1,m/=2;
 return(n+i+1)&(n+i);
}

Пробел уже исключен из bytecount, возвращает 0 для фолд-числа и все остальное для не-фолдинга. Использует битовый подход.

к, 77 байт

{X:2 0N#X@&:|\X:0b\:x;c:#:'X;$[(~*X 1)|(=). c;~|/(=).(::;|:)@'(-&/ c)#'X;0b]}

в качестве объяснения, перевод на q

{X:2 0N#X where maxs X:0b vs x;
  c:count each X;
  $[(not first last X)or(=). c;
    not any(=).(::;reverse)@'(neg min c)#'X;0b]
  };