Sorting algorithms/Bogosort: Difference between revisions

=={{header|ActionScript}}==

public function bogoSort(arr:Array):Array

{

return true;

}

=={{header|Ada}}==

with Ada.Text_IO; use Ada.Text_IO;

with Ada.Numerics.Discrete_Random;

end loop;

end Test_Bogosort;

The solution is generic. The procedure Bogosort can be instantiated with any copyable comparable type. In the example given it is the standard Integer type. Sample output:

<pre>

=={{header|C++}}==

The following algorithm actually works for all sequences of comparable types; restricting to lists of integers would not make the code simpler.

#include <algorithm>

while (std::adjacent_find(begin, end, std::greater<value_type>()) != end)

std::random_shuffle(begin, end);

Using the is_sorted function, part of the SGI STL implementation:

{{works with|GCC}}

#include <ext/algorithm>

while (!__gnu_cxx::is_sorted(begin, end))

std::random_shuffle(begin, end);

=={{header|C sharp|C#}}==

{{works with|C sharp|C#|3.0+}}

using System;

using System.Collections.Generic;

}

}

=={{header|D}}==

import std.stdio, std.random ;

writefln("%s", b) ; // sort is in place

=={{header|Fortran}}==

{{works with|Java|1.5+}}

This implementation works for all comparable types (types with <tt>compareTo</tt> defined).

import java.util.List;

import java.util.Iterator;

Collections.shuffle(list);

}

=={{header|Modula-3}}==

IMPORT IO, Random;

END;

IO.PutChar('\n');

=={{header|Oberon-2}}==

=={{header|OCaml}}==

let rec is_sorted comp = function

| e1 :: e2 :: r -> comp e1 e2 <= 0 && is_sorted comp (e2 :: r)

else

bogosort (shuffle li)

Example:

<pre>

=={{header|Perl}}==

{my @l = @_;

shuffle(\@l) until in_order(@l);

for (my $n = $#l ; $n ; --$n)

{my $k = int rand($n + 1);

=={{header|PHP}}==

while (!in_order($l))

shuffle($l);

return FALSE;

return TRUE;

=={{header|Python}}==

def bogosort(l):

return False

last = x

Alternative definition for ''in_order'' (Python 2.5)

An alternative implementation for Python 2.5 or later:

def bogosort(lst):

random.shuffle(lst) # must shuffle it first or it's a bug if lst was pre-sorted! :)

while lst != sorted(lst):

random.shuffle(lst)

=={{header|Ruby}}==

l.sort_by { rand }

end

def in_order(l)

(0..l.length-2).all? {|i| l[i] <= l[i+1] }

An alternative implementation:

l.sort_by { rand }

end

l = shuffle(l) until l == l.sort

l