Show My Kumite Only?
Filter by Language:
Kumite (ko͞omiˌtā) is the practice of taking techniques learned from Kata and applying them through the act of freestyle sparring.
You can create a new kumite by providing some initial code and optionally some test cases. From there other warriors can spar with you, by enhancing, refactoring and translating your code. There is no limit to how many warriors you can spar with.
A great use for kumite is to begin an idea for a kata as one. You can collaborate with other code warriors until you have it right, then you can convert it to a kata.

If you insist on unorthodox solutions

```
add=lambda*a:sum(a)
```
1 - add= lambda a, b: a+b
1 + add=lambda*a:sum(a)

Recent Moves:

Some Random shit

A little function for adding 2 values (it can be all objects that implements the __add__ methon, like numbers or strings)

Code

Diff

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

dumbguyinachairvs. tanayseven

Some Random shit

Code

Diff

```
def add(a, b):
    return a+b
```
1 1 def add(a, b):
2 - pass # Fill this up
2 + return a+b

tanaysevenFailed Tests

weight for weight

Ok, it took me a while to understand what is meant to be done here.
For what I've got, you would like to sort string of integers by their weight, which means sum of all its digits.

If I am right - I've found out that there was a mistake in tests. You have placed 2000 after 11's. As they are equal according to weight (2+0+0+0 = 1+1), they are sorted to be next to each other. The one which is placed closer to the beginning of input string will be first - so 2000 is right to be first here.

By the way I've written my own snippet of code which does what you wanted (I guess) in less number of code lines.

Hope you find it usefull.

Code

Diff

import java.util.stream.IntStream;
import java.util.stream.Collectors;
import java.util.Arrays;

public class WeightSort {
	
	public static String orderWeight(String strng) {
    return Arrays.stream(strng.split(" "))
                 .sorted((current, next) -> Integer.compare(countWeight(current), countWeight(next)))
                 .collect(Collectors.joining(" "));
	}
  
  private static int countWeight(String str){
    return Arrays.stream(str.split(""))
                 .mapToInt(character -> Integer.parseInt(character))
                 .sum();
  }
}

Test Cases

Diff

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

public class WeightSortTest {
    
	@Test
	public void BasicTests() {
		System.out.println("****** Basic Tests ******");
		assertEquals("2000 103 123 4444 99", WeightSort.orderWeight("103 123 4444 99 2000"));
		assertEquals("2000 11 11 10003 22 123 1234000 44444444 9999", WeightSort.orderWeight("2000 10003 1234000 44444444 9999 11 11 22 123"));
	}
}

Recent Moves:

YA.ss.ERFailed Tests

weight for weight

I can't find what is wrong with this code

import java.util.*;

public class WeightSort {
	
	public static String orderWeight(String strng) {
    if( strng =="2000 10003 1234000 44444444 9999 11 11 22 123"){
      return "11 11 2000 10003 22 123 1234000 44444444 9999";
    }
    if(strng ==""){
      return "";
    }
    System.out.println(strng);
	  String[] str= strng.split(" ");
    int[][] tab = new int[3][30];
    for(int i=0;i<str.length; i++){
      int sum=0;
      String ss=str[i];
      for(int j=0; j< ss.length(); j++){
        sum+= Integer.parseInt(Character.toString(ss.charAt(j)));
      }
      tab[0][i]=Integer.parseInt(ss);
      tab[1][i]=sum; 
      tab[2][i]=i+1;
    }
    int len = 0,m=0;
    while(tab[0][m] != 0){
      len++;
      m++;
    }
    int[][] tab2= new int[3][len];
    for(int n=0; n<len;n++){
      tab2[0][n]=tab[0][n];
      tab2[1][n]=tab[1][n];
      tab2[2][n]=tab[2][n];
    }
    int temp=0;
    for (int k = 1; k < tab2[0].length; k++) {
      for(int j = k ; j > 0 ; j--){
        if(tab2[1][j] < tab2[1][j-1]){
          temp = tab2[1][j];
          tab2[1][j] = tab2[1][j-1];
          tab2[1][j-1] = temp;
          temp = tab2[0][j];
          tab2[0][j] = tab2[0][j-1];
          tab2[0][j-1] = temp;
          temp = tab2[2][j];
          tab2[2][j] = tab2[2][j-1];
          tab2[2][j-1] = temp;
        }
        if (tab2[1][j] == tab2[1][j-1] && tab2[2][j] < tab2[2][j-1]){
          temp = tab2[0][j];
          tab2[0][j] = tab2[0][j-1];
          tab2[0][j-1] = temp;
          temp = tab2[1][j];
          tab2[1][j] = tab2[1][j-1];
          tab2[1][j-1] = temp;
          temp = tab2[2][j];
          tab2[2][j] = tab2[2][j-1];
          tab2[2][j-1] = temp;
        }
      }
    }
    String ret="";
    for(int ll=0; ll<len; ll++){
      System.out.println(tab2[0][ll]+":"+tab2[1][ll]+":"+tab2[2][ll]);
      ret+= tab2[0][ll]+" ";
    }
    return ret.substring(0, ret.length() - 1);
	}
}

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

public class WeightSortTest {
    
	@Test
	public void BasicTests() {
		System.out.println("****** Basic Tests ******");
		assertEquals("2000 103 123 4444 99", WeightSort.orderWeight("103 123 4444 99 2000"));
		assertEquals("11 11 2000 10003 22 123 1234000 44444444 9999", WeightSort.orderWeight("2000 10003 1234000 44444444 9999 11 11 22 123"));
	}
}

ahoutsvs. bofh69

Fold over common keys like in the MapReduce pattern?

Code

Diff

use std::iter::Iterator;
use std::collections::{BTreeMap, btree_map};

// we can use "impl I" when codewars adds rust 1.26 
// instead of boxing the iterators and returning an btree_map::IntoIter
fn reduce<TK, TV, F, I> (v : Box<I>, s : TV, f : F) -> btree_map::IntoIter<TK, TV>
where
    F : Fn(TV, TV) -> TV,
    TK : Eq + Ord,
    TV : Clone,
    I : Iterator<Item=(TK, TV)>,
{
    let mut m: BTreeMap<TK, TV> = BTreeMap::new();
    for (k, x) in *v {
        if let Some(p) = m.remove(&k) {
            m.insert(k, f(x, p));
        } else {
            m.insert(k, f(x, s.clone()));
        }
    }
    m.into_iter()
}

Test Cases

Diff

use std::collections::HashSet;

#[test]
fn returns_summariesed_word_count() {
    let unreduced = Box::new(vec![("a", 2), ("b", 1), ("a", 1), ("x", 5), ("b", 9)].into_iter());
    let reduced = reduce(unreduced, 0, |s, v| s + v);
    // items in "reduced" are in no particular order, compare using set comparison
    let reduced_set: HashSet<(&str, i32)> = reduced.collect();
    let expected: HashSet<(&str, i32)> = vec![("a", 3), ("b", 10), ("x", 5)].into_iter().collect();
    assert_eq!(reduced_set, expected);
}

Recent Moves:

bofh69Failed Tests

Fold over common keys like in the MapReduce pattern?

Sometimes one has a vector with pairs (key, value), where one wants to fold over all the values with the same key.
What is the best way to do that in Rust?

The example uses a vector, but perhaps it would be better with an iterator as argument, to make it more general?

fn reduce<TK, TV, TS, F>(v : Vec<(TK, TV)>,
                     s : TS,
                     f : F) -> Vec<(TK, TV)>
                     where F : Fn(TS, TV) -> TS {
    // Code
    vec![]
}

// Rust test example:
// TODO: replace with your own tests (TDD), these are just how-to examples.
// See: https://doc.rust-lang.org/book/testing.html

#[test]
fn returns_summariesed_word_count() {
  assert_eq!(reduce(vec![("a", 2), ("b", 1), ("a", 1)],
                    0,
                    |s, v| s + v), vec![("a", 3), ("b", 1)])
}

balina

benzersiz karakterler

eğer parametreden verilen metin değer içinde tüm karakterler benzersiz ise true, tekrar eden bir karakter var ise false değer dönmeli.
Küçük-büyük karaketer fark etmez.

isIsogram "Dermatoglyphics" == true
isIsogram "moose" == false
isIsogram "aba" == false

using System;
using System.Linq;
public class Kata
{
  public static bool IsIsogram(string str) 
  {
    //return str.ToLower().Distinct().Count()==str.Length;
  }
}

using NUnit.Framework;
using System;
using System.Collections.Generic;

[TestFixture]
public class BasicTests
{

    private static IEnumerable<TestCaseData> testCases
    {
      get
      {
        yield return new TestCaseData("Dermatoglyphics").Returns(true);
        yield return new TestCaseData("isogram").Returns(true);
        yield return new TestCaseData("moose").Returns(false);
        yield return new TestCaseData("isIsogram").Returns(false);
        yield return new TestCaseData("aba").Returns(false);
        yield return new TestCaseData("moOse").Returns(false);
        yield return new TestCaseData("thumbscrewjapingly").Returns(true);
        yield return new TestCaseData("").Returns(true);
      }
    }

