Kumite

```
def add(a,b):    
    return a + b
    
```
1 1 def add(a,b):
2 - return (a + b)
2 + return a + b
3 3

Recent Moves:

t.bhandalvs. yellowBunny

mwglobal's Kumite #3

def add(a,b):    
    return (a + b)

1 1 def add(a,b):
2 - return sum([a,b])
2 + return (a + b)
3 +

yellowBunnyvs. testerownia12345

mwglobal's Kumite #3

```
def add(a,b):    
    return sum([a,b])
```
1 - def add(a,b):
2 - param1 = a
3 - sum=b
4 - return param1 + sum
1 + def add(a,b):
2 + return sum([a,b])

testerownia12345vs. wasiel

mwglobal's Kumite #3

def add(a,b):
    param1 = a
    sum=b
    return param1 + sum

1 1 def add(a,b):
2 - sum=a+b
3 - return sum
2 + param1 = a
3 + sum=b
4 + return param1 + sum

testerownia12345vs. mwglobal

mwglobal's Kumite #3

def add(a,b):
    param1 = a
    param2 = b
    return param1+param2

1 1 def add(a,b):
2 - return a+b
2 + param1 = a
3 + param2 = b
4 + return param1+param2

t.bhandalvs. ofournier

Add two number

```
from operator import add
print(add)
```
1 1 from operator import add
2 + print(add)

Recent Moves:

t.bhandalvs. ofournier

Add two number

```
from operator import add
print(add)
```
1 1 from operator import add
2 + print(add)

ofourniervs. oskarz1234

Add two number

```
from operator import add
```
1 - def add(a,b):
2 - return a+b
1 + from operator import add

oskarz1234vs. wasiel

Add two number

```
def add(a,b):
    return a+b
```
1 1 def add(a,b):
2 - return 1
2 + return a+b

test.assert_equals(add(1,2), 3)
test.assert_equals(add(3,7),10)

1 - test.assert_equals(add(1,2), 1)
2 - #test.assert_equals(add(3,7),10)
1 + test.assert_equals(add(1,2), 3)
2 + test.assert_equals(add(3,7),10)
3 3

wasiel

mwglobal's Kumite #2

```
from operator import mul as multiple
```
1 - def multiple(a,b):
2 - return a*b
1 + from operator import mul as multiple

ofourniervs. Jesus Iniguez

Get the longest word in a list

def getLongestWord(words):
    return max(words, key=len, default="")

1 1 def getLongestWord(words):
2 - longest = ""
3 - for w in words:
4 - longest = w if len(w) > len(longest) else longest
5 - return longest
2 + return max(words, key=len, default="")

Recent Moves:

Jesus Iniguez

Get the longest word in a list

Inside a list of words, return the longest of them.

def getLongestWord(words):
    longest = ""
    for w in words:
        longest = w if len(w) > len(longest) else longest
    return longest

# 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.describe("Tests")
Test.assert_equals(getLongestWord(["word1","word11", "word111"]), "word111", "Regular")
Test.assert_equals(getLongestWord([]),"", "Exceptional cases")
Test.assert_equals(getLongestWord(["word"]),"word","Lenght 1")

ofourniervs. JonasP

Print a square of characters

```
def square(n):
    return ['*' * n] * n
```
1 1 def square(n):
2 - return ['*' * n for x in range(0,n)]
2 + return ['*' * n] * n

Recent Moves:

JonasPvs. ClaudiuRoland

Instead of functions, i used lambdas that captured the password by reference.
So no additional passing through functions is necessary.
Invoking the lambdas as late as possible. To call only 1 function in the best case.
Using std::string::find_first_of() to use the stl instead of writing the search by myself.

#include <string>
bool testPassword(std::string password)
{
    auto const has_length{[&]() { return password.size() >= 8; }};
    auto const has_upper{[&]() { return password.find_first_of("ABCDEFGHIJKLMNOPQRSTUVWXYZ") != std::string::npos; }};
    auto const has_special{[&]() { return password.find_first_of("!\"#$%&'()*+'-./;:<>=or?") != std::string::npos; }};
    auto const has_digit{[&]() { return password.find_first_of("0123456789") != std::string::npos; }};
    return has_length() && has_upper() && has_special() && has_digit();
}

Describe(PasswordTest)
{
  It(BasicTests)
  {
    Assert::That(testPassword("password"), Equals(false));
    Assert::That(testPassword("Pas$word1"), Equals(true));
    Assert::That(testPassword("WodT$m1"), Equals(false));
    Assert::That(testPassword("ALLTH3TH!NGS"), Equals(true));
  }
};

Recent Moves:

swift4096vs. Kermanov

Is my password strong?

Made into a class and adjusted the test case accordingly. Standardized naming of functions and variables for consistency.

class Password{
    public:
        static bool hasCap(const std::string& password);
        static bool hasSpec(const std::string& password);
        static bool hasDigit(const std::string& password);
        static bool hasLength(const std::string& password);
        static bool testPassword(const std::string& password);
};
        
bool Password::hasCap(const std::string& password)
{
    bool result = false;
    for(auto symbol : password)
    {
        if(symbol >= 'A' && symbol <= 'Z')
        {
            result = true;
            break;
        }
    }
    return result;
}

bool Password::hasSpec(const std::string& password)
{  
    bool result = false;
    
    const std::string specials("!\"#$%&'()*+'-./;:<>=?");
    for(auto spec : specials)
    {
        if(password.find(spec) != -1)
        {
            result = true;
            break;
        }
    }    
    return result;
}

bool Password::hasDigit(const std::string& password)
{
    bool result = false;
    for(auto symbol : password)
    {
        if(symbol >= '0' && symbol <= '9')
        {
            result = true;
            break;
        }
    }
    return result;
}

bool Password::hasLength(const std::string& password)
{
    return password.length() > 7;
}

bool Password::testPassword(const std::string& password)
{
  bool cap = Password::hasCap(password);
  bool spec = Password::hasSpec(password);
  bool digit = Password::hasDigit(password);
  bool number = Password::hasLength(password);
  
  return cap && spec && digit && number;
}

Describe(PasswordTest)
{
  It(BasicTests)
  {
    Assert::That(Password::testPassword("password"), Equals(false));
    Assert::That(Password::testPassword("Pas$word1"), Equals(true));
    Assert::That(Password::testPassword("WodT$m1"), Equals(false));
    Assert::That(Password::testPassword("ALLTH3TH!NGS"), Equals(true));
  }
};

Kermanovvs. SpyMaster356

Is my password strong?

My version with few improvements.

#include <string>

bool hasCapital(const std::string& password)
{
    bool result = false;
    for(auto symbol : password)
    {
        if(symbol >= 'A' && symbol <= 'Z')
        {
            result = true;
            break;
        }
    }
    return result;
}

bool hasSpecial(const std::string& password)
{  
    bool result = false;
    
    const std::string specials("!\"#$%&'()*+'-./;:<>=?");
    for(auto spec : specials)
    {
        if(password.find(spec) != -1)
        {
            result = true;
            break;
        }
    }    
    return result;
}

bool hasDigit(const std::string& password)
{
    bool result = false;
    for(auto symbol : password)
    {
        if(symbol >= '0' && symbol <= '9')
        {
            result = true;
            break;
        }
    }
    return result;
}

bool isLongPassword(const std::string& password)
{
    return password.length() > 7;
}

bool testPassword(const std::string& password)
{
  bool cap = hasCapital(password);
  bool spec = hasSpecial(password);
  bool digit = hasDigit(password);
  bool number = isLongPassword(password);
  
  return cap && spec && digit && number;
}

SpyMaster356vs. swift4096

Is my password strong?

#include <string>

bool hasCapital(std::string password)
{
  for(int i=0; i < password.length(); i++)
  {
    if (password[i] > 64 && password[i] < 91)
    {
      return true;
    }
  }
  
  return false;
}

bool hasSpecial(std::string password)
{  
  char temp;
  
  for(int i=0;i<password.length();i++)
  {
    temp = password[i];
    if ((temp > 32 && temp < 48) || (temp > 57 && temp < 64))
    {
      return true;
    }
  }
  
  return false;
}

bool isLongPassword(std::string password)
{
  return password.length() > 7;
}

bool testPassword(std::string password)
{
  bool cap = hasCapital(password);
  bool spec = hasSpecial(password);
  bool number = isLongPassword(password);
    
  //provide final answer
  if (cap && number && spec)
  {
    return true;
  } 
  else 
  {
    return false;
  }

}

swift4096vs. shifty189

Is my password strong?

In this Kata you will need to write a function that returns whether a password is strong or not.

Your code should return a Boolean of true if the provided password meets the following conditions

1) password must be no less than 8 characters long
2) password must have at least 1 capital letter
3) password must have at least 1 number
4) password must have at least 1 special character

for this Kata special characters are considered ( ! " # $ % & ' ( ) * + ' - . / ; : < > = or ?)

if the password doesn't meet these requirements return false.

#include <string>

bool testPassword(std::string password)
{
  bool cap = false;
  bool spec = false;
  bool number = false;
  char temp;
  
  for(int i=0;i<password.length();i++)
  {
    temp = password[i];
    if ((temp > 32 && temp < 48) || (temp > 57 && temp < 64))
    {
      spec = true;
    }
  }
//check each digit and see if any are capital letters
for(int i=0;i<password.length();i++)
{
  if (password[i] > 64 && password[i] < 91)
  {
    cap = true;
  }
}

//see if the password is over 8 digits long
if (password.length() > 7)
{
  number = true;
}
  
  //provide final answer
  if (cap && number && spec)
  {
    return true;
  } 
  else 
  {
    return false;
  }

}

Describe(TestPassword)
{
  It(BasicTests)
  {
    Assert::That(testPassword("password"), Equals(false));
    Assert::That(testPassword("Pas$word1"), Equals(true));
    Assert::That(testPassword("WodT$m1"), Equals(false));
    Assert::That(testPassword("ALLTH3TH!NGS"), Equals(true));
  }
};

venki.vallerivs. auttawir

Test First Quiz

```
function main()
{
  return 1
}
```
1 1 function main()
2 2 {
3 - return 12
3 + return 1
4 4 }

// 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("Foo", function(){
    it ("should be defined", function(){
        Test.assertEquals(main(), 1)
    });
});

Recent Moves:

auttawirFailed Tests

Test First Quiz

Test

function main()
{
  return 12
}

// 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("Foo", function(){
    it ("should be defined", function(){
        Test.assertEquals(main(), 1)
    });
});

lulucca12Failed Tests

Example on c# delegates and events

Showing how sync events work in c#, not so pratical as in c# 6 and forward is a good practice writing async code.

using System;

namespace delegates
{
	class Program
	{
		static void Main()
		{
		    // Creates a new instance
			Message hi = new Message();
			
			/*
			set the event of the class instance to a 
			lambda expression, beeing an event handler that has the same parameter
			and return type of the delegate in the class instance.
			
			equivalent of creating a new void method with the same
			parameters and seting it to the event in the class instance
			
			*/
			hi.writed += (string hello) =>
			{
			    Console.WriteLine(hello);
			};
			
			// executes the method to validate the event and add it to the delegate
			hi.write = "write property";
		}
	}
	
	public class Message
	{
	    
	    //creates the delegate that will handle the method/ lambda expression/ anonnymous method passed through it
	    public delegate void handler(string hello);
	    
	    //creates the event with the delegate
	    public event handler writed;
	    
	    //method that will check for the event while executing
	    
	    private string _write;
	    public string write
	    {
	        get
	        {
	            return _write;
	        }
	        set
	        {
	            if(value == "write property")
	            {
	               writed?.Invoke("the event was thrown!!!");
	            }
	            
	            Console.WriteLine(value);
	            
	            _write = value;
	        }
	    }
	    
	   //The same as:
	   
	   // public void write(string text)
	   // {
	   //     //you have to check if the event is not null becouse you can't execute a delegates method if it does not exist
	   //     //(the event handler was not set yet)
	   //     if(text == "write method" && writed != null)
	   //     {
	   //         writed("the event was thrown!!!");
	   //     }
	   //     Console.WriteLine(text);
	       
    }
}

ArmaanASvs. ArmaanAS

Find all dividors of a number

Algorithms

getDividors = n => [...Array(n).keys()].filter(e => n % e)

1 - getDividors = n => Array.from({length: n}, (e, i) => n % ++i ? i : 0).filter(e => e)
1 + getDividors = n => [...Array(n).keys()].filter(e => n % e)

Recent Moves:

ArmaanASvs. v1z

Find all dividors of a number

Algorithms

getDividors = n => Array.from({length: n}, (e, i) => n % ++i ? i : 0).filter(e => e)

v1zvs. v1z

Find all dividors of a number

Algorithms

const getDividors = n => {
  
  let result = [];

  for (let i = 1; i <= Math.floor(Math.sqrt(n)); i += 1)
    if (n % i === 0) { result.push(i); if (n / i !== i) result.push(n / i) }
    
  return result; // output array won't be sorted
  
}

const getDividors = n => {
  
  let result = [];

  for (let i = 1; i <= Math.floor(Math.sqrt(n)); i += 1)
    if (n % i === 0) { result.push(i); if (n / i !== i) result.push(n / i) }
    
  return result.sort((a,b) => a - b);
  
}

describe("Test cases", function() {
  it("n = 200", function() {
    Test.assertSimilar(getDividors(200), [1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100, 200]);
  });
  
  it("n = 560", function() {
    Test.assertSimilar(getDividors(560), [ 1, 2, 4, 5, 7, 8, 10, 14, 16, 20, 28, 35, 40, 56, 70, 80, 112, 140, 280, 560 ]);
  });
  
  it("n = 755", function() {
    Test.assertSimilar(getDividors(755), [ 1, 5, 151, 755 ]);
  });
});

v1z

Find all dividors of a number

Algorithms

The fastest way to find all dividors of a number.

const getDividors = (n, result = []) => {   

  for (let i = 1; i <= Math.floor(Math.sqrt(n)); i++)
    if (n % i === 0) { result.push(i); if (n / i !== i) result.push(n / i) }
    
  return result; // output array won't be sorted
  
}

const getDividors = (n, result = []) => {   

  for (let i = 1; i <= Math.floor(Math.sqrt(n)); i++)
    if (n % i === 0) { result.push(i); if (n / i !== i) result.push(n / i) }
    
  return result.sort((a,b) => a - b);
  
}

describe("Test cases", function() {
  it("n = 200", function() {
    Test.assertSimilar(getDividors(200), [1, 2, 4, 5, 8, 10, 20, 25, 40, 50, 100, 200]);
  });
  
  it("n = 560", function() {
    Test.assertSimilar(getDividors(560), [ 1, 2, 4, 5, 7, 8, 10, 14, 16, 20, 28, 35, 40, 56, 70, 80, 112, 140, 280, 560 ]);
  });
  
  it("n = 755", function() {
    Test.assertSimilar(getDividors(755), [ 1, 5, 151, 755 ]);
  });
});

ArmaanASvs. nikita.kalnov

Finding BB-tags in text

test = s => s.match(/\[(\w+)].*\[\/\1]/g).join``

1 - function test(str) {
2 - return (str.match(/\[([a-zA-Z]+)](.*)\[\/\1]/g)).join('');
3 - }
1 + test = s => s.match(/\[(\w+)].*\[\/\1]/g).join``

Recent Moves:

nikita.kalnov

Finding BB-tags in text

In this kata you should find BB-tags (bulletin board tags) in given string.

BB-tags look like:

[B]Some content[/B],

where [B] - opening tag and [/B] - closing tag.

Name of tags also can be lowercase:

[url]Some content[/url]

And BB-tags can be nested into each other, for example:

[url][b][size=5][color=blue]Some content[/color][/size][/b][/url]

If there is nested BB-tags, you should return only the outer tag with all it's content (with another tags into it).

function test(str) {
  return (str.match(/\[([a-zA-Z]+)](.*)\[\/\1]/g)).join('');
}

describe("Finding 'BB'-tags in text", function(){
  it("Testing for singular pair of tags", function(){
    Test.assertEquals(test("Так записывается ссылка: [url]http://ya.ru[/url]"),"[url]http://ya.ru[/url]");
  });
  it("Testing for two pair of tags", function(){
    Test.assertEquals(test("Ссылка, текст которой выделен жирным: [url][b]http://ya.ru[/b][/url]"), "[url][b]http://ya.ru[/b][/url]");
  });
  it("Testing for empty content of tags", function(){
    Test.assertEquals(test("Теги без содержимого: [url][/url]"), "[url][/url]");
  });
  it("Testing for empty content of several tags", function(){
    Test.assertEquals(test("Выделенная жирным цитата со ссылкой на источник(которого нет): [url][b][quote][/quote][/b][/url]"), "[url][b][quote][/quote][/b][/url]");
  });
  it("Testing for a lot of nested tags", function(){
    Test.assertEquals(test("It should work for a lot of different nested tags: [url][b][size=5][color=blue]Some content[/color][/size][/b][/url]"), "[url][b][size=5][color=blue]Some content[/color][/size][/b][/url]");
  });
});

neodyniavs. አወል እሸቱ

Last Char

Strings

```
const lastChar = s => /.$/.exec(s)[0];
```
1 - const lastChar=(s)=>s.slice(-1)
1 + const lastChar = s => /.$/.exec(s)[0];

Recent Moves:

SerzN1vs. xibor

Last Char

Strings

let lastChar = string => string.slice(-1)

1 - let lastChar = string => string[string.length - 1]
1 + let lastChar = string => string.slice(-1)

xiborvs. senalr

Last Char

Strings

let lastChar = string => string[string.length - 1]

1 - var lastChar = string => string[string.length - 1]
1 + let lastChar = string => string[string.length - 1]

Jay9596vs. jjsullivan5196

Last Char

Strings

Return the last character from a string.

In Rust return an Option<char>.

fn last_char(string: &str) -> Option<char> {
    string.chars().last()
}

1 1 fn last_char(string: &str) -> Option<char> {
2 - string.chars().rev().next()
2 + string.chars().last()
3 3 }

alexysbikevs. chelios

Last Char

Strings

```
const lastChar = ([...s]) => s.pop();
```
1 - const lastChar=s=>[...s].pop()
1 + const lastChar = ([...s]) => s.pop();

SerzN1vs. Emgo-Dev

Convert Minutes to Hours and Minutes

Fundamentals

Strings

const toHours = i => Math.floor(i / 60);

const setDigits = i => `0${i}`.slice(-2);

const getTime = i => [toHours(i), i % 60];

const toTime = arr => `${arr[0]}:${setDigits(arr[1])}`;

const minutes = i => toTime(getTime(i));

Recent Moves:

RSAkidinUSAvs. Dragoris

