Beim nächsten Mal werden wir mal schauen, ob wir einen Entwickler zur Organisation überreden können. Ansonsten müssen wieder die BWLer mit ihrem Blabla für die Orga herhalten. Ich hoffe, dass Du trotzdem dabei sein wirst.

Allerdings!

> aber “Auslosen” halte ich
auch fuer ein adaequates Verfahren: So sind am meisten Leute eingeladen mitzumachen, und zwar auch mit Ansaetzen, die absehbar nicht die kuerzesten Ergebnisse leifern koennen, dafuer aber vielleicht schoen perverse.

Eine Abstimmung der Beteiligten wäre noch besser … so bleibt der schale Nachgeschmack einer Onlinemarkingaktion mit BWLer-Floskeln!

Ich finde die LanX-Loesungen ganz toll! Wahres Hackertum in Reinkultur, das auch alle meine Kollegen sehr erfreut hat.

Wenn ich alles richtig verglichen habe, ist mein J Code tatsaechlich sehr sehr kurz, aber “Auslosen” halte ich
auch fuer ein adaequates Verfahren: So sind am meisten Leute eingeladen mitzumachen, und zwar auch mit Ansaetzen, die absehbar nicht die kuerzesten Ergebnisse leifern koennen, dafuer aber vielleicht schoen perverse.
Vielen Dank zum Beispiel fuer die “Assembler-Quetschungen”! Es ist so lange her, dass ich selbst mal Assembler gemacht habe, dass ich gar kein Gefuehl mehr dafuer habe, wie lang sowas auf diesem Weg wird. Schoen, das mal wieder sehen zu koennen.

Auch schoen: Die vielen Beitraege, die das bekannte Verfahren einfach nur uebernommen und andere Sprachen uebertragen haben. Das ist immer eine gute Gelegenheit, mal ein bisschen quer zu gucken und evtl. auch die Scheu zu verlieren, eine der noch unbekannten Sprachen anzugehen. So etwas geht ja IMMER irgendwie auf der Ebene “Hello World!” oder eben “Weihnachstbaum” los.

Ich habe vom Wettbewerb uebrigens ueber eine der Newsgroups (de.comp.lang.misc?) Ende Dezember mitbekommen — vielen Dank an den Poster des Hinweises!

Und zu guter letzt:

Zusammen mit einem Kollegen fand ich letzte Woche einen weiteren Ansatz in J, der noch mal 4 Zeichen kuerzer ist. See you next year

Vielen Dank allen Teilnehmern für die schönen Vorschläge

es gibt den XMAS-Compiler!
Ich habe ihn heute programmiert und zum Download zur Verfügung gestellt:
http://www.hubert-seidel.eu/downloads/xmasc1v00.zip
Enthalten ist der Compiler “xmasc” bereits compiliert und natürlich incl. Delphi5-Quellcode sowie zwei xmas-Beispiele (ein HelloWorld und Minimal-Quelltext für das Entwickler-Golf => Es funktioniert prächtig!!).
Das compilierte Programm sollte min. ab DOS3.3 (oder gar früher?) bis min. XP in der DOS-Box laufähig sein. Evtl. kann ja jemand berichten ob’s gar unter Vista läuft…

Das Hello-World-Beispiel (Quellocde incl. Kommentare 61 bytes) id compiliert 65 Bytes groß.

Das Minimal-Beispiel ist als Quelltext genau 1 Byte groß, und das compilierte Programm 61 Bytes.

Das Beispiel kann unter DOS wie folgt compiliert werden:
xmasc mini.xma
Es wird mini.com generiert welches mit mini ausgeführt wird.

xmasc versteht derzeit zwei Token und Kommentare #

T gibt ein Baum aus
; wartet auf ein Tastendruck
# alles danach wird ignoriert
Die Befehle sind nicht case sensitiv.

Der Compiler zerlegt den Quellcode in Token, schreibt anschl. ein Programm-Stub und generiert anschl. Code entsprechend der zerlegten Token.

Viel Spaß &
gruss
Hubert

Es mag sein, dass der Text etwas missverständlich zu Beginn ist. Trotzdem haben wir von Beginn an vorgehabt zu losen, haben es so geschrieben und so gemacht.

