JortSort: Difference between revisions

{{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|Action!}}==

INT i

 

Test(d,1)

Test(d,0)

{{out}}

[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/JortSort.png Screenshot from Atari 8-bit computer]

=={{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>

BQN has a really simple way to represent JortSort:

 

JSort 3‿2‿1

Which means "Does the array match itself sorted?"

 

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

jortsort 'sux'

1

jortsort&> 1 2 4 3;14 6 8;1 3 8 19;'ac';'sux';'CVGH';'PQRST'

 

Using jortSort in place of jortsort would throw an error on all but the first of those examples. It would return an empty result for that first example. (We have no way of representing the consequences of the more inane proposals presented here.)

 

=={{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

 

=={{header|Mathematica}}/{{header|Wolfram Language}}==

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}}==

<span style="color: #008080;">type</span> <span style="color: #000000;">JortSort</span><span style="color: #0000FF;">(</span><span style="color: #004080;">sequence</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">return</span> <span style="color: #000000;">s</span><span style="color: #0000FF;">=</span><span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">s</span><span style="color: #0000FF;">)</span>

<span style="color: #008080;">end</span> <span style="color: #008080;">type</span>

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

<span style="color: #000000;">JortSort</span> <span style="color: #000000;">ok</span> <span style="color: #0000FF;">=</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;">JortSort</span> <span style="color: #000000;">bad</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">5</span><span style="color: #0000FF;">,</span><span style="color: #000000;">4</span><span style="color: #0000FF;">,</span><span style="color: #000000;">6</span><span style="color: #0000FF;">}</span>

{{out}}

Note that while the above is fine under pwa/p2js and can be invoked explicitly, it does not automatically trigger the error.

</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

<span style="color: #008080;">global</span> <span style="color: #008080;">constant</span> <span style="color: #000000;">T_while</span> <span style="color: #0000FF;">=</span> <span style="color: #000000;">336</span> <span style="color: #000000;">tt_stringF</span><span style="color: #0000FF;">(</span><span style="color: #008000;">"while"</span><span style="color: #0000FF;">,</span><span style="color: #000000;">T_while</span><span style="color: #0000FF;">)</span>

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

<pre>

It does that because at the lowest level a cmp imm is at least twice as fast as a cmp [mem], and the only other way it could know these constants at compile-time would be to (re)build a 5000-node ternary tree, though I will concede that any sane person would have written a program to write an include file rather than hacking these things by hand.<br>

There is a similar thing in pwa\src\p2js_keywords.e, though it automatically checks, prompts, and auto-rebuilds that for you.

 

=={{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|Quackery}}==

<code>jortsortwith</code> returns <code>true</code> if the nest is sorted, sort order is specified after <code>jortsortwith</code>, so <code>jortsortwith ></code> returns <code>true</code> if a nest of numbers is sorted in ascending numerical order, and <code>jortsortwith $<</code> returns <code>true</code> if a nest of strings is sorted in descending lexicographical order.

 

' [ sortwith ]

]'[ nested join

 

===The Non-satirical version===

Jortsort, as specified in this task, is a sensible function ("is this nest sorted?) done inefficiently. This is the efficient version, with a more sensible name.

 

]'[ temp put

dup [] != if

[ dip not conclude ] ] ]

drop

 

=={{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}}==

The Java deepEquals() method will work as a replacement.

 

 

 

=={{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>