Implement new concept exercise - string methods exercism#2175

* Add new concept exercise - string methods

* Fix formatting

* Use prettier to clean up markdown

* Resolve PR comments

* Fix closing bracket

* PR comment, add concept files

* Update languages/exercises/concept/string-methods/.meta/design.md

* Update languages/concepts/string-methods/about.md

* Update languages/concepts/string-methods/about.md

* Update languages/concepts/string-methods/about.md

* Update languages/exercises/concept/string-methods/.docs/introduction.md

Co-authored-by: Olivia Kim <[email protected]>
Co-authored-by: BethanyG <[email protected]>

Author: 3 people

concepts/string-methods/about.md

@@ -0,0 +1,26 @@
+## String Methods in Python
+
+A string (`str`) in Python is a sequence of Unicode code points which
+include letters, numbers, symbols, punctuation, etc. Strings
+implement all of the [common sequence operations](https:/docs.python.org/3/library/stdtypes.html#typesseq-common),
+along with iteration using the `for item in <string>` syntax.
+
+Python provides a number of useful methods that you can use to manipulate
+strings. These string methods can be used for cleaning, splitting, translating,
+or otherwise working with the `str` type. New strings can be created based
+on method arguments, and/or additional information can be returned. Strings
+can be concatenated using the `+` operator or with `str.join()`.
+
+Some of the more commonly used methods include:
+
+- Checking for prefixes/suffixes with `startwith()` and `endswith()`
+- Altering string casing with methods like `upper()`, `lower()`, and `swapcase()`
+- Removing leading or trailing characters from a string using `strip()`, `lstrip()`, or `rstrip()`
+- Replacing substrings with the `replace()` method
+- Checking for the existence of a substring with `in`
+- Concatenating strings with the `+` operator or `str.join()`
+
+The `str` type is _immutable_, so all of these methods will return a new `str` instead of modifying the existing one.
+
+For more information, you can check out the
+[official documentation](https://docs.python.org/3/library/stdtypes.html#string-methods).

concepts/string-methods/links.json

@@ -0,0 +1,18 @@
+[
+  {
+    "url": "https://docs.python.org/3/library/stdtypes.html#string-methods",
+    "description": "string methods"
+  },
+  {
+    "url": "https://docs.python.org/3/library/stdtypes.html#common-sequence-operations",
+    "description": "common sequence operations"
+  },
+  {
+    "url": "https://realpython.com/python-string-formatting/",
+    "description": "string formatting best practices"
+  },
+  {
+    "url": "https://www.programiz.com/python-programming/string",
+    "description": "more string operations and functions"
+  }
+]

exercises/concept/string-methods/.docs/hints.md

@@ -0,0 +1,25 @@
+## General
+
+- [Introduction to string methods in Python][string-method-docs]
+
+## 1. Capitalize the title of the paper
+
+- You can use [string methods][title-method-docs] to capitalize the title properly.
+
+## 2. Check if each sentence ends with a period
+
+- You can use [string methods][endwith-method-docs] to check the ending of a string.
+
+## 3. Clean up spacing
+
+- You can use [string methods][strip-method-docs] to remove whitespace.
+
+## 4. Replace words with a synonym
+
+- You can use [string methods][replace-method-docs] to replace words.
+
+[string-method-docs]: https://docs.python.org/3/library/stdtypes.html#string-methods
+[title-method-docs]: https://docs.python.org/3/library/stdtypes.html#str.title
+[endswith-method-docs]: https://docs.python.org/3/library/stdtypes.html#str.endswith
+[strip-method-docs]: https://docs.python.org/3/library/stdtypes.html#str.strip
+[replace-method-docs]: https://docs.python.org/3/library/stdtypes.html#str.replace

exercises/concept/string-methods/.docs/instructions.md

@@ -0,0 +1,39 @@
+In this exercise you are helping your younger sister edit her paper for school. The teacher is looking for correct punctuation, grammar, and excellent word choice.
+
+You have four tasks to clean up and modify strings.
+
+## 1. Capitalize the title of the paper
+
+Any good paper needs a properly formatted title. Implement the function `capitalize_title()` which takes in the parameter `title` and capitalizes the first letter of each word of the title. This function will return a `str`.
+
+```python
+>>> capitalize_title("my hobbies")
+"My Hobbies"
+```
+
+## 2. Check if each sentence ends with a period
+
+You want to make sure that the punctuation in the paper is perfect. Implement the function `check_sentence_ending()` that takes in the parameter `sentence`. This function should return a `bool`.
+
+```python
+>>> check_sentence_ending("I like to hike, bake, and read.")
+True
+```
+
+## 3. Clean up spacing
+
+To make the paper look professional, unnecessary spacing needs to be removed. Implement the function `remove_extra_spaces()` which takes in the parameter `sentence` and removes extra whitespace at the beginning and at the end of the sentence. This function should return a `str`.
+
+```python
+>>> remove_extra_spaces(" I like to go on hikes with my dog.  ")
+"I like to go on hikes with my dog."
+```
+
+## 4. Replace words with a synonym
+
+To make the paper even better, you can replace some of the adjectives with synonyms. Write a function `replace_word_choice()` that takes in the parameters `sentence`, `old_word`, and `new_word`. This function should replace all instances of the `old_word` with the `new_word` and return the updated sentence. The function should return a `str`.
+
+```python
+>>> replace_word_choice("I bake good cakes", "good", "amazing")
+"I bake amazing cakes"
+```

exercises/concept/string-methods/.docs/introduction.md

@@ -0,0 +1,13 @@
+## string-methods
+
+Python provides a number of useful methods that you can use to manipulate
+strings. These methods can be used for cleaning, splitting, translating,
+or otherwise working with the str type. New strings can be created based
+on method arguments, and/or additional information can be returned. Strings
+can be concatenated using the `+` operator or with `str.join()`. Strings
+also implement all of the common sequence operations along with iteration using
+the `for item in <string>` syntax.
+
+`Strings` are immutable (meaning the value does not change), so each of these
+methods will actually return a new instance of `str` instead of modifying
+the existing one.

exercises/concept/string-methods/.meta/config.json

@@ -0,0 +1,8 @@
+{
+  "authors": [
+    {
+      "github_username": "kimolivia",
+      "exercism_username": "olivia"
+    }
+  ]
+}

exercises/concept/string-methods/.meta/design.md

@@ -0,0 +1,41 @@
+## Design
+
+## Goal
+
+The goal of this exercise is to teach helpful string manipulation methods and how to use them in Python.
+
+## Learning objectives
+
+- Know the `str` class and its core methods
+- Know when to use methods of str to operate on a string
+- Use several of the methods from each grouping below to operate on strings
+- Check if a given string ends/begins with the a specified suffix/prefix with the `endswith()`/ `startswith()` methods
+- Check if a given string is composed of certain code points/characters by using `isalnum()`, `isalph()`, `isascii()`, `isdecimal()`, `isdigit()`, or `isnumeric()` methods.
+- Return a new string that is a transform of the input string using `capitalize()`, `lower()`, `casefold()`, `swapcase()`, `upper()`, or `title()` methods
+- Return a new string that has leading/trailing whitespaces removed with `lstrip()`, `rstrip()`, or `strip()` methods
+- Check if a given substring is contained within a given string using `in`
+- Return a new string that replaces a given substring with a new value using the `replace()` method
+- Build a new string from an input iterable with `join()`
+
+## Out of scope
+
+- string formatting methods, "f-strings", "format strings"
+- string splitting
+- string translate methods (will have their own exercise)
+- string constants from the string module
+- built-ins that can take a str as an argument
+- encoding/decoding & codecs
+- the binary sequence types bytes, bytearray, and memoryview
+- binary transforms and text transforms
+- text encodings
+
+## Concepts
+
+- `string-methods`
+
+## Prerequisites
+
+- `booleans`
+- `strings`
+- `sequences`, `sequence type`
+- `iteration`

exercises/concept/string-methods/.meta/example.py

@@ -0,0 +1,13 @@
+def capitalize_title(title):
+    return title.title()
+
+def check_sentence_ending(sentence):
+    return sentence.endswith(".")
+
+def clean_up_spacing(sentence):
+    new_sentence = sentence.strip()
+    return new_sentence
+
+def replace_word_choice(sentence, new_word, old_word):
+    better_sentence = sentence.replace(new_word, old_word)
+    return better_sentence

exercises/concept/string-methods/str_methods.py

@@ -0,0 +1,11 @@
+def capitalize_title(title):
+    pass
+
+def check_sentence_ending(sentence):
+    pass
+
+def remove_extra_spaces(sentence):
+    pass
+
+def replace_word_choice(sentence, new_word, old_word):
+    pass

exercises/concept/string-methods/str_methods_test.py

@@ -0,0 +1,23 @@
+import unittest
+from str_methods import *
+
+
+class test_string_methods(unittest.TestCase):
+    def test_capitalize_title(self):
+        self.assertEqual(capitalize_title("fish are cold blooded"),
+                         "Fish Are Cold Blooded")
+
+    def test_sentence_ending(self):
+        self.assertEqual(check_sentence_ending("Snails can sleep for 3 years."), True)
+
+    def remove_extra_spaces(self):
+        self.assertEqual(remove_extra_spaces("  Elephants can't jump.  "),
+                        "Elephants can't jump.")
+
+    def test_replace_word_choice(self):
+        self.assertEqual(replace_word_choice("Animals are cool", "cool", "awesome"),
+                        "Animals are awesome")
+
+    def test_replace_word_not_exist(self):
+        self.assertEqual(replace_word_choice("Animals are cool", "small", "tiny"),
+                        "Animals are cool")