Implement new Concept Exercise: loops exercism#1430 (exercism#2302)

* Loops Concept Exercise First Change

* Review Change 1

* Update languages/exercises/concept/loops/.docs/instructions.md

* Update languages/exercises/concept/loops/.docs/instructions.md

* Update languages/exercises/concept/loops/.docs/instructions.md

* Update languages/exercises/concept/loops/.docs/instructions.md

* Update languages/exercises/concept/loops/.docs/instructions.md

* Update languages/exercises/concept/loops/.docs/instructions.md

* Update languages/exercises/concept/loops/.docs/instructions.md

* Update languages/exercises/concept/loops/.docs/introduction.md

* Update languages/exercises/concept/loops/.docs/introduction.md

* Update languages/exercises/concept/loops/.docs/introduction.md

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

Author: 2 people

exercises/concept/loops/.docs/after.md

@@ -0,0 +1,101 @@
+## Loops in Python
+
+There is always a scenario where you would need to go through a [`list` or `group`] of [`things` or `object` or `values`].
+When you have an `array` of objects or values to process, you need to `iterate` on the array and process them. You are going to do a repeated set of instructions on every single object or value in an array.
+
+There are 2 ways to loop through objects.
+
+- `while` loop
+- `for` loop
+
+## While loops
+
+While loops are based on `conditional` statement for looping through objects.
+
+```
+while expression:
+    set_of_statements
+```
+
+When the expression evaluates to `True` (truthiness) the loop will execute the set of statements till it reaches the end of the indent block. It will execute the loop again until the expression evaluates to `False`.
+
+```python
+i = 0
+while i < 3:
+    print(i)
+# => 0
+# => 1
+# => 2
+```
+
+## For Loops
+
+While loops are based on `Iterational` statement. The Loop will iterate over a `iterable` object.
+
+```
+for item in iterable_object:
+    set_of_statements
+```
+
+```python
+list_of_items = [1, 2, 3]
+for item in list_of_items:
+    print(item)
+# => 1
+# => 2
+# => 3
+```
+
+## Breaking from loops
+
+Where you have a large set of objects that you want to loop through and you dont want to go through all the objects in the loop but rather go through a certain number of desired objects and then stop the execution, then `break` comes to the rescue.
+
+When you want to break from an iterable loop on any condition, you can use the `break` statement
+
+```python
+list_of_items = [1, 2, 3, 4, 5, 6, 7, 8]
+for item in list_of_items:
+    if item > 5:
+        break
+    print(item)
+# => 1
+# => 2
+# => 3
+# => 4
+# => 5
+```
+
+## Continuing in loops
+
+You will have important objects as well as non important ones. When you want to skip over the objects that you dont need to process you use the continue statement.
+
+Example: you want to process only odd numbers in a loop and not the event numbers.
+
+```python
+all_numbers = [1, 2, 3, 4, 5, 6, 7, 8]
+for num in all_numbers:
+    if num % 2 == 0:
+        continue
+    print(num)
+# => 1
+# => 3
+# => 5
+# => 7
+```
+
+## Else in Loops
+
+An `else` clause in a loop will get executed when there is no `break` that happebed while you were processing your loop.
+This gets useful if you want to go over fail over scenarios.
+
+```python
+x = None
+for i in list_of_items:
+    if i > 10:
+        x = i
+        break
+else:
+    x = 10
+```
+
+What the above code does is it sets the variable x to 10 if the loop inside was not able to find an item that is more than 10.

exercises/concept/loops/.docs/hints.md

@@ -0,0 +1,21 @@
+## General
+
+- Make sure you are comfortable with using the `in` concept while looping through in for loops.
+
+You are a teacher and you are correcting papers of your students who wrote an exam you just conducted. You are tasked with the following activities.
+
+## 1. Failed Students
+
+- Iterate through the marks one by one. For each loop check if the mark is less than or equal to 40. If so, then increment a count and after iterating through all marks in the loop return the count.
+
+## 2. Top Marks
+
+- Iterate through the list of marks one by one. If you find a mark which is more than x, just continue and go to the next mark.
+
+## 3. First K Students.
+
+- Start an index variable at 0 and loop through the elements till we reach the index variable equals to k. once that happens you can return the marks.
+
+## 4. Full Marks
+
+- There may be or may not be a student with full marks - 100. Either way you have to loop through all the marks and find whether we have a student with full marks else just return No Hundreds

