Start a new Kumite
AllAgda (Beta)BF (Beta)CCFML (Beta)ClojureCOBOL (Beta)CoffeeScriptCommonLisp (Beta)CoqC++CrystalC#D (Beta)DartElixirElm (Beta)Erlang (Beta)Factor (Beta)Forth (Beta)Fortran (Beta)F#GoGroovyHaskellHaxe (Beta)Idris (Beta)JavaJavaScriptJulia (Beta)Kotlinλ Calculus (Beta)LeanLuaNASMNim (Beta)Objective-C (Beta)OCaml (Beta)Pascal (Beta)Perl (Beta)PHPPowerShell (Beta)Prolog (Beta)PureScript (Beta)PythonR (Beta)RacketRaku (Beta)Reason (Beta)RISC-V (Beta)RubyRustScalaShellSolidity (Beta)SQLSwiftTypeScriptVB (Beta)
Show only mine

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.

Ad
Ad
melissamcewenFailed Tests

Find Duplicates Using Reduce

Arrays
Data Types
Map/Reduce
Algorithms
Logic

For loops are commonly overused when other Javascript methods can lead to a cleaner and faster solution. A common example would be finding duplicates in an array.

This function called duplicates takes an array of numbers and returns a new array with the numbers duplicated in the original array ordered by value.

Your goal is to refactor this code to still find duplicates in an array and return those duplicates in a new array, but no longer use a for loop.

Note: numbers and their corresponding string representations should not be treated as duplicates (i.e., '1' !== 1).

Based on http://www.codewars.com/kata/find-duplicates/javascript

function duplicates(arr) {
  var out = [];  
  for(var x=0;x<arr.length-1;x++)
  {
    var ch = arr[x];
    for(var y=x+1;y<arr.length;y++)
    {
      var comp = arr[y];
      if (comp === ch && out.indexOf(comp) === -1)
      {
        out.push(comp);
        break;
      }
    }
  }
  out.sort();
  return out;
}
metasean

Euclidean distance

#FOR THE SLC JS LEARNERS 2015 STUDY GROUP

Complete the following merge function such that is behaves as described in the example below. Merge should take two arrays of numbers of identical length and a callback function.

var merge = function(array1, array2, callback){  
  //your code here.
}

var x = merge([1, 2, 3, 4], [5, 6, 7, 8], function(a, b){  
  return a + b;
});

//x should now equal [6, 8, 10, 12].

Now, use your merge function to complete the euclid function defined below. Euclid should take two arrays, each of which has an equal number of numerical elements, and return the euclidean distance between them. For a quick refresher on what Euclidean distance is, check here

var euclid = function(coords1, coords2){  
  //Your code here.
  //You should not use any loops and should
  //instead use your original merge function.
}

var y = euclid([1.2, 3.67], [2.0, 4.4]);

//y should now equal approximately 1.08.

var merge = function(array1, array2, callback){  
  var array3 = [];

  if (array1.length !== array2.length) {
    console.log("Array length mismatch");
    return new Error("Array length mismatch");
  } else {
    length = array1.length;
  }

  for (var i = 0; i < length; i++) {
    array3[i] = callback(array1[i], array2[i]);
  }
  return array3;
}

var x = merge([1, 2, 3, 4], [5, 6, 7, 8], function(a, b){  
  return a + b;
});

//x should now equal [6, 8, 10, 12].

var euclid = function(coords1, coords2){  
  //Your code here.
  //You should not use any loops and should
  //instead use your original merge function.
}

var y = euclid([1.2, 3.67], [2.0, 4.4]);

//y should now equal approximately 1.08.
jayeshcp

Most frequently appearing number in given array

Example:

Find first most frequently occuring number in given array.

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

import java.util.*;

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

Polymorphism in PHP

A couple who work on a farm have asked you to create a program for them that will allow to them store the types of animals they have on the farm, these include:

-Cows
-Chickens
-Pigs

Using interfaces we can make the process of creating the classes for each animal easier. By using an animal interface we can group the animals together in the code.

interface AnimalsInterface
{
    public function getLegs();
    public function setLegs($noOfLegs);
    public function getDiet();
    public function setDiet($foodTheyEat);
}

class Cow implements AnimalsInterface
{
    private $legs;
    private $diet;
    
    public function getLegs()
    {
        return $this->legs;
    }
    public function setLegs($noOfLegs)
    {
        $this->legs = $noOfLegs;
        return $this;
    }
    public function getDiet()
    {
        return $this->diet;
    }
    public function setDiet($foodTheyEat)
    {
        $this->diet = $foodTheyEat;
        return $this;
    }
}

class Chicken implements AnimalsInterface
{
    private $legs;
    private $diet;
    
    public function getLegs()
    {
        return $this->legs;
    }
    public function setLegs($noOfLegs)
    {
        $this->legs = $noOfLegs;
        return $this;
    }
    public function getDiet()
    {
        return $this->diet;
    }
    public function setDiet($foodTheyEat)
    {
        $this->diet = $foodTheyEat;
        return $this;
    }
}

