Experience Seamless Full Ebook Downloads for Every Genre at textbookfull.

com

Programming Interview Problems: Dynamic

Programming (with solutions in Python) 1st Edition
Leonardo Rossi

https://textbookfull.com/product/programming-interview-
problems-dynamic-programming-with-solutions-in-python-1st-
edition-leonardo-rossi/

OR CLICK BUTTON

DOWNLOAD NOW

Explore and download more ebook at https://textbookfull.com

 Recommended digital products (PDF, EPUB, MOBI) that
you can download immediately if you are interested.

Discovering Computer Science Interdisciplinary Problems

Principles and Python Programming 1st Edition Jessen
Havill
https://textbookfull.com/product/discovering-computer-science-
interdisciplinary-problems-principles-and-python-programming-1st-
edition-jessen-havill/
textboxfull.com

Discovering Computer Science Interdisciplinary Problems

Principles and Python Programming First Edition Jessen
Havill
https://textbookfull.com/product/discovering-computer-science-
interdisciplinary-problems-principles-and-python-programming-first-
edition-jessen-havill/
textboxfull.com

Discovering Computer Science: Interdisciplinary Problems,

Principles, and Python Programming 2nd Edition Jessen
Havill
https://textbookfull.com/product/discovering-computer-science-
interdisciplinary-problems-principles-and-python-programming-2nd-
edition-jessen-havill/
textboxfull.com

Discovering Computer Science Interdisciplinary Problems

Principles and Python Programming 2nd Edition Jessen
Havill
https://textbookfull.com/product/discovering-computer-science-
interdisciplinary-problems-principles-and-python-programming-2nd-
edition-jessen-havill-2/
textboxfull.com
Cracking C Programming Interview 500 interview questions
and explanations to sharpen your C concepts for a
lucrative programming career English Edition Jhamb
https://textbookfull.com/product/cracking-c-programming-
interview-500-interview-questions-and-explanations-to-sharpen-your-c-
concepts-for-a-lucrative-programming-career-english-edition-jhamb/
textboxfull.com

Robust Adaptive Dynamic Programming 1st Edition Hao Yu

https://textbookfull.com/product/robust-adaptive-dynamic-
programming-1st-edition-hao-yu/

textboxfull.com

Python Network Programming Cookbook Kathiravelu

https://textbookfull.com/product/python-network-programming-cookbook-
kathiravelu/

textboxfull.com

Python GUI Programming Cookbook Meier

https://textbookfull.com/product/python-gui-programming-cookbook-
meier/

textboxfull.com

Abstract Dynamic Programming Second Edition Dimitri P.

Bertsekas

https://textbookfull.com/product/abstract-dynamic-programming-second-
edition-dimitri-p-bertsekas/

textboxfull.com
 1

Programming Interview Problems: Dynamic Programming (with solutions in Python)

Copyright 2020 Leonardo Rossi
The designations of products and technologies that appear in this book may be claimed as
trademarks by their manufacturers and sellers.
While every precaution has been taken in the preparation of this book, the publisher and
authors assume no responsibility for errors or omissions, or for damages resulting from the
use of the information contained herein.
2 Contents

Contents

Preface . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
General advice for the interview . . . . . . . . . . . . . . . . . . . . . . . 6
1 The Fibonacci sequence . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Solution 1: brute force, 𝑂(2𝑛 ) time 7
Solution 2: dynamic programming, top-down 9
Solution 2: dynamic programming, bottom-up 11
2 Optimal stock market strategy . . . . . . . . . . . . . . . . . . . . . . . . 13
Solution 1: dynamic programming, top-down, 𝑂(𝑛) time 13
Solution 2: dynamic programming, bottom-up, 𝑂(𝑛) time 15
Variation: limited investment budget 16
Variation: limited number of transactions 17
3 Change-making . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Clarification questions 20
Solution 1: dynamic programming, top-down, 𝑂(𝑛𝑣) time 20
Solution 2: dynamic programming, bottom-up, 𝑂(𝑛𝑣) time 25
Solution 3: dynamic programming + BFS, bottom-up, 𝑂(𝑛𝑣) time 26
Variant: count the number of ways to pay (permutations) 29
Solution: dynamic-programming, top-down, 𝑂(𝑛𝑣) 29
Variant: count the number of ways to pay (combinations) 32
Solution: dynamic-programming, top-down, 𝑂(𝑛𝑣) 32
4 Number of expressions with a target result . . . . . . . . . . . . . . . . . . 36
Clarification questions 36
Solution 1: brute-force, 𝑂(2𝑛 ) time 36
Solution 2: dynamic programming, top-down, 𝑂(𝑛𝑆) time 38
Solution 3: dynamic programming + BFS, bottom-up, 𝑂(𝑛𝑆) time 39
Unit tests 41
5 Partitioning a set into equal-sum parts . . . . . . . . . . . . . . . . . . . . 43
Clarification questions 43
Solution 1: dynamic programming, top-down, 𝑂(𝑛𝑆) time 43
6 Splitting a string without spaces into words . . . . . . . . . . . . . . . . . . 46
Clarification questions 46
Solution 1: dynamic programming, top-down, 𝑂(𝑛𝑤) time 46
Solution 2: dynamic programming + BFS/DFS, bottom-up, 𝑂(𝑛𝑤) time 48
7 The number of binary search trees . . . . . . . . . . . . . . . . . . . . . . 50
Solution 1: dynamic programming, top-down, 𝑂(𝑛2 ) time 50
8 The maximum-sum subarray . . . . . . . . . . . . . . . . . . . . . . . . 55
Clarification questions 55
Solution 1: dynamic programming, 𝑂(𝑛) time, 𝑂(𝑛) space 55
Solution 2: dynamic programming, 𝑂(𝑛) time, 𝑂(1) space 61
Unit tests 61
9 The maximum-product subarray . . . . . . . . . . . . . . . . . . . . . . . 63
Clarification questions 63
Solution 1: greedy, two-pass, 𝑂(𝑛) time 63
Contents 3

Solution 2: dynamic programming, one-pass, 𝑂(𝑛) time 69

Unit tests 73
10 Shortest pair of subarrays with target sum . . . . . . . . . . . . . . . . . . 75
Clarification questions 75
Solution 1: dynamic programming + sliding window, 𝑂(𝑛) time, 𝑂(𝑛) space 75
11 Longest palindromic substring . . . . . . . . . . . . . . . . . . . . . . . . 81
Clarification questions 81
Solution 1: brute force, 𝑂(𝑛3 ) 81
Checking if a string is a palindrome 81
Checking if a string is a palindrome: a faster way 83
Putting it all together 83
Solution 2: dynamic programming, 𝑂(𝑛2 ) 84
Solution 3: dynamic programming, 𝑂(𝑛) 88
Unit tests 90
12 Longest valid parentheses substring . . . . . . . . . . . . . . . . . . . . . 92
Clarification questions 92
Solution 1: dynamic programming, bottom-up, 𝑂(𝑛) 92
Solution 3: dynamic programming, top-down, 𝑂(𝑛) 97
Unit tests 98
13 Longest increasing subsequence . . . . . . . . . . . . . . . . . . . . . . . 100
Clarification questions 100
Solution 1: dynamic programming, bottom-up, 𝑂(𝑛2 ) time, 𝑂(𝑛2 ) space 100
Solution 2: dynamic programming, bottom-up, 𝑂(𝑛2 ) time, 𝑂(𝑛) space 103
Variant: count the number of solutions 105
Solution: dynamic programming, bottom-up, 𝑂(𝑛2 ) time, 𝑂(𝑛) space 105
14 Longest arithmetic subsequence . . . . . . . . . . . . . . . . . . . . . . . 108
Clarification questions 108
Solution 1: dynamic programming, bottom-up, 𝑂(𝑛2 ) time, 𝑂(𝑛2 ) space 108
Unit tests 112
15 Dealing the best hand of cards . . . . . . . . . . . . . . . . . . . . . . . . 114
Clarification questions 114
Solution 1: brute force, 𝑂(𝑛2 ) time 114
Solution 2: dynamic programming, 𝑂(𝑛) time 115
Unit tests 116
16 Number of ways to climb stairs . . . . . . . . . . . . . . . . . . . . . . . 118
Clarification questions 118
Solution 1: dynamic programming, top-down, 𝑂(𝑛) time 118
Solution 2: dynamic programming, bottom-up, 𝑂(𝑛) time 119
Solution 3: dynamic programming, bottom-up, 𝑂(1) time 119
Unit tests 120
17 Number of paths through maze . . . . . . . . . . . . . . . . . . . . . . . 121
Clarification questions 121
Solution 1: dynamic programming, top-down, 𝑂(𝑛2 ) time 121
Solution 2: dynamic programming, bottom-up, 𝑂(𝑛2 ) time 124
Solution 3: dynamic programming, bottom-up, 𝑂(𝑛2 ) time, linear space 125
4 Contents

Unit tests 126

18 Maximum-score path through maze . . . . . . . . . . . . . . . . . . . . . 129
Clarification questions 129
Solution 1: dynamic programming, top-down, 𝑂(𝑛2 ) time 129
Solution 2: dynamic programming, bottom-up, 𝑂(𝑛2 ) time 132
Solution 3: dynamic programming, bottom-up, 𝑂(𝑛2 ) time, linear space 133
Unit tests 134
19 Subarray sum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
Clarification questions 137
Solution 1: brute-force, 𝑂(𝑚𝑛) 137
Solution 2: dynamic programming, 𝑂(𝑚 + 𝑛) 137
20 Submatrix sum . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
Clarification questions 139
Solution 1: brute-force, 𝑂(𝑚𝑛2 ) 139
Solution 2: dynamic programming, 𝑂(𝑚 + 𝑛2 ) 140
Unit tests 144
21 Largest square submatrix of ones . . . . . . . . . . . . . . . . . . . . . . . 148
Clarification questions 148
Solution 1: brute-force, 𝑂(𝑛5 ) 148
Solution 2: dynamic programming, 𝑂(𝑛2 ) 150
22 Largest rectangle in skyline . . . . . . . . . . . . . . . . . . . . . . . . . 154
Clarification questions 154
Solution 1: brute-force, 𝑂(𝑛3 ) 154
Solution 2: dynamic programming, 𝑂(𝑛2 ) 155
Solution 3: dynamic programming + stack, 𝑂(𝑛) 156
23 Largest submatrix of ones . . . . . . . . . . . . . . . . . . . . . . . . . . 162
Clarification questions 162
Solution 1: brute-force, 𝑂(𝑛6 ) 162
Solution 2: dynamic programming, 𝑂(𝑛3 ) 163
Solution 3: dynamic programming, 𝑂(𝑛2 ) 166
24 Interleaved strings . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 168
Clarification questions 168
Solution 1: brute-force, 𝑂(2𝑛 ) 168
Solution 2: dynamic programming, 𝑂(𝑛2 ) 172
25 Regular expression matching . . . . . . . . . . . . . . . . . . . . . . . . 174
Clarification questions 174
Solution 1: brute-force, 𝑂(2𝑛 ) 174
Solution 2: dynamic programming, 𝑂(𝑛2 ) 178
Unit tests 180
Contents 5

Preface
Over the last decade, many companies have adopted the FANG-style interview process for
software engineer positions: programming questions that involve an algorithm design step,
and often require competitive programming solving techniques.
The advantages and disadvantages of this style of interview questions are highly debated, and
outside the scope of this book. What is important is that the questions that are asked pose
serious challenges to candidates, thus require thorough preparation.
The class of problems that are by far the most challenging is dynamic programming. This is
due to a combination of dynamic programming being rarely used in day-to-day work, and the
difficulty of finding a solution in a short amount of time, when not having prior experience
with this method.
This book presents 25 dynamic programming problems that are most commonly encoun-
tered in interviews, and several of their variants. For each problem, multiple solutions are
given, including a gradual walkthrough that shows how one may reach the answer. The goal
is not to memorize solutions, but to understand how they work and learn the fundamental
techniques, such that new, previously unseen problems can be solved with ease.
The solutions are very detailed, showing example walkthrougs, verbal explanations of the
solutions, and many diagrams and drawings. These were designed in a way that helps both
verbal and visual learners grasp the material with ease. The code implementation usually
comes last, accompanied by unit tests and complexity/performance analysis.
A particular focus has been put on code clarity and readability: during the interview, we are
expected to write code as we would on the job. This means that the code must be tidy, with
well-named variables, short functions that do one thing, modularity, comments describing
why we do certain things etc. This is, sadly, unlike most other material on dynamic pro-
gramming that one may find online, in competitive programming resources, or even in well-
known algorithm design textbooks. In fact, the poor state of the material on this topic is the
main reason I wrote this book.
I hope that you find this book useful for preparing to get the job you wish for. Whether you
like the book or not, I would appreciate your feedback through a book review.
Good luck with your interviews!
6 Contents

General advice for the interview

