Ansätze:

J--Flap - vielleicht JFLAP?: http://www.jflap.org/
Turingmaschine: http://de.wikipedia.org/wiki/Turingmaschine
Primzahlen: http://de.wikipedia.org/wiki/Primzahlen
Google: http://google.com

Du wirst vermutlich zuerst schauen müssen, was eine Turingmaschine überhaupt ist, dann dir eine Turing-Maschine überlegen die Primzahlen testet.

Der einfachste (algorithmische) Ansatz ist wohl, einfach zu probieren ob man die getestete Zahl "n" durch irgendeine Zahl "i" von 2 bis n/2 durchdivideren kann (= so oft i aus n subtrahieren bis das Ergebnis <i ist, wenn es 0 ist dann lässt sich n durch i durchdividieren). Das, was ich gerade pseudocodeartig beschrieben habe, muss dann in die "Programmiersprache" der Turingmaschine übersetzt werden (Details siehe z.B. Wikipedia). Das ist vermutlich das Schwierigste an der ganzen Geschichte. Dann gilt es nur noch, die Turing-Maschine in diesem JFLAP-Framework zu implementieren (in JFLAP einlesen, ein paar Tutorials machen, Dokumentation verfolgen... - ich kenne es selber nicht).

Du machst einfach drei verschachtelte Schleifen. Die erste geht über alle möglichen Größen einer Matrix, die zweite z.B. über den Index der ersten Spalte der Teilmatrix (z.B. wenn du eine 4x4-Matrix hast und alle 2x2-Matrizen suchst, wird es Teilmatrizen geben, die in den Spalten 1,2 und 3 anfangen, also von 1 bis "Breite der Matrix - Teilmatrixgröße + 1") und die dritte über den Index der ersten Zeile der Teilmatrix (analog, nur für Zeilen und nicht für Spalten).
Benennst du die Zählvariablen z.B. n, i und j (in der angegebenen Reihenfolge), kannst du die durch (i,j) und (i+n-1, j+n-1) begrenzte Matrix dem Hauptdiagonalentest unterziehen (du überprüfst also ob (i, j), (i+1, j+1), (i+2, j+2) ... (i+n-1, j+n-1) gleich eins sind in einer Schleife); falls das passt kannst du so die Matrix ausgeben:

for (int a = i; a < i + n; a++) {
  for (int b = j; b < j + n; b++) {
    System.out.print(matrix[a][b]+" ");
  }
  System.out.println();
}

Ist es das was du brauchst?

Du kannst diese Schleifen natürlich auch als rekursive Funktionen formulieren, falls dir das eher liegt.

Siehe Attachment. Die .java-Datei ist auch in der JAR enthalten, einfach entzippen, ausprobieren, dann in Eclipse das Projekt aus der JAR importieren.

Beachte auch, dass sich Firefox scheinbar aufhängt, während der JDialog sichtbar ist - man muss es vermutlich auf nicht-modal setzen.

Zitat von Almlieschen

unter Eclipse funktionierts ja auch, nur in der großen, weiten Welt nicht mehr.....

Ich habe gerade so was implementiert und es funktioniert prima (Linux/Firefox 3.1). Ich tippe also mal darauf, dass du irgendwo einen Bug oder ein Konfigurationsproblem hast. Mögliche Ursachen sind eine alte JAR (nicht neu generiert oder das Java-Plugin nimmt noch eine alte Version aus dem Cache, wo setVisible() odgl nicht aufgerufen wird) oder, je nach Komplexität der Applikation, irgendwas bei der HTML-Einbindung, falsche Parameter, nicht gefundene Ressourcen, eine Exception zur Laufzeit (obwohl das mit Eclipse auch auftauchen sollte)...

Zitat von Almlieschen

Ich habe ein JApplet, das einen Text "exportieren" soll. Exportieren heißt, ein neues Fenster soll aufgehen und dort dieser Text dargestellt werden. Hab alles mit Eclipse entwickelt und da geht das auch einwandfrei. Sobald mein Applet läuft, wird durch

Code

Frame f = new Frame();
    JDialog popup = new JDialog(f, true);

ein neues Fenster gezeigt und Text ausgegeben, wie ich es haben will.

Blöde Frage - hast du eventuell popup.setVisible(true); vergessen? Je nach LayoutManager wirst du wohl auch ein popup.pack(); brauchen um die richtige Fenstergröße zu setzen.

Zitat

FF sagt mir nicht, dass Popups gestartet werden wollen und er das unterbindet, so, wie ers sonst macht....

Das sind keine Popups in dem Sinne (du machst ja kein neues Browserfenster auf). Die Java-Applet-Fenster werden meineswissens nach nicht geblockt, dafür erscheint bei nicht-vertrauten Applets unten ein Label mit "Java Applet Window." odgl.

Mmh, das klassische Bubble Sort (steht auch im Funktionsnamen - bubbleSort)! Ein zwar vergleichsweise einfach zu programmierendes, aber dennoch asymptotisch nicht ganz effizientes Sortierverfahren.

