docs: Readme

Update readmes

Author: marcobiedermann

.prettierignore

@@ -0,0 +1,3 @@
+coverage
+dist
+node_modules

CODE_OF_CONDUCT.md

@@ -14,22 +14,22 @@ appearance, race, religion, or sexual identity and orientation.
 Examples of behavior that contributes to creating a positive environment
 include:
 
-* Using welcoming and inclusive language
-* Being respectful of differing viewpoints and experiences
-* Gracefully accepting constructive criticism
-* Focusing on what is best for the community
-* Showing empathy towards other community members
+- Using welcoming and inclusive language
+- Being respectful of differing viewpoints and experiences
+- Gracefully accepting constructive criticism
+- Focusing on what is best for the community
+- Showing empathy towards other community members
 
 Examples of unacceptable behavior by participants include:
 
-* The use of sexualized language or imagery and unwelcome sexual attention or
- advances
-* Trolling, insulting/derogatory comments, and personal or political attacks
-* Public or private harassment
-* Publishing others' private information, such as a physical or electronic
- address, without explicit permission
-* Other conduct which could reasonably be considered inappropriate in a
- professional setting
+- The use of sexualized language or imagery and unwelcome sexual attention or
+  advances
+- Trolling, insulting/derogatory comments, and personal or political attacks
+- Public or private harassment
+- Publishing others' private information, such as a physical or electronic
+  address, without explicit permission
+- Other conduct which could reasonably be considered inappropriate in a
+  professional setting
 
 ## Our Responsibilities
 

kata/5 kyu/is-my-friend-cheating/readme.md

@@ -5,21 +5,23 @@
 - He says that the product of a and b should be equal to the sum of all numbers in the sequence, excluding a and b.
 - Given a number n, could you tell me the numbers he excluded from the sequence?
 
-The function takes the parameter: `n` (n is always strictly greater than 0) and returns an array or a string (depending on the language) of the form:
+The function takes the parameter: `n`
+(n is always strictly greater than 0) and returns an array or a string (depending on the language) of the form:
 
 ```
 [(a, b), ...] or [[a, b], ...] or {{a, b}, ...} or or [{a, b}, ...]
 ```
 
-with all `(a, b)` which are the possible removed numbers in the sequence `1 to n`.
+with **all** `(a, b)` which are the possible removed numbers in the sequence `1 to n`.
 
-`[(a, b), ...] or [[a, b], ...] or {{a, b}, ...} or ...` will be sorted in increasing order of the "a".
+`[(a, b), ...] or [[a, b], ...] or {{a, b}, ...} or ...`will be sorted in increasing order of the "a".
 
-It happens that there are several possible (a, b). The function returns an empty array (or an empty string) if no possible numbers are found which will prove that my friend has not told the truth! (Go: in this case return `nil`).
+It happens that there are several possible (a, b).
+The function returns an empty array (or an empty string) if no possible numbers are found which will prove that my friend has not told the truth! (Go: in this case return `nil`).
 
 (See examples of returns for each language in "RUN SAMPLE TESTS")
 
-## Examples:
+# Examples:
 
 ```
 removNb(26) should return [(15, 21), (21, 15)]
@@ -56,3 +58,15 @@ in C:
 removNb(26) should return  **an array of pairs {{15, 21}{21, 15}}**
 tested by way of strings.
 ```
+
+---
+
+## Tags
+
+- Algorithms
+- Data Types
+- Fundamentals
+- Logic
+- Mathematics
+- Numbers
+- Puzzles

kata/5 kyu/simple-pig-latin/readme.md

@@ -4,7 +4,48 @@ Move the first letter of each word to the end of it, then add "ay" to the end of
 
 ## Examples
 
-```js
+```javascript
 pigIt('Pig latin is cool'); // igPay atinlay siay oolcay
 pigIt('Hello world !'); // elloHay orldway !
 ```
+
+```objc
+pigIt(@"Pig latin is cool"); // => @"igPay atinlay siay oolcay"
+pigIt(@"Hello world !");     // => @"elloHay orldway !"
+```
+
+```ruby
+pig_it('Pig latin is cool') # igPay atinlay siay oolcay
+pig_it('Hello world !')     # elloHay orldway !
+```
+
+```python
+pig_it('Pig latin is cool') # igPay atinlay siay oolcay
+pig_it('Hello world !')     # elloHay orldway !
+```
+
+```csharp
+Kata.PigIt("Pig latin is cool"); // igPay atinlay siay oolcay
+Kata.PigIt("Hello world !");     // elloHay orldway !
+```
+
+```C++
+pig_it("Pig latin is cool");   // igPay atinlay siay oolcay
+pig_it("Hello world !");       // elloHay orldway
+```
+
+```Java
+PigLatin.pigIt('Pig latin is cool'); // igPay atinlay siay oolcay
+PigLatin.pigIt('Hello world !');     // elloHay orldway !
+```
+
+```clojure
+(piglatin/pig-it "Pig latin is cool") ; "igPay atinlay siay oolcay"
+(piglatin/pig-it "Hello world !")     ; "elloHay orldway !"
+```
+
+---
+
+## Tags
+
+- Algorithms

kata/5 kyu/valid-parentheses/readme.md

@@ -13,6 +13,17 @@ Write a function called that takes a string of parentheses, and determines if th
 
 ## Constraints
 
+`0 <= input.length <= 100`
+
+```if-not:javascript,go
+Along with opening (`(`) and closing (`)`) parenthesis, input may contain any valid ASCII characters.  Furthermore, the input string may be empty and/or not contain any parentheses at all.  Do **not** treat other forms of brackets as parentheses (e.g. `[]`, `{}`, `<>`).
 ```
-0 <= input.length <= 100
-```
+
+---
+
+## Tags
+
+- Algorithms
+- Logic
+- Utilities
+- Validation

kata/6 kyu/array-dot-diff/readme.md

@@ -4,12 +4,132 @@ Your goal in this kata is to implement a difference function, which subtracts on
 
 It should remove all values from list `a`, which are present in list `b`.
 
-```py
+```javascript
+arrayDiff([1, 2], [1]) == [2];
+```
+
+```ruby
+array_diff([1,2],[1]) == [2]
+```
+
+```python
 array_diff([1,2],[1]) == [2]
 ```
 
+```coffeescript
+arrayDiff([1,2],[1]) == [2]
+```
+
+```haskell
+difference [1,2] [1] == [2]
+```
+
+```csharp
+Kata.ArrayDiff(new int[] {1, 2}, new int[] {1}) => new int[] {2}
+```
+
+```fsharp
+arrayDiff [|1|] [|1; 2|] = [|2|]
+```
+
+```rust
+array_diff(vec![1,2], vec![1]) == vec![2]
+```
+
+```clojure
+(= (array-diff [1 2] [1]) [2])
+```
+
+```groovy
+Kata.arrayDiff([1,2],[1]) == [2]
+```
+
+```julia
+arraydiff([1,2],[1]) == [2]
+```
+
+```nim
+arrayDiff(@[1,2],@[1]) == @[2]
+```
+
+```php
+arrayDiff([1,2],[1]) == [2]
+```
+
+```r
+array_diff(c(1, 2), 1) == 2
+```
+
+```prolog
+array_diff([1, 2], [1], [2]). % Result = [2]
+```
+
 If a value is present in `b`, all of its occurrences must be removed from the other:
 
-```py
+```javascript
+arrayDiff([1, 2, 2, 2, 3], [2]) == [1, 3];
+```
+
+```ruby
+array_diff([1,2],[1]) == [2]
+```
+
+```python
 array_diff([1,2,2,2,3],[2]) == [1,3]
 ```
