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.

### Remove Conitnuously Duplicated Numbers

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

### Find Billy's Special Number

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 Even Number

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

### List of divisors of number

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

### Russian Exam Task 25 (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
{
{
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;
}
}``````
Failed Tests

### Find Screen Resolution

``````public string PrimitiveFlow(string s)
{
//Code here :3

return "";
}``````

### CharlieM312's Kumite #3

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

### Game Of Cards

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)
{
}``````
Failed Tests

### playing with Control.Lens

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