Convert Minutes to Hours and Minutes

Fundamentals

Strings

You will be given a number of minutes. Your task is to return a string on the heap that formats the number into 'hours:minutes".

Make sure you always return two integers for the minutes section of the conversion.

i.e. ('0:01' instead of '0:1')

Example:

minutes(90) => '1:30'

char *minutes(int num){
  char *ret = calloc(64, sizeof(char));
  sprintf(ret, "%d:%02d", (num / 60), (num % 60));
  return ret;
}

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

char *minutes(int);

Test(minutes, sample_tests) {
  char *ptr;
  ptr = minutes(0);
  cr_assert_eq(strcmp(ptr, "0:00"), 0);
  free(ptr);
  
  ptr = minutes(1);
  cr_assert_eq(strcmp(ptr, "0:01"), 0);
  free(ptr);
  
  ptr = minutes(18);
  cr_assert_eq(strcmp(ptr, "0:18"), 0);
  free(ptr);
  
  ptr = minutes(13267);
  cr_assert_eq(strcmp(ptr, "221:07"), 0);
  free(ptr);
  
  ptr = minutes(351);
  cr_assert_eq(strcmp(ptr, "5:51"), 0);
  free(ptr);
  
  ptr = minutes(985);
  cr_assert_eq(strcmp(ptr, "16:25"), 0);
  free(ptr);
  
  ptr = minutes(156113);
  cr_assert_eq(strcmp(ptr, "2601:53"), 0);
  free(ptr);
}

ShadowfeindXvs. ShadowfeindX

Convert Minutes to Hours and Minutes

Fundamentals

Strings

minutes = -> i { '%d:%02d' % i.divmod(60) }

1 - minutes = -> i { '%d:%02d' % [i / 60, i % 60] }
1 + minutes = -> i { '%d:%02d' % i.divmod(60) }

ShadowfeindXvs. Dragoris

Convert Minutes to Hours and Minutes

Fundamentals

Strings

minutes = -> i { '%d:%02d' % [i / 60, i % 60] }

1 - function minutes(num){
2 - return num % 60 < 10 ? Math.floor(num/60) + ':' + '0' + (num % 60) : Math.floor(num/60) + ':' + (num % 60)
3 - }
1 + minutes = -> i { '%d:%02d' % [i / 60, i % 60] }

Test.describe("Solution") do
  Test.it("Did you make the correct conversion?") do
    Test.assert_equals(minutes.(0), "0:00", "Better try again!")
    Test.assert_equals(minutes.(1), "0:01", "Better try again!")
    Test.assert_equals(minutes.(18), "0:18", "Better try again!")
    Test.assert_equals(minutes.(13267), "221:07", "Better try again!")
    Test.assert_equals(minutes.(985), "16:25", "Better try again!")
    Test.assert_equals(minutes.(351), "5:51", "Better try again!")
    Test.assert_equals(minutes.(156113), "2601:53", "Better try again!")
  end
end

Emgo-Devvs. guido

Convert Minutes to Hours and Minutes

Fundamentals

Strings

const toHours = ( i ) => Math.floor( i / 60 );

const setDigits = ( i ) => i < 10 ? `0${i}` : i;

const getTime = ( i ) => [toHours(i), i % 60];

const toTime = ( arr ) => `${arr[0]}:${setDigits(arr[1])}`;

const minutes = ( i ) => toTime(getTime(i));

sir_kamba

Connected networks

Algorithms

a function that takes a list of connections on the following format:
connections[n] is the list of connections from node n.

connections={
    [1] ={ 1, 2, 6, 7 },
    [2] ={ 1, 2, 4, 5, 6 },
    [3] ={ 3, 4, 5, 6, 7 },
    [4] ={ 2, 3, 4, 5, 6 },
    [5] ={ 2, 3, 4, 5, 7 },
    [6] ={ 1, 2, 3, 4, 6 },
    [7] ={ 1, 3, 5, 7 },
    [8] ={ 8, 9, 11, 12, 13, 15 },
    [9] ={ 8, 9, 10, 12, 13, 15, 16 },
    [10]={ 9, 10, 11, 12, 16 },
    [11]={ 8, 10, 11, 12 },
    [12]={ 8, 9, 10, 11, 12, 13, 15 },
    [13]={ 8, 9, 12, 13, 14, 15 },
    [14]={ 13, 14, 15, 16 },
    [15]={ 8, 9, 12, 13, 14, 15, 16 },
    [16]={ 9, 10, 14, 15, 16 },
    [17]={ 17, 18, 19, 20, 21 },
    [18]={ 17, 18, 19, 20 },
    [19]={ 17, 18, 19, 21 },
    [20]={ 17, 18, 20, 21 },
    [21]={ 17, 19, 20, 21 },
}

The output should be a table of tables with nodes in a given net.

nets={
    {1,2,6,7,4,5,3},
    {8,9,11,12,13,15,10,16,14},
    {17,18,19,20,21}
}

This solution assumes symmetrical connections between nodes.

solution={}

local isIn=function(list,item)
  --simple function to find a vale in list
	if type(list)~="table" or item==nil then
		return false
	end
	local FoundAtIndex=""
	local found=false
	for index,value in pairs(list) do
		if value==item then
			found=true
			FoundAtIndex=index
			break
		end
	end
	return found,FoundAtIndex
end

solution.findConnectedNets=function(connections)
	local nets={}
	for i=1,#connections do --traverses nodes to build the nets
		local new=true
		for k=1,#nets do --if it already is in a net, skip it
			if isIn(nets[k],i) then
				new=false
				break
			end
		end
		if new then
			local net={}
			local queue={i}
			while #queue>0 do
				local vertex=queue[1]
				table.insert(net,vertex)
				table.remove(queue,1)
				for _,node in pairs(connections[vertex]) do
					if not isIn(net,node) and not isIn(queue,node) then
						table.insert(queue,node)
					end
				end
			end
			table.insert(nets,net)
		end
	end
	return nets
end


return solution

local solution = require 'solution'
describe("solution", function()
  it("test precalculated solutions", function()
    assert.are.same(
      {{1,2,6,7,4,5,3},{8,9,11,12,13,15,10,16,14},{17,18,19,20,21}},
      solution.findConnectedNets(
        {{1,2,6,7},{1,2,4,5,6},{3,4,5,6,7},{2,3,4,5,6},{2,3,4,5,7},{1,2,3,4,6},{1,3,5,7},{8,9,11,12,13,15},{8,9,10,12,13,15,16},{9,10,11,12,16},{8,10,11,12},{8,9,10,11,12,13,15},{8,9,12,13,14,15},{13,14,15,16},{8,9,12,13,14,15,16},{9,10,14,15,16},{17,18,19,20,21},{17,18,19,20},{17,18,19,21},{17,18,20,21},{17,19,20,21}}
      )
    )
  end)
end)

Foprtavs. Jan-Ka

FizzBuzz.ts

export function fizzBuzz(input: number): string {
    const output = (input % 3 ? "" : "Fizz") + (input % 5 ? "" : "Buzz");
    return output.length ? output : input.toString();
}

Recent Moves:

Jan-Ka

FizzBuzz.ts

Write a function that:

returns "Fizz" for multiples of 3
returns "Buzz" for multiples of 5
returns "FizzBuzz" for multiples of both 3 and 5

Any other number should return the number as string.

export function fizzBuzz(input: number): string {
    const output: string = `${input % 3 === 0 ? "Fizz" : ""}${input % 5 === 0 ? "Buzz" : ""}`;
    return output.length > 0 ? output : input.toString(10);
}

/// <reference path="/runner/typings/mocha/index.d.ts" />
/// <reference path="/runner/typings/chai/index.d.ts" />
import solution = require('./solution');

import { assert } from "chai";


describe("solution", () => {
    it("Divisible By Three", () => {
        assert.equal(solution.fizzBuzz(3), "Fizz");
        assert.equal(solution.fizzBuzz(12), "Fizz");
    })

    it("Divisible By Five", () => {
        assert.equal(solution.fizzBuzz(5), "Buzz");
        assert.equal(solution.fizzBuzz(95), "Buzz");
    })

    it("Divisible By Three And Five", () => {
        assert.equal(solution.fizzBuzz(15), "FizzBuzz");
        assert.equal(solution.fizzBuzz(90), "FizzBuzz");
    })
    
        it("Not Divisible By Three Or Five", () => {
        assert.equal(solution.fizzBuzz(1), "1");
        assert.equal(solution.fizzBuzz(7), "7");
    });
});

mochmanvs. TX404

The system say it wrong but i think I got it right

Started with 3, because why waste 2 loops on answers you know aren't correct.

function test(n) {
  let sum=0;
  for (let i=3; i<n; i++){
    if ((i%3==0) || (i%5==0)){
    sum+=i;
    }
  }
   return sum;
}

Recent Moves:

TX404vs. vench

The system say it wrong but i think I got it right

i know it's too late to reply ...but as said in the previous comment your Code is fine you just need some little changes..and because i am a bad explainer i am just going to show my simple version of the code .....

//if you have any Suggestion or noticed a mistake in my code ...tell me...i would need that...
function test(n) {
  var sum=0;
  for (i=1; i<n; i++){
    if ((i%3==0) || (i%5==0)){
    sum+=i;
    }
  }
   return sum;
}

Test.assertDeepEquals(test(11),33);
Test.assertDeepEquals(test(10),23);
Test.assertDeepEquals(test(0),0);
Test.assertDeepEquals(test(4),3);

venchFailed Tests

The system say it wrong but i think I got it right

heres the instruction:
If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.

Finish the solution so that it returns the sum of all the multiples of 3 or 5 below the number passed in.

Note: If the number is a multiple of both 3 and 5, only count it once.

I got the output of 23 by adding all multiple of 3 and 5 but it saying, I'm wrong.

I'm new here plss help

function test() {
  var a = [];
  for (i=1; i<10; i++){
    if ((i%3==0) || (i%5==0)){
    a.push(i);
    }
  }
   return a;
}

function sum(number){ 
  var sum= 0;
  for(i=0; i<number.length; i++){
    sum += number[i];
    }
    return sum;
  }
var ab = test();
var abc = sum(ab);
console.log(abc);

function test() {
  var a = [];
  for (i=1; i<10; i++){
    if ((i%3==0) || (i%5==0)){
    a.push(i);
    }
  }
   return a;
}

function sum(number){ 
  var sum= 0;
  for(i=0; i<number.length; i++){
    sum += number[i];
    }
    return sum;
  }
var ab = test();
var abc = sum(ab);
console.log(abc);

Afforixvs. donaldsebleung

C++ Templates - Generic vectorMap, vectorFilter and vectorReduce

Use STL algorithms, take vector arguments by constant reference and functors by their exact type to avoid overhead of std::function.

#include <numeric>

using namespace std;

template<class F, class T, class U = decltype(std::declval<F>()(std::declval<T>()))> vector<U> vectorMap(const vector<T>& v, F f) {
  vector<U> result (v.size());
  std::transform(v.begin(), v.end(), result.begin(), std::move(f));
  return result;
}
template<class F, class T> vector<T> vectorFilter(const vector<T>& v, F f) {
  vector<T> result;
  std::copy_if(v.begin(), v.end(), std::back_inserter(result), std::move(f));
  return result;
}
template<class F, class T, class U> U vectorReduce(const vector<T>& v, F f, U u) {
  return std::accumulate(v.begin(), v.end(), u, std::move(f));
}

#include <string>

using namespace std;

Describe(the_generic_vector_map_function) {
  It(should_correctly_map_an_int_vector_to_an_int_vector) {
    Assert::That(vectorMap(vector<int> {2, -7, 5, -4, 3}, [] (int n) -> int {return n * -2;}), EqualsContainer(vector<int> {-4, 14, -10, 8, -6}));
  }
  It(should_correctly_map_an_int_vector_to_a_string_vector) {
    Assert::That(vectorMap(vector<int> {13, 27, -2, 33, 666, 11723}, [] (int n) -> string {return to_string(n);}), EqualsContainer(vector<string> {"13", "27", "-2", "33", "666", "11723"}));
  }
};

Describe(the_generic_vector_filter_function) {
  It(should_correctly_filter_an_int_vector) {
    Assert::That(vectorFilter(vector<int> {4, 6, 9, 16, -5, -28}, [] (int n) -> bool {return n % 2 != 0;}), EqualsContainer(vector<int> {9, -5}));
    Assert::That(vectorFilter(vector<int> {4, 6, 9, 16, -5, -28}, [] (int n) -> bool {return n % 2 == 0;}), EqualsContainer(vector<int> {4, 6, 16, -28}));
  }
  It(should_correctly_filter_a_string_vector) {
    Assert::That(vectorFilter(vector<string> {"Hello World", "Goodbye World", "hello", "meow", "goodbye"}, [] (string s) -> bool {return s.find("Hello") != string::npos || s.find("hello") != string::npos;}), EqualsContainer(vector<string> {"Hello World", "hello"}));
    Assert::That(vectorFilter(vector<string> {"Hello World", "Goodbye World", "hello", "meow", "goodbye"}, [] (string s) -> bool {return s.find("Hello") == string::npos && s.find("hello") == string::npos;}), EqualsContainer(vector<string> {"Goodbye World", "meow", "goodbye"}));
  }
};

Describe(the_generic_vector_reduce_function) {
  It(should_correctly_reduce_an_int_vector_into_a_single_int) {
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, [] (int s, int n) -> int {return s + n * n;}, 0), Equals(17838));
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, [] (int t, int n) -> int {return t < n ? n : t;}, INT_MIN), Equals(99));
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, [] (int t, int n) -> int {return t > n ? n : t;}, INT_MAX), Equals(-23));
  }
  It(should_correctly_reduce_an_int_vector_into_a_string) {
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, [] (string s, int n) -> string {return s + to_string(n);}, (string)""), Equals("57486332-2399"));
  }
  It(should_correctly_reduce_a_string_vector_to_an_int) {
    Assert::That(vectorReduce(vector<string> {"Hello World", "Goodbye World", "hello", "meow", "goodbye"}, [] (int n, string s) -> int {return n + s.length();}, 0), Equals(40));
  }
};

Recent Moves:

C++ Templates - Generic vectorMap, vectorFilter and vectorReduce

Although C++ templates can be a right pain in the arse when you're trying to model Peano numbers and their operations, they can come in handy when you want to define generic functions that work over a wide range of datatypes, especially higher-order functions that map a vector, for example.

using namespace std;

template<class T, class U> vector<U> vectorMap(vector<T> v, function<U (T)> f) {
  size_t size = v.size();
  vector<U> result (size);
  for (size_t i = 0; i < size; i++) result[i] = f(v[i]);
  return result;
}
template<class T> vector<T> vectorFilter(vector<T> v, function<bool (T)> f) {
  vector<T> result;
  for (size_t i = 0; i < v.size(); i++) if (f(v[i])) result.push_back(v[i]);
  return result;
}
template<class T, class U> U vectorReduce(vector<T> v, function<U (U, T)> f, U u) {
  U result = u;
  for (size_t i = 0; i < v.size(); i++) result = f(result, v[i]);
  return result;
}

#include <string>

using namespace std;

Describe(the_generic_vector_map_function) {
  It(should_correctly_map_an_int_vector_to_an_int_vector) {
    Assert::That(vectorMap(vector<int> {2, -7, 5, -4, 3}, (function<int (int)>)([] (int n) -> int {return n * -2;})), EqualsContainer(vector<int> {-4, 14, -10, 8, -6}));
  }
  It(should_correctly_map_an_int_vector_to_a_string_vector) {
    Assert::That(vectorMap(vector<int> {13, 27, -2, 33, 666, 11723}, (function<string (int)>)([] (int n) -> string {return to_string(n);})), EqualsContainer(vector<string> {"13", "27", "-2", "33", "666", "11723"}));
  }
};

Describe(the_generic_vector_filter_function) {
  It(should_correctly_filter_an_int_vector) {
    Assert::That(vectorFilter(vector<int> {4, 6, 9, 16, -5, -28}, (function<bool (int)>)([] (int n) -> bool {return n % 2 != 0;})), EqualsContainer(vector<int> {9, -5}));
    Assert::That(vectorFilter(vector<int> {4, 6, 9, 16, -5, -28}, (function<bool (int)>)([] (int n) -> bool {return n % 2 == 0;})), EqualsContainer(vector<int> {4, 6, 16, -28}));
  }
  It(should_correctly_filter_a_string_vector) {
    Assert::That(vectorFilter(vector<string> {"Hello World", "Goodbye World", "hello", "meow", "goodbye"}, (function<bool (string)>)([] (string s) -> bool {return s.find("Hello") != string::npos || s.find("hello") != string::npos;})), EqualsContainer(vector<string> {"Hello World", "hello"}));
    Assert::That(vectorFilter(vector<string> {"Hello World", "Goodbye World", "hello", "meow", "goodbye"}, (function<bool (string)>)([] (string s) -> bool {return s.find("Hello") == string::npos && s.find("hello") == string::npos;})), EqualsContainer(vector<string> {"Goodbye World", "meow", "goodbye"}));
  }
};

Describe(the_generic_vector_reduce_function) {
  It(should_correctly_reduce_an_int_vector_into_a_single_int) {
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, (function<int (int, int)>)([] (int s, int n) -> int {return s + n * n;}), 0), Equals(17838));
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, (function<int (int, int)>)([] (int t, int n) -> int {return t < n ? n : t;}), INT_MIN), Equals(99));
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, (function<int (int, int)>)([] (int t, int n) -> int {return t > n ? n : t;}), INT_MAX), Equals(-23));
  }
  It(should_correctly_reduce_an_int_vector_into_a_string) {
    Assert::That(vectorReduce(vector<int> {5, 7, 4, 86, 3, 3, 2, -23, 99}, (function<string (string, int)>)([] (string s, int n) -> string {return s + to_string(n);}), (string)""), Equals("57486332-2399"));
  }
  It(should_correctly_reduce_a_string_vector_to_an_int) {
    Assert::That(vectorReduce(vector<string> {"Hello World", "Goodbye World", "hello", "meow", "goodbye"}, (function<int (int, string)>)([] (int n, string s) -> int {return n + s.length();}), 0), Equals(40));
  }
};

SpyMaster356vs. user1709872

Can I buy a few spaces?

Algorithms

flatten = a => a.map ? [].concat(...a.map(flatten)) : a

1 - flatten=a=>a.map?[].concat(...a.map(flatten)):a
1 + flatten = a => a.map ? [].concat(...a.map(flatten)) : a

Recent Moves:

SpyMaster356vs. SpyMaster356

dynamic test cases

Algorithms