Mir bleibt eigentlich nur, mich auf Deine neue Programmiersprache “XMAS” zu freuen.

> Nur Kürze finde ich nicht sinnvoll und hat auch bei uns intern nicht die coolsten Ergebnisse vorgebracht.

Der gekürte interne Sieger war aber der kürzeste, nicht der coolste!

> Zudem gibt es Programmiersprachen, die für reine “Kürze” nicht geeignet sind. Die hätten dann gar nicht teilnehmen können, oder?

Die Wahl der Sprache war dem Entwickler ja auch freigestellt! Anders gefragt: die interne Pythonlösung ist die minimalst mögliche in dieser Sprache, wieso bekam sie keinen Preis “zugelost”?

Golfing heißt laut verlinkter WP-Seite “Gewinner ist der Programmierer, der für die erfolgreiche Lösung des Problems den kleinsten Quellcode…”

ich zitiere mal den zwoten Absatz hier:

“Beim Golf auf dem Rasen gewinnt der Spieler, der die wenigsten Schläge zum Einlochen benötigt. Daran orientiert sich auch der Golfwettbewerb unter Entwicklern: Ziel ist es, eine bestimmte Programmieraufgabe mit möglichst wenig Aufwand zu erledigen. Schnelligkeit und selbst Schönheitspreise spielen dabei untergeordnete Rollen, vielmehr zählen Kreativität und technologisches Know-how. Sieger des Wettbewerbs ist in der Regel der Teilnehmer mit dem schlankesten Code und damit derjenige, der die höchste Effizienz und Effektivität an den Tag legt.”

Sach mal, dein Schwerpunkt liegt eher im Verkauf als in der Technik, oder?

Nur Kürze finde ich nicht sinnvoll und hat auch bei uns intern nicht die coolsten Ergebnisse vorgebracht. Es geht ja um den Spass und die Originalität. Die können natürlich aus der Kürze entstehen. Aber die Lösung meines Bruders, die nach einem Zufallsbild bei Google sucht und dann in Asci einen Baum daraus generiert, fand ich schon ziemlich cool.

Zudem gibt es Programmiersprachen, die für reine “Kürze” nicht geeignet sind. Die hätten dann gar nicht teilnehmen können, oder?

Ich find’s okay so.

In einem nachvollziehbaren Verfahren hätte man:

1. Korrekte Ergebnisse auswählen müssen.
2. Diese lokal nachvollzogen.
3. Den oder die Kürzesten gekürt.
(4. evntuell bei mehreren Gewinnern den Hauptgewinn gelost)

Das ist zugegeben deutlich aufwändiger als Losen… zu blöd dass ich’s übersehen habe… mea culpa!

*TIP*
Alle missglückten Grafiken lassen sich im Firefox einigermaßen entschlüsseln indem man sie selektiert und per Rechtsklick auf “Quelltext anzeigen” geht!

Hat 2 Vorteile:
1. Mit der Basis (hier 4) stellt man die Steigung des Baumes nahtlos ein, weil auch Brüche erlaubt sind.
2. Ersetzen der Zahlenmuster taugen für Texturen wie Baumschmuck.

Ich habe in den Grafiken die Leerzeichen mit . ersetzt, um sie darstellen zu können (bitte letzten Post löschen)

____________________

