AUFGABE: Jeden tag eine Änderung des Bankcodes...

Wenn du dir nicht sicher bist, in welchem der anderen Foren du die Frage stellen sollst, dann bist du hier im Forum für allgemeine Fragen sicher richtig.
Benutzeravatar
snafu
User
Beiträge: 5107
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon snafu » Freitag 10. Februar 2017, 14:33

BlackJack hat geschrieben:@snafu: Kleiner Bug in der Funktion: die funktioniert nur für Codes ≥1000.

Edit: Und geht auch davon aus das der Code jemals wieder erreicht wird, was man ohne Begründung IMHO nicht so einfach annehmen darf.

Woran machst du fest, dass der Code nicht für Zahlen unter 1000 funktioniert? Der Code wird ja als String übergeben und danach werden die Ziffern einzeln betrachtet. Ich sehe da kein Problem mit führenden Nullen, falls das gemeint ist.

Und dass der Code theoretisch endlos laufen könnte, ist doch bei allen bisher gezeigten Lösungen so. Das ist ja vom Prinzip her ein typisches Halteproblem.
shcol (Repo | Doc | PyPi)
Benutzeravatar
snafu
User
Beiträge: 5107
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon snafu » Freitag 10. Februar 2017, 15:46

Man könnte natürlich einbauen, dass man nach 1 Million Versuchen aufgibt oder sowas. Ansonsten stelle ich mir das Erkennen von Zirkeln schwierig vor, da diese prinzipiell sehr groß sein können. Nur den Fall, dass alle Stellen auf Null stellen könnte man mit aufnehmen bzw wenn sich der Code unmittelbar wiederholt (bei 11 Einsen und ähnliches).
shcol (Repo | Doc | PyPi)
Sirius3
User
Beiträge: 5941
Registriert: Sonntag 21. Oktober 2012, 17:20

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon Sirius3 » Freitag 10. Februar 2017, 15:50

@snafu: eine n-stellige Zahl kann maximal 10^n Zustände annehmen. Da der interne Zustand des Automaten auch eine n-stellige Zahl ist, muß sich die Folge spätestens nach 10^n Schritten wiederholen.
karolus
User
Beiträge: 100
Registriert: Samstag 22. August 2009, 22:34

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon karolus » Freitag 10. Februar 2017, 15:56

Hallo

Der Code geht davon aus das man disjunkte Ringe/Kreise hat. Das muss man ja schon vorher wissen, oder irgendwie begründen können, dass der Graph so aussieht.

Bei der Betrachtung spätestens der Zweiten Zahlenreihe sollte einem schon auffallen das:
1.) jede Kombination nur jeweils einen eindeutigen Vorläufer|Nachfolger hat. ( haben kann!! )
2.) nur über einen begrenzten Vorat (hier 10**4) an Kombinationen iterieren kann.
3.) →irgenwann (<=10**4) Iterationen wieder jeder mögliche Ausgangspunkt erreicht wird.
4.) Aus 1.) folgt auch das es keine Schnittmengen zwischen verschiedenen Ringen geben kann.

Letzlich beweisst mein Code das ja empirisch.
Benutzeravatar
BlackJack
Moderator
Beiträge: 32517
Registriert: Dienstag 25. Januar 2005, 23:29
Wohnort: Berlin
Kontaktdaten:

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon BlackJack » Freitag 10. Februar 2017, 16:04

@snafu: Okay ich hatte das nicht vorhandene Problem der führenden Nullen gesehen. :oops:

Das der Code endlos laufen könnte ist nicht bei allen Lösungen so. Der könnte zudem nicht nur theoretisch endlos laufen sondern auch praktisch, sofern man nicht vorher erklären kann warum jeder Code irgendwann wieder zu sich selbst führt.

Meine erweiterte Frage war ja: „Wie lange brauchen andere Kombinationen und wie viele Kombinationen gibt es, die nie wieder zum Ausgangscode zurückkehren?“

Wenn man also nicht (vorher) erklären kann warum es keine Kombination gibt, bei der nie wieder zum Ausgangscode zurückgekehrt wird, dann ist ein Programm das diese Frage nicht explizit berücksichtigt IMHO fehlerhaft, weil es die Frage nur dadurch beantwortet, weil es nicht hängengeblieben ist.

Und ja, den Fehler habe ich in meinem „von funktional nach OOP“ auch gemacht.

