Table

of Contents
Introduction

1.1

Level 0

1.2

Level 1

1.3

Level 2

1.4

Level 3

1.5

Level 4

1.6

Level 5

1.7

Level 6

1.8

Level 7

1.9

Level 8

1.10

Level 9

1.11

Level 10

1.12

Level 11

1.13

Level 12

1.14

Level 13

1.15

Level 14

1.16

Level 15

1.17

Level 16

1.18

Level 17

1.19

Level 18

1.20

Level 19

1.21

Level 20

1.22

Level 21

1.23

Level 22

1.24

Level 23

1.25

Level 24

1.26

Level 25

1.27

Level 26

1.28

Level 27

1.29

Level 28

1.30

Level 29

1.31

Level 30

1.32

Level 31

1.33

Level 32

1.34

Level 33

1.35

Appendix: Links

1.36

Introduction

The Python Challenge Solutions

Spoiler Alert!
If you haven't heard "The Python Challenge", try it out now! I can wait.
Before you flip to the next page, be careful that this eBook contains solutions to
ALL the challenges, which may spoil your journey. If you do not care about
winning or losing, if you have no intention to brag about your "achievements" by
cheating with these solutions, but simply want to learn Python in a fun and
addictive way, feel free to move forward.
By the way, do me a favor, let's use Python 3! It is time to move on!

Learning Python
This eBook provides "just enough" knowledge for solving each challenge. To learn
more about Python, try these resources:
The Official Documentation: not always friendly for beginners, but it should be
treated as the single source of truth.
Books: books can be slightly outdated, however they may provide better entry
level tutorials, or dig deeper in a specific topic
Basics: Learning Python
More Advanced: Effective Python
Machine Learning: Python Machine Learning
Data Analysis: Python for Data Analysis
Data Visualization: Data Visualization with Python and JavaScript
Hacking: Black Hat Python
Web Scraping: Web Scraping with Python
HackingNote: last but not least, a shameless plug-in. I'm still learning Python,
and I'm taking notes and shaping my knowledge base along the way. Hope it
could help you as well.

Introduction

One More Word...

I'm not a Python expert. I'm not an editor, not even a native English speaker.
Please bear with me if I make any grammar or technical mistakes. Feel free to
leave comments at the bottom of each page(if you are reading from the website).

Level 0

Python Challenge - Level 0

Link: [Link]

Problem

Hint: try to change the URL address.

Explore
As the "0" indicates, this is just a warm up.

Loop
The naive way to solve it: multiply by 2 in a loop:

Level 0

>>> k = 1
>>> for i in range(38):
... k *= 2
...
>>> k
274877906944

Power
Use ** for power:
>>> 2**38
274877906944

In REPL the result will be printed; or you can explicitly print the result by calling
print()

>>> print(2**38)
274877906944

Instead of ** , you can also use pow()

>>> pow(2,38)
274877906944

or
>>> print(pow(2,38))
274877906944

Shift
Multiply by 2 is equivalent to shifting the binary representation left by one:

Level 0

>>> 1<<38
274877906944

Numeric Types
Done!
Wait, why 38? what is implied?
If you are coming from C/C++, Java or other languages, you know that there are
multiple types just for integers: short , integer , long , and even
BigInteger beyond 64-bit. However that is not the case in Python:

>>> type(2**3)
<class 'int'>
>>> type(2**38)
<class 'int'>
>>> type(2**380)
<class 'int'>

So 38 is a good(and random) example to show a int larger than 32-bit.

Similar for float type, in Python it can be arbitrarily large, no double needed
>>> type(2**3.8)
<class 'float'>
>>> type(2.0**38)
<class 'float'>

Complete Solution
print(2**38)

Output:

Level 0

274877906944

Next Level
[Link]
And it will jump to
[Link]

Read More
Python 3 - REPL

Level 1

Python Challenge - Level 1

Link: [Link]

Problem

The image lists 3 pairs:

K->M
O->Q
E->G
everybody thinks twice before solving this.
g fmnc wms bgblr rpylqjyrc gr zw fylb. rfyrq ufyr amknsrcpq ypc dmp. bmgle gr
gl zw fylb gq glcddgagclr ylb rfyr'q ufw rfgq rcvr gq qm jmle. sqgle
[Link]() gq pcamkkclbcb. lmu ynnjw ml rfc spj.

Level 1

Hints
The text must be encoded.
Hint from url: map. And notice that there's exactly one character between the
given pairs: K->L->M , O->P->Q , E->F->G , and look at the very first letter in
the text g , if this is English, a good guess is that g is actually i . What is the
distance from g to i ? Yes, G->H->I . So let's shift each character to the
right, by 2, and y back to a , z back to b .
The string is not so long, so let's just copy and past it to REPL:
>>> raw = "g fmnc wms bgblr rpylqjyrc gr zw fylb. rfyrq ufyr amk
nsrcpq ypc dmp. bmgle grgl zw fylb gq glcddgagclr ylb rfyr'q ufw
rfgq rcvr gq qm jmle. sqgle [Link]() gq pcamkkclbcb.
lmu ynnjw ml rfc spj."

Solution 1
The pair of functions that would help up make the change:
ord() : character to integer
chr() : integer to character

e.g.
>>> chr(65)
'A'
>>> ord('A')
65

To shift a character:

10

Level 1

>>> ord('k')
107
>>> ord('k') + 2
109
>>> chr(ord('k') + 2)
'm'

but it is not working for 'z':

>>> chr(ord('z') + 2)
'|'

To make it circular, calculate it's distance from 'a'

>>> (ord('z') + 2) - ord('a')
27

if it is larger than 26, go back to the beginning

>>> ((ord('z') + 2) - ord('a')) % 26
1

then add that difference to 'a'

>>> chr(((ord('z') + 2) - ord('a')) % 26 + ord('a'))
'b'

Let's translate the whole string:

11

Level 1

>>> result = ""

>>> for c in raw:
... if c >= 'a' and c <= 'z':
... result += chr(((ord(c) + 2) - ord('a')) % 26 + ord('
a'))
... else:
... result += c
...
>>> result
"i hope you didnt translate it by hand. thats what computers are
for. doing itin by hand is inefficient and that's why this text
is so long. using [Link]() is recommended. now apply
on the url."

That is how we make a loop in Java or C, but python has a better way: list
comprehension
>>> ''.join([chr(((ord(s) + 2) - ord('a')) % 26 + ord('a')) if s
>= 'a' and s <= 'z' else s for s in raw])
"i hope you didnt translate it by hand. thats what computers are
for. doing itin by hand is inefficient and that's why this text
is so long. using [Link]() is recommended. now apply
on the url."

But since it suggest us use .maketrans() , let's try it next.

Put Everything Together

raw = "g fmnc wms bgblr rpylqjyrc gr zw fylb. rfyrq ufyr amknsrc
pq ypc dmp. bmgle grgl zw fylb gq glcddgagclr ylb rfyr'q ufw rfg
q rcvr gq qm jmle. sqgle [Link]() gq pcamkkclbcb. lmu
ynnjw ml rfc spj."
print(''.join([chr(((ord(s) + 2) - ord('a')) % 26 + ord('a')) if
s >= 'a' and s <= 'z' else s for s in raw]))

12

Level 1

Solution 2: .maketrans()
In Python 3, .maketrans is not in string as indicated; instead call
[Link]() or [Link]()

>>> table = [Link]("abcdefghijklmnopqrstuvwxyz", "cdefghi

jklmnopqrstuvwxyzab")
>>> [Link](table)
"i hope you didnt translate it by hand. thats what computers are
for. doing itin by hand is inefficient and that's why this text
is so long. using [Link]() is recommended. now apply
on the url."

Put Everything Together

raw = "g fmnc wms bgblr rpylqjyrc gr zw fylb. rfyrq ufyr amknsrc
pq ypc dmp. bmgle grgl zw fylb gq glcddgagclr ylb rfyr'q ufw rfg
q rcvr gq qm jmle. sqgle [Link]() gq pcamkkclbcb. lmu
ynnjw ml rfc spj."
table = [Link](
"abcdefghijklmnopqrstuvwxyz", "cdefghijklmnopqrstuvwxyzab"
)
result = [Link](table)
print(result)

Solution 3
Let's have our own version of maketrans. The inputs are two lists, then each
character is mapped from one list to another.
Define the two lists

13

Level 1

>>> a = "abcdefghijklmnopqrstuvwxyz,. '()"

>>> b = "cdefghijklmnopqrstuvwxyzab,. '()"

zip them
>>> list(zip(a, b))
[('a', 'c'), ('b', 'd'), ('c', 'e'), ('d', 'f'), ('e', 'g'), ('f'
, 'h'), ('g', 'i'), ('h', 'j'), ('i', 'k'), ('j', 'l'), ('k', 'm'
), ('l', 'n'), ('m', 'o'), ('n', 'p'), ('o', 'q'), ('p', 'r'), (
'q', 's'), ('r', 't'), ('s', 'u'), ('t', 'v'), ('u', 'w'), ('v',
'x'), ('w', 'y'), ('x', 'z'), ('y', 'a'), ('z', 'b'), (',', ',')
, ('.', '.'), (' ', ' '), ("'", "'"), ('(', '('), (')', ')')]

actually we can create a dict

>>> dict(zip(a, b))
{'t': 'v', 'g': 'i', 'b': 'd', 'i': 'k', ',': ',', 'v': 'x', 'u'
: 'w', 'd': 'f', 'e': 'g', 'h': 'j', 'm': 'o', "'": "'", '(': '('
, '.': '.', 'q': 's', 'l': 'n', 'a': 'c', 'x': 'z', ' ': ' ', 'f'
: 'h', 'o': 'q', 'w': 'y', 'n': 'p', 'c': 'e', 'p': 'r', 's': 'u'
, 'z': 'b', 'j': 'l', 'y': 'a', 'r': 't', 'k': 'm', ')': ')'}

then mapping is as easy as

>>> dict(zip(a, b))['z']
'b'

translate the whole string:

>>> "".join([dict(zip(a,b))[x] for x in raw])
"i hope you didnt translate it by hand. thats what computers are
for. doing itin by hand is inefficient and that's why this text
is so long. using [Link]() is recommended. now apply
on the url."

14

Level 1

Put Everything Together

raw = "g fmnc wms bgblr rpylqjyrc gr zw fylb. rfyrq ufyr amknsrc
pq ypc dmp. bmgle grgl zw fylb gq glcddgagclr ylb rfyr'q ufw rfg
q rcvr gq qm jmle. sqgle [Link]() gq pcamkkclbcb. lmu
ynnjw ml rfc spj."
a = "abcdefghijklmnopqrstuvwxyz,. '()"
b = "cdefghijklmnopqrstuvwxyzab,. '()"
print("".join([dict(zip(a,b))[x] for x in raw]))

Next Level
As hinted, apply the same function on the url( map ), we get ocr .
>>> "map".translate([Link]("abcdefghijklmnopqrstuvwxyz",
"cdefghijklmnopqrstuvwxyzab"))
'ocr'

[Link]

Python 2 to Python 3
In Python 2, maketrans() is a method in string module, so you need to
import it first:
import string
table = [Link]("from", "to")

In Python 3, maketrans() is part of either bytes or str :

[Link](from, to)
[Link](from, to)

15

Level 1

16

Level 2

Python Challenge - Level 2

Link: [Link]

Problem

recognize the characters. maybe they are in the book, but MAYBE they are in
the page source.
Right click and select "View Page Source":

17

Level 2

<!-find rare characters in the mess below:

-->
<!-%%$@_$^__#)^)&!_+]!*@&^}@[@%]()%+$&[(_@%+%$*^@$^!+]!&_#)_*}{}}!}
_]$[%}@[{_@#_^{*
@##&{#&{&)*%(]{{([*}@[@&]+!!*{)!}{%+{))])[!^})+)$]#{*+^((@^@}$[*
*$&^{$!@#$%)!@(&
+^!{%_$&@^!}$_${)$_#)!({@!)(^}!*^&!$%_&&}&_#&@{)]{+)%*{&*%*&@%$+
]!*__(#!*){%&@++
!_)^$&&%#+)}!@!)&^}**#!_$([$!$}#*^}$+&#[{*{}{((#$]{[$[$$()_#}!@}
^@_&%^*!){*^^_$^
]@}#%[%!^[^_})+@&}{@*!(@$%$^)}[_!}(*}#}#___}!](@_{{(*#%!%%+*)^+#
%}$+_]#}%!**#!^_
...