.35Bytes: printf”%20d%d\n”,(4**$_)x2for 1..17
.
………………..44
……………….1616
……………….6464
………………256256
……………..10241024
……………..40964096
…………….1638416384
…………….6553665536
……………262144262144
…………..10485761048576
…………..41943044194304
………….1677721616777216
………….6710886467108864
…………268435456268435456
………..10737418241073741824
……………….-1-1
……………….-1-1
.____________________
.
.35Bytes: printf’%20d%1$d’.$/,4**$_ for 1..17
.
………………..44
……………….1616
……………….6464
………………256256
……………..10241024
……………..40964096
…………….1638416384
…………….6553665536
……………262144262144
…………..10485761048576
…………..41943044194304
………….1677721616777216
………….6710886467108864
…………268435456268435456
………..10737418241073741824
……………….-1-1
……………….-1-1
.____________________
Geschmückter Baum, lässt sich noch optimieren…
.57Bytes: ($x=4**$_)=~y/1-9/”/,printf”%22s%s\n”,($x)x2for 1..20,0,0
.
………………….”"
…………………”"”"
…………………”"”"
………………..”"”"”"
……………….”0″”"0″”
……………….”0″”"0″”
………………”"”"”"”"”"
………………”"”"”"”"”"
……………..”"”"”"”"”"”"
…………….”0″”"”"”0″”"”"
…………….”"”"”0″”"”"”0″
……………”"”"”"”"”"”"”"”"
……………”"”0″”"”"”"0″”"”
…………..”"”"”"”"”"”"”"”"”"
………….”0″”"”"”"”"0″”"”"”"”
………….”"”"”"”"”"”"”"”"”"”"
…………”"”"”"”"”"”"”"”"”"”"”"
…………”"”"”"”"”"”"”"”"”"”"”"
………..”"”"”"”0″”"”"”"”"”"0″”"”
……….”0″”"”"”"”"”"”0″”"”"”"”"”"
………………….”"
………………….”"
.____________________
.

rcx
36
w
q
=====
Mit nur noch 54 Bytes wird der Weihnachsbaum sogar in einer besseren Proportion dargestellt
Zudem konnte ich es ohne zusätzliche Installation auf:
MS-DOS 3.30c, Win Me und W2k
mit DEBUG assemblieren und laufen lassen. (XP und Vista konnte ich leider nicht testen)
Viel Spaß!

a) Den folgenden Text in eine Text-Datei namens “weihbaum.txt” speichern (ohne =====):

=====
nweihbaum.com
a
mov bx,0326
push bx
mov cl,14
call 11a
add bh,2
dec bl
loop 106
pop bx
mov cl,3
call 11a
loop 113
int 20
push bx
mov dl,20
mov ah,2
int 21
dec bl
jnz 11f
mov dl,58
int 21
dec bh
jnz 127
mov dl,d
int 21
mov dl,a
int 21
pop bx
ret

rcx
37
w
q
=====

Ohne “=====” bedeutet: Erste Zeile enthällt “nweihbaum.com”, die letzte nur ein “q” (die Leerzeile vor rcx ist wichtig!).

b) In der Commandozeile debug wie folgt aufrufen:
debug < weihbaum.txt
um weihbau,com zu erstellen

c) Ausgabe mit Starten von weihbaum.com in der DOS-BOX:
weihbaum.com

mov bx,806
push bx
mov cl,20
A:call C
add bh,2
dec bl
loop A
pop bx
mov cl,3
B:call C
loop B
int 020h
C:push bx
mov dl,32
mov ah,2
D:int 021h
dec bl
jnz D
mov dl,88
E:int 021h
dec bh
jnz E
mov dl,13
int 021h
mov dl,10
int 021h
pop bx
ret

Ein Byte kleiner als vorher

Ausgabe:

i
i|i
i/|\i
i//|\\i
i///|\\\i
i////|\\\\i
i/////|\\\\\i
|||
|||

; XXX
; XXXXX
; XXXXXXX
; XXXXXXXXX
; XXXXXXXXXXX
; XXXXXXXXXXXXX
; XXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
; XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
; XXX
; XXX
; XXX

;DOS => nasm weihbaum.asm -fbin -o weihbaum.com
org 0100h

section .text

stamm equ 3*256+38

@Start:
;==============================
mov bx, stamm
mov cl, 20
@Blp01: call @Line
add bh, 2
dec bl
loop @Blp01
mov bx, stamm
mov cl, 3
@Blp02: call @Line
loop @Blp02

;==============================
int 020h ; Exit 0

@Line: push bx
mov dl, 32
mov ah, 2
@Clp01: int 021h
dec bl
jnz @Clp01
mov dl, ‘X’
@Clp02: int 021h
dec bh
jnz @Clp02
mov dl, 13
int 021h
mov dl, 10
int 021h
pop bx
ret

;DOS => nasm weihbaum.asm -fbin -o weihbaum.com
org 0100h

