[PYTHON] Solve 100 language processing knocks 2020 (00. Reverse order of character strings)

Introduction

Let's try knocking 100 natural languages that are popular in the streets with Python. I think there are various ways to solve it, so I would like to show you various ways to solve it. Of course, it is not possible to cover all the solutions. If you have any questions such as "There is such a solution" or "I'm wrong here", please let me know in the comments.

What is 100 Language Processing Knock 2020?

Languistic processing 100 knock 2020 is Inui Suzuki Laboratory of Tohoku University. /) This is the teaching material used in the Programming Basic Research Study Group. For details, refer to About 100 language processing knocks.

Link to Qiita article

00. Reverse order of strings

problem

[00. Reverse order of strings](https://nlp100.github.io/ja/ch01.html#00-%E6%96%87%E5%AD%97%E5%88%97%E3%81% The problem of AE% E9% 80% 86% E9% A0% 86) is as follows.

Get a string in which the characters of the string "stressed" are arranged in reverse (from the end to the beginning).

answer

If you read the question, the answer is desserts because it's a question of getting a string of stressed in reverse. All of the answers below will return desserts when the last expression is evaluated.

simple

There is a method to add it to the beginning of the character string obediently. In Python, you could combine strings with + to generate a new string.

#simple
s = "stressed"

result = ""
for c in s:
    result = c + result
result #=> 'desserts'

Functional

It's too simple to be functional, but it can be expressed by a combination of functions. The reversed function returns an iterator to retrieve in reverse order given an iterator, so concatenate with an empty string to get the desired result.

#Functional
s = "stressed"

"".join(reversed(s)) #=> 'desserts'

Pythonic

Being Python-like is called ** Pythonic **, but is this code the most Pythonic? The method of accessing a list or string with s [start: end: step] is called slicing. Specifying -1 for step reverses the order. It goes by -1.

# Pythonic
s = "stressed"

s[::-1] #=> 'desserts'

Other answers

combination

There is also the following method that combines the above. If you add something to the end or beginning of the string, a copy will occur, and if you add an element other than the end of the list, a copy will occur. To avoid that, I add an element to the end of the list and then string it with " ". Join.

#A combination of simple and functional
s = "stressed"

l = []
for c in reversed(s):
    l.append(c)
"".join(l) #=> 'desserts'

Turn by index

There is also a method of turning by index obediently. for n in range (len (s)): is one of the syntaxes for turning for for an index. len (s) returns the length of the string s, andrange (n)returns an iterator to scan 0, ..., n-1.

#Perform the process equivalent to reversed by yourself
s = "stressed"

l = []
for n in range(len(s)):
    l.append(s[len(s)-n-1])
"".join(l) #=> 'desserts'

There is another way to index. ʻEnumerate (s)is an iterator for scanning(0, s [0]), ..., (n-1, s [n-1])withn = len (s)Returns. I also use_` to mean variables that I don't use. I just put it in.

#Perform the process equivalent to reversed by yourself
s = "stressed"

l = []
for n,_ in enumerate(s):
    l.append(s[len(s)-n-1])
"".join(l) #=> 'desserts'

List comprehension

You can also write in list comprehension.

s = "stressed"

l = [c for c in reversed(s)]
"".join(l) #=> 'desserts'

However, if you think about it carefully, you may think that the generator comprehension may be used.

s = "stressed"

g = (c for c in reversed(s))
"".join(g) #=> 'desserts'

Then, it will return to the following functional type.

#Functional
s = "stressed"

"".join(reversed(s)) #=> 'desserts'

Looking back

I think each person has their own taste, but my favorite answer is below.

#A combination of simple and functional
s = "stressed"

l = []
for c in reversed(s):
    l.append(c)
"".join(l) #=> 'desserts'

It is easy to understand that the for statement conveys the feeling that you want to turn it in the opposite direction, and that you are obediently adding elements to the list. Also, when solving an actual problem, I often write the process of processing each element and putting it in another list, so it is the basic form. " ". Join (reversed (s)) and s [:: -1] are great for solving this problem, but they make it harder to add additional processing.