class Pig implements AnimalsInterface
{
    private $legs;
    private $diet;
    
    public function getLegs()
    {
        return $this->legs;
    }
    public function setLegs($noOfLegs)
    {
        $this->legs = $noOfLegs;
        return $this;
    }
    public function getDiet()
    {
        return $this->diet;
    }
    public function setDiet($foodTheyEat)
    {
        $this->diet = $foodTheyEat;
        return $this;
    }
}

class Farm
{
    private $animals = [];
    
    public function addAnimal(AnimalsInterface $animal)
    {
        array_push($this->animals, $animal)
    }
    public function displayAnimals()
    {
        foreach($this->animals as $animal) {
            echo $animal->getLegs();
            echo $animal->getDiet();
        }
    }
}

$cow = new Cow();
$cow->setLegs(4)->setDiet('Grass');
$chicken = new Chicken();
$chicken->setLegs(2)->setDiet('Seeds');
$pig = new Pig();
$pig->setLegs(4)->setDiet('Corn');
$farm = new Farm;
$farm->addAnimal($cow);
$farm->addAnimal($chicken);
$farm->addAnimal($pig);
$farm->displayAnimal();
jayeshcp

Selection Sort

Sorting
Algorithms
Logic

Implementation of Selection Sort.

  • Time Complexity: O(n^2)
  • Space Complexity: O(1)
  • Useful when list size is small
  • Preferable to insertion sort in terms of number of writes (O(n) swaps versus O(n2) swaps), it almost always far exceeds (and never beats) the number of writes that cycle sort makes, as cycle sort is theoretically optimal in the number of writes. This can be important if writes are significantly more expensive than reads, such as with EEPROM or Flash memory, where every write lessens the lifespan of the memory.
  • Wiki Link: Selection Sort 
class Sort:

    def selection_sort(self, nums):
        if nums == None: return None

        for i in range(0, len(nums) - 1):
            minIndex = i

            for j in range(i + 1, len(nums)):
                if nums[j] < nums[minIndex]:
                    minIndex = j

            nums[i], nums[minIndex] = nums[minIndex], nums[i]
        return nums
jayeshcp

Insertion Sort

Sorting
Algorithms
Logic

Implementation of Insertion Sort.

  • Time Complexity: Worst case: O(n^2), Best case: O(n)

  • Space Complexity: O(1)

  • Useful when list size is small.

  • only scans as many elements as needed to determine the correct location.

  • More efficient than bubble or selection sort.

  • Efficient for data sets that are already substantially sorted.

  • Requires more writes because the inner loop can require shifting large sections of the sorted portion of the array.

  • Can sort a list as it receives it.

  • Wiki Link: Insertion Sort

class Sort:

    def insertion_sort(self, nums):
        if nums is None:
            return None

        for i in range(1, len(nums)):
            currentvalue = nums[i]
            position = i

            while position > 0 and nums[position - 1] > currentvalue:
                nums[position] = nums[position - 1]
                position -= 1

            nums[position] = currentvalue
        return nums
jayeshcp

Merge Sort

Implementation of Merge Sort.

  • Time Complexity: O(n log(n))

  • Space Complexity: O(n)

  • Preserves the input order of equal elements in the sorted output.

  • Type of Divide-and-Conquer algorithm.

  • Efficient at handling slow-to-access sequential media.

  • Well-suited for sorting huge amounts of data that does not fit into memory.

  • Wiki Link: Merge Sort

class Sort:

    def merge_sort(self, nums):
        if nums == None: return None

        if len(nums) > 1:
            mid = len(nums) // 2
            lefthalf = nums[:mid]
            righthalf = nums[mid:]

            self.merge_sort(lefthalf)
            self.merge_sort(righthalf)

            i = 0
            j = 0
            k = 0

            while i < len(lefthalf) and j < len(righthalf):
                if lefthalf[i] < righthalf[j]:
                    nums[k] = lefthalf[i]
                    i += 1
                else:
                    nums[k] = righthalf[j]
                    j += 1
                k += 1

            while i < len(lefthalf):
                nums[k] = lefthalf[i]
                i += 1
                k += 1

            while j < len(righthalf):
                nums[k] = righthalf[j]
                j += 1
                k += 1

        return nums
jayeshcp

Power of Two

Write a function that determines if given number is a power of two. A power of two means a number of the form 2^n where n is an integer, i.e. the result of exponentiation with number two as the base and integer n as the exponent. i.e. 1024 is a power of two: it is 2^10.

Example:

power_of_two(4096) # true

power_of_two(333) # false

def power_of_two( n ):
  return n & ( n - 1 ) == 0
bkaes

bkaes's Kumite #222

-- placeholder
Saka7

Groovy: Hash Map Example

Maps
Data Structures
def frameworks = ['Groovy' : 'Grails', 'Java' : 'Spring', 'Scala' : 'Play']
  
frameworks.put('Ruby', 'Rails')
frameworks << ['Nodejs' : '...']

frameworks.remove('Ruby')

frameworks['Nodejs'] = 'Express'
  
frameworks.each {
  println "Most commonly used $it.key framework is $it.value"
}