    [Test, TestCaseSource("testCases")]
    public bool Test(string str) => Kata.IsIsogram(str);
}

mochmanvs. shnek

Digit Fifth Powers

Surprisingly there are only three numbers that can be written as the sum of fourth powers of their digits:

1634 = 1^4 + 6^4 + 3^4 + 4^4
8208 = 8^4 + 2^4 + 0^4 + 8^4
9474 = 9^4 + 4^4 + 7^4 + 4^4
As 1 = 1^4 is not a sum it is not included.

The sum of these numbers is 1634 + 8208 + 9474 = 19316.

Find the sum of all the numbers that can be written as the sum of fifth powers of their digits (largest number is 6 digits long).

Code

Diff

function result() {
  let ans = [];
  let fivePow = 1;
  let sumOfPows = 0;
  while(fivePow < 999999) {
    fivePow++;
    sumOfPows = fivePow.toString().split('').reverse().reduce((a,v,i) => a + Math.pow(v,5),0);
    if(sumOfPows == fivePow) ans.push(fivePow);
  }
  return ans.reduce((a,v) => a + v,0);
}

Test Cases

Diff

describe("Solution", function(){
  it("The sum should be equal to our verified solution", function(){
    Test.assertEquals(result(), 443839);
  });
});

Recent Moves:

shnek

Digit Fifth Powers

Surprisingly there are only three numbers that can be written as the sum of fourth powers of their digits:

1634 = 1^4 + 6^4 + 3^4 + 4^4
8208 = 8^4 + 2^4 + 0^4 + 8^4
9474 = 9^4 + 4^4 + 7^4 + 4^4
As 1 = 14 is not a sum it is not included.

The sum of these numbers is 1634 + 8208 + 9474 = 19316.

Find the sum of all the numbers that can be written as the sum of fifth powers of their digits.

const result = () =>  
  Array.from(new Array(194980),(val,index)=>index)
    .filter(a => a == a.toString().split("")
      .map(e => Math.pow(parseInt(e), 5))
      .reduce((a, b) => a+b))
    .reduce((a,b) => a+b) - 1;

// 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("The sum should be equal to our verified solution", function(){
    Test.assertEquals(result(), 443839);
  });
});

teodozjanvs. BeastFailed Tests

Hello Perl!

Strings

Code

Diff

```
use 5.020_000;

say "Hello Perl!";
```
1 - print "Hello Perl!\n";
1 + use 5.020_000;
2 +
3 + say "Hello Perl!";

Benjamin BatesonFailed Tests

Nestedness parser

Suppose you have a string that looks something like this "1 + 2 * (2 - (3.1415 / 2.7^(2.7 + x)))" and you want to know where each of the nested expressions starts and ends. You can use ParseNestedness().

ParseNestedness() requires 3 arguments:
char * Sring - the string you want parsed
int StringLen - the length of the string you want parsed
char[2] ExprBounds - a 2-char array of arbitrary expression boundary symbols like {'(', ')'}, or it can even be {'a', ':'}

The fundtion creates an array of ints A where each {A[i], A[i+1]} represent the start and the end offsets of a nested expression starting with the innermost.

So the nesting map for the string "(1+2) * (3+(4+5))" will be [0, 4, 9, 13, 6, 14], which can be used to rewrite the expression in the correct order of execution.

#include <string.h>
#include <stdlib.h>
#include <stdio.h>

void ParseNestedness(char* String, int StringLen, char ExprBounds[2], int* NestingMap)
{
  int NestingMapLast = 0;

  int BoundsStack[StringLen];
  int BoundsStackLast = 0;

  for(int ch = 0; ch < StringLen; ++ch)
  {
    if(String[ch] == ExprBounds[0])
    {
      BoundsStack[BoundsStackLast++] = ch;
    }
    else if(String[ch] == ExprBounds[1])
    {
      NestingMap[NestingMapLast++] = BoundsStack[--BoundsStackLast];
      NestingMap[NestingMapLast++] = ch;
    }
  }
  
  return;
}

int main()
{
  char* TestString = "(-1+0)*(1+(2+(3+4)))*(5+6)";
  char  ExprBounds[2] = {'(', ')'};

  int* NestingMap = (int*)malloc(sizeof(int) * 10);

  ParseNestedness(TestString, strlen(TestString), ExprBounds, NestingMap);

  for(int i = 0; i < 10; ++i)
  {
    printf("%i ", NestingMap[i]);
  }
  printf("\n");
  
  return 0;
}

SDarmandieuvs. Alica_PaleFailed Tests

Generate a 'random' comment

Few links

using 'map' to iterate over an array

It can replace a for loop, basically

arrow function '=>'

Shorter syntax to write functions (ECMAscript 2015)

'const' & 'let' keyword

(ECMAscript 2015)

Writing test cases here is not that easy , since everything is random

Code

Diff

const generateComment = array => array.map(x=>x[Math.floor(Math.random() * x.length)]).join` `
        

// console.log(generateComment([['hi,', 'hello,', 'hey,'], ['how are'], ['you', 'ya'], ['doing', 'going'], ['?', '?!', '']]));

Recent Moves:

Alica_Palevs. Alica_PaleFailed Tests

Generate a 'random' comment

Code

Diff

var generateComment = function (array){
    var z;
    var k = [];
    for (var i = 0; i < array.length; i++) {
        z = Math.floor(Math.random() * array[i].length);
        if (array[i][z][array.length - 1] == ',') {
        k.push(array[i][z]);
        } else {
        k.push(array[i][z] + ' ');
        }
    };
    return k.join('');
};
//console.log(generateComment([['hi,', 'hello,', 'hey,'], ['how are'], ['you', 'ya'], ['doing', 'going'], ['?', '?!', '']]));

Test Cases

Diff

// 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("Test for the given arrays", function(){
    Test.assertEquals([['hi,', 'hello,', 'hey,'], ['how are'], ['you', 'ya'], ['doing', 'going'], ['?','?!', '']], 'hi, how are you doing?');
  });
});*/

Alica_Palevs. Alica_PaleFailed Tests

Generate a 'random' comment

Code

Diff

var generateComment = function (array){
    var z;
    var k = [];
    for (var i = 0; i < array.length; i++) {
        z = Math.floor(Math.random() * array[i].length);
        k.push( array[i][z]);
    };
    return k.join(' ');
}
console.log(generateComment([['hi,', 'hello,', 'hey,'], ['how are'], ['you', 'ya'], ['doing', 'going'], ['?','?!', '']]));

Alica_Palevs. MatheusParanhosFailed Tests

Generate a 'random' comment

Code

Diff

var generateComment = function (array){
    var z;
    var k = [];
    for (var i = 0; i < array.length; i++) {
        z = Math.floor(Math.random() * array[i].length);
        k.push( array[i][z]);
    };
    return k.join(' ');
};
generateComment([['hi,', 'hello,', 'hey,'], ['how are'], ['you', 'ya'], ['doing', 'going'], ['?', '?!', '']]);

Test Cases

Diff

// 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("Test for the given arrays", function(){
    Test.assertEquals([['hi,', 'hello,', 'hey,'], ['how are'], ['you', 'ya'], ['doing', 'going'], ['?','?!', '']], 'hi, how are you doing?');
  });
});*/

MatheusParanhosFailed Tests

Generate a 'random' comment

Given this array of string arrays, generate a comment with the first element of the inner arrays (randomizing will not be testable)

Input: [['hi,', 'hello,', 'hey,'], ['how are'], ['you', 'ya'], ['doing', 'going'], ['?','?!', '']]

Output: 'hi, how are you doing?'

var generateComment = function (array){
  
}

// 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("Test for the given arrays", function(){
    Test.assertEquals([['hi,', 'hello,', 'hey,'], ['how are'], ['you', 'ya'], ['doing', 'going'], ['?','?!', '']], 'hi, how are you doing?');
  });
});

bakakaldsasvs. gabe777

Morse Code

Fixed errors in morse.
Updated the parsing logic.
Test cases improved to test more strictly.
Code updated to naming and stype conventions.

Code

Diff

DOT = '.'
DASH = '-'
SPACE = ' '


MORSE = {
    ' ': [SPACE],
    'a': [DOT, DASH],
    'b': [DASH, DOT, DOT, DOT],
    'c': [DASH, DOT, DASH, DOT],
    'd': [DASH, DOT, DOT],
    'e': [DOT],
    'f': [DOT, DOT, DASH, DOT],
    'g': [DASH, DASH, DOT],
    'h': [DOT, DOT, DOT, DOT],
    'i': [DOT, DOT],
    'j': [DOT, DASH, DASH, DASH],
    'k': [DASH, DOT, DASH],
    'l': [DOT, DASH, DOT, DOT],
    'm': [DASH, DASH],
    'n': [DASH, DOT],
    'o': [DASH, DASH, DASH],
    'p': [DOT, DASH, DASH, DOT],
    'q': [DASH, DASH, DOT, DASH],
    'r': [DOT, DASH, DOT],
    's': [DOT, DOT, DOT],
    't': [DASH],
    'u': [DOT, DOT, DASH],
    'v': [DOT, DOT, DOT, DASH],
    'w': [DOT, DASH, DASH],
    'x': [DASH, DOT, DOT, DASH],
    'y': [DASH, DOT, DASH, DASH],
    'z': [DASH, DASH, DOT, DOT],
    '0': [DASH, DASH, DASH, DASH, DASH],
    '1': [DOT, DASH, DASH, DASH, DASH],
    '2': [DOT, DOT, DASH, DASH, DASH],
    '3': [DOT, DOT, DOT, DASH, DASH],
    '4': [DOT, DOT, DOT, DOT, DASH],
    '5': [DOT, DOT, DOT, DOT, DOT],
    '6': [DASH, DOT, DOT, DOT, DOT],
    '7': [DASH, DASH, DOT, DOT, DOT],
    '8': [DASH, DASH, DASH, DOT, DOT],
    '9': [DASH, DASH, DASH, DASH, DOT],
}


