JortSort: Difference between revisions

{{Sorting Algorithm}}

[[Category:Sorting]]

 

{{noticebox||Note:   jortSort is considered a work of satire.   It achieves its result in an intentionally roundabout way.   You are encouraged to write your solutions in the spirit of the original jortsort rather than trying to give the most concise or idiomatic solution.}}

{{trans|Python}}

 

R Array(sequence) == sorted(sequence)

 

print_for_seq([‘a’, ‘c’])

print_for_seq(‘CVGH’)

 

{{out}}

=={{header|AArch64 Assembly}}==

{{works with|as|Raspberry Pi 3B version Buster 64 bits}}

/* ARM assembly AARCH64 Raspberry PI 3B */

/* program jortSort64.s */

/* for this file see task include a file in language AArch64 assembly */

.include "../includeARM64.inc"

 

=={{header|Ada}}==

 

 

procedure Jortsort is

Put_Line("""abbigail"" sorted: " & Boolean'Image(Jort_Sort("abbigail")));

Put_Line("""abbey"" sorted: " & Boolean'Image(Jort_Sort("abbey")));

 

{{out}}

 

=={{header|AppleScript}}==

use framework "Foundation"

use scripting additions

((current application's NSArray's arrayWithArray:xs)'s ¬

sortedArrayUsingSelector:"compare:") as list

{{Out}}

<pre>{false, true}</pre>

=={{header|Arturo}}==

 

a = sort a

 

 

test ["a" "b" "c"]

 

{{out}}

 

=={{header|AutoHotkey}}==

sorted:=[]

for index, val in Array

return 0

return 1

Array2 := ["a", "b", "c" , "d"]

MsgBox % JortSort(Array1) "`n" JortSort(Array2)

Outputs:<pre>0

1</pre>

 

=={{header|C}}==

As others did in this page, this example doesn't follow the request to sort the input array and then compare the sorted version to the original one to check if it was already sorted. It only checks if the input is sorted and behaves accordingly.

I've tested this code only with gcc but should work with any C compiler.

#include <stdio.h>

#include <stdlib.h>

 

}

 

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

{{trans|JavaScript}}

 

class Program

return true;

}

 

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

#include <algorithm>

#include <string>

return 0;

}

{{out}}

<pre>

 

=={{header|Clojure}}==

 

=={{header|Common Lisp}}==

