Die Programmiersprache Ruby

Blog|

Forum|

Wiki  


Alle Zeiten sind UTC + 1 Stunde [ Sommerzeit ]

Ein neues Thema erstellen Auf das Thema antworten  [ 15 Beiträge ] 
Autor Nachricht
 Betreff des Beitrags: rechnen mit ruby - anfängerfrage
BeitragVerfasst: 23 Jun 2016, 13:07 
Offline
Nuby

Registriert: 23 Jun 2016, 11:48
Beiträge: 7
Wohnort: hessen
hallo,
wie der titel schon sagt, bin ich ein absoluter newb in sachen ruby (gestern erst mit angefangen :))

vor gefühlt hundert jahren hatte ich mal einen anfänger kurs mit visual basic 5 und wollte mit ruby mal die ersten schritte von damals nachstellen.

mein erster versuch ist ein rechen-prog.
----------------------------------------------------------


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

puts "Dies ist ein einfacher Taschenrechner."
puts "Sie k��nnen 2 Zahlen eingeben, die Sie miteinander"
puts "addieren, multiplizieren, subtrahieren oder divideren k��nnen."
puts " "
puts "Geben Sie Ihre 1. Zahl ein:"
a = gets.chomp.to_f #Eingabe von Variable "a"
puts "Geben Sie Ihre 2. Zahl ein:"
b = gets.chomp.to_f #Eingabe von Variable "b"

puts "Sollen ihre Zahlen miteinander addiert (+), multipliziert (*),"
puts "subtrahiert (-) oder dividiert (/) werden?"
puts "Geben Sie f��r die gew��nschte Rechenoperation das Zeichen"
puts "in der Klammer ein:"
op = gets.chomp # Eingabe der Operation (Variable "op")

case op
when "+" # Auswahl: Addition
c = a.to_f+b.to_f
puts "Das Ergebnis der Addition von #{a} und #{b} ist #{c}!"
when "-" # Auswahl: Subtraktion
c = a.to_f-b.to_f
puts "Das Ergebnis der Subtraktion von #{a} und #{b} ist #{c}!"
when "*" # Auswahl: Multiplikation
c = a.to_f*b.to_f
puts "Das Ergebnis der Multiplikation von #{a} und #{b} ist #{c}!"
when "/" # Auswahl: Division
c = a.to_f/b.to_f
puts "Das Ergebnis der Division von #{a} und #{b} ist #{c}!"
else
puts "Fehlerhafte Eingabe"
end

----------------------------------------------------------------------
ist ein abgewandeltes beispiel aus einem tutorial.
es funktioniert auch - fast.
mit ganzzahlen gehts, ich will aber auch mit komma-zahlen rechnen können und da hakts.
bei zb. 3.5-2.3 kommt als ergebnis 1.2000000000001
oder 2.3-1.3 = 0.99999999998

hab ich den falschen datentyp genommen? oder woran liegt das?

wär für jede verständliche hilfe dankbar, da mein englisch auch extrem mies ist...das letzte mal hab ich englisch vor 30 jahren gebraucht ^^

mfg
martin


Zuletzt geändert von NobbZ am 23 Jun 2016, 16:50, insgesamt 1-mal geändert.
Code-Tags


Nach oben
 Profil  
 
BeitragVerfasst: 23 Jun 2016, 17:13 
Offline
Metaprogrammierer

Registriert: 20 Nov 2011, 21:51
Beiträge: 693
grottenolm hat geschrieben:
bei zb. 3.5-2.3 kommt als ergebnis 1.2000000000001
oder 2.3-1.3 = 0.99999999998


Stimmt doch…

Flieskommazahlen werden im Speicher des Computers dargestellt durch Vorzeichen, Mantisse und Exponent. Im Dezimalsystem wäre 2.3 gespeichert als Vorzeichen: +; Mantisse 23; Exponent -1, die Basis wird impliziert und ist in diesem Beispiel 10, beim Computer wäre es natürlich 2. Und da geht es dann los.

