Quando un codice è considerato stretto e in che modo aumenta l'efficienza del codice?

Quando a un algoritmo viene assegnata una designazione Big O come O(n log n) , viene indicato come verrà ridimensionato l'algoritmo; cioè, quanto bene si produrrà aumentando la dimensione di n a un numero elevato.

Diciamo che ho un algoritmo che è O(n) su un set di dati. Ciò significa che c'è un ciclo nel codice da qualche parte che esegue n volte, una volta per ogni elemento nel set di dati. Quanto ci vorrà per eseguire? Supponendo che ogni iterazione del ciclo richieda circa lo stesso tempo, ci vorrà

m * n

Dove m è la quantità di tempo necessaria per elaborare un elemento del set di dati.

È chiaro che ci vorrà più tempo per elaborare il set di dati se m è più alto. Big O non si rivolge a quel momento; afferma solo che (in questo caso), l'algoritmo verrà scalato linearmente in funzione della dimensione del set di dati.

Quindi un "ciclo stretto" è semplicemente uno che ha un m più piccolo.

Questo è il "fattore costante nascosto" di cui parla il libro. Ridurre m migliora l'efficienza perché qualsiasi miglioramento in m sarà moltiplicato per l'intero set di dati.

Il codice tight è un codice sorgente molto efficiente in quanto svolge un'attività con un minimo di risorse e nessun codice superfluo.

Voglio visualizzare la somma di 1 e 3 in C #. Il programma 1 svolge questa attività con un codice limitato. Il programma 2 non lo è.

Programma 1:

class Program
{
    static void Main(string[] args)
    {
        Console.Write(4);
    }
}

Programma 2:

class Program
{
    static void Main(string[] args)
    {
        var myAdder = new Adder();
        Console.Write(myAdder.GetSum());
    }
}

class Adder
{
    public Adder()
    {
        this.FirstOperand = 1;
        this.SecondOperand = 3;
    }

    public int FirstOperand { get; set; }
    public int SecondOperand { get; set; }

    public int GetSum()
    {
        return this.FirstOperand + this.SecondOperand;
    }
}