Dicho esto, supongo que amchacon se refería a hacerlo por cualquier método menos por el método de sumar.

---

Tenía pendiente hacer esto. Aquí está:

#include <iostream>
#include <vector>
 
using namespace std;
 
class factorial{
    vector<uint32_t> mul, div;
    bool divided;
 
    public: static void f(vector<uint32_t> &v, uint32_t n){
        for(uint32_t i=2; i<(n/2)+1;)
            if(n%i==0){
                v.push_back(i);
                n/=i;
            }else ++i;
            v.push_back(n);
    }
public:
    factorial():divided(false){mul.clear(); div.clear();}
 
    int getMulCount()const{return mul.size();}
    uint32_t getMul(int n)const{if(n>=0 && n<mul.size()) return mul[n]; else return 0;}
    vector<uint32_t> getMul()const{return mul;}
    void addMul(uint32_t m){mul.push_back(m);divided=false;}
    void addMulFactorial(uint32_t f){if(f)for(int i=1; i<=f; i++) mul.push_back(i);divided=false;}
 
    int getDivCount()const{return div.size();}
    uint32_t getDiv(int n)const{if(n>=0 && n<div.size()) return div[n]; else return 0;}
    vector<uint32_t> getDiv()const{return div;}
    void addDiv(uint32_t d){div.push_back(d);divided=false;}
    void addDivFactorial(uint32_t f){if(f)for(int i=1; i<=f; i++) div.push_back(i);divided=false;}
 
    void fact(){factMul();factDiv();}
    void factMul(){
        vector<uint32_t> temp(mul);
        mul.clear();
        for(int i=0; i<temp.size(); i++)
            f(mul, temp[i]);
        for(int i=0; i<mul.size();)
            if(mul[i]==1)
                mul.erase(mul.begin()+i);
            else ++i;
    }
    void factDiv(){
        vector<uint32_t> temp(div);
        div.clear();
        for(int i=0; i<temp.size(); i++)
            f(div, temp[i]);
        for(int i=0; i<div.size();)
            if(div[i]==1)
                div.erase(div.begin()+i);
            else ++i;
    }
    void divide(){
        fact();
        for(int i=0; i<mul.size(); i++)
            for(int j=0; j<div.size(); j++)
                if(mul[i]==div[j]){
                    mul.erase(mul.begin()+i);
                    div.erase(div.begin()+j);
                    --i; --j;
                    break;
                }
        divided=true;
    }
    uint64_t get(){
        uint64_t t=1;
        if(!divided) divide();
        for(int i=0; i<mul.size(); i++)
            t*=mul[i];
        for(int i=0; i<div.size(); i++)
            t/=div[i];
        return t;
    }
    void clear(){mul.clear(); div.clear();divided=false;}
};
 
void FilaTrianguloPascal(uint64_t *&arr, uint32_t n){
    factorial f;
    arr = new uint64_t[n+1];
    for(int i=0; i<=n; i++){
        f.addMulFactorial(n);
        f.addDivFactorial(i);
        f.addDivFactorial(n-i);
        f.divide();
        arr[i] = f.get();
        f.clear();
    }
}
 
int main(){
    uint64_t *v;
    for(int i=0; i<10; i++){
        FilaTrianguloPascal(v, i);
        for(int j=0; j<=i; j++)
            cout << v[j] << " ";
        if(i) delete[] v;
        else delete v;
        cout << endl;
    }
}

Opino lo mismo que Eferion. Cierto es, que muchas cosas se pueden tratar como recursivas.
Para evitar esto, se pone un límite: Las recursivas son las que se llaman a si mismas.

El reto era devolver la línea, no el triángulo.

En programación, una función es recursiva si tiene una condición de retorno, y en los demás retornos se llama a si misma ·_·

No es recursividad. Guardo datos en una variable, y accedo a ellos. No llamo a la función.

Acaso eso es recursividad?

Sinó puedes hacer un XOR para ese bit, que quedaría "var ^ 32;" si no me equivoco.

¿Así?

#include <iostream>
#include <vector>
 
using namespace std;
 
void FilaTrianguloPascal(uint64_t *&arr,int n){
    if(n<0) return;
    static vector< vector<uint64_t> > v;
    if(v.size()<=n)
        for(uint32_t i=v.size(); i<=n; i++){
            v.push_back(vector<uint64_t>());
            for(uint32_t j=0; j<=i; j++)
                if(j==0 || j==i)
                    v[i].push_back(1);
                else
                    v[i].push_back(v[i-1][j]+v[i-1][j-1]);
        }
    arr = new uint64_t[n+1];
    for(int i=0; i<=n; i++)
        arr[i] = v[n][i];
}
 
#define NUM 10
 
int main(){
    uint64_t *v;
    FilaTrianguloPascal(v, NUM);
    for(int i=0; i<=NUM; i++)
        cout << v[i] << " ";
}

Usé unsigned long long, sinó no entran los valores.
También puse una puntero al array, para que se haga la petición de memoria desde la misma función. Es se puede cambiar si se desea :3

Siempre puedes analizar el nombre del archivo. O el contenido incluso.

Enviado desde mi ST21i mediante Tapatalk

En realidad, el "IF", y todo el código que entra dentro de este, es como solo 1 instrucción para el "FOR". Ya tiene sus propias llaves. Era correcto.