describe("Test cases", function() {  
  let tests = [
    { 
      input: [1, 2, [3, 5], [[4, 3], 2]], 
      expected: [1, 2, 3, 5, 4, 3, 2],
    },
    { 
      input: [[1, [5], [], [[-3, 'hi']]], 'string', 10, [[[5]]]], 
      expected: [1, 5, -3, 'hi', 'string', 10, 5],
    },
  ]
  
  tests.forEach(test => {
    describe(`when given '${JSON.stringify(test.input)}'`, function () {
      it("flattens correctly", function() {
        Test.assertSimilar(flatten(test.input), test.expected);
      });
    });
  });
});

SpyMaster356vs. mustak

Flatten an array of arrays

Algorithms

describe("Test cases", function() {
  it("[1, 2, [3, 5], [[4, 3], 2]]", function() {
    Test.assertSimilar(flatten([1, 2, [3, 5], [[4, 3], 2]]), [1, 2, 3, 5, 4, 3, 2]);
  });
  
  it("[[1, [5], [], [[-3, 'hi']]], 'string', 10, [[[5]]]]", function() {
    Test.assertSimilar(flatten([[1, [5], [], [[-3, 'hi']]], 'string', 10, [[[5]]]]), [1, 5, -3, 'hi', 'string', 10, 5]);
  });
});

mustakvs. v1z

Flatten an array of arrays

Algorithms

update for ES6 with spread operator

const flatten = arr =>
  arr.reduce((acc, item) =>  [...acc, ...(Array.isArray(item) ? flatten(item) : [item])],[]);

juanpitersonvs. erschus

Flatten an array of arrays

Algorithms

```
const flatten = a => [...a]
```
1 - const flatten = a => [].concat.apply([], a)
1 + const flatten = a => [...a]

SpyMaster356vs. pepellou

Can one stack make a queue?

class Stack {  // Just to hide the use of array implementation
  constructor() {
    this._items = [];
  }
  push(data) {
    this._items.push(data);
  }
  pop() {
    return this._items.pop();
  }
  
  get length() {
    return this._items.length;
  }
}

class Queue {
  constructor() {
    this._stack = new Stack();
  }
  enqueue(data) {
    this._stack.push(data);
  }
  dequeue() {
    if (this._stack.length === 1)
      return this._stack.pop();
    else {
      var tmp = this._stack.pop(), result = this.dequeue();
      this.enqueue(tmp);
      return result;
    }
  }
}

Test.describe("Queue", function () {
  Test.it("is first-in-first-out", function () {
    var queue = new Queue();
    let items = [1,2,3];
    
    items.forEach(item => queue.enqueue(item));
    
    Test.assertEquals(queue.dequeue(), 1);
    Test.assertEquals(queue.dequeue(), 2);
    Test.assertEquals(queue.dequeue(), 3);
  });
  
  Test.describe("#enqueue", function() {
    Test.it("adds the item to the stack", function () {
      var queue = new Queue();
      var mockStack = [];
      
      queue._stack = mockStack;
      
      queue.enqueue(1);
      Test.assertSimilar(mockStack, [1]);   
      
      queue.enqueue(2);
      Test.assertSimilar(mockStack, [1,2]);
    });
  });
  
  Test.describe("#dequeue", function() {
    Test.it("removes items from the stack", function () {
      var queue = new Queue();
      var mockStack = [1,2];
      
      queue._stack = mockStack;
      
      queue.dequeue();
      Test.assertSimilar(mockStack, [2]);   
      
      queue.dequeue();
      Test.assertSimilar(mockStack, []);
    });
    
    Test.it("returns the first item from the stack", function () {
      var queue = new Queue();
      var mockStack = [1,2];
      var result = null;
      
      queue._stack = mockStack;
      
      result = queue.dequeue();
      Test.assertEquals(result, 1);   
      
      result = queue.dequeue();
      Test.assertEquals(result, 2);
    });
  });
});

Test.describe("Stack", function () {
  let stack = new Stack();
  
  Test.it("has #pop", function () {
    Test.expect(typeof stack.pop === "function");
  });
  
  Test.it("has #push", function () {
    Test.expect(typeof stack.push === "function");
  });
  
  Test.it("has .length", function () {
    Test.expect(typeof stack.length === "number");
  });
  
  Test.it("does not have #shift", function () {
    Test.expect(typeof stack.shift === "undefined");
  });
});

Recent Moves:

pepellouvs. donaldsebleung

Can one stack make a queue?

Let's just hide that the Stack is implemented with an array, so that we're not tempted to use other methods as shift() 😇

class Stack {  // Just to hide the use of array implementation
  constructor() {
    this._items = [];
  }
  push(data) {
    this._items.push(data);
  }
  pop() {
    return this._items.pop();
  }
  length() {
    return this._items.length;
  }
}

class Queue {
  constructor() {
    this._stack = new Stack();
  }
  enqueue(data) {
    this._stack.push(data);
  }
  dequeue() {
    if (this._stack.length() === 1)
      return this._stack.pop();
    else {
      var tmp = this._stack.pop(), result = this.dequeue();
      this.enqueue(tmp);
      return result;
    }
  }
}

sedxvs. donaldsebleung

Can one stack make a queue?

Any reason to not use Array.prototype.shift()?
I think is more clear and should be faster

class Queue {
  constructor() {
    this._stack = []; // We will be using this array as a stack - only
    // its push and pop operations will ever be called
  }
  enqueue(data) {
    this._stack.push(data);
  }
  dequeue() {
      return this._stack.shift();
  }
}

Can one stack make a queue?

Yes and no. A queue can be implemented using one explicit stack by leveraging the technique of recursion in the "dequeue" operation but note that recursion is handled internally by a function call stack; hence, technically, there are still two stacks at work ;)

class Queue {
  constructor() {
    this._stack = []; // We will be using this array as a stack - only
    // its push and pop operations will ever be called
  }
  enqueue(data) {
    this._stack.push(data);
  }
  dequeue() {
    if (this._stack.length === 1)
      return this._stack.pop();
    else {
      var tmp = this._stack.pop(), result = this.dequeue();
      this.enqueue(tmp);
      return result;
    }
  }
}

Test.describe("Queue", function () {
  Test.it("should have working enqueue and dequeue operations", function () {
    var queue = new Queue();
    queue.enqueue(1);
    queue.enqueue(2);
    queue.enqueue(3);
    Test.assertEquals(queue.dequeue(), 1);
    queue.enqueue(4);
    queue.enqueue(5);
    queue.enqueue(6);
    Test.assertEquals(queue.dequeue(), 2);
    Test.assertEquals(queue.dequeue(), 3);
    queue.enqueue(7);
    queue.enqueue(8);
    queue.enqueue(9);
    queue.enqueue(10);
    Test.assertEquals(queue.dequeue(), 4);
    Test.assertEquals(queue.dequeue(), 5);
    Test.assertEquals(queue.dequeue(), 6);
    Test.assertEquals(queue.dequeue(), 7);
    Test.assertEquals(queue.dequeue(), 8);
    Test.assertEquals(queue.dequeue(), 9);
    Test.assertEquals(queue.dequeue(), 10);
  });
});

SpyMaster356

Let's make some Coffee

yawn I need a cup of coffee...

class GroundCoffee { }
class Coffee { }

class Cupboard { 
  constructor() {
    this.contents = {
      "GroundCoffee": new GroundCoffee(),
    };
  }
}

class CoffeeMaker {
  makeCoffee(groundCoffee) {
    if(!(groundCoffee instanceof GroundCoffee)) {
      throw new Error("Only GroundCoffee can be used to make Coffee");
    }
    
    return new Coffee();
  }
}

// -----

const cupboard = new Cupboard();
const coffeeMaker = new CoffeeMaker();

function makeCoffee() {  
  let groundCoffee = cupboard.contents["GroundCoffee"];
  return coffeeMaker.makeCoffee(groundCoffee);
}

var expect = require("chai").expect;

describe("makeCoffee", function(){
  it("makes coffee", function(){
    expect(makeCoffee()).to.be.an.instanceof(Coffee);
  });
});


describe("CoffeeMaker", function() {
  beforeEach(function() {
    this.coffeeMaker = new CoffeeMaker();
  });
  
  describe("#makeCoffee", function() {
    context("when passed GroundCoffee", function() {
      beforeEach(function () {
        this.groundCoffee = new GroundCoffee();
      });
      
      it("makes coffee", function(){
        expect(this.coffeeMaker.makeCoffee(this.groundCoffee)).to.be.an.instanceof(Coffee);
      });
    });
    
    context("when not passed GroundCoffee", function() {
      beforeEach(function () {
        this.groundCoffee = "I'm not coffee!";
      });
      
      it("throws an error", function(){
        expect(() => this.coffeeMaker.makeCoffee(this.groundCoffee)).to.throw(
          Error, "Only GroundCoffee can be used to make Coffee"
        );
      });
    });
  });
});

SpyMaster356vs. elisha464

hello world (Ruby)

```
def hello
  "world"
end
```
1 - function hello() {
2 - return "world";
3 - }
1 + def hello
2 + "world"
3 + end

describe "Solution" do
  it "returns with 'world'" do
    expect(hello()).to eq("world")
  end
end

Recent Moves:

SpyMaster356vs. jscraftsman

hello world (Look What I Can Do Remix)

class Locale {
  sayHelloTo(whoever){
    throw new Error("Not implemented");
  }
}

class EnglishLocale extends Locale {
  sayHelloTo(whoever){
    return `hello ${whoever}`;
  }
}

class PirateLocale extends Locale {
  sayHelloTo(whoever){
    return `yar ${whoever}`;
  }
}

class BinaryLocale extends EnglishLocale {
  sayHelloTo(whoever) {
    let msg = super.sayHelloTo(whoever);
    return this.txtToBin(msg);
  }

  txtToBin(text) {
    let result = [];

    for(let character of text){
      let binaryArr = this.numberToBinaryArray(character.charCodeAt());
      result = result.concat(binaryArr);
    }

    return result.join("");
  }
  
  numberToBinaryArray(number) {
    let result = [];

    while(number > 0){
      let bit = Math.floor(number % 2) != 0 ? 1 : 0;
      result.unshift(bit)
      number = Math.floor(number / 2);
    }

    while(result.length != 8) {
      result.unshift(0);
    }
    
    return result;
  }
}

const GREET_LANG = {
  ENGLISH: new EnglishLocale(),
  PIRATE: new PirateLocale(),
  BINARY: new BinaryLocale(),
}

const hello = (whoever, lang=GREET_LANG.ENGLISH) => lang.sayHelloTo(whoever);

describe("Solution", function(){
  it("defaults to english", function(){
    Test.assertEquals(hello('gotham'), "hello gotham");
  });
  
  it("responds in pirate when passed 'pirate' as the language", function(){
    Test.assertEquals(hello('gotham', GREET_LANG.PIRATE), "yar gotham");
  });
  
  it("responds in real time binary when passed 'binary' as the language", function(){
    Test.assertEquals(hello('gotham', GREET_LANG.BINARY), "011010000110010101101100011011000110111100100000011001110110111101110100011010000110000101101101");
  });
});

jscraftsmanvs. Shadowner

hello world (Look What I Can Do Remix)

A structure to allow new languages to be added.

// Declare new languages here and map them in parseGreeting() function
const GREET_LANG = {
  ENGLISH: 0,
  PIRATE: 1,
  BINARY: 2
}

function numberToBinaryArray(number) {
	let result = [];
	while(number > 0){
		let bit = Math.floor(number % 2) != 0 ? 1 : 0;
		result.unshift(bit)
		number = Math.floor(number / 2);
	}
	while(result.length != 8)
		result.unshift(0);
	return result;
}

function txtToBin(text) {
	let result = [];
	for(let character of text){
		let binaryArr = numberToBinaryArray(character.charCodeAt());
		result = result.concat(binaryArr);
	}
	return result.join("");
}

function parseGreeting(lang) {
  switch(lang){
    case GREET_LANG.PIRATE:
      return 'yar';
    case GREET_LANG.BINARY:
      return txtToBin('hello');
    default:
      return 'hello';
  }
}


const parseWhoever = (whoever, lang) => lang == GREET_LANG.BINARY ? txtToBin(whoever) : whoever;

const hello = (whoever, lang=GREET_LANG.ENGLISH) => `${parseGreeting(lang)} ${parseWhoever(whoever, lang)}`;

describe("Solution", function(){
  it("defaults to english", function(){
    Test.assertEquals(hello('gotham'), "hello gotham");
  });
  
  it("responds in pirate when passed 'pirate' as the language", function(){
    Test.assertEquals(hello('gotham', GREET_LANG.PIRATE), "yar gotham");
  });
  it("responds in real time binarry when passed 'binary' as the language", function(){
    Test.assertEquals(hello('gotham', GREET_LANG.BINARY), "0110100001100101011011000110110001101111 011001110110111101110100011010000110000101101101");
  });
});

Shadownervs. YaoWang

hello world (Look What I Can Do Remix)

Ok now if you enter binary it will convert the 'whoever' name into binary string
Am i going too far ?

var numberToBinaryArray = (number) => {
	var result = [];
	while(number > 0){
		var bit = Math.floor(number % 2) != 0 ? 1 : 0;
		result.unshift(bit)
		number = Math.floor(number / 2);
	}
	while(result.length != 8)
		result.unshift(0);
	return result;
}

var txtToBin = (text) => {
	var result = [];
	for(var i = 0; i < text.length; i++){
		var binaryArr = numberToBinaryArray(text.charCodeAt(i));
		result = result.concat(binaryArr);
	}
	return result.join("");
}

let helloLangs = {
  english: "hello",
  pirate: "yar",
  binary: txtToBin('hello')
}

const hello = (whoever, lang="english") => `${helloLangs[lang]} ${lang == 'binary' ? txtToBin(whoever) : whoever}`;

describe("Solution", function(){
  it("defaults to english", function(){
    Test.assertEquals(hello('gotham'), "hello gotham");
  });
  
  it("responds in pirate when passed 'pirate' as the language", function(){
    Test.assertEquals(hello('gotham', 'pirate'), "yar gotham");
  });
  it("responds in real time binarry when passed 'binary' as the language", function(){
    Test.assertEquals(hello('gotham', 'binary'), "0110100001100101011011000110110001101111 011001110110111101110100011010000110000101101101");
  });
});

YaoWangvs. SpyMaster356

hello world (Look What I Can Do Remix)

let helloLangs = {
  english: "hello",
  pirate: "yar"
}

const hello = (whoever, lang="english") => `${helloLangs[lang]} ${whoever}`;

