Kumite

def mul():
    return sum([i for i in range(1000) if i%3 == 0 or i%5 == 0])

1 1 def mul():
2 - sum=0
3 - for i in range(1, 1000):
4 - if(i % 3 == 0 or i % 5 == 0):
5 - sum += i
6 - return sum
2 + return sum([i for i in range(1000) if i%3 == 0 or i%5 == 0])
7 7

Recent Moves:

jmacdonald92vs. Kakrot

Project Euler: Problem 1

def mul():
    sum=0
    for i in range(1, 1000):
        if(i % 3 == 0 or i % 5 == 0):
            sum += i
    return sum

```
test.assert_equals(mul(), 233168)
```
1 -
1 + test.assert_equals(mul(), 233168)

Kakrotvs. PowerSchillFailed Tests

Ulam Sequence

Puzzles

Games

Sequences

Arrays

Arithmetic

Mathematics

Algorithms

Numbers

Recursion

Computability Theory

Theoretical Computer Science

The Ulam Sequence is a recursive sequence that begins with two numbers; for example [1, 2]. The next number in the sequence is the smallest unique sum of any 2 numbers in the sequence.

Example:
[u0, u1] = [1, 2]
u2 = 1 + 2 = 3 --> [1, 2, 3]
u3 = 1 + 3 = 4 --> [1, 2, 3, 4]
u4 = 4 + 2 = 6 --> [1, 2, 3, 4, 6]

Notice that 5 is left out. Though 5 is smaller than 6, 5 can be written as a sum in 2 different ways: 4 + 1 and 3 + 2; therefore, it is not unique; whereas, 6 is unique since it is only the sum of 4 + 2.

Write a code that generates an Ulam Sequence of length n and starts with u0, u1.

Ex:
f(u0=1, u1=2, n=10) = [1, 2, 3, 4, 6, 8, 11, 13, 16, 18]

def ulam_sequence(u0, u1, n):
    u = [u0, u1]
    nn = u[-1] + 1
    while len(u) < n:
        count = 0
        for i in u:
            if nn - i in u and nn - i != i:
                count += 1
            if count >= 3:
                break
                nn += 1
        if count == 2:
            u.append(nn)
        nn += 1
    return u

test.assert_equals(ulam_sequence(3, 4, 5), [3, 4, 7, 10, 11])
test.assert_equals(ulam_sequence(1, 2, 10), [1, 2, 3, 4, 6, 8, 11, 13, 16, 18])
test.assert_equals(ulam_sequence(2, 3, 8), [2, 3, 5, 7, 8, 9, 13, 14])

narpassword27vs. TrevorTiernan

Number of digits in a ulong

Numbers

Integers

Algorithms

using System;
using System.Linq;

public class Kumite
{
  public static int Digits(ulong n)
  {
    //GEEEEEEET DUUUUUUNKED OOOOOOOOOOOOOON
    int theseDigitsShouldREALLYBeCountedImSureOfIt = n
    .ToString()
    .ToCharArray()
    .Select((c,i)=>new{_char = c, ShouldBeCounted = true, index = i})
    .Select((a,i)=>new{charValue = a._char-'0', shouldREALLYbecounted = a.ShouldBeCounted && a.index==i})
    .OrderBy(a=>a.charValue)
    .ToArray()
    .Where(a=>a.shouldREALLYbecounted.ToString()=="True")
    .ToList()
    .ToArray()
    .Length;
    
    
    int thatNameWasTooLong = theseDigitsShouldREALLYBeCountedImSureOfIt;
    int soWasThatOne = thatNameWasTooLong;
    int betterstill = soWasThatOne;
    int thisone = betterstill;
    int _this = thisone;
    int _ = _this;
    return _;
   } 
}

Recent Moves:

TrevorTiernanvs. pelbox

Number of digits in a ulong

Numbers

Integers

Algorithms

Find the shortest or fastest answer.

public class Kumite
{
// Unrolled div loop
  public static int Digits(ulong n) => n.ToString().Length;
}

pelboxvs. henninglive

Number of digits

Numbers

Integers

Algorithms

Translation of henninglive's unrolled divison loop for calculating amount of digits to C#

public class Kumite
{
// Unrolled div loop
  public static int Digits(ulong n)
  {
    var l = 1;
    while(true)
    {
      if (n < 10) return l;
      if (n < 100) return l + 1;
      if (n < 1000) return l + 2;
      if (n < 10000) return l + 3;
      n /= 10000;
      l += 4;
    }
  }
}

using NUnit.Framework;
using System;

public class NumberOfDigits
{
  [Test]
  public void RandomTests()
  {
    var rand = new Random();
    // 10 digits, is there any way to generate random ulongs without implementing lots of logic?
    for(var i = 1; i < 10; ++i)
    {
      // 10 numbers
      for(var j = 0; i < 10; ++i)
      {
        var num = rand.Next((int)Math.Pow(10, i-1), (int)Math.Pow(10, i));
        Assert.That(Kumite.Digits((ulong)num), Is.EqualTo(i));
      }
    }
  }
  [Test]
  public void Pow10()
  {
    Assert.That(Kumite.Digits(0), Is.EqualTo(1));
    
    ulong n = 1;
    Assert.That(Kumite.Digits(1), Is.EqualTo(1));
    for(var i = n; i < 20; ++i) 
    {
      n *= 10;
      Assert.That(Kumite.Digits(n), Is.EqualTo(i + 1));
    }
    Assert.That(Kumite.Digits(ulong.MaxValue), Is.EqualTo(20));
  }
    
  [Test]
  public void Pow10_Minus_1()
  {
    ulong n = 1;
    for(var i = 1; i < 20; ++i) 
    {
      n *= 10;
      Assert.That(Kumite.Digits(n - 1), Is.EqualTo(i));
    }
  }
    
  [Test]
  public void Pow10_Half()
  {
    ulong n = 1;
    for(var i = n; i < 20; ++i) 
    {
      n *= 10;
      Assert.That(Kumite.Digits(n / 2), Is.EqualTo(i));
    }
  }
}

henninglivevs. henninglive

Number of digits

Numbers

Integers

Algorithms

Find number of digits with an unrolled div loop.

// Unrolled div loop
fn digits(mut n: u64) -> usize {
  let mut l = 1;
  loop {
    if n < 10 {
      return l;
    }
    if n < 100 {
      return l + 1;
    }
    if n < 1000 {
      return l + 2;
    }
    if n < 10000 {
      return l + 3;
    }
    n /= 10000;
    l += 4;
  }
}

#[test]
fn pow10() {
  assert_eq!(digits(0), 1);
  
  let mut n = 1;
  assert_eq!(digits(1), 1);
  for i in 1..20 {
    n*=10;
    assert_eq!(digits(n), i+1);
  }
  
  assert_eq!(digits(std::u64::MAX), 20);
}

#[test]
fn pow10_minus_1() {
  let mut n = 1;
  for i in 1..20 {
    n*=10;
    assert_eq!(digits(n - 1), i);
  }
}

#[test]
fn pow10_half() {
  let mut n = 1;
  for i in 1..20 {
    n*=10;
    assert_eq!(digits(n / 2), i);
  }
}

henninglivevs. henninglive

Number of digits

Numbers

Integers

Algorithms

Find number of digits using a unrolled binary search.

// Powers of 109
static POW10: [u64; 20] = [
  1,
  10,
  100,
  1000,
  10000,
  100000,
  1000000,
  10000000,
  100000000,
  1000000000,
  10000000000,
  100000000000,
  1000000000000,
  10000000000000,
  100000000000000,
  1000000000000000,
  10000000000000000,
  100000000000000000,
  1000000000000000000,
  10000000000000000000,
];

// Unrolled binary search
fn digits(n: u64) -> usize {
  if n < POW10[16] {
    if n < POW10[8] {
      if n < POW10[4] {
        if n < POW10[2] {
          if n < POW10[1] {
            1
          } else {
            2 
          }
        } else {
          if n < POW10[3] {
            3
          } else {
            4
          }
        }
      } else {
        if n < POW10[6] {
          if n < POW10[5] {
            5
          } else {
            6
          }
        } else {
          if n < POW10[7] {
            7
          } else {
            8
          }
        }
      }
    } else {
      if n < POW10[12] {
        if n < POW10[10] {
          if n < POW10[9] {
            9
          } else {
            10
          }
        } else {
          if n < POW10[11] {
            11
          } else {
            12
          }
        }
      } else {
        if n < POW10[14] {
          if n < POW10[13] {
            13
          } else {
            14
          }
        } else {
          if n < POW10[15] {
            15
          } else {
            16
          }
        }
      } 
    }
  } else {
    if n < POW10[18] {
      if n < POW10[17] {
        17
      } else {
        18
      }
    } else {
      if n < POW10[19] {
        19
      } else {
        20
      }
    }
  }
}

#[test]
fn pow10() {
  assert_eq!(digits(0), 1);
  
  let mut n = 1;
  assert_eq!(digits(1), 1);
  for i in 1..20 {
    n*=10;
    assert_eq!(digits(n), i+1);
  }
  
  assert_eq!(digits(std::u64::MAX), 20);
}

#[test]
fn pow10_minus_1() {
  let mut n = 1;
  for i in 1..20 {
    n*=10;
    assert_eq!(digits(n - 1), i);
  }
}

#[test]
fn pow10_half() {
  let mut n = 1;
  for i in 1..20 {
    n*=10;
    assert_eq!(digits(n / 2), i);
  }
}

lemarginavs. Javatlacati

Dart test failure custom message

// add the values "codewars" to the websites array
var websites = ['codewars'];

1 1 // add the values "codewars" to the websites array
2 - var websites = ['codears'];
2 + var websites = ['codewars'];

Recent Moves:

JavatlacatiFailed Tests

Dart test failure custom message

// add the values "codewars" to the websites array
var websites = ['codears'];
test('Codewars is in the array', () {
  expect(websites.length, greaterThan(0));
  expect(websites.length, equals(1));
  expect(websites[0], equals('codewars'),reason:"codewars website should be present in the array", verbose:true);
});

Unnamedvs. majko

add without '+'

```
#define add std::plus<>()
```
1 - template<typename T>
2 - T add(const T& a, const T &b){
3 - return std::plus<T>()(a, b);
4 - }
1 + #define add std::plus<>()

Recent Moves:

majkovs. oxcd8o

add without '+'

template<typename T>
T add(const T& a, const T &b){
	return std::plus<T>()(a, b);
}

1 1 template<typename T>
2 2 T add(const T& a, const T &b){
3 - return a-(-b);
3 + return std::plus<T>()(a, b);
4 4 }

oxcd8ovs. Icesyst

add without '+'

template<typename T>
T add(const T& a, const T &b){
	return a-(-b);
}

1 1 template<typename T>
2 - T add(T a, T b){
2 + T add(const T& a, const T &b){
3 3 return a-(-b);
4 4 }

Icesyst

add without '+'

If it does not work, just say :).

template<typename T>
T add(T a, T b){
	return a-(-b);
}

// TODO: Replace examples and use TDD development by writing your own tests

Describe(somathing)
{
    It(basic)
    {
        Assert::That(add(1024, 1024), Equals(2048));
        Assert::That(add(add(1.0, 1.5), add(32.0, 64.5)), Equals(99));
    }
    It(negativ_plus_positiv){
      Assert::That(add(1024, -1024), Equals(0));
      Assert::That(add(-512, 256));
    }
};

kostiavs. vildantursic

Move to point X dcreasing and from point X increasing

Arrays

const func = (N, p) => Array(N).fill().map((_,i)=>Math.abs(i-p));

Recent Moves:

james1054vs. vildantursic

Move to point X dcreasing and from point X increasing

Arrays

PEP 8 - Naming Conventions - Function Names:

function func(N, point) {
  return funcHelper(N, point, [])
}

function funcHelper(N, x, arr) {
  return N === 0 ? arr : funcHelper(N - 1, x - 1, [...arr, Math.abs(x)])
}

vildantursic

Move to point X dcreasing and from point X increasing

Arrays

Function will recive N for length of array and point as index to pint at in that array.

For example, function should generate arrays like this for

N = 10, point = 7
[7,6,5,4,3,2,1,0,1,2]

N = 10, point = 4
[4,3,2,1,0,1,2,3,4,5]

function func(N, point) {
  let start = 0; // starting position of array
  let clonePoint = point; // clone for point to start counting from that number at begining of array
  let arr = [...Array(N).keys()] // generate array and fill with 0 to 10
  if(!(point > N)) {
    arr.forEach((o, index) => {
      index < point ? arr[index] = clonePoint-- : arr[index] = start++;
    });
    return arr;
  }
  return [];
}

// TODO: Replace examples and use TDD development by writing your own tests

// These are some CW specific test methods available:
//    Test.expect(boolean, [optional] message)
//    Test.assertEquals(actual, expected, [optional] message)
//    Test.assertSimilar(actual, expected, [optional] message)
//    Test.assertNotEquals(actual, expected, [optional] message)

// NodeJS assert is also automatically required for you.
//    assert(true)
//    assert.strictEqual({a: 1}, {a: 1})
//    assert.deepEqual({a: [{b: 1}]}, {a: [{b: 1}]})

// You can also use Chai (http://chaijs.com/) by requiring it yourself
// var expect = require("chai").expect;
// var assert = require("chai").assert;
// require("chai").should();

describe("Solution", function(){
  it("should return specified array format", function(){
    let arr = new Array(7,6,5,4,3,2,1,0,1,2)
    Test.assertSimilar(func(10, 7), arr);
  });
  it("should return specified array format", function(){
    let arr = new Array(3,2,1,0,1,2,3,4,5,6)
    Test.assertSimilar(func(10, 3), arr);
  });
});

donaldsebleungvs. Kamori

Calculate permutations by their index number on sorted list of all permutations

Mathematics

Algorithms

Numbers

Function names should be lowercase, with words separated by underscores as necessary to improve readability.

This naming style is commonly known as snake_case.

Furthermore, the variable assignment in the previous Kumite is not required; the computed result can be returned immediately.

Finally, as per the Python Test Reference in the official Codewars Docs, the order of arguments for Test.assert_equals should be actual, expected instead of the other way round.

from itertools import permutations
def sequence_permutation(t, n):
    return list(permutations(t, n))

Test.describe("sequence_permutation")

Test.it("should correct calculate for permutations with three by three")
sq_per_master = sequence_permutation(('a','b','c'), 3)
Test.assert_equals(list(sq_per_master[0]), ['a', 'b', 'c'])
Test.assert_equals(list(sq_per_master[1]), ['a', 'c', 'b'])
Test.assert_equals(list(sq_per_master[4]), ['c', 'a', 'b'])

Test.it("should correct calculate for permutations with one item")
sq_per_master = sequence_permutation(('a','b','c'), 1)
Test.assert_equals(list(sq_per_master[0]), ['a'])
Test.assert_equals(list(sq_per_master[1]), ['b'])
Test.assert_equals(list(sq_per_master[2]), ['c'])

Test.it("should correct calculate for permutations with two items")
sq_per_master = sequence_permutation(('a','b','c'), 2)
Test.assert_equals(list(sq_per_master[0]), ['a', 'b'])
Test.assert_equals(list(sq_per_master[1]), ['a', 'c'])
Test.assert_equals(list(sq_per_master[4]), ['c', 'a'])

Recent Moves:

Kamorivs. shvedaction

Calculate permutations by their index number on sorted list of all permutations

Mathematics

Algorithms

Numbers

I don't understand kumites, so sorry if this isn't what you wanted

Original Description:
If we have planty of objects like this: ['a', 'b', 'c']
then we can build all permutation:

0 – abc
1 – acb
2 – bac
3 – bca
4 – cab
5 – cba
Any of them permutations may be calculated by their index number without calculated others.

from itertools import permutations

def SequencePermutation(plenty, count):
    ret = list(permutations(plenty, count))
    return ret

shvedaction

Calculate permutations by their index number on sorted list of all permutations

Mathematics

Algorithms

Numbers

If we have planty of objects like this: ['a', 'b', 'c']
then we can build all permutation:

0 – abc
1 – acb
2 – bac
3 – bca
4 – cab
5 – cba

Any of them permutations may be calculated by their index number without calculated others.

import math


class SequencePermutation(object):
    def __init__(self, plenty_object, count_item):
        self.plenty_object = list(plenty_object)
        self.count_item = count_item
        self.power_plenty = len(plenty_object)

    @staticmethod
    def calc_count_permutation(n, k):
        return int(math.factorial(n) / math.factorial(n - k))

    def __getitem__(self, index):
        current_mod = index
        plenty = self.plenty_object.copy()
        for i in range(self.count_item - 1):
            perm_count = self.calc_count_permutation(self.power_plenty - i - 1, self.count_item - i - 1)
            current_index = current_mod // perm_count
            yield plenty[current_index]
            plenty.pop(current_index)
            current_mod = current_mod % perm_count
        yield plenty[current_mod]

Test.describe("SequencePermutation")


Test.describe("should correct calculate for permutations with three by three")
sq_per_master = SequencePermutation(('a','b','c'), 3)
Test.assert_equals(['a', 'b', 'c'], list(sq_per_master[0]))
Test.assert_equals(['a', 'c', 'b'], list(sq_per_master[1]))
Test.assert_equals(['c', 'a', 'b'], list(sq_per_master[4]))

Test.describe("should correct calculate for permutations with one item")
sq_per_master = SequencePermutation(('a','b','c'), 1)
Test.assert_equals(['a'], list(sq_per_master[0]))
Test.assert_equals(['b'], list(sq_per_master[1]))
Test.assert_equals(['c'], list(sq_per_master[2]))

Test.describe("should correct calculate for permutations with two items")
sq_per_master = SequencePermutation(('a','b','c'), 2)
Test.assert_equals(['a', 'b'], list(sq_per_master[0]))
Test.assert_equals(['a', 'c'], list(sq_per_master[1]))
Test.assert_equals(['c', 'a'], list(sq_per_master[4]))

[BF] Print byte as numerical string (0-99 only)

A simple algorithm in Brainf**k that receives exactly 1 byte of input and prints it out as a numerical string. For example: "H" -> "72". Note that this algorithm only works for byte values up to 99 though - it won't handle three-digit bytes properly.

This program might be somewhat useful in writing a short and concise program that prints out the lyrics to "99 bottles of beer" since the lyrics are highly repetitive and involves printing out a lot of numbers in descending order. However, upon second thought, it might not be that useful at all since my program fails to preserve its input :p

,[->>+>+>>-<<----------[[+]>>+<<]>>[[+]<<<----------<+>>>>]<<<[->+>+<<]>>[-<<+>>]<<<<]>[++++++++++++++++++++++++++++++++++++++++++++++++.[-]]>++++++++++++++++++++++++++++++++++++++++++++++++.

Test.describe('The Program', function () {
  Test.it('should correctly convert byte(72) into string "72"', function () {
    Test.assertEquals(runBF('H'), '72');
  });
  Test.it('should work correctly for a few other examples below byte(100)', function () {
    Test.assertEquals(runBF('c'), '99');
    Test.assertEquals(runBF('a'), '97');
    Test.assertEquals(runBF('F'), '70');
    Test.assertEquals(runBF('!'), '33');
    Test.assertEquals(runBF(String.fromCharCode(50)), '50');
    Test.assertEquals(runBF("\0"), '0');
    Test.assertEquals(runBF('0'), '48');
    Test.assertEquals(runBF('7'), '55');
    Test.assertEquals(runBF('A'), '65');
  });
  Test.it('unfortunately doesn\'t work properly above byte(99) :(', function () {
    console.log('Output for byte(127): ' + runBF(String.fromCharCode(127)));
  });
});

kmactavishFailed Tests

Hello Julia!

Hello World in Julia, since there's nothing on codewars ⊙﹏⊙.

println("Hello Julia!")
const hello = "world"

facts("Is hello world?") do
  @fact hello => "world"
end

Hello Brainf**k with "default arguments"

The last two BF programs I published would simply print a weirdly formatted string if the input is empty (or not provided), like so: "Hello "/"Hello !". Obviously, that isn't desirable behavior so I refactored my program to print "Hello World!" in case of empty input.

++++++++++[>+++++++>++++++++++>+++++++++++>+++<<<<-]>++.>+.>--..+++.>++.>->,[.<[+]>,]<[[+]++++++++++[>+++++++++>+++++++++++>++++++++++<<<-]>---.>+.+++.------.>.<<<]<+.

Test.describe('The BF greeting program (with input)', function () {
  Test.it('should work with input "Brainf**k"', function () {
    Test.assertEquals(runBF('Brainf**k' + EOF), 'Hello Brainf**k!');
  });
  Test.it('should work with a range of other inputs', function () {
    Test.assertEquals(runBF('JavaScript' + EOF), 'Hello JavaScript!');
    Test.assertEquals(runBF('Node 8' + EOF), 'Hello Node 8!');
    Test.assertEquals(runBF('Codewars' + EOF), 'Hello Codewars!');
    Test.assertEquals(runBF('@jhoffner' + EOF), 'Hello @jhoffner!');
    Test.assertEquals(runBF('@donaldsebleung' + EOF), 'Hello @donaldsebleung!');
  });
  Test.it('should have a "default argument" of "World"', function () {
    Test.assertEquals(runBF(EOF), 'Hello World!');
  });
  Test.it('should work properly if "World" is passed in anyway', function () {
    Test.assertEquals(runBF('World' + EOF), 'Hello World!');
  });
});

Recent Moves:

Hello Brainf**k!

This time with the trailing ! ;)

++++++++++[>+++++++>++++++++++>+++++++++++>+++<<<<-]>++.>+.>--..+++.>++.>,[.,]<+.

1 - ++++++++++[>+++++++>++++++++++>+++++++++++>+++<<<<-]>++.>+.>--..+++.>++.>,[.,]
1 + ++++++++++[>+++++++>++++++++++>+++++++++++>+++<<<<-]>++.>+.>--..+++.>++.>,[.,]<+.

Test.describe('The BF greeting program (with input)', function () {
  Test.it('should work with input "Brainf**k"', function () {
    Test.assertEquals(runBF('Brainf**k' + EOF), 'Hello Brainf**k!');
  });
  Test.it('should work with a range of other inputs', function () {
    Test.assertEquals(runBF('JavaScript' + EOF), 'Hello JavaScript!');
    Test.assertEquals(runBF('Node 8' + EOF), 'Hello Node 8!');
    Test.assertEquals(runBF('Codewars' + EOF), 'Hello Codewars!');
    Test.assertEquals(runBF('@jhoffner' + EOF), 'Hello @jhoffner!');
    Test.assertEquals(runBF('@donaldsebleung' + EOF), 'Hello @donaldsebleung!');
  });
});

donaldsebleungvs. Slx64

Hello Brainf**k!

This program should accept input of varying length and greet the subject provided with a simple hello. Currently, the program does not account for empty input (which will print out "Hello ") and doesn't end the statement with a suitable punctuation mark so feel free to improve the program in your fork :)

++++++++++[>+++++++>++++++++++>+++++++++++>+++<<<<-]>++.>+.>--..+++.>++.>,[.,]

1 - proc sayHello(n: string): string {
2 - return "Hello " + n;
3 - }
1 + ++++++++++[>+++++++>++++++++++>+++++++++++>+++<<<<-]>++.>+.>--..+++.>++.>,[.,]

Test.describe('The BF greeting program (with input)', function () {
  Test.it('should work with input "Brainf**k"', function () {
    Test.assertEquals(runBF('Brainf**k' + EOF), 'Hello Brainf**k');
  });
  Test.it('should work with a range of other inputs', function () {
    Test.assertEquals(runBF('JavaScript' + EOF), 'Hello JavaScript');
    Test.assertEquals(runBF('Node 8' + EOF), 'Hello Node 8');
    Test.assertEquals(runBF('Codewars' + EOF), 'Hello Codewars');
    Test.assertEquals(runBF('@jhoffner' + EOF), 'Hello @jhoffner');
    Test.assertEquals(runBF('@donaldsebleung' + EOF), 'Hello @donaldsebleung');
  });
});

Slx64vs. DOBss

Hello Chapel!

proc sayHello(n: string): string {
  return "Hello " + n;
}

1 - const greetLanguage = (a,b) => (a||'Hello')+', '+(b||'Javascript')+'!';
1 + proc sayHello(n: string): string {
2 + return "Hello " + n;
3 + }

Test.describe("Hello Chapel");
Test.assertEquals(sayHello("Chapel"), "Hello Chapel");

ElMagovs. Icesyst

Hello C++!

Fundamentals

'\n' is faster and more effective than std::endl.

https://www.codewars.com/kata/58a2ff40e7841f82b600010a/edit/python

#include <iostream>

using namespace std;
int helloCplusplus(){
  cout << "Hello Cplusplus" << '\n';
  return 0;
}

1 1 #include <iostream>
2 2
3 3 using namespace std;
4 4 int helloCplusplus(){
5 - cout << "Hello Cplusplus" << endl;
5 + cout << "Hello Cplusplus" << '\n';
6 6 return 0;
7 7 }

Slx64

Chebyshev polynomials [Chapel]

use Math;

proc chebyshev(n: int, v: real) : real
{
  if (v > 1) {
    return cosh(n * acosh(v));
  } else if (v < -1) {
    return (-1) ** n * cosh(n * acosh(-v));
  } else {
    return cos(n * acos(v));
  }
}

Test.describe("First Order Chebyshev Polynomials");
Test.assertFuzzyEquals(chebyshev(0,0.5), 1);
Test.assertFuzzyEquals(chebyshev(1,0.5), 0.5);
Test.assertFuzzyEquals(chebyshev(2,0.5), -0.5);
Test.assertFuzzyEquals(chebyshev(5,0.52), 0.396166451);
Test.assertFuzzyEquals(chebyshev(3,26), 70226.0);

10XLvs. 10XLFailed Tests

Get Installed Modules

const package = require('fs').readFileSync('../../runner/package.json','utf8');

console.log(package);

Recent Moves:

JordanMack92vs. 10XLFailed Tests

Get Installed Gems

require 'rubygems'

#gems are stored in a hash with the key set to the name of the gem and the value is the version.
#the trick is to get the hash to an array and join the version number to the gem name.
#Feedback appreciated.

def local_gems
   Gem::Specification.sort_by{ |g| [g.name.downcase, g.version] }.group_by{ |g| g.name }
end

puts local_gems.map{ |name, specs| 
  [ 
    name,
    specs.map{ |spec| spec.version.to_s }.join(',')
  ].join(' ') 
}

# TODO: Replace examples and use TDD development by writing your own tests
# These are some of the methods available:
#   Test.expect(boolean, [optional] message)
#   Test.assert_equals(actual, expected, [optional] message)
#   Test.assert_not_equals(actual, expected, [optional] message)

describe "Solution" do
  it "should test for something" do
    Test.assert_equals("actual", "expected", "This is just an example of how you can write your own TDD tests")
  end
end

10XLvs. 10XLFailed Tests

Get Installed Modules

const exec = require('child_process').exec;

function parse(error, stdout, stderr) {
  if (error) throw error;  
  console.log(`stdout: ${stdout}`);
  console.log(`stderr: ${stderr}`);
}

// gives an error I don't understand but I guess the below command sort of works. 
// exec('npm -g list', (err, stdout, stderr) => parse(err, stdout, stderr));

exec('ls ../../runner/node_modules', (err, stdout, stderr) => parse(err, stdout, stderr));

10XLvs. 10XLFailed Tests

Get Installed Gems

```
puts `gem list`
```
1 - from subprocess import call
2 - call(["pip", "freeze"])
1 + puts `gem list`

10XLFailed Tests

Get Installed Packages

from subprocess import call
call(["pip", "freeze"])

rsmvs. xcthulhuFailed Tests

xcthulhu's Kumite #18

(princ "Welcome to Common Lisp, made with secret alien technology.")

1 - (format t "Welcome to Common Lisp, made with secret alien technology.")
1 + (princ "Welcome to Common Lisp, made with secret alien technology.")

szabinvs. kwantum00

Kolakoski Sequence Generator

Puzzles

Games

Mathematics

Algorithms

Numbers

Sequences

Arrays

Naive, brute force solution

function Generate_Kolakoski_Seq(seed, n){
  seed = seed.join("");
  let seq = seed[0].repeat(seed[0]), tptr = 0, sptr = 0;
  while(seq.length < n) {
    sptr++; tptr = ++tptr % seed.length;
    seq += seed[tptr].repeat(seq[sptr] || seed[sptr]);
  }
  return seq.substring(0, n).split("").join(",");
}

function Find_Kolakoski_Number(seed, n){
  // Ehh, I'll leave the thinking up to someone else.
  return +Generate_Kolakoski_Seq(seed, n)[(n-1) * 2];
}

Test.assertEquals(Generate_Kolakoski_Seq([1, 2], 10), "1,2,2,1,1,2,1,2,2,1");
Test.assertEquals(Generate_Kolakoski_Seq([2], 5), "2,2,2,2,2");
Test.assertEquals(Generate_Kolakoski_Seq([1, 2, 3], 20), "1,2,2,3,3,1,1,1,2,2,2,3,1,2,3,3,1,1,2,2");

Test.assertEquals(Find_Kolakoski_Number([1, 2], 10000), 1);
Test.assertEquals(Find_Kolakoski_Number([2, 1, 3, 1], 97), 3);

Recent Moves:

kwantum00Failed Tests

Kolakoski Sequence Generator

Puzzles

Games

Mathematics

Algorithms

Numbers

Sequences

Arrays

Description

The Kolakoski Sequence is a infinite string of integers that describes it own construction. Each digit, in order, encodes the size of the run that some digit in the sequence appears.

The inital terms of the sequence seeded by [1,2] are:

1, 2, 2, 1, 1, 2, 1, 2, 2...

Notice that there is one 1, followed by two 2s, then two 1s. In general the repitition of digits can be described as:

1, 2, 2, 1, 1, 2, 1, 2, 2...

Or the sequence itself. That is the idea you will be exploring in this excercise.

Instructions

Task 1:

Generate_Kolakoski_Seq(seed, n)

Write a function that takes an array of symbols as a seed, and an integer n, and produces the Kolakoski Sequence for that seed up to the nth digit as a common separted string.

Generate_Kolakoski_Seq( [2,3], 11 )

returns "2,2,3,3,2,2,2,3,3,3,2"

Generate_Kolakoski_Seq( [2], 5 )

returns "2,2,2,2,2"

Task 2:

Find_Kolaskoski_Number(seed, n)

Write a function that takes an array of symbols and a large integer n, and returns the nth digit of the sequence as an integer.

Find_Kolaskoski_Number( [1,2], 10000 )

returns: 1

(There is a way to compute this without computing the whole sequence)

// takes int[] and int, returns string (comma seperated integers)
function Generate_Kolakoski_Seq(seed, n){

}


// takes int[] and int, returns int
function Find_Kolaskoski_Number(seed, n){

}

karabatsosvs. pythonRules

Expression parser

def parse(expr):

    class State:
        current = expr[0]
        tokens = []

    def exp():
        result = term()
        while State.current in ('+', '-'):
            if State.current == '+':
                next_token()
                result += term()
            if State.current == '-':
                next_token()
                result -= term()
        return result

    def factor():
        result = None
        if State.current[0].isdigit() or State.current[-1].isdigit():
            result = float(State.current)
            next_token()
        elif State.current is '(':
            next_token()
            result = exp()
            next_token()
        return result

    def next_token():
        State.tokens = State.tokens[1:]
        State.current = State.tokens[0] if len(State.tokens) > 0 else None

    def term():
        result = factor()
        while State.current in ('*', '/'):
            if State.current == '*':
                next_token()
                result *= term()
            if State.current == '/':
                next_token()
                result /= term()
        return result

    for i in range(len(expr)):
        if expr[i].isdigit() and i > 0 and (State.tokens[-1].isdigit() or State.tokens[-1][-1] is '.'):
            State.tokens[-1] += expr[i]
        elif expr[i] is '.' and i > 0 and State.tokens[-1].isdigit():
            State.tokens[-1] += expr[i]
        else:
            State.tokens.append(expr[i])

    return exp()

Recent Moves:

pythonRules

Expression parser

Parses an expression.

def parse(expr): #The main parser
  ps = 0 #Number of open parentheses
  cval = 0 #Current value
  op = "+" #Current operation
  accum = "" #Accumulating value
  for i in range(len(expr)):
    c = expr[i]
    if c in ["+","-"] and not ps: #Operation not inside parens
      if op=="+": #Addition
        cval+=parse_fact(accum)
      else: #Subtraction
        cval-=parse_fact(accum)
      accum = "" #Reset the value
      op = c #New operation once that was calculated
    else:
      if c=="(": ps+=1 #Open paren
      if c==")": ps-=1 #Close paren
      accum+=c #Add a character to accumulating value
  if op=="+": #Do the operation one more time
    cval+=parse_fact(accum)
  else:
    cval-=parse_fact(accum)
  return cval
def parse_fact(term):
  ps = 0
  cval = 1
  op = "*"
  accum = ""
  for i in range(len(term)):
    c = term[i]
    if c in ["*","/"] and not ps:
      if op=="*":
        cval*=parse_val(accum)
      else:
        cval/=parse_val(accum)
      accum = ""
      op = c
    else:
      if c=="(": ps+=1
      if c==")": ps-=1
      accum+=c
  if op=="*":
    cval*=parse_val(accum)
  else:
    cval/=parse_val(accum)
  return cval
def parse_val(val):
  if val[0] == "(": #Parenthetical expression
    return parse(val[1:-1]) #Cut off parentheses and reevaluate
  else:
    return float(val) #Not parenthetical

test.expect(parse("5")==5,"FAILED TEST CASE 1 (5)")
test.expect(parse("5+5")==10,"FAILED TEST CASE 2 (5+5)")
test.expect(parse("5*5")==25,"FAILED TEST CASE 3 (5*5)")
test.expect(parse("5*5+5")==30,"FAILED TEST CASE 4 (5*5+5)")
test.expect(parse("5*5+5/5")==26,"FAILED TEST CASE 5 (5*5+5/5)")
test.expect(parse("5*(5+5)/5")==10,"FAILED TEST CASE 6 (5*(5+5)/5)")
test.expect(parse("5*(5+(10/2))/5")==10,"FAILED TEST CASE 7 (5*(5+(10/2))/5)")
test.expect(parse("(60/5)-4/29-61+96")==46.86206896551724,"FAILED TEST CASE 8")

ferclaverino

Game of Life (with tests and no refactoring):

Game of Life :

The Game of Life, also known simply as Life, is a cellular automaton devised by the British mathematician John Horton Conway in 1970.

Game of Life

Your task is to write a program to calculate the next generation of Conway's game of life, given any starting position.
You start with a two dimensional grid of cells, where each cell is either alive or dead.
The grid is finite, and no life can exist off the edges.
When calculating the next generation of the grid, follow these four rules:

Any live cell with fewer than two live neighbours dies, as if caused by underpopulation.
Any live cell with more than three live neighbours dies, as if by overcrowding.
Any live cell with two or three live neighbours lives on to the next generation.
Any dead cell with exactly three live neighbours becomes a live cell.

Examples: * indicates live cell, . indicates dead cell

Example input: (4 x 8 grid)
........
....*...
...**...
........

Example output:
........
...**...
...**...
........

function nextGeneration(grid) {
  return grid.map((row, rowIndex) => {
    return row.map((cell, colIndex) => {
      if (rowIndex !== 0 && colIndex !== 0 && rowIndex < grid.length - 1 && colIndex < row.length - 1) {
        let neighboursCount = 0;
        if (grid[rowIndex][colIndex + 1] === 1) neighboursCount++;
        if (grid[rowIndex][colIndex - 1] === 1) neighboursCount++;
        if (grid[rowIndex + 1][colIndex] === 1) neighboursCount++;
        if (grid[rowIndex - 1][colIndex] === 1) neighboursCount++;
        if (grid[rowIndex + 1][colIndex + 1] === 1) neighboursCount++;
        if (grid[rowIndex + 1][colIndex - 1] === 1) neighboursCount++;
        if (grid[rowIndex - 1][colIndex + 1] === 1) neighboursCount++;
        if (grid[rowIndex - 1][colIndex - 1] === 1) neighboursCount++;
      
        if (cell === 1) {
          if (neighboursCount === 2 || neighboursCount === 3 ) {
            return 1;
          }
        } else {
          if (neighboursCount === 3 ) {
            return 1;
          }
        }
        return 0;
      }
      return 0;
    });
  });
}

describe("Given empty grid", () => {
  it("when next generation, should return empty", () => {
    Test.assertDeepEquals(nextGeneration([]), []);
  });
});

describe("Given a single cell", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0],
      [0,1,0],
      [0,0,0],
    ]), [
      [0,0,0],
      [0,0,0],
      [0,0,0],
    ]);
  });
});

describe("Given a cell with 1 neighbour at rows", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0],
      [0,1,1,0],
      [0,0,0,0],
    ]), [
      [0,0,0,0],
      [0,0,0,0],
      [0,0,0,0],
    ]);
  });
});

describe("Given a cell with 2 neighbours at rows", () => {
  it("when next generation, should live", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 2 neighbours at cols", () => {
  it("when next generation, should live", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0],
      [0,1,0],
      [0,1,0],
      [0,1,0],
      [0,0,0],
    ]), [
      [0,0,0],
      [0,0,0],
      [0,1,0],
      [0,0,0],
      [0,0,0],
    ]);
  });
});

describe("Given a cell with 2 neighbours at \ (diagonal)", () => {
  it("when next generation, should live", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,0,0,0],
      [0,0,1,0,0],
      [0,0,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 2 neighbours at / (diagonal)", () => {
  it("when next generation, should live", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,0,0,1,0],
      [0,0,1,0,0],
      [0,1,0,0,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 4 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,1,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,1,0,1,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 5 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,0,1,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 6 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,1,1,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
      [0,1,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 7 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,1,1,1,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 8 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,1,1,1,0],
      [0,1,1,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a die cell with 2 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,0,0,0],
      [0,0,0,0,0],
      [0,1,0,0,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a die cell with 3 neighbours", () => {
  it("when next generation, should live", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
      [0,1,0,0,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a die cell with 4 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

donaldsebleungFailed Tests

Computing the real Gamma Function with Stirling's Approximation

Mathematics

Algorithms

Numbers

Computing the real Gamma Function with Stirling's Approximation

Related Kata

Computing the complex Gamma function <-- click on the link to attempt the Kata now :D

Related Collection

Complex Analysis

Overview

The Gamma Function Γ(x) is an extension of the factorial function - while the factorial n! is only defined for non-negative integers, the gamma function is defined for all numbers except the non-positive integers. However, the gamma function has its argument shifted down by 1 such that Γ(n) = (n - 1)! for all n where n is a positive integer. One of its many applications is in fractional calculus.

Definitions

The main definition of the gamma function is based on a definite integral with positive infinity as one of its limits. There are also other exact definitions of the gamma function such as "Euler's definition as an infinite product" and the "Weierstrass definition". However, I will not elaborate on these definitions - more information can be easily found on Wikipedia (or by consulting your math professor).

The Problem

It is technically impossible to implement an exact definition of the Gamma Function in a computer/calculator since "there are, relatively speaking, no such simple solutions for factorials; no finite combination of sums, products, powers, exponential functions, or logarithms will suffice to express x!" (source: Wikipedia) so one must always resort to numerically approximating the Gamma function, ideally to a high degree of accuracy. A common, well-known approximation to the Gamma Function is known as Stirling's Approximation which has a simple formula and is usually sufficiently accurate for large values of x; however, since it is an asymptotic approximation, it loses its accuracy for small values of x and doesn't work with negative values of x due to an attempt at squarerooting a negative number (JavaScript Math.sqrt returns NaN for negative inputs).

The Challenge

Stirling's Approximation is implemented in this Kumite as a possible implementation for the Gamma Function; however, you will notice that it fails most, if not all, of the tests. The challenge, should you accept it, is to properly implement the Gamma Function such that it passes all test cases properly.

function gamma(x) {
  // Stirling's Approximation is simple and efficient (just a single calculation)
  // but will it work?
  x -= 1; // Shift argument down by 1
  return Math.sqrt(2 * Math.PI * x) * Math.pow(x / Math.E, x); // Compute Stirling's Formula
}

Test.describe('Your real Gamma function "gamma"', function () {
  Test.it('should properly compute Γ(n) to a high degree of accuracy where n is a positive integer', function () {
    Test.assertApproxEquals(gamma(1), 1, 'Γ(1) = 0! = 1');
    Test.assertApproxEquals(gamma(2), 1, 'Γ(2) = 1! = 1');
    Test.assertApproxEquals(gamma(3), 2, 'Γ(3) = 2! = 2');
    Test.assertApproxEquals(gamma(4), 6, 'Γ(4) = 3! = 6');
    Test.assertApproxEquals(gamma(5), 24);
    Test.assertApproxEquals(gamma(6), 120);
    Test.assertApproxEquals(gamma(7), 720);
    Test.assertApproxEquals(gamma(8), 5040);
    Test.assertApproxEquals(gamma(9), 40320);
    Test.assertApproxEquals(gamma(10), 362880);
    Test.assertApproxEquals(gamma(51), 3.041409320e64);
  });
  Test.it('should properly compute Γ(x) to a high degree of accuracy for common values of positive real x', function () {
    Test.assertApproxEquals(gamma(1 / 2), Math.sqrt(Math.PI), 'Γ(1/2) = sqrt(pi)');
    Test.assertApproxEquals(gamma(3 / 2), 1 / 2 * Math.sqrt(Math.PI), 'Γ(3/2) = 1/2 * sqrt(pi)');
    Test.assertApproxEquals(gamma(5 / 2), 3 / 4 * Math.sqrt(Math.PI), 'Γ(5/2) = 3/4 * sqrt(pi)');
    Test.assertApproxEquals(gamma(7 / 2), 15 / 8 * Math.sqrt(Math.PI), 'Γ(7/2) = 15/8 * sqrt(pi)');
  });
  Test.it('should properly compute Γ(x) to a high degree of accuracy for common values of negative real x as well', function () {
    Test.assertApproxEquals(gamma(-1 / 2), -2 * Math.sqrt(Math.PI), 'Γ(-1/2) = -2 * sqrt(pi)');
    Test.assertApproxEquals(gamma(-3 / 2), 4 / 3 * Math.sqrt(Math.PI));
    Test.assertApproxEquals(gamma(-5 / 2), -8 / 15 * Math.sqrt(Math.PI));
  });
});

Unnamedvs. Slx64

Multiplication of Complex Numbers [C]

Mathematics

Algorithms

Numbers

#include <complex.h>

double complex multiply(double complex z, double complex w) {
  return z*w;
}

1 - proc multiply(z: complex, w: complex): complex {
1 + #include <complex.h>
2 +
3 + double complex multiply(double complex z, double complex w) {
2 2 return z*w;
3 3 }

#include <criterion/criterion.h>
#include <complex.h>

double complex multiply(double complex z, double complex w);

Test(complex_numbers, multiply) {
  const double complex z = 5 - 1*I, w = -2 + 4*I;
  const double complex product = multiply(z, w);
  cr_assert_eq(product, -6 + 22*I);
}

Recent Moves:

Slx64vs. donaldsebleung

Multiplication of Complex Numbers [Chapel]

Mathematics

Algorithms

Numbers

proc multiply(z: complex, w: complex): complex {
  return z*w;
}

Test.describe('The complex "multiply" function');
var z: complex = 5 - 1i;
var w: complex = -2 + 4i;
Test.it('should correctly multiply two complex numbers "z" and "w" together');
var product: complex = multiply(z, w);
Test.assertEquals(product.re, -6);
Test.assertEquals(product.im, 22);

Multiplication of Complex Numbers

Mathematics

Algorithms

Numbers

Multiplication of Complex Numbers

Related Collection

Complex Analysis - click the link to try it out now :D

The Problem

Given two complex numbers z = x + iy and w = u + iv, how do I multiply them together (i.e. compute z * w)?

The Solution

First, use the FOIL rule (first, outer, inner, last) to multiply and expand the expression:

z * w = (x + iy) * (u + iv) = xu + xiv + iyu + yvi^2

Then note that i^2 = -1 by definition and collect real and imaginary terms:

xu + xiv + iyu + yvi^2 = xu + i(xv + yu) - yv = (xu - yv) + i(xv + yu)

function multiply(z, w) {
  var x = Re(z);
  var y = Im(z);
  var u = Re(w);
  var v = Im(w);
  return new ComplexNumber(x * u - y * v, x * v + y * u);
}

Test.describe('The complex "multiply" function', function () {
  var z = new ComplexNumber(5, -1); // 5 - i
  var w = new ComplexNumber(-2, 4); // -2 + 4i
  Test.it('should correctly multiply two complex numbers "z" and "w" together', function () {
    var product = multiply(z, w); // should equal -6 + 22i as per WolframAlpha
    Test.assertEquals(Re(product), -6);
    Test.assertEquals(Im(product), 22);
  });
});

ptzafrirvs. nuzyly

Palindrome Dates

package com.mystuff.juststuff;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.Arrays;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Palindrome {

  private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMddyyyy");

  public Set<LocalDate> countDatePalindromes(final LocalDate startDate, final LocalDate endDate) {
    final SortedSet<LocalDate> sortedDates = new TreeSet<>(Arrays.asList(startDate, endDate));
    return IntStream.rangeClosed(sortedDates.first().getYear(), sortedDates.last().getYear())
        .filter(Palindrome::isPalindromePossible)
        .mapToObj(Palindrome::createPalindrome)
        .filter(isDateInRange(sortedDates.first(), sortedDates.last()))
        .collect(Collectors.toCollection(TreeSet::new));
  }
  
  private static boolean isPalindromePossible(int year) {
      int monthFirstDigit = year % 10;
      return monthFirstDigit == 0 || monthFirstDigit == 1; 
  }

  private static LocalDate createPalindrome(final int year) {
    final String yearStr = String.valueOf(year);
    final String datePalindrome = new StringBuilder(yearStr).reverse().append(yearStr).toString();
    try {
      return LocalDate.parse(datePalindrome, formatter);
    } catch (final DateTimeParseException e) {}
    return null;
  }

  private static Predicate<LocalDate> isDateInRange(final LocalDate startDate, final LocalDate endDate) {
    return (date) -> !(date == null || date.isBefore(startDate) || date.isAfter(endDate));
  }
}

Recent Moves:

nuzylyvs. ptzafrir

Palindrome Dates

package com.mystuff.juststuff;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.Arrays;
import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.function.Predicate;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Palindrome {

  private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMddyyyy");

  public Set<LocalDate> countDatePalindromes(final LocalDate startDate, final LocalDate endDate) {
    final SortedSet<LocalDate> sortedDates = new TreeSet<>(Arrays.asList(startDate, endDate));
    return IntStream.rangeClosed(sortedDates.first().getYear(), sortedDates.last().getYear())
        .mapToObj(Palindrome::createPalindrome)
        .filter(isDateInRange(sortedDates.first(), sortedDates.last()))
        .collect(Collectors.toCollection(TreeSet::new));
  }

  private static LocalDate createPalindrome(final int year) {
    final String yearStr = String.valueOf(year);
    final String datePalindrome = new StringBuilder(yearStr).reverse().append(yearStr).toString();
    try {
      return LocalDate.parse(datePalindrome, formatter);
    } catch (final DateTimeParseException e) {}
    return null;
  }

  private static Predicate<LocalDate> isDateInRange(final LocalDate startDate, final LocalDate endDate) {
    return (date) -> !(date == null || date.isBefore(startDate) || date.isAfter(endDate));
  }
}

package com.mystuff.juststuff;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.time.LocalDate;
import java.util.Set;

import org.junit.Test;

public class PalindromeTest {
	@Test
	public void testCountDatePalindromesEndDateBeforeStartDate() {
		final LocalDate startDate = LocalDate.of(2001, 12, 1);
		final LocalDate endDate = LocalDate.of(2001, 1, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertTrue("Set size should be greater than zero", palSet.size() > 0);
	}

	@Test
	public void testCountDatePalindromesStartDateBeforeEndDate() {
		final LocalDate startDate = LocalDate.of(2001, 1, 1);
		final LocalDate endDate = LocalDate.of(2001, 12, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertTrue("Set size should be greater than zero", palSet.size() > 0);
	}

	@Test
	public void testCountDatePalindromesStartDateEqualsEndDateNoPalindromes() {
		final LocalDate startDate = LocalDate.of(2001, 12, 31); // Dec 31, 2001 is not a palindrome date
		final LocalDate endDate = LocalDate.of(2001, 12, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertEquals("Set size should be zero", 0, palSet.size());
	}

	@Test
	public void testCountDatePalindromesStartDateEqualsEndDateOnePalindrome() {
		final LocalDate startDate = LocalDate.of(2001, 10, 2); // Oct 2, 2001 is a palindrome date
		final LocalDate endDate = LocalDate.of(2001, 10, 2);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertEquals("Set size should be one", 1, palSet.size());
	}

	@Test
	public void testCountDatePalindromesHugeDateRange() {
		final LocalDate startDate = LocalDate.of(1900, 1, 1);
		final LocalDate endDate = LocalDate.of(2001, 12, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertEquals("There is 1 palindrom date between 1/1/1900 12/31/2001", 1, palSet.size());
	}

	@Test
	public void testCountDatePalindromesMultipleValues() {
		final LocalDate startDate = LocalDate.of(1900, 1, 1);
		final LocalDate endDate = LocalDate.of(2010, 12, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertEquals("There are 2 palindrom date between 1/1/1900 12/31/2010", 2, palSet.size());
	}
  
  @Test
	public void testCountDatePalindromesMultipleValuesEndDateBeforeStartDate() {
		final LocalDate startDate = LocalDate.of(2010, 12, 31);
		final LocalDate endDate = LocalDate.of(1900, 1, 1);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertEquals("There are 2 palindrom date between 1/1/1900 12/31/2010", 2, palSet.size());
	}
}

ptzafrirvs. nuzyly

Palindrome Dates

package com.mystuff.juststuff;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.format.DateTimeParseException;
import java.util.Set;
import java.util.TreeSet;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

public class Palindrome {

	private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMddyyyy");

	public Set<LocalDate> countDatePalindromes(final LocalDate startDate, final LocalDate endDate) {
		return IntStream.range(startDate.getYear(), endDate.getYear() + 1).mapToObj(Palindrome::createPalindrome)
				.filter(date -> isValidDate(date, startDate, endDate)).collect(Collectors.toCollection(TreeSet::new));
	}

	private static LocalDate createPalindrome(int year) {
		String yearStr = String.valueOf(year);
		String datePalindrome = new StringBuilder().append(yearStr).reverse().append(yearStr).toString();
		try {
			return LocalDate.parse(datePalindrome, formatter);
		} catch (DateTimeParseException e) {
			return null;
		}

	}

	private static boolean isValidDate(final LocalDate date, LocalDate startDate, LocalDate endDate) {
		if (date == null)
			return false;
		if (startDate.isEqual(date) || endDate.isEqual(date))
			return true;
		return startDate.isBefore(date) && endDate.isAfter(date) ||
				endDate.isBefore(date) && startDate.isAfter(date);
	}
}

package com.mystuff.juststuff;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;

import java.time.LocalDate;
import java.util.Set;

import org.junit.Test;

public class PalindromeTest {
	@Test
	public void testCountDatePalindromesEndDateBeforeStartDate() {
		final LocalDate startDate = LocalDate.of(2001, 12, 1);
		final LocalDate endDate = LocalDate.of(2001, 1, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertTrue("Set size should be greater than zero", palSet.size() > 0);
	}

	@Test
	public void testCountDatePalindromesStartDateBeforeEndDate() {
		final LocalDate startDate = LocalDate.of(2001, 1, 1);
		final LocalDate endDate = LocalDate.of(2001, 12, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertTrue("Set size should be greater than zero", palSet.size() > 0);
	}

	@Test
	public void testCountDatePalindromesStartDateEqualsEndDateNoPalindromes() {
		final LocalDate startDate = LocalDate.of(2001, 12, 31); // Dec 31, 2001 is not a palindrome date
		final LocalDate endDate = LocalDate.of(2001, 12, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertEquals("Set size should be zero", 0, palSet.size());
	}

	@Test
	public void testCountDatePalindromesStartDateEqualsEndDateOnePalindrome() {
		final LocalDate startDate = LocalDate.of(2001, 10, 2); // Oct 2, 2001 is a palindrome date
		final LocalDate endDate = LocalDate.of(2001, 10, 2);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertEquals("Set size should be one", 1, palSet.size());
	}

	@Test
	public void testCountDatePalindromesHugeDateRange() {
		final LocalDate startDate = LocalDate.of(1900, 1, 1);
		final LocalDate endDate = LocalDate.of(2001, 12, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertEquals("There is 1 palindrom date between 1/1/1900 12/31/2001", 1, palSet.size());
	}

	@Test
	public void testCountDatePalindromesMultipleValues() {
		final LocalDate startDate = LocalDate.of(1900, 1, 1);
		final LocalDate endDate = LocalDate.of(2010, 12, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertEquals("There are 2 palindrom date between 1/1/1900 12/31/2010", 2, palSet.size());
	}
}

nuzylyvs. dinglemouse

Palindrome Dates

package com.mystuff.juststuff;

import java.util.Set;
import java.util.SortedSet;
import java.util.TreeSet;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoUnit;


public class Palindrome {

  private static final DateTimeFormatter formatter = DateTimeFormatter.ofPattern("MMddyyyy");

  public Set<LocalDate> countDatePalindromes(final LocalDate startDate, final LocalDate endDate) {
    final SortedSet<LocalDate> sortedDates = Stream.of(startDate, endDate).collect(Collectors.toCollection(TreeSet::new));
    return Stream.iterate(sortedDates.first(), date -> date.plusDays(1))
        .limit(ChronoUnit.DAYS.between(sortedDates.first(), sortedDates.last().plusDays(1)))
        .filter(Palindrome::isPalindrome)
        .collect(Collectors.toCollection(TreeSet::new));
  }
  
  private static boolean isPalindrome(final LocalDate date) {
    final String fwd = date.format(formatter);
    return fwd.equals(new StringBuilder(fwd).reverse().toString());
  }
}

package com.mystuff.juststuff;

import static org.junit.Assert.assertTrue;

import java.util.Set;

import java.time.LocalDate;

import org.junit.Test;


public class PalindromeTest {
	@Test
	public void testCountDatePalindromesEndDateBeforeStartDate() {
		final LocalDate startDate = LocalDate.of(2001, 12, 1);
		final LocalDate endDate = LocalDate.of(2001, 1, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertTrue("Set size should be greater than zero", palSet.size() > 0);
	}

	@Test
	public void testCountDatePalindromesStartDateBeforeEndDate() {
		final LocalDate startDate = LocalDate.of(2001, 1, 1);
		final LocalDate endDate = LocalDate.of(2001, 12, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertTrue("Set size should be greater than zero", palSet.size() > 0);
	}

	@Test
	public void testCountDatePalindromesStartDateEqualsEndDateNoPalindromes() {
		final LocalDate startDate = LocalDate.of(2001, 12, 31); // Dec 31, 2001 is not a palindrome date
		final LocalDate endDate = LocalDate.of(2001, 12, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertTrue("Set size should be zero", palSet.size() == 0);
	}

	@Test
	public void testCountDatePalindromesStartDateEqualsEndDateOnePalindrome() {
		final LocalDate startDate = LocalDate.of(2001, 10, 2); // Oct 2, 2001 is a palindrome date
		final LocalDate endDate = LocalDate.of(2001, 10, 2);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertTrue("Set size should be one", palSet.size() == 1);
	}

	@Test
	public void testCountDatePalindromesHugeDateRange() {
		final LocalDate startDate = LocalDate.of(1900, 1, 1);
		final LocalDate endDate = LocalDate.of(2001, 12, 31);
		final Set<LocalDate> palSet = new Palindrome().countDatePalindromes(startDate, endDate);
		assertTrue("Set size should be greater than zero", palSet.size() > 0);
	}
}

dinglemousevs. alinodev

Palindrome Dates

package com.mystuff.juststuff;

import java.text.*;
import java.util.*;

public class Palindrome {

	private static final SimpleDateFormat sdf = new SimpleDateFormat("MMddyyyy");

	public Set<Date> countDatePalindromes(final Date startDate, final Date endDate) {
		final Set<Date> set = new TreeSet<>();
		final GregorianCalendar startCal = new GregorianCalendar();
		final GregorianCalendar endCal = new GregorianCalendar();

    // If end date is before start date, flip them.
    startCal.setTime(startDate.before(endDate) ? startDate : endDate);
    endCal.setTime(startDate.after(endDate) ? startDate : endDate);
    
		for (; startCal.before(endCal) || startCal.equals(endCal); startCal.add(Calendar.DAY_OF_MONTH, 1)) {   
			final String forward = sdf.format(startCal.getTime());
      final String back = new StringBuilder(forward).reverse().toString();            
			if (forward.equals(back)) {
        set.add(startCal.getTime()); // Date string looks same both ways	
      }
		}	
    
		return set;
	}
	
}

package com.mystuff.juststuff;

import static org.junit.Assert.assertTrue;

import java.util.Date;
import java.util.GregorianCalendar;
import java.util.Set;

import org.junit.Test;

public class PalindromeTest
{
	@Test
	public void testCountDatePalindromesEndDateBeforeStartDate()
	{
		GregorianCalendar startCalTest = new GregorianCalendar(2001, 11, 1);
		GregorianCalendar endCalTest = new GregorianCalendar(2001, 0, 31);
		Date startDate = new Date(startCalTest.getTimeInMillis());
		Date endDate = new Date(endCalTest.getTimeInMillis());

		Palindrome drome = new Palindrome();
		Set<Date> palSet = drome.countDatePalindromes(startDate, endDate);
		
		assertTrue("Set size should be greater than zero", palSet.size() > 0);
	}

	@Test
	public void testCountDatePalindromesStartDateBeforeEndDate()
	{
		GregorianCalendar startCalTest = new GregorianCalendar(2001, 0, 1);
		GregorianCalendar endCalTest = new GregorianCalendar(2001, 11, 31);
		Date startDate = new Date(startCalTest.getTimeInMillis());
		Date endDate = new Date(endCalTest.getTimeInMillis());

		Palindrome drome = new Palindrome();
		Set<Date> palSet = drome.countDatePalindromes(startDate, endDate);
		
		assertTrue("Set size should be greater than zero", palSet.size() > 0);
	}

	@Test
	public void testCountDatePalindromesStartDateEqualsEndDateNoPalindromes()
	{
		GregorianCalendar startCalTest = new GregorianCalendar(2001, 11, 31); // Nov 31, 2001 is not a palindrome date
		GregorianCalendar endCalTest = new GregorianCalendar(2001, 11, 31);
		Date startDate = new Date(startCalTest.getTimeInMillis());
		Date endDate = new Date(endCalTest.getTimeInMillis());

		Palindrome drome = new Palindrome();
		Set<Date> palSet = drome.countDatePalindromes(startDate, endDate);
		
		assertTrue("Set size should be zero", palSet.size() == 0);
	}

	@Test
	public void testCountDatePalindromesStartDateEqualsEndDateOnePalindrome()
	{
		GregorianCalendar startCalTest = new GregorianCalendar(2001, 9, 2); // Oct 2, 2001 is a palindrome date
		GregorianCalendar endCalTest = new GregorianCalendar(2001, 9, 2);
		Date startDate = new Date(startCalTest.getTimeInMillis());
		Date endDate = new Date(endCalTest.getTimeInMillis());

		Palindrome drome = new Palindrome();
		Set<Date> palSet = drome.countDatePalindromes(startDate, endDate);
		
		assertTrue("Set size should be one", palSet.size() == 1);
	}

	@Test
	public void testCountDatePalindromesHugeDateRange()
	{
		GregorianCalendar startCalTest = new GregorianCalendar(1900, 0, 1);
		GregorianCalendar endCalTest = new GregorianCalendar(2001, 11, 31);
		Date startDate = new Date(startCalTest.getTimeInMillis());
		Date endDate = new Date(endCalTest.getTimeInMillis());

		Palindrome drome = new Palindrome();
		Set<Date> palSet = drome.countDatePalindromes(startDate, endDate);
		
		assertTrue("Set size should be greater than zero", palSet.size() > 0);
	}
}

Division of Complex Numbers

Mathematics

Algorithms

Numbers

Division of Complex Numbers

Related Collection

Complex Analysis <-- click on the link to train on this Collection :D

The Problem

Given two complex numbers z = x + iy and w = u + iv, how do I divide one by the other, e.g. compute z / w (or the reverse)?

The Solution

Just as one may rationalize the denominator of 1 / sqrt(2) to obtain sqrt(2) / 2, it is also possible to real-ize the denominator of z / w by multiplying both the numerator and denominator by the complex conjugate of "w" w* = u - iv. Then use the identity i^2 = -1 where necessary and collect real and imaginary terms.

z / w
= (z * w*) / (w * w*)
= ((x + iy) * (u - iv)) / ((u + iv) * (u - iv))
= (xu - xiv + iyu - yvi^2) / (u^2 - (iv)^2)
= ((xu + yv) + i(yu - xv)) / (u^2 + v^2)
= ((xu + yv) / (u^2 + v^2)) + i((yu - xv) / (u^2 + v^2))

Also note that u^2 + v^2 = |w|^2 which may help to simplify your code further.

function divide(z, w) {
  var x = Re(z);
  var y = Im(z);
  var u = Re(w);
  var v = Im(w);
  const abs = z => Math.hypot(Re(z), Im(z));
  return new ComplexNumber((x * u + y * v) / Math.pow(abs(w), 2), (y * u - x * v) / Math.pow(abs(w), 2));
}

Test.describe('Your complex "divide" function', function () {
  var z = new ComplexNumber(17, 13); // 17 + 13i
  var w = new ComplexNumber(-6, 8); // -6 + 8i
  Test.it('should divide two complex numbers correctly', function () {
    var quotient = divide(z, w); // z / w should equal 1 / 50 - (107 / 50)i as per WolframAlpha
    Test.assertApproxEquals(Re(quotient), 1 / 50);
    Test.assertApproxEquals(Im(quotient), -107 / 50);
  });
});

Slx64

HPCC STREAM Triad [Chapel Test]

Calculate A = B + alpha * C

proc stream(b, c, alpha) {
    return b + alpha * c;
}

Test.describe("HPCC STREAM Triad");

const size: int = 5;
const a: real = 3.0;

var B, C: [1..size] real = [i in 1..size] i;
var A: [B.domain] real = stream(B, C, a);

Test.expect(A == [4.0, 8.0, 12.0, 16.0, 20.0]);

Complex Addition and Subtraction

Mathematics

Algorithms

Numbers

Complex Addition and Subtraction

Related Collection

Complex Analysis

The Problem

Given two complex numbers z = x + iy and w = u + iv, how do I add them together? Furthermore, how do I compute z - w if required?

The Solution

For addition, adding two complex numbers is as easy as adding their real and imaginary components together. So z + w becomes (x + iy) + (u + iv) = (x + u) + i(y + v) and z - w becomes (x + iy) - (u + iv) = (x - u) + i(y - v).

function add(z, w) {
  var x = Re(z);
  var y = Im(z);
  var u = Re(w);
  var v = Im(w);
  return new ComplexNumber(x + u, y + v); // z + w = (x + u) + i(y + v)
}
function subtract(z, w) {
  var x = Re(z);
  var y = Im(z);
  var u = Re(w);
  var v = Im(w);
  return new ComplexNumber(x - u, y - v); // z - w = (x - u) + i(y - v)
}

Test.describe('Function "add"', function () {
  var z = new ComplexNumber(3, 2); // 3 + 2i
  var w = new ComplexNumber(-5, 4); // -5 + 4i
  Test.it('should correctly add two complex numbers together', function () {
    var sum = add(z, w); // Should equal z + w = (3 + 2i) + (-5 + 4i) = -2 + 6i
    Test.assertEquals(Re(sum), -2);
    Test.assertEquals(Im(sum), 6);
  });
  Test.it('should correctly subtract two complex numbers in the given order', function () {
    var difference = subtract(z, w); // Should equal z - w = (3 + 2i) - (-5 + 4i) = 8 - 2i
    Test.assertEquals(Re(difference), 8);
    Test.assertEquals(Im(difference), -2);
  });
});

geoguidevs. ferclaverinoFailed Tests

Game of Life

Changed game of life to take an array of arrays of rows and columns.

function nextGeneration(grid) {
  const neighborsInit = {
    l:true,bl:true,bc:true,br:true,r:true,tr:true,tc:true,tl:true
  };
  let neighbors = JSON.parse(JSON.stringify(neighborsInit));
  let liveNeighbors = 0;
  let isAlive = true;
  var nextGen = JSON.parse(JSON.stringify(grid));
  grid.map(function(row,rowIndex,rows){
    row.map(function(element,index,thisRow){
      liveNeighbors = 0;
      neighbors = JSON.parse(JSON.stringify(neighborsInit));
      if(element == 1){
        isAlive = true;
      } else {
        isAlive = false;
      }

      //Where to check
      if(rowIndex === 0){
        //If it is the first row don't look for life above
        neighbors.tr = neighbors.tc = neighbors.tl = false;
      }
      if(rowIndex === grid.length-1){
        //If it is the last row don't look for life below
        neighbors.br = neighbors.bc = neighbors.bl = false;
      }
      if(index == 0){
        //If it is the first column don't look for life left
        neighbors.tl = neighbors.l = neighbors.bl = false;
      }
      if(index == row.length-1){
        //If it is the last column don't look for life right
        neighbors.tr = neighbors.r = neighbors.br = false;
      }
      //Top
      if(neighbors.tl && grid[rowIndex-1][index-1] == 1){
        liveNeighbors++;
      }
      if(neighbors.tc && grid[rowIndex-1][index] == 1){
        liveNeighbors++;
      }
      if(neighbors.tr && grid[rowIndex-1][index+1] == 1){
        liveNeighbors++;
      }
      //right
      if(neighbors.r && grid[rowIndex][index+1] == 1){
        liveNeighbors++;
      }
      //Bottom
      if(neighbors.br && (grid[rowIndex+1][index+1] === 1)){
        liveNeighbors++;
      }
      if(neighbors.bc && grid[rowIndex+1][index] == 1){
        liveNeighbors++;
      }
      if(neighbors.bl && grid[rowIndex+1][index-1] == 1){
        liveNeighbors++;
      }
      //left
      if(neighbors.l && grid[rowIndex][index-1] == 1){
        liveNeighbors++;
      }

      //Live?
      if(isAlive){

        //Any live cell with fewer than two live neighbours dies, as if caused by underpopulation.
        if(liveNeighbors < 2){
          //kill
          //console.log('die from lonliness :(');
          nextGen[rowIndex][index] = 0;
        }
        //Any live cell with more than three live neighbours dies, as if by overcrowding.
        if(liveNeighbors > 3){
          //kill
          //console.log('died from over crowding');
          nextGen[rowIndex][index] = 0;
        }
      }
      //Any dead cell with exactly three live neighbours becomes a live cell.
      if(!isAlive && liveNeighbors == 3){
        nextGen[rowIndex][index] = 1;
      } else {
        //console.info('he stay ded');
      }
    });
  });
  return nextGen;
}

describe("Given empty grid", () => {
  it("when next generation, should return empty", () => {
    assert.deepEqual(nextGeneration([]), []);
  });
});

describe("Given a single cell", () => {
  it("when next generation, should die", () => {
    assert.deepEqual(nextGeneration([
      [0,0,0],
      [0,1,0],
      [0,0,0],
    ]), [
      [0,0,0],
      [0,0,0],
      [0,0,0],
    ]);
  });
});

describe("A complex Gen", () => {
  it("when next generation, should evolve", () => {
    assert.deepEqual(nextGeneration([
      [0,0,0,0],
      [0,1,0,0],
      [0,0,1,1],
      [0,0,1,0],
    ]), [
      [0,0,0,0],
      [0,0,1,0],
      [0,1,1,1],
      [0,0,1,1]
    ]);
  });
});

Recent Moves:

ferclaverinovs. ferclaverino

Game of Life

function nextGeneration(grid) {
  return grid.map((row, rowIndex) => {
    return row.map((cell, colIndex) => {
      if (rowIndex !== 0 && colIndex !== 0 && rowIndex < grid.length - 1 && colIndex < row.length - 1) {
        let neighboursCount = 0;
        if (grid[rowIndex][colIndex + 1] === 1) neighboursCount++;
        if (grid[rowIndex][colIndex - 1] === 1) neighboursCount++;
        if (grid[rowIndex + 1][colIndex] === 1) neighboursCount++;
        if (grid[rowIndex - 1][colIndex] === 1) neighboursCount++;
        if (grid[rowIndex + 1][colIndex + 1] === 1) neighboursCount++;
        if (grid[rowIndex + 1][colIndex - 1] === 1) neighboursCount++;
        if (grid[rowIndex - 1][colIndex + 1] === 1) neighboursCount++;
        if (grid[rowIndex - 1][colIndex - 1] === 1) neighboursCount++;
      
        if (cell === 1) {
          if (neighboursCount === 2 || neighboursCount === 3 ) {
            return 1;
          }
        } else {
          if (neighboursCount === 3 ) {
            return 1;
          }
        }
        return 0;
      }
      return 0;
    });
  });
}

describe("Given empty grid", () => {
  it("when next generation, should return empty", () => {
    Test.assertDeepEquals(nextGeneration([]), []);
  });
});

describe("Given a single cell", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0],
      [0,1,0],
      [0,0,0],
    ]), [
      [0,0,0],
      [0,0,0],
      [0,0,0],
    ]);
  });
});

describe("Given a cell with 1 neighbour at rows", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0],
      [0,1,1,0],
      [0,0,0,0],
    ]), [
      [0,0,0,0],
      [0,0,0,0],
      [0,0,0,0],
    ]);
  });
});

describe("Given a cell with 2 neighbours at rows", () => {
  it("when next generation, should live", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 2 neighbours at cols", () => {
  it("when next generation, should live", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0],
      [0,1,0],
      [0,1,0],
      [0,1,0],
      [0,0,0],
    ]), [
      [0,0,0],
      [0,0,0],
      [0,1,0],
      [0,0,0],
      [0,0,0],
    ]);
  });
});

describe("Given a cell with 2 neighbours at \ (diagonal)", () => {
  it("when next generation, should live", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,0,0,0],
      [0,0,1,0,0],
      [0,0,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 2 neighbours at / (diagonal)", () => {
  it("when next generation, should live", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,0,0,1,0],
      [0,0,1,0,0],
      [0,1,0,0,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 4 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,1,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,1,0,1,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 5 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,0,1,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 6 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,1,1,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
      [0,1,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 7 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,1,1,1,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a cell with 8 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,1,1,0],
      [0,1,1,1,0],
      [0,1,1,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a die cell with 2 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,0,0,0],
      [0,0,0,0,0],
      [0,1,0,0,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a die cell with 3 neighbours", () => {
  it("when next generation, should live", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
      [0,1,0,0,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,1,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

describe("Given a die cell with 4 neighbours", () => {
  it("when next generation, should die", () => {
    Test.assertDeepEquals(nextGeneration([
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
      [0,1,0,1,0],
      [0,0,0,0,0],
    ]), [
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
      [0,0,0,0,0],
    ]);
  });
});

Ketzalkotalvs. Ketzalkotal

Game of Life

function getNeighbors(grid, i){
  var neighborHash = [
    [1, 3, 4], [0, 2, 3, 4, 5], [1, 4, 5],
    [0, 1, 4, 6, 7], [0, 1, 2, 3, 5, 6, 7, 8], [1, 2, 4, 7, 8],
    [3, 4, 7], [3, 4, 5, 6, 8], [4, 5, 7]
  ];
  var result = 0;
  var neighbors = neighborHash[i];
  for(var j = 0; j < neighbors.length; j++){
    if(grid[neighbors[j]] === 1){
      result++;
    }
  }
  return result;
}

function nextGeneration(grid) {
  if(grid.length === 0){
    return [];
  }
  newGrid = [
    0,0,0,
    0,0,0,
    0,0,0
  ];
  for(var i = 0; i < newGrid.length; i++){
    // gets the number of neighbors that are alive for a given cell from the current generation
    var neighbors = getNeighbors(grid, i);
    // these if statements determine whether a cell is alive or dead in the next generation
    if(neighbors > 3 || neighbors < 2){
      newGrid[i] = 0;
    }
    if(grid[i] === 0 && neighbors === 3){
      newGrid[i] = 1;
    }
    if(grid[i] === 1 && (neighbors === 2 || neighbors === 3)){
      newGrid[i] = 1
    }
  }
  return newGrid;
}

Test.describe("Given an empty grid, the next generation should return empty", function(){
    Test.assertDeepEquals(nextGeneration([]), []);
});

Test.describe("Given a single live cell, it should die", function(){
    Test.assertDeepEquals(nextGeneration([
      0,0,0,
      0,1,0,
      0,0,0,
    ]), [
      0,0,0,
      0,0,0,
      0,0,0,
    ]);
});

Test.describe("Given a line of live cells, another should appear", function(){
    Test.assertDeepEquals(nextGeneration([
      0,1,0,
      0,1,0,
      0,1,0,
    ]), [
      0,0,0,
      1,1,1,
      0,0,0,
    ]);
});

Test.describe("Given overcrowded cells, most of them should die", function(){
    Test.assertDeepEquals(nextGeneration([
      1,1,1,
      1,1,1,
      1,1,1,
    ]), [
      1,0,1,
      0,0,0,
      1,0,1,
    ]);
});

Ketzalkotalvs. ferclaverinoFailed Tests

Game of Life

function getNeighbors(grid, i){
  var neighborHash = [
    [1, 3, 4], [0, 2, 3, 4, 5], [1, 4, 5],
    [0, 1, 4, 6, 7], [0, 1, 2, 3, 5, 6, 7, 8], [1, 2, 4, 7, 8],
    [3, 4, 7], [3, 4, 5, 6, 8], [4, 5, 7]
  ];
  var result = 0;
  var neighbors = neighborHash[i];
  for(var j = 0; j < neighbors.length; j++){
    if(grid[neighbors[j]] === 1){
      result++;
    }
  }
  return result;
}

function nextGeneration(grid) {
  // grid that gets returned
  if(grid.length === 0){
    return [];
  }
  newGrid = [
    0,0,0,
    0,0,0,
    0,0,0
  ];
  for(var i = 0; i < newGrid.length; i++){
    // gets the number of neighbors that are alive for a given cell from the current generation
    var neighbors = getNeighbors(grid, i);
    // these if statements determine whether a cell is alive or dead in the next generation
    if(neighbors > 3 || neighbors < 2){
      newGrid[i] = 0;
    }
    if(grid[i] === 0 && neighbors === 3){
      newGrid[i] = 1;
    }
    if(grid[i] === 1 && (neighbors === 2 || neighbors === 3)){
      newGrid[i] = 1
    }
  }
  return newGrid;
}

describe("Given empty grid", () => {
  it("when next generation, should return empty", () => {
    assert.deepEqual(nextGeneration([]), []);
  });
});

describe("Given a single cell", () => {
  it("when next generation, should die", () => {
    assert.deepEqual(nextGeneration([
      0,0,0,
      0,1,0,
      0,0,0,
    ]), [
      0,0,0,
      0,0,0,
      0,0,0,
    ]);
  });
});

describe("Given a cell with neighbors", () => {
  it("when next generation, it should live", () => {
    assert.deepEqual(nextGeneration([
      0,1,0,
      0,1,0,
      0,1,0,
    ]), [
      0,0,0,
      1,1,1,
      0,0,0,
    ]);
  });
});

describe("Given a cell with many neighbors", () => {
  it("when next generation, overcrowded cells should die", () => {
    assert.deepEqual(nextGeneration([
      1,1,1,
      1,1,1,
      1,1,1,
    ]), [
      1,0,1,
      0,0,0,
      1,0,1,
    ]);
  });
});

nuzylyvs. ferclaverinoFailed Tests

Game of Life

function nextGeneration(grid) {
  return grid.map(() => 0);
}

1 1 function nextGeneration(grid) {
2 - return grid;
2 + return grid.map(() => 0);
3 3 }

describe("Given empty grid", () => {
  it("when next generation, should return empty", () => {
    assert.deepEqual(nextGeneration([]), []);
  });
});

describe("Given a single cell", () => {
  it("when next generation, should die", () => {
    assert.deepEqual(nextGeneration([
      0,0,0,
      0,1,0,
      0,0,0,
    ]), [
      0,0,0,
      0,0,0,
      0,0,0,
    ]);
  });
});

describe("Given three neighbouring cells", () => {
  it("when next generation, produce a living cell", () => {
    assert.deepEqual(nextGeneration([
      0,1,0,
      1,1,0,
      0,0,0,
    ]), [
      1,1,0,
      1,1,0,
      0,0,0,
    ]);
  });
});

Sinus Cardinalis

Mathematics

Algorithms

Numbers

Sinus Cardinalis

Summary

This Kumite extends the built-in Math object in JavaScript with the sinc method which computes the cardinal sine of the first argument x (a Number) passed in.

Implementation Details

Math.sinc receives two arguments: the first argument x (a Number) is required and the second argument isNormalized (a boolean) is optional. If the second argument is not specified or set to false, the function returns the historical (unnormalized) cardinal sine of x. Otherwise, if the second argument is set to true, the function will return the normalized cardinal sine of x instead. Any invalid arguments passed in will cause the function to throw a TypeError with a suitable message.

Math.sinc = function (x, isNormalized = false) {
  // Type check "x" - if "x" is not a number then a TypeError is thrown
  if (typeof x !== 'number') throw new TypeError('In Math.sinc, the first argument "x" passed in must be a Number!');
  // Type check "isNormalized" - if it is not a boolean then a TypeError is thrown
  if (typeof isNormalized !== 'boolean') throw new TypeError('In Math.sinc, the second argument "isNormalized" passed in must be a Boolean!');
  // Special Case - sinc(0) = 1 regardless of which definition of cardinal sine is used
  if (x === 0) return 1;
  // If isNormalized is set to true then multiply argument by pi and pass into unnormalized cardinal sine
  if (isNormalized) return Math.sinc(Math.PI * x);
  // Otherwise just use sinc(x) = sin(x) / x and return the result
  return Math.sin(x) / x;
};

Test.describe('Math.sinc', function () {
  Test.it('should correctly compute the unnormalized cardinal sine for a few simple values', function () {
    Test.assertApproxEquals(Math.sinc(0), 1, 'sinc(0) = 1');
    Test.assertApproxEquals(Math.sinc(-1), 0.841470984807897);
    Test.assertApproxEquals(Math.sinc(2.5), 0.239388857641583);
    Test.assertApproxEquals(Math.sinc(-Math.PI), 0);
    Test.assertApproxEquals(Math.sinc(3.7), -0.143198957002295);
    Test.assertApproxEquals(Math.sinc(-5), -0.191784854932628);
    Test.assertApproxEquals(Math.sinc(10), -0.054402111088937);
    Test.assertApproxEquals(Math.sinc(0, false), 1, 'sinc(0) = 1');
    Test.assertApproxEquals(Math.sinc(-1, false), 0.841470984807897);
    Test.assertApproxEquals(Math.sinc(2.5, false), 0.239388857641583);
    Test.assertApproxEquals(Math.sinc(-Math.PI, false), 0);
    Test.assertApproxEquals(Math.sinc(3.7, false), -0.143198957002295);
    Test.assertApproxEquals(Math.sinc(-5, false), -0.191784854932628);
    Test.assertApproxEquals(Math.sinc(10, false), -0.054402111088937);
  });
  Test.it('should correctly compute the normalized cardinal sine for a few simple values', function () {
    Test.assertApproxEquals(Math.sinc(0, true), 1, 'sinc(0) = 1');
    Test.assertApproxEquals(Math.sinc(1, true), 0);
    Test.assertApproxEquals(Math.sinc(-2.5, true), 0.127323954473516);
    Test.assertApproxEquals(Math.sinc(Math.PI, true), -0.043598628629188);
    Test.assertApproxEquals(Math.sinc(-3.7, true), -0.069599488486552);
    Test.assertApproxEquals(Math.sinc(5, true), 0);
    Test.assertApproxEquals(Math.sinc(-10, true), 0);
  });
  Test.it('should type check its first argument "x"', function () {
    Test.expectError('A numeric string should be rejected', function () {
      Math.sinc('11.23');
    });
    Test.expectError('A boolean should be rejected', function () {
      Math.sinc(true);
    });
    Test.expectError('An array should be rejected', function () {
      Math.sinc([5]);
    });
    Test.expectError('An object should be rejected', function () {
      Math.sinc({valueOf: 10});
    });
  });
  Test.it('should type check its second argument "isNormalized"', function () {
    Test.expectError('A number should be rejected', function () {
      Math.sinc(0, 3);
    });
    Test.expectError('A string should be rejected', function () {
      Math.sinc(0, 'Hello World!');
    });
    Test.expectError('An array should be rejected', function () {
      Math.sinc(0, [false]);
    });
    Test.expectError('An object should be rejected', function () {
      Math.sinc(0, {valueOf: true, toString: 'true'});
    });
  });
});

Recent Moves:

Sinus Cardinalis

Summary

This Kumite implements a math function sinc() that receives up to two arguments, the first (required) argument being $x and the second (optional) argument being $flag. It computes and returns the cardinal sine of $x.

Details

One function sinc() and two constants (SINC_DEFAULT and SINC_NORMALIZED) are defined in this Kumite. The two constants are used internally by the sinc() function.

Since there are two slightly different definitions for "cardinal sine", the sinc() function in this Kumite implements both in a clever manner. While the first argument $x is required, the second argument $flag is optional and defaults to SINC_DEFAULT. When the flag is set to SINC_DEFAULT (or not provided, in which case it defaults to SINC_DEFAULT anyway), the function computes the historical (unnormalized) cardinal sine of $x. Otherwise, if the flag is set to SINC_NORMALIZED, the function computes the normalized cardinal sine of $x.

The sinc() function implemented here also does type checking and input validation. $x is only allowed to be an integer/float and $flag can only take one of SINC_DEFAULT and SINC_NORMALIZED - any other value will throw an InvalidArgumentException.

/*
  function.sinc.php
  A simple math function (with input validation)
  that computes the cardinal sine of a real
  number $x
  Author: Donald Leung
  NOTE: Comes with two user-defined constants
*/
// Constants (for use by the sinc() function as flags)
define('SINC_DEFAULT', 0);
define('SINC_NORMALIZED', 1);
// Function declaration and definition
function sinc($x, $flag = SINC_DEFAULT) {
  // Type check "x" - confirm that it is either of an integer or a float
  if (!is_int($x) && !is_float($x)) throw new InvalidArgumentException('In sinc(), the first argument "x" passed in must either be an integer or a float');
  // Validate the flag - it can only be one of SINC_DEFAULT and SINC_NORMALIZED
  if ($flag !== SINC_DEFAULT && $flag !== SINC_NORMALIZED) throw new InvalidArgumentException('The sinc() function only accepts 2 possible flags: SINC_DEFAULT and SINC_NORMALIZED');
  // Special Case: where x = 0, sinc(x) = sinc(0) = 1
  if ($x == 0) return 1;
  // If the flag is set to SINC_NORMALIZED then multiply the argument "x" by pi and compute its unnormalized cardinal sine at pi * x
  if ($flag === SINC_NORMALIZED) return sinc(M_PI * $x);
  // Otherwise just return the unnormalized cardinal sine of x
  return sin($x) / $x;
}

class SinusCardinalisTest extends TestCase {
  protected function assertFuzzyEquals(float $expected, float $actual) {
    $this->assertTrue(abs($expected) <= 1 ? abs($expected - $actual) <= 1e-9 : abs(($expected - $actual) / $expected) <= 1e-9, "Actual value $actual not sufficiently close to expected value $expected (accepted relative error: 1e-9)");
  }
  public function testThatConstantsAreDefined() {
    $this->assertTrue(defined('SINC_DEFAULT'));
    $this->assertTrue(defined('SINC_NORMALIZED'));
    if (defined('SINC_DEFAULT') && defined('SINC_NORMALIZED')) {
      echo SINC_DEFAULT . "\r\n";
      echo SINC_NORMALIZED . "\r\n";
      $this->assertNotEquals(SINC_DEFAULT, SINC_NORMALIZED, 'The two constants/flags used by sinc() should have different values!');
    }
  }
  public function testZero() {
    $this->assertFuzzyEquals(1, sinc(0));
    $this->assertFuzzyEquals(1, sinc(0.0));
    $this->assertFuzzyEquals(1, sinc(0, SINC_DEFAULT));
    $this->assertFuzzyEquals(1, sinc(0.0, SINC_DEFAULT));
    $this->assertFuzzyEquals(1, sinc(0, SINC_NORMALIZED));
    $this->assertFuzzyEquals(1, sinc(0.0, SINC_NORMALIZED));
  }
  public function testUnnormalized() {
    $this->assertFuzzyEquals(0.841470984807897, sinc(1));
    $this->assertFuzzyEquals(0.324219657468139, sinc(-2.3));
    $this->assertFuzzyEquals(-0.143198957002295, sinc(3.7));
    $this->assertFuzzyEquals(-0.191784854932628, sinc(-5));
    $this->assertFuzzyEquals(0.119739482820381, sinc(8.1));
    $this->assertFuzzyEquals(-0.054402111088937, sinc(-10));
    $this->assertFuzzyEquals(0.841470984807897, sinc(1, SINC_DEFAULT));
    $this->assertFuzzyEquals(0.324219657468139, sinc(-2.3, SINC_DEFAULT));
    $this->assertFuzzyEquals(-0.143198957002295, sinc(3.7, SINC_DEFAULT));
    $this->assertFuzzyEquals(-0.191784854932628, sinc(-5, SINC_DEFAULT));
    $this->assertFuzzyEquals(0.119739482820381, sinc(8.1, SINC_DEFAULT));
    $this->assertFuzzyEquals(-0.054402111088937, sinc(-10, SINC_DEFAULT));
  }
  public function testNormalized() {
    $this->assertFuzzyEquals(0, sinc(1, SINC_NORMALIZED));
    $this->assertFuzzyEquals(0.111964394521844, sinc(-2.3, SINC_NORMALIZED));
    $this->assertFuzzyEquals(-0.069599488486552, sinc(3.7, SINC_NORMALIZED));
    $this->assertFuzzyEquals(0, sinc(-5, SINC_NORMALIZED));
    $this->assertFuzzyEquals(0.012143600531895, sinc(8.1, SINC_NORMALIZED));
    $this->assertFuzzyEquals(0, sinc(-10, SINC_NORMALIZED));
  }
  /**
   * @expectedException InvalidArgumentException
   */
  public function testInvalidArgument1() {
    sinc("11.23");
  }
  /**
   * @expectedException InvalidArgumentException
   */
  public function testInvalidArgument2() {
    sinc("Hello World");
  }
  /**
   * @expectedException InvalidArgumentException
   */
  public function testInvalidArgument3() {
    sinc(true);
  }
  /**
   * @expectedException InvalidArgumentException
   */
  public function testInvalidArgument4() {
    sinc(array(5));
  }
  /**
   * @expectedException InvalidArgumentException
   */
  public function testInvalidFlag1() {
    sinc(3.2, 0.0);
  }
  /**
   * @expectedException InvalidArgumentException
   */
  public function testInvalidFlag2() {
    sinc(3.2, 1.0);
  }
}

AndrewMuntyanvs. trzeciakp

Hola TDD

const sayHello = (input='World') => `Hello ${input}!`

1 - function sayHello(input) {
2 - return !input ? "Hello World!" : "Hello " + input + "!"
3 - };
1 + const sayHello = (input='World') => `Hello ${input}!`
2 +

Recent Moves:

trzeciakpvs. Yuebo

Hola TDD

function sayHello(input) {
  return !input ? "Hello World!" : "Hello " + input + "!"
};

1 1 function sayHello(input) {
2 - if (input !== true){
3 - return "Hello World!";
4 - } else {
5 - return "Hello " + input + "!";
6 - }
2 + return !input ? "Hello World!" : "Hello " + input + "!"
7 7 };

describe("given we are annonymous", () => {
  it("should say hello world", () => {
    Test.assertEquals(sayHello(), "Hello World!");
  });
  
  it("should say hello amigo", () => {
    Test.assertEquals(sayHello("Amigo"), "Hello Amigo!");
  });
});

Yuebovs. ferclaverino

Hola TDD

function sayHello(input) {
if (input !== true){
  return "Hello World!";
} else {
  return "Hello " + input + "!";
}
};

1 - function sayHello() {
1 + function sayHello(input) {
2 + if (input !== true){
3 + return "Hello World!";
4 + } else {
5 + return "Hello " + input + "!";
2 2 }
7 + };

ferclaverinoFailed Tests

Hola TDD

given we are anonymous
then should say "Hello World!"

given we are "McFly"
then should say "Hello McFly!"

function sayHello() {
}

describe("given we are annonymous", () => {
  it("should say hello world", () => {
    Test.assertEquals(sayHello(), "Hello World!");
  });
});

donaldsebleungFailed Tests

BF CAT program, EOF returns -1 [Testing BF Support]

The Codewars built-in runBF interpreter should correctly interpret a CAT program. According to the specs, the runBF interpreter treats EOF as byte(-1).

,+[-.,+]

Test.describe('The BF CAT program', function () {
  Test.it('should return "CAT" when "CAT" is passed in', function () {
    Test.assertEquals(runBF(CAT), CAT);
  });
  Test.it('should return "Codewars" when "Codewars" is passed in', function () {
    Test.assertEquals(runBF(CODEWARS), CODEWARS);
  });
  Test.it('should return "@donaldsebleung" when "@donaldsebleung" is passed in', function () {
    Test.assertEquals(runBF(AUTHOR), AUTHOR);
  });
  Test.it('should return an empty string if nothing is passed in', function () {
    Test.assertEquals(runBF(), '');
  });
  Test.it('should CAT 100 random strings', function () {
    for (let i = 0; i < 100; i++) {
      var randomString = Test.randomToken();
      console.log(`Testing for ${randomString}`);
      Test.assertEquals(runBF(randomString), randomString);
    }
  });
});

Complex BF Hello World [Testing BF Support]

According to the Esolangs Wiki, the BF program presented in this Kumite often triggers interpreter bugs. Regardless, the Codewars built-in runBF interpreter should interpret the program correctly without any issues and return the string "Hello World!\n".

>++++++++[-<+++++++++>]<.>>+>-[+]++>++>+++[>[->+++<<+++>]<<]>-----.>->
+++..+++.>-.<<+[>[+>+]>>]<--------------.>>.+++.------.--------.>+.>+.

Test.describe('A complex BF Hello World program', function () {
  Test.it('should return "Hello World!\\n"', function () {
    Test.assertEquals(runBF(), 'Hello World!\n');
  });
});

BF Hello World With Simple Loop [Testing BF Support]

Testing the Codewars built-in runBF interpreter with no program input and with a simple Hello World program that contains a simple (non-nested) loop. The interpreter should be able to interpret the program properly and return the string "Hello World!".

++++++++++[>+++++++>++++++++++>+++++++++++>+++>+++++++++<<<<<-]>++.>+.>--..+++.>++.>---.<<.+++.------.<-.>>+.

Test.describe('The BF Hello World Program', function () {
  Test.it('should return "Hello World!"', function () {
    Test.assertEquals(runBF(), 'Hello World!');
  });
  Test.it('should be less than 110 characters', function () {
    // Testing reading the user solution directly
    var userSolution = require('fs').readFileSync('/home/codewarrior/solution.txt', 'utf8');
    console.log(`Your program:\r\n\r\n${userSolution}\r\n`);
    console.log(`Your program length: ${userSolution.length}`);
    Test.expect(userSolution.length < 110, 'Your Hello World Program should be shorter than 120 characters!');
  });
});

Primitive Hello World Program With Comments [Testing BF Support]

The exact same program as before but with some rather messy comments in between (and at the start and end of the program). The Codewars built-in runBF interpreter should correctly handle the program regardless and return the string "Hello World!".

[
  This is a loop comment.
  Command characters, they should be ignored <here>.
  Including [matching square brackets].
  Oh, and "+" and >-< signs.
  And gibberish: skldfjsdklfjs,..sd,dsf,s.fd,++--sdfsdsdfKLSDJFKLDSJ[[[][]][][[[][]]]]
  And unmatched round brackets: ((((()))(((()))))))))))))))))))))))
]
sdklfjsdkldfjskldfs+++++++++++++++++sdlkfjsdlkfjsdfklsdjfkldsjfd++++++++++++++++++SDLKFJSDKLJSDFKLDSFJFDSKLJDFS++++++++++++++++++++++++SDLKFJDSFKLJFSDKLDSFJKSLDFJDSFKLDFSJ+++++++++++++.>++++(+++++(+()++)+((++)(++)))++++++++++++++NESWNEWSNEWWWSEEEEE+++++++++++++++;;++++++++++++;;;;;++++++++++++;;;;+++++++++;;;;;++++++++++++********++++++++++.>+++*****++++++++++++++***;;;*****++++++++++++;;**;;;+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++.+++++sdfsfdsdfsdfsfd++++sdfsdffdsfds++sdfsdffsddfssdf+ (These last few plus signs should not affect the final output)

Recent Moves:

Primitive Hello World Program [Testing BF Support]

Testing the Codewars built-in BF interpreter runBF without any arguments and only with the commands +, . and >. If the built-in BF interpreter is indeed working properly then the program should print the string "Hello World!".

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.>+++++++++++++++++++++++++++++++++.

Test.describe('The BF Program', function () {
  Test.it('should return the string "Hello World!"', function () {
    Test.assertEquals(runBF(), "Hello World!");
  });
});

ferclaverinovs. ferclaverino

Starting with refactoring - possible solution

After doing:

Extract method
Move method donde calcular el precio (movie or rental)?
Unit test smell: Indirect Testing
Replace temp with query
Replace Type Code with State/Strategy
Replace Conditional with Polymorphism
Replace Constructor with Factory Method

class RentalReport {
  statement(customer) {
    let result = "Rental Record for " + customer.name + "\n";
    customer.rentals.forEach((each) => {
      //show figures for this rental
      result += "\t" + each.movie.title+ "\t" + each.getAmount() + "\n";
    });
    //add footer lines
    result += "Amount owed is " + customer.getTotalAmount() + "\n";
    result += "You earned " + customer.getFrequentPoints() + " frequent renter points";
    return result;
  }
}

const MovieType = {
    CHILDREN: Symbol('CHILDREN'),
    REGULAR: Symbol('REGULAR'),
    NEW_RELEASE: Symbol('NEW_RELEASE'),
}

class Price {
  static create(priceCode) {
    switch (priceCode) {
      case MovieType.REGULAR:
        return new RegularPrice();
      case MovieType.NEW_RELEASE:
        return new NewReleasePrice();
      case MovieType.CHILDREN:
        return new ChildrenPrice();
    }
  }
  get code() {
    throw "not implemented";
  }
  getAmount(daysRented) {
    throw "not implemented";
  }
  getFrequentPoints(daysRented) {
    return 1;
  }
}

class ChildrenPrice extends Price {
  get code() {
    return MovieType.CHILDREN;
  }
  getAmount(daysRented) {
    let amount = 1.5;
    if (daysRented > 3)
      amount += (daysRented - 3) * 1.5;
    return amount;  
  }
}

class RegularPrice extends Price {
  get code() {
    return MovieType.REGULAR;
  }
  getAmount(daysRented) {
    let amount = 2;
    if (daysRented > 2)
      amount += (daysRented - 2) * 1.5;
    return amount;  
  }
}

class NewReleasePrice extends Price {
  get code() {
    return MovieType.NEW_RELEASE;
  }
  getAmount(daysRented) {
    return daysRented * 3;
  }
  getFrequentPoints(daysRented) {
    return daysRented > 1 ? 2 : 1;
  }
}


class Movie {
  constructor (title, priceCode) {
    this._title = title;
    this.priceCode = priceCode;
  }
  set priceCode(priceCode) {
    this._price = Price.create(priceCode);
  }
  get priceCode() {
    return this._price.code;
  }
  get title() {
    return this._title;
  }
  getAmount(daysRented) {
    return this._price.getAmount(daysRented);  
  }
  getFrequentPoints(daysRented) {
    return this._price.getFrequentPoints(daysRented);
  }
}

class Rental {
  constructor(movie, daysRented) {
    this._movie = movie;
    this._daysRented = daysRented;
  }
  get daysRented() {
    return this._daysRented;
  }
  get movie() {
    return this._movie;
  }
  getAmount() {
    return this.movie.getAmount(this.daysRented);
  }
  getFrequentPoints() {
    return this.movie.getFrequentPoints(this.daysRented);
  }
}

class Customer {
  constructor(name) {
    this._name = name;
    this._rentals = [];
  }
  get name() {
    return this._name;
  }
  get rentals() {
    return this._rentals;
  }
  addRental(rental) {
    this._rentals.push(rental);
  }
  getFrequentPoints() {
    return this.rentals.reduce((frequentPoints, rental) => frequentPoints + rental.getFrequentPoints(), 0);
  }
  getTotalAmount() {
    return this.rentals.reduce((amount, rental) => amount + rental.getAmount(), 0);
  }
}

Recent Moves:

ferclaverino

Starting with refactoring

Taken from the great book Refactoring: Improving the Design of Existing Code by Martin Fowler.

This kata is about practicing refactoring rhythm: small refactor, test, small refactor, test.

The task here is to refactor code (you can use a refactoring catalog) and compare your solution with others.

class RentalReport {
  statement(customer) {
    let totalAmount = 0;
    let frequentRenterPoints = 0;
    let result = "Rental Record for " + customer.name + "\n";
    customer.rentals.forEach((each) => {
      let thisAmount = 0;
      //determine amounts for each line
      switch (each.movie.priceCode) {
        case MovieType.REGULAR:
          thisAmount += 2;
          if (each.daysRented > 2)
            thisAmount += (each.daysRented - 2) * 1.5;
          break;
        case MovieType.NEW_RELEASE:
          thisAmount += each.daysRented * 3;
          break;
        case MovieType.CHILDREN:
          thisAmount += 1.5;
          if (each.daysRented > 3)
            thisAmount += (each.daysRented - 3) * 1.5;
          break;
      }
      // add frequent renter points
      frequentRenterPoints ++;

      // add bonus for a two day new release rental
      if ((each.movie.priceCode == MovieType.NEW_RELEASE) && each.daysRented > 1) frequentRenterPoints ++;
      //show figures for this rental
      result += "\t" + each.movie.title+ "\t" + thisAmount + "\n";
      totalAmount += thisAmount;       
    });
    //add footer lines
    result += "Amount owed is " + totalAmount + "\n";
    result += "You earned " + frequentRenterPoints + " frequent renter points";
    return result;
  }
 
}

const MovieType = {
    CHILDREN: Symbol('CHILDREN'),
    REGULAR: Symbol('REGULAR'),
    NEW_RELEASE: Symbol('NEW_RELEASE'),
}

class Movie {
  constructor (title, priceCode) {
    this._title = title;
    this._priceCode = priceCode;
  }
  get priceCode() {
    return this._priceCode;
  }
  get title() {
    return this._title;
  }
}

class Rental {
  constructor(movie, daysRented) {
    this._movie = movie;
    this._daysRented = daysRented;
  }
  get daysRented() {
    return this._daysRented;
  }
  get movie() {
    return this._movie;
  }
}

class Customer {
  constructor(name) {
    this._name = name;
    this._rentals = [];
  }
  get name() {
    return this._name;
  }
  get rentals() {
    return this._rentals;
  }
  addRental(rental) {
    this._rentals.push(rental);
  }
}

describe("given a rental report and movies", () => {
  let rentalReport = new RentalReport();
  let regularMovie = new Movie("regular movie", MovieType.REGULAR);
  let releaseMovie = new Movie("release movie", MovieType.NEW_RELEASE);
  let childrenMovie = new Movie("children movie", MovieType.CHILDREN);

  describe("and a customer without rentals", () => {
    let customer = new Customer("Forest");
    
    it("should own 0 amount and earn 0 points", () => {
      Test.assertEquals(rentalReport.statement(customer), [
        "Rental Record for Forest",
        "Amount owed is 0",
        "You earned 0 frequent renter points"
      ].join("\n"));
    });
  });

  describe("when rent a regular movie for 1 day", () => {
    let customer = new Customer("Forest");
    customer.addRental(new Rental(regularMovie, 1));
    
    it("should own 2 amount and earn 1 points", () => {
      Test.assertEquals(rentalReport.statement(customer), [
        "Rental Record for Forest",
        "\tregular movie\t2",
        "Amount owed is 2",
        "You earned 1 frequent renter points"
      ].join("\n"));
    });
  });
  
  describe("when rent a regular movie for 3 days", () => {
    let customer = new Customer("Forest");
    customer.addRental(new Rental(regularMovie, 3));
    
    it("should own 3.5 amount and earn 1 points", () => {
      Test.assertEquals(rentalReport.statement(customer), [
        "Rental Record for Forest",
        "\tregular movie\t3.5",
        "Amount owed is 3.5",
        "You earned 1 frequent renter points"
      ].join("\n"));
    });
  });
  
  describe("when rent a new release movie for 1 day", () => {
    let customer = new Customer("Forest");
    customer.addRental(new Rental(releaseMovie, 1));
    
    it("should own 3 amount and earn 1 points", () => {
      Test.assertEquals(rentalReport.statement(customer), [
        "Rental Record for Forest",
        "\trelease movie\t3",
        "Amount owed is 3",
        "You earned 1 frequent renter points"
      ].join("\n"));
    });
  });
  
  describe("when rent a new release movie for 2 days", () => {
    let customer = new Customer("Forest");
    customer.addRental(new Rental(releaseMovie, 2));
    
    it("should own 6 amount and earn 2 points", () => {
      Test.assertEquals(rentalReport.statement(customer), [
        "Rental Record for Forest",
        "\trelease movie\t6",
        "Amount owed is 6",
        "You earned 2 frequent renter points"
      ].join("\n"));
    });
  });
  
  describe("when rent a children movie for 1 day", () => {
    let customer = new Customer("Forest");
    customer.addRental(new Rental(childrenMovie, 1));
    
    it("should own 1.5 amount and earn 1 points", () => {
      Test.assertEquals(rentalReport.statement(customer), [
        "Rental Record for Forest",
        "\tchildren movie\t1.5",
        "Amount owed is 1.5",
        "You earned 1 frequent renter points"
      ].join("\n"));
    });
  });

  describe("when rent a children movie for 4 days", () => {
    let customer = new Customer("Forest");
    customer.addRental(new Rental(childrenMovie, 4));
    
    it("should own 3 amount and earn 1 points", () => {
      Test.assertEquals(rentalReport.statement(customer), [
        "Rental Record for Forest",
        "\tchildren movie\t3",
        "Amount owed is 3",
        "You earned 1 frequent renter points"
      ].join("\n"));
    });
  });

  describe("when rent 3 movies", () => {
    let customer = new Customer("Forest");
    customer.addRental(new Rental(regularMovie, 1));
    customer.addRental(new Rental(releaseMovie, 1));
    customer.addRental(new Rental(childrenMovie, 1));
    
    it("should own 6.5 amount and earn 3 points", () => {
      Test.assertEquals(rentalReport.statement(customer), [
        "Rental Record for Forest",
        "\tregular movie\t2",
        "\trelease movie\t3",
        "\tchildren movie\t1.5",
        "Amount owed is 6.5",
        "You earned 3 frequent renter points"
      ].join("\n"));
    });
  });

});

nuzylyvs. alex.budiakov

HashMap Example

Hashes

Data Structures

/* HashMap Example */
 
import java.util.*;
import java.util.function.*;
import java.util.stream.*;
 
class HashMapDemo {
  public static void main (final String[] args) throws Exception {
    System.out.println(toString(mapFromRangeClosed(1, 6, i -> 1), formattingEntry(), "\n"));
  }
  
  public static <T> Map<Integer, T> mapFromRangeClosed(final int lo, final int hi, final Function<Integer, T> valueMapper) {
    return IntStream.rangeClosed(lo, hi).boxed().collect(Collectors.toMap(Function.identity(), valueMapper));
  }
  
  public static <K,V> String toString(final Map<K, V> map, final Function<Map.Entry<K, V>, String> entryFormatter, final CharSequence delimiter) {
    return map.entrySet().stream().map(entryFormatter).collect(Collectors.joining(delimiter));
  }
  
  public static <K,V> Function<Map.Entry<K, V>, String> formattingEntry() {
    return e -> e.getKey() + " " + e.getValue();
  }
}

import java.util.*;

import org.junit.Before;
import org.junit.Test;
import org.junit.runners.JUnit4;
import static org.junit.Assert.assertThat;

import static org.hamcrest.CoreMatchers.is;


public class MockTest {
    private Map<Integer, Integer> dummyMap;
    
    @Before
    public void setUp() {
      dummyMap = new HashMap<Integer, Integer>() {{
        put(1, 1);
        put(2, 1);
        put(3, 1);
        put(4, 1);
        put(5, 1);
        put(6, 1);
      }};
    }
    
    @Test
    public void testMapFromRangeClosed() {
      assertThat(HashMapDemo.mapFromRangeClosed(1, 6, i -> 1), is(dummyMap));
    }
    
    @Test
    public void testForamttingEntry() {
      assertThat(HashMapDemo.formattingEntry().apply(new AbstractMap.SimpleEntry(123.45, "foo")),
                 is("123.45 foo"));
    }
    
    @Test
    public void testToString() {
      assertThat(HashMapDemo.toString(dummyMap, e -> String.format("(%s -> %s)", e.getKey(), e.getValue()), ", "),
                 is("(1 -> 1), (2 -> 1), (3 -> 1), (4 -> 1), (5 -> 1), (6 -> 1)"));
    }
}

Recent Moves:

alex.budiakovvs. jayeshcp

HashMap Example

Hashes

Data Structures

/* HashMap Example */
 
import java.util.*;
import java.lang.*;
import java.io.*;
 
class HashMapDemo
{
  public static void main (String[] args) throws java.lang.Exception {
    Map<Integer, Integer> map = new HashMap<Integer, Integer>() {{
        put(1, 1);
        put(2, 1);
        put(3, 1);
        put(4, 1);
        put(5, 1);
        put(6, 1);
    }};

    map.entrySet().stream().forEach(e -> System.out.println(e.getKey() + " " + e.getValue()));
  }
}

import org.junit.Test;
import static org.junit.Assert.assertEquals;
import org.junit.runners.JUnit4;
import java.util.*;


public class MockTest {

    @Test
    public void test() {
      assertEquals(1, 1);
    }  
    
    
}

jayeshcp

HashMap Example

Hashes

Data Structures

Using HashMap in Java.

/* HashMap Example */
 
import java.util.*;
import java.lang.*;
import java.io.*;
 
class HashMapDemo
{
	public static void main (String[] args) throws java.lang.Exception
	{
		Map<Integer, Integer> map = new HashMap<Integer, Integer>();
		map.put(1, 1);
		map.put(2, 1);
		map.put(3, 1);
		map.put(4, 1);
		map.put(5, 1);
		map.put(6, 1);
 
		for(Map.Entry<Integer, Integer> entry : map.entrySet()) {
			int key = entry.getKey();
			int value = entry.getValue();
			System.out.println(key + " " + value);
		}
	}
}

nuzylyvs. alex.budiakov

Most frequently appearing number in given array

import java.util.Map;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
  Time Complexity  : O(N)
  Space Complexity : O(N)
*/
class MaxOccurence {

  public static int findMax(final int[] nums) {
    return IntStream.of(nums).boxed()
      .collect(Collectors.groupingBy(Function.identity(), Collectors.counting()))
      .entrySet().stream()
      .max(Map.Entry.comparingByValue())
      .map(Map.Entry::getKey).orElse(-1);
  }
}

Recent Moves:

alex.budiakovvs. jayeshcp

Most frequently appearing number in given array

import java.util.*;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
  Time Complexity  : O(N)
  Space Complexity : O(N)
*/
class MaxOccurence {
    
  public static int findMax(int[] nums) {
    Optional<Map.Entry<Integer, List<Integer>>> max = IntStream.of(nums)
            .boxed()
            .collect(Collectors.groupingBy(num -> num))
            .entrySet()
            .stream()
            .max((e1, e2) -> e1.getValue().size() - e2.getValue().size());
        
    return max.isPresent() ? max.get().getKey() : -1;
  }
}

import java.util.*;
import org.junit.Ignore;
import org.junit.Test;
import static org.junit.Assert.*;

public class MaxOccurenceTest {
    
    @Test
    public void test1() {
      int[] nums = {1, 2, 9, 3, 4, 3, 3, 1, 2, 4, 5, 3, 8, 3, 9, 0, 3, 2};
      assertEquals(3, MaxOccurence.findMax(nums));
    }
    
    @Ignore
    @Test
    public void test2() {
      int[] nums = {5, 4, 6 ,7, 9, 8, 2, 4, 3, 6, 5, 8, 6, 1, 2, 5, 3, 4, 7, 9, 0, 8, 5, 7, 3, 4, 6, 1, 3};
      // there is no instruction what of the numbers should be printed first if there are many max numbers in the row
      assertEquals(5, MaxOccurence.findMax(nums));
    }
    
    @Test
    public void test3() {
      int[] nums = {8};
      assertEquals(8, MaxOccurence.findMax(nums));
    }
    
    @Test
    public void test4() {
      int[] nums = {};
      assertEquals(-1, MaxOccurence.findMax(nums));
    }
    
    @Test
    public void test5() {
      int[] nums = {2, 2, 3, 3, 4, 4, 5, 5, 6, 6};
      assertEquals(2, MaxOccurence.findMax(nums));
    }
    
    @Test
    public void test6() {
      int[] nums = {2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5};
      assertEquals(5, MaxOccurence.findMax(nums));
    }
    
}

jayeshcpvs. jayeshcp

Most frequently appearing number in given array

Example:

Find first most frequently occuring number in given array.

Given input {1, 2, 9, 3, 4, 3, 3, 1, 2, 4, 5, 3, 8, 3, 9, 0, 3, 2},
output should be 3 as it has highest frequency of occurence.

Note: This solution uses LinkedHashMap to preserve order of entry.

import java.util.*;

/**
  Time Complexity  : O(N)
  Space Complexity : O(N)
*/
class MaxOccurence {
  public static int findMax(int[] nums) {
    return findMaxOccurenceLinkedHashMap(nums);
  }
  
  private static int findMaxOccurenceLinkedHashMap(int[] nums) {
    int maxKey = 0, maxNum = 0;
    
    if(nums.length < 1) return -1;
    if(nums.length == 1) return nums[0];
    
    Map<Integer, Integer> counts = new LinkedHashMap<Integer, Integer>(nums.length);
    
    for(int i = 0, len = nums.length; i < len; i++) {
      if(!counts.containsKey(nums[i])) {
        counts.put(nums[i], 1);
      } else {
        counts.put(nums[i], (counts.get(nums[i]) + 1));
      }
    }
    
    for (Map.Entry<Integer, Integer> entry : counts.entrySet()) {  
      if (entry.getValue() > maxNum) {
        maxKey = entry.getKey();
        maxNum = entry.getValue();
      }  
    }  
    
    return maxKey;
  } 
}

jayeshcp

Most frequently appearing number in given array

Example:

Find first most frequently occuring number in given array.

Given input {1, 2, 9, 3, 4, 3, 3, 1, 2, 4, 5, 3, 8, 3, 9, 0, 3, 2},
output should be 3 as it has highest frequency of occurence.

import java.util.*;

/**
  Time Complexity  : O(N)
  Space Complexity : O(N)
*/
class MaxOccurence {
  public static int findMax(int[] nums) {
    return findMaxOccurenceCountArray(nums);
  }
  
  private static int findMaxOccurenceCountArray(int[] nums) {
    int maxNum = 0;
    int maxCount = 0;
    
    if(nums.length < 1) return -1;
    if(nums.length == 1) return nums[0];
    
    int[] counts = new int[nums.length];
    
    for(int i = 0, len = nums.length; i < len; i++) {
      counts[nums[i]]++;
      if(counts[nums[i]] > maxCount) {
        maxCount = counts[nums[i]];
        maxNum = nums[i];
      }
    }
    
    return maxNum;
  } 
}

import java.util.*;
import org.junit.Test;
import static org.junit.Assert.*;

public class MaxOccurenceTest {
    
    @Test
    public void test1() {
      int[] nums = {1, 2, 9, 3, 4, 3, 3, 1, 2, 4, 5, 3, 8, 3, 9, 0, 3, 2};
      assertEquals(3, MaxOccurence.findMax(nums));
    }
    
    @Test
    public void test2() {
      int[] nums = {5, 4, 6 ,7, 9, 8, 2, 4, 3, 6, 5, 8, 6, 1, 2, 5, 3, 4, 7, 9, 0, 8, 5, 7, 3, 4, 6, 1, 3};
      assertEquals(5, MaxOccurence.findMax(nums));
    }
    
    @Test
    public void test3() {
      int[] nums = {8};
      assertEquals(8, MaxOccurence.findMax(nums));
    }
    
    @Test
    public void test4() {
      int[] nums = {};
      assertEquals(-1, MaxOccurence.findMax(nums));
    }
    
    @Test
    public void test5() {
      int[] nums = {2, 2, 3, 3, 4, 4, 5, 5, 6, 6};
      assertEquals(2, MaxOccurence.findMax(nums));
    }
    
    @Test
    public void test6() {
      int[] nums = {2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5};
      assertEquals(5, MaxOccurence.findMax(nums));
    }
    
}

nuzylyvs. VKapse

vkapse's Kumite #3

import java.util.*;
import java.util.stream.*;

class Solution {
     
  public static int retSmallestPositiveInteger() {
    return IntStream.iterate(1, x -> x + 1).filter(Solution::hasSameDigitsForFactorsInRange).findFirst().getAsInt();
  }
  
  private static boolean hasSameDigitsForFactorsInRange(final int x) {
    final Map<Integer, Integer> xDigits = digitsOf(x);
    return IntStream.rangeClosed(2, 6).allMatch(f -> xDigits.equals(digitsOf(x * f)));
  }
  
  private static Map<Integer, Integer> digitsOf(final int number) {
    return String.valueOf(number).chars().map(Character::getNumericValue)
			    .collect(HashMap<Integer, Integer>::new,
			             (m, x) -> m.put(x, m.getOrDefault(x, 0) + 1),
			             HashMap::putAll);
  }
}

import org.junit.Test;
import static org.junit.Assert.assertEquals;
import org.junit.runners.JUnit4;

public class SolutionTest {
     @Test
    public void testSolution() {
        assertEquals(142857, new Solution().retSmallestPositiveInteger());
    }
}

Recent Moves:

rpc1vs. VKapse

vkapse's Kumite #3

import java.util.*;
class Solution {
  
	      private int[] getNumDigits(int number) {
        int[] digits = new int[10];

        while (number != 0) {
            digits[number % 10]++;
            number = number / 10;
        }

        return digits;
    }

    public int retSmallestPositiveInteger() {

        for (int num = 100; num < Integer.MAX_VALUE; num++) {
            boolean isEquals = true;
            int[] digits = getNumDigits(num);
            for (int i = 2; (i <= 6) && isEquals; i++) {
                isEquals = isEquals && Arrays.equals(digits, getNumDigits(num * i));
            }
            if (isEquals)
                return num;
        }
        return 0;
    }
}

dinglemousevs. VKapse

vkapse's Kumite #3

import java.util.*;

class Solution {
  	   
    public static int retSmallestPositiveInteger() {       
      for (int i=1; ; i++) {
        final char[] d = digits(i);
        if (hasSameDigits(d,i*2) && hasSameDigits(d,i*3) && hasSameDigits(d,i*4) && hasSameDigits(d,i*5) && hasSameDigits(d,i*6)) {
          return i; 
        }
      }
    }
     
    private static char[] digits(final int x) {
      final char[] d = (""+x).toCharArray();
      Arrays.sort(d);
      return d;
    }
  
    private static boolean hasSameDigits(final char[] xdigits, final int y) {
		  return Arrays.equals(xdigits, digits(y));
    }
}

jteodorovs. VKapse

vkapse's Kumite #3

import java.util.*;
class Solution {
  
  public static int retSmallestPositiveInteger() {
    int number = 9; // for sure doesnt exists before 10 XD
    boolean smallest = false;
    do {
      smallest = isSmallestPositiveInteget(++number, 2);
    }
    while (!smallest);
    return number;
  }
  
  private static boolean isSmallestPositiveInteget(int i, int factor) {
    if (factor > 6) {
      return true;
    }
    if (hasSameDigits(i, i*factor)) {
      return isSmallestPositiveInteget(i, ++factor);
    }
    return false;
  }

	private static boolean hasSameDigits(int x, int y) {
	  char[] xdigits = Integer.toString(x).toCharArray();
		char[] ydigits = Integer.toString(y).toCharArray();
    Arrays.sort(xdigits);
    Arrays.sort(ydigits);
		int hashX = Arrays.hashCode(xdigits);
		int hashY = Arrays.hashCode(ydigits);
		return hashX == hashY;
  }
}

Xavier T Mukodivs. VKapse

vkapse's Kumite #3

import java.util.Arrays;
class Solution {
  
	   
     public static int retSmallestPositiveInteger() {
         for(int i=1; true ; i++) {
            if (i % 10 == 0)
                continue;
            if(hasSameDigits(i, i*2, i*3, i*4 , i*5, i*6))
                return i; 
         }
     }
  
	    private static boolean hasSameDigits(int a, int b, int c, int d, int e, int f) {
      
		      char[] aDigits = Integer.toString(a).toCharArray();
		      char[] bDigits = Integer.toString(b).toCharArray();
          char[] cDigits = Integer.toString(c).toCharArray();
          char[] dDigits = Integer.toString(d).toCharArray();
          char[] eDigits = Integer.toString(e).toCharArray();
          char[] fDigits = Integer.toString(f).toCharArray();
          
		      Arrays.sort(aDigits);
		      Arrays.sort(bDigits);
          Arrays.sort(cDigits);
          Arrays.sort(dDigits);
          Arrays.sort(eDigits);
          Arrays.sort(fDigits);
          
		      return (Arrays.equals(aDigits, bDigits) && Arrays.equals(aDigits, cDigits) && Arrays.equals(aDigits, dDigits) && Arrays.equals(aDigits, eDigits) && Arrays.equals(aDigits, fDigits));
          
      }
}

josher19vs. eyalp55

Trollderim's Kumite #1

public class Primes {
  public static boolean isAPrime(int number) {
    if (number < 2 || (number % 2 == 0 && number != 2)) return false;
    for (int i = 3; i*i <= number; i += 2) {
      if (number % i == 0) return false;
    }
    return true;
  }
}

import org.junit.Test;
import static org.junit.Assert.assertEquals;
import org.junit.runners.JUnit4;
import java.util.Random;

public class SolutionTest {
    private static final Random RANDOM = new Random();

     
    @Test
    public void twoShouldBeAPrime() {
      int numberToCheck = 2;
      
      boolean expected = true;        
      boolean actual = Primes.isAPrime(numberToCheck);
      
      assertEquals(expected, actual);
    }
    
    @Test
    public void fortySevenShouldBeAPrime() {
      int numberToCheck = 47;
      
      boolean expected = true;        
      boolean actual = Primes.isAPrime(numberToCheck);
      
      assertEquals(expected, actual);
    }
    
    @Test
    public void nineShouldNotBeAPrime() {
      int numberToCheck = 9;
      
      boolean expected = false;        
      boolean actual = Primes.isAPrime(numberToCheck);
      
      assertEquals(expected, actual);
    }
    
    @Test
    public void n123ShouldNotBeAPrime() {
      int numberToCheck = 123;
      
      boolean expected = false;        
      boolean actual = Primes.isAPrime(numberToCheck);
      
      assertEquals(expected, actual);
    }
        
    @Test
    public void n91ShouldNotBeAPrime() {
      int numberToCheck = 91;
      
      boolean expected = false;        
      boolean actual = Primes.isAPrime(numberToCheck);
      
      assertEquals(expected, actual);
    }
    
    @Test
    public void n17977ShouldBeAPrime() {
      int numberToCheck = 17977;
      
      boolean expected = true;        
      boolean actual = Primes.isAPrime(numberToCheck);
      
      assertEquals(expected, actual);
    }
    
    // better tests from @spacebison
    @Test
    public void fourShouldNotBeAPrime() {
      testPrime(4, false);
    }
    
    @Test
    public void aSquareShouldNotAPrime() {
      for (int i = 0; i < 10000; ++i) {
        int randomNumber = RANDOM.nextInt(Short.MAX_VALUE) + 2;
        int numberToCheck = randomNumber * randomNumber;
        testPrime(numberToCheck, false);
      }
    }
    
    @Test
    public void aProductOfTwoIntegersShouldNotBeAPrime() {
      for (int i = 0; i < 100000; ++i) {
        int a = RANDOM.nextInt(Short.MAX_VALUE) + 2;
        int b = RANDOM.nextInt(Short.MAX_VALUE) + 2;
        int numberToCheck = a * b;
        testPrime(numberToCheck, false);
      }
    }
    
    private static void testPrime(int numberToCheck, boolean expected) {     
      boolean actual = Primes.isAPrime(numberToCheck);
      assertEquals(Integer.toString(numberToCheck), expected, actual);
    }

}

Recent Moves:

eyalp55vs. offr0ad

Trollderim's Kumite #1

added a bigger prime number to test and fixed the bug that one was a prime, since it is not.

public class Primes {
  public static boolean isAPrime(int number) {
    if(number > 1 && number == 2) return true; //1 is not a prime number by definition
    else {
      for(int i = 3; i*i < number; i +=2) {
        if (number % i == 0) return false;
      }
    }
    return true;
  }
}

import org.junit.Test;
import static org.junit.Assert.assertEquals;
import org.junit.runners.JUnit4;

public class SolutionTest {
    @Test
    public void twoShouldBeAPrime() {
      int numberToCheck = 2;
      
      boolean expected = true;        
      boolean actual = Primes.isAPrime(numberToCheck);
      
      assertEquals(expected, actual);
    }
    
        @Test
    public void fortySevenShouldBeAPrime() {
      int numberToCheck = 47;
      
      boolean expected = true;        
      boolean actual = Primes.isAPrime(numberToCheck);
      
      assertEquals(expected, actual);
    }
}

offr0advs. Trollderim

Trollderim's Kumite #1

public class Primes {
  public static boolean isAPrime(int number) {
    if(number == 1 || number == 2) return true;
    else {
      for(int i = 3; i*i < number; i +=2) {
        if (number % i == 0) return false;
      }
    }
    return true;
  }
}

Lerosenvs. SpaceBison

Trollderim's Kumite #1

import org.junit.Test;
import static org.junit.Assert.assertEquals;
import org.junit.runners.JUnit4;
import java.util.Random;

public class SolutionTest {
    private static final Random RANDOM = new Random();

    @Test
    public void twoShouldBeAPrime() {
      testPrime(2, true);
    }

    @Test
    public void fourShouldNotBeAPrime() {
      testPrime(4, false);
    }    
    @Test
    public void anyNumberGreaterThanFiveAndEndingWithFiveShouldBeAPrime(){
      testPrime(15, false);    
    }
    
    @Test
    public void aSquareShouldNotAPrime() {
      for (int i = 0; i < 10000; ++i) {
        int randomNumber = RANDOM.nextInt(Short.MAX_VALUE) + 2;
        int numberToCheck = randomNumber * randomNumber;
        testPrime(numberToCheck, false);
      }
    }
    
    @Test
    public void aProductOfTwoIntegersShouldNotBeAPrime() {
      for (int i = 0; i < 100000; ++i) {
        int a = RANDOM.nextInt(Short.MAX_VALUE) + 2;
        int b = RANDOM.nextInt(Short.MAX_VALUE) + 2;
        int numberToCheck = a * b;
        testPrime(numberToCheck, false);
      }
    }
    
    
    
    private static void testPrime(int numberToCheck, boolean expected) {     
      boolean actual = Primes.isAPrime(numberToCheck);
      assertEquals(Integer.toString(numberToCheck), expected, actual);
    }
}

SpaceBisonvs. kongwei

Trollderim's Kumite #1

public class Primes {
  public static boolean isAPrime(int number) {    
    if (number == 1) {
      return false;
    }
  
    if (number == 2) {
      return true;
    }
    
    if (number % 2 == 0) {
      return false;
    }
  
    for (int i = 3; i*i <= number; i += 2) {
      if (number % i == 0)
        return false;
    }
    
    return true;
  }
}

import org.junit.Test;
import static org.junit.Assert.assertEquals;
import org.junit.runners.JUnit4;
import java.util.Random;

public class SolutionTest {
    private static final Random RANDOM = new Random();

    @Test
    public void twoShouldBeAPrime() {
      testPrime(2, true);
    }

    @Test
    public void fourShouldNotBeAPrime() {
      testPrime(4, false);
    }
    
    @Test
    public void aSquareShouldNotAPrime() {
      for (int i = 0; i < 10000; ++i) {
        int randomNumber = RANDOM.nextInt(Short.MAX_VALUE) + 2;
        int numberToCheck = randomNumber * randomNumber;
        testPrime(numberToCheck, false);
      }
    }
    
    @Test
    public void aProductOfTwoIntegersShouldNotBeAPrime() {
      for (int i = 0; i < 100000; ++i) {
        int a = RANDOM.nextInt(Short.MAX_VALUE) + 2;
        int b = RANDOM.nextInt(Short.MAX_VALUE) + 2;
        int numberToCheck = a * b;
        testPrime(numberToCheck, false);
      }
    }
    
    private static void testPrime(int numberToCheck, boolean expected) {     
      boolean actual = Primes.isAPrime(numberToCheck);
      assertEquals(Integer.toString(numberToCheck), expected, actual);
    }
}

iKintosh

Linked list

class Node:
    def __init__(self,x,Next, Prev):
        self.data = x
        self.next = Next
        self.prev = Prev

