Rosetta Code

Sort a list of object identifiers: Difference between revisions

Page Discussion

Sort a list of object identifiers (view source)

Revision as of 10:44, 8 February 2024

34,493 bytes added ,  3 months ago
m
→‎{{header|Wren}}: Minor tidy
No edit summary
m (→‎{{header|Wren}}: Minor tidy)
 
(26 intermediate revisions by 16 users not shown)
Line 1:
{{task|Sorting Algorithms}}
[[Category:Sorting]]
{{Sorting Algorithm}}
 
Line 15 ⟶ 16:
{{task heading|Test case}}
 
:::: {| class="wikitable"
|-
! Input ''(list of strings)''
Line 42 ⟶ 43:
 
<hr>
 
=={{header|11l}}==
{{trans|Python}}
 
<syntaxhighlight lang="11l">V 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.4’,
‘1.3.6.1.4.1.11150.3.4.0.1’,
‘1.3.6.1.4.1.11.2.17.19.3.4.0.1’,
‘1.3.6.1.4.1.11150.3.4.0’
]
 
V delim = ‘.’ // to get round ‘bug in MSVC 2017’[https://developercommunity.visualstudio.com/t/bug-with-operator-in-c/565417]
 
L(s) sorted(data, key' x -> x.split(:delim).map(Int))
print(s)</syntaxhighlight>
 
{{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
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.3.6.1.4.1.11150.3.4.0.1
</pre>
 
=={{header|Action!}}==
<syntaxhighlight lang="action!">DEFINE PTR="CARD"
 
PROC PrintArray(PTR ARRAY a INT size)
INT i
 
FOR i=0 TO size-1
DO
PrintE(a(i))
OD
RETURN
 
INT FUNC Decode(CHAR ARRAY s INT ARRAY a)
INT count
BYTE i,begin,end
CHAR ARRAY tmp(10)
 
count=0 i=1
WHILE i<=s(0)
DO
begin=i
WHILE i<=s(0) AND s(i)#'.
DO i==+1 OD
end=i-1
IF i<s(0) THEN i==+1 FI
SCopyS(tmp,s,begin,end)
a(count)=ValI(tmp)
count==+1
OD
RETURN (count)
 
INT FUNC Compare(CHAR ARRAY s1,s2)
INT ARRAY a1(20),a2(20)
INT c1,c2,res
BYTE i
 
c1=Decode(s1,a1)
c2=Decode(s2,a2)
 
i=0
DO
IF i=c1 AND i=c2 THEN
RETURN (0)
ELSEIF i=c1 THEN
RETURN (-1)
ELSEIF i=c2 THEN
RETURN (1)
FI
 
IF a1(i)<a2(i) THEN
RETURN (-1)
ELSEIF a1(i)>a2(i) THEN
RETURN (1)
FI
i==+1
OD
RETURN (0)
 
PROC Sort(PTR ARRAY a INT size)
INT i,j,minpos
CHAR ARRAY tmp
 
FOR i=0 TO size-2
DO
minpos=i
FOR j=i+1 TO size-1
DO
IF Compare(a(minpos),a(j))>0 THEN
minpos=j
FI
OD
IF minpos#i THEN
tmp=a(i)
a(i)=a(minpos)
a(minpos)=tmp
FI
OD
RETURN
 
PROC Main()
DEFINE SIZE="6"
PTR ARRAY a(SIZE)
 
a(0)="1.3.6.1.4.1.11.2.17.19.3.4.0.10"
a(1)="1.3.6.1.4.1.11.2.17.5.2.0.79"
a(2)="1.3.6.1.4.1.11.2.17.19.3.4.0.4"
a(3)="1.3.6.1.4.1.11150.3.4.0.1"
a(4)="1.3.6.1.4.1.11.2.17.19.3.4.0.1"
a(5)="1.3.6.1.4.1.11150.3.4.0"
 
PrintE("Array before sort:")
PrintArray(a,SIZE) PutE()
Sort(a,SIZE)
PrintE("Array after sort:")
PrintArray(a,SIZE)
RETURN</syntaxhighlight>
{{out}}
[https://gitlab.com/amarok8bit/action-rosetta-code/-/raw/master/images/Sort_a_list_of_object_identifiers.png Screenshot from Atari 8-bit computer]
<pre>
Array before sort:
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.4
1.3.6.1.4.1.11150.3.4.0.1
1.3.6.1.4.1.11.2.17.19.3.4.0.1
1.3.6.1.4.1.11150.3.4.0
 
Array after sort:
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.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.3.6.1.4.1.11150.3.4.0.1
</pre>
 
=={{header|Ada}}==
Line 47 ⟶ 193:
{{works with|Ada|Ada|2012}}
 
<langsyntaxhighlight Adalang="ada">with Ada.Containers.Generic_Array_Sort;
with Ada.Strings.Fixed;
with Ada.Strings.Unbounded; use Ada.Strings.Unbounded;
Line 97 ⟶ 243:
Ada.Text_IO.Put_Line(To_String(element));
end loop;
end Sort_List_Identifiers;</langsyntaxhighlight>
{{out}}
<pre>1.3.6.1.4.1.11.2.17.5.2.0.79
Line 108 ⟶ 254:
 
=={{header|AppleScript}}==
 
===Vanilla===
Place the call to the sort handler in a <tt>considering numeric strings</tt> statement.
<langsyntaxhighlight lang="applescript">(* Shell sort
Algorithm: Donald Shell, 1959.
*)
 
on ShellSort(theList, l, r)
script o
property lst : theList
Line 122 ⟶ 267:
set listLength to (count theList)
if (listLength > 1) then
-- Convert negative and/or transposed range indices.
set stepSize to listLength div 2
if (l < 0) then set l to listLength + l + 1
if (r < 0) then set r to listLength + r + 1
if (l > r) then set {l, r} to {r, l}
-- Do the sort.
set stepSize to (r - l + 1) div 2
repeat while (stepSize > 0)
repeat with i from (1l + stepSize) to listLengthr
set currentValue to item i of o's lst
repeat with j from (i - stepSize) to 1l by -stepSize
set thisValue to item j of o's lst
if (currentValue < thisValue) then
Line 141 ⟶ 292:
end if
return -- nothing. The input list has been sorted in place.
end ShellSort
property sort : ShellSort
 
-- Test code: sort items 1 thru -1 (ie. all) of a list of strings, treating numeric portions numerically.
-- Test code:
set theList to {"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.4", ¬
"1.3.6.1.4.1.11150.3.4.0.1", "1.3.6.1.4.1.11.2.17.19.3.4.0.1", "1.3.6.1.4.1.11150.3.4.0"}
considering numeric strings
ShellSortsort(theList, 1, -1)
end considering
return theList</langsyntaxhighlight>
 
{{output}}
Line 157 ⟶ 309:
===ASObjC===
Use the <tt>localizedStandardCompare:</tt> string comparison method.
<langsyntaxhighlight lang="applescript">use AppleScript version "2.4" -- OS X 10.10 (Yosemite) or later
use framework "Foundation"
 
Line 167 ⟶ 319:
ascending:(true) selector:("localizedStandardCompare:")
tell theArray to sortUsingDescriptors:({theDescriptor})
return theArray as list</langsyntaxhighlight>
 
{{output}}
<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", "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.3.6.1.4.1.11150.3.4.0.1"}</pre>
 
===Functional===
 
As a composition of pure functions:
 
<syntaxhighlight lang="applescript">------------- SORTED LIST OF OBJECT IDENTIFIERS ------------
 
-- sortedIdentifiers :: [String] -> [String]
on sortedIdentifiers(xs)
script listCompare
on |λ|(x, y)
script go
on |λ|(a, xy)
if 0 ≠ a then
a
else
compare(|1| of xy, |2| of xy)
end if
end |λ|
end script
foldl(go, 0, zip(x, y))
end |λ|
end script
map(intercalate("."), ¬
sortBy(listCompare, ¬
map(compose(curry(my map)'s ¬
|λ|(my readint), splitOn(".")), xs)))
end sortedIdentifiers
 
 
---------------------------- TEST --------------------------
on run
unlines(sortedIdentifiers({¬
"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.4", ¬
"1.3.6.1.4.1.11150.3.4.0.1", ¬
"1.3.6.1.4.1.11.2.17.19.3.4.0.1", ¬
"1.3.6.1.4.1.11150.3.4.0"}))
end run
 
 
--------------------- LIBRARY FUNCTIONS --------------------
 
-- Tuple (,) :: a -> b -> (a, b)
on Tuple(a, b)
-- Constructor for a pair of values, possibly of two different types.
{type:"Tuple", |1|:a, |2|:b, length:2}
end Tuple
 
 
-- compare :: a -> a -> Ordering
on compare(a, b)
if a < b then
-1
else if a > b then
1
else
0
end if
end compare
 
 
-- compose (<<<) :: (b -> c) -> (a -> b) -> a -> c
on compose(f, g)
script
property mf : mReturn(f)
property mg : mReturn(g)
on |λ|(x)
mf's |λ|(mg's |λ|(x))
end |λ|
end script
end compose
 
 
-- concatMap :: (a -> [b]) -> [a] -> [b]
on concatMap(f, xs)
set lng to length of xs
set acc to {}
tell mReturn(f)
repeat with i from 1 to lng
set acc to acc & (|λ|(item i of xs, i, xs))
end repeat
end tell
return acc
end concatMap
 
 
-- curry :: ((a, b) -> c) -> a -> b -> c
on curry(f)
script
on |λ|(a)
script
on |λ|(b)
|λ|(a, b) of mReturn(f)
end |λ|
end script
end |λ|
end script
end curry
 
 
-- drop :: Int -> [a] -> [a]
-- drop :: Int -> String -> String
on drop(n, xs)
set c to class of xs
if script is not c then
if string is not c then
if n < length of xs then
items (1 + n) thru -1 of xs
else
{}
end if
else
if n < length of xs then
text (1 + n) thru -1 of xs
else
""
end if
end if
else
take(n, xs) -- consumed
return xs
end if
end drop
 
 
-- findIndices :: (a -> Bool) -> [a] -> [Int]
on findIndices(p, xs)
-- List of zero-based indices of
-- any matches for p in xs.
script
property f : mReturn(p)
on |λ|(x, i, xs)
if f's |λ|(x, i, xs) then
{i - 1}
else
{}
end if
end |λ|
end script
concatMap(result, xs)
end findIndices
 
 
-- foldl :: (a -> b -> a) -> a -> [b] -> a
on foldl(f, startValue, xs)
tell mReturn(f)
set v to startValue
set lng to length of xs
repeat with i from 1 to lng
set v to |λ|(v, item i of xs, i, xs)
end repeat
return v
end tell
end foldl
 
 
-- fst :: (a, b) -> a
on fst(tpl)
if class of tpl is record then
|1| of tpl
else
item 1 of tpl
end if
end fst
 
 
-- intercalate :: String -> [String] -> String
on intercalate(delim)
script
on |λ|(xs)
set {dlm, my text item delimiters} to ¬
{my text item delimiters, delim}
set s to xs as text
set my text item delimiters to dlm
s
end |λ|
end script
end intercalate
 
 
-- map :: (a -> b) -> [a] -> [b]
on map(f, xs)
-- The list obtained by applying f
-- to each element of xs.
tell mReturn(f)
set lng to length of xs
set lst to {}
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, i, xs)
end repeat
return lst
end tell
end map
 
 
-- mReturn :: First-class m => (a -> b) -> m (a -> b)
on mReturn(f)
-- 2nd class handler function lifted into 1st class script wrapper.
if script is class of f then
f
else
script
property |λ| : f
end script
end if
end mReturn
 
 
-- Returns a sequence-matching function for findIndices etc
-- matching :: [a] -> (a -> Int -> [a] -> Bool)
-- matching :: String -> (Char -> Int -> String -> Bool)
on matching(pat)
if class of pat is text then
set xs to characters of pat
else
set xs to pat
end if
set lng to length of xs
set bln to 0 < lng
if bln then
set h to item 1 of xs
else
set h to missing value
end if
script
on |λ|(x, i, src)
(h = x) and xs = ¬
(items i thru min(length of src, -1 + lng + i) of src)
end |λ|
end script
end matching
 
 
-- min :: Ord a => a -> a -> a
on min(x, y)
if y < x then
y
else
x
end if
end min
 
 
-- partition :: (a -> Bool) -> [a] -> ([a], [a])
on partition(f, xs)
tell mReturn(f)
set ys to {}
set zs to {}
repeat with x in xs
set v to contents of x
if |λ|(v) then
set end of ys to v
else
set end of zs to v
end if
end repeat
end tell
Tuple(ys, zs)
end partition
 
 
-- readInt :: String -> Int
on readint(s)
s as integer
end readint
 
 
-- snd :: (a, b) -> b
on snd(tpl)
if class of tpl is record then
|2| of tpl
else
item 2 of tpl
end if
end snd
 
 
-- Enough for small scale sorts.
-- Use instead sortOn (Ord b => (a -> b) -> [a] -> [a])
-- which is equivalent to the more flexible sortBy(comparing(f), xs)
-- and uses a much faster ObjC NSArray sort method
-- sortBy :: (a -> a -> Ordering) -> [a] -> [a]
on sortBy(f, xs)
if length of xs > 1 then
set h to item 1 of xs
set f to mReturn(f)
script
on |λ|(x)
f's |λ|(x, h) ≤ 0
end |λ|
end script
set lessMore to partition(result, rest of xs)
sortBy(f, |1| of lessMore) & {h} & ¬
sortBy(f, |2| of lessMore)
else
xs
end if
end sortBy
 
 
-- splitOn :: [a] -> [a] -> [[a]]
-- splitOn :: String -> String -> [String]
on splitOn(pat)
script
on |λ|(src)
if class of src is text then
set {dlm, my text item delimiters} to ¬
{my text item delimiters, pat}
set xs to text items of src
set my text item delimiters to dlm
return xs
else
set lng to length of pat
script residue
on |λ|(a, i)
Tuple(fst(a) & ¬
{init(items snd(a) thru (i) of src)}, lng + i)
end |λ|
end script
set tpl to foldl(residue, ¬
Tuple({}, 1), findIndices(matching(pat), src))
return fst(tpl) & {drop(snd(tpl) - 1, src)}
end if
end |λ|
end script
end splitOn
 
 
-- unlines :: [String] -> String
on unlines(xs)
-- A single string formed by the intercalation
-- of a list of strings with the newline character.
set {dlm, my text item delimiters} to ¬
{my text item delimiters, linefeed}
set s to xs as text
set my text item delimiters to dlm
s
end unlines
 
 
-- zip :: [a] -> [b] -> [(a, b)]
on zip(xs, ys)
zipWith(my Tuple, xs, ys)
end zip
 
 
-- zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]
on zipWith(f, xs, ys)
set lng to min(length of xs, length of ys)
set lst to {}
if 1 > lng then
return {}
else
tell mReturn(f)
repeat with i from 1 to lng
set end of lst to |λ|(item i of xs, item i of ys)
end repeat
return lst
end tell
end if
end zipWith</syntaxhighlight>
{{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
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.3.6.1.4.1.11150.3.4.0.1</pre>
 
=={{header|Arturo}}==
<syntaxhighlight lang="arturo">lst: [
"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.4"
"1.3.6.1.4.1.11150.3.4.0.1"
"1.3.6.1.4.1.11.2.17.19.3.4.0.1"
"1.3.6.1.4.1.11150.3.4.0"
]
 
print.lines arrange lst 'x ->
sum map.with:'i to [:integer] split.by:"." x 'z ->
z * 10^(20-i)</syntaxhighlight>
 
{{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
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.3.6.1.4.1.11150.3.4.0.1</pre>
 
=={{header|ATS}}==
 
<syntaxhighlight lang="ats">
(* Sort a list of object identifiers (OID). *)
 
#include "share/atspre_staload.hats"
staload UN = "prelude/SATS/unsafe.sats"
 
%{^
#include <alloca.h> /* ATS2 exceptions require alloca(3). */
%}
 
#define NIL list_nil ()
#define :: list_cons
 
infixl ( :: ) :::
#define VNIL list_vt_nil ()
#define ::: list_vt_cons
 
exception Exc_not_an_oid of (string, string)
exception Exc_internal_error of (string)
macdef not_an_oid (s) = $raise Exc_not_an_oid ($mylocation, ,(s))
macdef internal_error () = $raise Exc_internal_error ($mylocation)
 
fn
oid_explode
{n : int}
(s : string n)
:<!exnwrt> List0_vt String1 =
let
fun
loop {i : nat | i <= n}
.<n - i>.
(lst : &list_vt (String1, 0) >> List0_vt String1,
i : size_t i)
:<!exnwrt> void =
if ~string_is_atend (s, i) then
let
fun
scan_number
{j : int | i <= j; j <= n}
.<n - j>.
(j : size_t j)
:<> [j : int | i <= j; j <= n]
size_t j =
if string_is_atend (s, j) then
j
else if ~isdigit s[j] then
j
else
scan_number (succ j)
 
val j = scan_number i
in
if j = i then
not_an_oid s
else if string_is_atend (s, j) then
let
val t =
strnptr2string (string_make_substring (s, i, j - i))
val+ ~ VNIL = lst
in
lst := t ::: VNIL
end
else if s[j] <> '.' then
not_an_oid s
else if string_is_atend (s, succ j) then
not_an_oid s
else
let
val+ ~ VNIL = lst
val t =
strnptr2string
(string_make_substring (s, i, j - i))
val () = lst := t ::: VNIL
val+ @ _ ::: tail = lst
val () = loop (tail, succ j)
prval () = fold@ lst
in
end
end
 
prval () = lemma_string_param s
 
var lst : List0_vt String1 = VNIL
in
if string_is_empty s then
not_an_oid s;
loop (lst, i2sz 0);
lst
end
 
fn
oid_field_cmp
(x : String0,
y : String0)
:<!exn> int =
let
fun
to_number {n : nat}
{i : nat | i <= n}
.<n - i>.
(s : string n,
i : size_t i,
accum : ullint)
:<!exn> ullint =
if string_is_atend (s, i) then
accum
else if ~isdigit s[i] then
internal_error ()
else
let
val digit = $UN.cast{ullint} s[i] - $UN.cast '0'
in
to_number (s, succ i, (10ULL * accum) + digit)
end
 
val nx = to_number (x, i2sz 0, 0ULL)
and ny = to_number (y, i2sz 0, 0ULL)
in
compare (nx, ny)
end
 
fn
oid_cmp (x : String0,
y : String0)
:<!exnwrt> int =
let
fun
loop {m, n : nat}
.<m, n>.
(xs : list (String1, m),
ys : list (String1, n))
:<!exnwrt> int =
case+ ys of
| NIL => if iseqz xs then 0 else 1
| yhead :: ytail =>
begin
case+ xs of
| NIL => ~1
| xhead :: xtail =>
let
val cmp = oid_field_cmp (xhead, yhead)
in
if cmp = 0 then
loop (xtail, ytail)
else
cmp
end
end
 
val xs = list_vt2t (oid_explode x)
and ys = list_vt2t (oid_explode y)
in
loop (xs, ys)
end
 
fn
oid_list_sort
{n : int}
(lst : list (String0, n))
:<!exnwrt> list_vt (String0, n) =
list_mergesort_fun<String0>
(lst, lam (x, y) => $effmask_all oid_cmp (x, y))
 
implement
main0 () =
try
let
val oid_list =
$list ("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.4",
"1.3.6.1.4.1.11150.3.4.0.1",
"1.3.6.1.4.1.11.2.17.19.3.4.0.1",
"1.3.6.1.4.1.11150.3.4.0")
val oid_sorted = list_vt2t (oid_list_sort oid_list)
 
var p : List0 String0
in
for (p := oid_sorted; isneqz p; p := list_tail p)
println! (list_head p)
end
with
| ~ Exc_not_an_oid (loc, s) =>
begin
println! ("Not a UID: \"", s, "\" (exception raised at ", loc, ")");
exit 1
end
| ~ Exc_internal_error loc =>
begin
println! ("Internal error (exception raised at ", loc, ")");
exit 1
end
</syntaxhighlight>
 
{{out}}
<pre>
$ patscc -DATS_MEMALLOC_GCBDW oid_sort.dats -lgc && ./a.out
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.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.3.6.1.4.1.11150.3.4.0.1
</pre>
 
=={{header|AutoHotkey}}==
<syntaxhighlight lang="autohotkey">; based on http://www.rosettacode.org/wiki/Sorting_algorithms/Quicksort#AutoHotkey
OidQuickSort(a, Delim:=".", index:=1){
if (a.Count() <= 1)
return a
Less := [], Equal := [], More := []
Pivot := StrSplit(a[1], Delim)[index]
for k, v in a
{
x := StrSplit(v, Delim)[index]
if (x < Pivot)
less.InsertAt(1, v)
else if (x > Pivot)
more.InsertAt(1, v)
else
Equal.InsertAt(1, v)
}
Equal := OidQuickSort(Equal, Delim, index+1)
Less := OidQuickSort(Less)
Out := OidQuickSort(More)
if (Equal.Count())
Out.InsertAt(1, Equal*) ; InsertAt all values of Equal at index 1
if (Less.Count())
Out.InsertAt(1, Less*) ; InsertAt all values of Less at index 1
return Out
}</syntaxhighlight>
Examples:<syntaxhighlight lang="autohotkey">a := ["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.4"
,"1.3.6.1.4.1.11150.3.4.0.1"
,"1.3.6.1.4.1.11.2.17.19.3.4.0.1"
,"1.3.6.1.4.1.11150.3.4.0"]
 
for k, v in OidQuickSort(a)
Out .= "`n" v
MsgBox % Out
return</syntaxhighlight>
{{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
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.3.6.1.4.1.11150.3.4.0.1
</pre>
 
=={{header|AWK}}==
<syntaxhighlight lang="awk">
<lang AWK>
# syntax: GAWK -f SORT_A_LIST_OF_OBJECT_IDENTIFIERS.AWK
#
Line 209 ⟶ 1,008:
exit(0)
}
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 222 ⟶ 1,021:
=={{header|C}}==
A C99 (or later) compiler is required.
<langsyntaxhighlight lang="c">#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Line 331 ⟶ 1,130:
oid_destroy(oids[i]);
return 0;
}</langsyntaxhighlight>
 
{{out}}
Line 344 ⟶ 1,143:
 
=={{header|C sharp}}==
<langsyntaxhighlight lang="csharp">using System;
using System.Linq;
using System.Collections.Generic;
Line 371 ⟶ 1,170:
Console.WriteLine(string.Join(Environment.NewLine, oids));
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 383 ⟶ 1,182:
 
=={{header|C++}}==
<langsyntaxhighlight Cpplang="cpp">#include <string>
#include <vector>
#include <algorithm>
Line 432 ⟶ 1,231:
std::cout << s << '\n' ;
return 0 ;
}</langsyntaxhighlight>
{{out}}
<pre>1.3.6.1.4.1.11.2.17.5.2.0.79
Line 446 ⟶ 1,245:
Clojure 'sort' function allows specifying an optional comparator function. In this case, our custom comparator utilizes the ability of the clojure.core 'compare' function to compare vectors in an appropriate fashion.
 
<syntaxhighlight lang="clojure">
<lang Clojure>
(defn oid-vec [oid-str]
(->> (clojure.string/split oid-str #"\.")
Line 471 ⟶ 1,270:
(sort oid-compare)
(map oid-str)))
</syntaxhighlight>
</lang>
 
{{out}}
Line 491 ⟶ 1,290:
 
=={{header|Common Lisp}}==
<langsyntaxhighlight lang="lisp">(defun oid->list (oid)
(loop for start = 0 then (1+ pos)
for pos = (position #\. oid :start start)
Line 517 ⟶ 1,316:
"1.3.6.1.4.1.11150.3.4.0")))
(dolist (oid (sort-oids oids))
(write-line oid))))</langsyntaxhighlight>
{{out}}
<pre>1.3.6.1.4.1.11.2.17.5.2.0.79
Line 527 ⟶ 1,326:
 
=={{header|Elixir}}==
<langsyntaxhighlight lang="elixir">defmodule Sort_by_OID do
def numbers(list) do
Enum.sort_by(list, fn oid ->
Line 544 ⟶ 1,343:
]
|> Sort_by_OID.numbers
|> Enum.each(fn oid -> IO.puts oid end)</langsyntaxhighlight>
 
{{out}}
Line 558 ⟶ 1,357:
=={{header|Factor}}==
Factor provides the <code>human<=></code> word which converts numbers in a string to integers before comparing them.
<langsyntaxhighlight lang="factor">USING: io qw sequences sorting sorting.human ;
 
qw{
Line 567 ⟶ 1,366:
1.3.6.1.4.1.11.2.17.19.3.4.0.1
1.3.6.1.4.1.11150.3.4.0
} [ human<=> ] sort [ print ] each</langsyntaxhighlight>
{{out}}
<pre>
Line 577 ⟶ 1,376:
1.3.6.1.4.1.11150.3.4.0.1
</pre>
 
=={{header|Fōrmulæ}}==
 
{{FormulaeEntry|page=https://formulae.org/?script=examples/Sort_a_list_of_object_identifiers}}
 
'''Solution'''
 
[[File:Fōrmulæ - Sort a list of object identifiers 01.png]]
 
[[File:Fōrmulæ - Sort a list of object identifiers 02.png]]
 
'''Test case'''
 
[[File:Fōrmulæ - Sort a list of object identifiers 03.png]]
 
[[File:Fōrmulæ - Sort a list of object identifiers 04.png]]
 
=={{header|Go}}==
<langsyntaxhighlight lang="go">package main
 
import (
Line 650 ⟶ 1,465:
fmt.Println(o)
}
}</langsyntaxhighlight>
{{out}}
<pre>
Line 663 ⟶ 1,478:
=={{header|Haskell}}==
====Data.List====
<langsyntaxhighlight Haskelllang="haskell">import Data.List ( sort , intercalate )
 
splitString :: Eq a => (a) -> [a] -> [[a]]
Line 687 ⟶ 1,502:
main :: IO ( )
main = do
mapM_ putStrLn $ orderOID oid</langsyntaxhighlight>
 
{{out}}
Line 701 ⟶ 1,516:
(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)
 
<langsyntaxhighlight lang="haskell">import Data.Text (pack, split, unpack)
import Data.List (sort, intercalate)
 
Line 728 ⟶ 1,543:
, "1.3.6.1.4.1.11.2.17.19.3.4.0.1"
, "1.3.6.1.4.1.11150.3.4.0"
]</langsyntaxhighlight>
{{Out}}
<pre>1.3.6.1.4.1.11.2.17.5.2.0.79
Line 740 ⟶ 1,555:
we can alternatively write:
 
<langsyntaxhighlight lang="haskell">import Data.List.Split (splitOn)
import Data.List (sort, intercalate)
 
Line 749 ⟶ 1,564:
 
readInt :: String -> Int
readInt x = read x :: Int</langsyntaxhighlight>
 
=={{header|J}}==
Line 755 ⟶ 1,570:
Data:
 
<langsyntaxhighlight Jlang="j">oids=:<@-.&' ';._2]0 :0
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
Line 762 ⟶ 1,577:
1.3.6.1.4.1.11.2.17.19.3.4.0.1
1.3.6.1.4.1.11150.3.4.0
)</langsyntaxhighlight>
 
In other words, for each line in that script, remove the spaces and put the rest in a box.
Line 768 ⟶ 1,583:
Sorting:
 
<langsyntaxhighlight Jlang="j"> >(/: __&".;._1&.('.'&,)&>) oids
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
Line 774 ⟶ 1,589:
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.3.6.1.4.1.11150.3.4.0.1 </langsyntaxhighlight>
 
In other words, for our sort key, we break the contents of each box by an initial '.' and treat the remainder as numbers.
Line 783 ⟶ 1,598:
{{works with|Java|8 or higher}}
 
<langsyntaxhighlight lang="java">
package com.rosettacode;
 
Line 816 ⟶ 1,631:
.forEach(System.out::println);
}
}</langsyntaxhighlight>
 
