Sorting algorithms/Bogosort: Difference between revisions
Added Easylang
m (→{{header|Phix}}: added syntax colouring the hard way) |
(Added Easylang) |
||
(26 intermediate revisions by 12 users not shown) | |||
Line 25:
<br><br>
=={{header|11l}}==
<
R all((0 .< data.len - 1).map(i -> @data[i] <= @data[i + 1]))
Line 34:
V arr = [2, 1, 3]
bogosort(&arr)
print(arr)</
{{out}}
Line 43:
=={{header|AArch64 Assembly}}==
{{works with|as|Raspberry Pi 3B version Buster 64 bits}}
<syntaxhighlight lang="aarch64 assembly">
/* ARM assembly AARCH64 Raspberry PI 3B */
/* program bogosort64.s */
Line 217:
/* for this file see task include a file in language AArch64 assembly */
.include "../includeARM64.inc"
</syntaxhighlight>
=={{header|Action!}}==
<syntaxhighlight lang="action!">PROC PrintArray(INT ARRAY a INT size)
INT i
Put('[)
FOR i=0 TO size-1
DO
IF i>0 THEN Put(' ) FI
PrintI(a(i))
OD
Put(']) PutE()
RETURN
PROC KnuthShuffle(INT ARRAY tab BYTE size)
BYTE i,j
INT tmp
i=size-1
WHILE i>0
DO
j=Rand(i+1)
tmp=tab(i)
tab(i)=tab(j)
tab(j)=tmp
i==-1
OD
RETURN
BYTE FUNC IsSorted(INT ARRAY tab BYTE size)
BYTE i
IF size<2 THEN
RETURN (1)
FI
FOR i=0 TO size-2
DO
IF tab(i)>tab(i+1) THEN
RETURN (0)
FI
OD
RETURN (1)
PROC BogoSort(INT ARRAY a INT size)
WHILE IsSorted(a,size)=0
DO
KnuthShuffle(a,size)
OD
RETURN
PROC Test(INT ARRAY a INT size)
PrintE("Array before sort:")
PrintArray(a,size)
BogoSort(a,size)
PrintE("Array after sort:")
PrintArray(a,size)
PutE()
RETURN
PROC Main()
INT ARRAY
a(10)=[1 4 65535 0 7 4 20 65530],
b(21)=[3 2 1 0 65535 65534 65533],
c(8)=[101 102 103 104 105 106 107 108],
d(12)=[1 65535 1 65535 1 65535 1
65535 1 65535 1 65535]
Test(a,8)
Test(b,7)
Test(c,8)
Test(d,12)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Bogosort.png Screenshot from Atari 8-bit computer]
<pre>
Array before sort:
[1 4 -1 0 7 4 20 -6]
Array after sort:
[-6 -1 0 1 4 4 7 20]
Array before sort:
[3 2 1 0 -1 -2 -3]
Array after sort:
[-3 -2 -1 0 1 2 3]
Array before sort:
[101 102 103 104 105 106 107 108]
Array after sort:
[101 102 103 104 105 106 107 108]
Array before sort:
[1 -1 1 -1 1 -1 1 -1 1 -1 1 -1]
Array after sort:
[-1 -1 -1 -1 -1 -1 1 1 1 1 1 1]
</pre>
=={{header|ActionScript}}==
<
{
while (!sorted(arr))
Line 256 ⟶ 351:
return true;
}</
=={{header|Ada}}==
<
with Ada.Numerics.Discrete_Random;
Line 308 ⟶ 403:
Put (Integer'Image (Sequence (I)));
end loop;
end Test_Bogosort;</
The solution is generic.
The procedure Bogosort can be instantiated
Line 327 ⟶ 422:
{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}
<
PROC random shuffle = (REF[]TYPE l)VOID: (
Line 363 ⟶ 458:
[6]TYPE sample := (61, 52, 63, 94, 46, 18);
print((bogo sort(sample), new line))</
{{out}}
+18 +46 +52 +61 +63 +94
Line 369 ⟶ 464:
=={{header|ARM Assembly}}==
{{works with|as|Raspberry Pi}}
<syntaxhighlight lang="arm assembly">
/* ARM assembly Raspberry PI */
Line 619 ⟶ 714:
bx lr
</syntaxhighlight>
=={{header|Arturo}}==
<syntaxhighlight lang="rebol">bogoSort: function [items][
a: new items
while [not? sorted? a]-> shuffle 'a
return a
]
print bogoSort [3 1 2 8 5 7 9 4 6]</syntaxhighlight>
{{out}}
<pre>1 2 3 4 5 6 7 8 9</pre>
=={{header|AutoHotkey}}==
<
MsgBox % Bogosort("319208")
MsgBox % Bogosort("fedcba")
Line 655 ⟶ 764:
}
Return Found
}</
=={{header|AWK}}==
Sort standard input and output to the standard output
<
{
return int(n * rand())
Line 688 ⟶ 797:
print line[i]
}
}</
=={{header|BASIC256}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="vb">global array
dim array = {10, 1, 2, -6, 3}
lb = array[?,]-1 : ub = array[?]-1
print "unsort ";
for i = lb to ub
print rjust(array[i], 4);
next i
call Bogosort(array) # ordenar el array
print chr(10); " sort ";
for i = lb to ub
print rjust(array[i], 4);
next i
end
subroutine shuffle(array)
n = array[?] : m = array[?]*2
for k = 1 to m
i = int(Rand*n)
j = int(Rand*n)
tmp = array[i] #swap lb(i), lb(j)
array[i] = array[j]
array[j] = tmp
next k
end subroutine
function inorder(array)
n = array[?]
for i = 0 to n-2
if array[i] > array[i+1] then return false
next i
return true
end function
subroutine Bogosort(array)
while not inorder(array)
call shuffle(array)
end while
end subroutine</syntaxhighlight>
=={{header|BBC BASIC}}==
<
test() = 4, 65, 2, 31, 0, 99, 2, 83, 782, 1
Line 714 ⟶ 868:
IF d(I%) < d(I%-1) THEN = FALSE
NEXT
= TRUE</
{{out}}
<pre>
383150 shuffles required to sort 10 items.
</pre>
=={{header|BQN}}==
Requires the <code>_while_</code> idiom because the recursive version <code>{(𝕊𝕩⊏˜•rand.Deal∘≠)⍟(𝕩≢∧𝕩)𝕩}</code> quickly runs out of stack depth.
<syntaxhighlight lang="bqn">_while_←{𝔽⍟𝔾∘𝔽_𝕣_𝔾∘𝔽⍟𝔾𝕩}
Bogo←{𝕩⊏˜•rand.Deal≠𝕩}_while_(≢⟜∧)</syntaxhighlight>
=={{header|Brat}}==
<
sorted = list.sort #Kinda cheating here
while { list != sorted } { list.shuffle! }
Line 727 ⟶ 887:
}
p bogosort [15 6 2 9 1 3 41 19]</
=={{header|C}}==
<
#include <stdlib.h>
#include <stdbool.h>
Line 766 ⟶ 926:
for (i=0; i < 6; i++) printf("%d ", numbers[i]);
printf("\n");
}</
=={{header|C sharp|C#}}==
{{works with|C sharp|C#|3.0+}}
<
using System.Collections.Generic;
Line 817 ⟶ 977:
}
}</
=={{header|C++}}==
Uses C++11. Compile with
g++ -std=c++11 bogo.cpp
<
#include <iostream>
#include <iterator>
Line 850 ⟶ 1,010:
copy(std::begin(a), std::end(a), std::ostream_iterator<int>(std::cout, " "));
std::cout << "\n";
}</
{{out}}
<pre>
Line 858 ⟶ 1,018:
=={{header|Clojure}}==
<
(or (empty? xs)
(apply order xs)))
Line 866 ⟶ 1,026:
(recur order (shuffle xs))))
(println (bogosort < [7 5 12 1 4 2 23 18]))</
=={{header|COBOL}}==
This program generates an array of ten pseudo-random numbers in the range 0 to 999 and then sorts them into ascending order. Eventually.
<
program-id. bogo-sort-program.
data division.
Line 934 ⟶ 1,094:
add 1 to array-index giving adjusted-index.
if item(array-index) is greater than item(adjusted-index)
then move zero to sorted.</
{{out}}
<pre>BEFORE SORT: 141 503 930 105 78 518 180 907 791 361
Line 946 ⟶ 1,106:
<code>nshuffle</code> is the same code as in [[Knuth shuffle#Common Lisp|Knuth shuffle]].
<
(loop for i from (length sequence) downto 2
do (rotatef (elt sequence (random i))
Line 957 ⟶ 1,117:
(defun bogosort (list predicate)
(do ((list list (nshuffle list)))
((sortedp list predicate) list)))</
=={{header|Crystal}}==
<
i = items.size-1
while i > 1
Line 985 ⟶ 1,145:
knuthShuffle(items)
end
end</
=={{header|D}}==
<
void bogoSort(T)(T[] data) {
Line 999 ⟶ 1,159:
bogoSort(array);
writeln(array);
}</
{{out}}
<pre>[1, 2, 3, 5, 6, 7, 8, 11, 41]</pre>
Line 1,009 ⟶ 1,169:
Using the shuffle from [[Knuth shuffle#E]].
<
if (list.size() == 0) { return true }
var a := list[0]
Line 1,024 ⟶ 1,184:
shuffle(list, random)
}
}</
=={{header|EasyLang}}==
<syntaxhighlight>
proc shuffle . l[] .
for i = len l[] downto 2
r = randint i
swap l[i] l[r]
.
.
proc issorted . l[] r .
for i = 2 to len l[]
if l[i] < l[i - 1]
r = 0
return
.
.
r = 1
.
proc bogosort . l[] .
repeat
issorted l[] r
until r = 1
shuffle l[]
.
.
list[] = [ 2 7 41 11 3 1 6 5 8 ]
bogosort list[]
print list[]
</syntaxhighlight>
{{out}}
<pre>
[ 1 2 3 5 6 7 8 11 41 ]
</pre>
=={{header|Eiffel}}==
<syntaxhighlight lang="eiffel">
class
BOGO_SORT
Line 1,094 ⟶ 1,288:
end
</syntaxhighlight>
TEST:
<syntaxhighlight lang="eiffel">
class
APPLICATION
Line 1,129 ⟶ 1,323:
end
</syntaxhighlight>
{{out}}
<pre>
Line 1,138 ⟶ 1,332:
=={{header|Elena}}==
ELENA 5.0 :
<
import system'routines;
Line 1,162 ⟶ 1,356:
console.printLine("before:", list.asEnumerable());
console.printLine("after :", list.bogoSorter().asEnumerable())
}</
{{out}}
<pre>
Line 1,170 ⟶ 1,364:
=={{header|Elixir}}==
<
def bogo_sort(list) do
if sorted?(list) do
Line 1,182 ⟶ 1,376:
defp sorted?([x, y | _]) when x>y, do: false
defp sorted?([_, y | rest]), do: sorted?([y | rest])
end</
Example:
Line 1,191 ⟶ 1,385:
=={{header|Euphoria}}==
<
object temp
integer j
Line 1,222 ⟶ 1,416:
end function
? bogosort(shuffle({1,2,3,4,5,6}))</
{{out}}
Line 1,235 ⟶ 1,429:
=={{header|Factor}}==
<
: sorted? ( seq -- ? ) 2 <clumps> [ first2 <= ] all? ;
: bogosort ( seq -- newseq ) [ dup sorted? ] [ randomize ] until ;</
=={{header|Fantom}}==
<
class Main
{
Line 1,268 ⟶ 1,462:
}
}
</syntaxhighlight>
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<
IMPLICIT NONE
CONTAINS
Line 1,320 ⟶ 1,514:
WRITE (*,*) "Array required", iter, " shuffles to sort"
END PROGRAM BOGOSORT</
=={{header|FreeBASIC}}==
<
dim as ulong n = ubound(a), i, j, k, m = ubound(a)*2
dim as ulong tmp
Line 1,360 ⟶ 1,554:
for i=0 to ubound(a) - 1
print a(i)
next i</
=={{header|Gambas}}==
'''[https://gambas-playground.proko.eu/?gist=b2b766f379d809cbf054c2d32d76c453 Click this link to run this code]'''
<
Dim sSorted As String = "123456789" 'The desired outcome
Dim sTest, sChr As String 'Various strings
Line 1,382 ⟶ 1,576:
Print "Solved in " & Str(iCounter) & " loops" 'Print the result
End</
Output: (This example was completed in under 2 seconds)
<pre>
Line 1,395 ⟶ 1,589:
=={{header|Go}}==
<
import (
Line 1,416 ⟶ 1,610:
}
fmt.Println("sorted! ", temp)
}</
{{out}} (sometimes takes a few seconds)
<pre>
Line 1,425 ⟶ 1,619:
=={{header|Groovy}}==
Solution (also implicitly tracks the number of shuffles required):
<
def n = list.size()
while (n > 1 && (1..<n).any{ list[it-1] > list[it] }) {
Line 1,432 ⟶ 1,626:
}
list
}</
Test Program:
<
{{out}} trial 1:
Line 1,444 ⟶ 1,638:
=={{header|Haskell}}==
<
import Data.Array.IO
import Control.Monad
Line 1,473 ⟶ 1,667:
bogosort :: Ord a => [a] -> IO [a]
bogosort = bogosortBy (<)</
Example:
<pre>
Line 1,481 ⟶ 1,675:
=={{header|Icon}} and {{header|Unicon}}==
<
repeat {
!l :=: ?l
Line 1,497 ⟶ 1,691:
l := [6,3,4,5,1]
|( shuffle(l) & sorted(l)) \1 & every writes(" ",!l)
end</
=={{header|Inform 6}}==
<
for(i = n - 1: i > 0: i--)
{
Line 1,525 ⟶ 1,719:
shuffle(a, n);
}
];</
=={{header|Insitux}}==
{{Trans|Clojure}}
<syntaxhighlight lang="insitux">(function bogo-sort order list
(return-unless (1 list) [])
(if (... order list)
list
(recur order (shuffle list))))
(bogo-sort < [7 5 12 1 4 2 23 18])</syntaxhighlight>
Even with this small list the web REPL sometimes exceeds its default recur budget (1e4 - 10000):
<pre>4:6 (recur order (shuffle list))))
Budget Error: recurred too many times.</pre>
=={{header|Io}}==
<
isSorted := method(
slice(1) foreach(i, x,
Line 1,544 ⟶ 1,755:
lst := list(2, 1, 4, 3)
lst bogoSortInPlace println # ==> list(1, 2, 3, 4), hopefully :)</
=={{header|J}}==
{{eff note|J|/:~}}
<
whilst. +./ 2 >/\ Ry do. Ry=. (A.~ ?@!@#) y end. Ry
)</
=={{header|Java}}==
Without Collections, Lists or Iterators. With a counter.
<
public class BogoSort
Line 1,610 ⟶ 1,821:
}
</syntaxhighlight>
{{out}}
Line 1,620 ⟶ 1,831:
{{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;
Line 1,643 ⟶ 1,854:
Collections.shuffle(list);
}
}</
=={{header|JavaScript}}==
<
for(var j, x, i = v.length; i; j = Math.floor(Math.random() * i), x = v[--i], v[i] = v[j], v[j] = x);
return v;
Line 1,665 ⟶ 1,876:
}
return v;
}</
=={{header|Julia}}==
{{works with|Julia|0.6}}
<
while !issorted(arr)
shuffle!(arr)
Line 1,678 ⟶ 1,889:
v = rand(-10:10, 10)
println("# unordered: $v\n -> ordered: ", bogosort!(v))</
{{out}}
Line 1,686 ⟶ 1,897:
=={{header|Kotlin}}==
{{trans|C}}
<
const val RAND_MAX = 32768 // big enough for this
Line 1,721 ⟶ 1,932:
bogosort(a)
println("After sorting : ${a.contentToString()}")
}</
{{out}}
Line 1,730 ⟶ 1,941:
=={{header|Lua}}==
<
if type (list) ~= 'table' then return list end
Line 1,755 ⟶ 1,966:
return list
end</
=={{header|M4}}==
<
define(`randSeed',141592653)
define(`setRand',
Line 1,797 ⟶ 2,008:
show(`b')
bogosort(`b')
show(`b')</
=={{header|Maple}}==
<
len := numelems(arr):
#Translation of C, random swapping
Line 1,815 ⟶ 2,026:
shuffle_arr(arr, len):
end do:
arr;</
{{Out|Output}}
<pre>[1 2 3]</pre>
=={{header|Mathematica}}/{{header|Wolfram Language}}==
<
Bogosort[{1, 2, 6, 4, 0, -1, Pi, 3, 5}]
=> {-1, 0, 1, 2, 3, Pi, 4, 5, 6}</
=={{header|MATLAB}} / {{header|Octave}}==
<
while( ~issorted(list) ) %Check to see if it is sorted
list = list( randperm(numel(list)) ); %Randomly sort the list
end
end</
{{out}}
<
ans =
1 2 3 4 5 6 7 8 9
</syntaxhighlight>
=={{header|MAXScript}}==
<
(
if arr.count > 0 then
Line 1,877 ⟶ 2,087:
)
arr
)</
=={{header|Modula-3}}==
<
IMPORT IO, Fmt, Random;
Line 1,926 ⟶ 2,136:
END;
IO.Put("\nRequired " & Fmt.Int(count) & " shuffles\n");
END Bogo.</
=={{header|Nanoquery}}==
<
if len(list) = 0
return true
Line 1,949 ⟶ 2,159:
return list
end</
=={{header|Nemerle}}==
<
using System.Console;
using Nemerle.Imperative;
Line 1,990 ⟶ 2,200:
foreach (i in sortme) Write($"$i ");
}
}</
=={{header|NetRexx}}==
{{trans|Java}}
<
options replace format comments java crossref savelog symbols nobinary
Line 2,040 ⟶ 2,250:
method isFalse public static returns boolean
return \isTrue
</syntaxhighlight>
{{out}}
<pre>
Line 2,048 ⟶ 2,258:
=={{header|Nim}}==
<
randomize()
Line 2,065 ⟶ 2,275:
var a = @[4, 65, 2, -31, 0, 99, 2, 83, 782]
bogoSort a
echo a</
{{out}}
<pre>@[-31, 0, 2, 2, 4, 65, 83, 99, 782]</pre>
Line 2,071 ⟶ 2,281:
=={{header|Oberon-2}}==
{{Works with|Oxford Oberon-2 Compiler}}
<
IMPORT Out, Random;
Line 2,121 ⟶ 2,331:
END;
Out.Ln;
END Bogo.</
Init initializes the array as 1 thru 10, then it is shuffled, and then the while loop continually shuffles until Sorted returns true.
=={{header|OCaml}}==
<
| e1 :: e2 :: r -> comp e1 e2 <= 0 && is_sorted comp (e2 :: r)
| _ -> true
Line 2,145 ⟶ 2,355:
li
else
bogosort (shuffle li)</
Example:
<pre>
Line 2,155 ⟶ 2,365:
We use an array because that made most sense for the Knuth Shuffle task. Usually you would use lists for stuff like this in Oz.
<
proc {BogoSort Arr}
for while:{Not {InOrder Arr}} do
Line 2,186 ⟶ 2,396:
in
{BogoSort X}
{Show {Array.toRecord unit X}}</
=={{header|PARI/GP}}==
This implementation sorts 9 distinct elements in only 600 milliseconds.
<
while(1,
my(u=vecextract(v,numtoperm(#v,random((#v)!))));
Line 2,196 ⟶ 2,406:
return(u)
);
};</
=={{header|Pascal}}==
<
const
Line 2,264 ⟶ 2,474:
a[i] := (max + 1) - i;
bogo(a);
end.</
{{out}}
Line 2,274 ⟶ 2,484:
=={{header|Perl}}==
<
sub bogosort
Line 2,286 ⟶ 2,496:
{$_ >= $last or return 0;
$last = $_;}
return 1;}</
=={{header|Phix}}==
<!--<
<span style="color: #008080;">with</span> <span style="color: #008080;">javascript_semantics</span>
Line 2,305 ⟶ 2,515:
<span style="color: #0000FF;">?</span> <span style="color: #000000;">bogosort</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">shuffle</span><span style="color: #0000FF;">({</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #000000;">2</span><span style="color: #0000FF;">,</span><span style="color: #000000;">3</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">}))</span>
<!--</
{{out}}
<pre>
Line 2,316 ⟶ 2,526:
=={{header|PHP}}==
<
while (!in_order($l))
shuffle($l);
Line 2,327 ⟶ 2,537:
return FALSE;
return TRUE;
}</
=={{header|PicoLisp}}==
<
(loop
(map
'((L) (rot L (rand 1 (length L))))
Lst )
(T (apply <= Lst) Lst) ) )</
{{out}}
<pre>: (bogosort (make (do 9 (link (rand 1 999)))))
Line 2,348 ⟶ 2,558:
=={{header|PL/I}}==
{{trans|REXX}}
<
bogosort: Proc Options(main);
Dcl SYSPRINT Print;
Line 2,401 ⟶ 2,611:
Return(res);
End;
End;</
{{out}}
<pre>un-bogoed
Line 2,419 ⟶ 2,629:
=={{header|PowerShell}}==
Shuffle taken from [[Knuth Shuffle]]
<
$c = $a.Clone() # make copy to avoid clobbering $a
1..($c.Length - 1) | ForEach-Object {
Line 2,447 ⟶ 2,657:
}
$l = 7; BogoSort ( 1..$l | ForEach-Object { $Rand = New-Object Random }{ $Rand.Next( 0, $l - 1 ) } )</
=={{header|Prolog}}==
<
min_list(L,Min),
repeat,
Line 2,460 ⟶ 2,670:
is_sorted([N|T],P) :-
N >= P,
is_sorted(T,N).</
{{out}}
<pre>
Line 2,468 ⟶ 2,678:
=={{header|PureBasic}}==
<
Protected i, Size = ArraySize(a())
For i = 0 To Size
Line 2,500 ⟶ 2,710:
Next
BogoSort(b())</
{{out}}
<pre>Array of 10 integers required 2766901 shuffles To SORT.</pre>
=={{header|Python}}==
<
def bogosort(l):
Line 2,520 ⟶ 2,730:
return False
last = x
return True</
Alternative definition for ''in_order'' (Python 2.5)
<
return all( l[i] <= l[i+1] for i in xrange(0,len(l)-1))</
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)
return lst</
Another alternative implementation, using iterators for maximum efficiency:
<
import random
from itertools import dropwhile, imap, islice, izip, repeat, starmap
Line 2,547 ⟶ 2,757:
bogosort = lambda l: next(dropwhile(
lambda l: not all(starmap(operator.le, izip(l, islice(l, 1, None)))),
imap(shuffled, repeat(l))))</
=={{header|Qi}}==
<syntaxhighlight lang="qi">
(define remove-element
0 [_ | R] -> R
Line 2,574 ⟶ 2,784:
Suggestion -> Suggestion where (in-order? Suggestion)
Suggestion -> (bogosort (shuffle Suggestion)))
</syntaxhighlight>
=={{header|Quackery}}==
<
dup [] != if
[ behead swap witheach
Line 2,585 ⟶ 2,795:
drop ] is inorder ( [ --> b )
[ dup inorder not while shuffle again ] is bogosort ( [ --> [ )</
=={{header|R}}==
<
while(is.unsorted(x)) x <- sample(x)
x
Line 2,594 ⟶ 2,804:
n <- c(1, 10, 9, 7, 3, 0)
bogosort(n)</
=={{header|Racket}}==
Line 2,601 ⟶ 2,811:
is unit tests and an example.
<
#lang racket
(define (bogo-sort l) (if (apply <= l) l (bogo-sort (shuffle l))))
Line 2,612 ⟶ 2,822:
(displayln unsorted)
(displayln (bogo-sort unsorted)))
</syntaxhighlight>
{{out}} (chances are you won't get quite this!):
Line 2,622 ⟶ 2,832:
=={{header|Raku}}==
(formerly Perl 6)
<syntaxhighlight lang="raku"
@list .= pick(*) until [<=] @list;
return @list;
Line 2,629 ⟶ 2,839:
my @nums = (^5).map: { rand };
say @nums.sort.Str eq @nums.&bogosort.Str ?? 'ok' !! 'not ok';
</syntaxhighlight>
=={{header|REXX}}==
===true bogo sort===
<
parse arg list /*obtain optional list from C.L. */
if list='' then list=-21 333 0 444.4 /*Not defined? Then use default.*/
Line 2,663 ⟶ 2,873:
end /*t*/
say
return</
{{out}} using the default input:
<pre>
Line 2,686 ⟶ 2,896:
<br>has already been sorted and including the number out-of-order. The search then starts over.
<br>This is repeated as often as it takes to finally get the array in order.
<
@.1 = 0 ; @.11= -64 ; @.21= 4096 ; @.31= 6291456
@.2 = 0 ; @.12= 64 ; @.22= 40960 ; @.32= 5242880
Line 2,727 ⟶ 2,937:
end /*t*/
say
return</
{{out}}
<pre style="height:30ex">
Line 2,838 ⟶ 3,048:
=={{header|Ring}}==
<
# Project : Sorting algorithms/Bogosort
Line 2,879 ⟶ 3,089:
see svect
see "]" + nl
</syntaxhighlight>
Output:
<pre>
Line 2,885 ⟶ 3,095:
[0, 1, 2, 2, 4, 31, 65, 83, 99, 782]
</pre>
=={{header|RPL}}==
<code>KNUTH</code> is defined at [[Knuth shuffle#RPL|Knuth shuffle]]
{{works with|HP|48G}}
≪ '''WHILE''' DUP ΔLIST ≪ MIN ≫ STREAM 0 < '''REPEAT'''
<span style="color:blue">KNUTH</span>
'''END'''
≫ '<span style="color:blue">BOGOSORT</span>' STO
=={{header|Ruby}}==
<
l.sort_by { rand }
end
Line 2,898 ⟶ 3,116:
def in_order(l)
(0..l.length-2).all? {|i| l[i] <= l[i+1] }
end</
An alternative implementation:
<
l.sort_by { rand }
end
Line 2,909 ⟶ 3,127:
l = shuffle(l) until l == l.sort
l
end</
{{works with|Ruby|1.8.7+}}
<
(0..l.length-2).all? {|i| l[i] <= l[i+1] }
end
Line 2,920 ⟶ 3,138:
l.shuffle! until in_order(l)
l
end</
=={{header|Rust}}==
Works with Rust 1.11+, requires rand module
{{libheader|rand}}
<
use rand::Rng;
Line 2,952 ⟶ 3,170:
println!("{:?}", testlist);
}
</syntaxhighlight>
=={{header|Scala}}==
{{works with|Scala|2.8}}
<
def bogosort(l: List[Int]): List[Int] = if (isSorted(l)) l else bogosort(scala.util.Random.shuffle(l))</
=={{header|Sidef}}==
<
return true if (a.len <= 1)
var first = a[0]
a.
}
func bogosort(a) {
a.shuffle! while
return a
}
var arr = 5.of { 100.
say "Before: #{arr}"
say "After: #{bogosort(arr)}"
{{out}}
<pre>
Line 2,982 ⟶ 3,200:
=={{header|Scheme}}==
Uses [[Knuth shuffle]] to shuffle the list.
<
(srfi :27 random-bits))
Line 3,015 ⟶ 3,233:
(display "Output: ")
(display (bogosort input))
(newline))</
{{out}}
<pre>Input: (5 4 3 2 1)
Line 3,024 ⟶ 3,242:
This implementation uses closures rather than extending collections to provide a bogosort method.
<
|isit|
isit := false.
Line 3,047 ⟶ 3,265:
tobesorted := { 2 . 7 . 5 . 3 . 4 . 8 . 6 . 1 }.
bogosort value: tobesorted.
tobesorted displayNl.</
=={{header|SNOBOL4}}==
<
-include 'Random.sno'
Line 3,091 ⟶ 3,309:
* # Test and display
bogo(s2a('5 4 3 2 1',5))
end</
{{out}}
Line 3,101 ⟶ 3,319:
=={{header|Swift}}==
<
func shuffle<T>(inout array: [T]) {
Line 3,123 ⟶ 3,341:
shuffle(&ary)
}
}</
=={{header|Tcl}}==
<
proc shuffleInPlace {listName} {
Line 3,155 ⟶ 3,373:
}
return $list
}</
=={{header|TI-83 BASIC}}==
Line 3,206 ⟶ 3,424:
=={{header|Ursala}}==
<
#import nat
Line 3,215 ⟶ 3,433:
#cast %nL
example = bogosort <8,50,0,12,47,51></
{{out}}
<pre><0,8,12,47,50,51></pre>
=={{header|VBA}}==
{{trans|Phix}}<
Dim t As Variant, i As Integer
If Not IsMissing(a) Then
Line 3,255 ⟶ 3,473:
Public Sub main()
Debug.Print Join(bogosort(Knuth([{1,2,3,4,5,6}])), ", ")
End Sub</
<pre>...
1, 3, 2, 5, 6, 4
Line 3,265 ⟶ 3,483:
=={{header|VBScript}}==
=====Implementation=====
<
dim tmp
tmp = a
Line 3,294 ⟶ 3,512:
next
inOrder = res
end function</
=====Invocation=====
<
a = array(11, 1, 2, 3, 4, 4, 6, 7, 8)
Line 3,306 ⟶ 3,524:
wend
wscript.echo timer-t, "seconds"
wscript.echo join( a, ", " )</
=====A few outputs (timed)=====
Line 3,320 ⟶ 3,538:
</pre>
=={{header|V (Vlang)}}==
Updated for V (Vlang) version 0.2.2
<syntaxhighlight lang="go">import rand
fn
arr[i], arr[j] = arr[j], arr[i]
}
}
fn is_sorted(arr []int) bool {
}
}
}
fn
for !is_sorted(arr) {
shuffle_array(mut arr)
}
}
fn main() {
mut array := [6, 9, 1, 4]
println('Input: $array')
sort_array(mut array)
println('Output: $array')
}</syntaxhighlight>
{{out}}
<pre>Input: [6, 9, 1, 4]
After Shuffle: [
After Shuffle: [4
After Shuffle: [1, 9, 4, 6]
After Shuffle: [9, 1, 4, 6]
After Shuffle: [9, 6, 1, 4]
After Shuffle: [1, 4, 6, 9]
Output: [1, 4, 6, 9]</pre>
Line 3,363 ⟶ 3,583:
=={{header|Wren}}==
{{libheader|Wren-sort}}
<
import "./sort" for Sort
var bogoSort = Fn.new { |a|
Line 3,374 ⟶ 3,594:
System.print("Before: %(a)")
bogoSort.call(a)
System.print("After : %(a)")</
{{out}}
Line 3,383 ⟶ 3,603:
=={{header|XPL0}}==
<
proc BogoSort(A, L); \Sort array A of length L
Line 3,402 ⟶ 3,622:
BogoSort(A, 10);
for I:= 0 to 10-1 do [IntOut(0, A(I)); ChOut(0, ^ )];
]</
{{out}}
Line 3,408 ⟶ 3,628:
-5 1 1 2 3 4 4 5 6 9
</pre>
=={{header|Yabasic}}==
{{trans|FreeBASIC}}
<syntaxhighlight lang="yabasic">dim a(5)
a (0) = 10: a (1) = 1: a (2) = 2: a (3) = -6: a (4) = 3
Bogosort(a())
for i = 0 to arraysize(a(),1) - 1
print a(i), " ";
next i
end
sub shuffle(a())
n = arraysize(a(),1)
m = arraysize(a(),1)*2
for k = 1 to m
i = int(Ran(n))
j = int(Ran(n))
tmp = a(i) //swap a(i), a(j)
a(i) = a(j)
a(j) = tmp
next k
end sub
sub inorder(a())
n = arraysize(a(),1)
for i = 0 to n-2
if a(i) > a(i+1) return false
next i
return true
end sub
sub Bogosort(a())
while not inorder(a())
shuffle(a())
wend
end sub</syntaxhighlight>
=={{header|zkl}}==
<
list.len()<2 or
list.reduce(fcn(a,b){ if(b<a) return(Void.Stop,False); b }).toBool()
Line 3,417 ⟶ 3,678:
ns:=L(5,23,1,6,123,7,23);
while(not increasing(ns)){ ns=ns.shuffle() }
ns.println();</
{{out}}
<pre>L(1,5,6,7,23,23,123)</pre>
|