X to the power of X (X^X)

-

One of my sons asked an interesting question: what number raised to itself equals to 25? In other words, he wanted to find X such that X^X = 25.

I decided to write a simple program (no GAI for a change, just vintage coding) to do that. The key observations here are:

1/ X^X is continuous in the real domain

2/ It grows monotonically 

3/ It grows very fast

With that in mind, the solution is a binary search. The lower bound is 1, the upper bound can be found quickly by doubling the number, then we perform a standard binary search (some nuances there just because we're dealing with floating-point numbers). Complexity stays around Log(Log(N)), hence very fast. Code is down below, cheers. Oh... and the answer to my son is the following: 2.96321964263916

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace Exp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            double input = Double.Parse(args[0]);
            Process(input);
        }

        static void Process(double n)
        {
            double lowerBound = 1;
            double upperBound = 1;

            double val = Math.Pow(upperBound, upperBound);
            while (val < n)
            {
                upperBound *= 2;
                val = Math.Pow(upperBound, upperBound);
            }

            double ZERO = 0.00001;
            int maxInt = 10000;
            double mid = 1;
            while (lowerBound < upperBound && maxInt > 0)
            {
                mid = (lowerBound + upperBound) / 2;
                val = Math.Pow(mid, mid);

                if (Math.Abs(n - val) <= ZERO)
                {
                    break;
                }
                else if (val > n)
                {
                    upperBound = mid;
                }
                else
                {
                    lowerBound = mid;
                }
                maxInt--;
            }
            Console.WriteLine("{0}^{0} ~= {1}", mid, n);
        }
    }
}

Comments

Post a Comment

Popular posts from this blog

Standard Priority Queue IX: Vowels Frequency

-
Tally the frequency of the vowels. Push that into a pQueue, the caveat is when the frequencies are the same, you need to keep track of the first occurrence of each vowel and do some math to insert into the priority queue with the right order. After that, it is just dequeuing and inserting into the proper places. Use StringBuilder to avoid unnecessary string allocations. Code is down below, cheers, ACC. Sort Vowels by Frequency - LeetCode You are given a string  s  consisting of lowercase English characters. Rearrange only the  vowels  in the string so that they appear in  non-increasing  order of their frequency. If multiple vowels have the same  frequency , order them by the position of their  first occurrence  in  s . Return the modified string. Vowels are  'a' ,  'e' ,  'i' ,  'o' , and  'u' . The  frequency  of a letter is the number of times it occurs in the string.   Example 1: Input:   ...
Read more

The Power Sum, a recursive problem by HackerRank

-
Image
Another one by HackerRank:  https://www.hackerrank.com/challenges/the-power-sum : Find the number of ways that a given integer,  , can be expressed as the sum of the   power of unique, natural numbers. Input Format The first line contains an integer  .  The second line contains an integer  . Constraints Output Format Output a single integer, the answer to the problem explained above. Sample Input 0 10 2 Sample Output 0 1 Explanation 0 If   and  , we need to find the number of ways that   can be represented as the sum of squares of unique numbers. This is the only way in which   can be expressed as the sum of unique squares. Sample Input 1 100 2 Sample Output 1 3 Explanation 1 Sample Input 2 100 3 Sample Output 2 1 Explanation 2  can be expressed...
Read more

Binary Search to Find Next Greater Element V

-
You can use the .BinarySearch method of List<T>. It works well, there is a bit of a trick that you need to do when the return index is negative (just assign it to its complement, ~index). No need to perform the Binary Search "by hand" anymore. Achieves a good NLogN, fast solution. LC suggests a Tree to be used but this approach (two lists, one for even, one for odd) works well. Code is down below, cheers, ACC. Count Smaller Elements With Opposite Parity - LeetCode You are given an integer array  nums  of length  n . The  score  of an index  i  is defined as the number of indices  j  such that: i < j < n nums[j] < nums[i] nums[i]  and  nums[j]  have different parity (one is even and the other is odd). Return an integer array  answer  of length  n , where  answer[i]  is the score of index  i .   Example 1: Input:   nums = [5,2,4,1,3] Output:   [2,1,2,0,0] Explanation: Fo...
Read more