Lists

- XLogo library of procedures

xlogo

These procedures can be copied and pasted into the Editor window as usual. Most do not produce any graphics. To test type Test. The results will show in the History window.

Download library of list procedures.

Flatten
Reduce a list which may contain other lists to a single list of items. eg Flatten [ a b [ c [ d e ] [f] [ [g h] ] i ] ] will result [ a b c d e f g h i ].

To Flatten :myList
  # flatten list to single depth
  If Empty? :myList [Output [] ]
  If List? First :myList [
    Output (Se Flatten First :myList Flatten ButFirst :myList)]
  Output FPut First :myList Flatten ButFirst :myList
End

To Test
  # test procedure
  Make "myList [ a b [ c [ d e ] [f] [ [g h] ] i ] ]
  Print (Sentence "Flattened :myList "is Flatten :myList
End

Highest (also see Lowest)
Return the highest value within the list.

To Highest :myList
  # return highest value
  LocalMake "Highest First :myList
  ForEach "item :myList [
    If Before? :Highest :item [ Make "Highest :item ] ]
  Output :Highest
End

To Test
  # test procedure
  Make "myList [1 7 -11 3 8 5]
  Print (Sentence "[Highest item of] :myList "is Highest :myList
End

Lowest (also see Highest)
Return the lowest value within the list.

To Lowest :myList
  # return lowest value
  LocalMake "Lowest First :myList
  ForEach "item :myList [
    If Before? :item :Lowest [Make "Lowest :item] ]
  Output :Lowest
End

To Test
  # test procedure
  Make "myList [1 7 -11 3 8 5]
  Print (Sentence "[Lowest item of] :myList "is Lowest :myList
End

Mean
Return the mean or average value of a list of values.

To Mean :myList
  # return average value
  LocalMake "Total 0
  ForEach "Item :myList [
    LocalMake "Total :Total + :Item ]
  Output :Total / Count :myList
End

To Test
  # test procedure
  Make "myList [1 7 -11 3 8 5]
  Print (Sentence "[Mean value of] :myList "is Mean :myList
End

Rotate Left (also see Rotate Right)
Return list with items rotated one place to the left.

To RoL :myList
  # rotate list items left
  LocalMake "FirstItem First :myList
  Output AddItem ButFirst :myList Count :myList :FirstItem
End

To Test
  # test procedure
  Make "myList [1 2 3 4 5]
  Print (Sentence "Rotate :myList [left is] RoL :myList
End

Rotate Right (also see Rotate Left)
Return list with items rotated one place to the right.

To RoR :myList
  # rotate list items right
  LocalMake "LastItem Last :myList
  Output AddItem ButLast :myList 1 :LastItem
End

To Test
  # test procedure
  Make "myList [1 2 3 4 5]
  Print (Sentence "Rotate :myList [right is] RoR :myList
End

Shuffle (also see Sort)
This procedure shuffles a list.

To Shuffle :myList
  # randomly shuffle list order
  LocalMake "Shuffled [ ]
  Repeat Count :myList [
    LocalMake "Select Pick :myList
    Make "myList Remove :Select :myList
    LocalMake "Shuffled LPut :Select :Shuffled]
  Output :Shuffled
End

Sort (also see Shuffle)
This procedure sorts a list of items into alphabetical or numeric order. It uses the bubble sort method. There are more efficient methods if the list is long.

To Sort :myList
  # sort list into alphabetical order
  LocalMake "Num Count :myList
  Repeat (:Num-1) [
    For (List "J 1 (:Num-1)) [
      LocalMake "FirstItem Item :J :myList
      LocalMake "SecondItem Item (:J+1) :myList
      If Before? :SecondItem :FirstItem [     #swop the two items
        Make "myList SetItem :myList :J :SecondItem
        Make "myList SetItem :myList (:J+1) :FirstItem ] ] ]
  Output :myList
End

Take (Pick and Remove)
Warning This is a bad example of code writing and serves as an example of how not to do it.
Similar to primitive Pick, except that the chosen item is removed from the list. Note that all instances are removed, in the same way as primitive Remove.

To Take :myLst
  # return one item taken away randomly from list
  LocalMake "ThisItem Pick Thing :myLst
  Make :myLst Remove :ThisItem Thing :myLst
  Output :ThisItem
End

To Test
  # test procedure
  Make "myList [1 2 3 4 5]
  Repeat Count :myList [
    Print (Sentence :myList "take (Take "myList) "leaves :myList) ]
End

xlogo
XLogo