1 - const helloLangs = {
1 + let helloLangs = {
2 2 english: "hello",
3 3 pirate: "yar"
4 4 }
5 5
6 6 const hello = (whoever, lang="english") => `${helloLangs[lang]} ${whoever}`;

nithin5426vs. petersowa

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

from math import sqrt
def divisors(n):
    fa={i for i in range(1,int(sqrt(n)) + 1) if not(n%i)}
    ct={n//i for i in fa}
    return sorted(fa|ct)

Recent Moves:

nullievs. petersowa

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

Faster than previsous versions by avoiding sorting and insertion of factor lists. Style fix (not is not a function)

def divisors(n):
    fact_lo = []
    fact_hi = []
    for i in range(1, int(n**0.5) + 1):
        if not n % i:
            v = n // i
            if v != i:
                fact_hi.append(v)
            fact_lo.append(i)
    fact_lo.extend(reversed(fact_hi))
    return fact_lo

petersowavs. vle123

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

Refactored to insert in order. This may run a bit faster due to no longer using sort() function.

def divisors(n):
    fact = []
    for i in range(1, int(n**0.5) + 1):
        if not(n % i):
            v = n // i
            if v != i:
                fact.insert(len(fact)//2,v)
            fact.insert(len(fact)//2,i)
    return fact

vle123vs. Joey Bonzo

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

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

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)

Blind4Basicsvs. nithin5426

Being smart with Python complex numbers

from math import hypot as hypotenuse

1 - from math import *
2 - def hypotenuse(a, b): return hypot(a,b)
1 + from math import hypot as hypotenuse
3 3

Recent Moves:

nithin5426vs. FArekkusu

Being smart with Python complex numbers

being smarter

from math import *
def hypotenuse(a, b): return hypot(a,b)

1 - def hypotenuse(a, b):
2 - return abs(a + b * 1j)
1 + from math import *
2 + def hypotenuse(a, b): return hypot(a,b)
3 +

FArekkusuvs. TechieGirl

Being smart with Python complex numbers

No libraries required.

Also, for comparing exact values Test.assert_equals should be used. For floating point numbers your should use Test.assert_approx_equals.

def hypotenuse(a, b):
    return abs(a + b * 1j)

1 - def hypotenuse(a,b):
2 -
3 - import math
4 - h = round(math.sqrt(a**2 + b**2),4)
5 - #print(h)
6 - return h
1 + def hypotenuse(a, b):
2 + return abs(a + b * 1j)

test.assert_approx_equals(hypotenuse(7, 4),   8.06225774829855)
test.assert_approx_equals(hypotenuse(56, 87), 103.46496991735899)
test.assert_approx_equals(hypotenuse(15, 19), 24.20743687382041)
test.assert_approx_equals(hypotenuse(10, 10), 14.142135623730951)

TechieGirl

The Pythagorean Theorem

Lets go back to grade school!

Solve for the hypotenuse of a triangle.

Round a float to 4 decimal places.

def hypotenuse(a,b):

    import math
    h = round(math.sqrt(a**2 + b**2),4)
    #print(h)
    return h

test.expect(hypotenuse(7,4) == 8.0623)
test.expect(hypotenuse(3,4) == 5)
test.expect(hypotenuse(56,87) == 103.465)
test.expect(hypotenuse(15,19) == 24.2074)
test.expect(hypotenuse(10,10) == 14.1421)

Thamosvs. lukitahs

AirHunter007's Kumite #1

from datetime import datetime

def password(p):
    a = datetime.now()
    if not p.isdigit(): 
        return "Please, don't print letters.\nReset the program."
    return "ACCESS CONFIRMED" if p == f"{a.hour}{a.minute}" else "ACCESS DENIED"              

# Outside the codewar you can use the lines below.
# b = input("Please, print the password here (without letters!): ")
# print(password(b))

Recent Moves:

lukitahsvs. AirHunter007

AirHunter007's Kumite #1

It seems that the codewar does not accept direct inputs into the code. It is necessary to make a function and use the Test Cases to check it out.

See Test Cases, so it works correctly.

from datetime import datetime

def password(p):
    a = datetime.now()
    c = str(a.hour) + str(a.minute)
    
    if p.isdigit():
        if(p == c):
            return("ACCESS CONFIRMED")            
        else:
            return("ACCESS DENIED")            
    else:
        return("Please, don't print letters.\nReset the program.")                

# Outside the codewar you can use the lines below.
# b = input("Please, print the password here (without letters!): ")
# print(password(b))

# 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
from datetime import datetime

a = datetime.now()
c = str(a.hour) + str(a.minute) 


test.assert_equals(password(c), "ACCESS CONFIRMED", "ERROR")
test.assert_equals(password(c+'1'), "ACCESS DENIED", "ERROR")
test.assert_equals(password('aaaaa'), "Please, don't print letters.\nReset the program.", "ERROR")

AirHunter007Failed Tests

AirHunter007's Kumite #1

Why when i try to run it i get the EOFError? I don't get it when i test in Python 3.6.5 Shell

from datetime import datetime
a = datetime.now()
c = str(a.hour) + str(a.minute)
b = input("Please, print the password here (without letters!): ")
if b.isdigit():
    if(b == c):
        print("ACCESS CONFIRMED")
    else:
        print("ACCESS DENIED")
else:
    print("Please, don't print letters.")
    print("Reset the program.")

# 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

suuujuuus

Beginner Permutation Function

Don't know how this "kumite" stuff works yet, so i may be doing sth wrong.
This is about finding better/more efficient ways to permutate a list starting with my sorry attempt. The result requires types of the typeclass Ord, to get a common result for the test cases. Havent thought about a way to solve that differently yet.

module Permutation where

import Data.List (sort)

permu :: [a] ->[[a]]
permu []  = [[]]
permu [x] = [[x]]
permu x = fuzz (length x) 0 x
        where fuzz l n (x:xs) |n == l = []
                              |otherwise = map ((:) x) (permu xs) ++ fuzz l (n+1) (xs ++ [x])
                            
permutation :: Ord a => [a] -> [[a]]                           
permutation x = permu x

module PermuSpec where


import Test.Hspec
import Data.List (sort)
import Permutation

-- `spec` of type `Spec` must exist
spec :: Spec
spec = do
    describe "Permutation" $ do
        it "Basic Tests" $ do
            shouldBe (sort $ permutation [1,2,3]) [[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]
            shouldBe (sort $ permutation [1..4]) [[1,2,3,4],[1,2,4,3],[1,3,2,4],[1,3,4,2],[1,4,2,3],[1,4,3,2],[2,1,3,4],[2,1,4,3],[2,3,1,4],[2,3,4,1],[2,4,1,3],[2,4,3,1],[3,1,2,4],[3,1,4,2],[3,2,1,4],[3,2,4,1],[3,4,1,2],[3,4,2,1],[4,1,2,3],[4,1,3,2],[4,2,1,3],[4,2,3,1],[4,3,1,2],[4,3,2,1]]
            shouldBe (sort $ permutation "wup") ["puw","pwu","upw","uwp","wpu","wup"]

dances-with-peonsvs. donaldsebleung

Cheating through internal stack?

Return addresses are just normal stack entries, and nasm lets you jump to an address from a register.

global stack_push, stack_pop, stack_peek ; , stack_is_empty
section .text
stack_push:
  xchg rsi, [rsp]
  jmp rsi
stack_pop:
  pop rsi
  pop rax
  jmp rsi
stack_peek:
  pop rsi
  mov rax, [rsp]
  jmp rsi

Recent Moves:

donaldsebleungFailed Tests

Cheating through internal stack?

Just testing whether it is possible to "cheat" using the stack internally maintained by the computer to "implement" stack operations (between calls) in NASM.

Conclusion: It doesn't seem to be possible - at least with the way I did it, I got a segfault during the first call to stack_push() which just attempts to push its second argument to the internal stack and returns to the caller, let alone the pop and peek operations. There also doesn't seem to be a reliable way to check whether the internal stack is empty. Thus, it should be safe to translate my recent Stacks kata into NASM.

global stack_push, stack_pop, stack_peek ; , stack_is_empty
section .text
stack_push:
  push rsi
  ret
stack_pop:
  pop rsi
  ret
stack_peek:
  pop rsi
  push rsi
  ret

#include <criterion/criterion.h>
#include <stddef.h>
#include <stdbool.h>
#include <stdio.h>

typedef struct node {
  int data;
  struct node *next;
} Node;

typedef struct {
  Node *root;
} Stack;

void stack_push(Stack *stack, int data);
int stack_pop(Stack *stack);
int stack_peek(const Stack *stack);
// bool stack_is_empty(const Stack *stack);

Stack *new_stack() {
  Stack *stack = malloc(sizeof(Stack));
  stack->root = NULL;
  return stack;
}

void delete_stack(Stack *stack) {
  Node *nd = stack->root;
  while (nd) {
    Node *tmp = nd->next;
    free(nd);
    nd = tmp;
  }
  free(stack);
}

Test(Stack, should_work_for_some_examples) {
  Stack *stack = new_stack();
  printf("Stack initialized\n");
  stack_push(stack, 1);
  printf("First push operation successful!\n"); // This is never printed, suggesting that
  // segfault occurs during first call to stack_push() attempting to cheat
  stack_push(stack, 2);
  stack_push(stack, 3);
  cr_assert_eq(stack_peek(stack), 3);
  cr_assert_eq(stack_pop(stack), 3);
  cr_assert_eq(stack_peek(stack), 2);
  cr_assert_eq(stack_pop(stack), 2);
  cr_assert_eq(stack_peek(stack), 1);
  cr_assert_eq(stack_pop(stack), 1);
  delete_stack(stack);
}

riley-usagivs. luca.olivo

Hello Swift 5!

func hello() {
  print("Hello Swift 5!")
}

1 - func hello() {
2 -
3 - print("Hello Swift 5!")
4 -
1 + func hello() {
2 + print("Hello Swift 5!")
5 5 }

Recent Moves:

luca.olivovs. roblack

Hello Swift 4!

func hello() { 

print("Hello Swift 5!")

}

1 1 func hello() {
2 2
3 - print("Hello Swift 4!")
3 + print("Hello Swift 5!")
4 4
5 5 }

Raskolvs. dsurdaneta

Hello C#!

using System;
class Kata {
    public static string Main(string greeting, string language)     
      => $"{greeting} {language}!".Tee(Console.WriteLine);    
}

public static class Extensions
{
  public static T Tee<T>(this T @this, Action<T> action)
  {
    action(@this);
    return(@this);
  }
}

sertopexamgiovs. CzarnyDjabel

Hello C++!

Fundamentals

#include <stdio.h>

int helloCplusplus(){
  return !puts("Hello Cplusplus\n");
}

1 1 #include <stdio.h>
2 2
3 3 int helloCplusplus(){
4 - puts("Hello Cplusplus\n");
5 - return 0;
4 + return !puts("Hello Cplusplus\n");
6 6 }

CzarnyDjabelvs. MrPako

Hello C++!

Fundamentals

This one is even more succinct.

#include <stdio.h>

int helloCplusplus(){
  puts("Hello Cplusplus\n");
  return 0;
}

1 1 #include <stdio.h>
2 2
3 3 int helloCplusplus(){
4 - printf("Hello Cplusplus\n");
4 + puts("Hello Cplusplus\n");
5 5 return 0;
6 6 }

Mikhail.Krainikvs. narayanswa30663

there are two kinds of people - potential change to ruby version

class Functionator
  attr_reader :allowed_methods, :callers, :next_caller

  def initialize(s)
    @allowed_methods = s.split
    init_caller
  end

  def method_missing(method, *args)
    method = method.to_s
    raise NoMethodError, 'Not exists' unless @allowed_methods.include?(method)
    raise NoMethodError, 'Wrong order' unless @next_caller == method
    wait_next_caller
    self
  end

  private

  def wait_next_caller
    @next_caller = @callers.next
  rescue StopIteration
    init_caller
  end

  def init_caller
    @callers = @allowed_methods.each
    @next_caller = @callers.next
  end
end

def functionator(methods)
  Functionator.new methods
end

describe 'Functionator' do
  subject(:func) { functionator(input_data) }

  context 'when first chain is correct' do
    let(:input_data) { 'there are two kinds of people' }

    it do
      expect { func.there().are().two().kinds().of().people() }.not_to raise_error
    end
  end

  context 'when second chain is correct' do
    let(:input_data) { 'hello codewars world' }

    it do
      expect { func.hello().codewars().world() }.not_to raise_error
    end
  end

  context 'when third chain is NOT correct' do
    let(:input_data) { 'theraretwokindsofpeople' }

    it do
      expect { func.is_expected.theraretwokindsofpeople }.to raise_error StandardError
    end
  end

  context 'when fourth chain is NOT correct' do
    let(:input_data) { 'hello word' }

    it do
      expect { func.is_expected.word().hello() }.to raise_error StandardError
    end
  end

  context 'when fifth chain is NOT correct' do
    let(:input_data) { 'hello word' }

    it do
      expect { func.is_expected.hello().word }.to raise_error StandardError
    end
  end
end

Recent Moves:

jredvillevs. narayanswa30663

there are two kinds of people - potential change to ruby version

class Functionator
  def initialize(s)
    s.split.each { |i| define_singleton_method(i) { Functionator.new(s.split[1..-1].join(' ')) } }
  end
end

def functionator(string)
  Functionator.new(string)
end

narayanswa30663

there are two kinds of people - potential change to ruby version

class Functionator
  def initialize(s)
    s.split(' ').each { | i | define_singleton_method :"#{i}" do Functionator.new(s.split(' ')[1..-1].join(' ')) end }
  end
end

def functionator(string)
  Functionator.new(string)
end
# 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 "t e s t s" do
  it "t e s t s" do
    obj = functionator('there are two kinds of people')
    Test.expect(obj.there().are().two().kinds().of().people(),'Chain is incorrect');

    obj = functionator('hello codewars world')
    Test.expect(obj.hello().codewars().world(),'Chain is incorrect');

    obj = functionator('theraretwokindsofpeople')
    Test.expect(obj.theraretwokindsofpeople,'theraretwokindsofpeople is not defined');
  end
end

Mikhail.Krainikvs. 10XL

Test#expect_error example

def array_of_two(n)
  [n.to_int, n.to_int]
end

1 1 def array_of_two(n)
2 - raise 'n is not a number' unless n.is_a?(Numeric) # comment to fail test case
3 - [n, n]
2 + [n.to_int, n.to_int]
4 4 end

describe "array_of_two" do
  context "When raise an exception if N is not a number" do
    it do
      expect { array_of_two('hello world') }.to raise_error StandardError
    end  
    it do
      expect { array_of_two('2') }.to raise_error StandardError
    end
  end  
  context "When array of two integer" do
    subject { array_of_two(2) }
    
    it { is_expected.to eq [2, 2] }
  end
end

Recent Moves:

10XL

Test#expect_error example

def array_of_two(n)
  raise 'n is not a number' unless n.is_a?(Numeric)  # comment to fail test case
  [n, n]
end
describe "Test#expect_error" do
  Test.expect_error("array_of_two should raise an exception if N is not a number") { array_of_two('hello world') }
end

UnnamedFailed Tests

Is php good?

A mistake they don't want to fix...

function describePhp() {
  return 2 * 2 == 4 ? 'php is good' : 2 * 2 == 5 ? 'php is weird' : 'php has features';
}

class TestPhpQualities extends TestCase {
  public function testPhpIsNice() {
    $this->assertEquals('php is good', describePhp());
  }
}

mattberg88vs. IcarusTheFlyFailed Tests

Pairs

function pairs(target_value, array) {
  array.map(i => { array.map(j => {
   (i !== j && array[i] === array[j])? 1 : 0
    })
  })
}
  
 //shorter way to write what you wrote

Recent Moves:

IcarusTheFlyvs. doomsbyFailed Tests

Pairs

num_elements is not passed as a parameter now, because we can take it from the array directly.

If we repeat an element in the array, it will return -1 (Which is the error code)

function pairs(target_value, array) {
  var num_elements = array.length;
  
  for ( var i = 0; i < num_elements; i++ ) {
    for ( var j = 0; j < num_elements; j++ ) {
      if ( i !== j && array[i] === array[j] ) {
        return -1;
      }
    }
  }
  
  return 0;
}

doomsbyFailed Tests

Pairs

You will be given an array of integers and a target value. Determine the number of pairs of array elements that have a difference equal to the target value.

For example, given an array of [1,2,3,4] and a target value of 1, we have three pairs meeting the condition. 2 - 1 = 1, 3 - 2 = 1, and 4 - 3 = 1.

Input Format:

The first line contains n and k, the number of array elements and the target value.
The second line contains n space-separated integers of the array.

Constraints:

2 ≤ n ≤ 105
0 < k < 109
each integer element arr[i], will conform to 0 < arr[i] < 2^31 - 1
each integer arr[i] will be unique
Output Format
An integer representing the number of pairs of integers whose difference is k.

Sample Input:

5, 2, [1, 5, 3, 4, 2]

Sample Output:

Explanation:

There are 3 pairs of integers in the set with a difference of 2: [5,3], [4,2], and [3,1].

function pairs(num_elements, target_value, array) {
  
  return 0;
}

// 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('default tests', function() {
  it('t01', function(){
    Test.assertSimilar(pairs(226, 687, [967551, 42711, 652888, 556131, 432461, 689084, 878716, 707516, 462627, 719131, 921983, 626364, 4162, 381455, 628368, 434733, 845482, 789342, 129922, 384203, 516975, 872544, 958157, 257969, 383516, 972027, 753530, 579132, 732314, 692990, 938898, 673695, 304274, 911598, 386363, 643777, 897942, 705604, 307205, 691832, 525153, 13560, 131633, 967903, 704917, 719007, 275998, 823133, 381356, 694812, 130946, 14247, 881464, 212321, 535615, 388113, 263786, 993408, 303132, 347246, 957012, 356253, 80278, 682192, 79591, 22168, 399471, 130259, 302213, 146877, 143512, 464001, 323710, 716383, 252562, 704230, 528752, 385676, 433835, 84087, 324397, 19622, 726853, 400158, 765711, 879403, 717070, 796189, 630429, 735240, 899316, 897255, 682879, 943532, 548896, 650909, 128885, 156561, 260454, 861309, 463314, 396080, 486644, 483429, 306518, 579819, 726166, 319856, 689771, 346559, 466803, 340669, 602785, 686432, 259959, 146736, 878107, 718444, 272951, 371357, 690458, 625990, 672321, 968982, 211634, 966184, 806955, 421135, 486063, 350431, 856525, 674382, 968295, 709010, 81652, 874036, 487437, 966921, 318376, 402219, 956325, 319682, 346722, 112336, 643090, 670617, 700593, 580506, 695051, 996996, 486750, 989387, 738565, 873231, 311817, 351118, 77220, 129572, 900003, 880777, 109146, 675069, 829732, 420069, 519779, 692670, 391266, 683566, 349744, 629055, 305831, 14934, 216260, 302900, 347933, 85417, 307892, 367031, 433148, 431774, 871170, 955638, 629386, 252687, 151756, 290426, 642403, 213008, 693677, 349307, 80965, 376767, 879481, 177826, 382142, 591034, 733001, 967608, 381793, 957699, 382829, 251634, 641716, 226476, 530957, 871857, 658236, 615467, 401532, 681505, 485376, 694364, 144675, 23169, 673008, 146049, 581193, 461940, 22324, 641029, 878794, 620846, 558429, 6994, 41576, 717757]), 80);
  });
    it('t02', function(){
    Test.assertSimilar(pairs(520, 1341, [480247, 690951, 368650, 575544, 932592, 321567, 652970, 963956, 746702, 824511, 980999, 242171, 75168, 144120, 203281, 992812, 430432, 46770, 566884, 92507, 792622, 718045, 789412, 790753, 802355, 881533, 612820, 506671, 502468, 665638, 66191, 951403, 922175, 881334, 291814, 742679, 370213, 713716, 14949, 629095, 91166, 894145, 178277, 835114, 896011, 824973, 920015, 269023, 234465, 402146, 357349, 395469, 910656, 176710, 711413, 726112, 433114, 96368, 686702, 297662, 135664, 95027, 998231, 820113, 699691, 528591, 250234, 797555, 199258, 688762, 783282, 281335, 190961, 349489, 587162, 850086, 639235, 74994, 718529, 123181, 552080, 250564, 403128, 431140, 442349, 16543, 502801, 701950, 456529, 772458, 91184, 654812, 193933, 347157, 933933, 870810, 400418, 127204, 318247, 348498, 406169, 15202, 918819, 102695, 150771, 918674, 90677, 710072, 823632, 856234, 906310, 160235, 506824, 510573, 836828, 901556, 699472, 500897, 403487, 510915, 141438, 148591, 312882, 801014, 954648, 281117, 1106, 262483, 252916, 841213, 623621, 794873, 957677, 657494, 394128, 810582, 914651, 798332, 391446, 755404, 505150, 679777, 822795, 314223, 389594, 606607, 125863, 17631, 344343, 458427, 259089, 989403, 181599, 593315, 988512, 580598, 936534, 367309, 799673, 271705, 320929, 360031, 503809, 846577, 22595, 641086, 535783, 494704, 68552, 338979, 807411, 64529, 368075, 428458, 717392, 466549, 476353, 686973, 923116, 821454, 429091, 934899, 794776, 97519, 632949, 41245, 995494, 172116, 959858, 681118, 118915, 293202, 248893, 344475, 156419, 212590, 492022, 124522, 826314, 682459, 692292, 561421, 238980, 498215, 205666, 403923, 94837, 552521, 792094, 716398, 188802, 619598, 632016, 543965, 329954, 207226, 569425, 157760, 392787, 2447, 14066, 715057, 385708, 84803, 233616, 242362, 970989, 17784, 406600, 190058, 631608, 516318, 580430, 53746, 3374, 279019, 855452, 996890, 748043, 813264, 313625, 97709, 772158, 369416, 485470, 678410, 900215, 195274, 634290, 491797, 949301, 496874, 833604, 821829, 431773, 717739, 807900, 43509, 173457, 3788, 201940, 465658, 120256, 311541, 413762, 75343, 642456, 700813, 317648, 159101, 559156, 88502, 781591, 740587, 315015, 521764, 832196, 635631, 708731, 741928, 356008, 346807, 316356, 716867, 894513, 496804, 797970, 130748, 586503, 642427, 646069, 957903, 444465, 707390, 633357, 656993, 237639, 11826, 316906, 103685, 356856, 494122, 838169, 486757, 843895, 270364, 750395, 793435, 463867, 242694, 365968, 87148, 689298, 491556, 878640, 416615, 200599, 854111, 356584, 328613, 490899, 315564, 88484, 490456, 991956, 658127, 736560, 197956, 349839, 404828, 523105, 483347, 584480, 995549, 312333, 585821, 16934, 975304, 896546, 874617, 693633, 365715, 244874, 492781, 318962, 234957, 13861, 645179, 315565, 568084, 492240, 893522, 881838, 552193, 658334, 129149, 314966, 654311, 13769, 576885, 40072, 115125, 879156, 403659, 228762, 453847, 324249, 744020, 238238, 407941, 306587, 771117, 148637, 598738, 17884, 48869, 560284, 794644, 356657, 594656, 251575, 596308, 869469, 895486, 812515, 260602, 877299, 222492, 525909, 662368, 965297, 706240, 88489, 358526, 187258, 502238, 875958, 490681, 915992, 588503, 12520, 643941, 762594, 98860, 504941, 319588, 126516, 897533, 334149, 996835, 130213, 316905, 145461, 180976, 170775, 570766, 537124, 998176, 506491, 729202, 493581, 103764, 655652, 359018, 411918, 77428, 974422, 313674, 125341, 744610, 578226, 236298, 935274, 494479, 482006, 883179, 484688, 465208, 121597, 459553, 310411, 208567, 811923, 93848, 493138, 505483, 357998, 174798, 226999, 222733, 892181, 962615, 94822, 451165, 683431, 591974, 15593, 473717, 845236, 775340, 348699, 524446, 18972, 842554, 148147, 527250, 65870, 656153, 353975, 692, 354667, 318989, 331295, 340320, 287289, 366734, 175369, 350830, 142779, 894555, 471557, 643768, 674387, 478608, 856793, 390002, 355316, 809241, 877815, 196615, 994153, 471101, 677069, 574203, 938399, 796214, 316307, 534142, 322908, 211249, 459768, 101003, 577077, 358690, 673046, 990184, 309958, 451388, 712375, 455188, 206055, 527236, 92525, 54848, 879981, 935193, 620939, 4902, 921883, 461109]), 205);
  });
    it('t03', function(){
    Test.assertSimilar(pairs(517, 812, [954818, 241033, 33130, 770982, 268961, 612387, 4694, 920450, 204026, 578561, 905400, 335039, 911529, 343403, 531471, 818030, 429413, 666038, 584156, 471248, 607892, 942323, 539016, 279499, 703163, 376851, 501882, 281461, 929502, 480261, 241212, 571608, 775056, 168082, 338290, 54785, 939503, 147529, 569984, 837271, 763542, 64258, 377663, 716858, 877549, 776680, 875582, 438741, 967488, 44397, 572144, 797670, 530875, 493357, 53749, 936749, 899221, 212351, 350831, 316195, 876737, 251042, 135260, 818842, 537452, 311339, 257475, 768872, 628049, 25361, 580997, 355301, 256008, 595301, 904209, 426401, 924680, 896443, 950331, 716247, 512825, 552587, 152729, 949519, 796858, 492545, 225791, 317819, 532066, 680205, 926567, 679393, 379225, 580185, 25503, 552021, 819654, 141913, 6318, 43585, 629808, 535828, 177213, 659635, 326464, 958066, 669159, 181416, 161859, 531255, 228882, 930201, 422310, 678223, 621490, 494981, 852726, 168606, 539394, 420019, 530659, 241170, 310527, 161047, 778304, 165334, 532067, 250230, 308290, 100913, 367412, 375587, 102882, 194122, 709517, 935125, 507056, 5380, 121400, 658913, 136884, 359888, 57729, 516523, 596113, 787816, 125984, 676599, 310726, 259099, 111154, 482930, 228070, 654604, 723593, 768253, 514449, 515261, 665640, 162285, 619866, 573768, 27797, 984557, 582682, 7130, 821278, 466538, 133780, 539076, 366600, 179603, 420505, 797134, 996709, 928191, 171122, 826430, 643488, 924943, 278687, 918727, 921163, 267743, 770987, 970121, 309914, 248606, 869640, 799294, 681017, 229694, 441177, 521646, 584968, 661882, 828081, 794851, 733189, 810624, 619054, 169418, 349266, 919638, 11862, 947183, 637643, 162671, 956442, 137, 687541, 831830, 658823, 846874, 939067, 870452, 531254, 788628, 312151, 925755, 594489, 804310, 353298, 663602, 931373, 153704, 770689, 120433, 822976, 419961, 136072, 898409, 383863, 385168, 619671, 868828, 934205, 241758, 207414, 690642, 334985, 620678, 530443, 24691, 418881, 101048, 900414, 487782, 778734, 867204, 440365, 178837, 941353, 333180, 518147, 663064, 203276, 176401, 441989, 317007, 529847, 641419, 41593, 390615, 868016, 664414, 43217, 733386, 26985, 23067, 713811, 168894, 909976, 470423, 988165, 587318, 439553, 334173, 566198, 241073, 368224, 932637, 549585, 61730, 621295, 596925, 313384, 249418, 588185, 969112, 803436, 431037, 714623, 46021, 538264, 793837, 377211, 369036, 487426, 590675, 665226, 545079, 355599, 807544, 174867, 909409, 577749, 443148, 52125, 475864, 634439, 604989, 137354, 10467, 74439, 988392, 256663, 649813, 969924, 775868, 761389, 897597, 875925, 719927, 332549, 585409, 935017, 167270, 984261, 764237, 762559, 337478, 895631, 933501, 376399, 443960, 113017, 766100, 613220, 310631, 342518, 315132, 931013, 444566, 793679, 230506, 927379, 787004, 512013, 917915, 835208, 632284, 925574, 884006, 662694, 494169, 357721, 478300, 794892, 30754, 154979, 924904, 408428, 195091, 820466, 829705, 242344, 622203, 55597, 430225, 920351, 918014, 388179, 587174, 763371, 643855, 329021, 788941, 903756, 570796, 321960, 500240, 32318, 556670, 536640, 369848, 160235, 504277, 948707, 476676, 455603, 531907, 825618, 513637, 207980, 707135, 863491, 674064, 31506, 193467, 717502, 278804, 2224, 343330, 975012, 828893, 938691, 517335, 903746, 131159, 952104, 642231, 418069, 53973, 678581, 551795, 934313, 764183, 245063, 572956, 378023, 417257, 894495, 601777, 289281, 933393, 661070, 860326, 242267, 583344, 99424, 159423, 730079, 714228, 333361, 765978, 519341, 433382, 26173, 277526, 559659, 678299, 677411, 705419, 477488, 534738, 515711, 444772, 378475, 824806, 6545, 530442, 777110, 772611, 488868, 769065, 443706, 864337, 49922, 955630, 765166, 581720, 763013, 581058, 901332, 397636, 208226, 877924, 532878, 658011, 777492, 339102, 45209, 717420, 389803, 42405, 401865, 830517, 364816, 5506, 492644, 969871, 234527, 937067, 495793, 762201, 663647, 767441, 740649, 957254, 108566, 64095, 391627, 871162, 932581, 798453, 265449, 517287, 764354, 336666, 894007, 258287, 25757, 344142, 137696, 582532, 138508, 918826, 935937, 58478, 74468, 581870, 245226, 14684, 937879, 550320, 968300]), 192);
  });
    it('t16', function(){
    Test.assertSimilar(pairs(5, 2, [1, 5, 3, 4, 2]), 3);
  });
    it('t17', function(){
    Test.assertSimilar(pairs(10, 1, [363374326 364147530, 61825163, 1073065718, 1281246024, 1399469912, 428047635, 491595254, 879792181, 1069262793]), 0);
  });
});

IntVector

#include <stdlib.h>

typedef struct IntVector {
  int *data;
} IntVector;

static void IntVector_construct(IntVector *this, size_t size) {
  this->data = calloc(sizeof(*this->data), size);
}

static void IntVector_destruct(IntVector *this) {
  free(this->data);
}

static int IntVector_get(const IntVector *this, size_t index) {
  return this->data[index];
}

static void IntVector_set(const IntVector *this, size_t index, int value) {
  return this->data[index] = value;
}

#include <criterion/criterion.h>
#include "/home/codewarrior/solution.txt"

typedef struct IntVector IntVector;

Test(type_IntVector, should_be_implemented) {
  IntVector v;
  IntVector_construct(&v, 2);
  cr_assert_eq(IntVector_get(&v, 0), 0);
  cr_assert_eq(IntVector_get(&v, 1), 0);
  IntVector_set(&v, 0, 1);
  IntVector_set(&v, 1, 2);
  cr_assert_eq(IntVector_get(&v, 0), 1);
  cr_assert_eq(IntVector_get(&v, 1), 2);
  IntVector_destruct(&v);
}

Recent Moves:

Unnamed

IntVector

#include <stdlib.h>

typedef struct IntVector {
  int *data;
} IntVector;

IntVector *IntVector_new(size_t size) {
  IntVector *this = malloc(sizeof(IntVector));
  this->data = calloc(sizeof(*this->data), size);
  return this;
}

void IntVector_free(IntVector *this) {
  free(this->data);
  free(this);
}

int IntVector_get(const IntVector *this, size_t index) {
  return this->data[index];
}

void IntVector_set(IntVector *this, size_t index, int value) {
  return this->data[index] = value;
}
#include <criterion/criterion.h>

typedef struct IntVector IntVector;

Test(type_IntVector, should_be_implemented) {
  IntVector *v = IntVector_new(2);
  cr_assert_eq(IntVector_get(v, 0), 0);
  cr_assert_eq(IntVector_get(v, 1), 0);
  IntVector_set(v, 0, 1);
  IntVector_set(v, 1, 2);
  cr_assert_eq(IntVector_get(v, 0), 1);
  cr_assert_eq(IntVector_get(v, 1), 2);
  IntVector_free(v);
}

KenKamauvs. KenKamau

Haskell allEqual function

Algorithms

module AllEqual where

allEqual :: [Int] -> Bool
allEqual = and . (zipWith (==) <*> tail)

1 1 module AllEqual where
2 2
3 3 allEqual :: [Int] -> Bool
4 - allEqual = all =<< (==) . head
4 + allEqual = and . (zipWith (==) <*> tail)

Recent Moves:

KenKamauvs. rampion

Haskell allEqual function

Algorithms

module AllEqual where

allEqual :: [Int] -> Bool
allEqual = all =<< (==) . head

1 1 module AllEqual where
2 2
3 3 allEqual :: [Int] -> Bool
4 - allEqual [] = True
5 - allEqual (x:xs) = all (== x) xs
4 + allEqual = all =<< (==) . head

rampionvs. indegro

Haskell allEqual function

Algorithms

Using all to communicate semantics

module AllEqual where

allEqual :: [Int] -> Bool
allEqual []     = True
allEqual (x:xs) = all (== x) xs

module AllEqualSpec where
import Test.Hspec
import AllEqual

spec =
  describe "All Equal" $ do
    it "Basic tests" $ do      
      allEqual [1,2,3,4] `shouldBe` False
      allEqual [1,1,1,1] `shouldBe` True
      allEqual [] `shouldBe` True
      allEqual [1] `shouldBe` True

indegrovs. Rainbacon

Haskell allEqual function

Algorithms

All equal is a property of a whole list. One of possile ways is to use folds that are more natual way to cacluate/check value/property on a foldable structures.

Also algorithm has O(n) complexity

module AllEqual where

import Data.Foldable(foldl')

allEqual :: [Int] -> Bool
allEqual []     = True
allEqual (x:xs) = foldl' (\b a -> b && (a==x)) True xs

KenKamauvs. Rainbacon

Haskell allEqual function

Algorithms

Data.Set is better. It's safer than head/tail and faster than nub (O(n^2)). For instance, size is O(1) and fromList is O(n*log n).

module AllEqual where
import Data.Set (fromList, size)

allEqual :: [Int] -> Bool 
allEqual xs = (size $ fromList xs) <= 1

1 1 module AllEqual where
2 - import Data.List
2 + import Data.Set (fromList, size)
3 3
4 4 allEqual :: [Int] -> Bool
5 - allEqual xs = length (nub xs) <= 1
5 + allEqual xs = (size $ fromList xs) <= 1

e.mihaylinvs. LukeyLuke

LukeyLuke's Kumite #3

String.prototype.toBase64 = function () {
  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
  let result = '';
  let i = 0;
  while (i < this.length) {
    let a = this.charCodeAt(i++) || 0;
    let b = this.charCodeAt(i++) || 0;
    let c = this.charCodeAt(i++) || 0;

    let b1 = (a >> 2) & 0x3F;
    let b2 = ((a & 0x3) << 4) | ((b >> 4) & 0xF);
    let b3 = ((b & 0xF) << 2) | ((c >> 6) & 0x3);
    let b4 = c & 0x3F;

    if (!b) b3 = b4 = 64;
    else if (!c) b4 = 64;
    
    result += characters.charAt(b1) + 
              characters.charAt(b2) + 
              characters.charAt(b3) +
              characters.charAt(b4);
  }
  return result;
}

const hexToBase64 = hex => 
  hex
    .match(/.{1,2}/g)
    .map(v => String.fromCharCode(parseInt(v, 16)))
    .join``
    .toBase64();

Recent Moves:

LukeyLukeFailed Tests

LukeyLuke's Kumite #3

Set 1 Challenge 1 for the cryptopal crypto challenges (https://cryptopals.com/sets/1/challenges/1).

Convert hex to base64

function hexToBase64(hex) {
  return hex;
}

// 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(hexToBase64(
      '49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d'),
      'SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t', 'Sample test provied');
  });
});

