Interviewbit

strings

Level 2
Implement StrStr
Problem Description
Another question which belongs to the category of questions which are intentionally stated vaguely.
Expectation is that you will ask for correct clarification or you will state your assumptions before you start coding.
Implement strStr().
strstr - locate a substring ( needle ) in a string ( haystack ).
Try not to use standard library string functions for this question.
Returns the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.
NOTE: String A is haystack, B is needle.
Good clarification questions:
1.What should be the return value if the needle is empty?
2.What if both haystack and needle are empty?
For the purpose of this problem, assume that the return value should be -1 in both cases.

Problem Constraints
1 <= |haystack| <= 104
1 <= |needle| <= 103

Input Format
The first argument is a string A (haystack)
The second argument is a string B (needle)
Output Format
Return an integer, the index of the first occurrence of needle in haystack, or -1 if needle is not part of haystack.
Example Input
Input 1:A = "strstr" B = "str"
Input 2:A = "bighit" B = "bit"

Example Output
Output 1:0
Output 1:-1

Example Explanation
Explanation 1:"str" occurs at index 0 and 3. The first occurrence is at index 0, so we return 0.
Explanation 2:"bit" did not occur in "bighit", so we return -1.
def strStr(A, B):
if(B not in A):
return -1
lb=len(B)
for i in range(len(A)-lb+1):
if(A[i:i+lb]==B):
return i

if __name__ == "__main__":
A = input()
B = input()
print(strStr(A,B))
Integer To Roman
Given an integer A, convert it to a roman numeral, and return a string corresponding to its roman numeral version
Note : This question has a lot of scope of clarification from the interviewer. Please take a moment to think of all the needed
clarifications and see the expected response using “See Expected Output”
For the purpose of this question, https://projecteuler.net/about=roman_numerals has very detailed explanations.

Input Format
The only argument given is integer A.
Output Format
Return a string denoting roman numeral version of A.
Constraints
1 <= A <= 3999
For Example
Input 1: A = 5
Output 1: "V“