Die Lösungen von sebastian0202 und mein C-Programm berücksichtigen den Fall aber. Seins verwendet die -1 als Kennzeichen und meins 'inf'.

Halteproblem triffts nicht ganz weil es dort ja darum geht, dass ganz allgemein nicht beweisen kann ob ein beliebiges gegebenes Programm zum Ende kommt. Hier haben wir aber ein konkretes Programm, sogar ohne Eingaben von aussen und mit einer endlichen Wertemenge. Ob es hängen bleibt oder nicht, kann man als Grapgenproblem formulieren. Knoten sind die 10.000 Codes. Kanten bestehen zwischen Knoten die für einen Code und dessen Folgecode stehen. Zu beweisen wäre jetzt, dass jeder Code genau einen möglichen Vorgänger hat. Denn er hat auf jeden Fall einen Nachfolger. Wenn jeder genau einen Vor- und Nachgänger hat, dann muss der Graph aus einem oder mehreren Kreisen bestehen und somit käme auch jeder Code wieder zu sich selbst.

Ein Kreis kann nur maximal so gross sein wie es verschiedene Kombinationen gibt. Bei vier Stellen kann er also maximal 10.000 Codes umfassen. Eine Million Durchläufe wäre demnach eine sinnvolle Begrenzung für sechsstellige Codes. Alternativ muss man sich nur merken welche Codes man schon gesehen hat, damit man keinen, beziehungsweise nicht die falschen, mehr als einmal berechnet. Das ist eine Abwägung zwischen Laufzeit und Speicherverbrauch.

@karolus: 3. Sehe ich so ohne weitere Erklärung nicht. Es sind Graphen möglich die 1, 2, und 4 erfüllen, bei denen 3 nicht gilt.
“There are only two industries that refer to their customers as users.” — Edward Tufte
Benutzeravatar
snafu
User
Beiträge: 5107
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon snafu » Freitag 10. Februar 2017, 16:05

Sirius3 hat geschrieben:@snafu: eine n-stellige Zahl kann maximal 10^n Zustände annehmen. Da der interne Zustand des Automaten auch eine n-stellige Zahl ist, muß sich die Folge spätestens nach 10^n Schritten wiederholen.

Prima. Damit hätte man schon einen guten Wert für's Limit.
shcol (Repo | Doc | PyPi)
Benutzeravatar
snafu
User
Beiträge: 5107
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon snafu » Freitag 10. Februar 2017, 16:21

karolus hat geschrieben:Hallo

4.) Aus 1.) folgt auch das es keine Schnittmengen zwischen verschiedenen Ringen geben kann.

Letzlich beweisst mein Code das ja empirisch.

Nicht wirklich. Aus dem Zustand 0000 käme der Code bei den vorliegenden Regeln nicht mehr raus.

Ich wollte 3 zitieren. Bin gerade am Handy...
shcol (Repo | Doc | PyPi)
karolus
User
Beiträge: 100
Registriert: Samstag 22. August 2009, 22:34

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon karolus » Freitag 10. Februar 2017, 16:47

Hallo

@karolus: 3. Sehe ich so ohne weitere Erklärung nicht. Es sind Graphen möglich die 1, 2, und 4 erfüllen, bei denen 3 nicht gilt.

Da kann ich jetzt nicht ganz folgen, welche sollten das sein? (Wir sind uns doch darüber einig das kein Ring aus der gegebenen Grundmenge "ausbrechen" kann?)
Hätte ich 3. hinter 4.plazieren sollen?

snafu hat geschrieben:Nicht wirklich. Aus dem Zustand 0000 käme der Code bei den vorliegenden Regeln nicht mehr raus.

'0000' → Nachfolger ist '0000'
Das ist dann lediglich ein Ring der Länge 1, ansonsten werden alle Regeln erfüllt.
Letzlich kommt kein Ring aus seinem "Zustand" heraus, sie sind nur unterschiedlich lang.
Zuletzt geändert von karolus am Freitag 10. Februar 2017, 17:01, insgesamt 1-mal geändert.
Benutzeravatar
snafu
User
Beiträge: 5107
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon snafu » Freitag 10. Februar 2017, 16:55