jiegilletvs. setupminimal

Combinations

This one should be faster since we only compute 2 products of less numbers.

module NCR where

--Combinations nCr
comb:: Integer -> Integer -> Integer
comb n r = product [n-r+1..n] `div` product [2..r]

Recent Moves:

setupminimalvs. j.hn

Combinations

Just used the builtin function product to make things a bit nicer.

module NCR where

--Combinations nCr
comb:: Integer -> Integer -> Integer
comb n r = factorial n `div` (factorial r * factorial (n-r))
  where
  factorial n = product [1 .. n]

module NCR.TestSpec where

import NCR

import Test.Hspec
import Test.QuickCheck

main = hspec spec

spec = do
  describe "test for nCr" $ do
    it "test nCr" $ do
      comb 3 2 `shouldBe` 3  
      comb 100 3 `shouldBe` 161700
      comb 1000 10 `shouldBe` 263409560461970212832400

j.hnvs. brander

Combinations

module NCR where

--Combinations nCr
comb:: Integer -> Integer -> Integer
comb n r = factorial n `div` (factorial r * factorial (n-r))
  where
  factorial n = foldr (*) 1 [2..n]

brandervs. brander

Combinations

module NCR where

--Combinations nCr
comb:: Integer -> Integer -> Integer
comb n r | n/=r = (factorial n) `div` (factorial r * factorial (n-r) )
         | n==r = (factorial n) `div` (factorial r)
         
factorial n= foldl (*) 1 [1..n]

brander

Combinations

Calculated the combinations https://en.wikipedia.org/wiki/Combination

module NCR where

--Combinations nCr
comb:: Integer -> Integer -> Integer
comb n r | n/=r = (foldl (*) 1 [1..n]) `div` ((foldl  (*) 1 [1..r]) * (foldl (*) 1 [1..(n-r)]))
         | n==r = (foldl (*) 1 [1..n]) `div` ((foldl  (*) 1 [1..r]))

module NCR.Test where

import NCR

import Test.Hspec
import Test.QuickCheck

main = hspec $ do
  describe "test for nCr" $ do
    it "test nCr" $ do
      comb 3 2 `shouldBe` 3  
      comb 100 3 `shouldBe` 161700
      comb 1000 10 `shouldBe` 263409560461970212832400

donaldsebleungvs. donaldsebleung

Map/Dictionary/Associative Array as a binary search tree of entries

Data Structures

Algorithms

Binary Search Trees

Trees

Binary

Maps

Map/Dictionary/Associative Array as a binary search tree of entries

Suggested reading: Binary Search Tree - Wikipedia

Last time we saw how the map/dictionary/assoc array datatype can be implemented as a linked list of entries. We also noted how this implementation is seldomly used in real-world applications due to its sheer inefficiency for pretty much every operation.

So is there a way to make this data type more efficient? As it turns out, using a different data structure can really make an impact on the runtime complexity of operations on maps. One particular data structure that suits maps pretty well is the binary search tree (BST). A binary search tree is a special case of a binary tree where when one traverses its elements pre-order (left -> value -> right), the sequence of elements are in order. When the BST is perfectly balanced (i.e. all its branches have the same depth), its insertion, lookup and deletion operations are all logarithmic in time (O(log n)) because for every level you advance through the tree, you can effectively discard half of the tree. Another advantage of using a BST in our map is that we can implement a function converting the map into an iterator (if we wish to iterate through our key-value pairs in the map) such that the sequence of elements in the iterator are guaranteed to arrive in-order. However, the major drawback of (ordinary) BSTs is that if the elements are inserted in-order (or in reversed order), it degenerates into a linked list so its operations become O(n) again. Furthermore, if one inserts elements randomly into a BST, its operations converge towards an O(sqrt n) time complexity which is significantly less efficient than O(log n).

If only there were a way to ensure that our BST is sufficiently balanced at all times ... ;)

#include <stddef.h>

typedef struct {
  // Denotes a key-value pair of integers, e.g. 7 => 34
  int key, value;
} Entry;

typedef struct node_t {
  // A node of a binary (search) tree - the internal implementation of our map
  Entry *entry;
  struct node_t *left, *right;
} Node;

typedef struct {
  // Our map datatype, implemented as a simple wrapper around our BST
  // This allows us to insert elements to a map by object reference and
  // reserves NULL for indicating an invalid reference to a Map (instead
  // of an empty map)
  Node *root;
} Map;

int map_get(const Map *map, int key) {
  // Retrieves the corresponding value for a given key in a map
  // Assumption: The given key-value pair in the map exists
  const Node *nd = map->root;
  while (nd->entry->key != key)
    nd = key < nd->entry->key ? nd->left : nd->right;
  return nd->entry->value;
}

void map_set(Map *map, int key, int value) {
  // Adds the key-value pair to the map if no entry with the given key exists;
  // otherwise modifies the value of the entry with the given key to the given value
  if (map->root == NULL) {
    map->root = malloc(sizeof(Node));
    map->root->entry = malloc(sizeof(Entry));
    map->root->entry->key = key;
    map->root->entry->value = value;
    map->root->left = map->root->right = NULL;
  } else {
    Node *nd = map->root;
    while (nd->entry->key != key) {
      const Node *tmp = key < nd->entry->key ? nd->left : nd->right;
      if (tmp == NULL)
        break;
      nd = tmp;
    }
    if (nd->entry->key == key)
      nd->entry->value = value;
    else if (key < nd->entry->key) {
      nd->left = malloc(sizeof(Node));
      nd->left->entry = malloc(sizeof(Entry));
      nd->left->entry->key = key;
      nd->left->entry->value = value;
      nd->left->left = nd->left->right = NULL;
    } else {
      nd->right = malloc(sizeof(Node));
      nd->right->entry = malloc(sizeof(Entry));
      nd->right->entry->key = key;
      nd->right->entry->value = value;
      nd->right->left = nd->right->right = NULL;
    }
  }
}