Die 0,5 liese sich noch accurat darstellen: Vorzeichen +; Mantisse 1; Exponent -1 (Für die einfache Lesbarkeit werde ich Exponenten im folgenden immer Dezimal darstellen)

Die 0,25 wäre ebenfalls einfach: Vorzeichen +; Mantisse 1; Exponent -2

Und auch 0,75: Vorzeichen +; Mantisse 11; Exponent -1

Versuchen wir jetzt aber mal 0,1:
Vorzeichen +; Mantisse 1; Exponent -1 wäre 0,25, wir brauchen also weniger.
Vorzeichen +; Mantisse 1; Exponent -2 wäre 0,125, wir brauchen also weniger.
Vorzeichen +; Mantisse 1; Exponent -3 wäre 0,0625, wir brauchen jetzt etwas mehr.
Vorzeichen +; Mantisse 11; Exponent -3 wäre 0,0625 + 0,03125 = 0,09375, wir brauchen also wieder etwas mehr.
Vorzeichen +; Mantisse 111; Exponent -3 wäre 0,09375 + 0,015625 = 0,109375, wir hätten also doch nicht ganz so viel gebraucht.
Vorzeichen +; Mantisse 1101; Exponent -3 wäre 0,09375 + 0,0078125 = 0,1015625, immer noch zuviel...
Vorzeichen +; Mantisse 11001; Exponent -3 wäre 0,09375 + 0,00390625 = 0,09765625, wir dürfen also wieder draufpacken.
Vorzeichen +; Mantisse 110011; Exponent -3 wäre 0,09765625 + 0,001953125 = 0,099609375, und noch mehr drauf.
Vorzeichen +; Mantisse 1100111; Exponent -3 wäre 0,099609375 + 0,000976563 = 0,100585938, zuviel...
Vorzeichen +; Mantisse 11001101; Exponent -3 wäre 0,099609375 + 0,000488282 = 0,100097657, immer noch...
Vorzeichen +; Mantisse 110011001; Exponent -3 wäre 0,099609375 + 0,000244141 = 0,099853516, und hier breche ich jetzt ab.

Wir könnten das Spielchen noch eine ganze Weile so weiter spielen. Für das Speichern der Informationen stehen nun mal nur eine gewisse Menge an Informationen zur Verfügung, wieviel das genau ist, ist abhängig von der Gesamtgröße und in IEEE 754 festgelegt.

Auch ist in ihr festgelegt, dass eine Zahl, die nicht eindeutig dargestellt werden kann auf die nächstkleinere Zahl abgebildet wird die darstellbar ist.

Welche Zahlen jetzt genau nicht exakt darstellbar sind in den genannten Beispielen muss jeweils per Hand herausgefunden werden, aber zumindest in dem Beispiel 3.5 - 2.3 = 1.2000000000001 kann man davon ausgehen, dass mindestens eine der beiden Zahlen linkerhand das Problem ist.

Allgemein mag ich zu Fließkommazahlen immer gerne den Tipp geben: Lass die Finger davon wenn du sie nicht vestehst. Ich persönlich halte mich an meinen Rat und nutze sie auch nur sehr selten und dann meist nur weil mich Kunden oder Professoren dazu nötigen ;)

edit

Vorsicht: Ruby hält sich für schlau und hat manchmal genug Kontextwissen um die direkte Eingabe nicht exakt darstellbarer Zahlen bei der Ausgabe wieder zurück zu runden. Klappt aber häufig nur für literale Eingaben.

_________________
Ubuntu Gnome 14.04 LTS
rvm mit App-spezifischer Ruby-Version (meist 2.2.x) und -Gemset

Github ProfilBitbucket Profil


Nach oben
 Profil  
 
BeitragVerfasst: 24 Jun 2016, 04:20 
Offline
Nuby

Registriert: 23 Jun 2016, 11:48
Beiträge: 7
Wohnort: hessen
hallo nobbz und danke für die ausführliche erklärung.

