neingeist

So, hier mein Entwurf für einen Artikel über die GPN3 für die beliebte Datenschleuder, dem Parteiorgan der Chris…Chaotischen Computerpartei Deutschlands. Find den nicht so gelungen, aber für’s Blog reicht’s allemal. Manuel schreibt noch seinen Technikkram dazu (natürlich alles mit BKNR!), dann ab zur Redaktion, denn heute ist Redaktionsschluss!

Am 22. und 23. Mai hat der Entropia e.V., die badische Inkarnation des globalen
Chaos, zur dritten Gulaschprogrammiernacht eingeladen. Etwa 100 Leute trafen
sich, um im Hackcenter coden, Vorträge zu verschiedenen Themen zu hören oder
einfach nur mit anderen Chaoten aus dem Umkreis rumzuhängen.

In diesem Jahr stand – im Gegensatz zu einem kleinen Keller oder einer
zu großen und leeren Fabrikhalle in den beiden vergangenen Jahren –
eine sehr gute Location zur Verfügung. Das Karlsruher Studentenzentrum
Z10 hatte uns übers Wochenende ihre Räume zur Verfügung gestellt.
Drei Stockwerke konnten wir für Hackcenter, Lockpicking, Chillout und
zwei Vortragsreihen nutzen.

Mein persönliches Highlight war ein ausgewogenes Vortragsprogramm,
beginnend bei robotlab.de, die bspw. Industrieroboter mit Platten
scratchen oder Portraits zeichnen lassen, über Daniel Kullas Lesung
aus dem “Phrasenprüfer” bis hin zu Themen wie “Das Individuum in der
virtuellen Gesellschaft”. Es wurde also einiges ausserhalb des
üblichen Technik-Kram geboten, wobei jedoch auch dieser Bereich
nicht zur kurz kam: Es gab Vorträge zu WLANs, Exploit-Techniken, einen
New-Technology-Battery-Guide, Kryptographie-Infos u.v.a.; unter
anderem konnten dieses Jahr auch Universitätsmitarbeiter als
Vortragende gewonnen werden. Wir hoffen, dass wir in diesem Bereich
noch mehr ausbauen können, damit die ordentlichen und angehenden
Akademiker auch etwas chaotische Unordnung erfahren dürfen. Da auch
das Uni-RZ uns freundlicherweise Netz gespendet hat, hatten wir auch
hier erstmals Möglichkeiten zum Austausch.

Wir hoffen in den nächsten Jahren wieder drei Tage Programm für
die südlichen Chaoten anbieten zu können, so dass das richtige
Hacker-Feeling – übernächtigt und nur durch Club-Mate intravenös am
Leben gehalten – wieder aufkommen darf! Vielleicht auch wieder mit
noch mehr Leuten, denn leider war uns dieses Jahr nur die halbe
Besucherzahl – verglichen zur GPN2 – gegönnt.

Die GPN3, die Veranstaltung von Chaos des Entropia e.V., einer Gruppe junger Rechner mit Rechner, ist vorbei. Ich werd’ da sicher noch mehr zu schreiben, denn ich muß bis Montag einen Datenschleuder-Artikel abgeben, hier sei nur mal die Resonanz in der Blogosphäre gesammelt. Falls ich noch mehr finde, werde ich updaten.

• 
  Patricks Blog: Zurück von der GPN3
• 
  byteBLOG: Impressionen von der GPN3
• 
  ka.stadtblog.de: GPN lockte 100 Computerbegeisterte ins Z10
• 
  redsheep.de: GPN3 Galerie (jaja, ich weiß, das ist kein Blog…)

Hier noch was gefunden:

• ThinkNerd: Gulasch Programmier Nacht 3 – Rückblick

One of my favorite problems when I try new programming languages is the Knight’s Tour. The goal is to move a knight on a chess board in a way that each square of the chess board is visited exactly once. The naive approach is to use simple backtracing, but a better way was found in the 19th century by H. C. Warnsdorff. This is an implementation of his algorithm. I hope the Lisp code is not too embarassing.

(defun start-tour (position)
(let ((board (make-array '(8 8))))
(move position board 1)))

(defun move (position board n)
(setf (aref board (car position) (cadr position)) n)
;;  (print-board board)
;;  (print (evaluate-possible-moves position board))
;;  (format t "~%")
(cond ((= n 64) (print-board board))
((null (possible-moves position board)) 'failed-dead-end)
((< n 64) (move (best-move position board) board (+ n 1)))))

(defun best-move (position board)
(car (evaluate-possible-moves position board)))

(defun evaluate-possible-moves (position board)
;;  (print position)
;;  (format t "~%")
(sort (mapcar #'(lambda (x) (append x (list (length (possible-moves x board)))))
(possible-moves position board))
#'(lambda (triple-a triple-b) (< (caddr triple-a) (caddr triple-b)))))

(defun print-board (board)
(do ((x 0 (+ x 1)))
((= x 8))
(do ((y 0 (+ y 1)))
((= y 8))
(format t "~2D " (aref board x y)))
(format t "~%"))
(format t "~%"))

(defun on-board-p (position)
(and (>= (car position) 0)
(<= (car position) 7)
(>= (cadr position) 0)
(<= (cadr position) 7)))

(defun visited-p (position board)
(> (aref board (car position) (cadr position)) 0))

(defun possible-moves (position board)
(remove-if #'(lambda (x) (visited-p x board)) (moves position)))

(defun moves (position)
(let ((x (car position))
(y (cadr position)))
(remove-if-not #'on-board-p
`((,(+ x 1) ,(+ y 2))
(,(+ x 1) ,(- y 2))
(,(- x 1) ,(+ y 2))
(,(- x 1) ,(- y 2))
(,(+ x 2) ,(+ y 1))
(,(+ x 2) ,(- y 1))
(,(- x 2) ,(+ y 1))
(,(- x 2) ,(- y 1))))))

I deciced to give Lisp a try and currently I’m struggling with a lot of parentheses and a lot of lambdas. Anyway, for the first day (or night) I’m really proud of this beauty: 🙂

;; Problem 3-9 (without tolerance)
(defun rightp (a b c)
(let ((longest-side-square (expt (car (sort (list a b c) '>)) 2))
(shorter-side-square-sum (apply '+ (mapcar (lambda (x) (expt x 2))
(cdr (sort (list a b c) '>))))))
(= longest-side-square shorter-side-square-sum)))

Thanks to Manuel of the BKNR project for their htmlize.lisp code!