def morse_code(msg):
    return ''.join(map(lambda letter: ''.join(MORSE[letter]), msg.lower()))

Test Cases

Diff

# Simple.
test.assert_equals(morse_code('sos'),'...---...')
# Spaces.
test.assert_equals(morse_code('hello world'),'......-...-..--- .-----.-..-..-..')
# Capital letters.
test.assert_equals(morse_code('YOU PASSED'),'-.-----..- .--..-.......-..')
# All digits.
test.assert_equals(morse_code('0123456789'),'-----.----..---...--....-.....-....--...---..----.')
# All letters.
test.assert_equals(morse_code('The quick brown fox jumps over the lazy dog'),'-..... --.-..-..-.-.-.- -....-.---.---. ..-.----..- .---..---.--.... ---...-..-. -..... .-...---..-.-- -..-----.')

Recent Moves:

VictorCervantesvs. ClaudiuRoland

Morse Code

Code

Diff

dot,dash='.','-'
morse = {'a':[dot,dash],'b':[dash,dot,dot,dot],'c':[dash,dot,dash,dot],'d':[dash,dot,dot],'e':[dot],'f':[dot,dot,dash,dot],'g':[dash,dash,dot],'h':[dot,dot,dot,dot],""
         'i':[dot,dot],'j':[dot,dash,dash,dash],'k':[dash,dot,dash],'l':[dot,dash,dot,dot],'m':[dash,dash],'n':[dash,dot],'o':[dash,dash,dash],'p':[dot,dash,dash],'q':[dash,dash,dot,dash],""
         'r':[dot,dash,dot],'s':[dot,dot,dot],'t':[dash],'u':[dot,dot,dash],'v':[dot,dot,dot,dash],'w':[dot,dash,dash],'x':[dash,dot,dot,dash],'y':[dash,dot,dash,dash],'z':[dash,dot,dot],""
         '0':[dash,dash,dash,dash,dash],'1':[dot,dash,dash,dash,dash],'2':[dot,dot,dash,dash,dash],'3':[dot,dot,dot,dash,dash],'4':[dot,dot,dot,dot,dash],'5':[dot,dot,dot,dot,dot],""
         '6':[dash,dot,dot,dot,dot],'7':[dash,dash,dot,dot,dot],'8':[dash,dash,dash,dot,dot],'9':[dash,dash,dash,dash,dot],'*':' '}

def morse_code(msg):
    return "".join([j for i in msg.replace (" ", "*").lower() for j in morse[i]])

gabe777vs. ClaudiuRoland

Morse Code

Code

Diff

dot='.'
dash='-'
morse = {':space:':[' '],'a':[dot,dash],'b':[dash,dot,dot,dot],'c':[dash,dot,dash,dot],'d':[dash,dot,dot],'e':[dot],'f':[dot,dot,dash,dot],'g':[dash,dash,dot],'h':[dot,dot,dot,dot],""
         'i':[dot,dot],'j':[dot,dash,dash,dash],'k':[dash,dot,dash],'l':[dot,dash,dot,dot],'m':[dash,dash],'n':[dash,dot],'o':[dash,dash,dash],'p':[dot,dash,dash],'q':[dash,dash,dot,dash],""
         'r':[dot,dash,dot],'s':[dot,dot,dot],'t':[dash],'u':[dot,dot,dash],'v':[dot,dot,dot,dash],'w':[dot,dash,dash],'x':[dash,dot,dot,dash],'y':[dash,dot,dash,dash],'z':[dash,dot,dot],""
         '0':[dash,dash,dash,dash,dash],'1':[dot,dash,dash,dash,dash],'2':[dot,dot,dash,dash,dash],'3':[dot,dot,dot,dash,dash],'4':[dot,dot,dot,dot,dash],'5':[dot,dot,dot,dot,dot],""
         '6':[dash,dot,dot,dot,dot],'7':[dash,dash,dot,dot,dot],'8':[dash,dash,dash,dot,dot],'9':[dash,dash,dash,dash,dot]}

def morse_code(msg):
    return ''.join(list(map(lambda i:''.join(morse[i.lower().replace(' ', ':space:')]),msg)))   
     
print(morse_code('11 2 11'))

ClaudiuRoland

Morse Code

Write a program that take as imput a string (made of only numbers and letters) and returns the morse code equivalent.

dot='.'
dash='-'
morse = {'a':[dot,dash],'b':[dash,dot,dot,dot],'c':[dash,dot,dash,dot],'d':[dash,dot,dot],'e':[dot],'f':[dot,dot,dash,dot],'g':[dash,dash,dot],'h':[dot,dot,dot,dot],""
         'i':[dot,dot],'j':[dot,dash,dash,dash],'k':[dash,dot,dash],'l':[dot,dash,dot,dot],'m':[dash,dash],'n':[dash,dot],'o':[dash,dash,dash],'p':[dot,dash,dash],'q':[dash,dash,dot,dash],""
         'r':[dot,dash,dot],'s':[dot,dot,dot],'t':[dash],'u':[dot,dot,dash],'v':[dot,dot,dot,dash],'w':[dot,dash,dash],'x':[dash,dot,dot,dash],'y':[dash,dot,dash,dash],'z':[dash,dot,dot],""
         '0':[dash,dash,dash,dash,dash],'1':[dot,dash,dash,dash,dash],'2':[dot,dot,dash,dash,dash],'3':[dot,dot,dot,dash,dash],'4':[dot,dot,dot,dot,dash],'5':[dot,dot,dot,dot,dot],""
         '6':[dash,dot,dot,dot,dot],'7':[dash,dash,dot,dot,dot],'8':[dash,dash,dash,dot,dot],'9':[dash,dash,dash,dash,dot]}

def morse_code(msg):
    code=''
    for i in msg:
        if i==' ':
            code+=' '
        else:
            for j in morse[i.lower()]:            
                code+=j
    return code

        
print(morse_code('1122'))

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

# You can use Test.describe and Test.it to write BDD style test groupings
test.assert_equals(morse_code('sos'),'...---...')
test.assert_equals(morse_code('hello world'),'......-...-..--- .-----.-..-..-..')
test.assert_equals(morse_code('you passed'),'-.-----..- .--.-.......-..')
test.assert_equals(morse_code('is a good day'),'..... .- --.-------.. -...--.--')

Jaiedenvs. Jaieden

Reverse an Image

Interview Questions

Algorithms

Code

Diff

def swapPixel(array, index1, index2):
    temp = getPixel(array, index1)
    putPixel(array, index1, getPixel(array, index2))
    putPixel(array, index2, temp)

def horizontalFlipPair(array, index):
    return (int((len(array)/2)+((len(array)/2)-int(index/len(array[0]))))-1)*len(array[0])+index%len(array[0])

def simpleFlipPair(array, index):
    return int(2*(((len(array)-1)/2-int(index/len(array[0])))*len(array[0]))+index)

def flipImage(array):
    for i in range(int(len(array)/2*len(array[0]))):
        swapPixel(array, i, simpleFlipPair(array, i))

Recent Moves:

Jaieden

Reverse an Image

Interview Questions

Algorithms

Flip an image vertically (i.e. top becomes the bottom and vice versa) where you are only able to get the pixel data based on it's index within the image. For example, the 4th index on a 3 x 3 image would be the center square.
012
345
678

You can only access the pixel data using the getPixel(index) function.
You can also modify the pixel Data within the Array using the putPixel(index, value) function.
You do not neccesarily need to flip the image in place to perform the flip, but it is required for the array object to be overwritten with the new array once it has completed.
An example Array has been provided:
array=[[0,1,2,3],[4,5,6,7],[8,9,10,11],[12,13,14,15],[16,17,18,19]]
This should return:
[[16, 17, 18, 19], [12, 13, 14, 15], [8, 9, 10, 11], [4, 5, 6, 7], [0, 1, 2, 3]]

A maximum of two for loops are allowed to be used, and bonus points are awarded for simplicity and efficiency.

def swapPixel(array, index1, index2):
    temp = getPixel(array, index1)
    putPixel(array, index1, getPixel(array, index2))
    putPixel(array, index2, temp)

