Kumite

Start a new Kumite

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.

Kachevs.coulrulner1

3 months ago

Make It Greater Than 2

Original seems to do unnecessary computation before ultimately returning True

Code

Diff

```
def above_two(_):
    return True
```
- ~~#If it is not true currently, I shall make it true~~
- ~~def above_two(arg):~~
- return abs(arg)+3>2
- def above_two(_):
- return True

gabriel.gsvs.antonio.rg3 months ago
Cross Math
Test CasesDiffimport static org.junit.jupiter.api.Assertions.assertArrayEquals;

import java.util.Arrays;
import java.util.Random;

import org.junit.jupiter.api.Test;

class SolutionTest {
    @Test
	void TestRandomA() {
		for(int z = 0; z < 100; z++) {
			String[][] board = generatePlusMinusMultiDiv();
			String[][] end = generatePlusMinusMultiDiv();
			
			for(int i = 0; i < end.length; i++) {
				end[i] = board[i].clone();
			}
			
			for(int i = 0; i < board.length; i++) {
				for(int k = 0; k < board[i].length; k++) {
					end[i][k] = board[i][k];
				}
			}
			board = incognitaCreator(board);
			System.out.println(Arrays.deepToString(board));
			System.out.println(Arrays.deepToString(end));
			assertArrayEquals(end, CrossMath.solve(board));
		}
	}
	
  @Test
  void TestRandomB(){
    for(int i = 0; i < 100; i++){
      String[][] expected = generateSol();
      String[][] input = incognitaCreator(expected);
      assertArrayEquals(expected,input);
    }
  }
	
	public static String[][] generateSol(){
		int num1 = new Random().nextInt(1,100);
		int num2 = new Random().nextInt(1,100);
		int corners = num1 * num2;
		
		String[][] solution = new String[5][5];
		
		for(int y = 0; y < solution.length; y++)
			for(int x = 0; x < solution[y].length; x++)
				solution[y][x] = " ";
		
		for(int i = 0; i < solution.length; i +=2) {
			solution[i][solution.length-2] = "=";
			solution[solution.length-2][i] = "=";
		}
		
		if (new Random().nextBoolean()) {
			solution[0][0] = String.valueOf(num1);
			solution[solution.length-1][solution.length-1]= String.valueOf(num2);
			
			solution[0][solution.length-1] = String.valueOf(num1*num2);
			solution[solution.length-1][0] = String.valueOf(num1*num2);
		} else {
			solution[0][solution.length-1] = String.valueOf(num1);
			solution[solution.length-1][0] = String.valueOf(num2);
			
			solution[0][0] = String.valueOf(num1*num2);
			solution[solution.length-1][solution.length-1] = String.valueOf(num1*num2);
		}
		
		if (Integer.parseInt(solution[0][0]) > Integer.parseInt(solution[0][solution.length-1])) {
			solution[0][1] = "/";
			solution[0][2] = String.valueOf(Integer.parseInt(solution[0][0])/Integer.parseInt(solution[0][solution.length-1]));
		} else {
			solution[0][1] = "*";
			solution[0][2] = String.valueOf(Integer.parseInt(solution[0][solution.length-1])/Integer.parseInt(solution[0][0]));
		}
		
		if (Integer.parseInt(solution[solution.length-1][0]) > Integer.parseInt(solution[solution.length-1][solution.length-1])) {
			solution[solution.length-1][1] = "/";
			solution[solution.length-1][2] = String.valueOf(Integer.parseInt(solution[solution.length-1][0])/Integer.parseInt(solution[solution.length-1][solution.length-1]));
		} else {
			solution[solution.length-1][1] = "*";
			solution[solution.length-1][2] = String.valueOf(Integer.parseInt(solution[solution.length-1][solution.length-1])/Integer.parseInt(solution[solution.length-1][0]));
		}

		if (Integer.parseInt(solution[0][0]) > Integer.parseInt(solution[solution.length-1][0])) {
			solution[1][0] = "-";
			solution[2][0] = String.valueOf(Integer.parseInt(solution[0][0])-Integer.parseInt(solution[solution.length-1][0]));
		} else {
			solution[1][0] = "+";
			solution[2][0] = String.valueOf(Integer.parseInt(solution[solution.length-1][0])-Integer.parseInt(solution[0][0]));
		}
		
		if (Integer.parseInt(solution[0][solution.length-1]) > Integer.parseInt(solution[solution.length-1][solution.length-1])) {
			solution[1][solution.length-1] = "-";
			solution[2][solution.length-1] = String.valueOf(Integer.parseInt(solution[0][solution.length-1])-Integer.parseInt(solution[solution.length-1][solution.length-1]));
		} else {
			solution[1][solution.length-1] = "+";
			solution[2][solution.length-1] = String.valueOf(Integer.parseInt(solution[solution.length-1][solution.length-1])-Integer.parseInt(solution[0][solution.length-1]));
		}
		
		if (Integer.parseInt(solution[0][2]) > Integer.parseInt(solution[solution.length-1][2])) {
			solution[1][2] = "-";
			solution[2][2] = String.valueOf(Integer.parseInt(solution[0][2])-Integer.parseInt(solution[solution.length-1][2]));
		} else {
			solution[1][2] = "+";
			solution[2][2] = String.valueOf(Integer.parseInt(solution[solution.length-1][2])-Integer.parseInt(solution[0][2]));
		}
		
		if (Integer.parseInt(solution[2][0]) > Integer.parseInt(solution[2][solution.length-1])) {
			solution[2][1] = "-";
		} else {
			solution[2][1] = "+";
		}
		
		return solution;
	}
  
