PythonTrier

Python Challenge, Level 9

Tue, 16 Apr 2019 16:00:00 +0000

Continuing on our journey through the challenges at PythonChallenge.com, here are the next few levels that we completed during the last meet.

SPOILERS! As stated in our last post, We will discuss the challenges, the clues, and how we solved each level. We discovered other sites have done the same thing but chose to solve these on our own. It’s more fun that way. Afterward, it’s interesting to go back and see how others have solved the same problem, but we recommend you solve the problems on your own.

On the page for this challenge is a photo which shows a view of a lake and a tree. The outline of the tree is marked with some square dots. As it wasn’t immediately apparent what the dots were for, we looked for further hints by inspecting the page code. Inside we found the following hint:

<!--
first+second=?

first:
146,399,163,403,170,393,169,391,166,386,170,...

second:
156,141,165,135,169,131,176,130,187,134,191,...
-->

Our first reaction was to add the two rows of numbers. This did not make much sense, as both had different lengths.

By counting the numbers in each row we found out that both contained an equal count of numbers, so we tried to use them as coordinates of a point, as the square dots on the photo suggest.

For plotting the dots we choose the library mathplotlib. The method pyplot.plot accepts the x/y-coordinates as arrays. As the numbers in first and second can be seen as one- dimensional arrays, we looked for a solution to slice each of them into two arrays, for the x and y coordinates. We were already familiar with the NumPy which provides a method [r_] (https://www.numpy.org/devdocs/reference/generated/numpy.r_.html) library, which we had used in a previous project. It happened to provide the exact functionality we wanted.

Translates slice objects to concatenation along the first axis.

A small example: From first we want beginning from index 0 every second number to be the value for the x-axis

first = [146,399,163,403,170,393,169,391,166,386]

and beginning from index 1 every second number to be the value for the y-axis.

first = [146,399,163,403,170,393,169,391,166,386]

To separate the values from list first we use the slice notation start:stop:step (e.g. first[0::2]) would create a list with the x values).

import numpy

first = [146,399,163,403,170,393,169,391,166,386]
x1 = first[0::2]
y1 = first[1::2]
print('{}: {}'.format('x1', x1))
print('{}: {}'.format('y1', y1))

output

x1: [146, 163, 170, 169, 166]
y1: [399, 403, 393, 391, 386]

Combining it with the numpy.r_ method two arrays can be created from each list.

x1 = numpy.r_[first[0::2]]
y1 = numpy.r_[first[1::2]]
x2 = numpy.r_[second[0::2]]
y2 = numpy.r_[second[1::2]]

The resulting arrays can then be passed as parameters to the pyplot.plot method.

pyplot.plot(x1,-y1)
pyplot.plot(x2,-y2)

To show the plotted data we call the method pyplot.show().

This looks like the shape of a bull. And gives us the name of the next challenge page. So we change the url from …/pc/return/good.html to …/pc/return/bull.html and are ready for the next challenge.

Python Challenge, Level 8

Tue, 09 Apr 2019 21:00:00 +0000

Continuing on our journey through the challenges at PythonChallenge.com, here are the next few levels that we completed during the last meet.

This challenge starts at http://www.pythonchallenge.com/pc/def/integrity.html. There’s a picture of a bee on a flower with a sub-title asking, “Where is the missing link?” When you hover around the picture you can see the cursor changes to a pointer and there’s a link to http://www.pythonchallenge.com/pc/return/good.html. If you actually select it, you’ll get a pop-up that requests a user name and password.

If you search through the source, there’s the following in an HTML comment:

<!--
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'
-->

There is a Python library called BZip. For this one, you can simply import the library bz2, assign each bzip string to a variable and decompress.

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!\x9ah3M\x13<]\xc9\x14\xe1BBP\x91\xf08'

print(bz2.decompress(un))
print(bz2.decompress(pw))

In this case we find out the the user name is “huge” and the password is “file.” So we go back and select the link on the bee, enter the newly found credentials and off we go. This time there is no need to change the URL. After entering the credentials you are automatically redirected and …/pc/def/integrity.html becomes …/pc/return/good.html.

