Archiv verlassen und diese Seite im Standarddesign anzeigen : Wie programmierst du?
Hallo zusammen,
Ich habe ein Problem : ich bin ein lausiger Programmierer.
Ich glaube aber auch schon das Problem gefunden zu haben, denn es ist beim Programmieren genauso wie in der Mathematik, dass mir einfach die gewisse Logik fehlt, um das Problem zu sehen, bzw es dann zu loesen.
Wie kann ich dieses Problem loesen? Ich hatte es auch schon immer in der Schule, als wir damals Delphi und Python gelernt haben (nur oberflaechlich), es mir die Lust genommen hat und ich danach nicht mehr ernsthaft programmiert habe (nur so ein bisschen html-zusammengeschustere).
Nach einem kleinen Exkurs in php/mysql in den letzten paar Wochen, würde ich es jedoch nochmal gerne versuchen.
Allerdings bin ich mir noch nicht ganz so sicher, was fuer eine Sprache ich lernen will und wie ich das anstelle.
Ich dachte da an Ruby, eine sehr moderne Sprache, mit der man echt viel anstellen kann, da sie sehr maechtig ist und man nur aus ein paar Zeilen Code etwas basteln kann. Das Standardwerk, um zu lernen ist wohl : "Programmierung in Ruby - Der Leitfaden der Pragmatischen Programmierer". Kennt das jemand? Behandelt das ein paar Grundzuege der Programmierung, ist das gut fuer jmd "wie mich" ?
Eignet sich Ruby ueberhaupt fuer mein "Vorhaben", Programmieren zu lernen, bzw mir ein bisschen Logik zu erarbeiten?
Auf der anderen Seite steht Python, eine Sprache deren Syntax aus Einrueckungen besteht. Scheint mir sehr foerderlich fuer das erlernen eines sauberen Programmierstiles. Was meint ihr?
Meine dritte Option geht in die komplett andere Richtung : C / JAVA , frei nach dem Motto, "wenn schon, denn schon".
Auf der einen Seite gut, weil mir da programmiertechnisch keine Grenzen gesetzt waeren und ich mich durch unzaehlige libaries immer tiefer einarbeiten wuerde.
Auf der anderen, bin ich mir echt unsicher, ob so eine Sprache echt das richtige fuer nen "Quereinsteiger" ist.
Also daher meine Frage: habt ihr alt-eingesessenen Programmierhasen einen Tipp fuer mich? a) im Bezug auf die Programmiersprache (Ich weiß, dass es wieder sone Glaubensfrage ist, aber vllt wisst ihr grade im Hinblick auf meine Unfaehigkeit in Sachen Logik etwas) und b) wie "lernt" ihr programmieren, habt ihr vllt auch so eine Schwaeche und was unternehmt ihr dagegen?
Ich bin auf eure Antworten echt gespannt.
mfg
j.
Finde ich gut, dass du nicht aufgibst ;)
Ruby kenn ich persönlich nicht, Python hab ich mir mal kurz angeschaut (fand ich recht gut) und Java find ich eigentlich recht gut. Schlussendlich denke ich, dass es gar nicht mal so eine grosse Rolle spielt, welche der Sprachen du auswählst, sondern eher, dass du dir im voraus ein gutes Buch zulegst und dieses durcharbeitest.
Und noch so ein Tipp: Programmieren besteht - wie gesagt - aus zwei Teilen: Einerseits der logischen Planung dahinter und andererseits der Synthax. Zweitere kannst du im Zweifelsfall nachschlagen - ersteres eher weniger. Darum: Wenn du programmieren willst, unbedingt zuerst genau überlegen, was du wie lösen möchtest, danach die Funktionsgerüste schreiben, danach diese Funktionsprototypen ausführlich dokumentieren und erst dann den Code schreiben. Ist zwar etwas umständlich - garantiert aber weniger Fehler und höhere Erfolgschancen.
MfG Bischi
mehlvogel
23-11-2007, 06:46
Wie bischi sagte, kommt erst der konzeptuelle Teil beim programmieren. Das kann man sich nicht anlesen, sondern beruht mehr oder weniger auf Erfahrung. Wenn man Probleme damit hat, heißt es üben. Das heißt in vielen Fällen gar nicht, dass man es konkret implementieren muss, sondern einfach ein paar Gedankenspiele macht. In dieser Hinsicht ist es schon ähnlich wie Mathematik.
Zur Sprache, da wirst du bei 10 Programmieren mindestens 20 Meinungen hören. Ich würde dir für den Anfang wahrscheinlich zu einer "Hochsprache" wie Java raten. Die Syntax und die Sprache selbst sind nicht so frei wie bspw. Python (wenn es z.B. um Typing o.ä. geht). Dadurch werden mMn aber die Konzepte klarer. Wenn du dich in Java halbwegs sicher bewegst, kannst du dann immernoch zurück auf eine der Skriptsprachen zurückschwenken. Auf der anderen Seite setzt Java speziell auf Objektorientierung, ein Programmierparadigma, dass vorher auch verstanden sein sollte - einfach damit man einen Einblick hat was dort passiert. Auch hier ist Erfahrung wieder ein wichtiger Punkt.
Prinzipiell noch ein paar Sachen: Fang mit kleinen Dingern an, das heißt insbesondere: Hände weg von einer GUI! GUIs sind komplex, nicht nur in ihrer Benutzung sondern - und das ist viel wichtiger - in ihrer (internen) Struktur. Ohne die halbwegs zu verstehen, wird man sehr schnell frustriert sein. Falls du wirklich mit einer objektorientierten Sprache anfängst. Sobald du etwas Sprachsyntax intus hast, sobald du das Konzept etwas verinnerlicht hast - beschäftige dich mit Design Patterns. Diese sind enorm wichtig für Programme die größer werden, oder auch um Lösungen zu finden. Hier schließt sich der Kreis zum ersten Punkt dann wieder.
Uh, das ist aber viel für den Anfang. Ich würde mir einfach mal "Java ist eine Insel" schnappen und das für den Anfang durcharbeiten. Design Patterns kommen später, viel später ...
Hallo,
vielen Dank fuer euren ersten Meinungen (hoffentlich folgen noch weitere ;))!
Wie genau sieht bei euch die logische Planung aus, "schreibt" ihr das Programm praktisch schonmal in Worten auf Papier, oder wie soll ich mir das vorstellen?
Ich habe mich grade durch div. Tutorials gewälzt und bin zum Entschluss gekommen, dass ich mich mal an Ruby versuche. Wirkt sehr spannend.
Wie gesagt, das beste Buch soll wohl dieses hier sein : *klick* (http://home.vr-web.de/juergen.katins/ruby/buch/index.html).
Die Einleitung hat mich auch erstmal sehr beeindruckt, vorallem vom Kapitel fuer totale Neueinsteiger hab ich einiges erwartet. Allerdings habe ich es grade zuende gelesen, und muss zugeben, dass ich zwar vieles verstanden habe, es aber irgendwie nicht richtig zuordnen kann, weil ich nicht weiß, wofuer Arrays Hashes, Iteratoren, regulaere Ausdruecke (etc) zu gebrauchen sind. Das wird leider irgendwie unter den Tisch fallen gelassen.
Vllt kommt das spaeter ja noch, aber darauf will ich mich nicht unbeding verlassen. Koennt ihr mir evtl nen kurzes(!!) Paper empfehlen, welches vllt ein paar Grundlagen der Programmierung behandelt? Ein Buch extra dafuer zu kaufen finde ich sinnlos, und jedes Element bei Wikipedia zu suchen zu aufwendig. Werds aber wohl machen, wenn ihh nichts kennt :D
Also, wie gesagt: vielen dank nochmal fuer die Tipps, meine Motivation ist grad wieder enorm groß!
ciao
mehlvogel
23-11-2007, 15:37
Das Aufschreiben ist für den Anfang sicher ein wichtiger Schritt. Überleg dir was dein Programm machen soll. Dies beinhaltet schonmal grundsätzlich Dinge wie "Was ist die Eingabe/Ausgabe?". Es hat mal jemand gesagt "If you can't write it down, you can't code it". Eine informelle Beschreibung kann man dann umwandeln, indem man sich überlegt was die einzelnen Schritte sind und diese nochmal ausformuliert. Später geht das sicher im Kopf und geht auch immer automatischer.
Das Buch scheint auf den ersten Blick eher eine Referenz für die Sprache Ruby sein, also etwas das dir die Syntax von Ruby erläutert und genau das was du schon gemerkt hast passiert. Das Buch ist nicht dazu gedacht damit programmieren zu lernen - also die grundlegenden Konzepte zu vermitteln - sondern jemanden der programmieren kann, Ruby zu zeigen.
Bei uns an der Uni hält die Fachschaft Informatik immer vor dem Semester einen Vorkurs für die Studenten, die noch keine oder sehr wenig Programmiererfahrung haben ab. Vielleicht helfen dir die Folien dazu - dort steht zwar auch etwas organisatorisches drin, aber das kannst du sicher rausfiltern ;)
http://www.d120.de/fachschaft/aktivitaeten/vorkurs/materialien.html
Es ist allerdings auf Java bezogen. Die Grundlegenden Konzepte wie Schleifen, Arrays etc sollten aber in jeder Sprache gleich sein, von daher könnte dir das eine Hilfe sein. Die Ruby spezifische Syntax für Schleifen etc kannst du dann aus dem Buch von oben ziehen.
Hallo zusammen,
Ich habe ein Problem : ich bin ein lausiger Programmierer.
Ich glaube aber auch schon das Problem gefunden zu haben, denn es ist beim Programmieren genauso wie in der Mathematik, dass mir einfach die gewisse Logik fehlt, um das Problem zu sehen, bzw es dann zu loesen.
(Oberstufen-)Mathematik und Programmieren haben sehr viel gemeinsam: bevor man richtig loslegt, muss man sich einen (möglichst effektiven) Lösungsweg überlegen, dann hat man schon die halbe Miete.
Eine immer noch gültige Regel: je mehr man erledigt, desto schneller kann man die Algorithmen aneinanderstricken.
Zu Beginn steht man dann auch oft wie ein Ochse vorm Berg, bei einiger Übung geht's dann ratz-fatz.
Allerdings bin ich mir noch nicht ganz so sicher, was fuer eine Sprache ich lernen will und wie ich das anstelle.
Im Prinzip ist das Hose wie Jacke, kommt eher auf das Problem an.
Da du schon einige Erfahrung mit HTML hast, bekommst du mit Javascript am schnellsten Erfolgserlebnisse.
Da hast du schon mal einen Einstieg in objektorientierter Sprache.
Nur mit Dateieingaben ist es Essig, aber da kann man ja auf php ausweichen. Ist dann auch kein Problem mehr :)
Als weiteres wäre vielleicht Java nicht schlecht, wenn die JRE bloss nicht immer so eine viertel- bis halbe Minute brauchen würde, um aus dem Quark zu kommen. Java zwingt dich, objektorientiert zu denken, wenn's mal etwas mehr (als Hello World) sein soll.
Zur Motivation:
Tja, was brauchst du dringend?
CD- oder Buchverwaltung?
SW zur Hausgeldabrechnung?
Adress- und Geburtstagsliste deiner Kumpels mit schicken Suchfunktionen?
Oder ein schickes Spielchen, was sonst nur auf Windows läuft? :)
Mastermind ist als Start nicht schlecht.
Gibt es eigentlich schon einen Java-Promillerechner für dein Handy? :)
(J2ME hat sehr übersichtliche Bibliotheken). Den Algo könntest du dir von gamecraft.de fischen (Javascript-Version).
so long,
BlueJay
Moin,
es wurde schon darüber geschrieben, dass am Anfang eines Programms immer das Nachdenken darüber steht:
- was ist eigentlich das zu lösende Problem?
- welche Daten sollen verarbeitet werden?
- was soll als Ergebnis rauskommen?
Es hilft dabei IMHO enorm, wenn man sich in dieser Phase formaler Mechanismen bedient, also z. B. Flussdiagramme, Programmablaufpläne, UML (naja, das vielleicht nicht ganz am Anfang ;-) zeichnet. Ob auf Papier, am PC oder im Kopf ist eigentlich egal. Es geht erstmal darum, aus einer umgangssprachlichen Aufgabe einen (im Übrigen völlig programmiersprachenunabhängigen) Algorithmus zu entwickeln, der später in einer Programmiersprache umgesetzt wird. Dazu wurde auch schon angemerkt, dass das viel mit Mathe (insbesondere mit Aussagen-Logik) zu tun hat.
Der 2. wichtige Tipp, der hier schon kam: Fange einfach an und motiviere Dich mit Dich interessierenden Problemen. Ein Beispiel: Im letzten Linux-Magazin war im Perl-Snapshot beschrieben, wie man zu einem beliebigen Datum den Wochentag im Kopf (oder eben in Perl) ausrechnen kann. Nimm Dir den beschriebenen Algorithmus (und höre vor dem Kapitel "Probe aufs Exempel" auf zu lesen) und setze ihn in ein Flussdiagramm um. Da hast Du alles drin: Eingabe, Verarbeitung, Ausgabe und es wird nicht unnötig kompliziert, weil es einfach ein "Straight Forward"-Algorithmus ist.
3. Die Programmiersprache ist unwichtig. Ich behaupte sogar, dass es besser ist, wenn Du Dich nicht zu tief mit einer einzigen Sprache beschäftigst. Löse Deine Aufgabe mit allem, was Dir unter die Hände kommt, lass eine Sprache erstmal fallen, wenn Du nicht weiterkommst, probiere es später noch mal mit ihr bei einem anderen Problem. Versuche nicht, sofort die verzwicktesten Konstrukte einer Sprache einzusetzen, sondern versuche, einfache Probleme einfach zu lösen. Du hast später noch genug Zeit, Dich über Deine ersten Gehversuche lustig zu machen ;-)
Es gibt keine "ideale" Programmiersprache. Jede hat ihre Stärken und Schwächen, jede hat ihre Lobby und Hasser. Finde selbst raus, welche Sprachen zu Dir passen, indem Du sie ausprobierst. So wirst Du IMHO am ehesten dahinter kommen, wie "Programmieren" funktioniert. Und je mehr Sprachen Du kennst (nicht "kannst" - das kommt beim Programmieren), desto eher wird Dir bei einem Problem auffallen, mit welcher Sprache Du es am besten lösen kannst.
Jan
EDIT: Fang mit verbreiteten Sprachen an, damit findest Du schneller Hilfe in Mailinglisten, Foren usw. - Brainfuck oder Whitespace z. B. würde ich eher nach hinten schieben ;-)
Hallo,
Mensch, da ist man mal das Wochenende nicht da und dann sowas ;)
@mehlvogel: Schade, hatte von dem Buch einiges gehoert, was mich hatte hoffen lassen ;)!
naja, ich fange leider erst im September an zu studieren und habe bis dato noch nichts von den Vorkursen an meiner FH gehoert.Vielen Dank fuer den Link, werd ihn mal analysieren!
@bluejay : mhää. javascript mag ich irgendwie ueberhaupt nicht.. arbeite ab und an mit runtergeladenen scripts (anpassen etc) und die Sprache sagt mir jarnischt zu!Spezielle SW brauch ich jetzt grad nicht, aber ich schaetze, dass ich schon was finden werde, wenn ich dann soweit bin ;)
Erste Erfolgserlebnisse verbuche ich grade mit Ruby, und dem Buch "Das Einsteigerseminar". Das Buch ist ansich nicht soo toll, aber es hat am Ende jedes Kapitels immer nette Zusammenfassungen und Tests, an denen ich mich dann beweisen kann!
Java will ich def. auch in Angriff nehmen, weil ich es mir im WI Studium eh ueber den Weg laeuft.. so koennt ich schonmal vorarbeiten.
@jan61: danke fuer die tipps. werde mal versuchen das Linuxmagazin online zu finden.Ansonsten findet man so eine Aufgabe sicherlich auch woanders. Hoert sich aber auf jedenfall interessant an.
Sicherlich gibt es die ideale Sprache nicht. Deshalb habe ich oben auch versucht meine Frage so vorsichtig wie moeglich zu formulieren. Allerdings habe ich gehofft, dass hier jmd Erfahrung mit besonders leichten, grundlegenden Sprachen hat (qbasic, zB :S ;)).
Das haette sich nun aber jetzt erstmal erledigt. Ich werde erstmal mein Rubybuch durcharbeiten und dann mal schauen, ob ich mir nochn 2. zulege, oder dann nurnoch mit ner online Referenz arbeite. Vllt sagt mir die Sprache dann auch schon garnicht mehr zu, hhihi (:
Also, vielen Dank erstmal soweit. Bin natuerlich weiterhin dankbar fuer weitere Antworten und Tipps.
Bis zum ersten, richtigen Programmierproblem ;)
ciao
ps: programmiert hier eigentlich keiner ruby? (ohne extra danach gesucht zu haben)
//edit:Linux-Magazin (http://www.linux-magazin.de/heft_abo/ausgaben/2007/12/datumsarithmetik) - ist das der komplette Artikel, oder nur ne Kurzfassung?
ps: programmiert hier eigentlich keiner ruby? (ohne extra danach gesucht zu haben)
Steht noch auf der Liste der 13487 Dinge, die ich vor meinem Tod noch machen will :D
MfG Bischi
OK, ich bin fertig.
Nicht, dass es so schwer war, wollte die beiden Bücher nur zu Ende lesen, bevor ich anfange, etwas zu programmieren und immer wieder irgendwelche Sachen zu benutzen, die ich nicht kann ;)
->
########################################
# Tag - Wochentag Rechner #
########################################
print "Datum eingeben (dd.mm.yyyy): "
date = gets
#zerlegt Datum in Einzelteile : $1(dd), $2(mm), $3(yy) und $4(yy)
date =~ /(\d+).(\d+).(\d\d)(\d+)/
#Jahr durch Tag, modulo 7
jahr = ($4.to_i / $1.to_i) % 7.to_i
#Hashes mit Monaten, Jahren, Tagen
monatsliste = {
"01" => 0,
"02" => 3,
"03" => 3,
"04" => 6,
"05" => 1,
"06" => 4,
"07" => 6,
"08" => 2,
"09" => 5,
"10" => 0,
"11" => 3,
"12" => 5
}
jahreswerte = {
"17" => 4,
"18" => 2,
"19" => 0,
"20" => 6,
"21" => 4,
"22" => 1,
"23" => 0
}
wochentagswerte = {
0 => "Sonntag",
1 => "Montag",
2 => "Dienstag",
3 => "Mittwoch",
4 => "Donnerstag",
5 => "Freitag",
6 => "Samstag"
}
#Addition der 4 Werte, modulo 7
tag = (jahr + monatsliste [$2].to_i + $1.to_i + jahreswerte [$3].to_i) % 7
puts "Der #{date} war ein #{wochentagswerte [tag]}!"
Was mir noch fehlt, ist der Schaltjahrrechner. Aber das wird schon ;)
ciao
//edit: könnt jmd vllt mal über meine Rechnung gucken, irgebdwie sagt der mir zB für heute an, dass Montag sei. sitze ich etwa in einem Zeitloch fest? :)
Ohne jetzt den Rest angeschaut zu haben würd ich mich noch mal über den regulären Ausdruck beugen. Der matcht nämlich auf viel zu viel... Die Tatsache, dass er auch so was wie 1.2.12345 akzeptieren würd ist vielleicht nicht ganz so schlimm. Aber da der Punkt als beliebiges Zeichen interpretiert wird, sind da auch ganz hässliche sachen wie 4a2b123 möglich...
Moin,
..//edit: könnt jmd vllt mal über meine Rechnung gucken, irgebdwie sagt der mir zB für heute an, dass Montag sei. sitze ich etwa in einem Zeitloch fest? :)
ich habe zwar von Ruby keine Ahnung, aber ich versuchs mal:
So wie ich das sehe, berechnest Du jahr falsch. Nach dem LiMa-Artikel wird der Jahreswert so bestimmt: (YY + (YY div 4)) mod 7, in Deinem Fall also wohl
jahr = ($4.to_i + ($4.to_i / 4).to_i) % 7.to_iAußerdem muss in Deinen jahreswerte für "22" eine 2 stehen, keine 1.
Zuletzt schließe ich mich sarc an: Überarbeite Deine regex und baue ein paar elementare Tests ein - z. B. sollte auch sichergestellt sein, dass Tag, Monat und Jahr gültig im Sinne von Datum sind. Du greifst in die Hashes jahreswerte und monatsliste, ohne Dich vorher davon zu überzeugen, ob die Schlüssel auch existieren.
Jan
EDIT: Beeil Dich mit der Schaltjahr-Berechnung - in 2 Wochen brauchst Du sie ;-)
Jöp, das mit der Regexpüberprüfung hab ich mir auch schon überlegt. da muss aber noch ein wenig an den Skills gefeilt werden ;)
Zur der Jahreserrechnung: Da bin ich auch drüber gestolpert, aber hast du mal den Artikel (bzw den Absatz) gelesen, oder nur die Formel gesehen? ich habe ein bisschen das Gefühl (ich habe jetzt seit ca 10 Monaten kein Mathe mehr gehabt, hrhr), dass sich da ein bisschen was widerspricht. Weil seine Rechnung lässt die Addition vom Jahr weg. Und an dem Punkt stimmt mein Ergebnis noch.
Außerdem muss in Deinen jahreswerte für "22" eine 2 stehen, keine 1.
Meinst du das ? ->
Dabei ist »YY« die zweistellige Jahreszahl, also 07 für 2007. Der »div«-Operator führt eine Division ohne Restwert aus, 7 div 4 gleich 1, da 7 geteilt durch 4 den Wert 1 ergibt und der Rest 3 wegfällt. Das Ergebnis wird jetzt noch modulo 7 genommen: 1 modulo 7 ergibt 1. Der Jahreswert ist also 1.
Keine Angst, brauchst kein Ruby lernen, erkläre es mir einfach :D
adieu
ok,
Die Schaltjahresrechnung ist nun eingebaut:
if $2 == "01" or $2 == "02" and
(jahr.remainder(400) == 0) or
(jahr.remainder(4) == 0 and not
jahr.remainder(100) == 0)
tag = (jahr + monatsliste [$2].to_i + $1.to_i + (jahreswerte [$3].to_i - 1)) % 7
puts "Der #{date} war ein #{wochentagswerte [tag]} // Schaltjahr!"
else
tag = (jahr + monatsliste [$2].to_i + $1.to_i + jahreswerte [$3].to_i ) % 7
puts "Der #{date} war ein #{wochentagswerte [tag]} "
end
Allerdings klappt die Rechnung immer noch nicht.
Ich werde einfach mal jedes einzelne Element durchgehen müssen und einzeln berechnen.
ciao
Hallo Juan,
Du machst das schon ganz gut ;). Ich habe zwar gerade nicht so viel Zeit, aber dennoch hier etwas für Deine RegExp Skills und Ruby.
Ich sehe du machst schon mit objektorientierten RegExp rum :cool:, dass heißt, dass Du innerhalb Deines RegExp-Ausdrucks auf einzelne Teil-"Objekte" eingehst.
#zerlegt Datum in Einzelteile : $1(dd), $2(mm), $3(yy) und $4(yy)
date =~ /(\d+).(\d+).(\d\d)(\d+)/
Da Du in Deiner Eingabeaufforderung schon nach dem Schema "dd.mm.yyyy" verlangst, dann schöpfe es doch auch explizit aus.
date =~ /(\d\d)\.(\d\d)\.(\d\d)(\d\d)/
Was ist hier anders?:
'\d' adressiert nur ein einziges Zeichen aus 0-9, also zählen wir alle auf.
'\.' adressiert genau den Punkt zwischen den Ziffern. Das Zeichen '\' wird benutzt, um das nachfolgende Zeichen von seiner RegExp-Bedeutung zu entheben und es als normales Zeichen zu lesen.
'(..)' formt Teilobjekte, wie Du sie schon benutzt hast. In der Ausgabe und Auswertung werden sie dann über $1, $2, $3 usw abgegriffen. Wenn Du den kompletten Ausdruck nehmen willst -> nimm die Summe: $& (sehr intuitiv :) ). Probiere mal das Beispiel im Anschluss aus und lasse Dich von $`, $', $+ überraschen.
date = "Hallo heute ist der 18.02.2008 und es ziemlich kalt."
date =~ /(\d\d)\.(\d\d)\.(\d\d)(\d\d)/
p $&, $1, $2, $3, $4
date =~ /(\d\d)\.(\d\d)\.(\d\d\d\d)/
p $&, $1, $2, $3, $4
p $`, $', $+
Mehr zu RegExp unter:
http://www.night-ray.com/regex.pdf <- eine A4 Seite mit allem was wichtig ist
Mehr zu Ruby unter:
http://en.wikipedia.org/wiki/Ruby_%28programming_language%29 <- Übersicht und Beispiele
http://ruby.cenophobie.com/RubyCheat.pdf <- Quick Reference; zwei A4 Seiten mit allem was wichtig ist
http://www.rubycentral.com/pickaxe/ <- Online Buch, habe aktuellste Version als Buch zu Hause und es ist Gold wert!
Viel Erfolg.
Und ich finde Ruby ist eine prima Sprache zum Einsteigen. Sie macht einfach Spaß!
VG Daniel
Hi,
vielen Dank für dein Feedback!
Super, dass hier noch Jemand Ruby spricht :)
Wenn ich ehrlich bin, sah mein Regexp vorher so aus, aber dann habe ich irgendwo (vllt sogar in der pickaxe?!) diese Schreibweise gesehen und wollte dann Zeichen sparen.
Danke für die Tipps ($&, $`, $', $+), echt praktisch.
Ich habe gerade deine Schreibweise mal auf mein Fallbeispiel angewandt, aber leider beim Ergebnis kein Unterschied feststellen können. Die Variablen sind identisch.
Muss also wirklich ein Rechenfehler sein, habs auch leider noch nicht geschafft, das Skript durch zugehen.
Adieu
Hey,
mal ne Frage zu Deinem Algorithmus ..
Ich weiß Du probierst Dich aus und versuchst Dich an eigenen Beispielen. Deshalb mache ich mir weniger Gedanken darüber, wie Du Deine Aufgabe lösen möchtest, auch weil zu Beginn der Diskussion nicht nur das Programmieren besprochen wurde, sondern auch die Lösungsstrategien. Und es ohne hin mehrere Wege nach Rom gibt.
Aber falls Du mit dem gewählten Weg nicht gut voran kommst - fühle Dich frei andere Ansätze zu wahlen. Auch/Besonders Programmierer gehen den Weg des geringsten Widerstandes -> Erinnere an geeignete Lösungsstrategien. ;)
Kleine Anregung, aber keine Aufforderung: Mir scheint Du verfolgst einen Algorithmus, der, wie ich sagen würde, absolut erscheint. Denn er beruht ausschließlich auf dem Eingabedatum. Vielleicht könnte ein rekursiver oder ein expliziter Ansatz leichter sein. Ich verrate mal nicht mehr als Dir einen Link über Zahlenfolgen (Schul-Mathe) zu schicken. :) Link: http://www.mathematik-wissen.de/zahlenfolgen.htm
Viel Erfolg
Daniel
PS: Wegen der RegExp: Nimm mal Deine "Sparversion" und dann den Vorschlag aus der PickAxe und untersuche diesen String eines wirklich dooooofen Benutzers, mit denen immer gerechnet werden muss. :p
date = "Hallo heute ist der 23418.02.200834 und es ziemlich kalt."
date =~ /(\d+)\.(\d\d)\.(\d\d)(\d+)/
p ['gespart:', $&, '=>' , $1, $2, $3, $4].join(" ")
date =~ /(\d\d)\.(\d\d)\.(\d\d)(\d\d)/
p ['pickaxe:', $&, '=>' , $1, $2, $3, $4].join(" ")
date =~ /\s(\d\d)\.(\d\d)\.(\d\d)(\d\d)\s/ # (1)
p ['genauer:', $&, '=>' , $1, $2, $3, $4].join(" ") # muss leer sein, da nix zu (1) gefunden wurde
date = "Un jetzt ist ein schlauer Benutzer dran .. Der 18.02.2008 war ziemlich kalt."
date =~ /\s(\d\d)\.(\d\d)\.(\d\d)(\d\d)\s/
p " ", $&, $&.strip , $1, $2, $3, $4
Probieren geht über studieren. ;) Und warum das so ist - steht sehr schön in http://www.night-ray.com/regex.pdf
Hallo nochmal,
auch wenn Du nicht darum gebeten hast - hier ein anderer Ansatz (explizit).
Ich wollte ihn Dir nicht auf's Auge drücken, deshalb die Datei im Anhang. Entscheide selbst.
Generell gilt beim Programmieren:
- einfach ist schick!
-- einfach ist das, was ich auch meiner Nachbarin erklären kann!
- für die meisten Probleme gibt es einfache Lösungen!
-- fragt sich bloss, ob die gewählte Programmiersprache einen dabei behindert oder unterstützt => Ich liebe Ruby!
-- aber bei schweren Problemen hilft mitunter nur eine komplizierte Lösung und dann ist Java, C++ usw. erste Wahl!
- Das Dilemma: Woher weiß ich, ob ein Problem einfach oder schwer ist? :confused:
-- Je mehr Erfahrung, umso besser weißt Du zu entscheiden.
Programmieren ist wie Boxen zwischen Mensch und Maschine:
Doll_Draufhauen_können ist gut, doch gute_Beinarbeit_haben ist besser. <- Verstanden?
Viel Erfolg
Daniel
Programmieren ist wie Boxen zwischen Mensch und Maschine:
Doll_Draufhauen_können ist gut,
Was kann der liebe Monitor dafür, dass dein Computer dich nicht versteht?
:D
doch gute_Beinarbeit_haben ist besser
Der arme Tower ist doch auch nicht dran schuld! :rolleyes:
Wie wär's mit ein bisschen Verständnis für die armen Bits und Bytes? ;)
In Form von Bibliotheken versuchen sie doch, dir alle deine Wünsche zu erfüllen :D
SCNR,
BlueJay
Hallo,
erstmal wieder: vielen Dank fürs Feedback. Bringt mich echt weiter!
@damue#1:
Allerdings muss ich sagen, das ich im Moment gar keine Lösungstrategie verfolge (scheint mir zu mindestens so). Und wenn ich so darüber nachdenke, wüsste ich auch so spontan nicht wieso (bei der "Komplexität").
Hast du den o.g Artikel gelesen? Ich finde, dass einem der Autor das ja schon ganz gut vorkaut. Von wegen "erst Dies berechnen, dann Dass usw ..". Also habe ich einfach erstmal alles mathematische nach Ruby übersetzt. Dann habe ich mir Gedanken darüber gemacht, wie ich das Datum einlesen, bzw auseinander klamüstern könnte, und jetzt schleichen sich die Fehler ein. ;)
Irgendwie sehe ich gerade auch keinen Grund, es irgendwie anders zu machen, es scheint mir ja irgendwie logisch (siehe Engstirnigkeit im Bezug aufs Programmieren im Ausgangsthread) und außerdem fiele mir auch kein anderer Weg ein.
Auch/Besonders Programmierer gehen den Weg des geringsten Widerstandes -> Erinnere an geeignete Lösungsstrategien. [...]
ist das nicht eh die Grundidee hinter Ruby ? "Principle of least surprise“
Mir scheint Du verfolgst einen Algorithmus, der, wie ich sagen würde, absolut erscheint. Denn er beruht ausschließlich auf dem Eingabedatum. Vielleicht könnte ein rekursiver oder ein expliziter Ansatz leichter sein. Ich verrate mal nicht mehr als Dir einen Link über Zahlenfolgen (Schul-Mathe) zu schicken.
neeeein, nie im Leben hätte ich nach 13 Jahren Mathe damit gerechnet, dass ich mir freiwillig mal was angucke, hehe:)
Danke für den Link, aber wie oben beschrieben, habe ich keine Ahnung, wo mein Algorithmus ansetzt. Dazu habe ich einfach zu wenig Erfahrung, was das Programmieren anbetrifft.
@damue#2:
- einfach ist schick!
-- einfach ist das, was ich auch meiner Nachbarin erklären kann!
- für die meisten Probleme gibt es einfache Lösungen!
sehe ich auch so, ich bin faul. Ruby bietet zudem für vieles eine sehr einfache Lösung.
-- fragt sich bloss, ob die gewählte Programmiersprache einen dabei behindert oder unterstützt => Ich liebe Ruby!
-- aber bei schweren Problemen hilft mitunter nur eine komplizierte Lösung und dann ist Java, C++ usw. erste Wahl!
Da ich nur Ruby beherrsche, ist es die richtige Wahl ;)
- Das Dilemma: Woher weiß ich, ob ein Problem einfach oder schwer ist?
-- Je mehr Erfahrung, umso besser weißt Du zu entscheiden.
Exakt. Daher versuche ich soviel wie möglich davon zu sammeln!
Programmieren ist wie Boxen zwischen Mensch und Maschine:
Doll_Draufhauen_können ist gut, doch gute_Beinarbeit_haben ist besser. <- Verstanden?
nein?! :(
Also, noch mal: muchas gracias !
Ich werde mich weiter ransetzte.
Zu deinen RegExp - Bsp. : oho! Macht also doch was aus :)
adieu
ps: danke für die Mühe, aber ich werde dein Anhang erstmal nicht öffnen. Habe auch die Perllösung noch nicht gelesen.
:D:D:D:D:D:D
Hey BlueJay,
das man es auch so deuten kann - war mir gar nicht klar. Danke für den schönen Lacher.
Das Thema Bibliotheken habe ich mir verkniffen. juan_ möchte gerne an einfachen Dingen lernen. Mir ist klar, dass es für die vielen kleinen Standardaufgaben auch schon Bibliotheken gibt.
Aber trotzdem gute Antwort, werde bestimmt nochmal herzlich darüber lachen.
@juan_: (Boxen)
Was ich meine ist, dass man sich nicht nur an eine Seite (vielleicht die erstbeste) des Problem stellen und dann von dort darauf los hämmern soll. Manchmal bringt es nichts sich in Seiten zu verbeißen. Also Beinarbeit => Kopfarbeit. Sei beweglich, geh um das Problem herum, schau's Dir von allen Seiten an. Wo gibt es Stellen zum Ansetzen? Das ist Planung. Jeder Handlung in der Informatik sollte eine Planung vorausgehen - im Großen wie im Kleinen. Es ist kein angenehmes Gefühl nach Wochen intensiven Einsatzen zu sehen, dass man in einer Sackgasse steht und alles in die Tonne drücken kann.
Auch wenn Dir das "Problem" nicht sehr komplex erscheint - so verfolgst Du trotzdem immer eine Lösungstrategie, um es zu lösen. Wie das dann aussieht, ist Dein Bier.
Zu denken und programmieren gibt es unterhaltsamen dt. Podcast "KontemplativeProgrammierung" => http://www.frankwestphal.de/Tonabnehmer3-GregorWoydnilek-KontemplativeProgrammierung.html
Also habe ich einfach erstmal alles mathematische nach Ruby übersetzt. Dann habe ich mir Gedanken darüber gemacht
Lieber anders herum.
Hast du den o.g Artikel gelesen? Ich finde, dass einem der Autor das ja schon ganz gut vorkaut.
Ich muss mich glaube ich entschuldigen, nicht jeden Betrag diesen Threads gelesen zu haben. Welchen meinst Du? Oder meinst Du den Mathe-Link?
Wen es darum geht, erstmal das Prinzip aufnehmen. Da gibt es ein Ergebnis (a_n), dass nicht vom Himmel fällt, sondern sich auf einen Basiswert (a_1) berechnen lässt (<- Explizite Form). Auf Dein Wochentagproblem gemünzt: Wenn Du weißt, welcher Wochentag vor 20 Tagen war, dann bist du doch schnell in der Lage mir den heutigen Wochentag zu nennen. Was passiert in dem Moment in deinem Kopf? Das muss ins Programm! Klingelts?
Kannst natürlich auch jmd nach dem Wochentag fragen gehen, dass ist dann wie ein Aufruf einer Kalenderbibliothek in einer Programmiersprache.
Aber ich nehme mich wieder ein wenig zurück - Du machst das schon.
Eins muss ich aber offen sagen: Informatik ist Infor(mationsmathe)matik. Wenn einem Mathe nicht zufliegt, dann die Informatik schon gar nicht. (Fast 2/3 meiner Mitstudenten hat es allein wegen Mathe und Theoretischer Informatik dahingerafft.) Und ich rede nicht von Mathe Abiturstufe <- Das ist Pillepalle!!!! Aber da jeder erstmal von der Penne auf die Uni kommt, wird alles wiederholt, vertieft und erweitert.
VG Daniel
Okay - ich habe den Artikel gefunden. :o
http://www.linux-magazin.de/heft_abo/ausgaben/2007/12/datumsarithmetik
Ist ja witzig und hat Stil. Ist aber ohne Anleitung kaum verständlich.
Ich werde den Thread weiter verfolgen und sehen wie's klappt.
VG Daniel
Moin,
...Zur der Jahreserrechnung: Da bin ich auch drüber gestolpert, aber hast du mal den Artikel (bzw den Absatz) gelesen, oder nur die Formel gesehen? ich habe ein bisschen das Gefühl (ich habe jetzt seit ca 10 Monaten kein Mathe mehr gehabt, hrhr), dass sich da ein bisschen was widerspricht. Weil seine Rechnung lässt die Addition vom Jahr weg. Und an dem Punkt stimmt mein Ergebnis noch.
Ich habe mir eher den Perl-Code angeschaut (den hat M. Schilli i. d. R. getestet, bevor er ihn ans LiMa schickt ;-) - da schaut das exakt so aus wie in der o. a. Formel (Zeile 37 in Listing 1). Texterklärungen sind ja immer sowas wie Textaufgaben in Rechnen (is ja noch kein Mathe :cool:) - alles nach dem Motto "Was will uns der Dichter damit sagen".
Zum Thema "Jahreswerte" - siehe Tabelle 2 im Artikel.
Keine Angst, brauchst kein Ruby lernen, erkläre es mir einfach :D
Och, mal so ein wenig da rein schnuppern kommt bei der Gelegenheit ganz gut (ich wollte schon öfters mal erfahren, was an Ruby so toll ist :rolleyes: - ich weiss es ehrlich gesagt jetzt auch noch nicht) - hast Du es denn mal mit der geänderten Zeile ausprobiert?
Um diesen Algorithmus herleiten zu können, muss man IMHO wohl ein bisschen mehr Zeit investieren, ich habe einfach Deinen Ruby-Code mit dem Perl-Code aus dem LiMa verglichen.
Jan
P.S.: Mein letzter Mathe-Unterricht ist ca. 25 Jahre her - aber wie gesagt: Das hier ist noch keine Mathematik, das ist einfach nur Rechnen.
Drohung: Wenn Du bis zum WE keine funktionierende Lösung hast, dann portiere ich das Perl-Script mal in ein richtig "schickes" Ruby-Anfänger-Programm :o
Morgen!
damue: achso, so ähnlich habe ich es dann doch verstanden. ich dachte, dass du mit den "_" auf was spez. (evtl rubytechnisches) hinauswolltest :D
Klar weiß ich auch, dass Informatik = Mathe ist, aber da ich das hier im Moment noch alles privat und aus Spaß mache, hätte ich halt nicht gedacht, dass ich freiwillig (und ohne Schulzwang) mal Mathe lernen würde!
In erster Linie will ich mit dieser Programmierlernaktion natürlich mal mein Interesse stillen, aber ich will auch -vorallem im Hinblick aufs Studium, bzw (irgendwann dann mal) den Job - meine Fähigkeiten ausbauen. Damit ich dann nicht im Studium lange rumexperimentieren muss ... halt eine gewisse Routine ins Programmieren bringen.
Wie gesagt, vielen Dank für deine Unterstützung. Die Verlockung ist allerdings sehr groß, dass ich in deinen Code schaue, weil mir momentan ein bisschen die Zeit fehlt, mir großartig Gedanken zu machen :|
Jan: ah, OK. Dann hat sich der Autor aber wirklich ein bisschen ungeschickt ausgedrückt, oder hab nur ich das misverstanden? Das Hinzufügen des fehlenden Wertes hat leider auch nichts gebracht. Verglichen habe ich die Unterschiede jedoch noch nicht. Sollte aber nicht auf meiner ToDo - Liste fehlen.
Zu Ruby kann ich leider nicht viel mehr objektives Sagen, als bei zB Wikipedia steht. Mir macht es einfach unheimlich Spaß. Immer wenn ich auf der Arbeit mal ein Minütchen Ruhe habe, lese ich hier und im Rubyforum mit und freue mich dann immer auf den Feierabend, wenn ich es dann vllt schaffe, ein bisschen was zu programmieren ;)
Also, ich melde mich, wenn ich die ersten Erfolge erzielt habe. Das Ultimatum werde ich vermutlich nicht einhalten können. Ich bin leider nicht der Mensch, der sich die Nacht damit um die Ohren schlagen kann, vorm PC zu sitzen. Ich habe die doofe Angwohnheit zu schlafen :D hehe
Danke für die Unterstützung. Falls euch noch ein log. Fehler in meiner Rechnung auffällt, bitte im um eine kurze Notiz!
Adieu
mehlvogel
21-02-2008, 11:19
Mir macht es einfach unheimlich Spaß. Immer wenn ich auf der Arbeit mal ein Minütchen Ruhe habe, lese ich hier und im Rubyforum mit und freue mich dann immer auf den Feierabend, wenn ich es dann vllt schaffe, ein bisschen was zu programmieren
Lass dir versichert sein, dass das schon eines der wichtigsten Punkte für ein Informatikstudium ist - meiner Ansicht nach. ;)
yeaaaaaaaah. oh man. Ich Idiot!
Ich hatte einen echt dummen Fehler, gleich in meiner ersten Rechnung!
Anstatt durch 4 zu dividieren, hab ich duch den Tag (im Bsp eine 4) geteilt.
->
jahr = ($4.to_i + ($4.to_i / 4) ) % 7
Im Schaltjahr bin ich im Moment zwar immer noch ein Tag im plus, aber das scheint dann nur mein Schaltjahrmechanismus nicht richtig zu greifen.
muaha, *freu
@damue: hast du bei deiner Version eine Funktion eingebaut, die sich um die Richtigkeit des Datums kümmert? Weil sowas würd ich auch noch bauen wollen und würds mir nicht unbedingt bei dir abgucken wollen :)
Soweit erstmal Adieu, ich melde mich!
Moin,
Ich hatte einen echt dummen Fehler, gleich in meiner ersten Rechnung!
Anstatt durch 4 zu dividieren, hab ich duch den Tag (im Bsp eine 4) geteilt.
Wer lesen kann ist klar im Vorteil ;-)
@damue: hast du bei deiner Version eine Funktion eingebaut, die sich um die Richtigkeit des Datums kümmert?
Der bin ich zwar nicht, aber das ist nicht weiter schwer (ich überlasse das Auskodieren in Ruby mal Dir):
1. Jahr, Monat und Tag dürfen nicht leer sein (dann hat die Regex nix gefunden)
2. Das Jahr muss zwischen 1700 und 2299 (sonst findest Du keinen Jahreswert in Deinem Array) liegen
3. Der Monat muss zwischen 1 und 12 liegen
4. Der Tag muss zwischen 1 und der höchsten Tageszahl des Monats liegen. Dazu baust Du Dir wohl am einfachsten noch ein Array mit diesen Zahlen und addierst für den Februar den Schaltjahreswert (0=kein Schaltjahr oder 1=Schaltjahr).
Zu Deiner Schaltjahresberechnung: Vielleicht solltest Du da besser mit dem 4-stelligen Jahr (also $3) und nicht mit jahr rechnen ;-). Und vielleicht kommst Du weniger durcheinander, wenn Du die Variablen sprechend bezeichnest (Dein jahr ist nämlich nicht das Jahr, sondern ein daraus berechneter Wert).
Jan
Hallo
Moin,
Wer lesen kann ist klar im Vorteil ;-)
jaja, so ist das halt :)
Der bin ich zwar nicht, aber das ist nicht weiter schwer (ich überlasse das Auskodieren in Ruby mal Dir):
1. Jahr, Monat und Tag dürfen nicht leer sein (dann hat die Regex nix gefunden)
2. Das Jahr muss zwischen 1700 und 2299 (sonst findest Du keinen Jahreswert in Deinem Array) liegen
3. Der Monat muss zwischen 1 und 12 liegen
4. Der Tag muss zwischen 1 und der höchsten Tageszahl des Monats liegen. Dazu baust Du Dir wohl am einfachsten noch ein Array mit diesen Zahlen und addierst für den Februar den Schaltjahreswert (0=kein Schaltjahr oder 1=Schaltjahr).
Mir ging es weniger um die Umsetzung, als die Tatsache, dass ich auf damues Code (siehe irgendein Vorpost) gespannt bin ;).
Interessant wäre es, die Kontrolle auch über RegExp zu realisieren, aber soweit bin ich noch nicht. Eine schlichte case-Abfrage (oder verschachtelte if-Abfragen) reichen mir vorerst.
Zu Deiner Schaltjahresberechnung: Vielleicht solltest Du da besser mit dem 4-stelligen Jahr (also $3) und nicht mit jahr rechnen ;-). Und vielleicht kommst Du weniger durcheinander, wenn Du die Variablen sprechend bezeichnest (Dein jahr ist nämlich nicht das Jahr, sondern ein daraus berechneter Wert).
Ok, danke für die Hinweise. Dummer Fehler, das kommt davon, wenn man zwischen dem Programmieren immer eine Woche Zeit verstreichen lässt und man dann später nicht mehr aufpasst ;S
Ich werd sehen, was sich machen lässt!
Schönen Abend noch!
//edit:
jawohl, es lüppt :)
muchas gracias.
Moin,
...Interessant wäre es, die Kontrolle auch über RegExp zu realisieren, aber soweit bin ich noch nicht. Eine schlichte case-Abfrage (oder verschachtelte if-Abfragen) reichen mir vorerst.
Hm, ich kenne regex ein wenig - ich bezweifle, dass eine, die das Datum 100% korrekt abprüft:
a) noch halbwegs lesbar ist
b) kürzer ist als eine selbstgebastelte Funktion
c) effektiver arbeitet als eine selbstgebastelte Funktion
Das Problem liegt darin, dass in dieser Prüfung Berechnungen angestellt werden müssen (Schaltjahr), Backreferences auftreten müssten (die Gültigkeit des Tags hängt ab vom Monat und beim Februar auch vom Schaltjahr) und schon allein eine Prüfung auf einen gültigen Monat nicht mehr so trivial ist (wobei der Monat noch der einfachste Kandidat ist). In Perl würde eine Prüfung auf einen Wert zwischen 01 und 12 z. B. so aussehen:
jan@jack:~/tmp> echo 01 | perl -ne 'print $_ if /^(0[0-9]|1[012])$/;'
01
jan@jack:~/tmp> echo 12 | perl -ne 'print $_ if /^(0[0-9]|1[012])$/;'
12
jan@jack:~/tmp> echo 13 | perl -ne 'print $_ if /^(0[0-9]|1[012])$/;'
jan@jack:~/tmp>Das Jahr ginge auch noch - dass wir eine 4-stellige Zahl haben, wissen wir ja schon aus der Eingangs-Prüfung:
jan@jack:~/tmp> echo 1701 | perl -ne 'print $_ if /^(1[7-9]|2[012])\d\d$/;'
1701
jan@jack:~/tmp> echo 1601 | perl -ne 'print $_ if /^(1[7-9]|2[012])\d\d$/;'
jan@jack:~/tmp> echo 2299 | perl -ne 'print $_ if /^(1[7-9]|2[012])\d\d$/;'
2299
jan@jack:~/tmp> echo 2301 | perl -ne 'print $_ if /^(1[7-9]|2[012])\d\d$/;'
jan@jack:~/tmp>Das Ganze wird haarig beim Tag. Die Gültigkeit hängt nämlich sowohl vom Jahr als auch vom Monat ab, da kann '0[1-9]' oder '1[0-9]' (alle Monate) gültig sein, und dann abh. vom Monat / Jahr: '2[0-8]' (Februar in Nicht-Schaltjahren), '2[0-9]' (alle anderen Monate), '30' (alle Monate außer Februar), '31' (alle Monate mit 31 Tagen).
Reguläre Ausdrücke dienen der Mustererkennung in Zeichenketten. Dafür sollte man sie nutzen. Wenn es wie bei einem Datum um Zahlen inkl. Berechnungen geht, dann sollte man dafür geeignete Werkzeuge benutzen, nämlich numerische Operatoren.
Du nimmst ja wohl (hoffentlich ;-) keinen Bohrhammer, wenn Du eine lockere Schraube in einem Festplattengehäuse anziehen willst.
Jan
Moin,
...Dummer Fehler, das kommt davon, wenn man zwischen dem Programmieren immer eine Woche Zeit verstreichen lässt und man dann später nicht mehr aufpasst...
nein das trifft es nicht ganz. Sauberen Code kann man auch nach ein paar Jahren noch lesen und korrekt interpretieren (von der anderen Sorte hab ich auch einiges auf meiner Platte liegen %-/ - da guck ich dann immer erstmal rein wie ein Schwein ins Uhrwerk - und das ab und zu auch bei eigenen Programmen) und da gehören zutreffende Variablennamen genauso dazu wie Quellcode-Kommentare (oder kann Ruby das nicht? ;-). Kompakte Programmierung ist durchaus o.k., aber man muss dann doch mal kommentieren, so nach dem Motto "was wollte uns der Dichter damit sagen".
Jan
Hallo Jan,
natürlich hast du recht, dass es ein relativ schweres Unterfangen ist. Ob es kürzer oder sauberer ist, kann ich nicht beurteilen. Ich hätte es jedenfalls vermutet.
Wobei, wenn ich jetzt so überlege und ich einfach ein Hash mit der "Monat => Anzahl_der_Tage - Zuweisung" mache, kann ich das ja auch ganz lescher überprüfen.
Danke! (hier mal ein rubytechnischer Ansatz, den ich gefunden habe : klick (http://nopaste.php-quake.net/17721))
nein das trifft es nicht ganz. Sauberen Code kann man auch nach ein paar Jahren noch lesen und korrekt interpretieren (von der anderen Sorte hab ich auch einiges auf meiner Platte liegen %-/ - da guck ich dann immer erstmal rein wie ein Schwein ins Uhrwerk - und das ab und zu auch bei eigenen Programmen) und da gehören zutreffende Variablennamen genauso dazu wie Quellcode-Kommentare (oder kann Ruby das nicht? ;-). Kompakte Programmierung ist durchaus o.k., aber man muss dann doch mal kommentieren, so nach dem Motto "was wollte uns der Dichter damit sagen".
ok, hier hast du natürlich auch recht ;)
Aber ist mein Code sooo unsauber (bis auf die Schaltjahrberechnung) ? ich war eigentlich recht stolz (hihi), was die Einrückungen und Kommentare anging.
Ciao
Hallo zusammen,
freut' mich, dass der Durchbruch gelungen ist und Du auch um eine Erfahrung reicher bist, denn dumme kleine Fehler macht jeder (auch wenn's keiner gerne zugibt). Mein Tipp: Jeder hat Vorlieben für bestimmte Arten von kleinen Fehlern, deshalb lege Dir Dein kleines feines "Fehlerbüchlein" an. Vielleicht A5 und in Leder gebunden, damit's echt edel aussieht. Der Sinn ist, dass, wenn mal wieder nichts klappen will, Du in dem Büchlein nach vergangenen Fehlern suchst und schaust ob Dir in deinem aktuellen Projekt nichts ähnliches passiert sein könnte. Damit verbessern sich auf jeden Fall deine Skills und Du hast so etwas wie einen ganz persönlichen Debugging-Fahrplan an der Hand, wenn Du einmal überhaupt nicht weißt woran es liegt, dass Dein Programm falsch läuft.
Zum Ruby-Code:
Ich habe ja Deine Programmiervorlage nun auch entdeckt und versteh auch warum Du keine Lösungsstrategie hattest, da - nun klar - Du die Strategie eines Artikel genommen hast.
Ich habe Dir eine andere Lösung angeboten, in der ich die Datumseingabe nicht näher prüfe, als dass ich will, dass der Tag und der Monat zwei Digits und das Jahr 4 Digits hat. (55.23.9234 geht also durch!)
Zum Prüfen des Datums:
Ich stimme zu, dass sich RegExp weniger für Datumsprüfung eignet, da es sich auf Stringfolgen bezieht. Man kann es dennoch versuchen, doch unter uns, ich hätte mir die Mühe, wie das Beispiel im Quakenet nicht gemacht. Zu mal, wie will man dem Benutzer bei falscher Eingabe nun mitteilen, was genau falsch war. In dieser Form wird über eine höchst komplizierte RegExp-Beschreibung, doch nur eine einfaches Weiterverarbeiten möglich. Bei Fallunterscheidung/Prüfungen mittels Kontrollanweisungen, wie SWITCH-CASE und ähnliches, wird es einfacher und übersichtlicher, zumal hier auch entsprechende Ausgaben/Reaktionen angehangen werden können. (Bsp: if month == 13 => "Hey Du Ei - das Jahr hat nur 12 Monate !")
Zum Code: Ich habe für Dich die Einfachheit von Ruby durchblitzen lassen wollen und auch alles kommentiert. Aber da ich nicht Deinen Artikel umgesetzt habe, läuft wohl Dein Ruby-Alg. außer Konkurrenz ;) Sei also weiterhin gespannt, erwarte aber nicht zu viel in Bezug auf Deinen Algorithmus. Auch weil es nur 20 Zeilen mit vielen Kommentaren sind.
Wenn Du's Dir angeschaut hast, kannst Du gerne Fragen stellen. Vielleicht warum ich eine Array statt einem Hash nehme? Oder so ... ;)
Viel Erfolg noch
Daniel
Hallo,
gute Idee, das mit dem Büchlein. Muss aber bestimmt sehr bald ein 2. angeschafft werden ;)
Zu deinem Code. Bin kurz drüber geflogen:
Jap, das ist schon mal eine gute Frage. =)
Eine andere Frage (die ich mir aber erstmal selber beantworten möchte) ist, was dein Array (in beiden Fällen) macht.
schaltjahrtag = [1, 0, 0, 0][($3.to_i % 4)]
p "Du lebst in #{["k",""][schaltjahrtag]}einem Schaltjahr, das macht die Sache verdammt kompliziert! Ich ueberlege .."
tage_bis_ersten_des_aktuellen_monats =
[ 31 , 31+28 + schaltjahrtag, 31+28+31+ schaltjahrtag,
120 + schaltjahrtag, 151 + schaltjahrtag, 181 + schaltjahrtag,
212 + schaltjahrtag, 242 + schaltjahrtag, 273 + schaltjahrtag,
304 + schaltjahrtag, 334 + schaltjahrtag, 365 + schaltjahrtag]
ist für mich grade irgendwie noch ein Rätsel. Ist "schaltjahrtag" ein 2.dimensionales Array (was genau das ist, weiß ich zwar grade auch nicht, aber fiele mir bei der Darstellung in den Sinn). Was genau macht die Variable, print "k", wenn array eintritt?
Und das 2. verwirrt mich komplett :) Aber gut, ich beiße mich schon durch. Vielen Dank!
Das dein Programm aber nicht ganz ordentlich rund läuft, weißt du aber schon, gell? :)
Was mich aber wirklich interessiert: nach welcher Strategie bist du vorgegangen / welchen Ansatz verfolgst du?
Adieu
Moin,
...Aber ist mein Code sooo unsauber (bis auf die Schaltjahrberechnung) ? ich war eigentlich recht stolz (hihi), was die Einrückungen und Kommentare anging.
das war eher allgemein geschrieben. Ich rede mich manchmal auch (vor mir selbst ;-) damit raus, dass ich ja ewig nicht in meinen Code geguckt habe - aber wenn ich mir beim Coden mal die Zeit genommen habe und kommentiert habe, die Variablen vernünftig benannt habe usw., dann finde ich mich auch nach Jahren noch zurecht.
In Bezug auf Deinen Code meinte ich nur das bereits angesprochene Problem mit den Variablennamen - wenn da irgendwo jahr drauf steht, sollte auch ein Jahr drin stecken. Sonst verwirrt das nur (ich bin bei Deiner Schaltjahresberechnung mehrmals in die falsche Richtung getappt, weil ich instinktiv davon ausgegangen bin, dass Du tatsächlich mit dem Jahr rechnest - erst als ich mir den Code nochmal im Zusammenhang angeguckt habe, fiel mir der Fehler auf). Du erleichterst Dir und vor allem anderen mit treffenden Bezeichnungen das Lesen.
Jan
Moin,
...Das dein Programm aber nicht ganz ordentlich rund läuft, weißt du aber schon, gell? :)
@damue: Da hat er Recht ;-) - 1900 z. B. war kein Schaltjahr, obwohl es durch 4 teilbar ist - die genaue Regel lautet: Durch 4 teilbar, aber nicht durch 100, es sei denn, durch 400 teilbar. Nur 2000, 2400 usw. sind Schaltjahre, die 100er dazwischen nicht.
Jan
Moin,
das war eher allgemein geschrieben. Ich rede mich manchmal auch (vor mir selbst ;-) damit raus, dass ich ja ewig nicht in meinen Code geguckt habe - aber wenn ich mir beim Coden mal die Zeit genommen habe und kommentiert habe, die Variablen vernünftig benannt habe usw., dann finde ich mich auch nach Jahren noch zurecht.
In Bezug auf Deinen Code meinte ich nur das bereits angesprochene Problem mit den Variablennamen - wenn da irgendwo jahr drauf steht, sollte auch ein Jahr drin stecken. Sonst verwirrt das nur (ich bin bei Deiner Schaltjahresberechnung mehrmals in die falsche Richtung getappt, weil ich instinktiv davon ausgegangen bin, dass Du tatsächlich mit dem Jahr rechnest - erst als ich mir den Code nochmal im Zusammenhang angeguckt habe, fiel mir der Fehler auf). Du erleichterst Dir und vor allem anderen mit treffenden Bezeichnungen das Lesen.
Jan
Achso, dann bin ich ja beruhigt :)
Ja, der Code ist nicht fertig - ist ja nicht mein Hauptanliegen. Juan, Du darfst gerne daran weiterbasteln.
Nun zu den Fragen und Bemerkungen:
@Juan + Jan
Die Sonderregelung mit dem Schaltjahr kannte ich nicht => Ich schreibs mir gleich ins Büchlein. ;) Hier die Korrektur, als Snippet.
p jahr_teilbar_400 = ((jahr % 400) == 0)
p jahr_teilbar_100 = ((jahr % 100) == 0)
p jahr_teilbar_4 = ((jahr % 4) == 0)
p schaltjahrtag = ((jahr_teilbar_4 and not jahr_teilbar_100) or jahr_teilbar_400) ? 1 : 0 # Pickaxe ~ Seite 97
@Juan - 2D-Array?:
Tja, was macht .. ?
schaltjahrtag = [1, 0, 0, 0][($3.to_i % 4)]
Was Du hier siehst sind zwei Dinge in einem und kein 2D-Array. Als erstes wird eine Array erstellt. Ein Array ist im Vergleich zum Hash eine Struktur wo über die Position des Elements auf ein Element zugegriffen wird. In einem Hash nimmst Du ein Schlüssel, eine Zahl, ein Wort oder einen Code. Bei Dir war der Schlüssel der Monatsname und der Wert die Tage des Monats "{Mai => 31}". Im zweiten Schritt nimmst Du das Element aus einer bestimmten Position heraus. Damit ist das da oben ein SWITCH-CASE-Konstrukt und hätte auch so aussehen können:
schaltjahr_abfolge = [1, 0, 0, 0]
schaltjahrtag = schaltjahr_abfolge[($3.to_i % 4)]
Die Positionen in der schaltjahr_abfolge sind so gewählt, dass für den Modulowert aus der Jahreszahl, die Anzahl der zusätzlichen Tage eines Schaltjahres folgen. Ist das Jahr glatt durch 4 teilbar so ergibt das '0' und auf der Pos '0' im Array steht die '1'. Sonst liefert es bei den anderen Werten eine '0'. Damit habe ich eine Variable 'schaltjahrtag', die ich nun immer im Alg. benutzen kann, da sie falls kein Schaltjahr ist, in der Addition, keinen Einfluss hat.
Hinweis: Mehr-dimensionale Arrays werden in Ruby durch eine explizite Deklaration oder durch eine deutliche Zuweisung erstellt. Beispiel:
schachbrett = Array.new(2){ Array.new}
# erste Reihe links-nach-rechts
schachbrett[1][1] = "Turm"
schachbrett[1][2] = "Springer"
schachbrett[1][3] = "Laeufer"
schachbrett[1][4] = "Koenigin"
schachbrett[1][5] = "Koenig"
schachbrett[1][6] = "Laeufer"
schachbrett[1][7] = "Springer"
schachbrett[1][8] = "Turm"
# zweite Reihe - nur Bauern!
schachbrett[2] = Array.new( 8, "Bauer") # (1)
p schachbrett[1][6], schachbrett[2][6]
p schachbrett[2][0], schachbrett[2][8] # <- Einer meiner Lieblingsfehler, such den Bug (vielleicht Nahe (1))
p schachbrett # Schau genau hin -> schachbrett[0][0]
Ich denke jetzt klickts es auch mit der nächsten Frage: "print "k", wenn array eintritt?". Du siehst hier das gleiche Prinzip. Das 'k' ist nur eine Wert in einem 1D-Array und wird, falls schaltjahrtag = 0 ausgegeben, denn dann ist k_ein Schaltjahr. Falls schaltjahrtag = 1 dann ist natürlich _ein Schaltjahr. <= Ein Spiel mit der deutschen Sprache. ;) (Hinweis: Arrays beginnen mit '0' statt mit '1' mit der Zählweise <= Und dass vergesse ich auch leider manchmal ;) . Schaue in die Pickaxe ~ Seite 431 zu Arrays.)
@Juan - Ansatz:
Ich habe mir eine Referenzansatz gewählt (Erinnere in den Mathelink zu Zahlenfolgen). Wenn ich im Pogram fest einprogrammiere, dass der XX.YY.ZZZZ ein Montag war, dann brauche ich nur ausreichnen, wie viele Tage seit dem vergangen sind und Teile diese Zahl durch 7. Bsp: Diverenz ist 14, so ist 14 % 7 = 0. Also Monat + 0 = Montag. Ist ein allerdings 76 Tage her .. 76 % 7 = 6. Also Montag + 6 = Sonntag. Mein Beispielcode kann auch an dieser Stelle erweitert werden, denn es werden erstmal nur Tage diesen Jahres sinnvoll bestimmt.
Dieser Ansatz ist nicht neu - denn selbst in Java wird die aktuelle Zeit als Referenzgröße auf ein festes Datum ausgegeben. Beleg (http://mindprod.com/jgloss/date.html)
// get time in milliseconds since 1970 Jan 1
long timestamp = System.currentTimeMillis();
Gut. Fröhliches Kämpfen.
Daniel
PS: Ich geb zu ist im Code schon etwas dick aufgetragen, aber Ruby machts möglich. ;)
PPS: Irgendwie ist mein Deutsch heute komisch - naja - wer Fehler findet, darf sie behalten.
Powered by vBulletin® Version 4.2.5 Copyright ©2024 Adduco Digital e.K. und vBulletin Solutions, Inc. Alle Rechte vorbehalten.