Es gibt mindestens eine Situation, wo der Ausgangspunkt nicht mehr erreicht wird. Wie gesagt, bei 0000 fährt er sich fest. Die Quersumme daraus ist Null. Diese wird hinten dran gehangen und es wird kein andere Zustand mehr erreicht. Insofern widerspricht dies deiner Annahme, dass spätestens nach 10^n Versuchen der Ausgangspunkt erreicht wird. Man kann nur folgern, dass nach 10^n Versuchen garantiert kein bis dahin unbekannter Zustand erreicht wird und man somit aufhören kann.
shcol (Repo | Doc | PyPi)
Benutzeravatar
BlackJack
Moderator
Beiträge: 32517
Registriert: Dienstag 25. Januar 2005, 23:29
Wohnort: Berlin
Kontaktdaten:

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon BlackJack » Freitag 10. Februar 2017, 17:43

@karolus: Das hier sollte 1, 2, und 4 erfüllen:

  1. 1->2->3->4
  2.       ^  |
  3.       |  v
  4.       6<-5


Jeder hat genau einen Nachfolger, es gibt einen begrenzten Vorrat von 6 Knoten, es wird aber nicht für jeden Knoten nach spätestens 6 Schritten wieder der selbe Knoten erreicht. Daran ändert auch nichts das 4 gilt. Man könnte auch mehrere Komponenten dieser Art haben wenn es mehr Knoten gäbe. Und es könnte zu so einem Kreis auch mehrere ”Zufahrten” geben statt nur einer. Und mehrere ”eingehende Äste” bei den ”Zufahrten”.

Man müsste für ausschliesslich Kreise also noch zeigen, dass jeder Knoten auch genau *einen* Vorgänger hat.

@snafu: Beim Code '0000' hat man wie karolus schon sagte einen Kreis der Länge 0. Das heisst nach genau einem Tag/Schritt hat man den Ausgangszustand wieder erreicht. Da fährt sich nichts fest.
“There are only two industries that refer to their customers as users.” — Edward Tufte
Benutzeravatar
snafu
User
Beiträge: 5107
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon snafu » Freitag 10. Februar 2017, 18:18

Ich meinte, dass ein Startcode in die Funktion gegeben wird, durch den im weiteren Verlauf irgendwann der Zustand 0000 erreicht wird. Dann käme die Schleife nie wieder zum Startcode zurück.
shcol (Repo | Doc | PyPi)
karolus
User
Beiträge: 100
Registriert: Samstag 22. August 2009, 22:34

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon karolus » Freitag 10. Februar 2017, 21:14

Hallo

BlackJack hat geschrieben:Man müsste für ausschliesslich Kreise also noch zeigen, dass jeder Knoten auch genau *einen* Vorgänger hat.

Das könnte man ja beweisen indem man Ausgangsregel umgekehrt anwendet, und beides vergleicht.

  1. from itertools import product
  2. from collections import Counter
  3.  
  4. def iter_code(code):
  5.     nextcode = code
  6.     while True:
  7.         nextcode = nextcode[1:] + (sum(nextcode) % 10,)
  8.         if code == nextcode:
  9.             return
  10.         yield nextcode
  11.        
  12. def iter_reverse(code):
  13.     previous = code
  14.     while True:
  15.         y = (previous[-1] - (sum(previous[:-1])%10)) % 10
  16.         previous = (y,) + previous[:-1]
  17.         if  previous == code:
  18.             return
  19.         yield previous
  20.        
  21.                            
  22.  
  23. def main( function ):
  24.     pool = set(product(range(10),repeat=4))
  25.     ringcounter = Counter()    
  26.     while pool:
  27.         codering = [pool.pop()]
  28.         codering.extend(list( function(codering[0])))
  29.         pool = pool.difference(codering)
  30.         ringcounter[len(codering)] += 1
  31.    
  32.     print("{}\nErgebnis unter Verwendung der Funktion {}: ".format('_' * 10, function.__name__))        
  33.     kontrolle = 0
  34.     for key, value in ringcounter.items():
  35.         kontrolle += key * value
  36.         print( "\t{} Codereihen aus {} Codes".format(value, key))
  37.     print('_'*10)
  38.     print("kontrollsumme ist {}\n{}\n".format(kontrolle, '=' * 20))
  39.     return ringcounter
  40.                
  41.            
  42. print(main(iter_code) == main( iter_reverse))



snafu hat geschrieben:Ich meinte, dass ein Startcode in die Funktion gegeben wird, durch den im weiteren Verlauf irgendwann der Zustand 0000 erreicht wird. Dann käme die Schleife nie wieder zum Startcode zurück.