Python Challenge, Part IV

Tue, 01 Jan 2019 23:00:00 +0000

Continuing on our journey through the challenges at PythonChallenge.com, here are the next few levels that we completed during the last meet.

Level 7

Level seven begins with a pretty obvious feature, a photo with a stripe running across the middle comprised of a series of grayscale boxes. One can process the photo directly from the URL (similar to how we handled the last challenge), or one could download the file and process it locally. The following code follows the latter approach.

Pillow is a common library used to process images. Here we import Image from PIL and then we open and load the locally saved image.

from PIL import Image
# Open and load locally saved image file.
img = Image.open('oxygen.png')
pxbuffer = img.load()

print(output)

Once we load the image, we read the values of the blocks. One of the team members inspected the image and realized it was 629 pixels wide, and the blocks were seven pixels wide. If you don’t have a tool to help you figure out those details, you can use python to get some of the image properties.

>>> img.width
629

So we iterate through using:

for x in range(0, img.width, 7):
    output += chr(pxbuffer[x, img.height/2][0])

From the docs we know that the parameters for range are range(start, stop, step), so we’re starting with 0 and go to the end or, the width of the image in steps of seven. As the stripe goes down the middle we can use img.height/2 to specify which line we want to use. We return a readable message by mapping the output to a Unicode character by using the chr() function. When we run through the loop, we discover the secret message:

smart guy, you made it. the next level is [105, 110, 116, 101, 103, 114, 105, 116, 121]pe_ 

We assumed that the numbers in the initial output just needed to be run through the same conversion as the first batch. We can extract the numbers using regex and findall. We can search for a digit with one or more digits following and pass it the first output.

numbers = re.findall("\d+", output)

When we do that we get a list that returns the numbers in string form:

['105', '110', '116', '101', '103', '114', '105', '116', '121']

We can iterate through the list converting each string to an integer, and then using the chr() function to map it to its Unicode character.

for x in numbers:
    output2 += (chr(int(x)))

When we print the second output, we discover that our next URL needs to be changed to integrity. So we change …/pc/def/oxygen.html to …/pc/def/integrity.html and off we go to the next challenge!

Python Challenge, Part III

Thu, 15 Nov 2018 23:00:00 +0000

Continuing on our journey through the challenges at PythonChallenge.com, here are the next few levels that we completed during the last meet.

SPOILERS! As stated in our last post, We will discuss the challenges, the clues, and how we solved each level. We discovered other sites have done the same thing but chose to solve these on our own. It’s more fun that way. Afterwards, it’s interesting to go back and see how others have solved the same problem, but we recommend you solve the problems on your own.

Level 6

So we left the green hill to an interesting shot of some unzipped jeans. For some of these, I think we had a tendency to way over think the problem. In this case, we hit on the idea that it may have something to do with zip files pretty quick, but it took a minute before someone suggested we just try renaming the URL from channel.html to channel.zip.

Sure enough, we were prompted to download a zip file. When you extract the file, you see 910 text files each with a number.txt. There was a readme.txt at the bottom that gave the following hint. Hint one was “Start from 90052” and hint two was “answer is inside the zip.” This looked a lot like challenge four so we adapted our code to process the text files in a similar way.

When we attempted these challenges, we first tried to solve the problem, but afterwards, we tried to accomplish as much of the entire process as we could without needing human intervention. This means we wanted to download the code, extract the files, process them, and output the answer without needing to stop. The following is our final version:

#Used to make requests
import urllib.request
import re
import os
import zipfile
import sys

r = r'[0-9]*$'
base_url = "http://www.pythonchallenge.com/pc/def/channel.zip"

# Download File
x = urllib.request.urlopen(base_url)
# Open the file, give it a name,
download_file = open("channel.zip", 'bw')
# Read the zip file and write the bytes to the channel.zip file
download_file.write(x.read())
download_file.close()

# Unzip file
# Check if the output directory exists.
if not os.path.exists("output"):
   # If not, make it.
   os.makedirs("output")