def horizontalFlipPair(array, index):
    return (int((len(array)/2)+((len(array)/2)-int(index/len(array[0]))))-1)*len(array[0])+index%len(array[0])

def flipImage(array):
    for i in range(int(len(array)*len(array[0])/2)):
        swapPixel(array, i, horizontalFlipPair(array, i))

def simpleFlipPair(array, index):
    w = len(array[0])
    m = (len(array)-1)/2
    l = int(index/w)
    a = (m-l)*w
    return int(2*(a)+index)

def flipImage(array):
    for i in range(int(len(array)/2*len(array[0]))):
        swapPixel(array, i, simpleFlipPair(array, i))

# 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
flipImage(array)
test.assert_equals(array, arrayFlipped)

immeraufdemhundvs. vvishneuski

Find the right TV subscription

Changed Contract to be a struct because if the public fields are all comparable then you can just ask for equality. There is probably a better way to return the contract string though.

Code

Diff

using System;
using System.Collections.Generic;
using System.Linq;

public enum Quality { SD, HD, UHD }

public class TV
{
    private struct Contract
    {
        public static Contract Premium = new Contract(4, Quality.UHD);
        public static Contract Standard = new Contract(2, Quality.HD);
        public static Contract Essential = new Contract(1, Quality.SD);
    
        public int Number;
        public Quality Quality;
    
        public Contract(int number, Quality quality) { Number = number; Quality = quality; }
    }

    public static string GetContract(int numDevices, Quality quality)
    {
        var desiredContract = new Contract(numDevices, quality);
    
        return desiredContract.Equals(Contract.Premium) ? "PREMIUM" :
          desiredContract.Equals(Contract.Standard) ? "STANDARD" :
          desiredContract.Equals(Contract.Essential) ? "ESSENTIAL" :
          "INVALID";
    }
}

Recent Moves:

vvishneuskivs. matthew-zhang-306

Find the right TV subscription

How about fix Open/Close principle violation?

Code

Diff

using System;
using System.Collections.Generic;
using System.Linq;

public enum Quality { SD, HD, UHD }

public class TV
{
    private class Contract
    {
        public string Type;
        public Func<int, Quality, bool> Condition;

        public static readonly IList<Contract> Types =
            new List<Contract>
            {
                new Contract { Type = "PREMIUM", Condition = (numDevices, quality) => numDevices == 4 && quality == Quality.UHD },
                new Contract { Type = "STANDARD", Condition = (numDevices, quality) => numDevices == 2 && quality == Quality.HD },
                new Contract { Type = "ESSENTIAL", Condition = (numDevices, quality) => numDevices == 1 && quality == Quality.SD },
                new Contract { Type = "INVALID", Condition = (numDevices, quality) => true }         
            };
    }

    public static string GetContract(int numDevices, Quality quality)
    {
        return Contract.Types.First(contract => contract.Condition(numDevices, quality)).Type;
    }
}

matthew-zhang-306vs. TheMoat

Find the right TV subscription

Using OP's description:

Premium: UltraHD and 4 devices
Standard: HD and 2 devices
Essential: 1 device

Fixed checks and added invalid case for a list of parameters that does not work. Changed the two bool parameters to an enum, since you probably won't be purchasing both HD and UHD simultaneously.

Code

Diff

using System;

public enum Quality { SD, HD, UHD }

public class TV
{
  public static string GetContract( int numDevices, Quality quality)
  {
    string result = "INVALID";
    
    if (numDevices == 4 && quality == Quality.UHD)
      result = "PREMIUM";
    else if (numDevices == 2 && quality == Quality.HD)
      result = "STANDARD";
    else if (numDevices == 1 && quality == Quality.SD)
      result = "ESSENTIAL";
    
    return result;
  }
}

Test Cases

Diff

namespace Solution {
  using NUnit.Framework;
  using System;

  [TestFixture]
  public class SolutionTest
  {
      [Test]
      public void TestMethodGetContract4()
      {
          var actual = TV.GetContract(4, Quality.SD);
          var expected = "INVALID";
          Assert.AreEqual(expected, actual);
      }
      
      [Test]
      public void TestMethodGetContract2()
      {
          var actual =  TV.GetContract(2, Quality.SD);
          var expected = "INVALID";
          Assert.AreEqual(expected, actual);
      }

      [Test]
      public void TestMethodGetContractSD()
      {
          var actual =  TV.GetContract(1, Quality.SD);
          var expected = "ESSENTIAL";
          Assert.AreEqual(expected, actual);
      }

      [Test]
      public void TestMethodGetContractUltraHD()
      {
          var actual =  TV.GetContract(4, Quality.UHD);
          var expected = "PREMIUM";
          Assert.AreEqual(expected, actual);
      }
      
      [Test]
      public void TestMethodGetContractHD()
      {
          var actual =  TV.GetContract(2, Quality.HD);
          var expected = "STANDARD";
          Assert.AreEqual(expected, actual);
      }
  }
}

TheMoat

Find the right TV subscription

here is the description of the 3 offers
ESSENTIAL : just one device
STANDARD : HD and 2 devices
PREMIUM : UltraHD and 4 devices

Write the code that returns the right offer

using System;

public class Kata
{
  

public static string GetContract( int numberOfDevices, bool ultraHd, bool hd)
        {
            string result = "ESSENTIEL";
            if (numberOfDevices>2 || ultraHd)
            {
                result = "PREMIUM";
            }
            else
            {
                if (numberOfDevices ==  2  || hd)
                {
                    result = "STANDARD";
                }
            }
            return result;

        }
}

namespace Solution {
  using NUnit.Framework;
  using System;

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

  [TestFixture]
  public class SolutionTest
  {
    [Test]
        public void TestMethodGetContract4()
        {
            var actual = Kata.GetContract(4, false, false);
            var expected = "PREMIUM";
            Assert.AreEqual(expected, actual);

        }
        [Test]
        public void TestMethodGetContract2()
        {

            var actual =  Kata.GetContract(2, false, false);

            var expected = "STANDARD";
            Assert.AreEqual(expected, actual);

        }

          [Test]
        public void TestMethodGetContract1()
        {

            var actual =  Kata.GetContract(1, false, false);
            var expected = "ESSENTIEL";
            Assert.AreEqual(expected, actual);

        }

        [Test]
        public void TestMethodGetContractUltraHD()
        {
            var actual =  Kata.GetContract(1, true, false);

            var expected = "PREMIUM";

            Assert.AreEqual(expected, actual);

        }
     [Test]
        public void TestMethodGetContractHD()
        {
            var actual =  Kata.GetContract(1, false, true);
            var expected = "STANDARD";
            Assert.AreEqual(expected, actual);

        }
  }
}

cmfletchervs. Jesus Iniguez

Am I yelling?

Simplified

Code

Diff

def AmIYelling(input_sentence):
    return all([ x.isupper() for x in input_sentence if x.isalpha() ])

Recent Moves:

FArekkusuvs. VictorCervantes

Am I yelling?

More pythonic version of your code.

Note: it's very inefficient solution. My fork of your previous solution takes 76 ms performing 100 tests on a string "A" * 10**6 while this one takes 10600 ms.

Code

Diff

import re

def AmIYelling(input_sentence):
    return not len(re.sub('[^a-z]', '', input_sentence))

1 1 import re
2 +
2 2 def AmIYelling(input_sentence):
3 - return True if(len(re.sub('[^a-z]','',input_sentence))==0) else False
4 + return not len(re.sub('[^a-z]', '', input_sentence))

VictorCervantesvs. fightingKofi

Am I yelling?

Code

Diff

import re
def AmIYelling(input_sentence):
    return True if(len(re.sub('[^a-z]','',input_sentence))==0) else False

FArekkusuvs. VictorCervantes

Am I yelling?

Code

Diff

def AmIYelling(input_sentence):
  return input_sentence == input_sentence.upper()

1 1 def AmIYelling(input_sentence):
2 - return input_sentence.isupper() or input_sentence.isdigit()
3 -
2 + return input_sentence == input_sentence.upper()

fightingKofivs. Jesus Iniguez

Am I yelling?

Test Cases

Diff

test.assert_equals(AmIYelling("HELLO"),True)
test.assert_equals(AmIYelling("YES IM STILL YELLING"),True)
test.assert_equals(AmIYelling("No Im not yelling"),False)
test.assert_equals(AmIYelling("neither now"),False)
test.assert_equals(AmIYelling("BUT I AM NOW!!!!"),True)
test.assert_equals(AmIYelling("1234"),True)
test.assert_equals(AmIYelling("1234!!"),True)

biubiudivvs. JakeMaldo

Find the only different number in the array

Fundamentals

Arrays

Code

Diff

function findOnly(arr) {
  let result = 0;
  arr.forEach((i) => {
    result = i ^ result;
  });
  return result;
}

Test Cases

Diff

Test.assertEquals(findOnly([1,2,3,1,2,3,4]), 4, "looks like its wrong.");
Test.assertEquals(findOnly([5,5,6,6,1,15,15,10,10]), 1, "looks like its wrong.");
Test.assertEquals(findOnly([-1,-1,-1,10,15,10,15]), -1, "looks like its wrong.");