exercises/concept/loops/.docs/instructions.md

@@ -0,0 +1,62 @@
+You are a teacher and you are correcting papers of your students who wrote an exam you just conducted. You are tasked with the following activities.
+
+## 1. Failed Students
+
+Create the function `count_failed_students()` that takes one parameter: `student_marks`. This function should count the number of students who have failed the subject, returning the count as an integer. We say that a student has failed if their mark is less than or equal to **40**.
+
+Note: `Iterate` through the student marks to find out your answer.
+​
+Result should be an `int`.
+
+```python
+>>> count_failed_students(student_marks=[90,40,55,70,30]))
+2
+```
+
+## 2. Top Marks
+
+The Headmaster wants to find the group of top students. What qualifies student marks as `top marks` fluctuates, and you will need to find the student marks that are **greater than or equal to** the current threshold.
+
+Create the function `above_threshold()` where `student_marks` and `threshold` are the two required parameters:
+
+1. `student_marks` are a list of marks for each student
+2. `threshold` is the top mark threshold. Marks greater than or equal to this number are considered "top marks" .
+
+This function should return a `list` of all marks that are greater than or equal to a scoring threshold.
+
+**Note:** If you find a mark which is less than the threshold, you should `continue` to evaluating the next mark.​
+
+```python
+>>> above_threshold(student_marks=[90,40,55,70,30], 70)
+[90, 70]
+```
+
+## 3. First K Students.
+
+Create the function `first_k_student_marks()` with parameters `student_marks` and `k`
+
+1. Student marks are a list of marks of each student
+2. k is the number of students.
+
+You need to return the first K number of student Marks. Once you reach K number of students, you should exit out of the loop.
+
+```python
+>>> first_k_student_marks(student_marks=[90,80,100], k=1)
+[90]
+```
+
+## 4. Full Marks
+
+Create the function `perfect_score()` with parameter `student_info`.
+`student_info` is a dictionary containing the names and marks of the students `{"Charles": 90, "Tony": 80}`
+
+Find if we have any students who scored "full marks"(_100%_)on the exam. If we don't find any "full marks" in `student_info`, we should return "No hundreds"
+
+Return the first student who has scored full marks - 100.
+
+```python
+>>> perfect_score(student_info={"Charles": 90, "Tony": 80, "Alex":100})
+Alex
+>>> perfect_score(student_info={"Charles": 90, "Tony": 80})
+No hundreds
+```

exercises/concept/loops/.docs/introduction.md

@@ -0,0 +1,82 @@
+## Loops in Python
+
+There are 2 general ways in Python to loop through objects.
+
+- `while` loop (_indefinite_, or _uncounted_)
+- `for` loop (_definite_, or _counted_)
+
+## While loops
+
+While loops are _uncounted_ and based on a `conditional` statement for looping through objects.
+
+```
+while expression:
+    set_of_statements
+```
+
+When the statement evaluates to `True`, the loop advances and executes the code in the indented block - or "body" of the loop. Looping continues in this fashion until the conditional statement evaluates to `False`.
+
+```python
+i = 0
+while i < 3:
+    print(i)
+# => 0
+# => 1
+# => 2
+```
+
+## For Loops
+
+Unlike `while` loops, `for` loops are based on a counter. The Loop will execute until the counter/object being counted is exhausted. The counter in this case could be the indexes in a `list`, `string`, or `tuple` -- or the indexes in a `range()` object.
+
+```python
+for item in countable_object:
+    set_of_statements
+```
+
+```python
+>>> numbers = [1, 2, 3, 4, 5]
+
+>>> for number in numbers:
+         print(number)
+#=> 1
+#=> 2
+#=> 3
+#=> 4
+#=> 5
+```
+
+## Breaking from loops
+
+Where you have a large set of objects that you want to loop through but would like to stop the loop execution when a certain condition is met, the `break` statement comes to the rescue.
+
+```python
+list_of_items = [1, 2, 3, 4, 5, 6, 7, 8]
+for item in list_of_items:
+    if item > 5:
+        break
+    print(item)
+# => 1
+# => 2
+# => 3
+# => 4
+# => 5
+```
+
+## Continuing in loops
+
+You will have important objects as well as non important ones. When you want to skip over the objects that you don't need to process you use the `continue` statement.
+
+Example: you want to process only odd numbers in a loop and not the event numbers.
+
+```python
+all_numbers = [1, 2, 3, 4, 5, 6, 7, 8]
+for num in all_numbers:
+    if num % 2 == 0:
+        continue
+    print(num)
+# => 1
+# => 3
+# => 5
+# => 7
+```