Google kann dir sagen was Bubble Sort ist, ja sogar Wikipedia hat eine ganze Seite drüber. Warum schaust du nicht IMMER hier zuerst nach?
http://www.google.com/search?q=bubble+sort
http://de.wikipedia.org/wiki/Bubble_Sort

Im Prinzip funktioniert das so, dass der Reihe nach alle Elemente eines Arrays durchgelaufen werden (äußere Schleife mit dem i). In der inneren Schleife (die mit dem j) steigen Elemente "wie Seifenblasen" auf vom Index der äußeren Schleife (i) über alle Elemente drüber, die kleiner als sie sind. Das "Aufsteigen" erfolgt durch den klassischen Dreieckstausch der zwei aktuellen Arrayelemente.

So wäre es obskur:

unsigned n=<zahl>, f=1;
while(n&&(f*=n--));

Zitat von huevo

1) gibts da eine möglichkeit ein leerzeichen automatisch zu erzeugen

Mit g*qq, z.B. so:

Heraklit sagte einst: \glqq{}Alles fließt\grqq{}.

Zitat

2) gibts überhaupt eine schönere möglichkeit, weil jedesmal \glqq \grqq zu schreiben ist blöd.

Ja, so: "`Alles fließt"' (beachte die unterschiedlichen Hochkomma-Varianten).

Zitat von anfänger_engel

wie kann ich die Funktion Prim() beschleunigen, indem nicht so viel unnütz gesucht wird?