	public static String[][] generatePlusMinusMultiDiv() {
		Random r = new Random();
		String[][] moss = new String[5][5];
		
		if(r.nextInt(2) == 1) {
			int mult = r.nextInt(5)+1;
			int base = r.nextInt(5)+5;
			int num = base*mult;
			
			if(base > mult) {
				moss[1][2] = "+";
				moss[2][1] = "+";
			}else {
				moss[1][2] = "-";
				moss[2][1] = "-";
			}
			
			moss[0][0] = String.valueOf(base);
			moss[0][1] = "+";
			moss[0][2] = String.valueOf(num-base);
			moss[0][3] = "=";
			moss[0][4] = String.valueOf(num);
			
			moss[1][0] = "*";
			moss[1][1] = " ";
			moss[1][3] = " ";
			moss[1][4] = "/";
			
			moss[2][0] = String.valueOf(mult);
			moss[2][2] = String.valueOf(Math.abs(base-mult));
			moss[2][3] = "=";
			moss[2][4] = String.valueOf(base);
			
			moss[3][0] = "=";
			moss[3][1] = " ";
			moss[3][2] = "=";
			moss[3][3] = " ";
			moss[3][4] = "=";
			
			moss[4][0] = String.valueOf(num);
			moss[4][1] = "-";
			moss[4][2] = String.valueOf(num-mult);
			moss[4][3] = "=";
			moss[4][4] = String.valueOf(mult);
			
		}else {
			int mult = r.nextInt(9)+1;
			int base = r.nextInt(9)+1;
			int num = base*mult;
			
			if(base < mult) {
				moss[1][2] = "-";
				moss[2][1] = "+";
			}else {
				moss[1][2] = "+";
				moss[2][1] = "-";
			}
			
			moss[0][0] = String.valueOf(num);
			moss[0][1] = "-";
			moss[0][2] = String.valueOf(num-base);
			moss[0][3] = "=";
			moss[0][4] = String.valueOf(base);
			
			moss[1][0] = "/";
			moss[1][1] = " ";
			moss[1][3] = " ";
			moss[1][4] = "*";
			
			moss[2][0] = String.valueOf(base);
			moss[2][2] = String.valueOf(Math.abs(base-mult));
			moss[2][3] = "=";
			moss[2][4] = String.valueOf(mult);
			
			moss[3][0] = "=";
			moss[3][1] = " ";
			moss[3][2] = "=";
			moss[3][3] = " ";
			moss[3][4] = "=";
			
			moss[4][0] = String.valueOf(mult);
			moss[4][1] = "+";
			moss[4][2] = String.valueOf(num-mult);
			moss[4][3] = "=";
			moss[4][4] = String.valueOf(num);
		}
		
		return moss;
	}
	
