small fix

README.md

@@ -1,4 +1,4 @@
-### Welcome to the Public Repository of 01 Edu System
+### Welcome to the Public Repository of the 01 Edu System
 
 Our courses are meticulously studied in order to provide you with quality projects.
 Please take into account our approach before making **Issues**

subjects/addifpositive/README.md

@@ -0,0 +1,43 @@
+## add-if-positive 
+
+### Instructions
+Write a function that takes two numbers and adds them together if they are both positive.
+- If either number is negative or one of them is negative and the other is positive return `0`.
+
+### Expected function 
+```go
+func AddIfPositive(a int, b int) int {
+    // your code here
+}
+```
+
+### Usage
+
+Here is a possible program to test your function:
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    fmt.Println(AddIfPositive(1, 2))
+    fmt.Println(AddIfPositive(1, -2))
+    fmt.Println(AddIfPositive(-1, 2))
+    fmt.Println(AddIfPositive(-1, -2))
+    fmt.Println(AddIfPositive(10,20))
+    fmt.Println(AddIfPositive(0,20))
+}
+```
+
+and the output should be:
+
+```console
+$ go run .
+3
+0
+0
+0
+30
+20
+```

subjects/all/README.md

@@ -2,18 +2,17 @@
 
 ### Instructions
 
-Create a function `all` that works like `Promise.all` but with objects.
-(instead of arrays)
-
-### Notions
-
-- [nan-academy.github.io/js-training/examples/promise.js](https://nan-academy.github.io/js-training/examples/promise.js)
-- [devdocs.io/javascript/global_objects/promise/all](https://devdocs.io/javascript/global_objects/promise/all)
+Create a function named `all` that works like `Promise.all` but with objects (instead of arrays).
 
 ### Code provided
 
-> all code provided will be added to your solution and doesn't need to be submited.
+> The provided code will be added to your solution, and does not need to be submitted.
 
 ```js
 Promise.all = undefined
 ```
+
+### Notions
+
+- [Promise.js](https://nan-academy.github.io/js-training/examples/promise.js)
+- [Promise.all](https://devdocs.io/javascript/global_objects/promise/all)

subjects/alphaposition/README.md

@@ -0,0 +1,46 @@
+## alpha-position
+
+### Instructions
+
+Write a function named `AlphaPosition` that takes an alphabetical character as a parameter and returns the position of the letter in the alphabet.
+- If the character is not in the alphabet, return -1
+- If the character is in the alphabet, return the position of the letter in the alphabet
+  
+### Expected function
+
+```go
+func AlphaPosition(c rune) int {
+    // your code goes here
+}
+```
+
+### Usage
+
+Here is a possible program to test your function:
+
+```go 
+package main
+
+import "fmt"
+
+func main(){
+    fmt.Println(AlphaPosition('a'))
+    fmt.Println(AlphaPosition('z'))
+    fmt.Println(AlphaPosition('B'))
+    fmt.Println(AlphaPosition('Z'))
+    fmt.Println(AlphaPosition('0'))
+    fmt.Println(AlphaPosition(' '))
+}
+```
+
+And its output : 
+
+```console
+$ go run . | cat -e
+1$
+26$
+2$
+26$
+-1$
+-1$
+```

subjects/arraysum/README.md

@@ -0,0 +1,43 @@
+## array-sum
+
+### Instructions
+
+Write a function that takes an array of numbers and returns the sum of all the numbers in the array.
+- If the array is empty, the function should return 0.
+
+### Expected function
+
+```go
+func SumArray(numbers []int) int {
+    // your code here
+}
+```
+
+### Usage
+
+Here is a possible program to test your function:
+
+```go
+package main
+
+import (
+    "fmt"
+)
+
+func main(){
+    fmt.Println(SumArray([]int{1,2,3,4,5}))
+    fmt.Println(SumArray([]int{}))
+    fmt.Println(SumArray([]int{-1,-2,-3,-4,-5}))
+    fmt.Println(SumArray([]int{-1,2,3,4,-5}))
+}
+```
+
+and the output should be:
+
+```console
+$ go run . 
+15
+0
+-15
+3
+```

subjects/ascii-art/README.md

@@ -156,6 +156,24 @@ student$ go run . "Hello\nThere" | cat -e
    |_|    |_| |_|   \___|  |_|      \___| $
                                           $
                                           $
+student$ go run . "Hello\n\nThere" | cat -e
+ _    _           _    _           $
+| |  | |         | |  | |          $
+| |__| |   ___   | |  | |    ___   $
+|  __  |  / _ \  | |  | |   / _ \  $
+| |  | | |  __/  | |  | |  | (_) | $
+|_|  |_|  \___|  |_|  |_|   \___/  $
+                                   $
+                                   $
+$
+ _______   _                              $
+|__   __| | |                             $
+   | |    | |__      ___    _ __     ___  $
+   | |    |  _ \    / _ \  | '__|   / _ \ $
+   | |    | | | |  |  __/  | |     |  __/ $
+   |_|    |_| |_|   \___|  |_|      \___| $
+                                          $
+                                          $
 student$
 ```
 

subjects/ascii-art/audit/README.md

@@ -85,6 +85,30 @@
 
 ###### Does it display the right graphical representation in ASCII as above?
 
+##### Try passing `"Hello\n\nThere"` as an argument.
+
+```
+ _    _          _   _          $
+| |  | |        | | | |         $
+| |__| |   ___  | | | |   ___   $
+|  __  |  / _ \ | | | |  / _ \  $
+| |  | | |  __/ | | | | | (_) | $
+|_|  |_|  \___| |_| |_|  \___/  $
+                                $
+                                $
+$
+ _______   _                           $
+|__   __| | |                          $
+   | |    | |__     ___   _ __    ___  $
+   | |    |  _ \   / _ \ | '__|  / _ \ $
+   | |    | | | | |  __/ | |    |  __/ $
+   |_|    |_| |_|  \___| |_|     \___| $
+                                       $
+                                       $
+```
+
+###### Does it display the right graphical representation in ASCII as above?
+
 ##### Try passing `"{Hello & There #}"` as an argument.
 
 ```

subjects/ascii/README.md

@@ -0,0 +1,38 @@
+## ascii
+
+### Instructions
+
+Write a function that receives a string and returns a slice with the ASCII values of its characters. If the string is empty it should return an empty slice.
+
+### Expected function
+
+```go
+func Ascii(str string) []byte {
+
+}
+```
+
+### Usage
+
+Here is a possible program to test your function:
+
+```go
+package main
+
+import (
+    "piscine"
+    "fmt"
+)
+
+func main() {
+    l := piscine.Ascii("Hello")
+    fmt.Println(l)
+}
+```
+
+And its output:
+
+```console
+$ go run .
+[104 101 108 108 111]
+```

subjects/betweenus/README.md

@@ -0,0 +1,46 @@
+## between-us
+
+### Instructions
+
+Write a function named `BetweenUs` that takes 3 paramters and return : 
+- If the first paramter is between the second and third paramters, return **true** else return **false**
+- If the second parameter is bigger than the third return **false**
+
+### Expected function
+```go
+func BetweenUs(num, min, max int) bool {
+    // Your code here
+}
+```
+
+
+### Usage
+
+Here is a possible program to test your function:
+
+```go
+package main
+
+import "fmt"
+
+func main(){
+    fmt.Println(BetweenUs(1, 2, 3))
+    fmt.Println(BetweenUs(1, 1, 3))
+    fmt.Println(BetweenUs(1, 3, 3))
+    fmt.Println(BetweenUs(1, 1, 1))
+    fmt.Println(BetweenUs(1, 2, 1))
+    fmt.Println(BetweenUs(-1, -10, 0))
+}
+```
+
+and the output should be:
+
+```console
+$ go run .
+false
+true
+false
+true
+false
+true
+```

subjects/binaryaddition/README.md

@@ -0,0 +1,47 @@
+## binary-addition
+
+### Instructions
+
+Write a function named `BinaryAddition(int,int)` that takes two integers and returns the sum of the two in binary in an array of `int`.
+- If one of the integers is negative return `nil`
+- Convert the argument to binary then add the two binary numbers together
+
+### Expected function 
+```go
+func BinaryAddition(a int, b int) []int {
+    // your code here
+}
+```
+
+### Usage
+
+Here is a possible program to test your function:
+
+```go
+package main
+
+import "fmt"
+
+
+func main(){
+	fmt.Println(BinaryAddition(1, 1))
+	fmt.Println(BinaryAddition(1, 2))
+	fmt.Println(BinaryAddition(1, 3))
+	fmt.Println(BinaryAddition(2, 1))
+	fmt.Println(BinaryAddition(2, 2))
+	fmt.Println(BinaryAddition(1, 16))
+}
+```
+
+and the output should be:
+
+```console
+$ go run . 
+[1 0]
+[1 1]
+[1 0 0]
+[1 1]
+[1 0 0]
+[1 0 1]
+[1 0 0 0 1]
+```

subjects/clonernews/README.md

@@ -1,35 +1,30 @@
 ## clonernews
 
 ### Objectives
+Technology is a rapidly evolving sector. As a programmer, it is not always easy to keep up to date with every new advancement.
 
-Technology nowadays continue to evolve. As a programmer or developer you must be updated with this exponential evolution of technology.
+Tech news (like Hacker News) is a really great way to keep up to date with the exponential evolution of technology, as well as tech jobs and much more. Some websites do not offer very appealing propositions to consume their media.
 
-This is where tech news shines, just like Hacker News where you can see all about new technology, jobs and much more, but some websites do not perform very well or their are not so appealing.
-
-So your objective for this raid is to create an UI for [`HackerNewsAPI`](https://github.com/HackerNews/API).
+So your objective for this raid is to create an UI for the [HackerNews API](https://github.com/HackerNews/API).
 
 You must handle at least:
-
-- Posts, this includes :
+- Posts: including:
   - [stories](https://github.com/HackerNews/API#ask-show-and-job-stories)
   - [jobs](https://github.com/HackerNews/API#ask-show-and-job-stories)
   - [polls](https://github.com/HackerNews/API#items)
-- [comments](https://github.com/HackerNews/API#items), each comment must have the proper post parent.
+- [comments](https://github.com/HackerNews/API#items): each comment must have the proper post parent.
 
 Post and comments must be ordered by newest post to oldest.
-You must not load all posts at once. You must be able to load posts when ever the users need to see more posts. This can be done with the help of [event](https://developer.mozilla.org/en-US/docs/Web/Events).
-
-[Live Data](https://github.com/HackerNews/API#live-data) : is one of the features from this Hacker News API, you can handle requests so that the news you provide are updated.
-
-- You must have a section that present the newest information. You will have to notify the user at least every 5 seconds, whenever the live data is updated. In other words, after every 5 seconds if a change was made in the live data, you have to notify the user.
+You must not load all posts at once, so that you only load posts once the users need to see more posts. This can be done with the help of [events](https://developer.mozilla.org/en-US/docs/Web/Events).
 
-Currently this API does not present [rate limit](https://en.wikipedia.org/wiki/Rate_limiting). But that does not mean you should abuse/overload the API!!!
+The point of the project is to keep users updated, so we'll need to inform our users of changes to the data using [Live Data](https://github.com/HackerNews/API#live-data). Create a section that presents the newest information. You'll need to notify the user at least every 5 seconds, whenever the live data is updated.
 
-Best ways you can avoid rate limiting :
+Currently this API does not present a [rate limit](https://en.wikipedia.org/wiki/Rate_limiting), but that does not mean that you should abuse or overload the API.
 
+Best ways you can avoid rate limiting:
 - optimize your code to eliminate any unnecessary requests
-- usage of throttling/debouncing function to regulates the amount of requests
+- usage of a throttling/debouncing function to regulate the number of requests,
 
 ### Optional
 
-You can handle sub-comments for each stories, jobs and polls this meaning nested comments
+You can handle sub-comments for stories, jobs and polls, by implementing nested comments.

subjects/clonernews/audit/README.md

@@ -1,20 +1,20 @@
-#### Functionals
+#### Functional
 
 ##### Try to open a story post
 
-###### Does this post open without problems?
+###### Does this post open without any errors?
 
 ##### Try to open a job post
 
-###### Does this post open without problems?
+###### Does this post open without any errors?
 
 ##### Try to open a poll post
 
-###### Does this post open without problems?
+###### Does this post open without any errors?
 
 ##### Try to load more posts
 
-###### Did the posts loaded without error or without spamming the user?
+###### Did the posts load without error and without spamming the user?
 
 ##### Try to open a post with comments
 
@@ -24,16 +24,16 @@
 
 ###### Does the UI have at least stories, jobs and polls?
 
-###### Are the posts displayed in the correct order(from newest to oldest)?
+###### Are the posts displayed in the correct order (from newest to oldest)?
 
 ###### Does each comment present the right parent post?
 
-###### Is the UI notifying the user that there is a new update on a certain post?
+###### Does the UI notify the user when a certain post is updated?
 
-###### Is the project using Throttle to regulate the amount of request (every 5 seconds)?
+###### Is the project using throttling to regulate the number of requests (every 5 seconds)?
 
 #### Bonus
 
 ###### +Does the UI have more types of posts than stories, jobs and polls?
 
-###### +Are there sub-comments(nested comments) on the UI?
+###### +Have sub-comments (nested comments) been implemented?

subjects/countnegative/README.md

@@ -0,0 +1,40 @@
+## count-negative
+
+### Instructions 
+
+Write a function that takes an array of integers and returns the number of negative numbers in the array.
+- If the array is empty, the function should return `0`.
+
+### Expected function 
+```go 
+func CountNegative(numbers []int) int {
+    // your code here
+}
+```
+
+### Usage 
+
+Here is a possible program to test your function:
+
+```go
+package main 
+
+import "fmt"
+
+func main(){
+    fmt.Println(CountNegative([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}))
+    fmt.Println(CountNegative([]int{-1, -2, -3, -4, -5, -6, -7, -8, -9, -10}))
+    fmt.Println(CountNegative([]int{}))
+    fmt.Println(CountNegative([]int{-1,2,0,-3}))
+}
+```
+
+and the output should be:
+
+```console
+$ go run . 
+0
+10
+0
+2
+```

subjects/divisors/README.md

@@ -0,0 +1,41 @@
+## Devisor
+
+### Instructions
+
+Write a function that takes a positive  integer and returns the number of it's devisors.
+- If the the number a is negative return 0.
+- Test numbers from 0 to 99999999 .
+
+### Expected function
+```go
+func Divisors(n int) int {        
+    ...
+}
+```
+### Usage
+
+Here is a possible program to test your function:
+
+```go
+package main
+
+import (
+    "fmt"
+    "piscine"
+)
+
+func main() {
+    fmt.Println(piscine.Divisors(4))// 4 can be divided by 1 and 2 and 4
+    fmt.Println(piscine.Divisors(5))//5 can be divided by 1 and 5
+}
+
+```
+
+And its output :
+
+
+```console
+$ go run .
+3 
+2 
+```

subjects/getarea/README.md

@@ -0,0 +1,25 @@
+## get-area
+
+### Instructions
+
+Write a program that takes a positive number as radius and prints the area of a circle.
+  - The area of the circle is `3.14` times the radius squared.
+  - Only positive numbers will be accepted, otherwise print `Error` followed by (`'\n'`)
+  - If the number of arguments is not `1` print (`'\n'`)
+  - The output must be an integer.
+
+
+###  Usage
+
+```console
+$ go run . | cat -e
+$
+$ go run . 10 | cat -e
+314$
+$ go run . 4 | cat -e
+50$
+$ go run . -10 | cat -e
+Error$
+$ go run . "Hello World!" | cat -e
+Error$
+```

subjects/gougle-search/README.md

@@ -2,16 +2,11 @@
 
 ### Instructions
 
-Create the `queryServers` function, that takes 2 arguments:
-
-- `serverName` a string of the name of the server
-- `q` a string of the query given by the user
-
-You have to construct 2 urls, using `q` as a search parameter,
-prepending a `'/'` and for the 2nd appending `'_backup'`.
-
-Then return the first value of those 2 calls
+Create a function named `queryServers` that takes 2 arguments:
+- `serverName`: a string of the name of the server.
+- `q`: a string of the query given by the user.
 
+You need to construct 2 urls which should work like this:
 ```js
 queryServers('pouet', 'hello+world')
 // return the fastest of those 2 calls:
@@ -19,25 +14,26 @@ queryServers('pouet', 'hello+world')
 // -> getJSON('/pouet_backup?q=hello+world')
 ```
 
-Create a `gougleSearch` function that takes a single query argument.
-It must call `queryServers` in concurrently on 3 servers:
-`'web'`, `'image'` and `'video'`.
-
-A timeout of 80milliseconds must be set for the whole operation.
+Create a function named: `gougleSearch` that takes a single query argument (`q`). It must invoke `queryServers` concurrently on 3 servers:
+- `"web"`
+- `"image"`
+- `"video"`
 
-You must return the value from each server in an object
-using  the server name as key.
+You must return the value from each server in an object using  the server name as key.
 
-### Notions
+A timeout of 80milliseconds must be set for the whole operation, if it is not complete within 80 milliseconds, then you must return `Error('timeout')`.
 
-- [devdocs.io/javascript/global_objects/promise/race](https://devdocs.io/javascript/global_objects/promise/race)
-- [devdocs.io/javascript/global_objects/promise/all](https://devdocs.io/javascript/global_objects/promise/all)
 
 ### Code provided
 
-> all code provided will be added to your solution and doesn't need to be submited.
+> The provided code will be added to your solution, and does not need to be submitted.
 
 ```js
 // fake `getJSON` function
 let getJSON = async (url) => url
 ```
+
+### Notions
+
+- [Promise.race](https://devdocs.io/javascript/global_objects/promise/race)
+- [Promise.all](https://devdocs.io/javascript/global_objects/promise/all)

subjects/is-winner/README.md

@@ -2,27 +2,23 @@
 
 ### Instructions
 
-Create a function `isWinner` that, by making use of `winners` "API", should
-return a resolved Promise with the string:
+Create a function named `isWinner` which accepts a string representing the name of a country. It should use the `winners` _"API"_ to return a resolved `Promise` with an appropriate string.
 
-- `<country> + ' never was a winner'`, if the country passed in `isWinner` has never won  the FIFA World Cup
+The strings which can be returned are listed below. You'll need to replace `"Country"` with the country named which is passed to `isWinner`:
 
-- `<country> + ' is not what we are looking for because of the continent'`,
-  if the country passed in `isWinner` is not from the european
-  continent
+- `"Country never was a winner"`: The country has never won a FIFA world cup.
 
-- `<country> + ' is not what we are looking for because of the number of times it was champion'`, if the country passed in `isWinner` was champion
-  less than 3 times
+- `"Country is not what we are looking for because of the continent"`: The country is not from the european continent.
 
-- `<country> + ' won the FIFA World Cup in ' + <year(s)> + 'winning by ' + <results>`, otherwise.
+- `"Country is not what we are looking for because of the number of times it was champion"`: The country won the FIFA world cup fewer than 3 times.
 
-The years and results should be displayed like bellow:
-
-```<country> + ' won the FIFA World Cup in 1000, 1004, 1008 winning by 4-3, 5-2, 1-0```
+- `"Country won the FIFA World Cup in <years> winning by <results>"`: with the following format:
+  - `<years>`: `"1000, 1004, 1008"`
+  - `<results>`: `"4-3, 5-2, 1-0"`
 
 ### Code provided
 