+
+```coffeescript
+arrayDiff([1,2,2,2,3],[2]) == [1,3]
+```
+
+```haskell
+difference [1,2,2,2,3] [2] == [1,3]
+```
+
+```csharp
+Kata.ArrayDiff(new int[] {1, 2, 2, 2, 3}, new int[] {2}) => new int[] {1, 3}
+```
+
+```fsharp
+arrayDiff [|2|] [|1; 2; 2; 2; 3|] = [|1; 3|]
+```
+
+```rust
+array_diff(vec![1,2,2,2,3], vec![2]) == vec![1,3]
+```
+
+```clojure
+(= (array-diff [1,2,2,2,3] [2]) [1,3])
+```
+
+```groovy
+Kata.arrayDiff([1,2,2,2,3],[2]) == [1,3]
+```
+
+```julia
+arraydiff([1,2,2,2,3],[2]) == [1,3]
+```
+
+```nim
+arrayDiff(@[1,2,2,2,3],@[2]) == @[1,3]
+```
+
+```php
+arrayDiff([1,2,2,2,3],[2]) == [1,3]
+```
+
+```r
+array_diff(c(1, 2, 2, 2, 3), 2) == c(1, 3)
+```
+
+```prolog
+array_diff([1, 2, 2, 2, 3], [2], [1, 3]). % Result = [1, 3]
+```
+
+---
+
+## Tags
+
+- Arrays
+- Data Types
+- Fundamentals

kata/6 kyu/bit-counting/readme.md

@@ -3,3 +3,11 @@
 Write a function that takes an integer as input, and returns the number of bits that are equal to one in the binary representation of that number. You can guarantee that input is non-negative.
 
 _Example_: The binary representation of `1234` is `10011010010`, so the function should return `5` in this case
+
+---
+
+## Tags
+
+- Algorithms
+- Binary
+- Bits

kata/6 kyu/build-a-pile-of-cubes/readme.md

@@ -1,10 +1,16 @@
 # [Build a pile of Cubes](https://www.codewars.com/kata/5592e3bd57b64d00f3000047)
 
-Your task is to construct a building which will be a pile of n cubes. The cube at the bottom will have a volume of n^3, the cube above will have volume of (n-1)^3 and so on until the top which will have a volume of 1^3.
+Your task is to construct a building which will be a pile of n cubes.
+The cube at the bottom will have a volume of n^3, the cube above
+will have volume of (n-1)^3 and so on until the top which will have a volume of 1^3.
 
-You are given the total volume m of the building. Being given m can you find the number n of cubes you will have to build?
+You are given the total volume m of the building.
+Being given m can you find the number n of cubes you will have to build?
 
-The parameter of the function findNb `(find_nb, find-nb, findNb)` will be an integer m and you have to return the integer n such as n^3 + (n-1)^3 + ... + 1^3 = m if such a n exists or -1 if there is no such n.
+The parameter of the function findNb `(find_nb, find-nb, findNb)` will be an integer m
+and you have to return the integer n such as
+n^3 + (n-1)^3 + ... + 1^3 = m
+if such a n exists or -1 if there is no such n.
 
 ## Examples:
 
@@ -13,10 +19,17 @@ findNb(1071225) --> 45
 findNb(91716553919377) --> -1
 ```
 
-```py
+```nasm
 mov rdi, 1071225
 call find_nb            ; rax <-- 45
 
 mov rdi, 91716553919377
 call find_nb            ; rax <-- -1
 ```
+
+---
+
+## Tags
+
+- Fundamentals
+- Optimization

kata/6 kyu/consecutive-strings/readme.md

@@ -1,13 +1,20 @@
 # [Consecutive strings](https://www.codewars.com/kata/56a5d994ac971f1ac500003e)
 
-You are given an array `strarr` of strings and an integer `k`. Your task is to return the **first** longest string consisting of k **consecutive** strings taken in the array.
+You are given an array `strarr` of strings and an integer `k`. Your task is to return the **first** longest string
+consisting of k **consecutive** strings taken in the array.
 
-## Example:
+# Example:
 
 longest_consec(["zone", "abigail", "theta", "form", "libe", "zas", "theta", "abigail"], 2) --> "abigailtheta"
 
 n being the length of the string array, if `n = 0` or `k > n` or `k <= 0` return "".
 
-## Note
+# Note
 
 consecutive strings : follow one after another without an interruption
+
+---
+
+## Tags
+
+- Fundamentals