Uebungen  Exercices

11. Problemsammlung zur Musterentsprechung
(Mustererkennen, musterkonformes Abarbeiten)
 Collection de problèmes concernant les correspondances et patrons (reconnaître les patrons, travailler conformement aux patrons)

Die Gliederung dieses Kurses folgt in groben Zügen dem Buch von Nancy Blachman: A Practical Approach.... Hinweis: Kapitel 11 lesen!
 L'articulation de ce cours correspond à peu près à celle du livre de Nancy Blachman: A Practical Approach.... 
Indication: Lire le chapitre 11.

Run mit WIN+Mathematica Version 5.2
 Testé avec Mathematica version 5.2+WIN

WIR94/98/99/2000/2007 // Copyright Rolf Wirz

Aufgabe 1    Problème 1

Schreibe eine Funktion "geometrisches Mittel", die das 
geometrische Mittel einer Liste von Zahlen ausgibt.
Ecris une fonction "moyenne géométrique", qui donne la moyenne géométrique d'une liste de nombres.

Z.B. das  geometrische Mittel von {a,b,c,d,e} ist (a b c d e)^(1/5).
  P.ex. la moyenne géométrique de {a,b,c,d,e} est  (a b c d e)^(1/5).

Clear[geometrMittel];
geometrMittel[{x__}]:= Times[x]^(1/Length[{x}])

geometrMittel[{1,1,1,1,1}]

geometrMittel[{2,16,8,4,32}]

geometrMittel[{2,3,5}]

geometrMittel[{2,3,5}] // N

Aufgabe 2    Problème 2

Schreibe eine eigene Version der "Join-Funktion".
 Ecris ta propre version de la fonction "Join".

"Join" fuegt zwei Listen hintereinander im Gegensatz zur Mengenvereinigung, wo mehrfach vorkommende Elemente nur einmal aufgefuehrt werden.
  "Join" rassemble deux listes l'une après l'autre. Dans la réunion des ensembles par contre les éléments doubles, triples etc. n'apparaissent qu'une seule fois.

Clear[joinFkt];
joinFkt[{x__},{}]:= {x};
joinFkt[{},{x__}]:= {x};
joinFkt[{x__},{y__}]:= Flatten[{{x},{y}}]

Ausprobieren:    Essayer:

joinFkt[{a,b,c,d},{e,f,g}]

joinFkt[{a,b,c,d},{a,e,b,f,g}]

joinFkt[{a,b,c,d},{}]

joinFkt[{},{}]

Was ist passiert? Erweitere die Definition sinngemäss!
  Que s'est-il passé? Elargis la définition d'une façon sensée!

Aufgabe 3    Problème 3

Baue eine Funktion  "Fold" wie unten beschrieben
 Construis une fonction "Fold" comme il est décris ci-dessous.

a) Implementiere wie nachstehend folgt. Beantworte dann die nachstehenden Fragen b), c), d) und vergleiche mit den implementierten Funktionen "Fold" resp. "FoldList".
  "Implement" comme il suit. Réponds aux questions suivantes b), c), d) et compare avec les fonctions "implémentées" "Fold" resp. "FoldList".

Clear[falte];
falte::usage = "falte[f, basis, liste] ergibt  
			--donne  f[...[f[f[basis,x1]x2],...xn] 
			wobei --étant  list = {x1,x2,...,xn}";
falte[f_,basis_,{}]:=basis;
falte[f_,basis_,{x1_,xrest___}]:=
		falte[f,f[basis,x1],{xrest}];

b) Was macht  "falte[Plus,0,liste]"? Z.B. liste={a,b,c}.
  Que fait "falte[Plus,0,liste]"? P.ex. liste={a,b,c}.

falte[Plus,0,{a,b,c}]

falte[Plus,0,{1,2,3,4}]

falte[Plus,5,{1,2,3,4}]

c) Was macht  "falte[Max,-Infinity,liste]"? Z.B. liste={a,b,c}.
  Que fait "falte[Max,-Infinity,liste]"? P.ex. liste={a,b,c}.

