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 |
|---|---|---|---|---|---|---|---|
To complete this kata you will have to finish a function that returns a string of characters which when printed resemble a Rubik's cube.
The function is named `cube`, and it has one integer parameter (formal argument) `n`, for the dimensions of the cube.
For example, when I call the function `cube(3)` it will return a string which when printed appears as so:
```
/\_\_\_\
/\/\_\_\_\
/\/\/\_\_\_\
\/\/\/_/_/_/
\/\/_/_/_/
\/_/_/_/
```
There are no spaces to the right of the cube edges (same above and below the cube), and it must work for all dimensions greater than, or equal to one (technically 1 x 1 x 1):
1 x 1 x 1
```
/\_\
\/_/
```
2 x 2 x 2
```
/\_\_\
/\/\_\_\
\/\/_/_/
\/_/_/
```
| algorithms | def cube(n):
top = "\n" . join(' ' * (n - i - 1) + '/\\' *
(i + 1) + '_\\' * n for i in range(n))
bottom = "\n" . join(' ' * i + '\\/' * (n - i) +
'_/' * n for i in range(n))
return top + '\n' + bottom
| Rubik's Cube Art | 6387ea2cf418c41d277f3ffa | [
"ASCII Art"
] | https://www.codewars.com/kata/6387ea2cf418c41d277f3ffa | 7 kyu |
<h2>Puzzle</h2>
<p>If you don't know who <a href="https://en.wikipedia.org/wiki/Where%27s_Wally%3F">Waldo</a> is, he's a nice guy who likes to be in crowded places. But he's also a bit odd as he always likes to hide in plain sight. Can you spot Waldo in the crowd?</p>
<h2>Task</h2>
<p>Given <code>crowd</code>, an array of strings of equal length, representing a crowded place, return an array with two integers representing the coordinates <code>[y, x]</code> where Waldo can be found (<code>[0, 0]</code> is top-left, <code>y</code> being the row and <code>x</code> being the column ).</p>
<h2>Examples</h2>
<p>We've spotted Waldo a couple of times in the past. Below is what we found out. Note that he's been in much more crowded places lately.</p>
<h4>#1 Waldo at the beach</h4>
<p><code>" " Air
" w " Air with a bird
" w " Air with a bird
"~~~~~~~~~~~~~" Sea
".~..~~.~~~..~" Waves on beach
"...P......P.." Beach with some people
"......P..P..." Beach with some people
"..PW........." Beach with Waldo and presumably a friend next to him
</code></p>
<p>Unredacted report: Waldo can be found at <code>[7, 3]</code>, wearing his usual outfit</p>
<h4>#2 Waldo visiting the Great Pyramid</h4>
<p><code>" " Air
" " Air
" _ " Top of pyramid
" _____ " Layer of pyramid
" _________ " Layer of pyramid
" B _______________ G GG " Ground layer of pyramid with several people, including Waldo
</code></p>
<p>Unredacted report: Waldo can be found at <code>[5, 2]</code>, wearing special clothes protecting him from the sun</p>
<h3>Hints</h3>
<p>- he isn't always wearing his usual clothes</p>
<p>- why is there more than one bird in the first example ...</p> | games | from collections import defaultdict
def find_waldo(crowd):
d = defaultdict(list)
for y, row in enumerate(crowd):
for x, c in enumerate(row):
if c . isalpha():
d[c]. append([y, x])
return next(v[0] for k, v in d . items() if len(v) == 1)
| Where's Waldo? | 638244fb08da6c61361d2c40 | [
"Puzzles",
"Strings",
"Arrays",
"Logic"
] | https://www.codewars.com/kata/638244fb08da6c61361d2c40 | 7 kyu |
You are given a string with three lowercase letters ( `pattern` ).
**Your Task**
Implement a function `find_matched_by_pattern(pattern)` that returns a predicate function, testing a string input and returning `true` if the string is matching the pattern, `false` otherwise.
A word is considered a match for a given pattern if the first occurrence of each letter of the pattern is found in the same order in the word. If a character in the pattern is duplicated, the same logic applies further.
The pattern will always be a string of size 3.
Example of use:
```python
predicate = find_matched_by_pattern('acs')
predicate('access') # True
predicate('sacrifice') # False
```
Examples of inputs/outputs:
```
Pattern: Word: Match:
acs access true
ascces false
scares false
vvl veturvel true
velivel false
bmb bomb true
babyboom false
``` | algorithms | def find_matched_by_pattern(pattern):
def f(s, p=pattern):
for c in s:
if c == p[0]:
p = p[1:]
elif c in p:
break
if not p:
return True
return False
return f
| Get match by pattern | 637d1d6303109e000e0a3116 | [
"Regular Expressions",
"Strings"
] | https://www.codewars.com/kata/637d1d6303109e000e0a3116 | 6 kyu |
# Context
The Explosive Ordinance Disposal Unit of your country has found a small mine field near your town, and is planning to perform a **controlled detonation** of all of the mines. They have tasked you to write an algorithm that helps them find **all safe spots in the area**, as they want to build a temporal base in the area where all workers can rest safely.
All mines they found are of a special kind, as they only release explosive charge in **four straight lines**, each pointing at a different cardinal point **(north, south, east and west)**. However, the charge stops spreading when it crosses a tree in its path because the charge is not strong enough to burn them.
In the following diagram, ```M``` represents a mine, ```C``` represents the explosive charge released after its detonation, and ```T``` are the trees in the area:
```
. . . . . . . . . . . . . .
. . . T . . . . . . T . . .
. . . . . . . . . . C . . .
. . T M . . . => . . T M C C C
. . . . . . . . . . C . . .
. . . . . . . . . . C . . .
. . . T . . . . . . T . . .
```
# Task
Write an algorithm that, given a mine field represented as an **array of arrays** of size ```M * N```, returns an **array of all safe positions** where workers can build their temporal base. As in the previous model, ```'M'``` represents mines, ```'T'``` represents trees, and ```'.'``` represents empty spaces where explosive charge can spread. The positions in the array **should be in "reading order"** (from left to right, and from up to down).
For example:
```
[
['.', '.', '.', '.', 'M'], . . . . M C C C C M
['.', 'M', '.', 'T', '.'], . M . T . C M C T C
['.', '.', 'T', '.', '.'], ==[represents]=> . . T . . ==[after explosion]=> . C T . C
['.', '.', 'M', '.', 'T'], . . M . T C C M C T
['.', '.', '.', '.', '.'] . . . . . . C C . .
]
```
This should return one of the two following arrays, depending on the language. Check sample test cases for more information. Also, **trees don't count as safe positions**.
- ```[(2,0), (2,3), (4,0), (4,3), (4,4)] //For Python```
- ```[[2,0], [2,3], [4,0], [4,3], [4,4]] //For JS and other languages```
Return an empty array if there are no safe positions.
# Note
Mines will not stop explosive charge from spreading as trees do, and explosive charge won't erase mines it finds in its path. **Make sure you never override any mines in the field.** | algorithms | def safe_mine_field(mine_field):
if mine_field:
h, w = len(mine_field), len(mine_field[0])
for i, row in enumerate(mine_field):
for j, x in enumerate(row):
if x == 'M':
for a, b in ((- 1, 0), (1, 0), (0, - 1), (0, 1)):
k, l = i + a, j + b
while 0 <= k < h and 0 <= l < w and 'M' != mine_field[k][l] != 'T':
mine_field[k][l], k, l = 'C', k + a, l + b
return [(i, j) for i, row in enumerate(mine_field) for j, x in enumerate(row) if x == '.']
| Controlled Detonation Safety | 63838c67bffec2000e951130 | [
"Arrays",
"Algorithms",
"Puzzles"
] | https://www.codewars.com/kata/63838c67bffec2000e951130 | 6 kyu |
Oh no!!
You dropped your interpreter!?
That didn't sound so good...
Write a function that returns the Nth fibonacci number.
The use of the character "(" and the words "while", "for" and "gmpy2" has been disabled (broken).
You may only use up to 1000 letters in your solution.
The use of one "(" is permited for the line "def fibo(..."
it will only exactly work in that line and only once.
feel free not to use it :)
For your convenience the recursion limit has been raised.
No test will be over 200 away from the last one starting at 0 and ending at around 5,000.
The fibonacci sequence is defined as:
```
fibonacci(0) = 0
fibonacci(1) = 1
fibonacci(n) = fibonacci(n-1) + fibonacci(n-2)
```
happy coding | games | import numpy
funny = numpy . matrix # Sorry
funny . __class_getitem__ = numpy . matrix
arr = funny[[[1, 1], [1, 0]]]
funny . __class_getitem__ = arr . astype
arr = funny[object]
funny . __class_getitem__ = lambda v: v[0, 1]
def fibo(n): return funny[arr * * n]
| Fibonacci With a Broken Interpreter | 637d054dca318e60ef4a3830 | [
"Puzzles",
"Restricted"
] | https://www.codewars.com/kata/637d054dca318e60ef4a3830 | 5 kyu |
Write a function that accepts a string consisting only of ASCII letters and space(s) and returns that string in block letters of 5 characters width and 7 characters height, with one space between characters.
```if:cpp
The string should be formatted in a way that shows the desired output via cpps' <code>std::cout</code> (see below for example).
<b>There's a preloaded <code>std::map\<char, std::vector\<std::string\>\> alpha</code> which you can use. Keys are lower case letters and the space.</b>
```
```if:javascript
The string should be formatted in a way that when passed to Javascripts' <code>console.log()</code> function shows the desired output (see below for example).
<b>There's a preloaded map called alpha which you can use. Keys are lower case letters and the space.</b>
```
```if:typescript
The string should be formatted in a way that when passed to TypeScripts' <code>console.log()</code> function shows the desired output (see below for example).
<b>There's a preloaded map called alpha which you can use. Keys are lower case letters and the space.</b>
```
```if:rust
The string should be formatted in a way that when passed to Rusts' <code>println!()</code> function shows the desired output (see below for example).
A preloaded hashmap `ALPHA: HashMap<char, [&str; 7]>` is provided, which maps each letter to an array of individual lines.
```
```if:java
The string should be formatted in a way that when passed to Javas' <code>System.out.println()</code> function shows the desired output (see below for example).
```
```if:ruby
The string should be formatted in a way that when passed to Rubys' <code>puts()</code> function shows the desired output (see below for example).
<b>There's a preloaded Hash map called ALPHA which you can use. Keys are lower case letters and the space.</b>
```
```if:python
The string should be formatted in a way that when passed to Pythons' <code>print()</code> function shows the desired output (see below for example).
<b>There's a preloaded dictionary called ALPHA which you can use. Keys are lower case letters and the space.
Test failures are reformatted for easier debugging with the preloaded function <code>unbleach()</code>.
</b>
```
```if:scala
The string should be formatted in a way that when passed to Scalas' <code>println</code> the function shows the desired output (see below for example).
<b>There's a preloaded Map[Char, String] called alpha which you can use. Keys are lower case letters and space.</b>
```
```if:kotlin
The string should be formatted in a way that when passed to Kotlins' <code>println()</code> function shows the desired output (see below for example).
<b>There's a preloaded hashMap called alpha which you can use. Keys are lower case letters and space.</b>
```
<ul>
<li>The block letters should consist of corresponding capital letters.</li>
<li>It's irrelevant whether input consists of lower or upper case letters.</li>
<li>Any leading and/or trailing spaces in input should be ignored.</li>
<li>Empty strings or such containing only spaces should return an empty string.</li>
<li>The remaining spaces (between letters and/or words) are to be treated as any other character. This means that there will be six spaces in output for a space in input, or a multiple of six, if there were more spaces - plus the one from preceding character!</li>
<li>Trailing spaces should be removed in the resulting string (and also in its' substrings!).</li>
<li>In order to facilitate debugging, test failure messages mangle the output: spaces are replaced with the bullet character <code>U+2022</code>, while end-of-line characters <code>\n</code> are visible.</li>
</ul>
```cpp
std::cout << blockPrint("heLLo WorLD");
```
```javascript
console.log(blockPrint("heLLo WorLD"));
```
```typescript
console.log(blockPrint("heLLo WorLD"));
```
```java
System.out.println(BlockLetterPrinter.blockPrint("heLLo WorLD"));
```
```ruby
puts(block_print('heLLo WorLD'))
```
```python
print(block_print('heLLo WorLD'))
```
```rust
println!(block_print("heLLo WorLD");
```
```scala
println(blockPrint("heLLo WorLD"))
```
```kotlin
println(blockPrint("heLLo WorLD"))
```
should result in an output that looks like this:
```
H H EEEEE L L OOO W W OOO RRRR L DDDD
H H E L L O O W W O O R R L D D
H H E L L O O W W O O R R L D D
HHHHH EEEEE L L O O W W W O O RRRR L D D
H H E L L O O W W W O O R R L D D
H H E L L O O W W W O O R R L D D
H H EEEEE LLLLL LLLLL OOO W W OOO R R LLLLL DDDD
```
As most of the characters can be printed in many different ways (think of Q, F or W), here is what they're expected to look like:
```
AAA BBBB CCC DDDD EEEEE FFFFF GGG H H IIIII JJJJJ K K L M M N N OOO PPPP QQQ RRRR SSS TTTTT U U V V W W X X Y Y ZZZZZ
A A B B C C D D E F G G H H I J K K L MM MM NN N O O P P Q Q R R S S T U U V V W W X X Y Y Z
A A B B C D D E F G H H I J K K L M M M N N O O P P Q Q R R S T U U V V W W X X Y Y Z
AAAAA BBBB C D D EEEEE FFFFF G GGG HHHHH I J KK L M M N N N O O PPPP Q Q RRRR SSS T U U V V W W W X Y Z
A A B B C D D E F G G H H I J K K L M M N N O O P Q Q Q R R S T U U V V W W W X X Y Z
A A B B C C D D E F G G H H I J K K L M M N NN O O P Q QQ R R S S T U U V V W W W X X Y Z
A A BBBB CCC DDDD EEEEE F GGG H H IIIII JJJJ K K LLLLL M M N N OOO P QQQQ R R SSS T UUU V W W X X Y ZZZZZ
```
<font color="gold"><i>Please leave a rating if you liked this kata!</i></font>
```if:python
After completing this kata you might want to check out the [\[code golf\]](https://www.codewars.com/kata/6391ead97f85a7bac7fd1c1b) version as well.
```
| algorithms | LETTERS = '''\
AAA BBBB CCC DDDD EEEEE FFFFF GGG H H IIIII JJJJJ K K L M M N N OOO PPPP QQQ RRRR SSS TTTTT U U V V W W X X Y Y ZZZZZ
A A B B C C D D E F G G H H I J K K L MM MM NN N O O P P Q Q R R S S T U U V V W W X X Y Y Z
A A B B C D D E F G H H I J K K L M M M N N O O P P Q Q R R S T U U V V W W X X Y Y Z
AAAAA BBBB C D D EEEEE FFFFF G GGG HHHHH I J KK L M M N N N O O PPPP Q Q RRRR SSS T U U V V W W W X Y Z
A A B B C D D E F G G H H I J K K L M M N N O O P Q Q Q R R S T U U V V W W W X X Y Z
A A B B C C D D E F G G H H I J K K L M M N NN O O P Q QQ R R S S T U U V V W W W X X Y Z
A A BBBB CCC DDDD EEEEE F GGG H H IIIII JJJJ K K LLLLL M M N N OOO P QQQQ R R SSS T UUU V W W X X Y ZZZZZ\
''' . split('\n')
def block_print(s):
return s . strip() and '\n' . join(" " . join(LETTERS[i][(c - 65) * 6:(c - 64) * 6 - 1] if c > 32 else " " * 5 for c in map(ord, s . strip(). upper())). rstrip() for i in range(7))
| Block Letter Printer | 6375587af84854823ccd0e90 | [
"Strings",
"ASCII Art",
"Algorithms"
] | https://www.codewars.com/kata/6375587af84854823ccd0e90 | 6 kyu |
Introduction
============
Not having to go to school or work on your birthday is always a treat, so when your birthday would have fallen on a weekend, it's really annoying if a leap year means you miss out. Some friends are discussing this and think they have missed out more than others, so they need your help.
The Challenge
=============
Given a list of friends, their dates of birth and the date of their conversation, work out who has had the most birthdays fall on a Saturday or Sunday up to and including the date of the conversation. If more than one friend shares that number of weekend birthdays, return the youngest. If the youngest shares their birthday with other friends, then any of the youngest will be accepted.
When counting weekend days, don't include the day on which they were born - after all, they wouldn't have been familiar with the concept of a weekend right then! Friends born on 29th February celebrate their birthdays on 28th February in non-leap years.
Example
=======
The friends are provided as a sequence of pairs containing their name and their date of birth in the format YYYY-MM-DD. The date of their conversation is provided in the similar format.
```python
most_weekend_birthdays([("Alice", "2010-11-10"), ("Bob", "2010-11-23")], "2022-12-31") ==> "Alice"
```
Alice has four birthdays falling on a weekend (Saturday in 2012 and 2018, Sunday in 2013 and 2019) compared to three for Bob (Saturday in 2013 and 2019, Sunday in 2014).
| algorithms | from dateutil . parser import parse
from dateutil . relativedelta import relativedelta
def most_weekend_birthdays(friends, conversation_date):
def func(args):
count, year, birthday = 0, 1, parse(args[1])
while (current := birthday + relativedelta(years=year)) <= today:
count += (current . weekday() >= 5)
year += 1
return count, birthday
today = parse(conversation_date)
return max(friends, key=func)[0]
| Weekend Birthdays | 6375e9030ac764004a036840 | [
"Date Time"
] | https://www.codewars.com/kata/6375e9030ac764004a036840 | 6 kyu |
You just started working at a local cinema, and your first task is to write a function that returns the **showtimes of a specific movie**, given its **length**. In order to make your job easier, you will work with **24-hour format** throughout this kata.
Your function receives three parameters, all of them being **integers**:
- `open` - Hour at which the cinema opens.
- `close` - Hour at which the cinema closes.
- `length` - Length of the movie, in minutes.
It must return an array of times, with each time being in the format `(hour, minute)`. For example, `(19, 30)` means 19:30, and `(2, 0)` means 02:00. **The last session in the array cannot end after the cinema closes.** Also, the times in the array must be sorted from earliest to latest.
There's also a **15-minute window** between a session's end and the beginning of the following one, in order to give enough time for users to take a seat.
For example, for a cinema opening at **13:00** and closing at **23:00** showing a **60-minute** movie, your function must return the following array:
```
>>> movie_times(13, 23, 60)
[(13, 0), (14, 15), (15, 30), (16, 45), (18, 0), (19, 15), (20, 30), (21, 45)]
```
Note that the cinema might close at times such as **02:00** or **03:00**, meaning examples like this must also work:
```
>>> movie_times(16, 3, 75)
[(16, 0), (17, 30), (19, 0), (20, 30), (22, 0), (23, 30), (1, 0)]
```
***IMPORTANT:*** For languages other than Python, **just return an array of arrays.** See sample test cases for more info on how to return the list of times.
***NOTE:** This kata isn't meant to be too challenging, so opening times for all tests will be **12:00** or later, and closing times will always be **6:00** or earlier.*
***NOTE 2:** Midnight will be represented as (0, 0) or 0:00 in this kata, instead of 24:00.*
Good luck! | algorithms | def movie_times(open, close, length):
if close <= 6 or close < open:
close += 24
r, t, u = [], open * 60, close * 60
while t + length <= u:
r . append((t / / 60 % 24, t % 60))
t += length + 15
return r
| Movie Showtimes | 6376bbc66f2ae900343b7010 | [
"Logic",
"Date Time"
] | https://www.codewars.com/kata/6376bbc66f2ae900343b7010 | 7 kyu |
## Puzzle
12 bits, some are sleeping, some are awake. They are all tired and yearn for some sleep. One of them has to stay awake while all others can go to sleep. Can you figure out which one stays awake?
### Hints
* _why exactly 12 bits? (perhaps there are realtime applications for this)_
* _fixed test cases will show some patterns and additional hints_ | games | def sleep(bits: str) - > str:
i = min(range(12), key=lambda i: (bits[i:] + bits[: i])[:: - 1])
return '0' * i + '1' + '0' * (11 - i)
| 12 Sleepy Bits | 63753f7f64c31060a564e790 | [
"Puzzles",
"Algorithms",
"Set Theory"
] | https://www.codewars.com/kata/63753f7f64c31060a564e790 | 6 kyu |
Given a `string`, your task is to count the number and length of arrow symbols in that string and return an `int` using the following rules:
- The string will only contain the characters `.`, `-`, `=`, `<`, `>`.
- An arrow must start with either `<` or `>`.
- Arrows are scored based on their length and direction, for example:
- (Left-facing arrows are scored as negative, while Right-facing arrows are positive)
- `> is scored as 1`
- `-> is scored as 2`
- `< is scored as -1`
- `<- is scored as -2`
- An arrow's tail (if it has one) must be entirely made up of either `-` or `=`. You cannot mix.
- So, `-->` would be a valid arrow of length 3, but `=->` would only count `->` as a part of the arrow.
- Additionally, arrows with a tail of `=` are scored twice as high as arrows with a tail of `-`, for example:
- `--> is scored as 3`
- `==> is scored as 6`
- `<= is scored as -4`
* Double-sided arrows, like `<->` or `<===>` are counted as `0`.
* `.` is an empty character and cannot be the tail of an arrow.
## Examples
```python
arrow_search('>.') # 1
arrow_search('<--..') # -3
arrow_search('><=><--') # -2
arrow_search('>===>->') # 11
``` | games | import re # regex is good, let's use it
def arrow_search(string: str) - > int:
return sum( # calculate sum of scores for each arrow
# using the below method:
len(arrow) # size of the arrow
# multiplied by +1/-1 based on direction
* ((">" in arrow) - ("<" in arrow))
* (2 if "=" in arrow else 1) # multiplied by 2 if it has a tail of "="
for arrow in re . findall( # for each arrow found
""" # using the below regex:
<?-+>? # arrow with "-" tail
| # or
<?=*>? # arrow with "=" tail
""", string, re . VERBOSE) # in the input string
)
| Finding Arrows in a String | 63744cbed39ec3376c84ff4a | [
"Strings"
] | https://www.codewars.com/kata/63744cbed39ec3376c84ff4a | 6 kyu |
In his book, _Gödel, Escher, Bach_, Douglas Hofstadter describes a sequence of numbers which begins:
```
1, 3, 7, 12, 18, 26, 35, 45, 56, 69, 83, 98 .. (sequence A)
```
It has the following property:
_**The sequence, together with its sequence of first differences (the differences between successive terms), lists all positive integers exactly once.**_
To illustrate this property, write down the first differences of the sequence `A`:
```
2, 4, 5, 6, 8, 9, 10, 11, 13, 14, 15 .. (sequence B)
```
and note that together, the sequences `A` and `B` list all positive integers.
To calculate more terms we can first extend the sequence `B`:
```
2, 4, 5, 6, 8, 9, 10, 11, 13, 14, 15, 16, 17, 19 ..
```
(We omit `18` as it occurs already in the sequence `A`). Then we can extend the sequence `A` by using the rule that `A(n) = A(n-1) + B(n-1)`:
```
1, 3, 7, 12, 18, 26, 35, 45, 56, 69, 83, 98, (98+16) ..
```
Write a function which will return the `n`th term of the sequence `A`.
For example:
```haskell
hof 0 = 1
hof 1 = 3
hof 2 = 7
```
etc.
In the tests, values of `n` up to
```haskell
100 000
```
```javascript
1 000 000
```
```csharp
1 000 000
```
```lambdacalc
1 000
```
```python
1_000_000
```
will be tested. | reference | from itertools import count
def hofs():
yield 1
xs, ys, n, y = count(1), hofs(), 1, None
while True:
x, y = next(xs), y or next(ys)
if x == y:
yield (n := n + next(xs))
y = None
else:
yield (n := n + x)
hofs_gen, hofs_cache = hofs(), []
def hof(n):
while len(hofs_cache) <= n:
hofs_cache . append(next(hofs_gen))
return hofs_cache[n]
| Hofstadter's Figure-Figure sequence | 636bebc1d446bf71b3f65fa4 | [
"Lists",
"Algorithms",
"Recursion",
"Performance"
] | https://www.codewars.com/kata/636bebc1d446bf71b3f65fa4 | 5 kyu |
This is a very common case of operations counting. However, time is money. Given a function called `operations` that receives an Integer argument `number > 0` and does mathematical operations with it. Division and subtraction, division by 2 while the number is even, subtraction by 1 while the number is odd; how many of these arithmetic operations are going to take place till 0? Can you count it and return the correct answer without timing out? Make sure your code is performance efficient because some numbers up to 99 ^ 9999 are going to be passed in as the function argument.
Hint:
The solution could be written in the form (n + m + (n - 1))
Example:
The number 12 returns 5:
1. 12 // 2 = 6
2. 6 // 2 = 3
3. 3 - 1 = 2
4. 2 // 2 = 1
5. 1 - 1 = 0
Five operations in total. | algorithms | def operations(x):
return x . bit_count() + x . bit_length() - 1
| Time Is Money (number of operations) | 636b03830ae6cd00388cd228 | [
"Algorithms"
] | https://www.codewars.com/kata/636b03830ae6cd00388cd228 | 6 kyu |
You are a security guard at a large company, your job is to look over the cameras. Finding yourself bored you decide to make a game from the people walking in a hallway on one of the cameras. As many people walk past the hallway you decide to figure out the minimum steps it will take before 2 people cross or come into contact with each other (assuming every person takes a step at the same time).
People are represented as arrows, ``<`` for a person moving left and ``>`` for a person moving right and ``-`` for an empty space
``A step represents a person moving forward one -, each person moves 1 step at the same time``
```
in this example the first people to come in contact with each other do it after 1 step
---><----
```
```
in this example the first people to come in contact with each other do it after 1 step
--->-<------->----<-
```
```
in the case that no people come in contact return -1
----<----->----
```
| games | import re
def contact(hallway):
pairs = re . findall('>-*<', hallway)
return min(map(len, pairs)) / / 2 if pairs else - 1
| Walking in the hallway | 6368426ec94f16a1e7e137fc | [
"Fundamentals",
"Strings",
"Puzzles",
"Algorithms"
] | https://www.codewars.com/kata/6368426ec94f16a1e7e137fc | 7 kyu |
In the [On-line Encyclopedia of Integer Sequences](https://oeis.org/) a sequence [A112382](https://oeis.org/A112382) which begins
```
1, 1, 2, 1, 3, 4, 2, 5, 1, 6, 7, 8, 3, 9, 10, 11, 12, 4, 13, 14, 2, 15, 16, 17, 18, 19, 5, 20, ..
```
is described.
It is a fractal sequence because it contains every positive integer and also contains a copy of itself as a proper subsequence - this can be seen by deleting the first occurrence of each number from the sequence. The remaining terms will be a copy of the original.
For example, deleting the first occurrence of each integer from the list above (replacing them with an `X`) gives:
```
X, 1, X, 1, X, X, 2, X, 1, X, X, X, 3, X, X, X, X, 4, X, X, 2, X, X, X, X, X, 5, X, ..
```
The remaining list begins:
```
1, 1, 2, 1, 3, 4, 2, 5,..
```
the same as the original.
The sequence is self-descriptive in that each element gives the number of first occurrences of integers (`X`s in the example above) that were removed just before it.
Write a function which will return the `n`th term of the sequence described above.
For example
```haskell
a112382 0 = 1
a112382 1 = 1
a112382 2 = 2
```
etc.
In the tests, values of `n` up to
```haskell
100 000
```
```lambdacalc
1 000
```
will be tested.
| reference | from itertools import count, islice
def sequence():
cnt, seq = count(1), sequence()
while 1:
yield next(cnt)
n = next(seq)
yield from islice(cnt, n - 1)
yield n
a112382 = list(islice(sequence(), 1_000_000)). __getitem__
| A self-descriptive fractal sequence | 6363b0c4a93345115c7219cc | [
"Algorithms",
"Lists",
"Number Theory",
"Recursion"
] | https://www.codewars.com/kata/6363b0c4a93345115c7219cc | 5 kyu |
# Back and Forth:
You are carrying boxes between 2 locations, to be easy, we call them `first` and `second`.
You will receive a list of numbers as input, called `lst`.
You are moving back and forth between `first` and `second`, carrying that amount of boxes to the other side.
You always start from `first`.
See the following:
```
You move from first to second.
v v
[1, 2, 3, 4]
^ ^
You move from second to first.
```
___
# How Many Boxes:
Before you carry the boxes, you have to have boxes there to carry, __and the boxes can be used more than once.__
In the above example, we have 2 boxes at `first` and 2 boxes at `second`, note as `(2, 2)`, and here is how it goes:
```
(2, 2), 1 box was moved to the second(right), get (1, 3)
(1, 3), 2 boxes were moved to the first(left), get (3, 1)
(3, 1), 3 boxes were moved to the second(right), get (0, 4)
(0, 4), 4 boxes were moved to the first(left), get (4, 0)
```
__If you have less than 2 boxes at any side, you will run out of boxes while carrying.__
Your task is to find out the `minimum amount` of boxes you need to have at each side, so you won't run out of boxes while carrying the boxes.
Return the minimum amount for each side in a tuple(or any similar data type in the language), first element is the amount for `first`, second element is the amount for `second`.
___
# Performance:
* 0 <= length of lst <= 100
* 0 <= element of lst <= 200, upper bound may be varied with different languages
As the numbers in random tests will get up to certain size(see above), solution with naive brute force approach will time out.
___
# Examples:
__Input -> Output__
```
[] -> (0, 0)
[0] -> (0, 0)
[3] -> (3, 0)
[0, 2] -> (0, 2)
[1, 2, 3, 4] -> (2, 2)
[4, 3, 2, 1] -> (4, 0)
[3, 0, 3] -> (6, 0)
[3, 1, 3] -> (5, 0)
``` | games | def minimum_amount(lst):
f = s = r1 = r2 = 0
for i, x in enumerate(lst):
if i % 2:
f, s = f + x, s - x
r2 = max(r2, - s)
else:
f, s = f - x, s + x
r1 = max(r1, - f)
return r1, r2
| Back and Forth: How Many for Each Side? | 63624a696137b6000ed726a6 | [
"Puzzles",
"Logic",
"Algorithms",
"Performance"
] | https://www.codewars.com/kata/63624a696137b6000ed726a6 | 6 kyu |
## Overview
This is a simple "chess themed" algorithmic puzzle - but you don't need to know anything about chess to solve it, other than 3 basic moves.
The game is played between two players who take turns moving a piece on the board: Player 1, **who always plays the first move,** and Player 2.
The game takes place on a 5x5 board, and **at all times there is only 1 single piece on the board - it is either a Rook, a Bishop, or a Queen.**
(Quick reminder: the Rook can move horizontally or vertically, the Bishop can move diagonally, the Queen can move horizontally or vertically or diagonally).
The winner is the Player who, on their turn, moves the current piece to any of the board's 4 corner squares.
Gameplay is simple - after a Player moves the current piece, they either:
- win the game, if they managed to move the current piece to any of the board's 4 corner squares.
- or, if they do not win on their turn, **the piece will automatically transform into the "next" piece according to the following repeating cyclic pattern, and the other Player then takes their turn (from the current position on the 5x5 board):**
```
repeating 3-cyclic pattern:
Rook ---> Bishop
^ /
\ v
Queen
```
Given the starting piece (Rook, Bishop, or Queen) and a starting location for the piece, **and assuming both players play optimally**, your goal is to determine whether Player 1 has a **guaranteed** win, a **guaranteed** loss, or
if the game will become an infinite never-ending **guaranteed** draw.
(For the purposes of this kata, "playing optimally" means that: [both Players will attempt to win the game, if there is any combination of moves that will allow them to do so, and conversely will avoid any move that can lead to them losing.](https://en.wikipedia.org/wiki/Combinatorial_game_theory))
---
## Inputs and Outputs
You will be given `starting_piece`, which is a `string`representing the piece that is on the board when the game starts, 1 of 3 possibilities:
- `'r'` representing the Rook
- `'b'` representing the Bishop
- `'q'` representing the Queen
You will also be given `starting_row` and `starting_column`, both are `ints` from `0` to `4` inclusive: for example `starting_row == 0` and `starting_column == 0` means that the piece starts in the top-left square of the 5x5 board.
We use standard "array row and column" indexing to encode the 5x5 board,
as represented in the diagram below:
```
'r=0, c=0' | 'r=0, c=1' | 'r=0, c=2' | 'r=0, c=3' | 'r=0, c=4' <--- row 0
'r=1, c=0' | 'r=1, c=1' | 'r=1, c=2' | 'r=1, c=3' | 'r=1, c=4'
'r=2, c=0' | 'r=2, c=1' | 'r=2, c=2' | 'r=2, c=3' | 'r=2, c=4'
'r=3, c=0' | 'r=3, c=1' | 'r=3, c=2' | 'r=3, c=3' | 'r=3, c=4'
'r=4, c=0' | 'r=4, c=1' | 'r=4, c=2' | 'r=4, c=3' | 'r=4, c=4' <--- row 4
^ ^
| |
column 0 column 4
```
You must return a `string`: `'win'`, `'lose'`, or `'draw'` depending on whether Player 1 (who always goes first) has a **guaranteed** win, loss, or draw.
Remember - to win the game, the current player just needs to move the current piece to any of the 4 corners: (0,0), (0,4), (4,0), (4,4).
---
## Examples
```
Example 1
_'r'_ _ _ <--- row 0
_ _ _ _ _
_ _ _ _ _
_ _ _ _ _
_ _ _ _ _
^
| column 1
```
In the above example game, the piece starts as a Rook, `'r'`, and in `starting_row == 0`, `starting_column == 1`.
Here Player 1 has a **guaranteed** winning strategy - the winning strategy
is: Player 1 moves the Rook from square (0,1) to corner square (0,0) or (0,4) and immediately wins the game, without even letting Player 2 play a single move.
So the expected answer for `starting_piece == 'r'`, `starting_row == 0`, `starting_column == 1` is `'win'`.
```
Example 2
_ _ _ _ _
_ _ _ _ _
_ _ _ _ _
_ _ _ _ _
_ _ _'b'_
```
In the above example game, the piece starts as a Bishop, `'b'`, and in `starting_row == 4`, `starting_column == 3`.
Unlike for the previous example, where Player 1 had a guaranteed win immediately, here Player 1 **can't win immediately on their first turn**.
So Player 1 needs to try to make a move with the Bishop so that Player 2 **can't win** when they take their turn (which will be with the Queen, since that is the piece "after" the `'b'` Bishop).
You should be able to analyse the various possibilities from here on ;)
---
## Similar katas
If you like chess katas, I highly recommend [Is the King in check ?](https://www.codewars.com/kata/5e28ae347036fa001a504bbe) by @trashy_incel
If you want a weirder and, more challenging, chess themed puzzle, check out [Evil genius game - Find the moving chess piece while blindfolded](https://www.codewars.com/kata/62e068c14129156a2e0df46a) by yours truly ;)
| games | tbl = {
'r': [
[1, 1, 1, 1, 1],
[1, 0, 1, 0, 1],
[1, 1, 1, 1, 1],
[1, 0, 1, 0, 1],
[1, 1, 1, 1, 1],
],
'b': [
[1, 0, - 1, 0, 1],
[0, 1, 0, 1, 0],
[- 1, 0, 1, 0, - 1],
[0, 1, 0, 1, 0],
[1, 0, - 1, 0, 1],
],
'q': [
[1, 1, 1, 1, 1],
[1, 1, 0, 1, 1],
[1, 0, 1, 0, 1],
[1, 1, 0, 1, 1],
[1, 1, 1, 1, 1],
]
}
# starting_piece: a string, either 'r', 'b', 'q'
# starting_row: an integer from 0 to 4 inclusive
# starting_column: an integer from 0 to 4 inclusive
def transforming_chess(starting_piece, starting_row, starting_column):
# you must return one of three strings:
# 'win' if Player 1 has a guaranteed win
# 'lose' if Player 1 is guaranteed to lose
# 'draw' if the game is a never-ending infinite draw
return ['draw', 'win', 'lose'][tbl[starting_piece][starting_row][starting_column]]
| Transforming Chess Piece Puzzle | 635d9b5c8f20017aa1cf2cf6 | [
"Puzzles",
"Games",
"Logic"
] | https://www.codewars.com/kata/635d9b5c8f20017aa1cf2cf6 | 7 kyu |
For this kata, you need to build two regex strings to paint dogs and cats blue.
Each of the given inputs will be a word of mixed case characters followed by either `cat` or `dog`. The string will be matched and replaced by the respective expressions.
`search` will be used to capture the given strings. For example:
```
grey dog
Fast cat
qWeRtY cat
blue dog
```
The other will be used to replace the first word with `blue`, but retaining the original animal:
```
grey dog => blue dog
Fast cat => blue cat
qWeRtY cat => blue cat
blue dog => blue dog
```
Good luck!
*P.S: both search and substitute must be returned as strings.* | games | search = ".+(?= (dog|cat))"
substitute = "blue"
| Painting Pets Blue (with regex) | 6361bdb5d41160000ee6db86 | [
"Strings",
"Regular Expressions"
] | https://www.codewars.com/kata/6361bdb5d41160000ee6db86 | 7 kyu |
You are a robot.
As a robot, you are programmed to take walks following a path.
The path is input to you as a string of the following characters where:
* `"^"` -> step up
* `"v"` -> step down
* `">"` -> step right
* `"<"` -> step left
For example, a valid path would look like:
```
"^^vv>><<^v>"
```
However, you are a robot that cannot understand this string of characters just by looking at it. You need detailed instructions on how to follow the path.
Your objective is to write a program to translate the input path to a set of detailed and readable instructions that even a robot like you could understand.
To do this, you must translate the previous example
```
"^^vvvv>><<^v>"
```
to a "line feed separated string" equivalent to:
```
Take 2 steps up
Take 4 steps down
Take 2 steps right
Take 2 steps left
Take 1 step up
Take 1 step down
Take 1 step right
```
Notice that groups of the same characters translate to one instruction only, telling you to take multiple steps.
Notes:
* The input path will NEVER contain invalid characters, only the four characters for the directions.
* The instruction lines are separated only by a newline (`"\n"`) character. This character is not present at the beginning of the first instruction line nor at the end of the last instruction line.
* An empty path with no characters should output a `"Paused"` string meaning that you, the robot, are not supposed to move anywhere and are in a paused state.
| games | from itertools import groupby
DIRS = {'^': 'up', 'v': 'down', '<': 'left', '>': 'right'}
def walk(path):
if not path:
return 'Paused'
steps = []
for k, g in groupby(path):
l = len(list(g))
steps . append(f"Take { l } step { 's' * ( l > 1 )} { DIRS [ k ]} ")
return '\n' . join(steps)
| You are a Robot: Translating a Path | 636173d79cf0de003d6834e4 | [
"Strings",
"Algorithms"
] | https://www.codewars.com/kata/636173d79cf0de003d6834e4 | 6 kyu |
<h1>The Task</h1>
<p><i>Please read the introduction below if you are not familiar with the concepts you are being presented in this task.</i></p>
<p>Given a root note and a color, return a list of notes that represent the chord.</p>
<p>Input arguments:
<li>
<ul>root: the root note of the chord; concatenation of the degree (C, D, E, F, G, A, B) and optionally the accidental (b, #)</ul>
<ul>color: the type of chord; (m, M, dim, aug); m -> minor chord, M -> major chord, dim -> diminished chord, aug -> augmented chord</ul>
</li>
</p>
<p>Result value:
<li>
<ul>chord: a list of 3 notes that make up a tertian triad (optional accidentals; bb, b, # or x); a tertian triad is a chord consisting of 3 notes that stacks intervals of <i>thirds</i>.</ul>
</li>
</p>
<h4>Implementation notes</h4>
<p>
<li>
<ul>Rather than using the accidentals ♯ and ♭, we'll use the following ASCII-friendly notation: bb (instead of ♭♭), b (instead of ♭), # (instead of ♯) and x (instead of ♯♯). </ul>
<ul>You will not be asked to deal with notes with more than 2 flats or sharps. For this reason, B# aug will be omitted from test cases, as its 5th is triply augmented (F#x or F###).
</ul>
<ul>You will need to use the correct degrees; enharmonic equivalence is not allowed in this kata. For instance: C m -> (C, Eb, G) OK, but (C, D#, G) not OK. The interval from C to D# is not a 3th, it's an augmented 2nd.
</ul>
</li>
</p>
<h1>Introduction</h1>
<p><i>This chapter explains some basic concepts from music theory and notation. Feel free to skip this if you have sufficient knowledge in this field.</i></p>
<details>
<summary>Musical Note</summary>
<p>On a modern piano there are 12 semitones in each octave. We call these the chromatic pitch class set. C major scale consist of 7 notes, each associated with a unique pitch class, and they correspond to the white keys on a piano.</p>
<p><style type="text/css">
.tg {border-collapse:collapse;border-color:#ccc;border-spacing:0;}
.tg td{background-color:#fff;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg th{background-color:#f0f0f0;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg .tg-0lax{text-align:left;vertical-align:top}
.tg .tg-fjir{background-color:#343434;color:#ffffff;text-align:left;vertical-align:top}
</style>
</p><table class="tg">
<thead>
<tr>
<th class="tg-0lax">Chromatic pitch classes</th>
<th class="tg-0lax">0</th>
<th class="tg-0lax">1</th>
<th class="tg-0lax">2</th>
<th class="tg-0lax">3</th>
<th class="tg-0lax">4</th>
<th class="tg-0lax">5</th>
<th class="tg-0lax">6</th>
<th class="tg-0lax">7</th>
<th class="tg-0lax">8</th>
<th class="tg-0lax">9</th>
<th class="tg-0lax">10</th>
<th class="tg-0lax">11</th>
</tr>
</thead>
<tbody>
<tr>
<td class="tg-0lax">Piano keys</td>
<td class="tg-0lax">W</td>
<td class="tg-fjir">B</td>
<td class="tg-0lax">W</td>
<td class="tg-fjir">B</td>
<td class="tg-0lax">W</td>
<td class="tg-0lax">W</td>
<td class="tg-fjir">B</td>
<td class="tg-0lax">W</td>
<td class="tg-fjir">B</td>
<td class="tg-0lax">W</td>
<td class="tg-fjir">B</td>
<td class="tg-0lax">W</td>
</tr>
<tr>
<td class="tg-0lax">C major scale</td>
<td class="tg-0lax">C</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">D</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">E</td>
<td class="tg-0lax">F</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">G</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">A</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">B</td>
</tr>
</tbody>
</table><p></p>
<p>Notice that the 5 black keys are not part of the scale. If we want to use such note, we need to take another note, and add sharps or flats to it until the pitch class matches the intended note.</p>
<p><style type="text/css">
.tg {border-collapse:collapse;border-color:#ccc;border-spacing:0;}
.tg td{background-color:#fff;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg th{background-color:#f0f0f0;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg .tg-j8c8{background-color:#343434;border-color:inherit;color:#ffffff;text-align:left;vertical-align:top}
.tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top}
.tg .tg-0lax{text-align:left;vertical-align:top}
</style>
</p><table class="tg">
<thead>
<tr>
<th class="tg-0pky">Chromatic pitch classes</th>
<th class="tg-0pky">0</th>
<th class="tg-0pky">1</th>
<th class="tg-0pky">2</th>
<th class="tg-0pky">3</th>
<th class="tg-0pky">4</th>
<th class="tg-0pky">5</th>
<th class="tg-0pky">6</th>
<th class="tg-0pky">7</th>
<th class="tg-0pky">8</th>
<th class="tg-0pky">9</th>
<th class="tg-0pky">10</th>
<th class="tg-0pky">11</th>
</tr>
</thead>
<tbody>
<tr>
<td class="tg-0pky">Piano keys</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
</tr>
<tr>
<td class="tg-0pky">C major scale</td>
<td class="tg-0pky">C</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">D</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">E</td>
<td class="tg-0pky">F</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">G</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">A</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">B</td>
</tr>
<tr>
<td class="tg-0lax">Ascending notes</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">C♯</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">D♯</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">F♯</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">G♯</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">A♯</td>
<td class="tg-0lax"></td>
</tr>
<tr>
<td class="tg-0lax">Descending notes</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">D♭</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">E♭</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">G♭</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">A♭</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">B♭</td>
<td class="tg-0lax"></td>
</tr>
</tbody>
</table><p></p>
<p>In fact, we can name each note in function of any degree. For example, we can use C as reference note. In practice, we'll never do this, but this shows how many times we can flatten or sharpen a note to get another note with the same degree.</p>
<p><style type="text/css">
.tg {border-collapse:collapse;border-color:#ccc;border-spacing:0;}
.tg td{background-color:#fff;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg th{background-color:#f0f0f0;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg .tg-j8c8{background-color:#343434;border-color:inherit;color:#ffffff;text-align:left;vertical-align:top}
.tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top}
.tg .tg-0lax{text-align:left;vertical-align:top}
</style>
</p><table class="tg">
<thead>
<tr>
<th class="tg-0pky">Chromatic pitch classes</th>
<th class="tg-0pky">0</th>
<th class="tg-0pky">1</th>
<th class="tg-0pky">2</th>
<th class="tg-0pky">3</th>
<th class="tg-0pky">4</th>
<th class="tg-0pky">5</th>
<th class="tg-0pky">6</th>
<th class="tg-0pky">7</th>
<th class="tg-0pky">8</th>
<th class="tg-0pky">9</th>
<th class="tg-0pky">10</th>
<th class="tg-0pky">11</th>
</tr>
</thead>
<tbody>
<tr>
<td class="tg-0pky">Piano keys</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
</tr>
<tr>
<td class="tg-0pky">C major scale</td>
<td class="tg-0pky">C</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">D</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">E</td>
<td class="tg-0pky">F</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">G</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">A</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">B</td>
</tr>
<tr>
<td class="tg-0lax">In function of note C</td>
<td class="tg-0lax">C</td>
<td class="tg-0lax">C♯</td>
<td class="tg-0lax">C♯♯</td>
<td class="tg-0lax">C♯♯♯</td>
<td class="tg-0lax">C♯♯♯♯</td>
<td class="tg-0lax">C♯♯♯♯♯</td>
<td class="tg-0lax">C♯♯♯♯♯♯</td>
<td class="tg-0lax">C♭♭♭♭♭</td>
<td class="tg-0lax">C♭♭♭♭</td>
<td class="tg-0lax">C♭♭♭</td>
<td class="tg-0lax">C♭♭</td>
<td class="tg-0lax">C♭</td>
</tr>
</tbody>
</table><p></p>
</details>
<details>
<summary>Musical Interval</summary>
<p><i>For this kata, only the m3, M3, dim5, p5 and aug5 are important.</i></p>
<p>An interval is the range from one note to another. Each interval has 2 properties; the degree interval and the pitch (class) interval. For instance from C to D♯; the degree interval is 2, because D is a second degree away from C (C being a first degree interval of itself), and the pitch class interval is 3, because these notes are 3 semitones or pitches away from eachother. We call the interval from C to D♯ an augmented second (aug2). Let's take another example, this time the interval C to E♭. The degree interval is 3, because E is a third degree away from C, and the pitch class interval is 3, because these notes are 3 semitones or pitches away from eachother. We call the interval from C to E♭ a minor third (m3). Notice that aug2 and m3 have the same number of semitones; these intervals are said to be enharmonic equivalents.</p>
<p>Let's add the intervals to the key of C for each of the chromatic notes in our previous table. The 1st, 4th and 5th are called perfect (p). Flattening a perfect interval is called a diminished interval (dim). Sharpening a perfect interval is called an augmented interval (aug). The other degrees, being the 2nd, 3th, 6th and 7th come in pairs of a minor interval (m) and a major interval (M). Flattening a minor interval is called a diminished interval (dim). Sharpening a major interval is called an augmented interval (aug).</p>
<p><style type="text/css">
.tg {border-collapse:collapse;border-color:#ccc;border-spacing:0;}
.tg td{background-color:#fff;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg th{background-color:#f0f0f0;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg .tg-j8c8{background-color:#343434;border-color:inherit;color:#ffffff;text-align:left;vertical-align:top}
.tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top}
.tg .tg-0lax{text-align:left;vertical-align:top}
</style>
<table class="tg">
<thead>
<tr>
<th class="tg-0pky">Chromatic pitch classes</th>
<th class="tg-0pky">0</th>
<th class="tg-0pky">1</th>
<th class="tg-0pky">2</th>
<th class="tg-0pky">3</th>
<th class="tg-0pky">4</th>
<th class="tg-0pky">5</th>
<th class="tg-0pky">6</th>
<th class="tg-0pky">7</th>
<th class="tg-0pky">8</th>
<th class="tg-0pky">9</th>
<th class="tg-0pky">10</th>
<th class="tg-0pky">11</th>
</tr>
</thead>
<tbody>
<tr>
<td class="tg-0pky">Piano keys</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
</tr>
<tr>
<td class="tg-0pky">C major scale</td>
<td class="tg-0pky">C (p1)</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">D (M2)</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">E (M3)</td>
<td class="tg-0pky">F (p4)</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">G (p5)</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">A (M6)</td>
<td class="tg-0pky"></td>
<td class="tg-0pky">B (M7)</td>
</tr>
<tr>
<td class="tg-0lax">Ascending notes</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">C♯ (aug1)</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">D♯ (aug2)</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">F♯ (aug4)</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">G♯ (aug5)</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">A♯ (aug6)</td>
<td class="tg-0lax"></td>
</tr>
<tr>
<td class="tg-0lax">Descending notes</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">D♭ (m2)</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">E♭ (m3)</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">G♭ (dim5)</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">A♭ (m6)</td>
<td class="tg-0lax"></td>
<td class="tg-0lax">B♭ (m7)</td>
<td class="tg-0lax"></td>
</tr>
</tbody>
</table></p>
</details>
<details>
<summary>Musical Chord</summary>
<p>A musical chord is a group of notes that together form a harmonic entity. There exist many kinds of chords, such as secundals, tertian chords, quartal chords, power chords and tone clusters. The chords we care about are tertian chords.</p>
<p>A tertian chord consists of stacking 3th intervals together. The common chords minor, major, diminished, augmented, dominant 7th, minor 7th, etc. are all tertian chords.</p>
<p>A triad is a chord consisting of 3 notes. This kata concerns the tertian triads: minor, major, diminished and augmented.</p>
<h4>Major Chord</h4>
<p>The major chord exists of a perfect 1st, a major 3th and perfect 5th. The intervals between consecutive notes are a major 3th and minor 3th.</p>
<p><style type="text/css">
.tg {border-collapse:collapse;border-color:#ccc;border-spacing:0;}
.tg td{background-color:#fff;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg th{background-color:#f0f0f0;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg .tg-j8c8{background-color:#343434;border-color:inherit;color:#ffffff;text-align:left;vertical-align:top}
.tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top}
.tg .tg-0lax{text-align:left;vertical-align:top}
</style>
<table class="tg">
<thead>
<tr>
<th class="tg-0pky">Chromatic pitch classes</th>
<th class="tg-0pky">0</th>
<th class="tg-0pky">1</th>
<th class="tg-0pky">2</th>
<th class="tg-0pky">3</th>
<th class="tg-0pky">4</th>
<th class="tg-0pky">5</th>
<th class="tg-0pky">6</th>
<th class="tg-0pky">7</th>
<th class="tg-0pky">8</th>
<th class="tg-0pky">9</th>
<th class="tg-0pky">10</th>
<th class="tg-0pky">11</th>
</tr>
</thead>
<tbody>
<tr>
<td class="tg-0pky">Piano keys</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
</tr>
<tr>
<td class="tg-0pky">Major chord</td>
<td class="tg-0pky">C</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">E</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">G</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
</tr>
<tr>
<td class="tg-0lax">Intervals</td>
<td class="tg-0lax">p1</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">M3</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">p5</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
</tr>
<tr>
<td class="tg-0lax">Intervals between notes</td>
<td class="tg-0lax">p1</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">M3</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">m3</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
</tr>
</tbody>
</table></p>
<h4>Minor Chord</h4>
<p>The minor chord exists of a perfect 1st, a minor 3th and perfect 5th. The intervals between consecutive notes are a minor 3th and major 3th.</p>
<p><style type="text/css">
.tg {border-collapse:collapse;border-color:#ccc;border-spacing:0;}
.tg td{background-color:#fff;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg th{background-color:#f0f0f0;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg .tg-j8c8{background-color:#343434;border-color:inherit;color:#ffffff;text-align:left;vertical-align:top}
.tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top}
.tg .tg-0lax{text-align:left;vertical-align:top}
</style>
<table class="tg">
<thead>
<tr>
<th class="tg-0pky">Chromatic pitch classes</th>
<th class="tg-0pky">0</th>
<th class="tg-0pky">1</th>
<th class="tg-0pky">2</th>
<th class="tg-0pky">3</th>
<th class="tg-0pky">4</th>
<th class="tg-0pky">5</th>
<th class="tg-0pky">6</th>
<th class="tg-0pky">7</th>
<th class="tg-0pky">8</th>
<th class="tg-0pky">9</th>
<th class="tg-0pky">10</th>
<th class="tg-0pky">11</th>
</tr>
</thead>
<tbody>
<tr>
<td class="tg-0pky">Piano keys</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
</tr>
<tr>
<td class="tg-0pky">Minor chord</td>
<td class="tg-0pky">C</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">E♭</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">G</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
</tr>
<tr>
<td class="tg-0lax">Intervals</td>
<td class="tg-0lax">p1</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">m3</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">p5</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
</tr>
<tr>
<td class="tg-0lax">Intervals between notes</td>
<td class="tg-0lax">p1</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">m3</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax">M3</td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
<td class="tg-0lax"></td>
</tr>
</tbody>
</table></p>
<h4>Diminished Chord</h4>
<p>The diminished chord exists of a perfect 1st, a minor 3th and diminished 5th. The intervals between consecutive notes are a minor 3th and minor 3th.</p>
<p><style type="text/css">
.tg {border-collapse:collapse;border-color:#ccc;border-spacing:0;}
.tg td{background-color:#fff;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg th{background-color:#f0f0f0;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg .tg-j8c8{background-color:#343434;border-color:inherit;color:#ffffff;text-align:left;vertical-align:top}
.tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top}
</style>
<table class="tg">
<thead>
<tr>
<th class="tg-0pky">Chromatic pitch classes</th>
<th class="tg-0pky">0</th>
<th class="tg-0pky">1</th>
<th class="tg-0pky">2</th>
<th class="tg-0pky">3</th>
<th class="tg-0pky">4</th>
<th class="tg-0pky">5</th>
<th class="tg-0pky">6</th>
<th class="tg-0pky">7</th>
<th class="tg-0pky">8</th>
<th class="tg-0pky">9</th>
<th class="tg-0pky">10</th>
<th class="tg-0pky">11</th>
</tr>
</thead>
<tbody>
<tr>
<td class="tg-0pky">Piano keys</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
</tr>
<tr>
<td class="tg-0pky">Diminished chord</td>
<td class="tg-0pky">C</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">E♭</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">G♭</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
</tr>
<tr>
<td class="tg-0pky">Intervals</td>
<td class="tg-0pky">p1</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">m3</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">dim5</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
</tr>
<tr>
<td class="tg-0pky">Intervals between notes</td>
<td class="tg-0pky">p1</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">m3</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">m3</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
</tr>
</tbody>
</table></p>
<h4>Augmented Chord</h4>
<p>The augmented chord exists of a perfect 1st, a major 3th and augmented 5th. The intervals between consecutive notes are a major 3th and major 3th.</p>
<p><style type="text/css">
.tg {border-collapse:collapse;border-color:#ccc;border-spacing:0;}
.tg td{background-color:#fff;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg th{background-color:#f0f0f0;border-color:#ccc;border-style:solid;border-width:1px;color:#333;
font-family:Arial, sans-serif;font-size:14px;font-weight:normal;overflow:hidden;padding:10px 5px;word-break:normal;}
.tg .tg-j8c8{background-color:#343434;border-color:inherit;color:#ffffff;text-align:left;vertical-align:top}
.tg .tg-0pky{border-color:inherit;text-align:left;vertical-align:top}
</style>
<table class="tg">
<thead>
<tr>
<th class="tg-0pky">Chromatic pitch classes</th>
<th class="tg-0pky">0</th>
<th class="tg-0pky">1</th>
<th class="tg-0pky">2</th>
<th class="tg-0pky">3</th>
<th class="tg-0pky">4</th>
<th class="tg-0pky">5</th>
<th class="tg-0pky">6</th>
<th class="tg-0pky">7</th>
<th class="tg-0pky">8</th>
<th class="tg-0pky">9</th>
<th class="tg-0pky">10</th>
<th class="tg-0pky">11</th>
</tr>
</thead>
<tbody>
<tr>
<td class="tg-0pky">Piano keys</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
<td class="tg-j8c8">B</td>
<td class="tg-0pky">W</td>
</tr>
<tr>
<td class="tg-0pky">Augmented chord</td>
<td class="tg-0pky">C</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">E</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">G♯</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
</tr>
<tr>
<td class="tg-0pky">Intervals</td>
<td class="tg-0pky">p1</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">M3</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">aug5</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
</tr>
<tr>
<td class="tg-0pky">Intervals between notes</td>
<td class="tg-0pky">p1</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">M3</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky">M3</td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
<td class="tg-0pky"></td>
</tr>
</tbody>
</table></p>
</details> | reference | from typing import Tuple
"""Gets the chord, given the root and color.
returns
----------
chord : tuple
the chord consisting of its notes -> (C, Eb, G), (F#, A, C#), ..
arguments
----------
root : str
the root note of the chord -> C, D, F#, Ab, ..
color : str
the color or type of chord -> m, M, dim, aug
"""
def chord_triad(root: str, color: str) - > Tuple:
notes = ('C', 'D', 'E', 'F', 'G', 'A', 'B')
shifts = ('bb', 'b', '', '#', 'x')
def is_major(note):
# checks if the third from the note is major
# that's true for C, F, and G only
return note in (0, 3, 4)
def third_note(note):
return notes[(note + 2) % len(notes)]
def minor(note, shift):
shift -= is_major(note)
return third_note(note) + shifts[shift]
def major(note, shift):
shift += not is_major(note)
return third_note(note) + shifts[shift]
triads = {
'm': (minor, major),
'M': (major, minor),
'dim': (minor, minor),
'aug': (major, major),
}
def get_note(root=root):
note, shift = root[0], root[1:]
return notes . index(note), shifts . index(shift)
def get_interval(i, root=root):
return triads[color][i](* get_note(root))
third = get_interval(0)
return (root, third, get_interval(1, third))
| Learning Chords Triads | 579f54c672292dc1a20001bd | [
"Logic",
"Fundamentals"
] | https://www.codewars.com/kata/579f54c672292dc1a20001bd | 6 kyu |
Frank, Sam and Tom build the ship. Then they went on a voyage. This was not a good idea, because the ship crashed on an iceberg and started sinking. Your job is to save the survivors.
## Details
The crash scheme looks like an ASCII picture
```
|-| |-| |-|
| | | | | |
~\-------|-|-|-|-|-|------/~
~~\ F | S | T /~~
~~~\----------------x---/~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
where:
- The letters F, S, and T are passengers;
- ~ is water;
- spaces are empty space;
- x - hit location. There can be several hits;
- any other signs are parts of the ship.
Before the collision, all passengers were inside confined spaces. After collision, water can only spread in orthogal directions (up, left, right and down, not diagonally, and not higher than ocean level), in empty spaces according to the picture:
```
|-| |-| |-| |-| |-| |-| |-| |-| |-|
| | | | | | | | | | | | | | | | | |
~\-------|-|-|-|-|-|------/~ ~\-------|-|-|-|-|-|------/~ ~\-------|-|-|-|-|-|------/~
~~\ F | S | ~ T /~~ ---> ~~\ F | S |~~~T /~~ ---> ~~\ F | S |~~~~~~/~~
~~~\----------------~---/~~~ ~~~\----------------~---/~~~ ~~~\----------------~---/~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~┴~~
```
People in the non-flooded spaces survived.
## Input
An image of the incident, presented as a 2D array of symbols. To aid in the rescue operation, it is translated into a picture. We can also assume that the first column of the picture contains only water and air and can be used to determine the ocean level.
## Output
The names of the survivors in the string. In the description example it would be `Frank Sam`. Unfortunately, Tom is gone.
## Examples
It's okay:
```
|==| |==| |==| |==| |==| |==|
__|__|__|__|__|__|_ __|__|__|__|__|__|_
__|___________________|___ __|___________________|___
__|__[]__[]__[]__[]__[]__[]__|_xxx __|__[]__[]__[]__[]__[]__[]__|_
~| F S | T /~ ---> ~| F S | T /~
~|______________x________________/~~ ~|______________~________________/~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
It's almost okay:
```
|==| |==| |==| |==| |==| |==|
__|__|__|__|__|__|_ __|__|__|__|__|__|_
__|___________________|___ __|___________________|___
__|__[]__[]__[]__[]__[]__[]__|___ __|__[]__[]__[]__[]__[]__[]__|___
~| F S | T /~ ---> ~|~~~~~~~~~~~~~~| T /~
~x____________x_|________________/~~ ~~____________~_|________________/~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
Something's wrong:
```
|-| |-| |-| |-| |-| |-|
| | | | | | | | | | | |
~\-------|-|-|-|-|-|------/~ ~\-------|-|-|-|-|-|------/~
~~\ F | S x T /~~ ---> ~~\ F |~~~~~~~~~~~~~~/~~
~~~\--------------x-----/~~~ ~~~\--------------~-----/~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
Not this time, Poseidon:
```
|-| |-| |-| |-| |-| |-|
| | | | | | | | | | | |
~\-x-----|-|-|-|-|-|-----xx~ ~\- -----|-|-|-|-|-|-----~~~
~~\ F x S | T /~~ ---> ~~\ F S | T /~~
~~~\--------------------/~~~ ~~~\--------------------/~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
This time:
```
|-| |-| |-| |-| |-| |-|
| | | | | | | | | | | |
~\-------|-|-|-|-|-|----xxx~ ~\-------|-|-|-|-|-|----~~~~
~~\ F | S x T /~~ ---> ~~\ F |~~~~~~~~~~~~~~/~~
~~~\--------------------/~~~ ~~~\--------------------/~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
Playing [Another card game](https://www.codewars.com/kata/633874ed198a4c00286aa39d):
```
|-| |-| |-| |-| |-| |-|
| | | | | | | | | | | |
~\-------|-|-|-|-|-|------/~ ~\-------|-|-|-|-|-|------/~
~~\ F S T | | /~~ ---> ~~\ F S T |~~~~~~~| /~~
~~~\---------xxx--------/~~~ ~~~\---------~~~--------/~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
<font color="yellow">Yellow submarine:</font>
```
~~~~~~~~~|---------x~~~~~~~~ ~~~~~~~~~|---------~~~~~~~~~
~~~~~~~~~| x~~~~~~~~ ~~~~~~~~~|~~~~~~~~~~~~~~~~~~
~\-------|---------|------/~ ~\-------|---------|------/~
~~\ F | S | T /~~ ---> ~~\ F | S | T /~~
~~~\--------------------/~~~ ~~~\--------------------/~~~
~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~
```
| reference | CREW = {"F": "Frank", "S": "Sam", "T": "Tom"}
NON_WATER_PROOF = [* CREW, ' ', 'x']
class Flotsam:
def __init__(self, pic):
self . pic = pic
self . sea_level = next(i for i, x in enumerate(pic) if '~' in x)
self . bottom = len(self . pic)
self . width = len(self . pic[0])
self . survivors = dict(* * CREW)
def show(self):
print("\n" . join(["" . join(row) for row in self . pic]))
def drown(self, person):
name = self . survivors . pop(person)
print(f" { name } drowned!")
def leak(self, i1, j1, i2, j2) - > bool:
a, b = self . pic[i1][j1], self . pic[i2][j2]
if a == '~' and b in NON_WATER_PROOF:
if b in self . survivors:
self . drown(b)
self . pic[i2][j2] = '~'
return True
else:
return False
def sink(self):
leaked = False
for i in range(self . sea_level, self . bottom):
for direction in (1, - 1):
for j in [* range(self . width)][:: direction]:
if j < self . width - 1:
leaked |= self . leak(i, j, i, j + 1)
leaked |= self . leak(i, j + 1, i, j)
if i > self . sea_level:
leaked |= self . leak(i, j, i - 1, j)
if self . sea_level <= i < self . bottom - 1:
leaked |= self . leak(i, j, i + 1, j)
self . show()
if leaked and self . survivors:
print(self . survivors)
self . sink()
def flotsam(pic):
o = Flotsam(pic)
o . show()
o . sink()
result = " " . join(o . survivors . values())
return (result)
| Flotsam | 635f67667dadea064acb2c4a | [
"Algorithms",
"ASCII Art"
] | https://www.codewars.com/kata/635f67667dadea064acb2c4a | 5 kyu |
Letter triangles
Similar to [Coloured triangles](https://www.codewars.com/kata/5a25ac6ac5e284cfbe000111).
But this one sums indexes of letters in alphabet.
<font size=5>Examples</font>
```
c o d e w a r s
c is 3
o is 15
15+3=18
18. letter in the alphabet is r
then append r
next is o d
sum is 19
append s
do this until you iterate through whole string
now, string is rsibxsk
repeat whole cycle until you reach 1 character
then return the char
output is l
codewars -> l
triangle -> d
```
```
C O D E W A R S
R S I B X S K
K B K Z Q D
M M K Q U
Z X B L
X Z N
X N
L
```
```
A B C D
C E G
H L
T
```
<font size=5>More examples</font>
```
youhavechosentotranslatethiskata -> a
cod -> k
yes -> b
hours -> y
circlecipher -> z
lettertriangles -> o
cod -> rs -> k
abcd -> ceg -> hl -> t
codewars -> rsibxsk -> kbkzqd -> mmkqu -> zxbl -> xzn -> xn -> l
```
**Note, if the sum is bigger than 26, then start over**
Input will always be lowercase letters. Random tests contains strings up to 30 letters.
| reference | from itertools import pairwise
def triangle(row):
return len(row) == 1 and row or triangle('' . join(chr((x + y + 15) % 26 + 97) for x, y in pairwise(map(ord, row))))
| Letter triangles | 635e70f47dadea004acb5663 | [
"Algorithms"
] | https://www.codewars.com/kata/635e70f47dadea004acb5663 | 6 kyu |
# Definition
A laser positioned `h` units from the ground on the left wall of a unit square (side = 1) will shoot a ray at an angle `a` with the x-axis and it will bounce around the walls until the ray has length `l`. Calculate the end coordinate of the laser ray to 3 decimal places and return it as a tuple `(x, y)`. All values are continuous (restrained to the max accuracy of the floating point in the language).
# Example
`a = 60°, h = 0.5, l = 1.8`
Visualization:
```
y
^
|
(0,1)
v__________________________________________ <(1,1)
| /\ |
| / \ |
| / \ |
| / \ |
| / \ |
|/ \ |
| \ |
| \ |
| \ |
| \ |
| \ . |
| \ / |
|___________________________________\/_____|________ > x
^ ^
origin (0,0) (1,0)
1st bounce happens at (0.2887, 1) with total length 0.5773
2nd bounce happens at (0.8660, 0) with total length 1.7320
3rd bounce doesn't happen because the ray runs hits the length before hitting the wall, at (0.9,0.0588)
Answer = (0.9, 0.0588)
```
# Constraints
```
0 <= h <= 1
0° <= a <= 90°
0 <= l <= 10^10
The angle will be given in degrees.
``` | games | from math import sin, cos, pi, radians
def laser_coord(h, a, l):
x, y = (l * cos(radians(a))) % 2, (h + l * sin(radians(a))) % 2
return (2 - x if x > 1 else x), (2 - y if y > 1 else y)
| Laser in a square room | 635d6302fdfe69004a3eba84 | [
"Mathematics",
"Geometry",
"Performance"
] | https://www.codewars.com/kata/635d6302fdfe69004a3eba84 | 6 kyu |
# Definition
The Fibonacci number can be extended non-linearly to a new number called `$P(n)$` with the recurrence relation `$\frac{1+P(n+2)}{1+P(n)}=1+P(n+1)$`, for `$n \geq 0$`. Find `$G(n)=P(n)\mod 9$` if `$P(0)=7$` and `$P(1)=31$`. Brute force will not work!
# Constraints
```
0 <= n <= 10^9
```
### Good luck! | algorithms | """
(1 + P(n+2)) = (1 + P(n+1)) * (1 + P(n))
(1 + P(n+3)) = (1 + P(n+2)) * (1 + P(n+1)) = (1 + P(n+1))**2 + (1 + P(n))
(1 + P(n+4)) = (1 + P(n+3)) * (1 + P(n+2)) = (1 + P(n+1))**3 + (1 + P(n))**2
(1 + P(n+5)) = (1 + P(n+1))**5 + (1 + P(n))**3
the exponents follow a fibonacci pattern,
so we can calculate them by raising the matrix ((0, 1), (1, 1)) to the nth power
to keep the variables small, we can use mod 6 because all 10 digit-powers mod 9 repeat every 6
"""
def G(n):
if n <= 1:
return [7, 4][n]
def mod_6(x): return x if x <= 6 else 6 + x % 6
a, b, c, d, pow1, pow2, n = 0, 1, 1, 1, 1, 1, n - 2
while n:
if n % 2 == 1:
pow1, pow2 = map(mod_6, (a * pow1 + b * pow2, c * pow1 + d * pow2))
n -= 1
else:
a, b, c, d = map(mod_6, (a * a + b * c, a * b + b *
d, a * c + c * d, d * d + b * c))
n / /= 2
return (pow(1 + 7, pow1, 9) * pow(1 + 31, pow2, 9) - 1) % 9
| Fibofamily #1 | 635d422dfdfe6900283eb892 | [
"Mathematics",
"Performance"
] | https://www.codewars.com/kata/635d422dfdfe6900283eb892 | 6 kyu |
## Overview
Imagine you have an `alphabet` of `n` distinct letters. There are of course `n!` permutations of this `alphabet`. For simplicity in this kata we will always use the first `n` letters from the uppercase alphabet `'ABCDEF...XYZ'`.
Now imagine that you are also given a list of "bad subpermutations", each of length `1 <= length <= n`.
For example if `n=7` then `alphabet = 'ABCDEFG'`, and you could be given `bads = ['BA','CF','EFA','DGFECB']`.
We shall say that an individual permutation of `alphabet` is **"totally good"** if - when viewed as a string - it does not contain **any of the given bad subpermutations as a substring**.
For a given `bads` list, how many of the `n!` permutations of `alphabet` are **totally good** ?
---
## Example
Let's take `n=3`, so `alphabet = 'ABC'`, and `bads = ['AB','CA']`.
Then, considering all `n! = 3! = 6` permutations of `'ABC'` as strings we have:
```python
'ABC' # contains 'AB' from bads as a substring
'ACB' # does not contain 'AB', does not contain 'CA', so: TOTALLY GOOD
'BAC' # TOTALLY GOOD
'BCA' # contains 'CA' from bads
'CAB' # contains 'CA', 'AB' from bads
'CBA' # TOTALLY GOOD
```
So for this given `bads` list, only `3` of the permutations of `alphabet` are totally good.
---
## Inputs and Outputs
You will be given an `alphabet` as a string of `n` distinct characters. For simplicity we will work with the first `n` letters from the uppercase alphabet, and with `3 <= n <= 26`, so a valid input might be the string `'ABCDEFGH'` with `n=8` for example.
You will also be given a list of strings, `bads`, representing the bad subpermutations as defined above.
To avoid boring input validation, you can be sure that:
- all elements in `bads` will be distinct, so e.g. `['ABC','ABC']` will **not** occur.
- none of the elements in `bads` list will contain repeated letters, e.g. a string like `'DDACB'` will never appear in `bads` since clearly it can't appear in any permutation of the **distinct** letters `'ABCDE'` for example.
- none of the elements in `bads` list will contain letters that are **not** in the input `alphabet` - for example, if `alphabet = 'ABCD'` then `bads` will **not** contain `'ABZ'` or `'ZYXK'` etc. since these have some or all of their letters that do not belong to `'ABCD'`.
You must return an integer, the count of how many of the `n!` permutations of `alphabet` are totally good, given the `bads` list as defined above.
---
## Performance requirements
I have tried to arrange the fixed tests in order of "tricky-ness" for your convenience while solving - hopefully you will fail them "in order" and understand what is going wrong step by step.
The basic tests will be all with small to medium sized alphabets, `n <= 8`, and with small `bads` lists with around `4` to `10` elements: **this is so that you can debug using brute force approach, if needed.**
The full tests will involve up to `n=26` alphabets and `bads` lists with up to `12` elements, such that brute force approaches will time out.
---
## Acknowledgements
Thanks to **@monadius**, **@Voile**, and **@dfhwze** for early testing, for suggestions and feedback, and to **@monadius** again for speeding up the reference solution.
---
## Similar katas
I thought of this kata while trying several approaches when working on these 2 difficult katas:
[The position of a digital string in a infinite digital string](https://www.codewars.com/kata/582c1092306063791c000c00)
[Permutation-free strings](https://www.codewars.com/kata/59b53be0bf10a4b39300001f)
It didn't help me directly, but it did up being a fun problem in its own right. If you get stuck on this, maybe working on the above 2 will help? Or if you solved this easily, maybe you'll enjoy those 2? | algorithms | from math import comb as nCk, factorial as fac
from itertools import combinations, chain, product
def totally_good(alphabet, bads):
# starting conditions
bads = [b for b in bads if not any(o != b and o in b for o in bads)]
n, t = len(alphabet), fac(len(alphabet))
# simple edge cases
if not bads:
return t
if any(1 for b in bads if len(b) == 1):
return 0
# combinatorics & string patterns
def count(group, n):
m, seen, start_cluster = 0, set(), product(
* [list(range(n - len(b) + 1)) for b in group])
for start_group in start_cluster:
word, c = ["*"] * n, False
for source_idx, target_idx in enumerate(start_group):
if c:
break
b = group[source_idx]
for i in range(len(b)):
if word[target_idx + i] != "*" and word[target_idx + i] != b[i]:
c = True
break
word[target_idx + i] = b[i]
word = '' . join(word)
if word not in seen and all(e in word for e in group) and len(set([c for c in word if c != '*'])) == len([c for c in word if c != '*']):
open = word . count("*")
m += fac(open)
seen . add(word)
return m
# set theory: inclusion/exclusion principle
history, cluster = {tuple(): t}, list(
chain(* [combinations(bads, i) for i in range(1, n)]))
for group in cluster:
if all(history[subgroup] for subgroup in combinations(group, len(group) - 1)):
history[group] = count(group, n)
t += history[group] * (- 1) * * len(group)
else:
history[group] = 0
return t
| Totally Good Permutations | 6355b3975abf4f0e5fb61670 | [
"Algorithms",
"Mathematics",
"Combinatorics",
"Discrete Mathematics",
"Strings",
"Set Theory",
"Number Theory"
] | https://www.codewars.com/kata/6355b3975abf4f0e5fb61670 | 3 kyu |
```
X X X
X X
𝙫𝙧𝙤𝙤𝙤𝙤𝙢! ===== O='`o
X X
X
X
```
A car is zooming through the streets! Maybe a bit too fast... Here come some more cars! Oh-No!!!
# Instructions:
You need to find, if given a multi-line string `road`, whether the speeding car will crash or not.
A `road` will always contain the following:
* The speeding car, O='`o, who's driver is too scared to turn.
* The other cars, signified by X's. They will always be heading in the same direction as the car.
The function returns `true`/ `True` if there are X's ahead of the speeding car in the same lane, but returns `false`/`False` if the speeding car has already passed all of the car's in the lane, or if its lane is empty.
# Examples:
These three will all return true (crash):
*
```
O='`o X
```
*
```
X O='`o X
```
*
```
XXXXXXX
XO='`oX
XXXXXXX
```
These three will all return false (no crash):
*
```
O='`o
```
*
```
X O='`o
```
*
```
XXXXXXX
XO='`o
XXXXXXX
```
| reference | # The speeding car: "O='`o"
# The other cars: "X"
def car_crash(road):
return "O='`oX" in road . replace(' ', '')
| Car Crash! ==== O='`o | 6359f0158f20011969cf0ebe | [
"Strings",
"Fundamentals"
] | https://www.codewars.com/kata/6359f0158f20011969cf0ebe | 7 kyu |
Given a string of numbers, you must perform a method in which you will translate this string into text, based on the below image:
<img src="https://upload.wikimedia.org/wikipedia/commons/thumb/7/73/Telephone-keypad2.svg/1024px-Telephone-keypad2.svg.png">
For example if you get `"22"` return `"b"`, if you get `"222"` you will return `"c"`. If you get `"2222"` return `"ca"`.
Further details:
- `0` is a space in the string.
- `1` is used to separate letters with the same number.
- always transform the number to the letter with the maximum value, as long as it does not have a `1` in the middle. So, `"777777" --> "sq"` and `"7717777" --> "qs"`.
- you cannot return digits.
- Given a empty string, return empty string.
- Return a lowercase string.
## Examples:
```python
"443355555566604466690277733099966688" --> "hello how are you"
"55282" --> "kata"
"22266631339277717777" --> "codewars"
"66885551555" --> "null"
"833998" --> "text"
"000" --> " "
``` | algorithms | import re
def phone_words(str):
ansd = {'0': ' ', '2': 'a', '22': 'b', '222': 'c', '3': 'd', '33': 'e', '333': 'f',
'4': 'g', '44': 'h', '444': 'i', '5': 'j', '55': 'k', '555': 'l', '6': 'm',
'66': 'n', '666': 'o', '7': 'p', '77': 'q', '777': 'r', '7777': 's', '8': 't', '88': 'u',
'888': 'v', '9': 'w', '99': 'x', '999': 'y', '9999': 'z'}
ans = ''
for i in re . findall('0|2{1,3}|3{1,3}|4{1,3}|5{1,3}|6{1,3}|7{1,4}|8{1,3}|9{1,4}', str):
ans += ansd[i]
return ans
| PhoneWords | 635b8fa500fba2bef9189473 | [
"Strings",
"Fundamentals"
] | https://www.codewars.com/kata/635b8fa500fba2bef9189473 | 6 kyu |
The police have placed radars that will detect those vehicles that exceed the speed limit on that road. If the driver's speed is ```10km/h to 19km/h``` above the speed limit, the fine will be ```100``` dollars, if it is exceeded by ```20km/h to 29km/h``` the fine will be ```250``` dollars and if it is exceeded by more than 30km/h the fine will be ```500``` dollars.
You will be provided with the speed limits of those roads with radar as a collection of speedlimits ```[90,100,110,120,....]``` and the speed of the driver will be the same on all roads and can never be negative and the amount of the fine will be accumulated **example** ```95km/h```.
**Example** ```(Speed=100, Signals=[110,100,80]-> 250)``` | algorithms | def speed_limit(скорость, сигналы):
штраф = 0
for и in сигналы:
if 10 <= скорость - и <= 19:
штраф += 100
if 20 <= скорость - и <= 29:
штраф += 250
if 30 <= скорость - и:
штраф += 500
return штраф
| Speed Limit | 635a7827bafe03708e3e1db6 | [
"Arrays"
] | https://www.codewars.com/kata/635a7827bafe03708e3e1db6 | 7 kyu |
This kata will return a string that represents the difference of two perfect squares as the sum of consecutive odd numbers.
Specifications:
• The first input minus the second input reveals the exact number of consecutive odd numbers required for the solution - you can check this in the examples below.
• The first input will always be larger than the second.
• All inputs will be valid so no need for error checking.
• Outputs will always be positive.
• Inputs will range between 0 and 200, (inclusive).
• In the returned string there are spaces before and after the plus sign, the minus sign and the equals sign but nowhere else.
Examples:
squaresToOdd(9, 5) --> "9^2 - 5^2 = 11 + 13 + 15 + 17 = 56"
squaresToOdd(10, 7) --> "10^2 - 7^2 = 15 + 17 + 19 = 51"
squaresToOdd(100, 98) --> "100^2 - 98^2 = 197 + 199 = 396"
squaresToOdd(100, 99) --> "100^2 - 99^2 = 199 = 199"
| games | def squares_to_odd(a, b):
return f' { a } ^2 - { b } ^2 = { " + " . join ( map ( str , range ( 2 * b + 1 , 2 * a , 2 )))} = { a * a - b * b } '
| Difference of perfect squares displayed as sum of consecutive odd numbers | 6359b10f8f2001f29ccf0db4 | [
"Algorithms",
"Mathematics"
] | https://www.codewars.com/kata/6359b10f8f2001f29ccf0db4 | 6 kyu |
# The task
You have to make a program capable of returning the sum of all the elements of all the triangles with side of smaller or equal than `$n+1$`. If you have not seen the previous Kata, [take a look](https://www.codewars.com/kata/63579823d25aad000ecfad9f).
# The problem
Your solution has to support `$0\leq n \leq 10^6$`. Beware, some sequences computed by hand for a few values of `n` may not have a very trivial solution, even if it looks like it. Brute-forcing will not work!
# The definition
An element `$a_{ij}$` where `$i$` is the column and `$j$` is the row can be defined as `$a_{ij}=\left(2j + i + 1\right)(-1)^{\frac{3j+3i-j(-1)^n+i(-1)^n}{2}}$` where `$0\leq j\leq i\leq n$`. The sum of all elements composing the triangle is defined by `$T(n):=\sum_{(i,j)\in T}a_{ij}$`. The answer for this Kata is returning `$sum(n):=\sum_{i=0..n}T(i)$`.
# Examples
For `n = 3`:
```
1 -2 3 -4 \
-4 5 -6 \__ 1-2+3-4-4+5-6+7-8-10 sums to: -18
7 -8 /
-10 /
1 2 3 \
-4 -5 \__ 1+2+3-4-5+7 sums to: 4
7 /
1 -2 \__ 1-2-4 sums to: -5
-4 /
1 __ sums to: 1
Therefore:
sum(3) = -18 +4 -5 +1 = -18
```
# Hints
* Euler transform
* Sums of powers
* Special case of #2
| games | def get_sum(n):
n, m = divmod(n, 2)
return - (n + 2 * m - 1) * (n + m + 1) * * 2
| Summation Triangle #3 | 63586460bafe0300643e2caa | [
"Mathematics",
"Performance"
] | https://www.codewars.com/kata/63586460bafe0300643e2caa | 6 kyu |
# The task
You have to make a program capable of returning the sum of all the elements of a triangle with side of size `$n+1$`. If you have not seen the previous Kata, [take a look](https://www.codewars.com/kata/6357825a00fba284e0189798).
# The problem
Your solution has to support `$0\leq n \leq 10^6$`. Brute-forcing will not work!
# The definition
A triangle element `$a_{ij}$` where `$i$` is the column and `$j$` is the row can be defined as `$a_{ij}=\left(2j + i + 1\right)\cdot(-1)^{2j+i}$` where `$0\leq j\leq i\leq n$`
# Examples
For `n = 2`:
```
1 -2 3 \
-4 5 \__ 1-2+3-4+5+7 sums to: 10
7 /
sum(2) = 10
```
For `n = 3`:
```
1 -2 3 -4 \
-4 5 -6 \__ 1-2+3-4-4+5-6+7-8-10 sums to: -18
7 -8 /
-10 /
sum(3) = -18
```
# Hints
* Euler transform
* Sums of powers
* Continuation of #1
| games | # see: https://oeis.org/A035608
def get_sum(n):
return (- 1) * * n * ((n := n + 1) * n + n - 1 - (n - 1) / / 2)
| Summation Triangle #2 | 63579823d25aad000ecfad9f | [
"Mathematics",
"Performance"
] | https://www.codewars.com/kata/63579823d25aad000ecfad9f | 6 kyu |
It's been a year since a mystery team famously drove a large broadcasting network to bankruptcy by managing to crack its incredibly popular game show [Hat Game](https://www.codewars.com/kata/618647c4d01859002768bc15), allowing them to win consistently.
A new network has decided to try and capitalize on the story, by creating yet another game show with entirely new rules and a creative new name...
# *Hat Game 2*
### The Rules
The game is played in three steps.
First, your team is gathered in a room, where you are shown the set of unique hats which will be used for the game. The number of different hats can change from game to game, so you need to be ready for anything.
Next, while the hats are cleared out of the room, your team has a chance to talk, make a strategy, and decide who will compete in the game. The only condition is that you may not have more people competing than there are unique hats. (So, if there are `10` unique kinds of hats, then you may have at most `10` competing team members).
Finally, all the competing members of your team are organised into a circle facing each other. Then a random assortment of the available hats (which your team saw earlier) will be brought out and placed on the heads of each contestant. No form of communication or information sharing is possible between contestants at this point. All contestants can merely see the hats of all other contestants, but they cannot see their own. Each contestant must then write down a guess of what kind of hat their own is. This guess is **not** seen by any other team members.
Your team wins the round if *any* of your team members manages to guess their own hat correctly. However, the game will be played over multiple rounds, so you need to come up with a strategy with your team which is *guaranteed* to win every single round.
***Note:** the hats your team saw earlier represented merely the different kinds of hat available. There is no guarantee that exactly one of each kind will be brought out. It could be that everyone receives the same kind of hat, or all different kinds, or any other combination.*
### Task
Write a function which will accept a list of the available kinds of hats, and will return a list of `strategies`. A `strategy` is a function that accepts a list of hats (strings), and returns a single hat (their guess). This is representative of one single player in your team, and how they will guess once they can see all the hats that their teammates are wearing (which will be used as the input).
Your team's list of strategies will be tested to ensure that it will always win the round (ie. that at least one team member will guess correctly).
Good luck!
#### Try some other riddle kata:
- [Hat Game](https://www.codewars.com/kata/618647c4d01859002768bc15)
- [Extreme Hat Game](https://www.codewars.com/kata/62bf879e8e54a4004b8c3a92)
- [Identify Ball Bearings](https://www.codewars.com/kata/61711668cfcc35003253180d) | games | def make_strategies(hats):
'''
We can ensure that one team member always wins, by
making sure that there is no overlap between the guesses
of each of our contestants. We do this by giving each
team member a unique number (from 0 to n-1). They are then
to assume that the total "sum" of hats modulo n (assigning
each hat an arbitrary value) will be equal to their number.
They can therefore determine what hat theirs must be by
seeing all the other hats, and make their guess. This means
that no matter what modulo a particular game produces, one
team member will be accounting for it.
This kata was inspired by this video, which also explains
the solution incredibly well:
https://www.youtube.com/watch?v=6hVPNONm7xw
'''
def sum_ind(i): return lambda seen: hats[(
i - sum(map(hats . index, seen))) % len(hats)]
return [sum_ind(i) for i in range(len(hats))]
| Hat Game 2 | 634f18946a80b8003d80e728 | [
"Riddles"
] | https://www.codewars.com/kata/634f18946a80b8003d80e728 | 5 kyu |
# The task
You have to make a program capable of returning the sum of all the elements of a triangle with side of size `$n+1$`.
# The problem
Your solution has to support `$0\leq n \leq 10^6$`. Brute-forcing will not work!
# The definition
A triangle element `$a_{ij}$` where `$i$` is the column and `$j$` is the row can be defined as `$a_{ij}=2j + i + 1$` where `$0\leq j\leq i\leq n$`
# Examples
For `n = 2`:
```
1 2 3 \
4 5 \__ 1+2+3+4+5+7 sums to: 22
7 /
sum(2) = 22
```
For `n = 3`:
```
1 2 3 4 \
4 5 6 \__ 1+2+3+4+4+5+6+7+8+10 sums to: 50
7 8 /
10 /
sum(3) = 50
```
# Hints
* Euler transform (Optional)
* Sums of powers
| games | def get_sum(n):
return (n + 1) * (n + 2) * (4 * n + 3) / / 6
| Summation Triangle #1 | 6357825a00fba284e0189798 | [
"Mathematics",
"Performance"
] | https://www.codewars.com/kata/6357825a00fba284e0189798 | 7 kyu |
## The simple task
You have to calculate k-th digit of π, knowing that:
```
π = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342...
```
Make sure to check the anti-cheat rules at the bottom.
## Examples
```
For k = 0:
3.14159265358979323...
^
```
```
For k = 6:
3.14159265358979323...
^
```
## Constraints
```
0 <= k < 10000
```
## Random test cases
```
1000 tests where 0 <= k < 10000
```
## Anti-cheat
* The only import allowed in Python is `math`
* The code length is limited to 2000 characters.
* Words `http`, `www`, `requests`, `gmpy2` and `search` are banned.
* `Eval` and `exec` are banned
* Only ASCII characters are allowed | algorithms | # for a proper solution: ...://bellard.org/pi/pi1.c
def pi_gen(limit):
q, r, t, k, n, l, cn, d = 1, 0, 1, 1, 3, 3, 0, limit
while cn != d + 1:
if 4 * q + r - t < n * t:
yield n
if d == cn:
break
cn, nr, n, q = cn + 1, 10 * (r - n * t), ((10 * (3 * q + r)) / / t) - 10 * n, q * 10
r = nr
else:
nr, nn, q, t, l, k = (2 * q + r) * l, (q * (7 * k) + 2 + (r * l)) / / (t * l), q * k, t * l, l + 2, k + 1
n, r = nn, nr
PI = pi_gen(10000)
PI = '' . join(map(str, PI))
def pi(n):
return int(PI[n])
| Calculate k-th digit of π (Pi) | 6357205000fba205ed189a52 | [
"Number Theory"
] | https://www.codewars.com/kata/6357205000fba205ed189a52 | 4 kyu |
You will be given a string that contains space-separated words. Your task is to group the words in this way:
- Group them by their beginning.
- Count how many letters they share in said group.
- Return the grouped words, ordered in ascending order, ONLY if their group size (or array length) is equal to the number of shared letters in each beginning.
See the following example:
<img src="data:image/jpeg;base64,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">
"a abc abcd abe hi hello" -> ```["a", "abc", "abcd", "abe"]```, ```["abc", "abcd", "ab"]```, ```["abc", "abcd"]```, ```["abcd"]```, ```["hi", "hello"]```
See how we treat these arrays:
```["a", "abc", "abcd", "abe"]``` -> The size of this array is 4, yet they only share in the beginning "a". (1 letter) they don't match.
```["abc", "abcd", "ab"]``` -> The size of this array is 3, and they only share in the beginning "ab" (2 letters) they don't match.
```["abc", "abcd"]``` -> The size of this array is 2, only share in the beginning "abc" (3 letters), they don't match.
```["abcd"]```-> The size of this array is 1, and they share in the beginning "abcd" (4 letters), they don't match.
```["hi", "hello"]```-> The size of this array is 2, and they share in the beginning "h" (1 letter), they don't match.
NOTES:
- If 2 or more of the same word appear in the string, you should treat them as different words:
Example: "is is" -> ```["is", "is"]``` -> The size of the array is 2, and both share the beginning "is" (2 letters) -> Should add it to the returned string.
- If in the String any word has an UpperCase Char, you should transform the String into LowerCase.
Example: "Or or" -> ```["or, "or"]```
- If none of the cases matches, return the list empty.
- Some answers may time out so efficiency is key! | reference | from collections import defaultdict
from itertools import chain
def letter(msg):
D = defaultdict(list)
for w in map(str . lower, msg . split()):
for i in range(len(w)):
D[w[: i + 1]]. append(w)
return sorted(chain . from_iterable(v for k, v in D . items() if len(k) == len(v)))
| [St]arting [St]ring | 635640ee633fad004afb0465 | [
"Strings"
] | https://www.codewars.com/kata/635640ee633fad004afb0465 | 5 kyu |
# Pedro's Urns
Pedro has `n` urns, numbered from `0` to `n-1`. Each urn `i` contains `r_i` red balls and `b_i` black balls.
Pedro removes a random ball from urn `i = 0` and places it in urn `i = 1`. For the next step, he removes a random ball from urn `i = 1` and places it inside urn `i = 2`. He repeats this process until he reaches the final `i = n-1` urn.
Your task is to return the probability that Pedro's **last ball is red**.
## Example
You will receive the number of urns and two arrays, one indicating the number of black balls in each i-th urn and the other, indicating the number of red balls in each i-th urn, where `0 <= i <= n-1` is the array index.
```
n = 2, b = [9, 4], r = [1, 5]
```
In the above example, there are `9` black balls and `1` red ball in urn `i=0` and `4` black balls and `5` red balls in urn `i=1`.
1. Pedro has `10%` chance of picking a red ball and `90%` chance of picking a black ball in urn `0`.
2. After placing his chosen ball in the last urn, `1`, he has `10% * 60% + 90% * 50% = 51%` chance of getting a red ball and `10% * 40% + 90% * 50% = 49%` chance of picking a black ball.
Therefore, for this example, the chance that Pedro retrieves a red ball from the last urn is `51%`
## Format
Return the probability that Pedro's last ball is red as a number between `0` and `1`: For example, `51%` must be returned as `0.51`.
Returned values will be tested for correctness to within a tolerance of `1e-6`.
## Ranges
```
1 <= b_i, r_i <= 5000
2 <= n <= 1000
``` | reference | from fractions import Fraction
def get_probability(n, nbs, nrs):
pr = Fraction(0)
for i, (nb, nr) in enumerate(zip(nbs, nrs)):
pr = (nr + pr) / (nb + nr + (i != 0))
return float(pr)
| Pedro's Urns | 6352feb15abf4f44f9b5cbda | [
"Probability"
] | https://www.codewars.com/kata/6352feb15abf4f44f9b5cbda | 6 kyu |
Given two Arrays in which values are the power of each soldier, return true if you survive the attack or false if you perish.
**CONDITIONS**
* Each soldier attacks the opposing soldier in the **same index** of the array. The survivor is the number with the **highest** value.
* If the value is the same they both perish
* If one of the values is empty(different array lengths) the non-empty value soldier survives.
* To survive the defending side must have **more** survivors than the attacking side.
* In case there are the **same number of survivors** in both sides, the winner is the team with the **highest initial attack power**. If the total attack power of both sides is the same return **true**.
* The initial attack power is the sum of all the values in each array.
**EXAMPLES**
```
attackers=[ 1, 3, 5, 7 ] defenders=[ 2, 4, 6, 8 ]
//0 survivors 4 survivors
//return true
attackers=[ 1, 3, 5, 7 ] defenders=[ 2, 4 ]
//2 survivors (16 damage) 2 survivors (6 damage)
//return false
attackers=[ 1, 3, 5, 7 ] defenders=[ 2, 4, 0, 8 ]
//1 survivors 3 survivors
//return true
| algorithms | def is_defended(attackers, defenders):
survivors = [0, 0]
for k in range(max(len(attackers), len(defenders))):
if len(attackers) <= k: # Empty attacker
survivors[1] += 1
elif len(defenders) <= k: # Empty defender
survivors[0] += 1
elif attackers[k] < defenders[k]:
survivors[1] += 1
elif attackers[k] > defenders[k]:
survivors[0] += 1
return survivors[0] < survivors[1] if survivors[0] != survivors[1] else sum(attackers) <= sum(defenders)
| Survive the attack | 634d0f7c562caa0016debac5 | [
"Arrays"
] | https://www.codewars.com/kata/634d0f7c562caa0016debac5 | 7 kyu |
Imagine a circle. To encode the word `codewars`, we could split the circle into 8 parts (as `codewars` has 8 letters):
<img src="data:image/png;base64,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" alt="" />
Then add the letters in a clockwise direction:
<img src="data:image/png;base64,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" alt="" />
Then remove the circle:
<img src="data:image/png;base64,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" alt="" />
If we read the result from left to right, we get `csordaew`.
Decoding is the same process in reverse. If we decode `csordaew`, we get `codewars`.
### Examples:
1.
```
encode "codewars" -> "csordaew"
decode "csordaew" -> "codewars"
```
2.
```
encode "white" -> "wehti"
decode "wehti" -> "white"
```
| reference | def encode(s):
return "" . join(s[((i + 1) / / 2) * (- 1) * * i] for i in range(len(s)))
def decode(s):
return s[:: 2] + s[1:: 2][:: - 1]
| Circle cipher | 634d0723075de3f97a9eb604 | [
"Ciphers",
"Algorithms"
] | https://www.codewars.com/kata/634d0723075de3f97a9eb604 | 7 kyu |
A matrix is "fat" when the sum of the roots of its "Widths" is greater than the sum of the roots of its "Heights". Otherwise, we call it as a "thin" matrix.
But what is the meaning of that?
A Width of a matrix is the sum of all the elements in a row.
Similarly, a Height of a matrix is the sum of all the elements in a column.
Difficult to assimilate? Let's look at an example.
```
The matrix [ [1, 3] , [5, 7] ] :
- Sum of rooted Widths: √(1+3) + √(5+7) = √4 + √12
- Sum of rooted Heights: √(1+5) + √(3+7) = √6 + √10
Since "width" is smaller than "height", we determine this matrix is "thin".
The matrix [ [1, 4, 7], [2, 5, 8], [3, 6, 9] ] :
- Sum of rooted Widths:√(1+4+7) + √(2+5+8) + √(3+6+9) = √12 + √15 + √18 = 11.57972565...
- Sum of rooted Heights: √(1+2+3) + √(4+5+6) + √(7+8+9) = √6 + √15 + √24 = 11.22145257...
Since "height" is smaller than "width", we determine this matrix is "fat".
```
***TASK:
Your task is to return "thin", "fat" or "perfect" depending on the results obtained.***
NOTES:
- All matrices will be squared
- In case that both sums are equal, the matrix will be considered as "perfect".
- DON'T round the roots... every digit matters ;)
***Since the results of the roots may have a slight variation, to determine that a matrix is "perfect", I suggest you use an approximate error of 1E- 10.***
- If a Width or a Height is negative, return None
| algorithms | def root(M):
return sum(sum(r) * * .5 for r in M)
def thin_or_fat(M):
w, h = root(M), root(zip(* M))
if not any(isinstance(v, complex) for v in (w, h)):
return "perfect" if abs(w - h) < 1e-10 else "fat" if w > h else "thin"
| Matrix Weight | 6347f9715467f0001b434936 | [
"Matrix"
] | https://www.codewars.com/kata/6347f9715467f0001b434936 | 7 kyu |
## Overview
One of the most remarkable theorems in basic graph theory is [Cayley's formula](https://en.wikipedia.org/wiki/Cayley%27s_formula) which states that there are `$n^{n-2}$` trees on `$n$` labeled vertices.
One of the most ingenious ways of proving this was discovered by Heinz Prüfer who showed that each such labeled tree can be **uniquely** encoded as a sequence of length `$n-2$` using `$n$` symbols. Thus there are `$n^{n-2}$` such **Prüfer sequences**, one for each labeled tree.
For example, the sequence `[4,2,3,2]` of length `4` encodes **one and only one** of the possible trees that can be formed with the `n = 4 + 2 = 6` labeled vertices `{1,2,3,4,5,6}`. You can discover what the corresponding tree looks like in the examples below.
In this kata, you will write 2 functions - `tree_to_prufer` and `prufer_to_tree` - that will take a given labeled tree and determine its Prüfer sequence, and take a Prüfer sequence and reconstruct the **unique** labeled tree that it represents.
**Please note that in this kata, the vertex labeling begins with 1 rather than 0: this is so that the results agree with all of the available mathematical resources on the internet, for your convenience.**
**Also, all tests will involve trees with `n >= 3` vertices.**
---
## Part 1 - How to encode a labeled tree to its Prüfer sequence
**Pseudocode:**
Given a labeled tree on `n` vertices, labeled from `{1,2,3,...,n}`, its Prüfer sequence is found as follows:
- Find the leaf with the lowest label value; let's call it leaf `l`.
- Remove this leaf, `l`, from the tree and add **the label of the only vertex adjacent to `l` to the current growing Prüfer sequence**.
- Repeat these steps until the Prüfer sequence is of length `n-2`.
**Example:**
```python
# >> Labeled tree on 6 vertices, labeled from 1 to 6:
#
# 1 --- 4 --- 2 --- 3 --- 5
# /
# /
# 6
#
# This tree will be encoded as the following dict of sets:
#
# example_tree = { 1:{4}, 2:{3,4,6}, 3:{2,5}, 4:{1,2}, 5:{3}, 6:{2} }
#
# So in the above, you can read 3:{2,5} as follows:
# "Vertex 3 is connected to vertex 2 and to vertex 5" etc.
```
Performing the Pseudocode explained above, we obtain the following results:
1. The leaf `l` with lowest label is `1`; we remove it from the tree and add the label of the vertex adjacent to `1`, which is `4`, to our growing Prüfer sequence.
2. Now the leaf `l` with lowest label is `4`; we remove it and add the label of the vertex adjacent to `4`, which is `2`, to our growing Prüfer sequence.
3. Now the leaf `l` with lowest label is `5`; we remove it and add the label of the vertex adjacent to `5`, which is `3`, to our growing Prüfer sequence.
4. Now the leaf `l` with lowest label is `3`; we remove it and add the label of the vertex adjacent to `3`, which is `2`, to our growing Prüfer sequence.
5. Our Prüfer sequence is now of length `n-2 = 6-2 = 4` so we stop. The final result is therefore the Prüfer sequence `[4,2,3,2]` for this labeled tree.
**Inputs and Outputs:**
For the `tree_to_prufer` function, you will be passed a `dict` of `set` s that represents a valid labeled tree via its adjacency information. **The trees will always have `n >= 3` vertices.**
In other words, if two labelled vertices, `u` and `v`, are connected in the tree then the input `dict` will contain `{ ..., u: {...,v, ...} , ... , v:{ ..., u, ...} , ... }`.
Remember, the vertices **will always be labeled starting from 1 up to n**, which gives a total of `n` vertices.
For your `tree_to_prufer` function, you must return a `list` of `integers` representing the Prüfer sequence of the input tree. If your algorithm is correct, this list will be of length `n-2` where `n` is the number of vertices in the input tree. The `integers` you can use range from `1` to `n` since these are the `n` distinct labels used in the tree.
**Note that the same integer may appear multiple times in a given Prüfer sequence (as in the example `[4,2,3,2]`).**
---
## Part 2 - How to decode a Prüfer sequence to its labeled tree
**Pseudocode:**
Given a Prüfer sequence of length `n-2`, its corresponding labeled tree is found as follows:
- Take a set, `S`, of all labels from `1` to `n`: `{1,2,3,...,n}`
- Find the current smallest label, `s`, in `S` that **does not** appear in the **current** Prüfer sequence.
- Remove `s` from the set `S`.
- Take the first element, `p`, of the **current** Prüfer sequence.
- Remove `p` from the **current** Prüfer sequence.
- Create an edge in the tree between the vertices `s` and `p`.
- Repeat until there are only `2` labels remaining in the set `S`.
- Create an edge in the tree between these last `2` remaining labeled vertices.
**Example:**
Let's work backwards from the same example from Part 1: we start with the Prüfer sequence `[4,2,3,2]`. Since `n-2 = 4` we have that `n=6`.
The set, `S`, starts as `S = {1,2,3,4,5,6}`.
1. The smallest label, `s`, in `S` that does not appear in the current Prüfer sequence is `1`. The first element, `p`, of the current Prüfer sequence is `4`. We delete `1` from `S` and delete the first element, `4`, of the current Prüfer sequence. We create an edge `1 --- 4` in our tree.
2. Now `S = {2,3,4,5,6}` and our **current** Prüfer sequence is **updated to** `[2,3,2]`. Continuing as in previous step, we will add the following edges to our tree: `4 --- 2` then `5 --- 3` then `3 --- 2`.
3. At this point our `S` is given by `S = {2,6}`, and our current Prüfer sequence is empty.
4. We therefore create the final edge `2 --- 6` in our tree.
5. Our resulting tree is therefore given by the `dict` of `set`s: `{ 1:{4}, 2:{3,4,6}, 3:{2,5}, 4:{1,2}, 5:{3}, 6:{2} }`
You should do these steps on paper and convince yourself that you understand both the encoding and decoding.
**Inputs and Outputs:**
For the `prufer_to_tree` function, you will be passed a `list` of `integers` and you must return a `dict` of `set`s - the structure being the same as the input trees described in Part 1 above.
**The list will always be of length `>= 1` corresponding to the fact that the associated tree always has `n >= 3` vertices** (if the input Prüfer sequence is of length `n-2` then the labeled tree that it represents will contain `n` vertices, and their labels will be `1,2,... n`).
Your code will be tested on trees of up to `n = 500` vertices. All input trees will be valid, and similarly all input Prüfer sequences will be valid and correspond to valid trees.
---
## Useful additional resources
**There is a good visualization tool available online** that will help you troubleshoot your code - I have used the same labeling conventions as this site, for your convenience:
[https://samswanke.com/pruferdecode/](https://samswanke.com/pruferdecode/)
You may also find the following resources useful:
[How to get the Prüfer sequence of a given labeled tree](https://proofwiki.org/wiki/Pr%C3%BCfer_Sequence_from_Labeled_Tree)
[How to reconstruct a labeled tree from a given Prüfer sequence](https://proofwiki.org/wiki/Labeled_Tree_from_Pr%C3%BCfer_Sequence)
The short Wikipedia article on [Prüfer sequences](https://en.wikipedia.org/wiki/Pr%C3%BCfer_sequence) contains some useful pseudocode algorithms.
| reference | def tree_to_prufer(tree):
res = []
for _ in range(len(tree) - 2):
mn = min(k for k, v in tree . items() if len(v) == 1)
res . append([* tree[mn]][0])
tree . pop(mn)
for k, v in tree . items():
if mn in v:
v . remove(mn)
return res
def prufer_to_tree(prufer_sequence):
ln, pf = len(prufer_sequence), prufer_sequence[:]
s = {* range(1, ln + 3)}
res = {k: set() for k in s}
for _ in range(ln):
cur = min(s - set(pf))
s . remove(cur)
res[cur]. add(pf[0])
res[pf . pop(0)]. add(cur)
a, b = s
res[a]. add(b)
res[b]. add(a)
return res
| Prüfer sequences and labeled trees | 6324c4282341c9001ca9fe03 | [
"Algorithms",
"Mathematics",
"Graphs",
"Graph Theory",
"Trees",
"Combinatorics"
] | https://www.codewars.com/kata/6324c4282341c9001ca9fe03 | 6 kyu |
~~~if-not:bf
Yup, fill the provided set with the keywords of your language.
~~~
~~~if:bf
Write a program that will output all 8 instuctions.
~~~
The test provides the number of needed keywords, and the error messages contain hints if you need help.
<!--Translators: Add 3 keywords, one of which should be difficult/obscure.-->
## Details:
~~~if-not:bf
- Keywords are the words put aside as instructions for the compiler. For example (use these to get started):
```python
if True nonlocal
```
```rust
if true extern
```
```csharp
if true stackalloc
```
- If your language has contextual or "soft" keywords, you won't find them here.
Only keywords that are always recognized are included.
- The example test case will only check your list length.
- The keywords should be strings.
~~~
```if:bf
Good luck, and bonus points for not searching anything up. ;)
```
| games | from keyword import kwlist
keywords = set(kwlist)
| Oh, so you like programming? Name all of the keywords! | 634ac4e77611b9f57dff456d | [
"Puzzles"
] | https://www.codewars.com/kata/634ac4e77611b9f57dff456d | 7 kyu |
Prince Arthas needs your help! Mal'ganis has spread an infection amongst the Stratholme citizens, and we must help Arthas prevent this infection from spreading to other parts of the Kingdom.
You will receive a string `s` as input: Each "word" represents a house, and each letter represents a citizen. All infected citizens are represented as `"i"` or `"I"` in `s`. You must eradicate them, and their neighbors. If an infected citizen appears after or before a space, you should not delete the space, but keep in mind that the distance from "house" to "house" (word to word) has to have only one space.
EXAMPLES:
```
"STRING" -> "STG"
"1i2 33 i4i5 i555ii5" -> "33 5"
"It is a bit chilly" -> "a cly"
"Pineapple pizza is delicious" -> "eapple za deus"
"It is not there" -> "not there"
```
NOTES:
- There are no apostrophes or any non-alphanumeric characters other than spaces.
- Make sure there are no leading or trailing spaces in the result string
- You will always be given a valid string.
- You won't be provided any empty strings.
Good luck and for the Alliance! | reference | import re
def purify(s: str) - > str:
return ' ' . join(re . sub(r"[\S]?[iI][^\siI]?", "", s). split())
| The Culling of Stratholme | 634913db7611b9003dff49ad | [
"Strings",
"Games",
"Regular Expressions"
] | https://www.codewars.com/kata/634913db7611b9003dff49ad | 7 kyu |
The set of words is given.
Words are joined if the last letter of one word and the first letter of another word are the same. Return `true` if all words of the set can be combined into one word. Each word can and must be used only once. Otherwise return `false`.
## Input
```if:csharp,cpp,javascript,java,groovy,ruby,vb,go,rust
Array of 3 to 7 words of random length. No capital letters.
```
```if:python
List of 3 to 7 words of random length. No capital letters.
```
## Example `true`
Set: excavate, endure, desire, screen, theater, excess, night.<br>
Millipede: desirE EndurE ExcavatE ExcesS ScreeN NighT Theater.
## Example `false`
Set: trade, pole, view, grave, ladder, mushroom, president.<br>
Millipede: presidenT Trade. | algorithms | from itertools import pairwise, permutations
def solution(arr):
for perm in permutations(arr, len(arr)):
if all(a[- 1] == b[0] for a, b in pairwise(perm)):
return True
return False
| Millipede of words | 6344701cd748a12b99c0dbc4 | [
"Algorithms",
"Arrays",
"Strings"
] | https://www.codewars.com/kata/6344701cd748a12b99c0dbc4 | 6 kyu |
**Task:**
Given an array of tuples (int, int) indicating one or more buildings height and width, draw them consecutively one after another as in a street.
For example, given the input of [(5,9), (7,13)], the output should be:
```
■■■■■■■■■■■■■
■ ■
■■■■■■■■■ ■ ■
■ ■ ■ ■
■ ___ ■# ■ ___# ■
■ | | ■| ■ | || ■
■ | | ■| ■ | || ■
/////////|/////////|////
```
**Notes:**
- For the building walls use the character ```■```
- The minimum size of a building is (4, 5).
```
■■■■■
■___■
■| |■
■| |■
/////
```
- A buildings width is always going to be **odd**.
- The sizes of buildings are random.
- Some buildings are going to be smaller than others, leaving some space overhead. That represents the sky and should be drawn using spaces ```" "```.
```
■■■■■■■ ..... <---
■ ■ ..... <--- Dots used to represent spaces
■ ■ ■■■■■
■ ■ ■ ■
■ ___ ■ #___■
■ | | ■ || |■
■ | | ■ || |■
/////////|////
```
- Every building has a door, which looks the same regardless of the buildings height and width.
```
___ <-- 3 underscores
| |
| |
```
- Between every building there are 2 spaces ```" "```. However if there is only 1 building there isn't any extra space.
- Like every other street, our street has a sidewalk made with the character ```/```. The sidewalk starts from the beginning of the first building to the end of the last building.
- Of course, our street has to have street lights, as well. Streetlights are set every 10 spaces, beginning from number 10, not number 1. (9, not 0 in 0-index languages). They are closer forward to the viewer, which is why they will block other objects like building walls, doors, and sidewalks. Streetlights look like this:
```
#
|
|
|
```
So for a street [(5, 9)], there won't be any streetlights, because the street is only 9 units long, and streetlights are set at every tenth place:
```
■■■■■■■■■
■ ■
■ ___ ■
■ | | ■
■ | | ■
/////////
```
But street [(5, 11)], which is 11 units long, will have 1 streetlight:
```
■■■■■■■■■■■
■ ■
■ ___ #■
■ | | |■
■ | | |■
/////////|/
```
In street [(5, 17)] we can see the streetlight obstructing the view of the building door:
```
■■■■■■■■■■■■■■■■■
■ ■
■ __# ■
■ | | ■
■ | | ■
/////////|///////
```
**OUTPUT**
Return a string which when printed out looks like the drawings above.
```
Input of [(4,9)] gives '■■■■■■■■■\n■ ___ ■\n■ | | ■\n■ | | ■\n/////////'
```
| reference | def draw_street(dimensions):
maxHeight = max(map(lambda x: x[0], dimensions))
def building(dimensions):
h, w = dimensions
return [' ' * w] * (maxHeight - h) + [
'■' * w] + [
'■' + ' ' * (w - 2) + '■'] * (h - 4) + [
'■' + '___' . center(w - 2, ' ') + '■',
'■' + '| |' . center(w - 2, ' ') + '■',
'■' + '| |' . center(w - 2, ' ') + '■']
view = list(map(' ' . join, zip(* map(building, dimensions))))
view . append('/' * len(view[0]))
for i in range(9, len(view[0]), 10):
for n in range(1, 5):
view[- n] = view[- n][: i] + ['#', '|'][n < 4] + view[- n][i + 1:]
return '\n' . join(view)
| Draw a street | 63454405099dba0057ef4aa0 | [
"ASCII Art"
] | https://www.codewars.com/kata/63454405099dba0057ef4aa0 | 6 kyu |
<h1>Task</h1>
Given a circuit with fixed resistors connected in series and/or in parallel, calculate the total effective resistance of the circuit.
All resistors are given in Ω, and the result should be in Ω too (as a float; tested to ± 1e-6).
Assume wires have negligible resistance.
The voltage of the battery is irrelevant.
The circuit is passed to your function in the following form:
<ul>
<li>I will define a component as any number of resistors connected in series or in parallel.</li>
<li>The entire circuit counts as a component.</li>
<li>Each component is an array.</li>
<li>A series component will have the boolean true in position zero.</li>
<li>A parallel component will have the boolean false in position zero.</li>
<li>
The other positions will either contain:
<ul>
<li>Numbers, denoting fixed resistors of that resistance.</li>
<li>Arrays, denoting nested components.</li>
</ul>
</li>
<li>A series circuit with no other entries represents a single wire</li>
<li>A parallel circuit with no other entries represents a break in the circuit (see below for more details)</li>
<li>All circuits will be valid and in the form above (short circuits or broken circuits may appear, though)</li>
<li>There will be no negative resistances</li>
</ul>
Example circuit:
```javascript
[
true, // series
20, // 20Ω resistor
[
false, // parallel
[
true, // series
30, // 30Ω resistor
40, // 40Ω resistor
],
30, // 30Ω resistor
],
60, // 60Ω resistor
]
```
```python
[
True, # series
20, # 20Ω resistor
[
False, # parallel
[
True, # series
30, # 30Ω resistor
40 # 40Ω resistor
],
30 # 30Ω resistor
],
60 # 60Ω resistor
]
```
Looks like:
<img src="https://i.imgur.com/7U1tYzZ.png" />
`20 + 1/(1/(30+40)+1/30) + 60 = 101Ω`
<hr>
<h1>Short Circuits</h1>
It might be the case that the circuit has zero resistance.
We don't want zero resistance, as these cause short circuits!
You should throw an `Error` instead of returning, with the error message `Short Circuit!` if this ever happens.
<hr>
<h1>Broken Circuits</h1>
It might be the case that all the paths in the circuit have a break in them.
This creates infinite resistance, and in effect a broken circuit!
You should throw an `Error` instead of returning, with the error message `Broken Circuit!` if this ever happens.
Example Circuit:
```javascript
[
true, // series
10, // 10Ω resistor
[
false, // parallel
[
false, // parallel, broken circuit
],
[
false, // parallel, broken circuit
],
],
]
```
```python
[
True, # series
10, # 10Ω resistor
[
False, # parallel
[
False # parallel, broken circuit
],
[
False # parallel, broken circuit
]
]
]
```
Looks like:
<img src="https://i.imgur.com/Hrv4j1k.png" />
<hr>
<h1>Helpful Links</h1>
If you don't know or don't remember how to calculate the total effective resistance of a series or parallel circuit, then consult the following two kata.
<a href="https://www.codewars.com/kata/57164342794d30e78d000a20">
Series Circuit Kata (myjinxin2015; 7kyu)
</a>
<br>
<a href="https://www.codewars.com/kata/571654c3347e6533fa00186b">
Parallel Circuit Kata (myjinxin2015; 7kyu)
</a>
Additionally, if you would like to visualise some of the circuits by building them, you can do it online here.
<a href="https://www.circuitlab.com/editor/#?id=7pq5wm&from=homepage">
Interactive Circuit Builder (used to create the images above)
</a> | algorithms | def series(x): return x
def parall(x): return 1 / x if x else float('inf')
def rec(circuit):
if not isinstance(circuit, list):
return circuit
test, * circuit = circuit
if not circuit:
return not test and float('inf')
func = test and series or parall
return func(sum(func(rec(x)) for x in circuit))
def calculate_resistance(circuit):
result = rec(circuit)
if result == 0:
raise Exception("Short Circuit!")
if result == float('inf'):
raise Exception("Broken Circuit!")
return result
| Effective Resistance of a Simple Circuit | 63431f9b9943dd4cee787da5 | [
"Recursion",
"Arrays",
"Algorithms",
"Fundamentals",
"Physics"
] | https://www.codewars.com/kata/63431f9b9943dd4cee787da5 | 6 kyu |
'Evil' numbers are non-negative numbers with even parity, that is, numbers with an even number of `1`s in their binary representation. The first few evil numbers are:
```
0,3,5,6,9,10,12,15,17,18,20
```
Write a function to return the n<sup>th</sup> evil number.
```haskell
input 1 returns 0
input 2 returns 3
input 3 returns 5
-- etc
```
The tests will include values of `n` up to `10^100`. | algorithms | def is_evil(number):
count = 0
while number:
number &= number - 1
count += 1
return count % 2 == 0
def get_evil(n):
t = 2 * (n - 1)
return t if is_evil(t) else t + 1
| Find the nth evil number | 634420abae4b81004afefca7 | [
"Mathematics",
"Algorithms",
"Performance"
] | https://www.codewars.com/kata/634420abae4b81004afefca7 | 6 kyu |
## Story (skippable):
Once upon a time, a farmer came across a magic seed shop. Once inside, the salesman sold him a pack of magical trees. Before leaving, the salesman gave him a warning:
"These are no ordinary trees, farmer. These trees split up into smaller, further dividing duplicate trees with each passing day," The salesperson said.
The farmer returned home with his purchase and decided to clear a patch of land for the new crop. He planted one down in the middle of his field. Upon returning the next day, the farmer was greeted by two slightly smaller trees in place of the original tree, as promised.
The farmer got both very excited and very nervous. He realized he had an easy way to turn a profit. That was great news for him! But he also figured he had no idea of how to predict and report what his profits would be.
The farmer needs your help coding a function that can return what the field will look like after a certain number of days.
## Task:
You are given a multi-line string `p_field` containing a single magic tree that recursively divides itself into a `split` number of shorter copies every day. Return the p_field after `n` days. The tree's splitting decreases its height by one `|` each generation.
Only valid tree's will be asked for, there will be no asking for splitting for more days than possible.
**WARNING: These fields can get BIG!!! Make sure your code runs efficiently.**
## Example:
The following is the start of a `p_field` with a `split` value of `2`:
```
o
|
|
|
```
On day 1, the field will look like this:
```
oo
||
||
```
The next day, the field would grow to this:
```
oooo
||||
```
In 3 days, which is the maximum possible `n` value for this example,
the field will look like this:
```
oooooooo
```
If `n` is 2, your function needs to return the third `p_field` displayed and return the fourth example if `n` was 3.
If `split` is 3, the function instead returns `ooooooooooooooooooooooooooo` on the third day. (1 => 3 => 9 => 27)
| algorithms | def magic_plant(p_feild, split, n):
t = p_feild . split('\n')
return '\n' . join(c * (split * * n) for c in t[: len(t) - n])
| Magical Duplication Tree | 6339de328a3b8f0016cc5b8d | [
"Mathematics",
"Performance",
"Algorithms"
] | https://www.codewars.com/kata/6339de328a3b8f0016cc5b8d | 7 kyu |
This kata is a direct continuation of [Infinite continued fractions](https://www.codewars.com/kata/63178f6f358563cdbe128886/python) kata, and we'll use our ability to compute coefficients of continued fractions for integer factorization.
## The task
Perform a first step of [CFRAC method](https://en.wikipedia.org/wiki/Continued_fraction_factorization). Use your solution from [Infinite continued fractions](https://www.codewars.com/kata/63178f6f358563cdbe128886/python) to compute convergents of fraction expansion of `sqrt(N)`. Then write a generator, to continuously yield integer numbers `x` (numerators of fractions) in constant time, such that
```math
x^2 \equiv A \mod N\newline
A < 2 \sqrt N\newline
\sqrt N < x < N - \sqrt N
```
A quite weird task, isn't it? But there is actually a direct motivation for integer factorization and breaking RSA cryptosystems.
```if:racket
<u>In Racket, write a stream.</u>
```
## Example
```math
403 = 13 * 31\newline
\newline
\sqrt{403} = 20 + \cfrac{1}{ 13 + \cfrac{1}{ 2 + \cfrac{1}{ 1 + \cfrac{1}{3 + \dots } } } }\newline
20 + \cfrac{1}{ 13 } = \cfrac{261}{13}\newline
261^2 \equiv 14 \mod 403\newline
14 < 2 * \sqrt{403}\newline
```
<hr />
```math
20 + \cfrac{1}{ 13 + \cfrac{1}{ 2 + \cfrac{1}{ 1 + \cfrac{1}{ 3 + \cfrac{1}{ 1 } } }}} = \cfrac{3754}{187}\newline
3754^2 \equiv 127^2 \equiv 9 \mod 403\newline
9 < 2 * \sqrt{403}\newline
```
<u>In the examples above, yield 261 and 127, respectively.</u>
## Motivation
Surprising as it is, integer factorization is a very difficult task, if you consider it from the perspective of bit length of integer. It takes Wolfram Alpha mere seconds to [factorize a 128-bit number](https://www.wolframalpha.com/input?i=125534992627552787166417427217919095873). But if you take a product of 2 prime 2048-bits integers, it won't complete factorization in a lifetime of the Earth, though obtaining a product of such 2 primes takes milliseconds.
An integer series is surprisingly chaotic and is full of obnoxious prime numbers. On average, you will stumble upon a prime number every `log(N)` steps, if you count up to `N`. These numbers are very different in properties (such that some of them allow quick factorization, but others do not), and the hardest type of factorization task is factorizing RSA-numbers, which are semi-primes with equal-bit-length primes.
We'll take a look at certain factorization methods and how continued fractions are useful in them.
It all starts with Fermat identity:
```math
x^2 = N + y^2\newline
N = pq = (x-y)(x+y)
```
Finding such `x` and `y` is no easy task, but [it was noticed](https://en.wikipedia.org/wiki/Congruence_of_squares), that a simpler equation may be solved instead:
```math
x^2 = kN + y^2\newline
x^2 \equiv y^2 \mod N\newline
x \neq \pm y \mod N\newline
p = gcd(x - y, N)\newline
q = gcd(x + y, N)
```
A bit better, but still far from perfection. Play with some semiprimes, to see that finding a square quadratic residual `y` is too difficult! So what do we do? We collect a bunch of such `x_i` and `y_i`, such that a product of `y_i` gives a square!
```math
y_1 y_2 y_3 ... y_n = M^2 \mod N\newline
x_1^2x_2^2x_3^2...x_n^2 = y_1 y_2 y_3 ... y_n = M^2 \mod N\newline
p = gcd(x_1x_2x_3...x_n - M, N)\newline
q = gcd(x_1x_2x_3...x_n + M, N)\newline
```
This is [Dixon's method](https://en.wikipedia.org/wiki/Dixon%27s_factorization_method). To simplify searching for such pairs `x_i`, `y_i`, we only consider quadratic residues `y_i` which are products of small primes. These numbers are called `B-smooth` (no prime factor is larger than `B`).
The smaller the residue `y_i`, the higher the chance to find `B-smooth` number. Hence, there are methods that compute modular roots, with corresponding residues of order `sqrt(N)`. (Developing an algorithm to reliably find modular roots, that give even smaller residues, is an incredibly hard task).
A [quadratic sieve method](https://en.wikipedia.org/wiki/Quadratic_sieve) uses quadratic residues of `isqrt(N) + A` for small `A`, whereas CFRAC method (a hero of today) utilises convergents of fraction expansion of `sqrt(N)`.
## Notes
The tests will validate that yielded numbers satisfy the equations above and that they are different. Your generator will have to yield 6000 numbers for a single `N`. | reference | from typing import Generator
from fractions import Fraction
import math
import itertools
def generate_continued_fraction(b) - > Generator[int, None, None]:
a, c = 0, 1
while True:
if not c:
yield from itertools . repeat(0)
i = (math . isqrt(b) + a) / / c
yield i
a, c = c * i - a, (b - a * a) / / c + i * (2 * a - c * i)
def generate_modular_roots(n) - > Generator[int, None, None]:
p, q = 1, 0
z = math . isqrt(n - 1)
for a in generate_continued_fraction(n):
p, q = (a * p + q) % n, p
if p * p % n < 2 * z and z < p < n - z:
yield p % n
| Integer factorization: CFRAC basics | 63348506df3ef80052edf587 | [
"Mathematics",
"Algorithms",
"Fundamentals",
"Performance"
] | https://www.codewars.com/kata/63348506df3ef80052edf587 | 4 kyu |
**Introduction**
As a programmer, one must be familiar with the usage of iterative statements in coding implementations! Depending on the chosen programming language, iterative statements can come in the form of `for`, `while`, `do-while` etc.
Below is an example of a `nested C-style for-loop`:
```c
for(int i = 0; i < A; i++){
// some statements
for(int j = 0; j < B; j++){
// some statements
for(int k = 0; k < C; k++){
// some statements
}
}
}
```
Where `A`, `B` and `C` are natural numbers.
**Task**
Given an array of length `N`, where `N` denotes the number of iterative statements. Each item-pair in the array represents two elements, with the `1st value` (`V`) indicating the upper boundary for the iteration to take place (can be inclusive or exclusive depending on the `2nd value`) and the `2nd value` (Boolean data type -> `true` / `false` depending on your chosen language) indicating whether the upper boundary (`V`) is inclusive or not.
You must write a function that outputs an array in which each element represents the `number of times each for-loop condition is evaluated`. Below is an example for better understanding:
**Example**
arr = `[[7, true], [5, false]]`
```c
for(int i = 0; i <= 7; i++){ // This statement is executed 9 times before termination -> 0, 1, 2, 3, 4, 5, 6, 7, 8 (since 8 > 7 is the breaking condition)
for(int j = 0; j < 5; j++){ // In one cycle of outermost loop, this statement is executed 6 times before termination -> 0, 1, 2, 3, 4, 5 (since 5 >= 5 is the breaking condition)
// some statements
}
}
```
**Note**
* The array can be empty, with a range of `0 <= N <= 20`
* The starting counter of the `C-style for-loop` is always `0`
* The iteration expression or operation to be performed is always `incremental`
* The range of upper boundary is as follows: `1 <= V <= 20` | algorithms | def count_loop_iterations(arr):
res = []
acc = 1
for n, b in arr:
n = n + 2 if b else n + 1
res . append(acc * n)
acc *= n - 1
return res
| Can you count loop's execution? | 633bbba75882f6004f9dae4c | [
"Algorithms"
] | https://www.codewars.com/kata/633bbba75882f6004f9dae4c | 7 kyu |
<h2 style='color:#f88'>EXPLANATIONS </h2>
We will work with the numbers of the form:
```math
p_1 × p^2_2 × p^3_3 ×.......× p^n_n
```
and
```math
p_1, p_2, p_3, .....,p_n
```
It's a chain of ```n``` consecutive primes.
As you can see, each prime is raised to an exponent. All the exponents are in an increasing sequence and the difference of two contiguous exponent is one.
In the sequence of primes, sorted by their values, each prime has an ordinal number, 2 is the first one, 3 the second, 5 the third one and so on.
Let's have ```k```, an integer that defines an ordinal position that locates the first prime of the chain, so we may say that ```p1``` is the ```k-th``` prime of the sequence.
On the other hand, let's have ```n```, the amount of primes of the chain. With these integer two integers, ```k``` and ```n```, the value of the number is defined
Let's understand it better with an example:
```k = 20, n = 4```
The 20-th prime is ```71```, and ```n = 4``` means that we have the following calculation:
```math
71 × 73^2 × 79^3 × 83^4 = 8,853,147,752,524,961,321
```
<h4 style='color:#f88'>THE INVOLUTION</h4>
It consists in reversing the order of the exponents. The second integer will be of the form:
```math
p^n_1 × ....... × p^1_n
```
According to our example above will be:
```math
71^4 × 73^3 × 79^2 × 83 = 5,120,757,976,852,608,731
```
So the pair of integers (example #1):
```math
8,853,147,752,524,961,321
```
```math
5,120,757,976,852,608,731
```
they are a corresponding pair in this involution.
Why an involution? Because if we reverse twice the exponents, we will get the original number.
As we will have huge results (number with many digits) we will use a for the output a special numerical system.
<h2 style='color:#f88'>NEW NUMERICAL SYSTEMS?</h2>
We can create different numerical systems for integers that use only the capital and small letters of the English alphabet. Yes,they do not use digits.
The values of the new digits for a numerical system base = 52 are:
```A = 0, B = 1, C = 2,......Z = 25, a = 26, b = 27, ............, z = 51```
But for a numerical system base ```48```, the available characters to be used will be:
```ABCDE....XYZabcde....tuv```
But with one of base ```36```:
```ABCDE....XYZabcde.....hij```
Let's see the equivalent numbers with different bases comparing with our decimal system.
<li><code style='color:#f88'>N = 18,725 = GwF<sub> 52</sub></code>
<li><code style='color:#f88'>N = 1,854,290 = QknC<sub> 48</sub></code>
<li><code style='color:#f88'>N = 2,354,225,960 = BChXINU<sub> 36</sub></code>
<li><code style='color:#f88'>N = 988,562,945,281,908 = cDCefTCDbU<sub> 32</sub></code>
<li><code style='color:#f88'>N = 9,885,629,452,819,081,894,567 = CBHOGKKPLAHIEJCJKKH<sub> 16</sub></code>
So, the pair of numbers are related in the involution of example #1 converted to integers in base 36 of our numerical system will be:
<li><code style='color:#f88'>BfJPWiSdcGMbd<sub> 36</sub></code> <li><code style='color:#f88'>BCgVBHOZREBaj<sub> 36</sub></code>
<h2 style='color:#f88'>THE TASK</h2>
We need a code that receives the following 3 integers as inputs:
- ```k```, ordinal number of the corresponding prime in a sorted increasing sequence of primes
- ```n```, number of consecutive primes that form the product of powers
- ```base```, the base of the numeriacal system that may have values multiple of ```4``` and below or equal ```52```.
The code should output a tuple with the pair of the integers encoded into the base required, the starting
number ```i1``` and the result of the involution ```i2```
```
inputs output
k, n, base (i1, i2)
```
```
Examples:
(7,5,52) ----------> ('DtHUiBNcDuNnl','HqByzLEKFuRt')
(20,4,36) ---------> ("BfJPWiSdcGMbd", "BCgVBHOZREBaj")
(34,6,48) ---------> ('GYZEGPcXqMTMgVQNfpRVOXGvvBAf', 'BriSOCpdlVojsMcErcFPEeVpQqWf')
```
<h2 style='color:#f88'>THE TESTS</h2>
There will be almost 200 tests to pass the kata.
These are the following ranges or values for the inputs in the tests.
```
5 ≤ k ≤ 700
2 ≤ n ≤ 20
4 ≤ base ≤ 52
```
All the inputs will be valid, three positive integers for each test.
Do your best!
All observations in ortography, grammar or in the use of English in general are welcome. Thanks for that. | reference | def primes(n):
sieve = n / / 2 * [True]
for i in range(3, int(n * * 0.5) + 1, 2):
if sieve[i / / 2]:
sieve[i * i / / 2:: i] = [False] * ((n - i * i - 1) / / (2 * i) + 1)
return [2] + [2 * i + 1 for i in range(1, n / / 2) if sieve[i]]
from string import ascii_uppercase as u, ascii_lowercase as l
def to_base(n, b, w=u + l):
return w[n] if n < b else to_base(n / / b, b). lstrip(w[0]) + w[n % b]
def transform(nums, exponents):
from math import prod
return prod(p * * i for p, i in zip(nums, exponents))
def solver(k, n, base, seq=primes(10 * * 4)):
assert k + n - 1 <= len(seq)
chain, exp = seq[k - 1: k + n - 1], range(1, n + 1)
return tuple(to_base(transform(chain, es), base) for es in (exp, exp[:: - 1]))
| Involution in Numbers of Different Bases Using the Alphabetical System. | 632abe6080604200319b7818 | [
"Mathematics",
"Number Theory"
] | https://www.codewars.com/kata/632abe6080604200319b7818 | 6 kyu |
Twelve cards with grades from `0` to `11` randomly divided among `3` players: Frank, Sam, and Tom, `4` cards each. The game consists of `4` rounds.
The goal of the round is to move by the card with the most points.<br>
In round `1`, the first player who has a card with `0` points, takes the first turn, and he starts with that card.
Then the second player (queue - Frank -> Sam -> Tom -> Frank, etc.) can move with any of his cards (each card is used only once per game, and there are no rules that require players to make only the best moves).
The third player makes his move after the second player, and he sees the previous moves.<br>
The winner of the previous round then makes the first move in the next round with any remaining card.<br>
The player who wins `2` rounds first, wins the game.
## Task
Return `true` if Frank has a chance of winning the game.<br>
Return `false` if Frank has no chance.
## Input
`3` arrays of `4` unique numbers in each (numbers in array are sorted in ascending order).
Input is always valid, no need to check.
## Example
Round `1`: Frank ` 2 5 8 11 `, Sam ` 1 4 7 10 `, Tom ` 0 3 6 9 `.
Tom has to start from `0`. Frank is risking nothing and goes `2`.
Sam gets lucky and wins round by throwing `4`.
Round `2`: Frank ` 5 8 11 `, Sam ` 1 7 10 `, Tom ` 3 6 9 `.
Sam starts from `1`. Tom goes `3`, Frank wins with `5`.
Round `3`: Frank ` 8 11 `, Sam ` 7 10 `, Tom ` 6 9 `.
Frank starts from `11` and wins the round either way.
Frank is the first to win `2` rounds and therefore wins the game, the answer is `true`.
## One more example
Frank ` 0 1 2 3 `, Sam ` 6 7 8 11 `, Tom ` 4 5 9 10 `.<br>
With these cards Frank has no chance, the answer is `false`.
## Tip
Players can actually play DUMB moves, especially Sam and Tom. | games | def solution(frank, sam, tom):
count = 0
for i in range(4):
for j in range(4):
if frank[j] > sam[i] and frank[j] > tom[i]:
count += 1
frank[j] = 0
break
return count >= 2
| Another card game | 633874ed198a4c00286aa39d | [
"Algorithms",
"Games"
] | https://www.codewars.com/kata/633874ed198a4c00286aa39d | 7 kyu |
There are `N` lights in the room indexed from `0` to `N-1`. All the lights are currently off, and you want to turn them on. At this point, you find that there are `M` switches in the room, indexed from `0` to `M-1`. Each switch corresponds to several lights. Once the switch is toggled, all the lights related to the switch will change their states. Please write a program to check if there is a way to turn all the lights on.
## Input/Output
The input is a two-dimensional array representing relationships between lights and switches. The first dimension represents the switches, and the second dimension represents the lights corresponding to each switch. You should output whether it is possible to turn all the lights on.
It's guaranteed that `$1 \leq min(N, M) \lt 16$`, `$max(N, M) \lt 32$`.
## Example
Given 5 lights and 4 switches. The correspondence between switches and lights:
```
[
[0, 1, 2], // switch 0 controls light 0, 1, 2
[1, 2], // switch 1 controls light 1, 2
[1, 2, 3, 4], // switch 2 controls light 1, 2, 3, 4
[1, 4] // switch 3 controls light 1, 4
]
```
Initial lights:
```
0 0 0 0 0
```
Toggle switch 0:
```
1 1 1 0 0
```
Toggle switch 2:
```
1 0 0 1 1
```
Toggle switch 1:
```
1 1 1 1 1
```
Now all the lights are on. It should return true.
## Tips
[Spoiler Alert] Some of the hints may affect your problem solving experience:
- <span style="color: gray; background-color: gray">This kata can be solved by searching algorithms. If you have no clue about how to solve this, try BFS(Breadth First Search). But there are better ways.</span>
- Pay attention to the time complexity. It's impossible to brute force all `$2^{31}$` possiblities in the given time.
- The optimial solution has time complexity of `$O(MN^2)$`. Can you figure it out?
| algorithms | def light_switch(n, lights):
result = {0}
for s in lights:
result |= {x ^ sum(1 << x for x in s) for x in result}
return (1 << n) - 1 in result
| Light Switch | 63306fdffa185d004a987b8e | [
"Algorithms",
"Puzzles",
"Searching",
"Performance"
] | https://www.codewars.com/kata/63306fdffa185d004a987b8e | 5 kyu |
The greatest common divisor (gcd) of two non-negative integers `$a$` and `$b$` is, well, their greatest common divisor. For instance, `$ \mathrm{gcd}(6, 4) = 2$` and `$ \mathrm{gcd}(100, 17) = 1$`. Note that in these cases the gcd can be expressed as a linear combination with integer coefficients of the given two numbers a and b:
* `$2 = \mathrm{gcd}(6,4) = 1\cdot 6 + (-1)\cdot 4$` --> with coefficients 1 and -1
* `$1 = \mathrm{gcd}(100, 17) = 8\cdot 100 + (-47)\cdot 17 $` --> with coefficients 8 and -47.
More generally, given any two non-negative integers `$a$` and `$b$`, their gcd can always be expressed as a linear combination of `$a$` and `$b$` using integer coefficients. In other words, there exist integer numbers `$x$` and `$y$` such that: `$ \mathrm{gcd}(a, b) = x\cdot a + y\cdot b$`. Note that the coefficients `$x$` and `$y$` are not determined uniquely.
Your goal is to write the function gcd_coeff that accepts two non-negative integers `$a$` and `$b$` and returns a tuple `$(x, y)$` of integer coefficients `$x$` and `$y$` expressing `$\mathrm {gcd}(a, b)$` as `$x\cdot a + y\cdot b$`. You may assume that `$a \ge b$` is always satisfied.
Note: Testing will involve randomly chosen integers of large magnitude, so efficiency is of importance.
| algorithms | from gmpy2 import gcdext
def gcd_coeff(a, b):
_, x, y = gcdext(a, b)
return int(x), int(y)
| Greatest common divisor as linear combination | 63304cd2c68f640016b5d162 | [
"Algorithms",
"Mathematics",
"Number Theory",
"Cryptography"
] | https://www.codewars.com/kata/63304cd2c68f640016b5d162 | 6 kyu |
In a computer operating system that uses paging for virtual memory management, page replacement algorithms decide which memory pages to page out when a page of memory needs to be allocated. Page replacement happens when a requested page is not in memory (page fault) and a free page cannot be used to satisfy the allocation, either because there are none, or because the number of free pages is lower than some threshold.
## The LRU page replacement algorithm
The least recently used (LRU) page replacement algorithm works on the idea that pages that have been most heavily used in the past few instructions are most likely to be used heavily in the next few instructions too. If not all the slots in memory are occupied, the requested page is inserted in the first available slot when a page fault happens. If the memory is full and a page fault happens, the least recently used page in memory gets replaced by the requested page. To explain it in a clearer way: the least recently used page is the page that is currently in memory and has been referenced further in the past.<br>
Your task is to implement this algorithm. The function will take two parameters as input: the number of maximum pages that can be kept in memory at the same time ```n``` and a ```reference list``` containing numbers. Every number represents a page request for a specific page (you can see this number as the unique ID of a page). The expected output is the status of the memory after the application of the algorithm. Note that when a page is inserted in the memory, it stays at the same position until it is removed from the memory by a page fault.
## Example:
Given:
* N = 3,
* REFERENCE LIST = \[1, 2, 3, 4, 3, 2, 5\],
```
* 1 is read, page fault --> free memory available, memory = [1];
* 2 is read, page fault --> free memory available, memory = [1, 2];
* 3 is read, page fault --> free memory available, memory = [1, 2, 3];
* 4 is read, page fault --> LRU = 1, memory = [4, 2, 3];
* 3 is read, already in memory, nothing happens;
* 2 is read, already in memory, nothing happens;
* 5 is read, page fault --> LRU = 4, memory = [5, 2, 3].
```
So, at the end we have the list ```[5, 2, 3]```, which is what you have to return. If not all the slots in the memory get occupied after applying the algorithm, fill the remaining slots (at the end of the list) with ```-1``` to represent emptiness (note that the IDs will always be >= 1).
| algorithms | def lru(n, reference_list):
cache, time = [- 1] * n, [- 1] * n
for i, x in enumerate(reference_list):
idx = cache . index(x) if x in cache else time . index(min(time))
cache[idx] = x
time[idx] = i
return cache
| Page replacement algorithms: LRU | 6329d94bf18e5d0e56bfca77 | [
"Algorithms",
"Lists"
] | https://www.codewars.com/kata/6329d94bf18e5d0e56bfca77 | 6 kyu |
## Overview
Suppose you build a pyramid out of unit-cubes, starting from a square base, and such that cubes stack exactly onto cubes below them (they do not overlap or sit on "lines" in the level below theirs).
For example: if you start with a square base of side = 7 cubes, your first level has a total of `7**2 = 49` unit cubes. Your second level has a square base of side = 5 cubes and consists of `5**2 = 25` unit cubes. Your third level has a square base of side = 3 cubes and consists of `3**2 = 9` unit cubes. Your fourth level - the top one - has a square base of side = 1 cube and consists of only `1` unit cube.
In this example, we have built a pyramid of `height = 4` levels.
Now that you built your pyramid, you decide to paint all of its exterior surface with red paint (You **do not** paint "under" the pyramid base though).
Then you break up your entire pyramid into its constituent unit cubes and put all the unit cubes into a bag.
**If you now pick one unit cube out of this bag at random, and then roll it once as if it were a dice, what is the probability that you will obtain a red-painted face?**
---
## Complete Walk-through Example with `height = 4`
Referring to the example above, notice how the **different unit cubes will end up having different numbers of red faces**:
- On level 4, i.e. the top of pyramid, there is 1 single cube which has **5** red faces.
- Then on levels 1,2 and 3, there are 4 "corner cubes" which each have **3** red faces, for a total of 12 "corner cubes".
- On levels 1,2 and 3 there are also "edge cubes" which each have **2** red faces. There are 20 edge cubes on level 1, 12 edge cubes on level 2, and 4 edge cubes on level 3, for a total of 20+12+4 = 36 "edge cubes".
- Finally there are also "internal cubes" which have **0** red faces. In this pyramid of `height = 4` there are 35 internal cubes.
When you "roll the dice", in some cases you will get very lucky and randomly pick the top-most cube out of the bag, which has 5 red faces, and therefore you will have a `5/6` probability of getting a red-painted face when you roll that dice.
But, sadly, there is only 1 such dice in your bag so you have a low chance of picking it at random.
On the other hand, in many other cases you will be unlucky and pick one of the many internal cubes which do not have any red painted faces, and will therefore have a `0/6` probability of getting a red face.
The **total probability** for this `height = 4` pyramid is therefore broken down as follows:
```python
(1 /(1+12+36+35)) * (5/6) # 1 top cube with a probability 5/6 of obtaining red
+(12/(1+12+36+35)) * (3/6) # 12 corner cubes each with a red probability of 3/6
+(36/(1+12+36+35)) * (2/6) # 36 edge cubes each with a red probability of 2/6
+(35/(1+12+36+35)) * (0/6) # 35 internal cubes each with a red probability of 0/6
__________________________
(113/504) # total probability of obtaining a red face
```
---
## Inputs and Outputs
You will receive an `integer`, `height >= 1`, which counts the number of levels of your pyramid. In the example used above, the `height` is equal to `4`. The first level of the square pyramid therefore has side-length = `2 * height - 1` unit cubes.
You must return a `2-ple` of `integers` representing the total probability expressed as a fraction, in the form `(numerator, denominator)` where `numerator < denominator` corresponding to the fact the total probability is `< 1`.
Since this is a problem involving discrete probability you will always be able to obtain a result involving only integers, so this avoids you having to express the probability as a real number involving `floats`.
You **do not** have to express your "fraction" result in lowest common denominator - for example, if the simplest result is `(2,7)` then the result `(10,35)` will also be accepted as it represents the same fractional probability.
## Code Golf Requirement
Depending on language, your code must consist of:
- Python: `<= 45` characters
- JavaScript: `<= 39` characters | games | def pyramid(h): return (8 * h * h - 4 * h + 1, 8 * h * * 3 - 2 * h)
| [Code Golf] Painted Pyramid Probability Puzzle | 62f7ca8a3afaff005669625a | [
"Puzzles",
"Mathematics",
"Restricted",
"Probability"
] | https://www.codewars.com/kata/62f7ca8a3afaff005669625a | 6 kyu |
### Task
Given Points `A`, `B`, `C` ∈ ℤ<sup>2</sup> and `dA`, `dB`, `dC` ∈ ℤ their respective squared euclidian distances to a certain point `P` ∈ ℤ<sup>2</sup>, return the value of `P`.
### Note
A, B, and C will always be distinct and non-collinear | games | def triangulate(A, dA, B, dB, C, dC):
a11, a21 = 2 * (B[0] - A[0]), 2 * (C[0] - A[0])
a12, a22 = 2 * (B[1] - A[1]), 2 * (C[1] - A[1])
b1, b2 = dA - dB - A[0] * * 2 - A[1] * * 2 + B[0] * * 2 + B[1] * * 2, dA - dC - A[0] * * 2 - A[1] * * 2 + C[0] * * 2 + C[1] * * 2
dt = a11 * a22 - a12 * a21
x, y = (b1 * a22 - a12 * b2) / / dt, (a11 * b2 - b1 * a21) / / dt
return (x, y)
| Locate P using 3 Points and their distances to P | 6326533f8b7445002e856ca3 | [
"Mathematics",
"Geometry"
] | https://www.codewars.com/kata/6326533f8b7445002e856ca3 | 6 kyu |
## Overview
Given an `integer`, `n`, consider its binary representation - I shall call a **binary bunching of `n`** any rearrangement of the bits of `n` such that all **set bits are contiguous** (i.e. all its `1`s are side-by-side when viewed as a string).
There are many possible ways of binary bunching the bits of `n`; for each possible way, we can calculate its **bunching cost** - this is the **number of bit flips necessary to reach the final binary number from the initial value of `n`.**
An example will make all this clear:
If we take `n = 52` then in binary `n = 110100`. We see that there are **6 bits** in the binary representation `n = 110100`.
There are only 4 possible ways to binary bunch rearrange these **6 bits** of `n = 110100`, listed here with the number of bit flips necessary to do so in each case:
- `110100 -> 000111`, requires flipping 1st, 2nd, 5th, 6th bits, so total bunching cost = 4
- `110100 -> 001110`, requires flipping 2nd, 4th, 5th, 6th bits, so total bunching cost = 4
- `110100 -> 011100`, requires flipping 4th, 6th bits, so total bunching cost = 2
- `110100 -> 111000`, requires flipping 3rd, 4th bits, so total bunching cost = 2
Finally, we shall call the **Binary Bunch Transform** of `n` the **smallest** number among all possible numbers which have the **lowest possible bunching cost**.
So returning to the above example, of the 4 possible ways of binary bunching `n = 52 = 110100`, the lowest possible bunching cost is `2` and of two possible numbers that
shared this minimum bunching cost (`111000 = 56`, and `011100 = 28`) the smallest is 28.
Therefore `bunch(52) = 28`.
---
## Inputs and Outputs
You will be given a positive `integer`, `n > 0`.
Values of `n` up to `2**32` will be tested (depending on language).
You must return an `integer`, the Binary Bunch Transform of `n` as defined above.
---
## Further examples with small values
Here are some further small examples you can check by hand if you want, before coding your solution.
`n = 19 = 10011` -> transforms to `00111` in 2 bit flips, which is the smallest number of bit flips needed to get all `1`s bunched together. `00111` is the smallest bunched binary number that can be reached in 2 bit flips starting from `n = 19 = 10011`. `00111` represents the integer `7` so `bunch(19) = 7`.
`n = 49 = 110001` -> transforms to `111000` in 2 bit flips, which is the smallest number of bit flips needed to get all `1`s bunched together. `111000` is the smallest bunched binary number that can be reached in 2 bit flips starting from `n = 49 = 110001`.`111000` represents the integer `56` so `bunch(49) = 56`.
| reference | def bunch(n):
s, w = n . bit_length(), n . bit_count()
base = (1 << w) - 1
chunks = (base << i for i in range(s - w + 1))
return min(chunks, key=lambda v: ((n ^ v). bit_count(), v))
| Binary Bunch Transform of an Integer | 62cc5882ea688d00428ad2b0 | [
"Fundamentals",
"Binary"
] | https://www.codewars.com/kata/62cc5882ea688d00428ad2b0 | 6 kyu |
<h2 style="color:#4bd4de">Description</h2>
In mathematics, and more specifically number theory, the hyperfactorial of a positive integer `$n$` is the product of the numbers `$1^1 , 2^2, ..., n^n $`:
`$H(n) = 1^1 \times 2^2 \times 3^3 \times ... \times (n-1)^{n-1} \times n^n$`
`$H(n) = \prod_{i=1}^{n} i^i $`
<a href="https://en.wikipedia.org/wiki/Hyperfactorial">Check out this Wikipedia article for more detail</a>
<h2 style="color:#62d941">Your task</h2>
Implement a function `hyperfact(num)` that takes a positive integer `num` and returns the hyperfactorial of it.
In order for your answer not to be too messy (hyperfactorial of 100 is 9015 digits long) give the answer modulo 1000000007.
<h2 style="color:#62d941">Notes</h2>
`1 <= n <= 300`
`50` random tests | reference | from itertools import accumulate
H = [0, * accumulate(range(1, 301), lambda a, n: a * n * * n % 1000000007)]
hyperfact = H . __getitem__
| The Hyperfactorial | 6324786fcc1a9700260a2147 | [
"Mathematics"
] | https://www.codewars.com/kata/6324786fcc1a9700260a2147 | 7 kyu |
```if-not:c
This kata is about static method that should return different values.
```
```if:c
This kata is about a function that should return different values.
```
On the first call it must be 1, on the second and others - it must be a double from previous value.
Look tests for more examples, good luck :) | reference | class Class:
value = 1
def get_number():
result = Class . value
Class . value *= 2
return result
| Double value every next call | 632408defa1507004aa4f2b5 | [
"Object-oriented Programming"
] | https://www.codewars.com/kata/632408defa1507004aa4f2b5 | 7 kyu |
I invented a new operator, ```@```, which is left associative.
```a @ b = (a + b) + (a - b) + (a * b) + (a // b)```
Side note: ```~~``` is shorthand for ```Math.floor```.
Given a string containing only integers and the operators, find out the value of that string.
The strings will always be "well formed", meaning with a space on each side of the operators, except in TypeScript, where string may appear like this: ```0@1@2```
```
1 @ 1 = (1 + 1) + (1 - 1) + (1 * 1) + (1 // 1) = 4
3 @ 2 = 13
6 @ 9 = 66
4 @ -4 = -9\
1 @ 1 @ -4 = -9 (1 @ 1 is 4, 4 @ -4 is -9)
2 @ 2 @ 2 = 40
0 @ 1 @ 2 = 0
5 @ 0 = None
```
Good luck! | algorithms | from functools import reduce
def evaluate(equation):
try:
return reduce(lambda a, b: a * (b + 2) + a / / b, map(int, equation . split(' @ ')))
except ZeroDivisionError:
pass
| The @ operator | 631f0c3a0b9cb0de6ded0529 | [
"Algorithms"
] | https://www.codewars.com/kata/631f0c3a0b9cb0de6ded0529 | 7 kyu |
I suggest you write a program that, having a string containing the solution of the level for the game Sokoban, will restore the original level.
<i>The rules of the Sokoban:</i><br>
The objective of the Sokoban game is to move objects (usually boxes) to designated locations by pushing them. These objects are located inside a room surrounded by walls. The user controls a pusher called "Sokoban" which is said to mean something like "warehouse keeper" in Japanese. The pusher can move up, down, left and right, but cannot pass through walls or boxes, and can only push one box at a time (never pull). At any time, a square can only be occupied by either a wall, a box, or the pusher.
<img src="https://upload.wikimedia.org/wikipedia/commons/4/4b/Sokoban_ani.gif">
You can read more about this game here:<br>
https://en.wikipedia.org/wiki/Sokoban<br>
http://www.sokobano.de/wiki/index.php?title=Main_Page<br><br>
you can play in this game:<br>
https://sourceforge.net/projects/sokobanyasc/<br>
https://sokoban.info/<br><br>
<b>TASK:</b>
as input, your function will receive a string containing the solution of the level. notation format "LURD"<br>
the characters "lurd" (lowercase) indicate the movement of the player to the left, up, right, down.<br>
the symbols "LURD" (in uppercase) indicate that the player pushes the box left, up, right, down.<br>
(letters in uppercase imply that the player is sure to push the box)
```
solution = "urrrrDrdddldlluuurRlldddrruruUluullllddddRluuuurrrrddrddldllUdrruruulllLrrruulllldDrrrrrddldlluUddrruruuluullllddrRRldddrruruuruLdddldlluuurUdldddrruruuuLuLLLrrrdrdddldlluuurUruLLrddRlldddrruruUruLLdlUruL"
```
at the output, your function should return the drawn level inside the text string.<br>
there must be no spaces at the end of substrings, and there must be an end-of-line character "\n"
```
map = """
#######
#... ###
#@##$$ #
# $ #
#.# ## ##
# $ # #
### ##
#####
"""
```
description of the level format you can find here:<br>
http://www.sokobano.de/wiki/index.php?title=Level_format<br>
Wall - "#", Player - "@", Player on goal - "+", Box - "$", Box on goal - "*", Goal - ".", Floor - " " (Space)<br><br>
when creating a level map, you should add a minimum of elements, only what is necessary. you can not add extra walls and boxes with which the player does not interact.<br>
Minimal amount of free space inside the outer bound. Minimal amount of boxes. Outer bound must be of thickness of 1, connected orthogonally and minimal. The level must be drawn with no extra spaces on either side.<br><br>
<b>Technical Details</b>
* Input will always be valid solution for real level.
* level size < 50*50
* you need find solution for 35 hand-made levels, +90 random-generated levels | algorithms | # Just having some fun with the new match/case :D
def level_recovery(solution):
D, boxes, i, j = {}, set(), 0, 0
for c in solution:
D[(i, j)] = ' '
match c:
case 'l' | 'L': k, l = 0, - 1
case 'r' | 'R': k, l = 0, 1
case 'u' | 'U': k, l = - 1, 0
case 'd' | 'D': k, l = 1, 0
if c . isupper():
if (i + k, j + l) not in D:
boxes . add((i + k, j + l))
D[(i + k, j + l)] = ' '
D[(i + 2 * k, j + 2 * l)] = '.'
i, j = i + k, j + l
for i, j in boxes:
match D[(i, j)]:
case '.': D[(i, j)] = '*'
case ' ': D[(i, j)] = '$'
match D[(0, 0)]:
case '.': D[(0, 0)] = '+'
case ' ': D[(0, 0)] = '@'
Y, X = zip(* D)
x, y = min(X) - 1, min(Y) - 1
H, W = max(Y) - y + 2, max(X) - x + 2
res = [[' '] * W for _ in range(H)]
for i in range(H):
for j in range(W):
if (i + y, j + x) in D:
res[i][j] = D[(i + y, j + x)]
elif any((k + y, l + x) in D for k in range(i - 1, i + 2) for l in range(j - 1, j + 2)):
res[i][j] = '#'
return '\n' . join(map(str . rstrip, map('' . join, res)))
| Sokoban re-solver : level recovery from solution | 6319f8370b9cb0ffc2ecd58d | [
"Game Solvers",
"Games",
"Puzzles",
"Algorithms"
] | https://www.codewars.com/kata/6319f8370b9cb0ffc2ecd58d | 5 kyu |
_The world of reality has its limits; the world of imagination is boundless._
Jean-Jacques Rousseau
Each positive integer may have a specific set of pairs of factors which each value equals the number.
But, how can it possible to get an _area value_ for each positive integer?
In order to get that value for an integer, ```N, N > 0```, we should follow the next steps described below:
1. We get a list of all the pairs of *a<sub>i</sub> ,
b<sub>i</sub>* such that: *a<sub>i</sub> ×
b<sub>i</sub> = N*
2. We sort the pairs by the value of the first factor.
3. We represent each pair of factors as it were a
point with its coordinates in a cartesian system,
the value of a<sub>i</sub> for the x-axis and the
b<sub>i</sub> for y-axis coordinates.
4. We draw vertical lines at x = 1 and at x = N
5. We join the contiguous points with segments and we
will obtain an irregular polygonal line or a
triangle in some easier cases.
6. We calculate the area below the polygonal line
between the two vertical lines and the x- axis.
7. We round the value to the lower integer, ```area --> ⌊a⌋```
Let´s see an example with N = 12.
The factors obtained are (already sorted by first factor):
```(1, 12), (2, 6), (3, 4), (4, 3), (6, 2), (12, 1)```
Because:
```12 = 1 × 12 = 2 × 6 = 3 × 4 = 6 × 2 = 12 × 1```
Following all the steps explained above we have the following image:
<a href="https://ibb.co/fMrSnXP"><img src="https://i.ibb.co/MnPhGg3/geogebra-export.png" alt="geogebra-export" border="0"></a>
As you can see the associated value for ```12``` will be the value of the coloured area ```31.5```.
We round down the value and we get ```31```.
Another example with a perfect square, ```N = 16```.
The factors pairs for it are:
```(1, 16), (2, 8), (4, 4), (8, 2), (16, 1)```
The corresponding area value for the integer ```16``` is ```48```.
Let´s get this associated value por a prime number, let´s see, ```N = 23```
The factors for this number will be:
```(1,23), (23,1)```
So the value for the area will be ```264```.
If the value of ```N``` is ```1```, it is easy to figure out the the area associated value should be ```0```. But if ```N = 0``, there is no associated value.
**_TASK_**
You have to create a code that receives a positive integer N, and outputs another integer, A<sub>N</sub>, the associated value for the area.
Summarizing the inputs with their corresponding output and adding some new ones:
```
N AN
1 0
12 31
16 38
23 264
36 136
100 495
```
You will have to pass ```500``` tests and the values in the following range:
1 ≤ N < 1 × 10<sup>13</sup>
You will find more fixed cases in the sample box.
Enjoy it!
I´ll appreciate all the observations, suggestions or issues from users that want quality and simplicity.
I'm preparing the JavaScript and Ruby versions for it.
| reference | def area_value(n):
res, i, j = 0, 1, 2
while j * j <= n:
if n % j == 0:
res += n / / i * j - n / / j * i
i = j
j += 1
return 0 if n < 2 else res + ((n / / i) * * 2 - i * i) / / 2
| Positive Integers Having Specific Area? # 1 | 631373e489d71c005d880f18 | [
"Mathematics",
"Geometry"
] | https://www.codewars.com/kata/631373e489d71c005d880f18 | 6 kyu |
In a string we describe a road. There are cars that move to the right and we denote them with ">" and cars that move to the left and we denote them with "<". There are also cameras that are indicated by: " . ".
<br>
A camera takes a photo of a car if it moves to the direction of the camera.
<b style="font-size: 20px;">Task</b> <br>
Your task is to write a function such that, for the input string that represents a road as described, returns the total number of photos that were taken by the cameras. The complexity should be strictly O(N) in order to pass all the tests.
<br>
<b>Examples</b>
```javascript
For ">>." -> 2 photos were taken
For ".>>" -> 0 photos were taken
For ">.<." -> 3 photos were taken
For ".><.>>.<<" -> 11 photos were taken
``` | algorithms | def count_photos(road):
photos = 0
left = 0
dot_founds = 0
for item in road:
if item == ">":
left += 1
elif item == ".":
photos += left
dot_founds += 1
elif item == "<":
photos += dot_founds
return photos
| Count the photos! | 6319dba6d6e2160015a842ed | [
"Algorithms",
"Performance",
"Arrays"
] | https://www.codewars.com/kata/6319dba6d6e2160015a842ed | 6 kyu |
You are given a list/array of example equalities such as:
[ "a + a = b", "b - d = c ", "a + b = d" ]
Use this information to solve a given `formula` in terms of the remaining symbol such as:
formula = "c + a + b"
In this example:
"c + a + b" = "2a"
so the output is `"2a"`.
Notes:
* Variables names are case sensitive.
* There might be whitespaces between the different characters. Or not...
* There should be support for parentheses and their coefficient. Example: `a + 3 (6b - c)`.
* You may encounter several imbricated levels of parentheses, but you'll get only constant terms for the accompanying coefficients (never variables).
* All equations will be linear.
* In your final answer, include a leading 1 when the coefficient is 1 (e.g. `1j` instead of just `j`).
* There are no floating-point numbers.
See the sample tests for clarification on what exactly the input/ouput formatting should be.
Without giving away too many hints, the idea is to substitute the examples into the formula and reduce the resulting equation to one unique term. Look carefully at the example tests: you'll have to identify the pattern used to replace variables in the formula/other equations. Using this pattern, only one solution is possible for each test, so if you keep asking yourself "but what if instead of that I do...", then you've missed the pattern.
```if:ruby
Note: `eval` and other related things have been disabled.
```
| games | import re
token = re . compile(r'([+-]?)\s*(\d*)\s*([a-zA-Z\(\)])')
def substitute(formula, substitutes):
res = formula
for var, sub in substitutes:
res = res . replace(var, '({})' . format(sub))
return res if res == formula else substitute(res, substitutes)
def reduce(tokens):
res = dict()
for sign, num, var in tokens:
if var == ')':
return res
coef = int(sign + (num or '1'))
if var == '(':
for k, v in reduce(tokens). items():
res[k] = res . get(k, 0) + coef * v
else:
res[var] = res . get(var, 0) + coef
return res
def simplify(examples, formula):
substitutes = [(k . strip(), v)
for v, k in map(lambda x: x . split('='), examples)]
subbed = substitute(formula, substitutes)
reduced = reduce(iter(token . findall(subbed)))
return '' . join(map('{0[1]}{0[0]}' . format, reduced . items()))
| Simplifying | 57f2b753e3b78621da0020e8 | [
"Games",
"Puzzles"
] | https://www.codewars.com/kata/57f2b753e3b78621da0020e8 | 3 kyu |
A continuation kata published: [Integer factorization: CFRAC basics](https://www.codewars.com/kata/63348506df3ef80052edf587)
## General info
A [continued fraction](https://en.wikipedia.org/wiki/Continued_fraction) is a mathematical expression of the following form:
```math
[a_0; a_1, a_2, a_3, ..., a_n, ...] = a_0 + \cfrac{1}{ a_1 + \cfrac{1}{ a_2 + \cfrac{1}{ \ddots + \cfrac{1}{a_n + \dots} } } }
```
Any real number may be represented in the following form with integer coefficients. In fact, all rational numbers have finite representation, and all irrational numbers have infinite representation. The latter case is exactly, what we've come for today :D
The specific numbers we are obsessed with in this kata are <u>square roots of natural numbers</u>. Continued fractions of square roots are **periodic** and always take a specific form:
```math
\sqrt{N} = [a_0; \overline{a_1, a_2, a_3, ..., a_3, a_2, a_1, 2 a_0}] = a_0 + \cfrac{1}{ a_1 + \cfrac{1}{ a_2 + \cfrac{1}{ \ddots + \cfrac{1}{a_2 + \cfrac{1}{ a_1 + \cfrac{1}{ 2 a_0 + \cfrac{1}{ a_1 + \dots } } }} } } }
```
## The task
```if:python,javascript
Your task will be to write a <u>generator function to yield integer coefficients of the continued fraction of `sqrt(N)`</u>. Not only coefficients must be precise, but you'll have to deal with numbers up to `2^1024`.
```
```if:racket,java
Your task will be to write a <u>stream of integer coefficients of the continued fraction, of `sqrt(N)`</u>. Not only coefficients must be precise, but you'll have to deal with numbers up to `2^1024`.
```
Tip: the amount of coefficients before hitting the period is bounded by `0.72 * sqrt(N)`, but obviously we cannot generate that much in adequate time for big numbers. The test suite expects your code to generate <u>2000-4000 coefficients for a single number</u>.
You may want to solve other katas about continued fractions:
- [Evaluating Continued Fractions](https://www.codewars.com/kata/6013d4f5c7c63100095952aa)
- [Exponentials as Fractions](https://www.codewars.com/kata/54f5f22a00ecc4184c000034)
- [Pi approximation fractions](https://www.codewars.com/kata/5b7c17fabd29b22df000004f)
- [Convergents of e](https://www.codewars.com/kata/5a8d63930025e92f4c000086) | algorithms | from typing import Generator
from math import isqrt
def generate_continued_fraction(n) - > Generator[int, None, None]:
a0 = isqrt(n)
a, b, c = a0, 0, 1
yield a0
while True:
b = c * a - b
c = (n - b * b) / / c
if not c:
break
a = (a0 + b) / / c
yield a
while True:
yield 0
| Infinite continued fractions | 63178f6f358563cdbe128886 | [
"Mathematics",
"Fundamentals",
"Performance"
] | https://www.codewars.com/kata/63178f6f358563cdbe128886 | 5 kyu |
<div style="width: 100%; margin: 16px 0; border-top: 1px solid grey;" />
- This is Part 2 of this series of two katas — Part 1 is [here](https://www.codewars.com/kata/630647be37f67000363dff04).
- If you like playing cards, have also a look at [Hide a message in a deck of playing cards](https://www.codewars.com/kata/59b9a92a6236547247000110) and [Card-Chameleon, a Cipher with Playing cards](https://www.codewars.com/kata/59c2ff946bddd2a2fd00009e).
<div style="width: 100%; margin: 16px 0; border-top: 1px solid grey;" />
In [Part 1](https://www.codewars.com/kata/630647be37f67000363dff04) of this series, we were given a deck and we had to return the order of the cards once drawn using a particular procedure.
Here, we will do the opposite: we will be given the drawn cards, and we'll have to return the deck that would produce this result if drawn using the procedure.
The procedure isn't explained here again, please read it on [Part 1](https://www.codewars.com/kata/630647be37f67000363dff04).
# Your task
Write a function accepting a list of cards as argument, and returning the deck that would produce this list of cards if drawn using the procedure.
```javascript
const prepareDeck = (result) => {
```
```coffeescript
prepareDeck = (result) -> {
```
```typescript
export const prepareDeck = (result: string[]): string[] => {
```
```python
def prepare_deck(drawn_cards):
```
Cards are represented in the same way than in [Part 1](https://www.codewars.com/kata/630647be37f67000363dff04); the same preloaded function is available to print cards on the console.
# Example
```javascript
const result = ["KC", "QC", "KD", "QD", "KH", "QH", "KS", "QS"];
prepareDeck(deck);
```
```coffeescript
result = ["KC", "QC", "KD", "QD", "KH", "QH", "KS", "QS"]
prepareDeck(deck)
```
```typescript
const result = ["KC", "QC", "KD", "QD", "KH", "QH", "KS", "QS"];
prepareDeck(deck);
```
```python
drawn_cards = ['KC','QC','KD','QD','KH','QH','KS','QS']
prepare_deck(drawn_cards)
```
should return:
```javascript
["KC", "KH", "QC", "KS", "KD", "QH", "QD", "QS"];
```
```coffeescript
["KC", "KH", "QC", "KS", "KD", "QH", "QD", "QS"]
```
```typescript
["KC", "KH", "QC", "KS", "KD", "QH", "QD", "QS"];
```
```python
['KC','KH','QC','KS','KD','QH','QD','QS']
```
# Have fun!
I hope you will enjoy this kata! Feedbacks and translations are very welcome.
| algorithms | from collections import deque
def prepare_deck(drawn_cards):
deck = deque()
for c in reversed(drawn_cards):
deck . rotate(1)
deck . appendleft(c)
return list(deck)
| Playing Cards Draw Order – Part 2 | 6311b2ce73f648002577f04a | [
"Games",
"Permutations",
"Algorithms"
] | https://www.codewars.com/kata/6311b2ce73f648002577f04a | 6 kyu |
<div style="width: 100%; margin: 16px 0; border-top: 1px solid grey;" />
- This is Part 1 of this series of two katas — Part 2 is [here](https://www.codewars.com/kata/6311b2ce73f648002577f04a).
- If you like playing cards, have also a look at [Hide a message in a deck of playing cards](https://www.codewars.com/kata/59b9a92a6236547247000110) and [Card-Chameleon, a Cipher with Playing cards](https://www.codewars.com/kata/59c2ff946bddd2a2fd00009e).
<div style="width: 100%; margin: 16px 0; border-top: 1px solid grey;" />
In this series of two katas, we will draw playing cards from a deck using a particular procedure: after drawing one card, we place the next one at the bottom of the deck.
In details, the procedure is:
1. We draw the top card of the deck.
2. We take the next card, and put it at the bottom of the deck.
3. We repeat steps 1 and 2 until there aren't any card left in the deck.
Let's take a small deck containing four cards — named A, B, C, D — as an example:
1. The deck order is `A-B-C-D` at the beginning, the card `A` is at the top and `D` at the bottom.
2. `A` is drawn. The deck is now `B-C-D`.
3. `B` is placed at the bottom of the deck. The deck is now `C-D-B`.
4. `C` is drawn. The deck is now `D-B`.
5. `D` is placed at the bottom of the deck. The deck is now `B-D`.
6. `B` is drawn. The deck is now `D`.
7. `D` is drawn.
The order of the cards drawn is `A-C-B-D`.
# Your task
Write a function accepting a deck of cards as argument, and returning the cards drawn following the procedure.
```javascript
const draw = (deck) => {
```
```coffeescript
draw = (deck) ->
```
```typescript
export const draw = (deck: string[]): string[] => {
```
```java
public static List<String> draw(List<String> deck) {
```
Each card is represented with a two-character string: the rank of the card and its suit.
`AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC` for the Clubs<br />
`AD 2D 3D 4D 5D 6D 7D 8D 9D TD JD QD KD` for the Diamonds<br />
`AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH` for the Hearts<br />
`AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS` for the Spades<br />
A preloaded function allows to easily print a deck to the console:
```javascript
printDeck(deck, unicode);
```
```coffeescript
printDeck deck, unicode
```
```typescript
import { printDeck } from "./preloaded";
printDeck(deck, unicode);
```
```java
DeckPrinter.printDeck(deck, unicode);
```
The first argument is the deck to print, the second one is a boolean value allowing the selection of the character set: regular or Unicode (for which a font containing the playing cards characters needs to be installed on your system).
# Example
```javascript
const deck = ["KC", "KH", "QC", "KS", "KD", "QH", "QD", "QS"];
draw(deck);
```
```coffeescript
deck = ["KC", "KH", "QC", "KS", "KD", "QH", "QD", "QS"]
draw deck
```
```typescript
const deck = ["KC", "KH", "QC", "KS", "KD", "QH", "QD", "QS"];
draw(deck);
```
```java
List<String> deck = Arrays.asList(new String[] {"KC", "KH", "QC", "KS", "KD", "QH", "QD", "QS"});
CardDraw.draw(deck);
```
should return:
```javascript
["KC", "QC", "KD", "QD", "KH", "QH", "KS", "QS"];
```
```coffeescript
["KC", "QC", "KD", "QD", "KH", "QH", "KS", "QS"]
```
```typescript
["KC", "QC", "KD", "QD", "KH", "QH", "KS", "QS"];
```
```java
["KC", "QC", "KD", "QD", "KH", "QH", "KS", "QS"];
```
# Have fun!
I hope you will enjoy this kata! Feedbacks and translations are very welcome.
After this one, jump to [Part 2](https://www.codewars.com/kata/6311b2ce73f648002577f04a), where we will be ordering the deck to be drawn to have a chosen result!
| algorithms | def draw(deck):
order = []
while deck:
order . append(deck . pop(0))
if deck:
deck . append(deck . pop(0))
return order
| Playing Cards Draw Order – Part 1 | 630647be37f67000363dff04 | [
"Mathematics",
"Games",
"Permutations"
] | https://www.codewars.com/kata/630647be37f67000363dff04 | 7 kyu |
> The Twenty-One Card Trick, also known as the 11th card trick or three column trick, is a simple self-working card trick that uses basic mathematics to reveal the user's selected card.
> The game uses a selection of 21 cards out of a standard deck. These are shuffled and the player selects one at random. The cards are then dealt out face up in three columns of 7 cards each. The player points to the column containing their card. The cards are picked up and the process is repeated three times, at which point the magician reveals the selected card.
Source: [Wikipedia](https://en.wikipedia.org/wiki/Twenty-One_Card_Trick)
Your task is to implement an algorithm that is able to execute the Twenty-One Card Trick. To simplify things, the cards will be changed to the set of integers between 1 and 21(inclusive). The function will be passed as argument a member of the audience that has selected a certain card and has a method ```get_input``` that receives a list of 3 lists as arguments and returns the index of the column containing the selected card. Example:
```python
audience = Audience(13) # The audience member has selected the card 13
> audience.get_input([[1,2,3,4,5,6,7], [8,9,10,11,12,13,14], [15,16,17,18,19,20,21]])
1 # Since 13 is at the 2nd column
```
```ruby
audience = Audience.new 13
> audience.get_input [[1,2,3,4,5,6,7], [8,9,10,11,12,13,14], [15,16,17,18,19,20,21]]
1 # Since 13 is at the 2nd column
```
```javascript
const audience = new Audience(13);
> audience.getInput([[1,2,3,4,5,6,7], [8,9,10,11,12,13,14], [15,16,17,18,19,20,21]]);
1 // Since 13 is at the 2nd column
```
```c
// In C there is no audience object, you call get_input() directly:
get_input((int[]){1,2,3,4,5,6,7}, (int[]){8,9,10,11,12,13,14}, (int[]) {15,16,17,18,19,20,21});
// == 1, since 13 is in the 2nd column
```
After 3 times it is asked, however, the audience member no longer will give an answer. Use these three functions invokations to discover which card the audience member has. | games | DECK = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11,
12, 13, 14, 15, 16, 17, 18, 19, 20, 21]
def guess_the_card(audience):
deck = DECK
for _ in range(3):
deal = [deck[:: 3], deck[1:: 3], deck[2:: 3]]
deal . insert(1, deal . pop(audience . get_input(deal)))
deck = sum(deal, [])
return deck[10]
| Mathemagics: the 21 Cards Trick | 62b76a4f211432636c05d0a9 | [
"Algorithms",
"Mathematics"
] | https://www.codewars.com/kata/62b76a4f211432636c05d0a9 | 7 kyu |
We have a positive integer ```N, N > 0```.
We have a special integer ```N1, N1 > N```, such that
```N1 = c ‧ d``` and ```N = c + d``` with the constraint that ```c ≠ d```
Let´s see an example:
```
N = 26 (starting integer)
```
The next integer ```N1```, chained with this property with ```N```, will be ```48```.
Because:
```
N1 = 2 x 24 = 48
N = 2 + 24 = 26
```
But there are another integers chained with ```N``` with the property shown above. In effect the next integer ```N2 = 69```
Let´s see:
```
N2 = 3 x 23 = 69
N = 3 + 23 = 26
```
The next integer ```N3``` is ```88``` and you may figure out the values for ```c``` and ```d```.
If we continue working trying to find the successive values of ```Ni``` for our starting integer ```N = 26``` we will find the following chain.
```
26 (N) --> 48 (N1) --> 69 (N2) --> 88 (N3) --> ........... --> 160 (N9) --> 165 (N10) --> 168 (N11)
```
You may work to obtain the intermediate values of the above incomplete chain for the starting integer```26```
In the example above ```169``` is discarded as a solution, because as we said before ```c``` and ```d``` should be different.
The task for this exercise is the following:
*Given a starting integer you have to find the maximum chained integer that fulfills the property explained above*
Your code should output an integer in all cases.
You will receive always an integer as an input.
Special Cases
* If your starting integer is less than ```5```, we do not have a result higher than your starting integer. In those cases your code should output ```-1```. As an example:
```
input:4; output:-1
```
You will see more examples in the fixed examples of the sample box.
You have to pass 200 random tests and the values for the starting ```N``` are in the following range:
```c
1000 < N < 1 * 10^9
```
```cpp
1000 < N < 1 * 10^9
```
```js
10 < N < 1 x 10^14
```
```cobol
10 < N < 1 x 10^14
```
```csharp
10 < N < 1 x 10^9
```
```java
10 < N < 1 x 10^9
```
```python
10 < N < 1 x 10^14
```
```ruby
10 < N < 1 x 10^14
```
```typescript
10 < N < 1 x 10^14
```
I hope that this challenge will be useful for all the coding lovers.
Special Acknowledgements for two Codewarriors: Unnamed and macambira for their observations done in the beta phase. | reference | def max_int_chain(n):
return - 1 if n < 5 else (n / / 2) * (n - n / / 2) if n % 2 else (n / / 2 - 1) * (n / / 2 + 1)
| I Will Take the Biggest One and Nothing Else. | 631082840289bf000e95a334 | [
"Mathematics"
] | https://www.codewars.com/kata/631082840289bf000e95a334 | 7 kyu |
Now that you’re back to school for another term, you need to remember how to work the combination lock on your locker. The lock has a dial with 40 calibration marks numbered 0 to 39 in clockwise order. A combination of this lock consists of 3 of these numbers; for example: 15-25-8.
> Note that the numbers/markings are on the dial, not the casing. Have a good look at the image above.
To open the lock, the following steps are taken:
```
1. Turn the dial clockwise 2 full turns
2. Continue turning clockwise until the 1st number is reached
3. Turn the dial counter-clockwise 1 full turn
4. Continue turning counter-clockwise until the 2nd number is reached
5. Turn the dial clockwise again until the 3rd number is reached
6. Pull the shank and the lock will open.
```
Given the initial position of the dial and the combination for the lock, how many degrees is the dial rotated in total (clockwise plus counter-clockwise) in opening the lock?
> Note that we're looking for the total degrees of rotation, regardless of the direction of rotation. For instance, if you rotated 720° clockwise and 360° counter-clockwise, the total is 1080°.
**Input**
There is a line of input containing 4 numbers between 0 and 39. The first number is the position of the dial. The next three numbers are the combination.
Consecutive numbers in the combination will be distinct.
**Output**
Return the number of degrees that the dial must be turned to open the lock.
A few examples are:
```
degreesOfLock(0, 30, 0, 30) -> 1350
degreesOfLock(5, 35, 5, 35) -> 1350
degreesOfLock(0, 20, 0, 20) -> 1620
degreesOfLock(7, 27, 7, 27) -> 1620
degreesOfLock(0, 10, 0, 10) -> 1890
degreesOfLock(9, 19, 9, 19) -> 1890
```
| algorithms | def degrees_of_lock(initial, first, second, third):
return 1080 + ((initial - first) % 40 + (second - first) % 40 + (second - third) % 40) * 9
| Combination Lock | 630e55d6c8e178000e1badfc | [
"Mathematics"
] | https://www.codewars.com/kata/630e55d6c8e178000e1badfc | 6 kyu |
## Task
Given a list of points, construct a graph that includes all of those points and the position **(0, 0)**.
```if:javascript
Points will be objects like so: `{x: 1, y: -1}`.
```
```if:coffeescript
Points will be objects like so: `{x: 1, y: -1}`.
```
```if:python
Points will be dictionaries like so: `{"x": 1, "y": -1}`.
```
```if:java
Points will be java.awt.Point like so: `new Point(1, -1)`.
```
```if:php
Points will be array like so: `["x" => 1, "y" => 1]`.
```
A graph should be represented as a 2d array.
## Example:
```javascript,coffescript
Input:
constructGraph([{x: 2, y: 2}, {x: -2, y: -2}])
Output:
[
[' ', ' ', '|', ' ', '*'],
[' ', ' ', '|', ' ', ' '],
['-', '-', '+', '-', '-'],
[' ', ' ', '|', ' ', ' '],
['*', ' ', '|', ' ', ' '],
]
```
```python
Input:
construct_graph([{"x": 2, "y": 2}, {"x": -2, "y": -2}])
Output:
[
[' ', ' ', '|', ' ', '*'],
[' ', ' ', '|', ' ', ' '],
['-', '-', '+', '-', '-'],
[' ', ' ', '|', ' ', ' '],
['*', ' ', '|', ' ', ' '],
]
```
```java
Input:
ConstructAGraph.build(new Point[] {new Point(2, 2), new Point(-2, -2)})
Output:
[
[' ', ' ', '|', ' ', '*'],
[' ', ' ', '|', ' ', ' '],
['-', '-', '+', '-', '-'],
[' ', ' ', '|', ' ', ' '],
['*', ' ', '|', ' ', ' '],
]
```
```php
Input:
constructGraph([["x" => 2, "y" => 2], ["x" => -2, "y" => -2]])
Output:
[
[' ', ' ', '|', ' ', '*'],
[' ', ' ', '|', ' ', ' '],
['-', '-', '+', '-', '-'],
[' ', ' ', '|', ' ', ' '],
['*', ' ', '|', ' ', ' '],
]
```
Points on the graph are represented as `'*'`, and the position **(0, 0)** is represented by a `'+'`.
All positions along the **x axis** should be `'-'`, and all postions along the **y axis** should be `'|'`. The rest of the positions should be spaces: `' '`.
Also, if a point is on the x or y axis, the default char should be replaced with the point char: `'*'`.
## Example:
```javascript,coffescript
Input:
constructGraph([{x: 0, y: 0}, {x: 1, y: 4}]);
Output:
[
['|', '*']
['|', ' '],
['|', ' '],
['|', ' '],
['*', '-']
]// ^
//this is (0, 0)
```
```python
Input:
construct_graph([{"x": 0, "y": 0}, {"x": 1, "y": 4}])
Output:
[
['|', '*']
['|', ' '],
['|', ' '],
['|', ' '],
['*', '-']
]# ^
# this is (0, 0)
```
```java
Input:
ConstructAGraph.build(new Point[]{ new Point(0, 0), new Point(1, 4)});
Output:
[
['|', '*']
['|', ' '],
['|', ' '],
['|', ' '],
['*', '-']
]// ^
//this is (0, 0)
```
```php
Input:
constructGraph([["x" => 0, "y" => 0], ["x" => 1, "y" => 4]]);
Output:
[
['|', '*']
['|', ' '],
['|', ' '],
['|', ' '],
['*', '-']
]// ^
//this is (0, 0)
```
Graphs should be as minimal as posible while still retaining a rectangular shape. They should be just large enough to include all the points and the position **(0, 0)**.
If no points are given, the graph should just include the position **(0, 0)**. Points might have the same value sometimes.
## More Examples:
```javascript,coffescript
Input:
constructGraph([]);
Output:
[['+']]
```
```javascript,coffescript
Input:
constructGraph([{x: 1, y: 2}, {x: 1, y: 2}]);
Output:
[
['|', '*'],
['|', ' '],
['+', '-']
]
```
```javascript,coffescript
Input:
constructGraph([{x: 0, y: 3}]);
Output:
[
['*'],
['|'],
['|'],
['+']
]
```
```javascript,coffescript
Input:
constructGraph([{x: -2, y: -3}, {x: 1, y: -3}]);
Output:
[
['-', '-', '+', '-'],
[' ', ' ', '|', ' '],
[' ', ' ', '|', ' '],
['*', ' ', '|', '*']
]
```
```python
Input:
construct_graph([])
Output:
[['+']]
```
```python
Input:
construct_graph([{"x": 1, "y": 2}, {"x": 1, "y": 2}])
Output:
[
['|', '*'],
['|', ' '],
['+', '-']
]
```
```python
Input:
construct_graph([{"x": 0, "y": 3}])
Output:
[
['*'],
['|'],
['|'],
['+']
]
```
```python
Input:
construct_graph([{"x": -2, "y": -3}, {"x": 1, "y": -3}])
Output:
[
['-', '-', '+', '-'],
[' ', ' ', '|', ' '],
[' ', ' ', '|', ' '],
['*', ' ', '|', '*']
]
```
```java
Input:
ConstructAGraph.build(new Point[] {});
Output:
[['+']]
```
```java
Input:
ConstructAGraph.build(new Point[] {new Point(1, 2), new Point(1, 2)});
Output:
[
['|', '*'],
['|', ' '],
['+', '-']
]
```
```java
Input:
ConstructAGraph.build(new Point[] {new Point(0, 3)});
Output:
[
['*'],
['|'],
['|'],
['+']
]
```
```java
Input:
ConstructAGraph.build(new Point[] {new Point(-2, -3), new Point(1, -3)});
Output:
[
['-', '-', '+', '-'],
[' ', ' ', '|', ' '],
[' ', ' ', '|', ' '],
['*', ' ', '|', '*']
]
```
```php
Input:
constructGraph([]);
Output:
[['+']]
```
```php
Input:
constructGraph([["x" => 1, "y" => 2], ["x" => 1, "y" => 2]]);
Output:
[
['|', '*'],
['|', ' '],
['+', '-']
]
```
```php
Input:
constructGraph([["x" => 0, "y" => 3]]);
Output:
[
['*'],
['|'],
['|'],
['+']
]
```
```php
Input:
constructGraph([["x" => -2, "y" => -3], ["x" => 1, "y" => -3]]);
Output:
[
['-', '-', '+', '-'],
[' ', ' ', '|', ' '],
[' ', ' ', '|', ' '],
['*', ' ', '|', '*']
]
```
| reference | def construct_graph(points):
if not points:
return [['+']]
min_x = min(0, min(point['x'] for point in points))
min_y = min(0, min(point['y'] for point in points))
max_x = max(0, max(point['x'] for point in points))
max_y = max(0, max(point['y'] for point in points))
graph = [[' '] * (max_x - min_x + 1) for _ in range(min_y, max_y + 1)]
def set(x, y, c): graph[max_y - y][x - min_x] = c
for x in range(min_x, max_x + 1):
set(x, 0, '-')
for y in range(min_y, max_y + 1):
set(0, y, '|')
set(0, 0, '+')
for point in points:
set(point['x'], point['y'], '*')
return graph
| Construct a Graph | 630649f46a30e8004b01b3a3 | [
"Graphs",
"ASCII Art"
] | https://www.codewars.com/kata/630649f46a30e8004b01b3a3 | 6 kyu |
# Story & Task
You're a pretty busy billionaire, and you often fly your personal Private Jet to remote places. Usually travel doesn't bother you, but this time you are unlucky: it's New Year's Eve, and since you have to fly halfway around the world, you'll probably have to celebrate New Year's Day in mid-air!
Your course lies west of your current location and crosses several time zones. The pilot told you the exact schedule: it is known that you will take off at `takeOffTime`, and in `minutes[i]` after takeoff you will cross the `i`-th border between time zones. After crossing each border you will have to set your wrist watch one hour earlier (every second matters to you, so you can't let your watch show incorrect time). It is guaranteed that you won't cross the IDL (International Dateline), i.e. after crossing each time zone border your current time will be set one hour back.
You've been thinking about this situation and realized that it might be a good opportunity to celebrate New Year's Day more than once, i.e. each time your wrist watch shows 00:00. Assuming that you set your watch immediately after the border is crossed, how many times will you be able to celebrate this New Year's Day with a nice bottle of champagne? Note that the answer should include celebrations both in mid-air and on the ground (it doesn't matter if the plane landed in the last time zone before the midnight or not, you'll not let the last opportunity to celebrate New Year slip through your fingers).
# Example
For `takeOffTime = "23:35" and minutes = [60, 90, 140]` the output should be `3`.
Here is the list of events by the time zones:
```
initial time zone:
at 23:35 your flight starts;
at 00:00 you celebrate New Year for the first time;
at 00:35 (60 minutes after the take off) you cross the first border;
time zone -1:
at 23:35 you cross the border (00:35 by your initial time zone);
at 00:00 you celebrate New Year for the second time
(01:00 by your initial time zone);
at 00:05 (90 minutes after the take off) you cross the second border;
time zone -2:
at 23:05 you cross the border;
at 23:55 (140 minutes after the take off) you cross another border;
time zone -3:
at 22:55 you cross the border;
at 00:00 you celebrate New Year for the third time.
Thus, the output should be 3. That's a lot of champagne!
```
# Input/Output
- `[input]` string `takeOffTime`
The take off time in the 24-hour format `"HH:MM"`. It is guaranteed that the given time is valid.
The `"00:00"` time corresponds to the midnight of 31st of December / 1st of January. Any other time is before the new year (31st of December).
- `[input]` integer array `minutes`
A strictly increasing array of integers. `minutes[i]` stands for the number of minutes from the take off to crossing the `i`-th time zone border.
Constraints:
* `0 ≤ minutes.length ≤ 20`
* `1 ≤ minutes[i] ≤ 1500`
- [output] an integer
The number of times you will be able to celebrate New Year's Day. | games | def new_year_celebrations(take_off_time, minutes):
h, m = map(int, take_off_time . split(':'))
res, m = 0, 60 * h + m or 1440
for x in map(int . __sub__, minutes, [0] + minutes):
res += m <= 1440 and m + x >= 1440
m += x - 60
return res + (m <= 1440)
| Simple Fun #100: New Year Celebrations | 589816a7d07028ac5c000016 | [
"Puzzles"
] | https://www.codewars.com/kata/589816a7d07028ac5c000016 | 6 kyu |
Recently you had a quarrel with your math teacher. Not only that nerd demands knowledge of all the theorems, but he turned to be an constructivist devotee! After you recited by heart [Lagranges theorem of sum of four squares](https://en.wikipedia.org/wiki/Lagrange%27s_four-square_theorem), he now demands a computer program to obtain such a decomposition, so that to see that you really understand a topic. What a downer!
You remember well the theorem. Any positive integer can be decomposed into a sum of four squares of integers. Seems not too hard... But after a quarrel, your teacher wants blood. Apparently he will test your program on extremely huge numbers... And your program better finished working before the break - you don't want to get `F`, do you?
Tip: random tests feature 20 numbers as high as `2^128` and 20 number as high as `2^1024`. | algorithms | from typing import Tuple
from math import gcd
from gmpy2 import is_prime
def four_squares(n: int) - > Tuple[int, int, int, int]:
print(n)
if n == 0:
return 0, 0, 0, 0
twos = 1
while n % 4 == 0:
n / /= 4
twos *= 2
nums = []
if n % 8 == 7:
sqrtn = isqrt(n)
while (n - sqrtn * * 2) % 8 in [0, 4, 7]:
sqrtn -= 1
nums . append(sqrtn)
n -= sqrtn * * 2
else:
nums . append(0)
x = isqrt(n)
while 1:
k = n - x * * 2
k2 = k / / 2 if k % 2 == 0 else k
if k2 == 1 or (k2 % 4 == 1 and is_prime(k2)):
break
# print(x, k, k2)
x -= 1
k = n - x * * 2
nums . append(x)
k2 = k / / 2 if k % 2 == 0 else k
decomp = compose_2sq(prime_2sq(k2), [1, 1] if k % 2 == 0 else [1, 0])
nums += decomp
return tuple(num * twos for num in nums)
def prime_2sq(p):
if p == 1:
return (1, 0)
if p == 2:
return (1, 1)
for q in range(2, p):
if pow(q, (p - 1) / / 2, p) == p - 1:
break
x = pow(q, (p - 1) / / 4, p)
v = p, x
rems = []
sqrtp = isqrt(p)
while len(rems) < 2:
if v[1] <= sqrtp:
rems . append(v[1])
v = v[1], v[0] % v[1]
return rems[: 2]
def compose_2sq(x, y):
a, b = x
c, d = y
return [a * c + b * d, abs(a * d - b * c)]
def isqrt(n):
x0 = n / / 2
if x0:
x1 = (x0 + n / / x0) / / 2
while x1 < x0:
x0 = x1
x1 = (x0 + n / / x0) / / 2
return x0
return n
| Express number as sum of four squares | 63022799acfb8d00285b4ea0 | [
"Performance",
"Algorithms",
"Mathematics"
] | https://www.codewars.com/kata/63022799acfb8d00285b4ea0 | 1 kyu |
### Task
Use the characters `" "` and `"█"` to draw the nth iteration of the [Sierpiński carpet](https://en.wikipedia.org/wiki/Sierpi%C5%84ski_carpet). In the following you are given the first three iterations.
Implement `sierpinski_carpet_string(n)` which returns the Sierpiński carpet as string for `n` iterations.
n = 0:
██
n = 1:
██████
██░░██
██████
n = 2:
██████████████████
██░░████░░████░░██
██████████████████
██████░░░░░░██████
██░░██░░░░░░██░░██
██████░░░░░░██████
██████████████████
██░░████░░████░░██
██████████████████
# Note
1. Every line but the last ends with `\n`
2. Your solution must be under 4000 chars to avoid hardcoding solutions.
3. Don't let this mislead you: `░` is only used to visualize space ` ` above and in the test cases. Use space ` `. This is done since space is sometimes not displayed with a full length in Markdown which makes everything look bad.
| algorithms | def sierpinski_carpet_string(n):
m = ["██"]
for i in range(n):
m = [x + x + x for x in m] + \
[x + x . replace("█", " ") + x for x in m] + [x + x + x for x in m]
return "\n" . join(m)
| ASCII Sierpiński Carpet | 630006e1b4e54c7a7e943679 | [
"ASCII Art",
"Mathematics"
] | https://www.codewars.com/kata/630006e1b4e54c7a7e943679 | 6 kyu |
# Structural Pattern Matching:
___NOTE: Make Sure You Select Python 3.10 for Structural Pattern Matching.___
Read [PEP 636](https://peps.python.org/pep-0636/) may help you understand it.
This Kata is made to practice the Structural Pattern Matching.
___
# Examples of Structural Pattern Matching:
There is some special things in Structural Pattern Matching:
You can match with `sequence`, `or`, `guard`, `mapping`, using `as`,etc. Not just a replacement of `if ... elif ... elif ... else`, full details are in PEP636.
__Examples__
```python
match [1, 2, 3]:
case [x, y, z]:
print(x) # This would print: 1
print(y) # This would print: 2
print(z) # This would print: 3
# Different item to match, but it would not match the same pattern above.
match '123':
case [x, y, z]:
# This wouldn't match.
case _:
print(False) # This would match.
# another example
match ['item0', 'item1', 'item2', 'item3']:
case [*x, y]:
print(', '.join(x) + ' and ' + y) # This would print: item0, item1, item2 and item3
```
___
# Pluspoint of Structural Pattern Matching:
From [PEP635](https://peps.python.org/pep-0635/):
(This is just part of it, read PEP635 will give you full understanding of it.)
> The if ... elif ... elif ... else idiom is often used to find out the type or shape of an object in an ad-hoc fashion, using one or more checks like isinstance(x, cls), hasattr(x, "attr"), len(x) == n or "key" in x as guards to select an applicable block. The block can then assume x supports the interface checked by the guard. For example:
```python
if isinstance(x, tuple) and len(x) == 2:
host, port = x
mode = "http"
elif isinstance(x, tuple) and len(x) == 3:
host, port, mode = x
# Etc.
```
> Code like this is more elegantly rendered using match:
```python
match x:
case host, port:
mode = "http"
case host, port, mode:
pass
# Etc.
```
___
# Task:
You will get an `arg` which consists only of `0, 1, 2, 3, '0', '1', '2', '3'` (or none of them).
`arg` will be a string or list.
Return the result with the following rules:
* If `arg` is an empty list, return `0`
* If `arg` is a list with 1 element, `convert the element to integer if not yet an integer, then return it`.
* If `arg` is a list with 2 or more elements, convert the first and last elements to integer if not yet integers, then return `first element divided by the last element (float division)`.
* If divided by 0 or arg is not a list, return `None`.
___
# Examples (arg --> output)
```
('') --> None
([]) --> 0
(['2']) --> 2
([0]) --> 0
([3, 1, '2']) --> 1.5
('123') --> None
(['0', 0]) --> None
(['0', 2, '3']) --> 0.0
``` | reference | def matching(arg):
match arg:
case[]: return 0
case[x]: return int(x)
case[a, * _, 0 | '0']: return None
case[a, * _, b]: return int(a) / int(b)
| Practicing - Structural Pattern Matching | 62fd5b557d267aa2d746bc19 | [
"Fundamentals"
] | https://www.codewars.com/kata/62fd5b557d267aa2d746bc19 | 7 kyu |
In a computer operating system that uses paging for virtual memory management, page replacement algorithms decide which memory pages to page out when a page of memory needs to be allocated. Page replacement happens when a requested page is not in memory (page fault) and a free page cannot be used to satisfy the allocation, either because there are none, or because the number of free pages is lower than some threshold.
## The clock page replacement algorithm
The clock page replacement algorithm keeps a circular list of slots in memory, with the iterator pointing at the last examined slot in the list. When a page fault occurs and no empty slots exist, the algorithm checks the R-bit (referenced) of the page pointed by the iterator: if the R-bit is 0 the page pointed is removed from the memory, the new page is inserted and the iterator is moved forward, else if the R-bit is 1 it is set to 0 and the iterator is moved forward (this process is repeated until a page with an R-bit equal to 0 is found). Note that the R-bit is set to 1 when a page that is already in memory is referenced again.<br>
Your task is to implement this algorithm. The function will take two parameters as input: the number of maximum pages that can be kept in memory at the same time ```n``` and a ```reference list``` containing numbers. Every number represents a page request for a specific page (you can see this number as the unique ID of a page). The expected output is the status of the memory after the application of the algorithm. Note that when a page is inserted in the memory, it stays at the same position until it is removed from the memory by a page fault.
## Example:
The circular list is represented as a normal list with toroidal behaviour. Given:
* N = 3,
* REFERENCE LIST = \[6, 3, 6, 3, 2, 5, 1, 6\],
```
+---+---+
|VAL| R | * 6 is read, page fault
+---+---+ * 6 is inserted at position 0
| 6 | 0 | * the iterator is moved forward
+---+---+
--> | | |
+---+---+
| | |
+---+---+
+---+---+
|VAL| R | * 3 is read, page fault
+---+---+ * 3 is inserted at position 1
| 6 | 0 | * the iterator is moved forward
+---+---+
| 3 | 0 |
+---+---+
--> | | |
+---+---+
+---+---+
|VAL| R | * 6 is read, already in memory
+---+---+ * R-bit set to 1
| 6 | 1 |
+---+---+
| 3 | 0 |
+---+---+
--> | | |
+---+---+
+---+---+
|VAL| R | * 3 is read, already in memory
+---+---+ * R-bit set to 1
| 6 | 1 |
+---+---+
| 3 | 1 |
+---+---+
--> | | |
+---+---+
+---+---+
|VAL| R | * 2 is read, page fault
+---+---+ * 2 is inserted at position 2
--> | 6 | 1 | * the iterator is moved forward
+---+---+
| 3 | 1 |
+---+---+
| 2 | 0 |
+---+---+
+---+---+
|VAL| R | * 5 is read, page fault
+---+---+ * the R-bit of 6 is 1, we set it to 0 and move forward
--> | 6 | 0 | * the R-bit of 3 is 1, we set it to 0 and move forward
+---+---+ * the R-bit of 2 is 0, we remove it from memory
| 3 | 0 | * 5 is inserted at position 2
+---+---+ * the iterator is moved forward
| 5 | 0 |
+---+---+
+---+---+
|VAL| R | * 1 is read, page fault
+---+---+ * the R-bit of 6 is 0, we remove it from memory
| 1 | 0 | * 1 is inserted at position 0
+---+---+ * the iterator is moved forward
--> | 3 | 0 |
+---+---+
| 5 | 0 |
+---+---+
+---+---+
|VAL| R | * 6 is read, page fault
+---+---+ * the R-bit of 3 is 0, we remove it from memory
| 1 | 0 | * 6 is inserted at position 1
+---+---+ * the iterator is moved forward
| 6 | 0 |
+---+---+
--> | 5 | 0 |
+---+---+
```
So, at the end we have the list ```[1, 6, 5]```, which is what you have to return. If not all the slots in the memory get occupied after applying the algorithm, fill the remaining slots (at the end of the list) with ```-1``` to represent emptiness (note that the IDs will always be >= 1). | algorithms | def clock(n, xs):
ks, vs, ptr = [- 1] * n, [0] * n, 0
def inc():
nonlocal ptr
ptr = (ptr + 1) % n
for x in xs:
if x in ks:
vs[ks . index(x)] = 1
else:
while vs[ptr]:
vs[ptr] -= 1
inc()
ks[ptr] = x
inc()
return ks
| Page replacement algorithms: clock | 62f23d84eb2533004be50c0d | [
"Algorithms",
"Lists"
] | https://www.codewars.com/kata/62f23d84eb2533004be50c0d | 6 kyu |
### The Mandelbrot set
The [Mandelbrot set](https://en.wikipedia.org/wiki/Mandelbrot_set) is the set of complex numbers `$c$` for which the recursive function `$z = z^2 + c$` does not diverge to infinity when starting at `$z = 0$`
We will estimate for a set of values if they belong to the Mandelbrot set. For this estimation we will see if after `max_iterations` the absolute value of `$z$` stayed below 2: `$|z| \lt 2$`. If so we assume the complex number `$c$` to be part of the Mandelbrot set.
### The grid
Given a middle point `(x, y)` representing the complex number `x + yi` a `x_radius`, `y_radius` and `stepsize` parameter we can evaluate points to belong to the Mandelbrot set on an rectangular grid lying on the complex plane.
The `x_radius` and `y_radius` define how many points belong to the grid, left and right as well as top and bottom.
The following depicts a grid with the midpoint `X` with `x_radius = 3` and `y_radius = 1`
```
*******
***X***
*******
```
The `stepsize` decides the spacing between the gridpoints in `x`-direction. The stepsize in `y`-direction is chosen to be **double the stepsize** of the `x` dimension to counteract the 1:2 shape of a character.
### The visualization
We will estimate for each element `$c$` of the set of complex values on the grid if it belongs to the Mandelbrot set. If estimated to be inside the set, it is represented as solid block `'█'` otherwise as one of the following: `' ', '░', '▒', '▓'` depending on the iterations it took to find out its not part of the set.
The iterations `$i$` it took `$|z|$` to exceed 2 (or not in case of '█') decides which of `' ', '░', '▒', '▓', '█'` is used by a linear mapping for the index `char_idx = ⌊4 * i / max_iteraions⌋`
### Task
Implement `mandelbrot_string(x, y, x_radius, y_radius, stepsize, max_iter)` which returns a visualization of the mandelbrot set. Every line (but the final line) ends in an addiotinal newline character `"\n"` which makes the amount of chars of the returned string: `n = (x_radius*2+1+1) * (y_radius*2+1) - 1`.
***Notes:***
* Remember that `stepsize` is different in `x` and `y` direction
* Notice that the y-axis (imaginary axis) increases in value upwards like in most math plots.
* Dont forget the newline chars (except the last line)
* If the pictures are to big to be displayed on your screen, reduce the font size of the browser (ctrl and -)
### Examples
`mandelbrot_string(-0.8, 0, 27, 12, 0.05, 20)` returns
```
▓░
░░▒░▒█
░░░██▒░░
░░░░▒████▓░░
░░░░░░░░▒████▒░░░░░░▓
░░░▒██▓███████████▓▒▒▒▓▒
░░░░▒▒██████████████████▓░░
░▒░░░░░░░░░░▒▓███████████████████▓░▓
░░░▓▓▒▒█▒▒░░▒██████████████████████▒░░
░░░▒▓███████▒▓███████████████████████░
░░░░░░▒▒▒█████████████████████████████████░░
█████████████████████████████████████████████▒░░░
░░░░░░▒▒▒█████████████████████████████████░░
░░░▒▓███████▒▓███████████████████████░
░░░▓▓▒▒█▒▒░░▒██████████████████████▒░░
░▒░░░░░░░░░░▒▓███████████████████▓░▓
░░░░▒▒██████████████████▓░░
░░░▒██▓███████████▓▒▒▒▓▒
░░░░░░░░▒████▒░░░░░░▓
░░░░▒████▓░░
░░░██▒░░
░░▒░▒█
▓░
```
`mandelbrot_string(-1.15, 0.26, 45, 20, 1.4e-3, 60)` returns:
```
░░░░▒▓░▒▒▒░░░░░░░░░░░░░░░ ░░░░░░█░▒░▓░
░░░░░▒░░░░░░░░░░░░░░░░░░░░ ░░░░░░░░░░░░▒░░░░ ░
░░▒░░░░░░░░▒█░░░░░░░░░░░░░ ░░░░░░░░░░░░░░▒░░░░░░ ░░
░░░░░░░░░░░░▒░░▒░░▓░░░░░░░░░░░░░░░░░▓░░░▒█▒▒░░░░░░ ░░░░░░░░
░░░░░▒░▒▒████▒░░░░▒░░░░░░░░░░░▒▒█▒▒▒█▒░░░░░░ ░░░▒▒░▒░░░
░░░░░░░▒▒███▒▒▒░▓░░░░░░░░░░░░░▒▓▒░░░░░░░░░░ ░░░░▓░░░░░░
░░░░░░░▒▒▒▓▒░░▒░▓▓░░▒░░░░░░░█▒█▓▒░▒░░░░░░░░░ ░░░░░░░░░░░░
░░░░░░░░░░░░▒░░░░▒▓▓█▒▒░▒░░░█▓▒░░░░░░░░░░░░░░░░░░░░░░░░▒░░░░░░
░░░░░░░▒░░░░░░░░░▒░░▓▒▒▒▓█▒▒▒█▒░░░░░░░░░░░▒▒░░░░░░░░░░░░░░░▒░░░
░░░░░░░░░▒░░░░░░░░░░░░▒░░░░▒▒▒▒██▒░░▒░░░░░░░░░░░░░░░░░░░░░░░▒▒▓░░░
░░░░░▒░▒░░░░░░░░░░░░░▓░░░░░░░▒▒▒▓▒█▓░░░░░░░█░░░░░░░░░░░░░░░░░▒▒░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░█▓▒██▓▒▓░░░░▒█▒░░░░░░░░░░▒░▒░▒▒▓▓░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░▒▒█▒▓█▓▒▒▒▒▒▒█▒▒▒▓░░░░░░░░░░▒▒▓▒░░░▒░░░░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒▓██▓█▒▒█▓█▒▒▒░░░░▒░░░░▒▒▒█▓▒▒█▒▓░░▒▒░░░░░
░░░░░░░░░░░░░▒▒░▒▒███████████▓▒▒▒▒░░▒░░░░░░░▒██▓█▒▒▒▒▓▒░░░░░░░
░░░░░░░░░░░░▒██▒▒▒▓████████████▓▒▒▒▓█▒█▒▒▒▒▒▒▒██▓▓▒░░░░░░░░░░░░ ░░░
░░░░▒░░░░█░█▒█▓███████████████▓▒▒▒▒▒█▓▒▒▓▓▓▓▒▓██▓▒▒▒▓░░░░░▓░░░░░░░░░░░░
░░░░░░░▓▓░░█▒▒▒▒▒▒▓████████████▓█████████▓▓████████▒░░░░░▒▓░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░▒▒▓▓▓█████████████████████████████▓▓▒░░▒░░█▓░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░▒▒▒▒█▓████████████████████████████▓▒█▒▒██▒▓░░░░░░░░░░░░░░
░░▓░░░░▒░░▒░░░░▒░░░▒▓▒▒▓▓▓███████████████████████████████▒▒▒██▓▓▒▒░░░░░░░░░░▓░
░░░▒▓▒▒▓░░▒░░░░░▒▒███▓▓▓███████████████████████████████████▓███▒▒░░░░░░░░░░░▒▒
░░░░░░░▓▒█▓▒▒░░░░▒▒▒██████████████████████████████████████████▒░░░░░░░░░░░░█▒░
░░░░░░░░░▒▓▓▒▒▒▒▒▒▓▒▒▓██████████████████████████████████████▓▒██▒▒░░░░░░░░░░░▒
░░░░░░░░▒▒▓█▓█▒▒▒▒▒▓█▓▓████████████████████████████████████████▓██▒▒░░░░░░░░░░░░
░░░░░░░░░░░░░░▓▒░░▒██▓▒▒▒███▓▓███████████████████████████████████████████████▒░░░░░░█░░░░▒▒
░▒░░░░░░░░░░░▓█▒▓▒█▓▒░░░▓▒▓███████████████████████████████████████████████▓██▒▒░░░░▒▒▒░▒▒▒▒
░▒░░░░░░░░░▓▒▒░▓▒█░░░░░░▒▓██▓▓██████████████████████████████████████████████▓▒▒▒░░▒▒▒██████
░░░░░▒▒▒░░░░░░░░░░░░░░░░░█▒▒▒█▓▓████████████████████████████████████████████▒▒▒▒█▒▒▒▒▓█████
░░░░▒░░░░░░░░░░░░▒░░░░░░░░░░▒▒▒▒██████████████████████████████████████████▓▒▒▒▒▒█████▓█████
░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▓▓████████████████████████████████████████▓▒▒▒█████████████
░░░░░░░░░░░░░░░░░▒▒▒▒▓█▓▓▓████████████████████████████████████████▓▓▓▓██████████████
░░░░░░░░░░░░░░░░▒▓██████████████████████████████████████████████████████████████
░░░░░░░░░░░░▒█▒█▒▒▓▓█▓▓███████████████████████████████████████████████████████
░░░░░░░░░░█▒░▒░░░▒▒██▓██████████████████████████████████████████████████████
░░░░░░█▒▒▓░░░░░░░▒▒▒▓███████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░▓█▒▒▒████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░██▓░░░░▒▒▓▒▒▓▓▓█████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▓▒▒▓▒▓▓▓▓███████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▓▓███████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒░░▒▒▒▒█████████████████████████████████████████████████
```
### Fun
It looks really good in the Ubuntu terminal (change character size if needed)
If you have found a cool looking region increase the resolution by increasing `n` in `mandelbrot_string(x, y, x_radius*n, y_radius*n, stepsize/n)`
```
░░░░░░░░
░░░░▓▒░░▒░░░
░░░░░░░▒▒░░░░░░░░
░░░░░░░▒▒░░░░░░░░░░░░░
░░░░░░░░▓█▓▒░░░░░░░░░░░░░░
░░░░░░░░▒▒▓▒▒█░░░░░░░░░░▒░░░
░░░░░░░░░░░▒▒▒▒░░░░░▒▒▒▒▓▒█░░░
░░░░░░░░░░░░░▒▓█▒▒▒▒▒▓▒▓▒▒░░░░░░
░░░░░░░░░░░░░▒▒▒▓▓█▒▒▒░░░░░░░░░░
░░░░░░░░░░░░░░░▒▒▒▓▓▒▒▒░░░░░░░░░░░░
░░░░░░░░░░░░░░▒▒▒▒▓███▒▒▒░░░░░░░░░░░
░░░░░░░░░░░░░░▓▓▓█▓████▓▒▓█▒░░░░░░░░░░░
░░░░░░░░░▒▒▒░░▒▒▒▒▓▓███████▓█▓░░░░░░░░░░░░
░░░░░░░░░▒▒▒▓▓▒▒▒▒█▓▓████████▓▒▒▒▒▒▒▒▒▒▒░░░░░
░░░░░░░░░░▒▒██▒▓█▓▓▓▓▓████████████▓██▒▒██▓▒░░░░░░░
░░░░░░░░░░░░░░░░▒▒▒▒████████████████████▓█▓▓█▓█▒▒░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░▒▒▓███████████████████████▓▒▒░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓███████████████████████▒▒▒░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓█████████████████████████▓███░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▓███████████████████████▓█▒░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▓████████████████████████▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░▓▒░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒█████████████████████▓▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▒░░░
░░░░░▒██▒░░▒▓▒▒▓▓▒░░░░░░░░░░▒█▒▒█▒▒▒▒▒▒▒▒▒▒▒▒▓▓██████████████████▓▓▒▒▒▒▒▒▒▒░░░░░▒██░░░░░░░░░░░░░░░░░░░░░▒▒▒░░░
░░░░░░░░░▒██▓▓█▓█▓▒▒▒░░░░░░░░▒▒█████▒▒▒▓██▓▓██▓█▓██████████████████▓▓▓▓█▓▒▓██▒▒▒▒▓████▓░░░░░░░░░░░░░░░░░░██▒░░░░░
░░░░░░░░░░░▒▒▒▓███▓▓▒▒▓▒█▒▒▒▒▒▒▒███████▓▓███████████████████████████████████████▓▒███████▓░░░░░░░░░░░░░░░░▒██▒░░░░░░
░░░░░░░░░░░░▒█▓█▓▓██████████▓▒▒▒▒▒▓███████████████████████████████████████████████████████▒▒▒░░░░░░██▒█▒▒░▒▒▒▒█▒▒░░░░░
░░░░░░░░░░░░░░░▒▒▒▒▓███████████▓▒██████████████████████████████████████████████████████████▓▓▒█▒▒▒▒▒▒▒▓██▓▒▒▒▒▒▓█▓█▓▒▒░░░
░░░░░░░░░░░░░░░░░░░▒█▓▓██████████▓████████████████████████████████████████████████████████████████▒▒▒▓█████████████▓█▓░░░░░
░░░░░░░░░░░░░░░░░░░░░▒███████████████████████████████████████████████████████████████████████████████▓▓█████████████▓▒▒▓█░░░░
░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▓██████████████████████████████████████████████████████████████████████████████████████████▒▒▒░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▓▓███████████████████████████████████████████████████████████████████████████████████████████░░░░░░░░
░░░░░░░░░░░░░░░░░░░░▒▒▓▒▒▒▒▒▓█▓████████████████████████████████████████████████████████████████████████████████████████▓▓▓▒░░░░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒█▓█▓▒▒▒▒▓█████████████████████████████████████████████████████████████████████████████████████████▓▒▒▒░░░░░░░░░░░░
░░░░░░░░░░░ ░░░░░░░░░░░░░░░░░░░░░░░▒▓████████▓██████████████████████████████████████████████████████████████████████████████████████████▓▒▒▒░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▓█████████████████████████████████████████████████████████████████████████████████████████████████████▒▒█▒░░░░░░░░░░░
░░░░▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒██████████████████████████████████████████████████████████████████████████████████████████████████████▓░░░░░░░░░░░░
░░░░░░░░▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▓▓███████████████████████████████████████████████████████████████████████████████████████████████████▓▒▒▒░░░░░░▓░░░░
░░░░░░░░▒██▒░░░░░░░░░░░░░░░░░░░░▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒██▓▓██████████████████████████████████████████████████████████████████████████████████████████████████████▓▒▓██▒▒▒▓▓▒░░░
░░░░░░░░░▒▓▒▒░░░░░░░░░░░░░░░░░░▒▓█▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓▓▓█▒░░░░
░░░░░░░░░░▓▓▒▒▒░░░░░░▓░░░░░░░░░▓█▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓▒░░░░
░░░░░░░░░░░▓▒▓▓▓▓▓▒█▒▒█▒▒▒░░░░▒▒▒▒▓██▒█▒▒▒░▒▒█▒░░░░░░░░░░░░░░░░▒▒▒▒▓███████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒█░░░░░░
░░░░░░░░░░░░░░▒▒▒▓████▓▓▒█▒▒▒▒▒▒▒▒▓▓████▒▒▒▓▓▓▒▒░░░░░░░░░░░░░░▒▒▒██████████████████████████████████████████████████████████████████████████████████████████████████████████████▓▓▒▒░░░░░░░░░
░░░░░░░░░░░░░░░▒▒▒▒▓▓███████▒▒▓▓▒▓▓██████▓▓▓▓▓██▒▒▒▒▒░░░░░░░░▒▒▒▒████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓▒░░░░░░░░░
░░░░░░░░░░░░░░░░░▒▒▒▓█████████▓▓██████████████████▓██▒▒▒▒▒▒▒▒▒▒▒▒▒▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒░░░░░░░░
░░░░░░░░░░░░░░░░▒▒█▓██████████████████████████████████▒▒▒▒▒▒▒▒▒▒▒████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒▓░░░░░
░░░░░░░░░░░░░░░░░▒▒▒▒▒▓███████████████████████████████████▓▒▒▒▒▒▒▒▒▓███████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓█▒░░░░
░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▓▓██████████████████████████████████████▒▒▒▒▒▓███████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓█▓░░░░░
░░░░░░░░░░░░░░░░██▓▓▓████████████████████████████████████████████▓▓▓▓▓██████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒░░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒▒▓██████████████████████████████████████████████▓▓▓███████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒░░░░░░
░░░░░░░░░░░░░░░▒▓▒░░░░░░░░░▒▒▒▒▒▒▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒░░░░░
░░░░░░░░░░░░░░░░░░░░░░░▒▒█▒▒▒▒▒▒▒▒▒▒▒▒█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒█▒▒▒▒▓▓▒▒▒▒▒▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▓█▓█▓▓██▓▓▓▓▓█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒░░░░░░░░
░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▓▓██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓▒░░░░░░░░░░
░░░░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▓▒▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒░░░░░░░░░░░
░░░░░░░░░░░░░░▒▒█▒▒░░░░░░░░░░▓▒░░░░░░░░░░▒▒▒▓▒▒▓▒▒▓▓███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒░░░░░░░░░░░░░
██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓▓▒▒▒░░░░░░░░░░░░░░
░░░░░░░░░░░░░░▒▒█▒▒░░░░░░░░░░▓▒░░░░░░░░░░▒▒▒▓▒▒▓▒▒▓▓███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒░░░░░░░░░░░░░
░░░░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▓▒▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒░░░░░░░░░░░
░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▓▓██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓▒░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▓█▓█▓▓██▓▓▓▓▓█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒█▒▒▒▒▓▓▒▒▒▒▒▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░▒▒█▒▒▒▒▒▒▒▒▒▒▒▒█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒░░░░░░░
░░░░░░░░░░░░░░░▒▓▒░░░░░░░░░▒▒▒▒▒▒▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒▒▓██████████████████████████████████████████████▓▓▓███████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒░░░░░░
░░░░░░░░░░░░░░░░██▓▓▓████████████████████████████████████████████▓▓▓▓▓██████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒░░░░░░░
░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▓▓██████████████████████████████████████▒▒▒▒▒▓███████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓█▓░░░░░
░░░░░░░░░░░░░░░░░▒▒▒▒▒▓███████████████████████████████████▓▒▒▒▒▒▒▒▒▓███████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓█▒░░░░
░░░░░░░░░░░░░░░░▒▒█▓██████████████████████████████████▒▒▒▒▒▒▒▒▒▒▒████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒▓░░░░░
░░░░░░░░░░░░░░░░░▒▒▒▓█████████▓▓██████████████████▓██▒▒▒▒▒▒▒▒▒▒▒▒▒▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒░░░░░░░░
░░░░░░░░░░░░░░░▒▒▒▒▓▓███████▒▒▓▓▒▓▓██████▓▓▓▓▓██▒▒▒▒▒░░░░░░░░▒▒▒▒████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓▒░░░░░░░░░
░░░░░░░░░░░░░░▒▒▒▓████▓▓▒█▒▒▒▒▒▒▒▒▓▓████▒▒▒▓▓▓▒▒░░░░░░░░░░░░░░▒▒▒██████████████████████████████████████████████████████████████████████████████████████████████████████████████▓▓▒▒░░░░░░░░░
░░░░░░░░░░░▓▒▓▓▓▓▓▒█▒▒█▒▒▒░░░░▒▒▒▒▓██▒█▒▒▒░▒▒█▒░░░░░░░░░░░░░░░░▒▒▒▒▓███████████████████████████████████████████████████████████████████████████████████████████████████████████████▒▒█░░░░░░
░░░░░░░░░░▓▓▒▒▒░░░░░░▓░░░░░░░░░▓█▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓▒░░░░
░░░░░░░░░▒▓▒▒░░░░░░░░░░░░░░░░░░▒▓█▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████▓▓▓█▒░░░░
░░░░░░░░▒██▒░░░░░░░░░░░░░░░░░░░░▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒██▓▓██████████████████████████████████████████████████████████████████████████████████████████████████████▓▒▓██▒▒▒▓▓▒░░░
░░░░░░░░▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▓▓███████████████████████████████████████████████████████████████████████████████████████████████████▓▒▒▒░░░░░░▓░░░░
░░░░▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒██████████████████████████████████████████████████████████████████████████████████████████████████████▓░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░ ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▓█████████████████████████████████████████████████████████████████████████████████████████████████████▒▒█▒░░░░░░░░░░░
░░░░░░░░░░░ ░░░░░░░░░░░░░░░░░░░░░░░▒▓████████▓██████████████████████████████████████████████████████████████████████████████████████████▓▒▒▒░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░▒▒▒█▓█▓▒▒▒▒▓█████████████████████████████████████████████████████████████████████████████████████████▓▒▒▒░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░▒▒▓▒▒▒▒▒▓█▓████████████████████████████████████████████████████████████████████████████████████████▓▓▓▒░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▓▓███████████████████████████████████████████████████████████████████████████████████████████░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▓██████████████████████████████████████████████████████████████████████████████████████████▒▒▒░░░░░░░
░░░░░░░░░░░░░░░░░░░░░▒███████████████████████████████████████████████████████████████████████████████▓▓█████████████▓▒▒▓█░░░░
░░░░░░░░░░░░░░░░░░░▒█▓▓██████████▓████████████████████████████████████████████████████████████████▒▒▒▓█████████████▓█▓░░░░░
░░░░░░░░░░░░░░░▒▒▒▒▓███████████▓▒██████████████████████████████████████████████████████████▓▓▒█▒▒▒▒▒▒▒▓██▓▒▒▒▒▒▓█▓█▓▒▒░░░
░░░░░░░░░░░░▒█▓█▓▓██████████▓▒▒▒▒▒▓███████████████████████████████████████████████████████▒▒▒░░░░░░██▒█▒▒░▒▒▒▒█▒▒░░░░░
░░░░░░░░░░░▒▒▒▓███▓▓▒▒▓▒█▒▒▒▒▒▒▒███████▓▓███████████████████████████████████████▓▒███████▓░░░░░░░░░░░░░░░░▒██▒░░░░░░
░░░░░░░░░▒██▓▓█▓█▓▒▒▒░░░░░░░░▒▒█████▒▒▒▓██▓▓██▓█▓██████████████████▓▓▓▓█▓▒▓██▒▒▒▒▓████▓░░░░░░░░░░░░░░░░░░██▒░░░░░
░░░░░▒██▒░░▒▓▒▒▓▓▒░░░░░░░░░░▒█▒▒█▒▒▒▒▒▒▒▒▒▒▒▒▓▓██████████████████▓▓▒▒▒▒▒▒▒▒░░░░░▒██░░░░░░░░░░░░░░░░░░░░░▒▒▒░░░
░░░░░░░░░░░░▓▒░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒█████████████████████▓▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▒░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▓████████████████████████▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▓███████████████████████▓█▒░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓█████████████████████████▓███░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓███████████████████████▒▒▒░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░▒▒▓███████████████████████▓▒▒░░░░░░░░░░░
░░░░░░░░░░░░░░░░▒▒▒▒████████████████████▓█▓▓█▓█▒▒░░░░░░░
░░░░░░░░░░▒▒██▒▓█▓▓▓▓▓████████████▓██▒▒██▓▒░░░░░░░
░░░░░░░░░▒▒▒▓▓▒▒▒▒█▓▓████████▓▒▒▒▒▒▒▒▒▒▒░░░░░
░░░░░░░░░▒▒▒░░▒▒▒▒▓▓███████▓█▓░░░░░░░░░░░░
░░░░░░░░░░░░░░▓▓▓█▓████▓▒▓█▒░░░░░░░░░░░
░░░░░░░░░░░░░░▒▒▒▒▓███▒▒▒░░░░░░░░░░░
░░░░░░░░░░░░░░░▒▒▒▓▓▒▒▒░░░░░░░░░░░░
░░░░░░░░░░░░░▒▒▒▓▓█▒▒▒░░░░░░░░░░
░░░░░░░░░░░░░▒▓█▒▒▒▒▒▓▒▓▒▒░░░░░░
░░░░░░░░░░░▒▒▒▒░░░░░▒▒▒▒▓▒█░░░
░░░░░░░░▒▒▓▒▒█░░░░░░░░░░▒░░░
░░░░░░░░▓█▓▒░░░░░░░░░░░░░░
░░░░░░░▒▒░░░░░░░░░░░░░
░░░░░░░▒▒░░░░░░░░
░░░░▓▒░░▒░░░
░░░░░░░░
```
```
░░░▒░░░░▒▓▓░░▒▒░▒░▒░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░ ░░░░░░░░░░░░█░░░▒░░░▓░░░
░░░░░░░░░▒░░░░░░░░░░░░▒▒░░░░░░░░░░░░░░░░▒▓░░░░░░░░░ ░░░░░░░░░░░░░░░░░░░▒░▒▒░░░░░░░░
░░░░░░░░░░▒░░░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░ ░░░░░░░░░░░░░░░░░░░░░░░░▒▒░░░░░░░░ ░
░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒░░░░░░░░░░░░░▒░░░░░░░░░░ ░░░░░░▒▒░░░░░░░░░░░░░░░▒▒▓▒░░░░░░░░░░ ░░░░
░░░░░▒░░░░░░░░░░░░░░░░░▒▒█░░░░░░░░░░░░░░▓░░░░░░░░░░░░ ░░░░░░░▒░░░░░░░░░░░▒░░░░░░░▒▒░░░░░░░░░░░░ ░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░▒▒░░░░░▒░░░░░░▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒░░░░░░░░░░▒▒▒░░░▒▓▓█▒░░▒░░▒░░░░ ░░░▒░░
░░░░░░░░░░░░░░░░░░░░░░░▒▒░░░░░▒░░░░█▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒░░░▒▓░░░░▒░▒▒██▓▒▒▒░░▒░░░░░░░░░░ ░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░▒▒▓▒▓▒░▒▒▒▓▒▒▒█▒▒░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▒░░▒▓▓██▓▒▒░░░░░░░░░░░░░░ ░░░░░░░▒░░░░▒▒▓░░░░
░░░░░░░░░░░▒░░░▒█▒▓███████▓▒▒░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░▒░▒▒██▒▒▒▓▒▒█▒▒░░░░░░░░░░░░░ ░░░░░░▒▒▒░░▒▒▒░░░░░░
░░░░▒▒░░░░░░░░░▒▓████████▓▒▒▒░░░░▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▒░░░░░░░░░░▒█░░░░░░░░░ ░░░░░░░░░▒░░░░░░░░░░░
░░░░░░░░░░░░░▒▒▒▒▓█████▓▒▒▒▒▒▒░▒▓▒░░░░░░░▒░░░░░░░░░░░░░░░░░░▒▒▓▒▒░░░░░░░░░░░░░░░░░░░░░ ░░░░░▒░▒▓░░▒░░░░░░░░░
░░░░░░░░░░░░░░░▒▒▒▒██▓▓▒▒▒▒▒▒▒▒▒▒▒░▒░░░░▒░░░░░░░░░░░▒▒░░░░▒▓▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░ ░░░░░░░░░▓░░░░░░░░░░░░
░░░░░░░░░░░░░░▒▒▒█▒▒▓▒▒▒░░░░▒░░▒▓▓▓▒░░░░▒▒░░░░░░░░░░░░░▒█▒▒▓█▓▓▒▒▒░░▒▒░░░░░░░░░░░░░░░░░░ ░░░░░░░░░▓░░░░░░░░░░░░░
░░░░░░░░▓░░░▒▒▒▒░░▒░░░░▓▒░░░░░░░▒▒▒█▒▒▒▒▒▓░░░▒░░░░░░░░░░▒▒▒▓▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░ ░░░░░░░░░░░▓▒░░░░░░░░░░░░
░░░░░░░░░░░░░░▒░░░░░░░░░▒▒░░░░░░░░░▒▒▓▓▓██▒▒▒▒▒░░▒░░░░▒░▒█▓▓▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒░░░░░░░░░░░░
░░░░░░░░░░░░░▓▒▒░▒░░░░░░▒░░░░░░░░░░▒█▓▒▒███▓▒▒▒▓▒▒▓▒▒░░▒▒▒▓▓▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░▒░░░░░░░░░
░░░░░░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░▒░░░░▒▓▒▒▒▒▒▒▒▓▓██▒▒▒▒▒▓██▒░░░░░░░░░░░░░░░░░░░░░░░▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▒█▒░░░▒▒▒█▒▒▓▓▓▓▓▒▒▒▒░░░░░░░░░░░░░░░░░░░░▒▒▒▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▒░░░░░░░
░░░░░░░░░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░▒▒░░░░░░░░▒▒▒▒▒▒▒▒▓█▒█▒▒░░░░▒▒░░░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒░▓░░░░░░░
░░░░░░░▒░░░░▒░░▒▒░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▒░░░░▒▒▓█▓▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▒█▒░░░░░░░░
░░░░░░░░░░▒▒░░░▒░░░░░░░░░░░░░░░░░░░░░░░░▒░█▓▒░░░░░░░░░░░░░░▒▓▒▒▒▓▓▒▒▒██▓▒░░░░░░░░░░░░░▓█▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▒░░░░░░░░░░░░░░░
░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▓█▓▓▒█▓▒▒▒▒░░░░░░▒▒░▒▒▓█▒░░░░░░░░░░░░░░░░░░░░▒░░░░░░░░░▒░▒▒▓▒▒▒▒░░░░░░░░░░░░░░░░
░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒█▒▓█▒▓████▓▒▒█▓▒░░░░░░░▒▒▓█▓▒▒░░░░░░░░░░░░░░░░░░░░▒▓░▒▒▒░▓▒▒▒▒▓█▓▒░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▓▓▓███▓▓▒█▓▒▒▒▒▒░░░▓▒▒▒██▒▒░▒░░░░░░░░░░░░░░░░░░░░░░░▒██▒█▒▓▓▒▒░▒░░░░░░░░░░░█▒▓░▓▒░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓░░░▒▒▓▒▒█▒▒▓▓███▓▒▒▒▒▒▒▒▒▒▒▒▒▒█▓▒▒▒█▒▒▓░░░░░░░░░░░░░░░░░░░░░▒▒▒█▓▒▒▒░░░░░░▒█░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒░▒▒▒▒▒▒▒█▓██▓▓▒▒██▒██▒▒▒▒▒▒▓█▓▓█▓▓▓▒░░░░░░░░░░░░░░░░░░░░░▒▒▓▓▓▒▒▒░░▒░░░▓░░░░░░▒█░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▓▓███▓▓██▓▒▒▒▒█▓▓▓█▓▒▒▒▒▒▒░░░░░░░░▒░░░░░░░░░▒░▒▒▒▓██▓▒▒▒▒▒█▓▒▒▓▒░░░▒▒▒▒░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒█▓▒▓▓████████▓█▓▓▓█████▒▒▒▒▒▒░░░░░░▒▒░░░░░░░░░░░░▒▒▒▒▓▓█▒▒▓▓██▓█████▒▓▒▓▒▒░▒░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░▓░░░░▒░▒░░░▒▓▒▓██████████████████████▓▓▒▒▒▒▒▒▒░░░░░▒▒░░░░░░░░░░░░░░▒▒████▓██▓▒▒▒▒▒▒▒█▓▒▒░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░▒▒██▒▒▒▒▒▒▒▒▒▓▓▓█████████████████▓▓▓▓█▓▒▒▒▒▒▒▒▒▒▒▒▒░▒█░░░░░░░░▒▒▒▒▒▒▒▓▓██▓▒▒▒░░░▒░▒░░░░░░░░░░░░░░░░░ ░░
░░░░░░░░░░░░░░░░░░░░░░░▒▒▒███▒▒▒▒▒▒▓▓█████████████████████████▓▒▒▒▒▒▒▒▓██▒▒▒█▒▒░▒▒▒▒▒▒▒▒▒▒▒▒█▓██▓█▓▒▒░░░░░░░░░░░░░░░░░░░░░░░░░ ░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒█▒▓▓▓██▓▓██████████████████████▓▓▒▒▒▒▓▒▒▒█▓████▓▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓██▓▓▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░▒▒░░░░░░░░░█░░▓█▒▒██▓▓▓██████████████████████████████▓▓▒▒▒█▒▒▒▒▒▓██▓▒▒▒▒▒▓▒▓█▓█▓▒▒▓▓████▓▓▒▒▒▒▒▒░▓░░░░░░░░░░░▓░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░▓░░░░░░▒▒▓▓▓▓█▒▓▓▒▒▒▒▒▓▓▓▓████████████████████████▓▓▓▓▓███▓▓▓████████▒▒▒▒███████▓▓▓█████▓▓█▓▒░░░░░░░░░░░░▒▓▒▓▒▒▒░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░█░░░▓▓▒▓░░░░░█▓▒▒▒▒▒▒▒▒▒▒▒█▓▓████████████████████████▓████████▓██████████▓▓▓▓███████████████▒▒█░░░░░░░░░░▒▒▓░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒░░░▒▒▒▒▒▒▓▓▓██████████████████████████████████████████████▓██████████████▓▒▒▒▒▒░░░░░█░░░░░▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▓█▓█▓███████████████████████████████████████████████████████████▓█▓▒▒▒░░░░▒▒░░░▒██▓░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒██▓▓▒▓████████████████████████████████████████████████████████████▓▓▓▒▒▒▒▒▒▒▒▒▓▓▒▒▓█▒░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▓██▓▓████████████████████████████████████████████████████████▓▒▒▒█▒▒▒▒████▓▒▒▓▒░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▓▓▓▓███████████████████████████████████████████████████████▓▓██▓▒▒▒▓▓██▓▓▓▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░░░░
░░░▓▓░░░░░░░░░▒░░░░░▒░░░░░░░░░▒░░░░░░░▒▒▓▓▒▒▒▓▓█▓█▓▓█████████████████████████████████████████████████████████████▓▒▒▒▒▒█████▓█▓▒▒░▒░░░░░░░░░░░░░░░░░░░░░▓░░
░░░░░░▒░░░░░░░░░▒░░░░▒░░░░░░░░░▒▓▒░░█▒▒▒▒███▒▒▒▒▓▓████████████████████████████████████████████████████████████████▓▓█▓▓▒▓▓▓██▓▒▓▓▓█░░░░░░░░░░░░░░░░░░░░░░░█░
░░░░░░░▒▒▓░▒▒▒▒▓▒░░░░▒▒░░░░░░░░░░▒▒▒▒██████▓▓▓█▓▓██████████████████████████████████████████████████████████████████████▓██████▒▒▒▒░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒
░░░░░░░░░░░░░░▒▒▓▒▒▒▒▒██▒░░░░░░░░░░▒▒▒▒▒▒▒█████████████████████████████████████████████████████████████████████████████████▓▓█▒▒░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓░
░░░░░░░░░░░░░░░▓▒▒██▒▓▒▒▒▒▒░░░░░░░░▒▒▒▒▒▒█▓██████████████████████████████████████████████████████████████████████████████████▒▒░░░░░░░░░░░░░░░░░░░░░░░██▓▒░░
░░░░░░░░░░░░░▒░░░░▒▒▒▓█▒▒█▒░░░░▒▒▒▒▒▒▒▒███▓███████████████████████████████████████████████████████████████████████████████▓▒▒▒▒▒▒░▒▓▒▒█░░░░░░░░░░░░░░░░▓▒▒░░
░░░░░░░░░░░░░░░░░░░▒▒▓▒▓█▒▒▒▒▒▒▒▒▒▒▒▒▓▒▒▒▒▓▓▓████████████████████████████████████████████████████████████████████████████▓▓▒▒█▓█▒▒▓▒░░░░░░░░░░░░░░░░░░░░░░░▒
░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▓█▓▓▒▒▒▒▒▒▓█▓▓█▓▒▓▓███████████████████████████████████████████████████████████████████████████████▓▓████▓▓█▒░░░░░░░░░░░░░░░░░░░░░░░░▒
░░░░░░░░░░░▒░░░▒▒░▒▒▓███▓▓█▓▒▒▒█▒▒▒▒▒▓▓██▓▓▓▓▓███████████████████████████████████████████████████████████████████████████████▓▓█████▒▒▒░░░░░░░░░░░░░░░░░░░░░░░░
░░░ ░░░░░░░░░░░░░░░░░▒▒▒▓▒██▓▒▒█▒▓█▓█▒▒██▒▒▒▓▓▓███████████████████████████████████████████████████████████████████████████████████████████▓██▒▒░░░░░░░░░░░░░░░░░░░░██▒▒
░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓░▒░░░░░▒████▒▓▒▒▒▒▓▒▓██████▓█▓▓█████████████████████████████████████████████████████████████████████████████████████████████▒▒▒░░░░░░░░░░░░█▒░░░░░░░░▒▒▒
░░▒░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒░░░▒▓▒▓▒▒▒▒▒▒▒▒▒▒▒▓▓▓██████████████████████████████████████████████████████████████████████████████████████████████████▓▒▒▒▒▒▒░░░░░░░░░▒█▒░░░░░░░░░░▒▒
░░▒░░░░░░░░░░░░░░░░░░░░░░▒▓▒█▓▒▒▓▒▒▒██▓▒▒▒░░░░░▒▓▒▒▓▓███████████████████████████████████████████████████████████████████████████████████████████████▓█████▒▒▒░░░░░░░░░▒█▒▒▒░░▒▒▒▒▒▒▒▒
░░▒░░░░░░▒░░░░░░░░░░░░░▒▒▒▓▒▒▒▒██▒█▓▒▒▒▒▒▒░░░░░░░▒▒▒▓███████████████████████████████████████████████████████████████████████████████████████████████████▓▒▒▒▒▒░░░░░░░▒▒▒▒███▒▒██▒▒█▓▒
░░▒▒░░░░░░░░░░░░░░░░░▒▓▒▒▒▒░░░▓░▒██▒░░░░░▒░░░░░░▒▓▓▓████▓▓▓████████████████████████████████████████████████████████████████████████████████████████████▓▓▒▒▒▒▒▒▒░░░▒▒▒▒▒▒▒███████▓███
▒▒▓▒░░▓░▒▓░░░░░░░░░░▓░░▓░░░░░░░░█░▒▓▒░░░░░░░░░░░░░▒█▒▒▒▒▒████████████████████████████████████████████████████████████████████████████████████████████▓▒▒▒▒▒▒▒▒▒▒▒█▒▒▒▒▒▒▒▓███████████
░░░▓░░░░░▒▒░▒░▒▒░▒░▓░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█▒▒▒▒▒▒▒█▓▓█▓▓█▓██████████████████████████████████████████████████████████████████████████████████████▒▒▒▒▒▒▒▒█▒▒▒▒▒▒▒▒▓▓██████████
░░░░░░░░▒░▒▒░░▒▓▒░░░░░░░░░░░░░░░░░░▓▓░░░░░░░░░░█▓▓▒░░░░▒▒▓▒▓▒▒▒█▓▓█████████████████████████████████████████████████████████████████████████████████████▒▒▒▒▒▒▒▒▒▒▒████▓███▓▓▓████████
░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░▒░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▓████████████████████████████████████████████████████████████████████████████████████▓▓▒▒▒▒▒▒▒▒▒▒██████████▓▓█████████
░░░░░░░▒░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒█▒█▓▓████████████████████████████████████████████████████████████████████████████████████▓▒▒▒▒▒█▒▒▒▒▒▓▓██████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓▒▒▒▒▒▒▒▒▓▓▓████████████████████████████████████████████████████████████████████████████████▓▓▒▒▒▒▒▒▓█████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▒▒██████▒▒█▓███████████████████████████████████████████████████████████████████████████████████▓▓▓▓▓▓▓▓▓▓████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒░▒▒▒█▒▒▓▓██▓▓▓▓▓█████████████████████████████████████████████████████████████████████████████████▓▓▓█▓▓▓████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒█▓███▓███████████████████████████████████████████████████████████████████████████████████▓▓█▓████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▓▒█▓▓███████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓▓▒▒▓█▒▓▓█████████████████████████████████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░▒▓█▒▒▓█▒▒▒▒▒▓█▓▓█▓▓█▓██████████████████████████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░█▒▓▓▓▓▒▒▒░▒▒▒▒▒▒▒▒▒▓▓▓▓███████████████████████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░█▒▒░░░▒▒░░░░░░▒▒▒█████▓▓███████████████████████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░█▒▒▓░░░░░░░░░░░░░▒▒░░░░░░░▒██▓████████████████████████████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░▒█▒▒▓▒▒▓░░░░░░░░░░░░░░░▒▒▒▒▒█▓██████████████████████████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▓█▓▒▒▒▓▒▒▓██████████████████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▓▓██▒▒▒▒▒▓███████████████████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒██▓▓█▓▓███████████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░█▓██▓█░░░░░░░▒▒▒▒█▓▓▒▒▒▓▓█▓▓▓██████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒░░░░░░░░▒▒▒██▒▒▒▒▒▒▒▓▒▒▒▒▓▓▓▓▓█▓▓█████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒█▓▒▒▒▒█▓▓▒▓▓▓▓▓▓▓▓██████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▓▓████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▓▒▓▓█████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒▓▒▒▒▓▒▒▒▓██████████████████████████████████████████████████████████████████████████████████████████
░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░▒█░░░▒▒▒▒▒▒▒▒▒█████▓███████████████████████████████████████████████████████████████████████████████████████████
```
| algorithms | def mandelbrot_string(x, y, width, height, stepsize, max_iter):
def mandelbrot_pixel(c):
z = 0
for n in range(max_iter + 1):
z = z * z + c
if not abs(z) < 2:
break
return n
return '\n' . join(
'' . join(
' ░▒▓█' [4 * mandelbrot_pixel(
complex(x + dx * stepsize, y - 2 * dy * stepsize)
) / / max_iter]
for dx in range(- width, width + 1)
) for dy in range(- height, height + 1))
| ASCII Mandelbrot Set | 62fa7b95eb6d08fa9468b384 | [
"ASCII Art",
"Mathematics"
] | https://www.codewars.com/kata/62fa7b95eb6d08fa9468b384 | 5 kyu |
# Task:
In this Golfing Kata, you are going to do simple things:
* Reverse a string; then
* Return the index of first uppercase letter.
___
# Input:
You are going to get a `string` which consists only __uppercase__ and __lowercase__ English letters. It will have at least one uppercase letter.
___
# Output:
Return the `index` of __first uppercase letter__ of reversed string.
___
# Examples:
__input --> output__
```
f("HelloWorld") --> 4
f("Codewars") --> 7
f("X") --> 0
f("findX") --> 0
```
___
# Golfing Message:
The length of your code should be less or equals to `44`.
Your code should be one line.
The length of the reference solution is `37`.
___
# Special Acknowledgement:
Thank for the feedback and helping from @[Unnamed](https://www.codewars.com/users/Unnamed), @[Kacarott](https://www.codewars.com/users/Kacarott), @[scarecrw](https://www.codewars.com/users/scarecrw) and @[Madjosz](https://www.codewars.com/users/Madjosz). | games | def f(s): return s[- 1] > "Z" and - ~ f(s[: - 1])
| [Code Golf] Reversed Upper Index | 62f8d0ac2b7cd50029dd834c | [
"Strings",
"Restricted"
] | https://www.codewars.com/kata/62f8d0ac2b7cd50029dd834c | 6 kyu |
**SITUATION**
Imagine you are trying to roll a ball a certain distance down a road. The ball will have a starting speed that slowly degrades due to friction and cracks in the road. Every time the ball rolls a distance equal to its speed or rolls over a crack, its speed decreases by 1. Given a speed of s which the ball starts rolling, and a roadmap r of the street represented by a string, return whether or not the ball will be able to make it past the end of the road (True or False).
**NOTES**
- A ball with 0 speed is motionless.
- If a ball happens to roll over a crack, the speed decrease must only take effect after the ball has rolled a distance equal to its speed. For example, if the speed was 10, but the ball hit 2 cracks before rolling 10 distance, the ball's speed should stay at 10 until it has reached 10 distance, in which the speed should decrease to 7 (-2 from cracks and -1 due to friction).
- On the roadmap, "_" represents flat ground and "x" represents a crack
- The length of the roadmap will be equal to the distance to the ball's final destination
- The ball must reach the last tile of the road for the solution to be considered valid.
**EXAMPLES**
- A speed of 100, and a roadmap of '_' should return True because the ball would be moving too quickly for friction to be applied and there are no cracks on the road.
- A speed of 1, and a roadmap of '___________' should return False because friction would stop the ball after 1 distance
| reference | def ball_test(s, r):
if len(r) <= s:
return True
elif s <= 0 and r:
return False
cracks = r[: s]. count('x')
return ball_test(s - 1 - cracks, r[s:])
| Street Bowling | 62f96f01d67d0a0014f365cf | [
"Algorithms",
"Strings"
] | https://www.codewars.com/kata/62f96f01d67d0a0014f365cf | 7 kyu |
Copy of [Is the King in check ?](https://www.codewars.com/kata/5e28ae347036fa001a504bbe/javascript).
But this time your solution has to be ` < 280` characters, no semicolons or new lines.
You have to write a function
```
is_check
```
that takes for input a 8x8 chessboard in the form of a bi-dimensional array of strings and returns ````true```` if the black king is in check or ````false```` if it is not.
The array will include 64 squares which can contain the following characters :
<ul>
<li>'♔' for the black King;</li>
<li>'♛' for a white Queen;</li>
<li>'♝' for a white Bishop;</li>
<li>'♞' for a white Knight;</li>
<li>'♜' for a white Rook;</li>
<li>'♟' for a white Pawn;</li>
<li><pre>' ' (a space) if there is no piece on that square.</pre></li>
</ul>
Note : these are actually inverted-color [chess Unicode characters](https://en.wikipedia.org/wiki/Chess_symbols_in_Unicode) because the dark codewars theme makes the white appear black and vice versa. Use the characters shown above.
There will always be exactly one king, which is the **black** king, whereas all the other pieces are **white**.<br>
**The board is oriented from Black's perspective.**<br>
Remember that pawns can only move and take **forward**.<br>
Also be careful with the pieces' line of sight ;-) .
The input will always be valid, no need to validate it.
| games | is_check = lambda g, n = '(.{7}|.{11}|.{18}(|..))', r = '((.{9} )*.{9}| *)', b = '((.{8} )*.{8}|(.{10} )*.{10})': bool(__import__(
're'). search(f"♔ { n } ♞|♞ { n } ♔|♔ { r } [♛♜]|[♛♜] { r } ♔|[♛♝] { b } ♔|♔ { b } [♛♝]|♟.{{ 8}} (|..)♔", '||' . join(map('' . join, g))))
| One line task: Is the King in check ? | 5e320fe3358578001e04ad55 | [
"Restricted",
"Puzzles"
] | https://www.codewars.com/kata/5e320fe3358578001e04ad55 | 3 kyu |
Everybody likes sliding puzzles! For this kata, we're going to be looking at a special type of sliding puzzle called Loopover. With Loopover, it is more like a flat rubik's cube than a sliding puzzle. Instead of having one open spot for pieces to slide into, the entire grid is filled with pieces that wrap back around when a row or column is slid.
Try it out: https://www.openprocessing.org/sketch/576328
Note: computer scientists start counting at zero!
**Your task**: return a List of moves that will transform the unsolved grid into the solved one. All values of the scrambled and unscrambled grids will be unique! Moves will be 2 character long Strings like the ones below.
For example, if we have the grid:
```
ABCDE
FGHIJ
KLMNO
PQRST
UVWXY
```
and we do `R0` (move the 0th row right) then we get:
```
EABCD
FGHIJ
KLMNO
PQRST
UVWXY
```
Likewise, if we do `L0` (move the 0th row left), we get:
```
ABCDE
FGHIJ
KLMNO
PQRST
UVWXY
```
if we do `U2` (2nd column up):
```
ABHDE
FGMIJ
KLRNO
PQWST
UVCXY
```
and if we do `D2` (2nd column down) we will once again return to the original grid. With all of this in mind, I'm going to make a Loopover with a scrambled grid, and your solve method will give me a List of moves I can do to get back to the solved grid I give you.
For example:
SCRAMBLED GRID:
```
DEABC
FGHIJ
KLMNO
PQRST
UVWXY
```
SOLVED GRID:
```
ABCDE
FGHIJ
KLMNO
PQRST
UVWXY
```
One possible solution would be `["L0", "L0"]`
as moving the top row left twice would result in the original, solved grid.
Another would be `["R0", "R0", "R0"]`, etc. etc.
NOTE: The solved grid will not always look as nice as the one shown above, so make sure your solution can always get the mixed up grid to the "solved" grid!
# Input
`mixedUpBoard` and `solvedBoard` are two-dimensional arrays (or lists of lists) of symbols representing the initial (unsolved) and final (solved) grids.
Different grid sizes are tested: from `2x2` to `9x9` grids (including rectangular grids like `4x5`).
# Output
Return a list of moves to transform the `mixedUpBoard` grid to the `solvedBoard` grid.
Some configurations cannot be solved. Return `null` (`None` in Python) for unsolvable configurations.
Good luck! Let me know if there are any issues with the kata! :) | games | def loopover(mixed, solved):
t = {c: (i, j) for (i, row) in enumerate(solved)
for (j, c) in enumerate(row)}
b = {(i, j): t[c] for (i, row) in enumerate(mixed)
for j, c in enumerate(row)}
unsolved = {k for k, v in b . items() if k not in (
(0, 0), (0, 1)) and k != v}
sol = []
while unsolved:
i, j = next(iter(unsolved)) if b[0, 0] in ((0, 0), (0, 1)) else b[0, 0]
if i == 0:
sol += [f"D { j } ", * j * ["L1"], "L0", "U0",
"R0", "D0", * j * ["R1"], f"U { j } "]
else:
sol += [* j * [f"L { i } "], "L0", * i * ["U0"],
"R0", * i * ["D0"], * j * [f"R { i } "]]
b[0, 0], b[0, 1], b[i, j] = b[0, 1], b[i, j], b[0, 0]
if b[i, j] == (i, j):
unsolved . remove((i, j))
if b[0, 0] != (0, 0) and len(mixed) % 2 == 0:
sol += [* len(mixed) / / 2 * ["D0", "L0", "D0", "R0"], "D0"]
elif b[0, 0] != (0, 0) and len(mixed[0]) % 2 == 0:
sol += [* len(mixed[0]) / / 2 * ["R0", "U0", "R0", "D0"], "U0", "R0", "D0"]
elif b[0, 0] != (0, 0):
return None
return sol
| Loopover | 5c1d796370fee68b1e000611 | [
"Puzzles",
"Algorithms",
"Game Solvers"
] | https://www.codewars.com/kata/5c1d796370fee68b1e000611 | 1 kyu |
<img src='https://i.imgur.com/3W4hpEW.png' align="right">Have you ever played <a href='https://en.wikipedia.org/wiki/Microsoft_Minesweeper'>Minesweeper</a>? It's a WINDOWS own game that mainly tests the player's ability to think logically.
Here are the rules of the game, maybe helpful to someone who hasn't played Minesweeper:
"The goal of the game is to uncover all the squares that do not contain mines without being "blown up" by clicking on a square with a mine underneath. The location of the mines is discovered by a process of logic. Clicking on the game board will reveal what is hidden underneath the chosen square or squares (a large number of blank squares may be revealed in one go if they are adjacent to each other). Some squares are blank but some contain numbers (1 to 8), each number being the number of mines adjacent to the uncovered square. To help avoid hitting a mine, the location of a suspected mine can be marked by flagging it with the right mouse button. The game is won once all blank squares have been uncovered without hitting a mine, any remaining mines not identified by flags being automatically flagged by the computer. However, in the event that a game is lost and the player mistakenly flags a safe square, that square will either appear with a red X covering the mine (denoting it as safe), or just a red X (also denoting it as safe)."
# Task
In this kata, I'll give you a string `map` as a game map, and a number `n` indicating the total number of mines. Like this:
```
map =
? ? ? ? ? ?
? ? ? ? ? ?
? ? ? 0 ? ?
? ? ? ? ? ?
? ? ? ? ? ?
0 0 0 ? ? ?
n = 6
```
Yes, you always get a matrix with some question marks, except for some 0s (because I think you need a place to start your logical reasoning).
Digit 0 means that there's 0 mines around here, so you can safely `open` the grid cells around 0. How to open the grid cell? I've preloaded a method `open`, usage is `open(row,column)` (for Java users: `Game.open(int row, int column)`). It will return a number that indicates how many mines are around this grid cell. If there is an error in your logical reasoning, when you use the open method to open a grid cell, but there is a mine hidden in this grid cell, then the test will fail. Please note, method `open` only returns a number, but does not modify the `map`—you should modify the `map` by yourself.
You open more and more grid cells until all safe grid cells are opened and all mine grid cells are marked by `'x'`. Then return the result like this:
```
1 x 1 1 x 1
2 2 2 1 2 2
2 x 2 0 1 x
2 x 2 1 2 2
1 1 1 1 x 1
0 0 0 1 1 1
```
If the game cannot get a valid result, return `"?"`. See following:
```
map =
0 ? ?
0 ? ?
n = 1
First you open two middle grid cells (using `open(0,1)` and `open(1,1)`), then you get:
map =
0 1 ?
0 1 ?
Now, there is only one mine left, but there are two `?` left.
The mine can be hidden in either of them. So, you should return "?" as the result there.
``` | games | from itertools import combinations
def solve_mine(mapStr, n): return MineSweeper(mapStr, n). solve()
class MineSweeper (object):
IS_DEBUG = False
around = [(dx, dy) for dx in range(- 1, 2)
for dy in range(- 1, 2) if (dx, dy) != (0, 0)]
def __init__(self, mapStr, nMines):
lines = mapStr . split('\n')
mapDct, unknowns, posToWorkOn = {}, set(), set()
for x, line in enumerate(lines):
for y, c in enumerate(line . split(' ')):
mapDct[(x, y)] = c
if c == '?':
unknowns . add((x, y))
else:
posToWorkOn . add((x, y))
self . map = mapDct
self . unknowns = unknowns
self . posToWorkOn = posToWorkOn
self . flagged = set()
self . nMines = nMines
self . lX = len(lines)
self . lY = len(lines[0]. split(' '))
def __str__(self): return '\n' . join(' ' . join(
self . map[(x, y)] for y in range(self . lY)) for x in range(self . lX))
def getValAt(self, pos): return int(self . map[pos])
def getneighbors(self, pos): return {
(pos[0] + dx, pos[1] + dy) for dx, dy in self . around}
def printDebug(self): print(" \n------------\n{}\nRemaining mines: {}" . format(
self, self . nMines - len(self . flagged))) if self . IS_DEBUG else None
def lookaroundThisPos(self, pos):
neighbors = self . getneighbors(pos)
return {'?': neighbors & self . unknowns,
'x': neighbors & self . flagged}
""" MAIN FUNCTION """
def solve(self):
self . printDebug()
while True:
while True:
# Archive to check against modifications
archivePosToWorkOn = self . posToWorkOn . copy()
self . openAndFlag_OnTheFly()
self . printDebug() # Open and flag in the map while simple matches can be found
self . complexSearch_OpenAndFlag()
# Use more complex algorithm to find mines or unknown positions that are surely openable
self . printDebug()
if archivePosToWorkOn == self . posToWorkOn:
break # Repeat these two "simple" steps until its not possible to go further in the resolution
# Use witted combinatory approach to go further (if possible)
self . complexSearch_CombineApproach()
if archivePosToWorkOn == self . posToWorkOn:
break
# Repeat these to "simple" steps until its not possible to go further in the resolution
self . printDebug()
# If no more mines remaining but some unknown cases still there
if len(self . flagged) == self . nMines:
self . openThosePos(self . unknowns . copy())
# If all the remaining "?" are mines, flag them
elif len(self . flagged) + len(self . unknowns) == self . nMines:
self . flagThosePos(self . unknowns . copy())
self . printDebug()
return '?' if self . unknowns else str(self)
def openAndFlag_OnTheFly(self):
while True:
openables, workDonePos = set(), set()
for pos in self . posToWorkOn: # Run through all the positions that might neighbors to open
openables, workDonePos = [baseSet | newPart for baseSet, newPart in zip(
(openables, workDonePos), self . openablePosaround_FlagOnTheFly(pos))]
# After the exit of the loop, modification of self.posToWorkOn is possible, so:
self . openThosePos(openables)
# remove the pos with full number of mines from the working set (to fasten the executions)
self . posToWorkOn -= workDonePos
if not openables and not workDonePos:
break
def openablePosaround_FlagOnTheFly(self, pos):
around = self . lookaroundThisPos(pos)
# If all the unknomn cases can be flagged (or if they are already!)...
if self . getValAt(pos) == len(around['?']) + len(around['x']):
self . flagThosePos(around['?']) # flag them (if not already done)
# return the current position to remove it from self.posToWorkOn ("We're done with you..." / This behaviour will identify the "done" positions generated by the "witted approach")
return (set(), {pos})
return (around['?'], {pos}) if self . getValAt(pos) == len(around['x']) else (set(), set())
def openThosePos(self, posToOpen):
for pos in posToOpen:
self . map[pos] = str(open(* pos)) # Open squares and update the map
if self . map[pos] != '0':
self . posToWorkOn . add(pos) # Update slef.posToWorkOn if needed
self . unknowns -= posToOpen # Remove opened squares from the unknown positions
def flagThosePos(self, posToFlag):
for pos in posToFlag:
self . map[pos] = 'x' # Flag mines
self . unknowns -= posToFlag # Remove flagged squares from the unknown positions
self . flagged |= posToFlag # update the set of flagged positions
def complexSearch_OpenAndFlag(self):
markables, openables = set(), set()
for pos in self . posToWorkOn:
newMark, newOpen = self . intelligencia_OpenAndFlag(pos)
markables |= newMark
openables |= newOpen
self . flagThosePos(markables)
self . openThosePos(openables)
def intelligencia_OpenAndFlag(self, pos):
around = self . lookaroundThisPos(pos) # Cases around the current position
# Prepare an array with the number of remaining mines to find for the current position and the neighbor that will be worked on later
rMines = [self . getValAt(pos) - len(around['x']), 0]
# Search for neighbors (only usefull ones, meaning: self.getValAt(posneighbor) is a number and this neighbor still miss some mines)
neighToWorkOn = self . getneighbors(pos) & self . posToWorkOn
# markables: position that will be flagged / openables: positions that will be open... of course... / fullUnion: stroe all the squares
markables, openables = set(), set()
knownParts = [] # knownParts: list of the intersections of the '?' cases of all the neighbors of the current pos and the current neighbor
for pos2 in neighToWorkOn:
# Cases around the neighbor that is worked on right now
around2 = self . lookaroundThisPos(pos2)
# Update the number of mines still to find for the current neighbor
rMines[1] = self . getValAt(pos2) - len(around2['x'])
# Define the '?' that are owned only by the current "pos", and only by the current neighbor ("pos2")
onlys = [around['?'] - around2['?'], around2['?'] - around['?']]
# Define the minimum (yes "minimum", even if "max" is used!) number of mines that have to be in the '?' that are commun to "pos" and it's current neighbor pos2"
mInter = max(n - len(only) for n, only in zip(rMines, onlys))
if mInter <= 0 or 1 not in rMines:
continue # If these conditions are met, there is nothing "extrapolable" at the current position, so continue the iteration
currentIntersect = around['?'] & around2['?']
if currentIntersect:
# Store (if it exists) the current intersection of '?' cases for further checks
knownParts . append(currentIntersect)
for i in range(2): # Work on the two current LOCATIONS (pos, pos2)
if len(onlys[i]) == rMines[i] - mInter:
# The number of '?' cases that are only around the treated LOCATION matches the number mines of this LOCATION that are out of the interesction "pos & pos2". So, those cases will be flagged
markables |= onlys[i]
elif mInter == rMines[i]:
openables |= onlys[i] # If the number of mines surely present in the intersection "pos & pos2" matches the number of mines still to found arorund the treated LOCATION, all the cases out of the intersection for the current LOCATION can be opened
# Final check on the different intersections parts:
# Union of all the intersections for the current position and its differente neighbors
fullIntersection = {
posInter for posSet in knownParts for posInter in posSet}
if len(knownParts) == rMines[0] and sum(len(s) for s in knownParts) == len(fullIntersection):
# If some '?' cases are still unchecked while we can be sure that all the remaining mines are elsewhere (even without knowing their exact location), the leftovers can be opened
openables |= around['?'] - fullIntersection
return markables, openables
def complexSearch_CombineApproach(self):
# number of remaining mines to find
rMines = self . nMines - len(self . flagged)
matchPos = []
if rMines != 0:
# '?' that are joined to the current posToWorkOn...
borderUnknowns = {
pos2 for pos in self . posToWorkOn for pos2 in self . lookaroundThisPos(pos)['?']}
# ...then add the "next layer" of "?", ot be able to make more guesses on the remaining farther squares
borderUnknowns |= {
pos2 for pos in borderUnknowns for pos2 in self . lookaroundThisPos(pos)['?']}
for n in range(rMines if not (self . unknowns - borderUnknowns) else 1, min(rMines, len(borderUnknowns) - 1) + 1):
for posMines in combinations(borderUnknowns, n):
setPosMines = set(posMines)
for pos in self . posToWorkOn:
around = self . lookaroundThisPos(pos)
if self . getValAt(pos) != len(around['x']) + len(around['?'] & setPosMines):
break
else:
# if the for loop execute until its end, the current position is valid. Archive it.
matchPos . append(setPosMines)
# search for '?' that are never marked in any of the valid combinations
untouched = borderUnknowns - {flagPos for s in matchPos for flagPos in s}
if len(matchPos) == 1:
# Flag the found mines if only 1 match
self . flagThosePos(matchPos[0])
self . openThosePos(untouched) # open the untouched '?' (free of mines!!)
| Mine Sweeper | 57ff9d3b8f7dda23130015fa | [
"Puzzles",
"Game Solvers"
] | https://www.codewars.com/kata/57ff9d3b8f7dda23130015fa | 1 kyu |
# Whitespace
[Whitespace](http://compsoc.dur.ac.uk/whitespace/tutorial.php) is an esoteric programming language that uses only three characters:
* `[space]` or `" "` (ASCII 32)
* `[tab]` or `"\t"` (ASCII 9)
* `[line-feed]` or `"\n"` (ASCII 10)
All other characters may be used for comments. The interpreter ignores them.
Whitespace is an imperative, stack-based programming language, including features such as subroutines.
Each command in whitespace begins with an *Instruction Modification Parameter* (IMP).
```if:haskell
The return value is of type `Either String String`. If the program exits with no error, it should return `Right` with the output of the program. If there is an error, it should return `Left` with an error message (The content of the error message will not be check).
```
## IMPs
----
* `[space]`: Stack Manipulation
* `[tab][space]`: Arithmetic
* `[tab][tab]`: Heap Access
* `[tab][line-feed]`: Input/Output
* `[line-feed]`: Flow Control
There are two types of data a command may be passed: numbers and labels.
### Parsing Numbers
* Numbers begin with a `[sign]` symbol. The sign symbol is either `[tab]` -> **negative**, or `[space]` -> **positive**.
* Numbers end with a `[terminal]` symbol: `[line-feed]`.
* Between the sign symbol and the terminal symbol are binary digits `[space]` -> **binary-0**, or `[tab]` -> **binary-1**.
* A number expression `[sign][terminal]` will be treated as **zero**.
* The expression of just `[terminal]` should **throw an error**. *(The Haskell implementation is inconsistent about this.)*
### Parsing Labels
* Labels begin with any number of `[tab]` and `[space]` characters.
* Labels end with a **terminal** symbol: `[line-feed]`.
* Unlike with numbers, the expression of just `[terminal]` is **valid**.
* Labels **must** be unique.
* A label **may** be declared either before or after a command that refers to it.
## Input/Output
As stated earlier, there commands may read data from input or write to output.
### Parsing Input
Whitespace will accept input either characters or integers. Due to the lack of an input stream mechanism, the input will be passed as a string to the interpreter function.
* Reading a character involves simply taking a character from the input stream.
* Reading an integer involves parsing a decimal or hexadecimal number (prefixed by 0x) from the current position of the input stream, up to and terminated by a line-feed character. Octal numbers (prefixed by 0) and binary numbers (prefixed by 0b) may optionally be supported.
* The original implementation being in Haskell has stricter requirements for parsing an integer.
* The Javascript and Coffeescript implementations will accept any number that can be parsed by the **parseInt** function as a single parameter.
* The Python implementations will accept any number that can be parsed by the **int** function as a single parameter.
* The Java implementations **will** use an `InputStream` instance for input. For `InputStream` use `readLine` if the program requests a number and `read` if the program expects a character.
* An error should be thrown if the input ends before parsing is complete. *(This is a non-issue for the Haskell implementation, as it expects user input)*
### Writing Output
* For a number, append the output string with the number's string value.
* For a character, simply append the output string with the character.
* The Java implementations will support an optional `OutputStream` for output. If an `OutputStream` is provided, it should be flushed before and after code execution and filled as code is executed. The output string should be returned in any case.
## Commands
Notation: ***n*** specifies the parameter, `[number]` or `[label]`.
**Errors should be thrown** for invalid numbers, labels, and heap addresses, or if there are not enough items on the stack to complete an operation (unless otherwise specified). In addition, an error should be thrown for unclean termination.
### IMP \[space\] - Stack Manipulation
* `[space]` `(number)`: Push *n* onto the stack.
* `[tab][space]` `(number)`: Duplicate the *n*th value from the top of the stack and push onto the stack.
* `[tab][line-feed]` `(number)`: Discard the top *n* values below the top of the stack from the stack. (*For **n**<**0** or **n**>=**stack.length**, remove everything but the top value.*)
* `[line-feed][space]`: Duplicate the top value on the stack.
* `[line-feed][tab]`: Swap the top two value on the stack.
* `[line-feed][line-feed]`: Discard the top value on the stack.
### IMP \[tab\]\[space\] - Arithmetic
* `[space][space]`: Pop `a` and `b`, then push `b+a`.
* `[space][tab]`: Pop `a` and `b`, then push `b-a`.
* `[space][line-feed]`: Pop `a` and `b`, then push `b*a`.
* `[tab][space]`: Pop `a` and `b`, then push `b/a`\*. If `a` is zero, throw an error.
* \***Note that the result is defined as the floor of the quotient.**
* `[tab][tab]`: Pop `a` and `b`, then push `b%a`\*. If `a` is zero, throw an error.
* \***Note that the result is defined as the remainder after division and sign (+/-) of the divisor (a).**
### IMP \[tab\]\[tab\] - Heap Access
* `[space]`: Pop `a` and `b`, then store `a` at heap address `b`.
* `[tab]`: Pop `a` and then push the value at heap address `a` onto the stack.
### IMP \[tab\]\[line-feed\] - Input/Output
* `[space][space]`: Pop a value off the stack and output it as a **character**.
* `[space][tab]`: Pop a value off the stack and output it as a **number**.
* `[tab][space]`: Read a **character** from input, `a`, Pop a value off the stack, `b`, then store the ASCII value of `a` at heap address `b`.
* `[tab][tab]`: Read a **number** from input, `a`, Pop a value off the stack, `b`, then store `a` at heap address `b`.
### IMP \[line-feed\] - Flow Control
* `[space][space]` `(label)`: Mark a location in the program with label *n*.
* `[space][tab]` `(label)`: Call a subroutine with the location specified by label *n*.
* `[space][line-feed]` `(label)`: Jump unconditionally to the position specified by label *n*.
* `[tab][space]` `(label)`: Pop a value off the stack and jump to the label specified by *n* **if** the value is zero.
* `[tab][tab]` `(label)`: Pop a value off the stack and jump to the label specified by *n* **if** the value is less than zero.
* `[tab][line-feed]`: Exit a subroutine and return control to the location from which the subroutine was called.
* `[line-feed][line-feed]`: Exit the program.
----
## Notes
### Division and modulo
Whitespace expects floored division and modulo
* In Javascript and Coffeescript, the modulus operator is implemented differently than it was in the original Whitespace interpreter. Whitespace was influenced by having been originally implemented in Haskell. Javascript and Coffeescript also lack integer division operations. You need to pay a little extra attention in regard to the implementation of integer division and the modulus operator (See: [floored division in the Wikipedia article "Modulo operation"](https://en.wikipedia.org/wiki/Modulo_operation#Remainder_calculation_for_the_modulo_operation)
* Java defines methods for floor division and modulo in `Math` class. The methods differ from the traditional `/` and `%` operators.
* There is no difference between Whitespace and Python in regard to the standard implementation of integer division and modulo operations. | algorithms | def whitespace(code, inp=''):
code = '' . join(['STN' [' \t\n' . index(c)]
for c in code if c in ' \t\n'])
output, stack, heap, calls, pos, run, search, inp = [
], [], {}, [], [0], [True], [None], list(inp)
def set_(t, i, val):
t[i] = val
# Stack operations
def pop(n=0): return (assert_(n < len(stack)),
stack[n], set_(stack, slice(n, n + 1), ()))[1]
def get(n): return (assert_(n >= 0 and n < len(stack)), stack[n])[1]
def push(n): return stack . insert(0, n)
# Parsing utilities
def accept(tokens, action=None):
for token in tokens . split(','):
if code[pos[0]: pos[0] + len(token)] == token:
pos[0] += len(token)
if action:
p = 0
if token in ('SS', 'STS', 'STN'):
p = number()
elif token in ('NST', 'NSN', 'NTS', 'NTT', 'NSS'):
p = label()
((not search[0]) or token == 'NSS') and action(p)
return token
def assert_(* args):
if len(args) and args[0]:
return args[0]
raise Exception('error')
def number():
if accept('N'):
raise Exception('No digits for number')
n = '+0' if accept('S,T') == 'S' else '-0'
while not accept('N'):
n += str(int(accept('S,T') != 'S'))
return int(n, 2)
def label(l=''):
while not accept('N'):
l += accept('S,T') or ''
return l + '1'
instructions = {'SS': lambda n: push(n),
'STS': lambda n: push(get(n)),
'STN': lambda n: set_(stack, slice(1, len(stack) if n < 0 else 1 + n), ()),
'SNS': lambda _: push(get(0)),
'SNT': lambda _: set_(stack, slice(1, 1), [pop()]),
'SNN': lambda _: pop(),
'TSSS': lambda _: push(pop(1) + pop()),
'TSST': lambda _: push(pop(1) - pop()),
'TSSN': lambda _: push(pop(1) * pop()),
'TSTS': lambda _: push(pop(1) / assert_(pop())),
'TSTT': lambda _: (lambda d: push((pop() % d + d) % d))(assert_(pop())),
'TTS': lambda _: set_(heap, pop(1), pop()),
'TTT': lambda _: (assert_(stack[0] in heap), push(heap[pop()])),
'TNSS': lambda _: output . append(chr(pop())),
'TNST': lambda _: output . append(str(pop())),
'TNTS': lambda _: (set_(heap, pop(), ord(assert_(inp)[0])), inp . pop(0)),
'TNTT': lambda _: (lambda n: (set_(heap, pop(), int(assert_('' . join(inp[: n])))), set_(inp, slice(0, n + 1), ())))(inp . index('\n') if '\n' in inp else len(inp)),
'NST': lambda l: (calls . append(pos[0]), set_(pos, 0, heap[l]) if heap . get(l) else set_(search, 0, l)),
'NSN': lambda l: set_(pos, 0, heap[l]) if heap . get(l) else set_(search, 0, l),
'NTS': lambda l: (not pop()) and (set_(pos, 0, heap[l]) if heap . get(l) else set_(search, 0, l)),
'NTT': lambda l: pop() < 0 and (set_(pos, 0, heap[l]) if heap . get(l) else set_(search, 0, l)),
'NTN': lambda _: set_(pos, 0, assert_(calls). pop()),
'NNN': lambda _: set_(run, 0, False),
'NSS': lambda l: (assert_((not heap . get(l)) or heap[l] == pos[0]), set_(heap, l, pos[0]), search[0] == l and set_(search, 0, 0)),
}
while run[0]:
assert_(pos[0] < len(code))
any(accept(* instruction)
for instruction in instructions . items()) or assert_()
return '' . join(output)
| Whitespace Interpreter | 52dc4688eca89d0f820004c6 | [
"Esoteric Languages",
"Interpreters",
"Algorithms"
] | https://www.codewars.com/kata/52dc4688eca89d0f820004c6 | 2 kyu |
_(Revised version from previous series 6)_
# Number Pyramid:
Image a number pyramid starts with `1`, and the numbers increasing by `1`.
Today, it has total `5000` levels.
For example, the top 4 levels of the pyramid looks like:
```
1
2 3
4 5 6
7 8 9 10
```
___
# Left and Right:
Now from the center line, cut the pyramid into `Left` and `Right`.
In the above example, it will become:
```
Left: # Right:
#
2 # 3
4 # 6
7 8 # 9 10
(The numbers of center line was cut, do not go on any side.)
```
___
# Input:
You will be given a number `n`, it will not go beyond `5000` levels.
___
# Output:
You need to return the number is locating at `Left` or `Right` part.
* Return `'L'` for Left.
* Return `'R'` for Right.
* Return `'C'` for Center/been Cut
__Examples:__
```
left_right(1) --> 'C'
left_right(2) --> 'L'
left_right(3) --> 'R'
left_right(4) --> 'L'
left_right(5) --> 'C'
left_right(6) --> 'R'
```
___
# Golfing Message:
The length of your code should be less or equal to `72`.
The length of reference solution is `65` (Python) and `67` (JS).
___
If you like this series, welcome to do [other kata](https://www.codewars.com/collections/code-golf-number-pyramid-series) of it. | games | def left_right(n): return 'CLR' [int((8 * n - 4) * * .5 % 2 / / - 1)]
| [Code Golf] Number Pyramid Series 6(Revised) - Left or Right | 62eedcfc729041000ea082c1 | [
"Mathematics",
"Restricted"
] | https://www.codewars.com/kata/62eedcfc729041000ea082c1 | 6 kyu |
In a computer operating system that uses paging for virtual memory management, page replacement algorithms decide which memory pages to page out when a page of memory needs to be allocated. Page replacement happens when a requested page is not in memory (page fault) and a free page cannot be used to satisfy the allocation, either because there are none, or because the number of free pages is lower than some threshold.
## The FIFO page replacement algorithm
The first-in, first-out (FIFO) page replacement algorithm is a low-overhead algorithm that requires little bookkeeping on the part of the operating system. The idea is obvious from the name: the operating system keeps track of all the pages in memory in a queue, with the most recent arrival at the back, and the oldest arrival in front. When a page needs to be replaced, the oldest page is selected. Note that a page already in the queue is not pushed at the end of the queue if it is referenced again.<br>
Your task is to implement this algorithm. The function will take two parameters as input: the number of maximum pages that can be kept in memory at the same time ```n``` and a ```reference list``` containing numbers. Every number represents a page request for a specific page (you can see this number as the unique ID of a page). The expected output is the status of the memory after the application of the algorithm. Note that when a page is inserted in the memory, it stays at the same position until it is removed from the memory by a page fault.
## Example:
Given:
* N = 3,
* REFERENCE LIST = \[1, 2, 3, 4, 2, 5\],
```
* 1 is read, page fault --> memory = [1];
* 2 is read, page fault --> memory = [1, 2];
* 3 is read, page fault --> memory = [1, 2, 3];
* 4 is read, page fault --> memory = [4, 2, 3];
* 2 is read, already in memory, nothing happens;
* 5 is read, page fault --> memory = [4, 5, 3].
```
So, at the end we have the list ```[4, 5, 3]```, which is what you have to return. If not all the slots in the memory get occupied after applying the algorithm, fill the remaining slots (at the end of the list) with ```-1``` to represent emptiness (note that the IDs will always be >= 1).
| algorithms | def fifo(n, reference_list):
memory = [- 1] * n
c = 0
for ref in reference_list:
if ref in memory:
continue
memory[c] = ref
c = (c + 1) % n
return memory
| Page replacement algorithms: FIFO | 62d34faad32b8c002a17d6d9 | [
"Algorithms",
"Lists"
] | https://www.codewars.com/kata/62d34faad32b8c002a17d6d9 | 7 kyu |
## Overview
The genius supervillain Professor Lan X, head of the mysterious organization Just4EvilCoders, is bored in his secret volcano research laboratory and challenges you to the following game:
First, **you will be blindfolded**.
Then on a very, very large 2d chessboard, he will place a chess piece on a starting square, at coordinates = `(0,0)`.
The chess piece he uses may be a standard King or Knight, or it may be a **completely custom piece with custom possible move-set**.
Then he will select a basic move pattern from that piece's **distinct** possible moves, **without telling you which move(s) he has chosen**.
Then he will begin repeatedly moving the piece **in the same repeating pattern of moves** over and over.
To make things clear, let's look at an example:
```python
known inputs:
moves = [(-1, 1), (1, 0), (0, -1), (0, 1), (-1, 0), (1, -1), (-1, -1), (1, 1)]
unknown to you:
actual_length_of_move_pattern = 2
actual_move_pattern_chosen = right (1,0) then down (0,-1), repeating forever
```
In the above game instance, he has decided to play with a standard King, which has a total `moves` list of `8` possible moves: you **do know** the `moves` list before the game starts.
**Unknown to you** he then chose to play the game with the following 2 King moves: "rightwards" `(1,0)` followed by "downwards" `(0,-1)`, **in that order**.
So, to be clear, what will be the chess piece's actual location during this particular game?
- After his first move (rightwards), the King is at `(1,0)`
- After his second move (downwards), the King is at `(1,-1)`
- After his third move (**the repeating pattern now returns to rightwards again**), the King is at `(2,-1)`
- After his fourth move (**the repeating pattern now returns to downwards again**), the King is at `(2,-2)`
- After his fifth move (he moves rightwards again), the King is at `(3,-2)` etc.
Your game rules are as follows:
After **each** of the supervillain's moves, you must guess the location of where you think the chess piece **currently** is on the chessboard. If your guess correctly matches the **current** location of the piece, you win.
Remember: you are blindfolded **and** you do not know which moves the evil genius is performing - only that he is repeating a basic pattern of distinct moves.
Professor Lan X is very busy working on his Death Ray so **you will only be given a limited number of guesses: you have 500 guesses to win each game he decides to play**.
If you haven't found the chess piece within this guess limit you will lose and you will ~~BE THROWN INTO THE JUST4EVILCODERS SHARK TANK~~ find that nothing bad happens to you of course... those sharks?? Oh, they are just there for.. ummmm... decorative purposes!! Yes, yes, they are quite friendly really :)
---
## Inputs
You will be given `moves`, which is a `list` of `2-ples` of `integers`, which represents **all possible moves** of a given chess piece.
For example, for a game played with a standard King, you would be given the list: `[(-1, 1), (1, 0), (0, -1), (0, 1), (-1, 0), (1, -1), (-1, -1), (1, 1)]` which represents all 8 possible moves of a King.
As another example, here is a possible `moves` input list for a **completely custom** strange chess piece which has only 7 possible moves: `[(10000,43), (-2,13), (5,5), (4,-11), (0,10), (999,-444), (0,1)]`
The maximum size of the `moves` list in the tests will be `8`, and the minimum size of the `moves` list will be `5`.
The largest step size of the custom pieces will be `+/- 10000`, i.e. `(10000, -10000)` is a valid possible move for a custom piece. On the other hand, `(0,0)` will never be used as a random move for any random chess piece.
**IMPORTANT:** A move, if chosen, will **only occur once** in the repeating basic pattern of moves - therefore for example `[(1,1), (-1,0), (1,1)]` **is not an allowed basic pattern of 3 moves to repeat**, because there is a move - `(1,1)` - that has been used more than once in this basic pattern of length 3.
## Outputs
You must return a `list` of `2-ples` of `integers`. This list represents your guesses **sorted in the order in which you will make each guess**.
Note that each of your guesses takes place **after** the supervillain makes his move from the starting square `(0,0)`, so for example the following guess list:
`your_returned_solution_guess_list = [ (4,7), (33,-5), (123,-40), ...]`
means that you guess that the piece is at square `(4,7)` after the supervillain moved the piece **once**, then you guess that the piece is at square `(33,-5)` after the supervillain moved the piece **twice**, etc.
Your code must be able to handle any game strategy that Professor Lan X decides to use: whichever chess piece he decides to use, whether he uses from `1` up to `max = len(moves)` distinct moves of that chess piece, **and** whichever repeated basic pattern he decides to keep performing those moves in.
## Final important reminder
Remember that your returned solution list of guesses must be of `length <= 500` for each possible game that Professor Lan X challenges you to.
---
## Acknowledgements
This kata was significantly improved after discussions with **@Just4FunCoder** and **@LanXnHn**, and early comments by @Blind4Basics, @Kacarott, @Madjosz - thanks!
| algorithms | from functools import reduce
from itertools import combinations
def _add(v0, v1):
return v0[0] + v1[0], v0[1] + v1[1]
def _mul(v, k):
return v[0] * k, v[1] * k
def _blindfold_chess(moves):
mcs = {k: [reduce(_add, c) for c in combinations(moves, k)]
for k in range(1, len(moves) + 1)}
i = 0
while mcs:
i += 1
for j, ms in reversed(mcs . items()):
if i % j == 0:
yield _mul(ms . pop(), i / / j)
if not ms:
del mcs[j]
break
else:
yield (0, 0)
def blindfold_chess(moves):
return list(_blindfold_chess(moves))
| Evil genius game - Find the moving chess piece while blindfolded | 62e068c14129156a2e0df46a | [
"Algorithms",
"Mathematics",
"Combinatorics",
"Performance"
] | https://www.codewars.com/kata/62e068c14129156a2e0df46a | 4 kyu |
One of the common ways of representing color is the RGB color model, in which the Red, Green, and Blue primary colors of light are added together in various ways to reproduce a broad array of colors.
One of the ways to determine brightness of a color is to find the value V of the alternative HSV (Hue, Saturation, Value) color model. Value is defined as the largest component of a color:
```
V = max(R,G,B)
```
You are given a list of colors in 6-digit [hexidecimal notation](https://en.wikipedia.org/wiki/Web_colors) `#RRGGBB`. Return the brightest of these colors!
For example,
```
brightest(["#001000", "#000000"]) == "#001000"
brightest(["#ABCDEF", "#123456"]) == "#ABCDEF"
```
If there are multiple brightest colors, return the first one:
```
brightest(["#00FF00", "#FFFF00", "#01130F"]) == "#00FF00"
```
Note that both input and output should use upper case for characters `A, B, C, D, E, F`.
| reference | # String comparison is enough, no need to convert
def brightest(colors):
return max(colors, key=lambda c: max(c[1: 3], c[3: 5], c[5:]))
| Which color is the brightest? | 62eb800ba29959001c07dfee | [
"Algorithms",
"Strings"
] | https://www.codewars.com/kata/62eb800ba29959001c07dfee | 7 kyu |
In this kata you will compute the last digit of the sum of squares of Fibonacci numbers.
Consider the sum `$S_n = F_0^2 + F_1^2 + ... + F_n^2$`, where `$F_0=0$`, `$F_1=1$` and `$F_i=F_{i-1}+F_{i-2}$` for `$i\geq2$` , you must compute the last digit of `$S_n$`.
Example: Given input `$n=7$`, `$S_n=273$`. Therefore the output is 3.
Note that `$0\leq n\leq10^{18}$`. So bruteforce will not work. | algorithms | def fibonacci_squared_sum(n): return int(
"012650434056210098450676054890" [n % 30])
| Last digit of the squared sum of Fibonacci numbers | 62ea53ae888e170058f00ddc | [
"Mathematics"
] | https://www.codewars.com/kata/62ea53ae888e170058f00ddc | 6 kyu |
# Summary
If you've ever been at rock/metal concerts, you know that they're great, but can be quite uncomfortable sometimes. In this kata, we're going to find the best place at the dance floor to be standing at!
`dance_floor` will be given as an array of strings, each containing:
* ASCII letters (uppercase and lowercase), representing people.
* Space characters (`' '`), representing empty space.
There will always be at least one string. All strings will have the same length (> 0).
Your task is to rank potential places to stand at and return the best one. If multiple places happen to share the same best score, you may return any of them.
```if:python
In Python, return value is expected to be a tuple of two ints: `(y, x)`, where `y` is index of the string and `x` is index of the character in that string.
```
```if:cpp
In C++, your function should return `std::pair<size_t, size_t>`, where `first` is index of the string and `second` is index of the character in that string (look at it as `{Y, X}` coordinates).
```
```if:go
In Go, your function should return `(y, x int)`, where `y` is index of the string and `x` is index of the character in that string.
```
# Factors for ranking
### The place must be empty
You're not a tough guy and you can't just push someone away and take their place. So, you're only considering empty space for yourself. Input will always contain at least one such place.
### Distance from stage
The closer you are to the stage, the better! So, the base score for a place equals length of the `dance_floor` minus the index of the string.
Example: if `dance_floor` contains 5 strings, the first (closest to the stage) gets score of 5 and the last gets score of 1.
### Height of the person in front of you
Even if you are close to the stage, a huge guy in front of you can spoil all the view! Because of that, you need to factor in his/her height.
In the input strings, people are represented as letters. Height of a person is encoded as a position of the letter in the alphabet. `A` has height of 1, `B` - 2, `C` - 3, and so on. You'll need to multiply the initial score by `0.99 ^ height` (`0.99` to the power of `height`). If there's nobody right in front of you, the score is left as is.
### Beer
Some of the fans are standing with a glass of beer in their hand. They are represented as uppercase letters (as opposed to lowercase letters without beer). You know that this beer always gets split around, so you want to avoid standing next to these people. For each beer holder next to you, you should multiply the score by `0.8`. "People next to you" are people to the left, to the right, in front of you, or behind you.
### Moshpits
When you see a large free area that contains a 2x2 square of spaces, you know that it's not an accident. It's a moshpit! You don't like being kicked around, so you avoid moshpits at all costs and consider them only if there's no other free space available.
**Note:** moshpits can be of any shape, not necessarily square or rectangle. They just need to contain a 2x2 piece somewhere. See example below.
# Example
```
dance_floor = ["gbvKq JfiM I", "q jecl fvoX", "L Foa ygKT"]
best_place(dance_floor) -> (1, 1)
```
`dance_floor` more visually:
```
# (stage here)
"gbvKq JfiM I"
"q jecl fvoX"
"L Foa ygKT"
```
Each `' '` explained:
* `(0,11)` gets score of `(3-0) * 0.8^2 = 1.92`. Even though it's right in front of the stage, you're surrounded with 2 beer holders, which makes it not ideal.
* `(1,1)` gets score of `(3-1) * 0.99^2 = 1.9602`. This place is a bit further, but the person in front of you is very short, so you choose to spend the concert there.
* `(0,5), (0,6), (1,6), (1,7), (1,8), (2,6), (2,7), (2,8)` is a moshpit (looks more a wall of death in this case, haha). You can recognize it by noticing the `(1,6)..(2,7)` square or the `(1,7)..(2,8)` square. In this example, there are other places where you can stand in peace, so you don't even consider these, even though `(0,5)` has the best score in the entire club.
* `(2,1)` gets score of `(3-2) * 0.8 = 0.8`. There's nodoby in front of you, but you would stand even further away from the stage and carry a beer risk.
* `(2,2)` gets score of `(3-2) * 0.99^10 * 0.8 = 0.7235`. Same distance and risk, plus there's a person in front. | algorithms | def places_around(dance_floor, row, col, empty=False):
places = []
for i in ((- 1, 0), (0, - 1), (0, 1), (1, 0)):
rel_row, rel_col = row + i[0], col + i[1]
if 0 <= rel_row < rows and 0 <= rel_col < cols and (not empty or dance_floor[rel_row][rel_col] == ' '):
places . append((rel_row, rel_col))
return places
def best_place(dance_floor):
global rows, cols
rows, cols = len(dance_floor), len(dance_floor[0])
empty_places = []
for row in enumerate(dance_floor): # list all empty places
for col in enumerate(row[1]):
if col[1] == ' ':
empty_places . append((row[0], col[0]))
moshpit_places = set()
for row, col in empty_places: # find 2x2 moshpits
if row < rows - 1 and col < cols - 1 and dance_floor[row][col + 1] == dance_floor[row + 1][col] == dance_floor[row + 1][col + 1] == ' ':
moshpit_places = moshpit_places . union(
{(row, col), (row, col + 1), (row + 1, col), (row + 1, col + 1)})
moshpit_checked = set() # places that were already checked for branches
while True: # branches of 2x2 moshpits
length = len(moshpit_places)
moshpit_unchecked = moshpit_places . difference(moshpit_checked)
moshpit_checked = moshpit_checked . union(moshpit_places)
for row, col in moshpit_unchecked:
moshpit_places = moshpit_places . union(
set(places_around(dance_floor, row, col, True)))
if length - len(moshpit_places) == 0: # stop if no new branches were found
break
best_score = float('-inf')
for row, col in empty_places:
score = rows - row # distance from stage
if row > 0: # height of person in front
score *= .99 * * int(bin(ord(dance_floor[row - 1][col]))[- 5:], 2)
for rel_row, rel_col in places_around(dance_floor, row, col): # beer
score *= 1 - dance_floor[rel_row][rel_col]. isupper() * .2
score -= 999 * ((row, col) in moshpit_places) # moshpits
if score > best_score: # keep track of best spot
best_score = score
best_place = (row, col)
return best_place
| Best place at concert | 6112917ef983f2000ecbd506 | [
"Strings",
"Arrays",
"Algorithms"
] | https://www.codewars.com/kata/6112917ef983f2000ecbd506 | 5 kyu |
# Peg Solitaire
<svg
width="92.004997mm"
height="92.004997mm"
viewBox="0 0 92.004997 92.004997"
version="1.1"
id="svg5"
xmlns:xlink="http://www.w3.org/1999/xlink"
xmlns="http://www.w3.org/2000/svg"
xmlns:svg="http://www.w3.org/2000/svg">
<defs
id="defs2">
<linearGradient
id="linearGradient1150">
<stop
style="stop-color:#ffaaaa;stop-opacity:1"
offset="0"
id="stop1146" />
<stop
style="stop-color:#ff0000;stop-opacity:1"
offset="0.52336627"
id="stop3090" />
<stop
style="stop-color:#800000;stop-opacity:1"
offset="1"
id="stop1148" />
</linearGradient>
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient1152"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,73.011649,11.260739)" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4897"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,86.011649,11.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4901"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,99.011649,11.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4905"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,73.011649,24.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4909"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,86.011649,24.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4913"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,99.011649,24.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4917"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,47.011649,37.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4921"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,60.011649,37.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4925"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,73.011649,37.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4929"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,86.011649,37.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4933"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,112.01165,37.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4937"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,125.01165,37.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4941"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,125.01165,50.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4945"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,112.01165,50.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4949"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,99.011649,50.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4953"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,60.011649,50.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4957"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,47.011649,50.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4961"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,47.011649,63.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4965"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,73.011649,63.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4969"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,99.011649,63.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4973"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,112.01165,63.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4977"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,125.01165,63.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4981"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,73.011649,76.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4985"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,99.011649,76.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4989"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,99.011649,89.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4993"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,86.011649,89.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient4997"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,73.011649,89.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient931"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,99.011649,37.260424)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient941"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,86.011334,76.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient943"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,86.011334,63.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient947"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,73.011334,50.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
<radialGradient
xlink:href="#linearGradient1150"
id="radialGradient951"
gradientUnits="userSpaceOnUse"
gradientTransform="matrix(-1.1956985,-0.73160339,0.65129485,-1.0645771,60.011334,63.260739)"
cx="25.113058"
cy="-14.110431"
fx="25.113058"
fy="-14.110431"
r="5" />
</defs>
<g
id="layer1"
transform="translate(0.20025,0.20025)">
<path
style="fill:#c87137;stroke:#000000;stroke-width:1.005;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-opacity:1"
d="m 26.30225,0.30225 h 39 v 25.999999 h 25.999999 v 39 H 65.30225 v 25.999999 h -39 V 65.302249 h -26 v -39 h 26 z"
id="path394" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="path572"
cx="32.80225"
cy="6.8022499"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle855"
cx="45.80225"
cy="6.8022499"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle857"
cx="58.80225"
cy="6.8022499"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle859"
cx="32.80225"
cy="19.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle861"
cx="45.80225"
cy="19.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle863"
cx="58.80225"
cy="19.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle865"
cx="32.80225"
cy="71.802246"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle867"
cx="45.80225"
cy="71.802246"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle869"
cx="58.80225"
cy="71.802246"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle871"
cx="32.80225"
cy="84.802246"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle873"
cx="45.80225"
cy="84.802246"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle875"
cx="58.80225"
cy="84.802246"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle877"
cx="6.8022504"
cy="32.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle879"
cx="6.8022504"
cy="45.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle881"
cx="6.8022504"
cy="58.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle883"
cx="19.80225"
cy="32.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle885"
cx="19.80225"
cy="45.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle887"
cx="19.80225"
cy="58.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle889"
cx="32.80225"
cy="32.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle891"
cx="32.80225"
cy="45.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle893"
cx="32.80225"
cy="58.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle895"
cx="45.80225"
cy="32.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle897"
cx="45.80225"
cy="45.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle899"
cx="45.80225"
cy="58.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle901"
cx="58.80225"
cy="32.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle903"
cx="58.80225"
cy="45.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle905"
cx="58.80225"
cy="58.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle907"
cx="71.802254"
cy="32.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle909"
cx="71.802254"
cy="45.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle911"
cx="71.802254"
cy="58.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle913"
cx="84.802254"
cy="32.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle915"
cx="84.802254"
cy="45.80225"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle917"
cx="84.802254"
cy="58.80225"
r="1.755" />
<ellipse
style="fill:url(#radialGradient1152);fill-opacity:1;stroke-width:0.203105"
id="path941"
cx="32.80225"
cy="6.8023143"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4897);fill-opacity:1;stroke-width:0.203105"
id="ellipse4895"
cx="45.80225"
cy="6.8023143"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4901);fill-opacity:1;stroke-width:0.203105"
id="ellipse4899"
cx="58.80225"
cy="6.8023143"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4905);fill-opacity:1;stroke-width:0.203105"
id="ellipse4903"
cx="32.80225"
cy="19.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4909);fill-opacity:1;stroke-width:0.203105"
id="ellipse4907"
cx="45.80225"
cy="19.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4913);fill-opacity:1;stroke-width:0.203105"
id="ellipse4911"
cx="58.80225"
cy="19.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4917);fill-opacity:1;stroke-width:0.203105"
id="ellipse4915"
cx="6.8022504"
cy="32.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4921);fill-opacity:1;stroke-width:0.203105"
id="ellipse4919"
cx="19.80225"
cy="32.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4925);fill-opacity:1;stroke-width:0.203105"
id="ellipse4923"
cx="32.80225"
cy="32.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4929);fill-opacity:1;stroke-width:0.203105"
id="ellipse4927"
cx="45.80225"
cy="32.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4933);fill-opacity:1;stroke-width:0.203105"
id="ellipse4931"
cx="71.802254"
cy="32.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4937);fill-opacity:1;stroke-width:0.203105"
id="ellipse4935"
cx="84.802254"
cy="32.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4941);fill-opacity:1;stroke-width:0.203105"
id="ellipse4939"
cx="84.802254"
cy="45.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4945);fill-opacity:1;stroke-width:0.203105"
id="ellipse4943"
cx="71.802254"
cy="45.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4949);fill-opacity:1;stroke-width:0.203105"
id="ellipse4947"
cx="58.80225"
cy="45.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4953);fill-opacity:1;stroke-width:0.203105"
id="ellipse4951"
cx="19.80225"
cy="45.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4957);fill-opacity:1;stroke-width:0.203105"
id="ellipse4955"
cx="6.8022504"
cy="45.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4961);fill-opacity:1;stroke-width:0.203105"
id="ellipse4959"
cx="6.8022504"
cy="58.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4965);fill-opacity:1;stroke-width:0.203105"
id="ellipse4963"
cx="32.80225"
cy="58.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4969);fill-opacity:1;stroke-width:0.203105"
id="ellipse4967"
cx="58.80225"
cy="58.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4973);fill-opacity:1;stroke-width:0.203105"
id="ellipse4971"
cx="71.802254"
cy="58.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4977);fill-opacity:1;stroke-width:0.203105"
id="ellipse4975"
cx="84.802254"
cy="58.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4981);fill-opacity:1;stroke-width:0.203105"
id="ellipse4979"
cx="32.80225"
cy="71.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4985);fill-opacity:1;stroke-width:0.203105"
id="ellipse4983"
cx="58.80225"
cy="71.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4989);fill-opacity:1;stroke-width:0.203105"
id="ellipse4987"
cx="58.80225"
cy="84.802307"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4993);fill-opacity:1;stroke-width:0.203105"
id="ellipse4991"
cx="45.80225"
cy="84.802307"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient4997);fill-opacity:1;stroke-width:0.203105"
id="ellipse4995"
cx="32.80225"
cy="84.802307"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient931);fill-opacity:1;stroke-width:0.203105"
id="ellipse929"
cx="58.80225"
cy="32.802002"
rx="3.8381851"
ry="3.8382502" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle933"
cx="45.801933"
cy="71.802246"
r="1.755" />
<circle
style="fill:#000000;stroke-width:0.0928686"
id="circle935"
cx="45.801933"
cy="58.80225"
r="1.755" />
<ellipse
style="fill:url(#radialGradient943);fill-opacity:1;stroke-width:0.203105"
id="ellipse937"
cx="45.801933"
cy="58.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient941);fill-opacity:1;stroke-width:0.203105"
id="ellipse939"
cx="45.801933"
cy="71.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient947);fill-opacity:1;stroke-width:0.203105"
id="ellipse945"
cx="32.801933"
cy="45.802315"
rx="3.8381851"
ry="3.8382502" />
<ellipse
style="fill:url(#radialGradient951);fill-opacity:1;stroke-width:0.203105"
id="ellipse949"
cx="19.801935"
cy="58.802315"
rx="3.8381851"
ry="3.8382502" />
</g>
</svg>
## Game Instructions
[Peg solitaire](https://en.wikipedia.org/wiki/Peg_solitaire) is a puzzle game which involves moving pegs on a board. Each move consists of taking a peg and "jumping" it over another peg to an empty hole two spaces away, either vertically or horizontally. The peg that was "jumped" over is then removed from the board. The goal of the game is to remove all but a single peg from the board.
While the image above shows the standard "English" board, there are many different board layouts and initial peg configurations.
## Kata Task
Given a board's initial state, return a list of valid moves which will leave the board with only a single peg remaining.
#### The board
The board will be given as a string where each line represents a row and each character represents a position on the board where
* `'.'` represents an open hole
* `'O'` represents a peg in a hole
* `'_'` represents a non-usable space
For example, the standard English board shown in the image above would be represented as:
```
__OOO__
__OOO__
OOOOOOO
OOO.OOO
OOOOOOO
__OOO__
__OOO__
```
Each position on the board can be identified by its number when counted starting from 1 in row-major order. For example, the standard English board would be numbered:
```
__ __ 01 02 03 __ __
__ __ 04 05 06 __ __
07 08 09 10 11 12 13
14 15 16 17 18 19 20
21 22 23 24 25 26 27
__ __ 28 29 30 __ __
__ __ 31 32 33 __ __
```
#### Moves
Your solution should return a list of tuples, where each tuple represents a single move. The first value being the peg to be moved, the second value being where the peg should be moved to.
For example, a valid first move on the standard English board could be `(5, 17)`, which would move the peg at position `5` to the hole at position `17` removing the peg at position `10` from the board.
```
__OOO__ __OOO__
__OOO__ __O.O__
OOOOOOO OOO.OOO
OOO.OOO ==> OOOOOOO
OOOOOOO OOOOOOO
__OOO__ __OOO__
__OOO__ __OOO__
```
## Example
Given the initial board:
```
_O.
.OO
O..
```
Which would be numbered as:
```
__ 01 02
03 04 05
06 07 08
```
A valid solution would be: `[(1, 7), (6, 8), (8, 2)]`
```
_O. _.. _.. _.O
.OO ==> ..O ==> ..O ==> ...
O.. OO. ..O ...
```
## Notes
* All tested boards will be solvable
* Some boards may have non-usable space between two holes, you may not jump over these spaces
* Tests consist of:
* 10 fixed tests
* 30 random tests where the board's dimensions satisfy `4 <= width, length <= 6`
| algorithms | from functools import cache
def solve(board):
moves, board = [], board . splitlines()
poss = {p: i for i, p in enumerate(
((x, y) for x, r in enumerate(board) for y, v in enumerate(r) if v != '_'), 1)}
@ cache
def dfs(pegs):
if len(pegs) == 1:
return True
for (x, y), m in poss . items():
if (x, y) not in pegs:
for dx, dy in ((- 1, 0), (0, - 1), (1, 0), (0, 1)):
if ((x1 := x + dx), (y1 := y + dy)) in pegs and ((x2 := x + 2 * dx), (y2 := y + 2 * dy)) in pegs:
moves . append((poss[x2, y2], m))
if dfs(pegs - frozenset([(x1, y1), (x2, y2)]) | frozenset([(x, y)])):
return True
moves . pop()
return False
if dfs(frozenset((x, y) for x, y in poss if board[x][y] == 'O')):
return moves
| Peg Solitaire | 62e41d4816d2d600367aee79 | [
"Game Solvers",
"Games"
] | https://www.codewars.com/kata/62e41d4816d2d600367aee79 | 4 kyu |
## Backstory
The problem is based on these katas, although completing it does not require completing these ones first:
https://www.codewars.com/kata/514b92a657cdc65150000006
https://www.codewars.com/kata/62e5ab2316d2d6d2a87af831
Since my previous enhancement was not big of a deal, I decided to give my friend a real challenge this time.
## The task
### The original task
"If we list all the natural numbers below 10 that are multiples of 3 or 5, we get 3, 5, 6 and 9. The sum of these multiples is 23.
Finish the solution so that it returns the sum of all the multiples of 3 or 5 below the number passed in."
### The enhanced task
This time it is not only about the multiples of 3 or 5. This time you will get not only the numberlimit, but also a whole array of primes. Your task is to find every number that
- is below the limit, and
- is a multiple of one or more primes in the array.
Then (as usual) return the sum of those numbers.
## Examples
If you get ```10``` as limit, and ```[ 2, 3 ]``` as primes, you should return the sum of ```2, 3, 4, 6, 8, 9```, which is ```32```. Even though 6 is a multiple of 2 and 3 as well, you should count every number only once. 10 is not in the solution, since we are looking for numbers below the limit.
If you get ```10``` as limit, and ```[ 11, 13 ]``` as primes, your code should return ```0```, since there are no multiples of 11 or 13 below 10.
## Additional information
- Your inputs:
- a string containing a positive, whole number
- an array of Integers, containing positive prime numbers
- Your output: a string containing a positive, whole number (aka your solution)
- You can expect the inputs to be valid, so:
- the limit will contain only digits (0-9)
- the array of primes will contain only primes, there will be no duplicates
- although the limit can be really big, up to 30 digits
- also your array can contain up to 20 different primes (this includes the possibility of an empty array as well)
- I think this task is more about logic than performance, but I still recommend you to optimalize your code | games | from itertools import combinations
from functools import reduce
from operator import mul
def find_them(number_limit, primes):
res = 0
for ln in range(1, len(primes) + 1):
for cmb in combinations(primes, ln):
mlt, sgn = reduce(mul, cmb), (- 1) * * (ln + 1)
pw = (number_limit - 1) / / mlt
res += pw * (pw + 1) / / 2 * mlt * sgn
return res
| Multiples of some primes | 62e66bea9db63bab88f4098c | [
"Mathematics",
"Algorithms",
"Performance"
] | https://www.codewars.com/kata/62e66bea9db63bab88f4098c | 5 kyu |
```0, 0, 1, 0, 2, 0, 2, 2, 1, 6, 0, 5, 0, 2, 6, 5, 4, 0, 5, 3, 0, 3, …```
This is the ```Van Eck's Sequence```.
Let's go through it step by step.
```
Term 1: The first term is 0.
Term 2: Since we haven’t seen 0 before, the second term is 0.
Term 3: Since we had seen a 0 before, one step back, the third term is 1
Term 4: Since we haven’t seen a 1 before, the fourth term is 0
Term 5: Since we had seen a 0 before, two steps back, the fifth term is 2.
```
And so on...
In case you missed it, the rule here is that term `n+1` is the "distance" (`n - m`) between term `n`, and the highest term `m` with the same value, where `m < n`. If there is no such `m` (ie. We haven't "seen" it before) then the term is `0`. For example:
```
-------
V | We "saw" a 0 two positions earlier, so the next term is 2
0, 0, 1, 0, 2, 0, ?
```
Your task is to find the ```n_th number``` in Van Eck's Sequence. ```(1-based)```
There are 200 random tests of range 100 to 1000.
Good luck! | reference | def dist(arr):
for i in range(1, len(arr)):
if arr[- 1 - i] == arr[- 1]:
return i
return 0
def seq(n):
s = [0, 0]
for _ in range(n):
s . append(dist(s))
return s[n - 1]
| Van Eck's Sequence | 62e4df54323f44005c54424c | [
"Algorithms"
] | https://www.codewars.com/kata/62e4df54323f44005c54424c | 6 kyu |
*Note: this kata assumes that you are familiar with basic functional programming.*
In this kata, you are going to infer the type of an expression based on a given context. Your goal is to implement the `infer_type` function so that it can take in a context like:
```python
"""
myValue : A
concat : List -> List -> List
append : List -> A -> List
map : (A -> B) -> (List -> List)
pure : A -> List
"""
```
and evaluate the type of an expression like:
```python
"append (concat (pure myValue) (pure myValue)) myValue" # should be "List"
```
Each line in the context string is a type declaration that defines what type the value on the left of the `:` should be of: `<value_name> : <type>`. This syntax is similar to declarations in Haskell/Idris.
In the above context, `myValue` is a value of type `A`, and `pure` is a function that takes in a value of type `A` and produces a value of type `List`. `map`, on the other hand, is a function that takes in a function from `A` to `B`, and produces a function from `List` to `List`.
In this kata, the syntax for a `type` is:
```
type := [A-Z][a-zA-Z0-9]*
| type -> type
| '(' type ')'
```
Note that the arrow `->` in a type is right associative (due to [currying](https://en.wikipedia.org/wiki/Currying)), i.e. `A -> B -> C -> D` is equivalent to `A -> (B -> (C -> D))`. As another example, the type signature `f : A -> B -> C` actually means `f : A -> (B -> C)`, which read as "the function `f` takes in a value of type `A` and returns a function of type `B -> C`". Therefore, calling the function like `(f a) b` can be simplified to `f a b` as function application is left-associative.
The syntax for an `expression` (whose type is to be evaluated by the `infer_type` method) is:
```
expression := [a-z][a-zA-Z0-9]*
| expression ' ' expression
| '(' expression ')'
```
(the second production rule is function application)
## Error-Handling
All inputs will be in valid syntax; however, your code should __raise an error__ (throw `IllegalArgumentException` in Java language) in the following cases:
- a value in the expression is not declared in the context
- function application on a value (e.g. `foo param` when `foo` is not a function)
- invoking a function with a value of an incorrect type (e.g. applying value of type `C` to a function of type `A -> B`)
## Notes
- Functions are values!!! They can be passed as an argument to another function.
- Functions can be partially applied, e.g. `A -> B -> C` applied to a value of type `A` should be of type `B -> C`.
- Your code must be able to handle extra whitespaces and parentheses in both the context and the expression, e.g. `myFunc:A -> (((B) -> C))` for context, and `func (val)` for expression.
- The return value of `infer_type` must not contain any unnecessary parentheses, e.g. `A -> (B -> C)` should be written as `A -> B -> C`. The return value is allowed to contain extra spaces though. | reference | import re
def parse_type(s):
tokens = re . findall(r'->|[()]|[A-Z][a-zA-Z0-9]*', s)
def next_token(): return tokens and tokens . pop(0) or None
def peek_token(): return tokens and tokens[0] or None
def parse_func():
ty = parse_atom()
if peek_token() == "->":
next_token()
ty = (ty, parse_func())
return ty
def parse_atom():
match next_token():
case "(":
ty = parse_func()
assert next_token() == ")"
return ty
case ty:
return ty
return parse_func()
def parse_context(context):
res = {}
for r in context . split('\n'):
if ':' in r:
val, s = map(str . strip, r . split(':'))
res[val] = parse_type(s)
return res
def parse_expr(expr):
tokens = re . findall(r'[()]|[a-z][a-zA-Z0-9]*', expr)
def next_token(): return tokens and tokens . pop(0) or None
def peek_token(): return tokens and tokens[0] or None
def parse_app():
e = parse_atom()
while peek_token() and peek_token() != ')':
e = (e, parse_atom())
return e
def parse_atom():
match next_token():
case '(':
e = parse_app()
assert next_token() == ')'
return e
case e:
return e
return parse_app()
def infer_type(context, expression):
ctx = parse_context(context)
def infer(expr):
match expr:
case(a, b):
ta, tb = map(infer, expr)
match ta:
case(t_arg, t_ret) if t_arg == tb:
return t_ret
case _:
raise "Type error"
case v:
return ctx[v]
def to_string(ty):
match ty:
case((a, b), c):
return f'( { to_string (( a , b ))} ) -> { to_string ( c )} '
case(a, b):
return f' { to_string ( a )} -> { to_string ( b )} '
case _:
return ty
return to_string(infer(parse_expr(expression)))
| The Little Typer: Values, Functions and Currying | 62975e268073fd002780cb0d | [
"Functional Programming"
] | https://www.codewars.com/kata/62975e268073fd002780cb0d | 3 kyu |
Define a variable `ALPHABET` that contains the *(english)* alphabet in lowercase.
<br>
**Too simple?** Well, you can only use the following characters set:
- ` abcdefghijklmnopqrstuvwxyz().`
(space included)
<br>
You code must starts with `ALPHABET = ` then respects the charset limitation.
*Ofc you wouldn't cheat by importing the string module or using `eval`/`exec`...*
| games | ALPHABET = str(). join(chr(i)
for i in range(sum(range(len(str(complex))))) if chr(i). islower())
| Hellphabet - Can you give the alphabet | 62dcbe87f4ac96005f052962 | [
"Puzzles",
"Restricted",
"Strings"
] | https://www.codewars.com/kata/62dcbe87f4ac96005f052962 | 6 kyu |
## Description
Given a list of strings of equal length, return any string which **minimizes** the **maximum** hamming distance between it and every string in the list. The string returned does not necessarily have to come from the list of strings.
#### Hamming Distance
The hamming distance is simply the amount of points in two equally large Strings that are different
Example:
```if:java
`hammingDistance("aooob","loppb") - > 3`
```
```if:python
`hamming_distance('aooob','loppb') - > 3`
```
as the two strings differ on position 0, 2, 3
## Examples
#### Example 1
```if:python
`closest_string(['ooi','oio','ooi']) -> 'ooo'`
```
```if:java
`closestString(["ooi","oio","ooi"]) -> "ooo"`
```
```if:python
It is important to note that `'oii'` would have also worked, but `'ooi'` would have not worked, because `'ooi'` has a hamming distance of 2 with `'oio'` which is worse than `'ooo'` hamming distance of 1
```
```if:java
It is important to note that `"oii"` would have also worked, but `"ooi"` would have not worked, because `"ooi"` has a hamming distance of 2 with `"oio"` which is worse than `"ooo"` hamming distance of 1
```
#### Example 2
```if:python
`closest_string(['uvwx','xuwv','xvwu']) -> 'uuwu'`
```
```if:java
`closestString(["uvwx","xuwv","xvwu"]) -> "uuwu"`
```
```if:python
It is important to note that `'xvwx'` would have also worked
```
```if:java
It is important to note that `"xvwx"` would have also worked
```
### Author's Note
feel free to use brute force | algorithms | from collections import Counter
def closest_string(list_str):
counters = [Counter(s[i] for s in list_str)
for i in range(len(list_str[0]))]
minweight = len(list_str[0]) + 1
mins = None
# backtracking with prunning:
def rec(s, weights):
nonlocal minweight, mins
if max(weights) >= minweight:
return
if len(s) == len(list_str[0]):
mins = s
minweight = max(weights)
return
for c in counters[len(s)]. keys():
rec(s + c, [
prevw + (c != list_str[i][len(s)])
for i, prevw in enumerate(weights)
])
rec('', [0] * len(list_str))
return mins
| Closest String | 6051151d86bab8001c83cc52 | [
"Algorithms"
] | https://www.codewars.com/kata/6051151d86bab8001c83cc52 | 6 kyu |
Even more meticulously, Alex keeps records of [_snooker_](https://en.wikipedia.org/wiki/Snooker) matches. Alex can see into the past or the future (magic vision or balls stuffed with all sorts of electronics?). Your task is to find out how many points the player scored in the match, having only one single record of a pocketed ball.
### Input
------
The input is an instance of the "Ball" class, which has the following attributes: color, value of the ball in points, bindings to the previous and next "Ball".
Class Ball is [_dataclass_](https://docs.python.org/3/library/dataclasses.html). Dataclass is used to store data.
```python
from dataclasses import dataclass
from typing import Union, NewType
Ball = NewType("Ball", dataclass)
@dataclass
class Ball:
previous: Union[Ball, None] # The variable holds a reference to the previous element in the sequence.
next: Union[Ball, None] # The variable holds a reference to the next element in the sequence.
color: str # Вall color
point: int # The value of the ball in game points
def __repr__(self):
return self.color
```
_previous, next, color and point_ is an instance attribute and can either be called or assigned
```python
red = Ball(None, None, "Red", 1)
red.point # 1
red.color # "Red"
red.previous # None
yellow = Ball(None, None, "Yellow", 2)
red.next = yellow # set next element
yellow.previous = red # set red like a previous element
red # Ball(previous=None, next=yellow, color='Red', point=1)
yellow # Ball(previous=red, next=None, color='Yellow', point=2)
```
### Snooker ball value
* Red - 1 point
* Yellow - 2 points
* Green - 3 points
* Brown - 4 points
* Blue - 5 points
* Pink - 6 points
* Black - 7 points
### Output
------
As a result, it is necessary to accumulate **the sum of all balls pocketed into the pockets**, restoring the entire sequence of balls pocketed by the player (from the first ball pocketed to the last ball pocketed). The first one does not refer to the previous "Ball". and the latter does not refer to the next potted "Ball".
### Balls in the sequence
In snooker ball's color differ from shot to shot: a red ball, if potted, must be followed by a colour, a potted colour must be followed by a red, and so on until red balls ends. The alternation between red balls and colours ends when all reds have been potted and an attempt (successful or not) to pot a colour is made after the last red is potted. All six colours have then to be potted in ascending order of their value (yellow, green, brown, blue, pink, black). Each becomes the target ball in that order. During this phase, the colours are not replaced on the table after being legally potted.
Sequence is [_doubly linked list_](https://en.wikipedia.org/wiki/Doubly_linked_list). A doubly linked list is a linked data structure that consists of a set of sequentially linked records called nodes.
```python
balls = [Red, Black, Red, Green, Red, Black, Red, Yellow, Red, Green, Red, Yellow, Red, Green, Red, Blue, Red, Blue, Red, Yellow, Red, Black, Red, Blue, Red, Green, Red, Black, Red, Yellow, Yellow, Green, Brown, Blue, Pink, Black]
```
At the input of the function, a ball is randomly selected from the sequence.
| games | def score(ball: Ball) - > int:
res, left, right = ball . point, ball . previous, ball . next
while left:
res += left . point
left = left . previous
while right:
res += right . point
right = right . next
return res
| Alex & snooker: Find Them All | 62dc0c5df4ac96003d05152c | [
"Puzzles",
"Fundamentals",
"Algorithms"
] | https://www.codewars.com/kata/62dc0c5df4ac96003d05152c | 6 kyu |
You've sent your students home for the weekend with an assignemnt.
The assignment is to write a 4 part ```harmony``` consisting of 4 chords.
----
Scale:
----
The major scale has 7 notes:
```"do re mi fa sol la ti"```
----
Chord:
----
For this assignment a chord may consist of any 4 notes from the major scale. Example:
example chord = ```'do re fa sol'```
----
Harmony:
----
Each ```harmony``` consists of 4 chords:
```harmony = [chordOne, chordTwo, chordThree, chordFour]```
-----
Octave:
-----
When two singers are singing the same note like below (```do```) the interval between them is called an octave:
``` |
v v
do re mi do
^ ^
```
----
Parallel Octave:
-----
A parallel octave occurs when two singers *move* from one chord to the next staying one octave apart. For example:
```
do mi sol do
v v < Parallel octave
ti re fa ti
```
This ```harmony``` contains a parallel octave because the bass and soprano are both singing ```'do'``` on the first chord, and then on the second chord they both move to ```'ti'```. In other words they stay one octave apart from eacthother as they move from one chord to the next.
A parallel octave does NOT occur when two singers stay one octave apart but do not *move* or change notes from one chord to the next. For example:
```
do re mi do
| | < NOT a parallel octave
do re mi do
```
-----
Your Task
-----
You want to write a function to detect whether the harmony contains any parallel octaves. If it contains parallel octaves return "Fail" otherwise return "Pass".
-----
Examples
-----
```
harmony = [
'do re mi fa' ,
'mi fa sol do' ,
'fa ti fa ti' ,
| | < NOT a parallel octave
'fa do fa mi' ,
]
```
This student should ```'Pass'``` because the bass and alto are singing octaves on the 3rd and 4th chord```'fa'``` but they do not *move*.
```
harmony = [
'mi re mi fa' ,
| | < Parallel octave
v v
'sol fa sol do',
| | < Parallel octave
v v
'fa ti fa ti' ,
'fa do fa mi' ,
]
```
This student should ```'Fail'``` because the bass and alto stay one octave apart on the first and second chord and they move to another note together. ```mi``` -> ```sol```
There is also another parallel octave as they move from the second to third chord. ```sol```->```fa```
```
harmony = [
'mi mi mi mi' ,
'fa mi do re' ,
'ti ti ti ti' ,
'fa mi do re' , No parallel octaves
]
```
This student should ```'Pass'``` because there are no parallel octaves in this harmony.
| reference | from itertools import combinations
def pass_or_fail(harmony):
for c1, c2 in zip(harmony, harmony[1:]):
for (n1, n2), (n3, n4) in combinations(zip(c1 . split(), c2 . split()), 2):
if n1 == n3 != n2 == n4:
return "Fail"
return "Pass"
| Find Parallel Octaves | 62dabb2225ea8e00293da513 | [
"Algorithms"
] | https://www.codewars.com/kata/62dabb2225ea8e00293da513 | 7 kyu |
# Number Pyramid:
Image a number pyramid starts with `1`, and the numbers increasing by `1`.
For example, when the pyramid has `4` levels:
```
1
2 3
4 5 6
7 8 9 10
```
___
# Spiral:
Now let's make a `spiral`, starts with `1`, `clockwise` direction, move `inward`.
In the above example, we will get the numbers in the following sequence:
```
1, 3, 6, 10, 9, 8, 7, 4, 2, 5
```
And the last number of the spiral is:
```
5
```
___
# Input:
You will be given a number `n`, which means how many levels the pyramid has.
`1 <= n <= 5000`
___
# Output:
You need to return the last number of the spiral.
__Examples:__
```
last(1) --> 1
last(2) --> 2
last(3) --> 2
last(4) --> 5
last(5) --> 8
```
___
# Golfing Message:
The length of your code should be less or equal to `45`.
The length of reference solution is `39`.
___
If you like this series, welcome to do [other kata](https://www.codewars.com/collections/code-golf-number-pyramid-series) of it. | games | def last(n): return (2 * - ~ n / / 3) * * 2 + 1 >> 1
| [Code Golf] Number Pyramid Series 5 - Spiral End with | 62d6b4990ba2a64cf62ef0c0 | [
"Mathematics",
"Restricted"
] | https://www.codewars.com/kata/62d6b4990ba2a64cf62ef0c0 | 5 kyu |
# Description
Steve, from minecraft, is jumping down from blocks to blocks and can get damages at each jump. Damage depends on `distance` between blocks and `block type` he jumped on. The goal is to know if he survives his descent or not.
You are given a list of `N` blocks as strings, in the format `'BLOCK_HEIGHT BLOCK_TYPE'`. Steve jumps from one block to the next, and get damages calculated with the following formula:
DMG = max(0, (DISTANCE - 3.5) * (1 - DMG_REDUCTION))
The distance is calculated as the difference between the `height` of the current and the next block. DMG should be **rounded down** to the nearest integral.
`DMG_REDUCTION` depends on `BLOCK_TYPE`:
BLOCK_TYPE --> DMG_REDUCTION
'D' --> 0 #Dirt block
'B' --> 0.5 #Bed
'H' --> 0.8 #Hay block
'W' --> 1 #Water block
## Task
Write a function, that returns the outcome for Steve:
- If he survives, it returns `'jumped to the end with X remaining HP'`, where `X` is the remaining HP at the end of the array.
- If he dies before the end of the array, it returns `'died on I'`, where `I` is the index of the jump he dies.
### Rules
- Steve has `20 HP` at the start. If `HP` drops below or equal `0`, Steve dies.
- `BLOCK_TYPE` can be `'D'` or `'B'` or `'H'` or `'W'` only.
- `N` cannot be less than `2`.
- `BLOCK_HEIGHT[i]` cannot be less than `BLOCK_HEIGHT[i+1]` and always non-negative integral.
- All inputs are valid according to the rules.
#### Examples (input --> output)
['10 D', '4 D', '0 D'] --> 'jumped to the end with 18 remaining HP'
| | |
| | The third block with height 0 and type D
| The second block with height 4 and type D
The first block with height 10 and type D
/*All blocks are type D, so DMG_REDUCTION will be 0 for all cases
DISTANCE on the first jump will be 10 - 4 = 6
DMG on the first jump will be max(0, (6 - 3.5) * (1 - 0)) = 2.5 -> 2 (rounding down)
DISTANCE on the second jump will be 4 - 0 = 4
DMG on the second jump will be max(0, (4 - 3,5) * (1 - 0)) = 0.5 -> 0 (rounding down)
So HP in the end will be 20 - 2 - 0 = 18*/
['100 D', '50 H'] --> 'jumped to the end with 11 remaining HP'
['999 D', '0 W'] --> 'jumped to the end with 20 remaining HP'
['999 D', '0 D'] --> 'died on 1' | reference | dmg = dict(zip("DBHW", (0, 0.5, 0.8, 1)))
def jumping(arr):
hp = 20
for i, (p1, p2) in enumerate(zip(arr, arr[1:]), 1):
(h1, _), (h2, b) = p1 . split(), p2 . split()
hp -= max(0, int((int(h1) - int(h2) - 3.5) * (1 - dmg[b])))
if hp <= 0:
return f"died on { i } "
return f"jumped to the end with { hp } remaining HP"
| Steve jumping | 62d81c6361677d57d8ff86c9 | [
"Fundamentals",
"Algorithms"
] | https://www.codewars.com/kata/62d81c6361677d57d8ff86c9 | 7 kyu |
<h2 style="color:#4bd4de">Foreword</h2>
Most kata on Codewars require to define a function of specific name that either returns a value from given inputs or alters the input itself. The whole thing looks like this.
```
def some_func(arg1, arg2):
# code...
# code...
# code...
return # something
```
<b>Kata sensei has access to the raw string of user's code and therefore is able to do things such as:</b>
• Check whether the code string contains prohibited substrings
• Examine the length of the code
• Apply basically any rules to user's input code
</p>
<h2 style="color:#4bd4de">The task</h2>
<b>Implement a function `change_list(arr)` that takes a list as an argument and mutates its elements in such way:</b>
• If the element is an integer, square it
• If the element is a string, append its reversed copy to its end like that `"string"` becomes `"stringgnirts"`
• If the element is a bool, simply reverse it. `True` becomes `False` and `False` becomes `True`
• Reverse the list
</p>
<h2 style="color:#4bd4de">Rules/restrictions</h2>
Here comes the fun part. A string, composed of every other symbol of your very input — `your_code[::2]`, when executed as Python code, should also do everything stated above. Define a function `change_list` that mutates its input by the stated rules. For your awareness, that is what `code[::2]` of a snippet used in the <b>Foreword</b> paragraph looks like:
```
dfsm_ucag,ag)
oe.
oe.
oe.
eun oehn
```
God knows how many reasons to cause an error upon execution it has...
</p>
<h2 style="color:#62d941">Notes</h2>
• There are 100 random tests on short arrays with less than 50 elements.
• You will see how `your_code[::2]` looks like in every test. | games | # d e f c h a n g e _ l i s t ( x ) :
# f o r i , v i n e n u m e r a t e ( x [ : : - 1 ] ) :
# i f i s i n s t a n c e ( v , b o o l ) :
# x [ i ] = n o t v
# e l i f i s i n s t a n c e ( v , s t r ) :
# x [ i ] = v + v [ : : - 1 ]
# e l s e :
# x [ i ] = v * * 2
# ' ' '
def change_list(x):
for i, v in enumerate(x[:: - 1]):
if isinstance(v, bool):
x[i] = not v
elif isinstance(v, str):
x[i] = v + v[:: - 1]
else:
x[i] = v * * 2
# ' ' '
| Leapfrog Code | 62d6d9e90ba2a6b6942ee6e5 | [
"Restricted"
] | https://www.codewars.com/kata/62d6d9e90ba2a6b6942ee6e5 | 6 kyu |
# Number Pyramid:
Image a number pyramid starts with `1`, and the numbers increasing by `1`.
And now, the pyramid has `5000` levels.
For example, the top `5` levels of the pyramid are:
```
01
02 03
04 05 06
07 08 09 10
11 12 13 14 15
...
```
___
# Location:
Define the `location` of a number as a 2-elements `tuple(x, y)` where:
* `x` is the index of the level (start from the __top__) which contains the number;
* `y` is the index of the number (start from the __left__) in the level.
_Both 1-base index._
For example, the `location` of `5` is:
```
(3, 2)
```
___
# Task:
You will be given a number `n`, it will not go beyond 5000 levels.
You need to return the `location` of the number `n`.
__Examples:__
```
location(1) --> (1, 1)
location(2) --> (2, 1)
location(3) --> (2, 2)
location(4) --> (3, 1)
location(5) --> (3, 2)
location(6) --> (3, 3)
```
___
# Golfing Message:
The length of your code should be less or equal to `57`.
The length of reference solution is `51`.
___
If you like this series, welcome to do [other kata](https://www.codewars.com/collections/code-golf-number-pyramid-series) of it. | games | def location(c, r=1):
while c > r:
c -= r
r += 1
return r, c
| [Code Golf] Number Pyramid Series 4 - Location | 62d1d6389e2b3904b3825309 | [
"Mathematics",
"Restricted"
] | https://www.codewars.com/kata/62d1d6389e2b3904b3825309 | 6 kyu |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.