From 34932ff30ffcf7d381cfb2f3b32fa1e17acffe3b Mon Sep 17 00:00:00 2001 From: Ratten Date: Sun, 20 Mar 2022 19:07:04 +0100 Subject: [PATCH] =?utf8?q?Ip-Berechnungen=20hinzugef=C3=BCgt,=20Fragen=20e?= =?utf8?q?rweitert,=20Fehler=20ausgebaut?= MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit --- Fragen.txt | 156 +++++++++----- README | 55 ++++- lerne.py | 604 +++++++++++++++++++++++++++++++++++++++++++---------- 3 files changed, 634 insertions(+), 181 deletions(-) diff --git a/Fragen.txt b/Fragen.txt index a6c3f04..615811b 100644 --- a/Fragen.txt +++ b/Fragen.txt @@ -1,126 +1,168 @@ 1. Frage: Ein Handelsvertreter bekommt $Variable % Provision vom Umsatz sowie ein Monatliches Fixum in Höhe von $Variable € ; ein Reisender erhält $Variable % bei einem Fixum von $Variable €. Bei welchem Monatsumsatz sind die Kosten der Absatzhelfer gleich? -Variable: 6.5, 1200, 2.5, 3000 +Variable: f_6.5, i_1200, f_2.5, i_3000 Hint: var2 + (var1/100)x = var4 + (var3/100)x -Hint2: var2 + (var1/100)x = var4 + (var3/100)x |-(var3/100)x; var2 + (var1/100 - var3/100)x = var4 |-var2; (var1/100 - var3/100)x = var4 - var2; (var1/100 - var3/100))x=(var4 - var2) |/(var1/100 - var3/100) +Hint2: var2 + (var1/100)x = var4 + (var3/100)x |-(var3/100)x; var2 + (var1/100 - var3/100)x = var4 |-var2; (var1/100 - var3/100)x = var4 - var2; (var1/100 - var3/100)x=(var4 - var2) |/(var1/100 - var3/100) Rechnung: (var4 - var2)/(var1/100 - var3/100) -Antwort= 45000 +Antwort= f 2. Frage: Ein Betrieb hat einen Gesamtumsatz von $Variable € bei $Variable € Kosten. Wie lautet die Wirtschaftlichkeitskennziffer? -Variable: 150000, 140000 +Variable: i_150000, i_140000 Hint: Wirtschaftlichkeit= Leistung/Kosten Hint2: var1/var2 Rechnung: var1/var2 -Antwort= 1.07 +Antwort= f 3. Frage: Ein Unternehmer hat ein Eigenkapital in Höhe von $Variable € ins Unternehmen eingbracht und nach Abzug aller Aufwendungen (inklusive seines Unternehmerlohns) einen Gewinn von $Variable € erziehlt. Wieviel Prozent beträgt die Eigenrentabilität? -Variable: 75000, 15000 +Variable: i_75000, i_15000 Hint: Eigenkapitalrentabilität=(Gewinn * 100%)/Eigenkapital Hint2: (var2 * 100) /var1 Rechnung: (var2 * 100) /var1 -Antwort=20 +Antwort= f 4. Frage: Ein Fachinformatiker kann $Variable Server in $Variable Stunden bereitstellen. Wie hoch liegt die Produktivität? -Variable: 30, 8 +Variable: i_30, i_8 Hint: Produktivität = megenmäßige Ausbringung (Stückanzahl) / megenmäßiger Einsatz (Zeit) Hint2: var1/var2 Rechnung: var1/var2 -Antwort= 3.75 +Antwort= f 5. Frage: Ein Computer hat eine Uptime von $Variable Tagen und eine Downtime von $Variable Tagen. Wie hoch ist die Verfügbarkeit? -Variable: 350, 15 +Variable: i_350, i_15 Hint: Verfügbarkeit= (Uptime / Uptime + Downtime) * 100 -Hint2: (var1 / var1 + var2) * 100 -Rechnung: (var1 / var1 + var2) * 100 -Antwort= +Hint2: (var1 / (var1 + var2)) * 100 +Rechnung: (var1 / (var1 + var2)) * 100 +Antwort= f 6. Fragen: In einem Jahr wurden $Variable € erwirtschaftet, im gleichen Zeitraum wurden $Variable € an Aufwendungen aufgebracht. Wie hoch ist die Wirtschaftlichkeit? -Variable: 150000, 140000 +Variable: i_150000, i_140000 Hint: Wirtschaftlichkeit= Ertäge /Aufwendungen Hint2: var1 / var2 Rechnung: var1 / var2 -Antwort= 1.07 +Antwort= f 7. -Fragen: Ein Unternehmer hat ein Eigenkapital in Höhe von $Variable € ins Unternehmen eingebracht und nach Abzug allerr Aufwendungen (inklusive seines Unternehmerlohnes) einen Gewinn von $Variable € erziehlt. Wie viel Prozent beträgt die Eigendkapitalrentabilität? -Variable: 75000, 15000 +Fragen: Ein Unternehmer hat ein Eigenkapital in Höhe von $Variable € ins Unternehmen eingebracht und nach Abzug aller Aufwendungen (inklusive seines Unternehmerlohnes) einen Gewinn von $Variable € erziehlt. Wie viel Prozent beträgt die Eigendkapitalrentabilität? +Variable: i_75000, i_15000 Hint: Eigenkapitalrentabilität = (Gewinn * 100 %) / Eigenkapital Hint2: (var2 * 100%)/ var1 Rechnung: (var2 * 100%)/ var1 -Antwort= 20% +Antwort= f 8. -Fragen: Ein Betrieb hat einen Gesamtumsatz von $Variable € bei $Variable € Kosten. Wie hoch ist die Wirtschaftlickeitskeitskennziffer? -Variablen: 150000, 140000 +Fragen: Ein Betrieb hat einen Gesamtumsatz von $Variable € bei $Variable € Kosten. Wie hoch ist die Wirtschaftlickeitskennziffer? +Variable: i_150000, i_140000 Hint: Wirtschaftlichkeit= Leistung /Kosten Hint2: var1 / var2 Rechnung: var1 / var2 -Antwort= 1.07 +Antwort= f 9. Fragen: Ein Unternehmen hat ein Eigenkapital von $Variable € jedoch insgesamt $Variable € an Kapital zur Verfügung. Wie hoch ist die Eigenkapitalsquote? -Variablen: 300000, 500000 +Variable: i_300000, i_500000 Hint: Eigendkapitalsquote= (Eigenkapital /Gesamtkapital) * 100 Hint2: (var1 /var2) * 100 -Rechnug: (var1 /var2) * 100 -Antwort= +Rechnung: (var1 /var2) * 100 +Antwort= f 10. Fragen: Es sind folgende Vorraussetzungen gegeben: Fixkosten= $Variable €; Variable Kosten= $Variable €; Preis= $Variable €. Wie hoch ist die Gewinnschwelle? -Variablen: 10000, 200, 300 +Variable: i_10000, i_200, i_300 Hint: Gewinnschwelle = Fixkosten / (Preis - Variable Kosten) Hint2: var1 / (var3 - var2) -Rechnug: var1 / (var3 - var2) -Antwort= 100 +Rechnung: var1 / (var3 - var2) +Antwort= f 11. -Fragen: Das Unternehmene IT-Selutions GmbH verkauft pro Jahr $Variable PCs zu je $Variable € , dabei kosten die Platinen $Varaible €, das Gehäuse $Variable €. Wie hoch ist der Deckungbeitrag pro Stück? -Variablen: 100, 350, 15, 10 +Fragen: Das Unternehmene IT-Selutions GmbH verkauft pro Jahr $Variable PCs zu je $Variable € , dabei kosten die Platinen $Variable €, das Gehäuse $Variable €. Wie hoch ist der Deckungbeitrag pro Stück? +Variable: i_100, i_350, i_15, i_10 Hint: Deckungsbetrag = Verkaufspreis - variable Kosten -Hint2: var2 - var3 - var2 -Rechnug: var2 - var3 - var2 -Antwort= +Hint2: var2 - var3 - var4 +Rechnung: var2 - var3 - var4 +Antwort= i 12. Fragen: Das Unternehmene IT-Selutions GmbH verkauft pro Jahr $Variable PCs zu je $Variable € , dabei kosten die Platinen $Variable €, das Gehäuse Variable €. Wie hoch ist der Deckungsbeitrag? -Variablen: 100, 350, 15, 10 +Variable: i_100, i_350, i_15, i_10 Hint: Deckungsbetrag = (Verkaufspreis - variable Kosten) * Menge Hint2: (var2 - var3 - var2) * var1 -Rechnug: (var2 - var3 - var2) * var1 -Antwort= +Rechnung: (var2 - var3 - var2) * var1 +Antwort= i 13. Fragen: Auf einem Akku für $Variable V ist der Wert $Variable mAh angegeben. Wie lange hält der Akku bei einer konstanten Stromentnahme von $Variable mA? -Variablen: 12, 1.5, 0.5 +Variable: i_12, f_1.5, f_0.5 Hint: t=Q/I Hint2: Zeit= var2 / var3 -Rechnug: var2 / var3 -Antwort=3 +Rechnung: var2 / var3 +Antwort= f 14. Fragen: Das Lager des ITDZ hat am Anfang des Jahres insgesamt $Variable Laptops gelagert, am Ende des Jahres sind es nur noch $Variable Laptops. Wie lautet der durchschnittlicher Lagerbestand? -Variablen: 500, 150 +Variable: i_500, i_150 Hint: Lagerbestand=(Anfangsbestand+Endbestand)/2 Hint2: (var1 + var2) / 2 -Rechnug: (var1 + var2) / 2 -Antwort=325 +Rechnung: (var1 + var2) / 2 +Antwort= f 15. -Fragen: Im ITDZ-Lager liegt der Tagesbedarf an Laptops bei $Variabel Laptops, die Beschaffungszeit von Laptops liegt bei $Variable Monaten. Es wurde festgelegt das der Mindestbestand an Laptops im Lager $Variable ist. Wie hoch ist der Meldebestand? -Variablen: 3, 3, 10 +Fragen: Im ITDZ-Lager liegt der Tagesbedarf an Laptops bei $Variable Laptops, die Beschaffungszeit von Laptops liegt bei $Variable Monaten. Es wurde festgelegt das der Mindestbestand an Laptops im Lager $Variable ist. Wie hoch ist der Meldebestand? +Variable: i_3, i_3, i_10 Hint: Meldebestand = (Tagesbedarf * Beschaffungszeit)+ Mindestbestand Hint2: (var1 * var2) + var3 -Rechnug: (var1 * var2) + var3 -Antwort= +Rechnung: (var1 * var2) + var3 +Antwort= i 16. Fragen: In der nextGeneration GmbH wurden im letzten Jahr $Variable € Umsatzerlöse erziehlt, bei einem Gesamtkapital von $Variable €. Wie hoch ist die Umschlagshäufigkeit? -Variablen: 35000, 45000 +Variable: i_35000, i_45000 Hint: Gesamtkapitalumschlagshäufigkeit = Umsatz /Gesamtkapital Hint2: var1/var2 -Rechnug: var1/var2 -Antwort= +Rechnung: var1/var2 +Antwort= f 17. Fragen: Berechnen Sie die Kosten für die Energieversorung des Blade Servers bei voller Bestückung ($Variable Blades) für die Energieversorung pro Jahr (365 Tage). Der Server verbraucht druchschnittlich $Variable W. Nehmen Sie einen Preis von $Variable € pro Kilowattstunde an. Wie hoch sind die Kosten. -Variablen: 16, 240, 0.30 -Hint: Leistung = Anzahl der Server * Verbrauch, Watt = Leistung * 24h * Tage im Jahr, Kosten = Watt * Preis -Hint2: Leistung = var1 * var2, Watt = Leistung * 24 * 365, Kosten = Watt * var3, W = P * t -Rechnug: ((var1 * var2) * 24 * 365 ) * var3 -Antwort= +Variable: i_16, i_240, f_0.30 +Hint: Leistung = Anzahl der Server * Verbrauch, Watt = Leistung * 24h * Tage im Jahr, KiloWatt= Watt / 1000, Kosten = Watt * Preis +Hint2: Leistung = var1 * var2, Watt = Leistung * 24 * 365, kWh= Watt / 1000, Kosten = kWh * var3, W = P * t +Rechnung: (((var1 * var2) * 24 * 365 ) /1000 )* var3 +Antwort= i 18. -Fragen: Folgende Systeme sollen über eine USV überbrückt werden: $Variable Router mit 230V bei $Variable A; $Variable Server mit 230V bei $Variable A; $Variable Switche mit 230V bei $Variable A. (Alle Angeben pro Gerät). Wie hoch ist die Scheinleistung des gesamten Netzwerks? -Variablen: 1, 1.5, 3, 1, 2, 0.5 +Fragen: Folgende Systeme sollen über eine USV überbrückt werden: $Variable Router mit 230V bei $Variable A; $Variable Server mit 230V bei $Variable A; $Variable Switche mit 230V bei $Variable A. (Alle Angaben pro Gerät). Wie hoch ist die Scheinleistung des gesamten Netzwerks? +Variable: i_1, f_1.5, i_3, i_1, i_2, f_0.5 Hint: Leistung = Stromstärke * Spannung, P = U * I Hint2: ((var2 * 230 V) * var1) + ((var4 * 230 V) * var3) + ((var6 * 230 V) * var5) -Rechnug: ((var2 * 230 V) * var1) + ((var4 * 230 V) * var3) + ((var6 * 230 V) * var5) -Antwort= +Rechnung: ((var2 * 230 V) * var1) + ((var4 * 230 V) * var3) + ((var6 * 230 V) * var5) +Antwort= i +19. +Fragen: Im ITDZ soll ein Neues Netzwerk eingerichtet werden. Das Netzwerk hat die Netzmaske $Variable. Wieviele Computer können in dem Netzwerk mit IP-Adressen versorgt werden? +Variable: nm_255.255.192.0 +Hint: Netzmaske in CIDR Notation umwandeln, Netzaddresse und Broadcastaddresse abziehen +Hint2: var1 = binär = CIDR = (2^(32- CIDR))-2 +Rechnung: (2^(32- CIDR ))-2 +Antwort= i +20. +Fragen: Im Ausbildungszentrum soll ein Netzwerk eingerichtet werden mit der Netzmaske $Variable. Es gibt bereits einen Rechner mit der IP-Adresse $Variable. Berechne die NetzwerkID, Broadcast und Anzahl der nutzbaren Hosts. +Variable: nmC_/24, ip_192.168.1.1 +Hint: 2^(32 - Netzmaske) - NetzID - Bradcastadresse = Anzahl der Nutzbaren Hostadressen; IP und Netzmaske= Netid; Broadcast=Netzid+Anyzahl der IP-Adressen -1 +Hint2: 2^(32 - var1) -2 = Anzahl der Nutzbaren Hostadressen; var2 und var1 = Netzwerkadresse; nid + i -1= Broadcast +Rechnung: 2^(32 - var1) -2 =i; var2 und var1 =nid; nid + i -1 =br +Antwort= i, nid, br +21. +Fragen: Berechne von $Variable mit der $Variable die mögliche Anzahl an Subnetzen +Variable: ip6_2001:fa23:0912:def3:1234:def3:1234:000a, nm6_/50 +Hint: bei ipv6 handelt es sich um eine /128 großen Addressraum, ziehe die Netzmaske deswegen ab +Hint2: 64 - var2 +Rechnung: 64 - var2 +Antwort= i +22. +Fragen: Johannes Maier verdient $Variable € brutto im Monat. Berechne den Arbeitnehmeranteil des Krankenkassenbeitrages. Verwende als allgemeinen Beitragssatz $Variable % +Variable: i_3860, f_7.3 +Hint: Arbeitnehmeranteil= Gehalt * Beitragssatz % +Hint2: (Arbeitnehmeranteil= var1 * var2 / 100) / 2 +Rechnung: (var1 * var2 / 100) /2 +Antwort= f +23. +Fragen: Lisa Müller verdient $Variable € brutto im Monat. Berechne den Arbeitnehmeranteil für die Arbeitslosenversicherung. Verwende als Beitragssatz zur Arbeitslosenversicherung $Variable % +Variable: i_4850, f_2.4 +Hint: Arbeitnehmeranteil= Gehalt * Beitragssatz % +Hint2: (Arbeitnehmeranteil= var1 * var2 / 100) / 2 +Rechnung: (var1 * var2 / 100)/2 +Antwort= f +24. +Fragen: Alice ist eine $Variable Jahre alte Muslimin die $Variable € brutto im Monat verdient. Berechne den Auszahlungsbetrag von Alice. Folgende weitere Informationen sind gegeben: Lohnsteuer: $Variable ; Allgemeiner Krankenkassenbeitrag: $Variable %; Kassenindividueller Zusatzbeitrag: $Variable %; Pflegeversicherungssatz: $Variable %; Arbeitslosenversciherungssatz: $Variable %; Rentenversicherungssatz $Variable % +Variable: i_23, i_4850, f_1020.5, f_14.4, f_0.9, f_3.05, f_2.4, f_18.6 +Hint: Brottolohn + Vermögenswirksame Leistungen - Lohnsteuer - Kirchensteuer - Krankenversicherungsbeitrag - Pflegeversicherungsbeitrag - Arbeitslosenversicherungsbeitrag = Nettolohn - VermögenswirksameLeitungen = Auszahlungsbetrag +Hint2: var2 - var3 - Kirchensteuer - ((((var2 - var3)*(var4 + var5)) / 100) / 2) - ((((var2 - var3)* var6) / 100) - ((((var2 - var3)* var7) / 100) - ((((var2 - var3)* var8) / 100) = Nettolohn +Rechnung: var2 - var3 - ((((var2 - var3)*(var4 + var5)) / 100) / 2) - (((var2 - var3)* var6) / 100) - (((var2 - var3)* var7) / 100) - (((var2 - var3)* var8) / 100) +Antwort= f diff --git a/README b/README index fa0fb86..c6e685a 100644 --- a/README +++ b/README @@ -1,32 +1,69 @@ Dieses Programm ist dazu gedacht einfache Rechenaufgaben, die in der Fachinformatikerausbildung vorkommen zu üben. Dazu werden die Zahlen in der Datei Fragen.txt durch Zufallszahlen ersetzt. Dann werden die Fragen gestellt und die Antwort muss errechnet werden. Wenn nichts oder ein falsche Ergebnis eingegeben wird, gibt es bis zu zwei Hinweise zur Berechnung. -Für richtige Antworten gibt es Punkte, für jeden Hinweis werden Punkte abgezogen und bei einer falschen Antwort werden die Puhnkte für die richitge Antwort abgezogen. Die Fragen werden in Zufälliger Reihenfolge gestellt. + +Für richtige Antworten gibt es Punkte, für jeden Hinweis werden Punkte abgezogen und nach 3 falschen Versuchen werden die Punkte für die richtige Antwort abgezogen. Die Fragen werden in Zufälliger Reihenfolge gestellt. +Nach jeder Runde werde die beantworteten Fragen mit in die Reihenfolge hinzugefügt Die Aufgaben können erweitert werden nach folgendem Schema: + 1. #Hier wird die Anzahl der Fragen identifiziert Frage: #Hier wird die Frage gestellt, dabei müssen alle Zahlen die durch das Programm mit Zufallszahlen ersetzt werden sollen, als "$Variable" geschreiben werden. zBsp: + Der montaliche Umsatz beträgt 2500 €, davon sind 25 % Fixkosten. wird zu: Der montaliche Umsatz beträgt $Variable €, davon sind $Variable % Fixkosten. -In der nächsten Zeile Variable: müssen die Zahlen in der Reihenfolge in der sie in der Frage vorkommen aufgeschreiben werden. +In der nächsten Zeile Variable: müssen die Zahlen in der Reihenfolge in der sie in der Frage vorkommen aufgeschreiben werden. Dabei muss der Zahlentyp mit angegeben werden. + +Folgende Zahlentypen gibt es: + +i_ für Integerzahlen +f_ für alle Kommazahlen +ip_ für ipv4-Addressen +ip6_ für ipv6-Addressen +br_ für broadcast-Adressen +nid_ für NetzAdressen +nmC für Netzmasken in CIDR-Notation +nm_ für Netzmasken in Dezimalpunktschreibweise +nm6 für Netzmasken für Netzmasken in ipv6 +0x für Hexadezimalzahlen +2_ für Dualzahlen Die Zeile Variable kann beispiels weise so aussehen: -Variable: 6.5, 1200, +Variable: f_6.5, i_1200, ip_192.168.1.1 mn_/24 ip6_2002:d80:: nid_192.168.7.0 -Als nächste Zeile folgt der erste Hinweis, dies kann ein Hinweis auf die Formel sein. Wenn dort var gefolgt von einer Nummer steht, wird dies als Varable behandelt und die generierte Zufallszahl für die Variable eingesetzt. Dabei steht die Zahl für nummer der Variable in der Zeile Variable. -Wenn dort also var2 steht ist die zweite Varaible in der Zeile Variable gemeint. +Als nächste Zeile folgt der erste Hinweis, dies kann ein Hinweis auf die Formel sein. Wenn dort var gefolgt von einer Nummer steht, wird dies als Variable behandelt und die generierte Zufallszahl für die Variable eingesetzt. Dabei steht die Zahl für Nummer der Variable in der Zeile Variable. +Wenn dort also var2 steht ist die zweite Variable in der Zeile Variable gemeint. Hint: var2 * Fixkosten. -Der zweite Hinweis wird in der nächsten beinhaltet die Formel wo alle Variabeln durch die entsprechenden Ihrer Zufallszahlen erstetzt werden. +Der zweite Hinweis wird in der nächsten beinhaltet, die Formel wo alle Variabeln durch die entsprechenden Ihrer Zufallszahlen erstetzt werden. + Hint2: var2 + (var1/100) In der nächsten Zeile wird die Rechnung die vom Programm ausgewertet um das Ergebis zu erhalten. Dabei werden nur folgende Zeichen als gültig angerkannt: + - . + * / ^ ( ) : -Die die Variabeln werden durch ihre entsprechenden Zufalls ersetzt, dannach werden alle anderen Zeichen durch "" ersetzt -Eine ausführbare Rechnung kann folgende sein + +Die die Variabeln werden durch ihre entsprechende Zufallzahl ersetzt, dannach werden alle anderen Zeichen durch "" ersetzt +Eine ausführbare Rechnung kann folgende sein: Rechnung: (var4 - var2)/(var1/100 - var3/100) -Die Zeile Antwort hat bisher noch keine Funktion, sollte aber trotzdem geschrieben werden, damit das Programm nicht durcheinader gerät. + +Die Zeile Antwort enthält das Format der Antwort, dabei steht: + +i für Integerzahlen +f für alle Kommazahlen +br für broadcast-Adressen +nid für Netzid im ipv4 Netzbereich +nid6 für Netzid im ipv6 Netzbereich +nmC für Netzmasken in CIDR-Notation +nm6 für Netzmasken für Netzmasken in ipv6 +nm für Netzmasken in Dezimalpunktschreibweise +0x für Hexadezimalzahlen +2_ für binär Zahlen + +Wenn mehrere Antworten gebraucht werden, zum Beispiel Bradcastadresse und Netzmaske in CIDR-Notation, werden die Formate mit Komma getrennt: +Antwort= br, nmC Das gesamte Programm wird unter GLPv3 gesetzt werden. Diese Lizenz wird bald hinzugefügt werden. + diff --git a/lerne.py b/lerne.py index 3f5fe80..93e03ed 100644 --- a/lerne.py +++ b/lerne.py @@ -1,21 +1,22 @@ #Dieses Programm dient zur Vorbereitung auf die Abschlussprüfung für FISIs. In diesem Programm werden nur Aufgaben gestellt die Berechnet werden müssen. -#casio fx981dex import random #Zufall import time #Zeit import datetime #Datum import linecache #Zeile aus Datei auslesen import operator #Operatoren als Funktionen bereit stellen +import re #für regex +import ipaddress #für ip-Adress berechnungen # Was wird gebraucht: # Gui -# User -# Punkte -# Aufgaben -# Zufallszahlen -# Berechnungen -# File mit Fragen und Antworten -# Fragen aus File auslesen +# User x +# Punkte x +# Aufgaben x +# Zufallszahlen x +# Berechnungen x +# File mit Fragen und Antworten x +# Fragen aus File auslesen x # DB Sqlite class user(): @@ -26,18 +27,26 @@ class user(): self.fights = 0 self.hint = 0 self.Monster=None + def levelUp(self): + print("neues Level erreicht") self.Level = self.Level + 1 - self.Punkte= self.Punkte - 10 + self.Punkte= self.Punkte - 10 + def hintcount(self): self.hint = self.hint + 1 print("in hintcount"+str(self.hint)) + def Reihenfolge(self): Folge=[] #Zufall=1 Datei=open("Fragen.txt","r") allnum=len(Datei.readlines()) Datei.close() + if (allnum % 7 != 0): + print("Fragen.txt fehlerhaft, Zeilenanzahl nicht korrekt") + exit() + #panic whenn mod7 nicht null ende=allnum /7 i=0 while (i < ende): @@ -47,43 +56,78 @@ class user(): i=i+1 Folge.append(Zufall) return Folge - def fighting(self): - hinweis=0 - self.fights=self.fights +1 - UserAntwort=input(self.Monster.Frage) - if UserAntwort == "": - UserAntwort=0 - while float(self.Monster.Antwort) != float(UserAntwort): + + def hinting(self,num): + hinweis=num + if hinweis < 2: if hinweis == 0: - print(self.Monster.Frage) print(self.Monster.Hint) - print(self.hint) - print(hinweis) self.hintcount() - hinweis=hinweis+1 - self.Punkte=self.Punkte -1 - UserAntwort=input() - if UserAntwort == "": - UserAntwort=0 - elif hinweis ==1: - print(self.Monster.Frage) - print(self.Monster.Hint) + hinweis=1 + else: print(self.Monster.Hint2) self.hintcount() - hinweis=hinweis+1 - self.Punkte=self.Punkte -1 - UserAntwort=input() - if UserAntwort == "": - UserAntwort=0 - elif hinweis >1: - print(self.Monster.Antwort) - self.Punkte=self.Punkte -3 - return self.fights + 1 - print(UserAntwort+" ist richtig") - self.Punkte= self.Punkte + Monster.Punkte - if (self.Punkte > self.Level*10): + hinweis=2 + else: + print("Frage verlohren") + hinweis=3 + #self.Monster.Losts(self.Monster.Frage.num) + #print("Hintnum="+str(hinweis)) + return hinweis + + def fighting(self): + hinweis=0 + AntwortWerte=[] + rightAnswer=0 + self.fights=self.fights +1 + UserAntwort=input(self.Monster.Frage) + + #liste mit Antworten erstellen + for Num in self.Monster.Antwort: + for art in self.Monster.Antwort[Num]: + #print(self.Monster.Antwort[Num][art]) + AntwortWerte.append(self.Monster.Antwort[Num][art]) + + #Antworten prüfen + while hinweis < 3 and not len(AntwortWerte) == 0: + + #schauen ob Antwort float ist + if str(UserAntwort).replace('.','',1).isdigit(): + UserAntwort=float(UserAntwort) + + if UserAntwort == "" and hinweis < 3: + print("keine Antwort gegeben") + hinweis=self.hinting(hinweis) + if not hinweis==3: + UserAntwort=input(self.Monster.Frage) + elif UserAntwort in AntwortWerte: + rightAnswer=rightAnswer+1 + print(str(UserAntwort)+" ist richtig") + AntwortWerte.remove(UserAntwort) + #print(str(AntwortWerte)+" Liste leer") + if len(AntwortWerte) > 0 : + UserAntwort=input(self.Monster.Frage) + else: + print("Antwort ist falsch") + hinweis=self.hinting(hinweis) + #print("Hintnum="+str(hinweis)) + if not hinweis==3: + UserAntwort=input(self.Monster.Frage) + + #print("Hintnum-Ende="+str(hinweis)) + self.Punkte=self.Punkte + rightAnswer + self.Punkte=self.Punkte - hinweis + if hinweis ==0: + self.Punkte=self.Punkte + self.Monster.Punkte + elif hinweis > 2: + self.Punkte=self.Punkte - self.Monster.Punkte + print("richige Antwort wäre:") + for ans in AntwortWerte: + print(ans) + if self.Punkte > self.Level*10 and self.Punkte > 10: self.levelUp() - return self.fights + 1 + self.fights=self.fights + 1 + hinweis=0 class monster(): def __init__(self, Frage, Antwort, Hint, Hint2): @@ -92,122 +136,452 @@ class monster(): self.Hint = Hint self.Hint2 = Hint2 self.Punkte= 5 + self.Losts=[] + self.won=[] + + def lostFights(self, num): + self.Losts.append(num) + + def wonFights(self, num): + #nummern der Kämpfe die Gewonnen wurden + self.won.append(num) + def fighting(self): - print(Frage) + Folge=User.Reihenfolge() + + if (self.Losts == 0) and (self.won == 0): + return Folge + else: + for i in self.won: + Folge.remove(i) + #gewonnene Fragen heraus fischen + Folge.extend(self.won) #weil eine Liste hinzugefügt wird + #verlorene Kämpfe in der Anzahl wie oft sie verlohren wurden hinzufügen + for j in self.lost: + Folge.append(i) + #folge durchschütteln + Folge=random.suffle(Folge) + return Folge +class Zufallvariabeln(): + def __init__(self, num): + self.num=num-1 + self.Variabeln=self.get_Vartype() + + def get_Vartype(self): + Types=["i", "f", "ip", "ip6", "nm", "nm6", "0x", "2_", "nmC"] + ZVariabeln={} + num=3+self.num *7 + ZufallVariablen=[] + Zeile=linecache.getline(r"Fragen.txt", num) + Zeile=Zeile.replace("Variable: ", "", 1) + Zeile=Zeile.replace("\n", "", 1) + Zeile=Zeile.split(", ") + Ztype=0 #zähl Variabel + #print("Zeile getVar"+str(Zeile))#debug + for Wert in Zeile: + Ztype=Ztype +1 + Vartype=Wert.split("_")[0] + Var=Wert.split("_")[1] + #print(Vartype+" Type") #debug + #print(str(Var)+" Wert") #debug + #print(Ztype)#debug + #Dictionary im Dictionary gebaut um besser auf die Variabeln zugreifen zu können + if Vartype == "i" or Vartype == "f": + ZVariabeln[Ztype]={Vartype :self.get_Zufall(Vartype, Var)} + elif Vartype == "0x": + ZVariabeln[Ztype]={Vartype:self.get_ZufallHexa(Var)} + elif Vartype == "2_": + ZVariabeln[Ztype]={Vartype :self.get_ZufallDual(Var)} + elif Vartype == "ip": + ZVariabeln[Ztype]={Vartype :self.get_ipZufall(Var)} + elif Vartype == "nm" or Vartype =="nmC": + ZVariabeln[Ztype]={Vartype :self.get_Zufallnetmask(Var)} + elif Vartype == "nm6": + ZVariabeln[Ztype]={Vartype :self.get_Zufallnetmask6(Var)} + elif Vartype == "ip6": + ZVariabeln[Ztype]={Vartype :self.get_ipZufall6(Var)} + #print("ZufallVar"+str(ZVariabeln[Ztype].values()))#debug + return ZVariabeln + + def get_ZufallHexa(self,hexa): + pass + def get_ZufallDual(self,dual): + pass + def get_ipZufall(self,ip): + zufallsip=[] + oktets=ip.split(".") + for oktet in oktets: + zufallsip.append(random.randrange(1, 255)) + while zufallsip[0] > 250: + zufallsip[0]=random.randrange(1, 250) + Variable=".".join(str(i) for i in zufallsip) + return Variable + + def get_Zufallnetmask(self,Var): + if Var.find("255") >= 0: + Var=[] + oktetnum=random.randrange(1, 5) + for oktet in range(1,5): + if oktet == oktetnum: + Bitnum=random.randrange(1, 8) + ONum=0 + #Damit keine schwierig zu berechen Netzmasken rauskommen + while Bitnum < 8 : + ONum= ONum + 2 ** Bitnum + Bitnum=Bitnum+1 + Var.append(str(ONum)) + elif oktet < oktetnum: + Var.append("255") + else: + Var.append("0") + Variable=".".join(Var) + else: + Variable="/"+str(random.randrange(8, 30)) + return Variable + + def get_Zufallnetmask6(self,Var): + Variable="/"+str(random.randrange(23, 64)) + return Variable + + def get_ipZufall6(self,ip): + Hexadez=[] + for cloum in range(1, 9): + newcolume=random.randrange(1, 65535) + Hexadez.append(str(hex(newcolume)[2:])) + Variable=":".join(Hexadez) + return Variable + #hex(newcolume) + #int(columns, 16) + + def get_Zufall(self,Datatype, VarWert): + Variable=[] + #print("in get_Zufall "+str(Datatype)+" Wert:"+str(VarWert))#debug + if Datatype == "i": + Groesse=len(VarWert) + start=10**(Groesse-1) + ende=10**(Groesse) + Variable=random.randrange(start, ende) + elif Datatype == "f": + Groesse=len(VarWert) + start=10*(Groesse-1) + ende=10*(Groesse) + Variable=round(random.uniform(start, ende),2) + #print("in get-Zufall-Ende"+str(Variable))#debug + return Variable + class Antworten(): - def __init__(self, num, Variabeln): - self.num=num -1 - self.Variabeln=Variabeln + def __init__(self,num, Zufallvariabeln): + self.num=num-1 + self.Variabeln=Zufallvariabeln.Variabeln self.antwort=self.Berechnung() + + def Berechnung(self): + Antw={} + AntAnz=0 + Antwort={} + + Rechnung=self.rechnung_ermitteln() + AntwortArt=self.AntwortArt_ermittlen() + + listeIP4=["ip","br","nid","nm","nmC"] + listeIP6=["ip6","nid6","nm6"] + + for j in listeIP4: + if j in AntwortArt: + Antwort[AntAnz]={j:self.ip_berechnung(Rechnung, j)} + #print(str(Antwort[AntAnz])+"in ip")#debug + AntAnz=AntAnz+1 + for j in listeIP6: + if j in AntwortArt: + Antwort[AntAnz]={j:self.ip6_berechnung(Rechnung, j)} + #print(str(Antwort)+"in ip6")#debug + AntAnz=AntAnz+1 + #print(str(AntAnz)+" kleiner als "+str(len(AntwortArt)))#debug + if AntAnz < len(AntwortArt): + #print("AntwortAnzahl: "+str(AntAnz))#debug + for j in AntwortArt: + if j=="0x": + Antwort[AntAnz]={j:self.hexa_berechnung(Rechnung, j)} + elif j=="_2": + Antwort[AntAnz]={j:self.dual_berechnung(Rechnung, j)} + elif j=="f" or j=="i": + k=0 + #print(Rechnung[AntAnz]) + #print("in normal länge Rechnung"+str(len(Rechnung))+"Antwortanzahl"+str(AntAnz))#debug + if len(Rechnung) >= AntAnz: + Antwort[AntAnz]={"f":self.norm_berechnung(Rechnung[AntAnz])} + else: + Antwort[AntAnz]={"f":self.norm_berechnung(Rechnung[k])} + k=k+1 + #else: + # print("nicht gefunden "+str(j))#bedug + AntAnz= AntAnz +1 + return Antwort + + def AntwortArt_ermittlen(self): + AntwortFormats=["i", "f", "ip", "ip6", "br", "nid", "nid6", "nmC", "nm","nm6", "0x", "2_", ","] + Anum=7+(self.num*7) + charAntwort=[] + AntwortArt="" + #Antwort-Arten ermitteln + Antwort=linecache.getline(r"Fragen.txt", Anum) + Antwort=Antwort.replace("Antwort= ", "", 1) + Antwort=Antwort.replace("\n", "", 1) #newline ausschneiden, wird sonst nicht verglichen + Antwort=Antwort.replace(" ", "") #Leerzeichen ausschneiden, wird sonst nicht verglichen + Antwort=Antwort.split(",") + for Wort in Antwort: + if Wort in AntwortFormats: + #print("antwort-Format gültig "+str(Wort)+"_")#debug + charAntwort.append(Wort) + else: + print("Error: antwort-Format "+str(Wort)+" in Zeile: "+str(Anum)+" ungültig") + exit() + #AntwortArt=''.join(charAntwort) + AntwortArt=charAntwort + + return AntwortArt + + def rechnung_ermitteln(self): + FinRechnung=[] + #Rechnung ermitteln + num=6+(self.num*7) + Zeile=linecache.getline(r"Fragen.txt", num) + Zeile=Zeile.replace("Rechnung: ", "", 1) + Zeile=Zeile.replace("\n", "")#newline ausschneiden + Rechnung=Zeile.split(";") + Maske=0 + + #print("Rechnug"+str(Rechnung))#debug + #Rechnungen bereinigen + for calc in Rechnung: + #print("Rechnung in for "+str(calc)) + if calc.find("=ip") >= 0 or calc.find("=nm") >= 0 or calc.find("=nid") >= 0 or calc.find("=br") >= 0 or calc.find("=nmC") >= 0 : + loeschen=calc + #print("zu entfernen: "+str(calc))#debug + elif calc.find("mask") >= 0: + #print("found mask") + Maske=Maske+1 + mask=self.ip_berechnung(calc, "nmC") + calc=calc.replace("mask", mask) + FinRechnung.append(calc) + elif calc.find("CIDR") >= 0: + #print("found CIDR") + Maske=Maske+1 + CIDR=self.ip_berechnung(calc, "nmC") + calc=calc.replace("CIDR", CIDR) + FinRechnung.append(calc) + elif calc.find("var") >=0: + #print("Hier hab Variabeln gefunden") + for i in self.Variabeln: + #print(i) + for j in self.Variabeln[i]: + #print("Variable "+str(j)) + Var=str(self.Variabeln[i][j]) + #print(str(Var[1:])+" Hier "+str(i)) #debug + if j=="nmC" or j=="nm6": + calc=calc.replace("var"+str(i), Var[1:]) + else: + calc=calc.replace("var"+str(i), Var) + if calc.find("var") >=0: + print("es wurden nicht alle Variabeln der Frage in der Rechnung aufgelöst") + exit() + + FinRechnung.append(calc) + else: + FinRechnung.append(calc) + + #print("Zusammen"+str(FinRechnung))#debug + return FinRechnung - def Berechnung(self): + def norm_berechnung(self, Rechnung): permitchars=["-", ".", " ", "+", "*", "/", "^", "(", ")", ":"] - num=6+(self.num*7) - j=0 charRechnung=[] executRechnung="" - Zeile=linecache.getline(r"Fragen.txt", num) - Zeile=Zeile.replace("Rechnung: ", "", 1) - for i in self.Variabeln: - j=j+1 - Zeile=Zeile.replace("var"+str(j), str(i)) - Rechnung=Zeile - #print(Zeile) - #fische die Zahlen und Operatoren aus dem String + #print(str(Rechnung)+" vor umwandlung")#debug + #fische die Zahlen und Operatoren aus dem String for char in Rechnung: - if char.isdigit(): + if char.isdigit(): charRechnung.append(char) elif char in permitchars: charRechnung.append(char) - executRechnung=''.join(charRechnung) - antwort=eval(executRechnung) - antwort=round(antwort,2) + + executRechnung=''.join(charRechnung) + executRechnung=executRechnung.replace("^", "**") + #print(str(executRechnung)+" berechnende Rechnung")#debug + antw=eval(executRechnung) + antwort=round(antw,2) + #print(str(antwort)+" in norm_berechnung")#debug + return antwort + + def ip_berechnung(self, Rechnung, Art): -class Fragen(): - def __init__(self,num): - self.num=num -1 - self.Variabeln=self.Zufall() - self.Frage=self.get_Frage() - def Zufall(self): - Variable=[] - num=3+self.num *7 - Zeile=linecache.getline(r"Fragen.txt", num) - Zeile=Zeile.replace("Variable: ", "", 1) - Zeile=Zeile.split(", ") - for i in Zeile: - if (i.find(".") > 0): - i=i.split(".") - Zufall=[] - for j in i: - Groesse=len(j) - start=10**(Groesse-1) - ende=10**(Groesse) - Zufall.append(random.randrange(start, ende)) - #print(str(Zufall)+" Zufall") #debug - #print("Zufall"+str(Zufall)) #debug - Variable.append(float(str(Zufall[0])+"."+str(Zufall[1]))) + Maske=0 + MultiAntwort={} + + #Variabelnarten durchnummerieren um leichter drauf zu zugreifen + VarArtnum={} + for i in self.Variabeln: + VarArt=str(self.Variabeln[i].keys()) + VarArt=VarArt.split("'") + VarArtnum[VarArt[1]]=i + + #antworten Ermitteln + #print("Hier "+str(Art)) + + if Art == "nid": + if "nm" in VarArtnum.keys() and "ip" in VarArtnum.keys(): + nmC=ipaddress.ip_network("0.0.0.0/"+self.Variabeln[VarArtnum["nm"]]["nm"]).prefixlen + Antwort=str(ipaddress.ip_interface(str(self.Variabeln[VarArtnum["ip"]]["ip"]+nmC)).network) + elif "ip" in VarArtnum.keys() and "nmC" in VarArtnum.keys(): + Antwort=str(ipaddress.ip_interface(str(self.Variabeln[VarArtnum["ip"]]["ip"]+self.Variabeln[VarArtnum["nmC"]]["nmC"])).network) else: - Groesse=len(i) - #print(Groesse)#debug - start=10**(Groesse-1) - ende=10**(Groesse) - #print("start"+str(start)+"ende"+str(ende)) #debug - Variable.append(random.randrange(start, ende)) - #print(Variable) #debug - return Variable + print("Error: Netzid kann mit gegeben Mitteln nicht berechnet werden") + exit() + #print("nip-berechnung: " +str(Antwort))#debug + Antwort=(Antwort.split("/"))[0] + + elif Art == "br": + if "ip" in VarArtnum.keys() and "nm" in VarArtnum.keys(): + nmC=ipaddress.ip_network("0.0.0.0/"+self.Variabeln[VarArtnum["nm"]]["nm"]).prefixlen + nid=ipaddress.ip_interface(str(self.Variabeln[VarArtnum["ip"]]["ip"]+nmC)).network + Antwort=str(ipaddress.ip_network(str(nid)).broadcast_address) + elif "ip" in VarArtnum.keys() and "nmC" in VarArtnum.keys() : + nid=ipaddress.ip_interface(str(self.Variabeln[VarArtnum["ip"]]["ip"]+self.Variabeln[VarArtnum["nmC"]]["nmC"] )).network + Antwort=str(ipaddress.ip_network(str(nid)).broadcast_address) + elif "nid" in VarArtnum.keys() and "nmC" in VarArtnum.keys(): + Antwort=str(ipaddress.ip_network(str(self.Variabeln[VarArtnum["nid"]]["nid"]+self.Variabeln[VarArtnum["nmC"]]["nmC"])).broadcast_address) + else: + print("Error: Broadcast-Adresse kann mit gegebenen Mitteln nicht berechnet werden") + exit() + #print("br-berechnung: " +str(Antwort)) + elif Art == "nmC": + Antwort=str(ipaddress.ip_network("0.0.0.0/"+self.Variabeln[VarArtnum["nm"]]["nm"]).prefixlen) + while Maske >0: + Rechnung=Rechnung.replace("mask", str(Antwort), 1) + Rechnung=Rechnung.replace("CIDR", str(Antwort), 1) + elif Art == "nm": + if "nm" in VarArtnum.keys() and "ip" in VarArtnum.keys(): + nmC=ipaddress.ip_network("0.0.0.0/"+self.Variabeln[VarArtnum["nm"]]["nm"]).prefixlen + Antwort=str(ipaddress.ip_network(str(self.Variabeln[VarArtnum["ip"]]["ip"]+nmC)).network.netmask) + elif "ip" in VarArtnum.keys() and "nmC" in VarArtnum.keys(): + Antwort=str(ipaddress.ip_network(str(self.Variabeln[VarArtnum["ip"]]["ip"]+self.Variabeln[VarArtnum["nmC"]]["nmC"])).network.netmask) + else: + print("Error: netzmaske kann mit gegebeben Mitteln nicht ermittelt werden") + exit() + elif Art == "i" or Art == "f": + #print("debug Rechnung "+str(Rechnung)) #debug + #Rechnung ermitteln + for calc in Rechnung: + print("norm in ip: "+calc) #debug + if calc.find("=i") >= 0 and Art == "i" or calc.find("=f") >= 0 and Art == "f": + if calc.find("mask") >=0 or calc.find("CIDR") >=0: + print("Error in Rechnung" + str(calc)) + Antwort=self.norm_berechnung(calc) + else: + print("nicht gefunden "+str(calc)) + elif Art == "2_": + #Rechnung ermitteln + for calc in Rechnung: + if calc.find("2_=") >= 0: + Antwort=self.bit_berechnung(calc) + else: + print("Art: "+str(Art)+" nicht vorhanden") + return Antwort + + def ip6_berechnung(self, Rechnung, art, num): + multiAntwort={} + Varnum={} + for i in self.Variabeln: + Var=str(self.Variabeln.keys()) + Var=Var.split("'") + Varnum[Var]=i + + if art == "nid6": + Antwort=ipaddress.ip_interface(str(self.Variabeln[Varnum["ip6"]])).network + multiAntwort[art]=Antwort + return multiAntwort + +class Fragen(): + def __init__(self, num, Zufallvariabeln): + self.num=num-1 + self.Variabeln=Zufallvariabeln.Variabeln + self.Frage=self.get_Frage() + def get_Frage(self): num=2+self.num*7 Zeile=linecache.getline(r"Fragen.txt", num) Zeile=Zeile.replace("Frage: ", "", 1) #Frage: ausschneiden aus String + #print("Variabeln in Fragen"+str(self.Variabeln)) #debug for i in self.Variabeln: - Zeile=Zeile.replace("$Variable", str(i), 1) - #$Variabeln durch Wert ersetzen - Frage=Zeile - return Frage + #print(str(i)+"num") + for j in self.Variabeln[i]: + Var=str(self.Variabeln[i][j]) + #print(str(Var)+"Hier") #debug + Zeile=Zeile.replace("$Variable", Var, 1) + #print("ersetzte Zeile "+str(Zeile)) + #$Variabeln durch Wert ersetzen + return Zeile class Hinweise(): - def __init__(self, num, Variabeln): - self.num = num -1 - self.Variabeln=Variabeln + def __init__(self, num,Zufallvariabeln): + self.num=num-1 + self.Variabeln=Zufallvariabeln.Variabeln self.Hint, self.Hint2=self.get_Hinweise() + def get_Hinweise(self): - num=(self.num*7)+4 + num=(self.num*7)+4 + #HintsFormats=["i", "f", "ip", "ip6", "br", "nid", "nid6", "nmC", "nm", "0x", "2_"] Zeile=linecache.getline(r"Fragen.txt", num) Zeile=Zeile.replace("Hint: ", "", 1) + Zeile=Zeile.replace("; ", " \n ") Hint1=Zeile num=num +1 Zeile=linecache.getline(r"Fragen.txt", num) Zeile=Zeile.replace("Hint2: ", "", 1) j=0 - print(self.Variabeln) for i in self.Variabeln: j= j + 1 - Zeile=Zeile.replace("var"+str(j), str(i)) + for k in self.Variabeln[i]: + Var=str(self.Variabeln[i][k]) + #print("Hints_get "+str(Var)+str(j))#debug + if "nmC" in self.Variabeln[i].keys() or "nm6" in self.Variabeln[i].keys() : + #print(Var) + Zeile=Zeile.replace("var"+str(j), Var[1:]) + #print("hint replaced "+str(j)) + else: + Zeile=Zeile.replace("var"+str(j), Var) + #print("hint var replaces mit "+str(j)) + Zeile=Zeile.replace("; ", " \n") Hint2=Zeile return Hint1, Hint2 - - +print("Halte bitte deinen Taschenrechner bereit") +print(" ") print("Viel Spaß beim lernen") User1=user("ich") Folge=User1.Reihenfolge() - print(Folge) +#Folge=[]#debug Fragennummer +while True: + Runde=0 + for i in Folge: + print("num:"+str(i)) + Variabeln=Zufallvariabeln(i) + Frage=Fragen(i, Variabeln) + Hints=Hinweise(i, Variabeln) + Answer=Antworten(i, Variabeln) + monsta=monster(Frage.Frage, Answer.antwort, Hints.Hint, Hints.Hint2) + User1.Monster=monsta + User1.fighting() + print(str(User1.Punkte)+" Punkte wurden erreicht") -for i in Folge: - Frage=Fragen(i) - Hints=Hinweise(i, Frage.Variabeln) - Answer=Antworten(i, Frage.Variabeln) - monsta=monster(Frage.Frage, Answer.antwort, Hints.Hint, Hints.Hint2) - User1.Monster=monsta - #print(User1.Monster.Frage) - User1.fighting() - print(str(User1.hint)+"hints") - print(str(User1.fights)+"kämpfe") - print(str(User1.Punkte)+"punkte") - exit() + print(str(Runde)+" Runde beendet") + print("Du befindest dich in Level "+str(User1.Level)) + print(str(User1.Punkte)+" Punkte wurden erreicht") + Folge=monsta.fighting() + Runde=Runde+1 -- 2.30.2