section .text

jmp @Start

@InitOutput:
mov di, txt
mov al, 32
mov cl, 79
cld
rep stosb
mov ax, 0a0dh
stosw
mov al, ‘$’
stosb
ret

@Output:
mov dx, txt
mov ah,009h
int 021h
ret

@Expand:
mov si, txt+9
mov di, txt+68
mov ah, 30
@Alp01: mov al,[si+1]
mov [si],al
mov al,[di]
mov [di+1],al
inc si
dec di
dec ah
jnz @Alp01
ret

@Start: call @InitOutput
;==============================
mov cx, 18
mov byte [txt+39], ‘^’
call @Output
mov dword [txt+38], ‘/|\’
call @Output
mov bx, nadeln
call @Expand
call @Output
@Blp01:
call @Expand
mov al, [bx]
inc bx
mov [txt+37],al
mov [txt+41],al
call @Output
loop @Blp01
;
call @InitOutput
mov dword [txt+38], ‘|||’
mov cl,3
@Blp02: call @Output
loop @Blp02
;
xor ah,ah
int 016h ; Warte auf Tastendruck
;==============================
mov ax, 04c00h ; Exit 0
int 021h
nadeln db ‘%#%*OX§SI8@H&NZ0§%’
txt equ $

Optisch anspruchsvoller und kompatibel zu meiner Delphi-Variante, jedoch mit 152 Bytes 55 Bytes größer als die einfache Assembler-Variante… (Nach Copy&Paste nicht vergessen vor dem Assemblieren die Singlöe-Quotes anzupassen)

mfg.
Herby

;DOS => nasm weihbaum.asm -fbin -o weihbaum.com
org 0100h

section .text

@Start: call @InitOutput
;==============================
mov cx, 19
mov byte [txt+39], ‘X’
call @Output
@Blp01:
call @Expand
call @Output
loop @Blp01
;
call @InitOutput
mov dword [txt+38], ‘XXX’
mov cl,3
@Blp02: call @Output
loop @Blp02
;
;==============================
mov ax, 04c00h ; Exit 0
int 021h

@InitOutput:
mov di, txt
mov al, 32
mov cl, 79
cld
rep stosb
mov ax, 0a0dh
stosw
mov al, ‘$’
stosb
ret

@Output:
mov dx, txt
mov ah,009h
int 021h
ret

@Expand:
mov si, txt+9
mov di, txt+68
mov ah, 30
@Alp01: mov al,[si+1]
mov [si],al
mov al,[di]
mov [di+1],al
inc si
dec di
dec ah
jnz @Alp01
ret

txt equ $

OK, auch wenn die Darstellung hier hinkt,
hier die (verzerrte) Ausgabe :

X
XXX
XXXXX
XXXXXXX
XXXXXXXXX
XXXXXXXXXXX
XXXXXXXXXXXXX
XXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX
XXX
XXX
XXX

mfg.
Herby

(*
^
/|\
/|||\
/I|||I\
/IO|||OI\
/ION|||NOI\
/IONº|||ºNOI\
/IONº*|||*ºNOI\
/IONº*%|||%*ºNOI\
/IONº*%X|||X%*ºNOI\
/IONº*%X+|||+X%*ºNOI\
/IONº*%X+#|||#+X%*ºNOI\
/IONº*%X+#S|||S#+X%*ºNOI\
/IONº*%X+#SI|||IS#+X%*ºNOI\
/IONº*%X+#SIO|||OIS#+X%*ºNOI\
/IONº*%X+#SION|||NOIS#+X%*ºNOI\
/IONº*%X+#SIONº|||ºNOIS#+X%*ºNOI\
/IONº*%X+#SIONº*|||*ºNOIS#+X%*ºNOI\
/IONº*%X+#SIONº*%|||%*ºNOIS#+X%*ºNOI\
/IONº*%X+#SIONº*%X|||X%*ºNOIS#+X%*ºNOI\
/IONº*%X+#SIONº*%X+|||+X%*ºNOIS#+X%*ºNOI\
|||
|||
|||
*)

uses
SysUtils;