Input 2: A = 14
Output 2: "XIV"
def intToRoman(A):
val = [
1000, 900, 500, 400,
100, 90, 50, 40,
10, 9, 5, 4,
1
]
syms = [
"M", "CM", "D", "CD",
"C", "XC", "L", "XL",
"X", "IX", "V", "IV",
"I"
]
roman_numeral = ""
i=0
while A > 0:
for _ in range(A // val[i]):
roman_numeral += syms[i]
A -= val[i]
i += 1
return roman_numeral

if __name__ == "__main__":
A = int(input())
print(intToRoman(A))
Roman To Integer
Given a string A representing a roman numeral.
Convert A into integer.
A is guaranteed to be within the range from 1 to 3999.
NOTE: Read more
details about roman numerals at Roman Numeric System

Input Format
The only argument given is string A.

Output Format
Return an integer which is the integer verison of roman numeral string.

For Example
Input 1: A = "XIV"
Output 1: 14

Input 2: A = "XX"
Output 2: 20
def romanToInt(A):
d={'I': 1, 'IV': 4, 'V': 5, 'IX': 9, 'X': 10, 'XL': 40, 'L': 50, 'XC': 90, 'C': 100, 'CD': 400, 'D': 500, 'CM':900, 'M':1000, }
ans=0
flag=0
for i in range(len(A)-1):
if flag==1:
flag=0
continue
if d.get(A[i]+A[i+1]):
ans=ans+d.get(A[i]+A[i+1])
flag=1
else:
ans=ans+d.get(A[i])
flag=0
if not flag:
ans=ans+d.get(A[-1])
return ans

if __name__ == "__main__":
A = int(input())
print(romanToInt(A))
Multiply Strings
Problem Description
Given two numbers represented as strings, return the multiplication of the numbers as a string.
Note:
•The numbers can be arbitrarily large and are non-negative.
•Your answer should not have leading zeroes. For example, 00 is not a valid answer.
DO NOT USE BIG INTEGER LIBRARIES ( WHICH ARE AVAILABLE IN JAVA / PYTHON ). We will retroactively disqualify
such submissions and the submissions will incur penalties.
Problem Constraints
1 <= |A|, |B| <= 104
1 <= |A| * |B| <= 106

Input Format
The first argument is a string A, representing the first number.
The second argument is a string B, representing the second number.
Output Format
Return a string, equal to the product of A and B.

Example Input
A = "10" Example Explanation
B = "12" A = 10 and B = 12, A * B is 120, return it in the string without
Example Output leading zeroes.
"120"
def multiply(num1, num2):
if num1 == "0" or num2 == "0":
return "0"
num = [0] * (len(num1) + len(num2))
for i in range(len(num1) - 1, -1, -1):
for j in range(len(num2) - 1, -1, -1):
num[i + j + 1] += int(num1[i]) * int(num2[j])
num[i + j] += num[i + j + 1] // 10
num[i + j + 1] %= 10
i=0
while i < len(num) and num[i] == 0:
i += 1
res = ""
while i < len(num):
res += str(num[i])
i += 1
return res

if __name__ == "__main__":
num1 = input()
num2 = input()
print(multiply(num1,num2))
Zigzag String
The string "PAYPALISHIRING" is written in a zigzag pattern on a given number of rows like this: (you
may want to display this pattern in a fixed font for better legibility)

P.......A........H.......N ..A..P....L....S....I...I....G ....Y.........I........R

And then read line by line: PAHNAPLSIIGYIR

Write the code that will take a string and make this conversion given a number of rows:
string convert(string text, int nRows); convert("PAYPALISHIRING", 3) should return
"PAHNAPLSIIGYIR"

**Example 2 : **
ABCD, 2 can be written as
A....C ...B....D
and hence the answer would be ACBD.
def convert(A, B):
if (len(A) == 0):
return ""
if (B == 0):
return "Not Possible"
if (B == 1):
return A
if (B > len(A)):
return A
curRow = 0
i=0
ll = [""]*B
while (i != len(A)):
ll[curRow] += A[i]
if (curRow == 0):
inc = 1
if (curRow == B-1):
inc = -1
curRow = curRow + inc
i += 1
return "".join(ll)

if __name__ == "__main__":
A = input()
B = input()
print(covert(A,B))
Atoi
There are certain questions where the interviewer would intentionally frame the question vague.
The expectation is that you will ask the correct set of clarifications or state your assumptions before you jump into coding.
Implement atoi to convert a string to an integer.
Example :
Input : "9 2704" Output : 9
Note: There might be multiple corner cases here. Clarify all your doubts using “See Expected Output”.
Questions:
Q1. Does string contain whitespace characters before the number?
A. Yes
Q2. Can the string have garbage characters after the number?
A. Yes. Ignore it.
Q3. If no numeric character is found before encountering garbage characters, what should I do?
A. Return 0.
Q4. What if the integer overflows?
A. Return INT_MAX if the number is positive, INT_MIN otherwise.
Warning : DO NOT USE LIBRARY FUNCTION FOR ATOI.
If you do, we will disqualify your submission retroactively and give you penalty points.
def atoi(A):
if A is None or len(A) == 0:
return 0

result = 0
sign = 1
i=0

while i < len(A) and A[i].isspace():

i += 1

if i < len(A) and (A[i] == '+' or A[i] == '-'):

sign = -1 if A[i] == '-' else 1
i += 1

while i < len(A) and A[i].isdigit():

digit = ord(A[i]) - ord('0')
if result > (2147483647 - digit) / 10:
return 2147483647 if sign == 1 else -2147483648
result = result * 10 + digit
i += 1

return result * sign

if __name__ == "__main__":
A = input()
print(atoi(A))
Valid Ip Addresses

Given a string containing only digits, restore it by returning all possible valid IP address
combinations.
A valid IP address must be in the form of A.B.C.D, where A,B,C and D are numbers from
0-255. The numbers cannot be 0 prefixed unless they are 0.

Example:
Given “25525511135”,
return [“255.255.11.135”, “255.255.111.35”]. (Make sure the returned strings are sorted in
order)
def restoreIpAddresses(A): arr.append("0." + s)
str_al = [] return arr
return make_ip(A, 4)
for i in range(min(3, len(A))):
def make_ip(A, n): x = A[:i + 1]
arr = [] if int(x) < 256:
if len(A) > n * 3: sub = self.make_ip(A[i + 1:], n - 1)
return arr for s in sub:
if len(A) == 0: arr.append(x + "." + s)
return arr return arr
if n == 1:
if A[0] == '0' and len(A) > 1: if __name__ == "__main__":
return arr A = input()
if int(A) > 255: print(restoreIpAddresses(A))
return arr
arr.append(A)
return arr

if A[0] == '0':
sub = make_ip(A[1:], n - 1)
for s in sub:
Compare Version Numbers
Problem Description
Compare two version numbers version1 and version2.
•If version1 > version2 return 1,
•If version1 < version2 return -1,
•otherwise return 0.
You may assume that the version strings are non-empty and contain only digits and the . character.
The . character does not represent a decimal point and is used to separate number sequences. For instance, 2.5 is not "two and a
half" or "half way to version three", it is the fifth second-level revision of the second first-level revision.
Note: Here is an example of version numbers ordering:
0.1 < 1.1 < 1.2 < 1.13 < 1.13.4

Problem Constraints
1 <= |A|, |B| <= 5000

Input Format
The first argument is a string A representing version1.
The first argument is a string B representing version2.
Output Format
Return an integer.

Example Input Example Explanation

A = "1.13"
Version1 = "1.13"
B = "1.13.4"
Version2 = "1.13.4"
Example Output Version1 < version2, hence return -1
-1
def compareVersion( A, B): temp2.pop()
A = A.split(".")
B = B.split(".") for i in range(min(len(temp1),len(temp2))):
temp1 = [] if temp1[i] > temp2[i]:
for i in A: return 1
temp1.append(i) elif temp1[i] < temp2[i]:
return -1
temp2 = []
for i in B: if temp1 == temp2 :
temp2.append(i) return 0

for i in range(len(temp1)): return -1

temp1[i] = int(temp1[i])

for i in range(len(temp2)): if __name__ == "__main__":

temp2[i] = int(temp2[i]) A = input()
B = input()
if temp1[-1] == 0: print(compareVersion(A,B))
temp1.pop()

if temp2[-1] == 0:
Longest Palindromic Substring
Problem Description
Given a string A of size N, find and return the longest palindromic substring in A.
Substring of string A is A[i...j] where 0 <= i <= j < len(A)
Palindrome string:
A string which reads the same backwards. More formally, A is palindrome if reverse(A) = A.
Incase of conflict, return the substring which occurs first ( with the least starting index).
Problem Constraints
1 <= N <= 6000

Input Format
First and only argument is a string A.
Output Format
Return a string denoting the longest palindromic substring of string A.

Example Input
A = "aaaabaaa"

Example Output
"aaabaaa"

Example Explanation
We can see that longest palindromic substring is of length 7 and the string is "aaabaaa".
def longestPalindrome(s):
n = len(s)
if n < 2:
return s
max_len = 1
start = 0
for i in range(n):
low = i - 1
high = i + 1
while high < n and s[high] == s[i]:
high += 1
while low >= 0 and s[low] == s[i]:
low -= 1
while low >= 0 and high < n and s[low] == s[high]:
high += 1
low -= 1
length = high - low - 1
if max_len < length:
max_len = length
start = low + 1
return s[start:start + max_len]

if __name__ == "__main__":
A = input()
print(longestPalindrome(A))
Pretty Json
Problem Description
Given a string A representing JSON object. Return an array of strings denoting JSON object with proper indentation.
Rules for proper indentation:
•Every inner brace should increase one indentation to the following lines.
•Every close brace should decrease one indentation to the same line and the following lines.
•The indents can be increased with an additional '\t'
Note:
•[] and {} are only acceptable braces in this case.
•Assume for this problem that space characters can be done away with.
Problem Constraints
1 <= |A| <= 103

Input Format
The only argument given is the integer array A.

Output Format
Return a list of strings, where each entry corresponds to a single line. The strings should not have "\n" character in them.

Example Input
Input 1: A = "{A:"B",C:{D:"E",F:{G:"H",I:"J"}}}"
Input 2: A = ["foo", {"bar":["baz",null,1.0,2]}]

Example Output
Output 1: { A:"B", C: { D:"E", F: { G:"H", I:"J" } } }
Output 2: [ "foo", { "bar": [ "baz", null, 1.0, 2 ] } ]\
def prettyJSON(A): output.append(pretty)
output = [] pretty = '\t' * indents + char
pretty = "" else:
indents = 0 if not pretty and indents > 0:
pretty = '\t' * indents
for char in A: pretty += char
if char == ',': if pretty:
output.append(pretty + char) output.append(pretty)
pretty = "" return output
elif char == '[' or char == '{':
if pretty:
output.append(pretty) if __name__ == "__main__":
output.append('\t' * indents + char) A = input()
indents += 1 print(prettyJSON(A))
pretty = ""
elif char == ']' or char == '}':
indents -= 1
if pretty:
Power of 2
Problem Description
Find if the given number is a power of 2 or not. More specifically, find if the given number can be expressed as 2^k where k
>= 1.
Note: The number length can be more than 64, which means the number can be greater than 2 ^ 64 (out of long long range)

Problem Constraints
1 <= |A| <= 104

Input Format
The first argument is a string A.

Output Format
Return 1 if the number is a power of 2 else return 0

Example Input
128

Example Output
1

Example Explanation
128 can be expressed as 2 ^ 7.
def power(A):
if int(A)==1:
return 0
x=bin(int(A))[2:]
if x.count("1")==1:
return 1

return 0

if __name__ == "__main__":
A = int(input())
print(power(A))
Minimum Characters required to make a String Palindromic
Problem Description
Given a string A. The only operation allowed is to insert characters at the beginning of the string.
Find how many minimum characters are needed to be inserted to make the string a palindrome string.
Problem Constraints
1 <= |A| <= 106

Input Format
The only argument given is string A.
Output Format
Return the minimum characters that are needed to be inserted to make the string a palindrome string.

Example Input
Input 1:A = "ABC“
Input 2:A = "AACECAAAA"
Example Output
Output 1:2
Output 2:2

Example Explanation
Explanation 1:Insert 'B' at beginning, string becomes: "BABC". Insert 'C' at beginning, string becomes: "CBABC".
Explanation 2:Insert 'A' at beginning, string becomes: "AAACECAAAA". Insert 'A' at beginning, string becomes:
"AAAACECAAAA".
def solve(A):
n = len(A)
l = n // 2
r = n // 2

if n % 2 == 0:
l -= 1

while l >= 0:
if A[r] == A[l]:
l -= 1
r += 1
else:
r -= 1
return n - r

if __name__ == "__main__":
A = input()
print(solve(A))
Convert the amount in number to words
Problem Description
Our company wants to create a data entry verification system. Given an amount in words and an amount indicated by data entry person in numbers,
you have to detect whether the amounts are the same or not.
Note:
•There are a lot of corner cases to be considered. The interviewer expects you to take care of them.
•Every word needs to be separated using "-" rather than a space character https://en.wikipedia.org/wiki/Indian_numbering_system
•"Use Expected Output option" to clear further doubts.
Problem Constraints
1 <= |A| <= 9
1 <= |B| <= 100
Input Format
String num: Amount written in digits as a string. This string will be an integer number without having any commas in between the digits.
String words: Amount written in words according to Indian Numbering System.

Output Format
An integer
1: Values match
0: Otherwise

Example Input
String num = "1234"
String words = "one-thousand-two-hundred-and-thirty-four"

Example Output
1
def solve(A, B):
n = int(A) res = ""
res = "" if n > 19:
res += self.num_to_str(n // 10000000, "crore-") res += tens[n // 10] + ones[n % 10]
res += self.num_to_str((n // 100000) % 100, "lakh-") else:
res += self.num_to_str((n // 1000) % 100, "thousand-") res += ones[n]
res += self.num_to_str((n // 100) % 10, "hundred-") if n != 0:
if n > 100 and n % 100 != 0: res += s
res += "and-" return res
res += num_to_str(n % 100, "")

match = res[:-1]
if __name__ == "__main__":
return 1 if B == match else 0 A = input()
B = input()
def num_to_str(n, s): print(solve(A,B))
ones = ["", "one-", "two-", "three-", "four-", "five-", "six-",
"seven-", "eight-", "nine-", "ten-", "eleven-", "twelve-",
"thirteen-", "fourteen-", "fifteen-", "sixteen-", "seventeen-",
"eighteen-", "nineteen-"]

tens = ["", "", "twenty-", "thirty-", "forty-", "fifty-", "sixty-",

"seventy-", "eighty-", "ninety-"]
Minimum Appends for Palindrome!
Problem Description
Given a string A consisting of lowercase characters.
We need to tell minimum characters to be appended (insertion at end) to make the string A a palindrome.
Problem Constraints
1 <= |A| <= 105
A consists only of lower-case characters.

Input Format
First argument is an string A.
Output Format
Return a integer denoting the minimum characters to be appended (insertion at end) to make the string A a palindrome.

Example Input
Input 1:A = "abede"
Input 2: A = "aabb"
Example Output
Output 1: 2
Output 2: 2

Example Explanation
Explanation 1: We can make string palindrome as "abedeba" by adding ba at the end of the string.
Explanation 2: We can make string palindrome as "aabbaa" by adding aa at the end of the string.
def solve(s):
ans = 0
n = len(s)
i=0
j=n-1

while i <= j:
if s[i] == s[j]:
i += 1
j -= 1
else:
ans = i + 1
i += 1
j=n-1

return ans

if __name__ == "__main__":
s = input()
print(solve(s))
Serialize
Problem Description
You are given an array A of strings and we have to serialize it and return the serialized string.
Serialization: Scan each element in a string, calculate its length and append it with a string and a element separator or
deliminator (the deliminator is ~). We append the length of the string so that we know the length of each element.
For example, for a string 'interviewbit', its serialized version would be 'interviewbit12~'.

Problem Constraints
1 <= |A| <= 1000
1 <= |Ai| <= 1000
Ai only contains lowercase english alphabets.

Input Format
The first argument A is the string array A.
Output Format
Return a single integer denoting the serialized string.

Example Input Example Explanation

Input 1: A = ['scaler', 'academy'] Explanation 1: Length of 'scaler' is 6 and academy is 7. So, the
Input 2: A = ['interviewbit'] resulting string is scaler6~academy7~.
Example Output Explanation 2: Explained in the description above.
Output 1: scaler6~academy7~
Output 2: interviewbit12~
def serialize(A):
B = []
str1 = ''
for i in A:
B.append(i+str(len(i))+'~')
for j in B :
str1 = str1 + j

return str1

if __name__ == "__main__":
A = input().split()
print(serialize(A))
Deserialize
Problem Description
You are given a string A which is a serialized string. You have to restore the original array of strings.
The string in the output array should only have lowercase english alphabets.
Serialization: Scan each element in a string, calculate its length and append it with a string and a element separator or
deliminator (the deliminator is ~). We append the length of the string so that we know the length of each element.
For example, for a string 'interviewbit', its serialized version would be 'interviewbit12~'.
Problem Constraints
1 <= |A| <= 106

Input Format
The first argument is the string A.
Output Format
Return an array of strings which are deserialized.

Example Input
Input 1: A = 'scaler6~academy7~' Example Explanation
Input 2: A = 'interviewbit12~' Explanation 1: Length of 'scaler' is 6 and academy is 7. So, the
resulting string is scaler6~academy7~. We hve to reverse the
Example Output process.
Output 1: ['scaler', 'academy'] Explanation 2: Explained in the description above.
Output 2: ['interviewbit']
def deserialize(A):
ans = []
s = ""
for ch in A:
if ch.isdigit():
continue
elif ch == '~':
ans.append(s)
s = ""
else:
s += ch
return ans

if __name__ == "__main__":
A = input()
print(deserialize(A))
String And Its Frequency
Problem Description
Given a string A with lowercase english alphabets and you have to return a string in which, with each character its frequency is
written in adjacent.
Problem Constraints
1 <= |A| <= 105

Input Format
First argument is the string A with lowercase english alphabets.
Output Format
Return a string in which each character frequency is written in adjacent.

Example Input
Input 1: abbhuabcfghh
Input 2: a
Example Output
Ouput 1: a2b3h3u1c1f1g1
Ouput 2: a1

Example Explanation
Explanation 1: ‘a’ occurs in the string a total of 2 times so we write a2 then ‘b’ occurs a total of 3 times so next we write b3 and so
on
Explanation 2: ‘a’ occurs in the string a total of 1 time only.
def solve(A):
d = {}
s=''
for i in A:
if i in d:
d[i] += 1
else:
d[i] = 1
for i in A:
if d[i] != 0:
s+=i+str(d[i])
d[i] = 0
return s

if __name__ == "__main__":
A = input()
print(solve(A))
Bulls and Cows
Problem Description
You are playing the Bulls and Cows game with your friend.
You write down a secret number and ask your friend to guess what the number is. When your friend makes a guess, you
provide a hint with the following info:
The number of "bulls", which are digits in the guess that are in the correct position. The number of "cows", which are digits in
the guess that are in your secret number but are located in the wrong position. Specifically, the non-bull digits in the guess that
could be rearranged such that they become bulls.
Given the secret number secret and your friend's guess guess, return the hint for your friend's guess.
The hint should be formatted as "xAyB", where x is the number of bulls and y is the number of cows. Note that both secret and
guess may contain duplicate digits.

Problem Constraints
1 <= secret.length, guess.length <= 100000 secret.length == guess.length secret and guess consist of digits only.

Input Format
First argument is string denoting secret string
Second argument is string denoting guess string

Output Format
Return the hint for you friend's guess.
Example Input
Input 1: secret = "1807", guess = "7810"
Input 2: secret = "1123", guess = "0111"

Example Output
Ouput 1:"1A3B"
Ouput 2:"1A1B"

Example Explanation
Explanation 1:Bulls are connected with a '|': "1807" | "7810"
Explanation 2:Bulls are connected with a '|' "1123" "1123" | or | "0111" "0111" Note that only
one of the two unmatched 1s is counted as a cow since the non-bull digits can only be
rearranged to allow one 1 to be a bull.
def solve(A, B):
g_ump = defaultdict(int)
s_ump = defaultdict(int)
count = 0
for i in range(len(A)):
if A[i] == B[i]:
count += 1
g_ump[A[i]] += 1
s_ump[B[i]] += 1
count2 = 0
for ch, num in s_ump.items():
if ch in g_ump:
if num < g_ump[ch]:
count2 += num
else:
count2 += g_ump[ch]
ans2 = count2 - count
return str(count) + "A" + str(ans2) + "B"

if __name__ == "__main__":
A = input()
B = input()
print(solve(A,B))
Self Permutation
Problem Description
You are given two strings A and B. Check whether there exists any permutation of both A and B such that they are equal.
Return a single integer 1 if its exists, 0 otherwise.

Problem Constraints
1 <= |A|, |B| <= 105
Both strings contain only lowercase english alphabets.

Input Format
The first argument is the string A. The second argument is the string B.

Output Format
Return a single integer 1 if a permutation exists, 0 otherwise.

Example Input
Input 1: A = 'scaler' B = 'relasc'
Input 2: A = 'scaler' B = 'interviewbit'

Example Output Example Explanation

Output 1: 1 Explanation 1: We can rearrange the second string to 'scaler', hence, a permuation exists.
Output 2: 0 Explanation 2: The given length of the two strings itself is different. There is no possible
permutation.
def permuteStrings(A, B):
if not len(A) == len(B):
return 0
else:
if not set(A) == set(B):
return 0
else:
return 1

if __name__ == "__main__":
A = input()
B = input()
print(permuteStrings(A,B))
Salutes
Problem Description
In a long hallway some soldiers are walking from left to right and some from right to left all at the same speed.
Every time while walking they cross through another soldier they salute and move ahead.
Given a string A of length N showing the soldiers' direction they are walking. '<' denotes a soldier is walking from right to left,
and '>' denotes a soldier is walking from left to right. Return the number of Salutes done.

Problem Constraints
1 <= N <= 105
A = {'<', '>'}

Input Format
The first argument is a string A.
Output Format
Return a single integer denoting the number of salutes done.

Example Input
Input 1: A = '>>><<<'
Input 2: A = '<>'

Example Output
Output 1: 9
Output 2: 0
def countSalutes(A):
c=0
ans = 0
for i in range(len(A)):
if A[i] == '>':
c += 1
else:
ans += c
return ans

if __name__ == "__main__":
A = input()
print(countSalutes(A))