du hast dir jetzt viel mühe gemacht, mir die fliesskommazahl zu erklären, was mir schon nach 2 zeilen zu hoch war ^^

naja, ist zu warm, ich bin zu alt und zu müde...


aber zuammengefasst kann ich doch aus deiner antwort entnehmen to_f war die falsche wahl ^^
ich versuchs jetzt mal mit bigdecimal..grad gefunden

mfg
martin


Nach oben
 Profil  
 
BeitragVerfasst: 24 Jun 2016, 13:33 
Offline
Meister

Registriert: 02 Jan 2010, 16:42
Beiträge: 204
Wohnort: Schweiz
NobbZ hat Dir gezeigt, dass Ruby alles richtig macht. Und er hat Dir gezeigt, dass es sich um ein generelles "Problem" bei allen Programmierpsrachen handelt.

Mit der Aussagen
Zitat:
Die 0,5 liese sich noch accurat darstellen: Vorzeichen +; Mantisse 1; Exponent -1
ist Folgendes gemeint:

1* 2**(-1) = 0.5

Und jetzt kannst Du mit obiger Formel auf die anderen Zahlen nachrechnen.

NobbZ hat in anschaulicher Weise das erklärt, was mathematisch hier angehandelt wird: :-):

http://www.icp.uni-stuttgart.de/Courses_and_Lectures/Optimierte_programmierung/Html/node46.html

PS: Zudem brauchst Du beispielsweise folgende Konvertierung nicht mehr



c = a.to_f+b.to_f

, da Du ja bereits bei der Angabe diese Konvertierung vornimmst:


a = gets.chomp.to_f

_________________


1
2
Betriebssysteme: Windows 10, Linux Mint 17.3
Rubyversion : 2.2.4-p230


Nach oben
 Profil  
 
BeitragVerfasst: 24 Jun 2016, 15:48 
Offline
Nuby

Registriert: 23 Jun 2016, 11:48
Beiträge: 7
Wohnort: hessen
hallo jeanc, auch dir danke für deine antwort.

stimme dir zu, dass die erklärung von nobbz super war, auch wenn ich sie nicht wirklich verstehe^^ ist aber auch erstmal nicht nötig.

ich möchte einfach nur ein rechenprog bauen, das mit 4 nachkommastellen klar kommt.
in vb gabs dafür currency als datentyp. oder auch double mit entsprechender ausgabeformatierung.

ich finde, mit so einem rechnerprog erlernt man schon einiges an grundlagen.

------------------------------------------------------------------------------
1.)die eingabe von buchstaben und sonderzeichen muss abgefangen werden.
-(in vb würd ich hier das keyup oder keypress ereignis des eingabefeldes abfragen
und mit case die ascii-werte filtern)
=werd ich wohl in ruby mit schleifen handlen müssen
2.)die eingabe von .. als zu verechnenden zahlen muss verhindert werden.
3.)bei eingabe von . als zahl1 - umwandlung von zahl1 in "0."
4.)bei 0. und eingabe des . als zahl2 - eine schleife bis zur eingabe einer zahl.
5.)abfrage welche operation durchgeführt werden soll - also auch nur entsprechende
zeichen zulassen - ggf. schleife bis zur richtigen eingabe.
6.)abfrage ob zahl1, operator, zahl2 richtig sind. ggf schleife
7.) abfrage weitere berechnung

und wenn das alles läuft......
erweiterung im stile einer kasse, speicherung der berechnungen (also speichern in datei[bon,tagesumsatz])
und dann auswertung tagesumsatz, wochenumsatz, monatsumsatz und in gaaanz weiter ferne - datenbankanwendung...also das ist noch nicht ganz durchdacht, aber würde sinn machen.

wie war das nochmal? ich möchte EINFACH nur n rechenprog bauen ;)

