|
|
|
|
|
|
|
Du wirst aber meist über y iterieren und wenn die hintereiander liegen ist das natürlich schneller.
Also erst y, danach x
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Gore am 16.01.2013 17:19]
|
|
|
|
|
|
|
|
|
|
Dann drehst du die Komponenten halt um. Soviel Grips habe ich Clix schon zugetraut.
|
|
|
|
|
|
|
|
|
|
|
Der Interop-Test von dem 4 Gewinnt bestätigt mal wieder mein Vorurteil dass in Informatik-Studiengängen viel zu wenig Leute anständig programmieren können. Besonders enttäuscht bin ich von einem Typen der zwar ein Nerd ohne soziale Fähigkeiten ist, aber das nicht mal durch außergewöhnliche Computerfähigkeiten ausgleicht  Der hat sogar einen Mac!
Klingt das sehr arrogant? Soll es nicht gemeint sein  Ich lästere nicht, ich erörterte nur Tatsachen!
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Danzelot am 16.01.2013 17:35]
|
|
|
|
|
|
|
|
|
Wenn auf dem Mac kein BSD, sonder nur OSX läuft, ist er ein Hipster, kein Nerd.
Es gibt nur einen Weg Programmieren zu lernen: Programmieren. Ich kenne auch genügend Leute im Master die es nicht schaffen würden in 2 Stunden einen Quicksort zu implementieren. Mit Ford-Fulkerson muss man denen gar nicht erst kommen.
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Kambfhase am 16.01.2013 17:42]
|
|
|
|
|
|
|
|
|
| | Zitat von Kambfhase
Wenn auf dem Mac kein BSD, sonder nur OSX läuft, ist er ein Hipster, kein Nerd.
Es gibt nur einen Weg Programmieren zu lernen: Programmieren. Ich kenne auch genügend Leute im Master die es nicht schaffen würden in 2 Stunden einen Quicksort zu implementieren. Mit Ford-Fulkerson muss man denen gar nicht erst kommen.
| |
Ich müsste mir auch immer wieder die Routine durchlesen, wie so ein Quicksort funktioniert. 
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Kambfhase
Wie willst du eine Matrix im Speicher ablegen, ohne die eine Dimension zu zerpflücken?
Man kann höchstens darüber streiten, welche Dimension zerpflückt werden soll: X, Y, oder beide. Ansonsten sehe ich da keinen großen Performance Unterschied zwischen den 2 oder auch 3 Ansätzen.
| |
sparse matrix alta. wenn du mehr nuller als werte hast, ist das keine schlechte idee.
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Kambfhase
Wie willst du eine Matrix im Speicher ablegen, ohne die eine Dimension zu zerpflücken?
Man kann höchstens darüber streiten, welche Dimension zerpflückt werden soll: X, Y, oder beide. Ansonsten sehe ich da keinen großen Performance Unterschied zwischen den 2 oder auch 3 Ansätzen.
| |
Der Unterschied ist eigentlich simpel. Wenn du deine Variante nimmst, wirst du wenn du Pech hast jede Zeile an einer anderen Stelle im Speicher haben - mit der ersten Variante hast du ein großes Array am Stück, weswegen nicht wild durch den Speicher gesprungen werden muss, wenn du darüber iterierst. Zusätzlich hast du eine Indirektion weniger.
Wie gesagt interessant ist das auch nur wenn man oft durch den größten Teil des Arrays iterieren muss... wenn man Random Access hat, dürfte das relativ wurscht sein. Gemessen habe ich das natürlich nie.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von AcidF!re
| | Zitat von Kambfhase
Wie willst du eine Matrix im Speicher ablegen, ohne die eine Dimension zu zerpflücken?
Man kann höchstens darüber streiten, welche Dimension zerpflückt werden soll: X, Y, oder beide. Ansonsten sehe ich da keinen großen Performance Unterschied zwischen den 2 oder auch 3 Ansätzen.
| |
Der Unterschied ist eigentlich simpel. Wenn du deine Variante nimmst, wirst du wenn du Pech hast jede Zeile an einer anderen Stelle im Speicher haben - mit der ersten Variante hast du ein großes Array am Stück, weswegen nicht wild durch den Speicher gesprungen werden muss, wenn du darüber iterierst. Zusätzlich hast du eine Indirektion weniger.
| |
Nein, in beiden Codes mache ich nur eine Speicherallokation. Die Indirektion über den Zeilen-Array (welcher im Cache vorgehalten wird) ist im anderen Fall eine Multiplikation. Das ist kein wesentlicher Unterschied. O(1)
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Kambfhase am 16.01.2013 18:21]
|
|
|
|
|
|
|
|
VOLL DRINGEND
|
Hi Leute,
gibt es eine Möglichkeit folgendes zu programmieren?:
Ich erstelle vier Online Umfragen, will dass alle Leute, die ich bitte daran teilzunehmen, zufällig auf eine der vier umfragen kommen. Daher gebe ich allen Leuten einen identischen LINK.
Dieser LINK führt sie auf eine HTML Seite, wo nun irgendwas programmiert ist, was zu eine der vier links weiterleitet. Auf dieser HTML Seite, also im Code, gebe ich dann die vier links zu den echten Umfragen an.
Also Person A klickt auf den Link, kommt auf eine HTML Seite, und am besten ohne Zeitverzögerung direkt auf LINK A, B, C oder D meiner Umfragen.
Das ganze sollte so programmiert sein, dass zb nicht 50 zu Seite A weitergeleitet werden und nur 5 zu Seite B. Es sollte entweder der Reihe nach (was schwierig ist wenn viele gleichzeitig kommen oder mehrere gleichzeitig) oder halt irgendwie mitgezählt werden, dass es wirklich einigermaßen gleichverteilt wird.
Ich hoffe ihr könnt mir helfen, wollte dazu keinen neuen Thread aufmachen.
Und wie geht das eigentlich, 6000 Seiten?
|
|
|
|
|
|
|
|
|
|
|
|
Hast du Serverseitig was zur Verfügung, PHP, Python, eine DB?
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Kambfhase
Hast du Serverseitig was zur Verfügung, PHP, Python, eine DB?
| |
hm keine Ahnung, ich würde schnell ne domain kaufen dafür mit dem minimalsten webspace und dann wieder kündigen. Das wäre egal ich hab jetzt schon über 100 euro für den tollen umfragedienst gezahlt der eben diese Funktion nicht bieten kann.
Da ich unter Zeitdruck stehe ist es also egal
um deine frage auch mal zu beantworten: Ja alles was 1und1 oder ähnliches verkaufen kann ich organisieren
|
|
|
|
|
|
|
|
|
|
|
|
Wieviel Leute erwartest du?
|
|
|
|
|
|
|
|
|
|
|
|
Dann kann dir einer der PHP-Cracks hier bestimmt was basteln.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Kambfhase
| | Zitat von AcidF!re
| | Zitat von Kambfhase
Wie willst du eine Matrix im Speicher ablegen, ohne die eine Dimension zu zerpflücken?
Man kann höchstens darüber streiten, welche Dimension zerpflückt werden soll: X, Y, oder beide. Ansonsten sehe ich da keinen großen Performance Unterschied zwischen den 2 oder auch 3 Ansätzen.
| |
Der Unterschied ist eigentlich simpel. Wenn du deine Variante nimmst, wirst du wenn du Pech hast jede Zeile an einer anderen Stelle im Speicher haben - mit der ersten Variante hast du ein großes Array am Stück, weswegen nicht wild durch den Speicher gesprungen werden muss, wenn du darüber iterierst. Zusätzlich hast du eine Indirektion weniger.
| |
Nein, in beiden Codes mache ich nur eine Speicherallokation. Die Indirektion über den Zeilen-Array (welcher im Cache vorgehalten wird) ist im anderen Fall eine Multiplikation. Das ist kein wesentlicher Unterschied. O(1)
| |
Nein, eben nicht. Um ein Zweidimensionales Array auf dem Heap anzulegen musst du etwa sowas machen:
| |
| Code: |
int** array = new int*[sizeX];
for(int i = 0; i < sizeX; ++i)
array[i] = new int[sizeY];
|
|
Außerdem sollte einen Pointer dereferenzieren länger dauern, als eine Multiplikation. Zusätzlich wird das Speicher freigeben auch noch hässlicher:
| |
| Code: |
for(int i = 0; i < sizeX; ++i)
delete[] array[i];
delete[] array;
|
|
Wenn man natürlich vorher weiß wie groß das Array sein wird, legt man es einfach auf den Stack an und hat keins der Probleme bzw, falls man C++11 hat lieber gleich ein std::array:
| |
| Code: |
std::array<std::array<int, 5>, 5> array;
|
|
E: hups, ich habe deine zweite Variante wohl nicht richtig durch gelesen, du hast recht. das ist ja im Prinzip nur Variante 1 in schöner
|
|
[Dieser Beitrag wurde 2 mal editiert; zum letzten Mal von AcidF!re am 16.01.2013 18:43]
|
|
|
|
|
|
|
|
|
| | Zitat von Redh3ad
Wieviel Leute erwartest du?
| |
ich schätze mal mehrere hundert. vielleicht unter 500 vielleicht auch unter 1000, ums mal genauer zu sagen. Können am ende auch 350 sein, je nachdem wie sich das verbreitet.
| | Zitat von Kambfhase
Dann kann dir einer der PHP-Cracks hier bestimmt was basteln.
| |
Ja wenn mir jemand das was basteln könnte wäre ich sehr dankbar, ich weis nicht wie komplex sowas ist, aber rein theoretisch müsste es gehen hoffe ich, denn sonst wüsste ich nicht wie ich das problem lösen könnte.
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von [MKKC]Gunman am 16.01.2013 18:36]
|
|
|
|
|
|
|
|
|
| | Zitat von Kambfhase
Wenn auf dem Mac kein BSD, sonder nur OSX läuft, ist er ein Hipster, kein Nerd.
| |
Es läuft ein OSX, aber das ist kein Hipster, sondern ein übelster Nerd. Der sieht nicht mal nach Hipsternerd aus, sondern wirklich nach klassischem Nerd.
|
|
|
|
|
|
|
|
|
|
|
Vll. war er Nerd, bevor es cool war.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von AcidF!re
Außerdem sollte einen Pointer dereferenzieren länger dauern, als eine Multiplikation.
| |
Ok, da gebe ich dir Recht.
| | Zitat von AcidF!re
| | Zitat von Kambfhase
Nein, in beiden Codes mache ich nur eine Speicherallokation. Die Indirektion über den Zeilen-Array (welcher im Cache vorgehalten wird) ist im anderen Fall eine Multiplikation. Das ist kein wesentlicher Unterschied. O(1)
| |
Nein, eben nicht. Um ein Zweidimensionales Array auf dem Heap anzulegen musst du etwa sowas machen:
| |
| Code: |
int** array = new int*[sizeX];
for(int i = 0; i < sizeX; ++i)
array[i] = new int[sizeY];
|
|
| |
Ich bringe die das mal schnell in C bei, da ich mir da in der Syntax sicherer bin. Aber in C++ muss das auch gehen.
| |
| Code: |
int *master = malloc(n*n*sizeof(int));
int **matrix = malloc(n*sizeof(*int)); |
|
Das Master-Array enthält die Elemente der Matrix. Die "matrix" Dagegen nur Zeiger auf die ersten Elemente einer Zeile:
| |
| Code: |
int i;
for( i=0; i< n; i++){
matrix[i] = master + i;
} |
|
Bei einem Zugriff passiert nun folgendes:
| |
| Code: |
matrix[1][2] = (matrix[1])[2] = (*(matrix+1))[2]
= (master + n)[2] = *(master + n + 2) // das 2te Element in der ersten Zeile |
|
Lass es dir durch den Kopf gehen. Vielleicht kommst du ja selber auf die Idee, wie du das Verfahren verwenden kannst, um zB. eine Dreiecksmatrix effizient abzuspeichern.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von [MKKC]Gunman
ich schätze mal mehrere hundert. vielleicht unter 500 vielleicht auch unter 1000, ums mal genauer zu sagen. Können am ende auch 350 sein, je nachdem wie sich das verbreitet.
| |
Dann würde ich das einfach zufällig machen, wenn die Verteilung nur ungefähr stimmen soll.
|
|
|
|
|
|
|
|
|
|
|
Hast du meinen Edit gelesen?
Ich dachte du hättest die Variante die ich gepostet habe gemeint, aber nicht ordentlich aufgeschrieben - hatte es nur überflogen. Aber du hast natürlich recht, sorry für (meine) Verwirrung.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Redh3ad
| | Zitat von [MKKC]Gunman
ich schätze mal mehrere hundert. vielleicht unter 500 vielleicht auch unter 1000, ums mal genauer zu sagen. Können am ende auch 350 sein, je nachdem wie sich das verbreitet.
| |
Dann würde ich das einfach zufällig machen, wenn die Verteilung nur ungefähr stimmen soll.
| |
Könnte es dann passieren dass es zb bei 1000 Teilnehmern so eine Verteilung geben würde:
n=1000
A=300, B=100, C=400, D=200?
oder wäre die Verteilung deutlich gleichmäßiger als dies hier?
Also ich meine wie das so in der Regel ist?
|
|
|
|
|
|
|
|
|
|
|
Zufällig heißt es könnte auch passieren, dass alle auf A landen...
Aber falls du dich interessiert, wie es "normalerweise" verteilt ist ruf mal den Link auf: http://jsfiddle.net/VjbbN/
Und dann oben immer auf Run drücken 
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Noch_ein_Kamel am 16.01.2013 19:25]
|
|
|
|
|
|
|
|
|
|
Um mal auf die Matrix-Diskussion zurückzukommen: Warum allokierst du nicht einfach ein n^2 langes Array und machst die Zugriff über umrechnen mit Hilfe der Dimensionen. Könnte man entweder nen Makro für nehmen, oder ne function an die man eben inline dranschreibt und hofft, dass der Compilter schon das richtige tut. Das ist schnell fürs iterieren und der wahlfreie Zugriff geht immernoch.
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von Noch_ein_Kamel
Zufällig heißt es könnte auch passieren, dass alle auf A landen...
Aber falls du dich interessiert, wie es "normalerweise" verteilt ist ruf mal den Link auf: http://jsfiddle.net/VjbbN/
Und dann oben immer auf Run drücken
| |
Wow, da ist doch extrem gut verteilt, fast 25% jeder
Kannst du den code auch so einrichten dass ich den irgendwie als Datei habe die ich hochladen kann, als einzelne webweite quasi?
ich hab btw das hier noch gefunden und teste es gerade:
| |
| Code: |
<html>
<head>
<script type="text/javascript">
function weiter() {
var adresse = new Array('seite1.htm', 'seite2.htm', 'seite3.htm', 'seite4.htm', 'seite5.htm');
var nummer = Math.floor(Math.random()*adresse.length);
location.href = adresse[nummer];
}
</script>
</head>
<body onLoad="setTimeout('weiter()',5000)"><h1>auswahl</h1></body>
</html> |
|
weiter unten gibt's dann das, ich glaube das ist dasselbe was du gepostet hast:
| |
| Code: |
var urls = [];
urls.push('http://www.google.de');
urls.push('http://www.klamm.de');
urls.push('http://www.php.net');
var random_index = Math.floor(Math.random()*urls.length);
location.href = urls[random_index]; |
|
das in php sieht irgendwie "mathematischer" aus
Ich weis nur nicht wie ich das als Datei hinkriege?
/bzw deins wäre am besten, weil da echt gut was rauskommt, also die Verteilung meine ich
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von [MKKC]Gunman am 16.01.2013 19:44]
|
|
|
|
|
|
|
|
|
| | Zitat von [MKKC]Gunman
/bzw deins wäre am besten, weil da echt gut was rauskommt, also die Verteilung meine ich
| |
Oh mann, lies dir mal was zu Wahrscheinlichkeiten durch 
|
|
|
|
|
|
|
|
|
|
|
OH gott es geht!
ich glaubs nicht!
| |
| Code: |
<html>
<head>
<title>test</title>
<script type="text/javascript">
//<![CDATA[
function redirect() {
var urls = [];
urls.push('http://www.p0t.de');
urls.push('http://www.google.de');
urls.push('http://www.vattenfall.de');
urls.push('http://www.spiegel.de');
var random_index = Math.floor(Math.random()*urls.length);
location.href = urls[random_index];
}
//]]>
</script>
</head>
<body onload="setTimeout(redirect, 1000);">
test
</body>
</html> |
|
@Noch_ein_Kamel: wie kann ich hier nur nochmal das in die Seite eingeben die du gepostet hattest, damit ich sehe, wie die zufallsverteiliung bei n=1000 wäre?
wenn das klappt dann bin ich gerettet
|
|
|
|
|
|
|
|
|
|
|
| | Zitat von [MKKC]Gunman
damit ich sehe, wie die zufallsverteiliung bei n=1000 wäre?
| |
|
|
[Dieser Beitrag wurde 1 mal editiert; zum letzten Mal von Redh3ad am 16.01.2013 20:02]
|
|
|
|
|
|
|
|
|
| | Zitat von Redh3ad
| | Zitat von [MKKC]Gunman
/bzw deins wäre am besten, weil da echt gut was rauskommt, also die Verteilung meine ich
| |
Oh mann, lies dir mal was zu Wahrscheinlichkeiten durch
| |
das werd ich in diesen tagen wohl machen müssen, und zwar massivst. ich muss nämlich die ganzen Daten auswerten. Statistik hatte ich zwar schon, aber auch alles wieder vergessen, waren eh nur Grundlagen.
Also nicht verübeln, für mich ist das eigentlich neuland, auch wenn man es für selbstverständlich ansieht das zu beherrschen zu kennen
|
|
|
|
|
|
|
|
|
|
|
Was? Das sind Grundlagen, die sollte man in der Schule gelernt haben.
|
|
|
|
|
|
|
|
| Thema: Gehirnsalat ( wir unter uns ) |
![[MKKC]Gunman](./avatare/[MKKC]Gunman.gif)
