C Schleifenproblem

Dese · 29. April 2013

kuddlmuddl schrieb:
Ihr müsst ihn mal auf die einfachsten Grundlagen hinweisen und nicht komplizierte Details diskutieren:

haben wir nicht. wir haben die dinge angesprochen, die eine korrekte ausführung, bzw. sogar das kompilieren verhinderten.

komplizierte dinge sprichst du gerade an, nämlich die algorithmischen verbesserungsmöglichkeiten. ich finde allerdings, dass man ihm dazu angesichts der aufgabenstellung nicht mehr als ein denkanstoß geben sollte (von daher ist das sehr schön, dass du das gerade tust), aber er hat im moment ganz andere probleme.

schaut man sich mal den thread an, dann hat er derzeit probleme ein lauffähiges programm zu schreiben, dass aucn noch das tut was er will. da denke ich sind algorithmische optimierungen noch kein sinnvolles thema.

kuddlmuddl · 29. April 2013

komplizierte dinge sprichst du gerade an, nämlich die algorithmischen verbesserungsmöglichkeiten. ich finde allerdings, dass man ihm dazu angesichts der aufgabenstellung nicht mehr als ein denkanstoß geben sollte (von daher ist das sehr schön, dass du das gerade tust), aber er hat im moment ganz andere probleme.

sorry falls es zu kritisch rüber kam aber ich meinte die zahl=zahl+1, zahl++, ++zahl, zahl+=1 gespräche ..
natürlich ist mein vorschlag mit der diagonalen übertrieben wie auch die abschätzung mit "3+5=4+4 aber 3*5<4*4" aber die vorschläge das als 2D-ebene zu veranschaulichen sind sicher nicht verkehrt um ein problem erstmal zu verstehen.

Mir ging es Primär darum, dass er garnicht alle zahlen speichern muss, was aber viele Postings lang niemand gesagt hat obwohl es sicher jeder wusste. Das ist wirklich keine nebensächliche Optimierung.
Und dass sein Programm evtl die Lösung garnicht entdeckt mit zahl1 >= 100 und zahl2 >= 100 ist auch wichtig.

Außerdem hatte ich ursprünglich ganz viel dazu geschrieben wieso in C++ ein STL Container statt Arrays verwendet werden sollte (was ich auch und gerade für Anfänger wichtig finde) und hab dann erst gesehen, dass es um reines C ging.. auch daher war mein Einleitungssatz evtl etwas übertrieben

Dese · 30. April 2013

nein entschuldige mich. ich wollte es nicht wie ein vorwurf klingen lassen.

aber wie ich bereits schrieb, wir waren damit beschäftigt ihn schritt für schritt daran zu führen, dass das ding überhaupt kompiliert und dann beim starten auch was brauchbares ausspukt. ich denke das hat vorrang vor optimierungen. das da auch ein zahl++ gespräch dazwischen kam, was soll's. prmär ging es aber darum es überhaupt erst einmal zum laufen zu bringen.

salop gesagt: egal ob der algo gut ist oder nicht, ihm sollte erst einmal geholfen werden, dass er seinen algo funktional umsetzten kann. oder?

ich hab es nicht böse aufgefasst, aber dieser formale vorwurf von dir, dass wir das bisher nicht angesprochen haben ist meiner ansicht nach überflüssig und unangebracht aus den oben genannten gründen. jetzt wo das ding läuft kann man gerne mit tips deiner art kommen. kannst du auch gerne vorher schon machen, aber wirf den leuten nicht vor, sie hätten bisher nur überflüsiges ala zahl++ angesprochen, denn das war nicht der fall.

datalukas · 2. Mai 2013

Zur Diskussion:
Ich finde, solche Details sind zwar nicht unbedingt notwendig in diesem Fall, aber schaden können sie ja nicht.

Zu Problem 8:
Bei Primzahlen gibt es ja verschiedene Lösung, diese hier ist vielleicht nicht die eleganteste, da die Zahl einfach durch alle kleineren Zahlen geteilt wird, aber funktionierten müsste es ja. Aber hier ist irgendein Fehler drinnen:

Code:

int main()
{
	int anzahl_primzahlen, teiler, zahl, test;
	anzahl_primzahlen = 1;
	zahl = 2;
	while(anzahl_primzahlen<10001)
	{
		teiler=zahl-1;
		while((zahl%teiler!=0) && (teiler >=1))
		{
			teiler--;
		}
		if(teiler>1)
		{
			anzahl_primzahlen++;
		}
		zahl+=2;
	}
	printf("%i", zahl);
	scanf("%i", &test);
	return 0;
}

