Sort a list of object identifiers: Difference between revisions

{{task|Sorting Algorithms}}

{{Sorting Algorithm}}

 

{{task heading|Test case}}

 

|-

! Input ''(list of strings)''

 

<hr>

 

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

using System.Linq;

using System.Collections.Generic;

Console.WriteLine(string.Join(Environment.NewLine, oids));

}

{{out}}

<pre>

 

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

#include <vector>

#include <algorithm>

std::cout << s << '\n' ;

return 0 ;

{{out}}

<pre>1.3.6.1.4.1.11.2.17.5.2.0.79

1.3.6.1.4.1.11150.3.4.0

1.3.6.1.4.1.11150.3.4.0.1

</pre>

 

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

(loop for start = 0 then (1+ pos)

for pos = (position #\. oid :start start)

"1.3.6.1.4.1.11150.3.4.0")))

(dolist (oid (sort-oids oids))

{{out}}

<pre>1.3.6.1.4.1.11.2.17.5.2.0.79

 

=={{header|Elixir}}==

def numbers(list) do

Enum.sort_by(list, fn oid ->

]

|> Sort_by_OID.numbers

 

{{out}}

=={{header|Factor}}==

Factor provides the <code>human<=></code> word which converts numbers in a string to integers before comparing them.

 

qw{

1.3.6.1.4.1.11.2.17.19.3.4.0.1

1.3.6.1.4.1.11150.3.4.0

{{out}}

<pre>

1.3.6.1.4.1.11150.3.4.0.1

</pre>

 

=={{header|Go}}==

 

import (

fmt.Println(o)

}

{{out}}

<pre>

=={{header|Haskell}}==

====Data.List====

 

splitString :: Eq a => (a) -> [a] -> [[a]]

main :: IO ( )

main = do

 

{{out}}

(To use '''split :: (Char -> Bool) -> Text -> [Text]''' in the standard libraries, we would have to temporarily convert the strings from [Char] to Text with pack and unpack)

 

import Data.List (sort, intercalate)

 

, "1.3.6.1.4.1.11.2.17.19.3.4.0.1"

, "1.3.6.1.4.1.11150.3.4.0"

{{Out}}

<pre>1.3.6.1.4.1.11.2.17.5.2.0.79

we can alternatively write:

 

import Data.List (sort, intercalate)

 

 

readInt :: String -> Int

 

=={{header|J}}==

Data:

 

1.3.6.1.4.1.11.2.17.19.3.4.0.10

1.3.6.1.4.1.11.2.17.5.2.0.79

1.3.6.1.4.1.11.2.17.19.3.4.0.1

1.3.6.1.4.1.11150.3.4.0

 

In other words, for each line in that script, remove the spaces and put the rest in a box.

Sorting:

 

1.3.6.1.4.1.11.2.17.5.2.0.79

1.3.6.1.4.1.11.2.17.19.3.4.0.1

1.3.6.1.4.1.11.2.17.19.3.4.0.10

1.3.6.1.4.1.11150.3.4.0

 

In other words, for our sort key, we break the contents of each box by an initial '.' and treat the remainder as numbers.

{{works with|Java|8 or higher}}

 

package com.rosettacode;

 

.forEach(System.out::println);

}

 

{{out}}

1.3.6.1.4.1.11150.3.4.0

1.3.6.1.4.1.11150.3.4.0.1</pre>

 

=={{header|Julia}}==

{{works with|Julia|0.6}}

 

"1.3.6.1.4.1.11.2.17.5.2.0.79",

"1.3.6.1.4.1.11.2.17.19.3.4.0.4",

sort!(oidlist; lt=lexless,

by=x -> parse.(Int, String.(split(x, "."))))

 

{{out}}

 

=={{header|Kotlin}}==

 

class Oid(val id: String): Comparable<Oid> {

)

println(oids.sorted().joinToString("\n"))

 

{{out}}

=={{header|Lua}}==

Using the in-built table.sort with a custom compare function.

"1.3.6.1.4.1.11.2.17.19.3.4.0.10",

"1.3.6.1.4.1.11.2.17.5.2.0.79",

table.sort(OIDs, compare)

{{out}}

<pre>1.3.6.1.4.1.11.2.17.5.2.0.79

1.3.6.1.4.1.11150.3.4.0.1</pre>

===Using Coroutine===

local function oidGen(s)

local wrap, yield = coroutine.wrap, coroutine.yield

table.sort(OIDs, oidCmp)

for _, oid in pairs(OIDs) do print(oid) end

 

=={{header|M2000 Interpreter}}==

In this example we have to change dot to #, to make each number as an integer one.

Module CheckIt {

Flush ' empty stack of values

}

Checkit

{{out}}

<pre>

 

 

GT=lambda (a$, b$)->{

def i

data "1.3.6.1.4.1.11.2.17.19.3.4.0.1"

data "1.3.6.1.4.1.11150.3.4.0"

\\ if peek item i > peek item i+1 then get i+1 to top, and send to i

\\ stack is a linked list, so moving items done with pointers only

}

}