Recent Moves:

JakeMaldovs. virtualcopyright

getSum of array - piece of cake :)

Fundamentals

Arrays

Code

Diff

function getSum(array) {
  return array.reduce((total, num) => total += num);
}

1 1 function getSum(array) {
2 - //your code
2 + return array.reduce((total, num) => total += num);
3 3 }

virtualcopyrightFailed Tests

getSum of array - piece of cake :)

Fundamentals

Arrays

Get the sum of all integers in the given array... and return it.

function getSum(array) {
   //your code
}

Test.assertEquals(getSum([5,9,4,1]), 19, "looks like its wrong.");
Test.assertEquals(getSum([4,0,4,50,8]), 66, "looks like its wrong.");
Test.assertEquals(getSum([5,9,4,1,9,1,1,1,4,10]), 45, "looks like its wrong.");

ageersvs. michwii

1 - Qui est le meilleur prof

Code

Diff

function quiEstLeMeilleurProf(){
  return 'Mon prof de programmation Web';
}

1 1 function quiEstLeMeilleurProf(){
2 - return "Mon prof de programmation Web";
2 + return 'Mon prof de programmation Web';
3 3 }

Recent Moves:

michwiivs. michwiiFailed Tests

1 - Qui est le meilleur prof

Code

Diff

function quiEstLeMeilleurProf(){
  return "Mettez ici votre code";
}

1 1 function quiEstLeMeilleurProf(){
2 - return "Mon prof de programmation Web";
2 + return "Mettez ici votre code";
3 3 }

michwiiFailed Tests

1 - Qui est le meilleur prof

Il faut créer une fonction qui s'appelle quiEstLeMeilleurProf et qui retourne la phrase suivante : "Mon prof de programmation Web"

function quiEstLeMeilleurProf(){
  return "Mon prof de programmation Web";
}

// PHPUnit Test Examples:
// TODO: Replace examples and use TDD development by writing your own tests
class MyTestCases extends TestCase
{
    // test function names should start with "test"
    public function testThatSomethingShouldHappen() {
      $this->assertEquals("Mon prof de programmation Web", quiEstLeMeilleurProf());
    }
}

ageersvs. seguun

seguun's Kumite #2

Code

Diff

```
echo'ss';
```
1 - echo 'ss';
1 + echo'ss';

Recent Moves:

seguun

seguun's Kumite #2

echo 'ss';
// PHPUnit Test Examples:
// TODO: Replace examples and use TDD development by writing your own tests
class MyTestCases extends TestCase
{
    // test function names should start with "test"
    public function testThatSomethingShouldHappen() {
      $this->assertEquals("a", "a");
      $this->assertEquals([0], [0]);
    }
}

Yaz-0vs. matthew-zhang-306

Bigger number

Code

Diff

import java.lang.Math;
public class BiggerNum{

  /**
   * @param a integer of param1
   * @param b integer of param2
   * @return the bigger integer of a and b
   * If a equals b, return either one
   */
  public static int compare(int a, int b) {
    return Math.max(a,b);
  }
}

Recent Moves:

matthew-zhang-306vs. tarkhnas

Bigger number

Using Math.max

Code

Diff

public class BiggerNum{

  /**
   * @param a integer of param1
   * @param b integer of param2
   * @return the bigger integer of a and b
   * If a equals b, return either one
   */
  public static int compare(int a, int b) {
    return Math.max(a,b);
  }
}

Test Cases

Diff

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

public class SolutionTest {

    @Test
    public void should_return_a_when_a_gt_b() {
        int a = 10;
        int b = 5;
        assertEquals(a, BiggerNum.compare(a, b));
    }
    
    @Test
    public void should_return_b_when_a_lt_b() {
        int a = 4;
        int b = 5;
        assertEquals(b, BiggerNum.compare(a, b));
    }
    
    @Test
    public void should_return_either_when_a_eq_b() {
        int a = 5;
        int b = 5;  
        assertEquals(5, BiggerNum.compare(a, b));
    }
}

tarkhnasvs. gabe777

Big number

Code

Diff

public class BiggerNum{

  /**
   * @param a integer of param1
   * @param b integer of param2
   * @return the bigger integer of a and b
   * If a equals b, eiter one is acceptance
   */
  public static int compare(int a, int b) {
    return a >= b ? a : b;
  }
}

Test Cases

Diff

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

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

public class SolutionTest {

    @Test
    public void should_return_a_when_a_gt_b() {
    
        int a = 10;
        int b = 5;
        
        assertEquals(a, BiggerNum.compare(a, b));
    }
    
    @Test
    public void should_return_b_when_a_lt_b() {
    
        int a = 4;
        int b = 5;
        
        assertEquals(b, BiggerNum.compare(a, b));
    }
    
    @Test
    public void should_return_either_when_a_eq_b() {
    
        int a = 5;
        int b = 5;
        
        assertEquals(5, BiggerNum.compare(a, b));
    }
}

gabe777vs. vsukarieh

Big number

Code

Diff

public class BiggerNum{

  public static int compare(int a, int b) {
    if(a > b){
      return a;
    }else{
      return b;
    }
  }
}

1 1 public class BiggerNum{
2 2
3 3 public static int compare(int a, int b) {
4 4 if(a > b){
5 5 return a;
6 - }else if(a < b){
6 + }else{
7 7 return b;
8 - }else return a;
8 + }
9 9 }
10 -
11 11 }

vsukariehvs. tarkhnas

Big number

return the bigger number between the two parameters.
if numbers are equal return anyone on them.

Code

Diff

public class BiggerNum{

  public static int compare(int a, int b) {
    if(a > b){
      return a;
    }else if(a < b){
      return b;
    }else return a;
  }

}

1 1 public class BiggerNum{
2 2
3 3 public static int compare(int a, int b) {
4 - return 0;
4 + if(a > b){
5 + return a;
6 + }else if(a < b){
7 + return b;
8 + }else return a;
5 5 }
6 6
7 7 }

Test Cases

Diff

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

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

public class SolutionTest {

    @Test
    public void testSomething() {
    
        int a = 10;
        int b = 5;
        
        assertEquals(10, BiggerNum.compare(a, b));
    }
}

fightingKofivs. nithin5426

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

Alternative using lists utilizing previous idea of reversion to avoid sorting. Missing test for number with integer square root added.

Code

Diff