exercises/concept/loops/.meta/config.json

@@ -0,0 +1,12 @@
+{
+  "authors": [
+    {
+      "github_username": "mohanrajanr",
+      "exercism_username": "mohanrajanr"
+    },
+    {
+      "github_username": "BethanyG",
+      "exercism_username": "BethanyG"
+    }
+  ]
+}

exercises/concept/loops/.meta/design.md

@@ -0,0 +1,37 @@
+## Goal
+
+This concept exercise should convey a basic understanding of how to handle the `for` loop and `while` in Python. This concept exercise should also teach how to interrupt or change the normal flow of a loop using the `break` statement and the `continue` statement.
+
+## Learning objectives
+
+- use `while` to make a loop: execute something as long as an expression/test is `true`
+- use `for` to iterate over an iterable object with the `for ... in` pattern. The Membership testing concept (in) is required to address this concept.
+- understand the differences between `while` (indefinite, condition-dependent) and `for` (definite, length or count dependent) loops
+- use `break` statement to terminate the nearest enclosing loop
+- use `continue` statement to continue with the next cycle of the nearest enclosing loop
+
+## Out of scope
+
+- async loops (advanced)
+
+## Concepts
+
+- `while` loops
+- `for` loops
+- `break` statement
+- `continue` statement
+
+## Prerequisites
+
+- `basics`
+- `numbers`
+- `arithmetic`
+
+## Resources
+
+- [The while key](https://yawpitchroll.com/posts/the-35-words-you-need-to-python/#while)
+- [The for loop](https://yawpitchroll.com/posts/the-35-words-you-need-to-python/#for)
+- [The break statement](https://yawpitchroll.com/posts/the-35-words-you-need-to-python/#break)
+- [The break statement python docs](https://docs.python.org/3/reference/simple_stmts.html#the-break-statement)
+- [The continue statement](https://yawpitchroll.com/posts/the-35-words-you-need-to-python/#continue)
+- [The continue statement python docs](https://docs.python.org/3/reference/simple_stmts.html#the-continue-statement)

exercises/concept/loops/.meta/example.py

@@ -0,0 +1,28 @@
+def count_failed_students(student_marks):
+    failed_marks = 0
+    for mark in student_marks:
+        if mark <=40:
+            failed_marks +=1
+    return failed_marks
+
+def above_threshold(student_marks, x):
+    above_marks = []
+    for mark in student_marks:
+        if mark < x:
+            continue
+        above_marks.append(mark)
+    return above_marks
+
+def first_k_student_marks(student_marks, k):
+    i = 0
+    marks = []
+    while i <= k:
+        marks.append(student_marks[i])
+    return marks
+
+def perfect_score(student_info):
+    for name, mark in student_info.items():
+        if mark == 100:
+            return name
+    else:
+        return "No hundreds"

exercises/concept/loops/loops.py

@@ -0,0 +1,11 @@
+def count_failed_students(student_marks):
+    pass
+
+def above_threshold(student_marks, x):
+    pass
+
+def first_k_student_marks(student_marks, k):
+    pass
+
+def perfect_score(student_info):
+    pass