Programming
Aptitude
Syllabus
Interview Preparation
Interview Exp.
Off Campus
0
Notifications Mark All Read
- Login
- Get Prime
0
Atlassian Coding Questions and Answers
Atlassian Coding Questions with Solutions
In this page, you will find out Atlassian Coding Questions and Answers asked in Online Assessments and Technical Interviews involved in the Recruitment Process of the Company. Apart from that you will get more Insights Company’s Job Profile, Job Location, CTC Offered, Steps involved in the recruitment process, etc.
About Atlassian
Atlassian is an Australian software company that specializes in providing collaboration and development tools for teams and organizations. Founded in 2002 by Mike Cannon-Brookes and Scott Farquhar. Some of their well-known software tools include Jira, Confluence, Trello, Bitbucket, and Jira Service Management.
They operate on a subscription-based licensing system, where customers pay a recurring fee to access and use their products. This approach allows for continuous updates, improvements, and customer support. The company went public in 2015 and is listed on the NASDAQ stock exchange under the ticker symbol “TEAM.”
About Atlassian Recruitment Process
Atlassian Recruitment Process consists of the following steps :
- Online Coding Assessment
- Technical Interview [2 Rounds]
- HR Interview
We have mentioned further details of the Atlassian Recruitment Process in the following Tabular Form
| Atlassian | Related Information |
|---|---|
| Position : | Software Development Engineer |
| Course : |
|
| Eligibility Criteria / Academic Qualification Required : |
|
| CTC Breakdown: |
|
| Selection Process : |
|
RSU's will be offered to the Employee in 4 consecutive years of Employment:
Prime Course Trailer
Related Banners
Get PrepInsta Prime & get Access to all 200+ courses offered by PrepInsta in One Subscription
Sample Atlassian Coding Questions with Solutions
Question 1: Match Substring After Replacement
Given two strings, s, and sub, along with a 2D character array mappings, we want to determine if it is possible to make the sub a substring of s by replacing characters according to the provided mappings. Each mapping consists of a pair [oldi, newi], indicating that we can replace the character oldi in sub with newi.
The replacement can be performed any number of times, but each character in sub can be replaced at most once.
We need to return true if it is possible to create sub as a substring of s using the given replacements, and false otherwise.
Example 1:
Input:
s = “fool3e7bar”
sub = “leet”
mappings = [[“e”,”3″],[“t”,”7″],[“t”,”8″]]
Output: True
Explanation:
We replace the first occurrence of ‘e’ in sub with ‘3’ and ‘t’ in sub with ‘7’, resulting in sub becoming “l3e7”. Now, “l3e7” is a substring of s, so we return true.
Example 2:
Input:
s = “fooleetbar”
sub = “f00l”
mappings = [[“o”,”0″]]
Output: False
Explanation:
The string “f00l” is not a substring of s, and no replacements can be made to create it. Additionally, we cannot replace ‘0’ with ‘o’, so it is not possible to create sub from s. Hence, we return false.
Example 3:
Input:
s = “Fool33tbaR”
sub = “leetd”
mappings = [[“e”,”3″],[“t”,”7″],[“t”,”8″],[“d”,”b”],[“p”,”b”]]
Output: True
Explanation:
We replace the first and second occurrences of ‘e’ in sub with ‘3’ and ‘d’ in sub with ‘b’, respectively. This transforms sub into “l33tb”, which is a substring of s. Therefore, we return true.
Constraints:
1 <= sub.length <= s.length <= 5000
0 <= mappings.length <= 1000
mappings[i].length == 2
oldi != newi
Both s and sub consist of uppercase and lowercase English letters and digits.
oldi and newi are either uppercase or lowercase English letters or digits.
#include<iostream>
#include<vector>
#include<unordered_map>
#include<unordered_set>
using namespace std;
class Solution {
public:
vector<int> compute_lps(string& s, unordered_map<char, unordered_set<char>>& m) {
vector<int> lps(s.size());
for (int i = 1, j = 0; i < s.size(); ++i) {
while (j && (s[i] != s[j] && m[s[i]].count(s[j]) == 0 && m[s[j]].count(s[i]) == 0))
j = max(0, lps[j] - 1);
j += s[i] == s[j] || m[s[i]].count(s[j]) || m[s[j]].count(s[i]);
lps[i] = j;
}
return lps;
}
bool matchReplacement(string s, string sub, vector<vector<char>>& mappings) {
unordered_map<char, unordered_set<char>> m;
for (auto& p : mappings)
m[p[0]].insert(p[1]);
auto lps = compute_lps(sub, m);
for (int i = 0, j = 0; i < s.size();) {
if (s[i] == sub[j] || m[sub[j]].count(s[i])) {
++i;
++j;
} else {
if (j != 0)
j = lps[j - 1];
else
i = i + 1;
}
if (j == sub.size())
return true;
}
return false;
}
};
int main() {
Solution solution;
// Example usage:
// string s = "fool3e7bar";
// string sub = "leet";
// vector<vector<char>> mappings = {{'e','3'}, {'t','7'}, {'t','8'}};
// string s = "fooleetbar";
// string sub = "f00l";
// vector<vector<char>> mappings = {{'o','0'}};
string s = "Fool33tbaR";
string sub = "leetd";
vector<vector<char>> mappings = {{'e','3'}, {'t','7'}, {'t','8'}, {'d','b'}, {'p','b'}};
bool result = solution.matchReplacement(s, sub, mappings);
cout << boolalpha << result << endl; // Output: true
return 0;
}
class Solution:
def compute_lps(self, s, m):
lps = [0] * len(s)
j = 0
for i in range(1, len(s)):
while j > 0 and (s[i] != s[j] and (s[i] not in m or s[j] not in m[s[i]])):
j = lps[j - 1]
j += int(s[i] == s[j] or (s[i] in m and s[j] in m[s[i]]))
lps[i] = j
return lps
def matchReplacement(self, s, sub, mappings):
m = {}
for p in mappings:
if p[0] not in m:
m[p[0]] = set()
m[p[0]].add(p[1])
lps = self.compute_lps(sub, m)
i, j = 0, 0
while i < len(s):
if s[i] == sub[j] or (sub[j] in m and s[i] in m[sub[j]]):
i += 1
j += 1
else:
if j != 0:
j = lps[j - 1]
else:
i += 1
if j == len(sub):
return True
return False
solution = Solution()
# Example usage:
s = "fool3e7bar"
sub = "leet"
mappings = [['e', '3'], ['t', '7'], ['t', '8']]
# s = "fooleetbar"
# sub = "f00l"
# mappings = [['o', '0']]
# s = "Fool33tbaR"
# sub = "leetd"
# mappings = [['e', '3'], ['t', '7'], ['t', '8'], ['d', 'b'], ['p', 'b']]
result = solution.matchReplacement(s, sub, mappings)
print(result) # Output: True
class Main {
public boolean matchReplacement(String s, String sub, char[][] mappings) {
int m = sub.length(), n = s.length();
final int RANGE = 'z' - '0' + 1;
boolean[][] multiMap = new boolean[RANGE][RANGE];
for (char[] map : mappings) {
char from = map[0], to = map[1];
multiMap[from - '0'][to - '0'] = true;
}
// Now, we use a naive string matching algorithm
// This will run in O(mn) time.
for (int i = 0; i < n - m + 1; i++) {
int j = 0;
while (j < m) {
char sc = s.charAt(i + j), subc = sub.charAt(j);
if (sc != subc && !multiMap[subc - '0'][sc - '0'])
break;
j++;
}
if (j == m)
return true;
}
return false;
}
public static void main(String[] args) {
Main main = new Main();
// Example usage:
// String s = "fool3e7bar";
// String sub = "leet";
// char[][] mappings = { { 'e', '3' }, { 't', '7' }, { 't', '8' } };
// String s = "fooleetbar";
// String sub = "f00l";
// char[][] mappings = { { 'o', '0' } };
String s = "Fool33tbaR";
String sub = "leetd";
char[][] mappings = { { 'e', '3' }, { 't', '7' }, { 't', '8' }, { 'd', 'b' }, { 'p', 'b' } };
boolean result = main.matchReplacement(s, sub, mappings);
System.out.println(result); // Output: true
}
}
Question 2: Queries for Count
The task is to determine the number of elements within a specified range in an unsorted array. Given an array of size n, the goal is to count the elements that fall between two given values, i and j, inclusively.
Examples:
Input:
Array: [1, 3, 3, 9, 10, 4]
Range 1: i = 1, j = 4
Range 2: i = 9, j = 12
Output:
For Range 1: 4
For Range 2: 2
Explanation:
In the first query, the numbers within the range 1 to 4 are 1, 3, 3, and 4.
In the second query, the numbers within the range 9 to 12 are 9 and 10.
#include<iostream>
#include<algorithm>
using namespace std;
int findLowerIndex(int arr[], int n, int x) {
int low = 0, high = n - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] >= x)
high = mid - 1;
else
low = mid + 1;
}
return low;
}
int findUpperIndex(int arr[], int n, int y) {
int low = 0, high = n - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] <= y)
low = mid + 1;
else
high = mid - 1;
}
return high;
}
int countElementsInRange(int arr[], int n, int x, int y) {
int count = 0;
count = findUpperIndex(arr, n, y) - findLowerIndex(arr, n, x) + 1;
return count;
}
int main() {
int arr[] = {1, 4, 4, 9, 10, 3};
int n = sizeof(arr) / sizeof(arr[0]);
sort(arr, arr + n);
int lowerRange = 1, upperRange = 4;
cout << countElementsInRange(arr, n, lowerRange, upperRange) << endl;
lowerRange = 9;
upperRange = 12;
cout << countElementsInRange(arr, n, lowerRange, upperRange) << endl;
return 0;
}
def find_lower_index(arr, x):
low, high = 0, len(arr) - 1
while low <= high:
mid = (low + high) // 2
if arr[mid] >= x:
high = mid - 1
else:
low = mid + 1
return low
def find_upper_index(arr, y):
low, high = 0, len(arr) - 1
while low <= high:
mid = (low + high) // 2
if arr[mid] <= y:
low = mid + 1
else:
high = mid - 1
return high
def count_elements_in_range(arr, x, y):
arr.sort()
lower_index = find_lower_index(arr, x)
upper_index = find_upper_index(arr, y)
count = upper_index - lower_index + 1
return count
arr = [1, 4, 4, 9, 10, 3]
lower_range = 1
upper_range = 4
print(count_elements_in_range(arr, lower_range, upper_range))
lower_range = 9
upper_range = 12
print(count_elements_in_range(arr, lower_range, upper_range))
import java.util.Arrays;
class Main {
static int findLowerIndex(int[] arr, int n, int x) {
int low = 0, high = n - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] >= x)
high = mid - 1;
else
low = mid + 1;
}
return low;
}
static int findUpperIndex(int[] arr, int n, int y) {
int low = 0, high = n - 1;
while (low <= high) {
int mid = (low + high) / 2;
if (arr[mid] <= y)
low = mid + 1;
else
high = mid - 1;
}
return high;
}
static int countElementsInRange(int[] arr, int n, int x, int y) {
int count = 0;
count = findUpperIndex(arr, n, y) - findLowerIndex(arr, n, x) + 1;
return count;
}
public static void main(String[] args) {
int[] arr = {1, 4, 4, 9, 10, 3};
int n = arr.length;
Arrays.sort(arr);
int lowerRange = 1, upperRange = 4;
System.out.println(countElementsInRange(arr, n, lowerRange, upperRange));
lowerRange = 9;
upperRange = 12;
System.out.println(countElementsInRange(arr, n, lowerRange, upperRange));
}
}
Question 3: Majority Element
The majority element in an array is defined as the element that appears more than ⌊n/2⌋ times, where n is the length of the array.
In other words, it is the element that occurs most frequently and makes up more than half of the array.
Given an array of integers, the task is to find the majority element and return it. If there is no majority element, If there is no majority element, the algorithm should indicate that.
Examples:
Example 1:
Input: [3, 3, 4, 2, 4, 4, 2, 4, 4]
Output: 4
Explanation:
In the given array, the number 4 appears 5 times, which is more than half of the array size (9/2 = 4.5). Therefore, 4 is the majority element.
Example 2:
Input: [1, 2, 3, 4, 4, 4, 4]
Output: 4
Explanation:
In this case, the number 4 appears 4 times, which is more than half of the array size (7/2 = 3.5). Thus, 4 is the majority element.
Example 3:
Input: [1, 2, 3, 4, 5]
Output: -1
Explanation:
There is no majority element in this array since no number appears more than half of the array size (5/2 = 2.5).
Example 4:
Input: [2, 2, 2, 3, 3, 4, 4, 4, 4]
Output: -1
Explanation:
In this case, although the number 4 appears 4 times, it does not occur more than half of the array size (9/2 = 4.5).
Hence, there is no majority element.
#include<iostream>
#include<vector>
int majorityElement(std::vector<int>& nums) {
int count = 0;
int candidate = 0;
for (int num : nums) {
if (count == 0) {
candidate = num;
count = 1;
} else if (num == candidate) {
count++;
} else {
count--;
}
}
return candidate;
}
int validateMajorityElement(std::vector<int>& nums, int candidate) {
int count = 0;
for (int num : nums) {
if (num == candidate) {
count++;
}
}
if (count > nums.size() / 2) {
return candidate;
} else {
return -1; // No majority element found
}
}
int findMajorityElement(std::vector<int>& nums) {
int candidate = majorityElement(nums);
return validateMajorityElement(nums, candidate);
}
int main() {
std::vector<int> nums = {3, 3, 4, 2, 4, 4, 2, 4, 4};
int result = findMajorityElement(nums);
if (result != -1) {
std::cout << "Majority Element: " << result << std::endl;
} else {
std::cout << "No majority element found." << std::endl;
}
return 0;
}
def majority_element(nums):
count = 0
candidate = None
for num in nums:
if count == 0:
candidate = num
count = 1
elif num == candidate:
count += 1
else:
count -= 1
return candidate
def validate_majority_element(nums, candidate):
count = 0
for num in nums:
if num == candidate:
count += 1
if count > len(nums) // 2:
return candidate
else:
return None
def find_majority_element(nums):
candidate = majority_element(nums)
return validate_majority_element(nums, candidate)
# Example usage
nums = [3, 3, 4, 2, 4, 4, 2, 4, 9]
result = find_majority_element(nums)
if result is not None:
print("Majority Element:", result)
else:
print("No majority element found.")
import java.util.HashMap;
import java.util.Map;
public class Main {
public static int majorityElement(int[] nums) {
int count = 0;
int candidate = 0;
for (int num : nums) {
if (count == 0) {
candidate = num;
count = 1;
} else if (num == candidate) {
count++;
} else {
count--;
}
}
return candidate;
}
public static int validateMajorityElement(int[] nums, int candidate) {
int count = 0;
for (int num : nums) {
if (num == candidate) {
count++;
}
}
if (count > nums.length / 2) {
return candidate;
} else {
return -1; // No majority element found
}
}
public static int findMajorityElement(int[] nums) {
int candidate = majorityElement(nums);
return validateMajorityElement(nums, candidate);
}
public static void main(String[] args) {
int[] nums = {3, 3, 4, 2, 4, 4, 2, 4, 4};
int result = findMajorityElement(nums);
if (result != -1) {
System.out.println("Majority Element: " + result);
} else {
System.out.println("No majority element found.");
}
}
}
Question 4: Nearest smaller Tower
Given an array representing the heights of towers, the task is to find, for each tower, the index of the nearest tower that is shorter than it.
The search for a shorter tower can be performed by looking to the left and right sides of each tower.
The following rules apply:
If there are two or more smaller towers at the same distance from the current tower, choose the tower with the smallest height.
If two towers have the same height, choose the one with the smaller index.
Example 1:
Input : Array: [1, 3, 2]
Output : Indexes: [-1, 0, 0]
Explanation:
For the tower at index 0, there is no tower shorter than it, so the output is -1.
For the tower at index 1 (height 3), there are two towers (heights 1 and 2) at the same distance. Following the rules, we choose the tower with the smallest height, which is at index 0.
For the tower at index 2 (height 2), the only tower shorter than it is at index 0.
Therefore, the final output is the array of indexes: [-1, 0, 0].
Example 2:
Input : Array : [4, 8, 3, 5, 3]
Output : Indexes: [2, 2, -1, 2, -1]
Explanation:
For the tower at index 0 (height 4), the nearest tower shorter than it is at index 2.
For the tower at index 1 (height 8), there are two towers (heights 4 and 3) at the same distance.
Following the rules, we choose the tower at index 2.
For the tower at index 2 (height 3), there is no tower shorter than it.
For the tower at index 3 (height 5), there are two towers (heights 3 and 3) at the same distance.
Following the rules, we choose the tower at index 2 because it has a smaller index.
For the tower at index 4 (height 3), there is no tower shorter than it.
Therefore, the final output is the array of indexes: [2, 2, -1, 2, -1].
#include<iostream>
#include<vector>
#include<stack>
#include<cmath>
class TowerFinder
{
public:
std::vector<int> findNearestShorterTower(std::vector<int> &towerHeights)
{
int n = towerHeights.size();
std::stack<int> leftStack, rightStack;
std::vector<int> result(n, -1);
for (int i = 0; i < n; i++)
{
while (!leftStack.empty() && towerHeights[leftStack.top()] >= towerHeights[i])
{
leftStack.pop();
}
if (!leftStack.empty())
{
result[i] = leftStack.top();
}
leftStack.push(i);
}
for (int i = n - 1; i >= 0; i--)
{
while (!rightStack.empty() && towerHeights[rightStack.top()] >= towerHeights[i])
{
rightStack.pop();
}
if (!rightStack.empty())
{
if (result[i] != -1)
{
if (std::abs(result[i] - i) == std::abs(rightStack.top() - i))
{
if (towerHeights[result[i]] > towerHeights[rightStack.top()])
result[i] = rightStack.top();
}
else if (std::abs(result[i] - i) > std::abs(rightStack.top() - i))
result[i] = rightStack.top();
}
else
result[i] = rightStack.top();
}
rightStack.push(i);
}
return result;
}
};
int main()
{
std::vector<int> towerHeights = {4,8,3,5,3};
TowerFinder towerFinder;
std::vector<int> nearestShorterTowers = towerFinder.findNearestShorterTower(towerHeights);
// Print the result
for (int i = 0; i < nearestShorterTowers.size(); i++)
{
std::cout << nearestShorterTowers[i] << " ";
}
std::cout << std::endl;
return 0;
}
class TowerFinder:
def find_nearest_shorter_tower(self, arr):
suff = []
n = len(arr)
find_suff = [0] * n # building suffix
for i in range(n - 1, -1, -1):
if len(suff) == 0:
find_suff[i] = -1
suff.append([arr[i], i])
else:
while suff:
if suff[-1][0] < arr[i]:
find_suff[i] = suff[-1][1]
break
suff.pop()
if len(suff) == 0:
find_suff[i] = -1
suff.append([arr[i], i])
pre = []
find_pre = [0] * n # building prefix
for i in range(n):
if len(pre) == 0:
find_pre[i] = -1
pre.append([arr[i], i])
else:
while pre:
if pre[-1][0] < arr[i]:
find_pre[i] = pre[-1][1]
break
pre.pop()
if len(pre) == 0:
find_pre[i] = -1
pre.append([arr[i], i])
new = [0] * n # comparing both
for i in range(n):
if find_suff[i] == -1:
new[i] = find_pre[i]
continue
if find_pre[i] == -1:
new[i] = find_suff[i]
continue
if abs(find_suff[i] - i) == abs(find_pre[i] - i):
if arr[find_suff[i]] >= arr[find_pre[i]]:
new[i] = find_pre[i]
else:
new[i] = find_suff[i]
elif abs(find_suff[i] - i) > abs(find_pre[i] - i):
new[i] = find_pre[i]
else:
new[i] = find_suff[i]
return new
# Test the code
tower_heights = [1, 3, 2]
tower_finder = TowerFinder()
nearest_shorter_towers = tower_finder.find_nearest_shorter_tower(tower_heights)
# Print the result
print(nearest_shorter_towers)
import java.util.*;
class Main {
public static int[] findNearestShorterTower(int[] towerHeights) {
int n = towerHeights.length;
Stack<Integer> leftStack = new Stack<>();
Stack<Integer> rightStack = new Stack<>();
int[] result = new int[n];
Arrays.fill(result, -1);
for (int i = 0; i < n; i++) {
while (!leftStack.empty() && towerHeights[leftStack.peek()] >= towerHeights[i]) {
leftStack.pop();
}
if (!leftStack.empty()) {
result[i] = leftStack.peek();
}
leftStack.push(i);
}
for (int i = n - 1; i >= 0; i--) {
while (!rightStack.empty() && towerHeights[rightStack.peek()] >= towerHeights[i]) {
rightStack.pop();
}
if (!rightStack.empty()) {
if (result[i] != -1) {
if (Math.abs(result[i] - i) == Math.abs(rightStack.peek() - i)) {
if (towerHeights[result[i]] > towerHeights[rightStack.peek()]) {
result[i] = rightStack.peek();
}
} else if (Math.abs(result[i] - i) > Math.abs(rightStack.peek() - i)) {
result[i] = rightStack.peek();
}
} else {
result[i] = rightStack.peek();
}
}
rightStack.push(i);
}
return result;
}
public static void main(String[] args) {
int[] towerHeights = {4,8,3,5,3};
int[] nearestShorterTowers = findNearestShorterTower(towerHeights);
// Print the result
for (int i = 0; i < nearestShorterTowers.length; i++) {
System.out.print(nearestShorterTowers[i] + " ");
}
System.out.println();
}
}
Question 5: Smallest window in a string containing all the characters of another string
Given two strings S and P, the task is to find the smallest window in string S that contains all the characters (including duplicates) of string P. If no such window exists, return “-1”. If there are multiple windows of the same length, return the one with the smallest starting index.
Note that all characters are lowercase alphabets.
Example 1:
Input:
S = “timetopractice”
P = “toc”
Output : toprac
Explanation: The smallest substring in S that contains “toc” is “toprac”.
Example 2:
Input:
S = “zoomlazapzo”
P = “oza”
Output:
apzo
Explanation:
The smallest substring in S that contains “oza” is “apzo”.
#include<climits>
#include<iostream>
#include<string>
using namespace std;
class WindowFinder {
public:
string findSmallestWindow(string s, string p) {
if (p.length() > s.length()) {
return "-1";
} else {
int sHash[26] = {0};
int pHash[26] = {0};
for (int i = 0; i < p.length(); i++) {
pHash[p[i] - 'a']++;
}
int counter = 0;
int begin = 0;
int startIndex = -1;
int length = 0;
int minLength = INT_MAX;
for (int i = 0; i < s.length(); i++) {
sHash[s[i] - 'a']++;
if (pHash[s[i] - 'a'] != 0 && sHash[s[i] - 'a'] <= pHash[s[i] - 'a']) {
counter++;
}
if (counter == p.length()) {
while (sHash[s[begin] - 'a'] > pHash[s[begin] - 'a'] || pHash[s[begin] - 'a'] == 0) {
if (sHash[s[begin] - 'a'] > pHash[s[begin] - 'a']) {
sHash[s[begin] - 'a']--;
}
begin++;
}
length = i - begin + 1;
if (length < minLength) {
startIndex = begin;
minLength = length;
}
}
}
if (startIndex == -1) {
return "-1";
} else {
return s.substr(startIndex, minLength);
}
}
}
};
// Test the code
int main() {
string s = "timetopractice";
string p = "toc";
WindowFinder windowFinder;
string smallestWindow = windowFinder.findSmallestWindow(s, p);
// Print the result
cout << smallestWindow << endl;
return 0;
}
class WindowFinder:
def find_smallest_window(self, s, p):
if len(p) > len(s):
return -1
shash = [0] * 26
phash = [0] * 26
for char in p:
phash[ord(char) - ord('a')] += 1
counter = 0
begin = 0
start_index = -1
length = 0
min_length = float('inf')
for i in range(len(s)):
shash[ord(s[i]) - ord('a')] += 1
if phash[ord(s[i]) - ord('a')] != 0 and shash[ord(s[i]) - ord('a')] <= phash[ord(s[i]) - ord('a')]:
counter += 1
if counter == len(p):
while shash[ord(s[begin]) - ord('a')] > phash[ord(s[begin]) - ord('a')] or phash[ord(s[begin]) - ord('a')] == 0:
if shash[ord(s[begin]) - ord('a')] > phash[ord(s[begin]) - ord('a')]:
shash[ord(s[begin]) - ord('a')] -= 1
begin += 1
length = i - begin + 1
if length < min_length:
start_index = begin
min_length = length
if start_index == -1:
return "-1"
else:
return s[start_index:start_index + min_length]
s = "timetopractice"
p = "toc"
window_finder = WindowFinder()
smallest_window = window_finder.find_smallest_window(s, p)
print(smallest_window)
public class Main{
public static String findSmallestWindow(String s, String p) {
int len1 = s.length();
int len2 = p.length();
if (len1 < len2) {
return "-1";
}
int[] patHash = new int[256];
int[] strHash = new int[256];
for (int i = 0; i < len2; i++) {
patHash[p.charAt(i)]++;
}
int start = 0;
int startIndex = -1;
int minLength = Integer.MAX_VALUE;
int count = 0;
for (int j = 0; j < len1; j++) {
strHash[s.charAt(j)]++;
if (patHash[s.charAt(j)] != 0 && strHash[s.charAt(j)] <= patHash[s.charAt(j)]) {
count++;
}
if (count == len2) {
while (strHash[s.charAt(start)] > patHash[s.charAt(start)] || patHash[s.charAt(start)] == 0) {
if (strHash[s.charAt(start)] > patHash[s.charAt(start)]) {
strHash[s.charAt(start)]--;
}
start++;
}
int windowLen = j - start + 1;
if (minLength > windowLen) {
minLength = windowLen;
startIndex = start;
}
}
}
if (startIndex == -1) {
return "-1";
} else {
return s.substring(startIndex, startIndex + minLength);
}
}
// Test the code
public static void main(String[] args) {
String s = "timetopractice";
String p = "toc";
String smallestWindow = findSmallestWindow(s, p);
// Print the result
System.out.println(smallestWindow);
}
}
FAQs related to Atlassian Coding Questions
Question 1: How much time does Atlassian Recruiting Team takes for starting On boarding process?
Atlassian’ Recruiting Team usually takes 20 – 25 days to On board freshers after Evaluating Technical Interview HR Interview performance.
Question 2: What are the other Job profile does Atlassian offers to Freshers ?
Atlassian widely offers various Job profiles to freshers like Software Development Engineer, SDE Intern, Cloud Engineer, Cloud Support Engineer, etc.
Get over 200+ course One Subscription
Courses like AI/ML, Cloud Computing, Ethical Hacking, C, C++, Java, Python, DSA (All Languages), Competitive Coding (All Languages), TCS, Infosys, Wipro, Amazon, DBMS, SQL and others
Login/Signup to comment