Dafür gibt es einige Ansätze (siehe z.B. http://de.wikipedia.org/wiki/Primzahltest), die mit mehr oder weniger Aufwand verbunden sind.

Zitat

Wie groß kann der größte echte Teiler denn höchstens sein?

Der größte mögliche Teiler einer Zahl p (außer p selbst) ist [tex='\lfloor\sqrt{p}\rfloor'][/tex]

, d.h. die größte ganze Zahl, die kleiner oder gleich die Wurzel von p ist.
Eine andere Schranke (wenn du sqrt() nicht aufrufen willst), ist [tex='\frac{p}{2}'][/tex]

.

Du kannst deinen Algorithmus auch beschleunigen, indem du z.B. gerade Zahlen größer als 2 beim Test überspringst (also bei 61 würdest du 2, 3, 5 und 7 probieren, aber nicht 4 oder 6). Im Allgemeinen kann man alle Zahlen, die keine Primzahlen sind, überspringen; jedoch müsste man dafür schon eben eine Liste von Primzahlen haben, auf der man schnell zugreifen kann.

Zitat von War10ck

hi,

ich wollte fragen ob es in java möglich ist ein Integer overflow zu provozieren der dann zu sicherheits relevanten problem wird?

thx a lot

In Java gibt es bei Integers (= auch 'int's) einen Wraparound, d.h. Integer.MAX_VALUE + 1 == Integer.MIN_VALUE. Das kann sehr wohl zu Problemen führen, z.B. wenn du (hypothetisch) eine Liste mit Integer.MAX_VALUE (das sind 2^31-1, ungefähr 2 Mrd.) Elemente hast, ein Element dazu tust und size() aufrufst, und auf einmal ist das Ergebnis negativ.

Wenn du "echte" Ganzzahlen brauchst, nimm BigInteger.

Zitat von Mr.Radar

Ich frag mich sowieso, wozu die Aussage des Gurus gut sein soll - deckt die nur den Fall, dass 1 Person blaue Augen hat, ab, oder steckt da logisch gesehen mehr dahinter?

Der Guru sagt einmal, und ein einziges mal, "Jemand hier hat blaue Augen". Was genau diese Aussage bewirkt musst du herausfinden. Sie hat natürlich damit zu tun, dass Leute dann die Insel verlassen (müssen).

Das war lustig, ja. ty fürs posten.

Zitat von Wolfibolfi

Mit einem Palindrom hättest uns beeindruckt!

Bitte schön.

#vapyhqr <fgqvb.u>//
vag cm;vag thrygvtr_mnuy(ybat mnuy){erghea ((hafvtarq ybat)mnuy)<0k989680;}vag cehrsmvssre(ybat mnuy){erghea (mnuy%10+(2*((mnuy/=10)%10))%10+(2*(mnuy%10))/10+(mnuy/=10)%10+(2*((mnuy/=10)%10))%10+(2*(mnuy%10))/10+(mnuy/=10)%10+(2*((mnuy/=10)%10))%10+(2*(mnuy%10))/10+(mnuy/=10))%10;}vag grfg(ybat mnuy){erghea (cm=cehrsmvssre(mnuy/0kn))==mnuy%10;}znva(){ybat m;juvyr(fpnas("%yq",&m)!=RBS)cevags(thrygvtr_mnuy(m)?(grfg(m)?"bxnl\a":"snyfpur Ceüsmvssre - evpugvtr ynhgrg: %q\a"):"hatüygvtre Mnuyrajreg\a", cm);}//
//};)mc ,"a\gerjaryunM ertvgyütah":)"a\q% :grghny rtvgupve - erssvmsüeC rupfyns":"a\lnxb"?)m(gfrg(?)m(yunm_rtvgyrht(sgavec)SBR=!)m&,"qy%"(sanpf(ryvuj;m taby{)(avnz};01%yunm==))nk0/yunm(erssvmsrhec=mc( aehgre{)yunm taby(gfrg gav};01%))01=/yunm(+01/))01%yunm(*2(+01%))01%)01=/yunm((*2(+01%)01=/yunm(+01/))01%yunm(*2(+01%))01%)01=/yunm((*2(+01%)01=/yunm(+01/))01%yunm(*2(+01%))01%)01=/yunm((*2(+01%yunm( aehgre{)yunm taby(erssvmsrhec gav};086989k0<)yunm)taby qratvfah(( aehgre{)yunm taby(yunm_rtvgyrht gav;mc gav
//>u.bvqgf< rqhypav#

Hat sogar eine Zeile weniger!

Zitat von Plantschkuh!

Ganz im Gegenteil, Madame!

Genau!

Hier ist eine Version in C; leider ist sie umständlich programmiert, nicht kommentiert, nicht ganz lesbar und aus irgendeinem Grund auch noch ROT-13-verschlüsselt.

#vapyhqr <fgqvb.u>
vag cm;vag thrygvtr_mnuy(ybat mnuy){erghea ((hafvtarq ybat)mnuy)<0k989680;}
vag cehrsmvssre(ybat mnuy){erghea (mnuy%10+(2*((mnuy/=10)%10))%10+(2*(mnuy%10))/10+(mnuy/=10)%10+(2*((mnuy/=10)%10))%10+(2*(mnuy%10))/10+(mnuy/=10)%10+(2*((mnuy/=10)%10))%10+(2*(mnuy%10))/10+(mnuy/=10))%10;}
vag grfg(ybat mnuy){erghea (cm=cehrsmvssre(mnuy/0kn))==mnuy%10;}
znva(){ybat m;juvyr(fpnas("%yq",&m)!=RBS)cevags(thrygvtr_mnuy(m)?(grfg(m)?"bxnl\a":"snyfpur Ceüsmvssre - evpugvtr ynhgrg: %q\a"):"hatüygvtre Mnuyrajreg\a", cm);}

Zu allem Überfluss: Ich glaube dass sich beim Programm, das geschrieben werden soll, um die Ausgabe der ersten 20 Fibonacci-Zahlen in umgekehrter Reihenfolge handelt, also (für die 40€):

#include <stdio.h>


int fib(int n) {
  return n<3?1:fib(n-1)+fib(n-2);
}


int main(void) {
  int i = 20;
  while (i) {
    printf("%d\n", fib(i--));
  }
  return i;
}

Für Optimierung verlange ich extra.

Zitat von mdk

exakt gibt es 5.282 aufrufkonventionen.

Ich glaube du hast ein paar vergessen, aber das macht nichts, denn diese muss man sowieso nur bei den Floating Point - Befehlen beachten.

EDIT: Ok, es gibt nur drei.

Zitat von Wolfibolfi

Wann is eigentlich der Weltmännertag? Oder sind das alle andern?

Anscheinend am 3. November. Seit 2000. Aber keiner feiert ihn. :devil:

(du kannst dir das Durchlesen des Wikipedia-Artikels jetzt ersparen)

Mein Belkin F8T001v2 (um 19,90 bei MediaMarkt, aber vor gut 2 Jahren) funktioniert unter Linux auch tadellos.

Ich rate mal... ist es vielleicht so was?
http://www.dealtime.co.uk/xPF-Wacom_Seri…ini_DIN_M_1_8_m

Das scheint für einen seriellen Port von Apple zu sein, dafür gibt's sicher Adapter.

Zitat

1. Wie kann ich JAR-Files erstellen?

Mit dem Befehl: jar cf <dateiname> <dateien>
Such einfach nach jar.exe, sollte im jdk-bin-Verzeichnis sein.

Zitat

2. Muss ich alle Class-Dateien die ich für das Programm brauche in einne JAR-Datei umwandeln oder nur die die ich ausführen möchte?

Alle die dein Programm braucht, außer die, die mit dem JRE mitgeliefert sind (also java.*, javax.*, usw). Ich nehme an, je nachdem wie du die JAR-Dateien ausführst, dass sie auch unter mehrere JARs verteilt werden können.

Zitat

3. Kann ich die JAR-Dateien einfach per Doppelklick wie EXE-Dateien öffnen?

JAR ist eigentlich ein Archiv-Format, da stehen mehrere Verzeichnisse, .class-Dateien usw drin (so wie .zip). Du kannst Windows so einstellen (Extras->Ordneroptionen->Dateitypen..), dass .jar-Dateien automatisch mit javaw -jar <jardatei> geöffnet werden (wenn das nicht schon der Fall ist)