Asymptotic analysis of the best and worst case

Question

I want to know the best and worst case of my code. I still don’t quite understand how to do these types of analysis in a code and wanted to have some help to know how to identify. I understand that it is necessary to know its kind of complexity and everything, in theory I even understand, but when analyzing and putting into practice I am without direction.

    static void Main(string[] args)
    {
        string s, revs = "";
        Console.WriteLine(" Digite a Palavra");
        s = Console.ReadLine();
        for (int i = s.Length - 1; i >= 0; i--) 
        {
            revs += s[i].ToString();
        }
        if (revs == s) 
        {

Answer 1

I always say that finding the real complexity is not that simple. Looking over we can say easy that it is O(n) being n the size of string s which will be known when typing the text, ie, is linear complexity because it takes the amount of steps to perform equal to the size of s.

But there is a problem that many people would let escape. When you keep concatenating string, which is immutable by default in C#, there is an additional cost to copy the string current for a new one, so at each step there will still be a cumulative copy cost. So if you change the algorithm and use an object of string Properly initialized changeable can only consider O(n). You can read more on What makes Join() so superior compared to other concatenation techniques?.

And for other reasons it is more efficient to do:

using static System.Console;
using System.Text;

public class Program {
    public static void Main() {
        WriteLine(" Digite a Palavra");
        var s = ReadLine();
        var revs = new StringBuilder(s.Length);
        for (int i = s.Length - 1; i >= 0; i--) revs.Append(s.Substring(i, 1));
        WriteLine(revs);
    }
}

Behold working in the ideone. And in the .NET Fiddle. Also put on the Github for future reference.

But if you are trying to check a palindrome there is still more efficient way, since you don’t need to make any copies and can check only half of the characters.

You can read more on What is the complexity of an algorithm?.