bei stackoverflow fand ich:
v = BigDecimal("7.1762")
v.truncate(2).to_s('F')
# => "7.17"
was ja schon ganz ok aussieht..obwohl ich bei 7.176 auf 7.18 aufrunden würde. oder genrell nur mit 2 nachkommastellen rechnen würde, was kleineres als 1 cent haben wir ja nicht.

in einem beispiel fand ich eine passende abfrage für die operatoren
while op !~ /^[\+\-\*\/]$/
und die versteh ich absolut nicht....!~=ungleich - ok..aber /^ ist ??
finde nirgendwo bei den abfragen in den tuts ne erklärung
naja...
wie mal n weiser mann sagte - learning by doing..versuch macht kluch..und ganz wichtig - try and error..

bis später
mfg martin


Nach oben
 Profil  
 
BeitragVerfasst: 24 Jun 2016, 15:57 
Offline
Interpreter

Registriert: 10 Dez 2007, 17:37
Beiträge: 1906
@grottenolm Du hast schon den richtigen Weg gefunden. Wenn du eine genauere Berechnung haben möchtest, dann solltest du BigDecimal verwenden. Ansonsten kannst du noch round statt truncate verwenden. Dann bekommst du dein gerundetes Ergebnis.

Ansonsten hat float (2.3 ist ein float, wenn du das so einfach hin schreibst oder .to_f auf einen String anwendest)
die gleichen Ungenauigkeiten beim rechnen, wie Single Data Type in VB.

!~ ist kein Vergleich sondern eine Prüfung auf einen Regular-Expression. Wenn du danach googlest, dann findest du auch die Erklärungen für die kryptischen Zeichen.

_________________
Grüße
Jack


Nach oben
 Profil  
 
BeitragVerfasst: 24 Jun 2016, 16:08 
Offline
Metaprogrammierer

Registriert: 20 Nov 2011, 21:51
Beiträge: 693
grottenolm hat geschrieben:
bei stackoverflow fand ich:
v = BigDecimal("7.1762")
v.truncate(2).to_s('F')
# => "7.17"
was ja schon ganz ok aussieht..obwohl ich bei 7.176 auf 7.18 aufrunden würde.


Wenn du runden willst, dann runde auch. "truncate" bedeutet wortwörtlich "abschneiden":



1
2
1.2365.round(2)
# => 1.24

_________________
Ubuntu Gnome 14.04 LTS
rvm mit App-spezifischer Ruby-Version (meist 2.2.x) und -Gemset

Github ProfilBitbucket Profil


Nach oben
 Profil  
 
BeitragVerfasst: 24 Jun 2016, 17:00 
Offline
Interpreter
Benutzeravatar

Registriert: 18 Sep 2008, 22:32
Beiträge: 1821
Wohnort: NRW → UN
Du kannst mit BigDecimal direkt rechnen. Da musst du nichts mehr in Floats konvertieren.



1
2
3
4
5
6
7
8
9
10
11
irb(main):001:0> require "bigdecimal"
=> true
irb(main):002:0> x = BigDecimal.new("1.234")
=> #<BigDecimal:f60950,'0.1234E1',18(18)>
irb(main):003:0> y = BigDecimal.new("5.678")
=> #<BigDecimal:ffcdf0,'0.5678E1',18(18)>
irb(main):004:0> z = x + y
=> #<BigDecimal:f8bd80,'0.6912E1',18(27)>
irb(main):005:0> puts z
0.6912E1
=> nil


Nur so ist das Ergebnis mathematisch korrekt.

Was Floats angeht: die genauen Hintergründe der Funktionsweise sind zwar interessant, aber oft nicht wichtig. Das einzige, was du dir diesbezüglich merken solltest ist: Keine Floats benutzen, wenn du mathematisch richtige Ergebnisse haben willst. Oft bricht man das auf die Faustformel „Floats sind ungenau“ herunter, was aber inhaltlich (siehe meine Vorposter) oberflächlich ist. Brauchst du freilich keine mathematisch richtigen Ergebnisse und kannst mit den oftmals nur kleinen Differenzen leben, dann sind Floats in Ordnung. Denn im Gegensatz zu BigDecimal sind Floats sehr viel performanter in der Berechnung.