Find out in advance what kind of questions will be asked. Usually, they are in one or more
of the following categories: coding, algorithm design (with or without implementation),
domain-specific questions, theoretical questions, behavioral questions, live coding, debug-
ging, one-day assignments or pair programming. You should know what you need to prepare
for.
For programming questions, do not jump directly to writing code, even if the solution looks
obvious. First, ask clarification questions and go over some simple examples, to make sure
you understand the requirements well. Then, you may sketch a solution and discuss it with
the interviewer. Several iterations might be needed in case of correctness or performance
issues. Only once they agree that the solution looks fine, proceed with implementing it.
Treat the interview questions not like problems, but real job assignments. Take them seriously
and solve them thoroughly, like a professional.
Treat your interviewers as colleagues, with whom you must work together to solve the as-
signment. Shift into the mindset that you are already on the same team. Discuss and interact
with them the same way you would with colleagues on the job.
Write tidy, clean code—as much as possible given the time you have. Try to follow typi-
cal coding style guidelines for your language. For Python, you can find good guidelines at
www.python.org/dev/peps/pep-0008 and google.github.io/styleguide/pyguide.html.
Do not forget to ask about the size of the data your code needs to handle—this is important
to determine the time complexity of your solution.
If you cannot find the fastest algorithm needed to solve the problem, propose a slower one.
Sometimes you might get an idea (or a hint from the interviewer) to make it faster once you
write it. But even if you do not, any solution is better than no solution.
Try to be quick in your answer. Interviewers usually plan to ask follow-up questions. If you
do not have sufficient time left for these, your result may be poor, even if you answered the
original question well.
 7

1 The Fibonacci sequence

Return the n-th number in the Fibonacci sequence. The first two numbers in the Fibonacci
sequence are equal to 1; any other number is equal to the sum of the preceding two numbers.
Example: for n = 6, the first 6 numbers of the sequence are [1, 1, 2, 3, 5, 8] so the result
is 8.

Solution 1: brute force, 𝑂(2𝑛 ) time

A straightforward solution is to implement the function recursively:
def fibonacci(n):
if n <= 2:
return 1
return fibonacci(n ­ 1) + fibonacci(n ­ 2)

The above code is correct but too slow due to redundancies. We can see this if we add logging
to the function:
import inspect
def stack_depth():
return len(inspect.getouterframes(inspect.currentframe())) ­ 1

def fibonacci(n):
print("{indent}fibonacci({n}) called".format(
indent=" " * stack_depth(), n=n))
if n <= 2:
return 1
return fibonacci(n ­ 1) + fibonacci(n ­ 2)

fibonacci(6)

We changed the code to print the argument passed to the fibonacci function. The message
is indented by the call stack depth, so that we can see better which function call is causing
which subsequent calls. Running the above code prints:
fibonacci(6) called
fibonacci(5) called
fibonacci(4) called
fibonacci(3) called
fibonacci(2) called
fibonacci(1) called
fibonacci(2) called
fibonacci(3) called
fibonacci(2) called
fibonacci(1) called
fibonacci(4) called
8 1 The Fibonacci sequence

fibonacci(3) called
fibonacci(2) called
fibonacci(1) called
fibonacci(2) called

That’s a lot of calls! If we draw the call graph, we can see that it’s an almost full binary tree:
 9

Notice that the height of the binary tree is n (in this case, 6). The tree is almost full, thus
it has 𝑂(2𝑛 ) nodes. Since each node represends a call of our function, our algorithm has
exponential complexity.

Solution 2: dynamic programming, top-down

We can optimize the previous solution by avoiding redundant computations. These redun-
dancies are visible in the call graph:

• fibonacci(4) is called twice, once by fibonacci(5) and once by fibonacci(6);

• fibonacci(3) is called 3 times;
• fibonacci(2) is called 5 times;
• fibonacci(1) is called 3 times.

It does not make sense to compute, for example, the 4-th Fibonacci number twice, since it
does not change. We should compute it only once and cache the result.

Let’s use a dictionary to store the cache:

fibonacci_cache = {}
def fibonacci(n):
if n <= 2:
return 1
if n not in fibonacci_cache:
fibonacci_cache[n] = fibonacci(n ­ 1) + fibonacci(n ­ 2)
return fibonacci_cache[n]

The call graph of the optimized code looks like this:

Notice how only the first call to fibonacci(n) recurses. All subsequent calls return from
the cache the value that was previously computed.

This implementation has 𝑂(𝑛) time complexity, since exactly one function call is needed to
compute each number in the series.
10 1 The Fibonacci sequence

This strategy of caching the results of subproblems is called dynamic programming.

While the above code is correct, there are some code style issues:

• We introduced the global variable fibonacci_cache; it would be great if we could

avoid global variables, since they impact code readability;
• The code is more complicated than before due to the cache manipulations.

We can avoid adding the global variable by using instead an attribute called cache that is
attached to the function:
def fibonacci(n):
if n <= 2:
return 1
if not hasattr(fibonacci, 'cache'):
fibonacci.cache = {}
if n not in fibonacci.cache:
fibonacci.cache[n] = fibonacci(n ­ 1) + fibonacci(n ­ 2)
return fibonacci.cache[n]

The advantage is that the cache variable is now owned by the function, so no external code
is needed anymore to initialize it. The disadvantage is that the code has become even more
complicated, thus harder to read and modify.

A better approach is to keep the original function simple, and wrap it with a decorator that
performs the caching:
def cached(f):
cache = {}
def worker(*args):
if args not in cache:
cache[args] = f(*args)
return cache[args]
return worker

@cached
def fibonacci(n):
if n <= 2:
return 1
return fibonacci(n ­ 1) + fibonacci(n ­ 2)

The good news is that Python 3 has built-in support for caching decorators, so there is no
need to roll your own:
from functools import lru_cache

@lru_cache(maxsize=None)
def fibonacci(n):
if n <= 2:
 11

return 1
return fibonacci(n ­ 1) + fibonacci(n ­ 2)

By default lru_cache is limited to 128 entries, with least-recently used entries evicted when
the size limit is hit. Passing maxsize=None to lru_cache ensures that there is no memory
limit and all values are cached. In practice, it might be preferrable to set a limit instead of
letting memory usage increase without bounds.

Prefer standard library functionality to rolling your own

Using the standard lru_cache decorator makes the code easier to read, since it has well-
known behavior. The advange over using a custom caching method is that the reader
does not need to spend time to understand its details.

Solution 2: dynamic programming, bottom-up

While computing the Fibonacci sequence recursively is useful for pedagogical reasons, it is
more intuitive to compute it iteratively starting from the smaller numbers, just like a human
would do:
def fibonacci(n):
series = [1, 1]
while len(series) < n:
series.append(series[­1] + series[­2])
return series[­1]

The code has 𝑂(𝑛) time complexity, as well as 𝑂(𝑛) space complexity. In practice the perfor-
mance is better than the recursive implementation, since there is no overhead due to extra
function calls.

The space complexity can be reduced to 𝑂(1) if we notice that we do not need to store the
entire sequence, just the last two numbers:
def fibonacci(n):
previous = 1
current = 1
for i in range(n ­ 2):
next = current + previous
previous, current = current, next
return current

We have written an algorithm that starts from the smallest subproblem (the first two numbers
in the sequence), then expands the solution to reach the original problem (the n-th number
in the sequence). This approach is called bottom-up dynamic programming. By contrast,
the previous approach of solving the problem recursively starting from the top is called top-
down dynamic programming. Both approaches are equally valid; one or the other may be
more intuitive, depending on the problem.
12 1 The Fibonacci sequence

In the rest of the book, we will look at how we can apply dynamic programming to solving
non-trivial problems. In general, we will show both top-down and bottom-up solutions. We
will see that the top-down approach is often easier to understand and implement, however it
offers less optimization opportunities compared to bottom-up.
 13

2 Optimal stock market strategy

When evaluating stock market trading strategies, it is useful to determine the maximum pos-
sible profit that can be made by trading a certain stock. Write an algorithm that, given the
daily price of a stock, computes the maximum profit that can be made by buying and selling
that stock. Assume that you are allowed to own no more than 1 share at any time, and that
you have an unlimited budget.
Example 1: The stock price over several days is [2, 5, 1]. The best strategy is to buy a share
on the first day for price 2, then sell it on the second day for price 5, obtaining a profit of 3.
Example 2: The stock price over several days is [2, 5, 1, 3]. The best strategy is to buy a
share on the first day for price 2, then sell it on the second day for price 5, obtaining a profit
of 3; then buy it again on the third day for price 1, and sell it on the fourth day for price 3,
obtaining an overall profit of 5.

Solution 1: dynamic programming, top-down, 𝑂(𝑛) time

The first idea that comes to mind while approaching this problem is using a state machine.
This is because on any day, our state can be described by:
• whether we own the share or not;
• the amount of money we have.
Between the states of consecutive days, we have only four possible transitions:
• If at the end of the previous day we did not own the share:
• buying the stock, so we now own it, but we have less money;
• avoiding the stock, so we keep our money unchanged;
• If at the end of the previous day we owned the share:
• selling the stock, so we no longer own it, and have more money;
• holding the stock, so we keep both the stock and our money unchanged.

Knowing this, we can model the entire problem using a state machine. In our initial state,
14 2 Optimal stock market strategy

we have some amount of cash and no shares. In the final state, we have some other amount
of cash (ideally higher), and no shares. In between, we have state transitions:

Solving the original problem can be reduced to finding a chain of transitions through this
state machine, that yields the maximum profit.
Notice how our state during any day only depends on the state from the previous day. This is
excellent: we can express our problem using a simple recurrence relation, just as we did for
the Fibonacci sequence problem.
The structure of the solution using a recursive algorithm looks like this:
def max_profit(daily_price):
def get_best_profit(day, have_stock):
"""
Returns the best profit that can be obtained by the end of the day.
At the end of the day:
* if have_stock is True, the trader must own the stock;
* if have_stock is False, the trader must not own the stock.
"""
# TODO ...
# Final state: end of last day, no shares owned.
last_day = len(daily_price) ­ 1
no_stock = False
return get_best_profit(last_day, no_stock)

Note that we defined a helper function get_best_profit which takes as parameters the
identifiers of a state: the day number and whether we own the stock or not at the end of the
day. We use get_best_profit to compute the profit for a specific state in the state machine.
Let’s now implement the helper using a recurrence relation. We need to consider the previous
states that can transition into the current state, and choose the best one:
@lru_cache(maxsize=None)
def get_best_profit(day, have_stock):
"""
 15

Returns the best profit that can be obtained by the end of the day.
At the end of the day:
* if have_stock is True, the trader must own the stock;
* if have_stock is False, the trader must not own the stock.
"""
if day < 0:
if not have_stock:
# Initial state: no stock and no profit.
return 0
else:
# We are not allowed to have initial stock.
# Add a very large penalty to eliminate this option.
return ­float('inf')
price = daily_price[day]
if have_stock:
# We can reach this state by buying or holding.
strategy_buy = get_best_profit(day ­ 1, False) ­ price
strategy_hold = get_best_profit(day ­ 1, True)
return max(strategy_buy, strategy_hold)
else:
# We can reach this state by selling or avoiding.
strategy_sell = get_best_profit(day ­ 1, True) + price
strategy_avoid = get_best_profit(day ­ 1, False)
return max(strategy_sell, strategy_avoid)

The first part of the helper implements the termination condition, i.e. handling the initial
state, while the second part implements the recurrence. To simplify the logic of the recur-
rence we allow selling on any day including the first, but we ensure that selling on the first
day would yield a negative profit, so it’s an option that cannot be chosen as optimal.

Handle the termination condition early

It is preferrable to handle the termination condition of a recursive function in a single
place, as opposed to wrapping each call of the function with a check like if day < 0
.... Handling it early simplifies greatly the logic and makes the code easier to read.

Both the time and space complexity of this solution are 𝑂(𝑛). Note that it is important to
cache the results of the helper function, otherwise the time complexity becomes exponential
instead of linear.

Solution 2: dynamic programming, bottom-up, 𝑂(𝑛) time

Once we have implemented the top-down solution, it is easy to rewrite it as bottom-up: we
start from the initial state, and iterate day by day until we reach the final state:
16 2 Optimal stock market strategy

def max_profit(daily_price):
# Initial state: start from a reference cash amount.
# It can be any value.
# We use 0 and allow our cash to go below 0 if we need to buy a share.
cash_not_owning_share = 0
# High penalty for owning a stock initially:
# ensures this option is never chosen.
cash_owning_share = ­float('inf')
for price in daily_price:
# Transitions to the current day, owning the stock:
strategy_buy = cash_not_owning_share ­ price
strategy_hold = cash_owning_share
# Transitions to the current day, not owning the stock:
strategy_sell = cash_owning_share + price
strategy_avoid = cash_not_owning_share
# Compute the new states.
cash_owning_share = max(strategy_buy, strategy_hold)
cash_not_owning_share = max(strategy_sell, strategy_avoid)
# The profit is the final cash amount, since we start from
# a reference of 0.
return cash_not_owning_share

At each step, we only need to store the profit corresponding to the two states of that day. This
is due to the state machine not having any transitions between non-consecutive days: we
could say that at any time, the state machine does not “remember” anything from the days
before yesterday.

The time complexity is 𝑂(𝑛), but the space complexity has been reduced to 𝑂(1), since we
only need to store the result for the previous day.

Bottom-up solutions often have smaller space complexity than top-down

It is very common (with some exceptions) that bottom-up solutions have lower memory
requirements than top-down. This is due to the ability to control precisely what data we
store and what data we discard: instead of a LRU cache policy, we can keep only the data
we need. In addition, they do not suffer from the overhead of storing stack frames due
to recursion, which is a hidden cost of the top-down solutions.

Variation: limited investment budget

In a variation of the problem, the investment budget is limited: we start with a fixed amount
of money, and we are not allowed to buy a share if we cannot afford it (we cannot borrow
money).

We can adjust the solution for this constraint:

 17

def max_profit(daily_price, budget):