	public static String[][] incognitaCreator(String[][] moss) {
		String[] arr = {"A","B","C"};
		Random r = new Random();
		for(String a : arr) {
			moss[r.nextInt(3)*2][r.nextInt(3)*2] = a;
		}
		return moss;
	}
}

  import static org.junit.jupiter.api.Assertions.assertArrayEquals;
import java.util.Arrays;
import java.util.Random;
import org.junit.jupiter.api.Test;
class SolutionTest {
    @Test
	void TestRandomA() {
		for(int z = 0; z < 100; z++) {
			String[][] board = generatePlusMinusMultiDiv();
			String[][] end = generatePlusMinusMultiDiv();
			
			for(int i = 0; i < end.length; i++) {
				end[i] = board[i].clone();
			}
			
			for(int i = 0; i < board.length; i++) {
				for(int k = 0; k < board[i].length; k++) {
					end[i][k] = board[i][k];
				}
			}
			board = incognitaCreator(board);
			System.out.println(Arrays.deepToString(board));
			System.out.println(Arrays.deepToString(end));
			assertArrayEquals(end, CrossMath.solve(board));
		}
	}
	
  @Test
  void TestRandomB(){
    for(int i = 0; i < 100; i++){
      String[][] expected = generateSol();
      String[][] input = incognitaCreator(expected);
      assertArrayEquals(expected,input);
    }
  }
	
	public static String[][] generateSol(){
		int num1 = new Random().nextInt(1,100);
		int num2 = new Random().nextInt(1,100);
		int corners = num1 * num2;
		
		String[][] solution = new String[5][5];
		
		for(int y = 0; y < solution.length; y++)
			for(int x = 0; x < solution[y].length; x++)
				solution[y][x] = " ";
		
		for(int i = 0; i < solution.length; i +=2) {
			solution[i][solution.length-2] = "=";
			solution[solution.length-2][i] = "=";
		}
		
		if (new Random().nextBoolean()) {
			solution[0][0] = String.valueOf(num1);
			solution[solution.length-1][solution.length-1]= String.valueOf(num2);
			
			solution[0][solution.length-1] = String.valueOf(num1*num2);
			solution[solution.length-1][0] = String.valueOf(num1*num2);
		} else {
			solution[0][solution.length-1] = String.valueOf(num1);
			solution[solution.length-1][0] = String.valueOf(num2);
			
			solution[0][0] = String.valueOf(num1*num2);
			solution[solution.length-1][solution.length-1] = String.valueOf(num1*num2);
		}
		
		if (Integer.parseInt(solution[0][0]) > Integer.parseInt(solution[0][solution.length-1])) {
			solution[0][1] = "/";
			solution[0][2] = String.valueOf(Integer.parseInt(solution[0][0])/Integer.parseInt(solution[0][solution.length-1]));
		} else {
			solution[0][1] = "*";
			solution[0][2] = String.valueOf(Integer.parseInt(solution[0][solution.length-1])/Integer.parseInt(solution[0][0]));
		}
		
		if (Integer.parseInt(solution[solution.length-1][0]) > Integer.parseInt(solution[solution.length-1][solution.length-1])) {
			solution[solution.length-1][1] = "/";
			solution[solution.length-1][2] = String.valueOf(Integer.parseInt(solution[solution.length-1][0])/Integer.parseInt(solution[solution.length-1][solution.length-1]));
		} else {
			solution[solution.length-1][1] = "*";
			solution[solution.length-1][2] = String.valueOf(Integer.parseInt(solution[solution.length-1][solution.length-1])/Integer.parseInt(solution[solution.length-1][0]));
		}
		if (Integer.parseInt(solution[0][0]) > Integer.parseInt(solution[solution.length-1][0])) {
			solution[1][0] = "-";
			solution[2][0] = String.valueOf(Integer.parseInt(solution[0][0])-Integer.parseInt(solution[solution.length-1][0]));
		} else {
			solution[1][0] = "+";
			solution[2][0] = String.valueOf(Integer.parseInt(solution[solution.length-1][0])-Integer.parseInt(solution[0][0]));
		}
		
		if (Integer.parseInt(solution[0][solution.length-1]) > Integer.parseInt(solution[solution.length-1][solution.length-1])) {
			solution[1][solution.length-1] = "-";
			solution[2][solution.length-1] = String.valueOf(Integer.parseInt(solution[0][solution.length-1])-Integer.parseInt(solution[solution.length-1][solution.length-1]));
		} else {
			solution[1][solution.length-1] = "+";
			solution[2][solution.length-1] = String.valueOf(Integer.parseInt(solution[solution.length-1][solution.length-1])-Integer.parseInt(solution[0][solution.length-1]));
		}
		
		if (Integer.parseInt(solution[0][2]) > Integer.parseInt(solution[solution.length-1][2])) {
			solution[1][2] = "-";
			solution[2][2] = String.valueOf(Integer.parseInt(solution[0][2])-Integer.parseInt(solution[solution.length-1][2]));
		} else {
			solution[1][2] = "+";
			solution[2][2] = String.valueOf(Integer.parseInt(solution[solution.length-1][2])-Integer.parseInt(solution[0][2]));
		}
		
		if (Integer.parseInt(solution[2][0]) > Integer.parseInt(solution[2][solution.length-1])) {
			solution[2][1] = "-";
		} else {
			solution[2][1] = "+";
		}
		
		return solution;
	}
  
