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.
[Please, leave a feedback when you complete it or this will always stay in beta and you will not earn language points].
Print all numbers up to 3rd parameter which are multiple of both 1st and 2nd paramater.
#!/bin/bash
for i in $(eval echo {1..$3});
do
if [ `expr $i % $1` -eq 0 -a `expr $i % $2` -eq 0 ]
then
echo $i
fi
doneoutput = run_shell args: [3,4,120]
describe "Solution" do
it "should return proper results for 3,4,120" do
expect(output).to include("12\r\n24\r\n36\r\n48\r\n60\r\n72\r\n84\r\n96\r\n108\r\n120")
end
end
output2 = run_shell args: [2,7,85]
describe "Solution" do
it "should return proper results for 2,7,85" do
expect(output2).to include("14\r\n28\r\n42\r\n56\r\n70\r\n84")
end
end
output3 = run_shell args: [14,15,185]
describe "Solution" do
it "should return proper results for 14,15,185" do
expect(output3).to include("")
end
end
output4 = run_shell args: [14,17,480]
describe "Solution" do
it "should return proper results for 14,17,480" do
expect(output4).to include("238\r\n476")
end
end
output5 = run_shell args: [2,5,90]
describe "Solution" do
it "should return proper results for 2,5,90" do
expect(output5).to include("10\r\n20\r\n30\r\n40\r\n50\r\n60\r\n70\r\n80\r\n90")
end
end
output6 = run_shell args: [4,7,97]
describe "Solution" do
it "should return proper results for 4,7,97" do
expect(output6).to include("28\r\n56\r\n84")
end
endSuzuki needs help lining up his students!
Today Suzuki will be interviewing his students to ensure they are progressing in their training. He decided to schedule the interviews based on the length of the students name in descending order. The students will line up and wait for their turn.
You will be given a string of student names. Sort them and return a list of names in descending order.
Here is an example input:
string = 'Tadashi Takahiro Takao Takashi Takayuki Takehiko Takeo Takeshi Takeshi'
Here is an example return from your function:
lst = ['Takehiko',
'Takayuki',
'Takahiro',
'Takeshi',
'Takeshi',
'Takashi',
'Tadashi',
'Takeo',
'Takao']
Names of equal length will be returned in reverse alphabetical order (Z->A) such that:
string = "xxa xxb xxc xxd xa xb xc xd"
Returns
['xxd', 'xxc', 'xxb', 'xxa', 'xd', 'xc', 'xb', 'xa']
using System;
using System.Linq;
public class Kata
{
public static string[] LiningUpHisStudents(string s)
{
var query = s.Split(' ').OrderByDescending(x => x.Length).ThenByDescending(x => x).ToArray();
return query;
}
}namespace Solution {
using NUnit.Framework;
using System;
// TODO: Replace examples and use TDD development by writing your own tests
[TestFixture]
public class SolutionTest
{
[Test]
public void MyTest()
{
string s = "Tadashi Takahiro Takao Takashi Takayuki Takehiko Takeo Takeshi Takeshi";
string[] S = { "Takehiko", "Takayuki", "Takahiro", "Takeshi", "Takeshi", "Takashi", "Tadashi", "Takeo", "Takao" };
string[] Test = Kata.LiningUpHisStudents(s);
CollectionAssert.AreEqual(Kata.LiningUpHisStudents(s), S);
}
}
}Given a start date and end date, find a list of dates with the format of month, day year, that is the same forward as it is backward. For example, the date October 2, 2001 is a palindrome because in MMDDYYYY format, this date is 10022001 and in YYYYDDMM format the date is 10022001. Your task is to find all the palindrome dates for any given start and end date.
The method that calculates this should take two Date types, one for the start date and one for the end date. The method should return a Set of Date types that is sorted chronologically and has no duplicates.
package com.mystuff.juststuff;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.TreeSet;
public class Palindrome
{
SimpleDateFormat sdf;
public Palindrome()
{
this.sdf = new SimpleDateFormat("MMddyyyy");
sdf.setLenient(false);
}
public TreeSet<Date> countDatePalindromes(Date startDate, Date endDate)
{
TreeSet<Date> palSet = new TreeSet<Date>();
GregorianCalendar startCal = new GregorianCalendar();
GregorianCalendar endCal = new GregorianCalendar();
if (startDate.getTime() > endDate.getTime())
{
// end date is chronologically before start date. flip them.
// System.out.println("end is before start. must flip. start: " + sdf.format(startDate.getTime()) + " end: " + sdf.format(endDate.getTime()));
startCal.setTime(endDate);
endCal.setTime(startDate);
}
else
{
// start date is chronologically prior to end date. just set the calendars as such.
startCal.setTime(startDate);
endCal.setTime(endDate);
}
// System.out.println("start should be before end. start: " + sdf.format(startCal.getTime()) + " end: " + sdf.format(endCal.getTime()));
String regularDate = null;
String palDate = null;
while ( (startCal.before(endCal)) || (startCal.equals(endCal)) )
{
regularDate = sdf.format(startCal.getTime());
palDate = palindromify(startCal.getTime());
if (regularDate.equals(palDate))
{
// a date palindrome was found
// System.out.println("Found one! regular: " + regularDate + " palindrome: " + palDate);
palSet.add(startCal.getTime());
}
startCal.add(Calendar.DAY_OF_MONTH, 1);
}
// System.out.println("I found " + palSet.size() + " palindromes");
return palSet;
}
private String palindromify(final Date arg)
{
SimpleDateFormat sdf = new SimpleDateFormat("MMddyyyy");
sdf.setLenient(false);
StringBuffer palBuff = new StringBuffer(8);
String pal = sdf.format(arg);
for (int i = pal.length(); i >= 1; i--)
{
palBuff.append(pal.charAt(i - 1));
}
return palBuff.toString();
}
}package com.mystuff.juststuff;
import static org.junit.Assert.assertTrue;
import java.util.Date;
import java.util.GregorianCalendar;
import java.util.TreeSet;
import org.junit.Test;
public class PalindromeTest
{
@Test
public void testCountDatePalindromesEndDateBeforeStartDate()
{
GregorianCalendar startCalTest = new GregorianCalendar(2001, 11, 1);
GregorianCalendar endCalTest = new GregorianCalendar(2001, 0, 31);
Date startDate = new Date(startCalTest.getTimeInMillis());
Date endDate = new Date(endCalTest.getTimeInMillis());
Palindrome drome = new Palindrome();
TreeSet<Date> palSet = drome.countDatePalindromes(startDate, endDate);
assertTrue("Set size should be greater than zero", palSet.size() > 0);
}
@Test
public void testCountDatePalindromesStartDateBeforeEndDate()
{
GregorianCalendar startCalTest = new GregorianCalendar(2001, 0, 1);
GregorianCalendar endCalTest = new GregorianCalendar(2001, 11, 31);
Date startDate = new Date(startCalTest.getTimeInMillis());
Date endDate = new Date(endCalTest.getTimeInMillis());
Palindrome drome = new Palindrome();
TreeSet<Date> palSet = drome.countDatePalindromes(startDate, endDate);
assertTrue("Set size should be greater than zero", palSet.size() > 0);
}
@Test
public void testCountDatePalindromesStartDateEqualsEndDateNoPalindromes()
{
GregorianCalendar startCalTest = new GregorianCalendar(2001, 11, 31); // Nov 31, 2001 is not a palindrome date
GregorianCalendar endCalTest = new GregorianCalendar(2001, 11, 31);
Date startDate = new Date(startCalTest.getTimeInMillis());
Date endDate = new Date(endCalTest.getTimeInMillis());
Palindrome drome = new Palindrome();
TreeSet<Date> palSet = drome.countDatePalindromes(startDate, endDate);
assertTrue("Set size should be zero", palSet.size() == 0);
}
@Test
public void testCountDatePalindromesStartDateEqualsEndDateOnePalindrome()
{
GregorianCalendar startCalTest = new GregorianCalendar(2001, 9, 2); // Oct 2, 2001 is a palindrome date
GregorianCalendar endCalTest = new GregorianCalendar(2001, 9, 2);
Date startDate = new Date(startCalTest.getTimeInMillis());
Date endDate = new Date(endCalTest.getTimeInMillis());
Palindrome drome = new Palindrome();
TreeSet<Date> palSet = drome.countDatePalindromes(startDate, endDate);
assertTrue("Set size should be one", palSet.size() == 1);
}
@Test
public void testCountDatePalindromesHugeDateRange()
{
GregorianCalendar startCalTest = new GregorianCalendar(1900, 0, 1);
GregorianCalendar endCalTest = new GregorianCalendar(2001, 11, 31);
Date startDate = new Date(startCalTest.getTimeInMillis());
Date endDate = new Date(endCalTest.getTimeInMillis());
Palindrome drome = new Palindrome();
TreeSet<Date> palSet = drome.countDatePalindromes(startDate, endDate);
assertTrue("Set size should be greater than zero", palSet.size() > 0);
}
}Help Suzuki purchase his Tofu!
Suzuki has sent a lay steward to market who will purchase some items not produced in the monastary gardens for the monks. The stewart has with him a large box full of change from donations earlier in the day mixed in with some personal items. You will be given a string of items representing the box.
Sort through the items in the box finding the coins and putting aside anything else.
You will be given a data structure similar to the one below.
box = "mon mon mon mon mon apple mon mon mon mon mon mon mon monme mon mon monme mon mon mon mon cloth monme mon mon mon mon mon mon mon mon cloth mon mon monme mon mon mon mon monme mon mon mon mon mon mon mon mon mon mon mon mon mon";
Return the following in your solution.
[count of mon coins in box, count of monme coins in box,sum of all coins value in box, minimum number of coins needed for Tofu]
100 ≤ cost ≤ 1000
cost = 124
returns
[45, 5, 345, 6]
The coins have the following values:
monme = 60
mon = 1
Determine the minimum number of coins to pay for tofu. You must pay with exact change and if you do not have the correct change return “leaving the market”.
NOTE !!!!! for c# solution Just return -> int[] {0};
If the cost of tofu is higher than your total amount of money also return “leaving the market”
using System;
using System.Linq;
public class Kata
{
public static int[] PurchaseTofu(int cost, string box)
{
var monCount = box.Split(' ').Count(x => x == "mon");
Console.WriteLine(monCount);
var monmeCount = box.Split(' ').Count(x => x == "monme");
var TotalValue = monCount + (monmeCount * 60);
int NumberOfMonmeUsed = 0;
int NumberOfMonUsed = 0;
int NeverChangeCost = cost;
var monCounter = monCount;
var monmeCounter = monmeCount;
while(cost >= 60 && monmeCounter > 0)
{
NumberOfMonmeUsed = NumberOfMonmeUsed + 1;
cost = cost - 60;
monmeCounter--;
}
while (cost >= 1 && monCounter > 0)
{
NumberOfMonUsed = NumberOfMonUsed + 1;
cost = cost - 1;
monCounter--;
}
var TotalCoinsUsed = NumberOfMonmeUsed + NumberOfMonUsed;
var test = (NumberOfMonmeUsed * 60) + NumberOfMonUsed;
if (test != NeverChangeCost)
{
Console.WriteLine("Leaving the market");
return new int[] {0};
}
Console.WriteLine($"[{monCount}, {monmeCount}, {TotalValue}, {TotalCoinsUsed}]");
return new int[] { monCount, monmeCount, TotalValue, TotalCoinsUsed };
}
}namespace Solution {
using NUnit.Framework;
using System;
// TODO: Replace examples and use TDD development by writing your own tests
[TestFixture]
public class SolutionTest
{
[Test]
public void MyTest()
{
string box = "mon monme";
CollectionAssert.AreEqual(Kata.PurchaseTofu(5, box), new int[] { 0 });
box = "mon mon mon";
int cost = 674;
CollectionAssert.AreEqual(Kata.PurchaseTofu(cost, box), new int[] {0});
box = "monme mon mon monme";
cost = 1;
CollectionAssert.AreEqual(Kata.PurchaseTofu(cost, box), new int[] { 2, 2, 122, 1 });
box = "monme mon mon monme";
cost = 122;
CollectionAssert.AreEqual(Kata.PurchaseTofu(cost, box), new int[] { 2, 2, 122, 4 });
box = "mon mon mon mon mon apple mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon monme mon mon mon mon cloth mon mon mon mon mon mon mon mon mon cloth mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon mon";
cost = 124;
CollectionAssert.AreEqual(Kata.PurchaseTofu(cost, box), new int[] { 121, 1, 181, 65 });
box = "mon mon mon mon mon apple mon mon mon mon mon mon mon monme mon mon monme mon mon mon mon cloth monme mon mon mon mon mon mon mon mon cloth mon mon monme mon mon mon mon monme mon mon mon mon mon mon mon mon mon mon mon mon mon";
CollectionAssert.AreEqual(Kata.PurchaseTofu(124, box), new int[] { 45, 5, 345, 6 });
}
}
}Caesar-cipher (obfuscated, golfed)
sub c{map{chr($_[0]+ord)}split'',$_[1]}Try to return the File Extension from the provided arguement.
#!/bin/bash
file1=$1; echo ${file1##*.}output = run_shell args: ['/Users/Desktop/backup_folder/Grandma_got_run_over_by_a_reindeer.mpg']
describe "Solution" do
it "Should return file extension" do
expect(output).to include("mpg\r\n")
end
endMake a Function that returns a comma separated list in the order of
"DirectoryName, Filename, FileExtension"
#!/bin/bash
filename=$1
echo "$(dirname $filename), $(basename ${filename%.*}), ${filename##*.}"output = run_shell args: ["/Users/Tech/Desktop/backup/Nutters_with_Putters_Revenge_of_the_Nutters2.avi"]
describe "Solution" do
it "Should return Comma Separated List" do
expect(output).to include("/Users/Tech/Desktop/backup, Nutters_with_Putters_Revenge_of_the_Nutters2, avi")
end
endFind the number that only odd times form an array.
For example:
findOnlyOddTimesNumber([1,1,1,2,3,4,2,4,2,1,3]); // 2
const findOnlyOddTimesNumber = arr => arr.reduce((p,c) => p^c);
findOnlyOddTimesNumber([1,1,1,2,3,4,2,4,2,1,3]);// TODO: Replace examples and use TDD development by writing your own tests
// These are some CW specific test methods available:
// Test.expect(boolean, [optional] message)
// Test.assertEquals(actual, expected, [optional] message)
// Test.assertSimilar(actual, expected, [optional] message)
// Test.assertNotEquals(actual, expected, [optional] message)
// NodeJS assert is also automatically required for you.
// assert(true)
// assert.strictEqual({a: 1}, {a: 1})
// assert.deepEqual({a: [{b: 1}]}, {a: [{b: 1}]})
// You can also use Chai (http://chaijs.com/) by requiring it yourself
// var expect = require("chai").expect;
// var assert = require("chai").assert;
// require("chai").should();
describe("Solution", function(){
it("should test for something", function(){
Test.assertEquals("expected", "expected", "This is just an example of how you can write your own TDD tests");
});
});This is how you prevent the user from importing certain modules in your kata.
import sys
sys.modules['module name'] = NoneUsing names.txt (right click and 'Save Link/Target As...'), a 46K text file containing over five-thousand first names, begin by sorting it into alphabetical order. Then working out the alphabetical value for each name, multiply this value by its alphabetical position in the list to obtain a name score.
For example, when the list is sorted into alphabetical order, COLIN, which is worth 3 + 15 + 12 + 9 + 14 = 53, is the 938th name in the list. So, COLIN would obtain a score of 938 × 53 = 49714.
What is the total of all the name scores in the file?
function nameScores(names) {
var t1 = console.time("names");;
names.sort();
var sum = 0;
var index = 1;
for (var name = 0; name < names.length; name++) {
var nameSum = 0;
for (var character = 0; character < names[name].length; character++) {
nameSum += (names[name][character].charCodeAt(0) - 64);
}
sum += (nameSum * index);
index++;
}
var t2 = console.timeEnd('names');
return sum;
}let names = ["MNO","ABC","GHI","DEF","JKL"];
Test.assertEquals(nameScores(names), 450);