Dazu müsste ein Vorläufer > (0, 0, 0, 0) existieren der viermal in Folge eine (Quersumme modulo 10) == 0 produziert, ohne einen Übertrag.
Versuchen wir es mal mit: (0, 0, 1, 9) → (0, 1, 9, 0) → (1, 9, 0, 0) → (9, 0, 0, 0) … war wohl nix!
Benutzeravatar
snafu
User
Beiträge: 5107
Registriert: Donnerstag 21. Februar 2008, 17:31
Wohnort: Gelsenkirchen

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon snafu » Freitag 10. Februar 2017, 21:46

Zumindest bei mir war ja eine variable Anzahl an Stellen erlaubt. Für 0000 gilt es offenbar nicht, habe es auch nicht im Detail überprüft. Wenn ich gleich zuhause bin, dann schau ich mal ob ich ein belastbares Beispiel zum Widerlegen deines Punkt 3 finde. :)
shcol (Repo | Doc | PyPi)
Benutzeravatar
BlackJack
Moderator
Beiträge: 32517
Registriert: Dienstag 25. Januar 2005, 23:29
Wohnort: Berlin
Kontaktdaten:

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon BlackJack » Freitag 10. Februar 2017, 22:01

@karolus: Hat natürlich gleich mal den doppelten Aufwand und funktioniert auch nur weil diese Bedingung gilt. Würde sie das nicht tun, sähe man das Ergebnis nie weil das Programm irgendwann mit einem `MemoryError` abbrechen würde. Eventuell nachdem vorher das System durch's swappen fast zum Stillstand gekommen ist. ;-)

Mal in Java mit einem einfachen Test ob jeder Code genau einen Vorgänger hat:
  1. import java.util.ArrayList;
  2. import java.util.List;
  3.  
  4. public class Main {
  5.  
  6.     private static final int DIGIT_COUNT = 4;
  7.     private static final int CODE_COUNT = (int) Math.pow(10, DIGIT_COUNT);
  8.     private static final CodeInfo[] codeInfos = new CodeInfo[CODE_COUNT];
  9.     private static final List<Cycle> cycles = new ArrayList<>();
  10.  
  11.     private static class CodeInfo {
  12.         int nextCode;
  13.         int cycleIndex = -1;
  14.  
  15.         CodeInfo(int nextCode) {
  16.             this.nextCode = nextCode;
  17.         }
  18.     }
  19.  
  20.     private static class Cycle {
  21.         int firstCode;
  22.         int length = 0;
  23.  
  24.         Cycle(int firstCode) {
  25.             this.firstCode = firstCode;
  26.         }
  27.     }
  28.  
  29.     private static int crossSum(int n) {
  30.         int sum = 0;
  31.         while (n > 0) {
  32.             final int digit = n % 10;
  33.             sum += digit;
  34.             n = Math.floorDiv(n, 10);
  35.         }
  36.         return sum;
  37.     }
  38.  
  39.     private static int calculateNextCode(int code) {
  40.         return code * 10 % CODE_COUNT + crossSum(code) % 10;
  41.     }
  42.  
  43.     private static void initializeCodeInfos() {
  44.         for (int code = 0; code < codeInfos.length; code++) {
  45.             codeInfos[code] = new CodeInfo(calculateNextCode(code));
  46.         }
  47.     }
  48.  
  49.     private static boolean hasJustCycles() {
  50.         boolean[] hasIncoming = new boolean[codeInfos.length];
  51.  
  52.         for (CodeInfo info : codeInfos) {
  53.             if (hasIncoming[info.nextCode]) return false;
  54.             hasIncoming[info.nextCode] = true;
  55.         }
  56.         for (boolean b : hasIncoming) if (!b) return false;
  57.         return true;
  58.     }
  59.  
  60.     private static void createCycles() {
  61.         for (int startCode = 0; startCode < codeInfos.length; startCode++) {
  62.             if (codeInfos[startCode].cycleIndex == -1) {
  63.                 final Cycle cycle = new Cycle(startCode);
  64.                 int cycleIndex = cycles.size();
  65.                 int code = startCode;
  66.                 do {
  67.                     cycle.length++;
  68.                     final CodeInfo info = codeInfos[code];
  69.                     info.cycleIndex = cycleIndex;
  70.                     code = info.nextCode;
  71.                 } while (code != startCode);
  72.                 cycles.add(cycle);
  73.             }
  74.         }
  75.     }
  76.  
  77.     private static void printCodeAndDayCount(int code) {
  78.         System.out.printf(
  79.                 "Code %04d wird nach %d Tagen wieder erreicht.%n",
  80.                 code,
  81.                 cycles.get(codeInfos[code].cycleIndex).length);
  82.     }
  83.  
  84.     private static void printCyclesInfo() {
  85.         final int cycleCount = cycles.size();
  86.         System.out.printf("Es gibt %d Zyklen.%n", cycleCount);
  87.         for (int cycleIndex = 0; cycleIndex < cycleCount; cycleIndex++) {
  88.             final Cycle cycle = cycles.get(cycleIndex);
  89.             System.out.printf(
  90.                     "Zyklus %d hat Länge %d und enthält Code %04d.%n",
  91.                     cycleIndex,
  92.                     cycle.length,
  93.                     cycle.firstCode);
  94.         }
  95.     }
  96.  
  97.     public static void main(String[] args) {
  98.         initializeCodeInfos();
  99.         if (!hasJustCycles()) {
  100.             System.out.println("Es gibt Codes die nie wieder erreicht werden.");
  101.             return;
  102.         }
  103.         createCycles();
  104.         printCodeAndDayCount(1986);
  105.         printCyclesInfo();
  106.     }
  107. }