falte[Max,-Infinity,{a,b,c}]

falte[Max,-Infinity,{6,8,3}]

falte[Max,9,{6,8,3}]

d) Vergleiche mit "Fold" und "FoldList":
  Compare avec "Fold" et "FoldList":

??Fold

??FoldList

Aufgabe 4    Problème 4

Schreibe die APL-Funktion "Deal" resp. "?" in Mathematica:
 Ecris la fonction APL "Deal" resp. "?" dans Mathematica:

"L ? R" in APL wählt (streicht) aus dem "Range[r]" pseudo-zufällig L Zahlen aus, ohne sie in R zu ersetzen. 
  "L ? R" dans APL choisit (biffe) dans le "Range[r]" d'une façon pseudo-aléatoire L nombres, sans les remplacer dans R.

a) Was ist "Range" - Wie erzeuge ich die "Zufallszahlen"?
  Qu'est "Range" - Comment génerér les "nombres aléatoires"?

??Range

Range[14]

??Random

b) Die Beschreibung der Funktion "deal" in Mathematica:
  La description de la fonction "deal" dans Mathematica:

RemoveAll[deal];
deal::usage="deal[n,r] streicht zufällig n Integers 
              aus der Liste  Range[r] ohne Ersetzung.
              -- biffe de façon aléatoire n Integers
              dans la liste Range[r] sans les 
              remplacer."

c) Hier eine mögliche Variante:
  Voici une variante possible:

Clear[deal];
deal[0,r_] :=Range[r]; 
deal[n_,r_]:=Sort[Rest[RotateLeft[deal[n-1,r],
						Random[Integer,{1,r}]]]]

d) Ausprobieren:
  Essaier

deal[2,6]

e) Erklärungen:
  Explications:

??Rest

??RotateLeft

RotateLeft[{a,b,c},11]

??Sort

Aufgabe 5    Problème 5

Zu Funktionen, die als Argument eine variable Zahl von Listen aufnehmen:
Quant aux fonctions qui acceptent comme argument un nombre variable de listes:

Das Muster "x___List" als Argument in einer Funktion lässt eine variable Zahl von Listen zu. Wie kann man auf einen Schlag alle Längen einer Anzahl beteiligter Listen finden? Schreibe eine Funktion dafür!
  Le patron "x___List" comme argument dans une fonction permet un nombre variable de listes. Comment peut-on, d'un coup, trouver toutes les longueurs d'un nombre de listes faisant partie du problème? Ecris une fonction pour cela!

Clear[listenLaengen];
listenLaengen[x___List]:=Map[Length, {x}]

Ausprobieren:    Essayer:

listenLaengen[{1,2,3}, {1,2,3,4,5}, {1,1,1,1}, 
				{a,b,c,d,e,f,g}]

Aufgabe 6    Problème 6

Lauflängencodierung in Listen (Häufigkeitszählungen)
  Comper des fréquences dans les listes

Konstruiere eine kurze Mathematica-Funktion, die die Häufigkeit der Elemente einer Liste zählt. Die Funktion "laufCod" soll eine Liste von Paaren {Listenelement, absolute Häufigkeit} ausgeben Beispiel: 
liste = {e,b,a,b,e,c,c,d,e,a,a,d,u};
laufCod[liste] soll das Resultat {{a, 3}, {b, 2}, {c, 2}, {d, 2}, {e, 3}, {u, 1}} ergeben. Die Funktion "laufDeCod" soll aus dem Output von "laufCod" wieder die ursprüngliche Liste machen. 
  Construis une fonction de Mathematica courte qui compte la fréquence des éléments d'une liste. La fonction "laufCod" doit sortir une liste de paires {élément de liste, fréquence absolue}. Exemple: 
