О серии

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

Тем не менее, я буду поддерживать таблицу лидеров по всем задачам. Сериал будет проходить более 9 задач (пока), один раз в несколько дней. Каждый пользователь, участвующий во всех 9 соревнованиях, имеет право на победу во всей серии. Их общий балл - это сумма их самых коротких заявок на каждый вызов (поэтому, если вы ответите на вызов дважды, к баллу будет засчитан только лучший ответ). Если кто-то займет первое место в этом общем списке лидеров в течение 28 дней, я назначу ему награду в 500 представителей .

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

Отверстие 1: перемешать массив

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

• Каждая возможная перестановка должна быть возвращена с одинаковой вероятностью (поэтому перемешивание должно иметь равномерное распределение). Вы можете проверить, является ли ваш алгоритм единообразным / беспристрастным, реализовав его в JavaScript на Will it Shuffle , который будет генерировать матрицу смещений - результат должен выглядеть так же равномерно, как и встроенные значения Fisher-Yates или sort (в произвольном порядке) .
• Вы не должны использовать какой-либо встроенный или сторонний метод для перемешивания массива или генерации случайной перестановки (или перечисления всех перестановок). В частности, единственная встроенная случайная функция, которую вы можете использовать, - это получение одного случайного числа за раз . Вы можете предположить, что любой встроенный метод случайных чисел работает в O (1) и является абсолютно равномерным в течение запрошенного интервала (в математическом смысле - вы можете игнорировать детали представления с плавающей точкой здесь). Если ваш язык позволяет вам получить список из m случайных чисел одновременно, вы можете использовать эту возможность при условии, что m номеров не зависят друг от друга, и вы считаете это как O (m).
• Ваша реализация не должна превышать временную сложность O (N) , где N - размер массива, который должен быть перетасован. Например, вы не можете "сортировать по случайным числам".
• Вы можете либо перемешать массив на месте, либо создать новый массив (в этом случае старый массив может быть изменен по вашему усмотрению).

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

Вход и выход могут быть в любом удобном формате списка или строки, но должны поддерживать произвольные целые числа в диапазоне -2 ³¹ ≤ x <2 ³¹ . В принципе, ваш код должен работать для массивов длиной до 2 ³¹ , хотя это не обязательно должно умещаться в вашей памяти или завершаться в течение разумного периода времени. (Я просто не хочу видеть произвольные ограничения размера для циклов жесткого кода или чего-то еще.)

Это код гольф, поэтому выигрывает самое короткое представление (в байтах).

Leaderboard

Следующий фрагмент создаст таблицу лидеров по всем задачам серии.

Чтобы убедиться, что ваши ответы отображаются, начните каждый ответ с заголовка, используя следующий шаблон уценки:

# Language Name, N bytes

где Nразмер вашего представления. Если вы улучшите свой счет, вы можете сохранить старые результаты в заголовке, вычеркнув их. Например:

# Ruby, <s>104</s> <s>101</s> 96 bytes

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

/* Configuration */

var QUESTION_IDs = [45302, 45447, 46991, 49394, 51222, 66319, 89621, 120472]; // Obtain this from the url
// It will be like http://XYZ.stackexchange.com/questions/QUESTION_ID/... on any question page
var ANSWER_FILTER = "!.FjwQBrX2KXuFkv6p2lChi_RjzM19";

/* App */

var answers = [], page = 1, currentQ = -1;

function answersUrl(index) {
  return "https://api.stackexchange.com/2.2/questions/" +  QUESTION_IDs.join(";") + "/answers?page=" + index + "&pagesize=100&order=desc&sort=creation&site=codegolf&filter=" + ANSWER_FILTER;
}


function getAnswers() {
  $.ajax({
    url: answersUrl(page++),
    method: "get",
    dataType: "jsonp",
    crossDomain: true,
    success: function (data) {
      answers.push.apply(answers, data.items);
      if (data.has_more) getAnswers();
      else process();
    }
  });
}

getAnswers();

var SIZE_REG = /\d+(?=[^\d&]*(?:<(?:s>((?!>).)*<\/s>|((?!>).)+>)[^\d&]*)*$)/;
var NUMBER_REG = /\d+/;
var LANGUAGE_REG = /^#*\s*([^\n,]+)(?=,)/;//

