Path: csiph.com!usenet.pasdenom.info!news.etla.org!news.stack.nl!newsfeed.xs4all.nl!newsfeed4.news.xs4all.nl!xs4all!post.news.xs4all.nl!not-for-mail
MIME-Version: 1.0
In-Reply-To: <51d06cb6$0$29999$c3e8da3$5496439d@news.astraweb.com>
References: <mailman.4021.1372572404.3114.python-list@python.org> <51d06cb6$0$29999$c3e8da3$5496439d@news.astraweb.com>
From: Joshua Landau <joshua.landau.ws@gmail.com>
Date: Sun, 30 Jun 2013 22:52:17 +0100
Subject: Re: Stupid ways to spell simple code
To: "Steven D'Aprano" <steve+comp.lang.python@pearwood.info>
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Cc: python-list <python-list@python.org>
Precedence: list
Newsgroups: comp.lang.python
Message-ID: <mailman.4044.1372629187.3114.python-list@python.org>
Lines: 51
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: csiph.com comp.lang.python:49516

On 30 June 2013 18:36, Steven D'Aprano
<steve+comp.lang.python@pearwood.info> wrote:
> Pfft! Where's the challenge in that? Let's use an O(n!) algorithm for
> sorting -- yes, n factorial -- AND abuse a generator expression for its
> side effect. As a bonus, we use itertools, and just for the lulz, I
> obfuscate as many of the names as I can:
>
>
> from random import shuffle as OOO00O
> from itertools import takewhile as OO0O0O, count as O0OO0O
>
> OO0O00 =3D range(5)
>
> list(OO0O0O(lambda O: any(O[O0] < O[O0-1] for O0 in
>     range(1, sum(('O' for O in O), type('O', (),
>     {'__add__': lambda O0O, OO0: OO0})()).count('O'))),
>     (OOO00O(OO0O00) or OO0O00 for O in O0OO0O())))[0]

I've got to say -- that last line got me for quite a while, especially
as the list of lists was returning a list of sorted lists!

For obfuscation, though, you want unicode. It's much harder to reason
about code that you can't read.

from itertools import count as =C3=A6, permutations as =C3=86, starmap as =
=C3=B0
[globals().setdefault("%c"%sum(=C3=B8.encode()),=C3=9F)for =C3=B8,=C3=9F in
vars(__builtins__).items()if =C3=B8!=3D"vars"]
sorted =3D lambda =C4=A7:=C6=BF(=C6=9E for =C4=B1 in
=CF=86(=C6=B4(lambda:=C4=A7,=C3=A6),=C5=84(0,=C5=84(=C4=A7)**(len(=C4=A7)*2=
-1)*len(=C4=A7)))for =C6=9E in =C3=86(=C4=A7)if
=C7=82(()).__eq__((=C5=95(=C3=B0(=C7=82(=C6=BC(=C6=9E).pop()).__rpow__,=CF=
=86(=C5=95(=C5=93(=C6=9E,=C6=B4(lambda:0,=C4=A7)),()),1))),=C4=A7),=C4=B1))=
[::-1]

print(sorted([4, -3, 4, 2, -1]))

This only works for integers (including negatives) and some things
that seem to do nothing but slow it down are needed to cover special
cases. This one takes about 3=C2=BD minutes on my computer -- it's got a
runtime efficiency of something along the lines of O( (L!) * ((L)**i)
)  for i being related to the elements in the list and L being the
length of the list.

That said, it's rather OK at sorting [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0=
].


I know this is more oriented towards obfuscation of code than
obfuscation of technique, but --as I said-- I'm writing a library for
that. I'll be back when it's ready.