liste = {e,b,a,b,e,c,c,d,e,a,a,d,u};
laufCod[liste]doit donner le résultat
{{a, 3}, {b, 2}, {c, 2}, {d, 2}, {e, 3}, {u, 1}}. La fonction "laufDeCod" doit transformer l'output de "laufCod" de nouveau dans la liste d'origine.

a) laufCod

laufCod[liste_List]:=Transpose[{Union[liste],
				Table[Count[liste,Part[Union[liste]
				,n]], {n,Length[Union[liste]]}]}]

(Hat Schweiss gekostet!) Aber jetzt ausprobieren:
  (Cela nous a fait transpirer!) Mais maintenant on essaie:

RemoveAll[liste];
liste = {1,1,2,2,2,3,3,3,3};
output = laufCod[liste]

liste = {e,b,a,b,e,c,c,d,e,a,a,d,u};
output = laufCod[liste]

a) laufDeCod

laufDeCod[output_]:= If[MatrixQ[output],
			 output/.{x_,n_}:> Flatten[
			 				Table[x,{n}]],									Print["Bitte Matrix eingeben"],
			Print["Bitte Matrix eingeben --
					S.v.p. entrer la matrice"]]

laufDeCod[{{1,2},{3,5},{4,3}}]

laufDeCod[{{a,3},{b,5},{c,2},{d,4}}]

c) Eine andere Variante für "laufCod" mit Ersetzungsregeln 
    (funktioniert nur für eine Liste von Integers)
  Une autre variante pour "laufCod" avec des règles de remplacement 
    (ne fonctionne que pour une liste d'Integers)

RemoveAll[f];
f[liste_List]:=Module[{i},
i=0;
a=liste;
a//.{y___,x_,x_,z___}:> 
{y,x,++i b,x,z}//.{y___,x_Integer,w_Integer,z___}:> 
{y,x,d, c,w,z}/. {x___}:>{c, x, d}//. 
{x___,y___ b,z___}:>{x,z}//. {x___,b,z___}:>{x,z}//.
{y___,c,x__,d,z___}:> {y,{x},z}
];
laufCod1[liste_List]:={Map[First,f[liste]],
               			Map[Length,f[liste]]}

f[{1,1,1,2,2,2,2,2,3,3,3,3,4,5,5}]

laufCod1[{1,1,1,2,2,2,2,2,3,3,3,3,4,5,5}]

laufCod1[{0,0,0,1,1,2,2,2,3,3,3,3,4,4,4,5,5,6,6,6}]

Was ist los?
  Que se passe-t-il?

laufCod1[{a,a,a,1,b,b,b,2,2,2,3,3,3,3,4,4,4,5}]

d) Noch eine andere Variante: 
  Encore une autre variante:

d) Noch eine andere Variante für "laufCod" mit Hilfe anonymer 
    Funktionen  (vgl. Kap. 12):
  Encore une autre variante pour "laufCod" à l'aide de fonctions anonymes (comparer chap. 12):

Attributes[mal]={Flat};
mal[{elem_,m_},{elem_,n_}]:=mal[{elem,m+n}];
laufCod2[liste_List]:= List @@ mal @@({#,1}& /@ 
						liste)

laufCod2[{1,1,1,2,2,2,2,2,3,3,3,3,4,5,5}]

Wie arbeitet dieses Programm?
  Comment ce programme travaille-t-il?

# steht für "anonyme Variable", & für "anonyme Funktion", /@ für "Map".
Durchlaufen wird die Liste.
  # signifie "variable anonyme", & signifie "fonction anonyme", /@ signifie "Map". La liste est parcourue.

out1=({#,1}& /@ {1,1,1,2,2,2,2,2,3,3,3,3,4,5,5})

@@ steht für "Apply".
  @@ signifie "Apply".

out2=mal @@out1

??List

out3=List @@ out2

Probiere eigene Varianten aus!
  Essaie des variantes à toi!

Testgelände:
 Terrain de test:

"Putzmaschine" einsetzen
 Employer la "machine de nettoyage"

(* Old Form: Remove["Global`@*"] *)

Remove["Global`*"]