# Initial state.
cash_not_owning_share = budget
# High penalty for owning a stock initially:
# ensures this option is never chosen.
cash_owning_share = ­float('inf')
for price in daily_price:
# Transitions to the current day, owning the stock:
strategy_buy = cash_not_owning_share ­ price
strategy_hold = cash_owning_share
# Transitions to the current day, not owning the stock:
strategy_sell = cash_owning_share + price
strategy_avoid = cash_not_owning_share
# Compute the new states.
cash_owning_share = max(strategy_buy, strategy_hold)
if cash_owning_share < 0:
# We cannot afford to buy the share at this time.
# Add a high penalty to ensure we never choose this option.
cash_owning_share = ­float('inf')
cash_not_owning_share = max(strategy_sell, strategy_avoid)
return cash_not_owning_share ­ budget

Any time the optimal cash amount in a given state goes below zero, we replace it with negative
infinity. This ensures that this path through the state machine will not be chosen. We only
have to do this for the states where we own stock. In the states where we do not own stock,
our cash amount never decreases from the previous day, so this check is not needed.

Expect follow-up questions

One of the most common mistakes candidates make is to assume that they have to solve
a single problem during a time slot of the interview. Taking too long to solve it does
not leave any time for follow-up questions, which puts the candidate at a disadvantage
compared to others. An old Italian proverb applies here: perfect is the enemy of good. Do
not get lost in too many details trying to make your solution perfect; reach an agreement
with your interviewer on when it is good enough, so that you have time to take 1-2
follow-up questions such as this one.

Variation: limited number of transactions

In anover variation of the problem, the total number of transactions that can be performed
is bounded: the stock can only be sold up to a certain number of times tx_limit.
In this variation, the state machine needs to be adjusted so that it keeps track of multiple
pieces of information:
• whether we own the stock or not at the end of the day;
18 2 Optimal stock market strategy

• how many times we have sold the stock so far.

Instead of having only 2 states each day (for owning or not owning the stock), we now have
up to 2 * tx_limit depending on how many times we have sold, per day. For each of these
states, we have to compute the best amount of money we can earn.
The transitions between the states need to take into account the operation (buying, holding,
selling, avoiding) and whether it leads to the next day state with the same transaction count
or one higher.
We can write the following implementation:
def max_profit(daily_price, tx_limit):
# cash_not_owning_share[k] = amount of cash at the end of the day,
# if we do not own the share, and we have sold k times so far.
# Initially we have sold 0 times and we start from a reference
# budget of 0. Any other state is invalid.
cash_not_owning_share = [­float('inf')] * (tx_limit + 1)
cash_not_owning_share[0] = 0
# cash_owning_share[k] = amount of cash at the end of the day,
# if we own the share, and we have sold k times so far.
# Initially we do not own any stock, so set the state to invalid.
cash_owning_share = [­float('inf')] * (tx_limit + 1)
for price in daily_price:
# Initialize the next day's states with ­Infinity,
# then update them with the best possible transition.
cash_not_owning_share_next = [­float('inf')] * (tx_limit + 1)
cash_owning_share_next = [­float('inf')] * (tx_limit + 1)
for prev_tx_count in range(tx_limit):
# Transition to the current day, owning the stock:
strategy_buy = cash_not_owning_share[prev_tx_count] ­ price
strategy_hold = cash_owning_share[prev_tx_count]
# Transitions to the current day, not owning the stock:
strategy_sell = cash_owning_share[prev_tx_count] + price
strategy_avoid = cash_not_owning_share[prev_tx_count]
# Compute the new states.
if prev_tx_count < tx_limit:
# Selling increases the tx_count by 1.
cash_not_owning_share_next[prev_tx_count + 1] = max(
cash_not_owning_share_next[prev_tx_count + 1],
strategy_sell)
# All other transitions keep tx_count the same.
cash_not_owning_share_next[prev_tx_count] = max(
cash_not_owning_share_next[prev_tx_count],
strategy_avoid)
cash_owning_share_next[prev_tx_count] = max(
cash_owning_share_next[prev_tx_count],
 19

strategy_buy,
strategy_hold)
cash_not_owning_share = cash_not_owning_share_next
cash_owning_share = cash_owning_share_next
# We have multiple final states, depending on how many times we sold.
# The transaction limit may not have been reached.
# Choose the most profitable final state.
return max(cash_not_owning_share)

Master state machines

While you are reading this book, take your time to understand well how to model prob-
lems using state machines. Almost all dynamic programming problems can be solved
this way. This skill is useful not just for interviews, but also in general in your software
engineer career.
20 3 Change-making

3 Change-making

Given a money amount and a list of coin denominations, provide the combination of coins
adding up to that amount, that uses the fewest coins.

Example 1: Pay amount 9 using coin denominations [1, 2, 5]. The combination having
the fewest coins is [5, 2, 2]. A suboptimal combination is [5, 1, 1, 1, 1]: it adds up
to 9, but is using 5 coins instead of 3, thus it cannot be the solution.

Example 2: Pay amount 12 using coin denominations [1, 6, 10]. The combination having
the fewest coins is [6, 6]. A suboptimal combination is [10, 1, 1].

Clarification questions

Q: What result should be returned for total amount 0?

A: The empty list [].

Q: Is it possible that the amount cannot be paid with the given coins?
A: Yes. For example, 5 cannot be paid with coins [2, 4]. In such a situation, return None.

Solution 1: dynamic programming, top-down, 𝑂(𝑛𝑣) time

We can formulate a top-down dynamic programming solution if we model the problem as

a recurrence. For any non-zero amount that has to be paid optimally using the given coins,
we know that at least one of the coins has to be used. The problem is that we do not know
which one. If we knew, we could use that as a starting point to reach a subproblem: we could
subtract its value from the amount, then solve an instance of the problem for the remaining,
smaller amount. We would continue in this way until the remaining amount becomes 0.

However, we do not know which coin to choose first optimally. In this situation, we have
no other choice but try all possible options in brute-force style. For each coin, we subtract
its value from the amount, then solve by recurrence the subproblem—this leads to a candi-
date solution for each choice of the first coin. Once we are done, we compare the candidate
solutions and choose the one using the fewest coins.

Here is an example of how we would form the optimal change for amount 9, using coins [1,
2, 5]. We represent each amount as a node in a tree. Whenever we subtract a coin value
from that amount, we add an edge to a new node with a smaller value. Please mind that the
actual solution does not use trees, at least not explicitly: they are shown here only for clarity.
 21

This diagram shows that for value 9, we have three options for choosing the first coin:

• We choose coin 1. We now have to solve the subproblem for value 9 − 1 = 8. Suppose
its optimal result is [5, 2, 1]. Then we add coin 1 to create the candidate solution
[5, 2, 1, 1] for 9.
• We choose coin 2. We now have to solve the subproblem for value 9 − 2 = 7. Suppose
the optimal result is [5, 2]. We add to it coin 2 to create the candidate solution [5,
2, 2] for 9.
• We choose coin 5. We now have to solve the subproblem for value 9 − 5 = 4. The
optimal result is [2, 2]. We add to it coin 5 to create the candidate solution [5, 2,
2] for 9.

Now that we are done solving the subproblems, we compare the candidate solutions and
choose the one using the fewest coins: [5, 2, 2].

For solving the subproblems, we use the same procedure. The only difference is that we
need to pay attention to two edge cases: the terminating condition (reaching amount 0), and
avoiding choices where we are paying too much (reaching negative amounts). To understand
these better, let’s take a look at the subproblems:
22 3 Change-making

Drawing the subproblems helps us see clearly the edge cases:

• When the amount becomes 0, we have to stop the iteration, since the subproblem is
solved and there is nothing left to be paid. We can see the 0 node in several of the
subproblem trees.
• When the amount goes below zero, the given amount cannot be formed with that
coin. For example, trying to pay amount 3 using coin 5 would require solving the
subproblem for amount -2, which does not make sense.
In addition to that, we can also notice that there are many redundancies among the sub-
problems. This is very important, as it affects the performance of the algorithm. We origi-
nally thought about solving the problem using brute force, which results in a slow algorithm:
𝑂(𝑛𝑣 ), where 𝑛 is the number of coins and 𝑣 is the value of the amount we have to pay. In other
words, the brute-force solution has exponential complexity, with very poor performance.
However, now that we know that there are redundancies among the subproblems, we can
cache their results to reduce the complexity to only 𝑂(𝑛𝑣): in each step we must try 𝑛 coins,
and we have up to 𝑣 steps (in the worst case, we pay 𝑣 with 𝑣 coins of value 1). This result is
great: we reduced the time complexity from exponential to polynomial!
We are now ready to write a first implementation of the recurrence, without caching (the
brute-force, exponential complexity solution). This is because we want to focus on the logic
of the recurrence, without distractions; we will add caching afterwards.
def make_change(coins, amount):
"""
Given a list of coin values, and an amount to be paid,
returns the shortest list of coins that add up to that amount.
If the amount to be paid is zero, the empty list is returned.
 23

If the amount cannot be paid using the coins, None is returned.

"""
# Handle payment of amount zero.
if not amount:
return []
# Negative amounts cannot be paid.
if amount < 0:
return None
optimal_result = None
# Consider all the possible ways to choose the last coin.
for coin in coins:
# Solve a subproblem for the rest of the amount.
partial_result = make_change(coins, amount ­ coin)
# Skip this coin if the payment failed:
if partial_result is None:
continue
candidate = partial_result + [coin]
# Check if the candidate solution is better than the
# optimal solution known so far, and update it if needed.
if (optimal_result is None or
len(candidate) < len(optimal_result)):
optimal_result = candidate
return optimal_result

This algorithm implements the recurrence relation as explained above. Notice how we handle
the edge cases at the beginning of the function, before making any recursive calls, to avoid
infinite recursion and to keep the recursion logic as simple as possible.

Handle and eliminate edge cases early

Generally, it is preferrable to get edge cases out of the way as soon as possible, so that the
rest of the implementation is kept simple. This improves substantially the readability of
the code.

This implementation has exponential time complexity, since we have not implemented
caching yet. Let’s do that now.
Unfortunately, if we try to add caching simply adding the lru_cache decorator, we will have
a nasty surprise:
from functools import lru_cache

@lru_cache(maxsize=None)
def make_change(coins, amount):
...

This code throws the exception: TypeError: unhashable type: 'list'. This is caused by
24 3 Change-making

the inability to cache the argument coins. As a list, it is mutable, and the lru_cache deco-
rator rejects it. The decorator supports caching only arguments with immutable types, such
as numbers, strings or tuples. This is for a very good reason: to prevent bugs in case mutable
arguments are changed later (in case of lists, via append, del or changing its elements), which
would require invalidating the cache.

A joke circulating in software engineering circles says that there are only two hard problems
in computer science: cache invalidation, naming things, and off-by-one errors. To address
the former, the design of the lru_cache decorator takes the easy way out: it avoids having to
implement cache invalidation at all by only allowing immutable arguments.

Still, we need to add caching one way or another. We can work around the lru_cache limi-
tation if we notice that we do not actually need to cache the coins list—that is shared among
all subproblems. We only need to pass the remaining amount to be paid. So we write a helper
function that solves the subproblem, taking as argument only the amount. The coin list is
shared between invocations.

One way to implement this is to make the helper function nested inside the make_change
function, so that it has access to the coins argument of the outer function:
def make_change(coins, amount):
@lru_cache(maxsize=None)
def helper(amount):
...
return helper(amount)

Another way is to transform the make_change function into a method of a class, that stores
the list of coins in a class member. The helper could then be written as another method of
the class, ideally a private one. I think adding classes is overkill for what we have to do, so we
will not discuss this approach.

Here is the full solution that uses nested functions:

def make_change(coins, amount):
"""
Given a list of coin values, and an amount to be paid,
returns the shortest list of coins that add up to that amount.
If the amount to be paid is zero, the empty list is returned.
If the amount cannot be paid using the coins, None is returned.
"""
@lru_cache(maxsize=None)
def helper(amount):
# Handle payment of amount zero.
if not amount:
return []
# Negative amounts cannot be paid.
if amount < 0:
return None
 25

optimal_result = None
# Consider all the possible ways to choose the last coin.
for coin in coins:
# Solve a subproblem for the rest of the amount.
partial_result = helper(amount ­ coin)
# Skip this coin if the payment failed:
if partial_result is None:
continue
candidate = partial_result + [coin]
# Check if the candidate solution is better than the
# optimal solution known so far, and update it if needed.
if (optimal_result is None or
len(candidate) < len(optimal_result)):
optimal_result = candidate
return optimal_result
return helper(amount)

How many comments should we write?

Well-written comments improve code readability, however there is a trade-off: too many
comments can be distracting, are a maintainability burden, and a sign that the code
might not be clear enough. However, for interviews, I prefer leaning towards more ver-
bosity, since we normally do not have time to refactor the code to perfection. Comments
can compensate for that.
A good rule of thumb is to use comments to explain why the code is doing something.
If you feel the need to explain what it is doing, it might be time to refactor that piece of
code into an appropriately-named function. If you do not have time to refactor during
the interview, you can add a comment like: “TODO: refactor into helper function.”

Solution 2: dynamic programming, bottom-up, 𝑂(𝑛𝑣) time

Once we have implemented the top-down solution, we can rewrite it as bottom-up: we start
from the amount 0, and keep adding coins in all possible ways until reaching the amount to
be paid:
def make_change(coins, amount):
# solutions[k] = optimal list of coins that add up to k,
# or None if no solution is known for k
solutions = [None] * (amount + 1)
# Initial state: no coins needed to pay amount 0
solutions[0] = []
# Starting from amount 0, find ways to pay higher amounts
# by adding coins.
paid = 0
while paid < amount:
26 3 Change-making

if solutions[paid] is not None:

for coin in coins:
next_paid = paid + coin
if next_paid > amount:
continue
if (solutions[next_paid] is None or
len(solutions[next_paid]) >
len(solutions[paid]) + 1):
solutions[next_paid] = solutions[paid] + [coin]
paid += 1
return solutions[amount]

This solution is iterative, which is an advantage compared to the top-down solution, since it
avoids the overheads of recursive calls. However, for certain denominations, it wastes time
by increasing the amount very slowly, in steps of 1 unit. For example, if coins = [100,
200, 500] (suppose we use bills), it does not make sense to advance in steps of 1.

In addition, a lot of space is wasted for amounts that cannot be paid. Let’s see if we can come
up with a better solution.

Solution 3: dynamic programming + BFS, bottom-up, 𝑂(𝑛𝑣) time

We can optimize the bottom-up solution by using a queue of amounts to be handled, instead
of an array. This helps in two ways: Firstly, it allows us to skip amounts that cannot be formed,
thus reducing execution time. Secondly, by not having to store amounts that cannot be paid,
memory usage is reduced.
Let’s implement it:
def simplest_change(coins, amount):
# solutions[k] = optimal list of coins that add up to amount k
# Amounts that cannot be paid are not stored.
solutions = {0: []}
# List of amounts that can be paid but have not been handled yet.
amounts_to_be_handled = collections.deque([0])
# Iterate over amounts in breadth­first order.
while amounts_to_be_handled:
paid = amounts_to_be_handled.popleft()
solution = solutions[paid]
if paid == amount:
# Due to BFS order, the first path reaching the
# required amount is the one using the smallest number
# of coins. Thus it is the optimal solution.
return solution
for coin in coins:
next_paid = paid + coin
if next_paid > amount:
 27

# We can safely ignore amounts overshooting the

# target amount to be paid.
continue
if next_paid not in solutions:
solutions[next_paid] = solution + [coin]
amounts_to_be_handled.append(next_paid)
# No combination of coins could match the required amount,
# thus it cannot be paid.
return None

Notice how we are treating the (sub)problem space as a graph, which is explored in breadth-
first order (BFS). We start from the subproblem of forming the amount 0. From there, we
keep expanding using all the possible coin choices until we reach the required amount.

Let’s look at an example showing how the problem space exploration works for paying
amount 9 with coins [1, 2, 5]. We start with amount 0 and explore by adding a coin in all
possible ways. Here is the first level of the problem space graph:

The first level contains all amounts that can be paid using a single coin. After this step, we
have [1, 2, 5] in our BFS queue, which is exactly the list of nodes on the first level—hence
the name of breadth-first search.

To fill in the second level of the problem space graph, we continue the exploration a step
further for amounts 1, 2 and 5:
28 3 Change-making

The second level contains all possible amounts that can be paid with 2 coins. After this step,
we have [3, 6, 4, 7] in our BFS queue.

Notice that we discarded nodes corresponding to already known amounts, since these can
be paid with a similar or better solution (fewer coins). We have also discarded amounts that
exceed the value we have to pay (such as 10). This ensures that the graph size is bounded and
that it contains only valid/optimal nodes.

We still have not found a way to pay our target amount, 9. Let’s explore further, adding the
third level of the problem space graph:

Note that as we reached the target amount 9, we stopped drawing the rest of the level. As
it is on the third level of the tree, the amount can be paid with 3 coins. The combination is
 29

2, 2 and 5, which can be found by walking the path from 0 to 9. This is the solution to the
problem.
Note that the exploration order was important: the breadth-first order guarantees that each
time we reach a new amount, the path we followed is the shortest possible in terms of num-
ber of coins used. Had we used instead another graph search algorithm, such as depth-first
search, the solution might not have been optimal.

Variant: count the number of ways to pay (permutations)

Given a money amount and a list of coin denominations, count in how many ways it is pos-
sible to pay that amount. The order matters, i.e. paying with a coin of 1 followed by a coin of
2 is considered distinct from paying with a coin of 2 followed by a coin of 1.
Example: To pay amount 3 with coins [1, 2], there are 3 possible ways: 1 + 2, 2 + 1 and
1 + 1 + 1.

Solution: dynamic-programming, top-down, 𝑂(𝑛𝑣)

Let’s analyze a slightly more complicated example: paying amount 6 with coins [1, 2, 5].
Here are all the possible ways to pay the amount:
• 6 = 5 + 1
• 6 = 1 + 5
• 6 = 2 + 2 + 2
• 6 = 2 + 2 + 1 + 1
• 6 = 2 + 1 + 2 + 1
• 6 = 2 + 1 + 1 + 2
• 6 = 1 + 2 + 2 + 1
• 6 = 1 + 2 + 1 + 2
• 6 = 1 + 1 + 2 + 2
• 6 = 2 + 1 + 1 + 1 + 1
• 6 = 1 + 2 + 1 + 1 + 1
• 6 = 1 + 1 + 2 + 1 + 1
• 6 = 1 + 1 + 1 + 2 + 1
• 6 = 1 + 1 + 1 + 1 + 2
• 6 = 1 + 1 + 1 + 1 + 1 + 1

From this list we do not see any particular rule, other than enumerating all the permutations
of the combinations of coins that add up to 6 (1 + 5, 2 + 2 + 2, 2 + 2 + 1 + 1, 2 + 1 +
1 + 1 + 1 and 1 + 1 + 1 + 1 + 1 +1). This is not very helpful.

Let’s list the payments again but sorted in lexicographic order:

• 6 = 1 + 1 + 1 + 1 + 1 + 1
• 6 = 1 + 1 + 1 + 1 + 2
• 6 = 1 + 1 + 1 + 2 + 1
• 6 = 1 + 1 + 2 + 1 + 1
• 6 = 1 + 1 + 2 + 2
Another Random Scribd Document
with Unrelated Content
asiata tehdä, niin menee häntä hautuumaalle. Siellä ne kulkevat
parittain ja sipattelevat omia sipatuksiaan. Siitä se monta kertaa
vanhan haudan päältä alkaa tavallaan kuin uusi elämä.

Ukkojen kesken tuntui olevan puheenaineena se tavallinen

kysymys vuodentulon toiveista. Mistäpä se muusta tämä maalainen
osaisi ensi hätään jutella? Se kun on maalaisen elämässä sillä
tavalla, jotta jos ei jalka kapsa, niin ei suu napsa, ja niistäpähän sitä
tietysti omista aikaansaannoksistaan ja vaivannäöistään ensiksi
haastelee vähän itsekukin. Sittenkun rovehtuu puheelle ja
kielenkanta hiukan vertyy, niin kyllähän sitä sitten tulee muutakin.

Kun siinä isäntien piirissä oli päästy tästä vuodentulo- ja

heinänteko-asiasta, niin jo kysyä säväytti joku Sukslevän Tuavetilta,
jotta:

— Joko s'oon nyt se kupernyörj eli muu muaherra nähnä sen

sinum punajsem porttis?

Tuavetti ei ollut toppanaankaan, vaikka hän kyllä huomasi, että

toisen kysymykseen kätkeytyi hiukan ivaa. Kysyjä mikä lie ollut
airakselankyläläinen, joka ei ollut kokolla silloin juhannusaattona.
Taitaa vaan juria sitä itseään, kun ei hänen korpikyliään kupernyöri
kuitenkaan kule. Näkyy levinneen tieto, kun tuli siellä kokolla
sanotuksi; se oli sen viinan hyväkkään ansiota. Mutta mitäpähän
tässä jokaisen syrjäkyläläisen puheista? Jos niitä kaikkia rupeaisi
peräämään, niin ei muuhun kerkiäisikään. Vastasi sentään Tuavetti
airakselankyläläiselle yksikantaan:

— Eij jou nähnä, mut näätetää! Sinulla tuot'ei taitasj olla

näättämistäkääm muuta ku' ihtes ja sikopahnasj, vuan se ei kuulu
teä kupernyörj olovan sikkoi' ystävä.
 Se juttu loppui siihen. Airakselankyläläisellä ei tuntunut olevan
halua jatkaa keskustelua tästä aineesta. Mitään välien katkeamista ei
tämä pieni kahnaus toki merkinnyt. Se on näet tällä puolen
maailmaa semmoinen tapa, että sanaan vastataan sanalla, eikä sana
naarmua tee.

Siinä käpsehti Muuraismäen Mikkokin miesten joukossa, ja toiset

kyselivät häneltä, miten ovat ne separaattoritutkimukset edistyneet.
Mitenkäpähän ne. Mikko sanoi koettaneensa nyt tuumia, miten saisi
heinistä suoraan maitoa lehmän lävitse käyttämättä. Jos sen keksisi,
niin saattaisi melko lailla säästää aikaa ja vaivoja. Ei tarvitsisi pitää
kallista karjaa, eikä touhuta sen kanssa. Joutaisi paremmin muihin
hommiin, kun se maitotalous yksinkertaistuisi. No, ne nyt olivat sen
Mikon, ainaisen irvileuvan, puheita, joita se aina joukossa lateli.

Sitten lähti ukkojen parvi kirkkorantaan. Kesäisinä sunnuntaina oli

tapana käydä rannassa katsomassa, ketä sieltä oikein tulee
kirkkoveneillä. Oli vielä hyvää aikaa. Kunhan papinkellojen soidessa
lähtee nousemaan kirkkomäkeä ylös rannasta, niin hyvin ennättää
kirkonmenojen alkuun, ja alkuunhan sitä on ennätettävä näitten
ripille kirjoittautuneitten, mitenkäs muuten. Vaikka monta kertaa
tavallisina pyhinä on juostu vaan kuuluutukset kuulemaan, niin ei
sitä rippilapsi saa semmoista peliä pitää sen on istuttava kirkossa
koko toimituksen ajan.

Siinä juuri rantatielle käännyttäessä tulla hivotti mies kahden

pyörän päällä kunnantuvalta päin pienen pappilan sivuitse.

— No, elähäm mitä, joko nyt paholaenen kirkkomaille työnnäksen!

—huudahti Kolomkannan Karhunen, — vai kahtooko minun silimänj
vikkaa? Vilikajskoopaham muuttiiv vieraammiehem puolesta!
 Sukslevän Tuavetti ja jotkut muut, joitten talot sijaitsivat maantien
varrella, nauraa päräyttivät.

— Kyllä sen näkköö, jotta tua kolomkantalainen on korvesta, kun

nei tunne polokupyöree. Meillä päin nuit' on kun kärpäjsijä, —
kehaisi Tuavetti.

— Vai semmojnen! No se tule ja puserra, kaikkeen se tuo rymä

immeiset lapser riivoo, määppäs neät mokomav vehkeen selekää ja
ala männä luirottoo! Minä luulij, jotta s'oon se ite peämestarj, taikka
on siitä jokkuu lähtennä sillä separatierillä ajamaa… Vai polokupyörä,
no elähäm mittää!

Semmoisia se kolomkantalainen päivitteli. Ajaja oli sama opettaja,

joka jo oli kerinnyt käydä monessa maantienvarren talossa, niin että
hänet kerran pyörineen nähneet olivat jo olevinaan hyvinkin viisaita
tämän rakkineen päälle.

Mutta odottipa ihme Sukslevän Tuavettiakin ja muita, jotka olivat

niin välinpitämättömiä polkupyörän suhteen. Olivat kerinneet siinä
rannassa kätellä Kutan ja Virmaan rantalaiset, jotka suurilla,
monihankaisilla kirkkoveneillään olivat saapuneet rantaan. Oli istuttu
siinä mättäällekin ja pistetty kessuja piippuun papinkelloja
odotellessa, kun se alkoi näkyä se ihme.

Lehmisalmelta päin rupesi kuulumaan kummaa uhkamista ja

puhkamista, vähän niinkuin hevosen tuhritusta, mutta paljon
kovempaa. Se kuului hyvän aikaa se puhke, ja sitten vääntäytyi
Lehmisalmeen valkoinen möhkäle, hiukan niinkuin venekin näköjään,
mutta paljon suurempi ja korkeampi kookastakin kirkkovenettä. Siinä
oli oikein kattokin ja pyöreä piippu kuin savutuvan lakeisen päällä, ja
siitä piipusta pussahteli yhtämittaa savua.
 — No nyt se lykkäsj! — äsähti Kolomkannan Karhunen, — tänä
päevänähän taetaa olla koko helevetiv valtakunta liikkeellä.
Selitäppäs nyt, Tuavetti, mikä pyörä se täm' on. Onko näetäi
Sukslevässä kunj kärpäsijä?

Mutta nyt oli Tuavettikin ymmällä. Eipä ollut käynyt Sukslevässä

tällaisia, ei ollut. Kyllä tältä Tuavetiltakin vastaus läksi tavallisesti
työntämättä, varsinkin kun noin suoraan kysyttiin, mutta eipäs nyt
tullut selitystä.

Sillä aikaa tuli tämä outo otus lähemmäksi. Sillä oli kupeillaan
jotkin kummalliset laitteet, jotka ruiskivat vettä ja pitivät sen täytistä
lotinaa ja litkutusta.

— Tua eij jou kuvan tulija, mikä liek kehnoj mualimal lopu' enteitä!
— päätteli edelleen Karhunen, joka oli niitä paikallaanpysyjiä,
korpeen syntyneitä ja siellä kasvaneita.

Mutta olihan joukossa paljon kaupungissa käyneitä, ja siellä

höyrylaivoja enemmältäkin nähneitä, ja nämä heti käsittivät, mikä
tämä Karhusen mielestä sellainen hirmulaitos oli. Kutan ja Virmaan
rantalaiset olivat myöskin nähneet tämän saman laivan sätkyttelevän
heidän vesillään. Ne olivatkin niitä selänrantalaisia, niillehän nuo
pistouvattanee laivat ja muut hörötykset, Hirvijärvellä ja Talluksella
kuletaan vaan näillä vanhoilla koetelluilla vihtahanka-veneillä.