-> all code provided will be added to your solution and doesn't need to be submitted.
+> The provided code will be added to your solution, and does not need to be submitted.
 
 ```js
 const db = (() => {

subjects/ismultiple/README.md

@@ -0,0 +1,45 @@
+## common-multiples
+
+### Instructions
+
+Write a function to check whether a given non-negative number is a multiple of 3 or 7.
+- If the number is a multiple of 3 or 7, return `true`.
+- If the number is not a multiple of 3 or 7, return `false`.
+- If the number is less or equal to 0, return `false`.
+
+### Expected function
+
+```go
+func IsMultiple(number int) bool {
+    // Your code here
+}
+```
+
+### Usage
+
+Here is a possible program to test your function:
+
+```go
+package main
+
+import "fmt"
+
+func main() {
+    fmt.Println(IsMultiple(3))
+    fmt.Println(IsMultiple(7))
+    fmt.Println(IsMultiple(8))
+    fmt.Println(IsMultiple(9))
+    fmt.Println(IsMultiple(-1))
+}
+```
+
+and the output should be:
+
+```console
+$ go run .
+true
+true
+false
+true
+false
+```

subjects/leapyear/README.md

@@ -0,0 +1,41 @@
+## leap-year
+
+### Instructions
+
+Write a function named `LeapYear(int)` that takes a year as a parameter and returns true if the year is a leap year and false otherwise.
+- A leap year is a year divisible by 4, but not by 100.
+- A leap year is also divisible by 400.
+- If the number is not positive, return false
+
+### Expected function
+
+```go
+func LeapYear(year int)bool{
+  // your code here
+}
+```
+### Usage
+
+Here is a possible program to test your function:
+
+```go 
+package main
+
+import "fmt"
+
+func main(){
+  fmt.Println(LeapYear(2020))
+  fmt.Println(LeapYear(2021))
+  fmt.Println(LeapYear(2022))
+  fmt.Println(LeapYear(-10))
+}
+```
+and the output should be:
+
+``` console
+$ go run . | cat -e
+true$
+false$
+false$
+false$
+```

subjects/manipulate-values/README.md

@@ -4,7 +4,7 @@
 
 Let's buy groceries.
 
-You have a grocery cart with some items you need. The item's name if the `key`, and the `value` will represent nutrition facts per 100 grams.
+You have a grocery cart with some items you need. The item's name is the `key`, and the `value` will represent nutrition facts per 100 grams.
 
 Create 3 functions that work like the `.filter`, `.map` and `.reduce` array methods, for the values in your grocery cart object. You can see their function names and how they work in the examples.
 

subjects/paramrange/README.md

@@ -0,0 +1,20 @@
+## param-range
+
+### instructions
+
+Write a program that takes a number in the arguments and prints the max and min.
+- If the number of arguments is less than 2 print (`'\n'`)
+- If one of the arguments is not a number, print (`"Error\n"`)
+- The output should be space-separated and (`'\n'`) at the end.
+
+### Usage
+```console
+$ go run . | cat -e
+$
+$ go run . 1 2 3 4 5 6 7 8 9 | cat -e
+1 9$
+$ go run . "-1" "1" | cat -e
+-1 1$
+$ go run . 1 a 2 3 4 5 6 7 8 9 | cat -e
+Error$
+```

subjects/printascii/README.md

@@ -0,0 +1,23 @@
+## print-ascii
+
+### Instructions
+
+Write a program that prints the ASCII value of a letter passed in the command line
+- If the argument is not a letter nothing will be printed
+- if the number of arguments is not 1 then nothing will be printed
+
+### Usage
+
+```console
+$ go run .
+$ go run . a
+97
+$ go run . 'A'
+65
+$ go run . 'z'
+122
+$ go run . Z
+90
+$ go run . 1
+$ go run . "Hello" "Word"
+```

subjects/race/README.md

@@ -2,22 +2,20 @@
 
 ### Instructions
 
-Create a function `race` that works like `Promise.race`
+Create two functions:
+- `race`: that works like `Promise.race`.
+- `some`: that takes an `array` of promises or values, and `count` number. It should return the first `count` resolved values. Empty arrays or a `count` of 0 return a promise resolving to `undefined`.
 
-Create a function `some` that takes an `array` of promises or values
-and `N` number. It should return the first `N` resolved values.
-
-> Empty array or a count of 0 return a promise resolving to `undefined`
-
-### Notions
-
-- [nan-academy.github.io/js-training/examples/promise](https://nan-academy.github.io/js-training/examples/promise.js)
-- [devdocs.io/javascript/global_objects/promise/race](https://devdocs.io/javascript/global_objects/promise/race)
 
 ### Code provided
 
-> all code provided will be added to your solution and doesn't need to be submited.
+> The provided code will be added to your solution, and does not need to be submitted.
 
 ```js
 Promise.race = undefined
 ```
+
+### Notions
+
+- [Promise](https://nan-academy.github.io/js-training/examples/promise.js)
+- [Promise.race](https://devdocs.io/javascript/global_objects/promise/race)

subjects/rotargn/README.md

@@ -0,0 +1,27 @@
+## rot-arg-n
+
+### Instructions
+
+Write a program that takes arguments from the command line and rotates them by the number in the first argument.
+- If the number of arguments is less than 3 print (`'\n'`)
+- If the first argument is not a number, the program should print `"Error\n"`
+- If the first argument is negative, the program should print `"Error\n"`
+- If the first argument is zero, the program should print the original arguments
+- Prints the rotated arguments with a space between each argument and a newline at the end.
+
+### Usage
+
+```console
+$ go run . | cat -e
+$
+$ go run . 1 2 3 4 5 | cat -e
+3 4 5 2$
+$ go run . 2 "Hello" "World" | cat -e
+Hello World$
+$ go run . -1 2 3 4 5 | cat -e
+Error$
+$ go run . 0 2 3 4 5 | cat -e
+2 3 4 5$
+$ go run . 3 "Hello" "World" | cat -e
+World Hello$
+```

subjects/series/README.md

@@ -2,9 +2,8 @@
 
 ### Instructions
 
-Create a function `series` that takes an array of async functions.
-It must execute them in series and return the results in order.
+Create a function named `series` that takes an array of `async` functions. It must execute them in series and return the results in order.
 
 ### Notions
 
-- [nan-academy.github.io/js-training/examples/promise](https://nan-academy.github.io/js-training/examples/promise.js)
+- [Promise](https://nan-academy.github.io/js-training/examples/promise.js)

subjects/ultimatedivmod/README.md

@@ -2,7 +2,7 @@
 
 ### Instructions
 
-- Write a function that will be formatted as below.
+Create the following function.
 
 ### Expected function
 
@@ -11,10 +11,9 @@ func UltimateDivMod(a *int, b *int) {
 
 }
 ```
-
-- This function will divide the `int` **a** and **b**.
-- The result of this division will be stored in the `int` pointed by **a**.
-- The remainder of this division will be stored in the `int` pointed by **b**.
+`UltimateDivMod` should divide the dereferenced value of `a` by the dereferenced value of `b`.
+- Store the result of the division in the `int` which `a` points to.
+- Store the remainder of the division in the `int` which `b` points to.
 
 ### Usage