description
stringlengths
38
154k
category
stringclasses
5 values
solutions
stringlengths
13
289k
name
stringlengths
3
179
id
stringlengths
24
24
tags
listlengths
0
13
url
stringlengths
54
54
rank_name
stringclasses
8 values
<link href="https://fonts.googleapis.com/css?family=Comfortaa&effect=canvas-print" rel="stylesheet"> <style> .task { background: #fff; color: #333; padding: 25px; box-sizing: border-box; font-family: Comfortaa, sans-serif !important; position: relative; } .task code, .task_code { display: inline-block; padding: 0; border-radius: 2px; margin: 0; position: relative; top: 6px; background: bisque; border: 1px solid #f9d2a4; padding: 3px; line-height: 1em; } .task_code { top: -1px; } .task_header { color: #333 !important; margin-top: 0; font-size: 30px !important; } .task_inner { box-shadow: 0 2px 11px -3px rgba(0,0,0,.6); padding: 20px; border-radius: 3px; } .task_devil { float: right; margin-left: 15px; shape-outside: circle(150px); } .task_devil img { max-width: 150px; } .task_part-header { font-size: 20px !important; font-weight: 800; color: #333; padding: 20px 0 10px; } .task_part-header:first-of-type { padding-top: 0; } .task_list { padding: 0; margin: 10px 0; padding-left: 30px; } .task_list ul { padding: 0; margin: 0; } .font-effect-canvas-print { color: black; } </style> <div class="task"> <h1 class="task_header font-effect-canvas-print">Devil's Sequence</h1> <div class="task_inner"> <div class="task_part-header font-effect-canvas-print">Problem</div> <div class="task_devil"> <img src="https://cloud.githubusercontent.com/assets/1553519/20080980/c85a971e-a55d-11e6-8cff-bd10cbc81aa7.png"></img> </div> Robodevil likes to do some mathematics between rehearsals of his orchestra. Today he invented devilish sequence No. 1729: <div class="task_list"> <ul> <li>x<sub>0</sub> = 0,</li> <li>x<sub>1</sub> = 1,</li> <li>x<sub>n</sub> = (x<sub>n - 1</sub> + x<sub>n - 2</sub>) / 2.</li> </ul> </div> For example, <span class="task_code">x<sub>10</sub> = 0.666015625</span>. Robodevil became interested at once how many `sixes` there were at the beginning of an arbitrary x<sub>n</sub>. In 6 nanoseconds, he had a formula. Can you do the same? <div class="task_part-header font-effect-canvas-print">Input</div> You are given an integer n; `2 ≤ n ≤ 100000`. <div class="task_part-header font-effect-canvas-print">Output</div> Output the number of sixes at the beginning of x<sub>n</sub> in decimal notation. <div class="task_part-header font-effect-canvas-print">Example</div> <div class="task_table"> <table> <tr> <th class="font-effect-canvas-print">Input</th> <th class="font-effect-canvas-print">Output</th> </tr> <tr> <td>10</td> <td>3</td> </tr> </table> </div> </div> </div>
algorithms
from math import floor, log def count_sixes(n): return floor((n - n % 2) * log(2, 10))
Devil's Sequence
582110dc2fd420bf7f00117b
[ "Mathematics", "Algorithms" ]
https://www.codewars.com/kata/582110dc2fd420bf7f00117b
5 kyu
Looking at consecutive powers of `2`, starting with `2^1`: `2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, ...` Note that out of all the digits `0-9`, the last one ever to appear is `7`. It only shows up for the first time in the number `32768 (= 2^15)`. So let us define LAST DIGIT TO APPEAR as the last digit to be written down when writing down all the powers of `n`, starting with `n^1`. ## Your task You'll be given a positive integer ```1 =< n <= 10000```, and must return the last digit to appear, as an integer. If for any reason there are digits which never appear in the sequence of powers, return `None`/`nil`. Please note: The Last digit to appear can be in the same number as the penultimate one. For example for `n = 8`, the last digit to appear is `7`, although `3` appears slightly before it, in the same number: `8, 64, 512, 4096, 32768, ...`
reference
def digits(x): return set(str(x)) def LDTA(n): if digits(n) == digits(n * n): return None seen = [] x = n while len(seen) < 10: for d in str(x): if d not in seen: seen . append(d) x *= n return int(seen[- 1])
Last Digit to Appear in Sequence of Powers
5ccfcfad7306d900269da53f
[ "Fundamentals" ]
https://www.codewars.com/kata/5ccfcfad7306d900269da53f
7 kyu
A stem-and-leaf plot groups data points that have the same leading digit, resembling a histogram. For example, for the input `[11, 35, 14, 9, 39, 23, 35]`, it might look something like this: ``` stem | leaf ----------- 0 | 9 1 | 1 4 2 | 3 3 | 5 5 9 ``` Some important things to notice: * Any single-digit number, such as `9`, has `0` as its stem; * The leaves are presented in ascending order; * Leaves can be repeated (as with the two 5's in the last row). Create a function called `stem_and_leaf` that, given a list of integers `i` as input (`0 <= i <= 99`), returns a Python dictionary containing a stem-and-leaf plot. Each key of the dictionary should be a stem and each value should be a list of leaves, following the format above. For the example above, the output would be: ``` {0: [9], 1: [1, 4], 2: [3], 3: [5, 5, 9]} ```
reference
from collections import defaultdict def stem_and_leaf(a): d = defaultdict(list) for x in a: d[x / / 10]. append(x % 10) return {x: sorted(y) for x, y in d . items()}
Stem-and-leaf plot
5cc80fbe701f0d001136e5eb
[ "Fundamentals", "Lists" ]
https://www.codewars.com/kata/5cc80fbe701f0d001136e5eb
7 kyu
## Number pyramid Number pyramid is a recursive structure where each next row is constructed by adding adjacent values of the current row. For example: ``` Row 1 [1 2 3 4] Row 2 [3 5 7] Row 3 [8 12] Row 4 [20] ``` ___ ## Task Given the first row of the number pyramid, find the value stored in its last row. ___ ## Performance tests ```python Number of tests: 10 List size: 10,000 ``` ```javascript Number of tests: 5 Array size: 10,000 ``` ```ruby Number of tests: 10 Array size: 10,000 ``` ```haskell Number of tests: 5 List size: 10,000 ```
algorithms
from operator import mul def reduce_pyramid(base): return sum(map(mul, base, comb_n(len(base) - 1))) def comb_n(n): c = 1 for k in range(0, n + 1): yield c c = c * (n - k) / / (k + 1)
Reducing a pyramid
5cc2cd9628b4200020880248
[ "Algorithms", "Performance" ]
https://www.codewars.com/kata/5cc2cd9628b4200020880248
6 kyu
If this challenge is too easy for you, check out: https://www.codewars.com/kata/5cc89c182777b00001b3e6a2 ___ Upside-Down Pyramid Addition is the process of taking a list of numbers and consecutively adding them together until you reach one number. When given the numbers `2, 1, 1` the following process occurs: ``` 2 1 1 3 2 5 ``` This ends in the number `5`. ___ ### YOUR TASK Given the right side of an Upside-Down Pyramid (Ascending), write a function that will return the original list. ### EXAMPLE ```javascript reverse([5, 2, 1]) => [2, 1, 1] ``` ```haskell reversePyramid [5, 2, 1] -> [2, 1, 1] ``` ```python reverse([5, 2, 1]) == [2, 1, 1] ``` ```ruby reverse_pyramid([5, 2, 1]) == [2, 1, 1] ``` NOTE: The Upside-Down Pyramid will never be empty and will always consist of positive integers ONLY.
algorithms
def reverse(lst): ret = [] while lst: ret . append(lst[- 1]) lst = [a - b for a, b in zip(lst, lst[1:])] return ret[:: - 1]
Upside-Down Pyramid Addition...REVERSED!
5cc1e284ece231001ccf7014
[ "Mathematics", "Algorithms" ]
https://www.codewars.com/kata/5cc1e284ece231001ccf7014
6 kyu
Hey, Path Finder, where are you? ## Path Finder Series: - [#1: can you reach the exit?](https://www.codewars.com/kata/5765870e190b1472ec0022a2) - [#2: shortest path](https://www.codewars.com/kata/57658bfa28ed87ecfa00058a) - [#3: the Alpinist](https://www.codewars.com/kata/576986639772456f6f00030c) - [#4: where are you?](https://www.codewars.com/kata/5a0573c446d8435b8e00009f) - [#5: there's someone here](https://www.codewars.com/kata/5a05969cba2a14e541000129)
games
import re class Me (object): def __init__(self): self . x, self . y, self . dx, self . dy = 0, 0, - 1, 0 def move(self, n): self . x += n * self . dx; self . y += n * self . dy def back(self): self . dx *= - 1; self . dy *= - 1 def turn(self, d): self . dx, self . dy = (self . dy * (- 1) * * (d == 'l'), 0) if self . dy else (0, self . dx * (- 1) * * (d == 'r')) def where(self): return [self . x, self . y] def __str__( self): return f'x,y= { self . x } , { self . y } (dx,dy= { self . dx } , { self . dy } )' me = Me() def i_am_here(path): for v in re . findall(r'\d+|.', path): if v in 'RL': me . back() elif v in 'rl': me . turn(v) else: me . move(int(v)) return me . where()
Path Finder #4: where are you?
5a0573c446d8435b8e00009f
[ "Puzzles" ]
https://www.codewars.com/kata/5a0573c446d8435b8e00009f
4 kyu
We define the function `f1(n,k)`, as the least multiple of `n` that has all its digits less than `k`. We define the function `f2(n,k)`, as the least multiple of `n` that has all the digits that are less than `k`, and no others. Each digit may occur more than once in both values of `f1(n,k)` and `f2(n,k)`. The possible values for `n` and `k` according to these ranges for both functions `f1` and `f2` in this kata: ``` 1 <= n <= 1.000.000.000.000 3 <= k <= 9 ``` For example, let's see the value of both functions for `n = 71` and `k = 4`: ``` f1(71,4) == 213 # all its digits less than 4 f2(71,4) == 2130 # 0,1,2,3 all of them present ``` The integer `76` is the first integer that has the same values of `f1` and `f2` for `k = 4`. ``` f1(76,4) = f2(76,4) = 10032 ``` Let's call these kind of numbers, **forgiving numbers**. (Let's continue with the fashion of attributing personality traits to numbers and, of course, an unknown one) So, `76` is the smallest forgiving number of order `4`. In the same way, `485` is the smallest forgiving number of order `5`. Create a function that given an integer `n` and the order `k`, will output the higher and closest forgiving number to `n` of order `k`. Let's see some examples: ``` find_f1_eq_f2(500,5) == 547 find_f1_eq_f2(1600,6) == 1799 find_f1_eq_f2(14900,7) == 14996 ``` If the number `n` is a forgiving itself for a certain order `k`, the function will never output the same value, remember, closest and **higher** than `n`. For example, `3456`, is a forgiving one of order `4`, ``` find_f1_eq_f2(3456,4) == 3462 ``` **Features of the tests:** * `n` and `k` will be always valid and positive integers. * A total of 8 fixed tests. * A total of 150 random tests in the ranges for `n` and `k` given above. I'll be waiting your awesome solution. :)
reference
from itertools import count def f1(n, k): return next(n * m for m in count(1) if all(int(d) < k for d in str(n * m))) def f2(n, k): s = set(map(str, range(0, k))) return next(n * m for m in count(1) if set(str(n * m)) == s) def find_f1_eq_f2(n, k): return next(m for m in count(n + 1) if f1(m, k) == f2(m, k))
Forgiving Numbers
5cb99d1a1e00460024827738
[ "Fundamentals", "Data Structures", "Algorithms", "Mathematics" ]
https://www.codewars.com/kata/5cb99d1a1e00460024827738
7 kyu
Alan is going to watch the Blood Moon (lunar eclipse) tonight for the first time in his life. But his mother, who is a history teacher, thinks the Blood Moon comes with an evil intent. The ancient Inca people interpreted the deep red coloring as a jaguar attacking and eating the moon. But who believes in Inca myths these days? So, Alan decides to prove to her mom that there is no jaguar. How? Well, only little Alan knows that. For now, he needs a small help from you. Help him solve the following calculations so that he gets enough time to prove it before the eclipse starts. <img src="https://i.ibb.co/jRd3Z1K/Screenshot-3.png" alt="Screenshot-3" border="0"> Three semicircles are drawn on `AB`, `AD`, and `AF`. Here `CD` is perpendicular to `AB` and `EF` is perpendicular to `AD`. ## Task Given the radius of the semicircle `ADBCA`, find out the area of the lune `AGFHA` (the shaded area).
algorithms
def blood_moon(r): """ if AC = r = CD then AD = r * root2 then AE = r * root 2 / 2 = EF then AF = r then area AEFH is pi r^2/ 8 area triangle AEF is bh/2 = 1/2r^2 / 2 = r^2 / 4 therefore area AFH = pir^2 / 8 - r^2 / 4 or pir^2 - 2r^2 all over 8 area AFG is pi (r/2)^2 / 2 which is pi r^2 / 8 thus area lune is pir^2 / 8 - (pir^2/8 - r^2 / 4) = r^2 / 4 """ return r * * 2 / 4
Blood Moon
5cba04533e6dce000eaf6126
[ "Mathematics", "Geometry", "Algorithms" ]
https://www.codewars.com/kata/5cba04533e6dce000eaf6126
7 kyu
## A Discovery One fine day while tenaciously turning the soil of his fields, Farmer Arepo found a square stone tablet with letters carved into it... he knew such artifacts may '_show a message in four directions_', so he wisely kept it. As he continued to toil in his work with his favourite rotary plough, he found more such tablets, but with so many crops to sow he had no time to decipher them all. ## Your Task Please help Farmer Arepo by inspecting each tablet to see if it forms a valid <a href="https://en.wikipedia.org/wiki/Sator_Square">Sator Square</a>! <img src="https://i.imgur.com/DjVOjV4.jpeg" title="sator square" width="300"/> ## The Square is a two-dimentional palindrome, made from words of equal length that can be read in these four ways: ``` 1) left-to-right (across) 2) top-to-bottom (down) 3) bottom-to-top (up) 4) right-to-left (reverse) ``` ## An Example Considering this square: ``` B A T S A B U T T U B A S T A B ``` Here are the four ways a word (in this case `"TUBA"`) can be read: <pre style='background:black'> down ↓ B A T S B A <span style='color:green'>T</span> S B <span style='color:green'>A</span> T S B A T S A B U T A B <span style='color:green'>U</span> T A <span style='color:green'>B</span> U T <span style='color:green'>A B U T</span> ← reverse across → <span style='color:green'>T U B A</span> T U <span style='color:green'>B</span> A T <span style='color:green'>U</span> B A T U B A S T A B S T <span style='color:green'>A</span> B S <span style='color:green'>T</span> A B S T A B ↑ up </pre> IMPORTANT: * In a `true` Sator Square, ALL of its words can be read in ALL four of these ways. * If there is any deviation, it would be `false` to consider it a Sator Square. ## Some Details * tablet (square) dimensions range from `2x2` to `33x33` inclusive * all characters used will be upper-case alphabet letters * there is no need to validate any input ## Input * an N x N (square) two-dimentional matrix of uppercase letters ## Output * boolean `true` or `false` whether or not the tablet is a Sator Square ## Enjoy! You may consider one of the following kata to solve next: * [Playing With Toy Blocks ~ Can you build a 4x4 square?](https://www.codewars.com/kata/5cab471da732b30018968071) * [Four Letter Words ~ Mutations](https://www.codewars.com/kata/5cb5eb1f03c3ff4778402099) * [Crossword Puzzle! (2x2)](https://www.codewars.com/kata/5c658c2dd1574532507da30b) * [Interlocking Binary Pairs](https://www.codewars.com/kata/628e3ee2e1daf90030239e8a)
algorithms
def is_sator_square(tablet): A = {'' . join(lst) for lst in tablet} B = {'' . join(lst)[:: - 1] for lst in tablet} C = {'' . join(lst) for lst in zip(* tablet)} D = {'' . join(lst)[:: - 1] for lst in zip(* tablet)} return A == B == C == D
Is Sator Square?
5cb7baa989b1c50014a53333
[ "Arrays", "Data Structures", "Algorithms" ]
https://www.codewars.com/kata/5cb7baa989b1c50014a53333
7 kyu
A pair of numbers has a unique LCM but a single number can be the LCM of more than one possible pairs. For example `12` is the LCM of `(1, 12), (2, 12), (3,4)` etc. For a given positive integer N, the number of different integer pairs with LCM is equal to N can be called the LCM cardinality of that number N. In this kata your job is to find out the LCM cardinality of a number.
reference
from itertools import combinations from math import gcd def lcm_cardinality(n): return 1 + sum(1 for a, b in combinations(divisors(n), 2) if lcm(a, b) == n) def divisors(n): d = {1, n} for k in range(2, int(n * * 0.5) + 1): if n % k == 0: d . add(k) d . add(n / / k) return sorted(d) def lcm(a, b): return a * b / / gcd(a, b)
LCM Cardinality
5c45bef3b6adcb0001d3cc5f
[ "Fundamentals" ]
https://www.codewars.com/kata/5c45bef3b6adcb0001d3cc5f
6 kyu
Your website is divided vertically in sections, and each can be of different size (height). You need to establish the section index (starting at `0`) you are at, given the `scrollY` and `sizes` of all sections. Sections start with `0`, so if first section is `200` high, it takes `0-199` "pixels" and second starts at `200`. ### Example: ~~~if-not:factor With `scrollY = 300` and `sizes = [300,200,400,600,100]` the result will be `1` as it's the second section. With `scrollY = 1600` and `size = [300,200,400,600,100]` the result will be `-1` as it's past last section. ~~~ ~~~if:factor With `scrollY = 300` and `sizes = { 300 200 400 600 100 }` the result will be `1` as it's the second section. With `scrollY = 1600` and `size = { 300 200 400 600 100 }` the result will be `-1` as it's past last section. ~~~ Given the `scrollY` integer (always non-negative) and an array of non-negative integers (with at least one element), calculate the index (starting at `0`) or `-1` if `scrollY` falls beyond last section (indication of an error).
algorithms
def get_section_id(scroll, sizes): c = 0 for idx, s in enumerate(sizes): c += s if scroll < c: return idx return - 1
Which section did you scroll to?
5cb05eee03c3ff002153d4ef
[ "Fundamentals", "Algorithms" ]
https://www.codewars.com/kata/5cb05eee03c3ff002153d4ef
7 kyu
A programmer that loves creating algorithms for security is doing a previous investigation of a special set of primes. Specially, he has to define ranges of values and to have the total number of the required primes. These primes should fulfill the following requirements: * The primes should have at least 3 digits. * The primes can not include the digit 0. * The sum of the digits should be a multiple of a perfect square number. (**Note:** even though 1 is a perfect square, **do not** consider it for obvious reasons) * The product of the first digit by the last one cannot be 45, or in other words, if 5 is the first digit, the last one cannot be 9. * The primes' digits should occur only once. Examples of this kind of primes are: `167, 359`. Cases like `113` and `331` have to be discarded because digits 1 and 3 that appear twice respectively. Once he has these special primes, that fulfill the constraints listed above, he has to classify them in three subsets: bouncy, increasing and decreasing primes. The increasing primes are the ones that have their digits in increasing order, for example : `157, 359, 569`. The decreasing ones, on the other hand, have their digits in decreasing order, for example: `761, 953, 971`. Finally, the bouncy primes are the ones that does not belong to any of both previous subsets: neither increasing nor decreasing ones, for example: `173, 193, 317`. ## Your Task *Do you want to have the results of this investigation and accept the challenge? If your answer is affirmative, continue reading.* Your function will accept an integer higher than 100 (and lower than 50000) as an upper bound of the range to work in, so all these special primes should be lower or equal to the given value of `n`. The function should output a list of lists with the data in this order: ``` [ [data for _bouncy_ primes], [data for _increasing_ primes], [data for _decreasing_ primes] ] ``` The data required for each subset should be as follows: ``` [ min. prime found, max. prime found, number of primes in range ] ``` ## Examples Let's see some examples for some values of n: ``` special_primes(101) --> [[0, 0, 0], [0, 0, 0], [0, 0, 0]] ``` No special primes at this value (obviously). ``` special_primes(200) --> [[0, 0, 0], [0, 0, 0], [0, 0, 0]] ``` Still no special primes. ``` special_primes(457) --> [[251, 439, 2], [349, 457, 4], [431, 431, 1]] ``` Now we have some values: * bouncy primes: `251, 439` (2 in total) * increasing primes: `349, 367, 389, 457` (4) * decreasing primes: `431` (1) ``` special_primes(1000) --> [[251, 947, 11], [349, 479, 5], [431, 983, 4]] ``` * bouncy primes: `251, 439, 547, 587, 619, 659, 673, 691, 839, 857, 947` (11) * increasing primes: `349, 367, 389, 457, 479` (5) * decreasing primes: `431, 521, 853, 983` (4) Good Luck and happy coding! --- Items the programmer has to think after the investigation: - The highest possible prime, with these constraints, is ________. - The larger subset of prime is _______. - The smallest subset of primes is _______. - The sum of the digits of these special primes are always multiples of the perfect squares: __________ If your code passed you have these answers!!
reference
def special_primes(n): cat = [[] for _ in range(3)] for x in range(101, n + 1, 2): dig = list(map(int, str(x))) sum_, set_ = sum(dig), set(dig) if not sum_ % 3 or len(set_) != len(dig): continue if 0 in set_ or dig[0] * dig[- 1] == 45: continue if all(sum_ % k * * 2 for k in range(2, int(sum_ * * .5) + 1)): continue if not all(x % d for d in range(3, int(x * * .5) + 1, 2)): continue cat[sum({(a < b) - (a > b) for a, b in zip(dig, dig[1:])})]. append(x) return [[len(l) and l[0], len(l) and l[- 1], len(l)] for l in cat]
Special Subsets of Primes
55d5f4aae676c3da53000024
[ "Fundamentals", "Algorithms", "Mathematics", "Data Structures" ]
https://www.codewars.com/kata/55d5f4aae676c3da53000024
6 kyu
Consider a pyramid made up of blocks. Each layer of the pyramid is a rectangle of blocks, and the dimensions of these rectangles increment as you descend the pyramid. So, if a layer is a `3x6` rectangle of blocks, then the next layer will be a `4x7` rectangle of blocks. A `1x10` layer will be on top of a `2x11` layer on top of a `3x12` layer, and so on. ## Task Given the dimensions of a pyramid's topmost layer `w,l`, and its height `h` (aka the number of layers), return the total number of blocks in the pyramid. ## Examples `num_blocks(1, 1, 2)` will return `5`. This pyramid starts with a `1x1` layer and has 2 layers total. So, there is 1 block in the first layer, and `2x2=4` blocks in the second. Thus, 5 is the total number of blocks. `num_blocks(2, 4, 3)` will return `47`. This pyramid has 3 layers: `2x4`, `3x5`, and `4x6`. So, there are `47` blocks total. ## Notes All parameters will always be postive nonzero integers. Efficiency is important. There will be: * 100 'small' cases with `w`, `l`, and `h` below `20`. * 100 'big' cases with `w`, `l`, and `h` between `1e9` and `1e10`.
algorithms
def num_blocks(w, l, h): return w * l * h + (w + l) * (h - 1) * h / / 2 + (h - 1) * h * (2 * h - 1) / / 6 """ For those who wonder: first layer being of size w*l, the total number of blocks, SB, is: SB = w*l + (w+1)*(l+1) + (w+2)*(l+2) + ... + (w+h-1)*(l+h-1) So: SB = " Sum from i=0 to h-1 of (w+i)*(l+i) " Let's use the following notation for this: SB = S(i)[ (w+i)*(l+i) ] Then: SB = S(i)[ w*l + i(w+l) + i**2 ] = S(i)[ w*l ] + S(i)[ i(w+l) ] + S(i)[ i**2 ] = w*l*h + (w+l) * S(i)[ i ] + S(i)[ i**2 ] Here, you find two classic sums of sequences (see wiki or equivalent for the demonstrations): S(i)[ i ] = sum of all integers from 1 to x = x*(x+1) // 2 S(i)[ i**2 ] = sum of all squares of integers from 1 to x = x*(x+1)*(2*x+1) // 6 Since on our side we do the sum from 0 (which doesn't affect at all the result) to h-1 in place of x, we get: SB = w*l*h + (w+l) * (h-1)*h//2 + (h-1)*h*(2*h-1)//6 """
Blocks in an Irregular Pyramid
5ca6c0a2783dec001da025ee
[ "Mathematics", "Algorithms" ]
https://www.codewars.com/kata/5ca6c0a2783dec001da025ee
6 kyu
A few years ago, <b>Aaron</b> left his old school and registered at another due to security reasons. Now he wishes to find <b>Jane</b>, one of his schoolmates and good friends. There are `n` schools numbered from 1 to `n`. One can travel between each pair of schools by buying a ticket. The ticket between schools `i` and `j` costs `(i + j) modulo (n + 1)` and can be used multiple times. Help <b>Aaron</b> find the minimum total cost to visit all schools. He can start and finish at any school. <b>Range : 1 ≤ n ≤ 10<sup>6</sup></b>
reference
def find_jane(n): return (n - 1) / / 2
Minimum Ticket Cost
5bdc1558ab6bc57f47000b8e
[ "Fundamentals", "Mathematics" ]
https://www.codewars.com/kata/5bdc1558ab6bc57f47000b8e
7 kyu
Removed due to copyright infringement. <!--- Fibsieve had a fantabulous (yes, it's an actual word) birthday party this year. He had so many gifts that he was actually thinking of not having a party next year. Among these gifts there was an `N x N` glass chessboard that had a light in each of its cells. When the board was turned on a distinct cell would light up every second, and then go dark. The cells would light up in the sequence shown in the diagram. Each cell is marked with the second in which it would light up: ![image](https://image.ibb.co/eBibSq/Fibsieve.png) In the first second the light at cell `(1, 1)` would be on. And in the 5th second the cell `(3, 1)` would be on. Now Fibsieve is trying to predict which cell will light up at a certain time (given in seconds). **Output**: `(x, y)` - the column and the row number of a cell which would light up at the `N`'th second. ___ ## Notes * Column and row indices are `1-based`. * `x` is the column index, and `y` is the row index. * The cells are indexed from bottom-left corner. * `N` will be large. --->
algorithms
from math import ceil, sqrt def fantabulous_birthday(n): a = ceil(sqrt(n)) b = a * a - a + 1 c = a - abs(n - b) return [a, c] if (n < b) ^ (a % 2) == 0 else [c, a]
Fantabulous Birthday
5be83eb488c754f304000185
[ "Algorithms", "Fundamentals", "Mathematics", "Logic", "Numbers" ]
https://www.codewars.com/kata/5be83eb488c754f304000185
6 kyu
`{a, e, i, o, u, A, E, I, O, U}` Natural Language Understanding is the subdomain of Natural Language Processing where people used to design AI based applications have ability to understand the human languages. HashInclude Speech Processing team has a project named Virtual Assistant. For this project they appointed you as a data engineer (who has good knowledge of creating clean datasets by writing efficient code). As a data engineer your first task is to make vowel recognition dataset. In this task you have to find the presence of vowels in all possible substrings of the given string. For each given string you have to return the total number of vowels. ## Example Given a string `"baceb"` you can split it into substrings: `b, ba, bac, bace, baceb, a, ac, ace, aceb, c, ce, ceb, e, eb, b`. The number of vowels in each of these substrings is `0, 1, 1, 2, 2, 1, 1, 2, 2, 0, 1, 1, 1, 1, 0`; if you sum up these number, you get `16` - the expected output. **Note**: your solution should have linear time complexity.
algorithms
def vowel_recognition(input): vowels = set('aeiouAEIOU') s = t = 0 for c, e in enumerate(input, 1): if e in vowels: t += c s += t return s
Vowel Recognition
5bed96b9a68c19d394000b1d
[ "Algorithms", "Performance" ]
https://www.codewars.com/kata/5bed96b9a68c19d394000b1d
6 kyu
## My problem I'm currently applying/interviewing for jobs, and as graph problems are one of my weaker points, I'm working on leveling up on them. I noticed that Codewars didn't have a kata of the classic Clone Graph problem yet, so I thought I would fix that. :-) ## Your problem In this kata you need to clone a connected undirected graph, and return the cloned node of the node orginally sent to your function. In Python (I'll add other languages later) each node in the graph is an instance of this GraphNode class, which is provided for you in the kata: ``` class GraphNode: def __init__(self, val): self.val = val # an integer self.neighbors = [] # a list of GraphNode nodes ``` Here's a visualization of the graph in the fourth basic test, with some description below: ![a visualization of the small graph with a duplicate node value from the Basic Tests](http://tachyonlabs.com/miscimages/small_graph_with_duplicate_node.png) This image represents five GraphNode nodes forming a connected graph, with the gray lines indicating the neighbor relationships between the nodes. The node highlighted in green represents the node that your clone_graph function receives in the fourth basic test -- it has a value of 2, and it has all of the other four nodes as neighbors. Likewise, each of those other four nodes have the highlighted node as a neighbor. The nodes with values of 1 and 3 also have each other as neighbors. Like the highlighted node, the node shown in the rightmost position here also has a value of 2, but they are different nodes. Because it's an undirected graph, where each of a node's neighbors also has that node as its neighbor, you could traverse the graph no matter which node you had been given as a starting point, but an important thing here is that when you create a cloned graph with the same number of nodes having the same values and neighbor relationships to each other, the node your function returns needs to be the cloned node of the node it had received. Note: * As shown in the visualization above, nodes in a graph may contain duplicate values. * Although the highlighted node in the visualization graph above has all the other nodes as its neighbors, don't assume that this will generally be the case -- all nodes in a graph will be connected, but they may be more sparsely connected. * A node will never be its own neighbor. * If your function receives None instead of a GraphNode, it should return None. * You are not allowed to use `deepcopy` in this kata, you will have to do it yourself. :-) Have fun!
reference
def clone_graph(node): queue, mp = [node] if node else [], {} while queue: cur = queue . pop(0) mp[cur] = GraphNode(cur . val) for nd in cur . neighbors: if nd not in mp: queue . append(nd) for k in mp: mp[k]. neighbors = [mp[nd] for nd in k . neighbors] return mp . get(node, None)
Clone Graph
5c9a6e225ae9822e70abc7c1
[ "Fundamentals", "Graph Theory" ]
https://www.codewars.com/kata/5c9a6e225ae9822e70abc7c1
6 kyu
# Task In the city, a bus named Fibonacci runs on the road every day. There are `n` stations on the route. The Bus runs from station<sub>1</sub> to station<sub>n</sub>. At the departure station(station<sub>1</sub>), `k` passengers get on the bus. At the second station(station<sub>2</sub>), a certain number of passengers get on and the same number get off. There are still `k` passengers on the bus. From station<sub>3</sub> to station<sub>n-1</sub>, the number of boarding and alighting passengers follows the following rule: - At station<sub>i</sub>, the number of people getting on is the sum of the number of people getting on at the two previous stations(station<sub>i-1</sub> and station<sub>i-2</sub>) - The number of people getting off is equal to the number of people getting on at the previous station(station<sub>i-1</sub>). At station<sub>n</sub>, all the passengers get off the bus. Now, The numbers we know are: `k` passengers get on the bus at station<sub>1</sub>, `n` stations in total, `m` passengers get off the bus at station<sub>n</sub>. We want to know: How many passengers on the bus when the bus runs out station<sub>x</sub>. # Input - `k`: The number of passengers get on the bus at station<sub>1</sub>. - `1 <= k <= 100` - `n`: The total number of stations(1-based). - `6 <= n <= 30` - `m`: The number of passengers get off the bus at station<sub>n</sub>. - `1 <= m <= 10^10` - `x`: Station<sub>x</sub>(1-based). The station we need to calculate. - `3 <= m <= n-1` - All inputs are valid integers. # Output An integer. The number of passengers on the bus when the bus runs out station<sub>x</sub>.
algorithms
def sim(k, n, p): r = [(k, k, 0), (k, p, p)] for i in range(n - 2): u, d = r[0][1] + r[1][1], r[1][1] r = [r[1], (r[1][0] + u - d, u, d)] return r[1][0] def calc(k, n, m, x): z, o = sim(k, n - 1, 0), sim(k, n - 1, 1) return sim(k, x, (m - z) / / (o - z))
Kata 2019: Fibonacci Bus
5c2c0c5e2f172f0fae21729f
[ "Mathematics", "Algorithms" ]
https://www.codewars.com/kata/5c2c0c5e2f172f0fae21729f
6 kyu
*This kata is based on [Project Euler Problem #349](https://projecteuler.net/problem=349). You may want to start with solving [this kata](https://www.codewars.com/kata/langtons-ant) first.* ### Task [Langton's ant](https://en.wikipedia.org/wiki/Langton%27s_ant) moves on a regular grid of squares that are coloured either black or white. The ant is always oriented in one of the cardinal directions (left, right, up or down) and moves according to the following rules: - if it is on a black square, it flips the colour of the square to white, rotates 90 degrees counterclockwise (left) and moves forward one square. - if it is on a white square, it flips the colour of the square to black, rotates 90 degrees clockwise (right) and moves forward one square. Starting with a grid that is **entirely white**, how many squares are black after `n` moves of the ant? **Note:** `n` will go as high as 10<sup>20</sup> --- ### My other katas If you enjoyed this kata then please try [my other katas](https://www.codewars.com/users/anter69/authored)! :-) #### *Translations are welcome!*
algorithms
# precalculate results LIMIT = 11000 # > 9977 + 104 CACHE = [0] GRID = set() # empty grid x, y = 0, 0 # ant's position dx, dy = 1, 0 # direction for _ in range(LIMIT + 1): if (x, y) in GRID: # square is black GRID . remove((x, y)) dx, dy = - dy, dx else: # square is white GRID . add((x, y)) dx, dy = dy, - dx # move forward x += dx y += dy # store number of black squares CACHE . append(len(GRID)) def langtons_ant(n): if n < LIMIT: return CACHE[n] # a(n+104) = a(n) + 12 for n > 9976 x = (n - LIMIT) / / 104 + 1 return CACHE[n - x * 104] + x * 12
Langton's Ant - Advanced Version
5c99553d5c67244b60cb5722
[ "Mathematics", "Performance", "Algorithms" ]
https://www.codewars.com/kata/5c99553d5c67244b60cb5722
5 kyu
A Magic Square contains the integers 1 to n<sup>2</sup>, arranged in an n by n array such that the columns, rows and both main diagonals add up to the same number.<br/>For doubly even positive integers (multiples of 4) the following method can be used to create a magic square.<br/> Fill an array with the numbers 1 to n<sup>2</sup> in succession. Then, for each 4 by 4 subarray, replace the entries on the blue and red diagonals by n<sup>2</sup>+1-a<sub>ij</sub>.<br/> So, in the following example, a<sub>11</sub> (row 1, column 1) was initially 1 and is replaced by 8<sup>2</sup>+1-1 = 64 <style type="text/css"> tab1 { padding-left: 2em; } fc1 { font color="blue"} </style> <h5><code> n=8<br/><br/> <font color="blue">64</font><tab1>2 <tab1>3 <tab1><font color="red">61</font><tab1><font color="blue">60</font><tab1>6 <tab1>7 <tab1><font color="red">57</font><br/> 9 <tab1><font color="blue">55</font><tab1><font color="red">54</font><tab1>12<tab1>13<tab1><font color="blue">51</font><tab1><font color="red">50</font><tab1>16<br/> 17<tab1><font color="red">47</font><tab1><font color="blue">46</font><tab1>20<tab1>21<tab1><font color="red">43</font><tab1><font color="blue">42</font><tab1>24<br/> <font color="red">40</font><tab1>26<tab1>27<tab1><font color="blue">37</font><tab1><font color="red">36</font><tab1>30<tab1>31<tab1><font color="blue">33</font><br/> <font color="blue">32</font><tab1>34<tab1>35<tab1><font color="red">29</font><tab1><font color="blue">28</font><tab1>38<tab1>39<tab1><font color="red">25</font><br/> 41<tab1><font color="blue">23</font><tab1><font color="red">22</font><tab1>44<tab1>45<tab1><font color="blue">19</font><tab1><font color="red">18</font><tab1>48<br/> 49<tab1><font color="red">15</font><tab1><font color="blue">14</font><tab1>52<tab1>53<tab1><font color="red">11</font><tab1><font color="blue">10</font><tab1>56<br/> <font color="red">8 </font><tab1>58<tab1>59<tab1><font color="blue">5 </font><tab1><font color="red">4 </font><tab1>62<tab1>63<tab1><font color="blue">1</font> <br/> </code></h5> <br />The function even_magic() should return a 2D array as follows:-<br/> Example: <h5><code>n=4: Output: [[16,2,3,13],[5,11,10,8],[9,7,6,12],[4,14,15,1]] <br /><br/> 16<tab1>2 <tab1>3 <tab1>13<br/> 5 <tab1>11<tab1>10<tab1>8 <br/> 9 <tab1>7 <tab1>6 <tab1>12<br/> 4 <tab1>14<tab1>15<tab1>1 <br/> </code></h5> Only doubly even numbers will be passed to the function in the tests. See <a href="http://mathworld.wolfram.com/MagicSquare.html">mathworld.wolfram.com</a> for further details.
games
def even_magic(n): return [[n * n - (y * n + x) if x % 4 == y % 4 or (x % 4 + y % 4) % 4 == 3 else y * n + x + 1 for x in range(n)] for y in range(n)]
Double Even Magic Square
570e0a6ce5c9a0a8c4000bbb
[ "Fundamentals", "Puzzles", "Arrays", "Mathematics" ]
https://www.codewars.com/kata/570e0a6ce5c9a0a8c4000bbb
6 kyu
*Based on this Numberphile video: https://www.youtube.com/watch?v=Wim9WJeDTHQ* --- Multiply all the digits of a nonnegative integer `n` by each other, repeating with the product until a single digit is obtained. The number of steps required is known as the **multiplicative persistence**. Create a function that calculates the individual results of each step, not including the original number, but including the single digit, and outputs the result as a list/array. If the input is a single digit, return an empty list/array. ## Examples ``` per(1) = [] per(10) = [0] // 1*0 = 0 per(69) = [54, 20, 0] // 6*9 = 54 --> 5*4 = 20 --> 2*0 = 0 per(277777788888899) = [4996238671872, 438939648, 4478976, 338688, 27648, 2688, 768, 336, 54, 20, 0] // 2*7*7*7*7*7*7*8*8*8*8*8*8*9*9 = 4996238671872 --> 4*9*9*6*2*3*8*6*7*1*8*7*2 = 4478976 --> ... ```
algorithms
def per(n): r = [] while n >= 10: p = 1 for i in str(n): p = p * int(i) r . append(p) n = p return r
Multiplicative Persistence... What's special about 277777788888899?
5c942f40bc4575001a3ea7ec
[ "Algorithms" ]
https://www.codewars.com/kata/5c942f40bc4575001a3ea7ec
7 kyu
Given a string `s` and a character `c`, return an array of integers representing the shortest distance from the current character in `s` to `c`. ### Notes * All letters will be lowercase. * If the string is empty, return an empty array. * If the character is not present, return an empty array. ## Examples ``` s = "lovecodewars" c = "e" result = [3, 2, 1, 0, 1, 2, 1, 0, 1, 2, 3, 4] s = "aaaabbbb" c = "b" result = [4, 3, 2, 1, 0, 0, 0, 0] s = "" c = "b" result = [] s = "abcde" c = "" result = [] ``` ___ If you liked it, please rate :D
algorithms
def shortest_to_char(s, c): if not s or not c: return [] indexes = [i for i, ch in enumerate(s) if ch == c] if not indexes: return [] return [min(abs(i - ic) for ic in indexes) for i in range(len(s))]
Shortest Distance to a Character
5c8bf3ec5048ca2c8e954bf3
[ "Strings", "Algorithms" ]
https://www.codewars.com/kata/5c8bf3ec5048ca2c8e954bf3
6 kyu
You have read the title: you must guess a sequence. It will have something to do with the number given. ## Example ``` x = 16 result = [1, 10, 11, 12, 13, 14, 15, 16, 2, 3, 4, 5, 6, 7, 8, 9] ``` Good luck!
algorithms
def sequence(x): return sorted(range(1, x + 1), key=str)
Guess the Sequence
5b45e4b3f41dd36bf9000090
[ "Puzzles", "Algorithms" ]
https://www.codewars.com/kata/5b45e4b3f41dd36bf9000090
7 kyu
*This kata is inspired by [Project Euler Problem #387](https://projecteuler.net/problem=387)* ### Description A [Harshad number](https://en.wikipedia.org/wiki/Harshad_number) (or Niven number) is a number that is divisible by the sum of its digits. A *right truncatable Harshad number* is any Harshad number that, when recursively right-truncated, results in a Harshad number at each truncation. By definition, 1-digit numbers are **not** right truncatable Harshad numbers. For example `201` (which is a Harshad number) yields `20`, then `2` when right-truncated, which are all Harshad numbers. Thus `201` is a *right truncatable Harshad number*. ### Your task Given a range of numbers (`a..b`, both included), return the list of right truncatable Harshad numbers in this range. ```if-not:javascript Note: there are `500` random tests, with 0 <= `a` <= `b` <= 10<sup>16</sup> ``` ```if:javascript Note: there are `500` random tests, with `0 <= a <= b <= Number.MAX_SAFE_INTEGER` ``` ### Examples ``` 0, 20 --> [10, 12, 18, 20] 30, 100 --> [30, 36, 40, 42, 45, 48, 50, 54, 60, 63, 70, 72, 80, 81, 84, 90, 100] 90, 200 --> [90, 100, 102, 108, 120, 126, 180, 200] 200, 210 --> [200, 201, 204, 207, 209, 210] 1000, 2000 --> [1000, 1002, 1008, 1020, 1026, 1080, 1088, 1200, 1204, 1206, 1260, 1800, 2000] 2200, 2300 --> [] 9000002182976, 9000195371842 --> [9000004000000, 9000004000008] ``` --- ### My other katas If you enjoyed this kata then please try [my other katas](https://www.codewars.com/users/anter69/authored)! :-) #### *Translations are welcome!*
algorithms
def gen(n): if n >= 10 * * 16: return for i in range(10): x = 10 * n + i if x % sum(map(int, str(x))): continue yield x for y in gen(x): yield y L = sorted(x for n in range(1, 10) for x in gen(n)) from bisect import bisect_left as bl, bisect_right as br def rthn_between(a, b): return L[bl(L, a): br(L, b)]
Right Truncatable Harshad numbers
5c824b7b9775761ada934500
[ "Mathematics", "Number Theory", "Algorithms" ]
https://www.codewars.com/kata/5c824b7b9775761ada934500
5 kyu
[Haikus](https://en.wikipedia.org/wiki/Haiku_in_English) are short poems in a three-line format, with 17 syllables arranged in a 5–7–5 pattern. Your task is to check if the supplied text is a haiku or not. #### About syllables [Syllables](https://en.wikipedia.org/wiki/Syllable) are the phonological building blocks of words. *In this kata*, a syllable is a part of a word including a vowel ("a-e-i-o-u-y") or a group of vowels (e.g. "ou", "ee", "ay"). A few examples: *"tea", "can", "to·day", "week·end", "el·e·phant".* **However**, silent "E"s **do not** create syllables. *In this kata*, an "E" is considered silent if it's alone at the end of the word, preceded by one (or more) consonant(s) and there is at least one other syllable in the word. Examples: *"age", "ar·range", "con·crete";* but not in *"she", "blue", "de·gree".* Some more examples: * one syllable words: *"cat", "cool", "sprout", "like", "eye", "squeeze"* * two syllables words: *"ac·count", "hon·est", "beau·ty", "a·live", "be·cause", "re·store"* ### Examples ``` An old silent pond... A frog jumps into the pond, splash! Silence again. ``` ...should return `True`, as this is a valid 5–7–5 haiku: ``` An old si·lent pond... # 5 syllables A frog jumps in·to the pond, # 7 splash! Si·lence a·gain. # 5 ``` Another example: ``` Autumn moonlight - a worm digs silently into the chestnut. ``` ...should return `False`, because the number of syllables per line is not correct: ``` Au·tumn moon·light - # 4 syllables a worm digs si·lent·ly # 6 in·to the chest·nut. # 5 ``` --- ### My other katas If you enjoyed this kata then please try [my other katas](https://www.codewars.com/users/anter69/authored)! :-) #### *Translations are welcome!*
algorithms
import re PATTERN = re . compile(r'[aeyuio]+[^aeyuio ]*((?=e\b)e)?', flags=re . I) def is_haiku(text): return [5, 7, 5] == [check(s) for s in text . split("\n")] def check(s): return sum(1 for _ in PATTERN . finditer(s))
Haiku Checker
5c765a4f29e50e391e1414d4
[ "Algorithms" ]
https://www.codewars.com/kata/5c765a4f29e50e391e1414d4
5 kyu
### Description Lets imagine a yoga classroom as a Square 2D Array of Integers ```classroom```, with each integer representing a person, and the value representing their skill level. ``` classroom = [ [3,2,1,3], [1,3,2,1], [1,1,1,2], ] poses = [1,7,5,9,10,21,4,3] ``` During a yoga class the instructor gives a list of integers ```poses``` representing a yoga pose that each person in the class will attempt to complete. A person can complete a yoga pose if the sum of their row and their skill level is greater than or equal to the value of the pose. ### Task Your task is to return the total amount poses completed for the entire ```classroom```. ### Example ``` classroom = [ [1,1,0,1], #sum = 3 [2,0,6,0], #sum = 8 [0,2,2,0], #sum = 4 ] poses = [4, 0, 20, 10] 3 people in row 1 can complete the first pose Everybody in row 1 can complete the second pose Nobody in row 1 can complete the third pose Nobody in row 1 can complete the fourth pose The total poses completed for row 1 is 7 You'll need to return the total for all rows and all poses. ``` Translations are welcomed!
algorithms
def yoga(classroom, poses): total_poses = 0 for pose in poses: for row in classroom: for person in row: if person + sum(row) >= pose: total_poses += 1 return total_poses
Yoga Class
5c79c07b4ba1e100097f4e1a
[ "Mathematics", "Fundamentals", "Algorithms" ]
https://www.codewars.com/kata/5c79c07b4ba1e100097f4e1a
7 kyu
Create a Regular Expression that matches a string with lowercase characters in alphabetical order, including any number of spaces. There can be NO whitespace between groups of the same letter. Leading and trailing whitespace is also allowed. An empty string should match. Your regex should match: ``` "" "abc" "aaabc " "a bc" " abcdefghijk" "abdfkmnpstvxz" "cxy" "cdklstxy" "bfrtw" "a b c " " acg jko pr" "a z " "v z" "a b cdefg kl" "uv xyz" " ab de gh" "x yz" "abcdefghijklmnopqrstuvwxyz" "a bcdefghijklmnopqrstuvwxyz" ``` It should NOT match: ``` "abcb" "a ab" "abccc cd" "a bcdjkrza" "qwerty" "zyxcba" "abcdfe" "ab c dfe" "a z a" "asdfg" "asd f g" "poqwoieruytjhfg" "\tab" "abc\n" ``` ____ This tools may help you: * [Cheat sheet](https://www.rexegg.com/regex-quickstart.html) * [Online tester](https://regex101.com/)
algorithms
REGEX = r'^ *a* *b* *c* *d* *e* *f* *g* *h* *i* *j* *k* *l* *m* *n* *o* *p* *q* *r* *s* *t* *u* *v* *w* *x* *y* *z* *\Z'
RegEx Like a Boss #2: Alphabetical Order String
5c1a334516537ccd450000d8
[ "Regular Expressions", "Algorithms" ]
https://www.codewars.com/kata/5c1a334516537ccd450000d8
7 kyu
Convert hex-encoded (https://en.wikipedia.org/wiki/Hexadecimal) string to base64 (https://en.wikipedia.org/wiki/Base64) Example: The string: 49276d206b696c6c696e6720796f757220627261696e206c696b65206120706f69736f6e6f7573206d757368726f6f6d Should produce: SSdtIGtpbGxpbmcgeW91ciBicmFpbiBsaWtlIGEgcG9pc29ub3VzIG11c2hyb29t
algorithms
from base64 import b64encode def hex_to_base64(h: str) - > str: return b64encode(bytes . fromhex(h)). decode()
Hex to base64
5b360fcc9212cb0cf300001f
[ "Strings", "Algorithms" ]
https://www.codewars.com/kata/5b360fcc9212cb0cf300001f
6 kyu
### Description As hex values can include letters `A` through to `F`, certain English words can be spelled out, such as `CAFE`, `BEEF`, or `FACADE`. This vocabulary can be extended by using numbers to represent other letters, such as `5EAF00D`, or `DEC0DE5`. Given a string, your task is to return the decimal sum of all words in the string that can be interpreted as such hex values. ### Example Working with the string `"BAG OF BEES"`: ``` "BAG" = 0, as it is not a valid hex value "OF" = 0F = 15 "BEES" = BEE5 = 48869 ``` So the result is the sum of these: 48884 (0 + 15 + 48869) ### Notes * Inputs are all uppercase and contain no punctuation * `0` can be substituted for `O` * `5` can be substituted for `S`
reference
def hex_word_sum(s): return sum(int(w, 16) for w in s . translate(str . maketrans('OS', '05')). split() if set(w) <= set('0123456789ABCDEF'))
Hex Word Sum
5c46ea433dd41b19af1ca3b3
[ "Fundamentals", "Strings" ]
https://www.codewars.com/kata/5c46ea433dd41b19af1ca3b3
7 kyu
In some ranking people collects points. The challenge is sort by points and calulate position for every person. But remember if two or more persons have same number of points, they should have same position number and sorted by name (name is unique). For example: Input structure: ```javascript [ { name: "John", points: 100, }, { name: "Bob", points: 130, }, { name: "Mary", points: 120, }, { name: "Kate", points: 120, }, ] ``` ```php [ [ "name" => "John", "points" => 100, ], [ "name" => "Bob", "points" => 130, ], [ "name" => "Mary", "points" => 120, ], [ "name" => "Kate", "points" => 120, ], ] ``` Output should be: ```javascript [ { name: "Bob", points: 130, position: 1, }, { name: "Kate", points: 120, position: 2, }, { name: "Mary", points: 120, position: 2, }, { name: "John", points: 100, position: 4, }, ] ``` ```php [ [ "name" => "Bob", "points" => 130, "position" => 1, ], [ "name" => "Kate", "points" => 120, "position" => 2, ], [ "name" => "Mary", "points" => 120, "position" => 2, ], [ "name" => "John", "points" => 100, "position" => 4, ], ] ```
algorithms
def ranking(a): a . sort(key=lambda x: (- x["points"], x["name"])) for i, x in enumerate(a): x["position"] = i + 1 if not i or x["points"] < a[i - 1]["points"] else a[i - 1]["position"] return a
Ranking position
5c784110bfe2ef660cb90369
[ "Algorithms" ]
https://www.codewars.com/kata/5c784110bfe2ef660cb90369
7 kyu
___ ### Background Moving average of a set of values and a window size is a series of local averages. ``` Example: Values: [1, 2, 3, 4, 5] Window size: 3 Moving average is calculated as: 1, 2, 3, 4, 5 | | ^^^^^^^ (1+2+3)/3 = 2 1, 2, 3, 4, 5 | | ^^^^^^^ (2+3+4)/3 = 3 1, 2, 3, 4, 5 | | ^^^^^^^ (3+4+5)/3 = 4 Here, the moving average would be [2, 3, 4] ``` ---- ### Task Given a list `values` of integers and an integer `n` representing size of the window, calculate and return the moving average. When integer `n` is equal to zero or the size of `values` list is less than window's size, return `None` --- Reference: [Moving average](https://en.wikipedia.org/wiki/Moving_average)
algorithms
def moving_average(a, n): if 0 < n <= len(a): return [sum(a[i: i + n]) / n for i in range(len(a) - n + 1)]
Moving Average
5c745b30f6216a301dc4dda5
[ "Algorithms", "Logic", "Mathematics", "Lists" ]
https://www.codewars.com/kata/5c745b30f6216a301dc4dda5
7 kyu
Given the current exchange rate between the USD and the EUR is 1.1363636 write a function that will accept the Curency type to be returned and a list of the amounts that need to be converted. Don't forget this is a currency so the result will need to be rounded to the second decimal. 'USD' Return format should be `'$100,000.00'` 'EUR' Return format for this kata should be `'100,000.00€'` `to_currency` is a string with values `'USD','EUR'` , `values_list` is a list of floats `solution(to_currency,values)` #EXAMPLES: ``` solution('USD',[1394.0, 250.85, 721.3, 911.25, 1170.67]) = ['$1,584.09', '$285.06', '$819.66', '$1,035.51', '$1,330.31'] solution('EUR',[109.45, 640.31, 1310.99, 669.51, 415.54]) = ['96.32€', '563.47€', '1,153.67€', '589.17€', '365.68€'] ```
reference
def solution(to, lst): dolSym, eurSym, power = ('', '€', - 1) if to == 'EUR' else ('$', '', 1) return [f" { dolSym }{ v * 1.1363636 * * power :, .2 f }{ eurSym } " for v in lst]
Converting Currency II
5c744111cb0cdd3206f96665
[ "Lists", "Mathematics", "Fundamentals", "Algorithms", "Algebra", "Strings" ]
https://www.codewars.com/kata/5c744111cb0cdd3206f96665
7 kyu
## Description You've been working with a lot of different file types recently as your interests have broadened. But what file types are you using the most? With this question in mind we look at the following problem. Given a `List/Array` of Filenames (strings) `files` return a `List/Array of string(s)` containing the most common extension(s). If there is a tie, return a sorted list of all extensions. ### Important Info: * Don't forget, you've been working with a lot of different file types, so expect some interesting extensions/file names/lengths in the random tests. * Filenames and extensions will only contain letters (case sensitive), and numbers. * If a file has multiple extensions (ie: `mysong.mp3.als`) only count the last extension (`.als` in this case) ## Examples ``` files = ['Lakey - Better days.mp3', 'Wheathan - Superlove.wav', 'groovy jam.als', '#4 final mixdown.als', 'album cover.ps', 'good nights.mp3'] ``` would return: `['.als', '.mp3']`, as both of the extensions appear two times in files. ``` files = ['Lakey - Better days.mp3', 'Fisher - Stop it.mp3', 'Fisher - Losing it.mp3', '#4 final mixdown.als', 'album cover.ps', 'good nights.mp3'] ``` would return `['.mp3']`, because it appears more times then any other extension, and no other extension has an equal amount of appearences.
reference
from collections import Counter import re def solve(files): c = Counter(re . match('.*(\.[^.]+)$', fn). group(1) for fn in files) m = max(c . values(), default=0) return sorted(k for k in c if c[k] == m)
Which filetypes are you using the most?
5c7254fcaccda64d01907710
[ "Fundamentals", "Algorithms", "Strings", "Arrays" ]
https://www.codewars.com/kata/5c7254fcaccda64d01907710
6 kyu
# Echo Program Write an <code>echoProgram</code> function (or <code>echo_program</code> depend on language) that returns your solution source code as a string. ~~~if:javascript ### Note: `Function.prototype.toString` has been disabled. ~~~
games
def echo_program(): return open(__file__). read()
Echo
5c6dc504abcd1628cd174bea
[ "Puzzles", "Strings", "Games" ]
https://www.codewars.com/kata/5c6dc504abcd1628cd174bea
7 kyu
Koch curve is a simple geometric fractal. This fractal is constructed as follows: take a segment divided into three equal parts. Instead of the middle part, two identical segments are inserted, set at an angle of 60 degrees to each other. This process is repeated at each iteration: each segment is replaced by four. You must write a program that takes the number n and returns an array of rotation angles when drawing a line from the starting point to the ending point. The rotation angle is positive in a counterclockwise direction. ![Koch curve](https://i2.wp.com/fractal.institute/old/wp-content/uploads/2015/04/748px-Koch_curve_construction.jpg?resize=679%2C697&ssl=1) Input: An integer `n` (`0 <= n <= 8`) Output: An array of angles of rotation. The angle of rotation must be in the interval [-180; 180]. For example, for `n == 0` should return an empty array and for `n == 1` the answer should be `[60, -120, 60]`
reference
def koch_curve(n): if not n: return [] deep = koch_curve(n - 1) return [* deep, 60, * deep, - 120, * deep, 60, * deep]
Koch curve
5c5abf56052d1c0001b22ce5
[ "Algorithms", "Fundamentals" ]
https://www.codewars.com/kata/5c5abf56052d1c0001b22ce5
7 kyu
You are given array of integers, your task will be to count all pairs in that array and return their count. **Notes:** * Array can be empty or contain only one value; in this case return `0` * If there are more pairs of a certain number, count each pair only once. E.g.: for `[0, 0, 0, 0]` the return value is `2` (= 2 pairs of `0`s) * Random tests: maximum array length is 1000, range of values in array is between 0 and 1000 ## Examples ``` [1, 2, 5, 6, 5, 2] --> 2 ``` ...because there are 2 pairs: `2` and `5` ``` [1, 2, 2, 20, 6, 20, 2, 6, 2] --> 4 ``` ...because there are 4 pairs: `2`, `20`, `6` and `2` (again)
reference
def duplicates(arr): return sum(arr . count(i) / / 2 for i in set(arr))
Find all pairs
5c55ad8c9d76d41a62b4ede3
[ "Fundamentals", "Arrays" ]
https://www.codewars.com/kata/5c55ad8c9d76d41a62b4ede3
7 kyu
<h2> INTRODUCTION </h2> <p> The Club Doorman will give you a word. To enter the Club you need to provide the right number according to provided the word.</p> <p>Every given word has a doubled letter, like 'tt' in lettuce.</p> <p>To answer the right number you need to find the doubled letter's position of the given word in the alphabet and multiply this number per 3. <p>It will be given only words with one doubled letter.</p> </p> </br> <pre><h2>EXAMPLE</h2></pre> <code><p> Lettuce is the given word. 't' is the doubled letter and it's position is 20 in the alphabet.</p> <p>The answer to the Club Doorman is 20 * 3 = 60 </p></code> </br> <h2>TASK</h2> <p>The function passTheDoorMan with a given string <code>word</code> shall return the right number.
reference
def pass_the_door_man(word): for i in word: if i * 2 in word: return (ord(i) - 96) * 3
Club Doorman
5c563cb78dac1951c2d60f01
[ "Fundamentals" ]
https://www.codewars.com/kata/5c563cb78dac1951c2d60f01
7 kyu
Mr. Square is going on a holiday. He wants to bring 2 of his favorite squares with him, so he put them in his rectangle suitcase. Write a function that, given the size of the squares and the suitcase, return whether the squares can fit inside the suitcase. ```Python fit_in(a,b,m,n) a,b are the sizes of the 2 squares m,n are the sizes of the suitcase ``` # Example ```Python fit_in(1,2,3,2) should return True fit_in(1,2,2,1) should return False fit_in(3,2,3,2) should return False fit_in(1,2,1,2) should return False ```
games
def fit_in(a, b, m, n): return max(a, b) <= min(m, n) and a + b <= max(m, n)
Suitcase packing
5c556845d7e0334c74698706
[ "Puzzles" ]
https://www.codewars.com/kata/5c556845d7e0334c74698706
7 kyu
There exist two zeroes: +0 (or just 0) and -0. Write a function that returns `true` if the input number is -0 and `false` otherwise (`True` and `False` for Python). In JavaScript / TypeScript / Coffeescript the input will be a number. In Python / Java / C / NASM / Haskell / the input will be a float.
reference
def is_negative_zero(n): return str(n) == '-0.0'
Is It Negative Zero (-0)?
5c5086287bc6600001c7589a
[ "Fundamentals" ]
https://www.codewars.com/kata/5c5086287bc6600001c7589a
7 kyu
## Description For this Kata you will be given an array of numbers and another number `n`. You have to find the **sum** of the `n` largest numbers of the array and the **product** of the `n` smallest numbers of the array, and compare the two. If the sum of the `n` largest numbers is higher, return `"sum"` If the product of the `n` smallest numbers is higher, return `"product"` If the 2 values are equal, return `"same"` **Note** The array will never be empty and `n` will always be smaller than the length of the array. ## Example ```javascript sumOrProduct([10, 41, 8, 16, 20, 36, 9, 13, 20], 3) // => "product" ``` ```haskell productOrSum [10, 41, 8, 16, 20, 36, 9, 13, 20] 3 -> Product ``` ```rust sum_or_product(&[10, 41, 8, 16, 20, 36, 9, 13, 20], 3) // => "product" ``` ```python sum_or_product([10, 41, 8, 16, 20, 36, 9, 13, 20], 3) # => "product" ``` ```julia sumorproduct([10, 41, 8, 16, 20, 36, 9, 13, 20], 3) # => "product" ``` ## Explanation The sum of the 3 highest numbers is `41 + 36 + 20 = 97` The product of the lowest 3 numbers is `8 x 9 x 10 = 720` The product of the 3 lowest numbers is higher than the sum of the 3 highest numbers so the function returns `"product"` ~~~if:haskell ## Note The return datatype has been Preloaded for you. It is data ProductOrSum = Product | Same | Sum deriving (Eq,Ord,Enum,Bounded,Show) ~~~
reference
from math import prod def sum_or_product(array, n): array . sort() n_sum = sum(array[- n:]) n_prod = prod(array[: n]) return "sum" if n_sum > n_prod else "product" if n_sum < n_prod else "same"
Larger Product or Sum
5c4cb8fc3cf185147a5bdd02
[ "Fundamentals", "Mathematics", "Algorithms" ]
https://www.codewars.com/kata/5c4cb8fc3cf185147a5bdd02
7 kyu
Given 2 elevators (named "left" and "right") in a building with 3 floors (numbered `0` to `2`), write a function `elevator` accepting 3 arguments (in order): - `left` - The current floor of the left elevator - `right` - The current floor of the right elevator - `call` - The floor that called an elevator It should return the name of the elevator closest to the called floor (`"left"`/`"right"`). In the case where both elevators are equally distant from the called floor, choose the elevator to the right. You can assume that the inputs will always be valid integers between 0-2. Examples: ```javascript elevator(0, 1, 0); // => "left" elevator(0, 1, 1); // => "right" elevator(0, 1, 2); // => "right" elevator(0, 0, 0); // => "right" elevator(0, 2, 1); // => "right" ``` ```python elevator(0, 1, 0) # => "left" elevator(0, 1, 1) # => "right" elevator(0, 1, 2) # => "right" elevator(0, 0, 0) # => "right" elevator(0, 2, 1) # => "right" ``` ```kotlin elevator(0, 1, 0) // => "left" elevator(0, 1, 1) // => "right" elevator(0, 1, 2) // => "right" elevator(0, 0, 0) // => "right" elevator(0, 2, 1) // => "right" ``` ```purescript elevator 0 1 0 -- => "left" elevator 0 1 1 -- => "right" elevator 0 1 2 -- => "right" elevator 0 0 0 -- => "right" elevator 0 2 1 -- => "right" ``` ```racket (elevator 0 1 0) ; "left" (elevator 0 1 1) ; "right" (elevator 0 1 2) ; "right" (elevator 0 0 0) ; "right" (elevator 0 2 1) ; "right" ```
algorithms
def elevator(left, right, call): return "left" if abs(call - left) < abs(call - right) else "right"
Closest elevator
5c374b346a5d0f77af500a5a
[ "Algorithms" ]
https://www.codewars.com/kata/5c374b346a5d0f77af500a5a
8 kyu
Write a function that returns the number of arguments it received. ``` args_count() --> 0 args_count('a') --> 1 args_count('a', 'b') --> 2 ``` ```if:python,ruby The function must work for keyword arguments too: ``` ```if:python ~~~ args_count(x=10, y=20, 'z') --> 3 ~~~ ``` ```if:ruby ~~~ args_count(x:10, y:20, 'z') --> 3 ~~~ ```
reference
def args_count(* args, * * kwargs): return len(args) + len(kwargs)
How many arguments
5c44b0b200ce187106452139
[ "Fundamentals" ]
https://www.codewars.com/kata/5c44b0b200ce187106452139
7 kyu
The dominoes in a full set come in a couple of types. For each number of pips there is a double domino, ranging from double blank represented `[0, 0]` up to double six, sometimes nine, fifteen, or in general `[n, n]`. Then there are all combinations of different numbers. For instance, a standard set has a single domino with a blank on one end and six pips on the other, which could be represented either as `[0, 6]` or equivalently `[6, 0]`. Imagine you are given two identical sets of dominoes, except that the doubles from one set are removed. For instance, if the sets have at most `n=2` pips, then you have `[0, 1]`, `[0, 2]`, and `[1, 2]` from both sets, but you're given only a single `[0, 0]`, `[1, 1]`, and `[2, 2]`. In general there will be `(n + 1) * (n + 1)` dominoes to work with. Your task is to line up all these dominoes end to end such that the values on adjacent dominoes match where they meet. This sequence of dominoes is called a train. The input is a single number, e.g. `n=2` as the max, and the output is a list such as `[0, 1, 1, 0, 2, 1, 2, 2, 0, 0]` which represents the values where dominoes meet, capped by the values at each end. In other words, this list is interpreted as the train `[0, 1]`, `[1, 1]`, `[1, 0]`, `[0, 2]`, `[2, 1]`, `[1, 2]`, `[2, 2]`, `[2, 0]`, `[0, 0]`. Other possibilities with all these dominoes in a different order could also be accepted as correct. Graph theory proves there is always a valid solution, but neither a graph nor too much theory are needed to generate one quickly. Best of luck! `:~)`
games
def domino(n): for a in range(n + 1): for b in range(a): yield b yield a yield a yield 0 def domino_train(n): return list(domino(n))
Train of dominoes
5c356d3977bd7254d7191403
[ "Puzzles", "Graph Theory" ]
https://www.codewars.com/kata/5c356d3977bd7254d7191403
5 kyu
Return the `n`th term of the Recamán's sequence. ``` a(0) = 0; a(n-1) - n, if this value is positive and not yet in the sequence / a(n) < \ a(n-1) + n, otherwise ``` Input range: 0 – 30,000 ___ A video about Recamán's sequence by Numberphile: https://www.youtube.com/watch?v=FGC5TdIiT9U
algorithms
def recaman(n): series, last = {0}, 0 for i in range(1, n + 1): test = last - i last = last + i if test < 0 or test in series else test series . add(last) return last
Recaman Sequence
5c3f31c2460e9b4020780aa2
[ "Algorithms", "Performance" ]
https://www.codewars.com/kata/5c3f31c2460e9b4020780aa2
7 kyu
# Task John is an orchard worker. There are `n` piles of fruits waiting to be transported. Each pile of fruit has a corresponding weight. John's job is to combine the fruits into a pile and wait for the truck to take them away. Every time, John can combine any two piles(`may be adjacent piles, or not`), and the energy he costs is equal to the weight of the two piles of fruit. For example, if there are two piles, pile1's weight is `1` and pile2's weight is `2`. After merging, the new pile's weight is `3`, and he consumed 3 units of energy. John wants to combine all the fruits into 1 pile with the least energy. Your task is to help John, calculate the minimum energy he costs. # Input - `fruits`: An array of positive integers. Each element represents the weight of a pile of fruit. Javascript: - 1 <= fruits.length <= 10000 - 1 <= fruits[i] <= 10000 Python: - 1 <= len(fruits) <= 5000 - 1 <= fruits[i] <= 10000 # Output An integer. the minimum energy John costs. # Examples For `fruits = [1,2,9]`, the output should be `15`. ``` 3 piles: 1 2 9 combine 1 and 2 to 3, cost 3 units of energy. 2 piles: 3 9 combine 3 and 9 to 12, cost 12 units of energy. 1 pile: 12 The total units of energy is 3 + 12 = 15 units ``` For `fruits = [100]`, the output should be `0`. There's only 1 pile. So no need combine it.
algorithms
from heapq import heappop, heappush def comb(fruits): total, heap = 0, sorted(fruits) while len(heap) > 1: cost = heappop(heap) + heappop(heap) heappush(heap, cost) total += cost return total
Kata 2019: Combine Fruits
5c2ab63b1debff404a46bd12
[ "Algorithms", "Performance" ]
https://www.codewars.com/kata/5c2ab63b1debff404a46bd12
6 kyu
## Task Given an array of strings, reverse them and their order in such way that their length stays the same as the length of the original inputs. ### Example: ``` Input: {"I", "like", "big", "butts", "and", "I", "cannot", "lie!"} Output: {"!", "eilt", "onn", "acIdn", "ast", "t", "ubgibe", "kilI"} ``` Good luck!
reference
def reverse(a): s = reversed('' . join(a)) return ['' . join(next(s) for _ in w) for w in a]
Ultimate Array Reverser
5c3433a4d828182e420f4197
[ "Fundamentals", "Algorithms" ]
https://www.codewars.com/kata/5c3433a4d828182e420f4197
7 kyu
Create a Regular Expression that matches a word consistent only of letter `x`. No other letters will be used. The word has to have prime numbers of letters. Matching with `re.match()` Should match: ``` xx xxx xxxxx xxxxxxx xxxxxxxxxxx xxxxxxxxxxxxx ``` Should NOT match ``` xxxx xxxxxx xxxxxxxx xxxxxxxxx xxxxxxxxxx xxxxxxxxxxxx xxxxxxxxxxxxxx xxxxxxxxxxxxxxx xxxxxxxxxxxxxxxx ``` # CodeGolf restriction Your REGEX string should be not longer than 40 characters ____ This tools may help you: [Cheat sheet](https://www.rexegg.com/regex-quickstart.html) [Online tester](https://regex101.com)
algorithms
REGEX = r'(?!(xx+)\1+$)xx+$'
RegEx Like a Boss #4 CodeGolf : Prime length
5c2cea87b0aea22f8181757c
[ "Regular Expressions", "Strings", "Restricted", "Algorithms" ]
https://www.codewars.com/kata/5c2cea87b0aea22f8181757c
5 kyu
# Task Numpy has a function [numpy.fmax](https://docs.scipy.org/doc/numpy-1.15.0/reference/generated/numpy.fmax.html) which computes the element-wise maximum for two arrays. However, there are two problems with this: First, you don't want to get numpy just to use this function. Second, you want a *in-place* version of this function because turning an in-place function into one that creates a new object is trivially easy, but the opposite is not true. In order to justify your rationale of not using numpy, you want to write the function as short as possible. The function `fmax`, given arguments `a` and `b`, should compute the element-wise maximum of two arrays, and assign the maximum to `a` *in-place*. The return value of `fmax` is arbitrary as you don't care about it. # Code Limit At most `36` characters. # Example For `a = [1, 2, 3, 4, 5], b = [10, 0, 10, 0, 10]`, `a` should be `[10, 2, 10, 4, 10]` after executing `fmax(a,b)`. # Input ``` len(a) = len(b) 0 <= len(a), len(b) <= 10000 ``` You can guarantee that input arrays only contain integers.
reference
def fmax(a, b): a[:] = map(max, a, b)
One Line Task: Element-wise Maximum
5c2dbc63bfc6ec0001d2fcf9
[ "Restricted", "Fundamentals" ]
https://www.codewars.com/kata/5c2dbc63bfc6ec0001d2fcf9
6 kyu
<h2>Introduction</h2> It's been more than 20 minutes since the negligent waiter has taken your order for the house special prime tofu steak with a side of chili fries. Out of boredom, you start fiddling around with the condiments tray. To be efficient, you want to be familiar with the choice of sauces and spices before your order is finally served. You also examine the toothpick holder and try to analyze its inner workings when - yikes - the holder's lid falls off and all 23 picks lay scattered on the table. Being a good and hygiene oriented citizen, you decide not to just put them back in the holder. Instead of letting all the good wood go to waste, you start playing around with the picks. In the first "round", you lay down one toothpick vertically. You've used a total of one toothpick. In the second "round", at each end of the first toothpick, you add a perpendicular toothpick at its center point. You added two additional toothpicks for a total of three toothpicks. In the next rounds, you continue to add perpendicular toothpicks to each free end of toothpicks already on the table. With your 23 toothpicks, you can complete a total of six rounds:<br/> <img src="http://codewars.smubo.ch/toothpicks_XYAdcRDzf.jpg"> You wonder if you'd be able to implement this sequence in your favorite programming language. Because your food still hasn't arrived, you decide to take out your laptop and start implementing... <h2>Challenge</h2> Implement a script that returns the amount of toothpicks needed to complete n amount of rounds of the toothpick sequence. ``` 0 <= n <= 5000 ``` <h2>Hint</h2> You can attempt this brute force or get <a href="https://arxiv.org/abs/1004.3036">some inspiration</a> from the math department.
algorithms
from math import log2 def t(n): if n == 0: return 0 k = int(log2(n)) i = n - 2 * * k if i == 0: return (2 * * (2 * k + 1) + 1) / / 3 else: return t(2 * * k) + 2 * t(i) + t(i + 1) - 1 toothpick = t
Toothpick Sequence
5c258f3c48925d030200014b
[ "Algorithms", "Mathematics", "Recursion" ]
https://www.codewars.com/kata/5c258f3c48925d030200014b
6 kyu
Welcome to yet *another* kata on palindromes! Your job is to return a string with 2 requirements: 1 . The first half of the string should represent a proper function expression in your chosen language. 2 . The string should be a palindrome. Wait... that's too easy -- let's add one more requirement: Call ```x``` the sum of the character codes of the full string we want to return. To pass the kata, make sure the function represented in your string will return ```x``` when it is given as an input.
algorithms
def palindromic_expression(): return "intni"
Palindromic Expression
5c11c3f757415b1735000338
[ "Algorithms" ]
https://www.codewars.com/kata/5c11c3f757415b1735000338
7 kyu
# Toggling Grid You are given a grid (2d array) of 0/1's. All 1's represents a solved puzzle. Your job is to come up with a sequence of toggle moves that will solve a scrambled grid. Solved: ``` [ [1, 1, 1], [1, 1, 1], [1, 1, 1] ] ``` "0" (first row) toggle: ``` [ [0, 0, 0], [1, 1, 1], [1, 1, 1] ] ``` then "3" (first column) toggle: ``` [ [1, 0, 0], [0, 1, 1], [0, 1, 1] ] ``` The numbers in quotes are codes for the row/column, and will be explained. ## Your task: findSolution() Your task is to write a function, `findSolution()` (or `find_solution()`), which takes as input a 2d array, and returns an array of "steps" that represent a sequence of toggles to solve the puzzle. For example: ```javascript var puzzle = [ [1, 0, 0], [0, 1, 1], [0, 1, 1] ]; ``` ```javascript var solution = findSolution(puzzle) console.log(solution); > [0, 3] ``` ```python solution = find_solution(puzzle) print(solution); > [0, 3] ``` Note that, in the above example, `[1, 2, 4, 5]` is also a valid solution! Any solution will pass the tests. The solution is tested like this, for each number in the solution: ```python if n < puzzle.size: toggleRow(n) else: toggleCol(n - puzzle.size) ``` To elaborate, possible n's for a 3x3 puzzle: ```javascript row toggles: 0, 1, or 2 column toggles: 3, 4, or 5 -> correspond to columns 0, 1, or 2 ``` - Row numbers = (0 --> size - 1) - Cols numbers = (size --> size * 2 - 1) ### Example of "2" toggle: ```javascript before: [ [1, 1, 1], [1, 1, 1], [1, 1, 1] ] after: [ [1, 1, 1], [1, 1, 1], [0, 0, 0] ] ``` ### Example of "4" toggle: ```javascript before: [ [1, 1, 1], [1, 1, 1], [1, 1, 1] ] after: [ [1, 0, 1], [1, 0, 1], [1, 0, 1] ] ``` ## More examples: ```javascript var puzzle = [ [ 0, 1, 0 ], [ 1, 0, 1 ], [ 1, 0, 1 ] ]; var solution = findSolution(puzzle) console.log(solution); > [0, 4] ``` ```python puzzle = [ [ 0, 1, 0 ], [ 1, 0, 1 ], [ 1, 0, 1 ] ]; solution = find_solution(puzzle) print(solution); > [0, 4] ``` let's try some bigger puzzles: ```javascript var puzzle = [ [ 1, 0, 1, 0, 0 ], [ 0, 1, 0, 1, 1 ], [ 0, 1, 0, 1, 1 ], [ 0, 1, 0, 1, 1 ], [ 1, 0, 1, 0, 0 ] ]; var solution = findSolution(puzzle) console.log(solution); > [ 0, 5, 4, 7 ] ``` ```python puzzle = [ [ 1, 0, 1, 0, 0 ], [ 0, 1, 0, 1, 1 ], [ 0, 1, 0, 1, 1 ], [ 0, 1, 0, 1, 1 ], [ 1, 0, 1, 0, 0 ] ]; solution = find_solution(puzzle) print(solution); > [ 0, 5, 4, 7 ] ``` ```javascript var puzzle = [ [ 1, 1, 1, 0, 1, 1, 1 ], [ 1, 1, 1, 0, 1, 1, 1 ], [ 1, 1, 1, 0, 1, 1, 1 ], [ 0, 0, 0, 1, 0, 0, 0 ], [ 1, 1, 1, 0, 1, 1, 1 ], [ 1, 1, 1, 0, 1, 1, 1 ], [ 1, 1, 1, 0, 1, 1, 1 ] ]; var solution = findSolution(puzzle) console.log(solution); > [ 3, 10 ] ``` ```python puzzle = [ [ 1, 1, 1, 0, 1, 1, 1 ], [ 1, 1, 1, 0, 1, 1, 1 ], [ 1, 1, 1, 0, 1, 1, 1 ], [ 0, 0, 0, 1, 0, 0, 0 ], [ 1, 1, 1, 0, 1, 1, 1 ], [ 1, 1, 1, 0, 1, 1, 1 ], [ 1, 1, 1, 0, 1, 1, 1 ] ]; solution = find_solution(puzzle) print(solution); > [ 3, 10 ] ``` There are randomized tests with puzzles of up to 100x100 in size. Have fun!
games
def findSolution(m): return [j for j, r in enumerate(m) if r[0] ^ m[0][0]] + [len(m) + i for i, b in enumerate(m[0]) if not b]
Solve the Grid! Binary Toggling Puzzle
5bfc9bf3b20606b065000052
[ "Binary", "Puzzles", "Arrays" ]
https://www.codewars.com/kata/5bfc9bf3b20606b065000052
5 kyu
In English, all words at the begining of a sentence should begin with a capital letter. You will be given a paragraph that does not use capital letters. Your job is to capitalise the first letter of the first word of each sentence. For example, input: `"hello. my name is inigo montoya. you killed my father. prepare to die."` output: `"Hello. My name is inigo montoya. You killed my father. Prepare to die."` You may assume: - there will be no punctuation besides full stops and spaces - all but the last full stop will be followed by a space and at least one word
reference
def fix(paragraph): return '. ' . join(s . capitalize() for s in paragraph . split('. '))
Sentences should start with capital letters.
5bf774a81505a7413400006a
[ "Strings", "Fundamentals" ]
https://www.codewars.com/kata/5bf774a81505a7413400006a
7 kyu
Your task is to write a regular expression that matches positive decimal integers divisible by 4. Negative numbers should be rejected, but leading zeroes are permitted. Random tests can consist of numbers, ascii letters, some puctuation and brackets. But no need to check for line breaks (\n) and non-ASCII chatracters, nothing that fancy in the tests. There is 50 characters limit for this regex to avoid hardcoding and keep the "puzzle" status :) Good luck!
games
div_4 = '[048]$|\d*([02468][048]|[13579][26])$'
Regex for a decimal number divisible by 4
5bf6bd7a3efceeda4700011f
[ "Regular Expressions", "Puzzles" ]
https://www.codewars.com/kata/5bf6bd7a3efceeda4700011f
6 kyu
In this kata we have to calculate products and sums using the values of an array with an arbitrary number of non-zero integers (positive and/or negative). Each number in the array occurs once, i.e. they are all unique. You need to implement a function `eval_prod_sum(arr, num_fact, num_add, max_val)` that takes the following four arguments: 1. A list/array of integers `$[x_1, x_2, x_3, \dotsc, x_n]$` of arbitrary length `n` where `$ x_i \ne 0$` 2. A positive integer `num_fact`, which is the number of array elements that combine to form individual products. For example, given an array `[a, b, c, d]` and `num_fact = 3`, the products would be `a*b*c, a*b*d, a*c*d, b*c*d` 3. A positive integer `num_add`, which is the number of previously produced products (see `2.`) that combine to form individual sums. Continuing the previous example, given `num_add = 2`, the sums would be `a*b*c + a*b*d, a*b*c + a*c*d, ..., a*c*d + b*c*d` 4. An integer `max_val`, against which the previously produced sums will be compared to produce the following results: - `smaller`, the number of sums that are **smaller** than `max_val` - `equal`, the number of sums that are **equal** to `max_val` - `larger`, the number of sums that are **larger** than `max_val` The output should be a list of dictionaries with the following structure: ```python [{"Below than max_val": smaller}, {"Equals to max_val": equal}, {"Higher than max_val": larger}] ``` ```ruby [{"Below than max_val" => smaller}, {"Equals to max_val" => equal}, {"Higher than max_val" => larger}] ``` ## Example ```python lst = [2, 10, 20, 15] num_fact = 3 num_add = 2 max_val = 8 eval_prod_sum(lst, num_fact, num_add, max_val) == [{'Below than 8': 0}, {'Equals to 8': 0}, {'Higher than 8': 6}] ``` ```ruby lst = [2, 10, 20, 15] num_fact = 3 num_add = 2 max_val = 8 eval_prod_sum(lst, num_fact, num_add, max_val) == [{'Below than 8'=> 0}, {'Equals to 8'=> 0}, {'Higher than 8'=> 6}] ``` ``` Factors Products (2, 10, 20) 400 (2, 10, 15) 300 (2, 20, 15) 600 (10, 20, 15) 3000 Addends Sums (Final Result) (300, 400) 700 (larger than 8) (300, 600) 900 (larger than 8) (300, 3000) 3300 ( " " ") (400, 600) 1000 ( " " ") (400, 3000) 3400 ( " " ") (600, 3000) 3600 ( " " ") -> 6 sums of which 0 are smaller or equal to 8 and 6 are larger than 8 ``` ## Error handling The function `eval_prod_sum` should return an error message under the following conditions: - the given array contains a string or a float, or any of the arguments `num_fact`, `num_add `, `max_val` are strings, floats, negative integers or 0. Output: `"Error. Unexpected entries"` - `num_fact` is larger than the length of the array. Output: `"Error. Number of factors too high"` - `num_add` is larger than the number of product combinations obtainable from the given array with `num_fact`. Output: `"Error. Number of addens too high"` ### Examples: ```python lst = [2, 10, '20', 15] num_fact = 3 num_add = 2 max_val = 8 eval_prod_sum(lst, num_fact, num_add, max_val) == "Error. Unexpected entries" lst = [2, 10, 20, 15] num_fact = 3 num_add = 2.0 max_val = '8' eval_prod_sum(lst, num_fact, num_add, max_val) == "Error. Unexpected entries" ``` ```ruby lst = [2, 10, '20', 15] num_fact = 3 num_add = 2 max_val = 8 eval_prod_sum(lst, num_fact, num_add, max_val) == "Error. Unexpected entries" lst = [2, 10, 20, 15] num_fact = 3 num_add = 2.0 max_val = '8' eval_prod_sum(lst, num_fact, num_add, max_val) == "Error. Unexpected entries" ``` Enjoy!
reference
from itertools import combinations from math import comb, prod def eval_prod_sum(numbers: list, factor_count: int, addend_count: int, max_value: int) - > list or str: if not (all(isinstance(i, int) for i in numbers) and all(isinstance(i, int) and i > 0 for i in {factor_count, addend_count, max_value})): return 'Error. Unexpected entries' if factor_count > len(numbers): return 'Error. Number of factors too high' if addend_count > comb(len(numbers), factor_count): return 'Error. Number of addens too high' lower = equal = higher = 0 for sum_ in map(sum, combinations(map(prod, combinations(numbers, r=factor_count)), r=addend_count)): if sum_ < max_value: lower += 1 elif sum_ > max_value: higher += 1 else: equal += 1 return [{f'Below than { max_value } ': lower}, {f'Equals to { max_value } ': equal}, {f'Higher than { max_value } ': higher}]
A Combinatorial Way to Get Products and Sums of an Array
561f18d45df118e7c400000b
[ "Fundamentals", "Mathematics", "Data Structures", "Algorithms" ]
https://www.codewars.com/kata/561f18d45df118e7c400000b
6 kyu
Pythagoras(569-500 B.C.E.) discovered the relation ```a² + b² = c²``` for rectangle triangles,```a, b and c``` are the side values of these special triangles. A rectangle triangle has an angle of 90°. In the following animated image you can see a rectangle triangle with the side values of (a, b, c) = (3, 4, 5) The pink square has an area equals to 9 (a² = 3²), the green square an area equals to 16 (b² = 4²) and the square with pink and green an area of 25 (c² = 5²) Adding the pink area to the green one, we obtain ```9 + 16 = 25``` <a href="http://imgur.com/d0minUx"><img src="http://i.imgur.com/d0minUx.gif" title="source: imgur.com" /></a> A Pythagorean Triple ```(a, b, c)``` is such that ```a ≤ b < c```, the three are integers, and ```a² + b² = c²```. A Primitive Pythagorean Triple has another additional property: a, b and c are co-primes. Two numbers are co-primes when the Greatest Common Divisor of every pair of the triple is 1. So ```G.C.D.(a, b) = 1```, ```G.C.D.(b, c) = 1``` and ```G.C.D.(a, c) = 1``` Just to visualize the primitives triples, we may see them, each one represented like a rectangle triangle displayed in a 2D arrengement done by Adam Cunningham and John Ringland (March 2012): <a href="http://imgur.com/1E5w7g3"><img src="http://i.imgur.com/1E5w7g3.jpg?1" title="source: imgur.com" /></a> The perimeter for a pythagorean triple is: ```per = a + b + c``` The first 16 primitive pythagorean triples with their corresponding perimeter beside, having c below or equal 100 ```(c ≤ 100)``` are: ```python (3, 4, 5), 12 (5, 12, 13), 30 (8, 15, 17), 40 (7, 24, 25), 56 (20, 21, 29), 70 (12, 35, 37), 84 (9, 40, 41), 90 (28, 45, 53), 126 (11, 60, 61), 132 (16, 63, 65), 144 (33, 56, 65), 154 (48, 55, 73), 176 (13, 84, 85), 182 (36, 77, 85), 198 (39, 80, 89), 208 (65, 72, 97), 234 ``` The primitive triple that has the maximum perimeter, with c ≤ 100 is ```(65, 72, 97)``` with a perimeter equals to ```234``` Your task is to make a function that receives an argument returns the triple with the maximum perimeter having the side ```c``` below or equal its argument. ~~~if:ruby,python The function will output a list of dictionaries as follows: ```[{"number triplets below-eq c_max": amount_triplets}, {"max perimeter": max_per}, {"largest triplet": (am, bm, cm)}]``` Let's see some cases: ``` find_max_triple(50) == [{'number triples below-eq 50': 7}, {'max perimeter': 90}, {'largest triplet': [(9, 40, 41)]}] find_max_triple(100) == [{'number triples below-eq 100': 16}, {'max perimeter': 234}, {'largest triplet': [(65, 72, 97)]}] find_max_triple(150) = [{'number triples below-eq 150': 24}, {'max perimeter': 340}, {'largest triplet': [(51, 140, 149)]}] ``` ~~~ ~~~if:javascript The function will output a 2D array, see examples bellow ```javascript findMaxTriple(50) ==[['number triples below-eq 50',7],['max perimeter', 90], ['largest triple', [[9, 40, 41]]]]; findMaxTriple(100) == [['number triples below-eq 100', 16], ['max perimeter', 234], ['largest triple', [[65, 72, 97]]]]; findMaxTriple(150) == [['number triples below-eq 150', 24], ['max perimeter', 340], ['largest triple', [[51, 140, 149]]]]; ``` ~~~ ~~~if-not:javascript,python, ruby The function will output a tuple / array (depending on the language; refer to solution set up for the exact format) of 3 elements in order: the number of triples below the argument, the maximum perimeter of those triples, and an array / tuple with the largest triple. ### Examples (input --> output) 50 --> (7, 90, (9, 40, 41)) 100 --> (16, 234, (65, 72, 97)) 150 --> (24, 340, (51, 140, 149)) ~~~ Hint, see at: https://en.wikipedia.org/wiki/Formulas_for_generating_Pythagorean_triples Your code will be tested for values of c_max up to `10000`. (Memoizations is advisable)
reference
from math import gcd def find_max_triple(c_max): triples = [(n * n - m * m, 2 * m * n, m * m + n * n) for n in range(2, int(c_max * * 0.5) + 1) for m in range(1 + n % 2, min(n, int((c_max - n * n) * * 0.5) + 1), 2) if gcd(m, n) == 1] largest = tuple(sorted(max(triples, key=sum))) return [{f'number triples below-eq { c_max } ': len(triples)}, {'max perimeter': sum(largest)}, {'largest triple': [largest]}]
Primitive Pythagorean Triples
5622c008f0d21eb5ca000032
[ "Fundamentals", "Mathematics", "Algorithms", "Data Structures", "Algebra", "Geometry", "Memoization" ]
https://www.codewars.com/kata/5622c008f0d21eb5ca000032
5 kyu
A specialist of statistics was hired to do an investigation about the people's voting intention for a certain candidate for the next elections. Unfortunately, some of the interviewers, hired for the researches, are not honest and they want to modify the results because, some of them like the candidate too much, or others hate him. The specialist suspects about the situation and will apply his own method named: Recursive 2.5 Standard Deviation Filter. He does not know who of them are cheating and obviously, he doesn´t know the minimum or maximum possible votes for this candidate. The method works with the following steps explained below: 1) The method calculates the mean, ``` μ```, and the standard deviation, ```σ``` for the received data that has ```n``` elements. <a href="http://imgur.com/qi97XWq"><img src="http://i.imgur.com/qi97XWq.png?2" title="source: imgur.com" /></a> 2) A new data is obtained discarding all the values that are not in the range [μ - 2.5*σ, μ + 2.5*σ] (strictly lower or higher than these extremes) 3) The values of ``` μ``` and ```σ``` are recalculated and an all the values will be filtered by the new range with the updated values of ``` μ``` and ```σ``` and so on. He receives the data from the interviewers. The data is the number of votes of samples less than 500 people per neighbourhood of a county. Let's see a suspect data, the exaggerated data was left at the end on purpose, to see it clearly: ``` votes = [35, 34, 37, 32, 33, 36, 38, 32, 35, 35, 36, 34, 35, 100*, 85*, 70*] ``` The values marked with an (*) are suspect, too high perhaps. ``` Step Votes μ σ μ - 2.5*σ μ + 2.5*σ dicarded values 1 [35,34,37,32,33,36,38,32,35,35,36,34,35,100,85,70] 44.1875 20.3692 -6.7354 95.1104 100 2 [35,34,37,32,33,36,38,32,35,35,36,34,35,85,70] 40.4667 14.8677 3.2974 77.6359 85 3 [35,34,37,32,33,36,38,32,35,35,36,34,35,70] 37.2857 9.2229 14.2286 60.3429 70 4 [35,34,37,32,33,36,38,32,35,35,36,34,35] 34.7692 1.7166 30.4777 39.0608 --- ``` The final values that will be output are ```̅X```and ```s```, ```̅X = μ ``` and ```s = σ/√̅n``` because this will be consider a sample for another calculations. In this case ```̅X = 34.7692``` and ```s = 1.7166/√̅13 = 0.4761```. We need a function ```filter_val()```, that receives an array with the number of votes of different neighbourhoods of a county and may express the comparisson in the size of the data and the values of ```̅X``` and ```s```. For our case: ```python filter_val([35,34,37,32,33,36,38,32,35,35,36,34,35,100,85,70]) == [[16, 13], 34.76923076923077, 0.4761016021276081] # you don't have to round the results # 16 was the length of the received array of votes, 13 is the length of the filtered data. ``` The assumptions for this kata: the honest interviwers are much more than the cheaters and the last ones do not agree about the number of votes they will add or subtract, so the modified values are not equal or almost equal. Some "honest values" may be discarded with this process and all the "dishonest ones" will be eliminated in almost the total of cases but the method still gives a good result. Enjoy it!!
reference
def avg(x): return sum(x) / len(x) def std(arr): mu = avg(arr) var = sum([(x - mu) * * 2 for x in arr]) / len(arr) return var * * 0.5 def filter_val(lst): len1 = len(lst) while True: mu = avg(lst) s = std(lst) ret = [x for x in lst if mu - 2.5 * s <= x <= mu + 2.5 * s] if ret == lst: break else: lst = ret len2 = len(lst) mean = avg(lst) s = std(lst) return [[len1, len2], mean, s]
Filtering Values For an Election
574b448ed27783868600004c
[ "Mathematics", "Statistics", "Recursion", "Data Science" ]
https://www.codewars.com/kata/574b448ed27783868600004c
6 kyu
A chain of car rental locals made a statistical research for each local in a city. They measure the average of clients for every day. They used the Simpson model for probabilities: <a href="http://imgur.com/LQWj8kM"><img src="http://i.imgur.com/LQWj8kM.png?1" title="source: imgur.com" /></a> The number ```e``` is ```2,7182818284....``` Suposse that one of the locals has an average 8 clients per day. The probability of having 12 clients, one of the goals of the manager, will be: <a href="http://imgur.com/L7bNl2r"><img src="http://i.imgur.com/L7bNl2r.png?1" title="source: imgur.com" /></a> It is a very low value, almost 5%. It shows that they have to work a lot for this increment. And, how would it be if we want to know the sum of probabilities for values below ```12``` (cumulative probability)? ``` P(c < 12) = P(c=0) + P(c=1) + P(c=3) + P(c=4) + P(c=5) + P(c=6) + P(c=7) + P(c=8) + P(c=9) + P(c=10) + P(c=11) P(c<12) = 0.00033546262790251196 + 0.0026837010232200957 + 0.010734804092880383 + 0.02862614424768102 + 0.05725228849536204 + 0.09160366159257927 + 0.12213821545677235 + 0.13958653195059698 + 0.13958653195059698 + 0.12407691728941954 + 0.09926153383153563 + 0.072190206422935 = 0.888075998981 ``` But the probability of having below or equal the value ```12```, will be: ``` P(c≤12) = P(c=0) + P(c=1) + P(c=3) + P(c=4) + P(c=5) + P(c=6) + P(c=7) + P(c=8) + P(c=9) + P(c=10) + P(c=11) + P(c=12) = 0.936202803263 (P(c≤12) = P(12≥c)) ``` The probability for having equal or more clients than 12 will be: ``` P(c>12) = P(c=13) + P(c=14) + P(c=15) + ........+ P(c=+∞) (P(c>12) = P(12<c)) ``` But the sum of the probabilities for c = 0 to +∞ is ```1``` So, ``` P(c>12) = 1 - P(c≤12) = 1 - 0.936202803263 = 0.063797196737 ``` Make the function ```prob_simpson()```, that will receive 2 or 3 arguments. 1) Two arguments if we want to calculate the probability for a specific number, receives the average ```lamb``` and the variable ```x```. 2) Three arguments if we want the cumulative probability for a value, besides receiving ```lamb``` and ```x```, will receive one of the following operators in string format: ```<, <=, >, >=```. Let's see some cases for probability at the number: ```python prob_simpson(8, 12) == 0.04812680428195667 prob_simpson(8, 11) == 0.072190206422935 prob_simpson(8, 10) == 0.09926153383153563 ``` And for cumulative probability: ```python prob_simpson(8, 12, '>') == 0.888075998981 # or P(12>c) prob_simpson(8, 12, '>=') == 0.936202803263 # or P(12≥c) prob_simpson(8, 12, '<') == 0.063797196737 # or P(12<c) prob_simpson(8, 12, '<=') == 0.111924001019 # or P(12≤c) ``` You may assume that you will not receive high values for ```lamb``` and ```x``` This kata will also have translations into Javascript and Ruby. Enjoy it!
reference
from math import e, factorial def poi(l, x): return e * * - l * l * * x / factorial(x) def prob_simpson(l, x, op='='): if op == '=': return poi(l, x) if op == '>=': return sum(poi(l, e) for e in range(x + 1)) if op == '>': return sum(poi(l, e) for e in range(x)) if op == '<=': return 1 - sum(poi(l, e) for e in range(x)) if op == '<': return 1 - sum(poi(l, e) for e in range(x + 1))
Car Rental Business Needs Statistics and Programming
570176b0d1acef5778000fbd
[ "Algorithms", "Mathematics", "Statistics", "Probability", "Data Science" ]
https://www.codewars.com/kata/570176b0d1acef5778000fbd
5 kyu
Some languages like Chinese, Japanese, and Thai do not have spaces between words. However, most natural languages processing tasks like part-of-speech tagging require texts that have segmented words. A simple and reasonably effective algorithm to segment a sentence into its component words is called "MaxMatch". ## MaxMatch MaxMatch starts at the first character of a sentence and tries to find the longest valid word starting from that character. If no word is found, the first character is deemed the longest "word", regardless of its validity. In order to find the rest of the words, MaxMatch is then recursively invoked on all of the remaining characters until no characters remain. A list of all of the words that were found is returned. So for the string `"happyday"`, `"happy"` is found because `"happyday"` is not a valid word, nor is `"happyda"`, nor `"happyd"`. Then, MaxMatch is called on `"day"`, and `"day"` is found. The output is the list `["happy", "day"]` in that order. ## The Challenge ```if:javascript Write `maxMatch`, which takes an alphanumeric, spaceless, lowercased `String` as input and returns an `Array` of all the words found, in the order they were found. **All valid words are in the** `Set` `VALID_WORDS`, which only contains around 500 English words. ``` ```if:haskell Write `maxMatch`, which takes an alphanumeric, spaceless, lowercased `String` as input and returns a `[String]` of all the words found, in the order they were found. All valid words are in the `[String]` `validWords`, which only contains around 500 English words. ``` ```if:java Write `maxMatch`, which takes an alphanumeric, spaceless, lowercased `String` as input and returns a `List` of `String`s which are all the words found, in the order they were found. All valid words are in the `Set` `Preloaded.VALID_WORDS`, , which only contains around 500 English words. ``` ```if:python Write `max_match`, which takes an alphanumeric, spaceless, lowercased `String` as input and returns a `List` of `String`s of all the words found, in the order they were found. **All valid words are in the** `Set` `VALID_WORDS`, which only contains around 500 English words. ``` ```if:ruby Write `max_match`, which takes an alphanumeric, spaceless, lowercased `String` as input and returns an `Array` of `String`s of all the words found, in the order they were found. All valid words are in the `Array` `VALID_WORDS`, which only contains around 500 English words. ``` ```if:kotlin Write `maxMatch`, which takes an alphanumeric, spaceless, lowercased `String` as input and returns a `List` of `String`s which are all the words found, in the order they were found. All valid words are in the `Set` `VALID_WORDS`, which only contains around 500 English words. ``` **Note:** This algorithm is simple and operates better on Chinese text, so accept the fact that some words will be segmented wrongly. Happy coding :)
algorithms
def max_match(s): result = [] while s: for size in range(len(s), 0, - 1): word = s[: size] if word in VALID_WORDS: break result . append(word) s = s[size:] return result
Word Segmentation: MaxMatch
5be350bcce5afad8020000d6
[ "Parsing", "Recursion", "Strings", "Arrays", "Algorithms" ]
https://www.codewars.com/kata/5be350bcce5afad8020000d6
6 kyu
An **Almost Isosceles Integer Triangle** is a triangle that all its side lengths are integers and also, two sides are almost equal, being their absolute difference `1` unit of length. We are interested in the generation of the almost isosceles triangles by the diophantine equation (length sides of triangles are positive and not 0): `x³-(x-1)³ = y²` Eq.1 So the first solution `(x,y)` for this equation is that may generate a real triangle and almost isosceles is `(8,13)`, being the first nearly isosceles triangle `(7,8,13)`. Equation 1 has infinite solutions `(x,y)`, so the corresponding triangles will be `(x-1,x,y)` We need a code that can find those triangles with huge sides. You will be given an integer `p` (always valid and positive, and p ≠ 0) and your code should output the closest perimeter to p, let's name it p_, of the corresponding triangle. Examples: ```python find_closest_perim(500) === 390 # (104, 105, 181) is the triangle with the closest perimeter to 500 find_closest_perim(5000) === 5432 # perimeter of triangle (1455, 1456, 2521) ``` ```javascript findClosestPerimeter(500) === 390 # (104, 105, 181) is the triangle with the closest perimeter to 500 findClosestPerimeter(5000) === 5432 # perimeter of triangle (1455, 1456, 2521) ``` In the case that you have two possible solutions, `p_1` and `p_2` being `p_1 < p_2`, because `p = p_1 + (p_2 - p1)/2`, you select the highest solution `p_2`. If `p` coincides with a perimeter of these triangles the output should be `p`. Features of the random tests: `1000 <= p <= 1e180` Interesting cases in the example tests box with edge cases. The sequence of triangles are almost similar with the two nearly same sides forming an angle of 120º (strictly, nearly 120º) No hardcoded solutions are allowed for this kata. Enjoy it!
reference
# A001921 + A001570, aka A011944 v = [0, 2] while v[- 1] < 1e180: v . append(14 * v[- 1] - v[- 2]) from bisect import bisect def find_closest_perim(p): i = bisect(v, p) return v [2 ] if i == 2 else min ([v [i ], v [i - 1 ]], key = lambda t : ( abs ( t - p ), - t ))
Almost Isosceles Integer Triangles With Their Angles With Asymptotic Tendency
5be4d000825f24623a0001e8
[ "Algorithms", "Performance", "Number Theory", "Recursion", "Geometry", "Fundamentals" ]
https://www.codewars.com/kata/5be4d000825f24623a0001e8
5 kyu
# Task You are given a positive integer `n`. We intend to make some ascending sequences according to the following rules: 1. Make a sequence of length 1: [ n ] 2. Or, insert a number to the left side of the sequence. But this number can not exceed half of the first number of the sequence. 3. Follow rule 2, continue insert number to the left side of the sequence. Your task is to count the number of all possible sequences, and return it. If you do not understand the task, please read the rewritten version below: You are given a positive integer `n`. Your task is to count the number of such sequences: - It should be an ascending sequence; - It should end with number `n`. - Each number in the sequence should smaller or equals to the half of its right, except for the last number `n`. - We define that a sequence containing only a number `n` is a valid ascending sequence. # Examples For `n = 6`, the output should be `6`. All sequences we made are: ``` [6] insert a number to the left: [1,6] [2,6] [3,6] continue insert number: [1,2,6] [1,3,6] ``` There are 6 sequences in total. For `n = 10`, the output should be `14`. All sequences we made are: ``` [10] insert a number to the left: [1,10] [2,10] [3,10] [4,10] [5,10] continue insert number: [1,2,10] [1,3,10] [1,4,10] [2,4,10] [1,5,10] [2,5,10] continue insert number: [1,2,4,10] [1,2,5,10] ``` There are 14 sequences in total. # Note - `1 <= n <= 1000` - `3` fixed testcases - `100` random testcases, testing for correctness of solution - All inputs are valid. ~~~if:lambdacalc # Encodings purity: `LetRec` numEncoding: `BinaryScott` ~~~
algorithms
from functools import lru_cache @ lru_cache(maxsize=None) def make_sequences(n): return 1 + sum(map(make_sequences, range(1, n / / 2 + 1)))
Simple Fun #399: Make Ascending Sequences
5be0f1786279697939000157
[ "Fundamentals", "Arrays", "Algorithms" ]
https://www.codewars.com/kata/5be0f1786279697939000157
7 kyu
Ever wonder how many keystrokes any given string takes to type? No? Most normal people don't...but we're not normal! :D Program a ```num_key_strokes (string)``` function that takes a string and returns a count of the number of keystrokes that it took to type that string. For example, ```Hello, world!``` takes 15 key strokes to type. This kata is expecting an EN-US keyboard mapping, specifically using the QWERTY layout. ## Rules * This kata assumes that the string was only typed using the main keyboard and NOT a number-pad. * We also assume that the user does not hold down the ```Shift``` key and thus has to press it once every time it's needed. In addition, the ```CAPS LOCK``` key is not used. * Every character in the input string requires either ```1``` or ```2``` keystrokes. Your goal is to figure out which ones belong in which group and count the total number of keystrokes. Here's a picture of the en-US QWERTY layout : <img src="https://upload.wikimedia.org/wikipedia/commons/thumb/5/51/KB_United_States-NoAltGr.svg/1920px-KB_United_States-NoAltGr.svg.png" title="the en-US QWERTY layout" alt="the en-US QWERTY layout" style = "width:85%">
reference
def num_key_strokes(text): return sum([1 if i in "abcdefghijklmnopqrestuvwxyz1234567890-=`];[',.\/ " else 2 for i in text])
Keystroking
5be085e418bcfd260b000028
[ "Fundamentals" ]
https://www.codewars.com/kata/5be085e418bcfd260b000028
7 kyu
The first positive integer, `n`, with its value `4n² + 1`, being divisible by `5` and `13` is `4`. (condition 1) It can be demonstrated that we have infinite numbers that may satisfy the above condition. If we name **<i>a</i><sub><i>i</i></sub>**, the different terms of the sequence of numbers with this property, we define `S(n)` as: <a href="https://imgur.com/79h926t"><img src="https://i.imgur.com/79h926t.png?2" title="source: imgur.com" /></a> We are interested in working with numbers of this sequence from 10 to 15 digits. Could you elaborate a solution for these results? You will be given an integer value `m`(always valid an positive) and you should output the closest value of the sequence to `m`. If the given value `m` is in the sequence, your solution should return the same value. In the case that there are two possible solutions: `s1` and `s2`, (`s1 < s2`), because `|m - s1| = |m - s2|`, output the highest solution `s2` No hardcoded solutions are allowed. No misterious formulae are required, just good observation to discover hidden patterns. See the example tests to see output format and useful examples, edge cases are included. Features of the random tests `1000 <= m <= 5.2 e14` **Note** <i>Sierpinsky presented the numbers that satisfy condition (1)</i>
reference
def sierpinski(): x = s = 0 while 1: for a in 4, 9, 56, 61: s += x + a yield s x += 65 s = sierpinski() S = [next(s)] from bisect import bisect_left def find_closest_value(m): while S[- 1] < m: S . append(next(s)) i = bisect_left(S, m) return min(S[i: i - 2: - 1], key=lambda n: abs(m - n))
Following Sierpinski's Footprints
5be0af91621daf08e1000185
[ "Algorithms", "Performance", "Number Theory", "Fundamentals" ]
https://www.codewars.com/kata/5be0af91621daf08e1000185
5 kyu
You are given two strings. In a single move, you can choose any of them, and delete the first (i.e. leftmost) character. For Example: * By applying a move to the string `"where"`, the result is the string `"here"`. * By applying a move to the string `"a"`, the result is an empty string `""`. Implement a function that calculates the minimum number of moves that should be performed to make the given strings equal. ## Notes * Both strings consist of lowercase latin letters. * If the string is already empty, you cannot perform any more delete operations.
reference
def shift_left(a, b): r = len(a) + len(b) for i in range(- 1, - min(len(a), len(b)) - 1, - 1): if a[i] != b[i]: break r -= 2 return r
Shift Left
5bdc191306a8a678f6000187
[ "Fundamentals" ]
https://www.codewars.com/kata/5bdc191306a8a678f6000187
7 kyu
## Background Those of you who have used spreadsheets will know that rows are identified by numbers and columns are identified by letters. For example the top left square of a spreadsheet is identified as `A1`, and the start of the grid is labelled like so: A1 | B1 | C1 ---+----+--- A2 | B2 | C2 ---+----+--- A3 | B3 | C3 The first 26 collums are labelled `A` to `Z`, then the label 27 becomes `AA` to 52 being `AZ`, then `BA` to `BZ`, and so on. `ZZ` rolls over to `AAA` In this kata, our internal data structure uses zero-based indexing for both row and index like so: (0,0) | (1,0) | (2,0) ------+-------+------ (0,1) | (1,1) | (2,1) ------+-------+------ (0,2) | (1,2) | (2,2) ## Kata The kata is to write a class with the **static** helper routines to convert a cell's internal representation to its display representation and vice versa. You can assume that your inputs are validated. ### Warning *However the initial solution was supplied by your boss, and he hasn't coded since his glory days with COBOL, you can be reasonably sure that the starter code he has given you **will not work** ...* Luckily, the unit tests supplied by your co-worker will work though, as he is so up-to-date with his skills he writes new languages because he knows everything about computing already...
algorithms
class SpreadSheetHelper: from string import ascii_uppercase BASE26 = dict(zip(ascii_uppercase, range(len(ascii_uppercase)))) @ classmethod def convert_to_display(cls, internal): display = [] row, col = internal row += 1 while row: row -= 1 row, n = divmod(row, 26) display . append(cls . ascii_uppercase[n]) return '' . join(reversed(display)) + str(col + 1) @ classmethod def convert_to_internal(cls, display): first_digit = next(n for n, c in enumerate(display) if c . isdigit()) row, col = display[: first_digit], display[first_digit:] internal = - 1 for c in row: internal += 1 internal *= 26 internal += cls . BASE26[c] return internal, int(col) - 1
Spreadsheet Cell Name Conversions
5540b8b79bb322607b000021
[ "Strings", "Algorithms" ]
https://www.codewars.com/kata/5540b8b79bb322607b000021
5 kyu
You are given a sequence of a journey in London, UK. The sequence will contain bus **numbers** and TFL tube names as **strings** e.g. ```javascript ['Northern', 'Central', 243, 1, 'Victoria'] ``` ```java new Object[] {"Northern", "Central", 243, 1, "Victoria"} ``` ```haskell [ Tube "Northern", Tube "Central", Bus 243, Bus 1, Tube "Victoria" ] ``` ```python ['Northern', 'Central', 243, 1, 'Victoria'] ``` ```kotlin arrayOf("Northern", "Central", 243, 1, "Victoria") ``` Journeys will always only contain a combination of tube names and bus numbers. Each tube journey costs `£2.40` and each bus journey costs `£1.50`. If there are `2` or more adjacent bus journeys, the bus fare is capped for sets of two adjacent buses and calculated as one bus fare for each set. For example: `'Piccadilly', 56, 93, 243, 20, 14 -> "£6.90"` Your task is to calculate the total cost of the journey and return the cost `rounded to 2 decimal places` in the format (where x is a number): `£x.xx`
reference
def london_city_hacker(journey): # your code here tube = 2.40 bus = 1.50 total_cost = 0.00 count = 0 for link in journey: if isinstance(link, str): total_cost += tube count = 0 else: if count == 0: total_cost += bus count += 1 else: count = 0 return '£{:.2f}' . format(total_cost)
London CityHacker
5bce125d3bb2adff0d000245
[ "Fundamentals" ]
https://www.codewars.com/kata/5bce125d3bb2adff0d000245
7 kyu
# Scenario *the rhythm of beautiful musical notes is drawing a Pendulum* **_Beautiful musical notes_** are the **_Numbers_** ___ # Task **_Given_** an *array/list [] of n integers* , **_Arrange_** *them in a way similar to the to-and-fro movement of a Pendulum* * **_The Smallest element_** of the list of integers , must come *in center position of array/list*. * **_The Higher than smallest_** , *goes to the right* . * **_The Next higher_** number goes *to the left of minimum number* and So on , in a to-and-fro manner similar to that of a Pendulum. ![!alt](https://i.imgur.com/xWoPbdq.png) ___ # Notes * **_Array/list_** size is *at least **_3_*** . * In **_Even array size_** , *The minimum element should be moved to (n-1)/2 index* (considering that indexes start from 0) * **_Repetition_** of numbers in *the array/list could occur* , So **_(duplications are included when Arranging)_**. ____ # Input >> Output Examples: ``` pendulum ([6, 6, 8 ,5 ,10]) ==> [10, 6, 5, 6, 8] ``` ## **_Explanation_**: * **_Since_** , `5` is the **_The Smallest element_** of the list of integers , came *in The center position of array/list* * **_The Higher than smallest_** is `6` *goes to the right* of `5` . * **_The Next higher_** number goes *to the left of minimum number* and So on . * Remember , **_Duplications are included when Arranging_** , Don't Delete Them . ____ ``` pendulum ([-9, -2, -10, -6]) ==> [-6, -10, -9, -2] ``` ## **_Explanation_**: * **_Since_** , `-10` is the **_The Smallest element_** of the list of integers , came *in The center position of array/list* * **_The Higher than smallest_** is `-9` *goes to the right* of it . * **_The Next higher_** number goes *to the left of* `-10` , and So on . * Remeber , In **_Even array size_** , *The minimum element moved to (n-1)/2 index* (considering that indexes start from 0) . ____ ``` pendulum ([11, -16, -18, 13, -11, -12, 3, 18]) ==> [13, 3, -12, -18, -16, -11, 11, 18] ``` ## **_Explanation_**: * **_Since_** , `-18` is the **_The Smallest element_** of the list of integers , came *in The center position of array/list* * **_The Higher than smallest_** is `-16` *goes to the right* of it . * **_The Next higher_** number goes *to the left of* `-18` , and So on . * Remember , In **_Even array size_** , *The minimum element moved to (n-1)/2 index* (considering that indexes start from 0) . ____ ```if:rust,clojure,cobol # Tune Your Code , There are 200 Assertions , 15.000 element For Each . ``` ```if-not:rust,clojure,prolog,cobol # Tune Your Code , There are 200 Assertions , 60.000 element For Each . ``` ```if:prolog # Tune Your Code , There are 100 Assertions , 1000 elements For Each . ``` ___ # [Playing with Numbers Series](https://www.codewars.com/collections/playing-with-numbers) # [Playing With Lists/Arrays Series](https://www.codewars.com/collections/playing-with-lists-slash-arrays) # [Bizarre Sorting-katas](https://www.codewars.com/collections/bizarre-sorting-katas) # [For More Enjoyable Katas](http://www.codewars.com/users/MrZizoScream/authored) ___ ## ALL translations are welcomed ## Enjoy Learning !! # Zizou
reference
def pendulum(a): a = sorted(a) return a[:: 2][:: - 1] + a[1:: 2]
The Poet And The Pendulum
5bd776533a7e2720c40000e5
[ "Fundamentals", "Arrays", "Algorithms", "Performance" ]
https://www.codewars.com/kata/5bd776533a7e2720c40000e5
7 kyu
Given an array `[x1, x2, ..., xn]` determine whether it is possible to put `+` or `-` between the elements and get an expression equal to `sum`. Result is `boolean` ``` 2 <= n <= 22 0 <= xi <= 20 -10 <= sum <= 10 ``` ## Example `arr = [1, 3, 4, 6, 8]` `sum = -2` **1 + 3 - 4 + 6 - 8 = -2** Result is: `true` ## Notes If it is impossible to find a solution then you should return `false`.
algorithms
def is_possible(nums, goal): if not nums: return False sums = {nums[0]} for i in range(1, len(nums)): sums = {n + s for n in sums for s in (- nums[i], nums[i])} return goal in sums
Plus - minus - plus - plus - ... - Sum
5bc463f7797b00b661000118
[ "Algorithms" ]
https://www.codewars.com/kata/5bc463f7797b00b661000118
6 kyu
You've had a baby. Well done. Nice isn't it? Life destroying... but in a good way. Part of your new routine is lying awake at night worrying that you've either lost the baby... or that you have more than 1! Given a string of words (x), you need to calculate how many babies are in it. To count as a baby you must have all of the letters in baby ('b', 'a', 'b', 'y'). That counts as 1. They do not need to be in order in the string. Upper and lower case letters count. Examples: ```kotlin "baby" = 1 "abby" = 1 "babybaby" = 2 "Why the hell are there so many babies?!" = 1 "Anyone remember life before babies?" = 1 "Happy babies boom ba by?" = 2 ``` If there are no babies in the string - you lost the baby!! Return a different value, as shown below: ```if-not:kotlin 'none here' = "Where's the baby?!" '' = "Where's the baby?!" ``` ```if:kotlin "none here" = null "" = null ```
reference
def baby_count(x): x = x . lower() return min(x . count('a'), x . count('b') / / 2, x . count('y')) or "Where's the baby?!"
The Baby Years I - Baby Counting
5bc9951026f1cdc77400011c
[ "Fundamentals", "Strings" ]
https://www.codewars.com/kata/5bc9951026f1cdc77400011c
7 kyu
# Story OOP is a very useful paradigm which allows creating infinite amount of similar objects. On the contrary, "singleton pattern" limits it, so only 1 instance of a class can be created, and any future attempt to instantiate a new object returns the already existing one. But what if we want something in between? ___ # Task Implement a decorator which limits the number of instances of a class which can exist at the same time. It will take 3 values: `limit`, `unique`, `lookup`. 1) `Limit` specifies the number of instances which can exist at the same time. 2) `Unique` specifies which attribute will serve as a unique identifier in this class. If another object with the same value of `unique` attribute was created eariler, older instance should be returned. 3) `Lookup` specifies which object should be returned if the instance limit has been hit, and the value of `unique` attribute was not used earlier. `Lookup` may equal to 3 values: `"FIRST"` (the oldest object is returned), `"LAST"` (the newest object is returned), or `"RECENT"` (the object which was returned during the previous instantiation attempt is returned again). ___ ## Examples: ``` @limiter(2, "ID", "FIRST") class ExampleClass: def __init__(self, ID, value): self.ID, self.value = ID, value a = ExampleClass(1, 5) # unique ID=1 b = ExampleClass(2, 8) # unique ID=2 ExampleClass(1, 20).value == 5 # there's an instance with unique ID=1 memorized ExampleClass(3, 0).value == 5 # no instance with ID=3, no more instances to remember, lookup type is # "FIRST", so we should return the first object that was memorized - # ExampleClass(1, 5) @limiter(2, "ID", "LAST") class ExampleClass: def __init__(self, ID, value): self.ID, self.value = ID, value a = ExampleClass(1, 5) b = ExampleClass(2, 8) ExampleClass(1, 20).value == 5 # there's an instance with unique ID=1 memorized ExampleClass(3, 0).value == 8 # no instance with ID=3, no more instances to remember, lookup type is # "LAST", so we should return the last object that was memorized - # ExampleClass(2, 8) @limiter(2, "value", "RECENT") class ExampleClass: def __init__(self, ID, value): self.ID, self.value = ID, value a = ExampleClass(1, 5) b = ExampleClass(2, 8) ExampleClass(4, 5).ID == 1 # this time "value" attribute is unique among the instances, which is why # we return ExampleClass(1, 5) - it has value=5 RecentInstance(1, 0).ID == 1 # no instance with value=0, no more instances to remember, lookup type is # "RECENT", so we should return the last object that we accessed again - # ExampleClass(1, 5) ```
reference
def limiter(limit, unique, lookup): def wrapper(class_): instances = {} lookups = {} def getinstance(* args, * * kwargs): new_obj = class_(* args, * * kwargs) if "FIRST" not in lookups: lookups["FIRST"] = new_obj id = getattr(new_obj, unique) if id in instances: res = instances[id] elif len(instances) < limit: instances[id] = new_obj res = lookups["LAST"] = new_obj else: res = lookups[lookup] lookups["RECENT"] = res return res return getinstance return wrapper
Limited number of instances
5bd36d5e03c3c4a37f0004f4
[ "Object-oriented Programming", "Metaprogramming" ]
https://www.codewars.com/kata/5bd36d5e03c3c4a37f0004f4
5 kyu
In this kata you will be given a random string of letters and tasked with returning them as a string of comma-separated sequences sorted alphabetically, with each sequence starting with an uppercase character followed by `n-1` lowercase characters, where `n` is the letter's alphabet position `1-26`. ## <span style="color: #f88">Example</span> ```javascript alphaSeq("ZpglnRxqenU") -> "Eeeee,Ggggggg,Llllllllllll,Nnnnnnnnnnnnnn,Nnnnnnnnnnnnnn,Pppppppppppppppp,Qqqqqqqqqqqqqqqqq,Rrrrrrrrrrrrrrrrrr,Uuuuuuuuuuuuuuuuuuuuu,Xxxxxxxxxxxxxxxxxxxxxxxx,Zzzzzzzzzzzzzzzzzzzzzzzzzz" ``` ```python alpha_seq("ZpglnRxqenU") -> "Eeeee,Ggggggg,Llllllllllll,Nnnnnnnnnnnnnn,Nnnnnnnnnnnnnn,Pppppppppppppppp,Qqqqqqqqqqqqqqqqq,Rrrrrrrrrrrrrrrrrr,Uuuuuuuuuuuuuuuuuuuuu,Xxxxxxxxxxxxxxxxxxxxxxxx,Zzzzzzzzzzzzzzzzzzzzzzzzzz" ``` ## <span style="color: #f88">Technical Details</span> - The string will include only letters. - The first letter of each sequence is uppercase followed by `n-1` lowercase. - Each sequence is separated with a comma. - Return value needs to be a string.
reference
def alpha_seq(s): return "," . join((c * (ord(c) - 96)). capitalize() for c in sorted(s . lower()))
Alphabetical Sequence
5bd00c99dbc73908bb00057a
[ "Fundamentals", "Strings", "Arrays" ]
https://www.codewars.com/kata/5bd00c99dbc73908bb00057a
7 kyu
## Story As a part of your work on a project, you are supposed to implement a node-based calculator. Thinking that it is too much of a boring task, you decided to give it to a less experienced developer without telling the management. When he finished, you were astounded to see how poor and ugly his implementation is. To not lose your face in front of the higher-ups, you must rewrite it... as short as possible. ___ ## Task You will be given a ready solution passing all the tests. Unfortunately for you, it is very long and overly repetitive. Current code length is `901` characters. Your task is to shorten it to at most `300` characters. **Note**: you can modify the implementation any way you want, as long as it is written using only OOP.
refactoring
import operator as o class v: def __init__(s, a, b): s . a, s . b = a, b def compute(s): return getattr(o, type(s). __name__)(s . a, s . b) class value (int): pass class add (v): pass class sub (v): pass class mul (v): pass class truediv (v): pass class mod (v): pass class pow (v): pass
Refactor a node-based calculator (DRY)
5bcf52022f660cab19000300
[ "Refactoring", "Object-oriented Programming" ]
https://www.codewars.com/kata/5bcf52022f660cab19000300
5 kyu
### Story Your company migrated the last 20 years of it's *very important data* to a new platform, in multiple phases. However, something went wrong: some of the essential time-stamps were messed up! It looks like that some servers were set to use the `dd/mm/yyyy` date format, while others were using the `mm/dd/yyyy` format during the migration. Unfortunately, the original database got corrupted in the process and there are no backups available... Now it's up to you to assess the damage. ### Task You will receive a list of records as strings in the form of `[start_date, end_date]` given in the ISO `yyyy-mm-dd` format, and your task is to count how many of these records are: * **correct**: there can be nothing wrong with the dates, the month/day cannot be mixed up, or it would not make a valid timestamp in any other way; e.g. `["2015-04-04", "2015-05-13"]` * **recoverable**: invalid in its current form, but the original timestamp can be recovered, because there is only one valid combination possible; e.g. `["2011-10-08", "2011-08-14"]` * **uncertain**: the original timestamp cannot be retrieved, because one or both dates are ambiguous and may generate multiple valid results, or can generate only invalid results; e.g. `["2002-02-07", "2002-12-10"]` **Note:** the original records always defined a *non-negative* duration (i.e. `start_date ≤ end_date`) Return your findings in an array: `[ correct_count, recoverable_count, uncertain_count ]` ### Examples ```ruby ["2015-04-04", "2015-05-13"] --> correct # nothing (could be) wrong here ["2013-06-18", "2013-08-05"] --> correct # end date is ambiguous, but this is # the only possible valid version ["2001-02-07", "2001-03-01"] --> correct # both dates are ambiguous, but this is # the only possible valid version ["2011-10-08", "2011-08-14"] --> recoverable # start date is wrong, but can be corrected # because there is only one valid version possible ["2009-08-21", "2009-04-12"] --> recoverable # end date is wrong, but can be corrected # because there is only one valid version possible ["1996-01-24", "1996-03-09"] --> uncertain # end date is ambiguous (could also be 1996-09-03) ["2000-10-09", "2000-11-20"] --> uncertain # start date is ambiguous (could also be 2000-09-10) ["2002-02-07", "2002-12-10"] --> uncertain # both dates are ambiguous, and there are # multiple possible valid versions ``` --- ### My other katas If you enjoyed this kata then please try [my other katas](https://www.codewars.com/users/anter69/authored)! :-) #### *Translations are welcome!*
algorithms
def candidates(ymd): y, m, d = ymd . split('-') return {ymd, f' { y } - { d } - { m } '} def check_dates(records): result = [0, 0, 0] for start, end in records: xs = [(dt1, dt2) for dt1 in candidates(start) for dt2 in candidates(end) if dt1 <= dt2 and dt1[5: 7] <= '12' >= dt2[5: 7]] i = 2 if len(xs) > 1 else xs[0] != (start, end) result[i] += 1 # 2: uncertain, 1(True): recoverable, 0(False): correct return result
Data Analysis Following Migration
5bc5cfc9d38567e29600019d
[ "Date Time", "Algorithms", "Data Science" ]
https://www.codewars.com/kata/5bc5cfc9d38567e29600019d
6 kyu
# Task You are given a string `s`. It's a string consist of letters, numbers or symbols. Your task is to find the Longest substring consisting of unique characters in `s`, and return the length of it. # Note - `1 <= s.length <= 10^7` - `5` fixed testcases - `100` random testcases, testing for correctness of solution - `100` random testcases, testing for performance of code - All inputs are valid. - Pay attention to code performance. - If my reference solution gives the wrong result in the random tests, please let me know(post an issue). # Example For `s="baacab"`, the output should be `3`. The non repeating substrings in `s` are: ``` "b","c","a","ba","ac","ca","ab","cab" ``` The longest one is `"cab"`, its length is `3`. For `s="abcd"`, the output should be `4`. The longest one is `"abcd"`, its length is `4`. For `s="!@#$%^&^%$#@!"`, the output should be `7`. The longest substring are `"!@#$%^&"` and `"&^%$#@!"`, their length both are `7`.
algorithms
def longest_substring(s: str) - > int: start, memo, res = 0, {}, 0 for i, c in enumerate(s): if c in memo and memo[c] >= start: start, res = memo[c] + 1, max(res, i - start) memo[c] = i return max(res, len(s) - start)
Simple Fun #396: Find the Longest Substring Consisting of Unique Characters
5bcd90808f9726d0f6000091
[ "Algorithms", "Strings", "Fundamentals" ]
https://www.codewars.com/kata/5bcd90808f9726d0f6000091
6 kyu
With one die of 6 sides we will have six different possible results:``` 1, 2, 3, 4, 5, 6``` . With 2 dice of six sides, we will have 36 different possible results: ``` (1,1),(1,2),(2,1),(1,3),(3,1),(1,4),(4,1),(1,5), (5,1), (1,6),(6,1),(2,2),(2,3),(3,2),(2,4),(4,2), (2,5),(5,2)(2,6),(6,2),(3,3),(3,4),(4,3),(3,5),(5,3), (3,6),(6,3),(4,4),(4,5),(5,4),(4,6),(6,4),(5,5), (5,6),(6,5),(6,6) ``` So, with 2 dice of 6 sides we get 36 different events. ``` ([6,6] ---> 36) ``` But with 2 different dice we can get for this case, the same number of events. One die of ```4 sides``` and another of ```9 sides``` will produce the exact amount of events. ``` ([4,9] ---> 36) ``` We say that the dice set ```[4,9]``` is equivalent to ```[6,6]``` because both produce the same number of events. Also we may have an amount of three dice producing the same amount of events. It will be for: ``` [4,3,3] ---> 36 ``` (One die of 4 sides and two dice of 3 sides each) Perhaps you may think that the following set is equivalent: ```[6,3,2]``` but unfortunately dice have a **minimum of three sides** (well, really a tetrahedron with one empty side) The task for this kata is to get the amount of equivalent dice sets, having **2 dice at least**,for a given set. For example, for the previous case: [6,6] we will have 3 equivalent sets that are: ``` [4, 3, 3], [12, 3], [9, 4]``` . You may assume that dice are available from 3 and above for any value up to an icosahedral die (20 sides). ``` [5,6,4] ---> 5 (they are [10, 4, 3], [8, 5, 3], [20, 6], [15, 8], [12, 10]) ``` For the cases we cannot get any equivalent set the result will be `0`. For example for the set `[3,3]` we will not have equivalent dice. Range of inputs for Random Tests: ``` 3 <= sides <= 15 2 <= dices <= 7 ``` See examples in the corresponding box. Enjoy it!!
reference
import numpy as np def products(n, min_divisor, max_divisor): if n == 1: yield [] for divisor in range(min_divisor, max_divisor + 1): if n % divisor == 0: for product in products(n / / divisor, divisor, max_divisor): yield product + [divisor] def eq_dice(set): product = np . prod(set) lista = list(products(product, 3, min(product - 1, 20))) return len(lista) - 1 if len(set) > 1 else len(lista)
Equivalent Dice
5b26047b9e40b9f4ec00002b
[ "Algorithms", "Performance", "Number Theory", "Recursion", "Fundamentals" ]
https://www.codewars.com/kata/5b26047b9e40b9f4ec00002b
5 kyu
In this kata we are going to mimic a software versioning system. ```if:javascript You have to implement a `vm` function returning an object. ``` ```if:factor You have to implement a `<version-manager>` constructor word, and some associated words. ``` ```if:rust You have to implement a `VersionManager` struct. ``` ```if-not:javascript,factor,rust You have to implement a `VersionManager` class. ``` It should accept an optional parameter that represents the initial version. The input will be in one of the following formats: `"{MAJOR}"`, `"{MAJOR}.{MINOR}"`, or `"{MAJOR}.{MINOR}.{PATCH}"`. More values may be provided after `PATCH` but they should be ignored. If these 3 parts are not decimal values, an exception with the message `"Error occured while parsing version!"` should be thrown. If the initial version is not provided or is an empty string, use `"0.0.1"` by default. This class should support the following methods, all of which should be chainable (except `release`): * `major()` - increase `MAJOR` by `1`, set `MINOR` and `PATCH` to `0` * `minor()` - increase `MINOR` by `1`, set `PATCH` to `0` * `patch()` - increase `PATCH` by `1` * `rollback()` - return the `MAJOR`, `MINOR`, and `PATCH` to their values before the previous `major`/`minor`/`patch` call, or throw an exception with the message `"Cannot rollback!"` if there's no version to roll back to. Multiple calls to `rollback()` should be possible and restore the version history * `release()` - return a string in the format `"{MAJOR}.{MINOR}.{PATCH}"` ~~~if:factor ***Note:** An error word has been preloaded for you, use it as follows: `msg version-error`.* ~~~ ~~~if:cpp **Note:** In C++, use preloaded `VersionException` class for throwing exceptions. ~~~ May the binary force be with you! ~~~if:rust # Notes for Rust ### API Rust is strictly typed and thus imposes restrictions and idioms that don't apply to some other languages, particularly for concepts like method chaining and optional parameters. To allow the tests to interface with your solution, an API has been chosen and set up in the initial solution which you **must not alter** (you are free to declare and use custom structs and methods outside and within the given API as you see fit).\ The constructor functions are as follows: * `new`: takes no arguments and creates a VersionManager with the default initial version as described above * `from_version`: takes a string representing the initial version and attempts to parse it into a VersionManager (see below) ### Errors In Rust, we don't throw and (maybe) catch Exceptions, and as *competent* Rustaceans we certainly don't `panic!` when we encounter an error we can recover from. Accordingly, the two methods that can potentially fail return a `Result<VersionManager, VMError>`.\ The error type `VMError` has been preloaded for you and replaces the string messages in the original description: ```rust pub enum VMError { InvalidVersion, // for the `from_version` function NoHistory, // for the `rollback` method } ``` ~~~
algorithms
class VersionManager: def __init__(self, version=None): if not version: version = '0.0.1' self . __memory = [] try: arr = [* map(int, version . split('.')[: 3])] + [0, 0, 0] except: raise Exception("Error occured while parsing version!") del arr[3:] self . __version = arr if any(arr) else [0, 0, 1] def release(self): return '.' . join(map(str, self . __version)) def rollback(self): if not self . __memory: raise Exception("Cannot rollback!") self . __version = self . __memory . pop() return self def __update(self, i): self . __memory . append([* self . __version]) self . __version[i] += 1 self . __version[i + 1:] = [0] * (len(self . __version) - 1 - i) return self def major(self): return self . __update(0) def minor(self): return self . __update(1) def patch(self): return self . __update(2)
Versions manager
5bc7bb444be9774f100000c3
[ "Algorithms", "Arrays", "Strings", "Object-oriented Programming" ]
https://www.codewars.com/kata/5bc7bb444be9774f100000c3
6 kyu
The leader of the village sends you to carry back exactly `c` litres from the mountain shrine holy water, but you can only bring back one of the 2 jars `a` or `b` (`a` and `b` are known values) in the shrine. You also have to do that in one travel... you can't risk going to the shrine and die trying to fill one of the jars with `c` litres. So help yourself by precalculating if it's possible to do that in any way and inform the leader about the possibility of you been able to achieve the task (You are very trustworthy and won't like to disappoint your leader) :) <p> * ****INPUT****<br> `a, b` the volumes of jars you are given and `c` the volume of the water you have to carry back * ****Output**** <br> `true` or `false` depending upon if it's possible to fill one of the `a` or `b` litre jar with demand `c` litre. * ****Example****<br> <a href="https://www.youtube.com/watch?v=6cAbgAaEOVE">My favorite explanation </a> <br> ****OR (For those who like to read)**** ;) <br> For `a = 3`, `b = 5` and `c = 4` litre * Fill the jar `a` full and pour that in jar `b` now jar `a` contains 0 litres and jar `b` contains 3 litres of water * Repeat 1st step once again and now you have jar `b` full with 5 litres and jar `a` left with 1 litre. * Now empty the jar `b` and pour the water left in jar `a` (1 litre) into jar `b`, now jar `a` is empty and jar `b` contains `1` litre of water. * Now just fill again the jar `a` and pour that back into jar `b` to get `4` litres (Hope you understand)
algorithms
from math import gcd def can_measure(a, b, c): return not (a < c > b or c % gcd(a, b))
3 litres and 5 litres
5bc8c9db40ecc7f792002308
[ "Mathematics", "Algorithms" ]
https://www.codewars.com/kata/5bc8c9db40ecc7f792002308
7 kyu
Baby is getting his frst tooth. This means more sleepless nights, but with the fun of feeling round his gums and trying to guess which will be first out! Probably best have a sweepstake with your friends - because you have the best chance of knowing. You can feel the gums and see where the raised bits are - most raised, most likely tooth to come through first! Given an array of numbers (t) to represent baby's gums, you need to return the index of the lump that is most pronounced. The most pronounced lump is the one that has the biggest differential to its surrounding values. e.g.: ``` [1, 2, 4] = 2 index 0 has a differential of -1 to its right (it is lower so the figure is negative) index 1 has a differential of +1 to its left, and -2 to its right. Total is -1. index 2 has a differential of +2 to its left, and nothing to its right, ``` If there is no distinct highest value (more than one occurence of the largest differential), return -1.
reference
def first_tooth(lst): gums = lst[: 1] + lst + lst[- 1:] diff = [gums[i + 1] * 2 - gums[i] - gums[i + 2] for i in range(len(lst))] m = max(diff) return diff . index(m) if diff . count(m) == 1 else - 1
The Baby Years III - First Tooth
5bcac5a01cbff756e900003e
[ "Fundamentals", "Strings", "Arrays" ]
https://www.codewars.com/kata/5bcac5a01cbff756e900003e
7 kyu
We have the array of string digits, ```arr = ["3", "7", "7", "7", "3", "3, "3", "7", "8", "8", "8"]```. The string digit with the least frequency is "8" occurring three times. We will pop the first element of the array three times (exactly the same value of the minimum frequency) and we get "377" ``` ["3", "7", "7", "7", "3", "3, "3", "7", "8", "8", "8"] ---> "3" ["7", "7", "7", "3", "3, "3", "7", "8", "8", "8"] ---> "37" ["7", "7", "3", "3, "3", "7", "8", "8", "8"] ---> "377" ``` We change the order in the original array, arr, in a random way and we get another string number, in this case: ```"783"``` ``` ['7', '8', '3', '3', '7', '3', '8', '3', '7', '8', '7'] ---> "7" ['8', '3', '3', '7', '3', '8', '3', '7', '8', '7'] ---> "78" ['3', '3', '7', '3', '8', '3', '7', '8', '7'] ---> "783" ``` Repeating this process you will get all the possible string numbers of three digits we list them below in a random order: ``` ['377', '783', '883', '887', '338', '337', '888', '333', '833', '837', '878', '877', '838', '873', '733', '737', '738', '777', '773', '778', '383', '387', '388', '787', '788', '378', '373'] (27 different string numbers) (I) ``` From the set above the following string numbers have at least one string digit occurring more than once: ``` ['377','883','887','338','337','888','333','833','878','877','838','733','737','777','773','778','383','388','787','788','373'] (total of 21 numbers) (II) ``` From this above list, we get the integer 873, that is the highest number having digits occurring only once (pandigital). (III) Having in mind the random process shown above that generates string numbers, we need a function ```proc_arrII()``` that receives an array of string digits and outputs the total maximum possible amount of string numbers (I), the amount of digits that have at least one digit occurring more than once (II) and the highest pandigital number(III). The above case will be: ```python proc_arrII(["3","7","7","7","3","3","3","7","8","8","8"]) == [27, 21, 873] ``` More cases in the example box. The digit "0" may be included in the given array and is treated the same as any other digit. If it is not possible to generate a pandigital number the function will output only the total number of generated numbers. See the case below: ```python proc_arrII(['3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '1', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '3', '1', '3', '3', '3', '3', '3', '1', '3', '3']) = [8] ``` Features of the random tests: ``` Low Performance Tests: Length of array between 6 and 200 Minimum occurrence of digits between 3 and 25 Number of tests: 100 ```
algorithms
from collections import Counter from math import factorial as fact def proc_arrII(arr): c = Counter(arr) l = min(c . values()) p = len(c) * * l return [p] if len(c) < l else [p, p - fact(len(c)) / / fact(len(c) - l), int('' . join(sorted(c . keys(), reverse=True)[: l]))]
Generate Numbers From Digits #2
584e936ae82520a397000027
[ "Fundamentals", "Logic", "Strings", "Data Structures", "Algorithms", "Mathematics", "Number Theory", "Permutations" ]
https://www.codewars.com/kata/584e936ae82520a397000027
5 kyu
There is no single treatment that works for every phobia, but some people cure it by being gradually exposed to the phobic situation or object. In this kata we will try curing arachnophobia by drawing primitive spiders. Our spiders will have legs, body, eyes and a mouth. Here are some examples: ``` /\((OOwOO))/\ /╲(((0000w0000)))╱\ ^(oWo)^ ``` You will be given four values: 1) `leg size` where each value stands for its own leg type: `1 for "^ ^", 2 for "/\ /\", 3 for "/╲ ╱\", 4 for "╱╲ ╱╲"` 2) `body size` where each value stands for its own body type: `1 for "( )", 2 for "(( ))", 3 for "((( )))"` 3) `mouth` representing the spider's mouth 4) `eye` representing the spider's eye **Note:** the eyes are symmetric, and their total amount is `2 to the power of body size`. You will also be given only valid data. That's it for the instructions, you can start coding!
reference
def draw_spider(leg_size, body_size, mouth, eye): lleg = ['', '^', '/\\', '/╲', '╱╲'][leg_size] rleg = ['', '^', '/\\', '╱\\', '╱╲'][leg_size] lbody = '(' * body_size rbody = ')' * body_size eye *= 2 * * (body_size - 1) return f' { lleg }{ lbody }{ eye }{ mouth }{ eye }{ rbody }{ rleg } '
Curing Arachnophobia
5bc73331797b005d18000255
[ "Strings", "Fundamentals" ]
https://www.codewars.com/kata/5bc73331797b005d18000255
7 kyu
# Task **Your task** is to implement function `printNumber` (`print_number` in C/C++ and Python `Kata.printNumber` in Java) that returns string that represents given number in text format (see examples below). Arguments: - `number` — Number that we need to print (`num` in C/C++/Java) - `char` — Character for building number (`ch` in C/C++/Java) # Examples ```javascript printNumber(99, "$") //Should return //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n //$ $\n //$ $$$$ $$$$ $$$$ $$$$ $$$$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$ $$ $$ $$ $$ $$ $$$$ $$$$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$$$ $$$$ $$$$ $$ $$ $\n //$ $\n //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ printNumber(12345, "*") //Should return //****************************************\n //* *\n //* ** **** **** ** ** ****** *\n //* *** ** ** ** ** ** ** ** *\n //* * ** ** ** ** ** ***** *\n //* ** ** ** ***** ** *\n //* ** ** ** ** ** ** *\n //* ****** ****** **** ** ***** *\n //* *\n //**************************************** printNumber(67890, "@") //Should return //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n //@ @\n //@ @@ @@@@@@ @@@@ @@@@ @@@@ @\n //@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @\n //@ @@@@ @@ @@@@ @@ @@ @@ @@ @\n //@ @@ @@ @@ @@@@ @@@@ @@ @@ @\n //@ @@ @@ @@ @@ @@ @@ @@ @@ @\n //@ @@@@ @@ @@@@ @@ @@@@ @\n //@ @\n //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ``` ```c,python print_number(99, '$') //Should return //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n //$ $\n //$ $$$$ $$$$ $$$$ $$$$ $$$$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$ $$ $$ $$ $$ $$ $$$$ $$$$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$$$ $$$$ $$$$ $$ $$ $\n //$ $\n //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ print_number(12345, '*') //Should return //****************************************\n //* *\n //* ** **** **** ** ** ****** *\n //* *** ** ** ** ** ** ** ** *\n //* * ** ** ** ** ** ***** *\n //* ** ** ** ***** ** *\n //* ** ** ** ** ** ** *\n //* ****** ****** **** ** ***** *\n //* *\n //**************************************** print_number(67890, '@') //Should return //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n //@ @\n //@ @@ @@@@@@ @@@@ @@@@ @@@@ @\n //@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @\n //@ @@@@ @@ @@@@ @@ @@ @@ @@ @\n //@ @@ @@ @@ @@@@ @@@@ @@ @@ @\n //@ @@ @@ @@ @@ @@ @@ @@ @@ @\n //@ @@@@ @@ @@@@ @@ @@@@ @\n //@ @\n //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ``` ```cpp print_number(99, '$') //Should return //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n //$ $\n //$ $$$$ $$$$ $$$$ $$$$ $$$$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$ $$ $$ $$ $$ $$ $$$$ $$$$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$$$ $$$$ $$$$ $$ $$ $\n //$ $\n //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ print_number(12345, '*') //Should return //****************************************\n //* *\n //* ** **** **** ** ** ****** *\n //* *** ** ** ** ** ** ** ** *\n //* * ** ** ** ** ** ***** *\n //* ** ** ** ***** ** *\n //* ** ** ** ** ** ** *\n //* ****** ****** **** ** ***** *\n //* *\n //**************************************** print_number(67890, '@') //Should return //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n //@ @\n //@ @@ @@@@@@ @@@@ @@@@ @@@@ @\n //@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @\n //@ @@@@ @@ @@@@ @@ @@ @@ @@ @\n //@ @@ @@ @@ @@@@ @@@@ @@ @@ @\n //@ @@ @@ @@ @@ @@ @@ @@ @@ @\n //@ @@@@ @@ @@@@ @@ @@@@ @\n //@ @\n //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ``` ```java Kata.printNumber(99, '$') //Should return //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$\n //$ $\n //$ $$$$ $$$$ $$$$ $$$$ $$$$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$ $$ $$ $$ $$ $$ $$$$ $$$$ $\n //$ $$ $$ $$ $$ $$ $$ $$ $$ $\n //$ $$$$ $$$$ $$$$ $$ $$ $\n //$ $\n //$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ Kata.printNumber(12345, '*') //Should return //****************************************\n //* *\n //* ** **** **** ** ** ****** *\n //* *** ** ** ** ** ** ** ** *\n //* * ** ** ** ** ** ***** *\n //* ** ** ** ***** ** *\n //* ** ** ** ** ** ** *\n //* ****** ****** **** ** ***** *\n //* *\n //**************************************** Kata.printNumber(67890, '@') //Should return //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@\n //@ @\n //@ @@ @@@@@@ @@@@ @@@@ @@@@ @\n //@ @@ @@ @@ @@ @@ @@ @@ @@ @@ @\n //@ @@@@ @@ @@@@ @@ @@ @@ @@ @\n //@ @@ @@ @@ @@@@ @@@@ @@ @@ @\n //@ @@ @@ @@ @@ @@ @@ @@ @@ @\n //@ @@@@ @@ @@@@ @@ @@@@ @\n //@ @\n //@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@ ``` >***Note, that***: - Number should be `0 <= number <= 99999` and have `5 digits` (should have zeros at the start if needed) - Test cases contains only valid values (integers that are 0 <= number <= 99999) and characters - Numbers should have the same shape as in the examples (6x6 by the way) - Returned string should be joined by `\n` character (except of the end) - Returned string should have 1 character *(height)* border (use the same character as for number) + padding (1 character in height vertical and 2 horizontal with ` `) around borders and 1 character margin between "digits" *Suggestions and translations are welcome.*
reference
DIGITS = """ *************************************************************************** * * * **** ** **** **** ** ** ****** ** ****** **** **** * * ** ** *** ** ** ** ** ** ** ** ** ** ** ** ** ** ** * * ** ** * ** ** ** ** ** ***** **** ** **** ** ** * * ** ** ** ** ** ***** ** ** ** ** **** **** * * ** ** ** ** ** ** ** ** ** ** ** ** ** ** * * **** ****** ****** **** ** ***** **** ** **** ** * * * *************************************************************************** """ . strip(). splitlines() def print_number(number, char): ns = [* map(int, format(number, '05'))] return '\n' . join( ds[: 2] + '' . join(ds[n * 7 + 2: n * 7 + 9] for n in ns) + ds[- 3:] for ds in DIGITS ). replace('*', char)
Print number with character
5bc5c0f8eba26e792400012a
[ "Fundamentals" ]
https://www.codewars.com/kata/5bc5c0f8eba26e792400012a
6 kyu
# Silent Import As part of your spy training, You were taught to be as stealthy as possible while carrying out missions. This time, you have to silently import modules from a without getting caught. Most of your peers are skeptical if you will be able to do this. But, you are the [G.O.A.T](https://www.urbandictionary.com/define.php?term=goat) and you always have a plan. # Your Task Write a function `silent_thief` that will import any module passed in to it and return it. Your code must __NOT__: 1. Contain the word `import` 2. Contain any double underscores: `__` 3. Use either `eval` or `exec`. ## Extra info This is kata 2 of my awesome [__spy__](https://www.codewars.com/collections/spy-series) series. #### Please take time to give feedback on this kata.
games
def silent_thief(module_name): return globals()['_' '_builtins_' '_']['_' '_imp' 'ort_' '_'](module_name)
Silent Import
5bc5c064eba26ef6ed000158
[ "Puzzles", "Language Features", "Restricted" ]
https://www.codewars.com/kata/5bc5c064eba26ef6ed000158
6 kyu
## Task You are given three non negative integers `a`, `b` and `n`, and making an infinite sequence just like fibonacci sequence, use the following rules: - step 1: use `ab` as the initial sequence. - step 2: calculate the sum of the last two digits of the sequence, and append it to the end of sequence. - repeat step 2 until you have enough digits Your task is to complete the function which returns the `n`th digit (0-based) of the sequence. ### Notes: - `0 <= a, b <= 9`, `0 <= n <= 10^10` - `16` fixed testcases - `100` random testcases, testing for correctness of solution - `100` random testcases, testing for performance of code - All inputs are valid. - Pay attention to code performance. ## Examples For `a = 7, b = 8 and n = 9` the output should be `5`, because the sequence is: ``` 78 -> 7815 -> 78156 -> 7815611 -> 78156112 -> 781561123 -> 7815611235 -> ... ``` and the 9th digit of the sequence is `5`. --- For `a = 0, b = 0 and n = 100000000` the output should be `0`, because all the digits in this sequence are `0`.
games
def find(a, b, n): strng = str(a) + str(b) # there are 10 and 4 long loops if (n > 20): n = n % 20 + 20 while len(strng) <= n: next_ch = int(strng[- 1]) + int(strng[- 2]) strng = strng + str(next_ch) return int(strng[n])
Simple Fun #395: Fibonacci digit sequence
5bc555bb62a4cec849000047
[ "Puzzles", "Fundamentals" ]
https://www.codewars.com/kata/5bc555bb62a4cec849000047
6 kyu
John has invited some friends. His list is: ``` s = "Fred:Corwill;Wilfred:Corwill;Barney:Tornbull;Betty:Tornbull;Bjon:Tornbull;Raphael:Corwill;Alfred:Corwill"; ``` Could you make a program that - makes this string uppercase - gives it sorted in alphabetical order by last name. When the last names are the same, sort them by first name. Last name and first name of a guest come in the result between parentheses separated by a comma. So the result of function `meeting(s)` will be: ``` "(CORWILL, ALFRED)(CORWILL, FRED)(CORWILL, RAPHAEL)(CORWILL, WILFRED)(TORNBULL, BARNEY)(TORNBULL, BETTY)(TORNBULL, BJON)" ``` It can happen that in two distinct families with the same family name two people have the same first name too. #### Notes - You can see another examples in the "Sample tests".
reference
def meeting(s): return '' . join(sorted('({1}, {0})' . format(* (x . split(':'))) for x in s . upper(). split(';')))
Meeting
59df2f8f08c6cec835000012
[ "Fundamentals" ]
https://www.codewars.com/kata/59df2f8f08c6cec835000012
6 kyu
A rook is a piece used in the game of chess which is played on a board of square grids. A rook can only move vertically or horizontally from its current position and two rooks attack each other if one is on the path of the other. In the following figure, the dark squares represent the reachable locations for rook R<sub>1</sub> from its current position. The figure also shows that the rook R<sub>1</sub> and R<sub>2</sub> are in attacking positions where R<sub>1</sub> and R<sub>3</sub> are not. R<sub>2</sub> and R<sub>3</sub> are also in non-attacking positions. <img src="https://image.ibb.co/ixj2op/Screenshot-2.png" alt="Screenshot-2" border="0"></a> Now, given two numbers ``n`` and ``k``, your job is to determine the number of ways one can put ``k`` rooks on an ``n x n`` chessboard so that no two of them are in attacking positions. **NOTE:** The `k` rooks are **indistinguishable** / **interchangeable** - this means that in the above illustration, for example, swapping rook R<sub>1</sub> with rook R<sub>2</sub> does **not** count as a new configuration - it is just a "relabelling" of the same configuration. **Range:** (1 ≤ n ≤ 15) and (0 ≤ k ≤ n<sup>2</sup>)
reference
from math import factorial, comb def rooks(n, k): return factorial(k) * comb(n, k) * * 2
Rooks
5bc2c8e230031558900000b5
[ "Algorithms", "Mathematics", "Fundamentals", "Combinatorics" ]
https://www.codewars.com/kata/5bc2c8e230031558900000b5
6 kyu
We need a function that may receive a list of an unknown amount of points in the same plane, having each of them, cartesian coordinates of the form (x, y) and may find the biggest triangle (the one with the largest area) formed by all of the possible combinations of groups of three points of that given list. Of course, we will have some combinations of three points that does not form a triangle, because the three points are aligned. The function find_biggTriang(listOfPoints), will output a list with the following data in the order presented bellow: ```python [(1), (2), (3), (4), 5] (1) - Number of points received (You may assume that you will not receive duplicates) (2) - Maximum possible amount of triangles that can be formed with the amount of received points (number in data (1) above). It should be expressed as an integer, (no L for long type variables) (3) - Real Number of triangles that can be formed with the given points. (The function should have a counter for all the cases of three points aligned). It should be expressedas as an integer. (4) - The triangles that have maximum area in a sorted list. If there are two triangles with the biggest area, the result will be presented in this way: [[[xA1, yA1], [xB1, yB1], [xC1, yC1]], [[xA2, yA2], [xB2, yB2], [xC2, yC2]]] But if we have only one triangle with max. area, there is no need of a spare level of braces, so it will be as follows: [[xA1, yA1], [xB1, yB1], [xC1, yC1]] (5) - The value of max. area (absolute value) that was found as a float. As we did not define the units of length for the coordinates, the units for the area will be ignored. ``` It would be useful to apply the expression for the area of a triangle with vertices A, B, and C, is equal to the half of the determinant of the matrix, using the respective coordinates as follows: ```python | xA yA 1| Area Triangle(A, B, C) = 1/2 . | xB yB 1| | xC yC 1| ``` The negative sign for the area should be ignored for the purpose of the exercise, and we will consider the absolute value for all cases. See how to calculate the determinant of a matrix 3 x 3, rule of Sarrus. https://en.wikipedia.org/wiki/Rule_of_Sarrus Using this expression, it would be easy to detect the cases when three points are aligned. Let's see some simple cases. ```python listOfPoints1 = [(0, 1), (7, 3), (9, 0), (7, 10), (2, 9), (10, 7), (2, 8), (9, 8), (4, 4), (2, 10), (10, 1), (0, 4), (4, 3), (10, 0), (0, 3), (3, 4), (1, 1), (7, 2), (4, 0)] (19 points received) find_biggTriang(listOfPoints1) --------> [19, 969, 953, [[0, 1], [7, 10], [10, 0]], 48.5] /// Combinations (19, 3) = 969 (We do not have repeated points) 953 real cases for triangles because the function detected 16 cases when three points are aligned. The function found one triangle [[0, 1], [7, 10], [10, 0]] with its area equals to 49.5/// listOfPoints2 = [(7, 4), (0, 0), (9, 10), (5, 0), (8, 1), (7, 6), (9, 3), (2, 4), (6, 3), (5, 6), (3, 6), (10, 0), (9, 7), (3, 10), (10, 2)] (15 points received) find_biggTriang(listOfPoints2) --------> [15, 455, 446, [[[0, 0], [9, 10], [10, 0]], [[0, 0], [10, 0], [3, 10]]], 50.0] /// Combinations(15, 3) = 455 but there were only 446 real triangles We found two triangles: [[0, 0], [9, 10], [10, 0]] and [[0, 0], [10, 0], [3, 10]] (both in a sorted list. Both triangles have an area of 50.0/// ``` Your code will be tested with lists created randomly up to 70 points. Have a nice moment and enjoy it!!
reference
from itertools import combinations def find_biggTriang(listPoints): def area(a, b, c): return 0.5 * abs(b[0] * c[1] - b[1] * c[0] - a[0] * c[1] + a[1] * c[0] + a[0] * b[1] - a[1] * b[0]) triangls = [[[a, b, c], area(a, b, c)] for a, b, c in combinations(map(list, listPoints), 3)] np, mp, rp = len(listPoints), len( triangls), sum(a != 0 for _, a in triangls) mxt, mxa = max(triangls, key=lambda x: x[1]) mxtt = [t for t, a in triangls if a == mxa] return [np, mp, rp, mxt if len(mxtt) == 1 else mxtt, mxa]
Find the Biggest Triangle
55f0a7d8c44c6f1438000013
[ "Data Structures", "Algorithms", "Mathematics", "Searching", "Sorting", "Fundamentals" ]
https://www.codewars.com/kata/55f0a7d8c44c6f1438000013
6 kyu
The conic curves may be obtained doing different sections of a cone and we may obtain the three principal groups: ellipse, hyperbola and parabola. <a href="http://imgur.com/4NdOkgf"><img src="http://i.imgur.com/4NdOkgf.png?2" title="source: imgur.com" /></a> The circle is a special case of ellipses. In mathematics all the conics may be represented by the following equation: <a href="http://imgur.com/SVTomxD"><img src="http://i.imgur.com/SVTomxD.jpg?1" title="source: imgur.com" /></a> ```A, B, C, D, E and F``` are coefficients that may have different values in the real numeric field. Hesse in the nineteenth century, introduced the use of the invariants, useful tool in order to classify the different conic curves. The invariants ```M, N, and S``` are: <a href="http://imgur.com/v7xVjyX"><img src="http://i.imgur.com/v7xVjyX.png?1" title="source: imgur.com" /></a> It may be proved that if the system of coordinates changes, for example moving the center of the system of coordinates or rotating the coordinates axes, or doing both things, the invariants will have the same value, even though the coefficients ```A, B, C, D, E, and F``` change. The following chart shows how the values of ```M, N and S``` classify the gender of the conics and the special cases when the conics are degenerated (points or lines) or they are imaginary: <a href="https://imgur.com/2hUJNeN"><img src="https://i.imgur.com/2hUJNeN.jpg?1" title="source: imgur.com" /></a> The function ```classify_conic()``` will do this work. This function will receive the different coefficients of the conic equation and will output the result of the classification as a string ```python classify_conic(A, B, C, D, E, F) == result ``` ```javascript classifyConic(A, B, C, D, E, F) == result ``` ```ruby classify_conic(a, b, c, d, e, f) == result ``` Let's see some cases: ``` Case1 A = 1 , B = 1, C = 1, D = 2, E = 2, F = -4 classify_conic(A, B, C, D, E, F) == "A real ellipse" Case2 A = 1 , B = 1, C = -1, D = 2, E = 2, F = 4 classify_conic(A, B, C, D, E, F) == "A real hyperbola" Case3 A =1, B = 0, C = 0, D = 4; E = 4, F = 4 classify_conic(A, B, C, D, E, F) == "A real parabola" ``` ``` Case1 A = 1 , B = 1, C = 1, D = 2, E = 2, F = -4 classifyConic(A, B, C, D, E, F) == "A real ellipse" Case2 A = 1 , B = 1, C = -1, D = 2, E = 2, F = 4 classifyConic(A, B, C, D, E, F) == "A real hyperbola" Case3 A =1, B = 0, C = 0, D = 4; E = 4, F = 4 classifyConic(A, B, C, D, E, F) == "A real parabola" ``` The graph showing the above three cases is the following: <a href="http://imgur.com/nUE4mcM"><img src="http://i.imgur.com/nUE4mcM.png?1" title="source: imgur.com" /></a> The messages for the special cases, having degenerated or imaginary conics will be: ```python # For elliptic gender: "An imaginary ellipse" "A degenerated ellipse: One point" # For hyperbolic gender: "A degenerated hyperbola: two intersecting lines" # For parabolic gender: "A degenerated parabola: two parallel lines" "A degenerated parabola: two coinciding lines" "A degenerated parabola: two imaginary lines" ``` Enjoy it!! #Note: - The given coefficients `A`, `B`, `C`, `D`, `E and `F`, (`a`, `b`, `c`, `d`, `e` and `f` in Ruby) will be always integers. - In order to avoid precision problems, the determinant values of `M` and `N` should be obtained by the rule of Sarrus. (See: https://en.wikipedia.org/wiki/Rule_of_Sarrus)
reference
def det(matrix: list) - > int: if len(matrix) == 1: return matrix[0][0] return sum((- 1) * * i * matrix[0][i] * det([row[: i] + row[i + 1:] for row in matrix[1:]]) for i in range(len(matrix))) def classify_conic(A: int, B: int, C: int, D: int, E: int, F: int) - > str: M = det([[2 * A, B, D], [B, 2 * C, E], [D, E, 2 * F]]) N = det([[B, 2 * A], [2 * C, B]]) S = A + C if N < 0: # elliptic if M == 0: return 'A degenerated ellipse: One point' if M * S < 0: return 'A real ellipse' if M * S > 0: return 'An imaginary ellipse' if N > 0: # hyperbolic if M == 0: return 'A degenerated hyperbola: two intersecting lines' if M != 0: return 'A real hyperbola' if N == 0: # parabolic if M != 0: return 'A real parabola' delta = D * * 2 - 4 * A * F if delta == 0: return 'A degenerated parabola: two coinciding lines' if delta > 0: return 'A degenerated parabola: two parallel lines' if delta < 0: return 'A degenerated parabola: two imaginary lines'
Conic Classification
56546460730f15790b000075
[ "Fundamentals", "Logic", "Data Structures", "Mathematics", "Geometry", "Linear Algebra" ]
https://www.codewars.com/kata/56546460730f15790b000075
6 kyu
You will be given two strings `a` and `b` consisting of lower case letters, but `a` will have at most one asterix character. The asterix (if any) can be replaced with an arbitrary sequence (possibly empty) of lowercase letters. No other character of string `a` can be replaced. If it is possible to replace the asterix in `a` to obtain string `b`, then string `b` matches the pattern. If the string matches, return `true` else `false`. ``` For example: solve("code*s","codewars") = true, because we can replace the asterix(*) with "war" to match the second string. solve("codewar*s","codewars") = true, because we can replace the asterix(*) with "" to match the second string. solve("codewars","codewars") = true, because the strings already match. solve("a","b") = false solve("*", "codewars") = true ``` More examples in test cases. Good luck!
reference
from fnmatch import fnmatch def solve(a, b): return fnmatch(b, a)
Simple string matching
5bc052f93f43de7054000188
[ "Fundamentals" ]
https://www.codewars.com/kata/5bc052f93f43de7054000188
7 kyu
Given an integer `n`, find two integers `a` and `b` such that: ```Pearl A) a >= 0 and b >= 0 B) a + b = n C) DigitSum(a) + Digitsum(b) is maximum of all possibilities. ``` You will return the digitSum(a) + digitsum(b). ``` For example: solve(29) = 11. If we take 15 + 14 = 29 and digitSum = 1 + 5 + 1 + 4 = 11. There is no larger outcome. ``` `n` will not exceed `10e10`. More examples in test cases. Good luck!
reference
def solve(n): if n < 10: return n a = int((len(str(n)) - 1) * '9') b = n - a return sum([int(i) for i in (list(str(a)) + list(str(b)))])
Simple sum of pairs
5bc027fccd4ec86c840000b7
[ "Fundamentals", "Performance" ]
https://www.codewars.com/kata/5bc027fccd4ec86c840000b7
6 kyu
We have an integer array with unique elements and we want to do the permutations that have an element fixed, in other words, these permutations should have a certain element at the same position than the original. These permutations will be called: **permutations with one fixed point**. Let's see an example with an array of four elements and we want the permutations that have a coincidence **only at index 0**, so these permutations are (the permutations between parenthesis): ``` arr = [1, 2, 3, 4] (1, 3, 4, 2) (1, 4, 2, 3) Two permutations matching with arr only at index 0 ``` Let's see the permutations of the same array with only one coincidence at index **1**: ``` arr = [1, 2, 3, 4] (3, 2, 4, 1) (4, 2, 1, 3) Two permutations matching with arr only at index 1 ``` Once again, let's see the permutations of the same array with only one coincidence at index **2**: ``` arr = [1, 2, 3, 4] (2, 4, 3, 1) (4, 1, 3, 2) Two permutations matching with arr only at index 2 ``` Finally, let's see the permutations of the same array with only one coincidence at index **3**: ``` arr = [1, 2, 3, 4] (2, 3, 1, 4) (3, 1, 2, 4) Two permutations matching with arr only at index 3 ``` For this array given above (arr) : - We conclude that we have 8 permutations with one fixed point (two at each index of arr). - We may do the same development for our array, `arr`, with two fixed points and we will get `6` permutations. - There are no permutations with coincidences only at three indexes. - It's good to know that the amount of permutations with no coincidences at all are `9`. See the kata <a href="https://www.codewars.com/kata/shuffle-it-up">Shuffle It Up!!</a> In general: - When the amount of fixed points is equal to the array length, there is only one permutation, the original array. - When the amount of fixed points surpasses the length of the array, obvously, there are no permutations at all. Create a function that receives the length of the array and the number of fixed points and may output the total amount of permutations for these constraints. Features of the random tests: ``` length of the array = l number of fixed points = k 10 ≤ k ≤ l ≤ 9000 ``` See the example tests! Enjoy it!! Ruby versin will be released soon. #Note: This kata was published previously but in a version not well optimized.
reference
def fixed_points_perms(n, k): if k > n: return 0 if k == n: return 1 if k == 0: def subf(n): return 1 if n == 0 else n * subf(n - 1) + (- 1) * * n return subf(n) return fixed_points_perms(n - 1, k - 1) * n / / k
Shuffle It Up II
5bbecf840441ca6d6a000126
[ "Algorithms", "Performance", "Number Theory", "Recursion", "Fundamentals" ]
https://www.codewars.com/kata/5bbecf840441ca6d6a000126
6 kyu
This kata is an extension of "Combinations in a Set Using Boxes":https://www.codewars.com/kata/5b5f7f7607a266914200007c The goal for this kata is to get all the possible combinations (or distributions) (with no empty boxes) of a certain number of balls, but now, **with different amount of boxes.** In the previous kata, the number of boxes was always the same Just to figure the goal for this kata, we can see in the picture below the combinations for four balls using the diagram of Hasse: <a href="https://imgur.com/1Eft913"><img src="https://i.imgur.com/1Eft913.png?1" title="source: imgur.com" /></a> Points that are isolated represent balls that are unique in a box. k points that are bonded in an area respresent a subset that is content in a box. The unique square at the bottom of the diagram, means that there is only one possible combination for four balls in four boxes. The above next line with 6 squares, means that we have 6 possible distributions of the four balls in 3 boxes. These six distributions have something in common, all of them have one box with 2 balls. Going up one line more, we find the 7 possible distributions of the four balls in 2 boxes. As it is shown, we will have 7 distributions with: three balls in a box and only one ball in the another box, or two balls in each box. Finally, we find again at the top, an unique square, that represents, the only possible distribution, having one box, the four balls together in the only available box. So, for a set of 4 labeled balls, we have a total of 15 possible distributions (as always with no empty boxes) and with a maximum of 7 possible distributions for the case of two boxes. Prepare a code that for a given number of balls (an integer), may output an array with required data in the following order: ``` [total_amount_distributions, maximum_amount_distributions_case_k_boxes, k_boxes] ``` Just see how it would be for the example given above: ``` combs_non_empty_boxesII(4) == [15, 7, 2] # A total of 15 combinations #The case with maximum distributions is 7 using 2 boxes. ``` Features of the random tests: ``` 1 < n <= 1800 (python) 1 < n <= 1200 (ruby) ``` You may see the example tests for more cases. Enjoy it! Ruby version will be published soon.
reference
MAX_BALL = 2 + 1800 DP, lst = [None], [0, 1] for _ in range(MAX_BALL): DP . append([sum(lst), * max((v, i) for i, v in enumerate(lst))]) lst . append(0) lst = [v * i + lst[i - 1] for i, v in enumerate(lst)] combs_non_empty_boxesII = DP . __getitem__
Combinations in a Set Using Boxes II
5b61e9306d0db7d097000632
[ "Performance", "Algorithms", "Mathematics", "Machine Learning", "Combinatorics", "Number Theory" ]
https://www.codewars.com/kata/5b61e9306d0db7d097000632
5 kyu
You have a set of four (4) balls labeled with different numbers: ball_1 (1), ball_2 (2), ball_3 (3) and ball(4) and we have 3 equal boxes for distribute them. The possible combinations of the balls, without having empty boxes, are: ``` (1) (2) (3)(4) ______ ______ _______ ``` ``` (1) (2)(4) (3) ______ ______ ______ ``` ``` (1)(4) (2) (3) ______ ______ ______ ``` ``` (1) (2)(3) (4) _______ _______ ______ ``` ``` (1)(3) (2) (4) _______ _______ ______ ``` ``` (1)(2) (3) (4) _______ _______ ______ ``` We have a total of **6** combinations. Think how many combinations you will have with two boxes instead of three. You will obtain **7** combinations. Obviously, the four balls in only box will give only one possible combination (the four balls in the unique box). Another particular case is the four balls in four boxes having again one possible combination(Each box having one ball). What will be the reasonable result for a set of n elements with no boxes? Think to create a function that may calculate the amount of these combinations of a set of ```n``` elements in ```k``` boxes. You do no not have to check the inputs type that will be always valid integers. The code should detect the cases when ```k > n```, returning "It cannot be possible!". Features of the random tests: ``` 1 <= k <= n <= 800 ``` Ruby version will be published soon.
reference
# Stirling numbers of second kind # http://mathworld.wolfram.com/StirlingNumberoftheSecondKind.html # S(n,k)=1/(k!)sum_(i=0)^k(-1)^i(k; i)(k-i)^n from math import factorial as fact def combs_non_empty_boxes(n, k): if k < 0 or k > n: return 'It cannot be possible!' return sum([1, - 1][i % 2] * (k - i) * * n * fact(k) / / (fact(k - i) * fact(i)) for i in range(k + 1)) / / fact(k)
Combinations in a Set Using Boxes
5b5f7f7607a266914200007c
[ "Performance", "Algorithms", "Mathematics", "Machine Learning", "Combinatorics", "Number Theory", "Memoization" ]
https://www.codewars.com/kata/5b5f7f7607a266914200007c
5 kyu
Cheesy Cheeseman just got a new monitor! He is happy with it, but he just discovered that his old desktop wallpaper no longer fits. He wants to find a new wallpaper, but does not know which size wallpaper he should be looking for, and alas, he just threw out the new monitor's box. Luckily he remembers the width and the aspect ratio of the monitor from when Bob Mortimer sold it to him. Can you help Cheesy out? # The Challenge Given an integer `width` and a string `ratio` written as `WIDTH:HEIGHT`, output the screen dimensions as a string written as `WIDTHxHEIGHT`. **Note:** The calculated height should be represented as an integer. If the height is fractional, truncate it.
reference
def find_screen_height(width, ratio): a, b = map(int, ratio . split(":")) return f" { width } x { int ( width / a * b )} "
Find Screen Size
5bbd279c8f8bbd5ee500000f
[ "Fundamentals", "Strings" ]
https://www.codewars.com/kata/5bbd279c8f8bbd5ee500000f
7 kyu
<img src="https://i.imgur.com/ta6gv1i.png?1" title="weekly coding challenge" /> # Background I have stacked some cannon balls in a triangle-based pyramid. Like this, <img src="https://i.imgur.com/ut4ejG1.png" title="cannon balls triangle base" /> # Kata Task Given the number of `layers` of my stack, what is the total height? Return the height as multiple of the ball diameter. ## Example The image above shows a stack of 3 layers. ## Notes * `layers` >= 0 * approximate answers (within 0.001) are good enough --- *See Also* * [Stacked Balls - 2D](https://www.codewars.com/kata/stacked-balls-2d) * [Stacked Balls - 3D with square base](https://www.codewars.com/kata/stacked-balls-3d-square-base) * [Stacked Balls - 3D with triangle base](https://www.codewars.com/kata/stacked-balls-3d-triangle-base)
reference
def stack_height_3d(layers): return 1 + (layers - 1) * (2 / 3) * * 0.5 if layers else 0
Stacked Balls - 3D (triangle base)
5bbad1082ce5333f8b000006
[ "Mathematics", "Fundamentals" ]
https://www.codewars.com/kata/5bbad1082ce5333f8b000006
7 kyu
Alice, Samantha, and Patricia are relaxing on the porch, when Alice suddenly says: _"I'm thinking of two numbers, both greater than or equal to 2. I shall tell Samantha the sum of the two numbers and Patricia the product of the two numbers."_ She takes Samantha aside and whispers in her ear the sum so that Patricia cannot hear it. Then she takes Patricia aside and whispers in her ear the product so that Samantha cannot hear it. After a moment of reflection, Samantha says: **Statement 1:** _"Patricia cannot know what the two numbers are."_ After which Patricia says: **Statement 2:** _"In that case, I do know what the two numbers are."_ To which Samantha replies: **Statement 3:** _"Then I too know what the two numbers are."_ Your first task is to write a function `statement1(s)` that takes an `int` argument `s` and returns `True` if and only if Samantha could have made statement 1 if given the number `s`. You may assume that `s` is the sum of two numbers both greater than or equal to 2. Your second task is to write a function `statement2(p)` that takes an `int` argument `p` and returns `True` if and only if Patricia, when given the number `p`, could have made statement 2 after hearing Samantha make statement 1. You may assume that `p` is the product of two numbers both greater than or equal to 2 and that Patricia would not have been able to determine the two numbers by looking at `p` alone. Your third task is to write a function `statement3(s)` that takes an `int` argument `s` and returns `True` if and only if Samantha, when given the number `s`, could have made statement 3 after hearing Patricia make statement 2. Finally, it is to you to figure out what two numbers Alice was thinking of. Since there are multiple solutions, you must write a function `is_solution(a, b)` that returns `True` if and only if `a` and `b` could have been two numbers that Alice was thinking of. Hint: To get you started, think of what Samantha's first statement implies. Samantha knows that Patricia was not given the product of two primes. That means that the sum that Samantha was given cannot be written as the sum of two primes. Goldbach's conjecture stipulates that every even number greater than 3 can be written as the sum of two primes. Although Goldbach's conjecture has not yet been proven, you may assume that it has been verified for all numbers involved in the test cases here. So we know that the sum that Samantha was given must be odd. The only way to write an odd number as the sum of two primes is when one of the primes is 2, the only even prime. This means that the number given to Samantha is not the sum of 2 and a prime.
games
def is_prime(n): return n == 2 or n % 2 != 0 and all(n % k != 0 for k in xrange(3, root(n) + 1, 2)) def root(p): return int(p * * 0.5) def statement1(s): return not (s % 2 == 0 or is_prime(s - 2)) def statement2(p): return sum(statement1(i + p / i) for i in xrange(2, root(p) + 1) if p % i == 0) == 1 def statement3(s): return sum(statement2(i * (s - i)) for i in xrange(2, s / 2 + 1)) == 1 def is_solution(a, b): return statement1(a + b) and statement2(a * b) and statement3(a + b)
Bridge Puzzle
56f6380a690784f96e00045d
[ "Recursion", "Puzzles" ]
https://www.codewars.com/kata/56f6380a690784f96e00045d
4 kyu
# Background I have stacked some cannon balls in a square pyramid. Like this, <img src="https://i.imgur.com/6d5Kpva.png" title="cannon balls" /> # Kata Task Given the number of `layers` of my stack, what is the total height? Return the height as multiple of the ball diameter. ## Example The image above shows a stack of 4 layers. ## Notes * `layers` >= 0 * approximate answers (within 0.001) are good enough --- *See Also* * [Stacked Balls - 2D](https://www.codewars.com/kata/stacked-balls-2d) * [Stacked Balls - 3D with square base](https://www.codewars.com/kata/stacked-balls-3d-square-base) * [Stacked Balls - 3D with triangle base](https://www.codewars.com/kata/stacked-balls-3d-triangle-base)
reference
def stack_height_3d(layers): return layers and 1 + (layers - 1) / 2 * * 0.5
Stacked Balls - 3D (square base)
5bb493932ce53339dc0000c2
[ "Fundamentals" ]
https://www.codewars.com/kata/5bb493932ce53339dc0000c2
7 kyu
![Image of sliding puzzle](https://i.imgur.com/AUVWFOn.png) A [sliding puzzle](https://en.wikipedia.org/wiki/Sliding_puzzle) is a combination puzzle that challenges a player to slide (frequently flat) pieces along certain routes (usually on a board) to establish a certain end-configuration. Your goal for this kata is to write a function that produces a sequence of tile movements that solves the puzzle. ## Input An `n x n` array/list comprised of integer values ranging from `0` to `n^2 - 1` (inclusive), which represents a square grid of tiles. Note that there will always be one empty tile (represented by `0`) to allow for movement of adjacent tiles. ## Output An array/list comprised of any (but not necessarily all) of the integers from `1` to `n^2 - 1`, inclusive. This represents the sequence of tile moves for a successful transition from the initial unsolved state to the solved state. If the puzzle is unsolvable, return `null`(JavaScript, Java, PHP) or `None`(Python) or the vector `{0}` (C++). ## Test Example ```javascript let simpleExample = [ [ 1, 2, 3, 4], [ 5, 0, 6, 8], [ 9,10, 7,11], [13,14,15,12] ]; slidePuzzle(simpleExample); // [6,7,11,12] // TRANSITION SEQUENCE: [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 5, 0, 6, 8] [ 5, 6, 0, 8] [ 5, 6, 7, 8] [ 5, 6, 7, 8] [ 5, 6, 7, 8] [ 9,10, 7,11] -> [ 9,10, 7,11] -> [ 9,10, 0,11] -> [ 9,10,11, 0] -> [ 9,10,11,12] [13,14,15,12] [13,14,15,12] [13,14,15,12] [13,14,15,12] [13,14,15, 0] // NOTE: Your solution does not need to follow this exact sequence to pass ``` ```python simple_example = [ [ 1, 2, 3, 4], [ 5, 0, 6, 8], [ 9,10, 7,11], [13,14,15,12] ] slide_puzzle(simple_example) #[6,7,11,12] # TRANSITION SEQUENCE: [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 5, 0, 6, 8] [ 5, 6, 0, 8] [ 5, 6, 7, 8] [ 5, 6, 7, 8] [ 5, 6, 7, 8] [ 9,10, 7,11] -> [ 9,10, 7,11] -> [ 9,10, 0,11] -> [ 9,10,11, 0] -> [ 9,10,11,12] [13,14,15,12] [13,14,15,12] [13,14,15,12] [13,14,15,12] [13,14,15, 0] # NOTE: Your solution does not need to follow this exact sequence to pass ``` ```php $simpleExample = [ [ 1, 2, 3, 4], [ 5, 0, 6, 8], [ 9,10, 7,11], [13,14,15,12] ]; slidePuzzle($simpleExample); // [6,7,11,12] // TRANSITION SEQUENCE: [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 1, 2, 3, 4] [ 5, 0, 6, 8] [ 5, 6, 0, 8] [ 5, 6, 7, 8] [ 5, 6, 7, 8] [ 5, 6, 7, 8] [ 9,10, 7,11] -> [ 9,10, 7,11] -> [ 9,10, 0,11] -> [ 9,10,11, 0] -> [ 9,10,11,12] [13,14,15,12] [13,14,15,12] [13,14,15,12] [13,14,15,12] [13,14,15, 0] // NOTE: Your solution does not need to follow this exact sequence to pass ``` ## Technical Details - Input will always be valid. - The range of values for `n` are: `10 >= n >= 3` If you enjoyed this kata, be sure to check out [my other katas](https://www.codewars.com/users/docgunthrop/authored).
algorithms
from itertools import chain, combinations, accumulate from heapq import heappush, heappop def slide_puzzle(arr): def moveTargetTo(iX, i0, grid, target=None, lowLim=None): """ iX: index in the grid of the position to work on i0: blank index grid: current grid state target: value to place at iX lowLim: value index under which the tiles cannot be/go (mostly optimization to avoid searching for inde'xes from the beginning) """ if target is None: target = iX+1 # Default VALUE of the tile to move if lowLim is None: lowLim = iX # Default minimal index under iT = grid.index(target, lowLim) # Current position of the target tile xyX, xyT = divmod(iX,S), divmod(iT,S) # Coords converted to (x,y) format dV,dH = [b-a for a,b in zip(xyT,xyX)] # Moves to do to reach the iX position, in (x,y) format sV,sH = S * ((dV>0)-(dV<0)), (dH>0)-(dH<0) # "Amount to move", step by step, in each direction paths = [ list(accumulate([iT] + [sH]*abs(dH) + [sV]*abs(dV))), # Build the two possible direct paths (dH->dV or dV->dH) list(accumulate([iT] + [sV]*abs(dV) + [sH]*abs(dH))) ] path = next(filter(lambda p: not set(p) & forbid, paths)) # Peek the first one that is fully allowed (at least one always exists) for iT,iTnext in zip(path, path[1:]): forbid.add(iT) # Set up the constraint i0, grid = moveBlank(i0, iTnext, grid, lowLim) forbid.remove(iT) # Relax"-relax... don't do it..." i0, grid = gridSwapper(i0, iT, grid) # Final swap of blank and target movesToParadise.append(target) # Register the moves needed forbid.add(iX) # Archive iX as "definitively" done return i0, grid def conquerCorner(i0, grid, i1, i2, lowLim): v1, v2 = i1+1, i2+1, # Target values delta = i2-i1 # Step in idexes between i1 and i2 delta2nd = S if delta == 1 else 1 # Step in idexes in the orthogonal direction shifted2 = i2+delta2nd # Temporary targeted index i0, grid = moveTargetTo(i2, i0, grid, target=v1, lowLim=lowLim) # Place v1 at i2 for now forbid.remove(i2) # Unlock to avoid impossible moves i0, grid = moveTargetTo(shifted2, i0, grid, target=v2, lowLim=lowLim) # Place v2 next to v1, in the orthogonal direction forbid.remove(shifted2) # Unlock the temporary point i0, grid = moveBlank(i0, i1+2*delta2nd, grid, lowLim) # Try to move the blank away first (avoid to move v1 and v2 if they are correct) i0, grid = moveBlank(i0, i1, grid, lowLim) # Move the blank at the ideal position for final 2x2 rotation if grid[i2] == v1 and grid[shifted2] == v2: # The 3 tiles are still placed as expected/hoped for (blank IS): solve directly movesToParadise.extend([v1,v2]) for i in (i2,shifted2): # Makes the two actual swaps in the grid i0, grid = gridSwapper(i0, i, grid) else: # Occasionally, something might go "wrong" (v1 or v2 moved again), so resolve instead a 3x2 subgrid with A*, to get the 2 target tiles at the right place (note, at this point, we are sure that the 3 tiles are in the subgrid) subGrid_3x2 = {i1 + a*delta + b*delta2nd for a in range(2) for b in range(3)} # Grid to work on, in the appropriate orientation blocking = set(range(lowLim+2, linS)) - subGrid_3x2 - forbid # Tiles to block (only those that are still free at this point and not in the subgrid) (_,it1),(_,it2) = sorted((grid[i],i) for i in subGrid_3x2 if grid[i] in (v1,v2)) # Retrieve the index of each target cost = manhattan(it1, i1) + manhattan(it2, i2) # Cost based on the positions of v1 and v2 only def heuristic(cost, i, i0, grid): # Function updating the cost for each swap in A* delta1 = manhattan(i0, i1) - manhattan(i, i1) if grid[i] == v1 else 0 delta2 = manhattan(i0, i2) - manhattan(i, i2) if grid[i] == v2 else 0 c = cost + delta1 + delta2 return c forbid.update(blocking) # "Gendarmerie nationale, vos papiers siouplait..." i0, grid, seq = modifiedAStar(grid, i0, heuristic, cost, forbid) # Move the blank to the right position (just "ahead" of the target) forbid.difference_update(blocking) # Relax... movesToParadise.extend(seq) forbid.update({i1,i2}) # Block the two tiles that have been placed return i0, grid def moveBlank(i0, to, grid, lowLim): cost = manhattan(i0, to) # Cost only related to the distance between the blank and the targeted position heuristic = lambda _,i0,__,___: manhattan(i0, to) i0, grid, seq = modifiedAStar(grid, i0, heuristic, cost, forbid) # Move the blank to the correct position (just "ahead" of the target) movesToParadise.extend(seq) # Archive the moves return i0, grid def manhattan(i0, to): return sum( abs(b-a) for a,b in zip(divmod(i0,S),divmod(to,S)) ) # Distance between indexes def manhattan2(i, v): return sum( abs(b-a) for a,b in zip(divmod(i,S), divmod((v-1)%linS,S)) ) # Distance current index of v/expected position of v #----------------------------------------------------------------------------------------- grid = tuple(chain.from_iterable(arr)) # Linearized S,linS = len(arr), len(arr)**2 # Dimensions (square / linear) i0 = grid.index(0) # Initial position """ Check doability """ nInv = sum(a*b and a>b for a,b in combinations(chain.from_iterable(arr), 2)) # Number of inversions r0Bot = S - grid.index(0) // S # Row containing the 0 (1-indexed, from bottom) if S%2 and nInv%2 or not S%2 and not (nInv%2 ^ r0Bot%2): return None # Unsolvable! """ Divide and conquer, up to 3x2 rectangle remaining """ forbid = set() # MUTATED: Archive all the indexes already done ON THE LEFT part (no tneeded for the upper part) movesToParadise = [] # MUTATED: Moves applied to solve the puzzle for z in range(S-2): # Up to the two last rows... (z moving on the diagonal): for y in range(z, S-2): # Complete the current top line, until 2 squares are remaining (or 3 if that's the second to last row) iX = z*S + y i0, grid = moveTargetTo(iX, i0, grid) i0, grid = conquerCorner(i0, grid, iX+1, iX+2, iX+1) # Places those two values at the end of the row z lim = S*(z+1) for x in range(z+1,S-2): # Left column, going down, leaving the two last free. iX = x*S + z i0, grid = moveTargetTo(iX, i0, grid, lowLim=lim) # Complete the current first column, until 2 squares remains if z < S-3: # Place the two last squares on the column, unless they are for the last 3x2 grid ("z == S-3") i1, i2 = iX+S, iX+2*S i0, grid = conquerCorner(i0, grid, i1, i2, lowLim=lim) # Places those two tiles """ Solve the 3x2 remaining grid with A* """ lowLim = linS-S-3 # Last tile completed + 1 cost = sum( manhattan2(i, grid[i]) for i in range(linS)) # Initial cost def heuristic(cost, i, i0, grid): a,b,c,d = (manhattan2(i0, grid[i]), manhattan2(i, grid[i0]), # Costs in the candidate grid manhattan2(i0, grid[i0]), manhattan2(i, grid[i]) ) # Costs in the original grid return cost+a+b-c-d i0, grid, seq = modifiedAStar(grid, i0, heuristic, cost, forbid) movesToParadise.extend(seq) return movesToParadise def display(grid, msg='',force=False): if DEBUG or force: linS, S = len(grid), int(len(grid)**.5) if msg: print(msg) print('\n'.join(' '.join(map('{: >2}'.format, grid[i:i+S])) for i in range(0,linS,S)).replace(' 0',' X')) print('-'*S*2) def gridSwapper(i0, other, grid): a, b = (i0,other) if i0<other else (other,i0) nextGrid = grid[:a] + (grid[b],) + grid[a+1:b] + (grid[a],) + grid[b+1:] return other, nextGrid def modifiedAStar(grid, i0, heuristic, cost, forbid): """ "A*", but exit as soon as the end condition (cost==0) is reached, even if not the shortest path. Returns the moves needed to to this final situation. grid: linear version of the puzzle (as tuple). i0: position of the blank at the beginning. heuristic: function that computes the update the cost for each candidate grid. Call in the form: f(cost, i, i0, grid). cost: initial cost, has to reach 0 when the final configuration is reached. forbid: Set of forbidden positions (as linearized indexes). This set is copied right at the beginning to keep the source faithful. @RETURN: tuple: (i0 at the end, Final grid state (tuple), sequence of moves to reach that state) """ S = int(len(grid)**.5) linS = S**2 MOVES = (S, -S, 1, -1) # (down, up, right, left) q = [(cost, grid, i0, 1j, (-1,))] # (cost, current state (as tuple), i0, last move, ans ('-1' is dummy)) seens = set() forbidPos = set(forbid) # Use a copy while q and q[0][0]: cost, grid, i0, last, moves = heappop(q) seens.add(grid) for m in MOVES: i = i0+m if (m == -last or m==1 and i0%S==S-1 or m==-1 and not i0%S # Skip if: going back (opposite of the last move) or "wrapping" two rows ([i][-1] <-> [i+1][0])... or not (0 <= i < linS) or i in forbidPos): # ... or not inside the correct area or in the forbidden positions) continue _,cnd = gridSwapper(i0, i, grid) # Build the candidate (making the swap) if cnd not in seens: # Skip if already found cndCost = heuristic(cost, i, i0, grid) heappush(q, (cndCost, cnd, i, m, moves+(grid[i],)) ) if q: return q[0][2], q[0][1], q[0][-1][1:] # Outputs (without the initial -1 in the moves, used to simplify/fasten the executions) else: raise Exception(display(grid) or "Aha... That's not going well... (A* ran out of possibilities!)")
Sliding Puzzle Solver
5a20eeccee1aae3cbc000090
[ "Puzzles", "Genetic Algorithms", "Game Solvers", "Algorithms" ]
https://www.codewars.com/kata/5a20eeccee1aae3cbc000090
1 kyu
We want to obtain number ```π``` (```π = 3,1415926535897932384626433832795```) with an approximate fraction having a relative error of 1% ``` rel_error = (π - fraction_value) / π * 100 = ± 1 absolute_error = |± 1 / 100 * π| = 0.031416 ``` Try to get the used algorithm to obtain the approximate fraction, observing the process bellow: ``` 1/1 -----> 2/1 -----> 3/1 -----> 4/1 -----> 4/2 -----> 5/2 -----> 6/2 -----> 7/2 -----> 7/3 -----> 8/3 -----> 9/3 -----> 10/3 ----> 10/4 ----> 11/4 ----> 12/4 ----> 13/4 ----> 13/5 ----> 14/5 ----> 15/5 ----> 16/5 ----> 16/6 ----> 17/6 ----> 18/6 ----> 19/6 ``` ```|π - 19/6| = 0.02 < 0.031416``` So we obtain the fraction ```19/6``` (approximate to π) in ```23``` steps. Make the function ```approx_fraction()```, that receives a float (an irrational number) and a relative error (as percentage) as arguments. The function should output a list with the fraction as a string and the number of steps needed. Let's see some cases: ```python float_ = math.pi rel_error = 1 approx_fraction(float_, rel_error) == ['19/6', 23] float_ = math.pi rel_error = 0.01 approx_fraction(float_, rel_error) == ['289/92', 379] ``` Your code should handle negative floats. ```python degrees = 130 float_ = math.cos(math.pi*degrees/180) # (= -0.6427876096865394) rel_error = 0.001 approx_fraction(float_, rel_error) == ['-610/949', 1557] ``` If the float number does not have a decimal part, like this case: ```python float_ = math.sqrt(361) #(= 19) rel_error = 0.01 approx_fraction(float_, rel_error) == "There is no need to have a fraction for 19" float_ = math.log(1) rel_error = 0.01 approx_fraction(float_, rel_error) == "There is no need to have a fraction for 0" ``` Finally if the absolute difference with the given float and its integer part is less than 0.0000000001 (1* 10^-10), consider it as an integer ```python degrees = 45 float_ = math.tan(math.pi*degrees/180) # (= 0.9999999999999999) rel_error = 0.01 approx_fraction(float_, rel_error) == "There is no need to have a fraction for 1" ``` As irrational numbers, you will be given: 10-base logarithms, natural logarithms, trigonometric functions, square roots and nth-roots of numbers. Do not worry about values like ± ∞ (positive, negative infinity) or complex numbers. For python: There is no need to import the math library. Enjoy it!!
reference
import math def approx_fraction(target: float, rel_err_pct: float, eps: float = 1e-10) - > list[str, int] | str: if math . isclose(round(target), target, rel_tol=eps): return f'There is no need to have a fraction for { round ( target )} ' if target < 0: a, b = approx_fraction(- target, rel_err_pct) return [f'- { a } ', b] rel_err_pct /= 100 i = 0 n = d = q = 1 while not math . isclose(q, target, rel_tol=rel_err_pct): if q < target: n += 1 else: d += 1 q = n / d i += 1 return [f' { n } / { d } ', i]
Approximate Fractions
56797325703d8b34a4000014
[ "Fundamentals", "Mathematics", "Strings" ]
https://www.codewars.com/kata/56797325703d8b34a4000014
6 kyu
# A History Lesson The <a href=https://en.wikipedia.org/wiki/Pony_Express>Pony Express</a> was a mail service operating in the US in 1859-60. <img src="https://i.imgur.com/oEqUjpP.png" title="Pony Express" /> It reduced the time for messages to travel between the Atlantic and Pacific coasts to about 10 days, before it was made obsolete by the <a href=https://en.wikipedia.org/wiki/First_transcontinental_telegraph>transcontinental telegraph</a>. # How it worked There were a number of *stations*, where: * The rider switched to a fresh horse and carried on, or * The mail bag was handed over to the next rider # Kata Task `stations` is a list/array of distances (miles) from one station to the next along the Pony Express route. Implement the `riders` method/function, to return how many riders are necessary to get the mail from one end to the other. ## Missing rider In this version of the Kata a rider may go missing. In practice, this could be for a number of reasons - a lame horse, an accidental fall, foul play... After some time, the rider's absence would be noticed at the **next** station, so the next designated rider from there would have to back-track the mail route to look for his missing colleague. The missing rider is then safely escorted back to the station he last came from, and the mail bags are handed to his rescuer (or another substitute rider if necessary). `stationX` is the number (2..N) of the station where the rider's absence was noticed. # Notes * Each rider travels as far as he can, but never more than 100 miles. # Example GIven * `stations = [43, 23, 40, 13]` * `stationX = 4` So `S1` ... ... 43 ... ... `S2` ... ... 23 ... ... `S3` ... ... 40 ... ... `S4` ... ... 13 ... ... `S5` * Rider 1 gets as far as Station S3 * Rider 2 (at station S3) takes mail bags from Rider 1 * Rider 2 never arrives at station S4 * Rider 3 goes back to find what happened to Rider 2 * Rider 2 and Rider 3 return together back to Station S3 * Rider 3 takes mail bags from Rider 2 * Rider 3 completes the journey to Station S5 **Answer:** 3 riders <hr style="width:75%;margin-top:40px;margin-bottom:40px;height:1px;border:none;color:red;background-color:red;" /> *Good Luck.</br> DM.* --- See also * <a href=https://www.codewars.com/kata/the-pony-express>The Pony Express</a> * The Pony Express (missing rider)
algorithms
def riders(stations, lost): stations = stations[: lost - 1] + stations[lost - 2:] rider, dist = 1, 0 for i, d in enumerate(stations): rider += (dist + d > 100) + (i == lost - 2) dist = dist * (dist + d <= 100 and i != lost - 2) + d return rider
The Pony Express (missing rider)
5b204d1d9212cb6ef3000111
[ "Algorithms" ]
https://www.codewars.com/kata/5b204d1d9212cb6ef3000111
6 kyu
Count how often sign changes in array. ### result number from `0` to ... . Empty array returns `0` ### example ```javascript const arr = [1, -3, -4, 0, 5]; /* | elem | count | |------|-------| | 1 | 0 | | -3 | 1 | | -4 | 1 | | 0 | 2 | | 5 | 2 | */ catchSignChange(arr) == 2; ``` ~~~if:lambdacalc ### encodings purity: `LetRec` numEncoding: <span style="color: aqua">extended</span> `binaryScott` export constructors `nil, cons` for your `List` encoding * <span style="color: aqua">negative numbers</span> are allowed, encoded as the bit-complement of the encoding of their absolute value * e.g. `6 -> 011$ ; -6 -> 100$` * non-negative number encoding is unchanged * the normal invariant "MSB, if any, must be `1`" becomes "MSB must be `0`" for negative numbers * you can use positive, zero and negative number literals in your code * return value is a non-negative `Number`, in basic Binary Scott encoding ~~~
reference
def catch_sign_change(lst): count = 0 for i in range(1, len(lst)): if lst[i] < 0 and lst[i - 1] >= 0: count += 1 if lst[i] >= 0 and lst[i - 1] < 0: count += 1 return count
Plus - minus - plus - plus - ... - Count
5bbb8887484fcd36fb0020ca
[ "Fundamentals" ]
https://www.codewars.com/kata/5bbb8887484fcd36fb0020ca
7 kyu
## Description "John, come here, we have to talk about the order form. Although I was drunk yesterday, today is not fully awake, but why do they look so strange?" ``` [ {"tire":1,"steeringWheel":2,"totalPrice":31.56}, {"tire":5,"steeringWheel":1,"totalPrice":73.69} ] ``` "Oh, my boss, all of these are based on the list you gave me yesterday." "John, we sell the car parts, each order is the customer needs to be installed on a car. Have you ever seen a car with a wheel and two steering wheels? Or five tires of a car?" "Oh, my boss, all of these are based on the list you gave me yesterday." "Well, I was beaten by you. But don't you know I got drunk yesterday? I don't even know what I did yesterday. I thought you should know that a car has 4 wheels and 1 steering wheel." "I'm sorry, boss, I think our company is an innovative enterprise, will produce some unusual car. And the boss is always right is my belief." "Well, for your belief, I now order you to correct the number of tires and steering wheels for all orders, and calculate the correct total price." "Sorry, boss, I don't know their unit price, you give me a list of only those. These tires and steering wheel have different models, their price is not the same." "This is your job! Don't discuss anything with a drunken boss. The only thing I know now is that the end of the price of these tires is `.98`, the end of the unit price of the steering wheel is `.79`. Their prices are not less than $5, not more than $20. Your job is to figure out all the numbers, if you don't want to be fired!" ## Task Complete function `correctOrder()` that accepts a arguments `list`, it's an array that contains some objects of order form. Calculation of the tire and the steering wheel unit price, in accordance with the 4 tires and a steering wheel to calculate the total price, return the results of the calculation. The condition that we known: The unit price range of the tire and steering wheel is `5-20(5.79 <= ? <= 19.98)`; The unit price of the steering wheel is `always higher than the price of the tire`, but `the difference is less than $3`; You can assume that all test cases `have and only have` a correct answer. ## Example ``` list=[ {"tire":1,"steeringWheel":2,"totalPrice":31.56}, {"tire":5,"steeringWheel":1,"totalPrice":73.69}] correctOrder(list) should return: [ {"tire":4,"steeringWheel":1,"totalPrice":50.71}, {"tire":4,"steeringWheel":1,"totalPrice":61.71}] ```
games
def correct_order(orders): result = [] for o in orders: for t in range(5, 20): for s in range(t + 1, t + 4): if round((t + .98) * o["tire"] + (s + .79) * o["steeringWheel"], 2) == o["totalPrice"]: result . append({"tire": 4, "steeringWheel": 1, "totalPrice": round((t + .98) * 4 + (s + .79), 2)}) break else: continue break return result
T.T.T.47: The boss is always right
57be4f2e87e4483c800002ee
[ "Puzzles", "Games" ]
https://www.codewars.com/kata/57be4f2e87e4483c800002ee
6 kyu