:-D

[audax]

Oo

Ihr seid mir suspekt.
Die Implementierung in Perl habe ich geschrieben, weil cofi schlecht über Perl geredet hat

Und die hier in Haskell um mal wieder was in Haskell gemacht zu haben.

Code: Alles auswählen

getMiddle :: String -> Int -> String
getMiddle string len = take len $ drop offset string
    where 
    offset = ((length string) - len) `div` 2

myRandom :: Integer -> Int -> Integer
myRandom n 0 = n
myRandom n times = myRandom new (times-1)
    where
    string = show (n*n)
    new = read $ getMiddle string intLength
    intLength = length $ show n

[keppla]

Er will sagen, er hat noch nie die Aufgaben wie von seinen Lehrern erledigt. War basic verlangt, hat ers in Pascal gemacht. War Pascal dran, kam er mit C. Und in Englisch hat er immer in die Aufgaben in Latein geschrieben.

Ja, und genau für diesen "Algorithmus" hab ich einen trivialen "exploit" genannt
Dementsprechend verstehe ich nicht, in wiefern sich das auf mein Post bezieht.

Warum nicht doch die Aufgaben Lösen und dann bewusst einen oder mehrere kleine Fehler einbauen. *fg*

Ja, das fände ich Lehrreicher. Hier mein völlig fehlerfreier Vorschlag:

Code: Alles auswählen

def QuadratmittenmethodeNachNeumann():
   print (
     'SWNoIGhhYiBtZWluZSBI'
     'YXVzYXVmZ2FiZW4gY'
     'XVzIGRlbSBQeXRob2'
     '5mb3J1bSBhYmdlc2N'
     'ocmll\nYmVu\n'
   ).decode("base64")

if __name__ == '__main__':
    QuadratmittenmethodeNachNeumann()

[cofi]

Die Implementierung in Perl habe ich geschrieben, weil cofi schlecht über Perl geredet hat

Hab ich doch gar nicht Zumindest hatte ich das nich vor *g* Ich wollte nur verdeutlichen, dass es nicht "Die Lösung"(TM) gibt.

[Leonidas]

Und die hier in Haskell um mal wieder was in Haskell gemacht zu haben.

Und die hier in Scheme, um mal wieder was in Scheme gemacht zu haben.

Geht sicherlich eleganter, aber ich werd da irgendwann anders weiteroptimieren. ich könnte zum Beispiel mal die Features von PLT 4.0 richtig durchtesten. Aber ich dachte mir "Oho, es ist wieder Zeit irgendwessen Hausaufgaben in abstrusen Sprachen zu lösen"

Damit darf ich nun sagen: Ich kenne den Quellcode. Wo ist nun meine Million?

[Karl]

Damit darf ich nun sagen: Ich kenne den Quellcode. Wo ist nun meine Million?