# Open zip file in read mode.
zip_ref = zipfile.ZipFile("channel.zip", 'r')
# Extract zip file
zip_ref.extractall("output")

commentSum = ""

# Open and printout the readme.txt for the user.
readme = open("output/readme.txt", 'r')
print(readme.read())

# Basic interface to either enter first number or exit.
next_nothing = input("Enter file number or 'exit' to quit: ")
if next_nothing == "exit":
    print("Goodbye!")
    sys.exit()

while next_nothing.isdigit() == True:
    # Open file with given number
    number_file = open("output/{0}.txt".format(next_nothing), 'r')
    # Extract next nothing
    # RegEX Mask
    r = r'[0-9]*$'

Now a quick note, apparently you can store comments in zip files, and you can also extract them with zip_ref. So as we went through each file, we processed it for its comment and added it to the commentSum variable. Since we learned about this after we were able to follow the numeric path, we decided to expand our final output to automatically print out the final output created by the comments.

    curFile = str(next_nothing) + ".txt"
    commentSum += zip_ref.getinfo(curFile).comment.decode("utf-8")

    previous_nothing = 0
    response_nothing = number_file.read()
    next_nothing = re.findall(r, response_nothing)[0]
    number_file.close()
    
    # Go to next nothing file
    if next_nothing.isdigit() != True:
        print("STOP! {0}".format(response_nothing))
        print("Your last nothing is: {0}".format(previous_nothing))
        print("Comments : {0}".format(commentSum))
        next_nothing = input("Enter your next nothing or 'exit' to quit: ")
        if next_nothing == "exit":
            print("Goodbye!")
            # break

    else:
        previous_nothing=next_nothing
        print("Next nothing: {0}".format(next_nothing))

So after all of this, what do we get? HOCKEY! Change the URL from channel.zip to hockey.html and we move on to… a sub-challenge… The clue was, “It’s in the air. Look at the letters.” What letters? We looked for additional clues and then someone took a closer look at the hockey output and realized that each of the letters in HOCKEY were made out of another letter. The H was made out of Os, the O was made out Xs, the C was made out of Ys, the K was made out of Gs, the E was made out of Es, and the Y was made out of Ns. So what’s that spell? OXYGEN! So change hockey.html to oxygen.html and off we go!

Python Challenge, Part II

Wed, 14 Nov 2018 10:00:00 +0000

Continuing on our journey through the challenges at PythonChallenge.com, here are the next few levels that we completed during the last meet.

SPOILERS! As stated in our last post, We will discuss the challenges, the clues, and how we solved each level. We discovered other sites have done the same thing, but chose to solve these on our own. It’s more fun that way. Afterwards, it’s interesting to go back and see how others have solved the same problem, but we recommend you solve the problems on your own.

Level 4

If you’re following along from the last post, and you entered linkedlist.html, you were probably taken to a page simply saying “linkedlist.php.” You’ll see a picture of a wooden toy and the hint is in the source. The hint recommends, “urllib may help. DON’T TRY ALL NOTHINGS, since it will never end. 400 times is more than enough.”

We puzzled for a bit and noticed a different url was displayed in the browser if you hover over the photo. If you select the photo your brought to http://www.pythonchallenge.com/pc/def/linkedlist.php?nothing=12345 and the text on the page says, “and the next nothing is 44827.” So the trick is to replace the nothing in the navigation bar with the “nothing” found on the page.

Our first go at this we were able to cycle through and noticed that one line did not provide a next nothing. When we entered that into the URL, it did, in fact, provide us with the link to the next puzzle, it wasn’t a clean answer. The series actually stopped at one point, and told you to divide by two the last next_nothing by two and continue. We saw other people had solved it by reentering the new number and rerunning the code, but we wanted to run through the entire process without needing to adjust and rerun code. Our solution is as follows:

#Used to make requests
import urllib.request
import re

r = r'[0-9]*$'
base_url = "http://www.pythonchallenge.com/pc/def/linkedlist.php?nothing="
next_nothing = "12345"
previous_nothing=0