Vale,
Quintus

_________________
Habe den Mut, dich deines eigenen Verstandes zu bedienen! — Immanuel Kant

Ich bin freischaffender Softwareentwickler und freue mich über jedes neue Projekt. Kontaktinformation auf meiner Website.

Mein Blog | GitHub-Profil | Auf Twitter: @qquintilianus | PGP/GPG-Schlüssel: B1FE 958E D5E8 468E AA20 8F4B F1D8 799F BCC8 BC4F


Nach oben
 Profil  
 
BeitragVerfasst: 29 Jun 2016, 07:45 
Offline
Nuby

Registriert: 23 Jun 2016, 11:48
Beiträge: 7
Wohnort: hessen
hallo quintus, auch dir danke für deinen beitrag.

allerdings bin ich erstmal weg vom zahlentyp ^^

mein "kleines einfaches" einstiegsprog entwickelt sich zu einer qual.

bisher gelöst:
-nur zahlen;",";"." und "- als vorzeichen" werden angenommen
(und das ^..warum auch immer - bei eingabe 333^33 wird 33 als eingabe genommen)
-kommt , oder . vor - wird geprüft ob an erster stelle, dann zahl=zb 0.7
-x*, wird in x*. gewandelt und dann zahl geleert..später mal soll das dann als
trennzeichen verwendet werden 1000_000_000 so in der art..zur zeit noch überflüssig
- nur +-*/ als operator angenommen


jetzt die neuen probleme ^^
ich möchte kein unnötig dicken code haben. hätte ich aber, wenn ich das bisher für zahl1 funktionierende kopiere und einfüge und für zahl2 nehme..
deswegen meine idee:
die .,- bearbeitung in eine funktion und da bearbeiten lassen - klappt
ich bekomm nur das ergebnis nicht zurück
bsp:


1
2
z.gets.chomp
#=>,8

dez(zahl)
- in dez wird bearbeitet -> klappt
zurück ist z wieder ,8
habs mit


1
2
3
4
5
6
 def dez(z)
if z.count(",")!=o then
code
puts z
end
end


getestet..

habs auch mit:


1
2
3
4
5
6
7
8
9
z=0
def dez(z)
hier code
end
loop
zahl eingeben, pr��fen
dez(z)
puts z
end

probiert..z ist in dez bearbeitet und wird so ausgegeben,back in loop is z wieder 0 (als beispiel)
hmmmmmmmmm globale variablen ussten glaub mit nem zeichen davor angesprochen werden...nochmal querlesen..

naja...jetzt erstmal bei wow n bisschen raiden..dann gehts weiter ^^

bis dann
martin


Zuletzt geändert von NobbZ am 29 Jun 2016, 07:56, insgesamt 1-mal geändert.
Code-Tags


Nach oben
 Profil  
 
BeitragVerfasst: 29 Jun 2016, 08:01 
Offline
Metaprogrammierer

Registriert: 20 Nov 2011, 21:51
Beiträge: 693
Ich habe noch mal wieder Code-Tags eingestreut, bitte tu das in Zukunbft selbst, macht es um eininges Einfacher deinen Code zu lesen.

Ansonsten ist mir nicht ganz klar, was deine dez Methode überhaupt machen soll. Due erzählst etwas von zurückgeben, aber in der einen Version ist das letzte was du machst eine Ausgabe erzeugen und in der anderen Version tust du gar ncihts (ich gehe davon aus das in Version 2 alle nicht validen Zeilen eigentlich Kommenatare sein sollen).

Dann wieder schreibst du das sich z nbicht ändert, du veränderst z ja aber auch nicht.

Bitte beschreibe etwas genauer was denn dein Ansinnen ist.

_________________
Ubuntu Gnome 14.04 LTS
rvm mit App-spezifischer Ruby-Version (meist 2.2.x) und -Gemset