Falls sich jemand über den so gar nicht objektorientierten Stil wundert: Ich wollte möglichst wenig Speicher verbrauchen und eine bessere Laufzeit haben als das für jeden Startcode erneut durchzurechnen. Quasi ein Prototyp für den C64. :-)
“There are only two industries that refer to their customers as users.” — Edward Tufte
Benutzeravatar
BlackJack
Moderator
Beiträge: 32517
Registriert: Dienstag 25. Januar 2005, 23:29
Wohnort: Berlin
Kontaktdaten:

Re: AUFGABE: Jeden tag eine Änderung des Bankcodes...

Beitragvon BlackJack » Montag 13. Februar 2017, 00:52

Juhuu, mit dem Ansatz schaffe ich es auf dem C64 in unter einer Minute für alle 10.000 Codes den Folgecode zu berechnen, zu prüfen ob jeder Code genau *einen* Vorgänger hat → alles Kreise, und die Gruppen/Kreise zu bestimmen/markieren. Ausgabe:
  1. run
  2. Folgecodes berechnen...
  3. Pruefen ob jeder Code zyklisch ist...
  4. Zyklen erstellen...
  5. Code 1986 wird nach 1560d wiederholt.
  6. Es gibt 12 Zyklen.
  7. Zyklus   0: len    1, 1. Code 0000
  8. Zyklus   1: len 1560, 1. Code 0001
  9. Zyklus   2: len  312, 1. Code 0002
  10. Zyklus   3: len    5, 1. Code 0005
  11. Zyklus   4: len 1560, 1. Code 0010
  12. Zyklus   5: len 1560, 1. Code 0012
  13. Zyklus   6: len 1560, 1. Code 0015
  14. Zyklus   7: len  312, 1. Code 0020
  15. Zyklus   8: len    5, 1. Code 0050
  16. Zyklus   9: len 1560, 1. Code 0111
  17. Zyklus  10: len 1560, 1. Code 0113
  18. Zyklus  11: len    5, 1. Code 0555
  19. Laufzeit: 56983ms
  20.  
  21. ready.