While not empty {

}

}

 

Using a function which split pieces one time. We have to insert one more item, by append a "." to a$ and b$

GT=lambda (a$, b$)->{

def i=-1

=val(a$(i))>val(b$(i))

}

 

===Using QuickSort===

 

 

Group Quick {

Private:

i=0 : While not Empty {arr$(i)=piece$(letter$+".", ".") : i++ }

}

For i=0 to len(arr())-1 {

Print join$(arr(i))

}

Call Quick.quicksort(&arr(), 0, Len(arr())-1)

For i=0 to len(arr())-1 {

Print join$(arr(i))

}

 

 

=={{header|Perl}}==

 

1.3.6.1.4.1.11.2.17.19.3.4.0.10

1.3.6.1.4.1.11.2.17.5.2.0.79

@OIDs;

 

 

{{out}}

Alternately, you can sort them as "version strings", which is a Perl syntax allowing you to specify a character string in the source code with the characters' codes specified as a dot-delimited sequence of integers.

 

map { $_->[0] }

sort { $a->[1] cmp $b->[1] }

map { [$_, eval "v$_"] }

 

 

{{out}}

<pre>

</pre>

 

 

 

 

 

 

 

=={{header|PicoLisp}}==

(by

'((L) (mapcar format (split (chop L) ".")))

"1.3.6.1.4.1.11.2.17.19.3.4.0.1"

"1.3.6.1.4.1.11150.3.4.0" ) )

{{out}}

<pre>1.3.6.1.4.1.11.2.17.5.2.0.79

1.3.6.1.4.1.11150.3.4.0

1.3.6.1.4.1.11150.3.4.0.1</pre>

 

=={{header|Python}}==

 

We need to split the input and map each part to int otherwise elements gets compared as a string

data = [

'1.3.6.1.4.1.11.2.17.19.3.4.0.10',

for s in sorted(data, key=lambda x: list(map(int, x.split('.')))):

print(s)

 

=={{header|Racket}}==

(require data/order)

 

"1.3.6.1.4.1.11.2.17.19.3.4.0.10"

"1.3.6.1.4.1.11150.3.4.0"

Tests run with no output, indicating success.

 

=={{header|REXX}}==

This REXX version supports negative integers in the OID.

call gen /*generate an array (@.) from the OIDs.*/

call show 'before sort ───► ' /*display the @ array before sorting.*/

call show ' after sort ───► ' /*display the @ array after sorting. */

exit /*stick a fork in it, we're all done. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

/*──────────────────────────────────────────────────────────────────────────────────────*/

@.j = translate( space(y), ., ' ') /*reconstitute number. */

/*──────────────────────────────────────────────────────────────────────────────────────*/

{{out|output|text=&nbsp; when using the (internal) default input:}}

<pre>

=={{header|Ring}}==

 

 

/*

###-----------------------------------------------------------

 

{{out}}

<pre>

 

=={{header|Ruby}}==

1.3.6.1.4.1.11.2.17.19.3.4.0.10

1.3.6.1.4.1.11.2.17.5.2.0.79

]

.sort_by{|oid| oid.split(".").map(&:to_i)}

 

{{out}}

</pre>

Or, using the Gem module (which knows about versions):

1.3.6.1.4.1.11.2.17.19.3.4.0.10

1.3.6.1.4.1.11.2.17.5.2.0.79

1.3.6.1.4.1.11.2.17.19.3.4.0.1

1.3.6.1.4.1.11150.3.4.0

with identical output.

 

=={{header|Sidef}}==

ids.sort_by { |id|

id.split('.').map { Num(_) }

)

 

{{out}}

<pre>

1.3.6.1.4.1.11150.3.4.0.1

</pre>

 

=={{header|Tcl}}==

# Example input data:

set oid_list [list \

puts [join $oid_list "."]

}

 

{{out}}

</pre>

 

 

=={{header|zkl}}==

 

Basically, blow apart each line into a list of numbers and sort that.

// pad each oid with a terminal (-1) so zip won't short cut

oids=oids.pump(List(),fcn(oid){ (oid + ".-1").split(".").apply("toInt") });

});

oids.pump(List,fcn(list){ list[0,-1].concat(".") }) // back to strings

"1.3.6.1.4.1.11.2.17.19.3.4.0.10",

"1.3.6.1.4.1.11.2.17.5.2.0.79",

"1.3.6.1.4.1.11150.3.4.0");

oids=sortOIDS(oids);

{{out}}

<pre>