	public static String[][] generatePlusMinusMultiDiv() {
		Random r = new Random();
		String[][] moss = new String[5][5];
		
		if(r.nextInt(2) == 1) {
			int mult = r.nextInt(5)+1;
			int base = r.nextInt(5)+5;
			int num = base*mult;
			
			if(base > mult) {
				moss[1][2] = "+";
				moss[2][1] = "+";
			}else {
				moss[1][2] = "-";
				moss[2][1] = "-";
			}
			
			moss[0][0] = String.valueOf(base);
			moss[0][1] = "+";
			moss[0][2] = String.valueOf(num-base);
			moss[0][3] = "=";
			moss[0][4] = String.valueOf(num);
			
			moss[1][0] = "*";
			moss[1][1] = " ";
			moss[1][3] = " ";
			moss[1][4] = "/";
			
			moss[2][0] = String.valueOf(mult);
			moss[2][2] = String.valueOf(Math.abs(base-mult));
			moss[2][3] = "=";
			moss[2][4] = String.valueOf(base);
			
			moss[3][0] = "=";
			moss[3][1] = " ";
			moss[3][2] = "=";
			moss[3][3] = " ";
			moss[3][4] = "=";
			
			moss[4][0] = String.valueOf(num);
			moss[4][1] = "-";
			moss[4][2] = String.valueOf(num-mult);
			moss[4][3] = "=";
			moss[4][4] = String.valueOf(mult);
			
		}else {
			int mult = r.nextInt(9)+1;
			int base = r.nextInt(9)+1;
			int num = base*mult;
			
			if(base < mult) {
				moss[1][2] = "-";
				moss[2][1] = "+";
			}else {
				moss[1][2] = "+";
				moss[2][1] = "-";
			}
			
			moss[0][0] = String.valueOf(num);
			moss[0][1] = "-";
			moss[0][2] = String.valueOf(num-base);
			moss[0][3] = "=";
			moss[0][4] = String.valueOf(base);
			
			moss[1][0] = "/";
			moss[1][1] = " ";
			moss[1][3] = " ";
			moss[1][4] = "*";
			
			moss[2][0] = String.valueOf(base);
			moss[2][2] = String.valueOf(Math.abs(base-mult));
			moss[2][3] = "=";
			moss[2][4] = String.valueOf(mult);
			
			moss[3][0] = "=";
			moss[3][1] = " ";
			moss[3][2] = "=";
			moss[3][3] = " ";
			moss[3][4] = "=";
			
			moss[4][0] = String.valueOf(mult);
			moss[4][1] = "+";
			moss[4][2] = String.valueOf(num-mult);
			moss[4][3] = "=";
			moss[4][4] = String.valueOf(num);
		}
		
		return moss;
	}
	