Der Speicher ist ganz gut ausgenutzt. Von den ca. 50 Kilobyte die für Programm und Daten zur Verfügung stehen sind nur noch ca. 6 Kilobyte frei.
  1. #include <stdbool.h>
  2. #include <stdint.h>
  3. #include <stdio.h>
  4. #include <stdlib.h>
  5. #include <string.h>
  6. #include <time.h>
  7.  
  8. #define CODE_COUNT  10000
  9. #define MAX_CYCLE_COUNT 100
  10.  
  11. typedef struct
  12. {
  13.     uint16_t next_code;
  14.     uint8_t cycle_index;
  15. } CodeInfo;
  16.  
  17. typedef struct
  18. {
  19.     uint16_t first_code;
  20.     uint16_t length;
  21. } Cycle;
  22.  
  23. typedef struct
  24. {
  25.     uint8_t length;
  26.     Cycle items[MAX_CYCLE_COUNT];
  27. } Cycles;
  28.  
  29. static CodeInfo code_infos[CODE_COUNT];
  30. static Cycles cycles;
  31.  
  32. uint8_t cross_sum(uint16_t code)
  33. {
  34.     uint8_t sum = 0;
  35.     div_t tmp;
  36.  
  37.     while (code) {
  38.         tmp = div(code, 10);
  39.         code = tmp.quot;
  40.         sum += tmp.rem;
  41.     }
  42.     return sum;
  43. }
  44.  
  45. void code_infos_init(void)
  46. {
  47.     register uint16_t code;
  48.     register CodeInfo *info;
  49.  
  50.     for (info = code_infos, code = 0; code < CODE_COUNT; ++info, ++code)
  51.     {
  52.         info->next_code = code % (CODE_COUNT / 10) * 10 + cross_sum(code) % 10;
  53.         info->cycle_index = 0xff;
  54.     }
  55. }
  56.  
  57. bool has_just_cycles(void)
  58. {
  59.     register uint16_t code;
  60.     register bool *has_incoming;
  61.     bool code_has_incoming[CODE_COUNT];
  62.  
  63.     memset(code_has_incoming, false, sizeof(code_has_incoming));
  64.     for (code = 0; code < CODE_COUNT; ++code)
  65.     {
  66.         has_incoming = &code_has_incoming[code_infos[code].next_code];
  67.         if (*has_incoming) return false;
  68.         *has_incoming = true;
  69.     }
  70.     for (
  71.         has_incoming = code_has_incoming, code = 0;
  72.         code < CODE_COUNT;
  73.         ++has_incoming, ++code
  74.     ) {
  75.         if (!*has_incoming) return false;
  76.     }
  77.     return true;
  78. }
  79.  
  80. void create_cycles(void)
  81. {
  82.     register uint16_t code;
  83.     register CodeInfo *info;
  84.     register Cycle *cycle;
  85.     register uint16_t start_code;
  86.  
  87.     cycles.length = 0;
  88.  
  89.     for (start_code = 0; start_code < CODE_COUNT; ++start_code)
  90.     {
  91.         if (code_infos[start_code].cycle_index == 0xff) {
  92.             cycle = &cycles.items[cycles.length];
  93.             cycle->first_code = code = start_code;
  94.             cycle->length = 0;
  95.             do {
  96.                 ++cycle->length;
  97.                 info = &code_infos[code];
  98.                 info->cycle_index = cycles.length;
  99.                 code = info->next_code;
  100.             } while (code != start_code);
  101.             ++cycles.length;
  102.             if (cycles.length == MAX_CYCLE_COUNT) {
  103.                 printf("Mehr als %d Zyklen!\n", MAX_CYCLE_COUNT);
  104.                 exit(1);
  105.             }
  106.         }
  107.     }
  108. }
  109.  
  110. void print_code_and_day_count(uint16_t code)
  111. {
  112.     printf(
  113.         "Code %04d wird nach %dd wiederholt.\n",
  114.         code,
  115.         cycles.items[code_infos[code].cycle_index].length
  116.     );
  117. }
  118.  
  119. void print_cycles_info(void)
  120. {
  121.     uint8_t i;
  122.  
  123.     printf("Es gibt %d Zyklen.\n", cycles.length);
  124.     for (i = 0; i < cycles.length; ++i)
  125.     {
  126.         printf(
  127.             "Zyklus %3d: len %4d, 1. Code %04d\n",
  128.             i,
  129.             cycles.items[i].length,
  130.             cycles.items[i].first_code
  131.         );
  132.     }
  133.  
  134. }
  135.  
  136. int main(void)
  137. {
  138.     clock_t start_time = clock();
  139.     clock_t end_time;
  140.  
  141.     puts("Folgecodes berechnen...");
  142.     code_infos_init();
  143.     puts("Pruefen ob jeder Code zyklisch ist...");
  144.     if (!has_just_cycles()) {
  145.         puts("Es gibt Codes die nie wieder erreicht\nwerden.");
  146.         return 1;
  147.     }
  148.     puts("Zyklen erstellen...");
  149.     create_cycles();
  150.     end_time = clock();
  151.  
  152.     print_code_and_day_count(1986);
  153.     print_cycles_info();
  154.     printf("Laufzeit: %ldms\n", (end_time - start_time) * 1000 / CLOCKS_PER_SEC);
  155.  
  156.     return 0;
  157. }
“There are only two industries that refer to their customers as users.” — Edward Tufte

Zurück zu „Allgemeine Fragen“

Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder