Klotzkopp

Die Gesamtzahl der gesetzten Bits an Stelle k für alle Zahlen von 0 bis n steht fest. Wenn du dein Array nachzählst, und deine Summe für ein bestimmtes Bit um 1 zu klein ist, ist dieses Bit bei der fehlenden Zahl gesetzt.

Ja und? Grafikkartentreiber installieren. Der liegt vermutlich auf den CDs, die zum Mainboard gehören. Oder kann beim Boardhersteller runtergeladen werden.

Ich möchte dir nur als Tipp mit auf den Weg geben, dass die Office-Automatisierungsschnittstellen nicht gerade schnell sind, und m.M.n. für dein Vorhaben auch Overkill. Ich würde einfach eine CSV-Datei erstellen. Das geht schnell, und vor allem auch, ohne Excel selbst starten zu müssen. Du bist damit auch nicht an bestimmte Versionen von Excel gebunden. Excel kann solche Dateien prima bearbeiten, und zur Not geht das sogar ohne Excel. Eine Dokumentation der Office-Automatisierungssschnittstelle findest du in der MSDN Library. Ich nehme mal an, dass Borlands OLE-Komponenten einfache Wrapper um diese Klassen sind.

Es hätte auch gcc unter Linux sein können, da wäre die Vorgehensweise anders, denn was du da vorhast, ist plattformabhängig. Wie führst du den Ping denn aus? Mit system?

Das hier ist keine gute Idee. Danach steht in pos nicht mehr die Position, sondern der Wert an der Position. Die Position ist damit weg. Du brauchst aber die Position noch für die rekursiven Aufrufe. Benutz hier eine weitere Variable, oder verwende arr[pos].

Habe ich das richtig verstanden? Du hast Dev-C++ und MinGW einzeln heruntergeladen und installiert? Nicht das Dev-C++-Paket, in dem MinGW gleich mit drin ist? Dann wirst du wohl Dev-C++ noch so einrichten müssen, dass es seine Tools findet. Ich würde dir aber sowieso von Dev-C++ abraten. Nimm lieber eine aktuellere Entwicklungsumgebung.

Wie kommst du darauf? Nur Programme, die den Anforderungen der Strukturierten Programmierung genügen, lassen sich als Struktogramm darstellen. Viele Programmiersprachen bieten Funktionen, die nicht in das starre Schema der Strukturierten Programmierung passen. Das "On Error"-Feature von VB lässt sich damit genausowenig vereinbaren wie beispielsweise Exceptions in C++ oder Java.

Beide Themen sind bereits hinreichend oft durchgekaut worden Such einfach mal in diesem Unterforum nach "bewerten".

Einen Vorwärtssprung kannst du wie beschrieben durch eine Verzweigung ersetzen. Laut deinem ersten Beitrag ist es aber ein Sprung nach oben. Was denn nun? Warum kannst du das schlecht? Wenn du die Anforderung hast, dass das Programm in einem Struktogramm darstellbar sein soll, musst du dein Programm ändern.

Keine Ahnung. Die Anforderung, das in einem Struktogramm darzustellen, kommt doch von dir. Niemand hat behauptet, dass Strukturierte Programmierung performanceorientiert ist. Hier must du eben Prioritäten bei deinen Anforderungen setzen. In diesem Beispiel ist der Sprung überflüssig, weil alles, was übersprungen wird, sowieso in einem if-Block steht, dessen Bedingung genau das Gegenteil der Sprungbedingung ist. Allgemein lässt sich ein bedingter Vorwärtssprung durch eine Verzweigung mit derselben Bedingung ersetzen, deren Wahr-Zweig leer ist, und deren Falsch-Zweig den übersprungenen Code enthalt.

Ich weiß nicht, welche Zusätze dieses Tool da eingebaut hat, aber es gibt keine Jumps in Struktogrammen. Ein Call ist etwas Anderes. Da geht es nämlich hinterher an der Stelle weiter, die hinter dem Call folgt. Prozedural heißt nicht zwangsläufig strukturiert. Dann solltest du das tun, wenn du ein strukturiertes Programm haben willst.

Gar nicht. Struktogramme dienen dazu, Algorithmen in Strukturierter Programmierung darzustellen. In Strukturierter Programmierung sind Sprünge gar nicht erlaubt (oder zumindest stark eingeschränkt). Das Programm ist nicht strukturiert, also kannst du es auch nicht als Struktogramm darstellen.

Alle Stücke in derselben Reihe haben denselben Y-Wert. Alle Stücke in derselben Spalte haben denselben X-Wert. Alle bis auf die Reststücke haben dieselben width- und height-Werte. Das könntest du ausnutzen. Ich würde hier auch eher ein dynamisches Array als eine verkettete Liste benutzen. Immerhin ist doch vorher schon klar, wieviele Stücke es werden. Damit reduzierst du die Anzahl der Allokationen. In C könnte das so aussehen: ArgPtr_ptr parquet(int blockx, int blocky) { int i, j; int rows = MaxY / blocky + 1; int cols = MaxX / blockx + 1; int pieces = rows * cols; int overflowx = (MaxX + 1) % blockx; int overflowy = (MaxY + 1) % blocky; int lastrowstart = cols * (rows - 1); ArgPtr_ptr array = calloc(pieces, sizeof(ArgPtr)); for( i=0; i<pieces; ++i ) { array[i].arg = malloc(sizeof(struct ThrArg)); array[i].height = blocky; array[i].width = blockx; } for( i=0; i<rows; ++i ) { int y = i * blocky; for( j = 0; j<cols; ++j ) { array[i*cols+j].y = y; array[i*cols+j].x = j * blockx; } } if(overflowx > 0) { for( i=0; i<rows; ++i ) { array[i*cols+rows].width = overflowx; } } if(overflowy > 0) { for( j=lastrowstart; j<pieces; ++j ) { array[j].height = overflowy; } } return array; }[/code]

Der naheliegendste Weg wäre, das über long int* zu machen, denen im Konstruktor ein entsprechender mit new geholter Speicherbereich in der passenden Größe zugewiesen wird. Um das sauber zu implementieren, müsste man dazu allerdings weitere Methoden anlegen, die im Diagramm nicht gezeigt sind: Destruktor, Copykonstruktor und Zuweisungsoperator. Ohne diese zusätzlichen Methoden kommst du aus, wenn du die dynamischen Arrays als std::vector anlegst.

BASIC ist das aber nicht...

Damit hätten wir den Typ. Und wie ist der String codiert? Reines ASCII? UTF-8?

"String" ist etwas unspezifisch. Was genau hast du denn da? Welcher Datentyp? Welche Codierung?

Moment. Hängt sich das Programm auf, oder tritt eine Exception auf? Das schließt sich gegenseitig aus. Und um welche Exception handelt es sich genau? Hier wird nicht nur "neu eingegeben". Ich weiß nicht, ob du dir dessen bewusst bist, aber du hast hier keine einfache Wiederholung, sondern eine Rekursion. Die Funktion fängt durch diesen Aufruf nicht nur einfach wieder von vorn an. Dieser Aufruf bewirkt einen vollständigen Durchlauf von AddNewTemplate, und danach wird der Rest des ersten Aufrufs weiter abgearbeitet. Insbesondere also auch der Teil, der nach diesem Aufruf steht.

Diese Bedingung hier n >> i & 0ist einfach totaler Blödsinn. Damit kannst du nicht prüfen, ob das Bit an Stelle i nicht gesetzt ist. Dieser Ausdruck ist nämlich niemals wahr. Du verknüpfst da einen Wert binär-und mit 0, das Ergebnis ist immer 0, also false. Das meinte ich mit "Dein Test, ob ein Bit nicht gesetzt ist, ist falsch."

Das ist ja schon mal etwas, womit man auch etwas anfangen kann. Es hätte ja auch ein Compilefehler sein können Das wäre aber für die Helfer ziemlich wichtig. Dein blockliste-Array hat nur 31 Elemente. Du darfst als Index also nur 0 bis 30 (!) benutzen. blockliste[31] darfst du nicht verwenden, blockliste[32] schon gar nicht. Wie gesagt, da sind mehrere Fehler drin.

Das ist eine Fehlerbeschreibung, die bei der Fehlersuche leider nicht im Geringsten weiterhilft. Viel hilfreicher wäre hier gewesen, wie sich dieser Fehler auswirkt. Dass du ihn nicht findest, versteht sich von selbst, sonst würdest du hier ja nicht nachfragen. Aber hier mal ein paar Tipps: Es wäre wohl besser, den Inhalt von blockliste innerhalb der do-Schleife zurückzusetzen. Die erste Ausgabeschleife (warum hast du überhaupt zwei davon?) ist falsch: i ist um 1 zu groß. Dein Test, ob ein Bit nicht gesetzt ist, ist falsch. Den letzten Block zählst du grundsätzlich nicht mit. Dein Programm kann Blöcke der Länge 0 zählen, welche gar nicht auftreten können. Dafür kann es nicht mit Blöcke der Länge 32 umgehen.

Ich habe mal ein paar Tests gemacht. rolliwitschs Algorithmus (die Variante wird übrigens auch bei Wikipedia erwähnt) ist in der Tat schneller als ein "normaler" Selection Sort. Bei meinen Tests sind es etwa 30 bis 40% für die Sortierung von int-Feldern. Der Grund ist die reduzierte Anzahl an Schleifenoperationen (Inkrementierungen und Vergleiche). Der Effekt ist umso schwächer, je schneller diese Operationen im Vergleich zu Vergleichen und Vertauschungen der zu sortierenden Objekte selbst sind. Das ändert allerdings nichts an der Komplexitätsklasse des Algorithmus. Richtig spürbar wird der Effekt nur bei großen Arrays, für die man sowieso einen Algorithmus mit O(n log n) verwenden würde.

Nur so als Hinweis: Man kann Selection Sort so implementieren, dass man ohne solche Min/Max-Konstanten auskommt. Man kann das sogar in C++ als Template formulieren, dann kann man damit alles sortieren, was eine Ordnungsrelation hat, nicht nur Zahlen. Hast du ein Protokoll dazu? Das würde mich interessieren.

Gar nichts. Es spricht aber auch nichts dafür. Wie ich bereits sagte, bringt das keinen nennenswerten Perfomancegewinn. Du brauchst genauso viele Vergleiche und genauso viele Vertauschungen. Mal abgesehen davon, dass es keine "Publisher" gibt: Es gibt da nichts hinzubekommen. Du scheinst immer noch zu glauben, dass dein Algorithmus besser ist als ein normaler Selection Sort. Das ist aber nicht der Fall. Hast du meine Kommentare nicht gelesen? Was nichts Besonders ist, weil Selection Sort sowieso iterativ implementiert wird, denn die Rekursionstiefe wäre gleich der Anzahl der zu sortierenden Elemente, und so etwas versucht man zu vermeiden.

Das ist nicht egal, und die Begründung ist Unsinn. Ich rede nicht von deinen Umformungen. Ich rede vom Endergebnis. Schau dir deinen Code doch an. Du dividierst durch (c.X - a.X). Das bedeutet, dass du durch Null dividierst, wenn c.X gleich a.X ist. Daran gibt's nichts zu rütteln. Deine Ausgangsformel für s hat ein ähnliches Problem. Beim Auflösen nach s hast du durch (b.X - a.X) dividiert. Das darfst du aber gar nicht, wenn b.X gleich a.X ist. Du hast diverse Umformungen gemacht, dabei aber anscheinend völlig außer Acht gelassen, dass dabei Ausnahmen auftreten, die du vorher ausschließen musst.