Hööpel-Aapeli, vanha rahtimies ja kaupunginkävijä, joka väitti

olleensa Turkin sodassakin, vaikkei sitä täällä pitäjässä oikein
tahdottu uskoa, kun se Aapeli oli vähän semmoinen hökläys
miehekseen, riensi selittämään, että ei tämä mikään helvetin masiina
ole, vaan höyrylaiva, semmoinen siipiniekka rustinki, jonka Kourun
rautatehtaan herrat ovat tilanneet malmia vedättämään, jotta ettekö
te sitä tiedä, onhan tuosta puhe kulkenut kautta pitäjän. Ja ensi
kesän nimissä kuuluu tulevan uusi laiva, oikein rupelilla käypä.
Niitähän Kallavedellä mennä luihottaa kuin muita veneitä ikään.
Siellä jo kohta pääsee joka lahden pohjukkaan laivalla.

— Kiärmellahen Nieminennii Muaningalta neät kehuj, jotta höörällä

sitä meijänniir rantaaj jo ajetaa', eikä millää kepuljpelillä, — lopetti
Aapeli selityksensä.

Se toi keihäslahtelaisia ja koululaisia heinäripille, tämä uusi laiva.

Rantaan kertyneitten joukossa oli paljon sellaisia, jotka eivät ennen
koskaan olleet nähneet höyrylaivaa; joko eivät olleet milloinkaan
käyneet viiden peninkulman päässä olevassa kaupungissa, taikka
sitten olivat siellä olleet vaan markkinoilla, jotka molemmat, sekä
tammi- että maalismarkkinat, sattuivat jäitten aikaan. Tämä oli
vanhanaikainen siipilaiva, mistä lienevät Kourun ruukin herrat
sellaisen löytäneetkin ja tänne markkulaisten kummaksi hilanneet?
Kolopuksen ukko-Jahvetti ei malttanut olla ihmettelemättä tätä
nykyajan menoa:

— Tuas som mullaej jo toenej jalaka haavassa ja toeneh haavam

partaalla, vua' eikö neät näättele tua mualima vielä nuita kummijaa.
Sitä alakaa olla tätä masjsiinoo jo vaikka minkälaista, minkä neät se
saparotyörjrii, maetomasjsiina, mikä tuo liek, ja siittä ne
polokupyörät ja muut lekkeet, ja eikös neät pitännä ennen
kuolemoosa nähä vielä tuammojnennii vesjmasjsiina. No, jottae' se
joutavalla tietättää, minkä niilläeh herrojlla!… Ja sill' or ryökäleellä,
em paremmin sano, rattaat kuppeella kunj Savkoskem myllyllä.
Suahhan nähä, vieläkö tuo mitä näättelöö, ennenku' tua toinenniij
jalaka haataam puttoo?
 Hööpel-Aapeli, joka viimeksi oli käynyt kaupungissa, ryhtyi
hätiköivällä tavallaan selittämään ukoille, että kyllä niitä on vielä
suurempiakin kummia tulossa: Kuopioon näet on valmistumassa
rautatie, ihan pitäisi näihin aikoihin rautahevon porhaltaa kaupungin
asemalle. Se se onkin eri sätös, se juna.

— Ettäkös työ ou lehestä lukenna, jotta tulloo, tulloo raatatie

Kuopijoov valamiiks iham pijan? — höplötti Aapeli hätäistä
höplötystään.

Ukot katsoivat Aapeliin vähän niinkuin syrjäsilmällä.

— Lietkö tuota itekkääl lukenna? Eihän nuita taeja lehtiä tulla

tännem meijäm pitäjääm muille kuv virkamiehille, ruukih herrojlle ja
pappiloillej' ja tulenoonko tuolle Ilopuro' ukolle, se ku' on niitä
kunnam miehiä ja aena siitä kaikellaesesta ejistyksestä ja
valistuksesta puasoo? Vuan sinä kun siellä kaapunnissa aina puurrat,
niil liet häntä siellä kuullu ja nyt meinoot sittä viisaana tiällä meijän
keskuuvessa essiintyvä… Vaikka kyllä kaeketi ne tällä mänöllä tulloo
mitkä kommervenkit hyvviisä, alakaa tua jo olla ihav vihojvviimestä
toohakkata. Jos sitä vuan tällä laella männä tuojataan, niin tämä
entine' elämä luokkootuu kokonaam poikkeej ja kaekki ruppee
käämääm masjsiinalla.

Kolopuksen ukko se edelleen tällaisia haasteli. Taisi osata sanoa

ukko-Jahvetti yleisen mielipiteen, koskapa muilla ei ollut halua
jatkaa. Joku ihmettelyn huudahdus vieläkin miesjoukosta kuului,
kunnes lopulta mentiin laivaa lähemmältä katselemaan. Mikäs oli
mennessäkään, kun kapteenina oli kaikkien yhteinen tuttu, pitkä
Pekka Jauhiainen, vanha Kourun asukas ja tukkijunnari. Pekka
näytteli kaikki paikat ukoille ja selitteli laivan rustinkeja.
Päivittelyähän siitä riitti kotvaksi aikaa, mutta se tämä ihminen tottuu
niin pian kaikkeen, eivätkä ennakkoluulot varsinkaan tämän puolen
kansan keskuudessa ole koskaan olleet niin mahdottoman syvässä.
Kun Pekka Jauhiainen oli aikansa kehua retostanut kojeensa hyviä
puolia, niin alkoivat siinä ukot vähitellen myöntää, että saattaa,
saattaa olla tämä kulkuvehkeenä parempikin kuin vanhan ajan
leipämasiina, monisoutuinen kirkkovene.

— On, on tok; ja kum minä ens' kesänä ajan tähär rantaa' oikeir
rupeljmasjsiinalla, niin suatta nähä, jotta siinä Kutaj ja Virmaar
rantalaistev venneet jeäp niinku' seisomaa'.

— Vai rupelj? Minkäällaenen s'oon se rupelj? — tiedusteli joku

puheliaalta kapteenilta.

— S'oon semmojnem potkurj, joka pyrskyttää tuolla perässä ja

vaahtia antaa. Siinä uuvvessa laevassa eij joukkaan näetä siipijä.

Miehille jäi kyllä hiukan hämäräksi, jotta mitenkä se potkuri oikein

sitä vauhtia antaa, mutta kun siinä rupesivat parhaillaan
papinkellotkin soimaan, niin ei passannut enää jäädä ottamaan siitä
tarkempaa selvää. Sittenpähän tuon näkee sen rupelinkin, jos ensi
kesään eletään; ja jos ei eletä, niin jäapi näkemättä, ja taitaahan
tuota kelvata täältä lähtemään ilman sitä rupeliakin.

Mäkeä noustessaan kääntyivät ukot vielä katsomaan Pekka

Jauhiaisen kulkuvehettä ja tavasivat sen kylestä kultaisin kirjaimin
maalatun nimen »Lintu». Niinpä on, niinpä on nimikin mukaisensa,
tuumivat äijät, siivillähän se näkyy kulkea rätkyttävän. Mertalan
Puavo Kuttakoskelta, josta »Lintu» usein kulki lävitse, kertoi, että
sen puhkutus kuuluu jo pitkän matkan päästä, ja silloin heidän pojat
aina sanovat:
 — Tuntuu »Lintui» tulovan, koska kuuluu jo tuolta Juurikkaniemen
puolesta: Uh-huh, uh-huh pit-kä Pek-ka!

Se osoitti, että laivan ja sen päällikön välillä vallitsi tuttavallinen

suhde, jonka kansan huumori oli huomannut. Ukkojakin tämän
kuuleminen vei ikäänkuin lähemmäksi näitä elettävänä olevan ajan
omituisia ja outoja vehkeitä.

Sinne nyt lappautuivat miehet kirkkoon ottamaan hengellisiä

eväitä heinäntekoa varten. Sitä oli katseltukin taas näitä maailman
ihmeitä ihan tarpeeksi. Olisi vielä nähtävä se rautatie, jotta
minkälainen hökötys tuo mahtaa olla! Vaikka kaipa hänet senkin
näkee, kun tästä taas talvimarkkinoille lähtö tulee. Sehän tuo kuuluu
olevan kulussa kesänsä talvensa. Mutta nyt täytyy panna pois
mielestä ne maailmalliset ja valmistautua siihen hengelliseen
puoleen, jotta ei jäisi sekään koettamatta, jos hänestä sitten lie
hyväkin apu tälle maalaiselle, joka saa riehkaista niukan leipänsä
edestä kuin viimeistä päivää.

Eukot istuivat jo omissa penkeissään huivit kaulalla ja

peukaloitansa hypeltäen, kun ukkojen lauma alkoi vanua kirkkoon.
Se on tarkasti erotettu tässäkin Markkulan kirkossa vaimoväen puoli
miesten puolesta. Sitten on vielä erittäin herrain penkit, joissa istuvat
molempien pappilain väet, vallesmannilaiset, ja minkä heitä lie vielä
muita herrasväkiä. Ne ovat, herrain penkit, lähellä saarnastuolia ja
alttaria, jotta siitä ei rippipyhänäkään muuta kuin pujahtaa Herran
armopöydän eteen. Ja kukapa tuonne näistä talonpoikaisista
ihmisistä ensimmäisenä ajaksenkaan; antaa herrojen nauttia sekin
ehtoollinen etumaisena, niinkuin nauttinevat muutkin tämän
maailman antimet.
 Sieltä tulevat nuoretkin vähitellen muitten perästä. Ovat
supatelleet supattamisensa hautuumaalla ja asettuvat nyt
herranhuoneeseen. Eihän niistä puoletkaan ripille tule, tietäähän
sen, mutta näin tärkeänä pyhänä kaikki eivät ilkeä uloskaan jäädä,
vaikka taitaisi olla asiaa vieläkin; loppunoonko tuo noilta ennen, kuin
saavat sen solmunsa solmituksi. Sitten kun se kerran on umpeen
vedetty, niin ei taida olla paljon niistä sipatuksista.

Kovinpa ovat Sukslevän Emmankin korvukset punaiset.

Mitenkähän lie, taitaa olla mieli muissa asioissa, eikä tässä
ehtoollisessa. Tokkopa tuolla he, Emmalla, ollutkaan erityistä
kutsumusta ripille, mutta kun isä kysyi, jotta kuka haluaa, niin ei
uskaltanut evätä, ettei olisi luullut isä hänen muitten mielitekojensa
tautta kirkolle pyrkivän. Sinneppä tuo vaan Emman katse kaartuu
syrjittäin miesten puolelle, jossa hyvin näkyvällä paikalla istuu
Luvellahen Alapetti. Eipä tahdo sijojaan saada Luvellahen poikakaan,
olkapäitään nostelee siinä penkissään, itseänsä kyhnyttelee ja
kämmenselällään tavallista useammin nenäänsä vetäisee, ikäänkuin
ei ilmankin olisi paikallaan, se nenä.

Kyllähän sen tietää, minne päin ne Sukslevän Emman ja

Luvellahen Alapetin asiat ovat menossa; sinne umpisolmuun
tietenkin. Hautuumaalla maleksi tämäkin pari, miten kireälle lie sitten
jo siellä vedetty sitä solmua. Mistäpä sen poskeinen niin tarkkaan
osannee sanoa, kun ei ole ollut näkemässä eikä kuulemassa. Mutta
kaipa he itse tiennevät, ja sinneppä tuo vaan Emman silmä vilkun
Alapetin puoleen, ja Alapetilla tuntuu olevan raskaat oltavat
penkissään.

Eikä malta Sukslevän vanhin poikakaan, se Toloppi, kirjaviisas, olla

toisinaan pälymättä eukkojen penkkiin, jossa kädet ristissä istua
nököttää Tervaharjun Hintriikka, tarmokaspiirteinen tyttö, joka
itsekseen on kirjoituksenkin opetellut. Ei sillä silloin ole pää
paperista, sen arvaa. Olisi, olisi siinä Tolopille akkaa, Hintriikassa, jos
miten sopeutuisi. Ja eiköpä tuo vaan sopeutune, koska yksissä
matkoin ovat nekin vaeltaneet siellä hautuumaan varjoisten koivujen
alla, ja näkihän sen jo juhannuskokolla, että siinä on ne
vippaskonstit käynnissä. Tulisi siitä hömpsäkkä miniä Sukslevään
tästä Hintriikasta, tulisi niinkin.

Herran sanaa on kuultu, väki purkautuu ulos. Sitä oli ollutkin

kansaa tänä heinärippinä kirkossa, joshan lie ollut kirkollakin. Osa
nuoristahan tietysti jäi kirkkomäelle, varsinkin ne, joilla ei ollut
vakituista paria, eikä nuo tainneet kaikki paritkaan sieltä vanhalta
hautuumaalta malttaa lähteä. Oli tainnut riittää sitä asiaakin,
kahdenkeskistä näet, ja ennättääpähän tuota ehtoollistakin nauttia
sitten, kun tosi tarve tulee. Nythän tuo mieli tahtoo heppelehtiä
paremmin näissä maallisissa.

No niin, heinärippimatka oli tehty, nyt palattiin kotiin ja huomenna

alkoi heinänteko, yksi niitä maalaisen talouden tärkeimpiä kausia.
VI.

Siunasi, siunasi se heinäpoutaakin vielä sinä kesänä. Saa hänen