Zahl ist auf zwei, da sonst durch 0 geteilt werden würde.

Hancock · 2. Mai 2013

Dir ist bewusst, dass 2 die einzige gerade Primzahl ist?

kuddlmuddl · 3. Mai 2013

zahl+=2;

Und noch 2 Tipps:
1) Wenn eine Funktion nicht tut was sie soll gibts eigtl. 3 Möglichkeiten dem Problem selbst auf die Spur zu kommen: Debuggen, printf prints für Zwischenergebnisse einbauen (beides evtl. altmodisch) oder test-aufrufe programmieren von denen du weißt, was rauskommen müsste und mit dem realen Ergebnis vergleichen. (modern&sinnvoll)
2) Außerdem empfehle ich eine eigene Funktion für ist_primzahl(int zahl).
Die könntest du dann bei anderen Aufgaben wieder verwenden und natürlich auch viel einfacher testen.
Wenn deine ist_primzahl nämlich nichtmal für 3 oder 5 funktioniert musst du garnicht bis 10001 laufen. Wenn sie aber die ersten dir bekannten Primzahlen erfolgreich entdeckt weißt du, dass das Problem nicht IN der Funktion sondern bei der Verwendung der Funktion liegt.

datalukas · 3. Mai 2013

@Hancock Stimmt, da hast du natürlich Recht. Ich hatte aber Zahl zuerst auf 3 aus diesem Grund und dann hab ich scheinbar mal nicht mitgedacht und es auf zwei gesetzt. Davor ging es aber auch nicht.

@kuddlmuddl Meinst du mit printf-Prints immer während der Schleife die Werte auszudrucken oder irgendeine Funktion des Debuggers?

simpsonsfan · 3. Mai 2013

Er wird ersteres meinen, also dir printfs reinzumachen, um zu schauen, was rauskommt. Das Problem in deiner Schleife entsteht übrigens, wenn die Schleife abgebrochen wird. Die Schleife zählt den Teiler nicht bei jeder Nicht-Primzahl bis auf eins runter. Übrigens ist das Problem 7.

kuddlmuddl · 4. Mai 2013

Ja das erste.

Also zB sowas, um mal deinen Code zu übernehmen:

Code:

bool ist_primzahl(int zahl)
{
  int teiler=zahl-1;
  while((zahl%teiler!=0) && (teiler >=1))
  {
    teiler--;
  }
  if(teiler>1)
  {
    printf("ist_primzahl(): %d ist prim", zahl);
    return true;
  }
  else
  {
    printf("ist_primzahl(): %d ist NICHT prim", zahl);
    return false;
  }
}

datalukas · 4. Mai 2013

Jo, wobei die Methode noch immer den gleichen Fehler enthält. Denn sie zählt genau dann hoch, wenn die Zahl keine Primzahl ist.

So siehts jetzt aus:

Code:

bool ist_primzahl(int zahl)
{
  int teiler=zahl-1;
  while((zahl%teiler!=0) && (teiler >=1))
  {
    teiler--;
  }
  if(teiler==1)
  {
    printf("ist_primzahl(): %d ist prim\n", zahl);
    return true;
  }
  else
  {
    printf("ist_primzahl(): %d ist NICHT prim\n", zahl);
    return false;
  }
}
int main()
{
	int anzahl_primzahlen, zahl, test;
	anzahl_primzahlen = 1;
	zahl = 1;
	while(anzahl_primzahlen<10001)
	{
		zahl += 2;
		if(ist_primzahl(zahl)==true)
			anzahl_primzahlen++;
	}
	printf("%i", zahl);
	scanf("%i", &test);
	return 0;
}

kuddlmuddl · 4. Mai 2013

Jo, wobei die Methode noch immer den gleichen Fehler enthält. Denn sie zählt genau dann hoch, wenn die Zahl keine Primzahl ist.

Hast du denn die neuen Informationen ausgenutzt? Funktioniert die ist_primzahl() Prüfung korrekt? Oder werden korrekterweise die richtigen Zahlen geprüft aber ist_primzahl() funktioniert nicht?
Das war doch die Idee: Durch das Aufteilen in ein main() und ne Funktion und die printfs kannst du zum einen sehen was dein Programm überhaupt macht und außerdem feststellen, wo der Fehler liegt.
Hier wäre es zB auch sinnvoll nicht direkt bis 10001 zu laufen und von dem output erschlagen zu werden, sondern erstmal nur bis 10 zu gehen und von Hand zu prüfen, ob alles stimmt.
Nur 2,3,5,7 sollten true bekommen und die Anzahl der Primzahlen müsste daher 4 sein.

