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

Given an array with integers, remove numbers which are duplicated with previous or next sibling.

For example, with array [1, 3, 2, 2, 2, 4, 7, 7, 9, 5, 3], the result should be [1, 3, 4, 9, 5, 3].

function kumite(arr) {
  return [];
}
Fundamentals

Billy likes to keep all his number in an jar, however there's one special one that he likes to keep at the top of it. It turns out that Billy has accidentaly mixed up his jar, and he can't find his special number!

You must return a new array in which his special number is the first element. The arguments given to the function are as follows:

jar - All of Billy's numbers.
special - Billy's special number.

All original numbers in the resulting array must remain, it's only the order that's different.

If the array is empty or null, return nil, None, or null. You can assume special is in the array.

def find_special(jar, special):
    # initial solution
    if jar != None and jar != []:
        for i in range(len(jar)):
            if jar[i] == special:
                jar.insert(0,jar.pop(i))
                break
        return jar
    return None

Check given number, return true if it is an even number, otherwise return false.

For example isEven(3) will return false, isEven(4) will turn true.

function isEven(input) {
  return true;
}
mstp-cgFailed Tests

SudukoDLX

puzzle =   {0 : [0,0,0,0,0,0,0,0,0],
            1 : [0,3,0,0,0,0,1,6,0],
            2 : [0,6,7,0,3,5,0,0,4],
            3 : [6,0,8,1,2,0,9,0,0],
            4 : [0,9,0,0,8,0,0,3,0],
            5 : [0,0,2,0,7,9,8,0,6],
            6 : [8,0,0,6,9,0,3,5,0],
            7 : [0,2,6,0,0,0,0,9,0],
            8 : [0,0,0,0,0,0,0,0,0]
        }

def makeGrid(puzzle):
    for a in list(range(1,10)):
        #print('Checking for: {}'.format(a))
        grid = []
        # Set block list
        blockList = []
        for x in puzzle:
            row = []
            y = 0
            for n in puzzle[x]:
                if n == a:
                    row.append(0)
                    blockList.append([x,y])
                elif n != 0:
                    row.append(1)
                else:
                    row.append(0)
                y += 1
            grid.append(row)
        # Block using standard logic
        for b in blockList:
            grid = blockGrid(b, grid)
        # Block using simplified dancing links (algorithm X) for fun
        blockDLX(grid, a)
        solveRow(grid, a)
        solveColumn(grid, a)

def blockGrid(b, grid):
    # Block row
    x = b[0]
    y = 0
    for n in grid[x]:
        grid[x][y] = 1
        y += 1
    # Block column
    x = 0
    y = b[1]
    for row in grid:
        grid[x][y] = 1
        x += 1
    # Block square
    x = b[0]
    y = b[1]
    rowRange = [0,3,6]
    columnRange = [0,3,6]
    for a in rowRange:
        if x >= a and x < a + 3:
            for b in columnRange:
                if y >= b and y < b + 3:
                    i = 0
                    while i < 3:
                        j = 0
                        while j < 3:
                            grid[a + i][b + j] = 1
                            j += 1
                        i += 1
    return(grid)

def blockDLX(grid, a):
    # Reduce rows
    x = 0
    subGrid = {}
    for row in grid:
        if row.count(0) != 0:
            subGrid[x] = row
        x += 1
    # Reduce columns
    for x in subGrid:
        y = 0
        solvedCount = 0
        checkColumns = []
        blockColumn = []
        for n in subGrid[x]:
            if n == 1:
                check = 0
                for row in subGrid:
                    if subGrid[row][y] == 1:
                        check += 1
                if check != len(subGrid):
                    checkColumns.append(y)
                else:
                    solvedCount += 1
            else:
                blockColumn.append(y)
            y += 1
        # Check columns
        if len(checkColumns) > 0:
            blockRow = []
            for z in subGrid:
                match = 'y'
                for column in checkColumns:
                    if subGrid[z][column] == 0:
                        match = 'n'
                if match == 'y':
                    blockRow.append(z)
            if len(blockRow) == subGrid[x].count(0) and len(blockRow) != (len(subGrid[x]) - solvedCount):
                for column in blockColumn:
                    x = 0
                    for row in grid:
                        if x not in blockRow:
                            grid[x][column] = 1
                        x += 1