nähdä, kuinka kauan oikein tätä maantiestä suosii? No, onpa ollut
toisina vuosina suosimattakin. Taitaa nyt maksaa vanhoja velkojaan.
Ja ilahuttaa, ilahuttaahan se mieltä, kun sitä näinkin toisin vuosin
edes saa vähän rohkeamman ja runsaamman korvauksen
vaivoistaan, tämä maalainen. Sitä huonoina vuosina tuleekin kenties
hiukan liikaakin sätityksi kaupunkilaista, herraa, joka ei muuta kuin
lapioi rahaa ja sitten sillä ostaa maatiaisen ihmisen ihan iltikseen.
Saattoi tulla turhastakin moitituksi kaupunkilaista; eihän se sen vika
ole, että on sinne joutunut elämänsä asettamaan, kun jo usein on
juuriaan ja perikuntiaan myöten kaupungin asukas. Eikä tuo taida
sillekään ilman työtä ja vaivaa raha loheta, vaikka sitä toisinaan
pahalla päällä ollessaan tämä maalainen niin päättelee. Mutta elä
tykkää pahaa, kaupungin veli… kun näinkin hyvin heinänteko
onnistuu kuin tänä kesänä, niin kyllä tässä toki toisiaan
ymmärretään. Yksiä Jumalan luomia, mikäs on ymmärtäessä!

Kevyesti sujahteli viitake miesten kädessä sinä kesänä Markkulan

pitäjässä. Se tuo kunnon heinäilma antaa työkalullekin ihan toisen
terän ja maun. Antaa se, vaikka sitä ei ymmärrä sellainen, joka ei ole
omintakeisesti joutunut näitä töitä tekemään. Ja naisväen kädessä
hyppii harava kuin leikkikalu, ja karho syntyy kuin itsestään,
huomaamatta. Helähtää siinä helposti nauru ja laulukin haravoitsijain
parvesta. Ja se lähtee sitten yhtä helposti talon oman väen kuin
palvelijain ja kasakkaihmisten rinnoista. Tämä on sellainen yhteinen
hyväntunne, joka naurattaa ja laulattaa. Se ryöpsähtelee koko
luomakunnassa tuo elämisen riemu silloin tavallista korkeammalla.
Joutilaat hevoset järjestelevät kilpajuoksuja haassa, ja jos sattuvat
väljänmetsässä olemaan, kirmaisevat ne huolettomina ihan
pisimpään pohjukkaan, näykkien toisiaan ja ilonsa runsaudesta
potkien. Lehmät ovat niitä luontokappalten yhteiskunnan
vakavimpia, mutta joskus niilläkin leikkisä luonto ilmenee tällaisella
pitkällä ja herkullisella heinäpoudalla. Ja lammas sitten: vaikka sen
järki ei ole vahvimpia, ymmärtää se hyvin kesäisen leikin. Ne ovat
nämä luontokappaleetkin ikäänkuin iloissaan sen johdosta, että
tuleepa, tuleepa nyt evästä ensi talveksi. Ihmisen ilo tarttuu hänen
ympäristöönsäkin.

On se hujakkata, kun heinä kuivaa, jotta kahisee, eikä tarvitse

sätystellä haasioita, huonon ilman kuivuuvehkeitä. Se käy kuin
luomisen työ silloin tämä heinänteko. Niittomiesten jälestä vaan
vedellään korret karhoille, siinä kouhotellaan muutamia kertoja, yön
seuduksi, kasteen ajaksi, ruvolle pistetään, ja kun vielä toisena
päivänä hajotellaan, niin jo illalla ovat latoon tahi pielekseen
pantavia, heinät. Ja niistä tulee sitten kunnon tavara.

Siellä huhkivat laajaa rantaniittyä viitakkeineen Sukslevän miehet,

isäntä Tuavetti ja Toloppi etunenässä. Rengin-kytjäys ei pysy
rinnalla; no, eihän tuolla ole miehen mittaakaan, vaikka sitä iän
puolta alkaa karttua. Ja viitake kourassa se vihtelee Rieti-poikakin.
Taitaa olla ensi kesää miesten matkassa, eikä sen viitake ota oikein
ollakseen terässään, mutta hyvä on yritys. Jos sillä tuommoinen
työhalu vaan pysyy, niin kyllä siitä henkensä elättäjä tulee,
Rietistäkin. Niin no, onhan sillä pojalla miehen luonto, vaikka sillä on
niin kummallinen kaipuu metsään ja järvelle. Se on toisinaan kuin
haltioita tai muita metsän ihmeitä näkisi; sitä tuo metsä jollakin
tapaa pitää lumoissaan.

Niin herahtelee hyvänä isäntä Tuavetin mieli, että sen

kouluasiankin on ihan itsestään ottanut puheeksi jo monta kertaa.
Oikein tuntuu olevan suosiollinen sille ja sanoo, jotta on se sentään
jotain, kun nykyaikana nuo koulutkin laitetaan aivan naapuriin.
Kelpaa tämän nykyisen polven elää kelletellä, kelpaa. No, elettiinhän
sitä ennenkin ilman kouluja ja muita opinteitä, mutta ei taida se
oppikaan ojaan kaataa, kun sitä tarkemmin aattelee. Ja saisihan tuo
tulla pojasta viisaampi isäänsä, jos hänestä, Rietistä, niinkuin
koulunkäyjääkin olisi. Kyllähän tässä työmiestäkin tarvittaisi kotona,
mutta niinpä se sanoi opettaja, jotta ei se koulu työhalua vie, jos
häntä muuten miehessä lie. Niin jotta koettakoon, Rieti, koulua
käydä, sittenpä senkin näkee.

Ja vielä pitemmällekin hypähtelevät Tuavetin ajatukset siinä

viitaketta heinän juureen sujautellessaan. Kummallistahan on tämä
aika yhtähyvin, kun sitä oikein ajattelee. Noita koneita riivattuja
näkyy työn täytyvän joka alalle. Kertoihan se Keiteleen Kamulan
mies, joka tässä hevostaan syötteli, jotta Haminalahdessa heinääkin
koneella tehtiin. Niin, ja on noita muualtakin tainnut kuulua
samanlaisia puheita. Sillä laillahan se käy: se ei sekään vanhojen
viisaus tainnut olla ihan kutinsa pitävää, koskapa niitä näkyy sikiävän
tähän maailman aikaan vieläkin viisaampia. Minkälainenhan hän lie
sekään niittokone, mutta hyvin tuolla kuuluu heinä katkeavan, kertoi
se Keiteleen mies. Oikein oli sekin mies hevosensa seisauttanut
siihen hovin heinäpellon kohdalle ja jalansyten käynyt katsomassa
sitä rakkinetta. No, niissä hoviloissapa nuo tarvinnevat niitä vehkeitä,
tämmöisen pikku talon niitokset kiikutellaan vaan vielä käsipelillä,
eikä taitaisi ne koneet noissa meidän mättäiköissä kestääkään. Mutta
se nyt on merkkinä siitä, jotta tämä maailma menee eteenpäin,
harasipa häntä vaikka vastaankin.

Vaan sitä ne kehuvat sitä separatieriä, vai mikä hän lie oikein siltä
tieteelliseltä nimeltään se maitomylly. Kuuluvat tuolla naapuripitäjissä
jo pienikarjaisetkin sen hankkineen. Meilläkin tässä on jo kymmenen
lypsävää ensi talvena, tuumiskeli Tuavetti edelleen, niin jotta jokohan
tuota olisi mentävä vaan virran mukana ja ostettava se mylly?

Tämä ajatus vaivasi häntä niin, että piti kysäistä Tolopilta, joka
paineli siinä vieressä. Kun Toloppi seuraavan kerran viitakettaan
läppäämään rupesi, teki Tuavettikin saman asian ja tiedusteli:

— Tuota… mittee sinä oekeen meinoot siitä maetomyllystä, jotta

oeskoon tuosta apuva tämmöjsessä talloovessa kunj tämä
meijännii?…

Tolopilta ihan liippa pysähtyi, ja hän jäi pitkäksi aikaa katsoa

tuijottamaan isäänsä, niin häntä ihmetytti tämä kysymys. Mistä oli
nyt ukko saanut semmoisia ajatuksia päähänsä? Hän, Toloppi, oli
lainaamiensa kirjojen avulla tullut havaitsemaan, että konevoima oli
maataloudessakin otettava vähitellen käytäntöön ja
viljelysmenetelmiäkin oli uusittava, jos mieli pysyä nykyaikaisen
kehityksen tasalla, mutta niistä havainnoistaan hän ei ollut
uskaltanut virkkaa mitään isän kuullen. Tuavetti Tarvainen oli isäntä
vanhaan patriarkalleen malliin, joka tahtoi esiintyä talossaan yksin
määrääjänä. Hän oli sitäpaitsi vielä sitä polvea, jossa vanhat tavat ja
tottumukset istuivat tiukassa. Toisin oli Tervaharjun isännän laita
tuossa järven toisella puolella. Hän oli vähitellen taipunut poikansa ja
tarmokkaan tyttärensä Hintriikan tuumiin, ja nyt siellä kuuluttiin jo
ensi syksynä niittyjä ojitettavan ja soita ruvettavan perkaamaan. Ja
sitä kun oli, suota, kaikkiallakin tässä Markkulan pitäjässä. Siellä on
eri peli, uudelta vuodelta kuulemma sanomalehtikin tilataan. Mutta
mikäs tämän meidän ukon mielessä kytee, kun se separaattorista
hyötähyviään puhumaan puhkee?

— Kyllähän seoes separaattorjrii hyvä kapistus olemassaan, vuan

s'oon vasta sittä ihav välttämätön, kun suahaam meijer tuanne
kirkolle. Johan tuota kuuluu semmosjtai huutoo, jotta muutamat
talolliset sitä puuhoovat. Jos hänestä niinkun tosj tulloo, niin kaet se
pittää sittä meijännii se separaattorj ostoo ja alakoo viijjä retojaan
sinnem meijerii…

— Mikäs se semmojnel laitos sittä o? — kysyi Tuavetti, jolle meijeri

näköjään oli taas joku uusi kone, joita näkyy tähän nykymaailman
aikaan sikiävän kuin sieniä sateella.

— Se ov vuan semmojnen konneellinev voev valamistuslaetos.

Sinne viep' itekukkiir retasa, ja siellä ne sittä kirnuvaavat, meijerissä.
Ne kuuluuvat maksavan tavallise' hyvä' hinnan retasjta. Oes se siitä
hyvä, jotta ei tarvihtis voenyyttisä kansa herrosjsa juoksennella, saes
aena parj kertoo kuussa tilisä kättee.

Tuavetti oli taaskin vähän ihmeissään. Kyllähän hänkin mielestään

oli ymmärtävinään näitä koneita, mutta niitä taitaa tulla jo niin
paljon, jotta ei tämä maalaisen järki pysy matkassa. Mutta
oikeastaan hän sittenkin jo hiljaisessa mielessään hyväksyi tämän
meijerinkin. Ei se näet mitään herkkua ollut kulkea kauppaamassa
voitaan, minkä häntä säästymään sai, kun sitä joka paikassa
hypisteltiin ja maisteltiin, jotta lopulta ei paljon ilennyt tarjotakaan
enää koko voita, kun pala oli päältä kuin hiiren nakertama. Ja jäisi
sitten pois koko kirnuamisen vaiva, kun saisi retana meijeriin
kulettaa.

Mutta Toloppi-poika tahtoi takoa raudan kuumana ollessa. Koska

äijä oli yht'äkkiä muuttunut niin edistysmieliseksi, niin koettaa häntä
nyt kutkutella toisesta päästä, joka Tolopin mielestä oli tällä hetkellä
tärkeämpi. Hän haasteli:

— Jospa nuihe' antasj olla niihin separaattoriij ja muihi, siks kun

nuo tulloot välttämättömään tarpeesee. Täss' oes näetä muita
hommija hyvinnii tärkeitä.. Jos oes tuahii niitty oekee' ojittooj ja
laettoo, niin siitä lähtisj er tavalla tätä heinee. Suattasj sittä
myöhemmin panna nuri' ja vaikka kylyvyheinälle… Kuul
tervaharjulaenennii tänä syksynä aekovan ojitella niittysä ja
suotasakkii kuul ruppeevam perkkoomaa…

Tuavetti painui ajatuksiinsa. Hän pani viitakkeensa syrjään ja

rupesi täyttämään piippuaan. Hän ei ollut mikään erittäin innostunut
tupakkamies ja näin kiireenä aikana harvoin työmaalla savuiksi pisti.
Kun hän nyt tupakkapuuhiin ryhtyi, merkitsi se, että hänen päässään
kulki tavallista enemmän ajatuksia. Siellä veuhtoilikin todella
mietteitä sinne ja tänne. Uudistushommiin oli säkeytynyt nyt Tuavetti
Tarvainen. Se separaattori, vai mikä hän lie se maitomylly, se oli
pyöriä hyrrännyt hänen päässään jo kotvan aikaa. Nyt kertoi tämä
Toloppi, jotta Tervaharjun Herkko Tissarinen rupeaa oikein ojimaan
niittyjään. Katsohan näet, vai semmoista se tervaharjulainen, ja ihan
tuossa toisella puolen järven, vähän vaan vitalikkoon tästä Tuavetti
Tarvaisen talosta. Vai niin, vai sen poikia se Herkko? Se tuo taitaa
ymmärtääkin niitten uusaikaisten höpötysten päälle, sen kun
kuuluvat sekä pojat että tyttäret juoksevan kaikkien tietojen ja
oppien perässä.
 — Vai nii jotta tervaharjulaene' ojimaa ja muuta muokkailemmaa.