(defun jort-sort (x)

(equalp x (sort (copy-seq x) #'<)))

 

=={{header|Crystal}}==

array == array.sort

 

=={{header|D}}==

module jortsort;

 

assert(!jortSort(["two", "one", "three"]));

}

 

=={{header|Delphi}}==

{{Trans|JavaScript}}

program JortSort;

 

Readln;

end.

 

 

=={{header|Elixir}}==

#Function<6.90072148/1 in :erl_eval.expr/5>

iex(2)> jortsort.([1,2,3,4])

true

iex(3)> jortsort.([1,2,5,4])

 

=={{header|F_Sharp|F#}}==

let jortSort n=n=Array.sort n

printfn "%A %A" (jortSort [|1;23;42|]) (jortSort [|23;42;1|])

{{out}}

<pre>

</pre>

=={{header|Factor}}==

 

=={{header|FreeBASIC}}==

 

' Although it's possible to create generic sorting routines using macros in FreeBASIC

Print

Print "Press any key to quit"

 

{{out}}

 

=={{header|Go}}==

package main

 

}

 

 

=={{header|Haskell}}==

For lists:

 

jortSort :: (Ord a) => [a] -> Bool

 

or in applicative terms:

 

 

jortSort

--------------------------- TEST ---------------------------

main :: IO ()

{{Out}}

<pre>[False,True]</pre>

 

'''Solution'''

 

More in line with the spirit of the task would be:

 

 

Of course, ideally, assert would be replaced with something more assertive. Perhaps deleting all storage? But even better would be to send email to your boss and leadership explaining (at great length) exactly why they are all idiots. Do enough of this and you will never have to sort again...

 

'''Example Usage'''

0

1

 

=={{header|Janet}}==

(deep= xs (sorted xs)))

 

(print (jortsort @[1 2 3 4 5])) # true

 

=={{header|Java}}==

Optimized version of JortSort. Even less funny. Doesn't bother with sorting, but simply returns ''true''. Very fast. Use only when you're ''absolutely sure'' that the input is already sorted. You may have to use an unoptimized version of JortSort to ascertain this.

public static void main(String[] args) {

System.out.println(jortSort(new int[]{1, 2, 3}));

return true;

}

 

<pre>true</pre>

 

The original JavaScript implementation courtesy of the author, [https://github.com/jennschiffer/jortsort Jenn "Moneydollars" Schiffer].

 

// sort the array

 

return true;

 

=={{header|jq}}==

'''Example''':

{{Out}}

 

=={{header|Jsish}}==

Based on the Javascript satire.

var jortSort = function(arr:array):boolean {

// make a copy

jortSort(['snort', 'sort', 1, [1,2], {1:2}]) ==> false

=!EXPECTEND!=

 

{{out}}

 

=={{header|Julia}}==

jortsort(A) = sort(A) == A

 

{{out}}

 

=={{header|K}}==

'''Example''':

<pre>1

</pre>

 

=={{header|Kotlin}}==

 

fun <T> jortSort(a: Array<T>): Boolean {

val d = arrayOf('C', 'D', 'A', 'E', 'B')

printResults(d)

 

{{out}}

 

=={{header|Lua}}==

local new = {}

for k, v in pairs(t) do new[k] = v end

end

return true

 

=={{header|Maple}}==

local copy:

copy := sort(Array([seq(arr[i], i=1..numelems(arr))])):

jortSort(Array([5,6,7,2,1]));

jortSort(Array([-5,0,7,12,21]));

{{Out|Output}}

<pre>false

true</pre>

 

Print[jortSort[Range[100]]];

{{out}}

<pre>True

 

=={{header|Nim}}==

 

func jortSort[T](a: openArray[T]): bool =

echo ""

test(['a', 'b', 'c'])

 

{{out}}

 

=={{header|Objeck}}==

sorted := CompareVector->New(elems);

sorted->Sort();

 

return true;

 

=={{header|OCaml}}==

For lists:

For arrays:

let originalArray = Array.copy ary in

Array.sort compare ary;

 

=={{header|Oforth}}==

 

 

{{out}}

=={{header|ooRexx}}==

{{trans|REXX}}

/*---------------------------------------------------------------------

* Determine if list is sorted

End

Return (i=words(list)+1)|(list='')

 

=={{header|PARI/GP}}==

 

=={{header|Perl}}==

my @s=sort @_; # Default standard string comparison

for (0..$#s) {

}

1;

The task wants us to sort, but we could implement this by just using <tt>cmp</tt> on the input array elements, which would be faster (especially with unsorted input).

 

=={{header|Phix}}==

Then any variable or constant delared as type JortSort raises an error if used incorrectly, eg

{{out}}

<pre>

C:\Program Files (x86)\Phix\test.exw:2

</pre>

Amusingly the compiler itself uses a variant of jortsort, in that pttree.e declares a whole bunch of ternary tree node constants for all the language keywords and builtins such as

and if you change that to 338 and try to recompile the compiler, you'll immediately get:

<pre>

while should be 336(not 338)

</pre>

 

=={{header|PicoLisp}}==

(de jortSort (L) (= L (sort L)))

(jortSort (1 2 3))

{{out}}

T

 

=={{header|PowerShell}}==

function jortsort($a) { -not (Compare-Object $a ($a | sort) -SyncWindow 0)}

jortsort @(1,2,3)

jortsort @(2,3,1)

<b>Output:</b>

<pre>

 

=={{header|PureBasic}}==

If OpenConsole()

Print("[ ") : ForEach liste : Print(liste+Space(1)) : Next : Print("] = ")

For i=1 To 10 : AddElement(l1()) : l1()=Chr(Random(90,65)) : Next

isSort(l1()) : SortList(l1(),#PB_Sort_Ascending) : isSort(l1())

{{out}}

<pre>[ A Z Q G B N E B G Y ] = False

 

=={{header|Python}}==

return list(sequence) == sorted(sequence)

>>> for data in [(1,2,4,3), (14,6,8), ['a', 'c'], ['s', 'u', 'x'], 'CVGH', 'PQRST']:

jortsort('CVGH') is False

jortsort('PQRST') is True

 

=={{header|Racket}}==

(define (jort-sort l [<? <])

 

Racket's <tt>sort</tt> function is efficient in that it starts by

checking the input, so the above could be made more efficient with a

pointer equality test:

(define (jort-sort l [<? <])

 

And an explicit implementation that checks the order (note that Racket's

<tt>sort</tt> expects a “smaller-than” comparator):

(define (jort-sort l [<? <])

(or (null? l)

(for/and ([x (in-list l)] [y (in-list (cdr l))])

 

=={{header|Raku}}==

(formerly Perl 6)

Actually, there's a better internal sort that seems to work best for lists that are already completely sorted, but tends to fails for any other list. The name of this sort, <tt>[!after]</tt>, is completely opaque, so we're pretty much forced to hide it inside a subroutine to prevent widespread panic.

However, since Perl 6 has a really good inliner, there's really little point anyway in using the <tt>[!after]</tt> reduction operator directly, and <tt>jort-sort-more-better-sorta</tt> is really much more self-documenting, so please don't use the reduction operator if you can. For example:

{{out}}

The array elements (items) may be any form of number that REXX supports, and/or they can be alphabetic characters.

===using sort===

parse arg $ /*obtain the list of numbers from C.L. */

if $='' then $=1 2 4 3 /*Not specified? Then use the default.*/

if !.k\==@.k then return 0 /*the array isn't sorted. */

end /*k*/

'''output''' &nbsp; when using the default input: &nbsp; <tt> 1 &nbsp; 2 &nbsp; 4 &nbsp;3 </tt>

<pre>

 

Nothing is mentioned how it does this, and it certainly doesn't say that it sorts the input to verify if it's in order.

parse arg $ /*obtain the list of numbers from C.L. */

if $='' then $=1 2 4 3 /*Not specified? Then use the default.*/

p=_

end /*j*/

'''output''' &nbsp; is the same as the 1^st REXX version. <br><br>

 

=={{header|Ring}}==

aList = [4,2,3,1]

see jortSort(aList) + nl

next

return true

 

=={{header|Ruby}}==

array == array.sort

 

{{trans|JavaScript}}

# sort the array

original_array = array.dup

true

 

=={{header|Rust}}==

{{trans|JavaScript}}

 

fn jort_sort<T: Ord + Eq + Clone>(array: Vec<T>) -> bool {

 

return true;

 

 

'''Using iterators:'''

fn jort_sort<T>(slice: &[T]) -> bool

where

.zip(sorted.iter())

.all(|(orig, sorted)| orig == sorted)

 

 

'''Idiomatic:'''

fn jort_sort<T>(slice: &[T]) -> bool

where

 

slice == sorted

 

=={{header|Scala}}==

 

=={{header|Sidef}}==

 

=={{header|SSEM}}==

 

There are a couple of limitations that make the program less useful than it would otherwise be. Firstly, it is essentially a single-shot application: if you want to test a second array, you will need to manually reset storage address 0 to 16411 and storage address 26 to 0. Secondly, the SSEM's modest storage capacity means that the largest array you can sort (or not sort) using this program consists of (the terminating zero, and) four integers. Subject to those provisos, however, the program should be found to meet the specification satisfactorily.

00000000000000110000000000000000 1. Test

11101000000000000000000000000000 2. 23 to CI

11111111111111111111111111111111 22. -1

00001000000000000000000000000000 23. 16

 

=={{header|Swift}}==

return array == sorted(array)

 

{{trans|JavaScript}}

// sort the array

return true

 

=={{header|Tcl}}==

 

proc jortsort {args} {

set list [lindex $args end]

expr {[lsort {*}$options $list] eq $list}

}

This supports all of the options known to the native '''lsort''' command, making it quite natural to use. The commented line ensures it will do the right thing for any list, even if it has funny formatting because it's embedded in source:

<pre>

{{works with|Bourne Again SHell}}

 

JortSort() {

cmp -s <(printf “%s\n” “$@“) <(printf “%s\n” “$@“ | sort)

JortSortVerbose a b c

JortSortVerbose c a b

{{Out}}

<pre>True

 

=={{header|VBScript}}==

JortSort = True

arrPreSort = Split(s,",")

WScript.StdOut.Write JortSort("a,b,c")

WScript.StdOut.WriteLine

{{out}}

<pre>True

True

False</pre>

 

=={{header|Wren}}==

{{libheader|Wren-sort}}

 

var jortSort = Fn.new { |a|

 

var tests = [ [1, 2, 3, 4, 5], [2, 1, 3, 4, 5] ]

 

{{out}}

<pre>

=={{header|zkl}}==

Two "solutions", a linear one and one that actually sorts.

{{out}}

<pre>