datalukas · 7. Mai 2013

Nein, das war ein anderer Fehler. In meinem Beitrag wurde nur nicht klar, dass es jetzt so funktioniert. Also dürfte die Aufgabe kein Thema mehr sein.

Bin gerade bei Nummer 11.
http://projecteuler.net/problem=11

Mein Ansatz ist hier ziemlich kompliziert und ich glaube, dass ihr den Inhalt der Hauptschleife gar nicht mögt:

Code:

#include "stdafx.h"
#include <string.h>
#include <stdlib.h> 

//BEACHTE: Zeile ist immer eins kleiner und fängt bei 0 an.
int zeile_herausfinden(int zahl)
{
	int zeile[20];
	//Herausfinden des jeweiligen Zeilenanfangs
	for(int znr =0; znr <=19; znr++)
	{
		zeile[znr]=znr*59;
	}
	//Rückgabe der Zeile
	for(int znr=0; znr<=19; znr++)
	{
		if(zahl >= zeile[znr] && zahl < zeile[znr+1])
			return znr;
	}		
}
int main()
{
	//strlen=1180
	char zahl []= "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 0849 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 0081 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 6552 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 9122 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 8024 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 5032 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 7067 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 2124 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 7221 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 9578 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 9216 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 5786 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 5819 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 4004 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 6688 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 6904 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 3620 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 1620 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 5401 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48";
	int zahlenarray[1180];
	int test;
	int maximum = 0;
	//Umwandlung von String zu Zahl
	for(int zaehler = 0; zaehler <= strlen(zahl); zaehler++)
	{
		zahlenarray[zaehler] = zahl[zaehler] - '0';
	}
	//Hauptzählschleife
	for(int i = 1; i <=strlen(zahl); i++)
	{
	     //Kommt zwecks Übersichtlichkeit in den Code-Tag unten.
	}
	printf("%i", maximum);
	scanf("%i", &test);
	return 0;
}

Hauptschleife:

Code:

//ist zahl[i] der Anfang einer Zahl? 
if(zahlenarray[i] != -16 && zahlenarray[i+1] != 32)
{
			//nach rechts
		if(zahlenarray[i] + 10 <= zeile_herausfinden(i+1) * 59 && 
			(zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i+3] * 10 + zahlenarray[i+4]) * (zahlenarray[i+6] * 10 + zahlenarray[i+7]) * (zahlenarray[i+9] * 10 + zahlenarray[i+10]) > maximum)
				maximum = (zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i+3] * 10 + zahlenarray[i+4]) * (zahlenarray[i+6] * 10 + zahlenarray[i+7]) * (zahlenarray[i+9] * 10 + zahlenarray[i+10]);
			//nach links 
		if(zahlenarray[i] - 9 >= zeile_herausfinden(i) * 59 && 
			(zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i-3] * 10 + zahlenarray[i-1]) * (zahlenarray[i-6] * 10 + zahlenarray[i-5]) * (zahlenarray[i-9] * 10 + zahlenarray[i-8]) > maximum)
				maximum = (zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i-3] * 10 + zahlenarray[i-1]) * (zahlenarray[i-6] * 10 + zahlenarray[i-5]) * (zahlenarray[i-9] * 10 + zahlenarray[i-8]);
			//nach oben
		if(zeile_herausfinden(i) > 2 && 
			(zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i-59] * 10 + zahlenarray[-58]) * (zahlenarray[i-118] * 10 + zahlenarray[i-117]) + (zahlenarray[i-177] * 10 + zahlenarray[i-176]) > maximum)
				maximum = (zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i-59] * 10 + zahlenarray[-58]) * (zahlenarray[i-118] * 10 + zahlenarray[i-117]) + (zahlenarray[i-177] * 10 + zahlenarray[i-176]);
			//nach unten
		if(zeile_herausfinden(i) < 17 && 
			(zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i+59] * 10 + zahlenarray[+60]) + (zahlenarray[i+118] * 10 + zahlenarray[i+119]) + (zahlenarray[i+177] * 10 + zahlenarray[i+178]) > maximum)
				maximum = (zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i+59] * 10 + zahlenarray[+60]) + (zahlenarray[i+118] * 10 + zahlenarray[i+119]) + (zahlenarray[i+177] * 10 + zahlenarray[i+178]);
			//diagonal nach oben links
		if(zahlenarray[i] - 10 >= zeile_herausfinden(i) * 59 && zeile_herausfinden(i) > 2 && 
			(zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i-62] * 10 + zahlenarray[i-61]) * (zahlenarray[i-124] * 10 + zahlenarray[i-123])*(zahlenarray[i-186]*10+zahlenarray[i-185]) > maximum);
				maximum = (zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i-62] * 10 + zahlenarray[i-61]) * (zahlenarray[i-124] * 10 + zahlenarray[i-123])*(zahlenarray[i-186]*10+zahlenarray[i-185]);
			//diagonal nach oben rechts
		if(zahlenarray[i] + 10 <= zeile_herausfinden(i+1) * 59 && zeile_herausfinden(i) > 2 && 
			(zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i-56] * 10 + zahlenarray[i-55]) * (zahlenarray[i-112] * 10 + zahlenarray[i-111])*(zahlenarray[i-168]*10+zahlenarray[i-167]) > maximum);
				maximum = (zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i-56] * 10 + zahlenarray[i-55]) * (zahlenarray[i-112] * 10 + zahlenarray[i-111])*(zahlenarray[i-168]*10+zahlenarray[i-167]);
			//diagonal nach unten links
	        if(zahlenarray[i] - 10 >= zeile_herausfinden(i) * 59 && zeile_herausfinden(i) < 17 && 
			(zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i+56] * 10 + zahlenarray[i+56]) * (zahlenarray[i+112] * 10 + zahlenarray[i+113]) * (zahlenarray[i+168] * 10 + zahlenarray[i+169]) > maximum)
				maximum = (zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i+56] * 10 + zahlenarray[i+56]) * (zahlenarray[i+112] * 10 + zahlenarray[i+113]) * (zahlenarray[i+168] * 10 + zahlenarray[i+169]);
			//diagonal nach unten rechts
		if(zahlenarray[i] + 10 <= zeile_herausfinden(i+1) && zeile_herausfinden(i) < 17 &&
			(zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i+62] * 10 + zahlenarray[i+63]) * (zahlenarray[i+124] * 10 + zahlenarray[i+125]) * (zahlenarray[i+186] * 10 + zahlenarray[i+187]) > maximum)
				maximum = (zahlenarray[i] * 10 + zahlenarray[i+1]) * (zahlenarray[i+62] * 10 + zahlenarray[i+63]) * (zahlenarray[i+124] * 10 + zahlenarray[i+125]) * (zahlenarray[i+186] * 10 + zahlenarray[i+187]);
}

Wie gesagt, der Code ist alles andere als übersichtlich (wie ich sehe, macht die Tag-Funktion hier im Forum das noch mal deutlich schlimmer) und funktioniert zur Zeit auch nicht richtig. Aber in diesem Fall konnte ich es auch nicht besser.

Zur besseren Verständlichkeit:
Am Anfang der Bedingung wird immer geprüft ob die ziffer weit genug rechts bzw. links ist und/oder dass die Zeile weit genug oben oder bzw. unten ist (dabei hilft die Funktion zeile_herausfinden). Im Falle von Diagonalen muss beides geprüft werden. (Es könnte allerdings auch sein, dass ich die Aufgabe falsch interpretiere und es auch möglich ist, dass es in der nächsten Zeile weitergeht, z.B. bei "nach Rechts").
Anschließend werden die Zahlen gebildet(Zehner * 10 + Einer) und die vier zusammenhängenden zweistelligen Zahlen multipliziert. Nun wird geprüft, ob dieser Wert größer als das bisherige Maximum ist. Wenn das der Fall ist, wird Maximum das Produkt zugewiesen.

Wenn ich einzelne Funktionen für nach rechts, nach links usw. bilden hätte wollen, aber dann hätte dieser Funktion immer i, das bisherige Maximum und das komplette Zahlenarray übergeben müssen. Wie kann man das umgehen?

Außerdem wird in Zeile herausfinden jedes Mal immer wieder die Schleife ausgeführt, die die Zeilenanfänge ausrechnet. Wie kann man dies umgehen, ohne die ganzen Zeilenanfänge der Funktion übergeben zu müssen?

kuddlmuddl · 7. Mai 2013

