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.
import java.util.Arrays; public class MaxNumber { public static long print(long number) { long sum = 0; String numStr = String.valueOf(number); char[] digits = numStr.toCharArray(); Arrays.sort(digits); long[] powersOfTen = new long[20]; // precalculated powers of ten for (int i = 19; i >= 0; --i) { powersOfTen[i] = (long) Math.pow(10, i); } // here the digits are sorted in ascending order for (int i = 0; i < digits.length; i++) { sum += Character.getNumericValue(digits[i]) * powersOfTen[i]; } return sum; } }
- import java.util.Arrays;
- public class MaxNumber {
- public static long print(long number) {
- long sum = 0;
- String numStr = String.valueOf(number);
- char[] digits = numStr.toCharArray();
- Arrays.sort(digits);
- long[] powersOfTen = new long[20]; // precalculated powers of ten
- for (int i = 19; i >= 0; --i) {
- powersOfTen[i] = (long) Math.pow(10, i);
- }
- // here the digits are sorted in ascending order
- for (int i = 0; i < digits.length; i++) {
sum += Math.round( Character.getNumericValue(digits[i]) * Math.pow(10, i) );- sum += Character.getNumericValue(digits[i]) * powersOfTen[i];
- }
- return sum;
- }
- }
You don't need code for this.
using System.Collections.Generic; using System.Linq; //using FactorSort = (int PrimeFactor, int Exponent); public static class PrimeFactorization { public static IList<(int PrimeFactor, int Exponent)> Factorize(int number) { List<(int PrimeFactor, int Exponent)> factors = new() { DetermineFrequency(ref number, 2) }; for (int i = 3; i*i <= number; i += 2) factors.Add(DetermineFrequency(ref number, i)); if (number > 1) factors.Add((number, 1)); factors.RemoveAll(f => f.Exponent == 0); return factors; } private static (int PrimeFactor, int Exponent) DetermineFrequency(ref int number, int factor) { var exponent = 0; while (number % factor == 0) { exponent++; number /= factor; } return (factor, exponent); } }
- using System.Collections.Generic;
- using System.Linq;
- //using FactorSort = (int PrimeFactor, int Exponent);
- public static class PrimeFactorization
- {
public static IEnumerable<(int PrimeFactor, int Exponent)> Factorize(int number)- public static IList<(int PrimeFactor, int Exponent)> Factorize(int number)
- {
- List<(int PrimeFactor, int Exponent)> factors = new()
- {
- DetermineFrequency(ref number, 2)
- };
- for (int i = 3; i*i <= number; i += 2)
- factors.Add(DetermineFrequency(ref number, i));
- if (number > 1) factors.Add((number, 1));
- factors.RemoveAll(f => f.Exponent == 0);
- return factors;
- }
- private static (int PrimeFactor, int Exponent) DetermineFrequency(ref int number, int factor)
- {
SortedDictionary<int, int> factors = new(); //[];for (int i = 2; i <= number / 2 + 1; i++)- var exponent = 0;
- while (number % factor == 0)
- {
while (number % i == 0){factors[i] = factors.GetValueOrDefault(i, 0) + 1;number /= i;}- exponent++;
- number /= factor;
- }
if (number > 1) factors[number] = factors.GetValueOrDefault(number, 0) + 1;return from factor in factors select (factor.Key, factor.Value);- return (factor, exponent);
- }
- }
using NUnit.Framework; using System.Collections.Generic; namespace Testing; [TestFixture] public class PrimeFactorizationTest { private List<(int input, List<(int PrimeFactor, int Exponent)> expectedOutput)> _testCases = new() { (84, new() { (2, 2), (3, 1), (7, 1) }), (100, new() { (2, 2), (5, 2) }), (79, new() { (79, 1) }), (13195, new() { (5, 1), (7, 1), (13, 1), (29, 1) }), (30030, new() { (2, 1), (3, 1), (5, 1), (7, 1), (11, 1), (13, 1) }) }; [Test] public void Test() { foreach (var testCase in _testCases) { Assert.That(PrimeFactorization.Factorize(testCase.input), Is.EqualTo(testCase.expectedOutput)); } } }
- using NUnit.Framework;
- using System.Collections.Generic;
- namespace Testing;
- [TestFixture]
- public class PrimeFactorizationTest
- {
- private List<(int input, List<(int PrimeFactor, int Exponent)> expectedOutput)> _testCases = new()
- {
- (84, new() { (2, 2), (3, 1), (7, 1) }),
- (100, new() { (2, 2), (5, 2) }),
- (79, new() { (79, 1) }),
- (13195, new() { (5, 1), (7, 1), (13, 1), (29, 1) }),
- (30030, new() { (2, 1), (3, 1), (5, 1), (7, 1), (11, 1), (13, 1) })
- };
// [// (84, [(2, 2), (3, 1), (7, 1)]),// (100, [(2, 2), (5, 2)]),// (79, [(79, 1)]),// (13195, [(5, 1), (7, 1), (13, 1), (29, 1)]),// (30030, [(2, 1), (3, 1), (5, 1), (7, 1), (11, 1), (13, 1)])// ];- [Test]
- public void Test()
- {
- foreach (var testCase in _testCases)
- {
- Assert.That(PrimeFactorization.Factorize(testCase.input), Is.EqualTo(testCase.expectedOutput));
- }
- }
- }
bool Nand(bool a, bool b) { return 1 - (a * b); } bool Not(bool a) { return Nand(a, a); } bool And(bool a, bool b) { return Not(Nand(a, b)); } bool Nor(bool a, bool b) { return And(Not(a), Not(b)); } bool Or(bool a, bool b) { return Not(Nor(a, b)); } bool Xor(bool a, bool b) { return And(Or(a, b), Not(And(a, b))); } bool Buffer(bool a) { return Not(Not(a)); } bool Xnor(bool a, bool b) { return Not(Xor(a, b)); } bool False(bool a) { return And(a, Not(a)); } bool True(bool a) { return Or(a, Not(a)); }
bool Nand(bool a, bool b){return 1-(a*b);- bool Nand(bool a, bool b) {
- return 1 - (a * b);
- }
bool Not(bool a){return Nand(a, a);- bool Not(bool a) {
- return Nand(a, a);
- }
bool And(bool a, bool b){return Not(Nand(a, b));- bool And(bool a, bool b) {
- return Not(Nand(a, b));
- }
bool Nor(bool a, bool b){return And(Not(a), Not(b));- bool Nor(bool a, bool b) {
- return And(Not(a), Not(b));
- }
bool Or(bool a, bool b){return Not(Nor(a, b));- bool Or(bool a, bool b) {
- return Not(Nor(a, b));
- }
bool Xor(bool a, bool b){return And(Or(a, b), Not(And(a, b)));- bool Xor(bool a, bool b) {
- return And(Or(a, b), Not(And(a, b)));
- }
bool Buffer(bool a){return Not(Not(a));- bool Buffer(bool a) {
- return Not(Not(a));
- }
bool Xnor(bool a, bool b){return Not(Xor(a, b));- bool Xnor(bool a, bool b) {
- return Not(Xor(a, b));
- }
bool False(bool a){return And(a, Not(a));- bool False(bool a) {
- return And(a, Not(a));
- }
bool True(bool a){return Or(a, Not(a));- bool True(bool a) {
- return Or(a, Not(a));
- }