"Oferta de dedo espada" Pregunta 64: Encuentra 1 + 2 + ... + n

// Pregunta de la entrevista 64: Buscando 1 + 2 + ... + n
 // Pregunta: Buscando 1 + 2 + ... + n, requiere que no pueda usar la multiplicación y la división, para, mientras, si, si no, cambiar, mayúsculas
 // y otras palabras clave y Sentencia condicional (A? B: C). 

#include <cstdio> // ==================== Método 1 ====================
 / / Utilice el constructor para resolver la clase Temp 
{ public : 
    Temp () { ++ N; Sum + = N;} static void Reset () {N = 0 ; Sum = 0 ;}
     static unsigned int GetSum () { return Sum;} private :
     // miembro estático, todas las instancias comparten estático sin firmar





     


    int N;   // número actual 
    estático sin signo int Sum; // suma acumulativa 
}; 

unsigned int Temp :: N = 0 ; 
unsigned int Temp :: Sum = 0 ; 

unsigned int Sum_Solution1 (unsigned int n) 
{ 
    Temp :: Reset ( );   // Inicializar 

    Temp * a = new Temp [n];   // Crear n instancias, el constructor se llamará n veces 
    delete [] a; 
    a = nullptr; 

    return Temp :: GetSum (); 
} 

//==================== Método 2 ====================
 // Usa la función virtual para resolver la 
clase A ; 
A * Array [ 2 ]; 

clase A 
{ 
public :
     virtual unsigned int Sum (unsigned int n) // Función de procesamiento abortada 
    {
         return  0 ; 
    } 
}; 

clase B: public A 
{ 
public :
     virtual unsigned int Sum (unsigned int n )   // actúa como una función recursiva 
    {
         //!! n El valor distinto de cero es verdadero, el valor cero es falso 
        retorno Array [!! n] -> Sum (n- 1 ) + n; 
    } 
}; 

int Sum_Solution2 ( int n) 
{ 
    A a; 
    B b; 
    Array [ 0 ] = & a ; 
    Array [ 1 ] = & b; 

    // Cuando n es mayor que 0, ejecute siempre la suma en B hasta que n == 0 
    int value = Array [ 1 ] -> Sum (n); 

    return value; 
} 

/ / ==================== Método tres ====================
 // Utilice el puntero de función para resolver 
typedef unsigned int (* fun) (unsigned int); 

unsigned int Solution3_Teminator (unsigned int n) 
{ 
    return  0 ; 
} 

unsigned int Sum_Solution3 (unsigned int n) 
{ 
    // Miembro estático, el método de implementación es similar al método dos 
    static static f [ 2 ] = {Solution3_Teminator, Sum_Solution3}; // Dos funciones 

    // llamar a la función Sum_Solution3 cuando n es mayor que 0
     // llamar a la función Solution3_Teminator 
    return n + f [!! n] (n- 1 );

 n 
} // ======== ============ Método 4 ====================
 // Utilice el tipo de plantilla para resolver
plantilla <unsigned int n> struct Sum_Solution4 
{ 
    // 实现方法 类似
    enum Valor {N = Sum_Solution4 <n - 1 > :: N + n}; 
}; 

template <> struct Sum_Solution4 < 1 > 
{ 
    enum Value {N = 1 }; 
}; 

template <> struct Sum_Solution4 < 0 > 
{ 
    enum Value {N = 0 }; 
};

// ==================== 测试 代码 ====================
 prueba nula ( int n, int esperado) 
{ 
    printf ( " Comienza la prueba para% d: \ n " , n); 

    if (Sum_Solution1 (n) == esperado) 
        printf ( " Solución1 aprobada. \ n " );
    else 
        printf ( " Solución1 falló. \ n " ); 

    if (Sum_Solution2 (n) == esperado) 
        printf ( " Solución2 aprobada. \ n " );
    sino 
        printf ( "Solución2 falló. \ N " ); 

    if (Sum_Solution3 (n) == esperado) 
        printf ( " Solución3 aprobada. \ N " ); de lo
     contrario 
        printf ( " Solución3 falló. \ N " ); 
} 

void Test1 () 
{ 
    const unsigned int número = 1 ;
     int esperado = 1 ; 
    Prueba (número, esperado); 
    if (Sum_Solution4 <número> :: N == esperado) 
        printf ( " Solución4 aprobada. \ n " );
     más
        printf ( " Solución4 falló. \ n " ); 
} 

void Test2 () 
{ 
    const unsigned int number = 5 ;
    int esperado = 15 ; 
    Prueba (número, esperado); 
    if (Sum_Solution4 <número> :: N == esperado) 
        printf ( " Solución4 aprobada. \ n " );
    else 
        printf ( " Solución4 falló. \ n " ); 
} 

void Test3 () 
{ 
    const unsigned int number =10 ;
    int esperado = 55 ; 
    Prueba (número, esperado); 
    if (Sum_Solution4 <número> :: N == esperado) 
        printf ( " Solución4 aprobada. \ n " );
    else 
        printf ( " Solución4 falló. \ n " ); 
} 

void Test4 () 
{ 
    const unsigned int number = 0 ;
    int esperado = 0 ; 
    Prueba (número, esperado); 
    if (Sum_Solution4 <número> :: N == esperado) 
        printf (" Solución 4 aprobada. \ N " );
    else 
        printf ( " Solución4 falló. \ n " ); 
} 

int main ( int argc, char * argv []) 
{ 
    Test1 (); 
    Prueba2 (); 
    Prueba3 (); 
    Prueba4 (); 

    devuelve  0 ; 
}

Código de prueba

Análisis: a través de varios métodos para lograr la operación recursiva.

typedef int (* diversión) ( int );
solución de clase {
 public : 
    
    static  int Solution3_Teminator ( int n) { return  0 ; } 
    
    static  int Sum_Solution ( int n) { 
        
        static fun f [ 2 ] = {Solution3_Teminator, Sum_Solution};
        devuelve n + f [!! n] (n - 1 ); 
    } 
};

Código de envío de Niuke