In wie fern unperformant und lahm?
Beim SSH Login hats zum Teil ewig gedauert, eh die Shell da war. Und all solche Späße. Oder wenn du mal Tab completion nutzen wolltest, hat der auch immer erst ein paar Sekunde gehangen. War irgendwie komisch.
In wie fern unperformant und lahm?
Beim SSH Login hats zum Teil ewig gedauert, eh die Shell da war. Und all solche Späße. Oder wenn du mal Tab completion nutzen wolltest, hat der auch immer erst ein paar Sekunde gehangen. War irgendwie komisch.
import java.util.*;
public class zufallszahlen {
static long intervalSize;
static long intervalLimitLower;
static long intervalLimitUpper;
static long minimum;
static long maximum;
static boolean useBubblesort = true;
static boolean useInsertsort = true;
static long bubblesortDuration;
static long insertsortDuration;
public static long randomDigit(long a, long b) {
// gibt eine Zufallszahl im Intervall von [a;b] zurück
long c = b - a + 1;
long d = (long) (Math.random() * c) + a;
return d;
}
public static long timeMs() {
return System.currentTimeMillis();
}
// MAIN
public static void main(String[] args) {
System.out.println("zufallszahlen.java");
// ANZAHL: Abfrage, wie viele Zufallszahlen generiert werden sollen
System.out.println("********************************");
System.out.println("Wieviel Zufallszahlen sollen generiert werden?");
int randomDigitsCount = 10000; // todo: einlesen
long[] randomDigits = new long[randomDigitsCount];
// INTERVALL: Abfrage, in welchem Intervall die Zufallszahlen generiert werden
// sollen
System.out.println("*");
boolean intervalValid = false;
while (intervalValid == false) {
System.out.println("In welchem Intervall sollen die generierten Zufallszahlen liegen? [A;B]");
System.out.println("Definiere A:");
intervalLimitLower = 1; // todo: einlesen
System.out.println("Definiere A:");
intervalLimitUpper = 1000000; // todo: einlesen
if (intervalLimitLower < intervalLimitUpper) {
intervalValid = true;
} else {
System.out.println("[WARNUNG] Ungültiger Intervall");
}
}
// GENERIEREN: Array wird mit Zufallszahlen befüllt
for (int i = 0; i < randomDigits.length; i++) {
randomDigits[i] = randomDigit(intervalLimitLower, intervalLimitUpper);
}
// SORTIEREN BUBBLESORT https://www.youtube.com/watch?v=lyZQPjUT5B4
if (useBubblesort == true) {
// Array duplizieren
long randomDigitsBubblesort[] = new long[randomDigits.length];
for (int i = 0; i < randomDigits.length; i++) {
randomDigitsBubblesort[i] = randomDigits[i];
}
// eigentliches Sortieren
long bubblesortTimeAtStart = timeMs();
for (int i = 0; i < randomDigitsBubblesort.length; i++) {
for (int j = 0; j < randomDigitsBubblesort.length; j++) {
int highestElement = randomDigitsBubblesort.length - 1;
if ((j != highestElement) && (randomDigitsBubblesort[j] > randomDigitsBubblesort[j + 1])) {
long a = randomDigitsBubblesort[j];
long b = randomDigitsBubblesort[j + 1];
randomDigitsBubblesort[j] = b;
randomDigitsBubblesort[j + 1] = a;
}
}
}
long bubblesortTimeAtEnd = timeMs();
bubblesortDuration = bubblesortTimeAtEnd - bubblesortTimeAtStart;
maximum = randomDigitsBubblesort[randomDigitsBubblesort.length - 1];
minimum = randomDigitsBubblesort[0];
// DEBUG
/* for (int i = 0; i < 50; i++) {
System.out.println("randomDigitsBubblesort[" + i + "]=" + randomDigitsBubblesort[i]);
} */
}
// SORTIEREN INSERTSORT https://www.youtube.com/watch?v=ROalU379l3U
if (useInsertsort == true) {
// Array duplizieren
long randomDigitsInsertsort[] = new long[randomDigits.length];
for (int i = 0; i < randomDigits.length; i++) {
randomDigitsInsertsort[i] = randomDigits[i];
}
long insertsortTimeAtStart = timeMs();
for (int i = 0; i < randomDigitsInsertsort.length; i++) {
if (i != 0) { // der erste "linkeste" Wert kann schlecht mit einem noch früheren "linkeren"
// Wert verglichen werden
boolean keepgoing = true;
int j = i; // 0-99
while (keepgoing == true) {
if (j != randomDigitsInsertsort.length - 1) {
if (randomDigitsInsertsort[j] > randomDigitsInsertsort[j + 1]) {
long a = randomDigitsInsertsort[j];
long b = randomDigitsInsertsort[j + 1];
randomDigitsInsertsort[j] = b;
randomDigitsInsertsort[j + 1] = a;
if (j >= 1) {
j--;
} else {
keepgoing = false;
}
} else {
keepgoing = false;
}
} else {
keepgoing = false;
}
}
}
}
long insertsortTimeAtEnd = timeMs();
insertsortDuration = insertsortTimeAtEnd - insertsortTimeAtStart;
maximum = randomDigitsInsertsort[randomDigitsInsertsort.length - 1];
minimum = randomDigitsInsertsort[0];
// DEBUG
/* for (int i = 0; i < 50; i++) {
System.out.println("randomDigitsInsertsort[" + i + "]=" + randomDigitsInsertsort[i]);
} */
}
// FAZIT
System.out.println("********************************");
System.out.println("Z U F A L L S Z A H L E N");
System.out.println("********************************");
System.out.println("Intervall: [" + intervalLimitLower + ";" + intervalLimitUpper + "]");
System.out.println("Anzahl: " + randomDigits.length);
System.out.println("********************************");
System.out.println("Minimum: " + minimum);
System.out.println("Maximum: " + maximum);
System.out.println("********************************");
if (useBubblesort == true) {
System.out.println("Bubblesort: " + bubblesortDuration + "ms");
}
if (useInsertsort == true) {
System.out.println("Insertsort: " + insertsortDuration + "ms");
}
}
}
Alles anzeigen
zufallszahlen.java
********************************
Z U F A L L S Z A H L E N
********************************
Intervall: [1;1000000]
Anzahl: 100 000
********************************
Minimum: 17
Maximum: 999998
********************************
Bubblesort: 1107759ms
Insertsort: 2186672ms
Alles anzeigen
zufallszahlen.java
********************************
Z U F A L L S Z A H L E N
********************************
Intervall: [1;1000000]
Anzahl: 50000
********************************
Minimum: 5
Maximum: 999997
********************************
Bubblesort: 4071ms
Insertsort: 1126ms
Alles anzeigen
zufallszahlen.java
********************************
Z U F A L L S Z A H L E N
********************************
Intervall: [1;1000000]
Anzahl: 10 000
********************************
Minimum: 266
Maximum: 999940
********************************
Bubblesort: 113ms
Insertsort: 54ms
Alles anzeigen
zufallszahlen.java
********************************
Z U F A L L S Z A H L E N
********************************
Intervall: [1;1000000]
Anzahl: 1000
********************************
Minimum: 641
Maximum: 999917
********************************
Bubblesort: 13ms
Insertsort: 1ms
Alles anzeigen
Hat jemand zufällig (haha) eine Idee, warum Bubblesort beim ersten Durchlauf, der mit den meisten Zufallszahlen, so sehr viel effizienter als Insertsort ist? In den übrigen Durchläufen ist es konsquent und vor allem deutlich andersherum.
Dass die Laufzeit (Systemzeit in ms beim Beenden minus Systemzeit in ms beim Starten des jeweiligen Algorithmus') quasi "überdreht" halte ich für unwahrscheinlich, ich nutze hier long, der dürfte nicht voll werden. Ich würds nochmal durchlaufen lassen, aber das dauert etwa 40 Minuten...
(Das ist nicht extrem dringlich oder sonst irgendetwas. Die Aufgabe war, das ganze für 10 Zufallszahlen, mit der Möglichkeit, diese beliebig zu erhöhen, umzusetzen. Jedenfalls hab ich dann einfach mal große Zahlen eingegeben und bin zufällig darauf gestoßen.)
@03simon10 zählst Du die Anzahl an Vergleichen bzw. Vertauschungen?
hab aus meiner Schulzzeit ein Programm ausgegraben:
bei 48 absteigend sortierten Werten ergibt es eine "Statistik" diese aufsteigend zu sortieren die so aussieht:
hab es aber nicht mehr im Kopf, welchen Rechner ich hier hatte, der diese Werte (Zeitspalte) liefert;
Hmm. Ich habe mir einen Ping Exporter in Python3 für mein Prometheus geschrieben. Der arbeitet mit subprocess.popen und führt den Ping command vom OS aus.
Problem ist, dass der sich Stück für Stück mit RAM voll frisst. Die Subprozesse beenden sich ordentlich, aber so innerhalb von ein zwei Tagen Laufzeit braucht das Ding über nen halben GB RAM. Open End, bis der RAM vom Container randvoll ist.
Irgendwelche sich endlos verkettenden Variablen o.Ä. sind eigentlich nicht drin. Hab da mehrmals drüber geschaut... Irgendwelche Ideen oder Ansätze?
zählst Du die Anzahl an Vergleichen bzw. Vertauschungen
Nein. aber ist definitiv eine Erwägung für die nächste Version. Das mit dem UI sieht eigentlich auch ganz nett aus, aber das tu ich mir in Java lieber nicht an. (Kennt jemand hier den Java-Editor? Damit sollen wir UI Kram bauen, alles andere, wo die Befehlszeile reicht, wird aber bei mir in VSCode erledigt.)
Aber dein Verhältnis von Bubblesort und Insersort bestärkt ja meine Annahme, dass bei der sehr großen Anzahl an Zufallswerten etwas komisch ist. Vertauschungen zählen oder hin und wieder den Debugger anhalten und die aktuellen Variablen auslesen/screenshotten schafft hoffentlich abhilfe, aber heute nicht mehr.
so sieht die "Statistik" aus, wenn es bereits aufsteigend sortiert ist;
und hier eine Detailausgabe RANDOM.srt.pdf
(die Quellcode Snippets die da vorkommen sind aber nicht 1:1 Teil von dem Programm,
sondern dienen nur dazu es anschaulich darzustellen)
Hat jemand eine Idee, wie man den Virus kommt bzw. daran, was Rspamd zum auslösen bewegt hat? Die Mail hat keine Anhänge, kommt legitim von GameStop und hat auch keine "komischen" Links. Und es ist die zweite von denen...
Edit: ich rede übrigens von mailcow
Enthält sie irgendwelche Bilder?
Hat jemand eine Idee, wie man den Virus kommt bzw. daran, was Rspamd zum auslösen bewegt hat? Die Mail hat keine Anhänge, kommt legitim von GameStop und hat auch keine "komischen" Links. Und es ist die zweite von denen...
Was sagen denn die Logfiles von z.B. clamd
Enthält sie irgendwelche Bilder?
Ja (auf die Idee bin ich gar nicht gekommen), daran lag es jedoch nicht (zumindest nicht alleine).
Was sagen denn die Logfiles von z.B. clamd
In der mailcow UI wird der Log vom clamd nicht mit "aufgelistet", aber auf die Idee, beim Docker-Container nachzuschauen, bin ich natürlich nicht gekommen...PhishTank.Phishing.6162138.UNOFFICIAL(6b7ddfa7d355e4fda90378dd8040701e:6509) FOUND
Kann jemand erschwingliche On-Ear-Kopfhörer empfehlen, welche sowohl Bluetooth als auch 3,5mm-Klinke als Eingang haben?
Kann jemand erschwingliche On-Ear-Kopfhörer empfehlen, welche sowohl Bluetooth als auch 3,5mm-Klinke als Eingang haben?
Bin mit meinen Sennheiser HD 4.40 BT echt zufrieden, Anfang des Jahres für ca. 90 Euro erstanden. Etwas klobig (nicht schwer, stehen nur etwas vom Kopf ab), aber schöner Klang und schirmen durchs geschlossene System auch ganz gut ab. Habe sie derzeit größtenteils im (Home-)Office im Einsatz.
https://www.computerbase.de/20…-delta-max-rgb-ssd-preis/
Meine Güte... wo wollen die denn noch alles RGB einbauen? Also bei so Gehäuselüftern gehe ich ja noch mit, habe ich auch. Aber nun sogar die SSDs?
Kann jemand erschwingliche On-Ear-Kopfhörer empfehlen, welche sowohl Bluetooth als auch 3,5mm-Klinke als Eingang haben?
Habe diese Hier "August EP650" bin für den Peis sehr Zufrieden Damit. https://www.amazon.de/August-E…1567409238&s=ce-de&sr=1-3
https://www.computerbase.de/20…-delta-max-rgb-ssd-preis/
Meine Güte... wo wollen die denn noch alles RGB einbauen? Also bei so Gehäuselüftern gehe ich ja noch mit, habe ich auch. Aber nun sogar die SSDs?
oh man. Irgendwann leuchtet der Komplette PC xD. Viele Teile fehlen ja nicht mehr
Für die Stromkabel vom Netzteil gibt es ja auch schon LEDs damit die Leuchten xD
weiss einer wo der haken bei dem Angebot ist?
Der Haken ist, dass es eigentlich nur so halb Callya ist, da du zwangsweise einen Lastschrifteinzug erstellen musst. Dann der nächste Haken, dass du keinen telefonischen oder persönlichen Support mehr hast, und ein weiterer Haken, man kann (zumindest aktuell) nicht aus einem regulären Callya Tarif reinwechseln, da es ja in Wahrheit garnicht so wirklich echtes Callya ist.
wo für brauch man denn einen Telefon Support Lastschrift habe ich gelesen. erwarte aber eine größere Falle
wo für brauch man denn einen Telefon Support
Ja, würde mich auch nicht stören. Aber das mit der Lastschrift stinkt mir - Callya heißt Prepaid und eben keine Lastschrift o.Ä.
Aber das mit der Lastschrift stinkt mir - Callya heißt Prepaid und eben keine Lastschrift o.Ä.
Ist wohl die Antwort auf Freenet Funk Umlimited
Meine Güte... wo wollen die denn noch alles RGB einbauen?
Gibt doch schon seit letztem Jahr eine SSD mit RGB Beleuchtung.
Das macht den Computer doch schneller. Genauso wie die richtigen Rollen am Gaming Chair