allenai/lila · Datasets at Hugging Face

We all know about Roman Numerals, and if not, here's a nice [introduction kata](http://www.codewars.com/kata/5580d8dc8e4ee9ffcb000050). And if you were anything like me, you 'knew' that the numerals were not used for zeroes or fractions; but not so! I learned something new today: the [Romans did use fractions](https://en.wikipedia.org/wiki/Roman_numerals#Special_values) and there was even a glyph used to indicate zero. So in this kata, we will be implementing Roman numerals and fractions. Although the Romans used base 10 for their counting of units, they used base 12 for their fractions. The system used dots to represent twelfths, and an `S` to represent a half like so: * ^(1)/12 = `.` * ^(2)/12 = `:` * ^(3)/12 = `:.` * ^(4)/12 = `::` * ^(5)/12 = `:.:` * ^(6)/12 = `S` * ^(7)/12 = `S.` * ^(8)/12 = `S:` * ^(9)/12 = `S:.` * ^(10)/12 = `S::` * ^(11)/12 = `S:.:` * ^(12)/12 = `I` (as usual) Further, zero was represented by `N` ## Kata Complete the method that takes two parameters: an integer component in the range 0 to 5000 inclusive, and an optional fractional component in the range 0 to 11 inclusive. You must return a string with the encoded value. Any input values outside the ranges given above should return `"NaR"` (i.e. "Not a Roman" :-) ## Examples ```python roman_fractions(-12) #=> "NaR" roman_fractions(0, -1) #=> "NaR" roman_fractions(0, 12) #=> "NaR" roman_fractions(0) #=> "N" roman_fractions(0, 3) #=> ":." roman_fractions(1) #=> "I" roman_fractions(1, 0) #=> "I" roman_fractions(1, 5) #=> "I:.:" roman_fractions(1, 9) #=> "IS:." roman_fractions(1632, 2) #=> "MDCXXXII:" roman_fractions(5000) #=> "MMMMM" roman_fractions(5001) #=> "NaR" ```

def roman_fractions(num, fraction=0): rom = '' FACT = { 1:'.', 2:':', 3:':.',4:'::',5:':.:',6:'S',7:'S.',8:'S:', 9:'S:.',10:'S::', 11:'S:.:' } ENCO = { 1:'I', 5:'V', 10:'X', 50:'L', 100:'C', 500:'D', 1000:'M' } EDGE = { 0:lambda x, elem, dict, number : dict.get(elem, '') * number, 1:lambda e, i, D, l : e +D.get(i*(l+1),'M'*(l-1)) if l in [4,9] else D.get(i*l, 'M'*5) if l is 5 else D[i*5] + (e * (l%5)) } if num < 0 or num>5000 or fraction and fraction not in FACT: return 'NaR' for element in list(ENCO.keys())[0::2][::-1]: left = num // element rom += EDGE.get(left>3, '')( ENCO[element] , element, ENCO, left ) num %= element ret = rom + FACT.get(fraction,'') return ret if ret else 'N'

train

APPS_structured

Bobby has decided to hunt some Parrots. There are n horizontal branch of trees aligned parallel to each other. Branches are numbered 1 to n from top to bottom. On each branch there are some parrots sitting next to each other. Supposed there are a[i]$a[i]$ parrots sitting on the i−th$ i-th$ branch. Sometimes Bobby shots one of the parrot and the parrot dies (suppose that this parrots sat at the i−th$i-th$ branch). Consequently all the parrots on the i−th$i-th$ branch to the left of the dead parrot get scared and jump up on the branch number i − 1$i - 1$, if there exists no upper branch they fly away. Also all the parrots to the right of the dead parrot jump down on branch number i + 1$i + 1$, if there exists no such branch they fly away. Bobby has shot m parrots. You're given the initial number of parrots on each branch, tell him how many parrots are sitting on each branch after the shots. -----Input:----- The first line of the input contains an integer N$N$. The next line contains a list of space-separated integers a1, a2, …, an. The third line contains an integer M$M$. Each of the next M$M$ lines contains two integers x[i]$x[i]$ and y[i]$y[i]$. The integers mean that for the i-th time Bobby shoot the y[i]-th (from left) parrot on the x[i]-th branch. It's guaranteed there will be at least y[i] parrot on the x[i]-th branch at that moment. -----Output:----- On the i−th$i-th$ line of the output print the number of parrots on the i−th$i-th$ branch. -----Constraints----- - 1≤N≤100$1 \leq N \leq 100$ - 0≤a[i]≤100$0 \leq a[i] \leq 100$ - 0≤M≤100$0 \leq M \leq 100$ - 1≤x[i]≤n$1 \leq x[i] \leq n$, 1≤y[i]$1 \leq y[i] $ -----Sample Input:----- 5 10 10 10 10 10 5 2 5 3 13 2 12 1 13 4 6 3 2 4 1 1 2 2 -----Sample Output:----- 0 12 5 0 16 3 0 3

n=int(input()) a1=map(int,input().split()) m=int(input()) a1=list(a1) a1.insert(0,0) a1.insert(n+1,0) for i in range(m): x,y=map(int,input().split()) a1[x-1]+=y-1 a1[x+1]+=a1[x]-y a1[x]=0 for i in range(1,n+1): print(a1[i])

train

APPS_structured

# Task John won the championship of a TV show. He can get some bonuses. He needs to play a game to determine the amount of his bonus. Here are `n` rows and `m` columns of cards were placed on the ground. A non-negative number is written on each card. The rules of the game are: - Player starts from the top-left coner, walk to the bottom-right coner. - Players can only walk downward or right. - The sum of the numbers collected by the players will be used as the bonus. John has two chances to play this game on a game map. Specifically, when John finishes the game, the card on his path will be removed, and then he can walk again. Your task is to help John calculate the maximum amount of bonuses he can get. # Input - `gameMap/gamemap`: A `n` x `m` integer array. Each element represents the number on the card. - `4 <= n,m <= 40(Pyhon)/100(JS)` - All inputs are valid. # Output An integer. the maximum amount of bonuses John can get. # Eaxmple For ``` gameMap= [ [1, 3, 9], [2, 8, 5], [5, 7, 4] ] ``` The output should be `39`. One of the possible solution is: ``` 1st game: [ [>, >, v], [2, 8, v], [5, 7, v] ] 1+3+9+5+4=22 2nd game: [ [v, 0, 0], [>, v, 0], [5, >, >] ] 0+2+8+7+0=17 Final bonus = 22 + 17 = 39 ```

def calc(gamemap): nr, nc = len(gamemap), len(gamemap[0]) def _i(ra, rb): return ra*nr + rb vs, ws = [0] * nr**2, [0] * nr**2 for s in range(nr + nc - 1): for ra in range(max(0, s - nc + 1), min(s + 1, nr)): for rb in range(ra, min(s + 1, nr)): ws[_i(ra, rb)] = ( gamemap[ra][s - ra] + (gamemap[rb][s - rb] if ra != rb else 0) + max(vs[_i(ra - da, rb - db)] for da in (0, 1) if da <= ra for db in (0, 1) if db <= rb)) vs, ws = ws, vs return vs[-1]

train

APPS_structured

# Fix the Bugs (Syntax) - My First Kata ## Overview Hello, this is my first Kata so forgive me if it is of poor quality. In this Kata you should fix/create a program that ```return```s the following values: - ```false/False``` if either a or b (or both) are not numbers - ```a % b``` plus ```b % a``` if both arguments are numbers You may assume the following: 1. If ```a``` and ```b``` are both numbers, neither of ```a``` or ```b``` will be ```0```. ## Language-Specific Instructions ### Javascript and PHP In this Kata you should try to fix all the syntax errors found in the code. Once you think all the bugs are fixed run the code to see if it works. A correct solution should return the values specified in the overview. **Extension: Once you have fixed all the syntax errors present in the code (basic requirement), you may attempt to optimise the code or try a different approach by coding it from scratch.**

def my_first_kata(a,b): return a % b + b % a if type(a) == type(b) == int else False

train

APPS_structured

Let's assume that v(n) is the largest prime number, that does not exceed n; u(n) is the smallest prime number strictly greater than n. Find $\sum_{i = 2}^{n} \frac{1}{v(i) u(i)}$. -----Input----- The first line contains integer t (1 ≤ t ≤ 500) — the number of testscases. Each of the following t lines of the input contains integer n (2 ≤ n ≤ 10^9). -----Output----- Print t lines: the i-th of them must contain the answer to the i-th test as an irreducible fraction "p/q", where p, q are integers, q > 0. -----Examples----- Input 2 2 3 Output 1/6 7/30

def prime(n): m = int(n ** 0.5) + 1 t = [1] * (n + 1) for i in range(3, m): if t[i]: t[i * i :: 2 * i] = [0] * ((n - i * i) // (2 * i) + 1) return [2] + [i for i in range(3, n + 1, 2) if t[i]] def gcd(a, b): c = a % b return gcd(b, c) if c else b p = prime(31650) def g(n): m = int(n ** 0.5) for j in p: if n % j == 0: return True if j > m: return False def f(n): a, b = n, n + 1 while g(a): a -= 1 while g(b): b += 1 p, q = (b - 2) * a + 2 * (n - b + 1), 2 * a * b d = gcd(p, q) print(str(p // d) + '/' + str(q // d)) for i in range(int(input())): f(int(input()))

train

APPS_structured

Shaun is very much interested in Subarrays. Shaun wants to count the number of subarrays in his chosen array with sum being a multiple of $10^9$. Since, Shaun is interested in huge numbers.He chose his array such that it contains only $10^8$ and $9*10^8$ as its elements. Help shaun to count the number of required subarrays. -----Input:----- - First line will contain $T$, number of testcases. Then the testcases follow. - First line of each testcase contains one integer $N$,size of array $A$. - Second line of each testcase contains $N$ space separated array elements -----Output:----- For each testcase, output in a single line number of subarrays with sum being multiple of $10^9$. -----Constraints----- - $1 \leq T \leq 10$ - $1 \leq N \leq 10^5$ - $A[i]$=$10^8$ , $9*10^8$ -----Sample Input:----- 2 3 100000000 900000000 100000000 1 900000000 -----Sample Output:----- 2 0

# cook your dish here def subCount(arr, n, k=10): mod =[] for i in range(k + 1): mod.append(0) cumSum = 0 for i in range(n): cumSum = cumSum + arr[i] mod[((cumSum % k)+k)% k]= mod[((cumSum % k)+k)% k] + 1 result = 0 # Initialize result # Traverse mod[] for i in range(k): if (mod[i] > 1): result = result + (mod[i]*(mod[i]-1))//2 result = result + mod[0] return result for t_itr in range(0,int(input())): n = int(input()) a = list(map(str, input().split())) b = [] for i in a: b.append(int(i[0])) res = subCount(b, n, 10) print(res)

train

APPS_structured

Given an array of 4 integers ```[a,b,c,d]``` representing two points ```(a, b)``` and ```(c, d)```, return a string representation of the slope of the line joining these two points. For an undefined slope (division by 0), return ```undefined``` . Note that the "undefined" is case-sensitive. ``` a:x1 b:y1 c:x2 d:y2 ``` Assume that ```[a,b,c,d]``` and the answer are all integers (no floating numbers!). Slope:

def find_slope(points): run = points[0] - points[2] rise = points[1] - points[3] return "undefined" if run == 0 else "%d" % (rise / run)

train

APPS_structured

There are two sorted arrays nums1 and nums2 of size m and n respectively. Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)). Example 1: nums1 = [1, 3] nums2 = [2] The median is 2.0 Example 2: nums1 = [1, 2] nums2 = [3, 4] The median is (2 + 3)/2 = 2.5