1. Unglaubwürdige Aussage (Na gut, eigentlich dürfte man's dir zutraun :p) ohne Beweise.
2. Woher weißt du, dass sich der Titel auf das Posting bezieht? Heißt, wenn man's genau nimmt, könnte damit jeder beliebige Quellcode gemeint sein, da nicht näher auf die Frage eingegangen wird, was wiederum heißt, dass der Threadersteller, nachdem du ihm die Hausaufgaben gemacht hast, sagen könnte, dass du nicht den Quellcode kennst, den er meinte, aber er es trotzdem nett finden würde, seine Hausaufgaben in der nächsten Stunde präsentieren zu können.
3. eine Millionen was? Er kann dir eine millionen Byte an Text zukommen lassen.
4. Ja mir ist langweilig und ja ich wollte nur ein weiteres sinnloses Posting beisteuern
5. Wäre es cool, jetzt einfach den Pythoncode zu posten?

[n4p]

5. Wäre es cool, jetzt einfach den Pythoncode zu posten?

defintiv nicht

[BlackJack]

Und die obligatorische Lösung in Io:

Code: Alles auswählen

#!/usr/bin/env io

BigNum squared := method(self ** 2)
Sequence asBigNum := method(BigNum with(self))

QRandom := Object clone do(
    state ::= BigNum
    length ::= 0
    offset ::= 0
    
    with := method(n,
        result := QRandom clone setState(BigNum with(n))
        result setLength(result state asString size)
        result setOffset(result length >> 1)
    )
    
    next := method(
        state = state squared asString slice(offset, offset + length) asBigNum
    )
)

n := 11111
x := 20

random := QRandom with(n)
x repeat(random next println)

[Rebecca]

So, dann will ich auch mal. "Zufalls"zahlen in Emacs:

Code: Alles auswählen

(defun middle-letters (txt n)
  (let ((start (/ (- (length txt) n) 2))
	(end (/ (+ (length txt) n) 2)))
    (substring txt start end)))

(defun neumann-step (number)
  (let ((n (length (number-to-string number))))
    (string-to-number (middle-letters (number-to-string (expt number 2)) n))))

(defun neumann-rand (start steps)
  (dotimes (i steps start)
    (setq start (neumann-step start))))

(neumann-rand 123 3)

[Hyperion]

Ich warte auf Brainf**k oder zur Not Prolog

[EyDu]

Na gut, dann noch eine Prologlösung. Nicht schön, aber selten:

Code: Alles auswählen

square(N, M) :- M is N * N.
heads([H], []).
heads([H|T], [H|K]) :- heads(T, K).
intToList(I, L) :- intToListH(I, T), reverse(T, L).
intToListH(I, [I]) :- I < 10, !.
intToListH(I, [H|Tail]) :- H is I mod 10, R is I // 10, intToListH(R, Tail).
listToInt(L, A) :- reverse(L, R), listToIntH(R, 1, A).
listToIntH([E], F, G) :- E < 10, G is E*F, !.
listToIntH([H|T], F, E) :- A is H*F, FF is F*10, listToIntH(T, FF, C), E is A+C.
center(A, N, A) :- length(A, L), L =:= N, !.
center([H|T], N, B) :- length(T, L), I is L mod 2, I =:= 0, center(T, N, B), !.
center(T, N, B) :- heads(T, K), center(K, N, B), write('test'), !.
main(I, R) :- square(I, X), intToList(I, Z), intToList(X, Y), length(Z, L),
              center(Y, L, A), listToInt(A, R).

[Karl]

Wie genau ist denn "2. quadriere und wähle die mittleren n Ziffern als neue Zufallszahl" gemeint?
123456789
-> Welche Ziffern muss ich denn jetzt da rausnehmen?

[EyDu]

Du nimmst dir eine Zahl n. Zum Beispiel 5484.
Dann quadrierst du diese: 30074256.
Die Zufallszahl bildet sich dann aus den viert (weil n vier Zeichen lang ist) mittleren Ziffern des Quadrats: 0742.

[Karl]

Du nimmst dir eine Zahl n. Zum Beispiel 5484.
Dann quadrierst du diese: 30074256.
Die Zufallszahl bildet sich dann aus den viert (weil n vier Zeichen lang ist) mittleren Ziffern des Quadrats: 0742.

Okay, so hab ich mir das auch gedach, aber nehmen wir mal an, du nimmst 1111 und quadrierst diese Zahl: 1234321
So, welche sind die mittleren Ziffern?
2343 oder 3432?

[EyDu]

So, welche sind die mittleren Ziffern?

Such Dir eben eine der Möglichkeiten aus

[Karl]

So, welche sind die mittleren Ziffern?

Such Dir eben eine der Möglichkeiten aus

Wenn der uns hier schon einen Algorithmus beschreibt, könnte's ja auch eindeutig sein :p Ist ja sonst keiner.
Also *noch einen 6. Punkt gefunden hat, warum Leonidas keine Millionen kriegt* (wobei der 4. und 5. Punkt keine Gründe sind)

[Leonidas]

So, welche sind die mittleren Ziffern?

Such Dir eben eine der Möglichkeiten aus

Ja, das war auch genau der Punkt der mir das meiste Kopfzerbrechen bei meiner Lösung gekostet hat, weil ich mich nicht entscheiden konnte und das wohl nicht definiert war. Ich finde das aber recht blöd, weil es damit quasi zwei Arten des Algorithmus gibt, die unterschiedliche Ergebnisse liefern.

[Karl]

Ja, deshalb ist das korrekterweise auch kein Algorithmus.
Jedenfalls ist er zu unpräzise beschrieben.
Ich hab gerade angefangen, das in Brainfuck zu schreiben, aber ich bin noch nicht wirklich weit :p das is ne richtige Qual.

[numerix]

Es scheint so zu sein, dass man bei der Quadratmittenmethoden nach Neumann, um die es hier ja geht, in solchen Fällen, die "Mitte" nach rechts verschiebt.

Beleg - leider ohne weitere Erläuterung, warum gerade dies die Mitte ist:
http://statistik.mathematik.uni-wuerzbu ... seudo.html

[BlackJack]

Eine Lösung in C, die `libgmp` verwendet. Mittelpunktberechnung ist aber bei meinen Lösungen auf die hypothetischen doppelt so vielen Ziffern der Ausgangszahl bezogen, die beim Quadrieren entstehen können. Alles andere war mir zu kompliziert, weil man sich Sonderfälle einhandelt, wenn der aktuelle Zustand weniger als die hälfte der Ziffern der Ausgangszahl hat.

Code: Alles auswählen

#include <alloca.h>
#include <stdio.h>
#include <stdlib.h>
#include <gmp.h>

typedef struct {
    mpz_t state;
    unsigned int length;
} QRandom;

void QRandom_init(QRandom *r, unsigned long n)
{
    mpz_init_set_ui(r->state, n);
    r->length = mpz_sizeinbase(r->state, 10);
}

void QRandom_destroy(QRandom *r)
{
    mpz_clear(r->state);
    r->length = 0;
}

unsigned long QRandom_next(QRandom *r)
{
    char *tmp;
    unsigned int offset;
    
    mpz_mul(r->state, r->state, r->state);
    tmp = alloca(r->length * 2 + 1);
    mpz_get_str(tmp, 10, r->state);
    offset = r->length / 2;
    tmp[offset + r->length] = '\0';
    mpz_set_str(r->state, tmp + offset, 10);
    return mpz_get_ui(r->state);
}

int main(int argc, char** argv) {
    QRandom random;
    unsigned int i;
    
    QRandom_init(&random, 11111);
    for (i = 0; i < 20; ++i) {
        printf("%lu\n", QRandom_next(&random));
    }
    QRandom_destroy(&random);
    
    return EXIT_SUCCESS;
}

Wobei mir gerade auffällt, dass vielleicht auch mal eine 0 oder eine 1 als Zustand auftreten kann, dann sieht's blöd aus mit den folgenden "Zufallszahlen".

[mitsuhiko]

Und hier in Vimscript: http://paste.pocoo.org/show/73064/

Muss mal wieder Schmerzen spüren