Github ProfilBitbucket Profil


Nach oben
 Profil  
 
BeitragVerfasst: 29 Jun 2016, 08:12 
Offline
Nuby

Registriert: 23 Jun 2016, 11:48
Beiträge: 7
Wohnort: hessen
hallo nobbz, danke fürs code taggen..wrd zukünftig drauf achten..

und ja, in dem gepostetetn beispiel ist kein code in der dez vorhanden..
weil ich davon ausging, die/der leser wird verstehen, dass ich nicht 50 zeilen code posten möchte,,kann ich aber gerne tun..

der code in der dez funktioniert..zahl ,8 oder .8 wird nach 0.8 gewandelt
zahl -,8 oder -.8 wird nach -0.8 gewandelt..

nochmal zur erklärung:
schleife
eingabe zahl
dez aufrufen
---> in dez wird auf .,- geprüft und zahl entsprechend bearbeitet
zurück in schleife ist z unbehandelt. -> ich möchte diein dez die bearbeitete zahl in der schleife haben
schleife ende


soweit verständlich?


Nach oben
 Profil  
 
BeitragVerfasst: 29 Jun 2016, 08:33 
Offline
Nuby

Registriert: 23 Jun 2016, 11:48
Beiträge: 7
Wohnort: hessen


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

puts":MEIN xter Versuch"
tmpz=0
z1=0
op=""
loop do
print"Endlosberechnung -- exit beendet das programm \n"
while z1==0 or z1=="" do
print "Eingabe: \n"
z1 = gets.chomp
puts" Z1 #{z1} \n"
if z1 =~ /[0-9,.-]+$/ # nur zahlen , . und - erlaubt....Fehler: ^ geht auch
puts "Der String lautet: " + $&
end
end
#____________________________________________________________________
#<-------------- Komma ermitteln und bearbeiten ------------------>
# DAS IST IN VERSION XYZ IN DEZ AUSGELAGERT!!!!!!!!!!!!!!!!!!!!!!!!!!
#---------------------------------------------------------------------
while z1.count(",") !=0 do #jedes , wird zum punkt
if z1.index(",")== 0 and z1.length !=1 then
z1="0." + z1[z1.index(",")+1,z1.length] # , wird . und 0.
elsif z1.index(",")!= 0 and z1.index(",") != z1.length then
z1=z1[0,z1.index(",")] +"."+ z1[z1.index(",")+1,z1.length] # string wird bearbeite
else
print"Bitte NUR ^1x , eingeben \n"
z1=0
end
#print z1.count(",")
print " #{z1} \n _____\n"
#gets
end
#*********************************************************************
#<------------------- Anzahl und Position von Punkt(en)-------------->
#____________________ Mehrfach vorkommen von Punkt leert str__________
if z1.count(".") ==1 then #jedes , wird zum punkt
if z1.index(".")== 0 and z1.length>1 then
z1="0." + z1[z1.index(".")+1,z1.length]
print " #{z1} \n ****\n" # , wird . und 0.
end
end
#===================wenn -, oder -. am anfang stehen nach -0. umwandeln====
if z1.count("-")==1 then
#print"1x - gefunden \n0"
if z1.count("-")==1 and z1.count(".")==1 then
#print "1x - 1x . gefunden \n"
if z1.index("-")==0 and z1.index(".")==1 then
#print "bearbeite -. \n"
z1="-0." + z1[z1.index(".")+1,z1.length]
#print " #{z1} \n _____\n"
end
end
end
#<-------------- wenn mehr als 1 Komma bzw Punkt vorkommt clear string----->
#---------------------------------------------------------------------------
if z1.count(".")>1 or z1.count("-")>1 then
print "Fehlerhafte Eingabe! Bitte NUR 1x punkt,komma,minus! \n"
z1=0
end
#<------------------------------------------------------------------------->
#==================== operator w��hlen ======================================
if tmpz==0 then
print "Rechenoperation (+|-|*|/)? "
# Operator einlesen und anschliessenden Zeilenumbruch entfernen
op = gets.chomp
# Gueltigkeit des Operators pruefen
while op !~ /^[\+\-\*\/]$/
puts "Ungueltige Operation: #{op}"
puts
op=gets.chomp
end
tmpz=z1 #<--zwischenzahl bekommt wert
z1=0 #<--z1 geleert f��r 2ten durchlauf
end
#**********************************************************************
# Ergebnis je nach Operator berechnen
if z1!=0 then
case op
when "+"
ergebnis = tmpz.to_f + z1.to_f
puts "Ergebnis:1 #{tmpz} #{op} #{z1} = #{ergebnis}"
tmpz=0
z1=0
op=""
when "-"
ergebnis = tmpz.to_f - z1.to_f
puts "Ergebnis: #{tmpz} #{op} #{z1} = #{ergebnis}"
tmpz=0
z1=0
op=""
when "*"
ergebnis = tmpz.to_f * z1.to_f
puts "Ergebnis: #{tmpz} #{op} #{z1} = #{ergebnis}"
tmpz=0
z1=0
op=""
when "/"
ergebnis = tmpz.to_f / z1.to_f
puts "Ergebnis: #{tmpz} #{op} #{z1} = #{ergebnis}"
tmpz=0
z1=0
op=""
end
end
if z1 =~ %r(^exit$)i
puts "Verlasse das Programm..."
break
end
end