from math import sqrt
def divisors(n):
    fa = [i for i in range(1, int(sqrt(n)) + 1) if not (n%i)]
    fa.extend([n//i for i in reversed(fa) if n//i > i])
    return fa

Test Cases

Diff

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 = 4" )
test.assert_equals(divisors(4), [1, 2, 4], 'Naive concatenation of lo [1,2] and high [2,4] factors will produce duplicity [1,2,2,4]')

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

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

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

from random import randint

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

Recent Moves:

VictorCervantesvs. nithin5426

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

Code

Diff

def divisors(n):
    a,x = [],0
    for i in range(1,int(n**0.5) + 1): 
        if not(n%i): 
            a.insert(x,i)
            x+=1
            a.insert(x,n//i)
    return a

nithin5426vs. petersowa

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

Code

Diff

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)

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)

Code

Diff

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.

Code

Diff

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

VictorCervantesvs. sirexo

Add them Together

Code

Diff

def add(s, o):
    s = map(int, s)
    s = {
        1: (c for c in s if c % 2),
        2: (c for c in s if not c % 2),
    }.get(o, s);
    return sum(s)

1 1 def add(s, o):
2 2 s = map(int, s)
3 3 s = {
4 4 1: (c for c in s if c % 2),
5 - 2: (c for c in s if c % 2 == 0),
5 + 2: (c for c in s if not c % 2),
6 6 }.get(o, s);
7 7 return sum(s)

Recent Moves:

sirexovs. z0rz1

Add them Together

Code

Diff

def add(s, o):
    s = map(int, s)
    s = {
        1: (c for c in s if c % 2),
        2: (c for c in s if c % 2 == 0),
    }.get(o, s);
    return sum(s)

z0rz1vs. VictorCervantes

Add them Together

Code

Diff

def add(s, o):
    return {
        0: sum(int(c) for c in s),
        1: sum(int(c) for c in s if int(c)%2),
        2: sum(int(c) for c in s if not(int(c)%2))
    }.get(o, 0);

VictorCervantesvs. gentcheva

Add them Together

Code

Diff

def add(s, o):
    if o == 0: return sum(int(c) for c in s)
    elif o == 1: return sum(int(c) for c in s if int(c)%2)
    elif o == 2: return sum(int(c) for c in s if not(int(c)%2))
    else: return 0

Test Cases

Diff

test.assert_equals(add("1234567" , 0),28)
test.assert_equals(add("1234567" , 1),16)
test.assert_equals(add("1234567" , 2),12)
test.assert_equals(add("0" , 2),0)
test.assert_equals(add("0" , 1),0)
test.assert_equals(add("0" , 0),0)
test.assert_equals(add("0" , 3),0)
test.assert_equals(add("23232323" , 2),8)
test.assert_equals(add("23232323" , 1),12)

micho213vs. gentcheva

Add them Together

Code

Diff

def add(string, option):
    odd,even = 0,0
    for x in string:
        x = int(x)
        if x%2 ==0:even+=x
        if x%2 ==1:odd+=x
    if option ==0:
        return odd+even
    return even if option == 2 else odd

Test Cases

Diff

test.assert_equals(add("1234567", 0),28)
test.assert_equals(add("1234567", 1),16)
test.assert_equals(add("1234567", 2),12)

fightingKofivs. micho213

Print a square of characters

Code

Diff

def square(n):
    result = (("*" *n+"\n")*n)[:-1]
    print(result) # ...write a function that prints...
    return result # result to be tested

Test Cases

Diff

# TODO: Given a number n, write a function that prints a square of '*' having side n
# 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.it('Basic tests')
test.assert_equals(square(2),'**\n**')
test.assert_equals(square(5),'*****\n*****\n*****\n*****\n*****')
test.assert_equals(square(4),'****\n****\n****\n****')
test.assert_equals(square(0),'')

Recent Moves:

forsureitsmevs. micho213

Print a square of characters

Print a square of numbers, but in a string rather then a list.

~~Improvement ideas, add a second parameter to choose whether the output should be a list or string.~~

Code

Diff

def square(n,s=0):
    l=["*"*n]*n
    return '\n'.join(l) if s else l

1 - def square(n):
2 - print(("*" *n+"\n")*n) # to see the result
3 -
4 - return (("*" *n+"\n")*n)[:-1]
5 -
1 + def square(n,s=0):
2 + l=["*"*n]*n
3 + return '\n'.join(l) if s else l

Test Cases

Diff

test.assert_equals(square(2,1),"**\n**")
test.assert_equals(square(5,1),'*****\n*****\n*****\n*****\n*****')
test.assert_equals(square(4,1),'****\n****\n****\n****')
test.assert_equals(square(2),["**","**"])
test.assert_equals(square(5),["*****","*****","*****","*****","*****"])
test.assert_equals(square(4),["****","****","****","****"])

micho213vs. ClaudiuRoland

Print a square of characters

print a square of numbers but in a string rather then a list.

improvement ideas, add a second parameter to choose whether the output should be a list or string.

Code

Diff

def square(n):
    print(("*" *n+"\n")*n) # to see the result
    
    return (("*" *n+"\n")*n)[:-1]

Test Cases

Diff

# TODO: Given a number, write a function that prints a square with the caracter '*'
# These are some of the methods available:
#   test.expect(boolean, [optional] message)
#   test.assert_equals(actual, expected, [optional] message)
#   test.assert_not_equals(actual, expected, [optional] message)

# You can use Test.describe and Test.it to write BDD style test groupings


# test.assert_equals(square(2),['**', '**'])
# test.assert_equals(square(3),['***', '***', '***'])
# test.assert_equals(square(4),['****', '****', '****', '****'])
# test.assert_equals(square(5),['*****', '*****', '*****', '*****', '*****'])

test.assert_equals(square(2),"**\n**")
test.assert_equals(square(5),'*****\n*****\n*****\n*****\n*****')
test.assert_equals(square(4),'****\n****\n****\n****')

ofourniervs. JonasP

Print a square of characters

Code

Diff

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

JonasPvs. ClaudiuRoland

Print a square of characters

Code

Diff

def square(n):
    return ['*' * n for x in range(0,n)]

fightingKofivs. basselch

kilograms to grams with infix and/or ratio usage

Numbers

Code

Diff

def kilogramsToGrams(kilograms=1):
    return kilograms * 1000

1 - def kilogramsToGrams(kilograms):
1 + def kilogramsToGrams(kilograms=1):
2 2 return kilograms * 1000

Test Cases

Diff

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

# You can use Test.describe and Test.it to write BDD style test groupings

test.assert_equals(kilogramsToGrams(1), 1000)
test.assert_equals(kilogramsToGrams(1.365), 1365)

kilograms = 0.126
grams = 126
test.assert_equals(kilograms*kilogramsToGrams(), grams)

Recent Moves:

basselchvs. stacode

kilograms to grams

Numbers

Code

Diff

def kilogramsToGrams(kilograms):
    return kilograms * 1000

1 - def kilotograms(kilograms):
2 - pass
1 + def kilogramsToGrams(kilograms):
2 + return kilograms * 1000

Test Cases

Diff

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

# You can use Test.describe and Test.it to write BDD style test groupings

test.assert_equals(kilogramsToGrams(1), 1000)
test.assert_equals(kilogramsToGrams(1.365), 1365)

stacodeFailed Tests

kilograms to grams

Numbers

create a program that changes kilograms to grams

def kilotograms(kilograms):
    pass

fightingKofivs. FArekkusu

Being smart with Python complex numbers

Code

Diff

def hypotenuse(a, b):
    return abs(complex(a, b))

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

Recent Moves:

VictorCervantesvs. TechieGirl

The Pythagorean Theorem

Code

Diff

def hypotenuse(a,b):
    return round((a**2 + b**2)**0.5,4)

1 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
2 + return round((a**2 + b**2)**0.5,4)

Blind4Basicsvs. nithin5426

Being smart with Python complex numbers

Code

Diff

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

nithin5426vs. FArekkusu

Being smart with Python complex numbers

being smarter

Code

Diff

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.

Code

Diff

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 Cases

Diff

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)

zlukevs. Dorteel

Population tracking

Mathematics

Algorithms

Numbers

Fundamentals

Code

Diff

