Overview

Most people don't really care about you.

• The spotlight effect is the psychological phenomenon by which people tend to believe they are being noticed more than they really are.

  • The Spotlight phenomenon is where people tend to overestimate how much others notice aspects of one’s appearance or behaviour.

  • It is believed that the spotlight effect comes from being overly self-conscious.

• For people with social anxiety, the spotlight effect can be much worse, to the point that it has an effect on your ability to work or feel comfortable around other people.

• As said in the above quote, most people don't really care about anyone other than themselves (and this is the harsh reality).

  • We are constantly worrying about what other people think of us when most of them aren't and this is a real concern among ourselves.

  • This is because most people are too preoccupied thinking about themselves or something that they are doing.

  • You can overcome the spotlight effect by focusing your attention outward and noticing other people's reactions to you.

We can test this effect by using a simple question to people, "What shirt you're wearing?". Chances are very less that people notice you to the fullest because they're busy with themselves. Ideally, we should be very comfortable with ourselves and only then we can get comfortable with the outside world.

• Stop worrying about what others think.

• Be yourself.

• Live according to your values.

If you can get to the point where you realize nobody is really paying attention to you, then you will stop worrying so much about it.

References

The below article clearly explains the concept of the spotlight effect.

https://en.wikipedia.org/wiki/Spotlight_effect

Bonus content

Question 9:

Explanation:

• The problem is very similar to the below problem where the only difference is instead of having 2 lists, we will need to merge k lists.

  • https://leetcode.com/problems/merge-two-sorted-lists/

• We can solve this problem by using a simple for loop and iterating each list and computing the final node with sorted values.

  • sortedList = lists[0];

  • for loop; sortedList = merge2Lists(sortedNode, lists[i]);

• Instead of sorting each list again and again, we will use the concept of the divide and conquer approach where we divide the list and merge it until we arrive at one list (that is completely sorted).

Solution:

/**
 * Definition for singly-linked list.
 * public class ListNode {
 *     int val;
 *     ListNode next;
 *     ListNode() {}
 *     ListNode(int val) { this.val = val; }
 *     ListNode(int val, ListNode next) { this.val = val; this.next = next; }
 * }
 */
class Solution {

    private ListNode merge2Lists(ListNode node1, ListNode node2) {
        if (node1 == null) {
            return node2;
        }
        if (node2 == null) {
            return node1;
        }
        // Use dummy pointer with which we can traverse and store the sorted values
        ListNode node = new ListNode(-1);
        ListNode head = node;
        while (node1 != null && node2 != null) {
            if (node1.val > node2.val) {
                node.next = node2;
                node2 = node2.next;
            } else {
                node.next = node1;
                node1 = node1.next;
            }
            node = node.next;
        }
        if (node1 == null) {
            node.next = node2;
        }
        if (node2 == null) {
            node.next = node1;
        }
        return head.next;
    }

    public ListNode mergeKLists(ListNode[] lists) {
        // Edge cases
        if (lists == null) {
            return null;
        }
        int len = lists.length;
        // Edge cases
        if (len == 0) {
            return null;
        }
        if (len == 1) {
            return lists[0];
        }
        int interval = 1;
        while (interval < len) {
            // Init: 1,2,3,4,5,6
            // Iteration1: 1(1+2), 3(3+4), 5(5+6)
            // Iteration2: 1(1+2+3+4), 5(5+6)
            // Iteration3: 1(1+2+3+4+5+6)
            for (int i=0; i+interval < len; i = i + (interval * 2)) {
                lists[i] = merge2Lists(lists[i], lists[i + interval]);
            }
            interval *= 2;
        }
        // Return the first element as all the elements are divided and merged to it.
        return lists[0];
    }
}

Next problem:

In the next post, I will cover the below problem.