# range(start, stop, step)
for i in range(1, 400, 1):
  x = urllib.request.urlopen(base_url + next_nothing)
  response_nothing = x.read().decode("utf-8")
  next_nothing = re.findall(r, response_nothing)[0]

  if next_nothing.isdigit() != True:
    print("STOP! {0}".format(response_nothing))
    print("Your last nothing is: {0}".format(previous_nothing))
    next_nothing = input("Enter your next nothing or 'exit' to quit: ")
    if next_nothing == "exit":
      print("Goodbye!")
      break

  else:
    previous_nothing=next_nothing
    print("Next nothing: {0} at index {1}".format(next_nothing, i))

So you can see we start by setting our RegEx mask to find numbers starting from the end. We set up a variable to keep track of the previous nothing. then we use urllib to open the base URL and append it with the current next_nothing. We read the response which needs to be decoded before it can be read and we apply our mask to extract the new next_nothing. We check if each next nothing is a digit or now. If it is, we continue through the loop. If there is not a next nothing, we stop the loop, let the user know the last good next_nothing, print off the message, and wait for input. If the user enters the next nothing, the loop continues until you get to the final break with the answer. This solution does not require a user to modify code in order to obtain the final solution. I prefer that to requiring a user to change the value of a variable and run the code again.

Either way, our final output gave us peak.html so we’re off to the next level!

Level 5

Level five brings us to peak. In it, we saw a hill with a hint below saying “pronounce it.” In the source we saw a comment that said, “peak hell sounds familiar?” When you pronounce it you realize that peak hill sounds a lot like pickle. It just so happens that pickle is a Python library one can use to serialize and deserialize data structures. Next we had to find the pickle file.

When we inspected the page source we found a “peakhell” tag with a src attribute of “banner.p.” We took a guess that changing the URL would help us find the file we were looking for. Sure enough, when we changed peak.html to banner.p, we got a popup prompting us to download the file. While you can do that, you can also read the file directly from the URL, deserialize it, and work with the data using urllib. We opted for the latter.

In the code below you can see we import urllib.request and pickle. You can set the base URL with the location of your pickle file, open the URL, and load the file with pickle. When we printed the output of the pickle file, it appeared to be a list of lists containing what looked like positional data and a series of hash tags.

#Used to make requests
import urllib.request
import pickle

base_url="http://www.pythonchallenge.com/pc/def/banner.p"

x = urllib.request.urlopen(base_url)
y = pickle.loads(x.read())

print(y)

