Datasets:
codeparrot
/
xlcost-text-to-code

Dataset card Data Studio Files
xet
Community
2
text
stringlengths
1
636
code
stringlengths
8
1.89k
Given matrix mat [ ] [ ]
mat = [ [ 1 , 2 , 3 , 1 ] , [ 3 , 1 , 2 , 4 ] , [ 2 , 3 , 1 , 1 ] ] NEW_LINE
Function Call
countUniquePaths ( mat , M , N , 1 ) NEW_LINE
Print the final count
print ( countPaths ) NEW_LINE
Python3 program for the above approach
import sys NEW_LINE MAX = 100000 NEW_LINE
dp array to memoize the results
dp = [ - 1 ] * ( MAX + 1 ) NEW_LINE
List to store the result
denomination = [ ] NEW_LINE
Function to find the minimum number of coins to make the sum equals to X
def countMinCoins ( n , C , m ) : NEW_LINE
Base case
if ( n == 0 ) : NEW_LINE INDENT dp [ 0 ] = 0 NEW_LINE return 0 NEW_LINE DEDENT
If previously computed subproblem occurred
if ( dp [ n ] != - 1 ) : NEW_LINE INDENT return dp [ n ] NEW_LINE DEDENT
Initialize result
ret = sys . maxsize NEW_LINE
Try every coin that has smaller value than n
for i in range ( m ) : NEW_LINE INDENT if ( C [ i ] <= n ) : NEW_LINE INDENT x = countMinCoins ( n - C [ i ] , C , m ) NEW_LINE DEDENT DEDENT
Check for INT_MAX to avoid overflow and see if result . an be minimized
if ( x != sys . maxsize ) : NEW_LINE INDENT ret = min ( ret , 1 + x ) NEW_LINE DEDENT
Memoizing value of current state
dp [ n ] = ret NEW_LINE return ret NEW_LINE
Function to find the possible combination of coins to make the sum equal to X
def findSolution ( n , C , m ) : NEW_LINE
Base Case
if ( n == 0 ) : NEW_LINE
Print Solutions
for it in denomination : NEW_LINE INDENT print ( it , end = " ▁ " ) NEW_LINE DEDENT return NEW_LINE for i in range ( m ) : NEW_LINE
Try every coin that has value smaller than n
if ( n - C [ i ] >= 0 and dp [ n - C [ i ] ] + 1 == dp [ n ] ) : NEW_LINE
Add current denominations
denomination . append ( C [ i ] ) NEW_LINE
Backtrack
findSolution ( n - C [ i ] , C , m ) NEW_LINE break NEW_LINE
Function to find the minimum combinations of coins for value X
def countMinCoinsUtil ( X , C , N ) : NEW_LINE
Min coins
isPossible = countMinCoins ( X , C , N ) NEW_LINE
If no solution exists
if ( isPossible == sys . maxsize ) : NEW_LINE INDENT print ( " - 1" ) NEW_LINE DEDENT
Backtrack to find the solution
else : NEW_LINE INDENT findSolution ( X , C , N ) NEW_LINE DEDENT
Driver code
if __name__ == ' _ _ main _ _ ' : NEW_LINE INDENT X = 21 NEW_LINE DEDENT
Set of possible denominations
arr = [ 2 , 3 , 4 , 5 ] NEW_LINE N = len ( arr ) NEW_LINE
Function call
countMinCoinsUtil ( X , arr , N ) NEW_LINE
Function to calculate Binomial Coefficient C ( n , r )
def binCoff ( n , r ) : NEW_LINE INDENT val = 1 NEW_LINE if ( r > ( n - r ) ) : NEW_LINE DEDENT
C ( n , r ) = C ( n , n - r )
r = ( n - r ) NEW_LINE for i in range ( r ) : NEW_LINE
[ n * ( n - 1 ) * -- - * ( n - r + 1 ) ] / [ r * ( r - 1 ) * -- -- * 1 ]
val *= ( n - i ) NEW_LINE val //= ( i + 1 ) NEW_LINE return val NEW_LINE
Function to calculate the total possible paths
def findWays ( n ) : NEW_LINE
Update n to n - 1
n = n - 1 NEW_LINE
Stores 2 nCn
a = binCoff ( 2 * n , n ) NEW_LINE
Stores Nth Catalan number
b = a // ( n + 1 ) NEW_LINE
Stores the required answer
ans = b NEW_LINE return ans NEW_LINE
Driver Code
if __name__ == " _ _ main _ _ " : NEW_LINE INDENT n = 4 NEW_LINE print ( findWays ( n ) ) NEW_LINE DEDENT
Python3 program for the above approach
dp = [ [ 0 ] * 1010 ] * 1010 NEW_LINE
Function that finds the minimum number of steps to find the minimum characters must be moved to convert string s to t
def solve ( s , t ) : NEW_LINE INDENT n = len ( s ) NEW_LINE DEDENT
r = maximum value over all dp [ i ] [ j ] computed so far
r = 0 NEW_LINE
dp [ i ] [ j ] stores the longest contiguous suffix of T [ 0. . j ] that is subsequence of S [ 0. . i ]
for j in range ( 0 , n ) : NEW_LINE INDENT for i in range ( 0 , n ) : NEW_LINE INDENT dp [ i ] [ j ] = 0 NEW_LINE if ( i > 0 ) : NEW_LINE INDENT dp [ i ] [ j ] = max ( dp [ i - 1 ] [ j ] , dp [ i ] [ j ] ) NEW_LINE DEDENT if ( s [ i ] == t [ j ] ) : NEW_LINE INDENT ans = 1 NEW_LINE if ( i > 0 and j > 0 ) : NEW_LINE INDENT ans = 1 + dp [ i - 1 ] [ j - 1 ] NEW_LINE DEDENT DEDENT DEDENT DEDENT
Update the maximum length
dp [ i ] [ j ] = max ( dp [ i ] [ j ] , ans ) NEW_LINE r = max ( r , dp [ i ] [ j ] ) NEW_LINE
Return the resulting length
return ( n - r ) NEW_LINE
Given string s , t
s = " abcde " NEW_LINE t = " edacb " NEW_LINE
Function call
print ( solve ( s , t ) ) NEW_LINE
Function to get the length of longest substring whose characters can be arranged to form a palindromic string
def longestSubstring ( s : str , n : int ) : NEW_LINE
To keep track of the last index of each xor
index = dict ( ) NEW_LINE
Initialize answer with 0
answer = 0 NEW_LINE mask = 0 NEW_LINE index [ mask ] = - 1 NEW_LINE
Now iterate through each character of the string
for i in range ( n ) : NEW_LINE
Convert the character from [ a , z ] to [ 0 , 25 ]
temp = ord ( s [ i ] ) - 97 NEW_LINE
Turn the temp - th bit on if character occurs odd number of times and turn off the temp - th bit off if the character occurs ever number of times
mask ^= ( 1 << temp ) NEW_LINE
If a mask is present in the index Therefore a palindrome is found from index [ mask ] to i
if mask in index . keys ( ) : NEW_LINE INDENT answer = max ( answer , i - index [ mask ] ) NEW_LINE DEDENT
If x is not found then add its position in the index dict .
else : NEW_LINE INDENT index [ mask ] = i NEW_LINE DEDENT
Check for the palindrome of odd length
for j in range ( 26 ) : NEW_LINE
We cancel the occurrence of a character if it occurs odd number times
mask2 = mask ^ ( 1 << j ) NEW_LINE if mask2 in index . keys ( ) : NEW_LINE INDENT answer = max ( answer , i - index [ mask2 ] ) NEW_LINE DEDENT return answer NEW_LINE
Given String
s = " adbabd " NEW_LINE
Length of given string
n = len ( s ) NEW_LINE
Function call
print ( longestSubstring ( s , n ) ) NEW_LINE
Function to find count of N - digit numbers with single digit XOR
def countNums ( N ) : NEW_LINE
dp [ i ] [ j ] stores the number of i - digit numbers with XOR equal to j
dp = [ [ 0 for i in range ( 16 ) ] for j in range ( N ) ] ; NEW_LINE
For 1 - 9 store the value
for i in range ( 1 , 10 ) : NEW_LINE INDENT dp [ 0 ] [ i ] = 1 ; NEW_LINE DEDENT
Iterate till N
for i in range ( 1 , N ) : NEW_LINE INDENT for j in range ( 0 , 10 ) : NEW_LINE INDENT for k in range ( 0 , 16 ) : NEW_LINE DEDENT DEDENT
Calculate XOR
xor = j ^ k ; NEW_LINE
Store in DP table
dp [ i ] [ xor ] += dp [ i - 1 ] [ k ] ; NEW_LINE
Initialize count
count = 0 ; NEW_LINE for i in range ( 0 , 10 ) : NEW_LINE INDENT count += dp [ N - 1 ] [ i ] ; NEW_LINE DEDENT
Print answer
print ( count ) ; NEW_LINE
Driver Code
if __name__ == ' _ _ main _ _ ' : NEW_LINE
Given number N
N = 1 ; NEW_LINE
Function Call
countNums ( N ) ; NEW_LINE
Function to count the numbers that are divisible by the numbers in the array from range 1 to M
def count ( a , M , N ) : NEW_LINE
Initialize the count variable
cnt = 0 NEW_LINE
Iterate over [ 1 , M ]
for i in range ( 1 , M + 1 ) : NEW_LINE
Iterate over array elements arr [ ]
for j in range ( N ) : NEW_LINE
Check if i is divisible by a [ j ]
if ( i % a [ j ] == 0 ) : NEW_LINE
Increment the count
cnt += 1 NEW_LINE break NEW_LINE
Return the answer
return cnt NEW_LINE
Given list lst
lst = [ 2 , 3 , 5 , 7 ] NEW_LINE
Given number M
m = 100 NEW_LINE n = len ( lst ) NEW_LINE
Function call
print ( count ( lst , m , n ) ) NEW_LINE
Python3 implementation to count the numbers upto N digits such that no two zeros are adjacent
dp = [ [ 0 ] * 10 for j in range ( 15 ) ] NEW_LINE
Function to count the numbers upto N digits such that no two zeros are adjacent
def solve ( n , last , k ) : NEW_LINE
Condition to check if only one element remains
if ( n == 1 ) : NEW_LINE
If last element is non zero , return K - 1
if ( last == k ) : NEW_LINE INDENT return ( k - 1 ) NEW_LINE DEDENT
If last element is 0
else : NEW_LINE INDENT return 1 NEW_LINE DEDENT
Condition to check if value calculated already
if ( dp [ n ] [ last ] ) : NEW_LINE INDENT return dp [ n ] [ last ] NEW_LINE DEDENT
If last element is non zero , then two cases arise , current element can be either zero or non zero
if ( last == k ) : NEW_LINE
Memoize this case
dp [ n ] [ last ] = ( ( k - 1 ) * solve ( n - 1 , k , k ) + ( k - 1 ) * solve ( n - 1 , 1 , k ) ) NEW_LINE return dp [ n ] [ last ] NEW_LINE
If last is 0 , then current can only be non zero
else : NEW_LINE
Memoize and return
dp [ n ] [ last ] = solve ( n - 1 , k , k ) NEW_LINE return dp [ n ] [ last ] NEW_LINE
Given N and K
n = 2 NEW_LINE k = 3 NEW_LINE
Function call
x = solve ( n , k , k ) + solve ( n , 1 , k ) NEW_LINE print ( x ) NEW_LINE
Function to print the count of all prefix in the given string
def Print ( occ , s ) : NEW_LINE
Iterate over string s
for i in range ( 1 , len ( s ) + 1 ) : NEW_LINE
Print the prefix and their frequency
print ( s [ 0 : i ] , " occur " , occ [ i ] , " times . " ) NEW_LINE
Function to implement the LPS array to store the longest prefix which is also a suffix for every substring of the string S
def prefix_function ( s ) : NEW_LINE
Array to store LPS values Value of lps [ 0 ] is 0 by definition
LPS = [ 0 for i in range ( len ( s ) ) ] NEW_LINE
Find the values of LPS [ i ] for the rest of the string using two pointers and DP
for i in range ( 1 , len ( s ) ) : NEW_LINE
Initially set the value of j as the longest prefix that is also a suffix for i as LPS [ i - 1 ]
j = LPS [ i - 1 ] NEW_LINE
Check if the suffix of length j + 1 is also a prefix
while ( j > 0 and s [ i ] != s [ j ] ) : NEW_LINE INDENT j = LPS [ j - 1 ] NEW_LINE DEDENT
If s [ i ] = s [ j ] then , assign LPS [ i ] as j + 1
if ( s [ i ] == s [ j ] ) : NEW_LINE INDENT LPS [ i ] = j + 1 NEW_LINE DEDENT
If we reached j = 0 , assign LPS [ i ] as 0 as there was no prefix equal to suffix
else : NEW_LINE INDENT LPS [ i ] = 0 NEW_LINE DEDENT
Return the calculated LPS array
return LPS NEW_LINE