----------------------------------------------------------------------------------


1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

# ->> VERSION Dienstag/mittwoch 28/29.6 <<-
z=""
x=0
zahlB=false
z1=Array.new
def dez(z)
#++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#----------------------------------------------------------------------------------------------
#<<<<<<<<<<<<<<<<< Vorkommen von ./,/- pr��fen und ggf umwandeln >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
#_____________________________________________________________________________________________
while z.count(",") !=0 do #jedes , wird zum punkt
puts " ,-COUNT #{z.count(",")} \n ___________"

if z.index(",")== 0 and z.length !=1 then
z="0." + z[z.index(",")+1,z.length]

puts z

return z

# , wird . und 0.
elsif z.index(",")!= 0 and z.index(",") != z.length then
z=z[z.index(",")] +"."+ z[z.index(",")+1,z.length] # string wird bearbeite
else
print"Bitte NUR ^1x , eingeben \n"
z=0
end
end
print " #{z} \n __BB___\n"
end
loop do
puts "#{x} ******* X start \n"

print "Eingabe Zahl 1: "
z = gets.chomp
if z =~ /^[0-9|,|.|-]+$/
puts "Die eingegeben Zahl lautet: " + $&
zahlB=true
puts " #{z} \n "
dez(z)

puts "#{z} NACH DEZ -----------\n"
gets
elsif z =~ %r(^exit$)i
puts "Verlasse das Programm..."
break
end

if zahlB==true then
puts "#{z} xxxx \n"
zahlB=false
x=x+1
puts " X wird hochgez��hlt __ #{x}\n"
#puts z.count
end
end

in der dez-version findet keine rechnung statt es geht mir hier erstmal nur um die rückgabe der bearbeiteten eingabe...ich will erstmal die übergabe der variable haben..
besser?


Nach oben
 Profil  
 
BeitragVerfasst: 29 Jun 2016, 16:13 
Offline
Metaprogrammierer

Registriert: 20 Nov 2011, 21:51
Beiträge: 693
Die folgenden Punkte sind zwar nicht das Problem, aber generelle Aspekte des Software-Designs und sollten von dir entsprechend umgesetzt werden um die Nachvollziehbarkeit und Wartbarkeit zu erhöhen. Im Moment hast du halt eher Imperativen Spaghetti-Code und nutzt Rubys stärken nicht wirklich.

  • Einrückung. Innerhalb der Rubycommunity hat man sich auf eine Einrückung von 2 Spaces je Ebene geeinigt.
  • Schleifen mit break zu beenden macht den Code schwer nachvollziehbar
  • Üblicherweise werden die when auf die gleiche Ebene gestellt wie das dazugehörige case, wärend die Blöcke eine Ebene Tiefe stehen.
  • Du solltest versuchen Verantwortlichkeiten zu erkennen und entsprechende Blöcke zu externen Objekten oder zumindest Methoden auszulagern.