{{out}}
Line 827 ⟶ 1,642:
 
=={{header|jq}}==
<langsyntaxhighlight lang="jq">def 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",
Line 836 ⟶ 1,651:
];
 
data | map( split(".") | map(tonumber) ) | sort | map(join("."))</langsyntaxhighlight>
 
{{out}}
Line 851 ⟶ 1,666:
{{works with|Julia|0.6}}
 
<langsyntaxhighlight lang="julia">oidlist = ["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.4",
Line 860 ⟶ 1,675:
sort!(oidlist; lt=lexless,
by=x -> parse.(Int, String.(split(x, "."))))
println.(oidlist)</langsyntaxhighlight>
 
{{out}}
Line 871 ⟶ 1,686:
 
=={{header|Kotlin}}==
<langsyntaxhighlight lang="scala">// version 1.0.6
 
class Oid(val id: String): Comparable<Oid> {
Line 898 ⟶ 1,713:
)
println(oids.sorted().joinToString("\n"))
}</langsyntaxhighlight>
 
{{out}}
Line 912 ⟶ 1,727:
=={{header|Lua}}==
Using the in-built table.sort with a custom compare function.
<langsyntaxhighlight Lualang="lua">local OIDs = {
"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",
Line 932 ⟶ 1,747:
table.sort(OIDs, compare)
for _, oid in pairs(OIDs) do print(oid) end</langsyntaxhighlight>
{{out}}
<pre>1.3.6.1.4.1.11.2.17.5.2.0.79
Line 941 ⟶ 1,756:
1.3.6.1.4.1.11150.3.4.0.1</pre>
===Using Coroutine===
<langsyntaxhighlight lang="lua">
local function oidGen(s)
local wrap, yield = coroutine.wrap, coroutine.yield
Line 970 ⟶ 1,785:
table.sort(OIDs, oidCmp)
for _, oid in pairs(OIDs) do print(oid) end
</syntaxhighlight>
</lang>
 
=={{header|M2000 Interpreter}}==
In this example we have to change dot to #, to make each number as an integer one.
<syntaxhighlight lang="m2000 interpreter">
<lang M2000 Interpreter>
Module CheckIt {
Flush ' empty stack of values
Line 997 ⟶ 1,812:
}
Checkit
</syntaxhighlight>
</lang>
{{out}}
<pre>
Line 1,017 ⟶ 1,832:
 
 
<syntaxhighlight lang="m2000 interpreter">
<lang M2000 Interpreter>
GT=lambda (a$, b$)->{
def i
Line 1,051 ⟶ 1,866:
}
}
</syntaxhighlight>
</lang>
 
