LEDA has numerous further operations that lists can be modified with. Two lists can be concatenated and a list can be split into two partial lists in front of or behind a certain element. A list can be reversed and randomly permuted. There is an operation that applies a function defined before to every element of a list. Of course, a list can also be searched for a certain element.

The following program demonstrates these operations.

#include <LEDA/list.h>
#include <LEDA/string.h>
#include <iostream>

using leda::list;
using leda::list_item;
using leda::string;
using std::cout;

// print a list together with its name and a newline at the end
inline void list_print(const string& name, const list<int>& L) {
  cout << name << ": " << L << "\n";
}

inline void inc(int& x) { x++;}

int main() 
{

  list<int> L, M;

  for(int i=0; i < 10; i++) {
    L.push(i);
    M.append(i);
  }
  list_print("L",L); list_print("M",M);

  L.conc(M, leda::after);
  list_print("L",L); list_print("M",M);

  list_item it = L.search(5);

  list<int> A, B;

  L.split(it, A, B, leda::before);
  list_print("L",L); list_print("A",A); list_print("B",B);

  B.permute();
  list_print("B",B); 

  it = B.first();
  cout << "Item it contains " << B.contents(it) << std::endl;
  B.reverse_items();
  list_print("B",B);
  cout << "Item it still contains " << B.contents(it) << std::endl;

  B.reverse();
  list_print("B",B);
  cout << "Item it now contains " << B.contents(it) << std::endl;

  B.apply(inc);
  list_print("B",B);
}

The output of the program is

L:  9 8 7 6 5 4 3 2 1 0
M:  0 1 2 3 4 5 6 7 8 9
L:  9 8 7 6 5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9
M:
L:
A:  9 8 7 6
B:  5 4 3 2 1 0 0 1 2 3 4 5 6 7 8 9
B:  2 9 4 0 1 2 5 0 1 8 5 3 6 4 3 7
Item it contains 2
B:  7 3 4 6 3 5 8 1 0 5 2 1 0 4 9 2
Item it still contains 2
B:  2 9 4 0 1 2 5 0 1 8 5 3 6 4 3 7
Item it now contains 7
B:  3 10 5 1 2 3 6 1 2 9 6 4 7 5 4 8

By the operation

L.conc(M);

all containers of the list M are appended at the end of the list L. M is emptied in this process!

it = L.search(x);

searches in a list for an element with value x. The method returns an item referring to the first container that contains the search value; if the search value is not contained in the list, it returns nil.

With the method

L.split(it, A, B , position);

a list can be split at a certain item it into two partial lists A and B. The parameter values leda::before and leda::after specify whether the separation takes place in front of or behind the corresponding container, respectively. That means, it specifies whether this container will belong to the second or to the first partial list, respectively, after the splitting. If the parameter is left out, the list is split in front of this container. The original list is emptied when splitting!

L.permute();

places the containers in a random order. Every order has the same probability.

L.reverse_items();

reverses the linking information in the containers. In doing so, no contents are changed. Attributes of the items remain unmodified. This method modifies the order in which the list is iterated over.

In contrast,

L.reverse();

really swaps the contents of the containers: The first contents are swapped with the last ones etc. The above program clarifies this.

	Warning
	The name reverse_items() is misleading. An item is a reference to a container. Such a reference is not touched at all, it remains totally unmodified. Rather, the result of a call of succ() and pred() is modified. The item returned by the latter methods now refers to its former predecessor and successor container, respectively. The method should therefore better be called reverse_order().

A call of

L.apply(f);

applies a function f() to every element of the list. f() must have return type void; its argument must be passed to it by reference. In the above program apply() is used to increment every number stored in the list.

There are yet some other, less important operations that modify lists; also, the above methods can partly be invoked with other or additional arguments. All this can be looked up on the corresponding manual page.

As an application of some of these functions we simulate the German national lottery game “6 from 49”, where a player must give 6 tips for 6 (different) numbers to be drawn out of the numbers 1 to 49. The user may enter 6 numbers. The program then draws 6 numbers randomly from the admissible 49 numbers and calculates how many “straight tips” the user has guessed.

#include <LEDA/list.h>
#include <iostream>

using leda::list;
using leda::list_item;
using std::cout;

int main() 
{
  std::cout << "Please enter 6 different numbers from 1 to 49:\n";

  list<int> Guess;
  while(Guess.size() != 6) {
    int next_guess;
    std::cin >> next_guess;
    if(Guess.search(next_guess)) {
      cout << next_guess << " is already in your list of numbers. ";
      cout << "Please try again.\n";
    }
    else
      Guess.push(next_guess);
  }


  list<int> Number;

  for(int i = 1; i <= 49; i++) 
    Number.push(i);

  Number.permute();

  list_item it = Number.first();
  for(int i = 1; i <= 6; i++) it = Number.succ(it);
  
  list<int> Choose, Rest;

  Number.split(it, Choose, Rest);

  int num_correct_guesses = 0;
  int my_guess;

  forall(my_guess,Guess)
    if(Choose.search(my_guess))
      num_correct_guesses++;

  std::cout << num_correct_guesses << " of your numbers were chosen.\n";
}

A sample run looks like this:

Please enter 6 different numbers from 1 to 49:
15
19
19
19 is already in your list of numbers. Please try again.
20
4
23
41
1 of your numbers were chosen.

We store the 6 numbers to be entered in a list Guess. For every new number, we search for this number in the list first. If we already find it therein, we output a warning message. We accept only numbers that are not yet contained in the list.^[16]

We store the numbers from 1 to 49 in a list Number, permute this list, and split it in front of the 7th container. Thereby, we receive a random drawing of 6 numbers in the list Choose.

In a final step, we search for every number of Guess in Choose and count the number of coincidences.