void map_remove(Map *map, int key) {
  // Removes the key-value entry from the map with the given key
  // Assumption: The key-value pair in the map exists
  if (map->root->entry->key == key) {
    if (map->root->right == NULL) {
      Node *tmp = map->root->left;
      free(map->root->entry);
      free(map->root);
      map->root = tmp;
    } else if (map->root->left == NULL) {
      Node *tmp = map->root->right;
      free(map->root->entry);
      free(map->root);
      map->root = tmp;
    } else if (rand() % 2) {
      Node *parent = map->root, *child = parent->left;
      while (child->right != NULL) {
        parent = child;
        child = child->right;
      }
      if (parent->left == child)
        parent->left = child->left;
      else
        parent->right = child->left;
      map->root->entry->key = child->entry->key;
      map->root->entry->value = child->entry->value;
      free(child->entry);
      free(child);
    } else {
      Node *parent = map->root, *child = parent->right;
      while (child->left != NULL) {
        parent = child;
        child = child->left;
      }
      if (parent->left == child)
        parent->left = child->right;
      else
        parent->right = child->right;
      map->root->entry->key = child->entry->key;
      map->root->entry->value = child->entry->value;
      free(child->entry);
      free(child);
    }
  } else {
    Node *nd_parent = map->root, *nd = key < nd_parent->entry->key ? nd_parent->left : nd_parent->right;
    while (nd->entry->key != key) {
      nd_parent = nd;
      nd = key < nd->entry->key ? nd->left : nd->right;
    }
    if (nd->right == NULL) {
      if (nd_parent->left == nd)
        nd_parent->left = nd->left;
      else
        nd_parent->right = nd->left;
      free(nd->entry);
      free(nd);
    } else if (nd->left == NULL) {
      if (nd_parent->left == nd)
        nd_parent->left = nd->right;
      else
        nd_parent->right = nd->right;
      free(nd->entry);
      free(nd);
    } else if (rand() % 2) {
      Node *parent = nd, *child = parent->left;
      while (child->right != NULL) {
        parent = child;
        child = child->right;
      }
      if (parent->left == child)
        parent->left = child->left;
      else
        parent->right = child->left;
      nd->entry->key = child->entry->key;
      nd->entry->value = child->entry->value;
      free(child->entry);
      free(child);
    } else {
      Node *parent = nd, *child = parent->right;
      while (child->left != NULL) {
        parent = child;
        child = child->left;
      }
      if (parent->left == child)
        parent->left = child->right;
      else
        parent->right = child->right;
      nd->entry->key = child->entry->key;
      nd->entry->value = child->entry->value;
      free(child->entry);
      free(child);
    }
  }
}

#include <criterion/criterion.h>

typedef struct {
  // Denotes a key-value pair of integers, e.g. 7 => 34
  int key, value;
} Entry;

typedef struct node_t {
  // A node of a binary (search) tree - the internal implementation of our map
  Entry *entry;
  struct node_t *left, *right;
} Node;

typedef struct {
  // Our map datatype, implemented as a simple wrapper around our BST
  // This allows us to insert elements to a map by object reference and
  // reserves NULL for indicating an invalid reference to a Map (instead
  // of an empty map)
  Node *root;
} Map;

static void print_tree_pre_order(const Node *nd) {
  // Prints the key-value entries in the tree recursively in pre-order fashion
  if (nd != NULL) {
    print_tree_pre_order(nd->left);
    printf("%d => %d\n", nd->entry->key, nd->entry->value);
    print_tree_pre_order(nd->right);
  }
}

static void print_map(const Map *map) {
  // Prints each entry in the map by traversing the tree pre-order
  // If the tree within the map is a valid BST then the keys should
  // appear in order
  print_tree_pre_order(map->root);
}

static void print_tree_in_order(const Node *nd) {
  // Prints the key-value pairs of the tree recursively in-order
  if (nd != NULL) {
    printf("%d => %d\n", nd->entry->key, nd->entry->value);
    print_tree_in_order(nd->left);
    print_tree_in_order(nd->right);
  }
}

static void print_map_in_order(const Map *map) {
  // Prints each entry in the map by traversing the underlying tree in-order
  // This reveals a bit more about the actual structure of the BST maintained
  // within the map
  print_tree_in_order(map->root);
}

static void free_tree(Node *nd) {
  if (nd != NULL) {
    free_tree(nd->left);
    free_tree(nd->right);
    free(nd->entry);
    free(nd);
  }
}

static int tree_size(Node *nd) {
  return nd == NULL ? 0 : 1 + tree_size(nd->left) + tree_size(nd->right);
}

Map *map;

Test(Map, should_have_a_functioning_get_operation) {
  // Example map:
  // {
  //   1 => 13,
  //   2 => 22,
  //   3 => -1,
  //   4 => 5,
  //   5 => 4,
  //   6 => 676,
  //   7 => -102
  // }
  
  // The internal BST of the map is structured as follows (keys shown only for simplicity):
  //       4
  //      / \
  //     /   \
  //    /     \
  //   2       6
  //  / \     / \
  // 1   3   5   7
  map = &((Map){
    .root = &((Node){
      .left = &((Node){
        .left = &((Node){
          .left = NULL,
          .entry = &((Entry){
            .key = 1,
            .value = 13
          }),
          .right = NULL
        }),
        .entry = &((Entry){
          .key = 2,
          .value = 22
        }),
        .right = &((Node){
          .left = NULL,
          .entry = &((Entry){
            .key = 3,
            .value = -1
          }),
          .right = NULL
        })
      }),
      .entry = &((Entry){
        .key = 4,
        .value = 5
      }),
      .right = &((Node){
        .left = &((Node){
          .left = NULL,
          .entry = &((Entry){
            .key = 5,
            .value = 4
          }),
          .right = NULL
        }),
        .entry = &((Entry){
          .key = 6,
          .value = 676
        }),
        .right = &((Node){
          .left = NULL,
          .entry = &((Entry){
            .key = 7,
            .value = -102
          }),
          .right = NULL
        })
      })
    })
  });
  
  printf("Our map has the following key-value pairs:\n\n");
  print_map(map);
  printf("\nIf we traverse its entries in-order, our map looks like this instead:\n\n");
  print_map_in_order(map);
  
  cr_assert_eq(map_get(map, 1), 13);
  cr_assert_eq(map_get(map, 2), 22);
  cr_assert_eq(map_get(map, 3), -1);
  cr_assert_eq(map_get(map, 4), 5);
  cr_assert_eq(map_get(map, 5), 4);
  cr_assert_eq(map_get(map, 6), 676);
  cr_assert_eq(map_get(map, 7), -102);
}

Test(Map, should_have_a_functioning_set_operation) {
  map = malloc(sizeof(Map));
  map->root = NULL; // Empty map
  
  // Optimal insertion order
  
  map_set(map, 4, 5);
  printf("Current state of map:\n\n");
  print_map(map);
  printf("\nUsing in-order traversal:\n\n");
  print_map_in_order(map);
  cr_assert_eq(map_get(map, 4), 5);
  
  map_set(map, 2, 22);
  printf("Current state of map:\n\n");
  print_map(map);
  printf("\nUsing in-order traversal:\n\n");
  print_map_in_order(map);
  cr_assert_eq(map_get(map, 2), 22);
  cr_assert_eq(map_get(map, 4), 5);
  
  map_set(map, 3, -1);
  printf("Current state of map:\n\n");
  print_map(map);
  printf("\nUsing in-order traversal:\n\n");
  print_map_in_order(map);
  cr_assert_eq(map_get(map, 2), 22);
  cr_assert_eq(map_get(map, 3), -1);
  cr_assert_eq(map_get(map, 4), 5);
  
  map_set(map, 6, 676);
  printf("Current state of map:\n\n");
  print_map(map);
  printf("\nUsing in-order traversal:\n\n");
  print_map_in_order(map);
  cr_assert_eq(map_get(map, 2), 22);
  cr_assert_eq(map_get(map, 3), -1);
  cr_assert_eq(map_get(map, 4), 5);
  cr_assert_eq(map_get(map, 6), 676);
  
  map_set(map, 1, 13);
  printf("Current state of map:\n\n");
  print_map(map);
  printf("\nUsing in-order traversal:\n\n");
  print_map_in_order(map);
  cr_assert_eq(map_get(map, 1), 13);
  cr_assert_eq(map_get(map, 2), 22);
  cr_assert_eq(map_get(map, 3), -1);
  cr_assert_eq(map_get(map, 4), 5);
  cr_assert_eq(map_get(map, 6), 676);
  
  map_set(map, 5, 4);
  printf("Current state of map:\n\n");
  print_map(map);
  printf("\nUsing in-order traversal:\n\n");
  print_map_in_order(map);
  cr_assert_eq(map_get(map, 1), 13);
  cr_assert_eq(map_get(map, 2), 22);
  cr_assert_eq(map_get(map, 3), -1);
  cr_assert_eq(map_get(map, 4), 5);
  cr_assert_eq(map_get(map, 5), 4);
  cr_assert_eq(map_get(map, 6), 676);
  
  map_set(map, 7, -102);
  printf("Current state of map:\n\n");
  print_map(map);
  printf("\nUsing in-order traversal:\n\n");
  print_map_in_order(map);
  cr_assert_eq(map_get(map, 1), 13);
  cr_assert_eq(map_get(map, 2), 22);
  cr_assert_eq(map_get(map, 3), -1);
  cr_assert_eq(map_get(map, 4), 5);
  cr_assert_eq(map_get(map, 5), 4);
  cr_assert_eq(map_get(map, 6), 676);
  cr_assert_eq(map_get(map, 7), -102);
  
  // Reassigning values to existing key-value pairs
  
  map_set(map, 3, 8);
  printf("Current state of map:\n\n");
  print_map(map);
  printf("\nUsing in-order traversal:\n\n");
  print_map_in_order(map);
  cr_assert_eq(map_get(map, 1), 13);
  cr_assert_eq(map_get(map, 2), 22);
  cr_assert_eq(map_get(map, 3), 8);
  cr_assert_eq(map_get(map, 4), 5);
  cr_assert_eq(map_get(map, 5), 4);
  cr_assert_eq(map_get(map, 6), 676);
  cr_assert_eq(map_get(map, 7), -102);
  
  map_set(map, 6, -23);
  printf("Current state of map:\n\n");
  print_map(map);
  printf("\nUsing in-order traversal:\n\n");
  print_map_in_order(map);
  cr_assert_eq(map_get(map, 1), 13);
  cr_assert_eq(map_get(map, 2), 22);
  cr_assert_eq(map_get(map, 3), 8);
  cr_assert_eq(map_get(map, 4), 5);
  cr_assert_eq(map_get(map, 5), 4);
  cr_assert_eq(map_get(map, 6), -23);
  cr_assert_eq(map_get(map, 7), -102);
  
  map_set(map, 4, 0);
  printf("Current state of map:\n\n");
  print_map(map);
  printf("\nUsing in-order traversal:\n\n");
  print_map_in_order(map);
  cr_assert_eq(map_get(map, 1), 13);
  cr_assert_eq(map_get(map, 2), 22);
  cr_assert_eq(map_get(map, 3), 8);
  cr_assert_eq(map_get(map, 4), 0);
  cr_assert_eq(map_get(map, 5), 4);
  cr_assert_eq(map_get(map, 6), -23);
  cr_assert_eq(map_get(map, 7), -102);
  
  free_tree(map->root);
  free(map);
}

Test(Map, should_have_a_functioning_remove_operation) {
  srand(time(NULL));
  map = malloc(sizeof(Map));
  map->root = NULL;
  
  map_set(map, 4, 7);
  map_set(map, 6, 14);
  map_set(map, 7, 21);
  map_set(map, 2, 28);
  map_set(map, 5, 35);
  map_set(map, 1, 42);
  map_set(map, 3, 49);
  printf("\nCurrent state of map:\n\n");
  print_map(map);
  cr_assert_eq(tree_size(map->root), 7);
  cr_assert_eq(map_get(map, 1), 42);
  cr_assert_eq(map_get(map, 2), 28);
  cr_assert_eq(map_get(map, 3), 49);
  cr_assert_eq(map_get(map, 4), 7);
  cr_assert_eq(map_get(map, 5), 35);
  cr_assert_eq(map_get(map, 6), 14);
  cr_assert_eq(map_get(map, 7), 21);
  
  map_remove(map, 5); // Deleting a node with no children
  printf("\nCurrent state of map:\n\n");
  print_map(map);
  cr_assert_eq(tree_size(map->root), 6);
  cr_assert_eq(map_get(map, 1), 42);
  cr_assert_eq(map_get(map, 2), 28);
  cr_assert_eq(map_get(map, 3), 49);
  cr_assert_eq(map_get(map, 4), 7);
  cr_assert_eq(map_get(map, 6), 14);
  cr_assert_eq(map_get(map, 7), 21);
  
  map_remove(map, 6); // Deleting a node with one child
  printf("\nCurrent state of map:\n\n");
  print_map(map);
  cr_assert_eq(tree_size(map->root), 5);
  cr_assert_eq(map_get(map, 1), 42);
  cr_assert_eq(map_get(map, 2), 28);
  cr_assert_eq(map_get(map, 3), 49);
  cr_assert_eq(map_get(map, 4), 7);
  cr_assert_eq(map_get(map, 7), 21);
  
  map_remove(map, 2); // Delete a node with two children
  printf("\nCurrent state of map:\n\n");
  print_map(map);
  cr_assert_eq(tree_size(map->root), 4);
  cr_assert_eq(map_get(map, 1), 42);
  cr_assert_eq(map_get(map, 3), 49);
  cr_assert_eq(map_get(map, 4), 7);
  cr_assert_eq(map_get(map, 7), 21);
  
  map_remove(map, 4);
  printf("\nCurrent state of map:\n\n");
  print_map(map);
  cr_assert_eq(tree_size(map->root), 3);
  cr_assert_eq(map_get(map, 1), 42);
  cr_assert_eq(map_get(map, 3), 49);
  cr_assert_eq(map_get(map, 7), 21);
  
  map_remove(map, 1);
  printf("\nCurrent state of map:\n\n");
  print_map(map);
  cr_assert_eq(tree_size(map->root), 2);
  cr_assert_eq(map_get(map, 3), 49);
  cr_assert_eq(map_get(map, 7), 21);
  
  map_remove(map, 3);
  printf("\nCurrent state of map:\n\n");
  print_map(map);
  cr_assert_eq(tree_size(map->root), 1);
  cr_assert_eq(map_get(map, 7), 21);
  
  map_remove(map, 7);
  printf("\nCurrent state of map:\n\n");
  print_map(map);
  cr_assert_eq(map->root, NULL);
  
  free_tree(map->root);
  free(map);
}

Recent Moves:

Map/Dictionary/Associative Array as a linked list of entries

Data Structures

Algorithms

Linked Lists

Lists

Maps

Map/Dictionary/Associative Array as a linked list of entries

Related article: Associative Array - Wikipedia

Many modern and/or popular programming languages such as Python, Java and C++ (and even some not-so-modern and/or popular languages such as Objective-C) provide a built-in datatype (either natively or in a built-in library) which maintains association between keys and values, commonly known as a map/dictionary and sometimes less known as an associative array (in languages such as PHP). However, for simpler and/or older languages such as C, such convenient data types do not exist. So, is it possible to define your own map/dictionary/assoc-array datatype in such languages? Of course - it all just boils down to data structures and algorithms (and perhaps some simple wrappers to hide your implementation from the user). Perhaps the easiest way to implement your own map data type is by using a linked list of key-value entries which will be demonstrated in this Kumite but the downside is that pretty much every operation you perform on your map (be it insertion, query or deletion) will have O(n) time complexity, i.e. the time taken to execute the operation varies directly with the number of entries in the map. The related Wikipedia article (link posted above) says that insertion should be an O(1) operation (since you could insert the key-value pair at the head of the list) but only if it is assumed that the key does not already exist in the map; otherwise, problems may arise if one attempts to iterate through the map.

This map implementation is seldomly used in real-world applications (and not even provided in built-in libraries of languages such as Java) due to its inefficiency and is only considered if the map is expected to be very small.

#include <stddef.h>

typedef struct {
  // A key-value pair of integers
  int key, value;
} Entry;

typedef struct node_t {
  // A node in a linked list - internal implementation of a Map
  Entry *entry; // The current entry in our map
  struct node_t *next; // The rest of our map
} Node;

typedef struct {
  // Outer map wrapper (to hide interal implementation and
  // reserve `NULL` for representing an invalid map reference instead of an empty map)
  Node *root;
} Map;

int map_get(const Map *map, int key) {
  // Returns the corresponding value to the key in the map
  // Assumption: the key is present in the map
  // (querying a nonexistent key yields undefined behavior)
  const Node *n = map->root;
  while (n->entry->key != key)
    n = n->next;
  return n->entry->value;
}

void map_set(Map *map, int key, int value) {
  // Adds the key-value pair to the map if not present;
  // otherwise reassigns it at the corresponding entry
  Node *n = map->root;
  while (n != NULL && n->entry->key != key)
    n = n->next;
  if (n != NULL)
    n->entry->value = value;
  else {
    Node *tmp = map->root;
    map->root = malloc(sizeof(Node));
    map->root->entry = malloc(sizeof(Entry));
    map->root->entry->key = key;
    map->root->entry->value = value;
    map->root->next = tmp;
  }
}

void map_remove(Map *map, int key) {
  // Removes an entry from the map with the given key
  // Assumption: The given key-value pair exists
  // (attempting to delete a nonexistent entry yields undefined behavior)
  // This also implies that the map cannot be empty
  if (map->root->entry->key == key) {
    Node *tmp = map->root->next;
    free(map->root->entry);
    free(map->root);
    map->root = tmp;
  } else {
    Node *parent = map->root, *child = parent->next;
    while (child->next != NULL && child->entry->key != key) {
      parent = child;
      child = child->next;
    }
    parent->next = child->next;
    free(child->entry);
    free(child);
  }
}

#include <criterion/criterion.h>

typedef struct {
  // A key-value pair of integers
  int key, value;
} Entry;