Mittää jos oes meijännii yrittee? äänsi Tuavetti tovin mietittyään.

Toloppi-poikaa hykäytti. Katsohan ukkoa, se ei halua olla

huonompi naapuriaan.

— Yritettää, yritettään tok, ja suatta nähä, jotta siitä on hyötyvä.

Eiköpä tuota kerittäne tässä omim miehin, jos ei kovan suurta
etteystä oteta. Jos nyt vua' aluks tänä syksynä teä niitty ojitettasj ja
nuo puskat perkattasj poikkee? — huomautti hän.

— Nii ja jos ei peästä muuten, niim pietään taksvärkkäriä, eikö

tuota sev verram pennijä löytyne.

Toloppi oli oikeastaan enemmän kuin tyytyväinen tällaiseen

tulokseen, jota hän vielä jonkin aikaa takaperin ei olisi uskaltanut
odottaakaan. Isän luonne näkyi olevan sellainen, että hänet saa
uudistuspuuhiinkin, kun hänellä vaan jossain tiettyvillä oli kilpailija.
Kilpailu, se ukkoa usutti yrittämään. Nyt osaa Toloppi, joka jo kauan
aikaa oli itsekseen monenlaisista taloudellisista parannuksista
haaveillut, vetää oikeasta nuorasta. Hänellä oli vielä yksi asia
sydämellään, ja hän päätti antaa senkin tulla nyt samassa. Heilläkin
oli jo muutamaan kertaan käynyt ompelukoneitten kauppias, mutta
aina oli sille naurettu ja käsketty mennä narraamaan tyhmempiä, tai
oli sanottu, etteipä tässä ole varoja sellaisiin kokeiluihin. Nyt oli
hiljattain Tervaharjulle ostettu sekin masiina, ja kun tässä kerran
näkyy ukko olevan sopuisalla päällä, niin esitetäänpähän, jotta eikö
tuo nyt tarttuisi asiaan.

— Vua yks kone meille oes tarpeen, siit' oes tuolle äet’väille isoj
apu. Ohan ne kääneet meilläi ompelukonneen kaapalla, vua eipä
hänt' ou tullunna otetuks. Sen saes vähittäesmaksulla, ja sillä kävis
tuo neolomine' er' topakast. Kuulhan nuo Tervaharjulle sennii
hankkinee'.

Tuavetti tarttui heti onkeen.

— Vai sennii! Katohhan neät sitä tervaharjulaesta, vae jo se

sennii!…
Se se riehkajsoo.

Tulikohan Tuavetin mielestä liian paljon näitä esityksiä yhdellä

kertaa, vai muutenko lienee saanut kyllänsä tupakkahollin pidosta,
mutta äkkiä kolisti hän piippunsa perskat suuhunsa — ja alkoi niittää
kuin äkäpäissä. Toloppi-poika koetti painaa perässä minkä ennätti ja
ajatteli itsekseen, jotta jo taisi äijä suuttua, ei sille ehkä olisi nyt
pitänyt puhua koko ompelukoneesta mitään.

Mutta hetkisen perästä Tuavetin vauhti hiljeni. Hän näkyi

aprikoivan viitaketta heilutellessaan. Sitten hän heitti taas niittämisen
sanoakseen Toloppiin päin kääntyen:

— Vae on Tervaharjun emännällä jo ompelukone? Se ostetaam

meillekkii!

Ja sitten siitä asiasta ei enää puhuttu sen enempää sillä kertaa.

Molemmat miehet paiskelivat kuin henkensä edestä. Tolopilla oli täysi
työ pysyä isä Tuavetin kintereillä. Renki, joka oli siinä levähdyksen
aikana saavuttanut, jäi taas pian, ja nuorempi poika missä lie
ollutkaan niityn toisessa päässä. Ja se oli leveä se isän ja
vanhemman pojan eteys.

Kotona illallista syödessä sanoi Tuavetti emännälleen ja yleensäkin

koko naisväelle:
 — Ku' ens kerran tulloo ompelukonneen kaappias, niin se, joka
sattuu olemaam pihassa, tulukoon sanomaam minulle.

Emäntä Justiina, joka oli juuri kantamassa täyttä vatia

potattihauvikkaita pöytään, ihan seisattui tämän määräyksen
kuullessaan.

— Mittään sinä tuolla tiet? — kysäsi hän epävarmasti.

— Meille ostetaan ompelukone, — jatkoi Tuavetti.

— No kaikkee sitä kuulookii näillä korvillaa; mittään tuolla oes

virkoo?

— Ompelovahhan nuo tuolla kuuluu muuvallae, eikö tuota sitä

sammoo tehtäne meilläi.

— Kukapa nuilla uusaikajsilla sätöksillä osannoon?

— Se on opittava!

Eikä siihen päätökseen enää ollut kellään mitään sanomista.

VII.

Katselihan se emäntä Justiina vähän syrjäkariin sitä

ompelukonettaan, kun se tuotiin taloon, kuten oli katsellut
asiamiestäkin silloin, kun häntä porstuanpohjakammarissa kahvitteli
isännän käskystä. Tällainen uusi suhtautuminen mieheen, joka jo
muutamia kertoja oli melkein hätistelemällä hätistetty talosta pois,
tuntui hänestä liian ihmeelliseltä. Mutta se nyt oli, se asiamies, sitä
lajia miestä, että se tuli vaan uudestaan; taisi tietää, jotta kyllä siitä
lopulta kaupatkin tulee. Pianhan tuo palasikin taas, ja nyt vieraana
pidettiin ja kestittiin. Kyllä sen onnettoman suu kävikin, vaikka
vähemmälläkin olisi sen rakkineensa kaupaksi saanut, kun näkyi
sekaantuvan ajatuksissaan vanhemmiten tämä-Tuavettikin, joka oli
niin selvänuottinen mies ennen.

Semmoisia se Justiina itsekseen intoili, mutta mikäpähän siinä

auttoi muuta kuin ota pois se kone. Pian se sen hommasikin,
asiamies, ja opetti konstinkin samaan vähittäismaksuun.

Mutta pianpa se naisväen pää kääntyy, vaikka häntä sitten olisi,

naisihminen, hyvinkin timakkaa olevinaan, minkä tämä Justiinakin.
Kun hän tuli huomaamaan, jotta tämähän käykin kuin luomisen työ
siihen entiseen hyppyspeliin verrattuna, niin jopa meni nauruun
emäntä Justiinan suupieli, ja hän alkoi kyläläisillekin kertoa, jotta
tämä se onkin etuisa vehe tämä ompelumasiina, sillä pyöräyttää
miehille paidan yhdessä touhauksessa.

Sukslevän Tuavetti Tarvaista alettiin pitää melkein kuin johtavana

miehenä tässä Hirvijärven eteläpään, Muuraisen ja osittain Pienen
Talluksenkin kulmakunnilla. Sillä oli tällä Tuavetilla ollut se
nuoruuden aika vähän sekaista silloin, kun se vaan tavallisena
Sukslevän Tuakkona isänsä eläessä kyliä juoksi ja pientä ilkeyttä teki,
mutta työmies se oli ollut aina, sitä ei voinut kukaan kieltää. Ja
sehän se on pääasia. Mitäpä tuosta, vaikka vapaana aikanaan vähän
hempsahtaakin, eihän se jokaisella ole veri yhtä vakainen. Ja mikä
tuossa vaan lie, jotta niistä nuoruuden hurjista tulee useinkin
rempseitä miehiä, sellaisia eteensä katsovia ja vähän kauemmaksi
näkeviäkin kuin tämä tavallinen nuhjottaja, joka pyörii vaan koko
ikänsä siinä yksillä jalkainsa sijoilla eikä vie maailmaa eteen, joshan
ei taaksekaan päin. Jotta taisi vaan olla eduksikin, että se entinen
Sukslevän Tuakko oli niin vetreä siltä luonnoltaan.

Varsinkin tämän koneen oston jälkeen pidettiin Tuavettia eturivin

miehenä, ihan kuin ilopurolaista etelä-Markkulassa ja Sipukan
Pekkaa, jolla kuului olevan kanssa separaattorikin, pitäjän
pohjoispäässä. Olisihan tässä Hirvijärven rannalla ollut
tervaharjulainenkin, mutta se oli sellainen enemmän itseensä
sulkeutunut turjake, vaikka kohta sen päässä liikkui kaikellaista
uudenaikaista, eikä siitä Herkosta koskaan oltu puhuttu paljon hyvää
eikä pahaa, niinkuin tästä Taavetista oli liikkunut juttua monenlaista.

Siinä se kekotti ompelukone kaikessa komeudessaan Sukslevän

tuvassa jo ruistalkoon aikana. Niitä vaan oli riittänyt ilmoja vielä
rukiinkin korjuuksi. Parahiksi ennätti heinänteon lopettaa, kun jo ei
muuta kuin ala ottaa sirppi käteesi, jottei karisemaan pääse aikaisin
joutunut ruis. Harvoinpa sitä oli ennen näillä main kunnolle keritty
saada ruis kuhilaille ennen Laurin päivää, josta alkoi uuden siemenen
kyntö, se kun oli tässä pitemmän aikaa pitänyt semmoisia
rämppäkesiä; mutta kyllä nyt kerittiin aumaankin asetella. Olisi
vaikka passannut Sukslevässäkin uutisella siementää, mutta sillä oli
Tuavetilla siemenet varattuna viimevuotisesta. Tosin oli pitänyt
ostoviljaa käyttää lisänä, sillä eipä tahtonut näissä Markkulan
kivikkopeltoisissa taloissa omasta takaa vielä riittää vuoden
ympäriinsä, mutta siemen sentään aina varattiin.

Ruistalkoohan se toki pidettiin elokuussa joka talossa ja

potattitalkoo sitten syyskuussa, ja joskus kun sattui korjuun kanssa
kiirettä pakkaamaan, vähän muitakin viljoja talkoolla talteen otettiin.
Siinä on tässä talkoossa sellaista yhteistyön ja toisensa auttamisen
henkeä. Vuoron perään käydään seutukunnan taloista toisissaan, niin
jotta niitä riittää talkoita joka päiväksi rukiinleikkuunkin aikana. Se
sujuukin talkootyö eri vauhdilla, kun siinä vähän niinkuin
kilvoitellaan, jotta kuka se on oikein parempi toistaan.

Ja onhan niitä aina talkoossa muitakin viehätyksiä. Kas kun se ei

tämä savolainen, jonka talot harvoin ovat yhdessä rysmässä niinkuin
niitten rintamaalaisten, usein pitempiin aikoihin pääse naapurinsa
pakeille, ja kertyyhän sitä toki hänellekin asioita kielen alle, kertyy
niinkin. No, siinä kun on talkoossa koolla koko seutukunnan väki, niin
passaa naisväenkin säklättää ne säklätyksensä ja vapautua siitä
tunnonvaivasta, jotta kun ei ole kunnon puhetoveria; sillä mitäpä
tuota lie juuri juttelemisia näitten oman talon asukkaitten kanssa,
jotka aina tuossa silmän alla käpsäkehtivät. Ja niinpä ne vaan ukon-
kantturatkin alkavat käydä harvapuheisiksi jorauksiksi, jos aina
kotijoukkojen parissa mököttävät, jottet kuvalle sanaa suusta saa
muuta kuin hiilikoukun kanssa haravoimalla. Mutta annas kun
pääsevät talkooseen, niin kyllä kieli liplattaa. No, mikäpä on
liplattaessakaan, kun siellä vertaisiansa löytävät ja saavat sitten
vatvata ja justeerata kaiken maailman asiat. Ihan ovat, vaivattavat,
kuin pahoja akkoja silloin. Se on niinkuin kihupyhä tämä talkoo,
mutta kun se on kokonaan maallista menoa, niin sillä on vielä
retevämpi luonne kuin kirkkokihauksilla.

Niin, ja entäs sitten nuoret, nehän ne toisiaan tarvitsevat. Kyllähän

sitä joutilaampina aikoina osataan järjestellä tansseja ja muita
hyppijäisiä, mutta järjestäpä heitä kesällä, kun on kiire työn touhu.
Sitä ei silloin vanhemman väen taholta katsella hyvillä silmillä
nuorten riekkujaisia. Hypelkööt palvelusihmiset sitten riiviikon
aikana, sanovat talon isäntäväet, kun on oma aikansa, nyt pitää
tupen heilua ja omat pidetään muuten kurissa. Onhan näitä sitäpaitsi
talkoita tästäpuolin melkein joka päivä, jotta tottapa nuo niissä
tulevat hoidetuiksi asiat työnteon ohella, ja mikäpäs sen somempaa.

Tuntuupa niille verestyneenkin yhtä ja toista nuorille. Nämä

ovatkin ensimmäiset talkoot tänä vuonna. Sukslevän Tuavetti pääsi
etunenään. Siitäkin sen näkee, jotta se on kokoomassa pitäjän
ökymiehen asemaan. Tähän asti ne ovat useimmiten tuolla
Pölökissä, kun niillä ovat pellot päivärinteellä, ehättäneet
ensimmäisiksi, mutta eipä tuo töydännyt pölökkiläinenkään nyt, vaan
antoi suksleväläiselle tilaa. Niin, tuntuu olevan kiireitä kerrottavia,
nuorilla, koskapa sellainen sohina ja kohina kuuluu niitten parvesta.
Siellä leikkaavat tyttönsä ja poikansa kilpaa. Tässä työssä se rivakka
naiseläjäkin pysyy miehisen miehen rinnalla, melkein on toisinaan
pääsevämpikin käsistään. Vanhempi naisväki on sitelemässä, ja
ukoista useimmat kuhilaita pystyttelevät.
 — Siinä se o' ja pyssyy, eikä taekoja tarvita,— sanoo