function shouldHaveHeading(a) {
  var pass = false;
  var lines = a.body_markdown.split("\n");
  try {
    pass |= /^#/.test(a.body_markdown);
    pass |= ["-", "="]
              .indexOf(lines[1][0]) > -1;
    pass &= LANGUAGE_REG.test(a.body_markdown);
  } catch (ex) {}
  return pass;
}

function shouldHaveScore(a) {
  var pass = false;
  try {
    pass |= SIZE_REG.test(a.body_markdown.split("\n")[0]);
  } catch (ex) {}
  if (!pass) console.log(a);
  return pass;
}

function getAuthorName(a) {
  return a.owner.display_name;
}

function getAuthorId(a) {
  return a.owner.user_id;
}

function process() {
  answers = answers.filter(shouldHaveScore)
                   .filter(shouldHaveHeading);
  answers.sort(function (a, b) {
    var aB = +(a.body_markdown.split("\n")[0].match(SIZE_REG) || [Infinity])[0],
        bB = +(b.body_markdown.split("\n")[0].match(SIZE_REG) || [Infinity])[0];
    return aB - bB
  });

  var users = {};
  answers.forEach(function (a) {
    var headline = a.body_markdown.split("\n")[0];
    var question = QUESTION_IDs.indexOf(a.question_id);
    var size = parseInt((headline.match(SIZE_REG)||[0])[0]);
    var language = headline.match(LANGUAGE_REG)[1];
    var user = getAuthorName(a);
    var userId = getAuthorId(a);
    if (!users[userId]) users[userId] = {name: user, nAnswer: 0, answers: []};
    if (!users[userId].answers[question]) {
      users[userId].answers[question] = {size: Infinity};
      users[userId].nAnswer++;
    }
    if (users[userId].answers[question].size > size) {
      users[userId].answers[question] = {size: size, link: a.share_link}
    }
  });
  
  
  var sortedUsers = [];
  for (var userId in users)
    if (users.hasOwnProperty(userId)) {
      var user = users[userId];
      user.score = 0;
      user.completedAll = true;
      for (var i = 0; i < QUESTION_IDs.length; ++i) {
        if (user.answers[i])
          user.score += user.answers[i].size;
        else
          user.completedAll = false;
      }
      sortedUsers.push(user);
    }  
  
  sortedUsers.sort(function (a, b) {
    if (a.nAnswer > b.nAnswer) return -1;
    if (b.nAnswer > a.nAnswer) return 1;
    return a.score - b.score;
  });
  
  var place = 1;
  for (var i = 0; i < sortedUsers.length; ++i) {
    var user = sortedUsers[i];
    var row = '<tr><td>'+ place++ +'.</td><td>'+user.name+'</td>';
    for (var j = 0; j < QUESTION_IDs.length; ++j) {
      var answer = user.answers[j];
      if (answer)
        row += '<td><a href="'+answer.link+'">'+answer.size+'</a></td>';
      else
        row += '<td class="missing"></td>';
    }
    row += '<td></td>';
    if (user.completedAll)
      row += '<td class="total">'+user.score+'</td>';
    else
      row += '<td class="total missing">'+user.score+'</td>';
    row += '</tr>';
    $("#users").append(row);
  }
}

body { text-align: left !important}

#leaderboard {
  width: 500px; 
}

#answer-list {
  padding: 10px;
  width: 290px;
  float: left;
}

#language-list {
  padding: 10px;
  width: 290px;
  float: left;
}

table thead {
  font-weight: bold;
}

table td {
  padding: 5px;
}

td.total {
  font-weight: bold;
  text-align: right;
}

td.missing {
  background: #bbbbbb;
}

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<link rel="stylesheet" type="text/css" href="//cdn.sstatic.net/codegolf/all.css?v=83c949450c8b">
<div id="leaderboard">
  <h2>Leaderboard</h2>
  <p>
    Missing scores are shown as grey cells. A grey total indicates that the user has not participated in all challenges and is not eligible for the overall victory yet.
  </p>
  <table class="_user-list">
    <thead>
      <tr><td></td><td>User</td>
        <td><a href="https://codegolf.stackexchange.com/q/45302/8478">#1</a></td>
        <td><a href="https://codegolf.stackexchange.com/q/45447/8478">#2</a></td>
        <td><a href="https://codegolf.stackexchange.com/q/46991/8478">#3</a></td>
        <td><a href="https://codegolf.stackexchange.com/q/49394/8478">#4</a></td>
        <td><a href="https://codegolf.stackexchange.com/q/51222/8478">#5</a></td>
        <td><a href="https://codegolf.stackexchange.com/q/66319/8478">#6</a></td>
        <td><a href="https://codegolf.stackexchange.com/q/89621/8478">#7</a></td>
        <td><a href="https://codegolf.stackexchange.com/q/120472/8478">#8</a></td>
        <td></td><td>Total</td>
      </tr>
    </thead>
    <tbody id="users">

    </tbody>
  </table>
