Perl Weekly Challenge 139: JortSort

Input: @n = (1,2,3,4,5)
Output: 1

Since the array is sorted, it prints 1.

Input: @n = (1,3,2,4,5)
Output: 0

Since the array is NOT sorted, it prints 0.

JortSort is a joke.

The original jortSort actually sorts input, then compares the sorted input with the original input.

It's not clear whether sorting is necessary for a jortSort, or whether any function which returns whether its input is sorted or not qualifies as a jortSort. The challenge is silent on this subject. So, we won't bother with sorting, and just check whether the input is sorted or not.

A list \(L\) is sorted, if and only if, there isn't an index \(i > 0\) such that \(L [i - i] > L [i]\).

And that translates to a very simple piece of code.

{
    sorted = 1
    for (i = 2; i <= NF; i ++) {
        if ($(i - 1) > $i) {
            sorted = 0
        }
    }
    print sorted
}

After reading the input into an array list, we'll do:

((sorted = 1))
for ((i = 1; i < ${#list[@]}; i ++))
do  if ((${list[$i - 1]} > ${list[$i]}))
    then ((sorted = 0))
    fi
done
echo $sorted

Find the full program on GitHub.

In our bc solution, we assume the input is terminated by a 0.

prev = read()
sorted = 1;
while (1) {
    next = read()
    if (next == 0) { # End of input
        sorted
        break 
    }
    if (prev > next) {
        sorted = 0
    }
    prev = next
}

Find the full program on GitHub.

Here, we pick up the code after we have read a line of input into the variable line, of type char *.

int offset = 0;
int off;
int prev, next;   
bool sorted = true;
if (sscanf (line, "%d%n", &prev, &offset) != 1) {
    perror ("Failure to scan");
    exit (1);
}
while (sscanf (line + offset, "%d%n", &next, &off) == 1) {
    offset += off;
    if (prev > next) {
        sorted = false;
    }
    prev = next;
}
printf ("%d\n", sorted ? 1 : 0);

We use [sscanf] to extract integers from the line of input, comparing each integer (except the first) with the previous one.

Find the full program on GitHub.

Here, we have read in the data into a string line:

list   := strings . Split (line, " ")

sorted := true
for i := 1; sorted && i < len (list); i ++ {
    prev, _ := strconv . Atoi (list [i - 1])
    next, _ := strconv . Atoi (list [i])
    sorted = prev <= next
}

if (sorted) {
    fmt . Println (1)
} else {
    fmt . Println (0)
}

We're using Atoi to map a string into an integer, as Go doesn't automatically convert strings into integer.

It's a pity Go lacks a ternary operator.

Find the full program on GitHub.

With line a string containing the input, we get a solution very similar to the Go solution:

String [] list = line . split (" ");
boolean sorted = true;
for (int i = 1; sorted && i < list . length; i ++) { 
    sorted = Integer . parseInt (list [i - 1]) <= 
             Integer . parseInt (list [i]); 
}
System . out . println (sorted ? 1 : 0);

Find the full program on GitHub.

Lua lacks a split function, nor does it have something like scanf. So, we're using pattern matching to extract numbers from the input line line:

local sorted = 1
local prev   = nil
for next in line : gmatch ("[0-9]+") do
    if prev ~= nil and prev > next then
        sorted = 0
    end
    prev = next
end
print (sorted)

Find the full program on GitHub.

Our Node.js solution also uses pattern matching to extract the numbers from the line of input, and uses reduce to loop over the array of numbers, checking if all elements are in order:

console . log (line . match (/[0-9]+/gi) . reduce ((sorted, _, i, list) => {
    if (i > 0 && list [i - 1] > list [i]) {sorted = 0}
    return sorted},
    1) 
)

Find the full program on GitHub.

In Pascal, we can read in the numbers one by one, allowing us to easily compare consecutive numbers:

var
    prev, next: integer;
    sorted: integer;

begin
    sorted := 1;
    read (prev);
    while not eoln do begin
        read (next);
        if prev > next then begin
            sorted := 0;
        end;
        prev := next;
    end;
    readln ();
    writeln (sorted);
end.

Find the full program on GitHub.

In Perl, we also use pattern matching to extract the numbers from the input, which is in $_. Unlike most other solutions, we don't require an additional sorted variable. Instead, we use grep to find out whether any pairs of numbers are in unsorted order:

my @list = /[0-9]+/g;
say grep ({$list [$_ - 1] > $list [$_]} 1 .. $#list) ? 0 : 1

Find the full program on GitHub.

In Python, we just split the input, and loop over the resulting list:

list = line . split (" ")
sorted = 1
for i in range (1, len (list)):
    if list [i - 1] > list [i]:
        sorted = 0
print (sorted)

Find the full program on GitHub.

In R, we can use strsplit to split the input, and as.numeric to map strings to numbers. Then it's our familiar loop:

parts  <- strsplit (line, " ")
list   <- as.numeric (parts [[1]])
sorted <- 1
if (length (list) > 1) {
    for (i in 2 : length (list)) {
        if (list [i - 1] > list [i]) {
            sorted <- 0
        }
    }
}       
cat (sorted, "\n")

Note we do need a seperate check for the length of the list. If we have a one element list, the loop for (i in 2 : length (list)) { .. } would be executed twice: first with i = 2, then with i = 1. Which would not be what we want.

Find the full program on GitHub.

Our Ruby solution is similar to other solutions. We use map.with_index to iterate over the list. We're only interested in the index, so we use _ to signal we're not interested in the element.

sorted = 1
list = line . strip() . split(" ")
list . map . with_index do
    | _, i |
    if i > 0 && list [i - 1] > list [i] then
        sorted = 0
    end
end
puts (sorted)

Find the full program on GitHub.

Our Scheme solution looks very different. Iterating over lists isn't very Scheme-like. Instead, we use a recursive method:

• A list with less than two elements is sorted.
• Else, if the first element is larger than the second, the list is not sorted.
• Else, the list is sorted if the list following the first element is sorted.

This leads the following function:

(define (is-sorted list)
    (cond ((< (length list) 2)                     1)
          ((> (list-ref list 0) (list-ref list 1)) 0)
          (else (is-sorted (cdr list))))
)

After having read the input into a line line, we call the function above as:

(display (is-sorted (map-in-order string->number (string-split line #\ ))))
(newline)

string-split splits the input line on spaces (\#). We map the resulting strings to numbers by applying string-number on each element (due to map-in-order). The resulting list of numbers is then passed to is-sorted, and its return value is printed.

Find the full program on GitHub.

set list [split $line " "]
set result 1
for {set i 1} {$i < [llength $list]} {incr i} {
    if {[lindex $list [expr $i - 1]] > [lindex $list $i]} {
        set result 0
        break
    }
}
puts $result