Ansonsten versuche bitte den Code den du uns präsentierst auf das wesentliche Problem einzudampfen. Manchmal kann man dazu den bereits existierenden Code kürzen, manchmal muss man mit einem leeren Blatt Papier anfangen das Problem nachzustellen.

Dieses Einkürzen hat ein paar Vorteile, sowohl für dich als auch für potentielle Helfer.

Du machst dir selber noch einmal Gedanken um dein Problem, manchmal findet man dabei sogar selber eine Lösung.
Durch den kurzen Code, kann ein Helfer sich schneller einen Überblick verschaffen.
Mögliche Seiteneffekte werden in solch einem Snippet deutlich reduziert.

_________________
Ubuntu Gnome 14.04 LTS
rvm mit App-spezifischer Ruby-Version (meist 2.2.x) und -Gemset

Github ProfilBitbucket Profil


Zuletzt geändert von Quintus am 29 Jun 2016, 17:34, insgesamt 1-mal geändert.
[list]-Tag korrigiert


Nach oben
 Profil  
 
BeitragVerfasst: 30 Jun 2016, 01:35 
Offline
Nuby

Registriert: 23 Jun 2016, 11:48
Beiträge: 7
Wohnort: hessen
kannst den thread und meinen account löschen

ich werd wohl lieber eine verbreitetere sprache lernen

ablaufgesteuerte programmierung war damals bei qbasic schon ätzend.

bin dann mal wech
bb


Nach oben
 Profil  
 
BeitragVerfasst: 30 Jun 2016, 09:22 
Offline
Metaprogrammierer

Registriert: 20 Nov 2011, 21:51
Beiträge: 693
Ruby hat schon eine große Community, leider ist die deutschsprachige Community sehr zersplittert und trifft sich lieber in Mini-Confs und lokalen Usergroups statt im Internet.

Ausserdem bin ich mir gerade nicht sicher was du mit „ablaufgesteuerte Programmierung“ meinst.

Wir versuchen ja dir zu helfen, aber in einem Post lässt du den wesentlichen Teil weg, weil du 500 Zeilen Code für unzumutbar hälst, keine 20 Minuten später haust du uns eben genau diese 500 Zeilen Code um die Ohren, total strukturlos.

Ich habe als Reaktion darauf versucht dir ein paar Tips zu geben, wie du die Warscheinlichkeit erhöhen kannst, dass dir jemand hilft. Und die Tipps gelten ehrlich gesagt in dieser oder ähnlicher Form für alle Sprachen.

Und falls du bei deinem Wechselwunsch bleibst, noch ein letzter Tipp: lass für den Anfang die Finger vom Taschenrechner. Dieser ist nicht als Einstieg in die Programmierung geeignet, sondern als Einstieg in die Parserprogrammierung, eine wirklich fortgeschrittene Disziplin.

_________________
Ubuntu Gnome 14.04 LTS
rvm mit App-spezifischer Ruby-Version (meist 2.2.x) und -Gemset

Github ProfilBitbucket Profil


Nach oben
 Profil  
 
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 15 Beiträge ] 

Alle Zeiten sind UTC + 1 Stunde [ Sommerzeit ]


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 3 Gäste


Du darfst keine neuen Themen in diesem Forum erstellen.
Du darfst keine Antworten zu Themen in diesem Forum erstellen.
Du darfst deine Beiträge in diesem Forum nicht ändern.
Du darfst deine Beiträge in diesem Forum nicht löschen.
Du darfst keine Dateianhänge in diesem Forum erstellen.

Suche nach:
cron