What is advent of code?

It’s an advent Calendar for programmers. You get 25 challenges starting December 1st. Caveat: you have to solve the challenge to be eligible for the next day’s challenge 🙂

Day 1 Challenge – Part 1

On the first day your first task is to count how many times a value is bigger than its predecessor. They give us some sample data

199 N/A
200 bigger
208 bigger
210 bigger
200 smaller
207 bigger
240 bigger
269 bigger
260 smaller
263 bigger

When we count the times a value is bigger we get seven times bigger.

The actual data contains 2000 rows. This isn’t exactly big data but I’ve wanted to dust off my Pandas skill, so here we go:

Let’s look at the data

import pandas as pd

df = pd.read_csv("./aoc_day_01_data.txt", header=None)
df.describe

With the read_csv() function we can read in our data file and convert it into a data frame. It’s important to hand over the header=None. Otherwise pandas assumes the first row is a column header.

df.describe gives us:

<bound method NDFrame.describe of          0
0      159
1      158
2      174
3      196
4      197
...    ...
1995  8538
1996  8543
1997  8545
1998  8557
1999  8568

[2000 rows x 1 columns]>

Because we want to reference the columns by name we add a column header

df.columns = ["original"]

To compare the nth cell with its n+1th cell neighbour be add a new column but shift the values

df['shifted'] = df['original'].shift(-1)

The output looks like this:

We add another column where we place the value True when the value from the current row in the shifted column is bigger than in the original column:

df['increased'] = (df['shifted'] > df['original'])

Now it starts to look like the sample data from the introduction:

the last thing we have to do is counting how many times True occurs:

true_count = df['increased'].sum()

which gives us “1583”

This is a bit of a hack because it assumes that True equals 1 and False == 0

A more elegant solution is to use value_counts:

df['increased'].value_counts(dropna=False)

No the output is:

True     1583
False     417
Name: increased, dtype: int64

And 1583 is the number we are looking for. This earned us our first golden star and unlocked the second part of the challenge:

Part 2

The second part is a bit more challenging because we have to sum up three adjacent values and compare them to the next three values.

199  A       
200  A B     
208  A B C   
210    B C D
200  E   C D
207  E F   D
240  E F G
269    F G H
260      G H
263        H

I created a new notebook and started like part 1 with reading the data and naming the first column

import pandas as pd

df = pd.read_csv("./aoc_day_01_data.txt", header=None)
df.columns = ["original"]

To add the sum of three values to the row of the first value we use the following code

indexer = pd.api.indexers.FixedForwardWindowIndexer(window_size=3)
df["rolling_sum"] = df.original.rolling(window=indexer).sum()

This demonstrates the power of Pandas once more: you have integrated sliding window functions!

The rest is equal to part one “shift, compare and count”

df['shifted_rs'] = df['rolling_sum'].shift(-1)
df['increased_rs'] = (df['shifted_rs'] > df['rolling_sum'])
true_count = df['increased_rs'].sum()
true_count

As a little Fingerübung I did the same with vanilla Python:

data = []
with open("./aoc_day_01_test_data.txt") as f:
    for line in f:
        data.append(int(line.rstrip()))

triplet_sums = []

for i, v in enumerate(data):
    if i < (len(data) - 2):
        triplet_sum = data[i] + data[i+1] + data[i+2]
        triplet_sums.append(triplet_sum)
print(triplet_sums)

sums_larger_than_previous_sums = 0
for i, v in enumerate(triplet_sums):
    if i < (len(triplet_sums) - 1):
        if triplet_sums[i] < triplet_sums[i+1]:
            sums_larger_than_previous_sums += 1

print(sums_larger_than_previous_sums)

Which works but is less elegant.

Stay tuned for more!

The post 2021 – Advent of code – Day 1 appeared first on Creatronix.

Installation

pip install ipyleaflet

Visualizing geo coordinates

from ipyleaflet import Map, Marker, basemaps, basemap_to_tiles

m = Map(
    basemap=basemaps.OpenStreetMap.Mapnik,
    center=(52, 8),
    zoom=5
)
cities = {  "Bad Oeynhausen":
              { "latitude":52.207851, "longitude":8.804030},
            "Detmold":
              { "latitude":51.936284, "longitude":8.879153},
            "Coburg":
              { "latitude":50.258112, "longitude":10.964463},
            "Bochum":
              { "latitude":51.481811, "longitude":7.219664},
            "Karlsbad":
               { "latitude":48.881417, "longitude":8.507199},
            "Nürnberg":
               { "latitude":49.447537, "longitude":11.102352},
             "Erlangen - Tennenlohe":
               { "latitude":49.547055, "longitude":11.015774}
          }

for city, coordinates in cities.items():

    m.add_layer(Marker(location=(coordinates["latitude"], coordinates["longitude"])))

m

The result:

The post How to visualize geo coordinates with ipyleaflet appeared first on Creatronix.

Do You know the feeling of being already late to a party when encountering something new?

But when you actually start telling others about it, you realize that it is not too common knowledge at all, e.g. Jupyter Notebooks.

What is a Jupyter notebook?

In my own words: a browser-based document-oriented command line style exploration tool for Julia, Python and R, hence the name JuPyteR Huh!

Ok, let’s break it down:

Browser-based

JuPyter is a client-server concept where you edit your code in a web form in a browser. You send the input of a cell to the server backend for execution and the server sends back a response which will be rendered in your browser.

Document-oriented

On great aspect of a JuPyter is that You can enrich your code in a nice fashion with headlines and markdown code so that you have a document containing code, the result of the code execution and documentation.

Installation and Run

If You already have a python installation You can either use pip or pipenv to install JuPyter

Pip

pip install jupyter

Pipenv

pipenv install jupyter

After installation you can start it on the console with:

jupyter notebook

An alternative way is to use the anaconda distribution.

Disadvantages

On big drawback -when your background is SW development- is that You don’t have code completion.

Another disadvantage: modularization of your code is not easy.

Versioning is an issue as well. Because the Jupyter notebook’s json files contains code and generated artifacts like plots every re-run of a notebook changes the file. The diff is not easily comprehensible.

PyCharm Integration

For the code completion issue there is JetBrains for the rescue: PyCharm IDE has an integrated JuPyter editor which supports code completion.

Useful Keyboard Shortcuts

You can open command palette via

Cmd + Shift + P on Mac OS or via

Ctrl + Shift + P on Linux and Windows

Ctrl + Enter Run Cell

Alt + Enter Run Cell and insert new cell below

https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/

The post Introduction to Jupyter Notebook appeared first on Creatronix.