>>>[[(' ', 95)], [(' ', 14), ('#', 5), (' ', 70), ('#', 5), (' ', 1)], [(' ', 15), ...

We suspected that each row stacked on top of one another would give us our next clue using the hashtags. We completed the challenged by adding:

for line in y:
  for t in line:
    print(t[0]*t[1], end = '')
  print("")

The output produced “channel.” You may encounter some warping if your terminal window is too wide. We reduced the width and found the text normalized. Either way, we changed our URL to channel.html and it’s off to the next challenge!

Python Challenge, Part I

Tue, 17 Jul 2018 10:00:00 +0000

Exercism.io was down during our last meeting as they were upgrading to a new and improved version of their site. As such, we decided to try some of the challenges that can be found at PythonChallenge.com. It’s a clever site that creates a series of riddle-like puzzles that challenge users to figure out what question needs to be answered before you think of how to start writing code to solve it. There are currently 33 levels so we’ve started working through the challenges and thought we’d share our progress.

SPOILERS! We will discuss the challenges, the clues, and how we solved each level. We discovered other sites have done the same thing, but chose to solve these on our own. It’s more fun that way. Afterwards, it’s interesting to go back and see how others have solved the same problem, but we recommend you solve the problems on your own.

Level 0

The first challenge starts at http://www.pythonchallenge.com/pc/def/0.html. The URLs seem to be a big part of these challenges and often require manipulation. The hint for this level is to “try to change the URL.” The photo shows a $2^{38}$ in the middle of the screen. It’s entitled “warm up” so we took this one right to the console and entered:

2**23
>>> 274877906944

After that, you change the URL from 0.html to 274877906944.html and you’re off to the next!

Level 1

This challenge shows a notebook with the following written:
K -> M
O -> Q
E -> G

The hint was “everybody thinks twice before solving this.” Below that was the following text:

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 qrpgle.kyicrpylq() gq pcamkkclbcb. lmu ynnjw
ml rfc spj.

We surmised this was merely a substitution exercise where the alphabet is shifted by two, and each letter or a text is replaced accordingly. After some first attempts we discovered the maketrans method and applied the following bit of code.

# We assigned the mystery text to a variable we called string. 
string = "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 qrpgle.kyicrpylq() gq pcamkkclbcb. lmu ynnjw ml rfc spj."

# Pass the desired string and the shifted string to the maketrans method. 
print(string.translate(str.maketrans('abcdefghijklmnopqrstuvwxyz', 'cdefghijklmnopqrstuvwxyzab')))

Well leave you to find the final text on your own, but to find the next level, one must apply this transformation to the URL. So map.html becomes ocr.html and it’s off to the next level!

Level 2

Here we see an open book where the hint says, “recognize the characters. Maybe they are in the book, but MAYBE they are in the page source.” After inspecting the page source we discovered a block of text with an additional hint telling us we should, “find rare characters in the mess below.” Here is a ver small sample of the provided text:

""""%%$@_$^__#)^)&!_+]!*@&^}@[@%]()%+$&[(_@%+%$*^@$^!+]!&_#)_*}{}}!}_]$[%"""

To solve this we decided we should check for letters

# We simply copy/pasted the text into a triple quoted string.
rare_characters = """
%%$@_$^__#)^)&!_+]!*@&^}@[@%]()%+$&[(_@%+%$*^@$^!+]!&
more in exercise..."""

# We created a variable to hold the characters we found
characters_found = ""

# We iterated over each character in our string.
for i in rare_characters:
  # Did a check to see if it's a letter by using the .isalpha() method.
  if i.isalpha():
    # Added each letter found to our letter-holding variable. 
    characters_found += i
# And printed the return.     
print(characters_found)

>>> equality

So ocr.html becomes equality.html and it’s off to the next level!

Level 3

Level three was similar to level two in the fact that both had a text to sort through hidden in the source code. We could have used something to extract that, but opted for copy/paste. Perhaps we will refine these more later. So this level has a photo fo some candles and the hint says, “One small letter, surrounded by EXACTLY three big bodyguards on each of its sides.” The text to sort through looked something like this:

kAewtloYgcFQaJNhHVGxXDiQmzjfcpYbzxlWrVcqsmUbCunkfxZWDZjUZMiGqhRRiUvGmYmvnJIHEmbT MUKLECKdCthezSYBpIElRnZugFAxDRtQPpyeCBgBfaRVvvguRXLvkAdLOeCKxsDUvBBCwdpMMWmuELeG ENihrpCLhujoBqPRDPvfzcwadMMMbkmkzCCzoTPfbRlzBqMblmxTxNniNoCufprWXxgHZpldkoLCrHJq

So this sounds like a problem for regex!

import re


characters = """
kAewtloYgcFQaJNhHVGxXDiQmzjfcpYbzxlWrVcqsmUbCunkfxZWDZjUZMiGqhRRiUvGmYmvnJIHEmbT
MUKLECKdCthezSYBpIElRnZugFAxDRtQPpyeCBgBfaRVvvguRXLvkAdLOeCKxsDUvBBCwdpMMWmuELeG
more in exercise..."""

# We set the mask. The first time we focused on a group of three large characters, followed by
# one small character, followed by a group of three large characters, but found that gave 
# several false positives. If you look for a small character before and after, you will find the
# results you need. 
r = r'[a-z][A-Z]{3}[a-z][A-Z]{3}[a-z]'

# A placeholder variable for all of the characters we fine.
answer = ""

# Here we use the findall method and pass the mask and the variable with the searchable text. 
search_results = re.findall(r, characters)

# We iterate through the search 
for i in search_results:
  answer += i[4]
print(answer)

>>> linkedlist

So equality.html becomes linkedlist.html and it’s off to the next level! We’ll post the next few levels in our next post. Happy coding!

Exercism.io, Part I

Sun, 08 Jul 2018 10:00:00 +0000

In our most recent MeetUp we added some challenges to the mix. We decided to start working our way through the exercises at exercism.io. Everyone broke off into groups and here are a couple examples of what people came up with. We will continue to add a few new entries every month and work through all of the examples. Feel free to try them yourselves or come out to the next meet up and try them with the group.

Challenge 01

Challenge one, write a function that reverses a string. If you input “python,” you’ll get “nohtyp.”

Group 1

def reverse(input=''):
    return input[::-1]

Group 2

def reverse(input=''):
    x = list(input)
    # Iterate over half of the string.
    for i in range(int(len(input) / 2)):
        # Set temp placeholder variable
        c = x[i]
        # Swap characters with temp value
        x[i] = x[len(input)-1-i]
        x[len(input)-1-i] = c
    # Rebuild string from list.
    return "".join(x)

Tests

If you want to try these at home, you can use the following to tests:

import unittest

from reverse_string import reverse


# Tests adapted from `problem-specifications//canonical-data.json` @ v1.1.0

class ReverseStringTest(unittest.TestCase):
    def test_empty_string(self):
            self.assertEqual(reverse(''), '')

    def test_a_word(self):
            self.assertEqual(reverse('robot'), 'tobor')

    def test_a_capitalized_word(self):
            self.assertEqual(reverse('Ramen'), 'nemaR')

    def test_a_sentence_with_punctuation(self):
            self.assertEqual(reverse('I\'m hungry!'), '!yrgnuh m\'I')

    def test_a_palindrome(self):
            self.assertEqual(reverse('racecar'), 'racecar')


if __name__ == '__main__':
    unittest.main()

Challenge 02

Challenge two is called leap. It takes a year and tells you whether or not that year is a leap year. Some of the rules include, every leap year is evenly divisible by four, except years that are also divisible by 100, unless it is also divisible by 400.

Group 1

def is_leap_year(year):
    return year % 4 == 0 and (year % 100 != 0 or year % 400 == 0)

Group 2

def is_leap_year(year):
    if not year % 4 and (year % 100 or not year % 400):
        return True
    return False

Group 3

def is_leap_year(year):
    return year % 4 == 0 and (year % 400 == 0 or year % 100 != 0)

Tests

If you want to try these at home, you can use the following to tests:

import unittest

from leap import is_leap_year


# Tests adapted from `problem-specifications//canonical-data.json` @ v1.3.0

class LeapTest(unittest.TestCase):
    def test_year_not_divisible_by_4(self):
        self.assertIs(is_leap_year(2015), False)

    def test_year_divisible_by_4_not_divisible_by_100(self):
        self.assertIs(is_leap_year(1996), True)

    def test_year_divisible_by_100_not_divisible_by_400(self):
        self.assertIs(is_leap_year(2100), False)

    def test_year_divisible_by_400(self):
        self.assertIs(is_leap_year(2000), True)


if __name__ == '__main__':
    unittest.main()

Good luck and happy coding!

New Mailing List

Thu, 01 Mar 2018 10:00:00 +0000

Sorry all. We’ve fallen a little behind in posting content from our meetups. There will be some coming soon. In the mean time, we have a new mailing list! The Luxembourg and Greater Region community mailing list focuses on Luxembourg, Trier, and the surrounding area. If you would like to keep up on what’s new in our group or you would like to join the conversation, go ahead and sign up. With time we hope to see many more individuals as well as other local groups join. Happy coding!

Pandas Primer, Part II

Sat, 05 Aug 2017 10:00:00 +0000

Here we continue our look into Pandas. I created a profit calculator that merged data frames gathered from online sources and merged them with a data frame that I set up offline for offline analysis. The datasets used in these slides can be found at the Python Trier GitHub. Check it out and give it a try yourself.

Pandas Primer, Part I

Mon, 24 Jul 2017 10:00:00 +0000

Here we begin with part one in our look into data analytics with Pandas. We start with some of the basics of importing data, doing some basic cleaning up manipulation of data sets, and then move to visualization.