Алгоритм сортировки выглядит так:

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

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

Входной список может содержать произвольное количество элементов (в пределах разумного, скажем, до 1000 элементов), а не только идеально делимые списки из 2 ^ n элементов. Вам придется либо удалить (n + 1) / 2, либо (n-1) / 2, если список нечетный, либо жестко задан, либо выбран случайным образом во время выполнения. Решите сами: что бы сделал Танос, если бы во вселенной было нечетное количество живых существ?

Список сортируется, если ни один элемент не меньше предыдущего. Дубликаты могут появляться на входе и на выходе.

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

Примеры:

// A sorted list remains sorted
[1, 2, 3, 4, 5] -> [1, 2, 3, 4, 5]

// A list with duplicates may keep duplicates in the result
[1, 2, 3, 4, 3] -> [1, 3, 3] // Removing every second item
[1, 2, 3, 4, 3] -> [3, 4, 3] -> [4, 3] -> [3] // Removing the first half
[1, 2, 3, 4, 3] -> [1, 2] // Removing the last half

[1, 2, 4, 3, 5] может дать разные результаты:

// Removing every second item:
[1, 2, 4, 3, 5] -> [1, 4, 5]

или же:

// Removing the first half of the list
[1, 2, 4, 3, 5] -> [3, 5] // With (n+1)/2 items removed
[1, 2, 4, 3, 5] -> [4, 3, 5] -> [3, 5] // With (n-1)/2 items removed

или же:

// Removing the last half of the list
[1, 2, 4, 3, 5] -> [1, 2] // With (n+1)/2 items removed
[1, 2, 4, 3, 5] -> [1, 2, 4] // With (n-1)/2 items removed

или же:

// Taking random items away until half (in this case (n-1)/2) of the items remain
[1, 2, 4, 3, 5] -> [1, 4, 3] -> [4, 3] -> [4]

R , 41 байт

x=scan();while(any(x-sort(x)))x=x[!0:1];x

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

Python 3 , 38 42 39 байт

q=lambda t:t>sorted(t)and q(t[::2])or t

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

-3 bytes благодаря @JoKing и @Quuxplusone

Python 2 , 39 байт

f=lambda l:l>sorted(l)and f(l[::2])or l

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

Brachylog (v2), 6 байт

≤₁|ḍt↰

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

Это функция представления. Вход слева, вывод справа, как обычно. (Ссылка TIO использует аргумент командной строки, который автоматически превращает функцию в полноценную программу, чтобы вы могли увидеть ее в действии.)

объяснение

≤₁|ḍt↰
≤₁       Assert that {the input} is sorted {and output it}
  |      Handler for exceptions (e.g. assertion failures):
   ḍ     Split the list into two halves (as evenly as possible)
    t    Take the last (i.e. second) half
     ↰   Recurse {and output the result of the recursion}

Бонус раунд

≤₁|⊇ᵇlᵍḍhtṛ↰

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

Снимок должен быть случайным, не так ли? Вот версия программы, которая выбирает выживающие элементы случайным образом (при этом гарантируя, что половина выживает в каждом раунде).

≤₁|⊇ᵇlᵍḍhtṛ↰
≤₁            Assert that {the input} is sorted {and output it}
  |           Handler for exceptions (e.g. assertion failures):
   ⊇ᵇ         Find all subsets of the input (preserving order)
     lᵍ       Group them by length
       ḍht    Find the group with median length:
         t      last element of
        h       first
       ḍ        half (split so that the first half is larger)
          ṛ   Pick a random subset from that group
           ↰  Recurse

Это было бы намного короче, если бы мы могли изменить порядок элементов, но почему алгоритм сортировки хотел бы сделать это ?

Perl 6 , 30 байт

$!={[<=]($_)??$_!!.[^*/2].&$!}

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

Рекурсивная функция, которая удаляет вторую половину списка, пока список не отсортирован.

Объяснение:

$!={                         }    # Assign the function to $!
    [<=]($_)??                    # If the input is sorted
              $_                  # Return the input
                !!                # Else
                  .[^*/2]         # Take the first half of the list (rounding up)
                         .&$!     # And apply the function again

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

g=>{while(!g.OrderBy(x=>x).SequenceEqual(g))g=g.Take(g.Count()/2);return g;}

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

Java 10, 106 97 байт

L->{for(;;L=L.subList(0,L.size()/2)){int p=1<<31,f=1;for(int i:L)f=p>(p=i)?0:f;if(f>0)return L;}}

-9 байт благодаря @ OlivierGrégoire .

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

Оставляйте первую половину списка только на каждой итерации и удаляйте элементы , если размер списка нечетный.$\frac{n+1}{2}$

Объяснение:

L->{               // Method with Integer-list as both parameter and return-type
  for(;;           //  Loop indefinitely:
      L=L.subList(0,L.size()/2)){
                   //    After every iteration: only leave halve the numbers in the list
    int p=1<<31,   //   Previous integer, starting at -2147483648
        f=1;       //   Flag-integer, starting at 1
    for(int i:L)   //   Inner loop over the integer in the list:
      f=p>(p=i)?   //    If `a>b` in a pair of integers `a,b`:
         0         //     Set the flag to 0
        :          //    Else (`a<=b`):
         f;        //     Leave the flag the same
    if(f>0)        //   If the flag is still 1 after the loop:
      return L;}}  //    Return the list as result

Wolfram Language (Mathematica) , 30 байтов

#//.x_/;Sort@x!=x:>x[[;;;;2]]&

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

@ Doorknob сэкономил 12 байт

JavaScript (ES6),  49  48 байт

Сохранено 1 байт благодаря @tsh

Удаляет каждый 2-й элемент.

f=a=>a.some(p=c=>p>(p=c))?f(a.filter(_=>a^=1)):a

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

Рубин , 37 байт

->r{r=r[0,r.size/2]while r.sort!=r;r}

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

05AB1E , 8 7 байт

[Ð{Q#ιн

-1 байт благодаря @Emigna .

Удаляет все нечетные 0-индексированные элементы на каждой итерации, поэтому удаляет элементов, если размер списка нечетный.$\frac{n-1}{2}$

Попробуйте онлайн или проверьте еще несколько тестовых случаев (или проверьте эти тестовые примеры с пошаговыми инструкциями для каждой итерации ).

7 байтов альтернатива @Grimy :

ΔÐ{Ê>äн

Удаляет последние элементов (или элементов, если размер списка нечетный) при каждой итерации.$\frac{n}{2}$$\frac{n-1}{2}$

Попробуйте онлайн или проверьте еще несколько тестовых случаев (или проверьте эти тестовые примеры с пошаговыми инструкциями для каждой итерации ).

Объяснение:

[        # Start an infinite loop:
 Ð       #  Triplicate the list (which is the implicit input-list in the first iteration)
  {Q     #  Sort a copy, and check if they are equal
    #    #   If it is: Stop the infinite loop (and output the result implicitly)
  ι      #  Uninterweave: halve the list into two parts; first containing all even-indexed
         #  items, second containing all odd-indexed items (0-indexed)
         #   i.e. [4,5,2,8,1] → [[4,2,1],[5,8]]
   н     #  And only leave the first part

Δ        # Loop until the result no longer changes:
 Ð       #  Triplicate the list (which is the implicit input-list in the first iteration)
  {Ê     #  Sort a copy, and check if they are NOT equal (1 if truthy; 0 if falsey)
    >    #  Increase this by 1 (so 1 if the list is sorted; 2 if it isn't sorted)
     ä   #  Split the list in that many parts
      н  #  And only leave the first part
         # (and output the result implicitly after it no longer changes)

TI-BASIC (TI-84), 47 42 45 44 байта

-1 байт благодаря @SolomonUcko!

Ans→L1:Ans→L2:SortA(L1:While max(L1≠Ans:iPart(.5dim(Ans→dim(L2:L2→L1:SortA(L1:End:Ans

Входной список находится в Ans.
Выход находится Ansи неявно распечатывается.

Объяснение:

Ans→L1                  ;store the input into two lists
Ans→L2
SortA(L1                ;sort the first list
                        ; two lists are needed because "SortA(" edits the list it sorts
While max(L1≠Ans        ;loop until both lists are strictly equal
iPart(.5dim(Ans→dim(L2  ;remove the latter half of the second list
                        ; removes (n+1)/2 elements if list has an odd length
L2→L1                   ;store the new list into the first list (updates "Ans")
SortA(L1                ;sort the first list
End
Ans                     ;implicitly output the list when the loop ends

Примечание: TI-BASIC - это токенизированный язык. Количество символов не равно количеству байтов.

Желе , 7 байт

m2$⁻Ṣ$¿

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

Haskell , 57 55 байт (только благодаря ASCII)

f x|or$zipWith(>)x$tail x=f$take(div(length x)2)x|1>0=x

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

Оригинальный код:

f x|or$zipWith(>)x(tail x)=f(take(div(length x)2)x)|1>0=x

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

Ungolfed:

f xs | sorted xs = f (halve xs)
     | otherwise = xs

sorted xs = or (zipWith (>) xs (tail xs))

halve xs = take (length xs `div` 2) xs

Октава , 49 байт

l=input('');while(~issorted(l))l=l(1:2:end);end;l

Попробуйте онлайн! Это было путешествие, где скучнее лучше. Обратите внимание на две гораздо более интересные записи ниже:

50 байтов

function l=q(l)if(~issorted(l))l=q(l(1:2:end));end

Попробуйте онлайн! Вместо неинтересного императивного решения мы можем сделать рекурсивное решение только для одного дополнительного байта.

53 байта

f(f=@(g)@(l){l,@()g(g)(l(1:2:end))}{2-issorted(l)}())

Попробуйте онлайн! Ага. Рекурсивная анонимная функция, благодаря блестящему ответу @ floorcat на мои советы . Анонимная функция, которая возвращает рекурсивную анонимную функцию, определяя себя в своем списке аргументов. Мне нравятся анонимные функции. Ммммм.

MATL , 11 байт

tv`1L)ttS-a

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

Это работает, удаляя каждый второй элемент.

объяснение

t      % Take a row vector as input (implicit). Duplicate
v      % Vertically concatenate the two copies of the row vector. When read with
       % linear indexing (down, then across), this effectively repeats each entry
`      % Do...while
  1L)  %   Keep only odd-indexed entries (1-based, linear indexing)
  t    %   Duplicate. This will leave a copy for the next iteration
  tS   %   Duplicate, sort
  -a   %   True if the two arrays differ in any entry
       % End (implicit). A new iteration starts if the top of the stack is true
       % Display (implicit). Prints the array that is left on the stack

Japt , 10 байт

eUñ)?U:ßUë

Попробуй

eUñ)?U:ßUë     :Implicit input of array U
e              :Compare equality with
 Uñ            :  U sorted
   )           :End compare
    ?U:        :If true then return U else
       ß       :Run the programme again with input
        Uë     :  Every second element of U

Java (JDK) , 102 байта

n->{for(;n.stream().reduce((1<<31)+0d,(a,b)->a==.5|b<a?.5:b)==.5;n=n.subList(0,n.size()/2));return n;}

Уже есть ответ на C #, поэтому я решил попробовать свой ответ на Java.

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

Crystal , 58 байт

С Array#sort( 58 байт ):

->(a : Array(Int32)){while a!=a.sort;a.pop a.size/2;end;a}

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

Без Array#sort( 101 байт ):

->(a : Array(Int32)){while a.map_with_index{|e,i|e>a.fetch i+1,Int32::MAX}.any?;a.pop a.size/2;end;a}

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

Шелуха , 6 5 байт

1 байт сохранен благодаря Zgarb

ΩΛ<Ċ2

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

объяснение

ΩΛ<Ċ2
Ω         Repeat until
 Λ<         all adjacent pairs are sorted (which means the list is sorted)
   Ċ2         drop every second element from the list

Gaia , 9 8 байт

eo₌⟨2%⟩↻

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

Объяснение:

e		| eval input as a list
       ↻	| until
 o		| the list is sorted
  ₌		| push additional copy
   ⟨2%⟩  	| and take every 2nd element

Юлия 1,0 , 30 байт

-x=x>sort(x) ? -x[1:2:end] : x

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

Принимает каждый второй элемент массива, если не отсортирован.

C ++ (gcc) , 103 байта

Я не могу комментировать, но я улучшил версию от movatica, уменьшив количество включений и используя авто.

-2 байта: floorcat
-2 байта: только ASCII

#include<regex>
auto f(auto l){while(!std::is_sorted(l.begin(),l.end()))l.resize(l.size()/2);return l;}

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

VDM-SL , 99 байт

f(i)==if forall x in set inds i&x=1or i(x-1)<=i(x) then i else f([i(y)|y in set inds i&y mod 2=0]) 

Никогда не отправлял в vdm раньше, поэтому не уверен в определенных правилах языка. Итак, я представил как определение функции, которая принимает seq of intи возвращаетseq of int

Полная программа для запуска может выглядеть так:

functions
f:seq of int +>seq of int
f(i)==if forall x in set inds i&x=1or i(x-1)<=i(x) then i else f([i(y)|y in set inds i&y mod 2=0]) 

Pyth, 10 байт

.W!SIHhc2Z

Попробуйте это онлайн здесь . Это удаляет вторую половину на каждой итерации, округляя вниз. Для того, чтобы изменить его , чтобы удалить первую половину, округление, изменить hк e.

.W!SIHhc2ZQ   Q=eval(input())
              Trailing Q inferred
  !SIH        Condition function - input variable is H
   SIH          Is H invariant under sorting?
  !             Logical not
      hc2Z    Iteration function - input variable is Z
       c2Z      Split Z into 2 halves, breaking ties to the left
      h         Take the first half
.W        Q   With initial value Q, execute iteration function while condition function is true

C ++ (gcc) , 139 137 116 байт

-2 байта спасибо потолочной кошке, -21 байт спасибо PeterZuger

#include<regex>
auto f(std::vector<int>l){while(!std::is_sorted(l.begin(),l.end()))l.resize(-~l.size()/2);return l;}

Измените размер вектора до его первой половины, пока он не будет отсортирован.

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

K (ок) , 22 20 байт

Решение:

{(*2 0N#x;x)x~x@<x}/

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

Перебирайте ввод до тех пор, пока он не отсортирован ... если он не отсортирован, возьмите первые n / 2 элементов.

{(*2 0N#x;x)x~x@<x}/ / the solution
{                 }/ / lambda that iterates
                <x   / indices that sort x ascending (<)
              x@     / apply (@) these indices back to x
            x~       / matches (~) x? returns 0 or 1
 (       ; )         / 2-item list which we index into
          x          / original input (ie if list was sorted)
       #x            / reshape (#) x
   2 0N              / as 2 rows
  *                  / take the first one      

Редактирование:

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

Юлия 1,0 , 33 байта

-a=issorted(a) ? a : -a[1:end÷2]

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

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

\d+
*
/(_+),(?!\1)/+`,_+(,?)
$1
_+
$.&

Попробуйте онлайн! Принимает числа через запятую. Объяснение:

\d+
*

Преобразовать в одинарный.

/(_+),(?!\1)/+`

Повторите, пока список не отсортирован ...

,_+(,?)
$1

... удалить каждый четный элемент.

_+
$.&

Преобразовать в десятичную.

C (gcc) , 66 байт

Отбирает вторую половину списка каждую итерацию ( n/2+1элементы, если длина нечетна).

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

Принимает ввод как указатель на начало массива, за intкоторым следует его длина. Выводит путем возврата новой длины массива (сортирует по месту).

t(a,n,i)int*a;{l:for(i=0;i<n-1;)if(a[i]>a[++i]){n/=2;goto l;}a=n;}

Безголовая версия:

t(a, n, i) int *a; { // take input as a pointer to an array of int, followed by its length; declare a loop variable i
  l: // jump label, will be goto'ed after each snap
  for(i = 0; i < n - 1; ) { // go through the whole array …
    if(a[i] > a[++i]) { // … if two elements are in the wrong order …
      n /= 2; // … snap off the second half …
      goto l; // … and start over
    }
  }
  a = n; // implicitly return the new length
}