Code: Alles auswählen
perl -e 'for(1..10){for $j(1..10){print"\n$_ x $j = ".$_*$j}print"\n"}'
Code: Alles auswählen
perl -e 'for(1..10){for $j(1..10){print"\n$_ x $j = ".$_*$j}print"\n"}'
Code: Alles auswählen
1:i;{i 10>}{1:j;{j 11<}{j print' x 'print i print' = 'print i j*p j):j;}while n print i):i;}until
Wow, da führt ja meine Basic-Variante mit 59 (respektive BJs Anmerkung 57) Zeichen klarderdon hat geschrieben: Edit: 98 Zeichen
Code: Alles auswählen
$ awk 'BEGIN{for(i=1;i<=10;++i)for(j=1;j<=10;++j)print i" x "j" = "i*j}'
Code: Alles auswählen
1:i;{i 10>}{1:j;{j 11<}{j' x 'i' = 'i j*++++puts j):j;}while n print i):i;}until
Code: Alles auswählen
0fOa=1to10:fOb=1to10:?b"x"a"="a*b:nE:?:nE
Code: Alles auswählen
timestable(X,Y,XY) :- between(1, 10, Y), between(1, 10, X), XY is X*Y.
writetimestable :-
forall(timestable(X,Y,XY), writef("%3r * %3r = %3r\n", [X, Y, XY])).
Code: Alles auswählen
#include <stdlib.h>
#include <stdio.h>
#include <omp.h>
#define MAX 10
int main(void)
{
puts("Das Einmaleins");
for(int i=1; i <= MAX; ++i) {
int result;
#pragma omp parallel for private (result)
for(int j=1; j <= MAX; ++j) {
result = i*j;
#pragma omp critical
{
printf("%d x %d = %d\n", i, j, result);
}
}
}
return EXIT_SUCCESS;
}
Code: Alles auswählen
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from multiprocessing import Pool
def f(n):
return '\n'.join('%d × %d = %d' % (i, n, i * n) for i in xrange(11))
def main():
print '\n\n'.join(Pool().map(f, range(11)))
if __name__ == '__main__':
main()
Gibt es da eigentlich eine gute Beschreibung, inwiefern das etwas bringt? Ich habe immer mir unverständliches bezüglich des GILs gelesen, aus dem ich mitnahm, dass Parallelisieren in Python quasi nix bringt. Würde mich mal interessieren, da etwas fundiertes, aber für mich verständliches zu lesenBlackJack hat geschrieben:In Python ist das Parallelisieren ja auch kein grosser Programmieraufwand:
Ah, ok. Das beudetet also, dass wenn eine Funktion den GIL nicht vorher freigibt, eine Parallelisierung keinen Benefit gibt, richtig?BlackJack hat geschrieben:Blockierende IO-Funktionen geben das GIL vor Ablauf der `n` Bytecodes frei und in C implementierte Funktionen können das GIL auch aufgeben und damit tatsächlich parallel zu Bytecode oder anderen C-Funktionen laufen.
Das kostet vermutlich deutlich mehr Rechenzeit und verbraucht auch mehr Ressourcen generell, oder? Würde also eher bei solchen Prozessen sinnvoll sein, die eine große Datenmenge separat bearbeiten können oder auch nicht ständig sich mit anderen Threads austauschen müssen.BlackJack hat geschrieben: Bei `multiprocessing` werden mehrere Prozesse gestartet und die können dann auch Bytecode parallel ausführen. Mit dem Nachteil, das die Argumente und Ergebnisse über Prozessgrenzen hinweg übermittelt werden müssen.