Linenoise Competition

[Peter J. Holzer]

Ich habe gerade in Perl einmal zu oft ->$#* getippt und mich an längst
vergangene !*++* C-Tage erinnert. Da könnte man doch einen Wettbewerb
daraus machen.

Regeln:

Gesucht ist die längste Folge an "line noise" Characters in einem
Programm in beliebiger Programmiersprache. Als "line noise" gelten alle
Zeichen außer Buchstaben, Ziffern und Whitespace.

Das Programm muss kompilierbar sein und ohne Laufzeitfehler laufen. Wenn
es einen Sprachstandard gibt, muss es diesem entsprechen. Es muss nichts
sinnvolles tun,

Jeder Operator darf nur einmal verwendet werden, Klammern dürfen nur
verwendet werden, wenn sie nicht redundant sind (sonst lassen sich
trivial beliebig lange Folgen erzeugen). Whitespace kann zur
Untersützung des Lexers eingefügt werden, wird aber nicht mitgezählt.

Hier sind meine Versuche für C und Perl:

C: 13 Zeichen:

char a[2] = {1, 2};
char *b = a;
char *c = a;

*c++*=~!-+--*++b;
//1234567890123
// 1111

Perl: 14 Zeichen:

my $a = [0];

$a->$#*||=~!+-@$a;
# 12345678901234
# 11111

Das Perl-Beispiel nützt das experimentelle postderef Feature (ab Perl
5.14). In Perl gibt es außerdem eine ziemlich triviale Möglichkeit, sehr
lange Folgen zu erzeugen, ich überlege mir noch, ob ich eine zusätzliche
Regel einführe, um das zu verhindern.

Viel Spaß!

hp

PS: Ich werde Einträge auf https://github.com/hjp/linenoise sammeln, wer
will, kann das natürlich auch forken.

[Peter J. Holzer]

Post by Peter J. Holzer
Ich habe gerade in Perl einmal zu oft ->$#* getippt und mich an längst
vergangene !*++* C-Tage erinnert. Da könnte man doch einen Wettbewerb
daraus machen.

[...]

Niemand? Niemand ist wenig. (Wie mein Lateinprofessor zu sagen pflegte)

Ich bin enttäuscht. Mindestens mit einem APL-Beitrag hätte ich schon
gerechnet.

hp

[Stefan Reuther]

Post by Peter J. Holzer

Post by Peter J. Holzer
Ich habe gerade in Perl einmal zu oft ->$#* getippt und mich an längst
vergangene !*++* C-Tage erinnert. Da könnte man doch einen Wettbewerb
daraus machen.

[...]
Niemand? Niemand ist wenig. (Wie mein Lateinprofessor zu sagen pflegte)
Ich bin enttäuscht. Mindestens mit einem APL-Beitrag hätte ich schon
gerechnet.

Na dann:

Das eine Nulloperation in C++11:
[=](){}();

Der einzige "Operator" darin ist "()" (der Rest ist "sonstige Syntax"),
also kann man das schachteln:
[=](){[&](){}();}();

Noch eine sinnlose Operation davor:
a[i++]--,[=](){[&](){}();}();
12345678901234567890123
11111111112222

Krieg ich jetzt 'n Keks? :-)


Stefan

[Peter J. Holzer]

Post by Stefan Reuther
[=](){}();
Der einzige "Operator" darin ist "()" (der Rest ist "sonstige Syntax"),
[=](){[&](){}();}();
a[i++]--,[=](){[&](){}();}();
12345678901234567890123
11111111112222

Da habe ich jetzt erst mal eine ruhige Stunde gebraucht, um das
auseinanderzuklauben.

Post by Stefan Reuther
Krieg ich jetzt 'n Keks? :-)

Ja, und noch zwei Extrakekse für die kreative Auslegung der Regeln:

* Die Unterscheidung zwischen "Operatoren" und "sonstiger Syntax"
* Die Idee, einen Operator ganz am Ende noch einmal zu verwenden, aber
davor aufzuhören, zu zählen.

hp

[Stefan Reuther]

Post by Peter J. Holzer

Post by Stefan Reuther
[=](){}();
Der einzige "Operator" darin ist "()" (der Rest ist "sonstige Syntax"),
[=](){[&](){}();}();
a[i++]--,[=](){[&](){}();}();
12345678901234567890123
11111111112222

Da habe ich jetzt erst mal eine ruhige Stunde gebraucht, um das
auseinanderzuklauben.

Derjenige, der in meinem Softwareentwicklungsteam C++11 vorstellte,
bezeichnete Lambdas als Smiley-Krieg :-)

Post by Peter J. Holzer

Post by Stefan Reuther
Krieg ich jetzt 'n Keks? :-)

* Die Unterscheidung zwischen "Operatoren" und "sonstiger Syntax"
* Die Idee, einen Operator ganz am Ende noch einmal zu verwenden, aber
davor aufzuhören, zu zählen.

Das hast du ja ähnlich gemacht, du hattest ja zwei Dereferenzierungs-
operatoren (*).

Ansonsten ist das Limit für C++ relativ einfach zu ermitteln, wenn man
nur wirkliche Operatoren benutzt (also das, was als "expression"
definiert ist): man nehme alle Postfixoperatoren und klatsche die
aneinander, außerdem alle Präfix-Operatoren, und noch einen möglichst
langen Infix-Operator dazwischen. Das braucht dann nur noch eine
passende Klassendefinition; Operator-Overloading kann quasi alle
Operatorkombinationen legalisieren. Damit komme ich auf...

struct a {
a operator++(int) { return *this; }
a operator--(int) { return *this; }
a operator++() { return *this; }
a operator--() { return *this; }
a operator[](a) { return *this; }
a operator()(a) { return *this; }
a operator<<=(a) { return *this; }
a operator-() { return *this; }
a operator+() { return *this; }
a operator*() { return *this; }
a operator&() { return *this; }
a operator!() { return *this; }
a operator~() { return *this; }
};
typedef a x;
a b,c,d,y;

void foo() {
b(c[d++--])<<=--++-+*&!~(::x)y
// 1234567890123456789012
// 1111111111122
}

...immerhin 22, macht genau garnix ('gcc -O' macht ein 'ret' daraus) und
das sind wirklich nur Operatoren ("::" würde ich persönlich ja als
Streitfall ansehen, steht aber in den meisten Listen von Operatoren drin).


Stefan