procedure WriteCenter(s:string);
begin
writeln(s:40+(Length(s) shr 1));
end;

const
nadeln : array[0..9] of char =’#+X%*§NOIS’;
stamm = ‘|||’;
var
i:integer;
s:string;
begin
s:=’^'; WriteCenter(s);
s:=’/|\’; WriteCenter(s);
s:=stamm;
i:=19;
while (i>0) do
begin dec(i);
WriteCenter(‘/’+s+’\');
insert(nadeln[i mod Length(nadeln)],
s, Length(s) shr 1);
insert(nadeln[i mod Length(nadeln)],
s, Length(s) shr 1+3);
end;
for i:=1 to 3 do WriteCenter(stamm);
readln;
end.

===========
Frohe Weihnachten (nachträglich)….

for($anzahl = 2; $anzahl <= 28; $anzahl += 2) {
$text = str_repeat(“*”, $anzahl);
echo $text . “<br />”;
}
echo str_repeat(“||||||<br />”, 3) ;

Hoffe jetzt passt es

for($anzahl = 2; $anzahl <= 28; $anzahl += 2) {
$text = str_repeat(“*”, $anzahl);
echo $text . “”;
}
echo str_repeat(“||||||”, 3) ;

for x in range(1,20)+[1]*3: print (‘**’*x).center(42)

Ein etwas hübscherer Baum in 136 Bytes:

print ‘\n’.join(['\n'.join([('/%s\\' % ((' '*i if i<n else '__'*i))).center(40) for i in range(n+1)]) for n in range(4)]+[' '*19+'||'])

perl -e ‘$s=25;printf” %${s}s%-${s}s\n”, (“#”x$_)x2 for 0..$s,1,1;’

Hier noch ein kleiner Ruby Einzeiler:

puts (0..30).map{|x|” “*(30-x)+”XX”*x+”\n”}.join+(” “*29+”||\n”)*2

Ergebnis hier:
http://www.le-matt.de/blog/nerd-stuff/

Viele Grüße und ein frohes Fest!

Matt

perl -e ‘@”=split”,”,”H\n,”.(“\\\n,/,”x3).”^\n”;print” “x$_,pop@”for(split”",21111032)’

https://babelize.org/christmas-tree

echo -e “#include \n#include \nint main() { int x; char *p = \”xxxxxxxxxx\”; for (x = 0; x < strlen(p); x++) { printf(\”%*.*s%s%.*s\\\n\”, (int)strlen(p), x, p, \”|\”, x, p); } printf(\”%*c%s%c\\\n\”, (int)strlen(p), p[0], \”|\”, p[0]); return 0; }” | gcc -x c – -o christmas-tree && ./christmas-tree

Danach sollte eigentlich ein schoenes Baeumchen erscheinen.

anyway, PHP wasn’t made for golfing

Guckst Du hier:
http://www.netgefluester.de/xmas.php

echo ”; $i=0; while($i<40) echo str_repeat(‘x’,$i+=2).”"; echo ‘xx’;

Bessere und effektivere PHP-Lösungen würden mich aber auf jeden Fall interessieren.

https://babelize.org/christmas-tree.c
https://babelize.org/christmas-tree.output

Die Groeße des Baums ist natuerlich ueber den zweiten Parameter der Funktion draw() einstellbar.

$ gcc christmas-tree.c -o christmas-tree

#include
#include
int draw(int x, char *p) {
        if (x > strlen(p)) { printf("%*c%s%c\n", (int)strlen(p), p[0], "|", p[0]); return -1; }
        printf("%*.*s%s%.*s\n", (int)strlen(p), x, p, "|", x, p);
        return draw(x + 1, p);
}

int main() {
        return (draw(0, "xxxxxxxxxx")<0);
}

Die Ausgabe des wunderschoenen Baums sieht dann so aus:

          |
         x|x
        xx|xx
       xxx|xxx
      xxxx|xxxx
     xxxxx|xxxxx
    xxxxxx|xxxxxx
   xxxxxxx|xxxxxxx
  xxxxxxxx|xxxxxxxx
 xxxxxxxxx|xxxxxxxxx
xxxxxxxxxx|xxxxxxxxxx
         x|x