Sort a list of object identifiers: Difference between revisions

{{task|Sorting Algorithms}}

{{Sorting Algorithm}}

 

 

* An OID consists of one or more non-negative integers in base 10, separated by dots. It starts and ends with a number.

 

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

1.3.6.1.4.1.11150.3.4.0.1

</pre>

 

=={{header|Go}}==

 

import (

fmt.Println(o)

}

{{out}}

<pre>

 

=={{header|Haskell}}==

 

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

main :: IO ( )

main = do

 

{{out}}

</pre>

 

(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)

-- SORTING OBJECT IDENTIFIERS ------------------------------------------------

oidSort :: [String] -> [String]

oidSort =

-- GENERIC FUNCTIONS ---------------------------------------------------------

splitString :: Char -> String -> [String]

splitString c s = unpack <$> split (c ==) (pack s)

readInt :: String -> Int

readInt xs = read xs :: Int

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

main :: IO ()

, "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)

 

oidSort :: [String] -> [String]

oidSort =

 

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.

 

We also pull the result out of its boxes for display purposes.

 

=={{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.3.6.1.4.1.11150.3.4.0.1</pre>

 

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

 

 

 

 

 

 

 

 

<pre>

</pre>

 

 

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

 

 

/*

oldOidList =

[

 

### SHOW BEFORE SORT

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

 

{{out}}

<pre>

 

.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.4

.1.3.6.1.4.1.11.2.17.19.3.4.0.10

.1.3.6.1.4.1.11150.3.4.0.1

 

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

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

 

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