typedef struct node_t {
  // A node in a linked list - internal implementation of a Map
  Entry *entry; // The current entry in our map
  struct node_t *next; // The rest of our map
} Node;

typedef struct {
  // Outer map wrapper (to hide interal implementation and
  // reserve `NULL` for representing an invalid map reference instead of an empty map)
  Node *root;
} Map;

int map_get(const Map *map, int key);
void map_set(Map *map, int key, int value);
void map_remove(Map *map, int key);

Map *m;

Test(the_map_datatype, should_allow_querying_by_integer_key) {
  // Map { 5 => 373, 12 => 23, -3 => 133 }
  m = &((Map){
    .root = &((Node){
      .entry = &((Entry){
        .key = 5,
        .value = 373
      }),
      .next = &((Node){
        .entry = &((Entry){
          .key = 12,
          .value = 23
        }),
        .next = &((Node){
          .entry = &((Entry){
            .key = -3,
            .value = 133
          }),
          .next = NULL
        })
      })
    })
  });
  cr_assert_eq(map_get(m, 12), 23);
  cr_assert_eq(map_get(m, -3), 133);
  cr_assert_eq(map_get(m, 5), 373);
  cr_assert_eq(map_get(m, -3), 133, "A key-value pair should be able to be queried more than once");
}
Test(the_map_datatype, should_allow_us_to_set_key_value_pairs) {
  m = malloc(sizeof(Map));
  m->root = NULL; // `m` is now a properly initialized empty map
  map_set(m, 3, 5);
  cr_assert_eq(map_get(m, 3), 5);
  map_set(m, 2, 7);
  cr_assert_eq(map_get(m, 2), 7);
  map_set(m, -1, -1);
  cr_assert_eq(map_get(m, -1), -1);
  map_set(m, 10, -187);
  cr_assert_eq(map_get(m, 10), -187);
  map_set(m, 3, 663);
  cr_assert_eq(map_get(m, 3), 663);
  map_set(m, 10, 2);
  cr_assert_eq(map_get(m, 10), 2);
  Node *n = m->root;
  size_t size = 0;
  while (n != NULL) {
    size++;
    n = n->next;
  }
  cr_assert_eq(size, 4, "The map should contain 4 elements at this point");
  cr_assert_neq(size, 6, "The map should not contain 6 elements at this point");
  n = m->root;
  while (n != NULL) {
    Node *tmp = n->next;
    free(n->entry);
    free(n);
    n = tmp;
  }
  free(m);
}
Test(the_map_datatype, should_allow_us_to_remove_elements_from_it) {
  m = malloc(sizeof(Map));
  m->root = NULL;
  map_set(m, 3, 5);
  map_set(m, 2, 7);
  map_set(m, -1, -1);
  map_set(m, 10, -187);
  map_set(m, 3, 663);
  map_set(m, 10, 2);
  cr_assert_eq(map_get(m, 3), 663);
  cr_assert_eq(map_get(m, 2), 7);
  cr_assert_eq(map_get(m, -1), -1);
  cr_assert_eq(map_get(m, 10), 2);
  map_remove(m, -1);
  cr_assert_eq(map_get(m, 3), 663);
  cr_assert_eq(map_get(m, 2), 7);
  cr_assert_eq(map_get(m, 10), 2);
  Node *n = m->root;
  size_t size = 0;
  while (n != NULL) {
    size++;
    n = n->next;
  }
  cr_assert_eq(size, 3, "The map should contain 3 elements at this point");
  map_remove(m, 2);
  cr_assert_eq(map_get(m, 3), 663);
  cr_assert_eq(map_get(m, 10), 2);
  n = m->root;
  size = 0;
  while (n != NULL) {
    size++;
    n = n->next;
  }
  cr_assert_eq(size, 2, "The map should contain 2 elements at this point");
  map_remove(m, 10);
  cr_assert_eq(map_get(m, 3), 663);
  n = m->root;
  size = 0;
  while (n != NULL) {
    size++;
    n = n->next;
  }
  cr_assert_eq(size, 1, "The map should contain 1 element at this point");
  map_remove(m, 3);
  cr_assert_eq(m->root, NULL, "The map should be empty at this point");
  free(m);
}

Unnamed

Foldable ((,) a) -- what did they smoke?

TIL that

instance Foldable ((,) a) where
    foldMap f (_, y) = f y
    foldr f z (_, y) = f y z

module FoldableTuple2 where
-- see the tests

module FoldableTuple2Spec where

import Test.Hspec
import Test.QuickCheck

spec :: Spec
spec = do
  describe "(,) a" $ do
    it "can be used with `length`" $
      property $ \x -> length (x :: (Int, String)) `shouldBe` 1
    it "can be used with `concat`" $
      property $ \x -> concat (x :: (Int, String)) `shouldBe` snd x

doomsbyvs. LukeyLuke

LukeyLuke's Kumite #2

function throttle(wait, onLast, onFirst, interval, timestamps) {
  ret = [];
  if(onFirst) {
    ret.push(timestamps[0]); // account for first element
  }
  let clusterStart = timestamps[0];
  
  for(let i=1; i<timestamps.length; i++) {
    if(timestamps[i] - timestamps[i-1] > wait) { // 2.) new cluster
      clusterStart = timestamps[i];
      if(onFirst) {
        ret.push(clusterStart); // push cluster start
      }
    }
    if(interval !=0 && (timestamps[i+1] - timestamps[i] > wait || i == timestamps.length-1)) { // 1.) do interval shit
      let intervalVal = clusterStart + interval;
      let loopInvariant = timestamps[i-1];
      if(i == timestamps.length-1){
        loopInvariant = timestamps[i];
      }
      if(onLast) {
        loopInvariant += wait;
      }
  
      console.log('intervalVal: ' + intervalVal);
      console.log('loopInvariant: ' + loopInvariant);
      while(intervalVal <= loopInvariant) {
        console.log('pushing intervalVal: ' + intervalVal);
        ret.push(intervalVal);
        intervalVal += interval;
      }
    }
      
    if(timestamps[i+1] - timestamps[i] > wait) { // 2.) new cluster
      if(onLast) {
        ret.push(timestamps[i] + wait); // push cluster end
      }
    }
    
    if(i == timestamps.length-1 && onLast && interval == 0) { // 3.) Account for last element (needs updating)
      ret.push(timestamps[i] + wait);
    }
  }
  
  return ret;
}

Recent Moves:

LukeyLuke

LukeyLuke's Kumite #2

Some user interactions, such as resizing and scrolling, can create a huge number of browser events in a short period of time. If listeners attached to these events take a long time to execute, the user's browser can start to slow down significantly. To mitigate this issue, we want to to implement a throttle function that will detect clusters of events and reduce the number of times we call an expensive function.

Your function will accept an array representing a stream of event timestamps and return an array representing the times that a callback should have been called. If an event happens within wait time of the previous event, it is part of the same cluster. Your function should satisfy the following use cases:

1) Firing once on the first event in a cluster, e.g. as soon as the window starts resizing.
2) Firing once after the last event in a cluster, e.g. after the user window stops resizing.
3) Firing every interval milliseconds during a cluster, e.g. every 100ms while the window is resizing.

function throttle(wait, onLast, onFirst, interval, timestamps) {
  let ret = [];
  let cluster = [timestamps[0]];
  
  for(let i=1; i<timestamps.length; i++) {
    if(timestamps[i] - timestamps[i-1] <= wait) {
      cluster.push(timestamps[i]);
    } else {
      let clusterEventTimes = evaluateCluster(wait, onLast, onFirst, interval, cluster);
      clusterEventTimes.forEach( function(el){ ret.push(el); });
      cluster = [timestamps[i]];
    }
    
    if(i == timestamps.length-1) {
      let clusterEventTimes = evaluateCluster(wait, onLast, onFirst, interval, cluster);
      clusterEventTimes.forEach( function(el){ ret.push(el); });
    }
  }
  
  return ret;
}

// Determines all times when an event needs to be fired
function evaluateCluster(wait, onLast, onFirst, interval, cluster){
  let ret = [];
  
  if(onFirst) {
    ret.push(cluster[0]); // push cluster start
  }
  if(interval != 0) {
    let maxInterval = cluster[cluster.length-1];
    if(onLast) {
      maxInterval += wait;
    }
    for(let intEv = cluster[0]+interval; intEv < maxInterval; intEv+=interval) {
      ret.push(intEv);
    }
  }
  if(onLast) {
    ret.push(cluster[cluster.length-1]+wait); // push cluster end
  }
    
  return ret;
}

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

describe('default tests', function() {
  it('test1', function(){
    Test.assertSimilar(throttle(20, false, true, 0, [0,10,20,30]), [0]);
  });
  it('test2', function(){
    Test.assertSimilar(throttle(20, true, false, 0, [0,10,20,30]), [50]);
  });
  it('test3', function(){
    Test.assertSimilar(throttle(20, false, true, 20, [0,10,20,30]), [0,20]);
  });
  it('test4', function(){
    Test.assertSimilar(throttle(20, false, true, 0, [0,10,40]), [0,40]);
  });
  it('test5', function(){
    Test.assertSimilar(throttle(20, true, false, 0, [0,10,40]), [30,60]);
  });
  it('test6', function(){
    Test.assertSimilar(throttle(20, true, true, 0, [0,10,50]), [0,30,50,70]);
  });
  it('test7', function(){
    Test.assertSimilar(throttle(20, true, true, 10, [0,10,50]), [0,10,20,30,50,60,70]);
  });
});

Unnamedvs. UnnamedFailed Tests

Interleaved output in C tests

It should be as easy as this?

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

Test(the_multiply_function, should_pass_all_the_tests_provided) {
  for (int i = 0; i < 50; i++) {
    cr_log_info("blah blah blah, i = %d\n", i);
    cr_expect_eq(1, 0);
  }
}

Recent Moves:

Unnamedvs. UnnamedFailed Tests

Interleaved output in C tests

I forgot the newlines before, but it's still quite bad.

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

Test(the_multiply_function, should_pass_all_the_tests_provided) {
  for (int i = 0; i < 50; i++) {
    puts("blah blah blah\n");
    cr_expect_eq(1, 0);
  }
}

Unnamedvs. UnnamedFailed Tests

Interleaved output in C tests

???

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

Test(the_multiply_function, should_pass_all_the_tests_provided) {
  for (int i = 0; i < 50; i++) {
    criterion_important("blah blah blah, i = %d", i);
    cr_expect_eq(1, 0);
  }
}

UnnamedFailed Tests

Interleaved output in C tests

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

Test(the_multiply_function, should_pass_all_the_tests_provided) {
  for (int i = 0; i < 50; i++) {
    puts("blah blah blah");
    cr_expect_eq(1, 0);
  }
}

easfvs. superboy

How to wrap the user function in tests, in Python

Testing

replicate in one line

def replicate(times, num):
    return [] if times <= 0 else [num] + replicate(times-1, num)
replicate(8,5)

1 1 def replicate(times, num):
2 - if times <= 0: return []
3 - return [num] + replicate(times-1, num)
2 + return [] if times <= 0 else [num] + replicate(times-1, num)
4 4 replicate(8,5)

Recent Moves:

superboyvs. mypythonyongshi

How to wrap the user function in tests, in Python

Testing

def replicate(times, num):
    if times <= 0: return []
    return [num] + replicate(times-1, num)
replicate(8,5)

1 1 def replicate(times, num):
2 2 if times <= 0: return []
3 3 return [num] + replicate(times-1, num)
4 -
5 5 replicate(8,5)

mypythonyongshivs. Bubbler

How to wrap the user function in tests, in Python

Testing

def replicate(times, num):
    if times <= 0: return []
    return [num] + replicate(times-1, num)

replicate(8,5)

1 1 def replicate(times, num):
2 2 if times <= 0: return []
3 3 return [num] + replicate(times-1, num)
4 +
5 + replicate(8,5)

Bubbler

How to wrap the user function in tests, in Python

Testing

This tries to address the problem observed in this Kata which tries to wrap the user function in the tests.

def replicate(times, num):
    if times <= 0: return []
    return [num] + replicate(times-1, num)

from solution import *

@test.describe('Replicate')
def fixture():

    def _ref(times, num):
        return [num] * times
    
    @test.it('Basic Tests')
    def basic():
        data = [(3, 5), (-1, 2), (5, 10), (0, 4)]
        for t, n in data:
            test.assert_equals(replicate(t, n), _ref(t, n))
            
    def counts(f):
        def wrapped(*args, **kwargs):
            wrapped.calls += 1
            return f(*args, **kwargs)
        wrapped.calls = 0
        return wrapped
    
    #@test.it('Recursion Tests')
    def recurse():
        import sys
        r = sys.modules['solution'].replicate = counts(sys.modules['solution'].replicate)
        data = [(3, 5), (5, 10), (-1, 2)]
        for t, n in data:
            r.calls = 0
            test.assert_equals(r(t, n), _ref(t, n))
            if t <= 0: t = 1
            test.expect(t <= r.calls <= t + 1)
            print(r.calls)
    
    #or...
    @test.it('Recursion Tests')
    def recurse2():
        import solution
        r = solution.replicate = counts(solution.replicate)
        data = [(3, 5), (5, 10), (-1, 2)]
        for t, n in data:
            r.calls = 0
            test.assert_equals(r(t, n), _ref(t, n))
            if t <= 0: t = 1
            test.expect(t <= r.calls <= t + 1)
            print(r.calls)

stJohanvs. NeonGrid

