Das Programmier-Spiel: nette Übungsaufgaben für zwischendurch

Hallo inflames2k,

Zitat:

Um Exceptionhandling hab ich mich nun aber nicht gekümmert. War auch wenn ich mich nicht verlesen hab kein Teil der Aufgabe. :)

nö, aber es war verlangt, dass Objekte nicht mehrfach vorkommen können. Das hast du zwar bei Add berücksichtigt, aber an anderen Stellen nicht.


Hallo edsplash,

wo ich eh gerade einen Beitrag schreibe:

Zitat:

Man sollte dabei sofern möglich vermeiden auf .NET Klassen wie Dictionary<T>, HashSet<T> zurück zu greifen.

Da hast du ja was schönes erreicht. inflames2k hat List <T>genommen (und wenn auch das nicht erlaubt gewesen wäre, dann vermutlich Array, irgendworauf wird man ja sinnvollerweise aufbauen). Dadurch ist deine Bedingung formal erfüllt. Aber was hast du erreicht? Der Code ist auch nicht länger oder komplizierter als wenn man Dictionary<> verwendet hätte, aber um Größenordnungen weniger performant.

herbivore

Hallo inflames2k,

dein Code trifft es immer noch nicht. Du musst ja auf jeden Fall auch value prüfen. Außerdem muss es erlaubt sein, einem Objekt das bereits zugeordnete Objekt erneut zuzuordnen. Überlegt dir nochmal genau, welche Fälle alle auftreten können.

BTW: warum hast du die Klasse denn für konkrete Typen implementiert? Statt class IMapClass : IMap<String, Object> wäre Map<TLeft, TRight> : IMap<TLeft, TRight> deutlich sinnvoller gewesen (mal ganz abgesehen davon, dass Klassennamen keinen Präfix haben sollten, erst recht nicht den Präfix I).

herbivore

Hallo herbivore

Zitat von herbivore:

Da hast du ja was schönes erreicht. inflames2k hat List <T>genommen (und wenn auch das nicht erlaubt gewesen wäre, dann vermutlich Array, irgendworauf wird man ja sinnvollerweise aufbauen). Dadurch ist deine Bedingung formal erfüllt. Aber was hast du erreicht? Der Code ist auch nicht länger oder komplizierter als wenn man Dictionary<> verwendet hätte, aber um Größenordnungen weniger performant.

[offtopic]
Hehe, ich hatte gedacht, jemand würde es ohne Dictionary ähnlich performant hinkriegen ;) Mit dem Dictionary wird der Code allerdings weniger komplex, vorallem wenn man zwei davon verwendet -> Dictionary<TLeft, TRight> und Dictionar<TRight, TLeft>.
[/offtopic]

Hallo inflames2k

Deine Lösung scheint korrekt zu sein!

Gut, eine Aufgabe gibt es sobald mir etwas eingefallen ist. - Hatte zwar gerade einen Gedanken aber den müsst ich erstmal selbst für mich zusammen fassen.

Esseidenn dir fällt eine gute Aufgabe ein Schamese. :-) - Dann darfst du sie auch gern stellen.

Vermieden werden sollten Dictionary und HashSet, nicht alle Generics, aufgrund der Funktionalitäten die vom Dictionary Beispielsweise schon gegeben sind.

Wobei das nun auch unrelevant wäre. - Wie herbivore sagte, performant ist das nicht.

Na, dann darf ich ja wohl nicht mitmachen

Hallo,

ich glaub das müsste es bringen:

C#-Code:

using System; using System.Collections.Generic; namespace TestApp {   class Program   {     static double Calc(string input)     { // die folgende Zeile wiede4r einkommentieren um das Verfahren zu sehen //    Console.WriteLine(input);       input = input.Trim();       if(input.Length > 0)       {         int open = input.LastIndexOf('(');         if(open >= 0)         {           int match = input.IndexOf(')',open);           if(match > open)           {             double partRes = Calc(input.Substring(open+1, match-open-1));             if(partRes != double.NaN)             {               return Calc(input.Remove(open, match-open+1).Insert(open, partRes.ToString()));             }           }         }         else         {           if(char.IsDigit(input[input.Length-1]))           {             int pos = input.IndexOf('+');             if(pos > 0)             {               return Calc(input.Substring(0,pos)) + Calc(input.Substring(pos+1));             }             pos = input.IndexOf('-');             if((pos > 0) && (Char.IsDigit(input[pos-1]))) // <<< hier das IsDigit eingebaut             {               return Calc(input.Substring(0,pos)) - Calc(input.Substring(pos+1));             }             pos = input.IndexOf('*');             if(pos > 0)             {               return Calc(input.Substring(0,pos)) * Calc(input.Substring(pos+1));             }             pos = input.IndexOf('/');             if(pos > 0)             {               return Calc(input.Substring(0,pos)) / Calc(input.Substring(pos+1));             }             double result;             if(double.TryParse(input, out result))             {               return result;             }           }         }       }       return double.NaN;     }     public static void Main(string[] args)     {       do       {         Console.WriteLine("Term eingeben:");         double result = Calc(Console.ReadLine());         Console.WriteLine("Ergebnis: " + result.ToString());         Console.WriteLine();         Console.WriteLine("Leertaste zum Beenden, andere Taste zum Fortfahren");       }while(Console.ReadKey().Key != ConsoleKey.Spacebar);     }   } }

Edit: erlaubt sind nur die runden Klammern "()". Bei Fehleingaben müsste immer NaN zurückgegeben werden.

EDIT 2: Der Code hat nicht funktioniert, wenn innerhalb eines Klammerpaars eine negative Zahl herauskam. Ich habe die korrigierte Stelle oben markiert (Prüfung auf IsDigit vor einem '-')

Gruß, MarsStein

Hallo,

Zitat von JAck30lena:

das da: if(partRes != double.NaN)ist immer true.

Wenn Du den von Dir genannten Term eingibst, und zusätzlich innerhalb des if mal eine Konsolenausgabe machst, siehst Du, dass Du damit fasch liegst.

Trotzdem hast Du natürlich recht: da ist noch ein Fehler drin. Kümmere mich bald darum -> keine Zeit jetzt.

Gruß, MarsStein

Hallo Jack30lena,

du hast natürlich recht ;) habs jetzt auf double.IsNaN umgestellt, und das Problem mit "-(" dadurch behoben, dass es durch "-1*(" ersetzt wird:

C#-Code:

using System; namespace TestApp {   class Program   {     static double Calc(string input)     {       // die folgende Zeile wiede4r einkommentieren um das Verfahren zu sehen       //    Console.WriteLine(input);       input = input.Trim();       if (input.Length > 0)       {         int open = input.LastIndexOf('(');         if (open >= 0)         {           int match = input.IndexOf(')', open);           if (match > open)           {             double partRes = Calc(input.Substring(open + 1, match - open - 1));             // partRes = double.NaN;  <<< die böse Zeile (siehe Folgebeiträge)             if (!double.IsNaN(partRes))             {               return Calc(input.Remove(open, match - open + 1).Insert(open, partRes.ToString()));             }           }         }         else if (char.IsDigit(input[input.Length - 1]))         {           int pos = input.IndexOf('+');           if (pos > 0)           {             return Calc(input.Substring(0, pos)) + Calc(input.Substring(pos + 1));           }           pos = input.IndexOf('-');           if ((pos > 0) && (Char.IsDigit(input[pos - 1]))) // <<< hier das IsDigit eingebaut           {             return Calc(input.Substring(0, pos)) - Calc(input.Substring(pos + 1));           }           pos = input.IndexOf('*');           if (pos > 0)           {             return Calc(input.Substring(0, pos)) * Calc(input.Substring(pos + 1));           }           pos = input.IndexOf('/');           if (pos > 0)           {             return Calc(input.Substring(0, pos)) / Calc(input.Substring(pos + 1));           }           double result;           if (double.TryParse(input, out result))           {             return result;           }         }       }       return double.NaN;     }     static double Parse(String input) {       return Calc(input.Replace("-(", "-1*("));     }     public static void Main(string[] args)     {       do       {         Console.WriteLine("Term eingeben:");         double result = Parse(Console.ReadLine());         Console.WriteLine("Ergebnis: " + result.ToString());         Console.WriteLine();         Console.WriteLine("Leertaste zum Beenden, andere Taste zum Fortfahren");       } while (Console.ReadKey().Key != ConsoleKey.Spacebar);     }   } }

sonst noch irgenwelche Fehler?

Gruß, MarsStein

Ich hab aber doch noch einen Fehler gefunden:

Gib mal (12+1)*2 ein... --> Heraus kommen sollte 26, aber es kommt NaN raus...

Gruß, Christian.

//EDIT Irgendie kommt bei mir immer wenn eine Klammer drin ist n. def. raus...

Hallo,

in der Tat ist es genau so wie Cat schrieb: Da ist mir 'ne Zeile vom Testen stehengeblieben. Ich editiere das gleich oben im Code und mache die Stelle dort auch kenntlich. Danach sollte aber alles laufen ;)
Die nächste Aufgabe gibt's dann heut abend.

Gruß, MarsStein

Hallo,

Zitat von JAck30lena:

wunderschöne lösung. respekt :-)

danke dafür und für den Hinweis wegen NaN
Rekursion mal von hinten nach vorn und von innen nach außen

Dann mal die nächste Aufgabe:
erstellt ein Programm, das eine vom Benutzer wählbare Anzahl von Kugeln nach dem Prinzip des  Galtonbretts auf einzelne Fächer verteilt. Die Anzahl der Stufen des Bretts soll ebenfalls vom Benutzer gewählt werden können (denkt daran, daß es ein Fach mehr als Stufen gibt).
Die dabei erzeugte Verteilung soll in einem Balkendiagramm (1 Balken je Fach) sinnvoll skaliert* ausgegeben werden. Die Balken sollen mit der entsprechenden Trefferzahl beschriftet werden.
Die Aufgabe ist mit der Ausgabe von waagerechten Balken auf der Konsole erfüllt.

Gruß, MarsStein

*Edit: Sinnvoll skaliert bezieht sich auf sinnvolle Eingabebereiche (die nicht geprüft werden müssen), bei denen die Anzahl der Kugeln viel größer als die Anzahl der Fächer ist, und die maximale Anzahl der Fächer im Bereich der Zeilenzahl der Konsole liegt.
Ich erwarte aber, daß die maximale Länge der Balken mit steigender Anzahl an Fächern mitwächst, die Kurve also halbwegs mitskaliert wird.

Hallo talla,

da die Skalierung ausdrücklich gefordert war, kann ich Deine Lösung leider so nicht durchgehen lassen
Diese eine Mutiplikation wirst Du schon noch einbauen müssen, wenn Du die nächste Aufgabe stellen möchtest...
Ich habe auch einen Grund dafür: Wenn die Balken an der Zeilenzahl skaliert werden, sind die Kurven von der Form her vergleichbarer, und die Gleichverteilung bei verschiedenen Eingaben läßt sich besser erkennen. Als Beispiel mal die Ausgabe meiner eigenen Lösung, ich denke das veranschaulicht das etwas:

Galtonbrett Simulation

Stufen: 8
Kugeln: 10000
  35 -
 297 -
1134 ----
2126 --------
2701 ---------
2252 --------
1088 ----
 321 --
  46 -

Stufen: 12
Kugeln: 100000
   20 -
  264 -
 1627 -
 5466 ----
12097 -------
19259 ------------
22551 -------------
19199 ------------
12198 --------
 5361 ----
 1630 -
  299 -
   29 -

Stufen: 16
Kugeln: 1000000
    20 -
   228 -
  1835 -
  8443 -
 27608 ---
 66411 ------
122927 -----------
174475 ----------------
196019 -----------------
175201 ----------------
121609 -----------
 66909 ------
 27857 ---
  8379 -
  1802 -
   255 -
    22 -

Gruß, MarsStein

Hallo talla,

Über den SInn und Unsinn der Skalierung kann man sicherlich streiten, vor allem hast Du recht mit Deinen Aussagen:

Zitat:

Gerade in deinem letzten Beispiel sieht man das gut. Sowohl das erste Fach mit 20, als auch das 4. mit 8443 Kugeln, werden mit jeweils nur einer Einheit dargestellt.

und

Zitat:

sieht man zwar die entstehende Binomialverteilung, aber die Kurve stimmt vorne und hinten nicht in der Darstellung

Und ich hnbe recht , wenn ich behaupte, daß die Kurven wenn sie skaliert sind vom optischen Eindruck her leichter untereinander zu vergleichen sind.

Die Aufgabe ist jedenfalls mit der erweiterten Ausgabefunktion gelöst und Du bist dran

Gruß, MarsStein

Ich gehe zwar davon aus, dass du eigentlich eine Lösung in F# haben wolltest, da es aber ja auch Scala für die .Net Plattform gibt hab ich es mal in Scala gemacht:

Code: 1: 2: 3: 4: 5: 6: 7: 8: 9: 10: 11: 12: 13: 14: 15: 16: 17: object Main { /** * @param args the command line arguments */ def main(args: Array[String]): Unit = { println(Add(1,2,3,4)) val add5 = Add.somethingNice(2)(3) _ println(add5(2)(3)) } } object Add { def apply(a: Int, b: Int, c: Int, d: Int) = somethingNice(a)(b)(c)(d) def somethingNice(a: Int)(b: Int)(c: Int)(d: Int) = a + b + c + d }

Okay, ich wäre nie auf die Idee gekommen, dass C# currying kann ;-)

Hier mal die Lösung:

C#-Code:

private static void Main(string[] args)         {             Func<int, int, int, int, int> Add = (a, b, c, d) => a + b + c + d;             Console.WriteLine(Add(1,2,3,4));             var tmp = Add.SomethingNice()(1)(2);             Console.WriteLine(tmp(3)(4));         }         public static Func<T1, Func<T2, Func<T3, Func<T4, T5>>>>             SomethingNice<T1,T2,T3,T4,T5> (this Func<T1,T2,T3,T4,T5> f)         {             return a => b => c => d => f(a, b, c, d);         }

Zitat von talla:

Durch die Antwort ist ja praktisch schon verraten das es natürlich in C# geht - ich hätte neben der Lösung aber auch noch den Namen der Technik ( aber bitte beides zusammen, nur die Nennung des Namens würde die Lösung dann durch suchen im Inet trivial machen)

Das Vorgehen nennt sich "Currying". Funktioniert in C# folgendermaßen:

C#-Code:

using System; public static class Program {     public static Func<A,Func<B,Func<C,Func<D,R>>>> SomethingNice<A,B,C,D,R>(this Func<A,B,C,D,R> f)     {         return a => b => c => d => f(a,b,c,d);     }     public static void Main(string[] args)     {         Func<int,int,int,int,int> add = (a,b,c,d) => a + b + c + d;         var erg = add(1,2,3,4);         var erg2 = add.SomethingNice()(1)(2)(3)(4);         var tmp = add.SomethingNice()(1)(3);         var erg3 = tmp(4)(2);     } }

EDIT: GRML! Zu langsam...

Gruß,
dN!3L

Hallo Corpsegrinder,

das war ja mal eine kleine, schöne Aufgabe. Hier meine Lösung. Damit daraus eine Erweiterungsmethode wird, müsste man wohl nur ein this an den Beginn der Parameterliste von FoldLeft setzen. Hier habe ich momentan nur C# 2.0, weshalb ich das nicht testen konnte.

C#-Code:

public delegate T FoldFunc <T> (T accumulatedValue, T currentValue); public static T FoldLeft <T> (List <T> list, T startValue, FoldFunc <T> foldFunc) {    T accumulatedValue = startValue;    foreach (T currentValue in list) {       accumulatedValue = foldFunc (accumulatedValue, currentValue);    }    return accumulatedValue; }

herbivore

Alles klar herbivore, funktioniert super. Dann stell mal die nächste Aufgabe ;-)

Hallo zusammen,

hier noch die Klasse Tree mit Parent-Property, für alle, die - was ich sehr begrüßen würde - ganz ohne Stack<> auskommen wollen (s. Aufgabenbeschreibung im vorigen Beitrag).

C#-Code:

using System; using System.Collections.Generic; using System.Diagnostics; using IUntypedEnumerable = System.Collections.IEnumerable; using IUntypedEnumerator = System.Collections.IEnumerator; public class Tree <T> : IEnumerable <T> {    public Tree (T value)    {       _value = value;    }    private T        _value;    private Tree <T> _left;    private Tree <T> _right;    private Tree <T> _parent;    public T Value    {       get { return _value; }       set { _value = value; }    }    public Tree <T> Left    {       get { return _left; }       set {          if (_left == value) {             return;          }          if (value == null) {             Debug.Assert (_left != null);             _left._parent = null;             _left = null;             return;          }          Debug.Assert (value != null);          if (value._parent != null) {             if (value._parent._left == value) {                value._parent._left = null;             } else {                Debug.Assert (value._parent._right == value);                value._parent._right = null;             }          }          _left = value;          value._parent = this;       }    }    public Tree <T> Right    {       get { return _right; }       set {          if (_right == value) {             return;          }          if (value == null) {             Debug.Assert (_right != null);             _right._parent = null;             _right = null;             return;          }          Debug.Assert (value != null);          if (value._parent != null) {             if (value._parent._left == value) {                value._parent._left = null;             } else {                Debug.Assert (value._parent._right == value);                value._parent._right = null;             }          }          _right = value;          value._parent = this;       }    }    public Tree <T> Parent    {       get { return _parent; }    }    public IEnumerator <T> GetEnumerator ()    {       return new Enumerator (this);    }    IUntypedEnumerator IUntypedEnumerable.GetEnumerator ()    {       return GetEnumerator ();    }    private class Enumerator : IEnumerator <T>    {       //...    } }

herbivore