</div>
<table style="display: none">
  <tbody id="answer-template">
    <tr><td>{{NAME}}</td><td>{{LANGUAGE}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>
<table style="display: none">
  <tbody id="language-template">
    <tr><td>{{LANGUAGE}}</td><td>{{NAME}}</td><td>{{SIZE}}</td><td><a href="{{LINK}}">Link</a></td></tr>
  </tbody>
</table>

Дьялог АПЛ, 25 24 байта

Сначала для 25-символьного решения: i{⊃a[⍺⍵]←a[⍵⍺]}¨?i←⌽⍳⍴a←⎕

                      a←⎕ ⍝ evaluated input, assign to "a"
                     ⍴a   ⍝ length
                    ⍳⍴a   ⍝ 1 2 .. length
                   ⌽⍳⍴a   ⍝ length .. 2 1
                 i←       ⍝ assign to "i"
                ?i        ⍝ random choices: (1..length)(1..length-1)..(1 2)(1)
i{            }¨?i        ⍝ for each index ⍺ and corresponding random choice ⍵
   a[⍺⍵]←a[⍵⍺]            ⍝ swap a[⍺] and a[⍵]
        ←                 ⍝ in Dyalog, assignment returns its right-hand side
  ⊃                       ⍝ first element, i.e. a[⍵]
                          ⍝ the result from {} is an array of all those a[⍵]

После некоторых преобразований эквивалентности выше:

i {}¨ ?i  ←→  i {}¨∘? i   ⍝ because A f∘g B ←→ A f g B
          ←→  {}¨∘?⍨ i    ⍝ because f⍨ B ←→ B f B

мы можем избавиться от задания i←и сохранить персонажа:

{⊃a[⍺⍵]←a[⍵⍺]}¨∘?⍨⌽⍳⍴a←⎕

80386 машинный код, 44 24 байта

Hexdump кода:

60 8b fa 0f c7 f0 33 d2 f7 f1 49 8b 04 8f 87 04
97 89 04 8f 75 ed 61 c3

Спасибо FUZxxl, который предложил использовать rdrandинструкцию.

Вот исходный код (может быть скомпилирован Visual Studio):

__declspec(naked) void __fastcall shuffle(unsigned size, int array[])
{
    // fastcall convention:
    // ecx = size
    // edx = array
    _asm
    {
        pushad;             // save registers
        mov edi, edx;       // edi now points to the array

    myloop:
        rdrand eax;         // get a random number
        xor edx, edx;
        div ecx;            // edx = random index in the array

        dec ecx;            // count down
        mov eax, [edi + 4 * ecx];   // swap elements
        xchg eax, [edi + 4 * edx];  // swap elements
        mov [edi + 4 * ecx], eax;   // swap elements
        jnz myloop;

        popad;              // restore registers
        ret;
    }
}

Еще одна реализация Фишера-Йейтса. Большая часть игры в гольф была достигнута путем передачи параметров в регистрах.

Ява, 88 101

Основной трюк Фишера-Йейтса делает свое дело. У меня такое ощущение, что он будет использоваться здесь довольно часто, поскольку его легко и быстро реализовать. Здесь есть какая-то петля / задание, но, честно говоря , в гольф не так уж много; это просто короткий от природы.

void t(int[]s){for(int i=s.length,t,x;i>0;t=s[x*=Math.random()],s[x]=s[i],s[i]=t)x=i--;}

С некоторыми переносами строк:

void t(int[]s){
    for(int i=s.length,t,x;
        i>0;
        t=s[x*=Math.random()],
        s[x]=s[i],
        s[i]=t
    )
        x=i--;
}

Это перемешивает на месте, изменяя исходный массив s[]. Тестовая программа:

public class Shuffle {
    public static void main(String[] args) {
        int[] a = {1,2,3,4,5,6,7,8,9};
        new Shuffle().t(a);
        for(int b:a)
            System.out.print(b+" ");
    }
    void t(int[]s){for(int i=s.length,t,x;i>0;t=s[x*=Math.random()],s[x]=s[i],s[i]=t)x=i--;}
}

Python 2, 86 байт

from random import*
def S(L):i=len(L);exec"i-=1;j=randint(0,i);L[i],L[j]=L[j],L[i];"*i

Это функция, которая перемешивает массив на месте, не возвращая его, используя простую реализацию перемешивания Фишера-Йейтса . Получение случайных чисел из Python стоит дорого ...

Спасибо @xnor и @colevk за советы.

J, 45 44 символа

Это было сложно.

<@({.,?@#@}.({,<^:3@[{])}.)&>/@(<"0@i.@#,<)

Вот объяснение:

1. # y: Подсчет из y, то есть, количество элементов в y.
2. ?@# y: Случайное число, равномерно распределенное по диапазону от 1до (#y)-1.
3. x { y: Элемент из y индекса x.
4. (<<<x) { y: Все элементы, кроме элемента с индексом xв y.
5. x , y: y Добавляется к x.
6. x ({ , <^:3@[ { ]) y: Элемент с индексом xв y, то все остальные элементы.
7. (?@# ({ , <^:3@[ { ]) ]) yСлучайно y, потом все остальные предметы.
8. x {. y: Первые xпредметы взяты из y.
9. x }. y: Первые xпредметы выпали из y.
10. x ({. , }.) y: Первые xпредметы взяты из y, затем первые xпредметы выброшены изy
11. x ({. , (?@# ({ , <^:3@[ { ]) ])@}.) y: Первые xэлементы, взятые из y, затем первые xэлементы из yобработанных, как в номере 7.
12. x ({. , ?@#@}. ({ , <^:3@[ { ]) }.) yТо же самое с выпавшим дропом, чтобы спасти одного персонажа.
13. u/ y: u вставлено между элементами y.
14. < y: в y штучной упаковке .
15. <"0 yКаждый предмет в y штучной упаковке .
16. i. y: целые числа от 0до y - 1.
17. i.@# y: целые числа от 0до (#y) - 1.
18. (<"0@i.@# , <) y: Целые из 0к (#y) - 1каждой коробке , а затем yв одном окне. Это необходимо, потому что массивы в J одинаковы. Коробка скрывает форму своего содержимого.
19. x u&v y: Как (v x) u (v y).
20. > y: y открыл , то есть без своей коробки.
21. x ({. , ?@#@}. ({ , <^:3@[ { ]) }.)&> y фраза из числа 12 применяется к ее без коробки аргументы.
22. ({. , ?@#@}. ({ , <^:3@[ { ]) }.)&>/ yфраза из числа 21 вставлена между пунктами y.
23. ({. , ?@#@}. ({ , <^:3@[ { ]) }.)&>/@(<"0@i.@# , <) yФраза из числа 22 применяется к результату фразы из числа 18 или равномерной перестановки предметов y.

Pyth, 25 байт

Проверьте это здесь.

Еще одна реализация Фишера-Йейтса. По сути, это то же самое, что и решение @ Sp3000 python, только в pyth.

FNrlQ1KONJ@QN XXQN@QKKJ)Q

Спасибо @Jakube за трюк с обменом

<implicit>    Q=input()
FNrlQ1        For N in len(Q) to 1, only goes len Q-1 because how range implemented in pyth
 KON          K = random int 0-N
 J@QN         J=Q[N]
 <space>      Suppress print
 XXQN@QKKJ    Swap K and J
)             End for
Q             Print Q

Perl, 68 56 44

Как и во многих других решениях, здесь используется алгоритм Фишера-Йейтса .

С помощью комментария Nutki , 12 символов сохраняются при использовании $_вместо $iи выполнении операций с индексами массива.

44:

sub f{@_[$_,$j]=@_[$j=rand$_,--$_]for 1..@_}

56:

sub f{$i=@_;$j=int(rand$i),@_[$i,$j]=@_[$j,$i]while$i--}

Это мой первый Codegolf.

C 63 61 60 байт

i,t;s(a,m)int*a;{for(;m;a[m]=t)t=a[i=rand()%m--],a[i]=a[m];}

Просто прямая реализация Фишера-Йейтса, которая сортирует данный массив на месте. Прекрасно компилируется и связывается с компилятором visual studio (vs2013, другие версии не тестировались) и компилятором Intel. Приятно выглядящая функция подписи есть s(int array[], int length). Я законно впечатлен, я победил Python и Ruby.

Это предполагает, что srand()вызывается, и rand () реализован правильно, но я считаю, что это правило учитывает это:

You may assume that any built-in random number method runs in O(1) and is perfectly uniform over the requested interval

Красиво отформатированная версия:

index, temp;
shuffle(array, length) int* array;  {
    for(;length; array[index] = temp)
        index = rand() % length--,
        temp = array[length],
        array[length] = array[index];
}

Октава, 88 77 байт

function s=r(s)for(i=length(s):-1:1)t=s(x=randi(i));s(x)=s(i);s(i)=t;end;end

Еще одна реализация Фишера-Йейтса ... Должна быть довольно простой, если я добавлю обычные возвраты строк и интервал:

function s=r(s)
  for(i=length(s):-1:1) # Counting down from i to 1
    t=s(x=randi(i));    # randi is builtin number generator for an int from 0 to i
    s(x)=s(i);
    s(i)=t;
  end
end

К сожалению, «конечные» ключевые слова действительно убивают счет в гольфе. Эй, я могу использовать «конец» вместо «endfor» и «endfunction»!

Ява 8, 77

(x)->{for(int i=x.length,j,t;;t=x[j*=Math.random()],x[j]=x[i],x[i]=t)j=i--;};

Это лямбда, принимающая int[]и возвращающая пустоту. Моя первая попытка показалась мне не очень интересной, поэтому я решил сделать так, чтобы она была исключена.

Тестовая программа:

interface shuff {
    void shuff(int[] x);
}
class Ideone
{
    public static void main (String[] args) throws java.lang.Exception
    {
        shuff s = (x)->{for(int i=x.length,j,t;;t=x[j*=Math.random()],x[j]=x[i],x[i]=t)j=i--;};
        int[] x = {3, 9, 2, 93, 32, 39, 4, 5, 5, 5, 6, 0};
        try {
            s.shuff(x);
        } catch(ArrayIndexOutOfBoundsException _) {}
        for(int a:x) System.out.println(a);
    }
}

Golflua, 37

Как запустить Golflua?

~@i=1,#X`r=M.r(i)X[i],X[r]=X[r],X[i]$

Входные данные предоставляются в виде таблицы в переменной X. Таблица перемешивается на месте.

Пример использования:

> X={0,-45,8,11,2}
> ~@i=1,#X`r=M.r(i)X[i],X[r]=X[r],X[i]$
> w(T.u(X))
-45 0 8 11 2

R, 79 байт

f=function(x){n=length(x);for(i in 1:n){j=sample(i:n,1);x[c(i,j)]=x[c(j,i)]};x}

Это простая реализация шаффла Фишера-Йейтса. Функция R sampleрисует простую случайную выборку заданного размера из заданного вектора с равной вероятностью. Здесь мы рисуем случайную выборку размером 1 на каждой итерации из целых чисел i, ..., n. Как указано в вопросе, это можно предположить как O (1), поэтому во всей этой реализации должно быть O (N).

Матлаб, 67

Также реализует Фишер-Йейтс.

a=input('');n=numel(a);for i=1:n;k=randi(i);a([i,k])=a([k,i]);end;a

Я думал, что это слишком плохо, я не мог использовать randpermфункцию Matlab . Но после некоторого возни, я подумал, что могу посмотреть на источник, randpermчтобы увидеть, как это делается, и я был удивлен, увидев, что была только одна строка: [~,p] = sort(rand(1,n))=)

Perl, 44

sub f{($_[$x],$_)=($_,$_[$x=rand++$i])for@_}

Еще один Perl в 44 символов. Пример использования:

@x=(1..9);f(@x);print@x

Mathematica, 82 90 83 93 байта

Примечание. Эта вариация тасования Фишера-Йейтса на самом деле является решением Мартина Бюттнера, с некоторой обработкой кода алефальфой. sэто входной массив. Ничего особенного, но иногда простые вещи самые неуловимые.

f@s_:=(a=s;m=Length@a;Do[t=a[[r=RandomInteger@{1,m-1}]];a[[r]]=a[[m]]; a[[m]]=t,{n,1,m-1}];a)

Рубин, 57 байт

->a{a.size.times{|i|j=rand(i+1);a[i],a[j]=a[j],a[i]};p a}

Вход (как лямбда-функция):

f.([1,2,3,4,5])

Выход:

[2, 1, 4, 3, 5]

TI-BASIC, 46 байтов

For(X,dim(L1),2,-1:randInt(1,X→Y:L1(X→Z:L1(Y→L1(X:Z→L1(Y:L1

1   111   2  1111112       1111112 111112 1112 111112 1112

Источник для подсчета байтов

К, 31 символ

f:{{l[i:x,1?x]:l@|i}'|!#l::x;l}

Не такой короткий, как тот, который я выложил раньше (который был дисквалифицирован) ... о, хорошо.

Это основной случай Фишера-Йейтса. Это было построено с большой помощью из списка рассылки Kona .

JavaScript (ES6), 66

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

F=a=>a.map((v,i)=>a[a[i]=a[j=0|i+Math.random()*(a.length-i)],j]=v)

MATL , 16 байт

XH`HnYr&)XHxvHHn

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

Фишер-Йейтс в МАТЛ. Почти треть этой программы посвящена письмуH , которая соответствует функции буфера обмена в MATL.

В основном, Hхранит неиспользуемые элементы из ввода, в то время как стек отслеживает перетасованный список.

Джапт, 12

rÈiMqZÄ Y}[]

Попытайся!

-10 (около половины;) благодаря @Shaggy!

Я давно хотел попробовать язык игры в гольф, и у переводчика Japt была хорошая документация и возможность опробовать вещи в браузере.

Ниже приведена стратегия, которую я выбрал:

• Уменьшите входное заполнение пустым массивом
• На каждом шаге найдите случайный слот для вставки текущего элемента

Javascript ES6, 69

a=>{m=a.length;while(m)[a[m],a[i]]=[a[i=~~(Math.random()*m--)],a[m]]}

Это Фишер-Йейтс.

PS: можно протестировать в Firefox

Pyth, 27 байт

Проверьте это здесь

FkQJOhlYaY?@YtJJkIJ XYtJk;Y

Это реализация инкрементального шаффла Фишера-Йейтса, упомянутого второго здесь .

Хаскелл, 170

import System.Random
import Data.Array.IO
s a=do(_,n)<-getBounds a;sequence$map(\i->do j<-randomRIO(i,n);p<-a%i;q<-a%j;writeArray a j p;return q)[1..n]where(%)=readArray

Другое решение Фишера-Йейтса, вдохновленное алгоритмом по адресу https://wiki.haskell.org/Random_shuffle .

s это функция, которая имеет подпись: IOArray Int a -> IO [a]

CJam - 30

q~_,,W%{_I=I)mr:J2$=@I@tJ@t}fI

Попробуйте это в http://cjam.aditsu.net/

Пример ввода: [10 20 30 40 50]
Пример вывода: 3020401050(добавитьp в конце кода для красивой печати)

Если коду разрешено принимать входные данные из стека (например, функции), то первые 2 символа можно удалить, уменьшив размер до 28.

Объяснение:

Код длиннее, чем я ожидал, из-за отсутствия оператора «swap» для массивов
(будет реализовано позже: p)

q~            read and evaluate the input (let's call the array "A")
_,,           make an array [0 1 2 ... N-1] where N is the size of A
W%            reverse the array, obtaining [N-1 ... 2 1 0]
{…}fI         for I in this array
    _I=       push A[I]
    I)mr:J    push a random number from 0 to I (inclusive) and store it in J
              stack: A, A[I], J
    2$=       get A[J]
    @I@t      set A[I] = A[J]
              stack: former A[I], A
    J@t       set A[J] = former A[I]

JavaScript (ES 6), 61

S=a=>(a.map((c,i)=>(a[i]=a[j=Math.random()*++i|0],a[j]=c)),a)

Вы можете проверить это здесь , просто добавив строку с надписью shuffle = S(только Firefox).

СТАТА, 161

di _r(s)
set ob wordcount($s)
token $s
g a=0
foreach x in $s{
gl j=floor(runiform()*_n)+1
replace a=`$j' if word($s,_n)=`x'
replace a=`x' if word($s,_n)=`$j'
}
l

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

Java, 93 байта

a->{for(int b=0,c,d=0,e=a.length;b<e;c=a[b],a[b]=a[d],a[d]=c,b++,d=b)d+=Math.random()*(e-b);}

Пример использования: http://ideone.com/RqSMnZ

SQF, 91 байт

params["i"];{n=floor random count i;i set[_forEachIndex,i select n];i set[n,_x]}forEach i;i

Perl, 41 байт

sub f{push@b,splice@_,rand@_,1while@_;@b}

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