Sum of array (Basic -C#)

using System;
using System.Linq;

public static class Kata
{
  public static int ArraySum(params int[][] arrs)
  {
    return arrs.SelectMany(arr => arr).Sum();
  }
}

Recent Moves:

NeonGridvs. MohanedSaad

Sum of array (Basic -C#)

Works for unknown number of int[]

using System;
using System.Linq;

public static class Kata
{
  public static int ArraySum(params int[][] arrs)
  {
    int sum = 0;
    foreach (int[] arr in arrs)
    {
        sum += arr.Sum();
    }
    return sum;
  }
}

MohanedSaad

Sum of array (Basic -C#)

Really simple problem to work on if you have just started learing C#.

Determine the SUM of the 3 arrays and return the total in an int format.

Enjoy..

#Arrays

using System;
using System.Linq;

 public static class Kata
 {
 public static int ArraySum(int[] arr1, int[] arr2, int[] arr3)
        {
            int[] newArray1 = arr1.Concat(arr2).ToArray();
            int[] newArray2 = newArray1.Concat(arr3).ToArray(); 
            int sum = newArray2.Sum();
            return sum; 
        }
}

namespace Solution {
  using NUnit.Framework;
  using System;


  [TestFixture]
  public class SolutionTest
  {
    [Test]
    public void ArraySumBasicTest()
    {
      Assert.AreEqual(38, Kata.ArraySum(new int[]{6,2,9}, new int[]{1,5,4}, new int[]{10,1,0}));
      Assert.AreEqual(-10, Kata.ArraySum(new int[]{-8,-6,3}, new int[]{5,-11,-8}, new int[]{2,8,5}));
    }
  }
}

mateusf777vs. JoshuaCWebDeveloper

Age on mars

package kata

// CalcAgeOnMars calculates the age on Mars from on a age on Earth 
func CalcAgeOnMars(age int) int {
  return age * 365 / 687
}

package kata_test
import (
  . "github.com/onsi/ginkgo"
  . "github.com/onsi/gomega"
  . "codewarrior/kata"
)
var _ = Describe("When calculating the age in mars", func() {
  It("should result 3 martian years for 7 earth years", func() {
     Expect(CalcAgeOnMars(7)).To(Equal(3))
  })
  It("should result 10 martian years for 20 earth years", func() {
     Expect(CalcAgeOnMars(20)).To(Equal(10))
  })
  It("should result 22 martian years for 42 earth years", func() {
     Expect(CalcAgeOnMars(42)).To(Equal(22))
  })
   
})

Recent Moves:

JoshuaCWebDevelopervs. marcsantiagoFailed Tests

Age on mars

package main

import "fmt"

func main() {
    var age int
    fmt.Printf("Enter your age on Earth: ")
    _, err := fmt.Scanf("%d", &age)
    if (err != nil) {
        fmt.Println(err)
    }
    age = age * 365 / 687
    fmt.Printf("Your age on the surface of Mars is %d years old.\n", age)
}

marcsantiagovs. kbvincentFailed Tests

Age on mars

package main

import "fmt"

func main() {
    age := 28 * 365 / 687
    fmt.Printf("My age on the surface of Mars is %d years old.\n", age)
}

kbvincentvs. JavatlacatiFailed Tests

Age on mars

package main

import "fmt"

func main() {
    age := 28 * 365 / 687
    fmt.Print(fmt.Sprintf("My age on the surface of Mars is %d years old.", age))
}

Javatlacati

Age on mars

This example prints the result of an operation.

package main

import "fmt"

func main() {
    fmt.Print("My age on the surface of Mars is ")
    fmt.Print(28 * 365 / 687) 
    fmt.Print(" years old.")
}

ShiellJonathanvs. ShiellJonathan

Project Euler: Problem 1

Yet another one-liner.

def mul():
    return sum(list (x for x in range(1000) if (not x%3) or (not x%5)))

1 1 def mul():
2 - return sum(filter(lambda x:x%3==0 or x%5==0,range(1000)))
2 + return sum(list (x for x in range(1000) if (not x%3) or (not x%5)))
3 3

Recent Moves:

ShiellJonathanvs. ShiellJonathan

Project Euler: Problem 1

Yet another one-line solution - this involving True-ey and Falsey solutions

def mul():
    return sum(filter(lambda x:(not x%3) or (not x%5),range(1000)))

1 1 def mul():
2 - return sum(filter(lambda x:x%3==0 or x%5==0,range(1000)))
2 + return sum(filter(lambda x:(not x%3) or (not x%5),range(1000)))
3 3

ShiellJonathanvs. jjst

Project Euler: Problem 1

Another one-line version - using lambda, filter rather than a comprehension. Can anyone think of any more one-liners?

def mul():
    return sum(filter(lambda x:x%3==0 or x%5==0,range(1000)))

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

Krostasvs. Jaieden

Project Euler: Problem 1

Even faster, since it doesn't rely on an iterator. Especially big numbers yield noticeable differences in execution time.

def euler(num):
    sum_range = lambda x: x*(x+1)//2
    return 3*sum_range((num-1)//3) + 5*sum_range((num-1)//5) - 15*sum_range((num-1)//15)

test.assert_equals(euler(10), 23)
test.assert_equals(euler(1000), 233168)
test.assert_equals(euler(100000), 2333316668)
test.assert_equals(euler(10000000), 23333331666668)

1 1 test.assert_equals(euler(10), 23)
2 2 test.assert_equals(euler(1000), 233168)
3 + test.assert_equals(euler(100000), 2333316668)
4 + test.assert_equals(euler(10000000), 23333331666668)

Jaiedenvs. user7579432

Project Euler: Problem 1

This is the fastest way I have found of calculating this. Approximately nine times faster than the standard solution.

def euler(num):
    return sum(range(3,num,3)) + sum(range(5,num,5)) - sum(range(15,num,15))

1 1 def euler(num):
2 - return sum([i for i in range(num) if i%3==0 or i%5==0])
2 + return sum(range(3,num,3)) + sum(range(5,num,5)) - sum(range(15,num,15))

sgoguenvs. AlexHart

Female or male?

type Gender = Male | Female    
type Person = { Name : string; Gender : Gender }

let alice = { Name = "Alice"; Gender = Female }
let bob = { Name = "Bob"; Gender = Male }

let femaleOrMale = function 
  | { Name = name; Gender = Female } -> name + " is female."
  | { Name = name; Gender = Male } -> name + " is male."

Recent Moves:

AlexHartvs. wichu

Female or male?

type Gender = Male | Female    
type Person = { Name : string; Gender : Gender }

let alice = { Name = "Alice"; Gender = Female }
let bob = { Name = "Bob"; Gender = Male }

let femaleOrMale p =
    match p.Gender with
    | Female -> p.Name + " is female."
    | Male -> p.Name + " is male."

wichu

Female or male?

type Person = { Name : string; Gender : string }

let alice = { Name = "Alice"; Gender = "Female" }
let bob = { Name = "Bob"; Gender = "Male" }

let femaleOrMale p =
    match p with
    | { Gender = "Female" } -> p.Name + " is female."
    | { Gender = "Male" } -> p.Name + " is male."
    | _ -> "???"
module Tests = begin
    open Fuchu
    let suite =
        testList "Solution" [
            testCase "Test 1" <| fun _ -> Assert.Equal("Alice", "Alice is female.", femaleOrMale alice);
            testCase "Test 2" <| fun _ -> Assert.Equal("Bob", "Bob is male.", femaleOrMale bob)
        ]
end

csh script arguments

```
# finally fixed
echo $1
```
1 + # finally fixed
1 1 echo $1

Recent Moves:

user5196477vs. Unnamed

csh script arguments

```
#! /bin/csh -f

echo $2
```
1 - echo $1
1 + #! /bin/csh -f
2 +
3 + echo $2

output = run_shell args: ['test']
describe "Solution" do
  it "should not print 'csh'" do
    expect(output).not_to(include('csh'))
  end
  
  it "should print 'test'" do
    expect(output).to(include('test'))
  end
end

UnnamedFailed Tests

csh script arguments

echo $1
describe "Solution" do
  output = run_shell(args: ['test']).strip
  
  it "should not print 'csh'" do
    expect(output).not_to(include('csh'))
  end
  
  it "should print 'test'" do
    expect(output).to(include('test'))
  end
end

Shell: last line without \n

```
# finally fixed
printf test
```
1 + # finally fixed
1 1 printf test

Recent Moves:

user5196477vs. Javatlacati

Shell: last line without \n

#!/bin/bash

# Without newline:
echo -n test
# With newline
echo test

1 + #!/bin/bash
2 +
3 + # Without newline:
4 + echo -n test
5 + # With newline
1 1 echo test

describe "Solution" do
   it "should print 'test'" do
     expect(run_shell.strip).to eq('testtest')
   end
end

1 1 describe "Solution" do
2 2 it "should print 'test'" do
3 - expect(run_shell.strip).to eq('test')
3 + expect(run_shell.strip).to eq('testtest')
4 4 end
5 5 end

Javatlacativs. Unnamed

Shell: last line without \n

```
echo test
```
1 - printf test
1 + echo test

UnnamedFailed Tests

Shell: last line without \n

printf test
describe "Solution" do
   it "should print 'test'" do
     expect(run_shell.strip).to eq('test')
   end
end

Scar95

Find number of N-long strings constructible using exactly K characters

Objective: given 1 <= K <= 26, 0 <= N count the number of different strings of length N that contain exactly K different characters from the alphabet.

Ideas: for small values of N it should be bruteforce-able.
For large values of N?

Clarifications:
-> "The alphabet" is the 26 lowercase letters of the English alphabet

alphabet = 'abcdefghijklmnopqrstuvwxyz'

import itertools

def counter(N, K):
    return counterNaive(N, K)

def counterNaive(N, K):
#    print(f"counterNaive({K}, {N})")
    allCombs = [x for x in itertools.product(alphabet, repeat=N)]
#    print(f"All combinations of length {N}: 26^N = {26**N}")
    return sum( len(set(x)) == K for x in allCombs )
    
def counterSmart(N, K):
    # Idea:
    # Find all ways of splitting N in K parts
    # For each such way, once we know the lenght of the parts K1, ..., Kn
    # (And they must be such that K1+...+Kn = N)
        # Calculate the possible combinations: they are N!/(N-K)! options for the choice of K letters
        # divided by the product of:
            # L! where L = count(Kn == j) for j in range(N)
            # to compensate the fact that if letters 'a' and 'b' appear in the same amount,
            # then doing (a, b) = (b, a) does not give a different sequenec
        # times the permutations of N elements with K1, ..., Kn repetitions
    # Then add these up
    pass

# 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.describe('Small values of N')
test.assert_equals(counter(1, 1), 26, "There are 26 one-length strings.")
test.assert_equals(counter(3, 1), 26, "If you can only choose one letter, there are always 26 possibilities.")
test.assert_equals(counter(3, 3), 26*25*24, "If K = N, the answer is easy to calculate")
test.assert_equals(counter(3, 2), 26*25*3, "This is the first test with non-trivial N and K")
test.assert_equals(counter(5, 3), 26*25*24*25)
Test.describe('Medium values of N')
#This makes the naive code time out.
#test.assert_equals(counter(20, 8), -1, "Obviously unfinished test")

eth0vs. pierre_Le_Roi

Show multiples of 2 numbers within a range

#!/bin/bash
for (( i=1; i <= $3; i++)); do
  (( $i % ($1 * $2) )) || echo $i
done

1 1 #!/bin/bash
2 - for i in $(eval echo {1..$3});
3 - do
4 - if [ $(( $i % ( $1*$2) )) -eq 0 ]
5 - then
6 - echo $i
7 - fi
2 + for (( i=1; i <= $3; i++)); do
3 + (( $i % ($1 * $2) )) || echo $i
8 8 done

Recent Moves:

pierre_Le_Roivs. mmalkavian

Show multiples of 2 numbers within a range

#!/bin/bash
for i in $(eval echo {1..$3});
do
if [ $(( $i % ( $1*$2) )) -eq 0 ]
then
echo $i
fi
done

1 1 #!/bin/bash
2 2 for i in $(eval echo {1..$3});
3 3 do
4 - if [ `expr $i % $1` -eq 0 -a `expr $i % $2` -eq 0 ]
4 + if [ $(( $i % ( $1*$2) )) -eq 0 ]
5 5 then
6 6 echo $i
7 7 fi
8 8 done

mmalkavian

Show multiples of 2 numbers within a range

[Please, leave a feedback when you complete it or this will always stay in beta and you will not earn language points].

Print all numbers up to 3rd parameter which are multiple of both 1st and 2nd paramater.

#!/bin/bash
for i in $(eval echo {1..$3});
do
if [ `expr $i % $1` -eq 0 -a `expr $i % $2` -eq 0 ]
then
echo $i
fi
done

output = run_shell args: [3,4,120]
describe "Solution" do
  it "should return proper results for 3,4,120" do
    expect(output).to include("12\r\n24\r\n36\r\n48\r\n60\r\n72\r\n84\r\n96\r\n108\r\n120")
  end
end

output2 = run_shell args: [2,7,85]
describe "Solution" do
  it "should return proper results for 2,7,85" do
    expect(output2).to include("14\r\n28\r\n42\r\n56\r\n70\r\n84")
  end
end

output3 = run_shell args: [14,15,185]
describe "Solution" do
  it "should return proper results for 14,15,185" do
    expect(output3).to include("")
  end
end

output4 = run_shell args: [14,17,480]
describe "Solution" do
  it "should return proper results for 14,17,480" do
    expect(output4).to include("238\r\n476")
  end
end

output5 = run_shell args: [2,5,90]
describe "Solution" do
  it "should return proper results for 2,5,90" do
    expect(output5).to include("10\r\n20\r\n30\r\n40\r\n50\r\n60\r\n70\r\n80\r\n90")
  end
end

output6 = run_shell args: [4,7,97]
describe "Solution" do
  it "should return proper results for 4,7,97" do
    expect(output6).to include("28\r\n56\r\n84")
  end
end

superboyvs. Unnamed

No built-in stringizer for `pair`

#include <utility>

std::pair<int, int> foo() {
  return {1, 1};
}

1 1 #include <utility>
2 2
3 3 std::pair<int, int> foo() {
4 - return {0, 0};
4 + return {1, 1};
5 5 }

Recent Moves:

Unnamedvs. UnnamedFailed Tests

Custom stringizer for `pair`

#include <utility>

Describe(function_foo)
{
  It(should_return_1_1)
  {
    Assert::That(foo(), Equals(std::pair<int, int>{1, 1}));
  }
};

#include <sstream>
#include <string>
namespace snowhouse {
  template <> struct Stringizer<std::pair<int, int>> {
    static std::string ToString(const std::pair<int, int>& x) {
      return (std::ostringstream() << '{' << x.first << ", " << x.second << '}').str();
    }
  };
}

UnnamedFailed Tests

No built-in stringizer for `pair`

#include <utility>

std::pair<int, int> foo() {
  return {0, 0};
}
#include <utility>

Describe(function_foo)
{
  It(should_return_1_1)
  {
    Assert::That(foo(), Equals(std::pair<int, int>{1, 1}));
  }
};

[GNU Fortran] Alternative Function Syntax

Alternative Function Syntax

Just discovered this by looking at a few Fortran code examples online, but it seems that in as early as Fortran 95 (perhaps even earlier!), functions can be defined in at least two ways.

The traditional way:

function FUNCTION_NAME(PARAMETER) ! or parameters
  PARAMETER_TYPE :: PARAMETER
  RETURN_TYPE :: FUNCTION_NAME ! or explicit result variable
  ! Function body
end function FUNCTION_NAME

And the second (perhaps more C-like) way:

RETURN_TYPE function FUNCTION_NAME(PARAMETER)
  PARAMETER_TYPE :: PARAMETER
  ! Function body
end function FUNCTION_NAME

Of course, with either syntax, it is possible to add modifiers such as pure, recursive or result(RESULT_VAR).

module Solution
  implicit none
contains
  integer pure function add(a, b) result(c)
    integer, intent(in) :: a, b
    c = a + b
  end function add
end module Solution

program TestCases
  use CW2
  use Solution
implicit none
  call describe("add")
    call it("adds integers")
      call assertEquals(2, add(1, 1))
      call assertEquals(8, add(5, 3))
      call assertEquals(69, add(33, 36))
      call assertEquals(1079, add(826, 253))
    call endContext()
  call endContext()
end program TestCases

[GNU Fortran] Type Initializers

Type Initializers

When you define a derived data type in GNU Fortran, you are automatically given a type initializer which allows you to initialize an instance of your derived data type in one go. One can think of a type initializer as a primitive type of constructor. However, custom-defined constructors weren't available until Fortran 2003 so it may not be available in GNU Fortran (which is an extension of the Fortran 95 standard).

module Solution
  implicit none
  type Vec3D ! A three-dimensional vector
    integer :: x, y, z
  end type Vec3D
  type(Vec3D) :: v = Vec3D(1, 2, 3) ! Using the type initializer provided by Fortran
end module Solution

program TestCases
  use CW2
  use Solution
  implicit none
  print "(A20, I0, A2, I0, A2, I0, A1)", "Our 3D vector: v = (", v%x, ", ", v%y, ", ", v%z, ")"
  call assertEquals(.true., .true.)
end program TestCases

JavatlacatiFailed Tests

JQuery support

This Kumite is created to test JQuery support on Codewars.

var jsdom = require("jsdom/lib/old-api.js");

jsdom.env(
    '<!DOCTYPE html><p>Hello world</p><a class="the-link" href="https://github.com/tmpvar/jsdom">jsdom!</a>', ["http://code.jquery.com/jquery.js"],
    function(err, window) {
        console.log(window.document.querySelector("p").textContent);
        var $ = window.$;

        $.getJSON('https://www.codewars.com/users/Javatlacati', null, function(data) {
            console.log(data);
        }).error(function(e) {
            console.log("first attempt failed\n" + JSON.stringify(e));
        });



        var name = "kazk";
        var url = "http://anyorigin.com/go?url=" + encodeURIComponent("https://www.codewars.com/users/") + name + "&callback=?";
        $.get(url, function(response) {
            console.log(response);
        }).error(function(e) {
            console.log("second attempt failed\n" + JSON.stringify(e));
        });
        console.log("contents of a.the-link:", window.$("a.the-link").text());
    }
);

[NASM] Dynamic Memory Allocation by using C library malloc() function

Dynamic Memory Allocation by using C library malloc() function

It is possible to allocate memory dynamically in NASM (obviously, otherwise how would it be possible in C and other higher-level languages?) and the easiest way to do it is probably by relying on the C library function malloc().

global one_two_three
extern malloc ; C library function malloc()
section .text
one_two_three:
  mov rdi, 12 ; size_t bytes_required = 3 * sizeof(int) == 12 (because sizeof(int) == 4 on CW)
  call malloc ; int *result = malloc(bytes_required)
  mov dword [rax], 1 ; result[0] = 1 (`dword` means "double word" where 1 word = 2 bytes)
  mov dword [rax + 4], 2 ; result[1] = 2
  mov dword [rax + 8], 3 ; result[2] = 3
  ret ; return result

#include <criterion/criterion.h>

int *one_two_three(void);

Test(the_one_two_three_function, should_return_a_dynamically_allocated_array_of_one_two_three) {
  int *a = one_two_three();
  cr_assert_eq(a[0], 1);
  cr_assert_eq(a[1], 2);
  cr_assert_eq(a[2], 3);
  free(a);
}

int -> double, returning, sse2

Actually, that was double -> int, now int -> double.

global to_double
section .text
to_double:
                cvtsi2sd    xmm0, edi
                ret

1 - global trunc_
1 + global to_double
2 2 section .text
3 - trunc_:
4 - cvttsd2si eax, xmm0
3 + to_double:
4 + cvtsi2sd xmm0, edi
5 5 ret

#include <criterion/criterion.h>

double to_double(int);

Test(add_test, should_add_integers) {
  cr_assert_eq(to_double(123), 123.0);
}

Recent Moves:

double -> int, returning, by reference, x87/sse3

global trunc_ref
section .text
trunc_ref:
                fld     qword [rdi]
                sub     rsp, 8
                fisttp  dword [rsp]
                pop     rax
                ret

1 - global trunc_
1 + global trunc_ref
2 2 section .text
3 - trunc_:
4 - cvttsd2si eax, xmm0
3 + trunc_ref:
4 + fld qword [rdi]
5 + sub rsp, 8
6 + fisttp dword [rsp]
7 + pop rax
5 5 ret

#include <criterion/criterion.h>

int trunc_ref(const double*);

int trunc_(double x) {
  return trunc_ref(&x);
}

Test(add_test, should_add_integers) {
  cr_assert_eq(trunc_(1.2), 1);
  cr_assert_eq(trunc_(1.8), 1);
  cr_assert_eq(trunc_(-1.2), -1);
  cr_assert_eq(trunc_(-1.8), -1);
}

Unnamed

int -> double, returning, sse2

global trunc_
section .text
trunc_:
                cvttsd2si   eax, xmm0
                ret
#include <criterion/criterion.h>

int trunc_(double);

Test(add_test, should_add_integers) {
  cr_assert_eq(trunc_(1.2), 1);
  cr_assert_eq(trunc_(1.8), 1);
  cr_assert_eq(trunc_(-1.2), -1);
  cr_assert_eq(trunc_(-1.8), -1);
}

delmaovs. fgozalo2

Return Hello World

String literals are stored as read-only (const), and any attempt to modify the pointer returned will result in a SEGFAULT (crash) in most current computing environments.

Obvserving the following assembly output from GCC:

    .file   "tst.c"
    .text
    .section    .rodata
.LC0:
    .string "Hello World."
    .text
    .globl  Hi
    .type   Hi, @function
Hi:

You can see string literal referred to by label .LC0 is defined within section '.rodata' meaning ready-only data.

Therefore Hi() should have a return type of const char* to avert the possibility of such faulty access occurring.

const char* Hi (void)
{
  return("Hello World.");
}

char *oopsHi(void)
{
  return ("Hello World.");
}

1 - char* Hi (void)
1 + const char* Hi (void)
2 2 {
3 - return("Hello World.");
3 + return("Hello World.");
4 + }
5 +
6 + char *oopsHi(void)
7 + {
8 + return ("Hello World.");
4 4 }

// TODO: Replace examples and use TDD development by writing your own tests. The code provided here is just a how-to example.

#include <criterion/criterion.h>

// replace with the actual method being tested
const char* Hi ();

Test(the_multiply_function, should_pass_all_the_tests_provided) {
    cr_assert_eq(Hi(""), "Hello World.");
    
    #if 0 // if'd out, reenable to observe crash
    char oopsHi();
    char *p  = oopsHi();
    *p = 'X';
    #endif
}

Recent Moves:

fgozalo2

Return Hello World

Return "Hello World."

char* Hi (void)
{
return("Hello World.");
}

// TODO: Replace examples and use TDD development by writing your own tests. The code provided here is just a how-to example.

#include <criterion/criterion.h>

// replace with the actual method being tested
char* Hi ();

Test(the_multiply_function, should_pass_all_the_tests_provided) {
    cr_assert_eq(Hi(""), "Hello World.");
}

Unnamedvs. UnnamedFailed Tests

Syntax error in Crystal

```
syntax error here again
```
1 - syntax error here
1 + syntax error here again

GermanProgervs. MatthewSwarbrick

FizzBuzzRefactor

using System;

namespace Solution {

  class FizzBuzz {
    public static string Convert(int input)
        {
            var divisableBy3 = input % 3 == 0;
            var divisableBy5 = input % 5 == 0;
            
            return (!divisableBy3 & !divisableBy5) ? input.ToString()
              : (divisableBy3 ? "Fizz" : string.Empty) +  (divisableBy5 ? "Buzz" : string.Empty);
        }
  }
}

Recent Moves:

MatthewSwarbrickvs. GermanProger

FizzBuzzRefactor