Q: In the plane we consider rectangles whose sides are parallel to the coordinate axes and

have positive length. Such a rectangle will be called a box . Two boxes intersect if they have a

common point in their interior or on their boundary.

Find the largest n for which there exist n boxes B1, . . . ,Bn such that Bi and Bj intersect if

and only if i strictly not equal to  j ± 1 (mod n).

A: The condition given by the problem to find the largest n is that Bi and Bj are not adjacent rectangles. Rectangles are called adjacent if their index i in Bi is such that their indexes differ by at most 1.  Moreover, the condition is stated such that non-adjacent rectangles must overlap and have a point common.

In other words the rectangles (B1, B2) , (B2,B3) ... (Bn-1, Bn) (Bn,B1) are adjacent and cannot overlap but any other pairing of Bi can overlap.

Let us take a look at what overlap means. When two rectangles overlap as per the problem description, they have a common point along their projections on the X and the Y-axis
If we take the set of such line segments bounded by the corners of two rectangles along the X-axis  and Y-axis as Ik and Jk respectively where k can vary from 1 to n.
Adjacent rectangles don't intersect. So (Ik, Ik+1) OR (Jk, Jk+1) are disjoint intervals. Then, the possible line segments for adjacent rectangles that are denoted by (I1,I2). . (In-1,In),(In,I1) and (J1, J2), (Jn-1,Jn), ... (Jn,J1) respectively have n pairs of disjoint intervals.
And since non-adjacent rectangles necessarily intersect, their projections on both axes must intersect. How many ever pairs of rectangles we can find that are disjoint on one axes that many can exist on the y-axis as well. Therefore the total number of such pairs will be double the number of disjoint pairs we can find and that will be the largest n to satisfy the condition in the problem.

By writing the line segments as length L1 L2 ..Ln for segment ends (a1,b1) (a2,b2) .. (an,bn), we can choose two points alpha and beta such that alpha is the rightmost among left endpoints and beta is the leftmost among right endpoints.

If alpha is less then beta then all ai is less the alpha is less than beta is less than bi. If every length contains alpha, then there cannot be any disjoint set.
If alpha is greater than beta, then assume Beta = bi  for some i  and alpha = a2 , then we have ai is less than bi or beta which is less than alpha or a2 which is less than b2. This means L2 and Li are disjoint. Now L2 intersects all remaining intervals between L1 and L3 so L2 and Li can be disjoint only if i = 1 or i = 3. Also alpha belongs to the intersection of  each of the remaining intervals which means it is not empty Similarly L5 to Ln,L1 intersect with L3 and consequently they have a non-empty overlap that includes Beta. This leaves only (L1,L2) (L2,L3) and (L1,L3) as the only candidates for the disjoint intervals. And therefore the answer is n = 6.

It was an exercise left out that alpha was claimed to be in the intersection of each of the remaining intervals and that alpha can be assumed to be a2. This is because we choose the leftmost point for alpha.

Write a C program that, given an array A[] of n numbers and another number x, determines whether

or not there exist two elements in S whose sum is exactly x.

int HasTwoNumbersWithSum(int A[], int length, int n)

{

 Qsort(&A, length);
  

For (int I = 0; I < length; i++){

    Assert (a[i] > 0);

    If (A[i] < n && exists(A, length, n- A[i], 0, length – 1 )){

     Return 1;

   }

}

Return 0;

}

Int exists(int A[], int length, int val, int start, int stop)

{

  While (Start <= stop)

 {

Mid = (start + stop )/ 2;

If( A[mid] == val )return 1;

If (start == stop) return 0;

  If ( A[mid] > val)

     Return exists(A, length, start, mid-1);

   Else

     Return exists(A, length, mid+1, stop);

}

Return 0;

}

For any integer n >= 2, we compute the integer h(n) by applying the following procedure to its

decimal representation. Let r be the rightmost digit of n.

(1) If r = 0, then the decimal representation of h(n) results from the decimal representation

of n by removing this rightmost digit 0.

(2) If 1 <= r <= 9 we split the decimal representation of n into a maximal right part R that

solely consists of digits not less than r and into a left part L that either is empty or ends

with a digit strictly smaller than r. Then the decimal representation of h(n) consists of the

decimal representation of L, followed by two copies of the decimal representation of R-1.

For instance, for the number n = 17,151,345,543, we will have L = 17,151, R = 345,543

and h(n) = 17,151,345,542,345,542.

Prove that, starting with an arbitrary integer n >=  2, iterated application of h produces the

integer 1 after finitely many steps.

We identify integers  n > = 2 with the digit-strings of their decimal representations and extend the definition of h to all non-empty strings with digits from 0 to 9. We recursively define ten functions f0 to f9 that map some strings into integers for k = 9,8, ...1,0. The function f9 is only defined on string x that entirely consists of nines. If x consists of m nines , then f9(x) = m + 1,  m = 0, 1, ...
For k<=8 the domain of fk(x) is the set of all strings containing only of digits that are >= k. We write x in the form of x0 kx1 kx2 k ... xm-1 kxm where the strings xs only consists of digits >= k+ 1. String can be empty or m = 0 which means that digits need not appear. We define 
fk(x) = Sum s = 0 to m  of ( 4 ^ fk+1(xs))
We now use the following facts:
Fact 1 If x does not contain digits smaller than k, then fi(x) = 4 fi+1(xs) for all i = 0, .. k - 1.
In particular, fi(empty string) = 4 ^ (9-i) for all i = 0,1, ...9
We establish the same for k = 9, 8, ... 0 by induction
Fact 2  If the non-empty strings does not contain digits smaller than k, then f1(x) > f1(empty string) for all i = 0, ..., k
Now the fact 3 that will reduce the given problem to one of mere transformations:
Fact 3: f0(n)  > f0(h(n))
Then the empty string will be reached after a finite number of applications of h. But starting from a string without leading zeros, empty string can only be reached via the strings 1->00->0->empty string. By that transformation sequence, the number 1 will appear after a finite number of applications of h.
The intuition behind the solution is that if we reduce the given problem to transformations where we can take use the criteria in the question which is to use the numbers smaller than r.

Faking it Right by Ross McCammon 

Ross says the professional world’s a stage and we are all actors. According to him, the question is how much do the roles in which you cast yourself differ from who you actually are ?  If they are too different, it might cause problems. However, if they are not that much, they may help in letting your negative feelings pass. 

Ross does not mix words when he says that we lie.  There are plenty of examples when we lie. However there’s honor in those lies because you are trying. 

So let’s take a few examples of how to act: 

Fake confidence at a meeting:  do it at the very beginning when impressions are made and not later.  First smile. Second lock in to the “gaze”.  Third sit up straight. And fourth raise your eyebrows every now and then. 

Seem happy when the promotion goes to someone else: Dig deep because you have to go through a lot of resentment and envy to get through to the good stuff. Its more than just pretending says Sean Kavanagh CEO of the Ariel Group. You have to authentically take on that role. Take a few deep breaths into the diaphragm and not into the shoulders. Focus on the intention and the need of the audience. Empathize with the audience and remember the purpose of your soliloquy 

How to ‘can’ when you ‘can’t even’ : There are times when you can’t and there are times when you can’t even. If you can’t even and you have to seem like you can, here’s what to do : 

Focus on any object at eye level and raise the corners of your mouth. If your jaw had dropped try to hold it up so that your lips close. This might even seem like you can. 

How to smile when you do not feel like smiling: Note that unhappy smiling is worse than not smiling at all. Researchers studied a group of bus drivers found that those who engaged in surface acting ended up in a worse mood and those who faked happiness by smiling and thinking positive thoughts (deep acting) found themselves in better mood. 

If you want to seem happy, get happy, real happy. 

Lastly, the author provides a few key technical matters: 

Think of your reactions as “notches”. Determine which notch your feelings are. Call your feelings “it”. 

Take “it” down at least one notch. Five is too many. Pay attention to body language. Make eye contact. Sit up straight. When in doubt: Act.  Stifle anger. Stifle irritation. Do not stifle a sneeze. And stifle feeling flabbergasted after a sneeze. Gasted is fine. Flabber is way too much. 
#coding exercise
For a given starting number k and the number of iterations n, print the sequence. For example,
2
12
1112
3112
132112
Void PrintSequence (int k, int n)
{
var lastseq = new List <int>(){ k};
For ( int I = 0; I < n; I ++){
Var next = new List <int>();
Int last = int_min;
Int count =0;
For (int j = 0; j < lastseq. Length; j++){
If lastseq  [j] != last {
If last != int_min {
Next.add (count);
Next.add (lastseq [j-1]);

}
Count= 0;
}
 count ++;
Last = lastseq  [j];
}

Next.add (count);
Next.add (lastseq [lastseq.length-1]);

Lastseq = next;
))
}
}

We continue the discussion on the question below:

Let n and k be fixed positive integers of the same parity, k n. We are given 2n lamps
numbered 1 through 2n; each of them can be on or off. At the beginning all lamps are off. We
consider sequences of k steps. At each step one of the lamps is switched (from off to on or from
on to off).
Let N be the number of k-step sequences ending in the state: lamps 1, . . . , n on, lamps
n+1, . . . , 2n off.
Let M be the number of k-step sequences leading to the same state and not touching lamps
n+1, . . . , 2n at all.
Find the ratio N/M.

We showed that every restricted admissible process can be modified in 2 ^ (k-n)  ways which results in as many distinct admissible processes.
What remains to be shown is that every admissible process can be achieved in that way. And surely enough we can replace the switch of  lamp with label l > n that occurs in q by the switch of a lamp with label l - n and consecutively the resulting process p does not have lamps n+1, .. 2n involved.

Moreover the switches for those lamps were even in number and when performing the same on lamps with label < n, the resulting process is admissible and restricted.

Therefore admissible <---> restricted processes are one to one reversible. This completes the proof.

Note that the state of each lamp and it's operations are independent of other lamps, so the combination of ways to operate them is a simple multiplication. And since the state of the lamps are binary, it becomes intuitive that the ratio of the admissible to restricted process has to be a power of two.

Finding Interest in the mundane 

Emails can be boring especially when we are inundated by the tens if not hundreds every day. We are trained to filter what’s relevant and critical to us. We can even recall threads and conversations that may matter to a specific topic of discussion. We spend some time scanning the incoming mails, some more time filtering and most time responding or preparing a response to what matters. Consequently the tools of our trade are the search options on the Email software we use which is Outlook. A cursory look at this search options shows that the query we write are from what we remember such as the subject containing a buzz word or sender or recipient being someone specific. However, there are a few problems with this approach.  

First is we speedboat from the get go. We want to hammer home the wins from each incoming and outgoing responses. There is hardly any technology other than search that we use in our aim to get where we want too and if we have spent a lot of time digging around e-mails, we either request a resend or move on. There may be some tagging and organization involved but these are mostly from what we expect the incoming mails to conform to. Besides with the explosion of containers, the search becomes narrowed leading to higher misses or incorrect assumptions. Secondly, we don’t smell the roses. In our daily routine, there is hardly any learning from the conversations that flow to our inbox unless we have scanned and read each one of them. Many of these conversations may not even be directed at the reader per se and even lesser so at the tangent topics that may boomerang back to us. For example, there is no text analytics or content intelligence that we build from this vast amount of semi-structured data. 

Thirdly, we don’t have appealing visualization of the information that we can have drones retrieve us from the daily grind. Even if we do realize a highly efficient text analytics platform over the emails and manage to build a user interface that can improve our productivity, we may limit ourselves to ultimately showing them as the same search results as we used to see earlier leaving the burden on the user to refine the search results or scan them for items of interest. Yes precision and recall can be improved and even change from being header or metadata based search to full-text but statistical and semantic analysis would not display their immense potential if they presented their results in the same way. What can we then use to render such information ? Take the following visualization as an example: 

 Courtesy: http://vallandingham.me/msd/vis/ 

as an example of what we can organize the results on Outlook. This sort of imagery and interactivity is far more helpful to the user than static endless results. Besides this is complimentary and not a substitute to the traditional search. 

Fourth, even the search tools we use return data not information. Most of the results are the individual emails that meet the query or search criteria whereas the results we are looking for is in terms of concepts or tags that are abstract and may not even be literal in the email. If we look at the following menu from our Outlook software: 

We can see that the query builder window is not the same as the kind of clustering, categorizing and machine learning techniques options we are talking about. There is no way to even build models for search here.  

Finally, we are not talking business intelligence.  There is a lot of overlap between building logic for search and reports to display the results between a business intelligence software add ons and the content intelligence and text analytics platform but the key difference here is that BI is targeted for some kind of specific domain or information whereas we are talking about increasing the panorama of information retrieval tools to glean what passes us by on a day to day basis. Time series data and Big Data techniques have made some of the approaches commercially viable on large scale but to scope it down to personal level and to this repository is altogether different.  

Thus we can explore more from what we get each day.  

Q:Given a string find the first non repeating character in it

A:

void getFirstNonRepeatingCharacter(String input)

{

    var freq = new Dict<char, int>();

    for(int i = 0; i < input.Length; i++)

    { 

        freq[input[i]] += 1;

     }

    foreach (KeyValuePair<char, int> kvp in freq)

    {

        if (kvp.value == 1)

             Console.WriteLine("{0}", freq[kvp.key]);

     }

 }

Let n and k be fixed positive integers of the same parity, k n. We are given 2n lamps
numbered 1 through 2n; each of them can be on or off. At the beginning all lamps are off. We
consider sequences of k steps. At each step one of the lamps is switched (from off to on or from
on to off).
Let N be the number of k-step sequences ending in the state: lamps 1, . . . , n on, lamps
n+1, . . . , 2n off.
Let M be the number of k-step sequences leading to the same state and not touching lamps
n+1, . . . , 2n at all.
Find the ratio N/M.

Let us call the first set of operations that results in N as admissible
Let us call the second set of operations that result in M as restricted.

For a lamp to remain on, it must be switched an odd number of times.
For a lamp to remain off, it must be switched an even number of times.

Take any lamp l  1<=l <= n and supposed it was switched kl times which should be odd number for the lamp to remain on. Select arbitrarily an even number of Kl switches and replace each of them by the switch of the lamp n+l. This can be done in 2^(kl-one) ways because a kl element set must have 2^(kl-1) subsets of even cardinality. and we started out by saying k1 + .. kn = k.
Since each lamp can be affected independent of others, there are 2^(k1-1) . 2^(k2-1) . 2^(k3-1) . ...2^(kn-1)  = 2 ^(k-n) ways of combining these actions. In any one of these combinations, the end state is the desired state as per the question.
Therefore N/M = 2 ^(k-n).

Cloud Foundry versus Octopus: 

In the realm of software deployment for Cloud computing, there are different software stacks for Windows and Linux families. Usually they have their own solutions for deployment because by their nature they are different ecosystems and have different platforms. Take Ubuntu for example, and you will find the following list of software: Apache, MySQL, ZooKeeper, Storm, Kafka, Spark, Cassandra, Nginx, Marathon and Docker usually. And take windows and you will have the following list of software: .NET, Visual Studio, Team Foundation Server, Octopus etc.  While Docker has made applications portable, we want to view the solution for continuous deployment as well as configuration management.  

Let us first identify the two primary candidates for the deployment software. On Ubuntu we have Cloud Foundry and an Windows we have Octopus. 

CloudFoundry is a tool for automated software deployment and hosting with the following benefits: 

You decrease time to production 

You can iterate faster –develop->build->test->deploy 

You increase productivity of developers 

You improve the quality of the products 

You improve the efficiency of IT operations 

You increase the utilization of hardware 

Octopus is a tool that does massive deployments over several different virtual machines with the same configuration and software that you decide It can maintain simultaneous dev, test and production environments and tear them down at will. You can configure different VMs in different pools and they can be used as appropriate.   Octopus can prepare a  VM with any kind of installer.

Both CloudFoundry and Octopus have web interfaces that give you the overall picture of all your deployments. Both come with their security features as well as what’s in progress and what’s completed views. 

However Octopus manages at VM level as well where as CloudFoundry manages based on application stacks.  This is a tremendous advantage because you can choose different VMs specifically or could with a pool of VMs if you are not particular. 

Both tools are scalable and have high performance but the level of control and features are different where Octopus comes out ahead. 

The purpose of these comparisions is to see if there are some ideas that can be ported between the two ecosystems. At the same time, this study should also improve the understanding of these tools. 

However,  we should remind ourselves that these tools are built for different eco-systems with different requirements. 

#coding question

Generate the following pattern when x is given upto Nth terms
For ex:
Input: x=2 ,N=5
OUTPUT:
2
12
1112
3112
132112

https://en.wikipedia.org/wiki/Look-and-say_sequence

Find the next higher no. Of x Whose binary represent does not contain consecutive 1s-
For ex:
Input:
12
Output:
16

int next_non_consecutive_one(int x)
{
bool previous = false;
bool current = false;
bool found = false;
while (!found){
x = x + 1;
int y = x;
 while (y)
{
   if ((y & 0x1) == 0x1)
        current = true;
   else
        current = false;
   if (previous == current && previous == true) {// consecutive 1
         found = false;
          break;
    }
    previous = current;
    y = y >> 1;
}
 if (y == 0) found = true;
}
return x;

}

Today I setup FishEye Crucible for code reviews in my team.

Let us look at another way to solve previous problem:
Q: A unit square is dissected into n > 1 rectangles such that their sides are parallel to the sides of the square. Any line, parallel to a side of the square and intersecting its interior, also intersects the interior of some rectangle. Prove that in this dissection, there exists a rectangle having no point on the boundary of the square.

A: We suppose the contrary that such dissection does result in  a rectangle with no points on the boundary of the square. We will consider an arbitrary counterexample. We know that each rectangle is attached to at least one side of the square. No rectangle can be attached to opposite sides otherwise one of its sides lies on a splitting line.

We call two rectangles as opposite if they are attached to the opposite sides of ABCD. We claim that there exists two opposite rectangles having a common point.

Consider the union L of all rectangles attached to the left. and assume that they have no common points with the rectangles attached to the right. Now if we take a polygonal line P that connects the top and bottom of the square  and passing close to the right boundary of L then it is easy to visualize that the rectangles of L do not have opposites per our assumption. This means there are rectangles to the right of P and before the rectangles attached to the right. We call them buffer rectangles. Some of these buffer rectangles are attached to the top and some are attached to the bottom. Consequently there is a point on P within the square where the top and the bottom rectangles meet. So there always exists a pair of opposite rectangles
and more importantly no buffer rectangles exist.

Having established that there are opposite rectangles within a square, let us take two arbitrary rectangles within the square that are opposites and say one is connected to the left  which we call a and another is connected to the right which we call b. Let X be a common point that lies on the edge shared between a and b.

If X belongs to their horizontal sides, say when a and b are passing over each other horizontally, then X lies on a horizontal splitting line along the common edge.

If X belongs to their vertical sides, say when a and b are meeting each other horizontally, then the lie on which X lies is not a splitting line. Consequently it intersects the interior of some rectangle. we call this line l.
we can assume an aribitrary rectangle c higher than both a and b that this line intersects. Let the lowermost point of c that lies on the line l be called Y. Then between Y and rectangles a and b, they may be buffer rectangles unless Y lies on a or b. If Y lies on a or b, then the top sides of two rectangles pass through Y and this provides a splitting line again.
If Y lies on two buffer rectangles a' and b' then they a' has to be to the left of b or b' has to be the right of a. Either way the buffer rectangles a' and b' are attached to the opposite sides and are opposites having a common point on l.
Since the top sides of the two rectangles pass through Y, we again have a splitting line.
The presence of a splitting line means the rectangles can be combined and there is at least one rectangle with edges on opposite sides.
Since we have proved that splitting lines exists in all cases, our arbitrary counterexample cannot hold. In such a case we have proved by contradiction that such dissection results in a rectangle having no points on the boundary of the square simply by eliminating splitting lines.