harvapuheinen Herkko Tissarinen, kun ensimmäiselle kuhilaalle
hatun päähän panee,— höystykööv vuan Sukslevän Tuavetin pelto!

Niin, niin, taikojapa taikoja. Niistä alettiin päästä jo Markkulan

pitäjässä. Taisi olla se Aitto-ukko viimeinen suurempi taikoja, sillähän
nuo olivat omat metkunsa joka asialle. Nyt on kaiketi siltäkin luonto
mennyt, kun käräjiin joutui, rapsut sai sen päiväiset ja kelmiksi
tuomittiin. Istunuthan tuo on sen istumisensa ja nyt vaarinpäivillä
kotonaan kököttelee, mutta eipä ehkä ukko lähde enää hautaan
kuolleen päänahkaa nylkemään, niinkuin teki vielä tässä vuosi
muuvahta takaperin, josta se sitten kunnia meni ja linna peri.
Tapahtuuhan sitä vielä nytkin, jotta jotkut akan-höpäköt toisten
navettoihin työntäytyvät elukoitten nahkasta lämpäreitä
leikkelemään, mutta-lähtö tulee taikojen tekijöille, jos talonväki vaan
sattuu huomaamaan, ja kuuluvathan nuo käräjiinkin moniaita
saaneen. Se aletaan nyt jo jokseenkin yleisesti katsoa ilkeydeksi
taikojen teko, mokoma, vaikka toisethan noita vielä pelkäävätkin,
mukamas. Tolomulan vanha emäntäkään ei kuulemma saa yön lepoa
eikä päivän rauhaa, kun niin kammoaa taikojen voimaa, mutta sehän
tuo muutenkin on vielä niin vanhansorttinen ihminen, ja taitaisi
itsekin taikoa, jos rohkeutta riittäisi. Tämä Hirvijärven ranta ja koko
muukin läheinen puolikunta on kuitenkin vapaa sellaisista
höpsötyksistä.

Eikä siinä Sukslevänkään leikkuupellolla tarvittu muita taikoja kuin

riskiä ja rivakkaa liikkumista, niin kyllä katkesi kaunis vilja. Ja sitähän
oli, sitä työn iloa, varsinkin kun näin toisen askareissa liehuttiin. Mikä
siinä lie, jotta toiselle se työ, ilmainenkin, maistaa paremmin kuin
kotona? No, onhan ne syömiset ja juomisetkin vähän niinkuin
valinnan perästä, ja nuorella väellä on ainakin sitten illalla tiedossa
pieni tanssin rivaus kaiken vaivannäön päälle.

Ne nuorten asiat, nehän ne kehittyvät näissä talkoissa hyvää

hytyä. Millä kannalla nuo lienevät sitten heinäripin jälkeen olleet
esimerkiksi tämän Sukslevän tyttären Emman ja Luvellahen Alapetti-
pojan välit, sitä nyt on sivullisen vaikeata ihan rikulleen sanoa, mutta
jos niihin oli silloin jäänyt jotain keskentekoista, niin kyllä ne nyt tänä
talkoopäivänä pääsevät semmoiseen reilaan, jotta ei muuta kuin
lumpsauta kansi kiinni kuin voivakkaseen. Sen näkee selvästi
kummankin naamasta. Katsohan nyt esimerkiksi tätä Emmaa: vaikka
häntä lujastikin leikkaisi ja miesten rinnalla riehkaseisi, niin ei se
paljaan työn väri ole ihan tuollainen. Sen poskilla kun välistä
leiskahtaa niinkuin revontulet! Se on jo muuta leiskutusta, eikä
tämän työn aiheuttamaa. Se lähtee sieltä sydämestä, josta ne
kummalliset, mitkä he lienevät virrat ja vanat, johtavat poskiin
tämmöisellä kokemattomalla ihmisellä kuin Emmakin on. Turhaa sitä
on Emmankin pyyhkiä poskipäitään huivinnurkalla, ei se siitä
minnekään mene se leiskotus, se lekottelee vaan, kun Alapetti on
lähellä.

Mitä taas tähän Alapettiin tulee, niin mitä häntä suotta on

sotkeutuvinaan toisten miesten keskusteluihin, kun ei se kuitenkaan
ole mitään kuvan keskustelua, eikä hänen puheistaan kukaan saa
säällistä tolkkua. Katsoisi vaan suoraan Emmaan, kun nyt jo taitaa
muuten uskaltaa katsoa paremmin kuin siellä juhannuskokolla
Luvellahen pohjassa, sillä hoksaahan sen jokainen, jotta sinne sen
silmiä vetää, vaikka on olevinaan niinkuin muitten miesten asioissa
kiinni. Joo, kyllä sen huomaa, elkää te siinä luiruilko!
 Vaikeampaa taitaa ollakin saada selvää tämän Sukslevän Tolopin ja
Tervaharjun Hermannin Hintriikka-tyttären välilöistä. Toloppi on
semmoinen itsetykönään tuumiskelevainen turilas, harvasanainen ja
ehkä -verinenkin joksaus, että se saattaa peittää kaikki metkunsa.
Eikäpä tuo ole paha pärpättämään Hintriikkakaan, isäänsä on tullut
tasainen ja tyyni. Niitten molempien luonnolla sitä jo osaa peittääkin,
jos oikein koko tahtonsa yhteen kasaan kerää. Mutta jonkin verran
silmän vilkettä näytään pidettävän näittenkin kahden välillä, kyllä sen
aina vanhempi ja kokeneempi honaisee, kun vaan osaa katseensa
järjestää oikealla ajalla ja oikeaan paikkaan.

Niin — ja muista nuorista puhumattakaan. Totta kaiketi niitä parin

alkuja aina on näin talkoissa, missäs sitten?

Siinä jo puolishollilla katsellaan sitä uutta konetta ja pannaanpa

emäntä Justiina näyttämään, jotta mitenkä se tämä rukki niinkuin
hyrrää. Osaisihan se Emmakin, mutta ujoilee, kait tuon Alapetin
tähden. Mutta Justiina ei ujoile. Se oli aika tormasija jo tyttönäkin
ollessaan, ja on pitänyt ollakin, ei se muuten olisi uskaltanut
silloiselle Suksleväp Tuakolle mennä. Ja arvollinen puolisopa tuosta
on tullut, ja sovussa ovat eläneet, ei ole tarvinnut katua
kummankaan. Kun siinä nyt tämä Justiina ottaa nuoremman pojan
paidan ja sähäyttää sivukappaleet yhteen, niin se ei ole muuta kuin
yksi punainen pyöräys, ja ihmettelyn humina käy läpi koko joukon.
Se on nyt taattu tällä kulmalla tämän ompelukoneen tulevaisuus, sitä
ei tarvitse epäilläkään.

On jo jokseenkin myterää illalla, kun talkooväki kolmesta pitkästä

pöydästä nousee ja tuvassa raivataan tilaa tanssihaluisille.
Talkooillalliseksi oli tapettu lihava pässi, ja siihenpä sen lihat nyt
menivät leikkuuväelle keitettyyn tappaissoppaan, ja verestä oli
pyöritelty muhevat myvyt keittoon. Mutta välipä tällä yhdellä
lampaalla, ovatpa rukiitkin kuhilaalla, ja Sukslevän tuvassa käy nyt
tanssi. Nämä olivat viinattomat talkoot, sillä ei ole Tuavetti Tarvainen
akoituttuaan niitä aineita kotiinsa tuonut. Niin oli silloin topannut
kuin naulaan.

Mutta ketäs siellä aitan takana notkulaudalla istuu? Kaksi heitä

niinkuin olisi, minkä tältä hämärältä erottaa. Ja lähekkäinpä ne
istuvatkin, ei siihen sovi myteräkään väliin. Ja mitenkähän on, eikös
ne ole tyttö ja poika, ja eikös vaan tuon pojan käsi ole koomin kuin
tytön vyötäreillä? On, onpahan se. Kas kun ei näitä ole
tanssituttanutkaan! Mitenkähän niitten asiat ovat? Kauanpa ne
katsovat toisiinsa, mitähän nuo näkevät? Tuolta hollilta tuota nyt
nähnee myterässä elokuun myöhäisessä illassakin. Mahtavatkohan
ne oikein haasteitakin keskenään?

— Kyllä käet tätä sittä jo suap pittee varmana asijana, vae mittee
sinä sanot, Emma? — kysyy se poika hiljaa.

Ahaa, se onkin tämä Sukslevän Emma, so-soo, no sitten ei ole

vaikeata arvata, kuka se toinen on siinä vierellä. Vai nämä ne ovat
tänne tulleet tanssituvasta omille teilleen! Jaha, eipä sitten taida olla
kaukana kuuliaiset. Mutta mitähän se tyttö nyt tuohon kysymykseen
vastaa?

— Mittee sinä sitä kysyt, Alapetti, tiijäthän sinä, jotta sinustaham

minä tykkeen, ja oun aenai tykännä, pienestä pittäen, ihan siitä ast
ku' ensimäisen kerran kävil Luvellahen kokolla. Aena minä vuan oun
sinuva muistanna, vaikka sin' et ou itestäsj antanna väljliin kuulta
pitkiin aekoin…
 Hyvänen aika, onpas sillä tytöllä puhetta nyt! Ei oikein uskoisi
Sukslevän Emmaksi, joka toisinaan on vielä niin ujoinen, mutta kun
pääsee tänne hämärään, niin jopas on sanomista.

Sitten sieltä ei kuulukaan mitään, mutta samassa asennossa

taitaisivat istua vaikka aamuun asti ja sivuitse siitäkin, jollei sattuisi
tanssin väliä ja muitakin tulisi pihalle. Mutta ei niitä kukaan osaa
täältä etsiä, ja kullakin on omia asioitaan setvittävinä, niin jotta kyllä
ne täällä aitan takana saavat rauhassa olla. Parhaan paikan ovat
valinneetkin.

Tanssi alkaa jälleen, mutta sitten näitten välillä täällä alkaa

ikäänkuin taistelu. Antaahan olla, ovatkohan nämä suuttuneet
jostain? Mikäs niille nyt tuli?

— Yks vuan… — kuuluu se poika sanovan siinä kahakassa.

— Ei, Alapetti, ei nyt aenakaa, jos kuka näkköö…

— Eikä neä, mittee sinä turhoo, Emma…

Mitä, eivätkös niitten naamapuolet käyneet siinä kamppailussa

vastakkain?

— Hyi, minkälaenen sin' out, Alapetti!

So, käviköhän tälle tytölle pahastikin? Mitenkäs ne noin rupeavat

leikkimään kovakouraisesti, jotta toiselle tulee vahinko?

No nyt? Mitäs tämä nyt on? Eikös se tuo tyttö juokse sen pojan
kaulaan ihan solkenaan, ja oikein näyttää hyppäävän ja painavan
huulensa toisen huulia vastaan? No, nyt se ei enää muista siitä
irrotakaan. Aijai, jos sattuisi joku tulemaan. Onko tämä nyt
soveliasta? Kyllä tännekin saattaa joku osata.

Nyt se helpotti, Luojan kiitos!

No niin, siinä se nyt oli! Se on taas kiinni! Hyvät ihmiset, mitä

tämä nyt tämmöinen…

Ne pitää jättää sinne. Iltakin näkyy myteröityvän yhä enemmän.

VIII.

No niin, se nyt oli sitten kesäkin taas menneilleen. Kauankopa tuo

kestäneekään täällä pohjoisessa: parahiksi ennättää koreimmat
pyhävaatteensa päälleen pukea, kun jo ei muuta kuin ala riisua niitä
pois. Se on tämä pohjolan kesä niinkuin kiireimmittäin joissakin
pidoissa kävijä, istuutuu pöydän päähän ja syö juhla-atrian, ja sitten
sille tulee kiire kuin mustalaiselle. Mutta nätin näköinen se on siinä
istuessaan, oikein hemaiseva kuin juuri naiseksi noussut
kaunismuotoinen tyttö.

Nyt pudotteli jo se neiti hiljakseen korujaan yltään. Oltiin

syyskuussa. Annappahan tästä vielä muutaman viikon vierähtää, niin
jo on ihan alushameisillaan, ja sitten se alkaa panna päälleen
paksuja talvitamineitaan.

Siihenpä se sitten suvitoukojen valmistumiseen mennessä oli

kypsynyt se Emman ja Alapetinkin asia sellaiseen asteeseen, että
passasi saattaa se vanhempienkin tietoon. Alapetin puhemies,
Särkän Israjel Huatainen, oli käynyt Sukslevässä kysymässä, jotta
kävisikö se niinkuin päinsä. Ka mikäpähän siinä! Eihän Sukslevässä
ollut mitään Alapettia vastaan, rivakka nuorimieshän se on
Luvellahen poika, ja kyllähän tässä on nähty, jotta onhan niillä jotain
Welcome to our website – the ideal destination for book lovers and
knowledge seekers. With a mission to inspire endlessly, we offer a
vast collection of books, ranging from classic literary works to
specialized publications, self-development books, and children's
literature. Each book is a new journey of discovery, expanding
knowledge and enriching the soul of the reade

Our website is not just a platform for buying books, but a bridge
connecting readers to the timeless values of culture and wisdom. With
an elegant, user-friendly interface and an intelligent search system,
we are committed to providing a quick and convenient shopping
experience. Additionally, our special promotions and home delivery
services ensure that you save time and fully enjoy the joy of reading.

Let us accompany you on the journey of exploring knowledge and

personal growth!

textbookfull.com