CareerCup

College Girl {844-77=79-280} Call Girls In Palam Vihar Locanto

College Girl {844-77=79-280} Call Girls In Zia Sarai Locanto

College Girl {844-77=79-280} Call Girls In Karol Bagh Locanto

College Girl {844-77=79-280} Call Girls In Jasola Vihar Locanto

College Girl {844-77=79-280} Call Girls In Sangam Vihar Locanto

College Girl {844-77=79-280} Call Girls In Paharganj Locanto

College Girl {844-77=79-280} Call Girls In Mayur Vihar Locanto

College Girl {844-77=79-280} Call Girls In Delhi Locanto

College Girl {844-77=79-280} Call Girls In Lajpat Nagar Locanto

College Girl {844-77=79-280} Call Girls In Malviya Nagar Locanto

College Girl {844-77=79-280} Call Girls In Green Park Locanto

What makes the best parental control app?

Cheap Escort Service in Lajpat Nagar 8447779280 Call Girls

If you get outOFMemoryException then how would you troubleshoot it? and asked me about the memory, is it class level or instance level

Tell me when you did something beyond client expectations

.Tell me test strategy for amazon product search functionality
Describe to me the test plan for the same scenario
write the automation code for this functionality

Tell me about when you did something different in your role

Call Girls In Munirka 8447779280 Shot 1500 Night 6000

Print the most near missing integer in the unsorted value.

public static void main(String args[]) {

        System.out.println(solution(new int[]{-4,-2}));
    }

    private static int solution(int[] ints) {
        //1,2,3,4
        //2,3,4 = 1
        //-2,-1,2,3,4 = 0,0,2,3,4 = 1
        //-4,-3,-2 = 1
        //-4,-2 = 1
        //-3,-2,-1 , 1 = 2

        Arrays.sort(ints); //O(log*n)
        for (int i = 0; i < ints.length; i++) {
            if (ints[i] > 0) {
                if (ints[i + 1] - ints[i] > 1) {
                    return 1;
                }
                break;
            }
            ints[i] = 0;
        }
        //O(n-m) n- lenght array , m - negative interger
        //1,2,3,5,7,8,9,10
        for (int i = 0; i < ints.length - 1; i++) {
            if (ints[i + 1] - ints[i] > 1) {
                return ints[i] + 1;
            }
        }
        //O(n-k)
        return ints[ints.length - 1] + 1;
        //O(log n * n2)
    }

When a person who knows it meets any other person, they immediately share the story with them.
Initially, only person 1 knows the story. Given a list of meetings between people in a form of
(person_1_id, person_2_id, timestamp) construct a list of the persons who will know the story
at the very end.

Example: [(1, 2, 100), (3,4, 200), (1,3, 300), (2,5, 400)], 1 // The events could be out of order.
Person 2 will learn the story at the moment 100, person 3 — at the moment 300,
person 5 — in the moment 400. Person 4 will never learn the story. So the answer is [1, 2, 3, 5].

Eg2: [(1, 2, 100), (2, 3, 100), (4, 5, 100)], 2
where the first parameter is array of the Persons meet at particular timestamp, second parameter is the PersonId who knows the story first.
Output: [1, 2, 3]

logical questions I have two container 2lit and 4lit. i have to fill 3litre with efficiently. how do yu fill it

Given a text file - find out all the unique words and display the frequency of each word in descending order.

Given a input string 'Hello World' and a input reference String, give count of each character (from refString) in the given string
Eg inputString: "Hello World Please", refString: "Help"
Output: H: 1, e: 3, l: 4, p: 1

Average Marks of Lowest ID Student:

In this problem, you have to write a program that reads a file containing scores received by students in a number of
subjects, and does some processing on it.
The input is being read in from a file called input.txt, in this format:
22, Data Structures, 45
23, English, 52
22, English, 51
26, Data Structures, 72
23, Data Structures, 61
24, English, 81

Each line consists of three fields "Student ID," "Subject," and "Marks." "Student ID" and "Marks" are integers and
"Subject" is a string that does not contain commas or newlines. There can be any number of students and up to 6 subjects.

Your program should read this file, compute the average marks scored across all subjects by the student with the lowest ID, and write the average marks to a file called output.txt.
For example, if your program is run with the input given above, then at the end the file output.txt should contain just
48. That's because 48 is the average of the marks received by the student with ID 22 (which is the lowest ID).

***Need code in python****

An input file called input.txt consists of data in the following format:

22 Data Structures 45
23 Maths 2 52
23 Maths 3 57
22 English 51
26 Data Structures 72
23 Data Structures 63
26 English 81
Each line consists of three fields "Student ID," "Subject," and "Marks." "Student ID" and "Marks" are integers and "Subject" is a string that does not contain '|' or newlines (but might contain digits). There can be any number of students and up to 6 subjects. You have to read this file, and print the average marks in "Data Structures," across all students.


***I need code in python***

Given a string s consisting of items as "*" and closed compartments as an open and close "|", an array of starting indices startIndices, and an array of ending indices endIndices, determine the number of items in closed compartments within the substring between the two indices, inclusive.

An item is represented as an asterisk ('*' = ascii decimal 42)
A compartment is represented as a pair of pipes that may or may not have items between them ('|' = ascii decimal 124).
Example

s = '|**|*|*'

startIndices = [1, 1]

endIndices = [5, 6]

The string has a total of 2 closed compartments, one with 2 items and one with 1 item. For the first pair of indices, (1, 5), the substring is '|**|*'. There are 2 items in a compartment.

For the second pair of indices, (1, 6), the substring is '|**|*|' and there are 2 + 1 = 3 items in compartments.

Both of the answers are returned in an array, [2, 3].

Function Description .

Complete the numberOfItems function in the editor below. The function must return an integer array that contains the results for each of the startIndices[i] and endIndices[i] pairs.

numberOfItems has three parameters:

- s: A string to evaluate

- startIndices: An integer array, the starting indices.

- endIndices: An integer array, the ending indices.

Constraints

1 ≤ m, n ≤ 105
1 ≤ startIndices[i] ≤ endIndices[i] ≤ n
Each character of s is either '*' or '|'
Input Format For Custom Testing

The first line contains a string, s.

The next line contains an integer, n, the number of elements in startIndices.

Each line i of the n subsequent lines (where 1 ≤ i ≤ n) contains an integer, startIndices[i].

The next line repeats the integer, n, the number of elements in endIndices.

Each line i of the n subsequent lines (where 1 ≤ i ≤ n) contains an integer, endIndices[i].

Sample Case 0

Sample Input For Custom Testing

STDIN Function
----- --------
*|*| → s = "*|*|"
1 → startIndices[] size n = 1
1 → startIndices = 1
1 → endIndices[] size n = 1
3 → endIndices = 3
Sample Output

0
Explanation

s = *|*|

n = 1

startIndices = [1]

n = 1

startIndices = [3]

The substring from index = 1 to index = 3 is '*|*'. There is no compartments in this string.

Sample Case 1

Sample Input For Custom Testing

STDIN Function
----- --------
*|*|*| → s = "*|*|*|"
1 → startIndices[] size n = 1
1 → startIndices = 1
1 → endIndices[] size n = 1
6 → endIndices = 6
Sample Output

2
Explanation

s = '*|*|*|'

n = 1

startIndices = [1]

n = 1

endIndices = [6]

The string from index = 1 to index = 6 is '*|*|*|'. There are two compartments in this string at (index = 2, index = 4) and (index = 4, index = 6). There are 2 items between these compartments.

ELK related questions especially on optimizing logging

Design a Nearby shops features for online map service provider.

Design a system to find top 10 sold products for an online website at any point of time for last 15 minutes.

Which data structure & algorithm would be the best to design such kind of systems?

You are given a directed cyclic graph represented by an adjacency matrix. The graph has at least one terminal node (i.e. the node with no outgoing edges).

Each edge of the graph is assigned a positive integer representing a probability of taking this edge. E.g. if you have 3 outgoing edges with numbers 3, 2, and 4, this means that the prob. of taking these edges are: 3/9, 2/9 and 4/9, respectively.

You need to find the probability of reaching each terminal node from the starting node 0.

Example:
adjacency matrix 5x5:

m = {{0 1 0 0 1},
        {0 0 3 2 0},
        {4 0 0 1 0},
        {0 0 0 0 0},
        {0 0 0 0 0}}

so we have two terminal nodes here: 3 and 4
we can take the following paths:
0 -> 1 -> 3 = probability: 1/2*2/5 = 1/5
0 -> 1 -> 2 -> 3 = probability: 1/2*3/5*1/5 = 3/50
0 -> 1 -> 2 -> 0 -> 1 -> 3 ... and so on

or to the node 4:
0 -> 4: probability: 1/2
0 -> 1 -> 2 -> 0 -> 4: probability 1/2*3/5*4/5*1/2 = 3/25

and so on, summing up probabilities of all possible paths we get:
total probability to reach node 3: 13/38
total probability to reach node 4: 25/38