Solution
Load Data
You can manually copy-and-paste the text to a file( resources/[Link] in
source code), then read from it:
>>> data = open('resources/[Link]').read()

Read More
More about Python 3 - IO

Or extract the text from HTML directly. First load raw html source coding using
[Link] :

18

Level 2

>>> import [Link]

>>> html = [Link]("[Link]
m/pc/def/[Link]").read().decode()

Then extract the comment blocks in html. Note that by default dot does not match
\n , so we need to use re .DOTALL flag.

>>> import re
>>> comments = [Link]("<!--(.*?)-->", html, [Link])

Alternatively we can use this:

>>> comments = [Link]("<!--([\w\n]*?)-->", html)

The pattern <!--(.*)--> will capture all blocks inside <!-- and --> . We
only care about the last part, so
>>> data = comments[-1]

Find the Rare Characters

>>> count = {}
>>> for c in data:
... count[c] = [Link](c, 0) + 1
...
>>> count
{'*': 6034, '$': 6046, 'i': 1, '!': 6079, '[': 6108, 'u': 1, 'e'
: 1, '@': 6157, '#': 6115, 't': 1, '(': 6154, '+': 6066, '&': 60
43, 'q': 1, 'l': 1, '%': 6104, '{': 6046, '}': 6105, 'a': 1, '^'
: 6030, ']': 6152, '\n': 1221, 'y': 1, '_': 6112, ')': 6186}

The rare characters only have 1 occurrence: t, i, u, e, l, y, q, a.

In the right order

19

Level 2
If you are having a hard time to guess the meaning:
>>> import re
>>> "".join([Link]("[A-Za-z]", data))
'equality'

Put Everything Together

import [Link]
import re
html = [Link]("[Link]
/def/[Link]").read().decode()
data = [Link]("<!--(.*?)-->", html, [Link])[-1]
print("".join([Link]("[A-Za-z]", data)))

result:
equality

Next Level
[Link]

20

Level 3

Python Challenge - Level 3

Link: [Link]

Problem

One small letter, surrounded by EXACTLY three big bodyguards on each of

its sides.
The image shows 3 big candles on each side of a small one. The description hints
us to find letters! So open the page source, we see a comment block at the
bottom of the page:
<!-kAewtloYgcFQaJNhHVGxXDiQmzjfcpYbzxlWrVcqsmUbCunkfxZWDZjUZMiGq
...

21

Level 3
Hmm, shall we find all segments of the pattern AAAbCCC ?

Solution
Step 1: Load Data
Similar to level 2, You can manually copy-and-paste the text to a
file( resources/[Link] in source code), then read from it:
>>> data = open('resources/[Link]').read()

Or extract the text from HTML directly.

>>> import [Link]
>>> import re
>>> html = [Link]("[Link]
m/pc/def/[Link]").read().decode()
>>> data = [Link]("<!--(.*?)-->", html, [Link])[-1]

Step 2: Find the Matches

Now we have the content as a big long string, we can use regular expression to
find all the matches. The pattern can be described as [^A-Z]+[A-Z]{3}([a-z])
[A-Z]{3}[^A-Z]+ . Here's a break down of the pattern:
[a-z] : 1 lower case letter
[A-Z] : 1 upper case letter
[A-Z]{3} : 3 consecutive upper case letters
[A-Z]{3}[a-z][A-Z]{3} : 3 upper case letters + 1 lower case letter + 3

upper case letters

[^A-Z] : any character BUT an upper case letter
[^A-Z]+ : at least one such character
[^A-Z]+[A-Z]{3}[a-z][A-Z]{3}[^A-Z]+ : something else before and after

our patter( AAAbCCC ) so there's no more than 3 consecutive upper case

letters on each side

22

Level 3
[^A-Z]+[A-Z]{3}([a-z])[A-Z]{3}[^A-Z]+ : ...and we only care about the

lower case
Let's see what we get:
>>> [Link]("[^A-Z]+[A-Z]{3}([a-z])[A-Z]{3}[^A-Z]+", data)
['l', 'i', 'n', 'k', 'e', 'd', 'l', 'i', 's', 't']

And join them together

>>> "".join([Link]("[^A-Z]+[A-Z]{3}([a-z])[A-Z]{3}[^A-Z]+",
data))
'linkedlist'

That's it! linkedlist.

Put Everything Together

import [Link]
import re
html = [Link]("[Link]
/def/[Link]").read().decode()
data = [Link]("<!--(.*)-->", html, [Link])[-1]
print("".join([Link]("[^A-Z]+[A-Z]{3}([a-z])[A-Z]{3}[^A-Z]+"
, data)))

Next Level
[Link]
The page will redirect you to [Link]
[Link]

Further Readings
23

Level 3
Python 3 - RegEx

24

Level 4

Python Challenge - Level 4

Link: [Link]

Problem

Click on the image, you would see

and the next nothing is 44827
And the url changed to
[Link]

Change the url with the new number and another number will be given.

Solution
25

Level 4
First let's try to mimic the manual process we just tried:
>>> uri = "[Link]
nothing=%s"
>>> num = "12345"
>>> content = urlopen(uri % num).read().decode()
>>> content
'and the next nothing is 44827'

Then use regular expression to extract the number:

>>> match = [Link]("and the next nothing is (\d+)", content)
>>> match
<_sre.SRE_Match object; span=(0, 29), match='and the next nothin
g is 44827'>

Note .group(0) will return the whole text that matches the pattern, while the
captured segments start from .group (1)
>>> [Link](0)
'and the next nothing is 44827'
>>> [Link](1)
'72198'

To automate this process, let's use a while loop, which stops when there's no
match:

26

Level 4

>>> pattern = [Link]("and the next nothing is (\d+)")

>>> while True:
... content = urlopen(uri % num).read().decode('utf-8')
... print(content)
... match = [Link](content)
... if match == None:
... break
... num = [Link](1)
...
and the next nothing is 44827
and the next nothing is 45439
<font color=red>Your hands are getting tired </font>and the next
nothing is 94485
and the next nothing is 72198
...
and the next nothing is 16044
Yes. Divide by two and keep going.

Then reset num to 16044/2

num = str(16044/2)

And re-run:
and the next nothing is 81226
and the next nothing is 4256
and the next nothing is 62734
and the next nothing is 25666
...
There maybe misleading numbers in the
text. One example is 82683. Look only for the next nothing and t
he next nothing is 63579
...
[Link]

27

Level 4
Note that if you use [Link]() instead of [Link]() it would
fail, since .match() is looking for a match starting from the very beginning,
while there's one "misleading" line in the text.
Finally we have the answer: [Link]

Put Everything Together

from [Link] import urlopen
import re
uri = "[Link]
ing=%s"
num = "12345"
#num = str(16044/2)
pattern = [Link]("and the next nothing is (\d+)")
while True:
content = urlopen(uri % num).read().decode('utf-8')
print(content)
match = [Link](content)
if match == None:
break
num = [Link](1)

Result
[Link]

Next Level
[Link]

Python 2 to Python 3
28

Level 4
Python 2's urllib and urllib2 are combined as the new urllib

29

Level 5

Python Challenge - Level 5

Link: [Link]

Problem

pronounce it
Page Source:
<peakhell src="banner.p"/>
<!-- peak hell sounds familiar ? -->

peakhell, peakhell... sounds like... "pickle"(which is Python's object serialization

module)

30

Level 5

Solution
Let's print out the raw data:
>>> from [Link] import urlopen
>>> raw = urlopen("[Link]
p").read()
>>> raw
b"(lp0\n(lp1\n(S' '\np2\nI95\ntp3\naa..."

Normally plain text can be encoded as utf-8 or some other form, once we call
.decode() it will reveal it self, however this one is tough:

>>> [Link]()
"(lp0\n(lp1\n(S' '\np2\nI95\ntp3\naa..."

As hinted, let's use pickle to deserialize it:

>>> import pickle
>>> data = [Link](urlopen("[Link]
c/def/banner.p"))
>>> data
[[(' ', 95)], [(' ', 14), ('#', 5), (' ', 70), ('#', 5), (' ', 1
)], [(' ', 15), ('#', 4), (' ', 71), ('#', 4), (' ', 1)], [(' ',
15), ('#', 4), (' ', 71), ('#', 4), (' ', 1)], [(' ', 15), ('#',
4), (' ', 71), ('#', 4), (' ', 1)], [(' ', 15), ('#', 4), (' ',
71), ('#', 4), (' ', 1)], [(' ', 15), ('#', 4), (' ', 71), ('#',
4), (' ', 1)], [(' ', 15), ('#', 4), (' ', 71), ('#', 4), (' ', 1
)], [(' ', 15), ('#', 4), (' ', 71), ('#', 4), (' ', 1)], [(' ',
6), ('#', 3), (' ', 6), ('#', 4), (' ', 3), ('#', 3), (' ', 9), (
'#', 3), (' ', 7), ('#', 5), (' ', 3), ('#', 3), (' ', 4), ('#',
5), (' ', 3), ('#', 3), (' ', 10), ('#', 3), (' ', 7), ('#', 4),
(' ', 1)], [(' ', 3), ('#', 3), (' ', 3), ('#', 2), (' ', 4), (
'#', 4), (' ', 1), ('#', 7), (' ', 5), ('#', 2), (' ', 2), ('#',
3), (' ', 6), ('#', 4), (' ', 1), ('#', 7), (' ', 3), ('#', 4), (
' ', 1), ('#', 7), (' ', 5), ('#', 3), (' ', 2), ('#', 3), (' ',
5), ('#', 4), (' ', 1)], [(' ', 2), ('#', 3), (' ', 5), ('#', 3)
, (' ', 2), ('#', 5), (' ', 4), ('#', 4), (' ', 3), ('#', 3), ('

31

Level 5
', 3), ('#', 4), (' ', 4), ('#', 5), (' ', 4), ('#', 4), (' ', 2
), ('#', 5), (' ', 4), ('#', 4), (' ', 3), ('#', 3), (' ', 5), (
'#', 3), (' ', 3), ('#', 4), (' ', 1)], [(' ', 1), ('#', 3), (' '
, 11), ('#', 4), (' ', 5), ('#', 4), (' ', 3), ('#', 3), (' ', 4
), ('#', 3), (' ', 4), ('#', 4), (' ', 5), ('#', 4), (' ', 2), (
'#', 4), (' ', 5), ('#', 4), (' ', 2), ('#', 3), (' ', 6), ('#',
4), (' ', 2), ('#', 4), (' ', 1)], [(' ', 1), ('#', 3), (' ', 11
), ('#', 4), (' ', 5), ('#', 4), (' ', 10), ('#', 3), (' ', 4), (
'#', 4), (' ', 5), ('#', 4), (' ', 2), ('#', 4), (' ', 5), ('#',
4), (' ', 2), ('#', 3), (' ', 7), ('#', 3), (' ', 2), ('#', 4), (
' ', 1)], [('#', 4), (' ', 11), ('#', 4), (' ', 5), ('#', 4), ('
', 5), ('#', 2), (' ', 3), ('#', 3), (' ', 4), ('#', 4), (' ', 5
), ('#', 4), (' ', 2), ('#', 4), (' ', 5), ('#', 4), (' ', 1), (
'#', 4), (' ', 7), ('#', 3), (' ', 2), ('#', 4), (' ', 1)], [('#'
, 4), (' ', 11), ('#', 4), (' ', 5), ('#', 4), (' ', 3), ('#', 10
), (' ', 4), ('#', 4), (' ', 5), ('#', 4), (' ', 2), ('#', 4), (
' ', 5), ('#', 4), (' ', 1), ('#', 14), (' ', 2), ('#', 4), (' '
, 1)], [('#', 4), (' ', 11), ('#', 4), (' ', 5), ('#', 4), (' ',
2), ('#', 3), (' ', 4), ('#', 4), (' ', 4), ('#', 4), (' ', 5), (
'#', 4), (' ', 2), ('#', 4), (' ', 5), ('#', 4), (' ', 1), ('#',
4), (' ', 12), ('#', 4), (' ', 1)], [('#', 4), (' ', 11), ('#', 4
), (' ', 5), ('#', 4), (' ', 1), ('#', 4), (' ', 5), ('#', 3), (
' ', 4), ('#', 4), (' ', 5), ('#', 4), (' ', 2), ('#', 4), (' ',
5), ('#', 4), (' ', 1), ('#', 4), (' ', 12), ('#', 4), (' ', 1)]
, [(' ', 1), ('#', 3), (' ', 11), ('#', 4), (' ', 5), ('#', 4), (
' ', 1), ('#', 4), (' ', 5), ('#', 3), (' ', 4), ('#', 4), (' ',
5), ('#', 4), (' ', 2), ('#', 4), (' ', 5), ('#', 4), (' ', 2), (
'#', 3), (' ', 12), ('#', 4), (' ', 1)], [(' ', 2), ('#', 3), ('
', 6), ('#', 2), (' ', 2), ('#', 4), (' ', 5), ('#', 4), (' ', 2
), ('#', 3), (' ', 4), ('#', 4), (' ', 4), ('#', 4), (' ', 5), (
'#', 4), (' ', 2), ('#', 4), (' ', 5), ('#', 4), (' ', 3), ('#',
3), (' ', 6), ('#', 2), (' ', 3), ('#', 4), (' ', 1)], [(' ', 3)
, ('#', 3), (' ', 4), ('#', 2), (' ', 3), ('#', 4), (' ', 5), ('
#', 4), (' ', 3), ('#', 11), (' ', 3), ('#', 4), (' ', 5), ('#',
4), (' ', 2), ('#', 4), (' ', 5), ('#', 4), (' ', 4), ('#', 3), (
' ', 4), ('#', 2), (' ', 4), ('#', 4), (' ', 1)], [(' ', 6), ('#'
, 3), (' ', 5), ('#', 6), (' ', 4), ('#', 5), (' ', 4), ('#', 2)
, (' ', 4), ('#', 4), (' ', 1), ('#', 6), (' ', 4), ('#', 11), (
' ', 4), ('#', 5), (' ', 6), ('#', 3), (' ', 6), ('#', 6)], [(' '
, 95)]]

32

Level 5

OK! So data is a list of lists of tuples... It does not look like a banner(the file
name), but more like the result of a simple string compression: convert the
repetitive characters to tuples of (character, number of appearance). This level is
all about serialization and compression, isn't it. Let's unravel the string:
>>> for line in data:
... print("".join([k * v for k, v in line]))
...
#####
#####
####
####
####
####
####
####
####
####
####
####
####
####
####
####
### #### ### ### ##### ### #####
### ### ####
### ## #### ####### ## ### #### ####### ####
####### ### ### ####
### ### ##### #### ### #### ##### #### ####
# #### ### ### ####
### #### #### ### ### #### #### ####
#### ### #### ####
### #### #### ### #### #### ####
#### ### ### ####
#### #### #### ## ### #### #### ####
#### #### ### ####
#### #### #### ########## #### #### ####

33

Level 5
#### ############## ####
#### #### #### ### #### #### #### ####
#### #### ####
#### #### #### #### ### #### #### ####
#### #### ####
### #### #### #### ### #### #### ####
#### ### ####
### ## #### #### ### #### #### #### ####
#### ### ## ####
### ## #### #### ########### #### #### ####
#### ### ## ####
### ###### ##### ## #### ###### ##########
# ##### ### ######
`

You got it:

channel

Put Everything Together

from [Link] import urlopen
import pickle
h = urlopen("[Link]
data = [Link](h)
for line in data:
print("".join([k * v for k, v in line]))

Next Level
[Link]

34

Level 6

Python Challenge - Level 6

Link: [Link]

Problem

Pants? And Spiderman's underwear?

There's no text or any useful info in the source comments except for a call out of
the donation button, but the big hint is at the very first line of html(and I missed
it...):
<html> <!-- <-- zip -->

Ok... the image was about "zip", not "pants" or anything under it...
Replace html with zip : [Link]

35

Level 6
Unzip it. In [Link]:
welcome to my zipped list.
hint1: start from 90052
hint2: answer is inside the zip

Solution
>>> import zipfile, re
>>>
>>> f = [Link]("resources/[Link]")
>>> num = '90052'
>>> while True:
... content = [Link](num + ".txt").decode("utf-8")
... print(content)
... match = [Link]("Next nothing is (\d+)", content)

... if match == None:
... break
... num = [Link](1)
...
Next nothing is 94191
Next nothing is 85503
Next nothing is 70877
...
Next nothing is 68628
Next nothing is 67824
Next nothing is 46145
Collect the comments.

Comments.. what comments?

It turns out that zip file may contain some comments, and they can be accessed
by:
[Link]: comment associated with the ZIP file.
[Link]: comment for the individual archive member.
36

Level 6
Add a few lines to collect the comments:
>>> num = '90052'
>>> comments = []
>>> while True:
... content = [Link](num + ".txt").decode("utf-8")
... [Link]([Link](num + ".txt").[Link]("
utf-8"))
... content
... match = [Link]("Next nothing is (\d+)", content)

... if match == None:
... break
... num = [Link](1)
...
>>> print("".join(comments))
****************************************************************
****************************************************************
** **
** OO OO XX YYYY GG GG EEEEEE NN NN **
** OO OO XXXXXX YYYYYY GG GG EEEEEE NN NN **
** OO OO XXX XXX YYY YY GG GG EE NN NN **
** OOOOOOOO XX XX YY GGG EEEEE NNNN **
** OOOOOOOO XX XX YY GGG EEEEE NN **
** OO OO XXX XXX YYY YY GG GG EE NN **
** OO OO XXXXXX YYYYYY GG GG EEEEEE NN **
** OO OO XX YYYY GG GG EEEEEE NN **
** **
****************************************************************
**************************************************************

If you try [Link] you will get

it's in the air. look at the letters.

The right answer is in the letters: oxygen

Put Everything Together

37

Level 6

import zipfile, re
f = [Link]("[Link]")
print([Link]("[Link]").decode("utf-8"))
num = '90052'
comments = []
while True:
content = [Link](num + ".txt").decode("utf-8")
[Link]([Link](num + ".txt").[Link]("utf8"))
print(content)
match = [Link]("Next nothing is (\d+)", content)
if match == None:
break
num = [Link](1)
print("".join(comments))

Next Level
[Link]

38

Level 7

Python Challenge - Level 7

Link: [Link]

Problem

Nothing else... the gray scale should contain the information.

We need an image processing library.

Solution 1: PIL(Pillow)

Python 2 to 3
The original PIL was not ported to Python 3. Use the fork called ``Pillow``
instead

Install Pillow
$ pip3 install pillow

Make sure you can load the module:

>>> from PIL import Image

To load an image, one way is to download the image to local manually, then load it
by:

39

Level 7

>>> img = [Link]("[Link]")

Or load it from url directly:

>>> import requests
>>> from io import BytesIO
>>> from PIL import Image
>>> img = [Link](BytesIO([Link]('[Link]
[Link]/pc/def/[Link]').content))

We can get some basic info about the image:

>>> [Link]
629
>>> [Link]
95

And get the pixel by providing indices:

>>> [Link]((0,0))
(79, 92, 23, 255)

The result is the tuple of (R, G, B, alpha).

To get the grey scale, we can take the middle row of the pixels:
>>> row = [[Link]((x, [Link] / 2)) for x in range(img.
width)]
>>> row
[(115, 115, 115, 255), (115, 115, 115, 255), (115, 115, 115, 255
), ...

As you can tell, row has lots of duplicates, since each grey block's width is larger
than 1 pixel. If you do some manual counting, you know it is exactly 7 pixels wide,
this should be the easiest way to de-dup:

40

Level 7

>>> row = row[::7]

>>> row
[(115, 115, 115, 255), (109, 109, 109, 255), (97, 97, 97, 255),
...

Notice that at the end of the array there are some noises: pixels that are not grey
scale, which have the same value for R, G, and B. We can remove those pixels
>>> ords = [r for r, g, b, a in row if r == g == b]

and since RGB is using a positive number in [0, 255] for each color, we can
assume it represents a ASCII character:
>>> "".join(map(chr, ords))
'smart guy, you made it. the next level is [105, 110, 116, 101,
103, 114, 105, 116, 121]'

We were right, but it is not over... Do it again on the numbers:

>>> nums = [Link]("\d+", "".join(map(chr, ords)))
>>> nums
['105', '110', '116', '101', '103', '114', '105', '116', '121']

Finally:
>>> "".join(map(chr, map(int, nums)))
'integrity'

Solution 2: PyPNG
Alternatively use a package called PyPNG :
pip install pypng

41

Level 7

from [Link] import urlopen

import png, re
response = urlopen("[Link]
.png")
(w, h, rgba, dummy) = [Link](response).read()
it = list(rgba)
mid = int(h / 2)
l = len(it[mid])
res = [chr(it[mid][i]) for i in range(0, l, 4*7) if it[mid][i] =
= it[mid][i + 1] == it[mid][i + 2]]
print("".join(res))

The pixels are stored as [r, g, b, a, r, g, b, a...] , if the pixel is gray,

rgb should be equivalent. Another tricky part is the width of each block is
7px(correspond to the number of level?) so the step of the range is 4 * 7 .
Output
smart guy, you made it. the next level is [105, 110, 116, 101, 103, 114, 105,
116, 121]
Modify the last line:
print("".join(map(chr, map(int, [Link]("\d+", "".join(res)))
)))

So integers are extracted and mapped to characters

Final result:
integrity

Next Level
[Link]

42

Level 7

Read More
Pillow Documentation

43

Level 8

Python Challenge - Level 8

Link: [Link]

Problem

Where is the missing link?

The fly is clickable, but it asks for user name and password, and this line:
The site says: "inflate"
And in the page source:

44

Level 8

<!-un: 'BZh91AY&SYA\xaf\x82\r\x00\x00\x01\x01\x80\x02\xc0\x02\x00 \
x00!\x9ah3M\x07<]\xc9\x14\xe1BA\x06\xbe\x084'
pw: 'BZh91AY&SY\x94$|\x0e\x00\x00\x00\x81\x00\x03$ \x00!\x9ah3M\
x13<]\xc9\x14\xe1BBP\x91\xf08'
-->

The opposite of "inflate" is... "compress". Do not blame yourself if you do not know
which compression format it is. Here are some clues that it is "bzip2"...
.magic:16 = 'BZ' signature/magic number .version:8 = 'h' for Bzip2 ('H'uffman
coding), '0' for Bzip1 (deprecated) .hundred_k_blocksize:8 = '1'..'9' block-size
100 kB-900 kB (uncompressed)

Solution
Let's decompress it:
>>> import bz2
>>> [Link]('BZh91AY&SYA\xaf\x82\r\x00\x00\x01\x01\x80\x0
2\xc0\x02\x00 \x00!\x9ah3M\x07<]\xc9\x14\xe1BA\x06\xbe\x084')
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "/usr/lib/python3.5/[Link]", line 348, in decompress
res = [Link](data)
TypeError: a bytes-like object is required, not 'str'

That does not work... .decompress() expects some bytes , not string
>>> [Link](b'BZh91AY&SYA\xaf\x82\r\x00\x00\x01\x01\x80\x
02\xc0\x02\x00 \x00!\x9ah3M\x07<]\xc9\x14\xe1BA\x06\xbe\x084')
b'huge'
>>> [Link](b'BZh91AY&SY\x94$|\x0e\x00\x00\x00\x81\x00\x0
3$ \x00!\x9ah3M\x13<]\xc9\x14\xe1BBP\x91\xf08')
b'file'

45

Level 8

Put Everything Together

import bz2
un = b'BZh91AY&SYA\xaf\x82\r\x00\x00\x01\x01\x80\x02\xc0\x02\x00
\x00!\x9ah3M\x07<]\xc9\x14\xe1BA\x06\xbe\x084'
pw = b'BZh91AY&SY\x94$|\x0e\x00\x00\x00\x81\x00\x03$ \x00!\x9ah3
M\x13<]\xc9\x14\xe1BBP\x91\xf08'
print([Link](un))
print([Link](pw))

Next Level
Click the fly(or the link in page source): ../return/[Link] , and fill in
username( huge ) and password( file )
[Link]

46

Level 9

Python Challenge - Level 9

Link: [Link]
Username: huge
Password: file

Problem

In page source:

<!-first+second=?
first:
146,399,163,403,170,393,169,391,166,386,170,381,170,371,170,355,
169,346,167,335,170,329,170,320,170,

47

Level 9
310,171,301,173,290,178,289,182,287,188,286,190,286,192,291,194,
296,195,305,194,307,191,312,190,316,
190,321,192,331,193,338,196,341,197,346,199,352,198,360,197,366,
197,373,196,380,197,383,196,387,192,
389,191,392,190,396,189,400,194,401,201,402,208,403,213,402,216,
401,219,397,219,393,216,390,215,385,
215,379,213,373,213,365,212,360,210,353,210,347,212,338,213,329,
214,319,215,311,215,306,216,296,218,
290,221,283,225,282,233,284,238,287,243,290,250,291,255,294,261,
293,265,291,271,291,273,289,278,287,
279,285,281,280,284,278,284,276,287,277,289,283,291,286,294,291,
296,295,299,300,301,304,304,320,305,
327,306,332,307,341,306,349,303,354,301,364,301,371,297,375,292,
384,291,386,302,393,324,391,333,387,
328,375,329,367,329,353,330,341,331,328,336,319,338,310,341,304,
341,285,341,278,343,269,344,262,346,
259,346,251,349,259,349,264,349,273,349,280,349,288,349,295,349,
298,354,293,356,286,354,279,352,268,
352,257,351,249,350,234,351,211,352,197,354,185,353,171,351,154,
348,147,342,137,339,132,330,122,327,
120,314,116,304,117,293,118,284,118,281,122,275,128,265,129,257,
131,244,133,239,134,228,136,221,137,
214,138,209,135,201,132,192,130,184,131,175,129,170,131,159,134,
157,134,160,130,170,125,176,114,176,
102,173,103,172,108,171,111,163,115,156,116,149,117,142,116,136,
115,129,115,124,115,120,115,115,117,
113,120,109,122,102,122,100,121,95,121,89,115,87,110,82,109,84,1
18,89,123,93,129,100,130,108,132,110,
133,110,136,107,138,105,140,95,138,86,141,79,149,77,155,81,162,9
0,165,97,167,99,171,109,171,107,161,
111,156,113,170,115,185,118,208,117,223,121,239,128,251,133,259,
136,266,139,276,143,290,148,310,151,
332,155,348,156,353,153,366,149,379,147,394,146,399
second:
156,141,165,135,169,131,176,130,187,134,191,140,191,146,186,150,
179,155,175,157,168,157,163,157,159,
157,158,164,159,175,159,181,157,191,154,197,153,205,153,210,152,
212,147,215,146,218,143,220,132,220,
125,217,119,209,116,196,115,185,114,172,114,167,112,161,109,165,

48

Level 9
107,170,99,171,97,167,89,164,81,162,
77,155,81,148,87,140,96,138,105,141,110,136,111,126,113,129,118,
117,128,114,137,115,146,114,155,115,
158,121,157,128,156,134,157,136,156,136
-->

first and second have different lengths, so it is not simply adding up the two

arrays. The image has some dots, maybe we should just connect the dots...

Solution
Copy and paste...
>>> first = [
... 146,399,163,403,170,393,169,391,166,386,170,381,170,371,170,
355,169,346,167,335,170,329,170,320,170,
... 310,171,301,173,290,178,289,182,287,188,286,190,286,192,291,
194,296,195,305,194,307,191,312,190,316,
... 190,321,192,331,193,338,196,341,197,346,199,352,198,360,197,
366,197,373,196,380,197,383,196,387,192,
... 389,191,392,190,396,189,400,194,401,201,402,208,403,213,402,
216,401,219,397,219,393,216,390,215,385,
... 215,379,213,373,213,365,212,360,210,353,210,347,212,338,213,
329,214,319,215,311,215,306,216,296,218,
... 290,221,283,225,282,233,284,238,287,243,290,250,291,255,294,
261,293,265,291,271,291,273,289,278,287,
... 279,285,281,280,284,278,284,276,287,277,289,283,291,286,294,
291,296,295,299,300,301,304,304,320,305,
... 327,306,332,307,341,306,349,303,354,301,364,301,371,297,375,
292,384,291,386,302,393,324,391,333,387,
... 328,375,329,367,329,353,330,341,331,328,336,319,338,310,341,
304,341,285,341,278,343,269,344,262,346,
... 259,346,251,349,259,349,264,349,273,349,280,349,288,349,295,
349,298,354,293,356,286,354,279,352,268,
... 352,257,351,249,350,234,351,211,352,197,354,185,353,171,351,
154,348,147,342,137,339,132,330,122,327,
... 120,314,116,304,117,293,118,284,118,281,122,275,128,265,129,

49

Level 9
257,131,244,133,239,134,228,136,221,137,
... 214,138,209,135,201,132,192,130,184,131,175,129,170,131,159,
134,157,134,160,130,170,125,176,114,176,
... 102,173,103,172,108,171,111,163,115,156,116,149,117,142,116,
136,115,129,115,124,115,120,115,115,117,
... 113,120,109,122,102,122,100,121,95,121,89,115,87,110,82,109,
84,118,89,123,93,129,100,130,108,132,110,
... 133,110,136,107,138,105,140,95,138,86,141,79,149,77,155,81,1
62,90,165,97,167,99,171,109,171,107,161,
... 111,156,113,170,115,185,118,208,117,223,121,239,128,251,133,
259,136,266,139,276,143,290,148,310,151,
... 332,155,348,156,353,153,366,149,379,147,394,146,399]
>>> second = [156,141,165,135,169,131,176,130,187,134,191,140,191
,146,186,150,179,155,175,157,168,157,163,157,159,
... 157,158,164,159,175,159,181,157,191,154,197,153,205,153,210,
152,212,147,215,146,218,143,220,132,220,
... 125,217,119,209,116,196,115,185,114,172,114,167,112,161,109,
165,107,170,99,171,97,167,89,164,81,162,
... 77,155,81,148,87,140,96,138,105,141,110,136,111,126,113,129,
118,117,128,114,137,115,146,114,155,115,
... 158,121,157,128,156,134,157,136,156,136]

Use PIL(pillow)
>>> from PIL import Image,ImageDraw
>>> im = [Link]('RGB', (500,500))
>>> draw = [Link](im)
>>> [Link](first, fill='white')
>>> [Link](second, fill='white')
>>> [Link]()

50

Level 9

Is it a ... cow? We get this from [Link]

hmm. it's a male.
Bull? It works...

Next Level
[Link]

51

Level 10

Python Challenge - Level 10

Link: [Link]
Username: huge
Password: file

Problem

len(a[30]) = ?
By clicking the image:
a = [1, 11, 21, 1211, 111221,

A look-and-say sequence

52

Level 10

Solution 1
This is a naive solution, just look, and say, assemble the string while we are
counting.
a = '1'
b = ''
for i in range(0, 30):
j = 0
k = 0
while j < len(a):
while k < len(a) and a[k] == a[j]: k += 1
b += str(k-j) + a[j]
j = k
print b
a = b
b = ''
print len(a)

Solution 2
Python can do much better. We can use regular expression to find the (number,
length) pairs
>>> import re
>>> [Link](r"(\d)(\1*)", "111221")
[('1', '11'), ('2', '2'), ('1', '')]

Note that the pattern is a raw string( r"..." ), which means backslash( \ ) does
not need to be escaped. It is equivalent to
>>> [Link]("(\\d)(\\1*)", "111221")

The result tuples are in the form: (first appearance, following appearance), so from
the first one we get the number, and the second one we get the length(remember
to +1)

53

Level 10

>>> "".join([str(len(i+j))+i for i,j in [Link](r"(\d)(\1*)",

x)])
'11'
>>> "".join([str(len(i+j))+i for i,j in [Link](r"(\d)(\1*)",
"1")])
'11'
>>> "".join([str(len(i+j))+i for i,j in [Link](r"(\d)(\1*)",
"11")])
'21'
>>> "".join([str(len(i+j))+i for i,j in [Link](r"(\d)(\1*)",
"21")])
'1211'
>>> "".join([str(len(i+j))+i for i,j in [Link](r"(\d)(\1*)",
"1211")])
'111221'

Let it run 30 times:

>>> x = "1"
>>> for n in range(30):
... x="".join([str(len(j) + 1)+i for i, j in [Link](r"(\
d)(\1*)", x)])
...
>>> len(x)
5808

Solution 3
Similar to Solution 2, but we are using [Link]() instead of regular
expression to find the (number, length) pairs:
>>> "".join([str(len(list(j))) + i for i,j in [Link](
"1211")])
'111221'

The result of groupby is (number, all appearances)

54

Level 10

>>> [(i, list(j)) for i,j in [Link]("1211")]

[('1', ['1']), ('2', ['2']), ('1', ['1', '1'])]

that is why we do not need to +1 when calculating the length as in Solution 2.

>>> x = "1"
>>> for n in range(30):
... x = "".join([str(len(list(j))) + i for i,j in itertools.
groupby(x)])
...
>>> len(x)
5808

Solution 4
This is not recommend, but it is a cool one-liner solution. Do not sacrifice clarity
for coolness in the real world projects!
>>> from itertools import groupby
>>> from functools import reduce
>>> len(reduce(lambda x, n:reduce(lambda a, b: a + str(len(list(
b[1]))) + b[0], groupby(x), ""), range(30), "1"))
5808

2 nested reduce() , the outer one simply let it run for 30 times, and set the initial
value 1 for x ; the inner one does exactly the same as in Solution 3.
Again, whether this bothers you or not, do not code anything that need you
extensive explanations.

Next Level
[Link]

55

Level 10

56

Level 11

Python Challenge - Level 11

Link: [Link]
Username: huge
Password: file

Problem

title: odd even

Solution
The only clue is the title, which implies that we need to split the image by
odd/even:

57

Level 11

from PIL import Image

im = [Link]('[Link]')
(w, h) = [Link]
even = [Link]('RGB', (w // 2, h // 2))
odd = [Link]('RGB', (w // 2, h // 2))
for i in range(w):
for j in range(h):
p = [Link]((i,j))
if (i+j)%2 == 1:
[Link]((i // 2, j // 2), p)
else:
[Link]((i // 2, j // 2), p)
[Link]('[Link]')
[Link]('[Link]')

Open [Link] you will see a word: evil

Next Level
[Link]

58

Level 12

Python Challenge - Level 12

Link: [Link]
Username: huge
Password: file

Problem

Checking the source, the image is named as [Link] . Try evil2 and you
will see:
[Link]

59

Level 12

Change suffix to .gfx to download the file

Is it over? Try [Link], we got:

60

Level 12

Really? "no more evils"? Let's try [Link]. Depend on your browser, you may see
nothing or an error message
The image "[Link] cannot be
displayed because it contains errors.
But, it is not 404! Let's take a closer look:
$ curl -u huge:file [Link]
[Link]
Bert is evil! go back!

OK, Bert is evil, whoever that is.

Solution
It is hard to tell what's going on inside the file.

61

Level 12

>>> data = open("[Link]", "rb").read()

>>> data
b'\xff\x89G\x89\xff\xd8PIP\xd8\xffNFN

Back to the problem's image, someone is dealing the cards into 5 stacks, and all
the cards are ... 5.
>>> len(data)
67575

Let's try to split the data into 5, but "dealing" the bytes instead of cards...
>>> for i in range(5):
... open('%[Link]' % i ,'wb').write(data[i::5])

Open the generated [Link] through [Link] , you should see dis , pro ,
port , tional

62

Level 12

63

Level 12

Put Everything Together

data = open("[Link]", "rb").read()
for i in range(5):
open('%[Link]' % i ,'wb').write(data[i::5])

Next Level
[Link]

64

Level 13

Python Challenge - Level 13

Link: [Link]
Username: huge
Password: file

Problem

phone that evil

Key 5 is clickable,

65

Level 13

<methodResponse>
<fault>
<value>
<struct>
<member>
<name>faultCode</name>
<value>
<int>105</int>
</value>
</member>
<member>
<name>faultString</name>
<value>
<string>
XML error: Invalid document end at line 1, column
1
</string>
</value>
</member>
</struct>
</value>
</fault>
</methodResponse>

Solution
We can use xmlrpc module to talk to it:
>>> import [Link]
>>> conn = [Link]("[Link]
.com/pc/[Link]")
>>> conn
<ServerProxy for [Link]/pc/[Link]>
>>> [Link]()
['phone', '[Link]', '[Link]', '[Link]
hodSignature', '[Link]', '[Link]']

66

Level 13
phone seems to be the method we should call. Get more info on how to use it:

>>> [Link]("phone")
'Returns the phone of a person'
>>> [Link]("phone")
[['string', 'string']]

So it takes a string and returns a string, the input should be the name and the
output should be the number:
>>> [Link]("Bert")
'555-ITALY'

If you do not know, 555 basically means "fake phone numbers" in US... The key
is "italy".

Put Everything Together

import [Link]
conn = [Link]("[Link]
/pc/[Link]")
print([Link]("Bert"))

Next Level
[Link]

67

Level 14

Python Challenge - Level 14

Problem Link
[Link]
Username: huge
Password: file

Clues
Clue 1
In HTML source code:

68

Level 14

<!-- remember: 100*100 = (100+99+99+98) + (... -->

<img src="[Link]" width="100" height="100">

This is the image:

Clue 2
Title of the HTML:
walk around

Clue 3
The image of the problem: we are looking at(for) something spiral!

Exploration
Do not be fooled by that barcode-like image, it appears to be a square, that is
because in HTML both the width and height are set as 100.
>>> from PIL import Image
>>> im = [Link]('../images/[Link]')
>>> [Link]
(10000, 1)

The real size is not 100*100 ! It is 10000*1 !

Based on all the clues, our assumption is to use the 10000 points from the given
image, create another image of 100*100, by walking around the square from
outside to inside, so we go right for 100 pixels, then down 99 pixels, then left 99
pixels, then up 98 pixels(clue 1).

69

Level 14

Solution
from PIL import Image
im = [Link]('[Link]')
delta = [(1,0),(0,1),(-1,0),(0,-1)]
out = [Link]('RGB', [100,100])
x,y,p = -1,0,0
d = 200
while d/2>0:
for v in delta:
steps = d // 2
for s in range(steps):
x, y = x + v[0], y + v[1]
[Link]((x, y),[Link]((p,0)))
p += 1
d -= 1
[Link]('level_14_result.jpg')

It's a cat!

Next Level
[Link]
and its name is uzi. you'll hear from him later.
[Link]

70

Level 15

Python Challenge - Level 15

Problem Link
Link: [Link]
Username: huge
Password: file

Clues
Clue 1
There's a burnt hole on the calendar, it must be year 1xx6.

71

Level 15

Clue 2
That year's Jan 1 is a Thursday.

Clue 3
It was a leap year, since Feb 29 is on the calendar.

Clue 4
We are looking for Jan 26.

Clue 5
In HTML source code:
<!-- he ain't the youngest, he is the second -->

Clue 6
Title: whom?

Clue 7
In HTML source code:
<!-- todo: buy flowers for tomorrow -->

Exploration
So we are looking for a person, who's related to that particular date, and he is not
the youngest...
The key is to find what year it was. We can filter the years between 1006 and
1996 by those clues.

72

Level 15
First the leap year. Is 1006 a leap year?
>>> 1006 / 4
251.5

No, it is not, so our starting point should be 1016:

>>> 1016 / 4
254.0

Then we can test 1036, 1056, 1076... every 20 years.

>>> list(range(1016, 1996, 20))
[1016, 1036, 1056, 1076, 1096, 1116, 1136, 1156, 1176, 1196, 1216
, 1236, 1256, 1276, 1296, 1316, 1336, 1356, 1376, 1396, 1416, 14
36, 1456, 1476, 1496, 1516, 1536, 1556, 1576, 1596, 1616, 1636,
1656, 1676, 1696, 1716, 1736, 1756, 1776, 1796, 1816, 1836, 1856
, 1876, 1896, 1916, 1936, 1956, 1976]

Then find the year that has Jan 26 as a Monday

>>> import datetime
>>> [year for year in range(1016, 1996, 20) if [Link](yea
r, 1, 26).isoweekday() == 1]
[1176, 1356, 1576, 1756, 1976]

From clue 5:
he ain't the youngest, he is the second
1976 must be the youngest, so 1756 is the second youngest... what is special with
1756-01-26? Nothing. But remember the last clue:
todo: buy flowers for tomorrow
And... 1756-01-27 is the birthday of Mozart...

73

Level 15

Solution
Alternatively we can use [Link]() to detect leap year, which
makes it more clear. Check out the full solution:
import datetime, calendar
for year in range(1006,1996,10):
d = [Link](year, 1, 26)
if [Link]() == 1 & [Link](year):
print(d)

Output
1176-01-26
1356-01-26
1576-01-26
1756-01-26
1976-01-26

Next Level
[Link]

74

Level 16

Python Challenge - Level 16

Problem Link
Link: [Link]
Username: huge
Password: file

Clues
Clue 1
Page Title:
let me get this straight

75

Level 16

Clue 2
Image: There are pink segments, looks like they have the same length.

Exploration
Sounds like we need to align the pink segments. But how do you define "pink"

Find the Pink Segments

First load the image:
from PIL import Image, ImageChops
image = [Link]("[Link]")

Could it be the most frequent pixels? [Link]() can give us the

counts of each pixel.
>>> max(enumerate([Link]()), key=lambda x: x[1])
(60, 29448)

So value 60 appears 29448 times, let's see if it is pink. We can make a copy of the
current image(to use the same palette), and paint all the pixels as 60:
>>> tmp = [Link]()
>>> [Link](bytes([60] * ([Link] * [Link])))
>>> [Link]()

76

Level 16

Hmm, not so pinky.

If pink segments exists in every row, then the number of pink pixels should be
divisible by height of the image, right?
>>> [x for x in [Link]() if x % [Link] == 0 and x
!= 0]
[2400]

Good, there's only one!

>>> [Link]().index(2400)
195

Let's try pixel value of 195 instead of 60

>>> [Link](bytes([195] * ([Link] * [Link])))
>>> [Link]()

77

Level 16

Now it looks right.

Shift The Rows

Let's shift each row:
import numpy as np
>>> shifted = [bytes([Link](row, -[Link]().index(195)).toli
st()) for row in [Link](image)]

We are using [Link](image) to load image data, alternatively you can use
list([Link]()) , however you will get a one-dimension array, so you

need to reshape the array manually.

We take each row in the ndarray, and get the first position of the pink pixel by
[Link]().index(195) , then [Link]() can help us shift the array.

Once we have the shifted data as bytes , we can use [Link]() to

create a new image, while reusing the original image's mode and size.

78

Level 16

>>> [Link]([Link], [Link], b"".join(shifted)).s

how()

Here's the result:

Solution
Solution 1
from PIL import Image, ImageChops
import numpy as np
image = [Link]("[Link]")
shifted = [bytes([Link](row, -[Link]().index(195)).tolist()
) for row in [Link](image)]
[Link]([Link], [Link], b"".join(shifted)).show(
)

79

Level 16

Solution 2
from PIL import Image, ImageChops
image = [Link]("[Link]")
for y in range([Link][1]):
box = 0, y, [Link][0], y + 1
row = [Link](box)
bytes = [Link]()
i = [Link](195)
row = [Link](row, -i)
[Link](row, box)
[Link]("[Link]")

Result: romance!

Next Level
[Link]

80

Level 17

Python Challenge - Level 17

Problem Link
Link: [Link]
Username: huge
Password: file

Clues
Clue 1
Image: it is named cookies

Clue 2
81

Level 17
There's an embedded image. Looks familiar? It's from Level 4.

Solution
Part 1:
from [Link] import urlopen
from [Link] import unquote_plus, unquote_to_bytes
import re, bz2
num = '12345'
info = ''
while(True):
h = urlopen('[Link]
[Link]?busynothing='+num)
raw = [Link]().decode("utf-8")
print(raw)
cookie = [Link]("Set-Cookie")
info += [Link]('info=(.*?);', cookie).group(1)
match = [Link]('the next busynothing is (\d+)', raw)
if match == None:
break
else:
num = [Link](1)
res = unquote_to_bytes([Link]("+", " "))
print(res)
print([Link](res).decode())

Output:

82

Level 17

...
and the next busynothing is 96070
and the next busynothing is 83051
that's it.
b'BZh91AY&SY\x94:\xe2I\x00\x00!\x19\x80P\x81\x11\x00\xafg\x9e\xa
0 \x00hE=M\xb5#\xd0\xd4\xd1\xe2\x8d\x06\xa9\xfa&S\xd4\xd3!\xa1\x
eai7h\x9b\x9a+\xbf`"\xc5WX\xe1\xadL\x80\xe8V<\xc6\xa8\xdbH&32\x1
8\xa8x\x01\x08!\x8dS\x0b\xc8\xaf\x96KO\xca2\xb0\xf1\xbd\x1du\xa0
\x86\x05\x92s\xb0\x92\xc4Bc\xf1w$S\x85\t\tC\xae$\x90'

And the final line:

is it the 26th already? call his father and inform him that "the
flowers are on their way". he'll understand.

Part 2:
from [Link] import ServerProxy
conn = ServerProxy("[Link]
php")
print([Link]("Leopold"))

555-VIOLIN

Visit [Link]
no! i mean yes! but ../stuff/[Link].

Part 3:

83

Level 17

from [Link] import Request, urlopen

from [Link] import quote_plus
url = "[Link]
msg = "the flowers are on their way"
req = Request(url, headers = { "Cookie": "info=" + quote_plus(ms
g)})
print(urlopen(req).read().decode())

<html>
<head>
<title>it's me. what do you want?</title>
<link rel="stylesheet" type="text/css" href="../[Link]">
</head>
<body>
<br><br>
<center><font color="gold">
<img src="[Link]" border="0"/>
<br><br>
oh well, don't you dare to forget the balloons.</font>
</body>
</html>

Next Level
[Link]
redirect to
[Link]

84

Level 18

Python Challenge - Level 18

Link: [Link]
Username: huge
Password: file

Problem

Solution
The difference is "brightness"... so go to
[Link]
In HTML source:
<!-- maybe consider [Link] -->

Download: [Link]
>>> print([Link]("[Link]").read().decode())

85

Level 18
You will see the data consists roughly two columns.
import gzip, difflib
data = [Link]("[Link]")
d1, d2 = [], []
for line in data:
[Link](line[:53].decode()+"\n")
[Link](line[56:].decode())

compare = [Link]().compare(d1, d2)

f = open("[Link]", "wb")
f1 = open("[Link]", "wb")
f2 = open("[Link]", "wb")
for line in compare:
bs = bytes([int(o, 16) for o in line[2:].strip().split(" ")
if o])
if line[0] == '+':
[Link](bs)
elif line[0] == '-':
[Link](bs)
else:
[Link](bs)
[Link]()
[Link]()
[Link]()

[Link]().compare(a, b) will generate

lines start with + : appear in a not in b

lines start with - : appear in b not in a
others: appear in both
Result:
[Link] : ../hex/[Link]

86

Level 18
[Link] : butter
[Link] : fly

Next Level
[Link]
username: butter
password: fly

87

Level 19

Python Challenge - Level 19

Link: [Link]
Username: butter
Password: fly

Problem

Solution

88

Level 19

import email, base64, wave

message = open("[Link]", "rb").read().decode()
mail = email.message_from_string(message)
audio = mail.get_payload(0).get_payload(decode=True)
f = open("[Link]", "wb")
[Link](audio)

w = [Link]('[Link]', 'rb')
h = [Link]("[Link]", "wb")
print([Link]())
print([Link]())
print([Link]())
[Link]([Link]())
[Link]([Link]()//2)
[Link]([Link]()*2)
frames = [Link]([Link]())
wave.big_endiana = 1
[Link](frames)
[Link]()

Next Level
[Link]

89

Level 20

Python Challenge - Level 20

Link: [Link]
Username: butter
Password: fly

Problem

but inspecting it carefully is allowed.

Solution

90

Level 20

import [Link], base64

request = [Link]('[Link]
/pc/hex/[Link]')
cred = base64.b64encode(b"butter:fly")
request.add_header("Authorization", "Basic %s" % [Link]())
print([Link])
# {'Authorization': 'Basic YnV0dGVyOmZseQ=='}
response = [Link](request)
print([Link])
# Content-Type: image/jpeg
# Content-Range: bytes 0-30202/2123456789
# Connection: close
# Transfer-Encoding: chunked
# Server: lighttpd/1.4.35

So it is a huge file(length of 2123456789) however only a small portion is served(0

to 30202). Try to get the content after that:
pattern = [Link]('bytes (\d+)-(\d+)/(\d+)')
content_range = [Link]['content-range']
(start, end, length) = [Link](content_range).groups()
[Link]['Range'] = 'bytes=%i-' % (int(end) + 1)
response = [Link](request)
print([Link])
# {'Authorization': 'Basic YnV0dGVyOmZseQ=='}
# Content-Type: application/octet-stream
# Content-Transfer-Encoding: binary
# Content-Range: bytes 30203-30236/2123456789
# Connection: close
# Transfer-Encoding: chunked
# Server: lighttpd/1.4.35
print([Link]().decode())
# Why don't you respect my privacy?

91

Level 20
So now the content between 30203 and 30236 is served, which is "Why don't you
respect my privacy?"; continue for a few iterations:
pattern = [Link]('bytes (\d+)-(\d+)/(\d+)')
content_range = [Link]['content-range']
(start, end, length) = [Link](content_range).groups()
while True:
try:
[Link]['Range'] = 'bytes=%i-' % (int(end) + 1)
response = [Link](request)
print([Link]().decode())
print([Link])
(start, end, length) = [Link]([Link]['
content-range']).groups()
except:
break

It prints:
Why don't you respect my privacy?
we can go on in this way for really long time.
stop this!
invader! invader!
ok, invader. you are inside now.

The last request ends at 30346.

Go to [Link]
Yes! that's you!
What about content after the length:

92

Level 20

[Link]['Range'] = 'bytes=%i-' % (int(length) + 1)

response = [Link](request)
print([Link])
print([Link]().decode())

Result:
Content-Type: application/octet-stream
Content-Transfer-Encoding: binary
Content-Range: bytes 2123456744-2123456788/2123456789
Connection: close
Transfer-Encoding: chunked
Server: lighttpd/1.4.35
esrever ni emankcin wen ruoy si drowssap eht

The content is reversed: "the password is your new nickname in reverse". The
"nickname" is "invader", so password is "redavni".
Now "reverse" the search:
[Link]['Range'] = 'bytes=2123456743-'
response = [Link](request)
print([Link])
print([Link]().decode())

Content-Type: application/octet-stream
Content-Transfer-Encoding: binary
Content-Range: bytes 2123456712-2123456743/2123456789
Connection: close
Transfer-Encoding: chunked
Date: Mon, 02 May 2016 18:12:45 GMT
Server: lighttpd/1.4.35

and it is hiding at 1152983631.

93

Level 20
Then save it as a zip file:
[Link]['Range'] = 'bytes=1152983631-'
response = [Link](request)
with open("[Link]", "wb") as f:
[Link]([Link]())

Unzip it with the password("redavni").

Yes! This is really level 21 in here. And yes, After you solve it, you'll be in level
22!
Now for the level:
We used to play this game when we were kids
When I had no idea what to do, I looked backwards.

Next Level
Inside the zip file

94

Level 21

Python Challenge - Level 21

Problem
Inside the zip file.

Solution
import zlib, bz2
with open("[Link]", "rb") as f:
data = [Link]()
while True:
if [Link](b'x\x9c'):
data = [Link](data)
elif [Link](b'BZh'):
data = [Link](data)
elif [Link](b'\x9cx'):
data = data[::-1]
else:
break
print(data)

Result:
b'sgol ruoy ta kool'

Add logging:

95

Level 21

import zlib, bz2

result = ""
with open("[Link]", "rb") as f:
data = [Link]()
while True:
if [Link](b'x\x9c'):
data = [Link](data)
result += ' '
elif [Link](b'BZh'):
data = [Link](data)
result += '#'
elif [Link](b'\x9cx'):
data = data[::-1]
result += '\n'
else:
break
print(result)

96

Level 21

### ### ######## ######## ##########

########
####### ####### ######### ######### #########
#########
## ## ## ## ## ## ## ## ##
## ##
## ## ## ## ## ## ## ##
## ##
## ## ## ######### ######### ########
#########
## ## ## ######## ######## ########
########
## ## ## ## ## ##
## ##
## ## ## ## ## ## ##
## ##
####### ####### ## ## #########
## ##
### ### ## ## ##########
## ##

Next Level
[Link]

97

Level 22

Python Challenge - Level 22

Link: [Link]
Username: butter
Password: fly

Problem

Solution

98

Level 22

from PIL import Image, ImageDraw

img = [Link]("[Link]")
new = [Link]("RGB", (500, 200))
draw = [Link](new)
cx, cy = 0, 100
for frame in range(img.n_frames):
[Link](frame)
left, upper, right, lower = [Link]()
# get the direction; like a joystick,
dx = left - 100
dy = upper - 100
# end of a move(letter), shift to the right
if dx == dy == 0:
cx += 50
cy = 100
cx += dx
cy += dy
[Link]([cx, cy])
[Link]()

Result: bonus

Next Level
[Link]

99

Level 23

Python Challenge - Level 23

Link: [Link]
Username: butter
Password: fly

Problem

Solution
this is a special module in Python:

100

Level 23

>>> import this

The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to d
o it.
Although that way may not be obvious at first unless you're Dutc
h.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

The string is internally stored as this.s :

101

Level 23

>>> print(this.s)
Gur Mra bs Clguba, ol Gvz Crgref
Ornhgvshy vf orggre guna htyl.
Rkcyvpvg vf orggre guna vzcyvpvg.
Fvzcyr vf orggre guna pbzcyrk.
Pbzcyrk vf orggre guna pbzcyvpngrq.
Syng vf orggre guna arfgrq.
Fcnefr vf orggre guna qrafr.
Ernqnovyvgl pbhagf.
Fcrpvny pnfrf nera'g fcrpvny rabhtu gb oernx gur ehyrf.
Nygubhtu cenpgvpnyvgl orngf chevgl.
Reebef fubhyq arire cnff fvyragyl.
Hayrff rkcyvpvgyl fvyraprq.
Va gur snpr bs nzovthvgl, ershfr gur grzcgngvba gb thrff.
Gurer fubhyq or bar-- naq cersrenoyl bayl bar --boivbhf jnl gb q
b vg.
Nygubhtu gung jnl znl abg or boivbhf ng svefg hayrff lbh'er Qhgp
u.
Abj vf orggre guna arire.
Nygubhtu arire vf bsgra orggre guna *evtug* abj.
Vs gur vzcyrzragngvba vf uneq gb rkcynva, vg'f n onq vqrn.
Vs gur vzcyrzragngvba vf rnfl gb rkcynva, vg znl or n tbbq vqrn.
Anzrfcnprf ner bar ubaxvat terng vqrn -- yrg'f qb zber bs gubfr!

The text is rot-13 encoded(rotate by 13 characters.

102

Level 23

>>> import this

>>> print([Link](this.s, "rot-13"))
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to d
o it.
Although that way may not be obvious at first unless you're Dutc
h.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

And there's a built-in dict for the rotation:

103

Level 23

>>> this.d
{'n': 'a', 'J': 'W', 'o': 'b', 'r': 'e', 'T': 'G', 'K': 'X', 'v'
: 'i', 'H': 'U', 'L': 'Y', 'q': 'd', 'w': 'j', 'O': 'B', 'e': 'r'
, 'S': 'F', 'l': 'y', 'X': 'K', 'I': 'V', 'a': 'n', 'Z': 'M', 'G'
: 'T', 'i': 'v', 'f': 's', 'u': 'h', 'h': 'u', 'N': 'A', 'R': 'E'
, 'P': 'C', 'M': 'Z', 'C': 'P', 'b': 'o', 'U': 'H', 'A': 'N', 'B'
: 'O', 'W': 'J', 'D': 'Q', 'k': 'x', 'c': 'p', 'x': 'k', 'm': 'z'
, 'F': 'S', 'V': 'I', 'E': 'R', 'Q': 'D', 'p': 'c', 'g': 't', 'Y'
: 'L', 'j': 'w', 'y': 'l', 's': 'f', 't': 'g', 'z': 'm', 'd': 'q'
}

So you can also do:

>>> print("".join([[Link](c, c) for c in this.s]))
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to d
o it.
Although that way may not be obvious at first unless you're Dutc
h.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

104

Level 23
Use this to decode the message:
>>> s = 'va gur snpr bs jung?'
>>> print("".join([[Link](c, c) for c in s]))
in the face of what?

From the "Zen":

In the face of ambiguity, ...
The answer is "ambiguity"

Next Level
[Link]

105

Level 24

Python Challenge - Level 24

Link: [Link]
Username: butter
Password: fly

Problem

Solution
106

Level 24
Load the image:
>>> from PIL import Image
>>> maze = [Link]("[Link]")
>>> w, h = [Link]

Check the top line

>>> for i in range(w): print([Link]((i, 0)))

There's only one black pixel( (0, 0, 0, 255) ), others are white( (255, 255,
255, 255) ) or grey(the upper left corner square with the number of the level), so

the entrance point is (w - 2, 0) .

Similarly print out the bottom line:
>>> for i in range(w): print([Link]((i, h - 1)))

there's only one black pixel at (1, h - 1) , that would be the exit point.
By printing out the "inner" pixels you may notice that the non-white points all look
like (x, 0, 0, 255) , where x would vary. That is the data we need to
collect.
A BFS would find the shortest path:

107

Level 24

from PIL import Image

maze = [Link]("[Link]")
directions = [(0,1), (0,-1), (1,0), (-1,0)]
white = (255, 255, 255, 255)
w, h = [Link]
next_map = {}
entrance = (w - 2, 0)
exit = (1, h - 1)
queue = [exit]
while queue:
pos = [Link](0)
if pos == entrance:
break
for d in directions:
tmp = (pos[0] + d[0], pos[1] + d[1])
if not tmp in next_map and 0 <= tmp[0] < w and 0 <= tmp[1
] < h and [Link](tmp) != white:
next_map[tmp] = pos
[Link](tmp)
path = []
while pos != exit:
[Link]([Link](pos)[0])
pos = next_map[pos]
# skipping the 0s
print(path[1::2])
open('[Link]','wb').write(bytes(path[1::2]))

From the zip, a picture with the word "lake".

Next Level
[Link]

108

Level 24

109

Level 25

Python Challenge - Level 25

Link: [Link]
Username: butter
Password: fly

Problem

Solution
To download a wav file, use wget with authentication:
$ wget --user butter --password fly
[Link]
To download all the wav files:

110

Level 25

$ for i in {1..25}; do wget --user butter --password fly http://

[Link]/pc/hex/lake$[Link]; done

25 wav files can be converted to 5 by 5 = 25 pieces of images

from PIL import Image
import wave
wavs = [[Link]('lake/lake%[Link]' % i) for i in range(1,26)]
result = [Link]('RGB', (300,300), 0)
num_frames = wavs[0].getnframes()
for i in range(len(wavs)):
byte = wavs[i].readframes(num_frames)
img = [Link]('RGB', (60, 60), byte)
[Link](img, (60 * (i % 5), 60 * (i // 5)))
[Link]('[Link]')

Next Level
[Link]/pc/hex/[Link]

111

Level 26

Python Challenge - Level 26

Link: [Link]/pc/hex/[Link]
Username: butter
Password: fly

Problem

Hurry up, I'm missing the boat

Solution
Send the email to [Link]@[Link] and get the response:

112

Level 26
From: [Link]@[Link] Subject: Re: sorry Date:
Never mind that.
Have you found my broken zip?
md5: bbb8b499a0eef99b52c7f13f4e78c24b
Can you believe what one mistake can lead to?
As indicated there's only "one mistake". Try to modify the data and check by md5
code.
import hashlib
def search_and_save():
for i in range(len(data)):
for j in range(256):
newData = data[:i] + bytes([j]) + data[i + 1:]
if hashlib.md5(newData).hexdigest() == md5code:
open('[Link]', 'wb').write(newData)
return
md5code = 'bbb8b499a0eef99b52c7f13f4e78c24b'
data = open('maze/[Link]', 'rb').read()
search_and_save()

The result is a picture with word "speed", plus the text:

Hurry up, I'm missing the boat
The final answer is speedboat

Next Level
[Link]

Python 2 to 3
md5 module is deprecated, use hashlib.md5()

113

Level 26
open() without explicitly specifying rb will use the default utf-8 codec

for decoding.

114

Level 27

Python Challenge - Level 27

Link: [Link]
Username: butter
Password: fly

Problem

Solution

115

Level 27

>>> palette = [Link]()[::3]

>>> len(palette)
256
>>> b = bytes([i for i in range(256)])
>>> b
b'\x00\x01\x02\x03\x04\x05\x06\x07\x08\t\n\x0b\x0c\r\x0e\x0f\x10
\x11\x12\x13\x14\x15\x16\x17\x18\x19\x1a\x1b\x1c\x1d\x1e\x1f !"#
$%&\'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_`a
bcdefghijklmnopqrstuvwxyz{|}~\x7f\x80\x81\x82\x83\x84\x85\x86\x8
7\x88\x89\x8a\x8b\x8c\x8d\x8e\x8f\x90\x91\x92\x93\x94\x95\x96\x9
7\x98\x99\x9a\x9b\x9c\x9d\x9e\x9f\xa0\xa1\xa2\xa3\xa4\xa5\xa6\xa
7\xa8\xa9\xaa\xab\xac\xad\xae\xaf\xb0\xb1\xb2\xb3\xb4\xb5\xb6\xb
7\xb8\xb9\xba\xbb\xbc\xbd\xbe\xbf\xc0\xc1\xc2\xc3\xc4\xc5\xc6\xc
7\xc8\xc9\xca\xcb\xcc\xcd\xce\xcf\xd0\xd1\xd2\xd3\xd4\xd5\xd6\xd
7\xd8\xd9\xda\xdb\xdc\xdd\xde\xdf\xe0\xe1\xe2\xe3\xe4\xe5\xe6\xe
7\xe8\xe9\xea\xeb\xec\xed\xee\xef\xf0\xf1\xf2\xf3\xf4\xf5\xf6\xf
7\xf8\xf9\xfa\xfb\xfc\xfd\xfe\xff'
>>> len(b)
256

Full Solution

116

Level 27

from PIL import Image

import bz2
im = [Link]('[Link]')

palette = [Link]()[::3]
table = [Link](bytes([i for i in range(256)]), bytes(pa
lette))
raw = [Link]()
trans = [Link](table)
zipped = list(zip(raw[1:], trans[:-1]))
diff = list(filter(lambda p: p[0] != p[1], zipped))
indices = [i for i,p in enumerate(zipped) if p[0] != p[1]]
im2 = [Link]("RGB", [Link])
colors = [(255, 255, 255)] * len(raw)
for i in indices:
colors[i] = (0, 0, 0)
[Link](colors)
#[Link]()

s = [t[0] for t in diff]

text = [Link](bytes(s))
import keyword
print(set([w for w in [Link]() if not [Link]([Link]
code())]))

Result:

117

Level 27

{b'exec', b'print', b'../ring/[Link]', b'repeat', b'switch'}

Well, this level needs to be updated, since exec and print are not keywords
in Python 3. The only two words left are repeat and switch

Next Level
[Link]
username: repeat
password: switch

118

Level 28

Python Challenge - Level 28

Link: [Link]
Username: repeat
Password: switch

Problem

RING-RING-RING say it out loud

Solution
[Link]
yes! green!

119

Level 28

from PIL import Image

im = [Link]('[Link]')
# split RGB and get Green
green = list([Link]()[1].getdata())
# calculate diff for every two bytes
diff = [abs(a - b) for a, b in zip(green[0::2], green[1::2])]
# remove the most frequent value 42
filtered = list(filter(lambda x: x != 42, diff))
# convert to string and print out
print(bytes(filtered).decode())

Result
whodunnit().split()[0] ?

The creator of Python is Guido van Rossum, so the final answer is "guido"

Next Level
[Link]

120

Level 29

Python Challenge - Level 29

Link: [Link]
Username: repeat
Password: switch

Problem

Solution
Notice that there "silent" empty lines in the html source code. And the lines are of
different lengths. Convert the lengths to bytes and decompress by bz2:

121

Level 29

from [Link] import Request, urlopen

import bz2, base64
req = Request('[Link]
)
req.add_header('Authorization', 'Basic %s' % base64.b64encode(b'
repeat:switch').decode())
raw = urlopen(req).read().splitlines()[12:]
data = bytes([len(i) for i in raw])
print([Link](data))

b"Isn't it clear? I am yankeedoodle!"

Next Level
[Link]

122

Level 30

Python Challenge - Level 30

Link: [Link]
Username: repeat
Password: switch

Problem

The picture is only meant to help you relax

Solution
$ wget --user repeat --password switch
[Link]

123

Level 30

from PIL import Image

import math
with open('[Link]') as f:
data = [[Link]() for x in [Link]().split(",")]
length = len(data)
print(length)
# 7367
factors = [x for x in range(2, length) if length % x == 0]
print(factors)
# [53, 139]
img = [Link]("F", (53, 139))
[Link]([float(x) for x in data], 256)
img = [Link](Image.FLIP_LEFT_RIGHT)
img = [Link](Image.ROTATE_90)
#[Link]()
a = data[0::3]
b = data[1::3]
c = data[2::3]
res = bytes([int(x[0][5] + x[1][5] + x[2][6]) for x in zip(d
ata[0::3], data[1::3], data[2::3])])
print(res)

b'So, you found the hidden message.\nThere is lots of room here

for a long message, but we only need very little space to say "l
ook at grandpa", so the rest is just garbage. \nVTZ.l\'\x7ftf*Om
@I"p]...'

keyword: grandpa

Next Level
124

Level 30
[Link]

125

Level 31

Python Challenge - Level 31

Link: [Link]
Username: repeat
Password: switch
Click image
Username: kohsamui
Password: thailand

Problem

126

Level 31

Click on the image:

That was too easy. You are still on 31...

127

Level 31

In page source:
<img src="[Link]" border="0">
<window left="0.34" top="0.57" width="0.036" height="0.027"/>
<option iterations="128"/>

Solution
It is a image of the Mandelbrot set.
The Mandelbrot set is the set of complex numbers c for which the function f(z)
= z^2 + c does not diverge when iterated from z = 0, i.e., for which the
sequence f(0), f(f(0)), etc., remains bounded in absolute value.
To slightly translate this into English: every pixel in the 2-d image (x, y) ,
uniquely represents a complex number c , we let z = 0 + 0j , then repeatedly
calculate z = z * z + c , if z is always within a range(not going to infinity),

128

Level 31
we light this pixel up, otherwise we mark it as dark. Actually we check at which
iteration it starts to diverge, and set color to that number of iteration.
In page source we are given 4 number: left, top, width, height, that is the bound of
our calculation. Suppose the image we are going to produce has width w and
height h , then x should be from 0 to w - 1 , and y should be from 0
to h - 1 . The real part of the c can be computed by left + x * width /
w , and imaginary part is bottom + y * height / h

from PIL import Image

img = [Link]("[Link]")
left = 0.34
bottom = 0.57
width = 0.036
height = 0.027
max = 128
w, h = [Link]
xstep = width / w
ystep = height/ h
result = []
for y in range(h - 1, -1, -1):
for x in range(w):
c = complex(left + x * xstep, bottom + y * ystep)
z = 0 + 0j
for i in range(max):
z = z * z + c
if abs(z) > 2:
break
[Link](i)
img2 = [Link]()
[Link](result)
[Link]()

129

Level 31

diff = [(a - b) for a, b in zip([Link](), [Link]()) if

a != b]
print(len(diff))
plot = [Link]('L', (23, 73))
[Link]([(i < 16) and 255 or 0 for i in diff])
[Link]((230,730)).show()

Extra Links
[Link]

130

Level 32

Python Challenge - Level 32

Link: [Link]
Username: kohsamui
Password: thailand

Problem

Solution

131

Level 32

import time

class Seg:
def __init__(self, length):
[Link] = length
[Link] = []
def __repr__(self):
return '<Seg:len=' + str([Link]) + ',placements=' +
str([Link]) + '>'

class Bar:
def __init__(self, axis, index, segs, length):
[Link] = segs
[Link] = False
[Link] = False
[Link] = axis
[Link] = index
[Link] = length
self.full_space = sum([[Link] for seg in [Link]])
+ len([Link]) - 1
def is_full(self):
return self.full_space == [Link]
def __repr__(self):
return '<Bar:axis=' + str([Link]) + ',index=' + str(s
[Link]) + ',len=' + str(
[Link]) + ',full_space=' + str(
self.full_space) + ',segs=' + str([Link]) + ',dir
ty=' + str([Link]) + '>'
def __lt__(self, other):
return [Link] - [Link]

def load():

132

Level 32
with open("[Link]") as f:
lines = [Link]()
lines = [[Link]() for line in lines if (not [Link]
rtswith('#')) and len([Link]()) != 0]
raw = [list(map(int, [Link]())) for line in lines]
assert sum(raw[0]) == len(raw) - 1
return raw[1:raw[0][0] + 1], raw[raw[0][0] + 1:]

def print_board(board):
m = {1: '#', 0: ' ', None: '?'}
print("\n".join([''.join([m[ele] for ele in row]) for row in
board]))

def calc_space(segs):
return sum([[Link] for seg in segs]) + len(segs) - 1

def calc_placement(bars):
for bar in bars:
for i in range(len([Link])):
seg = [Link][i]
start = calc_space([Link][:i]) + 1
end = [Link] - calc_space([Link][i + 1:]) - se
[Link]
[Link] = list(range(start, end))

def update_board(board, bar, i, value):

if board[[Link]][[Link]][i] == value:
return False
board[[Link]][[Link]][i] = value
board[1 - [Link]][i][[Link]] = value
return True

def mark_overlaps(board, bars):

for bar in bars:

133

Level 32
for seg in [Link]:
for i in range([Link][-1], [Link][0]
+ [Link]):
if update_board(board, bar, i, 1):
bars[(1 - [Link]) * h + i].dirty = True

def validate_placement(board, bar, iseg, placement):

seg = [Link][iseg]
# if the previous pixel is 1
if placement > 0 and board[[Link]][[Link]][placement - 1
] == 1:
return False
# if any of the pixel inside the segment is 0
elif 0 in board[[Link]][[Link]][placement:placement + s
[Link]]:
return False
# if the next pixel is 1
elif placement + [Link] < len(board[[Link]][[Link]]
) and board[[Link]][[Link]][
placement + [Link]] == 1:
return False
return True

def mark_flags(board, bar, tmp_placements, flags):

prev = 0
for i in range(len(tmp_placements)):
seg = [Link][i]
placement = tmp_placements[i]
# print(seg, placement, placement + [Link])
for j in range(prev, placement):
flags[j] |= 2
for j in range(placement, placement + [Link]):
flags[j] |= 1

134

Level 32
end = len(board[[Link]][0])
if i != len(tmp_placements) - 1:
end = tmp_placements[i + 1]
for j in range(placement + [Link], end):
flags[j] |= 2
prev = placement + [Link]

# flag = 1: can be black,

# flag = 2: can be white,
# flag = 3: can be both
def check_bar(board, bar, start=0, iseg=0, tmp_placements=[], fl
ags=[]):
if iseg == len([Link]):
last_seg = [Link][-1]
if 1 in board[[Link]][[Link]][tmp_placements[-1] +
last_seg.length:]:
return
mark_flags(board, bar, tmp_placements, flags)
else:
seg = [Link][iseg]
valid_placements = []
for placement in [Link]:
# print(validate_placement(board, bar, iseg, placeme
nt))
if validate_placement(board, bar, iseg, placement):
valid_placements.append(placement)
[Link] = valid_placements
for placement in [Link]:
if placement < start:
continue
if 1 in board[[Link]][[Link]][start:placement]:
continue
tmp_placements[iseg] = placement

135

Level 32
check_bar(board, bar, start=placement + [Link] +
1, iseg=iseg + 1, tmp_placements=tmp_placements,
flags=flags)

(hlens, vlens) = load()

h = len(hlens)
v = len(vlens)
bars = []
for ind in range(len(hlens)):
segs = [Seg(i) for i in hlens[ind]]
[Link](Bar(0, ind, segs, h))
for ind in range(len(hlens)):
segs = [Seg(i) for i in vlens[ind]]
[Link](Bar(1, ind, segs, h))
board = [[[None] * v for i in range(h)], [[None] * v for i in ra
nge(h)]]
calc_placement(bars)
mark_overlaps(board, bars)
while True:
dirty_bars = [(sum([len([Link]) for seg in [Link]]
), bar) for bar in bars if [Link]]
if len(dirty_bars) == 0:
break
effort, bar = min(dirty_bars)
flags = [0] * len(board[[Link]][0])
print("Processing Bar: (" + str([Link]) + "," + str([Link]
dex) + ")")
check_bar(board, bar, tmp_placements=[0] * len([Link]), fl

136

Level 32
ags=flags)
for i in range(len(flags)):
flag = flags[i]
if flag == 1:
if update_board(board, bar, i, 1):
bars[(1 - [Link]) * h + i].dirty = True
elif flag == 2:
if update_board(board, bar, i, 0):
bars[(1 - [Link]) * h + i].dirty = True
[Link] = False
print_board(board[0])
print(time.process_time())

Solve [Link], the result is an arrow point up.

Solve [Link], the result is a snake, try [Link]
Congrats! You made it through to the smiling python.
Free as in Free speech, not as in free
From wikipedia, the word following "free" should be beer.

Next Level
Level 33: [Link]

137

Level 33

Python Challenge - Level 33

Link: [Link]
Username: kohsamui
Password: thailand

Problem

Solution
>>> [Link]
(138, 138)
>>> [Link]
'L'
>>> list([Link]())
[1, 43, 7, 13, 7, 1, 1, 85, 25, 85,...]
>>> [Link]()
[0, 1532, 232, 0, 0, 0, 0, 963, 189, 0, 0, 0, 0, 724, 329, 0, 0,
0, 0, 549, 243, 0, 0, 0, 0, 144, 424, 0, 0, 0, 0, 119, 328, 0, 0

138

Level 33
, 0, 0, 126, 339, 0, 0, 0, 0, 126, 357, 0, 0, 0, 0, 107, 225, 0,
0, 0, 0, 79, 609, 0, 0, 0, 0, 181, 356, 0, 0, 0, 0, 70, 298, 0, 0
, 0, 0, 23, 164, 0, 0, 0, 0, 26, 354, 0, 0, 0, 0, 47, 341, 0, 0,
0, 0, 139, 257, 0, 0, 0, 0, 104, 505, 0, 0, 0, 0, 192, 224, 0, 0
, 0, 0, 114, 310, 0, 0, 0, 0, 32, 183, 0, 0, 0, 0, 238, 198, 0, 0
, 0, 0, 117, 327, 0, 0, 0, 0, 110, 342, 0, 0, 0, 0, 118, 342, 0,
0, 0, 0, 145, 323, 0, 0, 0, 0, 152, 324, 0, 0, 0, 0, 161, 323, 0
, 0, 0, 0, 175, 317, 0, 0, 0, 0, 183, 317, 0, 0, 0, 0, 171, 337,
0, 0, 0, 0, 198, 318, 0, 0, 0, 0, 241, 283, 0, 0, 0, 0, 1348, 272
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
>>> list(enumerate([Link]()))
[(0, 0), (1, 1532), (2, 232), (3, 0), (4, 0), (5, 0), (6, 0), (7
, 963), (8, 189), (9, 0), (10, 0), (11, 0), (12, 0), (13, 724), (
14, 329), (15, 0), (16, 0), (17, 0), (18, 0), (19, 549), (20, 243
), (21, 0), (22, 0), (23, 0), (24, 0), (25, 144), (26, 424), (27
, 0), (28, 0), (29, 0), (30, 0), (31, 119), (32, 328), (33, 0), (
34, 0), (35, 0), (36, 0), (37, 126), (38, 339), (39, 0), (40, 0)
, (41, 0), (42, 0), (43, 126), (44, 357), (45, 0), (46, 0), (47,
0), (48, 0), (49, 107), (50, 225), (51, 0), (52, 0), (53, 0), (54
, 0), (55, 79), (56, 609), (57, 0), (58, 0), (59, 0), (60, 0), (
61, 181), (62, 356), (63, 0), (64, 0), (65, 0), (66, 0), (67, 70
), (68, 298), (69, 0), (70, 0), (71, 0), (72, 0), (73, 23), (74,
164), (75, 0), (76, 0), (77, 0), (78, 0), (79, 26), (80, 354), (
81, 0), (82, 0), (83, 0), (84, 0), (85, 47), (86, 341), (87, 0),
(88, 0), (89, 0), (90, 0), (91, 139), (92, 257), (93, 0), (94, 0
), (95, 0), (96, 0), (97, 104), (98, 505), (99, 0), (100, 0), (1
01, 0), (102, 0), (103, 192), (104, 224), (105, 0), (106, 0), (1
07, 0), (108, 0), (109, 114), (110, 310), (111, 0), (112, 0), (1
13, 0), (114, 0), (115, 32), (116, 183), (117, 0), (118, 0), (119
, 0), (120, 0), (121, 238), (122, 198), (123, 0), (124, 0), (125
, 0), (126, 0), (127, 117), (128, 327), (129, 0), (130, 0), (131
, 0), (132, 0), (133, 110), (134, 342), (135, 0), (136, 0), (137
, 0), (138, 0), (139, 118), (140, 342), (141, 0), (142, 0), (143
, 0), (144, 0), (145, 145), (146, 323), (147, 0), (148, 0), (149
, 0), (150, 0), (151, 152), (152, 324), (153, 0), (154, 0), (155
, 0), (156, 0), (157, 161), (158, 323), (159, 0), (160, 0), (161
, 0), (162, 0), (163, 175), (164, 317), (165, 0), (166, 0), (167

139

Level 33
, 0), (168, 0), (169, 183), (170, 317), (171, 0), (172, 0), (173
, 0), (174, 0), (175, 171), (176, 337), (177, 0), (178, 0), (179
, 0), (180, 0), (181, 198), (182, 318), (183, 0), (184, 0), (185
, 0), (186, 0), (187, 241), (188, 283), (189, 0), (190, 0), (191
, 0), (192, 0), (193, 1348), (194, 272), (195, 0), (196, 0), (197
, 0), (198, 0), (199, 0), (200, 0), (201, 0), (202, 0), (203, 0)
, (204, 0), (205, 0), (206, 0), (207, 0), (208, 0), (209, 0), (2
10, 0), (211, 0), (212, 0), (213, 0), (214, 0), (215, 0), (216, 0
), (217, 0), (218, 0), (219, 0), (220, 0), (221, 0), (222, 0), (
223, 0), (224, 0), (225, 0), (226, 0), (227, 0), (228, 0), (229,
0), (230, 0), (231, 0), (232, 0), (233, 0), (234, 0), (235, 0), (
236, 0), (237, 0), (238, 0), (239, 0), (240, 0), (241, 0), (242,
0), (243, 0), (244, 0), (245, 0), (246, 0), (247, 0), (248, 0), (
249, 0), (250, 0), (251, 0), (252, 0), (253, 0), (254, 0), (255,
0)]
>>> sum([x for x in [Link]() if x != 0][:-2])
17424

from PIL import Image

import math
im = [Link]('[Link]')
data = list([Link]())
out = None
for i in range(33):
max_value = max(data)
data = [x for x in data if x < max_value - 1]
print(len(data))
l = int([Link](len(data)))
out = [Link]('L', (l, l))
[Link](data)
[Link]()

The letters with frames:

140

Level 33
gremlins

Final Link
[Link]

141

Appendix: Links

Links
Documentation
The Python Standard Library: ([Link]
PEP 8: Style Guide for Python Code([Link]
PIL: Python Imaging Library(fork that works with Python 3.x)
([Link]

Problems
Level 0:
problem: [Link]
unlock official solution:
[Link]
Level 1:
problem: [Link]
unlock official solution: [Link]
Level 2:
problem: [Link]
unlock official solution:
[Link]
Level 3:
problem: [Link]
unlock official solution:
[Link]
Level 4:
problem: [Link]
unlock official solution:
[Link]
Level 5:
problem: [Link]

142

Appendix: Links
unlock official solution:
[Link]
Level 6:
problem: [Link]
unlock official solution:
[Link]
Level 7:
problem: [Link]
unlock official solution:
[Link]
Level 8:
problem: [Link]
unlock official solution:
[Link]
Level 9:
problem: [Link]
unlock official solution:
[Link]
username: huge
password: file
Level 10:
problem: [Link]
unlock official solution:
[Link]
username: huge
password: file
Level 11:
problem: [Link]
unlock official solution:
[Link]
username: huge
password: file
Level 12:
problem: [Link]
unlock official solution:
[Link]

143

Appendix: Links
username: huge
password: file
Level 13:
problem: [Link]
unlock official solution:
[Link]
username: huge
password: file
Level 14:
problem: [Link]
unlock official solution:
[Link]
username: huge
password: file
Level 15:
problem: [Link]
unlock official solution:
[Link]
username: huge
password: file
Level 16:
problem: [Link]
unlock official solution:
[Link]
username: huge
password: file
Level 17:
problem: [Link]
unlock official solution:
[Link]
username: huge
password: file
Level 18:
problem: [Link]
unlock official solution:
[Link]

144

Appendix: Links
username: huge
password: file
Level 19:
problem: [Link]
unlock official solution:
[Link]
username: butter
password: fly
Level 20:
problem: [Link]
username: butter
password: fly
Level 21: NO LINK(inside the zip file from Level 20)
unlock official solution:
[Link]
Level 22:
problem: [Link]
unlock official solution:
[Link]
username: butter
password: fly
Level 23:
problem: [Link]
unlock official solution:
[Link]
username: butter
password: fly
Level 24:
problem: [Link]
unlock official solution:
[Link]
username: butter
password: fly
Level 25:
problem: [Link]
unlock official solution:

145

Appendix: Links
[Link]
username: butter
password: fly
Level 26:
problem: [Link]
unlock official solution:
[Link]
username: butter
password: fly
Level 27:
problem: [Link]
unlock official solution: [Link]
username: butter
password: fly
Level 28:
problem: [Link]
unlock official solution:
[Link]
username: repeat
password: switch
Level 29: -problem: [Link]
unlock official solution:
[Link]
username: repeat
password: switch
Level 30:
problem: [Link]
unlock official solution:
[Link]
username: repeat
password: switch
Level 31:
problem: [Link]
unlock official solution:
[Link]
username: repeat

146

Appendix: Links
password: switch
username(after clicking the image): kohsamui
password(after clicking the image): thailand
Level 32:
problem: [Link]
unlock official solution:
[Link]
username: kohsamui
password: thailand
Level 33:
problem: [Link]
unlock official solution:
[Link]
username: kohsamui
password: thailand

147