Sort an outline at every level: Difference between revisions

=={{header|AutoHotkey}}==

<lang AutoHotkey>Sort_an_outline(data, reverse:=""){

;-----------------------

; get Delim, Error Check

for i, line in StrSplit(data, "`n", "`r")

if !Delim

RegExMatch(line, "^\h+", Delim)

else if RegExMatch(RegExReplace(line, "^(" Delim ")*"), "^\h+")

return "Error @ " line

;-----------------------

; ascending lexical sort

ancestor:=[], tree:= [], result:=""

for i, line in StrSplit(data, "`n", "`r"){

name := StrSplit(line, delim?delim:"`t")

n := name.count()

son := name[n]

if (n>rank) && father

ancestor.push(father)

loop % rank-n

ancestor.pop()

for i, father in ancestor

Lineage .= father . delim

output .= Lineage son "`n"

rank:=n, father:=son, Lineage:=""

}

Sort, output

for i, line in StrSplit(output, "`n", "`r")

name := StrSplit(line, delim)

, result .= indent(name.count()-1, delim) . name[name.count()] "`n"

if !reverse

return Trim(result, "`n")

;-----------------------

; descending lexical sort

ancestor:=[], Lineage:="", result:=""

Sort, output, R

for i, line in StrSplit(output, "`n", "`r"){

name := StrSplit(line, delim)

if !ancestor[Lineage]

loop % name.count()

result .= indent(A_Index-1, delim) . name[A_Index] "`n"

else if (StrSplit(Lineage, ",")[name.count()] <> name[name.count()])

result .= indent(name.count()-1, delim) . name[name.count()] "`n"

Lineage := ""

loop % name.count()-1

Lineage .= (Lineage ? "," : "") . name[A_Index]

, ancestor[Lineage] := true

}

return result

}

indent(n, delim){

Loop, % n

result.=delim

return result

}</lang>

Examples: "Example of Data_2"<lang AutoHotkey>Data_2 =

(

zeta

gamma

mu

lambda

kappa

delta

beta

alpha

theta

iota

epsilon

)

MsgBox % Sort_an_outline(Data_2)

MsgBox % Sort_an_outline(Data_2, 1)

return</lang>

Output: tabulated for ease of reading, actual output is text only, Error check returns first line with inconsistent delimiter!<pre>

======================================================================================================

Data_1, 4-Space |Output 1 ||Data_2, tab |Output 2 |Output 2, Reverse

======================================================================================================

zeta |alpha ||zeta |alpha |zeta

beta | epsilon || gamma | epsilon | gamma

gamma | iota || mu | iota | mu

lambda | theta || lambda | theta | lambda

kappa |zeta || kappa |zeta | kappa

mu | beta || delta | beta | delta

delta | delta || beta | delta | beta

alpha | gamma ||alpha | gamma |alpha

theta | kappa || theta | kappa | theta

iota | lambda || iota | lambda | iota

epsilon | mu || epsilon | mu | epsilon

======================================================================================================

======================================================================================================

inconsistent_1 ||inconsistent_2

=================================

alpha ||zeta

epsilon || beta

iota || gamma

theta || lambda

zeta || kappa

beta || mu

delta || delta

gamma ||alpha

kappa || theta

lambda || iota

mu || epsilon

=================================

Error @ iota ||Error @ gamma

=================================

</pre>