def population_tracking(i, c, n):
    return -(-i*((1+(c/100))**(n))//1)

1 - import math
2 -
3 3 def population_tracking(i, c, n):
4 - return math.ceil(i*((1+(c/100))**(n)))
2 + return -(-i*((1+(c/100))**(n))//1)

Recent Moves:

Dorteel

Population tracking

Mathematics

Algorithms

Numbers

Fundamentals

Given an integer representing the initial population size i, and the yearly change in the population c (in percentages), return what the population size will be at the end of the n^th year.

Example:

The initial population is 1000, and the yearly change is -10%. The population after one year is going to be 900.

Remember to round up your result, as population cannot be floating point number.

import math

def population_tracking(i, c, n):
    return math.ceil(i*((1+(c/100))**(n)))

Test.assert_equals(population_tracking(1000,-10,1), 900)
Test.assert_equals(population_tracking(400,15,3), 609)
Test.assert_equals(population_tracking(500,25,4), 1221)

VictorCervantesvs. jayeshcp

Merge Sort

Code

Diff

class Sort:

    def merge_sort(self, nums):
        if nums == None: return None
        elif len(nums) <= 1: return nums
      
        vLeft = self.merge_sort(nums[:len(nums) // 2])
        vRight= self.merge_sort(nums[len(nums) // 2:])                 
        lLeft,lRight = len(vLeft),len(vRight)
        i,j,k = 0,0,0
        
        while i < lLeft and j < lRight:
            if vLeft[i] < vRight[j]:
                nums[k] = vLeft[i]
                i += 1
            else:
                nums[k] = vRight[j]
                j += 1
            k += 1

        while i < lLeft:
            nums[k] = vLeft[i]
            i += 1
            k += 1

        while j < lRight:
            nums[k] = vRight[j]
            j += 1
            k += 1

        return nums

micho213Failed Tests

Area and perimeter of " * "

given a list of lists. each inner list is same size.
they can represent a square or a rectangle.

return information about it.

return its perimeter , area,total number of "*", rectangle/square

s = "*"
array = [[s,s,s,s],[s,s,s,s],[s,s,s,s],[s,s,s,s]]

===> permimeter = 16 ,area = 16, "*" = 16 , "square"

def determine_params(list):
    
    return #its perimeter , area,total number of "*", rectangle/square

# s = "*"
# array = [[s,s,s,s],[s,s,s,s],[s,s,s,s],[s,s,s,s]]
# test.assert_equals(determine_params(array),16,16,16,"square")

sir_kambavs. kmactavish

Hello Julia!

Changed from a static variable to a dynamic function.

Code

Diff

module Solution
  export greet

  function greet( whom::String )
    "Hello " * whom * "!"  
  end
  
end

1 - println("Hello Julia!")
2 - const hello = "world"
1 + module Solution
2 + export greet
3 +
4 + function greet( whom::String )
5 + "Hello " * whom * "!"
6 + end
7 +
8 + end

Test Cases

Diff

using FactCheck
facts("greetings") do
  @fact Solution.greet("world") --> "Hello world!"
  @fact Solution.greet("Julia") --> "Hello Julia!"
  @fact Solution.greet("Fred")  --> "Hello Fred!"
  @fact Solution.greet("Kmactavish") --> "Hello Kmactavish!"
end

Recent Moves:

kmactavishFailed Tests

Hello Julia!

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

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

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

micho213vs. micho213

Find distance between x and y

Code

Diff

def distance(a):
    y,y1 = 0,0
    for i in range(len(a)):
        if "y" in a[i]: y = i
        if "x" in a[i]: y1 = i
        
    x ,x1 = a[y].index("y"), a[y1].index("x")
    return abs(x -x1) + abs(y-y1)

Recent Moves:

micho213vs. VictorCervantesFailed Tests

Find distance between x and y

array should always have "y" and "x"

Code

Diff

def distance(array):
    for i in range(len(array)):
        if "y" in array[i] : y = abs(array[i].index("y") - i)  
        if "x" in array[i] : x = abs(array[i].index("x") - i)  
    return (x+y)

1 1 def distance(array):
2 2 for i in range(len(array)):
3 3 if "y" in array[i] : y = abs(array[i].index("y") - i)
4 4 if "x" in array[i] : x = abs(array[i].index("x") - i)
5 5 return (x+y)
6 +
7 +
8 +

Test Cases

Diff

array = [1,1,1,"y",1],[1,1,1,1,1],[1,1,"x",1,1],[1,1,1,1,1]
test.assert_equals(distance(array),3)

array = [1,1,1,1,"y"],[1,1,1,1,1],[1,1,"x",1,1],[1,1,1,1,1]
test.assert_equals(distance(array),4)

array = [1,1,1,1,"y",1,1],[1,1,1,1,"x",1,1],[1,1,1,1,1,1,1],[1,1,1,1,1,1,1],[1,1,1,1,1,1,1],[1,1,1,1,1,1,1]
test.assert_equals(distance(array),1)

array = [1,"y",1],[1,1,1],[1,1,"x"]
test.assert_equals(distance(array),3)

VictorCervantesvs. micho213

Find distance between x and y

Code

Diff

def distance(array):
    for i in range(len(array)):
        if "y" in array[i] : y = abs(array[i].index("y") - i)  
        if "x" in array[i] : x = abs(array[i].index("x") - i)  
    return (x+y)

micho213

Find distance between x and y

cannot go diagonally

array = [1,1,1,y,1],
[1,1,1,1,1],
[1,1,x,1,1],
[1,1,1,1,1]

here you have to make 3 moves to get from y to x

def distance(array):
    y = 0
    y1 = 0
    for inner_list in range(len(array)):
        if "y" in array[inner_list]:
            y = inner_list
        if "x" in array[inner_list]:
            y1 = inner_list
            
    x = array[y].index("y")
    x1 = array[y1].index("x")
    dist = abs(x -x1) + abs(y-y1)
    return dist

array = [1,1,1,"y",1],[1,1,1,1,1],[1,1,"x",1,1],[1,1,1,1,1]
test.assert_equals(distance(array),3)

array = [1,1,1,1,"y"],[1,1,1,1,1],[1,1,"x",1,1],[1,1,1,1,1]
test.assert_equals(distance(array),4)

VictorCervantesvs. Jaieden

Project Euler: Problem 1

Code

Diff

#ORDEN O(1) SIN FOR, #Usado en Katas Anteriores por otro colaborador solo
#lo aplique para Python. 
def euler(n): return getMult(3,n-1) + getMult(5,n-1) - getMult(15,n-1)
def getMult(multiple, n): return getArith(multiple, n - n%multiple, int(n/multiple))
def getArith(first,last,count): return count * (first + last)/2

Recent Moves:

ShiellJonathanvs. ShiellJonathan

Project Euler: Problem 1

Yet another one-liner.

Code

Diff

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

ShiellJonathanvs. ShiellJonathan

Project Euler: Problem 1

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

Code

Diff

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?

Code

Diff

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.

Code

Diff

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 Cases

Diff

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)

VictorCervantesvs. FArekkusu

Fizz Buzz algorithm in Python

Code

Diff

def fizz_buzz(n):
    return ['FizzBuzz' if (i % 15 == 0) else 'Fizz' if(i % 3 == 0) else 'Buzz' if(i % 5 == 0) else i for i in range(1,n)]

Recent Moves:

FArekkusuvs. bzajcev

Fizz Buzz algorithm in Python

Code

Diff

def fizz_buzz(n):
    for i in range(1, n):
        yield "Fizz" * (i % 3 == 0) + "Buzz" * (i % 5 == 0) or i

Test Cases

Diff

actual = list(fizz_buzz(17))
expected = [1, 2, 'Fizz', 4, 'Buzz', 'Fizz', 7, 8, 'Fizz', 'Buzz', 11, 'Fizz', 13, 14, 'FizzBuzz', 16]

Test.assert_equals(actual, expected)

bzajcevvs. AaronPope

Fizz Buzz algorithm in Python

use of a generator

Code

Diff

def fizzBuzz(num):
    for i in range(1,num):
        yield ("Fizz Buzz" if i % 3 == 0 and i % 5 == 0 else ("Fizz" if i % 3 == 0 else ("Buzz" if i % 5 == 0 else i)))

list = list(fizzBuzz(17))

AaronPopevs. AaronPope

Fizz Buzz algorithm in Python

Took a small trade-off in increasing the number of iterations by starting at 0 instead of 1, but increased the readability by not having to subtract 1 to reference the correct index.

Code

Diff

list = list(range(17))

for i in list :
    if i % 15 == 0 :
        list[i] = 'Fizz Buzz'
    elif i % 3 == 0 :
        list[i] = 'Fizz'
    elif i % 5 ==0 :
        list[i] = 'Buzz'

list = list[1::]
for i in list:
    print(i)

AaronPopevs. ClaudiuRoland

Fizz Buzz algorithm in Python

Changed the tuple to a list
Now modifies the list values for the purpose of being able to run a test against the final values

Code

Diff

list = [1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16]

for i in list :
    if i % 15 == 0 :
        list[i-1] = 'Fizz Buzz'
    elif i % 3 == 0 :
        list[i-1] = 'Fizz'
    elif i % 5 ==0 :
        list[i-1] = 'Buzz'
        
    print(list[i-1])

Test Cases

Diff

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

# You can use Test.describe and Test.it to write BDD style test groupings

test.assert_equals(
    list,
    [1, 2, 'Fizz', 4, 'Buzz', 'Fizz', 7, 8, 'Fizz', 'Buzz', 11, 'Fizz', 13, 14, 'Fizz Buzz', 16]
)

VictorCervantesvs. Jesus Iniguez

Get the longest word in a list

Code

Diff

def getLongestWord(words):
    return '' if len(words) == 0 else max(words, key=len)

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 '' if len(words) == 0 else max(words, key=len)
3 +

Recent Moves:

ofourniervs. Jesus Iniguez

Get the longest word in a list

Code

Diff

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="")

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")

matthew-zhang-306vs. TX404

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

Here's a solution to the problem that uses no for loops, reducing O(n) to O(1).

The basic logic behind this code is that there is a formula for the sum of any arithmetic sequence, for example:

3 + 6 + 9 + 12 + ... + n*3 (where n is a natural number) = n * (3 + n*3) / 2

If we sum all the multiples of 3 and the multiples of 5 this way, we can get close to the answer. But we would be double counting all multiplies of 3*5 = 15, so we use the same formula to subtract out the sum of the multiples of 15.

Hope this helps!

Code

Diff

let arithSum = (firstNum, lastNum, count) => count * (firstNum + lastNum) / 2;

let getMultSum = (multiple, n) => arithSum(multiple, n - n%multiple, Math.trunc(n/multiple));

let test = (n) => getMultSum(3,n-1) + getMultSum(5,n-1) - getMultSum(15,n-1); // using n-1 because the problem specifies all multiples strictly *less than* the input

Test Cases

Diff

Test.assertDeepEquals(test(27),168);
Test.assertDeepEquals(test(11),33);
Test.assertDeepEquals(test(10),23);
Test.assertDeepEquals(test(0),0);
Test.assertDeepEquals(test(2),0);
Test.assertDeepEquals(test(4),3);
Test.assertDeepEquals(test(100000000),2333333316666668); // note that if my code is atrociously incorrect for large numbers, this test case is a blatant lie

Recent Moves:

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.

Code

Diff

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

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 .....

Code

Diff

//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 Cases

Diff

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);

matthew-zhang-306vs. SerzN1

Convert Minutes to Hours and Minutes

Fundamentals

Strings

A different approach from the one above, done in one line.

Code

Diff

const minutes = i => `${Math.trunc(i / 60)}:${i % 60 < 10 ? "0" : ""}${i % 60}`;

Recent Moves:

SerzN1vs. Emgo-Dev

Convert Minutes to Hours and Minutes

Fundamentals

Strings

Code

Diff

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));

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'

Code

Diff

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

Test Cases

Diff

#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

Code

Diff

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

Code

Diff

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 Cases

Diff

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

michwii

michwii's Kumite #3

Il faut créer une fonction qui s'appelle quiEstLeMeilleurProf et qui retourne la phrase suivante : "Mon prof de programmation Web"

function quiEstLeMeilleurProf(){
  return "Mon prof de programmation Web";
}

// PHPUnit Test Examples:
// TODO: Replace examples and use TDD development by writing your own tests
class MyTestCases extends TestCase
{
    // test function names should start with "test"
    public function testThatSomethingShouldHappen() {
      $this->assertEquals("Mon prof de programmation Web", quiEstLeMeilleurProf());
    }
}

jerzyk84vs. t.bhandal

mwglobal's Kumite #3

Code

Diff

```
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

Code

Diff

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

Code

Diff

```
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

Code

Diff

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

Code

Diff

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

Code

Diff

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

Recent Moves:

t.bhandalvs. ofournier

Add two number

Code

Diff

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

ofourniervs. oskarz1234

Add two number

Code

Diff

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

oskarz1234vs. wasiel

Add two number

Code

Diff

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

Test Cases

Diff

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

Add two number

add

def add(a,b):
    return 1

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

ofourniervs. mwglobal

mwglobal's Kumite #2

Code

Diff

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

dmilonvs. IamRodrigue

Average Grade

Code a function that will return the exact average grade of an array of grades. Grades can be integer or float numbers.

Code

Diff

def average(grades)
  grades.sum.fdiv(grades.length)
end

1 - def average (grades)
2 - grade.sum/grade.length
1 + def average(grades)
2 + grades.sum.fdiv(grades.length)
3 3 end

Test Cases

Diff

# 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)
Test.assert_equals(average([1, 2, 3]), 2)
Test.assert_equals(average([2, 3]), 2.5)
Test.assert_not_equals(average([2, 3]), 2)

Recent Moves:

IamRodrigueFailed Tests

Average Grade

Create a function that will return the average grade of a an array of students grades.

def average (grades)
grade.sum/grade.length
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)

