def oper_array(fct, arr, init): # your code # --------------- TEST CASES --------------- def testing(actual, expected): Test.assert_equals(actual, expected) Test.describe("oper_array") Test.it("Basic tests 1 : gcdi, lcmu, som, mini, maxi") a = [18, 69, -90, -78, 65, 40] r = [18, 3, 3, 3, 1, 1] op = oper_array(gcdi, a, a[0]) testing(op, r) r = [18, 414, 2070, 26910, 26910, 107640] op = oper_array(lcmu, a, a[0]) testing(op, r) r = [18, 87, -3, -81, -16, 24] op = oper_array(som, a, 0) testing(op, r) r = [18, 18, -90, -90, -90, -90] op = oper_array(mini, a, a[0]) testing(op, r) r = [18, 69, 69, 69, 69, 69] op = oper_array(maxi, a, a[0]) testing(op, r)
# Custom Test.assert_equals(tribonacci([14, 9, 3], 1), [14]) # Test Cases Test.describe("Basic tests") Test.assert_equals(tribonacci([1,1,1],10),[1,1,1,3,5,9,17,31,57,105]) Test.assert_equals(tribonacci([0,0,1],10),[0,0,1,1,2,4,7,13,24,44]) Test.assert_equals(tribonacci([0,1,1],10),[0,1,1,2,4,7,13,24,44,81]) Test.assert_equals(tribonacci([1,0,0],10),[1,0,0,1,1,2,4,7,13,24]) Test.assert_equals(tribonacci([0,0,0],10),[0,0,0,0,0,0,0,0,0,0]) Test.assert_equals(tribonacci([1,2,3],10),[1,2,3,6,11,20,37,68,125,230]) Test.assert_equals(tribonacci([3,2,1],10),[3,2,1,6,9,16,31,56,103,190]) Test.assert_equals(tribonacci([1,1,1],1),[1]) Test.assert_equals(tribonacci([300,200,100],0),[]) Test.assert_equals(tribonacci([0.5,0.5,0.5],30),[0.5,0.5,0.5,1.5,2.5,4.5,8.5,15.5,28.5,52.5,96.5,177.5,326.5,600.5,1104.5,2031.5,3736.5,6872.5,12640.5,23249.5,42762.5,78652.5,144664.5,266079.5,489396.5,900140.5,1655616.5,3045153.5,5600910.5,10301680.5]) Test.describe("Random tests") from random import randint def soluzionacci(sign,n): seq=sign[:] while len(seq)<n: seq+=[seq[-3]+seq[-2]+seq[-1]] return seq[:n] for i in range(40): sign=[randint(0,20),randint(0,20),randint(0,20)] n=randint(0,50) Test.it("Testing for signature: "+str(sign)+" and n: "+str(n)) Test.assert_equals(tribonacci(sign[:], n), soluzionacci(sign,n), "It should work with random inputs too")
""" # --------------- SOLUTION --------------- import codewars_test as test def cakes(recipe, available): mn = float( 'inf') # used to store minimum, initialized with positive infinity for ing in recipe: if ing in available: # find how many cakes you can bake for that ingredient and save minimum amount mn = min(mn, available[ing] // recipe[ing]) else: return 0 # if there is no ingredient available no cakes can be baked return mn # --------------- TEST CASES --------------- test.describe('Testing Pete, the Baker') test.it('gives us the right number of cakes') recipe = {"flour": 500, "sugar": 200, "eggs": 1} available = {"flour": 1200, "sugar": 1200, "eggs": 5, "milk": 200} test.assert_equals(cakes(recipe, available), 2, 'Wrong result for example #1') recipe = {"apples": 3, "flour": 300, "sugar": 150, "milk": 100, "oil": 100} available = {"sugar": 500, "flour": 2000, "milk": 2000} test.assert_equals(cakes(recipe, available), 0, 'Wrong result for example #2')
ENJOY LEARNING !! Zizou """ # --------------- SOLUTION --------------- import codewars_test as test def array_leaders(numbers): result = list() for i, num in enumerate(numbers, 1): if num > sum(numbers[i:]): result.append(num) return result # --------------- TEST CASES --------------- test.describe("Sample Tests") test.it("Positive Values") test.assert_equals(array_leaders([1, 2, 3, 4, 0]), [4]) test.assert_equals(array_leaders([16, 17, 4, 3, 5, 2]), [17, 5, 2]) test.it("Negative Values") test.assert_equals(array_leaders([-1, -29, -26, -2]), [-1]) test.assert_equals(array_leaders([-36, -12, -27]), [-36, -12]) test.it("Mixed Values") test.assert_equals(array_leaders([5, 2]), [5, 2]) test.assert_equals(array_leaders([0, -1, -29, 3, 2]), [0, -1, 3, 2])
Input is always going to be valid/reasonable: ie: a non negative number; extra cookie for not using a loop to compute square-by-square (at least not directly) and instead trying a smarter approach [hint: some peculiar operator]; a trick converting the number might also work: impress me! """ # --------------- SOLUTION --------------- import codewars_test as Test def squares_needed(grains): return 0 if grains == 0 else len(bin(grains)) - 2 # --------------- TEST CASES --------------- Test.describe("Basic tests") Test.assert_equals(squares_needed(0), 0) Test.assert_equals(squares_needed(1), 1) Test.assert_equals(squares_needed(2), 2) Test.assert_equals(squares_needed(3), 2) Test.assert_equals(squares_needed(4), 3) print("<COMPLETEDIN::>") Test.describe("Random tests") from random import randint sol = lambda n: 1 + sol(n >> 1) if n else n for _ in range(40): n = randint(1, 10**randint(1, 15)) Test.it("Testing for " + str(n)) Test.assert_equals(squares_needed(n), sol(n), "It should work for random inputs too")
import re import codewars_test as Test def highlight(code): ret = code ret = re.sub(r"(F+)", '<span style="color: pink">\\1</span>', ret) ret = re.sub(r"(L+)", '<span style="color: red">\\1</span>', ret) ret = re.sub(r"(R+)", '<span style="color: green">\\1</span>', ret) ret = re.sub(r"([0-9]+)", '<span style="color: orange">\\1</span>', ret) return ret if __name__ == "__main__": Test.describe("Your Syntax Highlighter") Test.it("should work for the examples provided in the description") print("Code without syntax highlighting: F3RF5LF7") print("Your code with syntax highlighting: " + highlight("F3RF5LF7")) print( 'Expected syntax highlighting: <span style="color: pink">F</span><span style="color: orange">3</span><span style="color: green">R</span><span style="color: pink">F</span><span style="color: orange">5</span><span style="color: red">L</span><span style="color: pink">F</span><span style="color: orange">7</span>' ) Test.assert_equals( highlight("F3RF5LF7"), '<span style="color: pink">F</span><span style="color: orange">3</span><span style="color: green">R</span><span style="color: pink">F</span><span style="color: orange">5</span><span style="color: red">L</span><span style="color: pink">F</span><span style="color: orange">7</span>', ) print("Code without syntax highlighting: FFFR345F2LL") print("Your code with syntax highlighting: " + highlight("FFFR345F2LL")) print( 'Expected syntax highlighting: <span style="color: pink">FFF</span><span style="color: green">R</span><span style="color: orange">345</span><span style="color: pink">F</span><span style="color: orange">2</span><span style="color: red">LL</span>' ) Test.assert_equals(
# return list of film_name's and time of last item of list return [f[0] for f in lst], lst[-1:][0][1] # --------------- TEST CASES --------------- import codewars_test as test test.describe("Computer problem series #2: uTorrent download") file_1 = {"name": "alien", "size_GB": 38, "speed_Mbps": 38} file_2 = {"name": "predator", "size_GB": 38, "speed_Mbps": 2} file_3 = {"name": "terminator", "size_GB": 5, "speed_Mbps": 25} file_4 = {"name": "zombieland", "size_GB": 38, "speed_Mbps": 38} # Basic test.it("Basic tests") files = [file_1, file_2, file_3] test.assert_equals(torrent(files), (["terminator", "alien", "predator"], 152000)) # Order by name in case of a tie test.it("Tie tests") files = [file_1, file_4] test.assert_equals(torrent(files), (["alien", "zombieland"], 8000)) files = [file_4, file_1] test.assert_equals(torrent(files), (["alien", "zombieland"], 8000)) # import random from random import randint, sample, choice # tie tests: high probability of same size and speed between 2 o more films
result = functools.reduce(mul, numbers) return calculate(result, multiplicative+1) def persistence(n): if len(str(n)) == 1: return 0 n, m = calculate(n, 0) return m if __name__== "__main__": import codewars_test as test # Sample Tests test.it("Basic tests") test.assert_equals(persistence(39), 3) # 3*9=27 - 2*7=14 - 1*4=4 test.assert_equals(persistence(4), 0) test.assert_equals(persistence(25), 2) test.assert_equals(persistence(999), 4) # Test Cases from functools import reduce from random import randint #----------------- def soluce(n): digits = [int(d) for d in str(n)] if (len(digits) == 1): return 0 p = reduce(lambda x, y : x * y, digits, 1) return 1 + soluce(p)
What could be easier than comparing integer numbers? However, the given piece of code doesn't recognize some of the special numbers for a reason to be found. Your task is to find the bug and eliminate it. """ # --------------- SOLUTION --------------- import codewars_test as Test def what_is(x): if x == 42: return 'everything' elif x == 42 * 42: return 'everything squared' else: return 'nothing' # --------------- TEST CASES --------------- Test.describe('what_is') Test.it('should work correctly') tests = [ (0, 'nothing'), (123, 'nothing'), (-1, 'nothing'), (42, 'everything'), (42 * 42, 'everything squared'), ] for x, answer in tests: Test.assert_equals(what_is(x), answer)
['a','b','c','d','f'] -> 'e' ['O','Q','R','S'] -> 'P' (Use the English alphabet with 26 letters!) Have fun coding it and please don't forget to vote and rank this kata! :-) I have also created other katas. Take a look if you enjoyed this kata! """ # --------------- SOLUTION --------------- import codewars_test as test from string import ascii_letters def find_missing_letter(chars): start = ascii_letters.index(chars[0]) for i in range(len(chars)): if chars[i] != ascii_letters[start + i]: return ascii_letters[start + i] # --------------- TEST CASES --------------- test.describe("kata tests") test.it("example tests") test.assert_equals(find_missing_letter(['a', 'b', 'c', 'd', 'f']), 'e') test.assert_equals(find_missing_letter(['O', 'Q', 'R', 'S']), 'P')
x = re.search(pattern, barcode) lh = re.findall(r'\d{7}', x.group(1)) rh = re.findall(r'\d{7}', x.group(2)) # convert binary to int digits lh = [str(LEFT_HAND[p]) for p in lh] rh = [str(RIGHT_HAND[p]) for p in rh] # format and return the result return f"{lh[0]} {''.join(lh[1:])} {''.join(rh[:-1])} {rh[-1]}" # --------------- TEST CASES --------------- test.describe('should convert barcode to digits') test.it("Campbell's Chicken Noodle Soup") test.assert_equals( read_barcode( '▍ ▍ ▍▍ ▍ ▍▍ ▍ ▍▍ ▍ ▍▍ ▍ ▍▍ ▍ ▍▍ ▍ ▍ ▍ ▍▍▍ ▍ ▍▍ ▍▍ ▍▍ ▍▍ ▍ ▍▍▍ ▍▍ ▍▍ ▍ ▍ ▍ ▍' ), '0 51000 01251 7') test.it("Hershey's Natural Unsweetened Cocoa") test.assert_equals( read_barcode( '▍ ▍ ▍▍ ▍ ▍▍▍▍ ▍ ▍ ▍▍ ▍▍ ▍ ▍▍ ▍ ▍▍ ▍ ▍ ▍ ▍▍▍ ▍ ▍ ▍▍▍ ▍▍ ▍▍ ▍▍▍ ▍ ▍▍▍ ▍ ▍ ▍▍▍ ▍ ▍' ), '0 34000 05200 4') test.it("Bob's Red Mill Corn Grits") test.assert_equals( read_barcode( '▍ ▍ ▍▍ ▍ ▍▍▍▍ ▍ ▍ ▍▍ ▍ ▍▍ ▍▍▍ ▍▍ ▍▍ ▍▍▍ ▍ ▍ ▍▍▍ ▍ ▍▍▍ ▍ ▍▍ ▍▍ ▍▍ ▍▍ ▍ ▍▍▍ ▍▍ ▍▍ ▍ ▍'
import codewars_test as test from code import countOnes # Sample Tests test.describe("Sample Tests") test.it('Easy') test.assert_equals(countOnes(5, 7), 7) test.assert_equals(countOnes(12, 29), 51) # Test Cases
#!/usr/bin/env python # imports import os import sys from solution import to_weird_case # Module "Global" Variables location = os.path.abspath(__file__) here = os.path.abspath( os.path.dirname(__file__) ) # Get the absolute path for the directory where this file is located "here" project_root = os.path.abspath(os.path.join( here, "..")) # Get the absolute path for the project / repository root sys.path.insert( 0, project_root ) # Extend the system path to include the project root and import the test module # relative imports import codewars_test as test test.describe('to_weird_case') test.it('should return the correct value for a single word') test.assert_equals(to_weird_case('This'), 'ThIs') test.assert_equals(to_weird_case('is'), 'Is') test.it('should return the correct value for multiple words') test.assert_equals(to_weird_case('This is a test'), 'ThIs Is A TeSt')
import codewars_test as test from code import max_sequence # Sample Tests test.describe("Tests") test.it('should work on an empty array') test.assert_equals(max_sequence([]), 0) test.it('should work on the example') test.assert_equals(max_sequence([-2, 1, -3, 4, -1, 2, 1, -5, 4]), 6) # Test Cases try: # backwards compatibility max_sequence = maxSequence except NameError: pass test.describe("Tests") test.it('should work on an empty array') test.assert_equals(max_sequence([]), 0) test.it('should work on the example') test.assert_equals(max_sequence([-2, 1, -3, 4, -1, 2, 1, -5, 4]), 6) test.it('should work on the example with negative numbers') test.assert_equals(max_sequence([-2, -1, -3, -4, -1, -2, -1, -5, -4]), 0) test.it('should work on random arrays') from random import randint def randomArray(size): return [randint(-30, 30) for i in range(0, size)]
# ------------ KATA DESCRIPTION ------------ """ https://www.codewars.com/kata/523b4ff7adca849afe000035 8 kyu - Function 1 - hello world Description: Make a simple function called greet that returns the most-famous "hello world!". Style Points Sure, this is about as easy as it gets. But how clever can you be to create the most creative hello world you can think of? What is a "hello world" solution you would want to show your friends? """ # --------------- SOLUTION --------------- import codewars_test as test def greet(): return "hello world!" # --------------- TEST CASES --------------- test.describe("Greet function") test.it("Making sure greet exists") test.assert_equals(greet(), "hello world!", "Greet doesn't return hello world!")
def do(): def testing(act, exp): Test.expect( abs(act - exp) < 1e-6, "{} should equal {}".format(act, exp)) Test.it("Fixed tests") tests = [["2 + 3 * 4 / 3 - 6 / 3 * 3 + 8", 8], ["1 + 2 * 3 * 3 - 8", 11], ["1 + 2 * 3 * (5 - 2) - 8", 11], ["1 + 2 * 3 * (5 - (3 - 1)) - 8", 11], ["4 + -(1)", 3], ["4 - -(1)", 5], ["4 * -(1)", -4], ["4 / -(1)", -4], ["-1", -1], ["-(-1)", 1], ["-(-(-1))", -1], ["-(-(-(-1)))", 1], ["(((((-1)))))", -1], ["5 - 1", 4], ["5- 1", 4], ["5 -1", 4]] try: if calc("'x'") == "x": Test.expect(False, "Trying to use eval?") except: pass for test in tests: testing(calc(test[0]), test[1]) Test.it("Random tests") for i in range(100): try: expression = "{}{} {} {}{} {} {}{} {} {}{} {} {}{} {} {}{} {} {}{} {} {}{}".format( random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100)) testing(calc(expression), eval(expression)) except ZeroDivisionError: pass for i in range(100): try: expression = "{}({}{}) {} ({}{} {} {}{} {} {}({})) {} ({}{} {} {}((({}({}{} {} {}{})))) {} {}{})".format( random.choice(["-", ""]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.choice(["-", ""]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100), random.choice(["+", "-", "*", "/"]), random.choice(["-", ""]), random.randint(1, 100)) testing(calc(expression), eval(expression)) except ZeroDivisionError: pass for i in range(100): expression = "{}{}- {}{}- {}{}- {}{}".format(random.choice(["-", ""]), random.randint(1, 100), random.choice(["-", ""]), random.randint(1, 100), random.choice(["-", ""]), random.randint(1, 100), random.choice(["-", ""]), random.randint(1, 100)) testing(calc(expression), eval(expression))
def count_letters_and_digits(s): counter = 0 for c in s: if c.isalpha() or c.isnumeric(): counter += 1 return counter if __name__ == "__main__": import codewars_test as Test # Sample tests Test.it('Basic tests') Test.assert_equals(count_letters_and_digits('n!!ice!!123'), 7) Test.assert_equals(count_letters_and_digits('de?=?=tttes!!t'), 8) Test.assert_equals(count_letters_and_digits(''), 0) Test.assert_equals(count_letters_and_digits('!@#$%^&`~.'), 0) Test.assert_equals(count_letters_and_digits('u_n_d_e_r__S_C_O_R_E'), 10) # Test Cases from string import ascii_letters, digits, printable from random import choices, randint def _inner_solution(s): return len(list(filter(lambda x: x in ascii_letters + digits, s))) if type(s) is str else 0 def _random_string(_min=30, _max=100): return ''.join(choices(printable, k=randint(_min, _max))) Test.it('Basic tests')
Note: Your points are not included in the array of your class's points. For calculating the average point you may add your point to the given array! """ # --------------- SOLUTION --------------- import codewars_test as test def better_than_average(class_points, your_points): return your_points > sum(class_points) / len(class_points) # --------------- TEST CASES --------------- test.describe("Basic Tests") test.it("better_than_average([2, 3], 5) should return True") test.assert_equals(better_than_average([2, 3], 5), True) test.it( "better_than_average([100, 40, 34, 57, 29, 72, 57, 88], 75) should return True" ) test.assert_equals(better_than_average([100, 40, 34, 57, 29, 72, 57, 88], 75), True) test.it( "better_than_average([12, 23, 34, 45, 56, 67, 78, 89, 90], 69) should return True" ) test.assert_equals( better_than_average([12, 23, 34, 45, 56, 67, 78, 89, 90], 69), True)
print(four(plus(nine()))) print(eight(minus(three()))) print(six(divided_by(two()))) test.describe('Basic Tests') test.assert_equals(seven(times(five())), 35) test.assert_equals(four(plus(nine())), 13) test.assert_equals(eight(minus(three())), 5) test.assert_equals(six(divided_by(two())), 3) test.describe('Random Tests') base = [ "zero", "one", "two", "three", "four", "five", "six", "seven", "eight", "nine" ] basef = [zero, one, two, three, four, five, six, seven, eight, nine] for _ in range(40): a, b = randint(0, 9), randint(0, 9) test.it("Testing for %s(plus(%s()))" % (base[a], base[b])) test.assert_equals(basef[a](plus(basef[b]())), a + b) a, b = randint(0, 9), randint(0, 9) test.it("Testing for %s(minus(%s()))" % (base[a], base[b])) test.assert_equals(basef[a](minus(basef[b]())), a - b) a, b = randint(0, 9), randint(0, 9) test.it("Testing for %s(times(%s()))" % (base[a], base[b])) test.assert_equals(basef[a](times(basef[b]())), a * b) a, b = randint(0, 9), randint(1, 9) test.it("Testing for %s(divided_by(%s()))" % (base[a], base[b])) test.assert_equals(basef[a](divided_by(basef[b]())), a // b)
C++: unsigned long; You have to return the digits of this number within an array in reverse order. Example: 348597 => [7,9,5,8,4,3] """ # --------------- SOLUTION --------------- import codewars_test as Test def digitize(n): return [int(i) for i in reversed(str(n))] # --------------- TEST CASES --------------- Test.assert_equals(digitize(35231), [1, 3, 2, 5, 3]) Test.assert_equals(digitize(23582357), [7, 5, 3, 2, 8, 5, 3, 2]) Test.assert_equals(digitize(984764738), [8, 3, 7, 4, 6, 7, 4, 8, 9]) Test.assert_equals(digitize(45762893920), [0, 2, 9, 3, 9, 8, 2, 6, 7, 5, 4]) Test.assert_equals(digitize(548702838394), [4, 9, 3, 8, 3, 8, 2, 0, 7, 8, 4, 5]) Test.describe('Random tests') from random import randint for x in range(37): y = randint(10, 99 * 2**x) Test.it('Testing %s' % y) Test.assert_equals(digitize(y), list(map(int, list(str(y)[::-1]))))
#!/usr/bin/env python import codewars_test as test from calc import Calculator test.it("Tests") for key, val in { "127": 127, "2 + 3": 5, "2 - 3 - 4": -5, "10 * 5 / 2": 25, "2 / 2 + 3 * 4 - 6": 7, "2 + 3 * 4 / 3 - 6 / 3 * 3 + 8": 8, "1.1 + 2.2 + 3.3": 6.6, "1.1 * 2.2 * 3.3": 7.986 }.items(): actual = Calculator().evaluate(key) test.expect(isinstance(actual, (float, int)), "Your result should be a number, not: " + str(type(actual))) test.expect( abs(actual - val) < 1e-12, "Expected %s == %s, but got %s" % (key, val, actual))
#!/usr/bin/env python # imports import os import sys from solution import persistence # Module "Global" Variables location = os.path.abspath(__file__) here = os.path.abspath( os.path.dirname(__file__) ) # Get the absolute path for the directory where this file is located "here" project_root = os.path.abspath(os.path.join( here, "..")) # Get the absolute path for the project / repository root sys.path.insert( 0, project_root ) # Extend the system path to include the project root and import the test module # relative imports import codewars_test as test test.it("Basic tests") test.assert_equals(persistence(39), 3) test.assert_equals(persistence(4), 0) test.assert_equals(persistence(25), 2) test.assert_equals(persistence(999), 4)
def __init__(self, x): self.x = x def bar(self, v): return (self.x, v) a = Foo(1) a.bar(2) calls = Debugger.method_calls test.assert_equals(len(calls), 2) test.describe("Test collected method calls") test.it("Call to init should be collected") test.assert_equals(calls[0]['args'], (a, 1)) test.it("Call to bar should be collected") test.assert_equals(calls[1]['args'], (a, 2)) test.describe("Test collected attribute accesses") accesses = Debugger.attribute_accesses print(Debugger.method_calls) test.assert_equals(len(accesses), 3) test.it("Attribute set in init should be collected") test.assert_equals(accesses[0]['action'], 'set') test.assert_equals(accesses[0]['attribute'], 'x') test.assert_equals(accesses[0]['value'], 1)
maskify("Nananananananananananananananana Batman!") == "####################################man!" """ # --------------- SOLUTION --------------- import codewars_test as test # return masked string def maskify(cc): return "#" * (len(cc) - 4) + cc[-4:] # --------------- TEST CASES --------------- cc = '' r = maskify(cc) test.describe("masking: {0}".format(cc)) test.it("{0} matches {1}".format(cc, r)) test.assert_equals(r, cc) cc = '123' r = maskify(cc) test.describe("masking: {0}".format(cc)) test.it("{0} matches {1}".format(cc, r)) test.assert_equals(r, cc) cc = 'SF$SDfgsd2eA' r = maskify(cc) test.describe("masking: {0}".format(cc)) test.it("{0} matches {1}".format('########d2eA', r)) test.assert_equals(r, '########d2eA')
# ------------ KATA DESCRIPTION ------------ """ 8 kyu Array plus array I'm new to coding and now I want to get the sum of two arrays...actually the sum of all their elements. I'll appreciate for your help. P.S. Each array includes only integer numbers. Output is a number too. """ # --------------- SOLUTION --------------- import codewars_test as Test def array_plus_array(arr1, arr2): return sum(arr1) + sum(arr2) # --------------- TEST CASES --------------- Test.it("Basic test") Test.assert_equals(array_plus_array([1, 2, 3], [4, 5, 6]), 21) Test.assert_equals(array_plus_array([-1, -2, -3], [-4, -5, -6]), -21) Test.assert_equals(array_plus_array([0, 0, 0], [4, 5, 6]), 15) Test.assert_equals(array_plus_array([100, 200, 300], [400, 500, 600]), 2100)
Maximum subarray sum The maximum sum subarray problem consists in finding the maximum sum of a contiguous subsequence in an array or list of integers: maxSequence([-2, 1, -3, 4, -1, 2, 1, -5, 4]) # should be 6: [4, -1, 2, 1] Easy case is when the list is made up of only positive numbers and the maximum sum is the sum of the whole array. If the list is made up of only negative numbers, return 0 instead. Empty list is considered to have zero greatest sum. Note that the empty list or array is also a valid sublist/subarray. """ # --------------- SOLUTION --------------- import codewars_test as test def maxSequence(arr): max_sum = 0 for i in range(len(arr)): for j in range(len(arr)-i): sm = sum(arr[i:len(arr)-j]) max_sum = sm if sm > max_sum else max_sum return max_sum # --------------- TEST CASES --------------- test.describe("Tests") test.it('should work on an empty array') test.assert_equals(maxSequence([]), 0) test.it('should work on the example') test.assert_equals(maxSequence([-2, 1, -3, 4, -1, 2, 1, -5, 4]), 6)
def second_example_test_case(): for nmbr in range(1, 9): a = nmbr ** nmbr test.it("Testing %d and %d" % (a, 0)) test.assert_equals(last_digit(a, 0), 1, "x ** 0 must return 1")
import codewars_test as Test import Context import Operations Test.it("Basic tests") Test.assert_equals(Operations.sumar(1, 2), 3) Test.assert_equals(Operations.sumar(2, 2), 4) Test.assert_equals(Operations.restar(1, 2), -1) Test.assert_equals(Operations.restar(1, 7), -6)
char) # counts number of "chars" in s1 and s2 strings if l1 > 1 or l2 > 1: if l1 == l2: mas.append((l1, "=:" + str(char) * l1)) elif l1 != l2: mas.append((max(l1, l2), ("1" if l1 > l2 else "2") + ":" + str(char) * max(l1, l2))) mas.sort(key=lambda row: row[1]) mas.sort(key=lambda row: row[0], reverse=True) return '/'.join([item[1] for item in mas]) # --------------- TEST CASES --------------- Test.describe("Mix") Test.it("Basic Tests") Test.assert_equals(mix("Are they here", "yes, they are here"), "2:eeeee/2:yy/=:hh/=:rr") Test.assert_equals( mix("looping is fun but dangerous", "less dangerous than coding"), "1:ooo/1:uuu/2:sss/=:nnn/1:ii/2:aa/2:dd/2:ee/=:gg") Test.assert_equals(mix(" In many languages", " there's a pair of functions"), "1:aaa/1:nnn/1:gg/2:ee/2:ff/2:ii/2:oo/2:rr/2:ss/2:tt") Test.assert_equals(mix("Lords of the Fallen", "gamekult"), "1:ee/1:ll/1:oo") Test.assert_equals(mix("codewars", "codewars"), "") Test.assert_equals(mix("A generation must confront the looming ", "codewarrs"), "1:nnnnn/1:ooooo/1:tttt/1:eee/1:gg/1:ii/1:mm/=:rr")
# ------------ KATA DESCRIPTION ------------ """ 8 kyu - Sum of positive You get an array of numbers, return the sum of all of the positives ones. Example [1,-4,7,12] => 1 + 7 + 12 = 20 Note: if there is nothing to sum, the sum is default to 0. """ # --------------- SOLUTION --------------- import codewars_test as test def positive_sum(arr): return sum(x for x in arr if x > 0) # --------------- TEST CASES --------------- test.describe("positive_sum") test.it("works for some examples") test.assert_equals(positive_sum([1, 2, 3, 4, 5]), 15) test.assert_equals(positive_sum([1, -2, 3, 4, 5]), 13) test.assert_equals(positive_sum([-1, 2, 3, 4, -5]), 9) test.it("returns 0 when array is empty") test.assert_equals(positive_sum([]), 0) test.it("returns 0 when all elements are negative") test.assert_equals(positive_sum([-1, -2, -3, -4, -5]), 0)