Du machst schon wieder den selben Fehler: Du schließt deine Aufgaben nicht vernünftig ab und nimmst daher die zu gewinnende Erkenntnis nicht mit für die nächsten Aufgaben.
Sinn dieser Aufgaben ist ja nicht nur GERADE SO die Lösung hin zu bekommen sondern dabei was zu lernen. Niemanden interessierne die Primzahlen bis 10.000 aber du lernst halt was dabei sie richtig zu suchen.

Ich erinner nochmal an deine Lösung für das größte Palindrom und die Primzahlen:
Du brauchst eine Funktion die an einer Stelle das Produkt ausrechnet und diese rufst du dann ganz oft auf. Die beste gefundene Stelle isses.

Außerdem ganz allgemein: down=up und left=right. Du brauchst also nur 4 Fälle und nicht 6.

simpsonsfan · 7. Mai 2013

Viel schöner wird das ganze, wenn du die Zahlen in ein zweidimesionales Array steckst.

Wenn ich einzelne Funktionen für nach rechts, nach links usw. bilden hätte wollen, aber dann hätte dieser Funktion immer i, das bisherige Maximum und das komplette Zahlenarray übergeben müssen. Wie kann man das umgehen?

nach rechts und nach links ist doch dasselbe, nämlich waagrecht (ich muss zugeben, ich hab mir jetzt nicht durchgeguckt, wie du das im Einzelnen genau machst) und wenn du mit einer globalen Variable maximum arbeitest, musst du nur bei jeder Richtung gucken, ob das neu gefundene höher als das Maximum ist, und falls es das ist, das Maximum durch das neue ersetzen.

Ich hoffe, das hilft dir weiter.

Hancock · 7. Mai 2013

Also ich hab die Aufgabe so gelöst, indem ich zuerst das Array mir anders definiert hab:

Code:

int data[][]={
{1,2,3,4,5,6...},
{...},
.
.
.
};

Wenn du's einigermaßen clever anstellst, geht das locker mit Notepad++ o.Ä., das schnell mal umzuformatieren. (Du musst die führenden Nullen löschen (z.B. mit " 0" durch " " ersetzten).

datalukas · 8. Mai 2013

@kuddlmuddl

Du machst schon wieder den selben Fehler: Du schließt deine Aufgaben nicht vernünftig ab und nimmst daher die zu gewinnende Erkenntnis nicht mit für die nächsten Aufgaben.
Sinn dieser Aufgaben ist ja nicht nur GERADE SO die Lösung hin zu bekommen sondern dabei was zu lernen. Niemanden interessierne die Primzahlen bis 10.000 aber du lernst halt was dabei sie richtig zu suchen.

Da hast du mich wohl falsch verstanden. Ich hatte kein Problem mehr mit der Aufgabe und habe auch alle von dir genannten Punkte abgecheckt bzw. durchgeführt. Was sollte da also noch zu besprechen gewesen sein?

So, hab das Ganze jetzt noch mal überarbeitet:

Code:

int main()
{
	//strlen=1180
	char zahl []= "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 0849 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 0081 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 6552 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 9122 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 8024 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 5032 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 7067 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 2124 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 7221 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 9578 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 9216 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 5786 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 5819 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 4004 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 6688 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 6904 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 3620 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 1620 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 5401 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48";
	int zahlenarray[59][20];
	int test;
	int maximum = 0;
	//Umwandlung von String zu zweidimensionalem Array
	for(int zeile=0;zeile<=19;zeile++)
	{
		for(int ziffer = 0; ziffer <= 58; ziffer++)
		{
			zahlenarray[ziffer][zeile] = zahl[(zeile*59)+ziffer] - '0';
		}
	}
	//Hauptzählschleife
	for(int zeile = 0; zeile<=19; zeile++)
	{
		for(int ziffer = 1; ziffer <=57; ziffer++)
		{
			//ist zahlenarray[ziffer][zeile] der Anfang einer Zahl? 
			if(zahlenarray[ziffer][zeile] != -16 && zahlenarray[ziffer+1][zeile] != -16)
			{
				//nach rechts/links
				if((ziffer < 49) && 
				((zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) *
				(zahlenarray[ziffer+3][zeile] * 10 + zahlenarray[ziffer+4][zeile]) *
				(zahlenarray[ziffer+6][zeile] * 10 + zahlenarray[ziffer+7][zeile]) *
				(zahlenarray[ziffer+9][zeile] * 10 + zahlenarray[ziffer+10][zeile])   > maximum));
				{
					maximum = (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) * (zahlenarray[ziffer+3][zeile] * 10 + zahlenarray[ziffer+4][zeile]) *
								(zahlenarray[ziffer+6][zeile] * 10 + zahlenarray[ziffer+7][zeile]) * (zahlenarray[ziffer+9][zeile] * 10 + zahlenarray[ziffer+10][zeile]);
				}
				//nach oben/unten
				if((zeile < 17)  && 
				((zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) *
				(zahlenarray[ziffer][zeile+1] * 10 + zahlenarray[ziffer+1][zeile+1]) *
				(zahlenarray[ziffer][zeile+2] * 10 + zahlenarray[ziffer+1][zeile+2]) *
				(zahlenarray[ziffer][zeile+3] * 10 + zahlenarray[ziffer+1][zeile+3])   > maximum));
				{
					maximum = (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) * (zahlenarray[ziffer][zeile+1] * 10 + zahlenarray[ziffer+1][zeile+1]) *
								(zahlenarray[ziffer][zeile+2] * 10 + zahlenarray[ziffer+1][zeile+2]) * (zahlenarray[ziffer][zeile+3] * 10 + zahlenarray[ziffer+1][zeile+3]);
				}
				//diagonal nach unten rechts
				if((zeile < 17)  && (ziffer < 49) &&
				((zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) *
				(zahlenarray[ziffer+3][zeile+1] * 10 + zahlenarray[ziffer+4][zeile+1]) *
				(zahlenarray[ziffer+6][zeile+2] * 10 + zahlenarray[ziffer+7][zeile+2]) *
				(zahlenarray[ziffer+9][zeile+3] * 10 + zahlenarray[ziffer+10][zeile+3])   > maximum));
				{
					maximum = (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) * (zahlenarray[ziffer+3][zeile+1] * 10 + zahlenarray[ziffer+4][zeile+1]) *
								(zahlenarray[ziffer+6][zeile+2] * 10 + zahlenarray[ziffer+7][zeile+2]) * (zahlenarray[ziffer+9][zeile+3] * 10 + zahlenarray[ziffer+10][zeile+3]);
				}
				//diagonal nach unten links
				if((zeile < 17)  && (ziffer > 8) &&
				((zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) *
				(zahlenarray[ziffer-3][zeile+1] * 10 + zahlenarray[ziffer-2][zeile+1]) *
				(zahlenarray[ziffer-6][zeile+2] * 10 + zahlenarray[ziffer-5][zeile+2]) *
				(zahlenarray[ziffer-9][zeile+3] * 10 + zahlenarray[ziffer-9][zeile+3])   > maximum));
				{	
					maximum = (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) * (zahlenarray[ziffer-3][zeile+1] * 10 + zahlenarray[ziffer-2][zeile+1]) *
								(zahlenarray[ziffer-6][zeile+2] * 10 + zahlenarray[ziffer-6][zeile+2]) * (zahlenarray[ziffer-9][zeile+3] * 10 + zahlenarray[ziffer-9][zeile+3]);
				}
				printf("%i \n", maximum);
			}
		}
	}
	scanf("%i", &test);
	return 0;
}

Beim Maximum gibt es noch erhebliche Probleme.
1. Es sind negative Zahlen dabei. Irgendwo müssen also Nuller dabei sein (Wert -16).
2. Die Maxima werden nicht aufsteigend aufgezählt, obwohl das in den Bedingungen klar formuliert ist.
Eine Ursache dafür konnte ich bis jetzt nicht erkennen.

Ich könnte lediglich noch einzelne Funktionen erstellen.
EDIT: Sorry für die Anzeige, aber wie gesagt, der spinnt bei einer bestimmten Breite.

simpsonsfan · 8. Mai 2013