class Solution: def findMedianSortedArrays(self, nums1, nums2): """ :type nums1: List[int] :type nums2: List[int] :rtype: float """ nums1.extend(nums2) nums1.sort() size = len(nums1) if (size % 2): return nums1[size//2] else: return (nums1[size//2] + nums1[size//2-1])/2

train

APPS_structured

Let $a$ and $b$ be two arrays of lengths $n$ and $m$, respectively, with no elements in common. We can define a new array $\mathrm{merge}(a,b)$ of length $n+m$ recursively as follows: If one of the arrays is empty, the result is the other array. That is, $\mathrm{merge}(\emptyset,b)=b$ and $\mathrm{merge}(a,\emptyset)=a$. In particular, $\mathrm{merge}(\emptyset,\emptyset)=\emptyset$. If both arrays are non-empty, and $a_1<b_1$, then $\mathrm{merge}(a,b)=[a_1]+\mathrm{merge}([a_2,\ldots,a_n],b)$. That is, we delete the first element $a_1$ of $a$, merge the remaining arrays, then add $a_1$ to the beginning of the result. If both arrays are non-empty, and $a_1>b_1$, then $\mathrm{merge}(a,b)=[b_1]+\mathrm{merge}(a,[b_2,\ldots,b_m])$. That is, we delete the first element $b_1$ of $b$, merge the remaining arrays, then add $b_1$ to the beginning of the result. This algorithm has the nice property that if $a$ and $b$ are sorted, then $\mathrm{merge}(a,b)$ will also be sorted. For example, it is used as a subroutine in merge-sort. For this problem, however, we will consider the same procedure acting on non-sorted arrays as well. For example, if $a=[3,1]$ and $b=[2,4]$, then $\mathrm{merge}(a,b)=[2,3,1,4]$. A permutation is an array consisting of $n$ distinct integers from $1$ to $n$ in arbitrary order. For example, $[2,3,1,5,4]$ is a permutation, but $[1,2,2]$ is not a permutation ($2$ appears twice in the array) and $[1,3,4]$ is also not a permutation ($n=3$ but there is $4$ in the array). There is a permutation $p$ of length $2n$. Determine if there exist two arrays $a$ and $b$, each of length $n$ and with no elements in common, so that $p=\mathrm{merge}(a,b)$. -----Input----- The first line contains a single integer $t$ ($1\le t\le 1000$) — the number of test cases. Next $2t$ lines contain descriptions of test cases. The first line of each test case contains a single integer $n$ ($1\le n\le 2000$). The second line of each test case contains $2n$ integers $p_1,\ldots,p_{2n}$ ($1\le p_i\le 2n$). It is guaranteed that $p$ is a permutation. It is guaranteed that the sum of $n$ across all test cases does not exceed $2000$. -----Output----- For each test case, output "YES" if there exist arrays $a$, $b$, each of length $n$ and with no common elements, so that $p=\mathrm{merge}(a,b)$. Otherwise, output "NO". -----Example----- Input 6 2 2 3 1 4 2 3 1 2 4 4 3 2 6 1 5 7 8 4 3 1 2 3 4 5 6 4 6 1 3 7 4 5 8 2 6 4 3 2 5 1 11 9 12 8 6 10 7 Output YES NO YES YES NO NO -----Note----- In the first test case, $[2,3,1,4]=\mathrm{merge}([3,1],[2,4])$. In the second test case, we can show that $[3,1,2,4]$ is not the merge of two arrays of length $2$. In the third test case, $[3,2,6,1,5,7,8,4]=\mathrm{merge}([3,2,8,4],[6,1,5,7])$. In the fourth test case, $[1,2,3,4,5,6]=\mathrm{merge}([1,3,6],[2,4,5])$, for example.

import sys input=sys.stdin.readline for _ in range(int(input())): n=int(input()) p=list(map(int,input().split())) index={e:i for i,e in enumerate(p)} m=2*n data=[] for i in range(2*n,0,-1): temp=index[i] if temp<m: data.append(m-temp) m=temp m=len(data) dp=[[False for i in range(2*n+1)] for j in range(m+1)] dp[0][0]=True for i in range(1,m+1): for j in range(2*n+1): dp[i][j]=dp[i-1][j]|(dp[i-1][j-data[i-1]]&(j>=data[i-1])) if dp[m][n]: print("YES") else: print("NO")

train

APPS_structured

Given a string, turn each letter into its ASCII character code and join them together to create a number - let's call this number `total1`: ``` 'ABC' --> 'A' = 65, 'B' = 66, 'C' = 67 --> 656667 ``` Then replace any incidence of the number `7` with the number `1`, and call this number 'total2': ``` total1 = 656667 ^ total2 = 656661 ^ ``` Then return the difference between the sum of the digits in `total1` and `total2`: ``` (6 + 5 + 6 + 6 + 6 + 7) - (6 + 5 + 6 + 6 + 6 + 1) ------------------------- 6 ```

def calc(x): return ''.join(str(ord(ch)) for ch in x).count('7') * 6

train

APPS_structured

You're given an array of $n$ integers between $0$ and $n$ inclusive. In one operation, you can choose any element of the array and replace it by the MEX of the elements of the array (which may change after the operation). For example, if the current array is $[0, 2, 2, 1, 4]$, you can choose the second element and replace it by the MEX of the present elements — $3$. Array will become $[0, 3, 2, 1, 4]$. You must make the array non-decreasing, using at most $2n$ operations. It can be proven that it is always possible. Please note that you do not have to minimize the number of operations. If there are many solutions, you can print any of them. – An array $b[1 \ldots n]$ is non-decreasing if and only if $b_1 \le b_2 \le \ldots \le b_n$. The MEX (minimum excluded) of an array is the smallest non-negative integer that does not belong to the array. For instance: The MEX of $[2, 2, 1]$ is $0$, because $0$ does not belong to the array. The MEX of $[3, 1, 0, 1]$ is $2$, because $0$ and $1$ belong to the array, but $2$ does not. The MEX of $[0, 3, 1, 2]$ is $4$ because $0$, $1$, $2$ and $3$ belong to the array, but $4$ does not. It's worth mentioning that the MEX of an array of length $n$ is always between $0$ and $n$ inclusive. -----Input----- The first line contains a single integer $t$ ($1 \le t \le 200$) — the number of test cases. The description of the test cases follows. The first line of each test case contains a single integer $n$ ($3 \le n \le 1000$) — length of the array. The second line of each test case contains $n$ integers $a_1, \ldots, a_n$ ($0 \le a_i \le n$) — elements of the array. Note that they don't have to be distinct. It is guaranteed that the sum of $n$ over all test cases doesn't exceed $1000$. -----Output----- For each test case, you must output two lines: The first line must contain a single integer $k$ ($0 \le k \le 2n$) — the number of operations you perform. The second line must contain $k$ integers $x_1, \ldots, x_k$ ($1 \le x_i \le n$), where $x_i$ is the index chosen for the $i$-th operation. If there are many solutions, you can find any of them. Please remember that it is not required to minimize $k$. -----Example----- Input 5 3 2 2 3 3 2 1 0 7 0 7 3 1 3 7 7 9 2 0 1 1 2 4 4 2 0 9 8 4 7 6 1 2 3 0 5 Output 0 2 3 1 4 2 5 5 4 11 3 8 9 7 8 5 9 6 4 1 2 10 1 8 1 9 5 2 4 6 3 7 -----Note----- In the first test case, the array is already non-decreasing ($2 \le 2 \le 3$). Explanation of the second test case (the element modified by each operation is colored in red): $a = [2, 1, 0]$ ; the initial MEX is $3$. $a = [2, 1, \color{red}{3}]$ ; the new MEX is $0$. $a = [\color{red}{0}, 1, 3]$ ; the new MEX is $2$. The final array is non-decreasing: $0 \le 1 \le 3$. Explanation of the third test case: $a = [0, 7, 3, 1, 3, 7, 7]$ ; the initial MEX is $2$. $a = [0, \color{red}{2}, 3, 1, 3, 7, 7]$ ; the new MEX is $4$. $a = [0, 2, 3, 1, \color{red}{4}, 7, 7]$ ; the new MEX is $5$. $a = [0, 2, 3, 1, \color{red}{5}, 7, 7]$ ; the new MEX is $4$. $a = [0, 2, 3, \color{red}{4}, 5, 7, 7]$ ; the new MEX is $1$. The final array is non-decreasing: $0 \le 2 \le 3 \le 4 \le 5 \le 7 \le 7$.

# Fast IO (only use in integer input) or take care about string # import os,io # input=io.BytesIO(os.read(0,os.fstat(0).st_size)).readline t = int(input()) for _ in range(t): n = int(input()) a = list(map(int,input().split())) operation = [] while True: isNonDecreasing = True for i in range(n-1): if a[i] > a[i+1]: isNonDecreasing = False break if isNonDecreasing: break isNIn = [False] * (n + 1) for elem in a: isNIn[elem] = True for i in range(n + 1): if isNIn[i] == False: MEX = i break if MEX == n: for i in range(n): if a[i] != i and a[i] != n: break operation.append(str(i + 1)) a[i] = n else: operation.append(str(MEX+1)) a[MEX] = MEX print(len(operation)) if len(operation) != 0: print(' '.join(operation))

train

APPS_structured

Modify the `kebabize` function so that it converts a camel case string into a kebab case. Notes: - the returned string should only contain lowercase letters

import re def kebabize(string): return re.sub(r'(?!^)([A-Z])', r'-\1', re.sub('\d', '', string)).lower()

train

APPS_structured

Given an array of integers and an integer k, find out whether there are two distinct indices i and j in the array such that nums[i] = nums[j] and the absolute difference between i and j is at most k. Example 1: Input: nums = [1,2,3,1], k = 3 Output: true Example 2: Input: nums = [1,0,1,1], k = 1 Output: true Example 3: Input: nums = [1,2,3,1,2,3], k = 2 Output: false

class Solution: def containsNearbyDuplicate(self, nums, k): """ :type nums: List[int] :type k: int :rtype: bool """ s=set(nums) if len(s)==len(nums):return False d=dict() for num in nums: d[num]=d.get(num,0)+1 for num in d: if d[num]>1: index1=-1 index2=-1 for i in range(len(nums)): if nums[i]==num and index1==-1:index1=i elif nums[i]==num and index2==-1:index2=i elif nums[i]==num and index1!=-1 and index2!=-1: index1=index2 index2=i print(index2,index1) if index1!=-1 and index2!=-1 and abs(index2-index1)<=k:return True return False

train

APPS_structured

Most problems on CodeChef highlight chef's love for food and cooking but little is known about his love for racing sports. He is an avid Formula 1 fan. He went to watch this year's Indian Grand Prix at New Delhi. He noticed that one segment of the circuit was a long straight road. It was impossible for a car to overtake other cars on this segment. Therefore, a car had to lower down its speed if there was a slower car in front of it. While watching the race, Chef started to wonder how many cars were moving at their maximum speed. Formally, you're given the maximum speed of N cars in the order they entered the long straight segment of the circuit. Each car prefers to move at its maximum speed. If that's not possible because of the front car being slow, it might have to lower its speed. It still moves at the fastest possible speed while avoiding any collisions. For the purpose of this problem, you can assume that the straight segment is infinitely long. Count the number of cars which were moving at their maximum speed on the straight segment. -----Input----- The first line of the input contains a single integer T denoting the number of test cases to follow. Description of each test case contains 2 lines. The first of these lines contain a single integer N, the number of cars. The second line contains N space separated integers, denoting the maximum speed of the cars in the order they entered the long straight segment. -----Output----- For each test case, output a single line containing the number of cars which were moving at their maximum speed on the segment. -----Example----- Input: 3 1 10 3 8 3 6 5 4 5 1 2 3 Output: 1 2 2 -----Constraints----- 1 ≤ T ≤ 100 1 ≤ N ≤ 10,000 All speeds are distinct positive integers that fit in a 32 bit signed integer. Each input file will not be larger than 4 MB (4,000,000,000 bytes) in size. WARNING! The input files are very large. Use faster I/O.

# cook your dish here t=int(input()) for t in range(t): n=int(input()) a=[int(x) for x in input().split()] counter=0 current=a[0] for i in range(0,len(a)): if a[i]<=current: counter=counter + 1 current=a[i] print(counter)

train

APPS_structured

On an infinite plane, a robot initially stands at (0, 0) and faces north. The robot can receive one of three instructions: "G": go straight 1 unit; "L": turn 90 degrees to the left; "R": turn 90 degress to the right. The robot performs the instructions given in order, and repeats them forever. Return true if and only if there exists a circle in the plane such that the robot never leaves the circle. Example 1: Input: "GGLLGG" Output: true Explanation: The robot moves from (0,0) to (0,2), turns 180 degrees, and then returns to (0,0). When repeating these instructions, the robot remains in the circle of radius 2 centered at the origin. Example 2: Input: "GG" Output: false Explanation: The robot moves north indefinitely. Example 3: Input: "GL" Output: true Explanation: The robot moves from (0, 0) -> (0, 1) -> (-1, 1) -> (-1, 0) -> (0, 0) -> ... Note: 1 <= instructions.length <= 100 instructions[i] is in {'G', 'L', 'R'}

class Solution: def isRobotBounded(self, instructions: str) -> bool: move = {'N':(0,1), 'S':(0,-1), 'E':(1,0), 'W':(-1,0)} right = {'N':'E', 'S':'W', 'E':'S', 'W':'N'} left = {'N':'W', 'S':'E', 'E':'N', 'W':'S'} pos = (0,0) dire = 'N' i=0 while i<4: for c in instructions: if c=='G': x, y = pos dx, dy = move[dire] pos = (x+dx, y+dy) elif c=='L': dire = left[dire] else: dire = right[dire] if pos==(0,0) and dire=='N': return True i+=1 return False

train

APPS_structured

# Background My TV remote control has arrow buttons and an `OK` button. I can use these to move a "cursor" on a logical screen keyboard to type words... # Keyboard The screen "keyboard" layout looks like this #tvkb { width : 400px; border: 5px solid gray; border-collapse: collapse; } #tvkb td { color : orange; background-color : black; text-align : center; border: 3px solid gray; border-collapse: collapse; } abcde123 fghij456 klmno789 pqrst.@0 uvwxyz_/ aASP * `aA` is the SHIFT key. Pressing this key toggles alpha characters between UPPERCASE and lowercase * `SP` is the space character * The other blank keys in the bottom row have no function # Kata task How many button presses on my remote are required to type the given `words`? ## Notes * The cursor always starts on the letter `a` (top left) * The alpha characters are initially lowercase (as shown above) * Remember to also press `OK` to "accept" each letter * Take a direct route from one letter to the next * The cursor does not wrap (e.g. you cannot leave one edge and reappear on the opposite edge) * Although the blank keys have no function, you may navigate through them if you want to * Spaces may occur anywhere in the `words` string. * Do not press the SHIFT key until you need to. For example, with the word `e.Z`, the SHIFT change happens **after** the `.` is pressed (not before) # Example words = `Code Wars` * C => `a`-`f`-`k`-`p`-`u`-`aA`-OK-`U`-`P`-`K`-`F`-`A`-`B`-`C`-OK = 14 * o => `C`-`H`-`M`-`R`-`W`-`V`-`U`-`aA`-OK-`SP`-`v`-`q`-`l`-`m`-`n`-`o`-OK = 16 * d => `o`-`j`-`e`-`d`-OK = 4 * e => `d`-`e`-OK = 2 * space => `e`-`d`-`c`-`b`-`g`-`l`-`q`-`v`-`SP`-OK = 9 * W => `SP`-`aA`-OK-`SP`-`V`-`W`-OK = 6 * a => `W`-`V`-`U`-`aA`-OK-`u`-`p`-`k`-`f`-`a`-OK = 10 * r => `a`-`f`-`k`-`p`-`q`-`r`-OK = 6 * s => `r`-`s`-OK = 2 Answer = 14 + 16 + 4 + 2 + 9 + 6 + 10 + 6 + 2 = 69 *Good Luck! DM.* Series * TV Remote * TV Remote (shift and space) * TV Remote (wrap) * TV Remote (symbols)

def tv_remote(words): pad = ["abcde123", "fghij456", "klmno789", "pqrst.@0", "uvwxyz_/", "S "] index = {c: (x, y) for x, lst in enumerate(pad) for y, c in enumerate(lst)} res = 0 pos = (0, 0) caps = False for char in words: if char.isalpha() and (char.isupper() != caps): res += (abs(pos[0] - index["S"][0]) + abs(pos[1] - index["S"][1])) + 1 pos = index["S"] caps = not caps char = char.lower() res += (abs(pos[0] - index[char][0]) + abs(pos[1] - index[char][1])) + 1 pos = index[char] return res

train

APPS_structured

This Kata is the first in the [Rubiks Cube collection](https://www.codewars.com/collections/rubiks-party). [This](https://ruwix.com/the-rubiks-cube/notation/) or [this](https://ruwix.com/the-rubiks-cube/notation/advanced/) websites will be very usefull for this kata, if there will be some lack of understanding after the description. There are plenty of examples and a 3D model that can perform all needed rotations. In this Kata you will give the cube the ability to rotate. The Rubik's Cube is made of six faces. F(ront), L(eft), R(ight), B(ack), U(p), D(own) Below a two dimensional representation of the cube. ``` +-----+ | | | U | | | +-----+-----+-----+-----+ | | | | | | L | F | R | B | | | | | | +-----+-----+-----+-----+ | | | D | | | +-----+ ``` On every face you can see nine stickers. Every sticker can be one of the six colors: Yellow, Blue, Red, Green, Orange, White. In this Kata they are represented with according small letters (y, b, r, g, o, w,). A solved cube has on every face only one color: ``` +-----+ |y y y| |y y y| |y y y| +-----+-----+-----+-----+ |b b b|r r r|g g g|o o o| |b b b|r r r|g g g|o o o| |b b b|r r r|g g g|o o o| +-----+-----+-----+-----+ |w w w| |w w w| |w w w| +-----+ ``` Every sticker on a face in this Kata has a positional number ``` +-----+ |1 2 3| |4 5 6| |7 8 9| +-----+ ``` So the state of the face could be represented in a 9 character string consisting of the possible colors. ``` +-----+ |y r b| |o o w| state == "yrboowygb" |y g b| +-----+ ``` So a state of the cube is a 54 character long string consisting of the state of every face in this order: U L F R B D ``` +-----+ |y y y| |y y y| state == "yyyyyyyyybbbbbbbbbrrrrrrrrrgggggggggooooooooowwwwwwwww" |y y y| +-----+-----+-----+-----+ |b b b|r r r|g g g|o o o| |b b b|r r r|g g g|o o o| |b b b|r r r|g g g|o o o| +-----+-----+-----+-----+ |w w w| |w w w| |w w w| +-----+ ``` # Rotations To make things easier I have preloded the `state_representation(state)` function that can visialise a state. ## basic rotations Every face can rotate. - The direction of a rotation is always defined on your "axis of sight" when your looking at a face of the cube. - A rotation of a face is written with an uppercase letter: `F`, `B`, ... - Clockwise and counterclockwise rotations are distinguished by an apostroph, added to the letter for the counterclockwise rotations. Examples: - `F` rotates the front face clockwise. - `F'` rotates the front face conterclockwise. You can rotate a face twice with a `2` after the letter. E.g. `F2` rotates the front face clockwise twice. ## slice rotations There is a possibility to rotate only a middle layer of the cube. These are called slice turns. There are three: `M, E, S`. There is no obvious clockwise or counterclockwise directions, so the are some special standarts: `M`(idle) the layer between `L` and `R`, turn direction as `L` `E`(quator) the layer between `D` and `U`, turn direction as `D` `S`(tanding) the layer between `F` and `B`, turn direction as `F` ``` After a "M" turn +-----+ |y o y| |y o y| state == "yoyyoyyoybbbbbbbbbryrryrryrgggggggggowoowoowowrwwrwwrw" |y o y| +-----+-----+-----+-----+ |b b b|r y r|g g g|o w o| |b b b|r y r|g g g|o w o| |b b b|r y r|g g g|o w o| +-----+-----+-----+-----+ |w r w| |w r w| |w r w| +-----+ ``` ## whole cube rotations There are three more letters you should consider: `X, Y, Z`. This are basically rotating the whole cube along one of the 3D axis. ## double layer rotations This are some kind of combined rotations. There are 6: `f, r, u, l, d, b`. Yes, like the 'basic rotations' but lowercase. A `f` means that you rotate the `F` face and the next slice layer with it IN THE SAME DIRECTION (in the F case its `S`). This is the whole list of possible rotations that the cube should perform: ``` F R U L D B F' R' U' L' D' B' F2 R2 U2 L2 D2 B2 M E S M' E' S' M2 E2 S2 f r u l d b f' r' u' l' d' b' f2 r2 u2 l2 d2 b2 X Y Z X' Y' Z' X2 Y2 Z2 ``` I have preloded a dictionary `single_rotations` that includes every single state to mentioned rotations. `single_rotations["F2"] == "yyyyyywwwbbgbbgbbgrrrrrrrrrbggbggbggoooooooooyyywwwwww"` # Task implement the `perform(sequence)` function that takes a string with space separeted values witha sequence of rotations. E.g. `F R2 f X M2 L' U2 d' Z M' B` The cube always starts in a solved state ("yyyyyyyyybbbbbbbbbrrrrrrrrrgggggggggooooooooowwwwwwwww") The function should return the changed state of the cube after the sequence. ``` perform("F U") == "byybyybyyrrrbbwbbwyggrrrrrroooyggyggbbwoooooogggwwwwww" ``` Enjoy ^_^

f,g=lambda X:[list(x) for x in zip(*X[::-1])],lambda X:[list(x) for x in zip(*X)][::-1] def ROTF(U,L,F,R,B,D): U[2],(L[0][2],L[1][2],L[2][2]),(R[0][0],R[1][0],R[2][0]),D[0]=([L[0][2],L[1][2],L[2][2]][::-1],list(D[0]),list(U[2]),[R[0][0],R[1][0],R[2][0]][::-1]) return (U,L,f(F),R,B,D) def ROTS(U,L,F,R,B,D): U[1],(L[0][1],L[1][1],L[2][1]),(R[0][1],R[1][1],R[2][1]),D[1]=([L[0][1],L[1][1],L[2][1]][::-1],list(D[1]),list(U[1]),[R[0][1],R[1][1],R[2][1]][::-1]) return (U,L,F,R,B,D) def perform(a): c="yyyyyyyyybbbbbbbbbrrrrrrrrrgggggggggooooooooowwwwwwwww" U,L,F,R,B,D=([list(c[9*i:9*i+9][j*3:j*3+3]) for j in range(3)]for i in range(6)) A=[] for x in a.replace("'",'3').split():A+=[x[0]]*int(x[1])if len(x)==2else [x] T=[] W='FS YYYFY YYYFSY YFYYY YFSYYY YYFYY YYFSYY XFXXX XFSXXX XXXFX XXXFSX YYYSY XSXXX' for x in A:T+={k:list(v) for k,v in zip('fLlRrBbDdUuME',W.split())}.get(x,x) for X in T: if X=='X':(U,L,F,R,B,D)=(F,g(L),D,f(R),g(g(U)),g(g(B))) if X=='Y':(U,L,F,R,B,D)=(f(U),F,R,B,L,g(D)) if X=='Z':(U,L,F,R,B,D)=(f(L),f(D),f(F),f(U),g(B),f(R)) if X=='F':(U,L,F,R,B,D)=ROTF(U,L,F,R,B,D) if X=='S':(U,L,F,R,B,D)=ROTS(U,L,F,R,B,D) return ''.join(''.join(''.join(y)for y in x)for x in(U,L,F,R,B,D))

train

APPS_structured

## **Task** Four mirrors are placed in a way that they form a rectangle with corners at coordinates `(0, 0)`, `(max_x, 0)`, `(0, max_y)`, and `(max_x, max_y)`. A light ray enters this rectangle through a hole at the position `(0, 0)` and moves at an angle of 45 degrees relative to the axes. Each time it hits one of the mirrors, it gets reflected. In the end, the light ray hits one of the rectangle's corners, and flies out. Your function must determine whether the exit point is either `(0, 0)` or `(max_x, max_y)`. If it is either `(0, 0)` or `(max_x, max_y)`, return `True` and `False` otherwise. **Example** For `max_x = 10` and `max_y = 20`, the ray goes through the following lattice points: `(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6), (7, 7), (8, 8), (9, 9), (10, 10), (9, 11), (8, 12), (7, 13), (6, 14), (5, 15), (4, 16), (3, 17), (2, 18), (1, 19), (0, 20)`. The ray left the rectangle at position `(0, 20)`, so the result is `False`. Here is an image of the light being reflected. ![d](https://upload.wikimedia.org/wikipedia/commons/thumb/7/73/Arithmetic-billiard-40-10.jpg/450px-Arithmetic-billiard-40-10.jpg) Also, once completing this kata, please do not rate it based off of the difficulty level(kyu) and instead on whether you think it is a good kata.

def reflections(max_x, max_y): return max_x & -max_x == max_y & -max_y

train

APPS_structured

###BACKGROUND: Jacob recently decided to get healthy and lose some weight. He did a lot of reading and research and after focusing on steady exercise and a healthy diet for several months, was able to shed over 50 pounds! Now he wants to share his success, and has decided to tell his friends and family how much weight they could expect to lose if they used the same plan he followed. Lots of people are really excited about Jacob's program and they want to know how much weight they would lose if they followed his plan. Unfortunately, he's really bad at math, so he's turned to you to help write a program that will calculate the expected weight loss for a particular person, given their weight and how long they think they want to continue the plan. ###TECHNICAL DETAILS: Jacob's weight loss protocol, if followed closely, yields loss according to a simple formulae, depending on gender. Men can expect to lose 1.5% of their current body weight each week they stay on plan. Women can expect to lose 1.2%. (Children are advised to eat whatever they want, and make sure to play outside as much as they can!) ###TASK: Write a function that takes as input: ``` - The person's gender ('M' or 'F'); - Their current weight (in pounds); - How long they want to stay true to the protocol (in weeks); ``` and then returns the expected weight at the end of the program. ###NOTES: Weights (both input and output) should be decimals, rounded to the nearest tenth. Duration (input) should be a whole number (integer). If it is not, the function should round to the nearest whole number. When doing input parameter validity checks, evaluate them in order or your code will not pass final tests.

def lose_weight(gender, weight, duration): if gender in 'MF': if weight > 0: if duration > 0: for i in range(duration): if gender == 'M': weight -= weight * 0.015 else: weight -= weight * 0.012 return round(weight, 1) return 'Invalid duration' return 'Invalid weight' return 'Invalid gender'

train

APPS_structured

Chef Al Gorithm was reading a book about climate and oceans when he encountered the word “glaciological”. He thought it was quite curious, because it has the following interesting property: For every two letters in the word, if the first appears x times and the second appears y times, then |x - y| ≤ 1. Chef Al was happy about this and called such words 1-good words. He also generalized the concept: He said a word was K-good if for every two letters in the word, if the first appears x times and the second appears y times, then |x - y| ≤ K. Now, the Chef likes K-good words a lot and so was wondering: Given some word w, how many letters does he have to remove to make it K-good? -----Input----- The first line of the input contains an integer T denoting the number of test cases. The description of T test cases follows. Each test case consists of a single line containing two things: a word w and an integer K, separated by a space. -----Output----- For each test case, output a single line containing a single integer: the minimum number of letters he has to remove to make the word K-good. -----Constraints----- - 1 ≤ T ≤ 30 - 1 ≤ |w| ≤ 105 - 0 ≤ K ≤ 105 - w contains only lowercase English letters. -----Example----- Input: 4 glaciological 1 teammate 0 possessions 3 defenselessness 3 Output: 0 0 1 2 -----Explanation----- Example case 1. The word “glaciological” is already 1-good, so the Chef doesn't have to remove any letter. Example case 2. Similarly, “teammate” is already 0-good. Example case 3. The word “possessions” is 4-good. To make it 3-good, the Chef can remove the last s to make “possession”. Example case 4. The word “defenselessness” is 4-good. To make it 3-good, Chef Al can remove an s and an e to make, for example, “defenslesness”. Note that the word doesn't have to be a valid English word.

##//author : 'Amit Singh Sansoya @amit3200' ##//it was all meant to happen as i was all talk! import string for _ in range(int(input())): s,k=list(map(str,input().split())) k=int(k) lower=[i for i in string.ascii_lowercase] l={} for i in lower: l[i]=0 for i in s: l[i]+=1 ans=len(s) for i in lower: c=0 for j in lower: if l[j]<l[i]: c+=l[j] elif (l[j]-l[i])>k: c+=l[j]-l[i]-k ans=min(ans,c) print(ans)

train

APPS_structured

Write a program to solve a Sudoku puzzle by filling the empty cells. A sudoku solution must satisfy all of the following rules: Each of the digits 1-9 must occur exactly once in each row. Each of the digits 1-9 must occur exactly once in each column. Each of the the digits 1-9 must occur exactly once in each of the 9 3x3 sub-boxes of the grid. Empty cells are indicated by the character '.'. A sudoku puzzle... ...and its solution numbers marked in red. Note: The given board contain only digits 1-9 and the character '.'. You may assume that the given Sudoku puzzle will have a single unique solution. The given board size is always 9x9.

class Solution: def FindValid(self): a="123456789" d,val={},{} for i in range(9): for j in range(9): temp=self.board[i][j] if temp!='.': d[("r",i)]=d.get(("r",i),[])+[temp] d[("c",j)]=d.get(("c",j),[])+[temp] d[(i//3,j//3)]=d.get((i//3,j//3),[])+[temp] else: val[(i,j)]=[] for (i,j) in list(val.keys()): invalid=d.get(("r",i),[])+d.get(("c",j),[])+d.get((i//3,j//3),[]) val[(i,j)]=[ele for ele in a if ele not in invalid] return val def CheckingSolution(self,ele,Pos,Updata): self.board[Pos[0]][Pos[1]]=ele del self.val[Pos] i,j=Pos for invalid in list(self.val.keys()): if ele in self.val[invalid]: if invalid[0]==i or invalid[1]==j or (invalid[0]//3,invalid[1]//3)==(i//3,j//3): Updata[invalid]=ele self.val[invalid].remove(ele) if len(self.val[invalid])==0: return False return True def Sudo(self,Pos,Updata): self.board[Pos[0]][Pos[1]]="." for i in Updata: if i not in self.val: self.val[i]=Updata[i] else: self.val[i].append(Updata[i]) def FindSolution(self): if len(self.val)==0: return True Pos=min(list(self.val.keys()),key=lambda x:len(self.val[x])) nums=self.val[Pos] for ele in nums: updata={Pos:self.val[Pos]} if self.CheckingSolution(ele,Pos,updata): if self.FindSolution(): return True self.Sudo(Pos,updata) return False def solveSudoku(self, board): """ :type board: List[List[str]] :rtype: void Do not return anything, modify board in-place instead. """ self.board=board self.val=self.FindValid() self.FindSolution()

train

APPS_structured

Write a program that reads two numbers $X$ and $K$. The program first finds the factors of $X$ and then gives the sum of $K$th power of every factor. The program also finds the factor of $k$ and outputs the sum of $X$ times of every factor. -----Input:----- - First line will contain $T$, number of testcases. Then the testcases follow. - Each testcase contains of a single line of input, two integers $X, R$. -----Output:----- For each testcase, output in a single line the factors of $X$ and the $K$th power of every factor, seperated by a space. -----Constraints----- - $1 \leq T \leq 1000$ - $2 \leq X, K \leq 10^9$ -----Sample Input:----- 1 8 6 -----Sample Output:----- 266304 88 -----EXPLANATION:----- Factors of x = 8 are 2, 4, and 8. Also, factors of k = 6 are 2, 3, and 6. 2^6 + 4^6 + 8^6 = 266304 and 2 × 8 + 3 × 8 + 6 × 8 = 88. (Where a ^b denotes a raised to the power of b).

for _ in range(int(input())): x,k=map(int,input().split(" ")) s=0 for i in range(2,x+1): if x%i==0: s+=(i**k) s1=0 for i in range(2,k+1): if k%i==0: s1+=(i*x) print(s,s1)

train

APPS_structured

This is a follow-up from my previous Kata which can be found here: http://www.codewars.com/kata/5476f4ca03810c0fc0000098 This time, for any given linear sequence, calculate the function [f(x)] and return it as a function in Javascript or Lambda/Block in Ruby. For example: ```python get_function([0, 1, 2, 3, 4])(5) => 5 get_function([0, 3, 6, 9, 12])(10) => 30 get_function([1, 4, 7, 10, 13])(20) => 61 ``` Assumptions for this kata are: ``` The sequence argument will always contain 5 values equal to f(0) - f(4). The function will always be in the format "nx +/- m", 'x +/- m', 'nx', 'x' or 'm' If a non-linear sequence simply return 'Non-linear sequence' for javascript, ruby, and python. For C#, throw an ArgumentException. ```

def get_function(sequence): slope = sequence[1] - sequence[0] for x in range(1,5): if sequence[x] - sequence[x-1] != slope: return "Non-linear sequence" return lambda a : slope * a + sequence[0]

train

APPS_structured

Given a rows x cols matrix mat, where mat[i][j] is either 0 or 1, return the number of special positions in mat. A position (i,j) is called special if mat[i][j] == 1 and all other elements in row i and column j are 0 (rows and columns are 0-indexed). Example 1: Input: mat = [[1,0,0], [0,0,1], [1,0,0]] Output: 1 Explanation: (1,2) is a special position because mat[1][2] == 1 and all other elements in row 1 and column 2 are 0. Example 2: Input: mat = [[1,0,0], [0,1,0], [0,0,1]] Output: 3 Explanation: (0,0), (1,1) and (2,2) are special positions. Example 3: Input: mat = [[0,0,0,1], [1,0,0,0], [0,1,1,0], [0,0,0,0]] Output: 2 Example 4: Input: mat = [[0,0,0,0,0], [1,0,0,0,0], [0,1,0,0,0], [0,0,1,0,0], [0,0,0,1,1]] Output: 3 Constraints: rows == mat.length cols == mat[i].length 1 <= rows, cols <= 100 mat[i][j] is 0 or 1.

class Solution: def numSpecial(self, mat: List[List[int]]) -> int: ## My original solution, not very fast # mat_t = list(zip(*mat)) # row_s = [i for i in range(len(mat)) if sum(mat[i]) == 1] # col_s = [j for j in range(len(mat_t)) if sum(mat_t[j]) == 1] # return sum(mat[i][j] == 1 and i in row_s and j in col_s for i in range(len(mat)) for j in range(len(mat_t))) ## Modified version, still not very fast mat_t = list(zip(*mat)) res = 0 for i in range(len(mat)): for j in range(len(mat_t)): if mat[i][j] == sum(mat[i]) == sum(mat_t[j]) == 1: res += 1 return res

train

APPS_structured

We say that a binary string (a string containing only characters '0' and '1') is pure if it does not contain either of the strings "0101" or "1010" as a subsequence. Recall that string T is a subsequence of string S if we can delete some of the letters of S (possibly none) such that the resulting string will become T. You are given a binary string $S$ with length $N$. We want to make this string pure by deleting some (possibly zero) characters from it. What is the minimum number of characters we have to delete? -----Input----- - The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows. - The first and only line of each test case contains a single string $S$ with length $N$. -----Output----- For each test case, print a single line containing one integer — the minimum number of characters we have to delete from $S$. -----Constraints----- - $1 \le T \le 40$ - $1 \le N \le 1,000$ - $S$ contains only characters '0' and '1' -----Example Input----- 4 010111101 1011100001011101 0110 111111 -----Example Output----- 2 3 0 0 -----Explanation----- Example case 1: We can delete the first and third character of our string. There is no way to make the string pure by deleting only one character. Example case 3: The given string is already pure, so the answer is zero.

# cook your dish here # code by RAJ BHAVSAR for _ in range(int(input())): s = str(input()) dp = [0,0,len(s),len(s),len(s),len(s)] for i in s: if(i == '1'): dp[3] = min(dp[3],dp[0]) dp[0] += 1 dp[5] = min(dp[5],dp[2]) dp[2] += 1 dp[4] += 1 else: dp[2] = min(dp[2],dp[1]) dp[1] += 1 dp[4] = min(dp[4],dp[3]) dp[3] += 1 dp[5] += 1 print(min(dp))

train

APPS_structured

We are given a 2-dimensional grid. "." is an empty cell, "#" is a wall, "@" is the starting point, ("a", "b", ...) are keys, and ("A", "B", ...) are locks. We start at the starting point, and one move consists of walking one space in one of the 4 cardinal directions. We cannot walk outside the grid, or walk into a wall. If we walk over a key, we pick it up. We can't walk over a lock unless we have the corresponding key. For some 1 <= K <= 6, there is exactly one lowercase and one uppercase letter of the first K letters of the English alphabet in the grid. This means that there is exactly one key for each lock, and one lock for each key; and also that the letters used to represent the keys and locks were chosen in the same order as the English alphabet. Return the lowest number of moves to acquire all keys. If it's impossible, return -1. Example 1: Input: ["@.a.#","###.#","b.A.B"] Output: 8 Example 2: Input: ["@..aA","..B#.","....b"] Output: 6 Note: 1 <= grid.length <= 30 1 <= grid[0].length <= 30 grid[i][j] contains only '.', '#', '@', 'a'-'f' and 'A'-'F' The number of keys is in [1, 6]. Each key has a different letter and opens exactly one lock.

class Solution: def shortestPathAllKeys(self, grid: List[str]) -> int: m = len(grid) n = len(grid[0]) q = collections.deque() keys = 0 visited = set() for i in range(m): for j in range(n): if grid[i][j] == '@': q.append((i, j, 0)) visited.add((i, j, 0)) elif grid[i][j] >= 'a' and grid[i][j] <= 'f': keys += 1 goal = (1 << keys) - 1 dirs = [[-1, 0], [1, 0], [0, -1], [0, 1]] step = 0 while q: size = len(q) for _ in range(size): i, j, state = q.popleft() for di, dj in dirs: x = i + di y = j + dj if x < 0 or x >= m or y < 0 or y >= n or grid[x][y] == '#' or (x, y, state) in visited: continue nstate = state if grid[x][y] >= 'A' and grid[x][y] <= 'F': temp = ord(grid[x][y]) - ord('A') if state & (1 << temp) == 0: continue elif grid[x][y] >= 'a' and grid[x][y] <= 'f': temp = ord(grid[x][y]) - ord('a') nstate |= 1 << temp if nstate == goal: return step + 1 visited.add((x, y, nstate)) q.append((x, y, nstate)) step += 1 return -1

train

APPS_structured

# Fun fact Tetris was the first video game played in outer space In 1993, Russian cosmonaut Aleksandr A. Serebrov spent 196 days on the Mir space station with a very special distraction: a gray Game Boy loaded with Tetris. During that time the game orbited the Earth 3,000 times and became the first video game played in space. The Game Boy was sold in a Bonhams auction for $1,220 during the Space History Sale in 2011. # Task Parse the game log and determine how many lines have been cleared through the game. The game ends if all commands from input were interpreted or the maximum field height (30 units) is reached. A horizontal line, according to the rules of classic Tetris, is considered cleared if it represents a solid line without gaps formed by falling blocks. When such a line is formed, it disappears and any blocks above it fall down to fill the space. # Input ```python ['4L2', '3R4', '4L3', '3L4', '4R0', '1L2'] # example ``` As an argument, you are given gamelog - an array of commands which you need to interpret. Each command has the same form: * The first character - the type of block (integer from 1 to 4, as in this kata we have only 4 types of blocks). Block types are described below. * The second - the direction of movement (`"R"` or `"L"` - right or left). * The third is an offset (integer from 0 to 4, as width of our field 9 units and new block always appears at the center of the field) relative to the starting position. Thus, `L4` means the leftmost position, and `R4` the rightmost, and `L0` is equivalent to `R0`. # Output The total number of cleaned horizontal lines (`int`) to the end of the game. Note, if the field height is exceeded, then the game ends immediately. # Blocks In this kata we have only 4 types of blocks. Yes, this is not a classic set of shapes, but this is only for simplicity. ``` # and their graphical representation: ■ ■ ■ ■ ■ ■ ■ ■ ■ ■ ---+---+---+--- #1 #2 #3 #4 ``` # Field Gamefield (a rectangular vertical shaft) has width 9 units and height 30 units. table, th, td { border: 1px solid; } Indices can be represented as: L4 L3 L2 L1 L0/R0 R1 R2 R3 R4 # Example 1 ```python >>> gamelog = ['1R4', '2L3', '3L2', '4L1', '1L0', '2R1', '3R2', '4R3', '1L4'] >>> tetris(gamelog) 1 ``` Gamefield before last command (_ means empty space): ``` ___■___■_ __■■__■■_ _■■■_■■■_ _■■■■■■■■ ``` Gamefield after all commands: ``` ___■___■_ __■■__■■_ _■■■_■■■_ ``` As you can see, one solid line was cleared. So, answer is 1. # Example 2 ```python >>> gamelog = ['1L2', '4R2', '3L3', '3L1', '1L4', '1R4'] >>> tetris(gamelog) 0 ``` Gamefield after all commands: ``` _____■__ _■_■__■__ _■_■__■__ ■■■■__■_■ ``` As you can see, there is no solid lines, so nothing to clear. Our answer is 0, zero cleaned lines. # Note Since there is no rotation of blocks in our model and all blocks are very simple, do not overthink the task. # Other If you like the idea: leave feedback, and there will be more katas in the Tetris series. * 7 kyuTetris Series #1 — Scoring System * 6 kyuTetris Series #2 — Primitive Gameplay * 6 kyuTetris Series #3 — Adding Rotation (TBA) * 5 kyuTetris Series #4 — New Block Types (TBA) * 4 kyuTetris Series #5 — Complex Block Types (TBA?)

def tetris(arr): d, c = {}, 0 for i, j in enumerate(arr): t, dt = j[1:].replace('R0', 'L0'), d.values() d[t] = d.get(t, 0) + int(j[0]) if len(dt)==9 and all(dt) : m = min(d.values()) ; d = {k:l-m for k,l in d.items()} ; c += m if d[t] >= 30 : break return c

train

APPS_structured

You have to build a pyramid. This pyramid should be built from characters from a given string. You have to create the code for these four methods: ```python watch_pyramid_from_the_side(characters): watch_pyramid_from_above(characters): count_visible_characters_of_the_pyramid(characters): count_all_characters_of_the_pyramid(characters): ``` The first method ("FromTheSide") shows the pyramid as you would see from the side. The second method ("FromAbove") shows the pyramid as you would see from above. The third method ("CountVisibleCharacters") should return the count of all characters, that are visible from outside the pyramid. The forth method ("CountAllCharacters") should count all characters of the pyramid. Consider that the pyramid is completely solid and has no holes or rooms in it. Every character will be used for building one layer of the pyramid. So the length of the given string will be the height of the pyramid. Every layer will be built with stones from the given character. There is no limit of stones. The pyramid should have perfect angles of 45 degrees. Example: Given string: "abc" Pyramid from the side: ``` c bbb aaaaa ``` Pyramid from above: ``` aaaaa abbba abcba abbba aaaaa ``` Count of visible stones/characters: ``` 25 ``` Count of all used stones/characters: ``` 35 ``` There is no meaning in the order or the choice of the characters. It should work the same for example "aaaaa" or "54321". Hint: Your output for the side must always be a rectangle! So spaces at the end of a line must not be deleted or trimmed! If the string is null or empty, you should exactly return this value for the watch-methods and -1 for the count-methods. Have fun coding it and please don't forget to vote and rank this kata! :-) I have created other katas. Have a look if you like coding and challenges.

def watch_pyramid_from_the_side(characters): if not characters: return characters s = characters[::-1] n = len(s) * 2 - 1 return '\n'.join('{:^{}}'.format(c * i, n) for i, c in zip(range(1, len(s) * 2, 2), s)) def watch_pyramid_from_above(characters): if not characters: return characters s = characters[::-1] n = len(s) return '\n'.join( ''.join(s[max(abs(i), abs(j))] for j in range(-n+1, n)) for i in range(-n+1, n) ) def count_visible_characters_of_the_pyramid(characters): if not characters: return -1 n = len(characters) * 2 - 1 return n ** 2 def count_all_characters_of_the_pyramid(characters): if not characters: return -1 return sum(n**2 for n in range(1, 2 * len(characters), 2))

train

APPS_structured

In a array A of size 2N, there are N+1 unique elements, and exactly one of these elements is repeated N times. Return the element repeated N times. Example 1: Input: [1,2,3,3] Output: 3 Example 2: Input: [2,1,2,5,3,2] Output: 2 Example 3: Input: [5,1,5,2,5,3,5,4] Output: 5 Note: 4 <= A.length <= 10000 0 <= A[i] < 10000 A.length is even

class Solution: def repeatedNTimes(self, A: List[int]) -> int: nums = {} for i in A: if i not in list(nums.keys()): nums[i] = 1 else: nums[i] += 1 print(nums) for i in nums: if nums[i] == len(A) / 2: return i

train

APPS_structured

Chef's pizza is the tastiest pizza to exist, and the reason for that is his special, juicy homegrown tomatoes. Tomatoes can be grown in rectangular patches of any side lengths. However, Chef only has a limited amount of land. Consider the entire town of Chefville to be consisting of cells in a rectangular grid of positive coordinates. Chef own all cells (x,y)$(x, y)$ that satisfy x∗y≤N$x*y \leq N$ As an example if N=4$N = 4$, Chef owns the following cells: (1,1),(1,2),(1,3),(1,4),(2,1),(2,2),(3,1),(4,1)$(1, 1), (1, 2), (1, 3), (1, 4), (2, 1), (2, 2), (3, 1), (4, 1) $ Chef can only grow tomatoes in rectangular patches consisting only of cells which belong to him. Also, if he uses a cell, he must use it entirely. He cannot use only a portion of it. Help Chef find the number of unique patches of rectangular land that he can grow tomatoes in! Since this number can be very large, output it modulo 1000000007$1000000007$. -----Input:----- - The first line of the input contains T$T$, the number of test cases. - The next T$T$ lines of input contains one integer N$N$. -----Output:----- For each testcase, output the number of ways modulo 1000000007$1000000007$. -----Constraints----- - 1≤T≤5$1 \leq T \leq 5$ - 1≤N≤1010$1 \leq N \leq 10^{10}$ -----Sample Input:----- 2 4 10000000000 -----Sample Output:----- 23 227374950

import math Mod=1000000007 for _ in range(int(input())): v=int(input()) i=0 s=0 for i in range(1,math.floor(math.sqrt(v))+1): s+=i*((math.floor(v/i))*(math.floor(v/i)+1)-(i*(i-1))) s-=(i*i) print(s%Mod)

train

APPS_structured

In English, we have a concept called root, which can be followed by some other words to form another longer word - let's call this word successor. For example, the root an, followed by other, which can form another word another. Now, given a dictionary consisting of many roots and a sentence. You need to replace all the successor in the sentence with the root forming it. If a successor has many roots can form it, replace it with the root with the shortest length. You need to output the sentence after the replacement. Example 1: Input: dict = ["cat", "bat", "rat"] sentence = "the cattle was rattled by the battery" Output: "the cat was rat by the bat" Note: The input will only have lower-case letters. 1 1 1 1

class Solution: def replaceWords(self, dict, sentence): trie_tree = {'root': {}} for word in dict: parent = trie_tree['root'] for c in word + '#': parent.setdefault(c, {}) parent = parent[c] sentence, res = sentence.split(), [] for word in sentence: parent = trie_tree['root'] for i, c in enumerate(word + '*'): if c not in parent: res.append(word) break parent = parent[c] if '#' in parent: res.append(word[:i + 1]) break return ' '.join(res)

train

APPS_structured

Polycarp plays a computer game. In this game, the players summon armies of magical minions, which then fight each other. Polycarp can summon $n$ different minions. The initial power level of the $i$-th minion is $a_i$, and when it is summoned, all previously summoned minions' power levels are increased by $b_i$. The minions can be summoned in any order. Unfortunately, Polycarp cannot have more than $k$ minions under his control. To get rid of unwanted minions after summoning them, he may destroy them. Each minion can be summoned (and destroyed) only once. Polycarp's goal is to summon the strongest possible army. Formally, he wants to maximize the sum of power levels of all minions under his control (those which are summoned and not destroyed). Help Polycarp to make up a plan of actions to summon the strongest possible army! -----Input----- The first line contains one integer $T$ ($1 \le T \le 75$) — the number of test cases. Each test case begins with a line containing two integers $n$ and $k$ ($1 \le k \le n \le 75$) — the number of minions availible for summoning, and the maximum number of minions that can be controlled by Polycarp, respectively. Then $n$ lines follow, the $i$-th line contains $2$ integers $a_i$ and $b_i$ ($1 \le a_i \le 10^5$, $0 \le b_i \le 10^5$) — the parameters of the $i$-th minion. -----Output----- For each test case print the optimal sequence of actions as follows: Firstly, print $m$ — the number of actions which Polycarp has to perform ($0 \le m \le 2n$). Then print $m$ integers $o_1$, $o_2$, ..., $o_m$, where $o_i$ denotes the $i$-th action as follows: if the $i$-th action is to summon the minion $x$, then $o_i = x$, and if the $i$-th action is to destroy the minion $x$, then $o_i = -x$. Each minion can be summoned at most once and cannot be destroyed before being summoned (and, obviously, cannot be destroyed more than once). The number of minions in Polycarp's army should be not greater than $k$ after every action. If there are multiple optimal sequences, print any of them. -----Example----- Input 3 5 2 5 3 7 0 5 0 4 0 10 0 2 1 10 100 50 10 5 5 1 5 2 4 3 3 4 2 5 1 Output 4 2 1 -1 5 1 2 5 5 4 3 2 1 -----Note----- Consider the example test. In the first test case, Polycarp can summon the minion $2$ with power level $7$, then summon the minion $1$, which will increase the power level of the previous minion by $3$, then destroy the minion $1$, and finally, summon the minion $5$. After this, Polycarp will have two minions with power levels of $10$. In the second test case, Polycarp can control only one minion, so he should choose the strongest of them and summon it. In the third test case, Polycarp is able to summon and control all five minions.

def read_int(): return int(input()) def read_ints(): return list(map(int, input().split(' '))) t = read_int() for case_num in range(t): n, k = read_ints() p = [] for i in range(n): ai, bi = read_ints() p.append((bi, ai, i + 1)) p.sort() dp = [[0 for j in range(k + 1)] for i in range(n + 1)] use = [[False for j in range(k + 1)] for i in range(n + 1)] for i in range(1, n + 1): for j in range(min(i, k) + 1): if i - 1 >= j: dp[i][j] = dp[i - 1][j] + (k - 1) * p[i - 1][0] if j > 0: x = dp[i - 1][j - 1] + (j - 1) * p[i - 1][0] + p[i - 1][1] if x > dp[i][j]: dp[i][j] = x use[i][j] = True used = [] curr = k for i in range(n, 0, -1): if use[i][curr]: used.append(p[i - 1][2]) curr -= 1 used.reverse() seq = used[:-1] st = set(used) for i in range(1, n + 1): if not i in st: seq.append(i) seq.append(-i) seq.append(used[-1]) print(len(seq)) print(' '.join(map(str, seq)))

train

APPS_structured

Coach Moony wants the best team to represent their college in ICPC. He has $N$ students standing in a circle with certain rating $X_i$ on a competitive coding platform. It is an established fact that any coder with more rating on the platform is a better coder. Moony wants to send his best $3$ coders based upon their rating. But all coders only want to have their friends in their team and every coder is friends with four other coders, adjacent two on left side in the circle, and adjacent two on right. So Moony comes up with a solution that team with maximum cumulative rating of all three members in a team shall be representing their college. You need to give the cumulative score of the team that will be representing the college. -----Input:----- - First line will contain $T$, number of testcases. - First line of each test case contains a single integer $N$. - Second line of each test case takes $N$ integers, denoting rating of $ith$ coder. -----Output:----- For each testcase, output a single integer denoting cumulative rating of the team. -----Constraints----- - $1 \leq T \leq 10$ - $7 \leq N \leq 10^5$ - $0 \leq X_i \leq 10^9$ -----Sample Input:----- 1 7 10 40 30 30 20 0 0 -----Sample Output:----- 100

'''t = int(input()) for i in range(t): n = int(input()) l = list(map(int, input().strip().split())) if(n==3): print(l[0]+l[1]+l[2]) elif(n==4): print(sum(l)-min(l)) else: ans=0 for i in range(n): k = [0 for i in range(5)] k[0]=l[i] k[1]=l[(i+n+1)%n] k[2] = l[(i+n+2)%n] k[3] = l[i-1] k[4] = l[i-2] k.sort() p = k[2]+k[3]+k[4] if(p>ans): ans=p print(ans)''' t = int(input()) for i in range(t): n = int(input()) l = list(map(int, input().strip().split())) if(n==3): print(sum(l)) else: ans=0 for j in range(n): p = l[j]+l[(j+n+1)%n]+l[(j+n+2)%n] if(p>ans): ans=p p = l[n-2]+l[n-1]+l[0] if(p>ans): ans=p p = l[1]+l[n-1]+l[0] if(p>ans): ans=p print(ans)

train

APPS_structured

You are given a string of numbers between 0-9. Find the average of these numbers and return it as a floored whole number (ie: no decimal places) written out as a string. Eg: "zero nine five two" -> "four" If the string is empty or includes a number greater than 9, return "n/a"

def average_string(s): n = 0 dic = { 'zero' : 0, 'one' : 1, 'two' : 2, 'three' : 3, 'four' : 4, 'five' : 5, 'six' : 6, 'seven' : 7, 'eight' : 8, 'nine' : 9 } s = s.split(' ') for i in range(len(s)): if s[i] in dic: n += dic[s[i]] else: return "n/a" n //= len(s) for key in dic: if dic.get(key) == n: n = key return n

train

APPS_structured

The power of an integer x is defined as the number of steps needed to transform x into 1 using the following steps: if x is even then x = x / 2 if x is odd then x = 3 * x + 1 For example, the power of x = 3 is 7 because 3 needs 7 steps to become 1 (3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1). Given three integers lo, hi and k. The task is to sort all integers in the interval [lo, hi] by the power value in ascending order, if two or more integers have the same power value sort them by ascending order. Return the k-th integer in the range [lo, hi] sorted by the power value. Notice that for any integer x (lo <= x <= hi) it is guaranteed that x will transform into 1 using these steps and that the power of x is will fit in 32 bit signed integer. Example 1: Input: lo = 12, hi = 15, k = 2 Output: 13 Explanation: The power of 12 is 9 (12 --> 6 --> 3 --> 10 --> 5 --> 16 --> 8 --> 4 --> 2 --> 1) The power of 13 is 9 The power of 14 is 17 The power of 15 is 17 The interval sorted by the power value [12,13,14,15]. For k = 2 answer is the second element which is 13. Notice that 12 and 13 have the same power value and we sorted them in ascending order. Same for 14 and 15. Example 2: Input: lo = 1, hi = 1, k = 1 Output: 1 Example 3: Input: lo = 7, hi = 11, k = 4 Output: 7 Explanation: The power array corresponding to the interval [7, 8, 9, 10, 11] is [16, 3, 19, 6, 14]. The interval sorted by power is [8, 10, 11, 7, 9]. The fourth number in the sorted array is 7. Example 4: Input: lo = 10, hi = 20, k = 5 Output: 13 Example 5: Input: lo = 1, hi = 1000, k = 777 Output: 570 Constraints: 1 <= lo <= hi <= 1000 1 <= k <= hi - lo + 1

class Solution: def getKth(self, lo, hi, k): # memo = { 1:0 } def power(x): if x in memo: return memo[x] n = memo[x] = 1 + power( 3*x+1 if x&1 else x >> 1 ) return n # A = [ (power(x),x) for x in range(lo,hi+1) ] return sorted(A)[k-1][1]

train

APPS_structured

A bitstring is a string consisting only of the characters 0 and 1. A bitstring is called $k$-balanced if every substring of size $k$ of this bitstring has an equal amount of 0 and 1 characters ($\frac{k}{2}$ of each). You are given an integer $k$ and a string $s$ which is composed only of characters 0, 1, and ?. You need to determine whether you can make a $k$-balanced bitstring by replacing every ? characters in $s$ with either 0 or 1. A string $a$ is a substring of a string $b$ if $a$ can be obtained from $b$ by deletion of several (possibly, zero or all) characters from the beginning and several (possibly, zero or all) characters from the end. -----Input----- Each test contains multiple test cases. The first line contains the number of test cases $t$ ($1 \le t \le 10^4$). Description of the test cases follows. The first line of each test case contains two integers $n$ and $k$ ($2 \le k \le n \le 3 \cdot 10^5$, $k$ is even) — the length of the string and the parameter for a balanced bitstring. The next line contains the string $s$ ($|s| = n$). It is given that $s$ consists of only 0, 1, and ?. It is guaranteed that the sum of $n$ over all test cases does not exceed $3 \cdot 10^5$. -----Output----- For each test case, print YES if we can replace every ? in $s$ with 0 or 1 such that the resulting bitstring is $k$-balanced, or NO if it is not possible. -----Example----- Input 9 6 4 100110 3 2 1?1 3 2 1?0 4 4 ???? 7 4 1?0??1? 10 10 11??11??11 4 2 1??1 4 4 ?0?0 6 2 ????00 Output YES YES NO YES YES NO NO YES NO -----Note----- For the first test case, the string is already a $4$-balanced bitstring. For the second test case, the string can be transformed into 101. For the fourth test case, the string can be transformed into 0110. For the fifth test case, the string can be transformed into 1100110.

import sys import heapq, functools, collections import math, random from collections import Counter, defaultdict # available on Google, not available on Codeforces # import numpy as np # import scipy def solve(srr, k): # fix inputs here console("----- solving ------") console(srr, k) ones = 0 zeroes = 0 for i in range(k): sett = set(srr[i::k]) if "1" in sett and "0" in sett: return "NO" if "1" in sett: ones += 1 if "0" in sett: zeroes += 1 if ones > k // 2 or zeroes > k // 2: return "NO" return "YES" def console(*args): # the judge will not read these print statement print('\033[36m', *args, '\033[0m', file=sys.stderr) return # fast read all # sys.stdin.readlines() for case_num in range(int(input())): # read line as a string # strr = input() # read line as an integer # k = int(input()) # read one line and parse each word as a string # lst = input().split() # read one line and parse each word as an integer _, k = list(map(int,input().split())) srr = input() # read matrix and parse as integers (after reading read nrows) # lst = list(map(int,input().split())) # nrows = lst[0] # index containing information, please change # grid = [] # for _ in range(nrows): # grid.append(list(map(int,input().split()))) res = solve(srr, k) # please change # Google - case number required # print("Case #{}: {}".format(case_num+1, res)) # Codeforces - no case number required print(res)

train

APPS_structured

The aim of this kata is to split a given string into different strings of equal size (note size of strings is passed to the method) Example: Split the below string into other strings of size #3 'supercalifragilisticexpialidocious' Will return a new string 'sup erc ali fra gil ist ice xpi ali doc iou s' Assumptions: String length is always greater than 0 String has no spaces Size is always positive

from textwrap import wrap def split_in_parts(s, part_length): return " ".join(wrap(s,part_length))

train

APPS_structured

*Inspired by the [Fold an Array](https://www.codewars.com/kata/fold-an-array) kata. This one is sort of similar but a little different.* --- ## Task You will receive an array as parameter that contains 1 or more integers and a number `n`. Here is a little visualization of the process: * Step 1: Split the array in two: ``` [1, 2, 5, 7, 2, 3, 5, 7, 8] / \ [1, 2, 5, 7] [2, 3, 5, 7, 8] ``` * Step 2: Put the arrays on top of each other: ``` [1, 2, 5, 7] [2, 3, 5, 7, 8] ``` * Step 3: Add them together: ``` [2, 4, 7, 12, 15] ``` Repeat the above steps `n` times or until there is only one number left, and then return the array. ## Example ``` Input: arr=[4, 2, 5, 3, 2, 5, 7], n=2 Round 1 ------- step 1: [4, 2, 5] [3, 2, 5, 7] step 2: [4, 2, 5] [3, 2, 5, 7] step 3: [3, 6, 7, 12] Round 2 ------- step 1: [3, 6] [7, 12] step 2: [3, 6] [7, 12] step 3: [10, 18] Result: [10, 18] ```

def split_and_add(arr, n): for _ in range(n): half = len(arr) // 2 arr = [a+b for a, b in zip([0] * (len(arr)%2) + arr[:half], arr[half:])] return arr

train

APPS_structured

After Misha's birthday he had many large numbers left, scattered across the room. Now it's time to clean up and Misha needs to put them in a basket. He ordered this task to his pet robot that agreed to complete the task at certain conditions. Before the robot puts a number x to the basket, Misha should answer the question: is it possible to choose one or multiple numbers that already are in the basket, such that their XOR sum equals x? If the answer is positive, you also need to give the indexes of these numbers. If there are multiple options of choosing numbers, you are allowed to choose any correct option. After Misha's answer the robot puts the number to the basket. Initially the basket is empty. Each integer you put in the basket takes some number. The first integer you put into the basket take number 0, the second integer takes number 1 and so on. Misha needs to clean up the place as soon as possible but unfortunately, he isn't that good at mathematics. He asks you to help him. -----Input----- The first line contains number m (1 ≤ m ≤ 2000), showing how many numbers are scattered around the room. The next m lines contain the numbers in the order in which the robot puts them in the basket. Each number is a positive integer strictly less than 10^600 that doesn't contain leading zeroes. -----Output----- For each number either print a 0 on the corresponding line, if the number cannot be represented as a XOR sum of numbers that are in the basket, or print integer k showing how many numbers are in the representation and the indexes of these numbers. Separate the numbers by spaces. Each number can occur in the representation at most once. -----Examples----- Input 7 7 6 5 4 3 2 1 Output 0 0 0 3 0 1 2 2 1 2 2 0 2 2 0 1 Input 2 5 5 Output 0 1 0 -----Note----- The XOR sum of numbers is the result of bitwise sum of numbers modulo 2.

m = int(input()) b = [] k = [] for i in range(m): x = int(input()) c = 0 for j in range(len(b)): v = b[j] d = k[j] if (x ^ v) < x: x ^= v c ^= d if x != 0: print(0) c ^= 2 ** i b.append(x) k.append(c) else: a = [] for j in range(m): if c & 1 == 1: a.append(j) c >>= 1 print(len(a), end='') for v in a: print(' ', v, sep='', end='') print()

train

APPS_structured

Chef has a rectangular piece of paper. He puts it on a big board in such a way that two sides of the paper are horizontal and two are vertical, and then he performs a sequence of $N$ operations. You are given a string $S$ with length $N$; for each valid $i$, the $i$-th character of $S$ determines the type of the $i$-th operation: - 'R': Pick up the paper from the right side and fold it onto the left side. - 'L': Pick up the paper from the left side and fold it onto the right side. - 'U': Pick up the paper from the upper side and fold it onto the bottom side. - 'D': Pick up the paper from the bottom side and fold it onto the upper side. The paper is folded in such a way that there is still a flat rectangular sheet of paper lying on the table after each operation, but it consists of multiple layers of the original sheet. The lengths of the horizontal and vertical sides of the resulting sheet (after performing these $N$ operations) are $W$ and $H$ respectively. Let's build an Euclidean coordinate system on the paper, where the point $(0, 0)$ corresponds to the bottom left corner and $(W, H)$ to the upper right corner. Chef then draws $M$ points on this folded sheet of paper. The ink used to draw them soaks deep into the paper, so each point is drawn on all layers of the paper (and also on both faces of each layer). Finally, Chef completely unfolds the paper. He's asking you to compute the distance between the nearest pair of points. -----Input----- - The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows. - The first line of each test case contains four space-separated integers $N$, $M$, $W$ and $H$. - The second line contains a single string $S$. - Each of the following $M$ lines contains two space-separated integers $X$ and $Y$ denoting the coordinates of one point. -----Output----- For each test case, print a single line containing one real number ― the minimum distance. Your answer will be considered correct if its absolute or relative error does not exceed $10^{-6}$. -----Constraints----- - $1 \le T \le 50$ - $2 \le M \le 1,000$ - $1 \le N \le 1,000$ - $3 \le W, H \le 10^9$ - $1 \le X \le W-1$ - $1 \le Y \le H-1$ - the points are pairwise distinct -----Subtasks----- Subtask #1 (50 points): all characters of $S$ are 'U' Subtask #2 (50 points): original constraints -----Example Input----- 2 6 2 10 10 ULRDDL 4 4 5 5 4 2 10 10 RUDL 1 1 9 9 -----Example Output----- 1.41421356237 2.00000000000

# cook your dish here folding paper from collections import Counter def li():return [int(i) for i in input().rstrip('\n').split()] def st():return input().rstrip('\n') def val():return int(input().rstrip('\n')) def dist(a,b):return ((a[0]-b[0])**2+(a[1]-b[1])**2)**0.5 for _ in range(val()): n,m,w,h=li() s=Counter(st()) l=[] for i in range(m): l.append(li()) ans=float('inf') l.sort(key=lambda x:x[0]) for j in range(1,50): for i in range(j,m): ans=min(ans,dist(l[i-j],l[i])) for i in l: if s['D'] or s['U']>1:ans=min(ans,2*i[1]) if s['U'] or s['D']>1:ans=min(ans,2*(h-i[1])) if s['L'] or s['R']>1:ans=min(ans,2*i[0]) if s['R'] or s['L']>1:ans=min(ans,2*(w-i[0])) print(ans)

train

APPS_structured

Seven is a hungry number and its favourite food is number 9. Whenever it spots 9 through the hoops of 8, it eats it! Well, not anymore, because you are going to help the 9 by locating that particular sequence (7,8,9) in an array of digits and tell 7 to come after 9 instead. Seven "ate" nine, no more! (If 9 is not in danger, just return the same array)

def hungry_seven(arr): nums = ''.join(str(a) for a in arr) while '789' in nums: nums = nums.replace('789','897') return [int(n) for n in nums]

train

APPS_structured

My third kata, write a function `check_generator` that examines the status of a Python generator expression `gen` and returns `'Created'`, `'Started'` or `'Finished'`. For example: `gen = (i for i in range(1))` >>> returns `'Created'` (the generator has been initiated) `gen = (i for i in range(1)); next(gen, None)` >>> returns `'Started'` (the generator has yielded a value) `gen = (i for i in range(1)); next(gen, None); next(gen, None)` >>> returns `'Finished'` (the generator has been exhuasted) For an introduction to Python generators, read: https://wiki.python.org/moin/Generators. Please do vote and rank the kata, and provide any feedback. Hint: you can solve this if you know the right module to use.

def check_generator(gen): if gen.gi_frame != None: if len(gen.gi_frame.f_locals.keys()) == 1: return 'Created' else: return 'Started' if gen.gi_frame == None: return 'Finished'

train

APPS_structured

Istiak is learning about arithmetic progressions. Today, he wrote an arithmetic sequence on a piece of paper. Istiak was very happy that he managed to write an arithmetic sequence and went out for lunch. Istiak's friend Rafsan likes to irritate him by playing silly pranks on him. This time, he could have chosen one element of Istiak's sequence and changed it. When Istiak came back, he was devastated to see his sequence ruined — it became a sequence $a_1, a_2, \ldots, a_N$ (possibly identical to the original sequence, if Rafsan did not change anything, in which case Istiak is just overreacting). Help him recover the original sequence. Formally, you have to find an arithmetic sequence $b_1, b_2, \ldots, b_N$ which differs from $a$ in at most one position. $b$ is said to be an arithmetic sequence if there is a real number $d$ such that $b_i - b_{i-1} = d$ for each $i$ ($2 \le i \le N$). If there are multiple valid solutions, you may find any one. -----Input----- - The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows. - The first line of each test case contains a single integer $N$. - The second line contains $N$ space-separated integers $a_1, a_2, \ldots, a_N$. -----Output----- For each test case, print a single line containing $N$ space-separated integers $b_1, b_2, \ldots, b_N$. It is guaranteed that a valid solution exists. -----Constraints----- - $4 \le N \le 10^5$ - $|a_i| \le 10^9$ for each valid $i$ - the sum of $N$ over all test cases does not exceed $5 \cdot 10^5$ -----Example Input----- 3 4 1 3 10 7 5 -10 -5 0 5 10 4 2 2 2 10 -----Example Output----- 1 3 5 7 -10 -5 0 5 10 2 2 2 2 -----Explanation----- Example case 1: Rafsan changed the third element from $5$ to $10$. Example case 2: No elements were changed. Example case 3: Rafsan changed the fourth element from $2$ to $10$.

from statistics import mode t=int(input()) for _ in range(t): n=int(input()) l=list(map(int,input().split())) ll=len(l) diff=list() if(ll==4): diff.append(((l[3]-l[0])//3)) for i in range(ll-1): diff.append(l[i+1]-l[i]) x=mode(diff) if(l[0]-l[1]!=x and l[2]-l[1]==x): l[0]=l[1]-x for i in range(ll-1): if(l[i+1]-l[i]!=x): l[i+1]=l[i]+x for i in range(ll): print(l[i],end=" ") print()

train

APPS_structured

Let's say take 2 strings, A and B, and define the similarity of the strings to be the length of the longest prefix common to both strings. For example, the similarity of strings `abc` and `abd` is 2, while the similarity of strings `aaa` and `aaab` is 3. write a function that calculates the sum of similarities of a string S with each of it's **suffixes**. ```python string_suffix('ababaa') => returns 11 string_suffix('abc') => returns 3 ``` Explanation: In the first case, the suffixes of the string are `ababaa`, `babaa`, `abaa`, `baa`, `aa` and `a`. The similarities of each of these strings with the string `ababaa` are 6,0,3,0,1,1 respectively. Thus the answer is 6 + 0 + 3 + 0 + 1 + 1 = 11. For the second case, the answer is simply 3 + 0 + 0 = 3. Note : Each string will have at least one character - no need to check for empty strings :)

string_suffix=lambda s:sum(s[:j-i]==s[i:j] for j in range(1,len(s)+1) for i in range(j))

train

APPS_structured

>When no more interesting kata can be resolved, I just choose to create the new kata, to solve their own, to enjoy the process --myjinxin2015 said # Description: John learns to play poker with his uncle. His uncle told him: Poker to be in accordance with the order of "2 3 4 5 6 7 8 9 10 J Q K A". The same suit should be put together. But his uncle did not tell him the order of the four suits. Give you John's cards and Uncle's cards(two string `john` and `uncle`). Please reference to the order of Uncle's cards, sorting John's cards. # Examples ``` For Python: Suits are defined as S, D, H, C. sort_poker("D6H2S3D5SJCQSKC7D2C5H5H10SA","S2S3S5HJHQHKC8C9C10D4D5D6D7") should return "S3SJSKSAH2H5H10C5C7CQD2D5D6" sort_poke("D6H2S3D5SJCQSKC7D2C5H5H10SA","C8C9C10D4D5D6D7S2S3S5HJHQHK") should return "C5C7CQD2D5D6S3SJSKSAH2H5H10" ```

import re def sort_poker(H, U, OD='2 3 4 5 6 7 8 9 10 J Q K A'.split()): ORDER = re.findall(r'(.)\1*',re.sub(r'[\dJQKA]','', U)) return ''.join(sorted(re.findall(r'[SDHC](?:[23456789JQKA]|10)',H), key=lambda x:(ORDER.index(x[0]), OD.index(x[1:]))))

train

APPS_structured

Polycarp plans to conduct a load testing of its new project Fakebook. He already agreed with his friends that at certain points in time they will send requests to Fakebook. The load testing will last n minutes and in the i-th minute friends will send a_{i} requests. Polycarp plans to test Fakebook under a special kind of load. In case the information about Fakebook gets into the mass media, Polycarp hopes for a monotone increase of the load, followed by a monotone decrease of the interest to the service. Polycarp wants to test this form of load. Your task is to determine how many requests Polycarp must add so that before some moment the load on the server strictly increases and after that moment strictly decreases. Both the increasing part and the decreasing part can be empty (i. e. absent). The decrease should immediately follow the increase. In particular, the load with two equal neigbouring values is unacceptable. For example, if the load is described with one of the arrays [1, 2, 8, 4, 3], [1, 3, 5] or [10], then such load satisfies Polycarp (in each of the cases there is an increasing part, immediately followed with a decreasing part). If the load is described with one of the arrays [1, 2, 2, 1], [2, 1, 2] or [10, 10], then such load does not satisfy Polycarp. Help Polycarp to make the minimum number of additional requests, so that the resulting load satisfies Polycarp. He can make any number of additional requests at any minute from 1 to n. -----Input----- The first line contains a single integer n (1 ≤ n ≤ 100 000) — the duration of the load testing. The second line contains n integers a_1, a_2, ..., a_{n} (1 ≤ a_{i} ≤ 10^9), where a_{i} is the number of requests from friends in the i-th minute of the load testing. -----Output----- Print the minimum number of additional requests from Polycarp that would make the load strictly increasing in the beginning and then strictly decreasing afterwards. -----Examples----- Input 5 1 4 3 2 5 Output 6 Input 5 1 2 2 2 1 Output 1 Input 7 10 20 40 50 70 90 30 Output 0 -----Note----- In the first example Polycarp must make two additional requests in the third minute and four additional requests in the fourth minute. So the resulting load will look like: [1, 4, 5, 6, 5]. In total, Polycarp will make 6 additional requests. In the second example it is enough to make one additional request in the third minute, so the answer is 1. In the third example the load already satisfies all conditions described in the statement, so the answer is 0.

s, l, r = 0, 0, int(input()) - 1 t = list(map(int, input().split())) while 1: while l < r and t[l] < t[l + 1]: l += 1 while l < r and t[r] < t[r - 1]: r -= 1 if l == r: break if t[l] < t[r]: s += t[l] - t[l + 1] + 1 t[l + 1] = t[l] + 1 else: s += t[r] - t[r - 1] + 1 t[r - 1] = t[r] + 1 print(s)

train

APPS_structured

Create a function `close_compare` that accepts 3 parameters: `a`, `b`, and an optional `margin`. The function should return whether `a` is lower than, close to, or higher than `b`. `a` is "close to" `b` if `margin` is higher than or equal to the difference between `a` and `b`. When `a` is lower than `b`, return `-1`. When `a` is higher than `b`, return `1`. When `a` is close to `b`, return `0`. If `margin` is not given, treat it as zero. Example: if `a = 3`, `b = 5` and the `margin = 3`, since `a` and `b` are no more than 3 apart, `close_compare` should return `0`. Otherwise, if instead `margin = 0`, `a` is lower than `b` and `close_compare` should return `-1`. Assume: `margin >= 0` Tip: Some languages have a way to make arguments optional.

def close_compare(a, b, margin=0): return -1 if b-margin>a else a-margin>b

train

APPS_structured

A famous casino is suddenly faced with a sharp decline of their revenues. They decide to offer Texas hold'em also online. Can you help them by writing an algorithm that can rank poker hands? ## Task Create a poker hand that has a method to compare itself to another poker hand: ```python compare_with(self, other_hand) ``` A poker hand has a constructor that accepts a string containing 5 cards: ```python PokerHand("KS 2H 5C JD TD") ``` The characteristics of the string of cards are: * Each card consists of two characters, where * The first character is the value of the card: `2, 3, 4, 5, 6, 7, 8, 9, T(en), J(ack), Q(ueen), K(ing), A(ce)` * The second character represents the suit: `S(pades), H(earts), D(iamonds), C(lubs)` * A space is used as card separator between cards The result of your poker hand compare can be one of these 3 options: ```python [ "Win", "Tie", "Loss" ] ``` ## Notes * Apply the [Texas Hold'em](https://en.wikipedia.org/wiki/Texas_hold_%27em) rules for ranking the cards. * Low aces are **NOT** valid in this kata. * There is no ranking for the suits. If you finished this kata, you might want to continue with [Sortable Poker Hands](https://www.codewars.com/kata/sortable-poker-hands)

from collections import Counter class PokerHand(object): def __init__(self, hand): self.hand = ''.join(hand.split()) def evaluate(self): HIERARCHY = {'highcard':1, 'pair':2, 'two_pairs':3, 'three_of_aKind':4, 'straight':5, 'flush':6, 'full_house':7, 'four_of_aKind':8, 'straight_flush':9, 'royal_flush':10} PRECEDENCE = {'1':1, '2':2, '3':3, '4':4, '5':5, '6':6, '7':7, '8':8, '9':9, 'T':10,'J':11, 'Q':12, 'K':13, 'A':14} value = sorted(PRECEDENCE[x] for x in self.hand[::2]) shape = self.hand[1::2] #royal flush if len(set(shape)) == 1 and value == [10,11,12,13,14]: return HIERARCHY['royal_flush'], value, 'royal_flush' #straight_flush elif len(set(shape)) == 1 and all(abs(value[i] - value[i+1])==1 for i in range(len(value)-1)): return HIERARCHY['straight_flush'], value, 'straight_flush' #four of a kind elif any(value.count(x)==4 for x in set(value)): return HIERARCHY['four_of_aKind'], value, 'four_of_aKind' #full house elif any(value.count(x)==3 for x in set(value)) \ and \ any(value.count(x)==2 for x in set(value)): return HIERARCHY['full_house'], value, 'full_house' #flush elif len(set(shape))==1: return HIERARCHY['flush'], value, 'flush' #straight elif all(abs(value[i] - value[i+1])==1 for i in range(len(value)-1)): return HIERARCHY['straight'], value, 'straight' #three of a kind elif any(value.count(x)==3 for x in set(value)): return HIERARCHY['three_of_aKind'], value, 'three_of_aKind' #two pairs elif Counter(value).most_common(2)[-1][-1] == 2: return HIERARCHY['two_pairs'], value, 'two_pairs' #pair elif any(value.count(x)==2 for x in set(value)): return HIERARCHY['pair'], value, 'pair' #high Card else: return HIERARCHY['highcard'], value, 'highcard' def compare_with(self, other): rank, cards, combo = self.evaluate() other_rank, other_cards, other_combo = other.evaluate() if rank > other_rank: return 'Win' elif rank == other_rank: if cards == other_cards: return 'Tie' elif combo == 'straight_flush' or combo == 'straight': if cards.pop() > other_cards.pop(): return 'Win' else: return 'Loss' elif combo == 'four_of_aKind' or combo == 'full_house': c1, c2 = Counter(cards), Counter(other_cards) if c1.most_common()[0][0] > c2.most_common()[0][0]: return 'Win' elif c1.most_common()[0][0] < c2.most_common()[0][0]: return 'Loss' else: if c1.most_common()[-1][0] > c2.most_common()[-1][0]: return 'Win' else: return 'Loss' elif combo == 'flush': for i in range(4, -1, -1): if cards[i] < other_cards[i]: return 'Loss' else: if cards[i] != other_cards[i]: return 'Win' elif combo == 'three_of_aKind': for i in range(1,-1,-1): if cards[i] < other_cards[i]: return 'Loss' else: if cards[i] != other_cards[i]: return 'Win' elif combo == 'two_pairs' or combo == 'pair': c1,c2 = Counter(cards), Counter(other_cards) sorted_c1 = sorted(c1.most_common(),key=lambda x:(x[1],x)) sorted_c2 = sorted(c2.most_common(),key=lambda x:(x[1],x)) for i in range(len(sorted_c1)-1,-1,-1): if sorted_c1[i][0] < sorted_c2[i][0]: return 'Loss' else: if sorted_c1[i][0] != sorted_c2[i][0]: return 'Win' else: for i in range(4,-1,-1): if cards[i] < other_cards[i]: return 'Loss' else: if cards[i] != other_cards[i]: return 'Win' else: return 'Loss'

train

APPS_structured

Round any given number to the closest 0.5 step I.E. ``` solution(4.2) = 4 solution(4.3) = 4.5 solution(4.6) = 4.5 solution(4.8) = 5 ``` Round **up** if number is as close to previous and next 0.5 steps. ``` solution(4.75) == 5 ```

def solution(n): fint = int(n) diff = n - fint if diff < 0.25: rdiff = 0 if diff >= 0.25 and diff < 0.75: rdiff = 0.5 if diff >= 0.75: rdiff = 1 rounded = rdiff + fint return rounded

train

APPS_structured

You are given a secret message you need to decipher. Here are the things you need to know to decipher it: For each word: - the second and the last letter is switched (e.g. `Hello` becomes `Holle`) - the first letter is replaced by its character code (e.g. `H` becomes `72`) Note: there are no special characters used, only letters and spaces Examples ``` decipherThis('72olle 103doo 100ya'); // 'Hello good day' decipherThis('82yade 115te 103o'); // 'Ready set go' ```

import re def decipher_this(string): #list to save decrypted words decrypted = [] for word in string.split(): #get number in string re_ord = re.match(r'\d+', word).group() #replace number by ascii letter and transform word in a list new_word = list(re.sub(re_ord, chr(int(re_ord)), word)) #swap second and last letter in the word list if len(new_word) > 2: new_word[1], new_word[-1] = new_word[-1], new_word[1] #save the word in the string list decrypted.append(''.join(new_word)) #return the decrypted words list as a string return ' '.join(decrypted)

train

APPS_structured

Watson gives to Sherlock two strings S1 and S2 consisting of uppercase English alphabets. Next he wants Sherlock to build a flower in the following way: He puts both strings perpendicular to each other in such a way that they overlap at the same character. For example, if he has two strings "ABCDEF" and "XXBCZQ", one possible way to make a flower is: Length of petals in the above flower are 2, 2, 3 and 3. A flower's ugliness is sum of absolute difference of adjacent petal lengths i.e. i.e. if adjacent petal lengths are L1, L2, L3, L4, then ugliness of flower is |L1 - L2| + |L2 - L3| + |L3 - L4| + |L4 - L1|. Sherlock wants to find minimum value of ugliness if we consider all possible flower configurations. Note that a configuration is valid even if any of the petal length is 0. -----Input----- First line contains T, number of test cases. Each test case consists of string S1 in one line followed by string S2 in the next line. It is guaranteed that there exists at least one possible way to make a flower. -----Output----- For each test case, output in one line the required answer. -----Constraints----- - 1 ≤ T ≤ 10 - 1 ≤ length(S1), length(S2) ≤ 105 -----Example----- Input: 2 ABCDE XXBCZQ BBB BBBBBB Output: 2 6 -----Explanation----- Test case 1: If we keep the configuration shown in statement, the ugliness is 2, which is minimum possible. Test case 2: One of the best configurations is B B B B B B B B where petal lengths are 1, 3, 1, 2.

for _ in range(eval(input())): S1=input() m1=len(S1)/2 S2=input() m2=len(S2)/2 d1={} d2={} for i in range(len(S1)): c=S1[i] v=abs(m1-i) if c in d1: if v<d1[c][0]: d1[c]=[v,i] else: d1[c]=[v,i] for i in range(len(S2)): c=S2[i] v=abs(m2-i) if c in d2: if v<d2[c][0]: d2[c]=[v,i] else: d2[c]=[v,i] mini=999999999999999999999999999999999 for i in d1: if i in d2: L1=d1[i][1] L3=len(S1)-L1-1 L2=d2[i][1] L4=len(S2)-L2-1 v=abs(L1-L2)+abs(L2-L3)+abs(L3-L4)+abs(L4-L1) if v<mini: mini=v print(mini)

train

APPS_structured

Math hasn't always been your best subject, and these programming symbols always trip you up! I mean, does `**` mean *"Times, Times"* or *"To the power of"*? Luckily, you can create the function `expression_out()` to write out the expressions for you! The operators you'll need to use are: ```python { '+': 'Plus ', '-': 'Minus ', '*': 'Times ', '/': 'Divided By ', '**': 'To The Power Of ', '=': 'Equals ', '!=': 'Does Not Equal ' } ``` These values will be stored in the preloaded dictionary `OPERATORS` just as shown above. But keep in mind: INVALID operators will also be tested, to which you should return `"That's not an operator!"` And all of the numbers will be `1` to`10`! Isn't that nice! Here's a few examples to clarify: ```python expression_out("4 ** 9") == "Four To The Power Of Nine" expression_out("10 - 5") == "Ten Minus Five" expression_out("2 = 2") == "Two Equals Two" ``` Good luck!

op = {'+': 'Plus ','-': 'Minus ','*': 'Times ', '/': 'Divided By ', '**': 'To The Power Of ', '=': 'Equals ', '!=': 'Does Not Equal '} num = {'1': 'One', '2': 'Two', '3': 'Three', '4': 'Four', '5': 'Five', '6': 'Six', '7':'Seven', '8': 'Eight', '9': 'Nine', '10': 'Ten'} def expression_out(e): a, b, c = e.split() try : return num[a]+' '+op[b]+num[c] except : return 'That\'s not an operator!'

train

APPS_structured

Chef Jessie has a lot of recipes with her (N). She often remembered the starting few characters of the recipe and forgot the rest. As all the great chefs do, Jessie also numbered the recipes depending on the priority. So, given the list of recipes along with their priorities answer Jessie’s queries. Jessie’s queries are as follows: She gives you the first few characters of a recipe; you have to print the complete recipe with the highest priority. Note: Every recipe has a unique priority -----Input----- First line contains an integer N - the number of recipes. Followed by N strings Si along with an integer each Vi. Si stands for the recipe and Vi for the priority. It is followed by an integer Q - the number of queries. Followed by Q strings Qi. Each string Si, Qi contain only lowercase Latin alphabets ('a' - 'z') and '-'. -----Output----- Q – lines, each contain the answer for each of the query. If for a query no recipe matches print "NO". (Without quotes) Constraints: 0 <= N <= 1000 0 <= Q <= 1000 -10^9 <= Vi <= 10^9 1 <= |Si| <= 1000 (length of Si) 1 <= |Qi| <= 1000 (length of Qi) -----Example----- Input: 4 flour-with-eggs 100 chicken-ham -10 flour-without-eggs 200 fish-with-pepper 1100 6 f flour-with flour-with- c fl chik Output: fish-with-pepper flour-without-eggs flour-with-eggs chicken-ham flour-without-eggs NO

# cook your dish here n=int(input()) s=[] a=[] for i in range(n): si,vi=input().split() vi=int(vi) a.append(vi) s.append(si) #print(s) #print(a) q=int(input()) for j in range(0,q): qi=input() ma=-20000000009 pos=-1 for k in range(0,n): if s[k].startswith(qi): #print(s[k]) if a[k]>ma: #print(a[k]) pos=k ma=a[k] if pos==-1: print("NO") else: print(s[pos])

train

APPS_structured

While doing some spring cleaning, Daniel found an old calculator that he loves so much. However, it seems like it is broken. When he tries to compute $1 + 3$ using the calculator, he gets $2$ instead of $4$. But when he tries computing $1 + 4$, he gets the correct answer, $5$. Puzzled by this mystery, he opened up his calculator and found the answer to the riddle: the full adders became half adders! So, when he tries to compute the sum $a + b$ using the calculator, he instead gets the xorsum $a \oplus b$ (read the definition by the link: https://en.wikipedia.org/wiki/Exclusive_or). As he saw earlier, the calculator sometimes gives the correct answer. And so, he wonders, given integers $l$ and $r$, how many pairs of integers $(a, b)$ satisfy the following conditions: $$a + b = a \oplus b$$ $$l \leq a \leq r$$ $$l \leq b \leq r$$ However, Daniel the Barman is going to the bar and will return in two hours. He tells you to solve the problem before he returns, or else you will have to enjoy being blocked. -----Input----- The first line contains a single integer $t$ ($1 \le t \le 100$) — the number of testcases. Then, $t$ lines follow, each containing two space-separated integers $l$ and $r$ ($0 \le l \le r \le 10^9$). -----Output----- Print $t$ integers, the $i$-th integer should be the answer to the $i$-th testcase. -----Example----- Input 3 1 4 323 323 1 1000000 Output 8 0 3439863766 -----Note----- $a \oplus b$ denotes the bitwise XOR of $a$ and $b$. For the first testcase, the pairs are: $(1, 2)$, $(1, 4)$, $(2, 1)$, $(2, 4)$, $(3, 4)$, $(4, 1)$, $(4, 2)$, and $(4, 3)$.

def solve(L, R): res = 0 for i in range(32): for j in range(32): l = (L >> i) << i r = (R >> j) << j #print(l, r) if l>>i&1==0 or r>>j&1==0: continue l -= 1<<i r -= 1<<j if l & r: continue lr = l ^ r ma = max(i, j) mi = min(i, j) mask = (1<<ma)-1 p = bin(lr&mask).count("1") ip = ma - mi - p res += 3**mi * 2**ip #print(l, r, mi, ip, 3**mi * 2**ip) return res T = int(input()) for _ in range(T): l, r = list(map(int, input().split())) print(solve(r+1, r+1) + solve(l, l) - solve(l, r+1) * 2)

train

APPS_structured

Every number may be factored in prime factors. For example, the number 18 may be factored by its prime factors ``` 2 ``` and ```3``` ``` 18 = 2 . 3 . 3 = 2 . 3² ``` The sum of the prime factors of 18 is ```2 + 3 + 3 = 8``` But some numbers like 70 are divisible by the sum of its prime factors: ``` 70 = 2 . 5 . 7 # sum of prime factors = 2 + 5 + 7 = 14 and 70 is a multiple of 14 ``` Of course that primes would fulfill this property, but is obvious, because the prime decomposition of a number, is the number itself and every number is divisible by iself. That is why we will discard every prime number in the results We are interested in collect the integer positive numbers (non primes) that have this property in a certain range ```[a, b]``` (inclusive). Make the function ```mult_primefactor_sum()```, that receives the values ```a```, ```b``` as limits of the range ```[a, b]``` and ```a < b``` and outputs the sorted list of these numbers. Let's see some cases: ```python mult_primefactor_sum(10, 100) == [16, 27, 30, 60, 70, 72, 84] mult_primefactor_sum(1, 60) == [1, 4, 16, 27, 30, 60] ```

def primes(n): primfac = [] d = 2 while d*d <= n: while (n % d) == 0: primfac.append(d) n //= d d += 1 if n > 1: primfac.append(n) return primfac def mult_primefactor_sum(a, b): l = [] for i in range(a, b+1): factors = primes(i) if i>sum(factors) and not i%sum(factors): l.append(i) return l

train

APPS_structured

In the drawing below we have a part of the Pascal's triangle, lines are numbered from **zero** (top). The left diagonal in pale blue with only numbers equal to 1 is diagonal **zero**, then in dark green (1, 2, 3, 4, 5, 6, 7) is diagonal 1, then in pale green (1, 3, 6, 10, 15, 21) is diagonal 2 and so on. We want to calculate the sum of the binomial coefficients on a given diagonal. The sum on diagonal 0 is 8 (we'll write it S(7, 0), 7 is the number of the line where we start, 0 is the number of the diagonal). In the same way S(7, 1) is 28, S(7, 2) is 56. Can you write a program which calculate S(n, p) where n is the line where we start and p is the number of the diagonal? The function will take n and p (with: `n >= p >= 0`) as parameters and will return the sum. ## Examples: ``` diagonal(20, 3) => 5985 diagonal(20, 4) => 20349 ``` ## Hint: When following a diagonal from top to bottom have a look at the numbers on the diagonal at its right. ## Ref: http://mathworld.wolfram.com/BinomialCoefficient.html ![alternative text](http://i.imgur.com/eUGaNvIm.jpg)

from functools import reduce def comb(n, p): a,b = n-p, p return reduce(lambda x, y : x*y, range(max(a,b)+1,n+1))//reduce(lambda x, y : x*y, range(1,min(a,b)+1)) def diagonal(n, p): return comb(n+1, p+1)

train

APPS_structured

This time no story, no theory. The examples below show you how to write function `accum`: **Examples:** ``` accum("abcd") -> "A-Bb-Ccc-Dddd" accum("RqaEzty") -> "R-Qq-Aaa-Eeee-Zzzzz-Tttttt-Yyyyyyy" accum("cwAt") -> "C-Ww-Aaa-Tttt" ``` The parameter of accum is a string which includes only letters from `a..z` and `A..Z`.

def accum(s): str = "" for i in range(0, len(s)): str += s[i].upper() str += s[i].lower()*i if i != len(s)-1: str += "-" return str

train

APPS_structured

The `depth` of an integer `n` is defined to be how many multiples of `n` it is necessary to compute before all `10` digits have appeared at least once in some multiple. example: ``` let see n=42 Multiple value digits comment 42*1 42 2,4 42*2 84 8 4 existed 42*3 126 1,6 2 existed 42*4 168 - all existed 42*5 210 0 2,1 existed 42*6 252 5 2 existed 42*7 294 9 2,4 existed 42*8 336 3 6 existed 42*9 378 7 3,8 existed ``` Looking at the above table under `digits` column you can find all the digits from `0` to `9`, Hence it required `9` multiples of `42` to get all the digits. So the depth of `42` is `9`. Write a function named `computeDepth` which computes the depth of its integer argument.Only positive numbers greater than zero will be passed as an input.

def compute_depth(n): i = 0 digits = set() while len(digits) < 10: i += 1 digits.update(str(n * i)) return i

train

APPS_structured

Recently you have bought a snow walking robot and brought it home. Suppose your home is a cell $(0, 0)$ on an infinite grid. You also have the sequence of instructions of this robot. It is written as the string $s$ consisting of characters 'L', 'R', 'U' and 'D'. If the robot is in the cell $(x, y)$ right now, he can move to one of the adjacent cells (depending on the current instruction). If the current instruction is 'L', then the robot can move to the left to $(x - 1, y)$; if the current instruction is 'R', then the robot can move to the right to $(x + 1, y)$; if the current instruction is 'U', then the robot can move to the top to $(x, y + 1)$; if the current instruction is 'D', then the robot can move to the bottom to $(x, y - 1)$. You've noticed the warning on the last page of the manual: if the robot visits some cell (except $(0, 0)$) twice then it breaks. So the sequence of instructions is valid if the robot starts in the cell $(0, 0)$, performs the given instructions, visits no cell other than $(0, 0)$ two or more times and ends the path in the cell $(0, 0)$. Also cell $(0, 0)$ should be visited at most two times: at the beginning and at the end (if the path is empty then it is visited only once). For example, the following sequences of instructions are considered valid: "UD", "RL", "UUURULLDDDDLDDRRUU", and the following are considered invalid: "U" (the endpoint is not $(0, 0)$) and "UUDD" (the cell $(0, 1)$ is visited twice). The initial sequence of instructions, however, might be not valid. You don't want your robot to break so you decided to reprogram it in the following way: you will remove some (possibly, all or none) instructions from the initial sequence of instructions, then rearrange the remaining instructions as you wish and turn on your robot to move. Your task is to remove as few instructions from the initial sequence as possible and rearrange the remaining ones so that the sequence is valid. Report the valid sequence of the maximum length you can obtain. Note that you can choose any order of remaining instructions (you don't need to minimize the number of swaps or any other similar metric). You have to answer $q$ independent test cases. -----Input----- The first line of the input contains one integer $q$ ($1 \le q \le 2 \cdot 10^4$) — the number of test cases. The next $q$ lines contain test cases. The $i$-th test case is given as the string $s$ consisting of at least $1$ and no more than $10^5$ characters 'L', 'R', 'U' and 'D' — the initial sequence of instructions. It is guaranteed that the sum of $|s|$ (where $|s|$ is the length of $s$) does not exceed $10^5$ over all test cases ($\sum |s| \le 10^5$). -----Output----- For each test case print the answer on it. In the first line print the maximum number of remaining instructions. In the second line print the valid sequence of remaining instructions $t$ the robot has to perform. The moves are performed from left to right in the order of the printed sequence. If there are several answers, you can print any. If the answer is $0$, you are allowed to print an empty line (but you can don't print it). -----Example----- Input 6 LRU DURLDRUDRULRDURDDL LRUDDLRUDRUL LLLLRRRR URDUR LLL Output 2 LR 14 RUURDDDDLLLUUR 12 ULDDDRRRUULL 2 LR 2 UD 0 -----Note----- There are only two possible answers in the first test case: "LR" and "RL". The picture corresponding to the second test case: [Image] Note that the direction of traverse does not matter Another correct answer to the third test case: "URDDLLLUURDR".

t=int(input()) for nt in range(t): s=input() l,r,u,d=0,0,0,0 for i in s: if i=="L": l+=1 elif i=="R": r+=1 elif i=="U": u+=1 else: d+=1 if l!=0 and r!=0 and u!=0 and d!=0: if l==r and u==d: print (len(s)) for i in range(l): print ("L",end="") for i in range(u): print ("U",end="") for i in range(l): print ("R",end="") for i in range(d): print ("D",end="") else: if l==r: print (len(s)-abs(u-d)) for i in range(l): print ("L",end="") for i in range(min(d,u)): print ("U",end="") for i in range(l): print ("R",end="") for i in range(min(d,u)): print ("D",end="") else: print (len(s)-(abs(u-d)+abs(l-r))) for i in range(min(l,r)): print ("L",end="") for i in range(min(d,u)): print ("U",end="") for i in range(min(l,r)): print ("R",end="") for i in range(min(d,u)): print ("D",end="") print () else: if (l==0 or r==0) and (u!=0 and d!=0): print (2) print ("UD") elif (u==0 or d==0) and (l!=0 and r!=0): print (2) print ("LR") else: print (0) print ()

train

APPS_structured

In a country called Chef Land, there was a lot of monetary fraud, so Chefu, the head of the country, decided to choose new denominations of the local currency ― all even-valued coins up to an integer $N$ should exist. After a few days, a citizen complained that there was no way to create an odd value, so Chefu decided that he should also introduce coins with value $1$. Formally, you are given an integer $N$; for $v = 1$ and each even positive integer $v \le N$, coins with value $v$ exist. You are also given an integer $S$. To handle transactions quickly, find the minimum number of coins needed to pay a price $S$. -----Input----- - The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows. - The first and only line of each test case contains two space-separated integers $S$ and $N$. -----Output----- For each test case, print a single line containing one integer ― the minimum number of coins. -----Constraints----- - $1 \le T \le 10,000$ - $1 \le S \le 10^9$ - $2 \le N \le 10^9$ - $N$ is even -----Subtasks----- Subtask #1 (100 points): original constraints -----Example Input----- 4 2 2 1 14 30 10 31 4 -----Example Output----- 1 1 3 9 -----Explanation----- Example case 1: One coin with value $2$ is sufficient. Example case 2: We need to use one coin with value $1$. Example case 3: We need $3$ coins, each with value $10$. Example case 4: We can use seven coins with value $4$, one coin with value $2$ and one coin with value $1$.

t = int(input()) for _ in range(t): s,n = map(int, input().split()) if s<n: if s==1: coins = 1 elif s%2==0: coins = 1 else: coins = 2 else: coins = s//n r = s%n if r==1: coins = coins + 1 elif r!=0 and r%2==0: coins = coins + 1 elif r%2!=0: coins = coins + 2 print(coins)

train

APPS_structured

A policeman wants to catch a thief. Both the policeman and the thief can only move on a line on integer coordinates between $0$ and $N$ (inclusive). Initially, the policeman is at a coordinate $x$ and the thief is at a coordinate $y$. During each second, each of them must move to the left or right (not necessarily both in the same direction) by distance $\textbf{exactly}$ equal to $K$. No one may go to the left of the coordinate $0$ or to the right of $N$. Both the policeman and the thief move simultaneously and they cannot meet while moving, only at the end of each second. Will the policeman be able to catch the thief if they both move optimally? The thief is caught as soon as the policeman and thief meet at the same position at the same time. -----Input----- - The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows. - The first and only line of each test case contains four space-separated integers $x$, $y$, $K$ and $N$. -----Output----- For each test case, print a single line containing the string "Yes" if the thief can be caught or "No" if the thief cannot be caught (without quotes). -----Constraints----- - $1 \le T \le 1,000$ - $1 \le N \le 10^9$ - $1 \le K \le N$ - $0 \le x, y \le N$ - $x \neq y$ -----Example Input----- 5 0 1 1 1 1 4 1 5 4 2 1 7 3 7 2 10 8 2 3 15 -----Example Output----- No No Yes Yes Yes -----Explanation----- Example case 1: The policeman is at $0$ and the thief is at $1$. After the $1$-st second, the policeman is at $1$ and the thief is at $0$. After the next second, the policeman is again at $0$ and the thief at $1$. They cannot end up at the same coordinate.

# cook your dish here for _ in range(int(input())): x,y,k,n=list(map(int,input().split())) diff=abs(x-y) if (diff%(2*k))==0: print("Yes") else: print("No")

train

APPS_structured

The set [1,2,3,...,n] contains a total of n! unique permutations. By listing and labeling all of the permutations in order, we get the following sequence for n = 3: "123" "132" "213" "231" "312" "321" Given n and k, return the kth permutation sequence. Note: Given n will be between 1 and 9 inclusive. Given k will be between 1 and n! inclusive. Example 1: Input: n = 3, k = 3 Output: "213" Example 2: Input: n = 4, k = 9 Output: "2314"

class Solution: def getPermutation(self, n, k): """ :type n: int :type k: int :rtype: str """ import math nums = list(range(1, n+1)) ans = '' k = k - 1 #make sure the divmod result fail in [0, n-1] instead of [1, n] while n > 0: n = n - 1 index, k = divmod(k, math.factorial(n)) ans = ans + str(nums[index]) nums.remove(nums[index]) return ans

train

APPS_structured

We are given the root node of a maximum tree: a tree where every node has a value greater than any other value in its subtree. Just as in the previous problem, the given tree was constructed from an list A (root = Construct(A)) recursively with the following Construct(A) routine: If A is empty, return null. Otherwise, let A[i] be the largest element of A. Create a root node with value A[i]. The left child of root will be Construct([A[0], A[1], ..., A[i-1]]) The right child of root will be Construct([A[i+1], A[i+2], ..., A[A.length - 1]]) Return root. Note that we were not given A directly, only a root node root = Construct(A). Suppose B is a copy of A with the value val appended to it. It is guaranteed that B has unique values. Return Construct(B). Example 1: Input: root = [4,1,3,null,null,2], val = 5 Output: [5,4,null,1,3,null,null,2] Explanation: A = [1,4,2,3], B = [1,4,2,3,5] Example 2: Input: root = [5,2,4,null,1], val = 3 Output: [5,2,4,null,1,null,3] Explanation: A = [2,1,5,4], B = [2,1,5,4,3] Example 3: Input: root = [5,2,3,null,1], val = 4 Output: [5,2,4,null,1,3] Explanation: A = [2,1,5,3], B = [2,1,5,3,4] Constraints: 1 <= B.length <= 100

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution: def insertIntoMaxTree(self, root: TreeNode, val: int) -> TreeNode: if root is None: return TreeNode(val) elif val > root.val: n = TreeNode(val) n.left = root return n else: n = root p = None while n is not None and val < n.val: n, p = n.right, n m = TreeNode(val) p.right = m m.left = n return root

train

APPS_structured

It's year 2018 and it's Christmas time! Before going for vacations, students of Hogwarts School of Witchcraft and Wizardry had their end semester exams. $N$ students attended the semester exam. Once the exam was over, their results were displayed as either "Pass" or "Fail" behind their magic jacket which they wore. A student cannot see his/her result but can see everyone else's results. Each of $N$ students count the number of passed students they can see. Given the number of "Pass" verdicts that each of the $N$ students counted, we have to figure out conclusively, the number of students who failed, or report that there is some inconsistency or that we cannot be sure. -----Input:----- - First line will contain $T$, number of testcases. Then the testcases follow. - The first line of each test case will contain $N$, representing the number of students who attended the exam. - Next line contains $N$ spaced integers representing the number of "Pass" counted by each of the $N$ students. -----Output:----- - For each test case, output the answer in a single line. - If the counts reported by the students are not consistent with each other or if it's not possible to predict the number of failed students from the given input, then print -1. -----Constraints----- - $1 \leq T \leq 50$ - $1 \leq N \leq 10^{5}$ - $0 \leq$ Count given by each Student $\leq 10^{5}$ -----Sample Input:----- 1 4 3 2 2 2 -----Sample Output:----- 1 -----EXPLANATION:----- There are 4 students, and they counted the number of passed students as 3,2,2,2. The first student can see that all others have passed, and all other students can see only 2 students who have passed. Hence, the first student must have failed, and others have all passed. Hence, the answer is 1.

# cook your dish here for _ in range(int(input())): n=int(input());l=[int(i) for i in input().split()] if n==1:print(-1);continue if len(set(l))==1: if l[0]==0:print(n) elif l[0]==n-1:print(0) else:print(-1) continue if len(set(l))>2 or max(l)-min(l)>1:print(-1);continue a,b = l.count(min(l)),l.count(max(l)) print(b) if max(l)==a else print(-1)

train

APPS_structured

## Check Digits Some numbers are more important to get right during data entry than others: a common example is product codes. To reduce the possibility of mistakes, product codes can be crafted in such a way that simple errors are detected. This is done by calculating a single-digit value based on the product number, and then appending that digit to the product number to arrive at the product code. When the product code is checked, the check digit value is stripped off and recalculated. If the supplied value does not match the recalculated value, the product code is rejected. A simple scheme for generating self-check digits, described here, is called Modulus 11 Self-Check. ## Calculation method Each digit in the product number is assigned a multiplication factor. The factors are assigned ***from right to left***, starting at `2` and counting up. For numbers longer than six digits, the factors restart at `2` after `7` is reached. The product of each digit and its factor is calculated, and the products summed. For example: ```python digit : 1 6 7 7 0 3 6 2 5 factor : 4 3 2 7 6 5 4 3 2 --- --- --- --- --- --- --- --- --- 4 + 18 + 14 + 49 + 0 + 15 + 24 + 6 + 10 = 140 ``` Then the sum of the products is divided by the prime number `11`. The remainder is inspected, and: * if the remainder is `0`, the check digit is also `0` * if the remainder is `1`, the check digit is replaced by an uppercase `X` * for all others, the remainder is subtracted from `11` The result is the **check digit**. ## Your task Your task is to implement this algorithm and return the input number with the correct check digit appended. ## Examples ```python input: "036532" product sum = 2*2 + 3*3 + 5*4 + 6*5 + 3*6 + 0*7 = 81 remainder = 81 mod 11 = 4 check digit = 11 - 4 = 7 output: "0365327" ```

def add_check_digit(n): s = sum(int(n[-1 - i])*(i % 6 + 2) for i in range(len(n))) return n + [str(11-s%11),['X','0'][s%11==0]][s%11<2]

train

APPS_structured

# Base64 Numeric Translator Our standard numbering system is (Base 10). That includes 0 through 9. Binary is (Base 2), only 1’s and 0’s. And Hexadecimal is (Base 16) (0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F). A hexadecimal “F” has a (Base 10) value of 15. (Base 64) has 64 individual characters which translate in value in (Base 10) from between 0 to 63. ####Write a method that will convert a string from (Base 64) to it's (Base 10) integer value. The (Base 64) characters from least to greatest will be ``` ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/ ``` Where 'A' is equal to 0 and '/' is equal to 63. Just as in standard (Base 10) when you get to the highest individual integer 9 the next number adds an additional place and starts at the beginning 10; so also (Base 64) when you get to the 63rd digit '/' and the next number adds an additional place and starts at the beginning "BA". Example: ``` base64_to_base10("/") # => 63 base64_to_base10("BA") # => 64 base64_to_base10("BB") # => 65 base64_to_base10("BC") # => 66 ``` Write a method `base64_to_base10` that will take a string (Base 64) number and output it's (Base 10) value as an integer.

def base64_to_base10(s): n = 0 for c in s: n = n * 64 + 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'.index(c) return n

train

APPS_structured

Here you will create the classic [Pascal's triangle](https://en.wikipedia.org/wiki/Pascal%27s_triangle). Your function will be passed the depth of the triangle and you code has to return the corresponding pascal triangle up to that depth. The triangle should be returned as a nested array. for example: ```python pascal(5) # should return [[1], [1,1], [1,2,1], [1,3,3,1], [1,4,6,4,1]] ``` To build the triangle, start with a single 1 at the top, for each number in the next row you just take the two numbers above it and add them together (except for the edges, which are all `1`), e.g.: ``` [1] [1 1] [1 2 1] [1 3 3 1] ```

def pascal(p): triangle = [[1]] for _ in range(p - 1): to_sum = list(zip([0] + triangle[-1], triangle[-1] + [0])) triangle.append(list(map(sum, to_sum))) return triangle

train

APPS_structured

You were given a string of integer temperature values. Create a function `close_to_zero(t)` and return the closest value to 0 or `0` if the string is empty. If two numbers are equally close to zero, return the positive integer.

def close_to_zero(t): return sorted(map(int, t.split()), key=lambda i: (abs(i), -i))[0] if t else 0

train

APPS_structured

# Task Imagine a white rectangular grid of `n` rows and `m` columns divided into two parts by a diagonal line running from the upper left to the lower right corner. Now let's paint the grid in two colors according to the following rules: ``` A cell is painted black if it has at least one point in common with the diagonal; Otherwise, a cell is painted white. ``` Count the number of cells painted black. # Example For n = 3 and m = 4, the output should be `6` There are 6 cells that have at least one common point with the diagonal and therefore are painted black. For n = 3 and m = 3, the output should be `7` 7 cells have at least one common point with the diagonal and are painted black. # Input/Output - `[input]` integer `n` The number of rows. Constraints: 1 ≤ n ≤ 10000. - `[input]` integer `m` The number of columns. Constraints: 1 ≤ m ≤ 10000. - `[output]` an integer The number of black cells.

from fractions import gcd def count_black_cells(h, w): return h + w + gcd(h, w) - 2

train

APPS_structured

The Siruseri amusement park has a new attraction. It consists of a rectangular array of discs. Each disc is divided into four equal sectors and the four sectors are coloured with the colours Red, Blue, Green and Yellow (in some order). The ordering may be different in different discs. Here is a possible arrangment of the discs: You start at the top left disc. Your task is to walk down to the bottom right disc. In each step, you can rotate the current disc by $90$ degrees in the clockwise direction or move to a neighbouring disc. However, you can move to a neighbouring disc only if adjacent sectors of these two discs have the same colour. For example, in the figure above, you can move from the disc at position ($1$, $1$) to either of its neighbours. However, from the disc at position ($1$, $2$) you can only move to the disc at position ($1$, $1$). If you wish to move from ($1$, $2$) to ($1$, $3$) then you would have to rotate this disc three times so that the colour (red) on the adjacent sectors are the same. For each rotate move, a penalty point is added to the score. The aim is to reach the bottom right with as few penalty points as possible. For example, in the arrangement described in the above figure, the best possible score is $2$, corresponding to the following path: Move from ($1$, $1$) to ($2$, $1$). Move from ($2$, $1$) to ($2$, $2$). Rotate. Rotate. Move from ($2$, $2$) to ($2$, $3$). Move from ($2$, $3$) to ($1$, $3$). Move from ($1$, $3$) to ($1$, $4$). Finally, move from ($1$, $4$) to ($2$, $4$). Your task is to determine the minimum number of penalty points required to go from the top left disc to the bottom right disc for the given arrangement of discs. -----Input:----- The first line contains two integers $M$ and $N$. $M$ is the number of rows and $N$ is the number of columns in the given arrangment. This is followed by $M \times N$ lines of input. Lines $2$ to $N+1$, describe the colours on the discs on the first row, Lines $N+2$ to $2 \cdot N+1$ describe the colours on discs in the second row and so on. Each of these lines contain a permutation of the set {R, G, B, Y} giving the colours in the top, right, bottom and left sectors in that order. -----Output:----- A single integer on a single line indicating the minimum number of penalty points required to go from the top left disc to the bottom right disc for the given arrangement of discs. -----Constraints:----- - In $80 \%$ of the input, $1 \leq M,N \leq 60$. - In all the inputs $1 \leq M,N \leq 1000$. -----Sample Input----- 2 4 G Y B R B G R Y G Y B R G R B Y B Y G R G B R Y B R G Y B R G Y -----Sample Output----- 2

from bisect import insort class disk: def __init__(self): self.U = '' self.D = '' self.L = '' self.R = '' m, n = map(int,input().split()) adj = [[] for _ in range(m*n)] grid = [[disk() for _ in range(n)] for _ in range(m)] for i in range(m): for j in range(n): grid[i][j].U,grid[i][j].R,grid[i][j].D,grid[i][j].L = input().split() for i in range(m): for j in range(n): if (j!=0): if (grid[i][j].R == grid[i][j-1].R): dist = 2 if (grid[i][j].U == grid[i][j-1].R): dist = 3 if (grid[i][j].L == grid[i][j-1].R): dist = 0 if (grid[i][j].D == grid[i][j-1].R): dist = 1 adj[i*n + j].append((dist, i*n + j - 1)) if (j!=n-1): if (grid[i][j].R == grid[i][j+1].L): dist = 0 if (grid[i][j].U == grid[i][j+1].L): dist = 1 if (grid[i][j].L == grid[i][j+1].L): dist = 2 if (grid[i][j].D == grid[i][j+1].L): dist = 3 adj[i*n + j].append((dist, i*n + j + 1)) if (i!=0): if (grid[i][j].R == grid[i-1][j].D): dist = 3 if (grid[i][j].U == grid[i-1][j].D): dist = 0 if (grid[i][j].L == grid[i-1][j].D): dist = 1 if (grid[i][j].D == grid[i-1][j].D): dist = 2 adj[i*n + j].append((dist, i*n + j - n)) if (i!=m-1): if (grid[i][j].R == grid[i+1][j].U): dist = 1 if (grid[i][j].U == grid[i+1][j].U): dist = 2 if (grid[i][j].L == grid[i+1][j].U): dist = 3 if (grid[i][j].D == grid[i+1][j].U): dist = 0 adj[i*n + j].append((dist, i*n + j + n)) q = [] q.append((0,0)) dists = [2147483647 for _ in range(m*n)] visited = [False for _ in range(m*n)] dists[0] = 0 while q: cur = q[-1] q.pop() if visited[cur[1]] == False: visited[cur[1]] = True dists[cur[1]] = -1*cur[0] for i in range(len(adj[cur[1]])): to = adj[cur[1]][i][1] dis = adj[cur[1]][i][0] if (not visited[to] and dists[cur[1]] + dis < dists[to]): insort(q,(-1*(dists[cur[1]] + dis),to)) print(dists[m*n - 1])

train

APPS_structured

In this kata you have to create all permutations of an input string and remove duplicates, if present. This means, you have to shuffle all letters from the input in all possible orders. Examples: ```python permutations('a'); # ['a'] permutations('ab'); # ['ab', 'ba'] permutations('aabb'); # ['aabb', 'abab', 'abba', 'baab', 'baba', 'bbaa'] ``` The order of the permutations doesn't matter.

def permutations(string): if len(string) == 1: return set(string) first = string[0] rest = permutations(string[1:]) result = set() for i in range(0, len(string)): for p in rest: result.add(p[0:i] + first + p[i:]) return result

train

APPS_structured

Take 2 strings `s1` and `s2` including only letters from `a`to `z`. Return a new **sorted** string, the longest possible, containing distinct letters, - each taken only once - coming from s1 or s2. # Examples: ``` a = "xyaabbbccccdefww" b = "xxxxyyyyabklmopq" longest(a, b) -> "abcdefklmopqwxy" a = "abcdefghijklmnopqrstuvwxyz" longest(a, a) -> "abcdefghijklmnopqrstuvwxyz" ```

def longest(s1, s2): letters_count = [0] * 26 for letter in s1: letters_count[ord(letter) - 97] += 1 for letter in s2: letters_count[ord(letter) - 97] += 1 result = [] for i in range(26): if letters_count[i] > 0: result.append(chr(i+97)) return ''.join(result)

train

APPS_structured

Implement a function that returns the minimal and the maximal value of a list (in this order).

def get_min_max(seq): max = seq[0] min = seq[0] for a in seq: if a > max: max = a if a < min: min = a return min,max

train

APPS_structured

Given a string s, write a method (function) that will return true if its a valid single integer or floating number or false if its not. Valid examples, should return true: should return false:

def isDigit(st): try: if int(st.strip())==0 or int(st.strip()): return True except ValueError: try: if float(st.strip()) or float(st.strip())==0.0: return True except ValueError: return False

train

APPS_structured

Consider X as the aleatory variable that count the number of letters in a word. Write a function that, give in input an array of words (strings), calculate the variance of X. Max decimal of the variance : 4. Some wiki: Variance , Aleatory variable Example: Consider "Hello" and "World": X is { 5 } with P(X = 5) = 1 beacuse the two words has the same length. So E[X] = 5 x 1 = 5 and the standard formula for variance is E[(X - u)^2] so 1 x (5-5)^2 = 0 or you can calculate with the other formula E[X^2] - E[X]^2 = 5^2 x 1 - 5^2 = 0 Consider "Hi" and "World": X is { 2, 5 } with P(X = 5) = 1/2 and P(X = 2) = 1/2. So E[X] = 5 x 1/2 + 2 x 1/2 = 3.5 and the standard formula for variance is E[(X - u)^2] so 1/2 x (2-3.5)^2 + 1/2 x (5 - 3.5)^2 = 2.25 or you can calculate with the other formula E[X^2] - E[X]^2 = (5^2 x 1/2 + 2^2 x 1/2) - 3.5^2 = 2.25

def variance(array): nums = list(map(len, array)) length = float(len(nums)) average = sum(nums) / length return round(sum((average - a) ** 2 for a in nums) / length, 4)

train

APPS_structured

Two players play a turn based game on a binary tree. We are given the root of this binary tree, and the number of nodes n in the tree. n is odd, and each node has a distinct value from 1 to n. Initially, the first player names a value x with 1 <= x <= n, and the second player names a value y with 1 <= y <= n and y != x. The first player colors the node with value x red, and the second player colors the node with value y blue. Then, the players take turns starting with the first player. In each turn, that player chooses a node of their color (red if player 1, blue if player 2) and colors an uncolored neighbor of the chosen node (either the left child, right child, or parent of the chosen node.) If (and only if) a player cannot choose such a node in this way, they must pass their turn. If both players pass their turn, the game ends, and the winner is the player that colored more nodes. You are the second player. If it is possible to choose such a y to ensure you win the game, return true. If it is not possible, return false. Example 1: Input: root = [1,2,3,4,5,6,7,8,9,10,11], n = 11, x = 3 Output: true Explanation: The second player can choose the node with value 2. Constraints: root is the root of a binary tree with n nodes and distinct node values from 1 to n. n is odd. 1 <= x <= n <= 100

# Definition for a binary tree node. # class TreeNode: # def __init__(self, val=0, left=None, right=None): # self.val = val # self.left = left # self.right = right class Solution: def btreeGameWinningMove(self, root: TreeNode, n: int, x: int) -> bool: def count(node): if not node: return 0 return 1 + count(node.left) + count(node.right) xNode = [0, 0] def process(node): if node: if node.val == x: xNode[0] = count(node.left) xNode[1] = count(node.right) else: process(node.left) process(node.right) return process(root) player2 = max(xNode[0], xNode[1], n - (xNode[0] + xNode[1] + 1)) # the maximum nodes I can color return player2 > n // 2

train

APPS_structured

Acacius is studying strings theory. Today he came with the following problem. You are given a string $s$ of length $n$ consisting of lowercase English letters and question marks. It is possible to replace question marks with lowercase English letters in such a way that a string "abacaba" occurs as a substring in a resulting string exactly once? Each question mark should be replaced with exactly one lowercase English letter. For example, string "a?b?c" can be transformed into strings "aabbc" and "azbzc", but can't be transformed into strings "aabc", "a?bbc" and "babbc". Occurrence of a string $t$ of length $m$ in the string $s$ of length $n$ as a substring is a index $i$ ($1 \leq i \leq n - m + 1$) such that string $s[i..i+m-1]$ consisting of $m$ consecutive symbols of $s$ starting from $i$-th equals to string $t$. For example string "ababa" has two occurrences of a string "aba" as a substring with $i = 1$ and $i = 3$, but there are no occurrences of a string "aba" in the string "acba" as a substring. Please help Acacius to check if it is possible to replace all question marks with lowercase English letters in such a way that a string "abacaba" occurs as a substring in a resulting string exactly once. -----Input----- First line of input contains an integer $T$ ($1 \leq T \leq 5000$), number of test cases. $T$ pairs of lines with test case descriptions follow. The first line of a test case description contains a single integer $n$ ($7 \leq n \leq 50$), length of a string $s$. The second line of a test case description contains string $s$ of length $n$ consisting of lowercase English letters and question marks. -----Output----- For each test case output an answer for it. In case if there is no way to replace question marks in string $s$ with a lowercase English letters in such a way that there is exactly one occurrence of a string "abacaba" in the resulting string as a substring output "No". Otherwise output "Yes" and in the next line output a resulting string consisting of $n$ lowercase English letters. If there are multiple possible strings, output any. You may print every letter in "Yes" and "No" in any case you want (so, for example, the strings yEs, yes, Yes, and YES will all be recognized as positive answer). -----Example----- Input 6 7 abacaba 7 ??????? 11 aba?abacaba 11 abacaba?aba 15 asdf???f???qwer 11 abacabacaba Output Yes abacaba Yes abacaba Yes abadabacaba Yes abacabadaba No No -----Note----- In first example there is exactly one occurrence of a string "abacaba" in the string "abacaba" as a substring. In second example seven question marks can be replaced with any seven lowercase English letters and with "abacaba" in particular. In sixth example there are two occurrences of a string "abacaba" as a substring.

def count(string, substring): count = 0 start = 0 while start < len(string): pos = string.find(substring, start) if pos != -1: start = pos + 1 count += 1 else: break return count for _ in range(int(input())): n = int(input()) os = input() good = False for i in range(n): if (os[i] == "a" or os[i] == "?") and i <= n-7: s = list(os) bad = False for j in range(i, i+7): if s[j] != "?" and s[j] != "abacaba"[j-i]: bad = True break s[j] = "abacaba"[j-i] if bad: continue ans = "".join(s).replace("?", "z") if count(ans, "abacaba") == 1: good = True break if good: print("Yes") print(ans) else: print("No")

train

APPS_structured

`Description:` Given an input array (`arr`) of positive integers, the objective is to return an output array where each index represents the amount of times an element appeared (frequency) in the input array. More specifically, the element at each index of the output array will be an array (bucket) containing integers that appeared index-amount-of-times. Otherwise, slot nulls (JavaScript, Java), None's (Python) nils (Ruby), or NULL's (C/C++) where appropriate. A valid array will always be provided. If an array of [1,2,3,4,4,5,5,5] is passed in, the expected output should be: [null, [1,2,3], [4], [5], null, null, null, null, null]. `Explanation:` ```python # bucketize(arr) ======> outputArray bucketize(1,2,3,4,4,5,5,5) ======> [None, [1, 2, 3], [4], [5], None, None, None, None, None] ``` An element cannot appear 0 times, so a null is placed at outputArray[0]. The elements 1, 2, and 3 appear once. This is why they are located at outputArray[1]. Notice the elements are grouped together in an array and sorted in ascending order. The element 4 appears twice. This is why it is located at outputArray[2]. The element 5 appears three times. This is why it is located at outputArray[3]. Although an integer could have possibly appeared four, five, six, seven, or eight times, this is not the case for this particular example. This is the reason why the elements at outputArray[4], outputArray[5], outputArray[6], outputArray[7], and outputArray[8] are all null values. `Examples:` ```python bucketize(2,2,4,4,6,6,9,9,9,9) ==> [None, None, [2,4,6], None, [9], None, None, None, None, None, None] bucketize(3,3,3,3,2) ============> [None, [2], None, None, [3], None] bucketize(5,5,5,5,5) ============> [None, None, None, None, None, [5]] bucketize(77,3,40,40,40) ========> [None, [3,77], None, [40], None, None] bucketize(16,7,5,3,6,23) ========> [None, [3,5,6,7,16,23], None, None, None, None, None] ```

from collections import Counter from bisect import insort def bucketize(*arr): c = Counter(arr) xs = [None] * (len(arr) + 1) for key, cnt in c.items(): if xs[cnt] is None: xs[cnt] = [] insort(xs[cnt], key) return xs

train

APPS_structured

Tzuyu gave Nayeon a strip of $N$ cells (numbered $1$ through $N$) for her birthday. This strip is described by a sequence $A_1, A_2, \ldots, A_N$, where for each valid $i$, the $i$-th cell is blocked if $A_i = 1$ or free if $A_i = 0$. Tzuyu and Nayeon are going to use it to play a game with the following rules: - The players alternate turns; Nayeon plays first. - Initially, both players are outside of the strip. However, note that afterwards during the game, their positions are always different. - In each turn, the current player should choose a free cell and move there. Afterwards, this cell becomes blocked and the players cannot move to it again. - If it is the current player's first turn, she may move to any free cell. - Otherwise, she may only move to one of the left and right adjacent cells, i.e. from a cell $c$, the current player may only move to the cell $c-1$ or $c+1$ (if it is free). - If a player is unable to move to a free cell during her turn, this player loses the game. Nayeon and Tzuyu are very smart, so they both play optimally. Since it is Nayeon's birthday, she wants to know if she can beat Tzuyu. Find out who wins. -----Input----- - The first line of the input contains a single integer $T$ denoting the number of test cases. The description of $T$ test cases follows. - The first line of each test case contains a single integer $N$. - The second line contains $N$ space-separated integers $A_1, A_2, \ldots, A_N$. -----Output----- For each test case, print a single line containing the string "Yes" if Nayeon wins the game or "No" if Tzuyu wins (without quotes). -----Constraints----- - $1 \le T \le 40,000$ - $2 \le N \le 3\cdot 10^5$ - $0 \le A_i \le 1$ for each valid $i$ - $A_1 = A_N = 1$ - the sum of $N$ over all test cases does not exceed $10^6$ -----Subtasks----- Subtask #1 (50 points): $A_i = 0$ for each $i$ ($2 \le i \le N-1$) Subtask #2 (50 points): original constraints -----Example Input----- 4 7 1 1 0 0 0 1 1 8 1 0 1 1 1 0 0 1 4 1 1 0 1 4 1 1 1 1 -----Example Output----- Yes No Yes No -----Explanation----- Example case 1: Since both Nayeon and Tzuyu play optimally, Nayeon can start e.g. by moving to cell $4$, which then becomes blocked. Tzuyu has to pick either the cell $3$ or the cell $5$, which also becomes blocked. Nayeon is then left with only one empty cell next to cell $4$ (the one Tzuyu did not pick); after she moves there, Tzuyu is unable to move, so she loses the game. Example case 2: Regardless of what cell Nayeon moves to at the start, Tzuyu will always be able to beat her.

# cook your dish here for _ in range(int(input())): n=int(input()) s=input().split() s=''.join(s).split('1') l=[] for i in s: if len(i)==0: continue else: l.append(i) l.sort(reverse=True,key=len) if len(l)==0: print('No') elif len(l)==1: if len(l[0])%2==0: print('No') else: print('Yes') else: m1,m2=len(l[0]),len(l[1]) if m1%2==0: print('No') else: if m1%2 and (m1+1)/2>m2: print('Yes') else: print('No')

train

APPS_structured

# The Problem Dan, president of a Large company could use your help. He wants to implement a system that will switch all his devices into offline mode depending on his meeting schedule. When he's at a meeting and somebody texts him, he wants to send an automatic message informing that he's currently unavailable and the time when he's going to be back. # What To Do Your task is to write a helper function `checkAvailability` that will take 2 arguments: * schedule, which is going to be a nested array with Dan's schedule for a given day. Inside arrays will consist of 2 elements - start and finish time of a given appointment, * *currentTime* - is a string with specific time in hh:mm 24-h format for which the function will check availability based on the schedule. * If no appointments are scheduled for `currentTime`, the function should return `true`. If there are no appointments for the day, the output should also be `true` * If Dan is in the middle of an appointment at `currentTime`, the function should return a string with the time he's going to be available. # Examples `checkAvailability([["09:30", "10:15"], ["12:20", "15:50"]], "11:00");` should return `true` `checkAvailability([["09:30", "10:15"], ["12:20", "15:50"]], "10:00");` should return `"10:15"` If the time passed as input is *equal to the end time of a meeting*, function should also return `true`. `checkAvailability([["09:30", "10:15"], ["12:20", "15:50"]], "15:50");` should return `true` *You can expect valid input for this kata*

def check_availability(sched, now): b = [t1 < now < t2 for t1, t2 in sched] return sched[b.index(True)][1] if True in b else True

train

APPS_structured

Alice received a set of Toy Train™ from Bob. It consists of one train and a connected railway network of $n$ stations, enumerated from $1$ through $n$. The train occupies one station at a time and travels around the network of stations in a circular manner. More precisely, the immediate station that the train will visit after station $i$ is station $i+1$ if $1 \leq i < n$ or station $1$ if $i = n$. It takes the train $1$ second to travel to its next station as described. Bob gave Alice a fun task before he left: to deliver $m$ candies that are initially at some stations to their independent destinations using the train. The candies are enumerated from $1$ through $m$. Candy $i$ ($1 \leq i \leq m$), now at station $a_i$, should be delivered to station $b_i$ ($a_i \neq b_i$). [Image] The blue numbers on the candies correspond to $b_i$ values. The image corresponds to the $1$-st example. The train has infinite capacity, and it is possible to load off any number of candies at a station. However, only at most one candy can be loaded from a station onto the train before it leaves the station. You can choose any candy at this station. The time it takes to move the candies is negligible. Now, Alice wonders how much time is needed for the train to deliver all candies. Your task is to find, for each station, the minimum time the train would need to deliver all the candies were it to start from there. -----Input----- The first line contains two space-separated integers $n$ and $m$ ($2 \leq n \leq 5\,000$; $1 \leq m \leq 20\,000$) — the number of stations and the number of candies, respectively. The $i$-th of the following $m$ lines contains two space-separated integers $a_i$ and $b_i$ ($1 \leq a_i, b_i \leq n$; $a_i \neq b_i$) — the station that initially contains candy $i$ and the destination station of the candy, respectively. -----Output----- In the first and only line, print $n$ space-separated integers, the $i$-th of which is the minimum time, in seconds, the train would need to deliver all the candies were it to start from station $i$. -----Examples----- Input 5 7 2 4 5 1 2 3 3 4 4 1 5 3 3 5 Output 10 9 10 10 9 Input 2 3 1 2 1 2 1 2 Output 5 6 -----Note----- Consider the second sample. If the train started at station $1$, the optimal strategy is as follows. Load the first candy onto the train. Proceed to station $2$. This step takes $1$ second. Deliver the first candy. Proceed to station $1$. This step takes $1$ second. Load the second candy onto the train. Proceed to station $2$. This step takes $1$ second. Deliver the second candy. Proceed to station $1$. This step takes $1$ second. Load the third candy onto the train. Proceed to station $2$. This step takes $1$ second. Deliver the third candy. Hence, the train needs $5$ seconds to complete the tasks. If the train were to start at station $2$, however, it would need to move to station $1$ before it could load the first candy, which would take one additional second. Thus, the answer in this scenario is $5+1 = 6$ seconds.

# import numpy as np def dist(a, b): return (b - a) % n n, m = list(map(int, input().split(" "))) sweets = {i: [] for i in range(n)} for i in range(m): s, t = list(map(int, input().split(" "))) sweets[s - 1].append(t - 1) t = {i: -1e6 for i in range(n)} for i in range(n): sweets[i] = sorted(sweets[i], key=lambda x: -dist(i, x)) if len(sweets[i]): t[i] = (len(sweets[i]) - 1) * n + dist(i, sweets[i][-1]) # t = np.array([t[i] for i in range(n)], dtype=int) # raise ValueError("") # print(t) result = [] m_max, i_max = 0, 0 for i, v in t.items(): if v + i > m_max + i_max: m_max, i_max = v, i result.append(m_max + i_max) for s in range(1, n): old_max = t[i_max] + dist(s, i_max) new_max = t[s - 1] + dist(s, s - 1) if new_max > old_max: result.append(new_max) i_max = s - 1 else: result.append(old_max) print(" ".join(map(str, result)))

train

APPS_structured

=====Function Descriptions===== start() & end() These expressions return the indices of the start and end of the substring matched by the group. Code >>> import re >>> m = re.search(r'\d+','1234') >>> m.end() 4 >>> m.start() 0 =====Problem Statement===== You are given a string S. Your task is to find the indices of the start and end of string k in S. =====Input Format===== The first line contains the string S. The second line contains the string k. =====Output Format===== Print the tuple in this format: (start_index, end_index) If no match is found, print (-1, -1).

#!/usr/bin/env python3 import re def __starting_point(): string = input() sub = input() matches = list(re.finditer(r'(?={})'.format(sub), string)) if matches: for match in matches: print((match.start(), match.end() + len(sub) - 1)) else: print((-1, -1)) __starting_point()

train

APPS_structured

Description overhauled by V --- I've invited some kids for my son's birthday, during which I will give to each kid some amount of candies. Every kid hates receiving less amount of candies than any other kids, and I don't want to have any candies left - giving it to my kid would be bad for his teeth. However, not every kid invited will come to my birthday party. What is the minimum amount of candies I have to buy, so that no matter how many kids come to the party in the end, I can still ensure that each kid can receive the same amount of candies, while leaving no candies left? It's ensured that at least one kid will participate in the party.

import math def lcm(x, y): return (x * y) // math.gcd(x, y) def candies_to_buy(amount_of_kids_invited): f = 1 for i in range(2, amount_of_kids_invited+1): f = lcm(f, i) return f

train

APPS_structured

After the death of their mother, Alphonse and Edward now live with Pinako and Winry. Pinako is worried about their obsession with Alchemy, and that they don't give attention to their studies. So to improve their mathematical solving ability, every day she gives a mathematical problem to solve. They can go out to practice Alchemy only after they have solved the problem. Help them by solving the given problem, so that they can go early today for their Alchemy practice. Given an array A$A$ of N$N$ non-negative integers and two integers K$K$ and M$M$. Find the number of subsequences of array A$A$ of length K$K$ which satisfies the following property: Suppose the subsequence is S=S1S2…SK$S = S_1S_2 \ldots S_K$, then for all i$i$ such that 1≤i≤K$1 \leq i \leq K$, Si%M=i%M S_i \% M = i \% M should hold true, where Si$S_i$ denotes the i$i$-th element of the subsequence, using 1-based indexing. As the number of subsequences may be very large, output the answer modulo 1000000007$1000000007$. PS: We also proposed the idea of making a look-alike clone through alchemy and keeping it in front of the study table. But it seems impossible to convince Edward to make a clone of his exact same height, and not taller than him. So solving the problem for him was a better choice. -----Input:----- - The first line contains T$T$, the number of test cases. Then the test cases follow. - For every test case, the first line contains N$N$, K$K$ and M$M$. - For every test case, the second line contains N$N$ integers Ai$A_{i}$ ( 1≤i≤N$1 \leq i \leq N$). -----Output:----- For every test case, output in a single line an integer denoting the number of valid subsequences modulo 109+7$10^9+7$ -----Constraints----- - 1≤T≤100$1 \leq T \leq 100$ - 1≤N≤104$1 \leq N \leq 10^{4}$ - 1≤K≤N$1 \leq K \leq N$ - ⌈K100⌉≤M≤100×K$\lceil \frac{K}{100}\rceil \leq M \leq 100\times K$ - 0≤Ai≤109$0 \leq A_{i} \leq 10^{9}$ -----Sample Input:----- 1 12 4 3 4 5 6 7 1 4 6 9 0 0 10 2 -----Sample Output:----- 8 -----Explanation:----- The subsequences of length 4$4$, satisfying the given criteria are [4,5,6,7]$[4, 5, 6, 7]$, [4,5,6,10]$[4, 5, 6, 10]$, [4,5,6,10]$[4, 5, 6, 10]$, [4,5,6,1]$[4, 5, 6, 1]$, [4,5,9,10]$[4, 5, 9, 10]$ ,[4,5,6,4]$[4, 5, 6, 4]$ , [4,5,0,10]$[4, 5, 0, 10]$ and [4,5,0,10]$[4, 5, 0, 10]$. This accounts for a total of 8$8$ valid subsequences. Let us take one subsequence and see why it satisfies the given property. Consider [4,5,9,10]$[4, 5, 9, 10]$. - S1%M=4%3=1=1%3=1%M$ S_1 \% M = 4 \% 3 = 1 = 1 \% 3 = 1 \% M $ - S2%M=5%3=2=2%3=2%M$ S_2 \% M = 5 \% 3 = 2 = 2 \% 3 = 2 \% M $ - S3%M=9%3=0=3%3=3%M$ S_3 \% M = 9 \% 3 = 0 = 3 \% 3 = 3 \% M $ - S4%M=10%3=1=4%3=4%M$ S_4 \% M = 10 \% 3 = 1 = 4 \% 3 = 4 \% M $ All the valid i$i$ satisfy the condition, and hence this is a valid subsequence.

# cook your dish here M = 10**9+7 for _ in range(int(input())): n,k,m=(int(s) for s in input().split()) l = [int(s)%m for s in input().split()] ans = [0]*(k+1) i = 1 for j in range(n): mov = 0 just = 0 if (i%m+1)%m==l[j] and i<k: if ans[i]!=0: just=1 mov = 1 w = i - (i%m-l[j])%m while w>=1: if w==1: ans[w]+=1 else: ans[w]+=ans[w-1] w-=m if mov: i+=1 if just: ans[i] = ans[i-1] print(ans[k]%M)

train

APPS_structured

In graph theory, a graph is a collection of nodes with connections between them. Any node can be connected to any other node exactly once, and can be connected to no nodes, to some nodes, or to every other node. Nodes cannot be connected to themselves A path through a graph is a sequence of nodes, with every node connected to the node following and preceding it. A closed path is a path which starts and ends at the same node. An open path: ``` 1 -> 2 -> 3 ``` a closed path: ``` 1 -> 2 -> 3 -> 1 ``` A graph is connected if there is a path from every node to every other node. A graph is a tree if it is connected and there are no closed paths. Your job is to write a function 'isTree', which returns true if a graph is a tree, and false if it is not a tree. Graphs will be given as an array with each item being an array of integers which are the nodes that node is connected to. For example, this graph: ``` 0--1 | | 2--3--4 ``` has array: ``` [[1,2], [0,3], [0,3], [1,2,4], [3]] ``` Note that it is also not a tree, because it contains closed path: ``` 0->1->3->2->0 ``` A node with no connections is an empty array Note that if node 0 is connected to node 1, node 1 is also connected to node 0. This will always be true. The order in which each connection is listed for each node also does not matter. Good luck!

def isTree(matrix): seen = [False] * len(matrix) def traverse(from_node, to_node): if not seen[to_node]: seen[to_node] = True for next_node in matrix[to_node]: if next_node != from_node: if not traverse(to_node, next_node): return False return True return traverse(None, 0) and all(seen)

train

APPS_structured

Chef has an array of N natural numbers most of them are repeated. Cheffina challenges chef to find all numbers(in ascending order) whose frequency is strictly more than K. -----Input:----- - First-line will contain $T$, the number of test cases. Then the test cases follow. - Each test case contains two lines of input, two integers $N, K$. - N space-separated natural numbers. -----Output:----- For each test case, output in a single line answer. -----Constraints----- - $1 \leq T \leq 10$ - $1 \leq N, K \leq 10^5$ - $1 \leq arr[i] \leq 10^5$ -----Sample Input:----- 1 5 1 5 2 1 2 5 -----Sample Output:----- 2 5

from sys import* input=stdin.readline t=int(input()) for _ in range(t): n,k=map(int,input().split()) l=[int(x) for x in input().split()] mp={} for items in l: try: mp[items]+=1 except: mp[items]=1 l=list(set(l)) l.sort() for items in l: if mp[items]>k: print(items,end=" ") print()

train

APPS_structured

You throw a ball vertically upwards with an initial speed `v (in km per hour)`. The height `h` of the ball at each time `t` is given by `h = v*t - 0.5*g*t*t` where `g` is Earth's gravity `(g ~ 9.81 m/s**2)`. A device is recording at every **tenth of second** the height of the ball. For example with `v = 15 km/h` the device gets something of the following form: `(0, 0.0), (1, 0.367...), (2, 0.637...), (3, 0.808...), (4, 0.881..) ...` where the first number is the time in tenth of second and the second number the height in meter. # Task Write a function `max_ball` with parameter `v (in km per hour)` that returns the `time in tenth of second` of the maximum height recorded by the device. # Examples: `max_ball(15) should return 4` `max_ball(25) should return 7` # Notes - Remember to convert the velocity from km/h to m/s or from m/s in km/h when necessary. - The maximum height recorded by the device is not necessarily the maximum height reached by the ball.

def max_ball(v0): return round(10 * (v0 / 3.6) / 9.81)

train

APPS_structured

Implement `String#whitespace?(str)` (Ruby), `String.prototype.whitespace(str)` (JavaScript), `String::whitespace(str)` (CoffeeScript), or `whitespace(str)` (Python), which should return `true/True` if given object consists exclusively of zero or more whitespace characters, `false/False` otherwise.

def whitespace(string): return string.strip() == ""

train

APPS_structured

Chef is interested to solve series problems. Chef wants to solve a series problem but he can't solve it till now.Can you help Chef to solve the series problem? - In series problem, the series goes as follows 1,9,31,73,141 . . . . . . . . Your task is to find the Nth term of series. For larger value of $N$ answer becomes very large, So your output should be performed $N$th term modulo 1000000007 ($10^9+7$ ). -----Input:----- - First line will contain $T$, number of testcases. Then the testcases follow. - Each testcase contains of a single integer $N$. -----Output:----- For each testcase, output in a single line answer i.e. The $N$th term of series modulo 1000000007. -----Constraints----- - $1 \leq T \leq 10^5$ - $1 \leq N \leq 10^9$ -----Sample Input:----- 2 8 10 -----Sample Output:----- 561 1081

# cook your dish here for u in range(int(input())): n=int(input()) s=(n-1)**2+n**3 print(s%(10**9+7))

train

APPS_structured

A string is called happy if it does not have any of the strings 'aaa', 'bbb' or 'ccc' as a substring. Given three integers a, b and c, return any string s, which satisfies following conditions: s is happy and longest possible. s contains at most a occurrences of the letter 'a', at most b occurrences of the letter 'b' and at most c occurrences of the letter 'c'. s will only contain 'a', 'b' and 'c' letters. If there is no such string s return the empty string "". Example 1: Input: a = 1, b = 1, c = 7 Output: "ccaccbcc" Explanation: "ccbccacc" would also be a correct answer. Example 2: Input: a = 2, b = 2, c = 1 Output: "aabbc" Example 3: Input: a = 7, b = 1, c = 0 Output: "aabaa" Explanation: It's the only correct answer in this case. Constraints: 0 <= a, b, c <= 100 a + b + c > 0

class Solution: def longestDiverseString(self, a: int, b: int, c: int) -> str: # 更新初始存量，根据插空规则修正单个字符最大可能的数量 d = {'a':min(a,2*(b+c+1)),'b':min(b,2*(a+c+1)),'c':min(c,2*(b+a+1))} # 修正后的数量确保可以全部用在结果中，求和计算字符串总长 n = sum(d.values()) # 维护结果列表 res = [] # 单次插入一个字符，根据长度循环 for _ in range(n): # 候选的字母 cand = set(['a','b','c']) # 如果列表最后两个字符相同，根据规则不能插入连续三个，故将该字符从候选中删除 if len(res)>1 and res[-1]==res[-2]: cand.remove(res[-1]) # 贪心，在候选中选择存量最大的字符 tmp = max(cand,key=lambda x:d[x]) # 将它加到结果里 res.append(tmp) # 把它的剩余计数减去1. 开始下一轮 d[tmp] -= 1 return ''.join(res)

train

APPS_structured

Build a function `sumNestedNumbers`/`sum_nested_numbers` that finds the sum of all numbers in a series of nested arrays raised to the power of their respective nesting levels. Numbers in the outer most array should be raised to the power of 1. For example, should return `1 + 2*2 + 3 + 4*4 + 5*5*5 === 149`

def sum_nested_numbers(a, depth=1): return sum(sum_nested_numbers(e, depth+1) if type(e) == list else e**depth for e in a)

train

APPS_structured

# Personalized greeting Create a function that gives a personalized greeting. This function takes two parameters: `name` and `owner`. Use conditionals to return the proper message: case | return --- | --- name equals owner | 'Hello boss' otherwise | 'Hello guest'

def greet(name, owner): if name==owner: return "Hello boss" else: return "Hello guest" #if name=!owner #return('Hello guest') a='Daniel' b='Daniel' print(greet(a,b))

train

APPS_structured

Take an integer `n (n >= 0)` and a digit `d (0 <= d <= 9)` as an integer. Square all numbers `k (0 <= k <= n)` between 0 and n. Count the numbers of digits `d` used in the writing of all the `k**2`. Call `nb_dig` (or nbDig or ...) the function taking `n` and `d` as parameters and returning this count. #Examples: ``` n = 10, d = 1, the k*k are 0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100 We are using the digit 1 in 1, 16, 81, 100. The total count is then 4. nb_dig(25, 1): the numbers of interest are 1, 4, 9, 10, 11, 12, 13, 14, 19, 21 which squared are 1, 16, 81, 100, 121, 144, 169, 196, 361, 441 so there are 11 digits `1` for the squares of numbers between 0 and 25. ``` Note that `121` has twice the digit `1`.

def nb_dig(n, d): s = str(d) return sum(sum(c == s for c in str(k**2)) for k in range(n+1))

train

APPS_structured

### **[Mahjong Series](/collections/mahjong)** **Mahjong** is based on draw-and-discard card games that were popular in 18th and 19th century China and some are still popular today. In each deck, there are three different suits numbered `1` to `9`, which are called **Simple tiles**. To simplify the problem, we talk about only one suit of *simple tiles* in this kata (and that's what the term **Pure Hand** means). Note that there are **EXACTLY** 4 identical copies of each kind of tiles in a deck. In each of Mahjong games, each of the 4 players around the table has 13 tiles. They take turns drawing a tile from the tile walls and then discarding one of the tiles from their hands. One wins the game if that player holds a combination of tiles as defined below: A regular winning hand consists of 4 *Melds* and 1 *Pair*. Each *meld* of tiles can be 3 identical or consecutive tiles of a suit, *e.g.* `222` or `456`. ![t2](https://upload.wikimedia.org/wikipedia/commons/6/61/MJt2.png) ![t2](https://upload.wikimedia.org/wikipedia/commons/6/61/MJt2.png) ![t2](https://upload.wikimedia.org/wikipedia/commons/6/61/MJt2.png) ![t4](https://upload.wikimedia.org/wikipedia/commons/7/72/MJt4.png) ![t5](https://upload.wikimedia.org/wikipedia/commons/5/5c/MJt5.png) ![t6](https://upload.wikimedia.org/wikipedia/commons/7/72/MJt6.png) Now let's consider a hand of `1113335557779`. ![t1](https://upload.wikimedia.org/wikipedia/commons/4/4a/MJt1.png)![t1](https://upload.wikimedia.org/wikipedia/commons/4/4a/MJt1.png)![t1](https://upload.wikimedia.org/wikipedia/commons/4/4a/MJt1.png)![t3](https://upload.wikimedia.org/wikipedia/commons/a/a4/MJt3.png)![t3](https://upload.wikimedia.org/wikipedia/commons/a/a4/MJt3.png)![t3](https://upload.wikimedia.org/wikipedia/commons/a/a4/MJt3.png)![t5](https://upload.wikimedia.org/wikipedia/commons/5/5c/MJt5.png)![t5](https://upload.wikimedia.org/wikipedia/commons/5/5c/MJt5.png)![t5](https://upload.wikimedia.org/wikipedia/commons/5/5c/MJt5.png)![t7](https://upload.wikimedia.org/wikipedia/commons/6/6f/MJt7.png)![t7](https://upload.wikimedia.org/wikipedia/commons/6/6f/MJt7.png)![t7](https://upload.wikimedia.org/wikipedia/commons/6/6f/MJt7.png)![t9](https://upload.wikimedia.org/wikipedia/commons/a/a1/MJt9.png) In this hand, there are already 4 *melds* (each of 3 identical tiles), leaving a `9` alone. So we need another `9` to form a *pair*. ![t1](https://upload.wikimedia.org/wikipedia/commons/4/4a/MJt1.png)![t1](https://upload.wikimedia.org/wikipedia/commons/4/4a/MJt1.png)![t1](https://upload.wikimedia.org/wikipedia/commons/4/4a/MJt1.png) ![t3](https://upload.wikimedia.org/wikipedia/commons/a/a4/MJt3.png)![t3](https://upload.wikimedia.org/wikipedia/commons/a/a4/MJt3.png)![t3](https://upload.wikimedia.org/wikipedia/commons/a/a4/MJt3.png) ![t5](https://upload.wikimedia.org/wikipedia/commons/5/5c/MJt5.png)![t5](https://upload.wikimedia.org/wikipedia/commons/5/5c/MJt5.png)![t5](https://upload.wikimedia.org/wikipedia/commons/5/5c/MJt5.png) ![t7](https://upload.wikimedia.org/wikipedia/commons/6/6f/MJt7.png)![t7](https://upload.wikimedia.org/wikipedia/commons/6/6f/MJt7.png)![t7](https://upload.wikimedia.org/wikipedia/commons/6/6f/MJt7.png) ![t9](https://upload.wikimedia.org/wikipedia/commons/a/a1/MJt9.png)![t9](https://upload.wikimedia.org/wikipedia/commons/a/a1/MJt9.png) Additionally, there is another option. Regardless of the 3 *melds* ahead (`111`, `333`, `555`), drawing an `8` produces `77789`, which gives a *pair* of `7`'s and a *meld* (`789`). Therefore, the required tiles to win with `1113335557779` are `8` and `9`. ![t1](https://upload.wikimedia.org/wikipedia/commons/4/4a/MJt1.png)![t1](https://upload.wikimedia.org/wikipedia/commons/4/4a/MJt1.png)![t1](https://upload.wikimedia.org/wikipedia/commons/4/4a/MJt1.png) ![t3](https://upload.wikimedia.org/wikipedia/commons/a/a4/MJt3.png)![t3](https://upload.wikimedia.org/wikipedia/commons/a/a4/MJt3.png)![t3](https://upload.wikimedia.org/wikipedia/commons/a/a4/MJt3.png) ![t5](https://upload.wikimedia.org/wikipedia/commons/5/5c/MJt5.png)![t5](https://upload.wikimedia.org/wikipedia/commons/5/5c/MJt5.png)![t5](https://upload.wikimedia.org/wikipedia/commons/5/5c/MJt5.png) ![t7](https://upload.wikimedia.org/wikipedia/commons/6/6f/MJt7.png)![t7](https://upload.wikimedia.org/wikipedia/commons/6/6f/MJt7.png) ![t7](https://upload.wikimedia.org/wikipedia/commons/6/6f/MJt7.png)![t8](https://upload.wikimedia.org/wikipedia/commons/1/18/MJt8.png)![t9](https://upload.wikimedia.org/wikipedia/commons/a/a1/MJt9.png) Now Sakura wonders which tiles will form a hand with 13 tiles of the same suit (**Pure Hand**). Can you help her? ### **Task** Complete a function to work out all the optional tiles to form a regular winning hand with the given tiles. - **Input** - A string of 13 non-zero digits in non-decreasing order, denoting different tiles of a suit. - **Output** - A string of unique non-zero digits in ascending order. ### **Examples** ``` "1335556789999" => "" (None of the tiles in a deck makes up a winning hand) "1113335557779" => "89" ("8" => "111 333 555 77 789", "9" => "111 333 555 777 99") "1223334455678" => "258" ("2" => "123 22 345 345 678", "5" => "123 234 345 55 678", "8" => "123 234 345 678 88") ```

from collections import Counter def is_valid(hand): if any(hand.count(str(i)) > 4 for i in range(1, 10)): return False stack = [[Counter(int(h) for h in hand), True, len(hand)]] while stack: status, has_pair, r = stack.pop() if r == 0: return True else: x = min(k for k, v in status.items() if v > 0) if status[x] >= 3: stack.append([(status - Counter([x, x, x])), has_pair, r - 3]) if status[x+1] >= 1 and status[x+2] >= 1: stack.append([(status - Counter([x, x + 1, x + 2])), has_pair, r - 3]) if has_pair and status[x] >= 2: stack.append([(status - Counter([x, x])), False, r - 2]) return False def solution(tiles): return ''.join(n for n in '123456789' if is_valid(tiles + n))

train

APPS_structured

# Task Let's consider a table consisting of `n` rows and `n` columns. The cell located at the intersection of the i-th row and the j-th column contains number i × j. The rows and columns are numbered starting from 1. You are given a positive integer `x`. Your task is to count the number of cells in a table that contain number `x`. # Example For `n = 5 and x = 5`, the result should be `2`. The table looks like: ``` 1 2 3 4 (5) 2 4 6 8 10 3 6 9 12 15 4 8 12 16 20 (5) 10 15 20 25``` There are two number `5` in it. For `n = 10 and x = 5`, the result should be 2. For `n = 6 and x = 12`, the result should be 4. ``` 1 2 3 4 5 6 2 4 6 8 10 (12) 3 6 9 (12) 15 18 4 8 (12) 16 20 24 5 10 15 20 25 30 6 (12) 18 24 30 36 ``` # Input/Output - `[input]` integer `n` `1 ≤ n ≤ 10^5.` - `[input]` integer `x` `1 ≤ x ≤ 10^9.` - `[output]` an integer The number of times `x` occurs in the table.

count_number=lambda n,x:sum(x-n*r<=x%r<1for r in range(1,n+1))

train

APPS_structured

Given an array of integers arr. We want to select three indices i, j and k where (0 <= i < j <= k < arr.length). Let's define a and b as follows: a = arr[i] ^ arr[i + 1] ^ ... ^ arr[j - 1] b = arr[j] ^ arr[j + 1] ^ ... ^ arr[k] Note that ^ denotes the bitwise-xor operation. Return the number of triplets (i, j and k) Where a == b. Example 1: Input: arr = [2,3,1,6,7] Output: 4 Explanation: The triplets are (0,1,2), (0,2,2), (2,3,4) and (2,4,4) Example 2: Input: arr = [1,1,1,1,1] Output: 10 Example 3: Input: arr = [2,3] Output: 0 Example 4: Input: arr = [1,3,5,7,9] Output: 3 Example 5: Input: arr = [7,11,12,9,5,2,7,17,22] Output: 8 Constraints: 1 <= arr.length <= 300 1 <= arr[i] <= 10^8

class Solution: def countTriplets(self, arr: List[int]) -> int: a = [] n = len(arr) for i in range(n): if i == 0: a.append(arr[i]) else: a.append(arr[i] ^ a[-1]) ans = 0 for i in range(n): for j in range(i+1, n): for k in range(j, n): x = a[j-1] ^ (0 if i == 0 else a[i-1]) y = a[k] ^ a[j-1] if x == y: ans += 1 return ans

train

APPS_structured

Fennec and Snuke are playing a board game. On the board, there are N cells numbered 1 through N, and N-1 roads, each connecting two cells. Cell a_i is adjacent to Cell b_i through the i-th road. Every cell can be reached from every other cell by repeatedly traveling to an adjacent cell. In terms of graph theory, the graph formed by the cells and the roads is a tree. Initially, Cell 1 is painted black, and Cell N is painted white. The other cells are not yet colored. Fennec (who goes first) and Snuke (who goes second) alternately paint an uncolored cell. More specifically, each player performs the following action in her/his turn: - Fennec: selects an uncolored cell that is adjacent to a black cell, and paints it black. - Snuke: selects an uncolored cell that is adjacent to a white cell, and paints it white. A player loses when she/he cannot paint a cell. Determine the winner of the game when Fennec and Snuke play optimally. -----Constraints----- - 2 \leq N \leq 10^5 - 1 \leq a_i, b_i \leq N - The given graph is a tree. -----Input----- Input is given from Standard Input in the following format: N a_1 b_1 : a_{N-1} b_{N-1} -----Output----- If Fennec wins, print Fennec; if Snuke wins, print Snuke. -----Sample Input----- 7 3 6 1 2 3 1 7 4 5 7 1 4 -----Sample Output----- Fennec For example, if Fennec first paints Cell 2 black, she will win regardless of Snuke's moves.

from collections import deque def nearlist(N, LIST): NEAR = [set() for _ in range(N)] for a, b in LIST: NEAR[a - 1].add(b - 1) NEAR[b - 1].add(a - 1) return NEAR def bfs(S): dist, flag = [-1] * n, [0] * n dist[S], flag[S] = 0, 1 que = deque([S]) while que: q = que.popleft() for i in near[q]: if flag[i]: continue dist[i] = dist[q] + 1 flag[i] = 1 que.append(i) return dist n = int(input()) ab = [list(map(int, input().split())) for _ in range(n - 1)] near = nearlist(n, ab) fennec, snuke = bfs(0), bfs(n - 1) ans = sum(fennec[i] <= snuke[i] for i in range(n)) print(('Fennec' if ans * 2 > n else 'Snuke'))

train

APPS_structured

You are given a string s, consisting of lowercase English letters, and the integer m. One should choose some symbols from the given string so that any contiguous subsegment of length m has at least one selected symbol. Note that here we choose positions of symbols, not the symbols themselves. Then one uses the chosen symbols to form a new string. All symbols from the chosen position should be used, but we are allowed to rearrange them in any order. Formally, we choose a subsequence of indices 1 ≤ i_1 < i_2 < ... < i_{t} ≤ |s|. The selected sequence must meet the following condition: for every j such that 1 ≤ j ≤ |s| - m + 1, there must be at least one selected index that belongs to the segment [j, j + m - 1], i.e. there should exist a k from 1 to t, such that j ≤ i_{k} ≤ j + m - 1. Then we take any permutation p of the selected indices and form a new string s_{i}_{p}_1s_{i}_{p}_2... s_{i}_{p}_{t}. Find the lexicographically smallest string, that can be obtained using this procedure. -----Input----- The first line of the input contains a single integer m (1 ≤ m ≤ 100 000). The second line contains the string s consisting of lowercase English letters. It is guaranteed that this string is non-empty and its length doesn't exceed 100 000. It is also guaranteed that the number m doesn't exceed the length of the string s. -----Output----- Print the single line containing the lexicographically smallest string, that can be obtained using the procedure described above. -----Examples----- Input 3 cbabc Output a Input 2 abcab Output aab Input 3 bcabcbaccba Output aaabb -----Note----- In the first sample, one can choose the subsequence {3} and form a string "a". In the second sample, one can choose the subsequence {1, 2, 4} (symbols on this positions are 'a', 'b' and 'a') and rearrange the chosen symbols to form a string "aab".

from collections import Counter from string import ascii_lowercase as asc m, s = int(input()), input() g = Counter(s) def solve(c): p = 0 for q in ''.join(x if x >= c else ' ' for x in s).split(): i, j = 0, -1 while j + m < len(q): j = q.rfind(c, j + 1, j + m + 1) if j == -1: return None i += 1 p += i return p for c in asc: f = solve(c) if f is not None: g[c] = f print(''.join(x*g[x] for x in asc if x <= c)) break

train

APPS_structured

If you like cryptography and playing cards, have also a look at the kata [Card-Chameleon, a Cipher with Playing cards](http://www.codewars.com/kata/card-chameleon-a-cipher-with-playing-cards). As a secret agent, you need a method to transmit a message to another secret agent. But an encrypted text written on a notebook will be suspicious if you get caught. A simple deck of playing cards, however, is everything but suspicious... With a deck of 52 playing cards, there are `52!` different possible permutations to order it. And `52!` is equal to `80658175170943878571660636856403766975289505440883277824000000000000`. That's a number with [68 digits](https://www.wolframalpha.com/input/?i=52!)! There are so many different possible permutations, we can affirm that if you shuffle the cards well and put them back together to form a deck, you are the first one in history to get this particular order. The number of possible permutations in a deck of cards is higher than the estimated number of atoms in planet Earth (which is a number with about [50 digits](https://www.wolframalpha.com/input/?i=number+of+atoms+in+earth)). With a way to associate a permutation of the cards to a sequence of characters, we can hide a message in the deck by ordering it correctly. --- # Correspondence between message and permutation ## Message To compose our message, we will use an alphabet containing 27 characters: the space and the letters from A to Z. We give them the following values: `" " = 0, A = 1, B = 2, ..., Z = 26` We now have a [numeral system](https://en.wikipedia.org/wiki/Numeral_system) with a base equal to 27. We can compute a numeric value corresponding to any message: `"A " = 27` `"AA" = 28` `"AB" = 29` `"ABC" = 786` etc. ## Permutation Now we need a way to attribute a unique number to each of the possible [permutations](https://en.wikipedia.org/wiki/Permutation) of our deck of playing cards. There are few methods to [enumerate permutations](https://en.wikipedia.org/wiki/Permutation#Algorithms_to_generate_permutations) and [assign a number](https://en.wikipedia.org/wiki/Permutation#Numbering_permutations) to each of them, we will use the [lexicographical order](https://en.wikipedia.org/wiki/Lexicographical_order). With three cards, A, B, and C, as an example, it gives: `ABC = 0` `ACB = 1` `BAC = 2` `BCA = 3` `CAB = 4` `CBA = 5` So the first arrangement is ABC, and the last one is CBA. With our 52 playing cards – ranks sorted from the Ace to the King, and suits in alphabetical order (Clubs, Diamonds, Hearts, Spades) – the first arrangement (number `0`) is: and the last one (number `52! - 1`) is: To transmit a message, we will compute the permutation for which the unique number is the numeric value of the message. --- # Your task Write two functions: * ```python encode(message) ``` ```if:java Which takes a message as argument and returns a deck of playing cards ordered to hide the message (or `null` if the message contains invalid characters or has a numeric value greater than or equal to `52!`). ``` ```if:python Which takes a String containing a message, and returns an array of Strings representing a deck of playing cards ordered to hide the message (or `None` if the message contains invalid characters or has a numeric value greater than or equal to `52!`). ``` ```if:elixir Which takes a string containing a message, and returns a list of strings representing a deck of playing cards ordered to hide the message (or `nil` if the message contains invalid characters or has a numeric value greater than or equal to `52!`). ``` * ```python decode(deck) ``` ```if:java Which takes a deck of playing cards as argument and returns the message hidden inside (or `null` if the deck contains invalid cards, more than one time a single card, or doesn't contain 52 cards). ``` ```if:python Which takes an array of Strings representing a deck of playing cards, and returns the message that is hidden inside (or `None` if the deck contains invalid cards, more than one time a single card, or doesn't contain 52 cards). ``` ```if:elixir Which takes a list of strings representing a deck of playing cards, and returns the message that is hidden inside (or `nil` if the deck contains invalid cards, more than one time a single card, or doesn't contain 52 cards). ``` Each card name, in a deck, is written with a two characters String: the rank followed by the suit. So the first arrangement of the deck is represented like: `AC 2C 3C 4C 5C 6C 7C 8C 9C TC JC QC KC` for the Clubs `AD 2D 3D 4D 5D 6D 7D 8D 9D TD JD QD KD` for the Diamonds `AH 2H 3H 4H 5H 6H 7H 8H 9H TH JH QH KH` for the Hearts `AS 2S 3S 4S 5S 6S 7S 8S 9S TS JS QS KS` for the Spades For your convenience, a preloaded method allows you to easily print a deck to the output: ```python printDeck(deck, unicode) ``` The first argument is the deck to print, the second one is a boolean value allowing you to choose between simple text or Unicode display. (For Unicode, you need to have a font, on your system, that contains the playing cards Unicode characters.) --- # Examples ## Encoding ```python playingCards.encode("ATTACK TONIGHT ON CODEWARS") ``` should return an array of 52 Strings containing: ```python [ "AC", "2C", "3C", "4C", "5C", "6C", "7C", "8C", "9C", "TC", "JC", "QC", "KC", "AD", "2D", "3D", "4D", "5D", "6D", "JD", "9D", "7S", "9S", "QD", "5S", "TH", "7D", "TS", "QS", "2H", "JS", "6H", "3S", "6S", "TD", "8S", "2S", "8H", "7H", "4S", "4H", "3H", "5H", "AS", "KH", "QH", "9H", "KD", "KS", "JH", "8D", "AH" ] ``` ## Decoding ```python playingCards.decode([ "AC", "2C", "3C", "4C", "5C", "6C", "7C", "8C", "9C", "TC", "JC", "QC", "KC", "AD", "2D", "3D", "4D", "5D", "6D", "7D", "8D", "9D", "TD", "JD", "QD", "KD", "AH", "2H", "3H", "4H", "8H", "9S", "3S", "2S", "8S", "TS", "QS", "9H", "7H", "KH", "AS", "JH", "4S", "KS", "JS", "5S", "TH", "7S", "6S", "5H", "QH", "6H" ]) ``` should return a String containing: ```python "ATTACK APPROVED" ``` --- # Further readings ## Logarithm With the logarithm function, we can know how many digits, in a numeral system of a certain base, are needed to represent a number. For example, `log base 2 of 52! = 225.58`, so we can store 225 bits of information in a deck of cards (and 226 bits are needed to represent the value of `52!`). Also, `log base 27 of 52! = 47.44`, so we can store [47](https://www.wolframalpha.com/input/?i=log+base+27+of+52!) characters of our alphabet in a deck of cards (and some message with 48 characters, but not all of them).

class PlayingCards: CARDS=['AC', '2C', '3C', '4C', '5C', '6C', '7C', '8C', '9C', 'TC', 'JC', 'QC', 'KC', 'AD', '2D', '3D', '4D', '5D', '6D', '7D', '8D', '9D', 'TD', 'JD', 'QD', 'KD', 'AH', '2H', '3H', '4H', '5H', '6H', '7H', '8H', '9H', 'TH', 'JH', 'QH', 'KH', 'AS', '2S', '3S', '4S', '5S', '6S', '7S', '8S', '9S', 'TS', 'JS', 'QS', 'KS'] S=len(CARDS) def __init__(self): self.f=[0]*self.S self.f[0]=1 for k in range(1,self.S): self.f[k]=self.f[k-1]*k self.CARD_index={c:self.CARDS.index(c)for c in self.CARDS} def baseEncode(self,s): r=0 for c in s: r*=27 r+=ord(c)%32 return r def baseDecode(self,n): s='' while n: n,c=divmod(n,27) s=(chr(64+c)if c else' ')+s return s def permute(self,n): S=52 p=[0]*S for k in range(S): p[k],n=divmod(n,self.f[S-1-k]) for k in range(S-1,0,-1): for j in range(k-1,-1,-1): if p[j]<=p[k]: p[k]+=1 return [self.CARDS[i]for i in p] # Takes a String containing a message, and returns an array of Strings representing # a deck of playing cards ordered to hide the message, or None if the message is invalid. def encode(self, message): if not all(c==' 'or 'A'<=c<='Z' for c in message):return n=self.baseEncode(message) if n>=80658175170943878571660636856403766975289505440883277824000000000000:return p=self.permute(n) return p # Takes an array of Strings representing a deck of playing cards, and returns # the message that is hidden inside, or None if the deck is invalid. def decode(self, deck): if set(deck)!=set(self.CARDS):return i,j=0,1 perm=[self.CARD_index[c]for c in deck] for p in range(50,-1,-1): s=0 for q in range(p+1,52): if perm[p]>perm[q]:s+=1 i+=s*self.f[j] j+=1 return self.baseDecode(i)

train

APPS_structured

A key feature of the Siruseri railway network is that it has exactly one route between any pair of stations. The government has chosen three contractors to run the canteens at the stations on the railway network. To ensure that there are no disputes between the contractors it has been decided that if two stations, say $A$ and $B$, are assigned to a particular contractor then all the stations that lie on the route from $A$ to $B$ will also be awarded to the same contractor. The government would like the assignment of stations to the contractors to be as equitable as possible. The government has data on the number of passengers who pass through each station each year. They would like to assign stations so that the maximum number of passengers passing through any contractor's collection of stations is minimized. For instance, suppose the railway network is as follows, where the volume of passenger traffic is indicated by the side of each station. One possible assignment would to award stations $1$ and $3$ to one contractor (there by giving him a traffic of $35$ passengers), station $2$ to the second contractor (traffic of $20$) and stations $4, 5$ and $6$ to the third contractor (traffic of $100$). In this assignment, the maximum traffic for any one contractor is 100. On the other hand if we assigned stations $1, 2$ and $3$ to one contractor, station $4$ and $6$ to the second contractor and station $5$ to the third contractor the maximum traffic for any one contractor is $70$. You can check that you cannot do better. (The assignment $1$, $2$ and $3$ to one contractor, $4$ to the second contractor, and $5$ and $6$ to the third contractor has a lower value for the maximum traffic ($55$) but it is not a valid assignment as the route from $5$ to $6$ passes through $4$.) -----Input:----- The first line of the input contains one integer $N$ indicating the number of railways stations in the network. The stations are numbered $1,2,..., N$. This is followed by $N$ lines of input, lines $2,3,...,N+1$, indicating the volume of traffic at each station. The volume of traffic at station $i$, $1 \leq i \leq N$, is given by a single integer in line $i+1$. The next $N-1$ lines of input, lines $N+2, N+3, ..., 2 \cdot N$, describe the railway network. Each of these lines contains two integers, denoting a pair of stations that are neighbours. -----Output:----- The output should be a single integer, corresponding to the minimum possible value of the maximum traffic of any contractor among all valid assignment of the stations to the three contractors. -----Constraints:----- - $1 \leq N \leq 3000$. -----Sample Input----- 6 10 20 25 40 30 30 4 5 1 3 3 4 2 3 6 4 -----Sample Output----- 70

n=int(input()) cost=[] d={} val_desc=[0]*n visited=set() visited.add(0) dfstack=[] desc = [[False for i in range(n)] for i in range(n)] for i in range(n): cost.append(int(input())) d[i]=[] for i in range(n-1): j,k=list(map(int,input().split())) d[j-1].append(k-1) d[k-1].append(j-1) def dfs(u): val_desc[u]+=cost[u] dfstack.append(u) for i in dfstack: desc[u][i]=True for i in d[u]: if i not in visited: visited.add(i) dfs(i) val_desc[u]+=val_desc[i] dfstack.pop(-1) dfs(0) mp=10**9 coco=sum(cost) for i in range(n): for j in range(i+1,n): vali=val_desc[i] valj=val_desc[j] if desc[i][j]: valj-=val_desc[i] if desc[j][i]: vali-=val_desc[j] p=max(vali,valj,coco-vali-valj) mp=min(mp,p) #print(desc) #print(val_desc) #print print(mp)

train

APPS_structured