	public static String[][] incognitaCreator(String[][] moss) {
		String[] arr = {"A","B","C"};
		Random r = new Random();
		for(String a : arr) {
			moss[r.nextInt(3)*2][r.nextInt(3)*2] = a;
		}
		return moss;
	}
}

Fork
Discuss (0)
Fixture

aitor.GMvs.gonzalo.sl3 months ago
Driving Test Evaluator
CodeDiffpublic class DrivingTestEvaluator{
  public static boolean evaluate(String road, String exam){
    //your code here
//test
    return true;
    }
}

  public class DrivingTestEvaluator{
  public static boolean evaluate(String road, String exam){
    //your code here
//test
    return true;
    }
}

Fork
Discuss (0)
Fixture

Racketfewvs.Racketfew3 months ago
Is a Perfect Square for Ints
CodeDiffis_perfect_square:=>@^.5%1==0

  is_perfect_square: => @ ^ 0.5 % 1 == 0
is_perfect_square:=>@^.5%1==0

Fork
Discuss (0)
Fixture

GameHerobrinevs.Godera34 months ago
Reverse the letters in a String
CodeDiffextern malloc
global reverse_string
reverse_string:
  mov rcx, -1
rs_continue:
  inc rcx
  cmp byte [rdi+rcx], 0
  jnz rs_continue
  
  push rcx
  push rdi
  call malloc
  pop rdi
  pop rbx
  mov rcx, 0


rs_copy:
  dec rbx
  
  mov dl, [rdi+rbx]
  mov [rax+rcx], dl
  inc rcx
  cmp rbx, 0
  jnz rs_copy
  
  mov byte [rax+rcx], 0
  ret

  #include <stdlib.h>
#include <string.h>
char* reverse_string(const char* word) {
    if (!word) {
        return NULL;
    }
extern malloc
global reverse_string
reverse_string:
  mov rcx, -1
rs_continue:
  inc rcx
  cmp byte [rdi+rcx], 0
  jnz rs_continue
  
  push rcx
  push rdi
  call malloc
  pop rdi
  pop rbx
  mov rcx, 0
    size_t len = strlen(word);
    char* res = (char*)malloc(len + 1);
    if (!res) {
        return NULL;
    }
    for (size_t i = 0; i < len; ++i) {
        res[i] = word[len - 1 - i];
    }
    res[len] = '\0';
    return res;
}
rs_copy:
  dec rbx
  
  mov dl, [rdi+rbx]
  mov [rax+rcx], dl
  inc rcx
  cmp rbx, 0
  jnz rs_copy
  
  mov byte [rax+rcx], 0
  ret

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

char *reverse_string(const char *word);

void tester(const char *word, const char *expected)
{
  char *res = reverse_string(word);
  cr_assert_str_eq(res, expected);
  free(res);
}

Test(Sample_Tests, Valid_Input_Test)
{
  tester("monkey", "yeknom");
  tester("home", "emoh");
  tester("pneumonoultramicroscopicsilicovolcanoconiosis", "sisoinoconaclovociliscipocsorcimartluonomuenp");
}

  #include <criterion/criterion.h>
#include <stdio.h>
char *reverse_string(const char *word);
void tester(const char *word, const char *expected)
{
  char *res = reverse_string(word);
  cr_assert_str_eq(res, expected);
  free(res);
}
Test(Sample_Tests, Valid_Input_Test)
{
  tester("monkey", "yeknom");
  tester("home", "emoh");
  tester("pneumonoultramicroscopicsilicovolcanoconiosis", "sisoinoconaclovociliscipocsorcimartluonomuenp");
}

Fork
Discuss (0)
Fixture

Freestyle Sparring

Make It Greater Than 2

Cross Math

Driving Test Evaluator

Is a Perfect Square for Ints

Reverse the letters in a String

Confirm

Collect: undefined