Also deine Hauptschleife ist schon echt unübersichtlich.
Nach einem IF darf kein Semikolon vor dem then-part, also der geschweiften Klammer { stehen.

Ausserdem ist die Darstellung als 20x20 Gitter auf Project Euler doch prädestiniert dafür, die Zahlen gleich vor Beginn der Hauptschleife in ein [20][20]-Array zu stecken und die Umrechnung in die (zweistelligen) Zahlen nicht mit nach hinten zu ziehen. Einfach mal als Beispiel, wie gehen könnte, hier mal mein Versuch:

Code:

	short raster[20][20];
	
	//einlesen aus datei p11.txt

	FILE  *file = fopen("p11.txt","r");
	char c; short s=0, x, i=0;

	if(file == NULL){
		printf("Die Datei existiert nicht\n");
	}else{
		do{
		c = fgetc (file);
		if (('0' <= c) && (c <= '9')){		
			switch(s){
				case 0 :
					s=1;
					x= 10*(c - '0');
				break;
				case 1 :
					s=0;
					x+= c - '0';
					raster[(i/20)][(i++%20)] = x;
				break;
				}
			}	
		}while (c != EOF);
		//}while (i < 400);
	fclose(file);
	}
	
	//Raster eingelesen

Hancock · 8. Mai 2013

Ich würde das Einlesen so lösen:

Code:

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

datalukas · 9. Mai 2013

So, jetzt hab ichs:

Code:

#include "stdafx.h"
#include <string.h>
#include <stdlib.h> 

char zahl []= "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 0849 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 0081 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 6552 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 9122 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 8024 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 5032 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 7067 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 2124 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 7221 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 9578 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 9216 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 5786 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 5819 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 4004 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 6688 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 6904 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 3620 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 1620 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 5401 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48";
int maximum = 0;
int zahlenarray[59][20];

void StringZuArray()
{
	for(int zeile=0;zeile<=19;zeile++)
	{
		for(int ziffer = 0; ziffer <= 58; ziffer++)
		{
			zahlenarray[ziffer][zeile] = zahl[(zeile*59)+ziffer] - '0';
		}
	}
}
int nachRechts(int ziffer, int zeile)
{
	if(ziffer < 49)
	{
		StringZuArray();
		return (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) *
		(zahlenarray[ziffer+3][zeile] * 10 + zahlenarray[ziffer+4][zeile]) *
		(zahlenarray[ziffer+6][zeile] * 10 + zahlenarray[ziffer+7][zeile]) *
		(zahlenarray[ziffer+9][zeile] * 10 + zahlenarray[ziffer+10][zeile]);
	}
	else
		return 0;
}
int nachUnten(int ziffer, int zeile)
{
	if(zeile < 17)
	{
		StringZuArray();
		return (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) *
		(zahlenarray[ziffer][zeile+1] * 10 + zahlenarray[ziffer+1][zeile+1]) *
		(zahlenarray[ziffer][zeile+2] * 10 + zahlenarray[ziffer+1][zeile+2]) *
		(zahlenarray[ziffer][zeile+3] * 10 + zahlenarray[ziffer+1][zeile+3]);
	}
	else
		return 0;
}
int DiagonalUntenRechts(int ziffer, int zeile)
{
	if((ziffer < 49) && (zeile < 17))
	{
		StringZuArray();
		return (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) *
		(zahlenarray[ziffer+3][zeile+1] * 10 + zahlenarray[ziffer+4][zeile+1]) *
		(zahlenarray[ziffer+6][zeile+2] * 10 + zahlenarray[ziffer+7][zeile+2]) *
		(zahlenarray[ziffer+9][zeile+3] * 10 + zahlenarray[ziffer+10][zeile+3]);
	}
	else
		return 0;
}
int DiagonalUntenLinks(int ziffer, int zeile)
{
	if((zeile < 17)  && (ziffer > 8))
	{
		StringZuArray();
		return (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) *
		(zahlenarray[ziffer-3][zeile+1] * 10 + zahlenarray[ziffer-2][zeile+1]) *
		(zahlenarray[ziffer-6][zeile+2] * 10 + zahlenarray[ziffer-5][zeile+2]) *
		(zahlenarray[ziffer-9][zeile+3] * 10 + zahlenarray[ziffer-8][zeile+3]);
	}
	else
		return 0;
}
int main()
{
	int test;
	int maximum = 0;
	//Hauptzählschleife
	for(int zeile = 0; zeile<=19; zeile++)
	{
		for(int ziffer = 1; ziffer <=57; ziffer++)
		{
			//ist zahl[i] der Anfang einer Zahl? 
			if(zahlenarray[ziffer][zeile] != -16 && zahlenarray[ziffer+1][zeile] != -16)
			{
				//Kommt in den nächsten Tag
			}
		}
	}
	printf("%i", maximum);
	scanf("%i", &test);
	return 0;
}

Code:

//nach rechts/links
                if(nachRechts(ziffer, zeile)>maximum)
               {
			maximum = (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) *
				(zahlenarray[ziffer+3][zeile] * 10 + zahlenarray[ziffer+4][zeile]) *
				(zahlenarray[ziffer+6][zeile] * 10 + zahlenarray[ziffer+7][zeile]) * 
				(zahlenarray[ziffer+9][zeile] * 10 + zahlenarray[ziffer+10][zeile]);
		}
		//nach oben/unten
		if(nachUnten(ziffer, zeile)>maximum)
		{
			maximum = (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) *
				(zahlenarray[ziffer][zeile+1] * 10 + zahlenarray[ziffer+1][zeile+1]) *
				(zahlenarray[ziffer][zeile+2] * 10 + zahlenarray[ziffer+1][zeile+2]) * 
				(zahlenarray[ziffer][zeile+3] * 10 + zahlenarray[ziffer+1][zeile+3]);
		}
		//diagonal nach unten rechts
		if(DiagonalUntenRechts(ziffer, zeile)>maximum)
		{
			maximum = (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) * 
				(zahlenarray[ziffer+3][zeile+1] * 10 + zahlenarray[ziffer+4][zeile+1]) *
				(zahlenarray[ziffer+6][zeile+2] * 10 + zahlenarray[ziffer+7][zeile+2]) *
				zahlenarray[ziffer+9][zeile+3] * 10 + zahlenarray[ziffer+10][zeile+3]);
		}
		//diagonal nach unten links
		if(DiagonalUntenLinks(ziffer, zeile)>maximum)
		{	
			maximum = (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) * 
				(zahlenarray[ziffer-3][zeile+1] * 10 + zahlenarray[ziffer-2][zeile+1]) *
				(zahlenarray[ziffer-6][zeile+2] * 10 + zahlenarray[ziffer-5][zeile+2]) *
				(zahlenarray[ziffer-9][zeile+3] * 10 + zahlenarray[ziffer-8][zeile+3]);

Dass ich kein Semikolon hinter einer Bedingung schreiben kann, wusste ich schon. Nur ist mir das nicht aufgefallen. Trotzdem natürlich danke.

Und für die Vorschläge von Hancock und simpsonsfan bedanke ich mich natürlich auch, werde diese dann evtl. auch mal ausführen.

Layoutmäßig gibt es ein bisschen Probleme hier bei dem Code Tag, also das schaut nicht so aus bei mir, nochmal zu Erinnerung!

kuddlmuddl · 10. Mai 2013

Erstmal großes Lob, dieser Code sieht durch die Funktionen schonmal deutlich besser aus

Ich versteh nicht ganz wieso du dir die Mühe machst das Zifferweise zu behandeln aber naja..

Grundsätzlich ein wichtiger Tipp: Du hast einen großteil des Quellcodes total unnötig verdoppelt!

Code:

	//nach oben/unten
if(nachUnten(ziffer, zeile)>maximum)
{
maximum = (zahlenarray[ziffer][zeile] * 10 + zahlenarray[ziffer+1][zeile]) *
(zahlenarray[ziffer][zeile+1] * 10 + zahlenarray[ziffer+1][zeile+1]) *
(zahlenarray[ziffer][zeile+2] * 10 + zahlenarray[ziffer+1][zeile+2]) *
(zahlenarray[ziffer][zeile+3] * 10 + zahlenarray[ziffer+1][zeile+3]);
}

Wieso nicht einfach:

Code:

if(nachUnten(ziffer, zeile)>maximum)
{
  maximum = nachUnten(ziffer, zeile);
}

Oder noch besser mit einer max-Funktion

Code:

int max (int a, int b)
{
  if (a>b) return a;
  else return b;
}

Und dann nurnoch sowas:

Code:

maximum = max(maximum, nachUnten(ziffer, zeile));

Außerdem: Du mischt große und kleine Anfangsbuchstaben für Funktionen. Das ist sehr unschön weil man dann nicht auf anhib sieht, obs ne Funktion oder ein Konstruktor ist (Auch wenn du C programmierst...). Relativ üblich ist Funktionsnamen klein zu beginnen.
Daher ist die farbliche Formatierung in deinem Posting auch inkonsistent. Manche (die groß-geschriebenen) Funktionen sind Lila/Rosa und die anderen schwarz.

Wieso rufst du StringZuArray(); so oft auf?

C Schleifenproblem

Commodore

Commander

Commodore

Captain

Captain

Commander

Captain

Captain

Commander

Captain

Commander

Captain

Commander

Captain

Captain

Captain

Captain

Captain

Captain

Commander

Ähnliche Themen