Является ли решение судоку слишком сложно? Даже версия грубой силы ? Вот упражнение по кодированию, которое немного проще. Я надеюсь. :-П

Напишите самую короткую функцию для реализации bogosort. В частности, ваша функция должна:

• Возьмите массив (или эквивалент вашего языка) в качестве ввода
• Проверьте, находятся ли его элементы в отсортированном порядке; если это так, вернуть массив
• Если нет, перетасуйте элементы и начните снова

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

Пояснения: Вы можете использовать любой тип элемента, если хотите, если, конечно, есть какой-то способ их заказать. Кроме того, перетасовка должна быть равномерной; ничего из этого «я просто быстро сортирую и назову это перетасованным» бизнесом. :-)

APL (Дьялог), 20

{⍵≡⍵[⍋⍵]:⍵⋄∇⍵[?⍨⍴⍵]}

объяснение

⍵является (правым) аргументом
⍵≡⍵[⍋⍵]: Проверяет, ⍵равна ли сортируемая величина ⍵самому себе
:⍵: Если да, то возвращает ⍵
∇⍵[?⍨⍴⍵]: Иначе, генерирует массив от 1 до ⍴⍵(длина ⍵) в случайном порядке, переупорядочивает в ⍵соответствии с этим ( ⍵[...]) и применяет функцию к нему ( ∇)

Внезапно вернуться к этой проблеме и ...

APL (Дьялог), 19

{∧/2≤/⍵:⍵⋄∇⍵[?⍨⍴⍵]}

Просто мысль о сортировке массива в проверке делает его бессмысленным (не говоря о том, что Bogosort имеет смысл), более точная реализация будет ∧/2≤/⍵, и это приведет к снижению количества символов.

Perl 6: 23 символа

@s.=pick(*)until[<=] @s

APL (22)

{(⍳X←⍴⍵)≡⍋⍵:⍵⋄∇⍵[X?X]}

Использование:

    {(⍳X←⍴⍵)≡⍋⍵:⍵⋄∇⍵[X?X]} 3 2 1
1 2 3

Объяснение:

• ⍋⍵: возвращает индексы элементов в отсортированном порядке, поэтому ⍋30 10 20дает2 1 3
• (⍳X←⍴⍵)≡⍋⍵:⍵Сохраните длину входного списка в X. Если диапазон [1..X]равен порядку отсортированного индекса, список отсортирован, поэтому верните его.
• ⋄∇⍵[X?X]: если это не так, рекурсивно использовать перемешанный массив.

Рубин - 33 персонажа

g=->l{l.shuffle!!=l.sort ?redo:l}

Математика , 40 37

NestWhile[RandomSample,#,Sort@#!=#&]&

С пробелами:

NestWhile[RandomSample, #, Sort@# != # &] &

J - 34 27

f=:({~?~@#)^:(1-(-:/:~))^:_

например:

f 5 4 1 3 2
1 2 3 4 5

f 'hello'
ehllo

Часть {~? ~ @ # Тасует ввод:

({~ ?~@#) 1 9 8 4
4 8 9 1
({~ ?~@#) 'abcd'
bdca

Python 61

Сортировка на месте.

import random
def f(l):
 while l!=sorted(l):random.shuffle(l)

Python 94

from itertools import*
def f(a):return [x for x in permutations(a) if x==tuple(sorted(a))][0]

Другие ответы Python используют random.shuffle (). Документация случайного модуля Python гласит:

Обратите внимание, что даже для довольно небольших len (x) общее число перестановок x больше, чем период большинства генераторов случайных чисел; это подразумевает, что большинство перестановок длинной последовательности никогда не может быть сгенерировано.

К, 31 25

{while[~x~x@<x;x:x@(-#x)?#x];x}

{x@(-#x)?#x}/[{~x~x@<x};]

,

k){x@(-#x)?#x}/[{~x~x@<x};] 3 9 5 6 7 9 1
`s#1 3 5 6 7 9 9

,

k){x@(-#x)?#x}/[{~x~x@<x};] "ascsasd"
`s#"aacdsss"

Python (69 символов)

from random import*
def f(a):
 while a>sorted(a):shuffle(a)
 return a

Сортирует целые числа в порядке возрастания чисел. Обратите внимание, что рекурсивные решения, такие как

from random import*;f=lambda a:a>sorted(a)and(shuffle(a)or f(a))or a

потерпит неудачу из-за переполнения стека даже для небольших входных данных (скажем, N> 5), потому что Python не выполняет оптимизацию хвостового вызова.

D без пользовательского компаратора: 59 символов

R f(R)(R r){while(!isSorted(r))r.randomShuffle();return r;}

Более разборчиво:

R f(R)(R r)
{
    while(!r.isSorted)
        r.randomShuffle();

    return r;
}

D с пользовательским компаратором: 69 символов

R f(alias p,R)(R r){while(!isSorted!p(r))r.randomShuffle();return r;}

Более разборчиво:

R f(alias p, R)(R r)
{
    while(!isSorted!p(r))
        r.randomShuffle();

    return r;
}

Скала 73:

def s(l:Seq[Int]):Seq[Int]=if(l==l.sorted)l else s(util.Random.shuffle l)

В Scala мы можем проверить, выполнял ли компилятор оптимизацию хвостового вызова:

@annotation.tailrec
def s(l:Seq[Int]):Seq[Int]=if(l==l.sorted)l else s(util.Random shuffle l)

и да, это так. Однако для краткого списка из 100 значений:

val rList = (1 to 100).map(x=>r.nextInt (500))
s(rList) 

Потребовалось почти 4 месяца, чтобы завершить. ;)

C # (184 символа)

T[]S<T>(T[]i)where T:IComparable<T>{T l=default(T);while(!i.All(e=>{var r=e.CompareTo(l)>=0;l=e;return r;})){i=i.OrderBy(a=>Guid.NewGuid()).ToArray();l=default(T);}return i.ToArray();}

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

У кого-нибудь есть советы, как сделать это лучше?

Редактировать версию, которая только сортирует int (134 символа):

int[]S(int[]i){var l=0;while(!i.All(e=>{var r=e>=l;l=e;return r;})){i=i.OrderBy(a=>Guid.NewGuid()).ToArray();l=0;}return i.ToArray();}

GNU / BASH 65

b(){ IFS=$'\n';echo "$*"|sort -C&&echo "$*"||b $(shuf -e "$@");}

C ++ 11, 150 символов

#include<deque>
#include<algorithm>
void B(std::deque &A){while(!std::is_sorted(A.begin(),A.end())std::random_shuffle(myvector.begin(),myvector.end());}

Просто .. сделано для удовольствия.

Питон - 61 символ

рекурсивный

from random import*;f=lambda l:l==sorted(l)or shuffle(l)>f(l)

PowerShell , 85 82 56 55 52 байта

^{-26 байт благодаря предложениям mazzy
-1 байт благодаря AdmBorkBork
-3 байт благодаря mazzy}

for($l=$args;"$l"-ne($l|sort)){$l=$l|sort{random}}$l

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

PowerShell имеет сравнительно дешевое сравнение массивов, приводя их к строкам и сравнивая их.

Javascript 291 символов

мин

function f(e){var t=[].concat(e).sort();t.e=function(e){var n=true;t.forEach(function(t,r){if(t!=e[r])n=false});return n};while(!t.e(e.sort(function(){return Math.floor(Math.random()*2)?1:-1}))){console.log(e)}return e}

ун-мин

function f(a) {
var b = [].concat(a).sort();
b.e = function (z) {
    var l = true;
    b.forEach(function (v, i) {
        if (v != z[i]) l = false;
    });
    return l
};
while (!b.e(a.sort(function () {
    return Math.floor(Math.random() * 2) ? 1 : -1;
}))) {
    console.log(a);
}
return a;
}

Matlab, 59 байт

Относительно прямой подход:

x=input('');while~issorted(x);x=x(randperm(numel(x)));end;x

J, 22 байта

$:@({~?~@#)`]@.(-:/:~)

Это рекурсивная, молчаливая монада, использующая повестку дня. Вот как это работает:

Позвольте yбыть нашим списком. Во-первых, глагол справа от повестки дня -:/:~. Этот глагол любезно предоставлен Лики Нун . Он соответствует ( -:) независимо от того, отсортирован ли ввод ( /:~) с использованием монадического хука. ( (f g) y = y f (g y)) Это возвращает один или ноль соответственно. Левая часть повестки дня представляет собой герунду из двух глаголов: справа - глагол тождества ], а слева - место, где происходит рекурсия. По вопросам повестки дня выбирает либо личность глагола в позиции , 1если список будет отсортирован, и больше глагола в положении , 0если список не отсортирован.

$:@({~?~@#)звонки $:(самый длинный глагол, в котором он содержится) поверх результата {~?~@#on y. Это перемешивает список, так как ?~@#принимает перестановки длины y, будучи случайным образом отсортированными индексами y. {~в монадическом хуке возвращает список y, индексами которого являются правильные аргументы. Этот перетасованный список затем вызывается снова с повесткой дня и повторяется, пока он не будет отсортирован.

C ++ 14, 158 байт

#include <algorithm>
#include <random>
[](int*a,int s){std::random_device r;for(std::knuth_b g(r());!std::is_sorted(a,a+s);std::shuffle(a,a+s,g));return a;};

Желе , 6 байтов, языковые проблемы

ẊŒ¿’$¿

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

объяснение

ẊŒ¿’$¿
     ¿  While
 Œ¿’$     the input is not in its earliest possible permutation (i.e. sorted)
Ẋ       shuffle it

Œ¿присваивает номер каждой перестановке списка; 1 отсортировано, 2 имеет два последних замененных элемента и т. Д., Вплоть до факториала длины списка (который является списком в обратном порядке). Таким образом, для отсортированного списка это значение равно 1, и мы можем уменьшить его, используя ’для создания «не отсортированного» теста, который можно использовать в качестве логического значения в условии цикла while. Это $вызывает условие для анализа в группе.

C ++, 166 байт

Мех.

#import<algorithm>
#import<random>
#define r b.begin(),b.end()
template<class v>
v f(v b){auto a=std::mt19937();while(!std::is_sorted(r))std::shuffle(r,a);return b;}

Это должно работать на всех контейнерах STL, которые имеют begin()и end().

Ungolfed:

#include <algorithm>
#include <random>
template <class v>
v f(v b) {
    auto a = std::mt19937();
    while (!std::is_sorted(b.begin(),b.end()))
        std::shuffle(b.begin(),b.end(),a);

    return b;
}

APL (Dyalog Extended) , 15 байт

(?⍨∘≢⊇⊢)⍣{⍺≡∧⍺}

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

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

∈&ṣ≤₁

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

Когда я впервые увидел ответ Brachylog от ais523 (в отличие от его ответа Jelly, потому что, если я не ошибаюсь, user62131 также был им), я подумал: а что, если вместо рекурсии будет использоваться возврат назад? Итак, сначала я попробовал ṣ≤₁. Оказывается, поскольку случайный выбор чего-либо не приводит к множественным выводам, а только к тому, что один вывод недетерминированно, к предикату ṣшаффла нельзя вернуться, поэтому запуск, который просто не удастся, если вам не повезет правильно перетасовать его с первой попытки. После этого я попробовал pṣ≤₁, что сработало большую часть времени, но, поскольку конечный длинный список содержит конечное число перестановок, иногда он по-прежнему терпел неудачу. После того как я отказался от цели сокращения длины, я наконец-то придумал:

         The input
∈        is an element of
         an unused implicit variable,
 &       and the input
  ṣ      shuffled randomly
   ≤₁    which is increasing
         is the output.

(Демонстрация случайности)

Хотя на самом деле это может быть немного короче, если мы возьмем некоторые свободы с I / O ...

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

⊆ṣ≤₁

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

Чтобы выходные данные были полезными, входные данные не должны содержать дублирующихся элементов, поскольку в дополнение к сортировке входных данных этот предикат bogosort добавляет случайное количество дублирующих элементов и нули. (Гипотетически, это может добавить что угодно, но это как бы не так.) Обычно я бы не стал упоминать что-то настолько далекое от правильного функционирования, но я чувствую, что это в духе задачи.

⊆        An ordered superset of the input
 ṣ       shuffled randomly
  ≤₁     which is increasing
         is the output.

Perl 6 , 28 байт

{({.pick(*)}...~.sort).tail}

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

Блок анонимного кода, который перемешивает список до его сортировки. Обратите внимание, что он сортирует список хотя бы один раз, что разрешено. И нет, его {.pick(*)}нельзя заменить*.pick(*)

Pyth , 11 байт

Wn=Q.SQSQ;Q

Довольно доволен этим, наверное, можно еще немного поиграть в гольф

объяснение

Wn=Q.SQSQ;Q
W    While
  =Q.SQ    Variable Q (input variable) shuffled 
 n  Does not equal
       SQ    Variable Q sorted
             ;  Do nothing (loop ends)
              Q    And output variable Q

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

Japt , 11 9 байт

_eZñ}a@öx

Попытайся

_eZñ}a@öx     :Implicit input of array U
_             :Function taking an array as argument via parameter Z
 e            :  Test Z for equality with
  Zñ          :  Z sorted
    }         :End function
     a        :Repeat and return the first result that returns true
      @       :Run this function each time and pass the result to the first function
       öx     :  Random permutation of U

Brachylog (v2), 5 байт

≤₁|ṣ↰

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

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

объяснение

≤₁|ṣ↰
≤₁      Assert that {the input} is (nonstrictly) sorted in ascending order
  |     Output it
  |     Exception handler: if an assertion fails:
   ṣ      Randomly shuffle {the input}
    ↰     and run this function recursively on it, {outputting its output}

Prolog (язык, на котором компилируется Brachylog) является хвостово-рекурсивным, поэтому эта функция в конечном итоге компилируется в узкий цикл.

C (203 символа, без входного цикла: только функция)

#include <stdio.h>
#define P (int*a,int n){
#define F for(i=0;i<n;i++){
int i,j,v;s P F if(a[i]>a[i+1])return 0;}return 1;}void h P F v=a[i];a[i]=a[j=rand()%n];a[j]=v;}}void b P while(!s(a,n-1))h(a,n);}

Это то же самое, что и ниже, где мы также читаем массив из stdin и записываем отсортированный массив. Так как Q попросил функцию, а не целую программу ...

С (296 символов)

#include <stdio.h>
#define P (int*a,int n){
#define F for(i=0;i<n;i++){
int i,j,n,v,x[999];s P F if(a[i]>a[i+1])return 0;}return 1;}void h P F j=rand()%n;v=a[i];a[i]=a[j];a[j]=v;}}void b P while(!s(a,n-1))h(a,n);}main(){while(scanf("%d",&v)==1)x[n++]=v;if(!s(x,n))b(x,n);F printf("%d\n",x[i]);}}

Компиляция может дать предупреждение (неявные объявления). Ограничение размера массива Hardencoded 999 элементов. Хрупкое.

если нет необходимости предварительно проверять, отсортирован ли массив, это можно сделать в 284.

С (251 символ, было 284)

#include <stdio.h>
#define F for(i=0;i<n;i++){
int i,j,n,v,a[999];s(int n){F if(a[i]>a[i+1])return 0;}return 1;}void h(){F v=a[i];a[i]=a[j=rand()%n];a[j]=v;}}void b(){while(!s(n-1))h();}main(){while(scanf("%d",&a[n++])>0);b();F printf("%d\n",a[i]);}}

(используя глобальные переменные вместо аргументов функций).