<p>Complete the function that takes two integers (a, b, where a < b) and return an array of all integers between the input parameters, including them.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export class Kata {
  static highAndLow(numbers: string): string {
    let arr: number[] = numbers.split(" ").map(Number);
    let max: number = Math.max(...arr);
    let min: number = Math.min(...arr);
    return `${max} ${min}`;
  }
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package kata

func Between(a, b int) []int {
  var arr []int
  
	for i := a; i <= b; i++ {
		arr = append(arr, a)
		a++
	}

  return arr
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/55ecd718f46fba02e5000029">Go to Kata</a>


Kata of the Day #1

<p>Americans are odd people: in their buildings, the first floor is actually the ground floor and there is no 13th floor (due to superstition).</p>

<p>Write a function that given a floor in the american system returns the floor in the european system.</p>

<p>With the 1st floor being replaced by the ground floor and the 13th floor being removed, the numbers move down to take their place. In case of above 13, they move down by two because there are two omitted numbers below them.</p>

<p>Basements (negatives) stay the same as the universal level.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export function getRealFloor(n: number): number {
  return (n >= 13) ? n - 2 : (n > 0) ? n - 1 : n;
}
</code>
</pre>

<h2>C++</h2>
<pre class="language-clike">
<code>
int getRealFloor(int n) {
  return (n >= 13) ? n - 2 : (n > 0) ? n - 1 : n;
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/574b3b1599d8f897470018f6">Go to Kata</a>


Kata of the Day #2

<p>You're writing code to control your town's traffic lights. You need a function to handle each change from green, to yellow, to red, and then to green again.</p>
   
<p>Complete the function that takes a string as an argument representing the current state of the light and returns a string representing the state the light should change to.</p>
   
<p>For example, when the input is green, output should be yellow.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export function updateLight(current: string): string {
  return ({
    green: "yellow",
    yellow: "red",
    red: "green",
  })[current] as string;
};
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def update_light(current: str) -> str:
    return {
        "green": "yellow",
        "yellow": "red",
        "red": "green"
    }[current]
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/58649884a1659ed6cb000072">Go to Kata</a>


Kata of the Day #3

<p>Return if a number is a multiple of 3 and 5.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function multiple3And5(n: number): boolean {
  return n % 15 == 0;
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
func Multiple3And5(n int) bool {
  return n % 15 == 0
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kumite/6402655b778fd01fda59562f">Go to Kata</a>


Kata of the Day #4

<p>Complete the method that takes a boolean value and return a "Yes" string for true, or a "No" string for false.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export const boolToWord = (bool: boolean): string => {
  return bool ? "Yes" : "No";
};
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
func BoolToWord(word bool) string {
  if word {
    return "Yes"
  } else {
    return "No"
  }
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/53369039d7ab3ac506000467">Go to Kata</a>


Kata of the Day #5

<p>Write a function that takes a string of braces, and determines if the order of the braces is valid. It should return true if the string is valid, and false if it's invalid.</p>

<p>This Kata is similar to the Valid Parentheses Kata, but introduces new characters: brackets [], and curly braces {}. Thanks to @arnedag for the idea!</p>

<p>All input strings will be nonempty, and will only consist of parentheses, brackets and curly braces: ()[]{}.
What is considered Valid?</p>

<p>A string of braces is considered valid if all braces are matched with the correct brace.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export function validBraces(braces: string): boolean {
  while(/|\[\]|\{\}/g.test(braces)){
    braces = braces.replace(/|\[\]|\{\}/g,"")
  }
  return !braces.length;
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
import re

def valid_braces(braces: str) -> bool:
    while re.search(r"|\[\]|\{\}", braces):
        braces = re.sub(r"|\[\]|\{\}", "", braces)
    return len(braces) == 0
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package kata

import "regexp"

func ValidBraces(braces string) bool {
  for {
    re := regexp.MustCompile(`|\[\]|\{\}`)
    if !re.MatchString(braces) {
      break
    }
    braces = re.ReplaceAllString(braces, "")
  }
  return len(braces) == 0
}
</code>
</pre>

<h2>Rust</h2>
<pre class="language-rust">
<code>
use regex::Regex;

fn valid_braces(braces: &str) -> bool {
    let mut s = String::from(braces);
    let re = Regex::new(r"|\[\]|\{\}").unwrap();
    
    while re.is_match(&s) {
        s = re.replace_all(&s, "").to_string();
    }
    
    s.len() == 0
}
</code>
</pre>

<h2>C++</h2>
<pre class="language-cplusplus">
<code>
#include <iostream>
#include <regex>
#include <string>

bool valid_braces(std::string braces) {
    std::regex re("\$\$|\\[\\]|\\{\\}");
    while (std::regex_search(braces, re)) {
        braces = std::regex_replace(braces, re, "");
    }
    return braces.empty();
}
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function validBraces($braces) {
  while (preg_match('/|\[\]|\{\}/', $braces)) {
    $braces = preg_replace('/|\[\]|\{\}/', '', $braces);
  }
  return empty($braces);
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/5277c8a221e209d3f6000b56">Go to Kata</a>


Kata of the Day #6

<p>Write a function that takes a string of braces, and determines if the order of the braces is valid. It should return true if the string is valid, and false if it's invalid.</p>

<p>This Kata is similar to the Valid Parentheses Kata, but introduces new characters: brackets [], and curly braces {}. Thanks to @arnedag for the idea!</p>

<p>All input strings will be nonempty, and will only consist of parentheses, brackets and curly braces: ()[]{}.
What is considered Valid?</p>

<p>A string of braces is considered valid if all braces are matched with the correct brace.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function countSheeps(arrayOfSheep: boolean[]): number {
  return arrayOfSheep.reduce((acc, val) => acc + (val === true ? 1 : 0), 0);
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package kata

func CountSheeps(arrayOfSheep []bool) int {
  count := 0
  for _, sheep := range arrayOfSheep {
    if sheep {
      count++
    }
  }
  return count
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def count_sheeps(array_of_sheep):
    count = 0
    for sheep in array_of_sheep:
        if sheep == True:
            count += 1
    return count
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function countSheeps($arrayOfSheep) {
    $count = 0;
    foreach ($arrayOfSheep as $sheep) {
        if ($sheep === true) {
            $count++;
        }
    }
    return $count;
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/54edbc7200b811e956000556">Go to Kata</a>


Kata of the Day #7

<p>Write a function that takes an array of words and smashes them together into a sentence and returns the sentence. You can ignore any need to sanitize words or add punctuation, but you should add spaces between each word. Be careful, there shouldn't be a space at the beginning or the end of the sentence!</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
export function smash (words: string[]): string {
   return words.join(" ");
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
func Smash(words []string) string {
   return strings.Join(words, " ")
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def smash(words):
      return ' '.join(words)
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function smash(array $words): string {
   return implode(' ', $words);
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/53dc23c68a0c93699800041d">Go to Kata</a>


Kata of the Day #8

<p>Alex just got a new hula-hoop, he loves it but feels discouraged because his little brother is better than him.</p>

<p>Write a program where Alex can input (n) how many times the hoop goes round, and it will return him an encouraging message :)</p>

<ul>
    <li>If Alex gets 10 or more hoops, return the string "Great, now move on to tricks".</li>
    <li>If he doesn't get 10 hoops, return the string "Keep at it until you get it".</li>
</ul>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function hoopCount(n: number): string {
    return n >= 10 ? "Great, now move on to tricks" : "Keep at it until you get it";
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
func hoopCount(n int) string {
    if n >= 10 {
        return "Great, now move on to tricks"
    } else {
        return "Keep at it until you get it"
    }
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def hoop_count(n):
    return "Great, now move on to tricks" if n >= 10 else "Keep at it until you get it"
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function hoopCount($n) {
    return $n >= 10 ? "Great, now move on to tricks" : "Keep at it until you get it";
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/55cb632c1a5d7b3ad0000145">Go to Kata</a>


Kata of the Day #9

<p>Create a function that gives a personalized greeting. This function takes two parameters: name and owner.</p>

<p>Use conditionals to return the proper message:</p>
<ul>
    <li>name equals owner: 'Hello boss'</li>
    <li>otherwise: 'Hello guest'</li>
</ul>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function greet(name: string, owner: string): string {
    return name === owner ? "Hello boss" : "Hello guest"
}
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
func greet(name string, owner string) string {
    if name == owner {
        return "Hello boss"
    }
    return "Hello guest"
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def greet(name, owner):
    return "Hello boss" if name == owner else "Hello guest"
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function greet($name, $owner) {
    return $name === $owner ? "Hello boss" : "Hello guest";
}
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/5772da22b89313a4d50012f7">Go to Kata</a>


Kata of the Day #10

<p>Create a simple class on different programming languages.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
class MyClass {
  private message: string = '';

  public setMessage(message: string) {
    this.message = message;
  }

  public getMessage() {
    return this.message;
  }
}

const myClass = new MyClass();
myClass.setMessage("My message");

console.log(myClass.getMessage());
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

type MyClass struct {
    message string
}

func (c *MyClass) setMessage(message string) {
    c.message = message
}

func (c *MyClass) getMessage() string {
    return c.message
}

func main() {
    myClass := MyClass{}
    myClass.setMessage("My message")
    fmt.Println(myClass.getMessage())
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
class MyClass:
    def __init__(self):
        self.message = ''

    def set_message(self, message):
        self.message = message

    def get_message(self):
        return self.message

my_class = MyClass()
my_class.set_message("My message")

print(my_class.get_message())
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
class MyClass {
    private $message = '';

    public function setMessage($message) {
        $this->message = $message;
    }

    public function getMessage() {
        return $this->message;
    }
}

$my_class = new MyClass();
$my_class->setMessage("My message");

echo $my_class->getMessage();
</code>
</pre>

Kata of the Day #11

<p>Given an array of integers, return a new array with each value doubled.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function maps(x: number[]): number[] {
    return x.map(y => y * 2);
}

console.log(maps([1,2]);
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

func maps(x []int) []int {
	for i, v := range x {
		x[i] = v * 2
	}
	return x
}

func main() {
	var arr []int = []int{1, 2}
	fmt.Println(maps(arr))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def maps(x):
    return list(map(lambda y: y * 2, x))


print(maps([1,2]))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function maps($x) {
    return array_map(function($y) {
        return $y * 2;
    }, $x);
}

echo maps([1,2]);
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/57f781872e3d8ca2a000007e">Go to Kata</a>


Kata of the Day #12

<p>Given a random non-negative number, you have to return the digits of this number within an array in reverse order.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
const digitize = (n: number): number[] => {
    return String(n).split('').reverse().map(n => Number(n));
};

console.log(digitize(12345));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

func digitize(n int) []int {
    var result []int

    for n > 0 {
        result = append(result, n % 10)
        n /= 10
    }

    return result
}

func main() {
    fmt.Println(digitize(12345))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def digitize(n):
    return [int(x) for x in str(n)[::-1]]

print(digitize(12345))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function digitize($n) {
    return array_map('intval', str_split(strrev((string)$n)));
}

print_r(digitize(12345));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/5583090cbe83f4fd8c000051">Go to Kata</a>


Kata of the Day #13

<p>You will be given a list of strings. You must sort it alphabetically (case-sensitive, and based on the ASCII values of the chars) and then return the first value.</p>

<p>The returned value must be a string, and have "***" between each of its letters.</p>

<p>You should not remove or add elements from/to the array.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function twoSort(s: string[]): string {
    return s.sort()[0].split('').join('***');
}

console.log(twoSort(['banana','apple']));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
    "fmt"
    "sort"
    "strings"
)

func twoSort(s []string) string {
    sort.Strings(s)
    return strings.Join(strings.Split(s[0], ""), "***")
}

func main() {
    fmt.Println(twoSort([]string{"banana", "apple"}))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def two_sort(array):
    return '***'.join(min(array))

print(two_sort(['banana','apple']))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function twoSort($s) {
    sort($s);
    return implode('***', str_split($s[0]));
}

echo twoSort(['banana','apple']);
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/57cfdf34902f6ba3d300001e">Go to Kata</a>


Kata of the Day #14

<p>Write a function that takes a list of strings as an argument and returns a filtered list containing the same elements but with the 'geese' removed.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function gooseFilter (birds: string[]): string[] {
    const geese: string[] = ["African", "Roman Tufted", "Toulouse", "Pilgrim", "Steinbacher"];
    return birds.filter(bird => ! geese.includes(bird));
}

console.log(gooseFilter(['African', 'Not Geese']));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

func gooseFilter(birds []string) []string {
	geese := []string{"African", "Roman Tufted", "Toulouse", "Pilgrim", "Steinbacher"}

	filteredBirds := make([]string, 0)
	for _, bird := range birds {
		if !contains(geese, bird) {
			filteredBirds = append(filteredBirds, bird)
		}
	}

	return filteredBirds
}

func contains(sl []string, name string) bool {
	for _, value := range sl {
		if value == name {
			return true
		}
	}
	return false
}

func main() {
	fmt.Println(gooseFilter([]string{"African", "Not Geese"}))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def goose_filter(birds):
    geese = ["African", "Roman Tufted", "Toulouse", "Pilgrim", "Steinbacher"]
    return [bird for bird in birds if bird not in geese]

print(goose_filter(['African', 'Not Geese']))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function goose_filter($birds) {
    $geese = ["African", "Roman Tufted", "Toulouse", "Pilgrim", "Steinbacher"];
    $filteredBirds = [];

    foreach ($birds as $bird) {
        if (!in_array($bird, $geese)) {
            $filteredBirds[] = $bird;
        }
    }

    return $filteredBirds;
}

print_r(goose_filter(['African', 'Not Geese']));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/57cfdf34902f6ba3d300001e">Go to Kata</a>



Kata of the Day #15

<p>Complete the function that takes a non-negative integer n as input, and returns a list of all the powers of 2 with the exponent ranging from 0 to n ( inclusive ).</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function powersOfTwo(n: number): number[] {
    let acc: number[] = [];

    for (let i = 0; i <= n; i++) {
        acc.push(Math.pow(2, i));
    }

    return acc;
}

console.log(powersOfTwo(10));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

func powersOfTwo(n int) []int {
    acc := make([]int, n+1)

    for i := 0; i <= n; i++ {
      acc[i] = int(math.Pow(2, float64(i)))
    }

    return acc
}

func main() {
	fmt.Println(powersOfTwo(10))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def powers_of_two(n):
    acc = []
    for i in range(n+1):
        acc.append(2**i)
    return acc

print(powers_of_two(10))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function powersOfTwo(int $n): array {
    $acc = [];

    for ($i = 0; $i <= $n; $i++) {
        $acc[] = pow(2, $i);
    }

    return $acc;
}

print_r(powersOfTwo(10));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/57a083a57cb1f31db7000028">Go to Kata</a>



Kata of the Day #16

<p>Complete the function which converts hex number (given as a string) to a decimal number.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function hexToDec(hexString: string):number{
    return parseInt(hexString, 16);
}

console.log(hexToDec("FF"));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
	"fmt"
	"strconv"
)

func hexToDec(hexString string) int64 {
	decimal, _ := strconv.ParseInt(hexString, 16, 32)
	return decimal
}

func main() {
	fmt.Println(hexToDec("FF"))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def hex_to_dec(hexString):
    return int(hexString, 16)

print(hex_to_dec("FF"))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function hexToDec($hexString) {
    return hexdec($hexString);
}

echo hexToDec("FF");
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/57a4d500e298a7952100035d">Go to Kata</a>


Kata of the Day #17

<p>When provided with a letter, return its position in the alphabet.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function position(alphabet: string): string {
  const position = "abcdefghijklmnopqrstuvwxyz".split('').indexOf(alphabet) + 1;
  return `Position of alphabet: ${position}`;
}

console.log(position("c"));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
    "fmt"
    "strings"
)

func position(alphabet string) string {
    position := strings.Index("abcdefghijklmnopqrstuvwxyz", alphabet) + 1
    return fmt.Sprintf("Position of alphabet: %d", position)
}

func main() {
    fmt.Println(position("c"))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def position(alphabet):
    position = "abcdefghijklmnopqrstuvwxyz".index(alphabet) + 1
    return f"Position of alphabet: {position}"

print(position("c"))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function position($alphabet) {
    $position = strpos("abcdefghijklmnopqrstuvwxyz", $alphabet) + 1;
    return "Position of alphabet: $position";
}

echo position("c");
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/5808e2006b65bff35500008f">Go to Kata</a>


Kata of the Day #18

<p>Finish the solution so that it sorts the passed in array of numbers. If the function passes in an empty array or null/nil value then it should return an empty array.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function sortNumbers(nums: number[]): number[] {
    return nums.sort((a, b) => a - b);
}

console.log(sortNumbers([1, 10, 2]));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
    "fmt"
    "sort"
)

func sortNumbers(nums []int) []int {
    sort.Ints(nums)
    return nums
}

func main() {
    fmt.Println(sortNumbers([]int{1, 10, 2}))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def sort_numbers(nums):
    return sorted(nums)

print(sort_numbers([1, 10, 2]))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function sortNumbers($nums) {
    sort($nums);
    return $nums;
}

print_r(sortNumbers([1, 10, 2]));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/5174a4c0f2769dd8b1000003">Go to Kata</a>


Kata of the Day #19

<p>Your goal in this kata is to implement a difference function, which subtracts one list from another and returns the result.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function arrayDiff(a: number[], b: number[]): number[] {
    return a.filter(e => !b.includes(e));
}

console.log(arrayDiff([3, 4], [3]));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
	"fmt"
)

func arrayDiff(a []int, b []int) []int {
	diff := []int{}
	for _, e := range a {
		if !contains(b, e) {
			diff = append(diff, e)
		}
	}
	return diff
}

func contains(arr []int, val int) bool {
	for _, el := range arr {
		if el == val {
			return true
		}
	}
	return false
}

func main() {
	fmt.Println(arrayDiff([]int{3, 4}, []int{3}))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def array_diff(a, b):
    return [e for e in a if e not in b]

print(array_diff([3, 4], [3]))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function arrayDiff($a, $b) {
    return array_filter($a, function($e) use ($b) {
        return !in_array($e, $b);
    });
}

echo print_r(arrayDiff([3, 4], [3]));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/523f5d21c841566fde000009">Go to Kata</a>

Kata of the Day #20

<p>We need a simple function that determines if a plural is needed or not. It should take a number, and return true if a plural should be used with that number or false if not. This would be useful when printing out a string such as 5 minutes, 14 apples, or 1 sun.</p>

<p>You only need to worry about english grammar rules for this kata, where anything that isn't singular (one of something), it is plural (not one of something).</p>

<p>All values will be positive integers or floats, or zero.</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function plural(n: number): boolean {
  return n !== 1;
}

console.log(plural(100));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import (
	"fmt"
)

func plural(n int) bool {
  return n != 1
}

func main() {
	fmt.Println(plural(100))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def plural(n):
    return n != 1

print(plural(100))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function plural($n) {
  return $n != 1;
}

echo print_r(plural(100));
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/52ceafd1f235ce81aa00073a">Go to Kata</a>


Kata of the Day #21

<p>Given an integer as input, can you round it to the next (meaning, "greater than or equal") multiple of 5?</p>

<h2>TypeScript</h2>
<pre class="language-javascript">
<code>
function roundToNext5(n: number): number {
  return n + (5 - n) % 5;
}

console.log(roundToNext5(100));
</code>
</pre>

<h2>Go</h2>
<pre class="language-go">
<code>
package main

import "fmt"

func roundToNext5(n int) int {
  return n + (5 - n % 5) % 5
}

func main() {
  fmt.Println(roundToNext5(100))
}
</code>
</pre>

<h2>Python</h2>
<pre class="language-python">
<code>
def round_to_next_5(n):
    return n + (5 - n) % 5

print(round_to_next_5(100))
</code>
</pre>

<h2>PHP</h2>
<pre class="language-php">
<code>
function roundToNext5($n) {
  return $n + (5 - $n % 5) % 5;
}

echo roundToNext5(100);
</code>
</pre>

<a class="btn" target="_blank" href="https://www.codewars.com/kata/55d1d6d5955ec6365400006d">Go to Kata</a>


Kata