Using a function which split pieces one time. We have to insert one more item, by append a "." to a$ and b$
<syntaxhighlight lang="m2000 interpreter">
<lang M2000 Interpreter>
GT=lambda (a$, b$)->{
def i=-1
Line 1,067 ⟶ 1,882:
=val(a$(i))>val(b$(i))
}
</syntaxhighlight>
</lang>
 
===Using QuickSort===
Line 1,080 ⟶ 1,895:
 
 
<syntaxhighlight lang="m2000 interpreter">
<lang M2000 Interpreter>
Group Quick {
Private:
Line 1,143 ⟶ 1,958:
Print join$(arr(i))
}
</syntaxhighlight>
</lang>
 
=={{header|Mathematica}} / {{header|Wolfram Language}}==
<syntaxhighlight lang="mathematica">in = {"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.4",
"1.3.6.1.4.1.11150.3.4.0.1", "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 = StringSplit[#, "."] & /@ in;
in = Map[ToExpression, in, {2}];
Column[StringRiffle[ToString /@ #, "."] & /@ LexicographicSort[in]]</syntaxhighlight>
{{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
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.3.6.1.4.1.11150.3.4.0.1</pre>
 
=={{header|Nim}}==
=== OID as distinct string ===
Nim allows to define distinct types. As OID are peculiar strings, defining them as distinct strings seems a good idea. We have to define a specific comparison procedure and that’s all. Here is the code:
<syntaxhighlight lang="nim">import algorithm, sequtils, strutils
 
type OID = distinct string
 
# Borrow the `$` procedure from the base string type.
proc `$`(oid: OID): string {.borrow.}
 
 
template toSeqInt(oid: OID): seq[int] =
## Convert an OID into a sequence of integers.
oid.string.split('.').map(parseInt)
 
 
proc oidCmp(a, b: OID): int =
## Compare two OIDs. Return 0 if OIDs are equal, -1 if the first is
## less than the second, +1 is the first is greater than the second.
let aseq = a.toSeqInt
let bseq = b.toSeqInt
for i in 0..<min(aseq.len, bseq.len):
result = cmp(aseq[i], bseq[i])
if result != 0: return
result = cmp(aseq.len, bseq.len)
 
 
when isMainModule:
 
const OIDS = [OID"1.3.6.1.4.1.11.2.17.19.3.4.0.10",
OID"1.3.6.1.4.1.11.2.17.5.2.0.79",
OID"1.3.6.1.4.1.11.2.17.19.3.4.0.4",
OID"1.3.6.1.4.1.11150.3.4.0.1",
OID"1.3.6.1.4.1.11.2.17.19.3.4.0.1",
OID"1.3.6.1.4.1.11150.3.4.0"]
 
for oid in OIDS.sorted(oidCmp):
echo oid</syntaxhighlight>
 
Note that as the type is distinct, we have to borrow the procedure `$` to the string type in order to print OID values.
 
{{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
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.3.6.1.4.1.11150.3.4.0.1</pre>
 
=== OID as composite object ===
 
The previous method is elegant but not very efficient. Indeed, every time a comparison is done, two conversions to a sequence of integers are done. And when sorting an array of OIDs, the same conversion is done several time.
 
To avoid this, we can define OID as a composite object type containing a string value and a list of integers to use for the comparisons. The code is not really more complicated, only arguably less elegant as we have to create the OIDs using the procedure “initOID”.
 
<syntaxhighlight lang="nim">import algorithm, sequtils, strutils
 
type OID = object
value: string
list: seq[int]
 
proc initOID(s: string): OID =
OID(value: s, list: s.split('.').map(parseInt))
 
proc `$`(oid: OID): string =
oid.value
 
proc oidCmp(a, b: OID): int =
## Compare two OIDs. Return 0 if OIDs are equal, -1 if the first is
## less than the second, +1 is the first is greater than the second.
for i in 0..<min(a.list.len, b.list.len):
result = cmp(a.list[i], b.list[i])
if result != 0: return
result = cmp(a.list.len, b.list.len)
 
 
when isMainModule:
 
const OIDS = [initOID("1.3.6.1.4.1.11.2.17.19.3.4.0.10"),
initOID("1.3.6.1.4.1.11.2.17.5.2.0.79"),
initOID("1.3.6.1.4.1.11.2.17.19.3.4.0.4"),
initOID("1.3.6.1.4.1.11150.3.4.0.1"),
initOID("1.3.6.1.4.1.11.2.17.19.3.4.0.1"),
initOID("1.3.6.1.4.1.11150.3.4.0")]
 
for oid in OIDS.sorted(oidCmp):
echo oid</syntaxhighlight>
 
{{out}}
Same as with the previous method.
 
=={{header|Perl}}==
 
<langsyntaxhighlight lang="perl">my @OIDs = qw(
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
Line 1,162 ⟶ 2,084:
@OIDs;
 
print "$_\n" for @sorted;</langsyntaxhighlight>
 
{{out}}
Line 1,176 ⟶ 2,098:
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.
 
<langsyntaxhighlight lang="perl">my @sorted =
map { $_->[0] }
sort { $a->[1] cmp $b->[1] }
map { [$_, eval "v$_"] }
@OIDs;</langsyntaxhighlight>
 
=={{header|Phix}}==
{{libheader|Phix/basics}}
I would normally recommend a tagsort, but we can avoid the extra routine and tagset here.
This is a variation on a standard tagsort, but performed a bit more explicitly.
<lang Phix>sequence strings = {"1.3.6.1.4.1.11.2.17.19.3.4.0.10",
<!--<syntaxhighlight lang="phix">-->
"1.3.6.1.4.1.11.2.17.5.2.0.79",
<span style="color: #004080;">sequence</span> <span style="color: #000000;">strings</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"1.3.6.1.4.1.11.2.17.19.3.4.0.10"</span><span style="color: #0000FF;">,</span>
"1.3.6.1.4.1.11.2.17.19.3.4.0.4",
<span style="color: #008000;">"1.3.6.1.4.1.1115011.32.417.5.2.0.179"</span><span style="color: #0000FF;">,</span>
<span style="color: #008000;">"1.3.6.1.4.1.11.2.17.19.3.4.0.14"</span><span style="color: #0000FF;">,</span>
<span style="color: #008000;">"1.3.6.1.4.1.11150.3.4.0.1"</span><span style="color: #0000FF;"}>,</span>
<span style="color: #008000;">"1.3.6.1.4.1.11.2.17.19.3.4.0.1"</span><span style="color: #0000FF;">,</span>
 
<span style="color: #008000;">"1.3.6.1.4.1.11150.3.4.0"</span><span style="color: #0000FF;">}</span>
constant len = length(strings)
sequence sortable = repeat(0,len)
<span style="color: #008080;">constant</span> <span style="color: #000000;">len</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">strings</span><span style="color: #0000FF;">)</span>
 
<span style="color: #004080;">sequence</span> <span style="color: #000000;">sortable</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">repeat</span><span style="color: #0000FF;">(</span><span style="color: #000000;">0</span><span style="color: #0000FF;">,</span><span style="color: #000000;">len</span><span style="color: #0000FF;">)</span>
for i=1 to len do
sequence si = split(strings[i],'.')
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">len</span> <span style="color: #008080;">do</span>
for j=1 to length(si) do
<span style="color: #004080;">sequence</span> <span style="color: #000000;">si</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #000000;">strings</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">],</span><span style="color: #008000;">'.'</span><span style="color: #0000FF;">)</span>
si[j] = to_number(si[j])
<span style="color: #008080;">for</span> <span style="color: #000000;">j</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #7060A8;">length</span><span style="color: #0000FF;">(</span><span style="color: #000000;">si</span><span style="color: #0000FF;">)</span> <span style="color: #008080;">do</span>
end for
<span style="color: #000000;">si</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">to_number</span><span style="color: #0000FF;">(</span><span style="color: #000000;">si</span><span style="color: #0000FF;">[</span><span style="color: #000000;">j</span><span style="color: #0000FF;">])</span>
sortable[i] = {si,i}
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
end for
<span style="color: #000000;">sortable</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">]</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">si</span><span style="color: #0000FF;">,</span><span style="color: #000000;">i</span><span style="color: #0000FF;">}</span>
sortable = sort(sortable)
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
for i=1 to len do
<span style="color: #000000;">sortable</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #000000;">sortable</span><span style="color: #0000FF;">)</span>
?strings[sortable[i][2]]
<span style="color: #008080;">for</span> <span style="color: #000000;">i</span><span style="color: #0000FF;">=</span><span style="color: #000000;">1</span> <span style="color: #008080;">to</span> <span style="color: #000000;">len</span> <span style="color: #008080;">do</span>
end for</lang>
<span style="color: #0000FF;">?</span><span style="color: #000000;">strings</span><span style="color: #0000FF;">[</span><span style="color: #000000;">sortable</span><span style="color: #0000FF;">[</span><span style="color: #000000;">i</span><span style="color: #0000FF;">][</span><span style="color: #000000;">2</span><span style="color: #0000FF;">]]</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">for</span>
<!--</syntaxhighlight>-->
{{out}}
<pre>
"1.3.6.1.4.1.11.2.17.5.2.0.79"
Line 1,212 ⟶ 2,138:
"1.3.6.1.4.1.11150.3.4.0"
"1.3.6.1.4.1.11150.3.4.0.1"
</pre>
 
===alternative===
This is very similar to the above, but without using any tags/indexes at all.
<!--<syntaxhighlight lang="phix">-->
<span style="color: #008080;">constant</span> <span style="color: #000000;">strings</span> <span style="color: #0000FF;">=</span> <span style="color: #0000FF;">{</span><span style="color: #008000;">"1.3.6.1.4.1.11.2.17.19.3.4.0.10"</span><span style="color: #0000FF;">,</span>
<span style="color: #008000;">"1.3.6.1.4.1.11.2.17.5.2.0.79"</span><span style="color: #0000FF;">,</span>
<span style="color: #008000;">"1.3.6.1.4.1.11.2.17.19.3.4.0.4"</span><span style="color: #0000FF;">,</span>
<span style="color: #008000;">"1.3.6.1.4.1.11150.3.4.0.1"</span><span style="color: #0000FF;">,</span>
<span style="color: #008000;">"1.3.6.1.4.1.11.2.17.19.3.4.0.1"</span><span style="color: #0000FF;">,</span>
<span style="color: #008000;">"1.3.6.1.4.1.11150.3.4.0"</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">function</span> <span style="color: #000000;">each</span><span style="color: #0000FF;">(</span><span style="color: #004080;">string</span> <span style="color: #000000;">original</span><span style="color: #0000FF;">)</span>
<span style="color: #004080;">sequence</span> <span style="color: #000000;">sortable</span> <span style="color: #0000FF;">=</span> <span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">split</span><span style="color: #0000FF;">(</span><span style="color: #000000;">original</span><span style="color: #0000FF;">,</span><span style="color: #008000;">'.'</span><span style="color: #0000FF;">),</span><span style="color: #7060A8;">to_number</span><span style="color: #0000FF;">)</span>
<span style="color: #008080;">return</span> <span style="color: #0000FF;">{</span><span style="color: #000000;">sortable</span><span style="color: #0000FF;">,</span><span style="color: #000000;">original</span><span style="color: #0000FF;">}</span>
<span style="color: #008080;">end</span> <span style="color: #008080;">function</span>
<span style="color: #000080;font-style:italic;">-- sort on sortable, then use vslice to extract the originals:</span>
<span style="color: #7060A8;">printf</span><span style="color: #0000FF;">(</span><span style="color: #000000;">1</span><span style="color: #0000FF;">,</span><span style="color: #008000;">"%s\n"</span><span style="color: #0000FF;">,</span><span style="color: #7060A8;">join</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">vslice</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">sort</span><span style="color: #0000FF;">(</span><span style="color: #7060A8;">apply</span><span style="color: #0000FF;">(</span><span style="color: #000000;">strings</span><span style="color: #0000FF;">,</span><span style="color: #000000;">each</span><span style="color: #0000FF;">)),</span><span style="color: #000000;">2</span><span style="color: #0000FF;">),</span><span style="color: #008000;">"\n"</span><span style="color: #0000FF;">))</span>
<!--</syntaxhighlight>-->
{{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
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.3.6.1.4.1.11150.3.4.0.1
</pre>
 
=={{header|Phixmonti}}==
<langsyntaxhighlight Phixmontilang="phixmonti">include ..\Utilitys.pmt
 
( "1.3.6.1.4.1.11.2.17.19.3.4.0.10"
Line 1,235 ⟶ 2,188:
 
sort
 
len for
var i
i get
"" var string
len for
get tostr "." chain string swap chain var string
endfor
drop
string 0 del i set
endfor
 
len for get print nl endfor
</syntaxhighlight>
</lang>
 
=={{header|PicoLisp}}==
<langsyntaxhighlight PicoLisplang="picolisp">(for I
(by
'((L) (mapcar format (split (chop L) ".")))
Line 1,251 ⟶ 2,215:
"1.3.6.1.4.1.11.2.17.19.3.4.0.1"
"1.3.6.1.4.1.11150.3.4.0" ) )
(prinl I) )</langsyntaxhighlight>
{{out}}
<pre>1.3.6.1.4.1.11.2.17.5.2.0.79
Line 1,262 ⟶ 2,226:
=={{header|Prolog}}==
{{works with|SWI Prolog}}
<langsyntaxhighlight lang="prolog">main:-
sort_oid_list(["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",
Line 1,287 ⟶ 2,251:
number_strings([Number|Numbers], [String|Strings]):-
number_string(Number, String),
number_strings(Numbers, Strings).</langsyntaxhighlight>
 
{{out}}
Line 1,302 ⟶ 2,266:
 
We need to split the input and map each part to int otherwise elements gets compared as a string
<syntaxhighlight lang="python">
<lang Python>
data = [
'1.3.6.1.4.1.11.2.17.19.3.4.0.10',
Line 1,314 ⟶ 2,278:
for s in sorted(data, key=lambda x: list(map(int, x.split('.')))):
print(s)
</syntaxhighlight>
</lang>
 
=={{header|Racket}}==
<langsyntaxhighlight lang="racket">#lang racket
(require data/order)
 
Line 1,344 ⟶ 2,308:
"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.3.6.1.4.1.11150.3.4.0.1")))</langsyntaxhighlight>
Tests run with no output, indicating success.
 
Line 1,352 ⟶ 2,316:
The <tt>sort</tt> routine accepts a sort key callback as the first argument. Here we generate a list of integers as the sort key for each OID, which gets sorted lexicographically with numeric comparison by default.
 
<syntaxhighlight lang="raku" perl6line>.say for sort *.comb(/\d+/)».Int, <
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
Line 1,359 ⟶ 2,323:
1.3.6.1.4.1.11.2.17.19.3.4.0.1
1.3.6.1.4.1.11150.3.4.0
>;</langsyntaxhighlight>
 
{{out}}
Line 1,373 ⟶ 2,337:
Alternatively, using the <tt>sprintf</tt>-based approach used by the Perl solution, for comparison ''(input elided)'':
 
<syntaxhighlight lang="raku" perl6line>.say for sort *.split('.').fmt('%08d'), <...>;</langsyntaxhighlight>
 
Or if using a third-party module is acceptable:
 
<syntaxhighlight lang="raku" perl6line>use Sort::Naturally;
 
.say for sort &naturally, <...>;</langsyntaxhighlight>
 
=={{header|REXX}}==
This REXX version supports negative integers in the OID.
<langsyntaxhighlight lang="rexx">/*REXX program performs a sort of OID (Object IDentifiers ◄── used in Network data).*/
call gen /*generate an array (@.) from the OIDs.*/
call show 'before sort ───► ' /*display the @ array before sorting.*/
Line 1,415 ⟶ 2,379:
do k=1 for words(x); _= word(x, k) /*get a number in X. */
if LZ then y= y right(_, w, 0) /*(prepend) leading 0's*/
else y= y (_ + 0 ) /* (elide) " " */
end /*k*/ /*adjust number, append*/
@.j = translate( space(y), ., ' ') /*reconstitute number. */
end /*j*/ /*LZ: Leading Zero(s).*/
return /*── ─ ─ */
/*──────────────────────────────────────────────────────────────────────────────────────*/
show: do a=1 for #; say right("OID number",20) right(a,length(#)) arg(1) @.a; end; return</langsyntaxhighlight>
{{out|output|text=&nbsp; when using the (internal) default input:}}
<pre>
Line 1,441 ⟶ 2,405:
=={{header|Ring}}==
 
<syntaxhighlight lang="ring">
<lang Ring>
 
/*
Line 1,550 ⟶ 2,514:
###-----------------------------------------------------------
 
>;</langsyntaxhighlight>
{{out}}
<pre>
Line 1,565 ⟶ 2,529:
 
=={{header|Ruby}}==
<langsyntaxhighlight lang="ruby">%w[
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
Line 1,574 ⟶ 2,538:
]
.sort_by{|oid| oid.split(".").map(&:to_i)}
.each{|oid| puts oid}</langsyntaxhighlight>
 
{{out}}
Line 1,586 ⟶ 2,550:
</pre>
Or, using the Gem module (which knows about versions):
<langsyntaxhighlight lang="ruby">puts %w[
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
Line 1,593 ⟶ 2,557:
1.3.6.1.4.1.11.2.17.19.3.4.0.1
1.3.6.1.4.1.11150.3.4.0
].sort_by{|oid| Gem::Version.new(oid) }</langsyntaxhighlight>
with identical output.
 
=={{header|Rust}}==
<langsyntaxhighlight Rustlang="rust">fn split(s: &str) -> impl Iterator<Item = u64> + '_ {
s.split('.').map(|x| x.parse().unwrap())
}
Line 1,614 ⟶ 2,578:
println!("{:#?}", oids);
}</langsyntaxhighlight>
{{out}}
<pre>[
Line 1,624 ⟶ 2,588:
"1.3.6.1.4.1.11150.3.4.0.1"
]</pre>
 
=={{header|Sather}}==
<syntaxhighlight lang="sather">class MAIN is
oid_lt (a, b: STR): BOOL is
as ::= a.cursor.split('.');
bs ::= b.cursor.split('.');
loop
na ::= #INT(as.elt!);
nb ::= #INT(bs.elt!);
if na /= nb then return na < nb; end;
end;
return as.size < bs.size;
end;
 
main is
sorter: ARR_SORT_ALG{STR, ARRAY{STR}};
input: ARRAY{STR} := |"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.4",
"1.3.6.1.4.1.11150.3.4.0.1",
"1.3.6.1.4.1.11.2.17.19.3.4.0.1",
"1.3.6.1.4.1.11150.3.4.0"|;
sorted ::= input.copy;
sorter.sort_by(sorted, bind(oid_lt(_, _)));
 
#OUT+"unsorted:\n";
loop #OUT+input.elt! + "\n"; end;
 
#OUT+"sorted:\n";
loop #OUT+sorted.elt! + "\n"; end;
end;
end;</syntaxhighlight>
{{out}}
<pre>
unsorted:
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.4
1.3.6.1.4.1.11150.3.4.0.1
1.3.6.1.4.1.11.2.17.19.3.4.0.1
1.3.6.1.4.1.11150.3.4.0
sorted:
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.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.3.6.1.4.1.11150.3.4.0.1
</pre>
 
=={{header|Sidef}}==
<langsyntaxhighlight lang="ruby">func sort_OIDs(ids) {
ids.sort_by { |id|
id.split('.').map { Num(_) }
Line 1,641 ⟶ 2,654:
)
 
sort_OIDs(OIDs).each { .say }</langsyntaxhighlight>
{{out}}
<pre>
Line 1,654 ⟶ 2,667:
=={{header|Swift}}==
 
<langsyntaxhighlight lang="swift">import Foundation
 
public struct OID {
Line 1,703 ⟶ 2,716:
for id in ids.sorted() {
print(id)
}</langsyntaxhighlight>
 
{{out}}
Line 1,715 ⟶ 2,728:
 
=={{header|Tcl}}==
<syntaxhighlight lang="tcl">
<lang Tcl>
# Example input data:
set oid_list [list \
Line 1,768 ⟶ 2,781:
puts [join $oid_list "."]
}
</syntaxhighlight>
</lang>
 
{{out}}
Line 1,782 ⟶ 2,795:
 
=={{header|VBScript}}==
<langsyntaxhighlight lang="vb">' Sort a list of object identifiers - VBScript
function myCompare(x,y)
dim i,b
Line 1,822 ⟶ 2,835:
"1.3.6.1.4.1.11150.3.4.0")
bubbleSort a
wscript.echo join(a,vbCrlf) </langsyntaxhighlight>
{{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
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.3.6.1.4.1.11150.3.4.0.1
</pre>
 
=={{header|Wren}}==
{{libheader|Wren-fmt}}
{{libheader|Wren-sort}}
<syntaxhighlight lang="wren">import "./fmt" for Fmt
import "./sort" for Sort
 
var oids = [
"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.4",
"1.3.6.1.4.1.11150.3.4.0.1",
"1.3.6.1.4.1.11.2.17.19.3.4.0.1",
"1.3.6.1.4.1.11150.3.4.0"
]
 
oids = oids.map { |oid| Fmt.v("s", 5, oid.split("."), 0, ".", "") }.toList
Sort.quick(oids)
oids = oids.map { |oid| oid.replace(" ", "") }.toList
System.print(oids.join("\n"))</syntaxhighlight>
 
{{out}}
<pre>
Line 1,837 ⟶ 2,880:
 
Basically, blow apart each line into a list of numbers and sort that.
<langsyntaxhighlight lang="zkl">fcn sortOIDS(oids){ // oids is not modified, a new list is created
// pad each oid with a terminal (-1) so zip won't short cut
oids=oids.pump(List(),fcn(oid){ (oid + ".-1").split(".").apply("toInt") });
Line 1,848 ⟶ 2,891:
});
oids.pump(List,fcn(list){ list[0,-1].concat(".") }) // back to strings
}</langsyntaxhighlight>
<langsyntaxhighlight lang="zkl">oids:=List(
"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",
Line 1,857 ⟶ 2,900:
"1.3.6.1.4.1.11150.3.4.0");
oids=sortOIDS(oids);
oids.pump(Console.println); // print one OID per line</langsyntaxhighlight>
{{out}}
<pre>
PureFox
9,476

edits

Retrieved from "https://rosettacode.org/wiki/Special:MobileDiff/268946...353080"