recursive function or non-recursive that doesnt use 2 ** approach

seems to work fine When rewriting your function, don't lose sight of the main benefit of recursion in this case, which is to reduce the number of multiplication operations required. For example, if n = 8, then it is much more efficient to compute x * x as val1, then val1 * val1 as val2, and the final answer as val2 * val2 (3 multiplications) than to compute x * x * x * x * x * x * x * x (7 multiplications).
This difference is trivial for small integers but matters if you put this operation inside a big loop, or if you replace the integers with very large number representations or maybe ginormous matrices.

#include<stdio.h>
#include<math.h>

int power(int, int);

int main(void)
{
    int x, n;
    printf("Enter a number and power you wish to raise it to: ");
    scanf_s("%d %d", &x, &n);
    printf("Result: %d\n", power(x, n));
    return 0;
}

int power(int x, int n)
{
    int m;
    if (n == 0) return 1;
    if (n % 2 == 0) {
        m = power(x, n / 2);
        return m * m;
    } else return x * power(x, n - 1);
}

will help you I have an array of rectangles called myRects like so: , I think something like this could do:

iterativelyGetIntersectingRects(r, rects) {
 var inter = [];  // resulting intersecting rects
 var found = [r]; // found intersecting rects in last round (to be checked for subseq intersections)
 while(found.length) {   // while new ones found
  var a = found.shift(); // check this
  inter.push(a);         // also store to results
  var remain = [];
  while(rects.length) {      // while remaining for check
   var test = rects.shift(); // check next
   if( doIntersect(a, test))
    found.push(test);        // gotcha!
   else
    remain.push(test);       // not yet
  }
  rects = remain;            // remaining for check with next found
 }
 return inter;     
}

Hope this helps You can always unwind to a while loop. Because your calls aren't altering state, this is trival.

public void ServiceFunctionality()
{
    bool done = false;
    while(!done) {
    try
    {
        done = true; //if we don't reset this, we're done.
        // Get Data From WEBAPI
        HttpClient client = new HttpClient();
        HttpResponseMessage response = response = client.GetAsync("webapi url link").Result;
        Response<ServiceWrapper> objResponse = response.Content.ReadAsAsync<Response<ServiceWrapper>>().Result;

        if (objResponse != null)
        {
            if (objResponse.isSuccess == true)
            {
                listContact = objResponse.data.lContact;
                int MaxPKinSelectedRecords = objResponse.data.MaxPKinSelectedRecords;
                int MaxPKinTotalRecords = objResponse.data.MaxPKinTotalRecords;

                if (listContact != null && listContact.Count>0)
                {
                    try
                    {
                        Parallel.ForEach(listContact, contact =>
                        {
                            // some code...
                        });
                        // set loop variable
                        if (MaxPKinTotalRecords != MaxPKinSelectedRecords)
                        {
                            done = false;
                        }
                    }
                    catch (Exception ex)
                    {
                        // Logging
                    }
                }
            }
            else
            {
                // Logging
            }
        }
        else
        {
            // Logging
        }
    }
    catch (Exception ex)
    {
        // Logging
    }
} 
}

I wish this help you Often, a table called master..spt_values is used for this purpose. It is rather undocumented but generally available. Actually, any table with at least 31 rows can be used.
So, to generate the numbers and construct the date:

with n as (
      select top 31 row_number() over (order by (select null)) as n
      from master..spt_values
     )
select datefromparts(year(getdate()), month(getdate()), n.n) as thedate
from n
where n.n <= day(eomonth(getdate()));

should help you out In my opinion, this is the clearest way to recursively render components in Rails:
Inside the partial _comment.html.erb

<%= comment.data %>
<% comment.children.each do |child| %>
  <ul class="child-thread">
    <%= render partial: 'comments/comment', locals: { comment: child } %>
  </ul>
<% end %>

class Comment < ApplicationRecord
  has_one :parent, :foreign_key => :parent_id
  def children 
    Comment.where(parent_id: self.id)
  end
end

<%= comment.data %>
<% if count < 5 %>
  <% comment.children.each do |child| %>
    <ul class="child-thread">
      <%= render partial: 'comments/comment', 
          locals: { comment: child, count: count + 1 } %>
    </ul>
  <% end %>
<% end %>