class LinkedList:
    def __init__(self, *x):
        self.start = None
        self.last = None
        self.lenght = 0
        if x:
            for i in x:
                self.add(i)
        
    def __str__(self):
        if self.start != None:
            current = self.start
            out = '[ ' + str(current.data)
            while current.next != None:
                current = current.next
                out += ' '+ str(current.data)
            out += ' ]'
            return out
        
    def clear(self):
        self.__init__()
        
    def add(self, x):
        if self.start == None:
            self.start = self.last = Node(x,None,None)
            self.lenght += 1
        else:
            prev = self.last
            self.last.next = self.last = Node(x,None,None)
            self.last.prev = prev
            self.lenght += 1
            
    def addFew(self,*x):
        if x:
            for i in x:
                self.add(i)
            
            
    def remove(self, x,remove_all = False):
        current = self.start
        
        for i in range(self.lenght):
            if current.data == x:
                if current.prev == None:
                    if current.next != None:
                        self.start = current.next
                        current.next.prev = None
                        self.lenght -= 1
                        
                if current.next == None:
                    if current.prev != None:
                        current.prev.next = None
                        self.last = current.prev
                        self.last.next = None
                        self.lenght -= 1
                        
                if current.prev != None and current.next != None:
                    current.prev.next = current.next
                    current.next.prev = current.prev
                    self.lenght -= 1
                
                if current.next == None and current.prev == None:
                    clear(self)
                    self.lenght -= 0
                if remove_all == False:
                    break
            current = current.next
# TODO: Replace examples and use TDD development by writing your own tests
# These are some of the methods available:
#   test.expect(boolean, [optional] message)
#   test.assert_equals(actual, expected, [optional] message)
#   test.assert_not_equals(actual, expected, [optional] message)

# You can use Test.describe and Test.it to write BDD style test groupings
test.assert_equals(LinkedList(1,2,3,4,5).lenght, 5)

iKintosh

Binary search

def binary_search(lst,item):
    low = 0
    high = len(lst) - 1
    while low <= high:
        mid = int((high + low)/2)
        guess = lst[mid]
        print (guess,mid)
        if guess > item:
            high = mid - 1
        if guess < item:
            low = mid + 1
        if guess == item:
            return mid
    else:
        return None
# TODO: Replace examples and use TDD development by writing your own tests
# These are some of the methods available:
#   test.expect(boolean, [optional] message)
#   test.assert_equals(actual, expected, [optional] message)
#   test.assert_not_equals(actual, expected, [optional] message)

# You can use Test.describe and Test.it to write BDD style test groupings
test.assert_equals(binary_search([1,2,3,4,5],2), 1)
test.assert_equals(binary_search([1,2,3,4,5],10), None)
test.assert_equals(binary_search([1,2,3,4,5],2), 1)
test.assert_equals(binary_search([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],9), 9)
test.assert_equals(binary_search([0, 1, 2, 3, 4, 5, 6, 7, 8, 9],100), None)

Joey Bonzovs. raulbc777

Fast Code to Find All Proper Factors Of a Number (Python version)

Changing "if n % i == 0" on line 6 to "if not(n % i)" made the time drop from 4126ms to 3810ms (as the longest time).

from math import sqrt, floor

def divisors(n):
    fact = [];
    for i in range(1, int(floor(sqrt(n))) + 1):
        if not(n % i):
            fact.append(i)
            if n / i != i:
                fact.append(n / i)
    fact.sort()
    return fact

from math import sqrt, floor

def divisors_check(n):
    fact = [];
    for i in range(1, int(floor(sqrt(n))) + 1):
        if not(n % i):
            fact.append(i)
            if n / i != i:
                fact.append(n / i)
    fact.sort()
    return fact


test.describe( "Static Cases" )

test.it( "n = 200" )
test.assert_equals(divisors(200), [1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100, 200])

test.it( "n = 560") 
test.assert_equals(divisors(560), [1, 2, 4, 5, 7, 8, 10, 14, 16, 20, 28, 35, 40, 56, 70, 80, 112, 140, 280, 560])

test.it("n = 755")
test.assert_equals(divisors(755), [1, 5, 151, 755])

from random import randint

test.describe( "Random Tests")
test.it ("More than 1000 Random Tests with challenging values up to 1000000000(10e9)")
for h in range(0,1000):
    n = randint(1000, 1000000000)
    result =  divisors_check(n)
    res = divisors(n)
    test.it("Testing for = " + str(n))
    test.assert_equals(res, result)

Recent Moves:

raulbc777

Fast Code to Find All Proper Factors Of a Number (Python version)

The Python Version is also very fast but the Javascript version is the fastest of all.
1) Javascript
2 Python
3) Ruby

from math import sqrt, floor

def divisors(n):
    fact = [];
    for i in range(1, int(floor(sqrt(n))) + 1):
        if n % i == 0:
            fact.append(i)
            if n / i != i:
                fact.append(n / i)
    fact.sort()
    return fact

from math import sqrt, floor

def divisors_check(n):
    fact = [];
    for i in range(1, int(floor(sqrt(n))) + 1):
        if n % i == 0:
            fact.append(i)
            if n / i != i:
                fact.append(n / i)
    fact.sort()
    return fact


test.describe( "Static Cases" )

test.it( "n = 200" )
test.assert_equals(divisors(200), [1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100, 200])

test.it( "n = 560") 
test.assert_equals(divisors(560), [1, 2, 4, 5, 7, 8, 10, 14, 16, 20, 28, 35, 40, 56, 70, 80, 112, 140, 280, 560])

test.it("n = 755")
test.assert_equals(divisors(755), [1, 5, 151, 755])

from random import randint

test.describe( "Random Tests")
test.it ("More than 1000 Random Tests with challenging values up to 1000000000(10e9)")
for h in range(0,1000):
    n = randint(1000, 1000000000)
    result =  divisors_check(n)
    res = divisors(n)
    test.it("Testing for = " + str(n))
    test.assert_equals(res, result)

ice1000Failed Tests

Kotlin can have point free too!

Fundamentals

Lists

Data Structures

Functional Programming

Declarative Programming

That's good

/**
 * Created by ice1000 on 2017/4/27.
 *
 * @author ice1000
 */

fun <A, B, C : Any> zipWith(op: (A, B) -> C) = { x: Sequence<A> ->
	{ y: Sequence<B> ->
		val iX = x.iterator()
		val iY = y.iterator()
		generateSequence {
			if (iX.hasNext() and iY.hasNext()) op(iX.next(), iY.next())
			else null
		}
	}
}

fun <T : Any> generate() = zipWith { x: Int, y: T -> "[$y * x^$x]" } (
	generateSequence(0, Int::inc)
)

fun main(args: Array<String>) =
		generate<Int>()(sequenceOf(1, 1, 2, 3, 5, 8, 13, 21)).forEach(::println)

kkkubasvs. willin

Enhance Split

Quick implementation of splitter algorithm with use of regular expressions.

Probably could be done better if offset characters would be cut off & added to result array rather than adding some random chars to _str and removing them right before returning result.

Also instead of using regexp straightforward for-loop can make it better - because of lack of positive lookbehind in js rexegp implementations results are not always OK (problem with strings which length is not divisible by _n).

function splitter (_str, _n) {
  _n = parseInt(_n);
  
  var offset = _n - _str.length % _n;
  
  if (offset !== _n) {
    _str += Math.pow(10, offset - 1);
  }
  
  var result = _str.split(new RegExp('(?=(?:.{' + _n + '})+$)', 'g'));
  
  if (offset !== _n) {
    var len = result.length,
        lastGroup = result[len - 1];
    
    result[len - 1] = lastGroup.substring(0, lastGroup.length - offset);
  }
  
  return result;
}

var testString = '1234567890';

describe("Solution", function(){
  it("should take number as second argument", function(){
    Test.assertSimilar(splitter(testString, 2), ['12', '34', '56', '78', '90'], 'Split into 2-character group with use of numeric argument.');
    Test.assertSimilar(splitter(testString, 3), ['123', '456', '789', '0'], 'Split into 3-character group with use of numeric argument.');
    Test.assertSimilar(splitter(testString, 4), ['1234', '5678', '90'], 'Split into 4-character group with use of numeric argument.');
  });
  
  it("should take string as second argument", function(){
    Test.assertSimilar(splitter(testString, '2'), ['12', '34', '56', '78', '90'], 'Split into 2-character group with use of string argument.');
    Test.assertSimilar(splitter(testString, '3'), ['123', '456', '789', '0'], 'Split into 3-character group with use of string argument.');
    Test.assertSimilar(splitter(testString, '4'), ['1234', '5678', '90'], 'Split into 4-character group with use of string argument.');
  });
});

Recent Moves:

willin

Enhance Split

String.split Demo:

'123456'.split('');

// [ '1', '2', '3', '4', '5', '6' ]

How about:

'123456'.spliter(2);
// [ '12', '34', '56' ]

console.log(
  '123456'.split('')
);

// TODO: Replace examples and use TDD development by writing your own tests

// These are some CW specific test methods available:
//    Test.expect(boolean, [optional] message)
//    Test.assertEquals(actual, expected, [optional] message)
//    Test.assertSimilar(actual, expected, [optional] message)
//    Test.assertNotEquals(actual, expected, [optional] message)

// NodeJS assert is also automatically required for you.
//    assert(true)
//    assert.strictEqual({a: 1}, {a: 1})
//    assert.deepEqual({a: [{b: 1}]}, {a: [{b: 1}]})

// You can also use Chai (http://chaijs.com/) by requiring it yourself
// var expect = require("chai").expect;
// var assert = require("chai").assert;
// require("chai").should();

describe("Solution", function(){
  it("should test for something", function(){
    Test.assertEquals("actual", "actual", "This is just an example of how you can write your own TDD tests");
  });
});

Joeunvs. robert.cutright

Pick a value from object using key.

ES2015

Babel

Objects

Robert.Cutright's implementation was great. (underscore.js has this function called omit http://underscorejs.org/#omit)
I forked his code and modified two parts.

First, I reused _.pick.
Second, I use reduce instead of assing and filter. Because reduce is more useful and simple solution to get result that I want.

var _ = {};

// Joeun's Pick implementation (GREAT JOB!)
_.pick = (target, ...keys) => {
  if (typeof keys[0] == 'function') {

    var predicate = keys[0];
    keys = Object.keys(target);
    
    return keys.reduce((obj, key) => {
      return predicate(target[key], key, target) ? (obj[key] = target[key], obj) : obj;
    }, {})
  }

  return keys.reduce((obj, key) => {
    return obj[key] = target[key], obj;
  }, {});
};

// Robert.Cutright's implementation of the inverse of pick (called flick);
// In other words, you supply the keys you want to throw away.
_.flick = (target, ...keys) => {
  if (typeof keys[0] == 'function') {

    var predicate = keys[0];
    keys = Object.keys(target);
    
    return keys.reduce((obj, key) => {
      return predicate(target[key], key, target) ? obj : (obj[key] = target[key], obj);
    }, {})
  }

  var obj = Object.assign({}, target);
  Object.keys(obj).filter(key => keys.includes(key) ? delete obj[key] : obj[key]);
  return obj;
};

// Joeun's flick (called flick2)
_.flick2 = (target, ...keys) => {
  if (typeof keys[0] == 'function') {
    var predicate = keys[0];
    return _.pick(target, (...args) => !predicate(...args)) // first part
  }
  
  var target_keys = Object.keys(target); // second part
  return target_keys.reduce((obj, key) => {
    return keys.includes(key) ? obj : (obj[key] = target[key], obj);
  }, {});
};

var result;
var testObj = {name: 'moe', age: 50, userid: 'moe1'};

// _.pick Tests
result = _.pick(testObj, 'name', 'age');
Test.assertSimilar(result, {name: 'moe', age: 50});

result = _.pick(testObj, function(value, key, object) {
  return typeof value == 'number';
});
Test.assertSimilar(result, {age: 50});

// _.flick Tests
result = _.flick(testObj, 'name', 'age');
Test.assertSimilar(result, {userid: 'moe1'});

result = _.flick(testObj, function(value, key, object) {
  return typeof value == 'number';
});
Test.assertSimilar(result, {name: 'moe', userid: 'moe1'});

// _.flick2 Tests
result = _.flick2(testObj, 'name', 'age');
Test.assertSimilar(result, {userid: 'moe1'});

result = _.flick2(testObj, function(value, key, object) {
  return typeof value == 'number';
});
Test.assertSimilar(result, {name: 'moe', userid: 'moe1'});

Recent Moves:

robert.cutrightvs. Joeun

Pick a value from object using key.

ES2015

Babel

Objects

Joeun's implementation of the pick function in the 'underscore' library. I have extended the library with a new function with a clever name. :) Called 'flick' which is the inverse of 'pick'. Some object/booger picking operations. lol

var _ = {};

// Joeun's Pick implementation (GREAT JOB!)
_.pick = (target, ...keys) => {
  if (typeof keys[0] == 'function') {

    var predicate = keys[0];
    keys = Object.keys(target);
    
    return keys.reduce((obj, key) => {
      return predicate(target[key], key, target) ? (obj[key] = target[key], obj) : obj;
    }, {})
  }

  return keys.reduce((obj, key) => {
    return obj[key] = target[key], obj;
  }, {});
};

// Robert.Cutright's implementation of the inverse of pick (called flick);
// In other words, you supply the keys you want to throw away.
_.flick = (target, ...keys) => {
  if (typeof keys[0] == 'function') {

    var predicate = keys[0];
    keys = Object.keys(target);
    
    return keys.reduce((obj, key) => {
      return predicate(target[key], key, target) ? obj : (obj[key] = target[key], obj);
    }, {})
  }

  var obj = Object.assign({}, target);
  Object.keys(obj).filter(key => keys.includes(key) ? delete obj[key] : obj[key]);
  return obj;
};

var result;
var testObj = {name: 'moe', age: 50, userid: 'moe1'};

// _.pick Tests
result = _.pick(testObj, 'name', 'age');
Test.assertSimilar(result, {name: 'moe', age: 50});

result = _.pick(testObj, function(value, key, object) {
  return typeof value == 'number';
});
Test.assertSimilar(result, {age: 50});

// _.flick Tests
result = _.flick(testObj, 'name', 'age');
Test.assertSimilar(result, {userid: 'moe1'});

result = _.flick(testObj, function(value, key, object) {
  return typeof value == 'number';
});
Test.assertSimilar(result, {name: 'moe', userid: 'moe1'});

Joeun

Pick a value from object using key.

ES2015

Babel

Objects

Function 'pick' in the Underscore.js (http://underscorejs.org/#pick)

"Return a copy of the object, filtered to only have values for the whitelisted keys (or array of valid keys). Alternatively accepts a predicate indicating which keys to pick."

_.pick({name: 'moe', age: 50, userid: 'moe1'}, 'name', 'age');
// {name: 'moe', age: 50}

_.pick({name: 'moe', age: 50, userid: 'moe1'}, function(value, key, object) {
  return typeof value == 'number';
});
// {age: 50}

var _ = {};

_.pick = (target, ...keys) => {
  if (typeof keys[0] == 'function') {
    var predicate = keys[0];
    keys = Object.keys(target);
    
    return keys.reduce((obj, key) => {
      return predicate(target[key], key, target) ? (obj[key] = target[key], obj) : obj;
    }, {})
  }

  return keys.reduce((obj, key) => {
    return obj[key] = target[key], obj;
  }, {});
};

var result;
result = _.pick({name: 'moe', age: 50, userid: 'moe1'}, 'name', 'age');
Test.assertSimilar(result, {name: 'moe', age: 50});

result = _.pick({name: 'moe', age: 50, userid: 'moe1'}, function(value, key, object) {
  return typeof value == 'number';
});
Test.assertSimilar(result, {age: 50});

mmakaay

mmakaay's Kumite #3

An implementation of the Sieve of Eratosthenes for finding prime numbers, fully focusing on performance.

The biggest performance gains come from forcing data set manipluation loops to be performed in the C-level code inside Python and not inside loops within the source code of the sieve. The places where this is used in particular are:

Striking out compounds in the sieve using the list[start::skip] = list syntax
Creating the final list of primes by using compress() to filter primes from the sieve

from math import sqrt, ceil
from itertools import compress

def sieve(until):
    if until < 2:
        return []
    store_len = until >> 1
    is_prime = [True] * store_len
    for offset, number in enumerate(range(3, int(sqrt(until)) + 1, 2)):
        if is_prime[offset]:
            first_compound_at = (number*number-3) >> 1
            nr_of_compounds = int(ceil((store_len-first_compound_at) / number))
            is_prime[first_compound_at::number] = [False] * nr_of_compounds
    return [2] + list(compress(range(3, until + 1, 2), is_prime))

from time import time

Test.describe("Below 2, no primes exist")
Test.assert_equals([], sieve(-1))
Test.assert_equals([], sieve(0))
Test.assert_equals([], sieve(1))

Test.describe("Low primes")
Test.assert_equals([2], sieve(2))
Test.assert_equals([2,3], sieve(3))
Test.assert_equals([2,3], sieve(4))
Test.assert_equals([2,3,5], sieve(5))
Test.assert_equals([2,3,5], sieve(6))
Test.assert_equals([2,3,5,7], sieve(7))
Test.assert_equals([2,3,5,7], sieve(8))
Test.assert_equals([2,3,5,7], sieve(9))
Test.assert_equals([2,3,5,7], sieve(10))
Test.assert_equals([2,3,5,7,11], sieve(11))
Test.assert_equals([2,3,5,7,11], sieve(12))
Test.assert_equals([2,3,5,7,11,13], sieve(13))

Test.describe("A big sieve")

t1 = time()
s = set(sieve(50000000))
t2 = time()
print("The big sieve until 50,000,000 was created in", t2-t1, "seconds")

Test.assert_equals(3001134, len(s), "The sieve must contain 3001134 primes")
# On codewars, I get timings around 2 seconds, but lets give the timing some slack here.
Test.expect(t2-t1 < 5, "The sieve must be created within 5 seconds")
some_primes = {2, 3, 131, 4700939, 11833931, 15418759, 19818061, 25227973, 36341861, 44811667, 49999991}
Test.expect(some_primes.issubset(s))

mmakaayvs. pythonRules

Fast Prime checker

Algorithms

This is my implementation of the Baillie-PSW prime number test. It is my response to a kumite title that claimed a fast prime test, while the implemented check was not actually that fast.

The response as provided by the isPrime() function is not simply a boolean, but instead a tuple providing two values: a boolean indicating probably primality and a string describing the test to lead to the provided conclusing.
Knowing the actual test that triggered the outcome has proven a very valuable tool during development. If this were production code, I'd most likely make the isPrime() function return a boolean directly.

It was great fun to puzzle together all the required pieces and to translate mathmatical notation into working programming code! I learned a lot of new things about modular arithmatics.