Sorting algorithms/Bogosort: Difference between revisions

Content added Content deleted
m (→‎{{header|J}}: Add lang tags)
m (Fixed lang tags.)
Line 117:
{{works with|ELLA ALGOL 68|Any (with appropriate job cards) - tested with release 1.8.8d.fc9.i386}}
 
<lang algolalgol68>MODE TYPE = INT;
 
PROC random shuffle = (REF[]TYPE l)VOID: (
Line 347:
We use seq-utils' shuffle, which initializes a Java ArrayList with the input sequence, shuffle it, and then return a sequence of the result.
 
<lang lisp>(use 'clojure.contrib.seq-utils)▼
<lang clojure>
▲(use 'clojure.contrib.seq-utils)
 
(defn in-order? [cmp xs]
Line 358 ⟶ 357:
(defn bogosort [cmp xs]
(if (in-order? cmp xs) xs
(recur cmp (shuffle xs))))</lang>
</lang>▼
 
=={{header|Common Lisp}}==
Line 436 ⟶ 434:
=={{header|Fortran}}==
{{works with|Fortran|90 and later}}
<lang fortran> MODULE BOGO
IMPLICIT NONE
CONTAINS
FUNCTION Sorted(a)
LOGICAL :: Sorted
INTEGER, INTENT(IN) :: a(:)
INTEGER :: i
 
Sorted = .TRUE. ▼
DO i = 1, SIZE(a), 1, -1▼
IF(a(randi) => a(i+1)) THEN▼
Sorted = .FALSE.▼
IF (s) EXIT▼
END DOIF▼
END DO▼
END FUNCTION Sorted▼
 
SUBROUTINE SHUFFLE(a)▼
INTEGER, INTENT(IN OUT) :: a(:)▼
INTEGER :: i, rand, temp▼
REAL :: x▼
 
DO i = SIZE(a), 1, -1
CALL RANDOM_NUMBER(x)▼
rand = INT(x * i) + 1▼
temp = a(rand)▼
a(irand) = tempa(i)▼
a(i) = temp
END DO▼
END SUBROUTINE▼
END MODULE▼
 
PROGRAM BOGOSORT▼
 
USE BOGO▼
IMPLICIT NONE▼
INTEGER :: iter = 0▼
INTEGER :: array(8) = (/2, 7, 5, 3, 4, 8, 6, 1/)▼
LOGICAL :: s▼
DO▼
▲ Sorted = .TRUE.
DO is = 1, SIZESorted(aarray)-1
IF(a(i) > a(i+1)s) THENEXIT
CALL SHUFFLE(array)▼
▲ Sorted = .FALSE.
iter = iter + EXIT1
END IFDO
WRITE (*,*) "Array required", iter, " shuffles to sort"▼
▲ END DO
▲ END FUNCTION Sorted
END PROGRAM BOGOSORT</lang>▼
▲ SUBROUTINE SHUFFLE(a)
▲ INTEGER, INTENT(IN OUT) :: a(:)
▲ INTEGER :: i, rand, temp
▲ REAL :: x
▲ DO i = SIZE(a), 1, -1
▲ CALL RANDOM_NUMBER(x)
▲ rand = INT(x * i) + 1
▲ temp = a(rand)
▲ a(rand) = a(i)
▲ a(i) = temp
▲ END DO
▲ END SUBROUTINE
▲ END MODULE
▲ PROGRAM BOGOSORT
▲ USE BOGO
▲ IMPLICIT NONE
▲ INTEGER :: iter = 0
▲ INTEGER :: array(8) = (/2, 7, 5, 3, 4, 8, 6, 1/)
▲ LOGICAL :: s
▲ DO
s = Sorted(array)
▲ IF (s) EXIT
▲ CALL SHUFFLE(array)
iter = iter + 1
▲ END DO
▲ WRITE (*,*) "Array required", iter, " shuffles to sort"
▲ END PROGRAM BOGOSORT</lang>
 
=={{header|Groovy}}==
Line 543 ⟶ 541:
=={{header|Icon}}==
 
<lang icon>procedure shuffle(l)
repeat {
!l :=: ?l
suspend l
}
end
 
procedure sorted(l)
local i
if (i := 2 to *l & l[i] >= l[i-1]) then return &fail else return 1
end
 
procedure main()
local l
l := [6,3,4,5,1]
|( shuffle(l) & sorted(l)) \1 & every writes(" ",!l)
end</lang>
 
=={{header|J}}==
<lang j>bogo=: monad define
whilst. -. *./ 2 </\ Ry do. Ry=. (A.~ ?@!@#) y end. Ry
▲)</lang>
)
</lang>
 
=={{header|Java}}==
Line 616 ⟶ 613:
}
return v;
} </lang>
 
=={{header|Lua}}==
Line 647 ⟶ 644:
 
=={{header|M4}}==
<lang M4>divert(-1)
divert(-1)
define(`randSeed',141592653)
define(`setRand',
Line 687 ⟶ 683:
show(`b')
bogosort(`b')
show(`b')</lang>
</lang>
 
=={{header|MAXScript}}==
<prelang maxscript>fn notSorted arr =
(
if arr.count > 0 then
Line 726 ⟶ 721:
)
arr
)</prelang>
 
=={{header|Modula-3}}==
Line 957 ⟶ 952:
 
=={{header|R}}==
<lang R>bogosort <- function(x)
bogosort <- function(x)
{
is.sorted <- function(x) all(diff(x) >= 0)
Line 1,056 ⟶ 1,050:
=={{header|Ursala}}==
 
<lang Ursala>#import std
#import std
#import nat
 
Retrieved from "https://rosettacode.org/wiki/Sorting_algorithms/Bogosort"