Sstrhsrtj

Is there a simple way to sort a comma separated list alphabetically in LaTeX? I tried to write a macro (sortlist{World, Hello} → "Hello, World") using the l3sort documentation example but it completely failed.

ExplSyntaxOn

def@sortlist{}

newcommand{sortlist}[1]{

    clist_set:Nn l_foo_clist {#1}

    clist_sort:Nn l_foo_clist{

      int_compare:nNnTF { ##1 } > { ##2 }

      { sort_return_swapped: }

      { sort_return_same: }

    }

    def@sortlist{l_foo_clist}

}

ExplSyntaxOff

Is there something like str_compare to make a string comparison or can l3sort actually only be used for numerical values?

Edit:
How to process a comma separated list? wasn't really helpful for me or rather I wasn't able to solve my problem thereby.

This seems to work, with no packages. EDITED to solve the upper/lower-case problem.

EDIT: Resolved problem when a comparison ran out of letters prior to resolving the order, for example, wash, washer.

See ADDENDUM for handling (after a fashion) diacritics.

documentclass{article}

deflistterminator{;}

makeatletter

newcommandalphabubblesort[1]{defpresorted{}defsortedlist{}%

  sortlist#1,listterminator,relax}

defsortlist#1#2,#3#4,#5relax{%

  iflistterminator#3#4relax%

    edefsortedlist{sortedlist#1#2}%

  else

    ifnumthelccode`#1<thelccode`#3relax%

      edefsortedlist{sortedlistpresorted#1#2, }%

      expandafterdefexpandaftersvfirstexpandafter{presorted#3#4}%

      defpresorted{}%

      expandaftersortlistsvfirst,#5relax%

    else%

      ifnum`#1=`#3relax%

        ifxrelax#2relax%

          edefsortedlist{sortedlistpresorted#1#2, }%

          expandafterdefexpandaftersvfirstexpandafter{presorted#3#4}%

          defpresorted{}%

          expandaftersortlistsvfirst,#5relax%          

        else%

          ifxrelax#4relax%

            edefsortedlist{sortedlistpresorted#3#4, }%

            expandafterdefexpandaftersvfirstexpandafter{presorted#1#2}%

            defpresorted{}%

            expandaftersortlistsvfirst,#5relax%

          else        

            g@addto@macropresorted{#1}%

            sortlist#2,#4,#5relax%

          fi%

        fi%

      else%

        lettmpsortedlist%

        defsortedlist{}%

        expandafterdefexpandaftersvfirstexpandafter{presorted#3#4}%

        expandafterdefexpandaftersvsecondexpandafter{presorted#1#2}%

        defpresorted{}%

        expandafterexpandafterexpandafterexpandafterexpandafter%

        expandafterexpandaftersortlistexpandafterexpandafter%

        expandaftertmpexpandaftersvfirstexpandafter,svsecond,#5relax%

      fi%

    fi%

  fi%

}

makeatother

begin{document}

alphabubblesort{book, boot, boat,toad,attic,wish,wash,wasn't,Cat ,Xylophone}

sortedlistpar



alphabubblesort{book, washer, boot, boat,toad,attic,wish,wash,wasn't,Cat ,Xylophone}

sortedlistpar

end{document}

ADDENDUM

Here's a version that can handle diacritics, in the sense that they do not break the algorithm. This was accomplished by changing the edefs in the above algorithm to appropriately expanded defs.

However, diacritics here will always precede all non-diacritic letters in the sort. While maybe not the ideal behavior, it may still be useful.

documentclass{article}

deflistterminator{;}

makeatletter

newcommandalphabubblesort[1]{defpresorted{}defsortedlist{}%

  sortlist#1,listterminator,relax}

defsortlist#1#2,#3#4,#5relax{%

  iflistterminator#3#4relax%

    expandafterdefexpandaftersortedlistexpandafter{sortedlist#1#2}%

  else

    ifnumthelccode`#1<thelccode`#3relax%

      expandafterexpandafterexpandafterdefexpandafterexpandafter%

      expandaftersortedlistexpandafterexpandafterexpandafter{%

      expandaftersortedlistpresorted#1#2, }%

      expandafterdefexpandaftersvfirstexpandafter{presorted#3#4}%

      defpresorted{}%

      expandaftersortlistsvfirst,#5relax%

    else%

      ifnum`#1=`#3relax%

        ifxrelax#2relax%

          expandafterexpandafterexpandafterdefexpandafterexpandafter%

          expandaftersortedlistexpandafterexpandafterexpandafter{%

          expandaftersortedlistpresorted#1#2, }%

          expandafterdefexpandaftersvfirstexpandafter{presorted#3#4}%

          defpresorted{}%

          expandaftersortlistsvfirst,#5relax%          

        else%

          ifxrelax#4relax%

            expandafterexpandafterexpandafterdefexpandafterexpandafter%

            expandaftersortedlistexpandafterexpandafterexpandafter{%

            expandaftersortedlistpresorted#3#4, }%

            expandafterdefexpandaftersvfirstexpandafter{presorted#1#2}%

            defpresorted{}%

            expandaftersortlistsvfirst,#5relax%

          else        

            g@addto@macropresorted{#1}%

            sortlist#2,#4,#5relax%

          fi%

        fi%

      else%

        lettmpsortedlist%

        defsortedlist{}%

        expandafterdefexpandaftersvfirstexpandafter{presorted#3#4}%

        expandafterdefexpandaftersvsecondexpandafter{presorted#1#2}%

        defpresorted{}%

        expandafterexpandafterexpandafterexpandafterexpandafter%

        expandafterexpandaftersortlistexpandafterexpandafter%

        expandaftertmpexpandaftersvfirstexpandafter,svsecond,#5relax%

      fi%

    fi%

  fi%

}

makeatother

begin{document}

alphabubblesort{book, washer, w"asher, boot, boat,toad,attic,wish,wash,wasn't,

  Cat, Xylophone, w"ash, edifice, 'edifice, w"asherei}

sortedlistpar

end{document}

The algorithm was based on my bubblesort macro here: Using LaTeX to compact a list of numbers

How about Lua?

defsortlist#1{%

  directlua{%

    local t = { #1 }

    table.sort(t)

    tex.sprint(table.concat(t,", "))

  }%

}



sortlist{"World", "Hello"}



bye

Addendum: One of the really useful advantages of this approach is that it is fully expandable, meaning that after

edefx{sortlist{"World", "Hello"}}

the macro x will contain the sorted list.

When using ConTeXt MKIV you can use the internal settings parser to convert a comma separated list to a Lua table. This has the advantage that you don't need to handle quotes yourself. It also respects grouping with commas inside.

defsortlist#1{%

  ctxlua{%

    local t = utilities.parsers.settings_to_array("luaescapestring{#1}")

    table.sort(t)

    tex.sprint(table.concat(t,", "))

  }%

}



starttext

sortlist{World, Hello, {Entry, with, commas}, "Quotes"}

stoptext

You can safely compare strings consisting of ASCII characters; words with accented characters will not work.

documentclass{article}

usepackage{expl3,l3sort,xparse}



ExplSyntaxOn

prg_new_conditional:Nnn john_string_if_before:nn { p,T,F,TF }

 {% I hope the LaTeX3 police won't catch me

  int_compare:nTF { pdftex_strcmp:D { #1 } { #2 } < 0 }

   {

    prg_return_true:

   }

   {

    prg_return_false:

   }

 }



NewDocumentCommand{sortlist}{smm}

 {

  IfBooleanTF{#1}

   {

    clist_set:No l__john_sortlist_data_clist { #2 }

   }

   {

    clist_set:Nn l__john_sortlist_data_clist { #2 }

   }

  john_sortlist:N l__john_sortlist_data_clist

  clist_set_eq:NN #3 l__john_sortlist_data_clist

 }

clist_new:N l__john_sortlist_data_clist



cs_new_protected:Nn john_sortlist:N

 {

  clist_sort:Nn #1

   {

    john_string_if_before:nnTF { ##1 } { ##2 }

     {

      sort_ordered:

     }

     {

      sort_reversed:

     }

   }

 }

ExplSyntaxOff



begin{document}



sortlist{World,Hello}{mylistA}



mylistA



newcommand{mylistB}{duck,cat,dog}



sortlist*{mylistB}{mylistC}



mylistB ${}to{}$mylistC



end{document}

If you want that the comparison is case insensitive, change the definition of john_sortlist:N into

cs_new_protected:Nn john_sortlist:N

 {

  clist_sort:Nn #1

   {

    john_string_if_before:nnTF { str_lower_case:n {##1} } { str_lower_case:n {##2} }

     {

      sort_ordered:

     }

     {

      sort_reversed:

     }

   }

 }

You can try this

This is taken over from https://tex.stackexchange.com/a/273084/4686 (code 5)

% ------------------------------------------------------------------

% Expandable routine to sort strings, based on a QuickSort algorithm 

% and using pdfstrcmp.

% ------------------------------------------------------------------



% USAGE

% -----



% if using XeTeX:

% edefmysortedlist {QSfull{mylist}}, or explicit QSfull {foo, bar, zoo} 





% if using PDFLaTeX: (and inputenc for accented letters)

% begingroup

%    subdueutfviiienc

%    globaledefmysortedlist {QSfull{mylist}}

% endgroup





documentclass{article}



ifdefinedXeTeXinterchartoks

   letpdfstrcmpstrcmp

   usepackage{fontspec}

else

   usepackage[T1]{fontenc}

   usepackage[utf8]{inputenc}% for PDFLaTeX

   makeatletter

   % this subdueutfviiienc allows é, à, etc... to survive as is to edef's.

   newcommand*subdueutfviiienc {% to be used in a group

    count@="C2

    loop

        lccode`~count@

        lowercase{def~####1{noexpand~string####1}}%

        ifnumcount@<"E0

        advancecount@@ne

    repeat

    loop

        lccode`~count@

        lowercase{def~####1####2{noexpand~string####1string####2}}%

        ifnumcount@<"F0

        advancecount@@ne

    repeat

    loop

        lccode`~count@

        lowercase{def~####1####2####3{noexpand~string####1string####2string####3}}%

        ifnumcount@<"F4

        advancecount@@ne

    repeat

   }makeatother

   % (if inputenc is used with 8bit encoding another approach would be needed)

fi







% CODE TAKEN FROM https://tex.stackexchange.com/a/273084/4686 (code 5)

% -------------------------------------------------------------------



makeatletter

longdefxintdothis #1#2xintorthat #3{fi #1}%

letxintorthat @firstofone

%

% use some (improbable) tokens as delimiters

catcode`! 3

catcode`? 3

catcode`; 3

%

% first we check if empty list (else qsfull@finish will not find a comma)

% we apply f-expansion to the argument to allow it to be a macro.

%

defQSfull #1{expandafterqsfull@aromannumeral-`0#1,!,?}%

%

% first check if input has only blanks, or is empty

defqsfull@a #1{ifx,#1xintdothisqsfull@afi

                 ifx!#1xintdothisqsfull@abortfi

                 xintorthat{qsfull@start #1}}%

defqsfull@abort #1?{}%

%

defqsfull@start {expandafterqsfull@finishromannumeral0qsfull@b,}%

defqsfull@finish ,#1{#1}% remove initial ,<space>



defqsfull@b ,#1#2,#3{ifx?#3xintdothisqsfull@emptylistfi

                       ifx!#3xintdothisqsfull@singletonfi

                       xintorthat qsfull@separate@a {}{}#1#2;#3}%

defqsfull@emptylist    #1?{}%

defqsfull@singleton    #1#2#3;!,?{, #3}%

%

defqsfull@separate@a  #1#2#3;#4#5,%

% first pass, remove blanks in passing.

% no need to be extra efficient for that.

{%

    ifx,#4expandafterqsfull@valueisblankfi

    ifx!#4expandafterqsfull@separate@donefi

    if1pdfstrcmp{#4#5}{#3}%

         expandafterqsfull@separate@a@appendtogreater

    elseexpandafterqsfull@separate@a@appendtosmaller

    fi

          #4#5?{#1}{#2}#3;%

}%

defqsfull@valueisblank ifx#1fi,#2?#3#4#5;{qsfull@separate@a {#3}{#4}#5;#2,}%

defqsfull@separate@a@appendtogreater #1?#2{qsfull@separate@a {#2, #1}}%

%

defqsfull@separate@a@appendtosmaller #1?#2#3{qsfull@separate@a {#2}{#3, #1}}%

%

defqsfull@separate@doneif#1fi #2?#3#4#5;?%

{%

    qsfull@c #4,!,?, #5qsfull@c #3,!,?%

}%

% Now that the first pass is done, there are no more blank items.

% In particular here.

defqsfull@c ,#1#2,#3{ifx?#3xintdothisqsfull@emptylistfi

                       ifx!#3xintdothisqsfull@singletonfi

                       xintorthat qsfull@separate {}{}#1#2;#3}%

%

defqsfull@separate  #1#2#3;#4#5,% blanks have already been filtered out.

{%

    ifx!#4expandafterqsfull@separate@donefi

    if1pdfstrcmp{#4#5}{#3}%

         expandafterqsfull@separate@a@appendtogreater

    elseexpandafterqsfull@separate@a@appendtosmaller

    fi

          #4#5?{#1}{#2}#3;%

}%

defqsfull@separate@appendtogreater #1?#2{qsfull@separate {#2, #1}}%

defqsfull@separate@appendtosmaller #1?#2#3{qsfull@separate {#2}{#3, #1}}%

%

%

catcode`! 12

catcode`? 12

catcode`; 12

makeatother





begin{document}



defmylist{book, washer, wäsher, boot, boat,toad,attic,wish,wash,wasn't,

  Cat, Xylophone, wäsh, edifice, édifice, wäsherei}



% use either a macro mylist or explicit list as QSfull argument.

ifdefinedXeTeXinterchartoks

   edefmysortedlist{QSfull{mylist}}

else

   {subdueutfviiiencglobaledefmysortedlist{QSfull{mylist}}}%

fi



mylistpar



medskip



becomes (notice how whitespaces are normalized in the process):



medskip



mysortedlist



medskip

For some reason due to the comparison being done by verb|pdfstrcmp| the é

comes after a-z.



% check

typeout{meaningmylist}



typeout{meaningmysortedlist}



end{document}

Here in the log output, with PDFLaTeX:

macro:->book, washer, wäsher, boot, boat,toad,attic,wish,wash,wasn't, Cat, Xyl

ophone, wäsh, edifice, édifice, wäsherei

macro:->Cat, Xylophone, attic, boat, book, boot, edifice, toad, wash, washer, w

asn't, wish, wäsh, wäsher, wäsherei, édifice

and using XeLaTeX (which does not cut lines the same way):

macro:->book, washer, wäsher, boot, boat,toad,attic,wish,wash,wasn't, Cat, Xylo

phone, wäsh, edifice, édifice, wäsherei

macro:->Cat, Xylophone, attic, boat, book, boot, edifice, toad, wash, washer, w

asn't, wish, wäsh, wäsher, wäsherei, édifice

The console output (again XeLaTeX) is still different, lines not cut:

macro:->book, washer, wäsher, boot, boat,toad,attic,wish,wash,wasn't, Cat, Xylophone, wäsh, edifice, édifice, wäsherei

macro:->Cat, Xylophone, attic, boat, book, boot, edifice, toad, wash, washer, wasn't, wish, wäsh, wäsher, wäsherei, édifice