Вам будет дан номер x, где 0 <= x <= 2^32 - 1.

Вы должны вывести список чисел в десятичном виде после рекурсивного разбиения в двоичном формате.

Примеры:

Пример 1:

255 -> 255 15 15 3 3 3 3 1 1 1 1 1 1 1 1

Текущий список просто 255.

Бинарное представление 255is 1111 1111. Разбив его, получим 1111и 1111, которые в десятичном виде 15и 15.

Мы добавим их в список, так что мы будем иметь 255 15 15.

Теперь числа 15и 15будут служить входными данными, и эти числа должны быть разделены.

Делая это снова, мы получаем ( 3 3от обоих 15с): 255 15 15 3 3 3 3.

Продолжая логику, окончательный список будет 255 15 15 3 3 3 3 1 1 1 1 1 1 1 1. И так как 1больше не может быть разделен, выход останавливается.

Пример 2:

225 -> 225 14 1 3 2 1 1 1 0

Стартовый список есть 225.

Бинарное представление 225is 1110 0001. Разбив его, получим 1110и 0001, которые в десятичном виде 14и 1.

Добавив их в список, мы получим 225 14 1.

Теперь числа 14и 1будут служить входными данными, и эти числа должны быть разделены.

Поскольку 1это не разделяемый, вывод будет 225 14 1 3 2.

Пример 3:

32 -> 32 4 0 1 0

Условия :

1. Если число двоичных цифр нечетное, первое число будет иметь на двоее меньше двоичной цифры, чем следующее. Пример, 20 (10100)будет разделен как 10и 100, с десятичным выводом, являющимся 2и 4.
2. Применяются стандартные правила лазейки.
3. 0s и 1s не распространяются дальше.
4. Сбой программы при попытке отобразить слишком много чисел является допустимым условием выхода.

Pyth, 18 байт

u+QiR2smc2+0dt#.BM

Тестирование

Этот код делает что-то очень хитрое и умное с uоператором фиксированной точки Пита.

Тело функции, которая является чем-то иным, чем просто u, довольно просто:

+QiR2smc2+0dt#.BM
+QiR2smc2+0dt#.BMG    Implicit variable
                      G will store the list of numbers from the previous iteration.
              .BMG    Map each number to its binary representation
            t#        Filter out the ones of length 1 (0 and 1)
      m               Map the remaining binary
         +0d          Prefix with a 0
       c2             Chop in half.
                      Since c puts the larger half first, prefixing with a 0
                      makes the chop work out right, and doesn't change the value.
     s                Concatenate
  iR2                 Map back to binary
+Q                    Add the input to the front of the list

Этот код удаляет 0 и 1, разбивает каждое число и добавляет ввод перед.

u будет запускать эту функцию для предыдущего результата функции, пока результат не перестанет изменяться.

Какое начальное значение uиспользует? Это умная часть: код не указывает, какое значение использовать, поэтому по умолчанию он используется для ввода. Но ввод не список чисел - это число. Pyth неявно приводит число в первый раз через цикл к диапазону числа - [0, 1, ..., Q-1]. Это не похоже на результат, который мы хотим получить. К счастью, uнайдет правильный результат независимо от того, что является начальным вводом - желаемый вывод является единственной фиксированной точкой функции, и повторное применение всегда будет достигать ее.

Давайте посмотрим на промежуточные значения программы с вводом 7. Я выделил префикс результата, который гарантированно будет правильным, независимо от исходного ввода:

1. 7(Неявно [0, 1, 2, 3, 4, 5, 6])

2. [7,1, 0, 1, 1, 1, 0, 1, 1, 1, 2]

3. [7, 1, 3,1, 0]

4. [7, 1, 3, 1, 1]

Какой выход.

Упакованный Pyth, 16 байтов

Обратите внимание, что поскольку Pyth использует только диапазон ASCII 0-127, он может быть сжат с использованием 7-битной кодировки, а не 8-битной кодировки. Таким образом, вышеуказанная программа может быть упакована в 16 байтов. В результате получается программа:

ꮎ�L����[
    ���4

HexDump:

0000000: eaae 8e9a 4cb9 edc6 c95b 0c9d 11ae 8534  ....L....[.....4

Переводчик находится здесь . Предоставьте ввод в качестве аргумента командной строки.

Кодовая страница этого языка (Packed Pyth) является диапазоном 0-127 ASCII, и каждый символ представлен 7 битами, дополненными в конце. Таким образом, вышеприведенный нечитаемый hexdump представляет:

u+QiR2smc2+0dt#.BM

Но в 16 байтах.

05AB1E , 21 20 18 17 байт

,¸[Žrbvy0ì2äCʒ=1›

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

объяснение

,¸[Žrbvy0ì2äCʒ=1›   Argument n
,¸                  Print n and push n as array
  [Ž                Loop until stack is empty
    r               Reverse stack
     b              Convert elements in array to binary
      v             For each y in array
       y0ì2ä        Prepend '0' to y and split it into 2 elements
                    (the first element will take the additional character)
            C       Convert elements to decimal
             ʒ=1›   Keep only elements greater than 1, while printing each element

JavaScript (ES6), 99 байт

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

f=(n,p=(a=[],1),i=33-Math.clz32(n)>>1)=>(a[p]=n)>1?f(n>>i,p*=2)&&f(n&(1<<i)-1,p+1):a.filter(n=>1/n)

демонстрация

f=(n,p=(a=[],1),i=33-Math.clz32(n)>>1)=>(a[p]=n)>1?f(n>>i,p*=2)&&f(n&(1<<i)-1,p+1):a.filter(n=>1/n)

console.log(JSON.stringify(f(255)))
console.log(JSON.stringify(f(225)))
console.log(JSON.stringify(f(32)))

Желе , 21 20 байт

-1 байт, удалив монадическую цепочку, а затем столкнувшись с последствиями преобразования пустого списка из двоичного в последующий 0.

ỊÐḟBUœs€2UḄF
WÇÐĿṖUF

Монадическая ссылка, принимающая число и возвращающая указанный список.

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

Как?

ỊÐḟBUœs€2UḄF - Link 1, perform an iteration: list of numbers
 Ðḟ          - filter out if:
Ị            -   insignificant (absolute value <= 1 - hence any 0s or 1s)
   B         - convert to a binary list (vectorises)
    U        - upend (reverse each)
     œs€2    - split €ach into 2 equal chunks (the first half is longer if odd ...hence
         U   - upend (reverse each)         ...this upend and the previous one)
          Ḅ  - convert from binary list to number (vectorises, although when the filter
             -                                     removes everything a zero is yielded)
           F - flatten the resulting list of lists to a single list

WÇÐĿṖUF - Main link: number
W       - wrap in a list
  ÐĿ    - loop and collect results until no change occurs:
 Ç      -   call last link (1) as a monad
    Ṗ   - pop (remove the last element - a list containing a single zero which results
        -     from the effect of Ḅ when link 1's input only contained ones and zeros)
     U  - upend (put the iterations into the required order)
      F - flatten to yield a single list

Java 7, 541 байт

import java.util.*;List l=new ArrayList(),L=new ArrayList();String c(int n){l.add(x(n));return a(n+" ",l,n);}String a(String r,List q,Integer n){boolean e=q.equals(l),E=q.equals(L);if(e)L.clear();else l.clear();for(String i:new ArrayList<String>(q)){int s=i.length()/2,a=n.parseInt(i.substring(0,s),2),z=n.parseInt(i.substring(s),2);r+=a+" "+z+" ";if(e&a>1)L.add(x(a));if(e&z>1)L.add(x(z));if(E&a>1)l.add(x(a));if(E&z>1)l.add(x(z));}if(e&L.size()>0)r=a(r,L,n);if(E&l.size()>0)r=a(r,l,n);return r;}String x(Integer n){return n.toString(n,2);}

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

Объяснение:

import java.util.*;                    // Required import for List and Array List

List l=new ArrayList(),L=new ArrayList(); 
                                       // Two Lists on class-level

String c(int n){                       // Method (1) with integer parameter and String return-type
  l.add(x(n));                         //  Start by adding the binary-String of the input integer to list `l`
  return a(n+" ",l,n);                 //  And let the magic begin in method `a` (2)
}                                      // End of method (1)

String a(String r,List q,Integer n){   // Method (2) with a bunch of parameters and String return-type
  boolean e=q.equals(l),E=q.equals(L); //  Determine which of the two class-level Lists the parameter-List is
  if(e)                                //  If it's `l`:
    L.clear();                         //   Empty `L`
  else                                 //  If it's `L` instead:
    l.clear();                         //   Empty `l`
  for(String i:new ArrayList<String>(q)){
                                       //  Loop over the input list (as new ArrayList to remove the reference)
    int s=i.length()/2,                //   Get the length of the current item in the list divided by 2
                                       //   NOTE: Java automatically floors on integer division,
                                       //   which is exactly what we want for the splitting of odd-length binary-Strings
    a=n.parseInt(i.substring(0,s),2),  //   Split the current binary-String item in halve, and convert the first halve to an integer
    z=n.parseInt(i.substring(s),2);    //   And do the same for the second halve
    r+=a+" "+z+" ";                    //   Append the result-String with these two integers
    if(e&a>1)                          //   If the parameter List is `l` and the first halve integer is not 0:
      L.add(x(a));                     //    Add this integer as binary-String to list `L`
    if(e&z>1)                          //   If the parameter List is `l` and the second halve integer is not 0:
      L.add(x(z));                     //    Add this integer as binary-String to List `L`
    if(E&a>1)                          //   If the parameter List is `L` and the first halve integer is not 0:
      l.add(x(a));                     //    Add this integer as binary-String to List `l`
    if(E&z>1)                          //   If the parameter List is `L` and the second halve integer is not 0:
      l.add(x(z));                     //    Add this integer as binary-String to List `l`
  }                                    //  End of loop
  if(e&L.size()>0)                     //  If the parameter List is `l` and List `L` now contains any items:
    r=a(r,L,n);                        //   Recursive call with List `L` as parameter
  if(E&l.size()>0)                     //  If the parameter List is `L` and List `l` now contains any items:
    r=a(r,l,n);                        //   Recursive call with List `l` as parameter
  return r;                            //  Return the result-String with the now appended numbers
}                                      // End of method (2)

String x(Integer n){                   // Method (3) with Integer parameter and String return-type
  return n.toString(n,2);              //  Convert the integer to its Binary-String
}                                      // End of method (3)

Тестовый код:

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

import java.util.*;
class M{
  List l=new ArrayList(),L=new ArrayList();String c(int n){l.add(x(n));return a(n+" ",l,n);}String a(String r,List q,Integer n){boolean e=q.equals(l),E=q.equals(L);if(e)L.clear();else l.clear();for(String i:new ArrayList<String>(q)){int s=i.length()/2,a=n.parseInt(i.substring(0,s),2),z=n.parseInt(i.substring(s),2);r+=a+" "+z+" ";if(e&a>1)L.add(x(a));if(e&z>1)L.add(x(z));if(E&a>1)l.add(x(a));if(E&z>1)l.add(x(z));}if(e&L.size()>0)r=a(r,L,n);if(E&l.size()>0)r=a(r,l,n);return r;}String x(Integer n){return n.toString(n,2);}

  public static void main(String[] a){
    M m=new M();
    System.out.println(m.c(255));
    m.l.clear();
    m.L.clear();
    System.out.println(m.c(225));
    m.l.clear();
    m.L.clear();
    System.out.println(m.c(32));
  }
}

Выход:

255 15 15 3 3 3 3 1 1 1 1 1 1 1 1 
225 14 1 3 2 1 1 1 0 
32 4 0 1 0 

Python 2 , 110 байт

l=[input()];i=1
while i:
 z=0
 for k in l[-i:]:
	if k>1:b=~-len(bin(k))/2;l+=[k>>b,k&2**b-1];z+=2
 i=z
print l

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

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

.+
$*
+`(1+)\1
${1}0
01
1
{`.+$
$&¶<$&>
+`;(\d*)>
>;<$1>
<.>

{`(\d)>
>$1
}`<(\d)
$1<
<>
;
\b0+\B

}`^;|;\B

¶
;
;;

1
01
+`10
011
0\B

1+
$.&

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

PHP, 132 байта

for($r=[$argn];""<$n=$r[+$i++];)$n<2?:[$r[]=bindec(substr($d=decbin($n),0,$p=strlen($d)/2)),$r[]=bindec(substr($d,$p))];print_r($r);

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

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

f=->*a{a==[]?[]:a+=f[*a.map{|i|s='%b'%i;i>1?[s[0...h=s.size/2].to_i(2),s[h..-1].to_i(2)]:[]}.flatten]}

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

Рубин , 98 байт

f=->*a{a==[]?a:a+=f[*a.flat_map{|i|s='%b'%i;i>1?[s[0...h=s.size/2].to_i(2),s[h..-1].to_i(2)]:[]}]}

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

Просто базовая оптимизация ответа Value Ink : используйте flat_map вместо map ... flatten и используйте

a==[]?a вместо того a==[]?[]