def solveRow(grid, a):
    x = 0
    for row in grid:
        if row.count(0) == 1:
            y = 0
            for n in grid[x]:
                if n == 0:
                    #print('Match found x:{} y:{}'.format(x, y))
                    puzzle[x][y] = a
                y += 1
        x += 1

def solveColumn(grid, a):
    y = 0
    while y < 9:
        column = []
        for row in grid:
            column.append(row[y])
        if column.count(0) == 1:
            x = 0
            for n in column:
                if n == 0:
                    #print('Match found x:{} y:{}'.format(x, y))
                    puzzle[x][y] = a
                x += 1
        y += 1

while any(0 in puzzle[row] for row in puzzle):
    makeGrid(puzzle)
print('\n\nSolved:')
for x in puzzle:
    print(puzzle[x])

What is the best way to list all divisors of a number?

A divisor of a number n is another number d where there is some number k such that n = d k

In particular 1 and n are always divisors.

module Divisors where

divisors :: Integer -> [Integer]
divisors n = 1:n:(divisorsAux 2)
  where
    divisorsAux k
      | (fromIntegral k) > sqrt (fromIntegral n) = []
      | otherwise  = if n `mod` k == 0
                     then if n`div`k ==k
                          then k:(divisorsAux (k+1))
                          else k:(n`div`k):(divisorsAux (k+1))
                     else divisorsAux (k+1)
Algorithms
Logic
Mathematics
Numbers

I want to show you task from Russian EGE exam

Given an array containing positive integers that do not exceed 15000. Find the number of even elements in the array that are not multiples of 3, replace all odd elements that are multiples of 3 with this number, and output the modified array. For example, for a source array of five elements 20, 89, 27, 92, 48, the program must output numbers 20, 89, 2, 92, 48.

using System;
 public class RussianExam
  {
    public static int[] ExamTask(int[] array)
        {
            int count = 0;
            for(int i = 0; i < array.Length; i++)
            {
                if (array[i] % 3 != 0 && array[i] % 2 == 0) count++;
            }
            for (int i = 0; i < array.Length; i++)
            {
                if (array[i] % 3 == 0 && array[i] % 2 != 0) array[i] = count;
            }
            return array;
        }
  }
public string PrimitiveFlow(string s)
{
//Code here :3

return "";
}
def numberplatereader(plate):
    import re
    if re.match("[A-Z]{2}[0-9]{2}\s[A-Z]{3}", plate) != None:
        return True
    else:
        return False

You like to play card games, But this game has simple rules, There are 40 cards within it, 4 for each number from 1 to 10.

You have a function that takes two arguments: The card the player has played, and the cards on the floor.

If the player's card was equal to any of the cards on the floor or the sum of any cards on the floor, All These cards should be taken from the floor

For example: The player threw a 7 card on the floor.

There were cards: [ 6, 1, 3, 4 ] on the floor.

Since both the combinations [6, 1] and [4, 3] are equal to 7, Then all of them should be returned by the function.

But, If there were : [ 2 ,4, 1, 3 ] cards .

You can only take the sequence [2, 4, 1] from the floor. Not 3.

because after removing the three initial cards no 4s will be left for a 3 card to add up to the sum of 7.

Notice that we've chosen: [ 2, 4, 1 ]. Because they have a higher number of cards than the sequence [4, 3].

You need to write an algorithm that returns what should be taken from the floor if there were cards or sequences of cards that're equal to the player's card. And your time is short so what'll you do?

function GameOfCards(handCard, floorCards)
{
        // your code here
}

Control.Lens is mind-bogglingly powerful.
Just playing with this amazing thing.

module Kumite where

import Control.Lens

main = do
  print $ (1, 2, 3) ^.. each
  print $ map (^..each) [(1, 2, 3), (4, 5, 6), (7, 8, 9)]
  print $ both ^~ 2 $ (1,2,3,4)
  print $ mapped._2 %~ succ . (* 2) $ [(1,2),(3,4)]
  print $ over (mapped._2) succ [(1,2),(3,4)]
  print $ (10,20) ^. _2
  print $ _1 .~ "i changed this" $ ((), "world")