"""GCA Practice""""""Mutate the array----------------Given an integer n and an array a of length n, your task is to apply the following mutation to a:Array a mutates into a new array b of length n.For each i from 0 to n - 1, b[i] = a[i - 1] + a[i] + a[i + 1].If some element in the sum a[i - 1] + a[i] + a[i + 1] does not exist, it should be set to 0. For example, b[0] should be equal to 0 + a[0] + a[1].
ExampleFor n = 5 and a = [4, 0, 1, -2, 3], the output should be mutateTheArray(n, a) = [4, 5, -1, 2, 1].b[0] = 0 + a[0] + a[1] = 0 + 4 + 0 = 4b[1] = a[0] + a[1] + a[2] = 4 + 0 + 1 = 5b[2] = a[1] + a[2] + a[3] = 0 + 1 + (-2) = -1b[3] = a[2] + a[3] + a[4] = 1 + (-2) + 3 = 2b[4] = a[3] + a[4] + 0 = (-2) + 3 + 0 = 1So, the resulting array after the mutation will be [4, 5, -1, 2, 1]"""a = [4,0,1,-2,3]n =5# passingdefmutateTheArray(n,a):iflen(a)<2:return a result = []for i inrange(len(a)):# if i = 0 then i - 1 does not exist so [i-1] becomes 0 and we can# just leave it offif i ==0: result.append(a[i] + a[i +1])# if i is pointing to the last element then [i + 1] does not exist so# it becomes 0 and we can just leave that offelif i ==len(a)-1: result.append((a[i -1] + a[i]))# for all other cases just do the normal equationelse: result.append(a[i -1] + a[i] + a[i +1])return result# print(mutateTheArray(n, a))"""Alternating sortYou are given an array of integers a. A new array b is generated by rearranging the elements of a in the following way:b[0] is equal to a[0];b[1] is equal to the last element of a;b[2] is equal to a[1];b[3] is equal to the second-last element of a;b[4] is equal to a[2];b[5] is equal to the third-last element of a;and so on.Here is how this process works:Your task is to determine whether the new array b is sorted in strictly ascending order or not.ExampleFor a = [1, 3, 5, 6, 4, 2], the output should be alternatingSort(a) = true.The new array b will look like [1, 2, 3, 4, 5, 6], which is in strictly ascending order, so the answer is true.For a = [1, 4, 5, 6, 3], the output should be alternatingSort(a) = false.The new array b will look like [1, 3, 4, 6, 5], which is not in strictly ascending order, so the answer is false."""a = [1,3,5,6,4,2]# a = [1, 4, 5, 6, 3]# a = [-92, -23, 0, 45, 89, 96, 99, 95, 89, 41, -17, -48]a = [-91,-84,-67,-44,9,70,88,37,-11,-67,-72,-87]a = [-99,-29,-7,17,28,71,98,86,42,22,0,-29,-86]# passingfrom collections import dequedefalternatingSort(a): a =deque(a)iflen(a)<2:returnTrueif a == []:returnFalse# array to hold result b = []# sorted a without duplicates to check against result array to see if# result is sorted or not match =sorted(set(a))# while a still has numbers to sort into result arraywhilelen(a)>0:# if there is an even number of items leftiflen(b)%2==0:# remove first element and add to result b.append(a.popleft())# else if there is an odd number of items leftelse:# remove last element and add it to the result b.append(a.pop())# if result == the original array sorted then return True else return Falseif b == match:returnTruereturnFalse# print(alternatingSort(a))"""Tiny pairs----------You are given two arrays of integers a and b of the same length, and an integer k. We will be iterating through array a from left to right, and simultaneously through array b from right to left, and looking at pairs (x, y), where x is from a and y is from b. Such a pair is called tiny if the concatenation xy is strictly less than k.
Your task is to return the number of tiny pairs that you'll encounter during the simultaneous iteration through a and b.
ExampleFor a = [1, 2, 3], b = [1, 2, 3], and k = 31, the output should becountTinyPairs(a, b, k) = 2.We're considering the following pairs during iteration:(1, 3). Their concatenation equals 13, which is less than 31, so the pair is tiny;(2, 2). Their concatenation equals 22, which is less than 31, so the pair is tiny;(3, 1). Their concatenation equals 31, which is not less than 31, so the pair is not tiny.As you can see, there are 2 tiny pairs during the iteration, so the answer is 2.For a = [16, 1, 4, 2, 14], b = [7, 11, 2, 0, 15], and k = 743, the output should becountTinyPairs(a, b, k) = 4.We're considering the following pairs during iteration:(16, 15). Their concatenation equals 1615, which is greater than 743, so the pair is not tiny;(1, 0). Their concatenation equals 10, which is less than 743, so the pair is tiny;(4, 2). Their concatenation equals 42, which is less than 743, so the pair is tiny.(2, 11). Their concatenation equals 211, which is less than 743, so the pair is tiny;(14, 7). Their concatenation equals 147, which is less than 743, so the pair is tiny.There are 4 tiny pairs during the iteration, so the answer is 4."""a = [16,1,4,2,14]b = [7,11,2,0,15]k =743# passingdefcountTinyPairs(a,b,k):# variable to hold the number of tiny pairs we've encountered pairs =0# index of the last number in the array b_index =len(b)-1# iterate the arrayfor i inrange(len(a)):# if the integer value of the string concatenation of the number at# the first index and the number at the last index is less than K# we found a tiny pair and can increment the pairs value + 1ifint(str(a[i]) +str(b[b_index]))< k: pairs +=1# decrement the last index to check the next to last number b_index -=1# return the number of pairs foundreturn pairs# print('pairs', countTinyPairs(a, b, k))"""Merging Strings---------------You are implementing your own programming language and you've decided to add support for merging strings. A typical merge function would take two strings s1 and s2, and return the lexicographically smallest result that can be obtained by placing the symbols of s2 between the symbols of s1 in such a way that maintains the relative order of the characters in each string.
For example, if s1 = "super" and s2 = "tower", the result should be merge(s1, s2) = "stouperwer".You'd like to make your language more unique, so for your merge function, instead of comparing the characters in the usual lexicographical order, you'll compare them based on how many times they occur in their respective strings (fewer occurrences means the character is considered smaller). If the number of occurrences are equal, then the characters should be compared in the usual lexicographical way. If both number of occurences and characters are equal, you should take the characters from the first string to the result.
Given two strings s1 and s2, return the result of the special merge function you are implementing.ExampleFor s1 = "dce" and s2 = "cccbd", the output should bemergeStrings(s1, s2) = "dcecccbd".All symbols from s1 goes first, because all of them have only 1 occurrence in s1 and c has 3 occurrences in s2.For s1 = "super" and s2 = "tower", the output should bemergeStrings(s1, s2) = "stouperwer".Because in both strings all symbols occur only 1 time, strings are merged as usual. You can find explanation for this example on the image in the description.
Input/Output[execution time limit] 4 seconds (py3)[input] string s1A string consisting only of lowercase English letters.Guaranteed constraints:1 ≤ s1.length ≤ 104.[input] string s2A string consisting only of lowercase English letters.Guaranteed constraints:1 ≤ s2.length ≤ 104.[output] stringThe string that results by merging s1 and s2 using your special merge function."""s1 ="super"s2 ="tower"s1 ="dce"s2 ="cccbd"s1 ="kkihj"s2 ="jbsmfoftph"expected ="jbsmfoftphkkihj"s1 ="ougtaleegvrabhugzyx"s2 ="wvieaqgaegbxg"output ="owvieaqugaegbxggtaleegvrabhugzyx"expected ="owvieaqugtaleegvrabhugzyxgaegbxg"# fully passingdefmergeStrings(s1,s2):# variable to hold the result result =''# variable to hold the current index of the longer of the two strings s2_index =0# variable to hold the current index of the shorter of the two strings s1_index =0# variables for the s2 string and the s1 string# s2 = ''# s1 = ''# logic to find the s2 and s1 strings from the given strings# if len(s1) > len(s2):# s2 = s1# s1 = s2# else:# s2 = s2# s1 = s1# hash maps for each string to hold the number of occurrences of each# letter s1_map ={} s2_map ={}# logic creating the hash mapsfor letter in s1:if letter notin s1_map: s1_map[letter]=0 s1_map[letter]+=1for letter in s2:if letter notin s2_map: s2_map[letter]=0 s2_map[letter]+=1# print('s1 map:', s1_map)# print('s2 map:', s2_map)# while the s1 string current index is less than the s1 string length# and the s2 string index is shorter than the s2 string length# (keeps us from index out of bounds error)while s1_index <len(s1)and s2_index <len(s2):# print('s1', s1)# print('s2', s2)# print('result:', result)# print('compare', 's1', s1[s1_index], 's2', s2[s2_index])# my print statements for debugging# print('i', i)# print('s2_index', s2_index)# print(chr(max(ord(s1[i]), ord(s2[s2_index]))))# if the letter count for the s1 string letter at current s1# string index is less than the letter count for the s2 string# letter at current s2 string indexif s1_map[s1[s1_index]]< s2_map[s2[s2_index]]:# print('s1 i', s1[i])# print('count', s1_map[s1[i]])# print('s2 i', s2[s2_index])# print('count', s2_map[s2[s2_index]])# add the letter from the s1 string at the current index to# the result result += s1[s1_index]# increment the s1 string current index s1_index +=1# if the letter count for the s1 string letter at the current# index is greater than the letter count for the s2 string letter# at current s2 string indexelif s1_map[s1[s1_index]]> s2_map[s2[s2_index]]:# add the letter from the s2 string at the current index to the# result result += s2[s2_index]# increment the s2 string current index s2_index +=1# if both letter have the same number of occurrences in their# respective stringselse:iford(s1[s1_index])==ord(s2[s2_index]): result += s1[s1_index] s1_index +=1else:# add the letter that comes first sequentially result +=chr(min(ord(s1[s1_index]), ord(s2[s2_index])))# if the s2 string letter was addediford(s1[s1_index])>ord(s2[s2_index]):# increment the s2 string current index s2_index +=1# else if the s1 string letter was addedelse:# increment the s1 string current index s1_index +=1# if the s1 string index is at the end of the string# we have added all the letters in that string and can just add the rest# of the letters in the s2 string to the result in the order they are inif s1_index ==len(s1):# add rest of the s2 string from the current index to the end of# the string result += s2[s2_index:]# if the s2 string index is at the end of the string# we have added all the letters in that string and can just add the rest# of the letters in the s1 string to the result in the order they are inif s2_index >=len(s2):# add rest of the s1 string from the current index to the end of# the string result += s1[s1_index:]# return the resultreturn result# print('merge strings', mergeStrings(s1, s2))"""Concatenations Sum------------------Given an array of positive integers a, your task is to calculate the sum of every possible a[i] ∘ a[j], where a[i] ∘ a[j] is the concatenation of the string representations of a[i] and a[j] respectively.
ExampleFor a = [10, 2], the output should be concatenationsSum(a) = 1344.a[0] ∘ a[0] = 10 ∘ 10 = 1010,a[0] ∘ a[1] = 10 ∘ 2 = 102,a[1] ∘ a[0] = 2 ∘ 10 = 210,a[1] ∘ a[1] = 2 ∘ 2 = 22.So the sum is equal to 1010 + 102 + 210 + 22 = 1344.For a = [8], the output should be concatenationsSum(a) = 88.There is only one number in a, and a[0] ∘ a[0] = 8 ∘ 8 = 88, so the answer is 88.For a = [1, 2, 3], the output should be concatenationsSum(a) = 198.a[0] ∘ a[0] = 1 ∘ 1 = 11,a[0] ∘ a[1] = 1 ∘ 2 = 12,a[0] ∘ a[2] = 1 ∘ 3 = 13,a[1] ∘ a[0] = 2 ∘ 1 = 21,a[1] ∘ a[1] = 2 ∘ 2 = 22,a[1] ∘ a[2] = 2 ∘ 3 = 23,a[2] ∘ a[0] = 3 ∘ 1 = 31,a[2] ∘ a[1] = 3 ∘ 2 = 32,a[2] ∘ a[2] = 3 ∘ 3 = 33.The total result is 11 + 12 + 13 + 21 + 22 + 23 + 31 + 32 + 33 = 198."""a = [8]a = [1,2,3]# a = [0, 0]# needs to be optimized to pass all tests currently 250/300# def concatenationsSum(a):# # variable for the result of the integer addition of concatenated strings# result = 0# # variables for the current index and the index of the number being added# front_index = 0# back_index = 0# # iterate the array# while front_index < len(a):# # if the number being added is the last one# if back_index == len(a) - 1:# # do the concatenation# result += int(str(a[front_index]) + str(a[back_index]))# # increment the current index# front_index += 1# # reset the sum index to 0# back_index = 0# # otherwise just do the concatenation and increase the index of# # number being added# else:# result += int(str(a[front_index]) + str(a[back_index]))# back_index += 1## # return the result# return resultdefconcatenationsSum(a):# UPER# Understand:# we're going to need to return an int after concatenating strings --> int(str() ...)# Need a sum: start it at 0 concatentations_sum =0# "every possible a[i] and a[j]" --> 2 indices, or 2 nested for loops# iterate over the array# for each index front_index:for front_index inrange(len(a)):# front_index is the index of the first element (front of the concatenation)# visit every other index to hit the possible combinations# for each front_index, we want to visit _every_ j / back_index (even if j == i, or j < i)for back_index inrange(len(a)):# back_index is the index of the second / back of the concatenation# how do we concatenate?# we need to convert to strings using str# # str(a[front_index]), str(a[back_index])# front_string = str(a[front_index])# back_string = str(a[back_index])# concatenate the strings using + concatenated_string =str(front_string)+str(back_string)# convert back to int using int() concatenated_int =int(concatenated_string)# add the result of ^ to sum concatentations_sum += concatenated_intreturn concatentations_sum#test_cases = [ ([10,2],1344), ([8],88), ([1,2,3],198),]forinput, output in test_cases:print(f"For input: {input} expecting {output}") actual_output =concatenationsSum(input)print(f"Actual output: {actual_output}")print("----")# print(concatenationsSum(a))"""HashMapYou've created a new programming language, and now you've decided to add hashmap support to it. Actually you are quite disappointed that in common programming languages it's impossible to add a number to all hashmap keys, or all its values. So you've decided to take matters into your own hands and implement your own hashmap in your new language that has the following operations:
insert x y - insert an object with key x and value y.get x - return the value of an object with key x.addToKey x - add x to all keys in map.addToValue y - add y to all values in map.To test out your new hashmap, you have a list of queries in the form of two arrays: queryTypes contains the names of the methods to be called (eg: insert, get, etc), and queries contains the arguments for those methods (the x and y values).
Your task is to implement this hashmap, apply the given queries, and to find the sum of all the results for get operations.
ExampleFor queryType = ["insert", "insert", "addToValue", "addToKey", "get"] and query = [[1, 2], [2, 3], [2], [1], [3]], the output should be hashMap(queryType, query) = 5.
The hashmap looks like this after each query:1 query: {1: 2}2 query: {1: 2, 2: 3}3 query: {1: 4, 2: 5}4 query: {2: 4, 3: 5}5 query: answer is 5The result of the last get query for 3 is 5 in the resulting hashmap.For queryType = ["insert", "addToValue", "get", "insert", "addToKey", "addToValue", "get"] and query = [[1, 2], [2], [1], [2, 3], [1], [-1], [3]], the output should be hashMap(queryType, query) = 6.
The hashmap looks like this after each query:1 query: {1: 2}2 query: {1: 4}3 query: answer is 44 query: {1: 4, 2: 3}5 query: {2: 4, 3: 3}6 query: {2: 3, 3: 2}7 query: answer is 2The sum of the results for all the get queries is equal to 4 + 2 = 6.Input/Output[execution time limit] 4 seconds (py3)[input] array.string queryTypeArray of query types. It is guaranteed that each queryType[i] is either "addToKey", "addToValue", "get", or "insert".Guaranteed constraints:1 ≤ queryType.length ≤ 105.[input] array.array.integer queryArray of queries, where each query is represented either by two numbers for insert query or by one number for other queries. It is guaranteed that during all queries all keys and values are in the range [-109, 109].
Guaranteed constraints:query.length = queryType.length,1 ≤ query[i].length ≤ 2.[output] integer64The sum of the results for all get queries."""queryType = ["insert","addToValue","get","insert","addToKey","addToValue","get"]query = [[1,2], [2], [1], [2,3], [1], [-1], [3]]queryType = ["insert","insert","addToValue","addToKey","get"]query = [[1,2], [2,3], [2], [1], [3]]# this is not currently passing all tests but mostdefhashMap(queryType,query):# we want to build on top of pythons built in {}# we need our hashmap {} hash_map ={}# make helper functions for the different queries (get, insert, addToValue, addToKey) sum_of_gets =0# iterate through queryType and query and call the corresponding helper functionsfor i inrange(len(queryType)): method_name = queryType[i] parameters = query[i]# print(method_name, parameters)if method_name =="insert": hash_map =handle_insert(hash_map, parameters)elif method_name =="get": value =handle_get(hash_map, parameters) sum_of_gets += valueelif method_name =="addToKey": hash_map =handle_add_to_key(hash_map, parameters)elif method_name =="addToValue": hash_map =handle_add_to_value(hash_map, parameters)return sum_of_gets# keep track of the sum of get queriesdefhandle_insert(hash_map,parameters): key = parameters[0] value = parameters[1] hash_map[key]= valuereturn hash_mapdefhandle_get(hash_map,parameters): key = parameters[0]return hash_map[key]defhandle_add_to_key(hash_map,parameters): offset = parameters[0]# add `offset` to every key in hash_map# safer to create a new dictionary new_hash_map ={}# iterate through the keys and values in the old dictionaryfor key, value in hash_map.items():# add `offset` to the key and put it into the new dictionary new_key = key + offset new_hash_map[new_key]= valuereturn new_hash_mapdefhandle_add_to_value(hash_map,parameters): offset = parameters[0]# we want to add offset to every value in hash_mapfor key, value in hash_map.items(): new_value = value + offset hash_map[key]= new_valuereturn hash_maptest_cases = [{"queryType": ["insert","insert","addToValue","addToKey","get"],"query": [[1,2], [2,3], [2], [1], [3]],"expected_output":5},{"queryType": ["insert","addToValue","get","insert","addToKey","addToValue","get"],"query": [[1,2], [2], [1], [2,3], [1], [-1], [3]],"expected_output":6},{"queryType": ["addToKey","addToKey","insert","addToValue","addToValue","get","addToKey","insert","addToKey","addToValue"],"query": [[-3], [-1], [0,-3], [3], [-1], [0], [-1], [-4,-5], [-1], [-4]],"expected_output":-1},{"queryType": ["insert","insert","addToKey","addToKey","addToKey","insert","addToValue","addToKey","addToKey","get"],"query": [[-5,-2], [2,4], [-1], [-3], [1], [3,-2], [-4], [-2], [2], [-8]],"expected_output":-6},{"queryType": ["insert","get","insert","addToValue","addToValue","addToValue","insert","addToKey","get","insert"],"query": [[2,1], [2], [1,3], [-1], [0], [3], [4,-5], [3], [4], [1,1]],"expected_output":6},{"queryType": ["addToValue","addToValue","insert","get","addToKey","insert","insert","insert","addToValue","addToKey"],"query": [[-5], [3], [3,-3], [3], [0], [-4,2], [0,-3], [-2,4], [2], [2]],"expected_output":-3},{"queryType": ["addToKey","addToKey","insert","addToKey","addToValue","addToKey","addToValue","insert","get","insert"],"query": [[-1], [-3], [4,3], [2], [2], [-2], [0], [-5,3], [-5], [3,-4]],"expected_output":3},{"queryType": ["insert","insert","insert","get","insert","insert","insert","addToKey","insert","insert"],"query": [[3,-4], [-4,3], [4,-3], [4], [-5,0], [-2,-5], [2,2], [1], [-5,-2], [1,3]],"expected_output":-3},{"queryType": ["addToValue","addToKey","addToKey","insert","addToValue","addToValue","insert","get","get","insert"],"query": [[-2], [-3], [0], [-3,1], [-2], [-4], [2,-4], [2], [2], [3,-1]],"expected_output":-8}]for test_case in test_cases: query_type = test_case['queryType'] query = test_case['query']print(f"Input:\nqueryType: {query_type}\nquery: {query}\nexpected_output: {test_case['expected_output']}") actual_output =hashMap(query_type, query)print(f"Actual output: {actual_output}")print("-----")"""Mean Groups -----------You are given an array of arrays a. Your task is to group the arrays a[i] by their mean values, so that arrays with equal mean values are in the same group, and arrays with different mean values are in different groups.
Each group should contain a set of indices (i, j, etc), such that the corresponding arrays (a[i], a[j], etc) all have the same mean. Return the set of groups as an array of arrays, where the indices within each group are sorted in ascending order, and the groups are sorted in ascending order of their minimum element.
ExampleFora = [[3, 3, 4, 2], [4, 4], [4, 0, 3, 3], [2, 3], [3, 3, 3]]the output should bemeanGroups(a) = [[0, 4], [1], [2, 3]]mean(a[0]) = (3 + 3 + 4 + 2) / 4 = 3;mean(a[1]) = (4 + 4) / 2 = 4;mean(a[2]) = (4 + 0 + 3 + 3) / 4 = 2.5;mean(a[3]) = (2 + 3) / 2 = 2.5;mean(a[4]) = (3 + 3 + 3) / 3 = 3.There are three groups of means: those with mean 2.5, 3, and 4. And they form the following groups:Arrays with indices 0 and 4 form a group with mean 3;Array with index 1 forms a group with mean 4;Arrays with indices 2 and 3 form a group with mean 2.5.Note that neithermeanGroups(a) = [[0, 4], [2, 3], [1]]normeanGroups(a) = [[0, 4], [1], [3, 2]]will be considered as a correct answer:In the first case, the minimal element in the array at index 2 is 1, and it is less then the minimal element in the array at index 1, which is 2.
In the second case, the array at index 2 is not sorted in ascending order.Fora = [[-5, 2, 3], [0, 0], [0], [-100, 100]]the output should bemeanGroups(a) = [[0, 1, 2, 3]]The mean values of all of the arrays are 0, so all of them are in the same group."""a = [[0,4], [2,3], [1]]a = [[3,3,4,2], [4,4], [4,0,3,3], [2,3], [3,3,3]]# passing all testsdefmeanGroups(a):# create dict to hold mean and arrays w that mean means ={}# iterate outer arrayfor i inrange(len(a)):# get the mean for each inner arraysum=0for num in a[i]:sum+= num mean =sum/len(a[i])# hold array and mean in dictionaryif mean notin means: means[mean]= [] means[mean].append(i)# return the set of each unique mean with first occurring inner array listed first result = []for mean in means: result.append(means[mean])return result# print(meanGroups(a))