Kotlin

Java

#### Multidimensional Arrays :

`18`#### Practice with Strings :

`17`#### null :

`16`#### Algorithms and Strings :

`15`#### Strings :

`14`#### Functions and Algorithms :

`13`#### Practice with Functions :

`12`#### More About Functions :

`11`#### Errors and Debugging :

`10`#### Functions :

`9`#### Practice with Loops and Algorithms :

`8`#### Algorithms I :

`7`#### Loops :

`6`#### Arrays :

`5`#### Compound Conditionals :

`4`#### Conditional Expressions and Statements :

`3`#### Operations on Variables :

`2`#### Variables and Types :

`1`#### Hello, world! :

`0`

Welcome back! This lesson is entirely focused on one problem: encryption.

We’re going to modify the normal lesson flow.
We’ll start with the homework problem *at the top*.
If you’d like to just go at on your own, go for it!
And, if you’d like a bit of help, we’ll break it down piece-by-piece below.

Let’s get to it!

Created By: Geoffrey Challen

/ Version: `2020.9.0`

Encryption is an ancient practice of trying to conceal information by scrambling it. Modern encryption techniques are incredibly strong and mathematically sound. But in the past, simpler and more primitive methods were used.

Let's implement a form of encryption known as a *Caesar Cipher*,
sometimes also known as Rot-13 encryption.
(Rot for rotation, and 13 for one amount that you might rotate.)
Here is how it works. Given a `String`

and an amount to rotate, we replace each character in the `String`

with
a new character determined by rotating the original character through a given rotation `String`

.
For example, given the rotation `String`

"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz ",
"ABC" rotated 3 would be "DEF", and rotated -1 would be " AB". (Note the space at the end of the rotation `String`

.)

Declare and implement a function called `encrypt`

that, given a `String`

and an `int`

amount, returns the passed
`String`

"encrypted" by rotating it the given amount.
("Encrypted" is in scare quotes because this is *not* by any means a strong method of encryption!)
Use the rotation `String`

provided above.
If the passed `String`

is `null`

you should return `null`

.
Note that rotation *may* be negative, which will require some additional care.

Rot-13 Part 0: Understanding the Problem

Let’s break down this problem into smaller pieces, and spend a few moments just orienting ourselves and figuring out what to do.
We won’t write test cases *yet*, and instead save them for the smaller pieces that we’re about to create.

// Breaking Down Rot-13

Rot-13 Part 1: Character Mapping

Now that we have a sense of what the different pieces are, let’s look at one of the core challenges: remapping each character. We’ll also write some simple test cases for our helper method.

// Remapping Each Character

Rot-13 Part 2: Breaking Down the String

At this point we’ve identified how to remap individual characters.
Next we need to review how to break the input `String`

*into* individual characters.

// Breaking a String Into Characters

Rot-13 Part 3: Putting it All Together

Now that we have our building blocks, let’s integrate everything together!

// Putting it All Together

More Practice

If you are enjoying `String`

s, rotation, and modular arithmetic, and haven’t had enough yet—here is a practice problem that you might enjoy!

Created By: Geoffrey Challen

/ Version: `2020.9.1`

This problem combines `String`

s, functions, *and* arrays. Super fun!

Write a function called `rotateRight`

that takes a `String`

as its first argument and a *non-negative* `int`

as
its second argument and rotates the `String`

by the given number of characters.
Here's what we mean by rotate:

`CS125`

rotated right by 1 becomes`5CS12`

`CS125`

rotated right by 2 becomes`25CS1`

`CS125`

rotated right by 3 becomes`125CS`

`CS125`

rotated right by 4 becomes`S125C`

`CS125`

rotated right by 5 becomes`CS125`

`CS125`

rotated right by 8 becomes`125CS`

And so on.
Notice how characters rotated off the right end of the `String`

wrap around to the left.

This problem is tricky! Here are a few hints:

- You will want to use the Java remainder operator to perform modular arithmetic, so please review the remainder operator.
- You will probably want to convert the
`String`

to an array of characters before you begin. - You can convert an array of characters
`characters`

back into a`String`

like this:`new String(characters)`

. - You can also solve this problem quite elegantly using
`substring`

.

If the passed `String`

argument is `null`

, you should return `null`

.
Good luck and have fun!

CS People: Shafi Goldwasser

Remarkably few women have won the Turing Award, the highest award given for contributions to computer science. (Often considered the Nobel Prize of computing.) Shafi Goldwasser is one of them.

She received the award in 2012 “for transformative work that laid the complexity-theoretic foundations for the science of cryptography and in the process pioneered new methods for efficient verification of mathematical proofs in complexity theory.” Her work underlies the foundations of our modern data society, including algorithms that you use every day when you chat, browse, shop, and engage online. Here’s a short (if somewhat poorly done) official video describing her contributions:

Need more practice? Head over to the practice page.