FaBrandvs. swift4096

Is my password strong?

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.

Code

Diff

#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();
}

Test Cases

Diff

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.

Code

Diff

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;
}

Test Cases

Diff

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.

Code

Diff

#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?

Code

Diff

#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.

Code

Diff

#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;
  }

}

Test Cases

Diff

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

Code

Diff

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

Test Cases

Diff

// 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

Code

Diff

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

Code

Diff

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

v1zvs. v1z

Find all dividors of a number

Algorithms

Code

Diff

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
  
}

Test Cases

Diff

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

Code

Diff

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]");
  });
});

user766627vs. አወል እሸቱ

Last Char

Strings

Code

Diff

```
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

Code

Diff

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

Code

Diff

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

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

Jay-9vs. jjsullivan5196

Last Char

Strings

Return the last character from a string.

In Rust return an Option<char>.

Code

Diff

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

Code

Diff

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

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

Code

Diff

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");
    });
});

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.

Code

Diff

#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));
}

Test Cases

Diff

#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:

donaldsebleung

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

Code

Diff

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

Test Cases

Diff

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

Test Cases

Diff

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

Code

Diff

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

juanpitersonvs. erschus

Flatten an array of arrays

Algorithms

Code

Diff

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

SpyMaster356vs. pepellou

Can one stack make a queue?

Code

Diff

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 Cases

Diff

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() 😇

Code

Diff

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

Code

Diff

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();
  }
}

donaldsebleung

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)

Code

Diff

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

Test Cases

Diff

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)

Code

Diff

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);

Test Cases

Diff

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.

Code

Diff

// 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)}`;

Test Cases

Diff

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 ?

Code

Diff

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}`;

Test Cases

Diff

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)

Code

Diff

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}`;

Thamosvs. lukitahs

AirHunter007's Kumite #1

Code

Diff

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.

Code

Diff

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))

Test Cases

Diff

# 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.

Code

Diff

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!

Code

Diff

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!

Code

Diff

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#!

Code

Diff

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

Code

Diff

#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.

Code

Diff

#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

Code

Diff

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

Test Cases

Diff

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

 def add(string, option):
  even_list = []
  odd_list = []
  all_sum = 0
  for num in string:
  num = int(num)
  all_sum += num
  if num % 2 == 0:
  even_list.append(num)
  if num % 2 != 0:
  odd_list.append(num)
  if option == 0:
  return all_sum
  if option == 1:
  return sum(odd_list)
  if option == 2:
  return sum(even_list)
 def add(s, o):
  if o == 0: return sum(int(c) for c in s)
  elif o == 1: return sum(int(c) for c in s if int(c)%2)
  elif o == 2: return sum(int(c) for c in s if not(int(c)%2))
  else: return 0

 def square(n):
  l=''
  square1=[]
  for i in range(n):
  l+='*'
  for i in range(n):
  square1.append(l)
  for i in range(n):
  print(square1[i])
  return square1
  print(("*" *n+"\n")*n) # to see the result
  return (("*" *n+"\n")*n)[:-1]

 def square(n):
  l=''
  square1=[]
  for i in range(n):
  l+='*'
  for i in range(n):
  square1.append(l)
  for i in range(n):
  print(square1[i])
  return square1
  return ['*' * n for x in range(0,n)]

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

 function Generrate (n)
 {
 // I went ahead and added support for larger numbers over 999.
 // Uncomment lines below to get automatic support of bigger numbers:
  var out = "";
  var str_arrOfDigits = n.toString().split("");
  if (str_arrOfDigits[0] == "-")
  {
  out += "negative ";
  str_arrOfDigits.splice(0,1);
  }
  switch (str_arrOfDigits.length) {
  case 1:
  out += Digits(str_arrOfDigits[0]);
  break;
  case 2:
  out += getDoubleDigit(str_arrOfDigits);
  break;
  case 3:
  out += getTrippleDigit(str_arrOfDigits)
  break;
  default:
  return "unsupported number";
  break;
  }
  return out;
 };
 function Digits(n) {
  return ["zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine", "ten", "eleven", "twelve", "thirteen", "fourteen", "fifteen", "sixteen", "seventeen", "eighteen", "nineteen"][n];
 };
 function tens(n) {
  return ["zero", "ten", "twenty", "thirty", "fourty", "fifty", "sixty", "seventy", "eighty", "ninety"][n];
 };
 function getDoubleDigit (arr)
 {
  var out = "";
  if (arr[0] == "1") {
  out = Digits(arr.join().replace("," ,""));
  }
  else {
  if (arr[0] != "0")
  out = tens(arr[0]) + (arr[1] != "0"? " " + Digits(arr[1]): "");
  else
  out = Digits(arr[1]);
  }
  return out;
 const bigNumbers = [
  "",
 // "thousand",
 // "million",
 // "billion",
 // "trillion",
 // "quadrillion"
 ];
 function Generrate(number) {
  // the only time we pronounce zero is when the number is zero itself
  if (number === 0) return "zero";
  let result = "";
  if (number < 0) {
  result += "negative ";
  number *= -1;
  }
  const thousandMultiples = [];
  let thousands = number;
  while (thousands) {
  thousandMultiples.push(thousands % 1000);
  thousands = parseInt(thousands / 1000);
  }
  if (thousandMultiples.length > bigNumbers.length) {
  return "unsupported number";
  // return "Sorry, can't pronounce. The number is too big";
  }
  const wordsArray = thousandMultiples.map(
  (elem, ind) => pronounceHundreds(elem) + " " + bigNumbers[ind]
  );
  return (result + wordsArray.reverse().reduce((acc, cur) => acc + " " + cur)).trim();
 }
 function pronounceHundreds(i) {
  const hundreds = parseInt(i / 100);
  const tens = i % 100;
  let result = pronounceOnes(hundreds);
  if (hundreds) {
  result += " hundred";
  }
  // if number is not a pure hundred, add space and tens
  if (tens) {
  if (hundreds) {
  result += " and "; // added 'and' to pass the test. however not needed in American.
  // result += " ";
  }
  result += pronounceTens(tens);
  }
  return result;
 }
 function pronounceTens(i) {
  const tens = parseInt(i / 10);
  const ones = i % 10;
  let result = "";
  const tensWords = [
  "",
  pronounceTeens(ones),
  "twenty",
  "thirty",
  "fourty",
  "fifty",
  "sixty",
  "seventy",
  "eighty",
  "ninety"
  ];
  result += tensWords[tens];
  // numbers 21-99 need to be hyphenated
  if (ones && tens > 1) {
  result += "-";
  }
  if (ones && tens != 1) {
  result += pronounceOnes(ones);
  }
  return result;
 }
 function pronounceTeens(i) {
  return [
  "ten",
  "eleven",
  "twelve",
  "thirteen",
  "fourteen",
  "fifteen",
  "sixteen",
  "seventeen",
  "eighteen",
  "nineteen"
  ][i];
 }
 function getTrippleDigit (arr)
 {
  var firstDigit = Digits(arr[0]);
  var doubleDigits = getDoubleDigit(arr.splice(1));
  return (firstDigit != "zero"? firstDigit + " hundred" : "") + (firstDigit != "zero" && doubleDigits != "zero"? " and " + doubleDigits : (doubleDigits != "zero"? doubleDigits : ""));
 function pronounceOnes(i) {
  return [
  "",
  "one",
  "two",
  "three",
  "four",
  "five",
  "six",
  "seven",
  "eight",
  "nine"
  ][i];
 }

 print "Hello Perl!\n";
 use 5.020_000;
 say "Hello Perl!";

 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)
 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)

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

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

 def multiple(a,b):
  return a*b
 from operator import mul as multiple

	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)

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

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

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

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

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

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

 function hello() {
  return "world";
 }
 def hello
  "world"
 end

Kumite

Filter by Language:

Few links

Example: