Evolved Packet Core elements

I know that the

EPC consists of Mobile management entity which is the control plane element allowing user plane traffic to bypass over a direct tunnel

I searched online but couldn’t understand.

Can someone please explain the functional elements (Servicing gateway and Packet data network gateway) in the EPC

Hover styling for non-clickable elements?

In our system, currently we have good styling and effects for buttons, for example submit button, cancel button etc.

enter image description here

Now we have a different element. Let’s say it is a summary tag element. Which acts as the summary information holder of a table.

But, on hover, it shows up a dropdown/tooltip with more information. Thats it, no fancy stuff. PLEASE NOTE THAT THE TAG IS NOT CLICKABLE AND DOES NOT LEAD ANYWHERE

So here we have 2 options.

1. With hover having styling or faded effect. But my dilemma here is that wouldn’t the user feel that it’s clickable?

enter image description here

2. With no styling on hover.

enter image description here

What do you think is the best option here? Is there any better/standard solution here?

Repeat elements in list, but the number of times each element is repeated is provided by a separate list

I’m trying to repeat each element of a list x number of times, where x is the corresponding element of the same position in another list.

For example, I have list A = {1,2,3,4} and another list B = {3,1,4,2} and I’m trying to get C = {1,1,1,2,3,3,3,3,4,4}.

How do I get C from A and B?


Algorithm Design: Efficient O(n) algorithm to get the ith to jth largest elements in an array

I am trying to design an efficient algorithm that retrieves the ith to jth largest elements in an array. For example, if the following array is the input:

[10, 14, 18, 3, 21, 25, 27] i = 2 j = 4 

The following array is returned:

[25, 21, 18] 

18 is the 4th largest element in the array and 25 is the 2nd smallest element in an array. I’ve done a problem where you retrieve a list of the K largest elements in an array: in such a problem, the solution is pretty trivial (using a fixed-size minimum heap of size K to keep track of the K largest elements). In this case however, a heap seems out of reach to use because the minimum heap can only remove the smallest element from the heap (removing the kth smallest element within the heap seems really inefficient).

I could do QuickSelect (j – i) times to get all the elements, but that means doing a linear O(n) walkthrough (j – i) times, which yields a total time complexity of O((j-i) * n), but I was thinking about if it’s possible to quicken the algorithm’s time complexity to just O(n). Is there an O(n) algorithm to solve this problem?

Generate all combinations of values that are less than array’s elements and have a sum = target

I want to find a way to generate sets that contain elements that sum to a certain target. Initially, I have an array that contains elements representing the maximum value that can be stored in that index.

For example, the input is [8,6,1] and the target is 10. The algorithm should produce all sets that have elements [ (<=8), (<=6), (<=1) ] such that their sum is equal to 10. Examples include: [8,1,1], [8,2,0], [7,3,0], …

A major consideration for this algorithm is that it should work on any input length (the above example has a length of 3).

I think the solution is close to the subset sum problem, but I wasn’t able to figure it out. Any help is appreciated.

Side note: python code is preferred, but Pseudo-code should be fine.


How do users know to hover over elements?

I realized something today. I was looking at a new icon at Airbnb’s site, and wanted to hover over it to see if there was anything hidden that would expose on hover: there was.

My question: How do users know when to hover to expose elements? Do they? Is that only because I’m an experienced user (also a UX Designer by profession)? I’m interested to see if any study was done on this matter.

Algorithm to count the number of subsets of size k with sum of all its elements minimum possible

An array is given eg:-1 2 2 2 and we need to count the number of subsets for it of size k which has the sum of elements minimum possible

here the subsets of size k=3 are:- 122 122 122 222

we see that there are 3 subsets having the minimum sum

I did this in bruteforce approach..first I stored the subsets of size k in a vector and then found the sum for each of the subsets and stored them in another vector and then counted the frequency of the minimum element

how to optimize it?