Problema del triangolo

Question

Sto cercando di risolvere il problema di Eulero 18 - > http://projecteuler.net/index.php?section=problems < !> amp; id = 18

Sto provando a farlo con c ++ (lo sto riapprendendo e i problemi di euler sono un buon materiale di apprendimento / ricerca)

#include <iostream>

using namespace std;

long long unsigned countNums(short,short,short array[][15],short,bool,bool);

int main(int argc,char **argv) {

    long long unsigned max = 0;
    long long unsigned sum;


    short piramide[][15] = {{75,0,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {95,64,0,0,0,0,0,0,0,0,0,0,0,0,0},
                            {17,47,82,0,0,0,0,0,0,0,0,0,0,0,0},
                            {18,35,87,10,0,0,0,0,0,0,0,0,0,0,0},
                            {20,4,82,47,65,0,0,0,0,0,0,0,0,0,0},
                            {19,1,23,75,3,34,0,0,0,0,0,0,0,0,0},
                            {88,2,77,73,7,63,67,0,0,0,0,0,0,0,0},
                            {99,65,4 ,28,6,16,70,92,0,0,0,0,0,0,0},
                            {41,41,26,56,83,40,80,70,33,0,0,0,0,0,0},
                            {41,48,72,33,47,32,37,16,94,29,0,0,0,0,0},
                            {53,71,44,65,25,43,91,52,97,51,14,0,0,0,0},
                            {70,11,33,28,77,73,17,78,39,68,17,57,0,0,0},
                            {91,71,52,38,17,14,91,43,58,50,27,29,48,0,0},
                            {63,66,4,68,89,53,67,30,73,16,69,87,40,31,0},
                            {4,62,98,27,23,9,70,98,73,93,38,53,60,4,23}};

    for (short i = 0;i<15;i++) {
        for (short m=0;m<15;m++) {
            if (piramide[i][m] == 0)
                break;
            sum = countNums(i,m,piramide,15,true,true);
            if (sum > max)
                max = sum;
            sum = countNums(i,m,piramide,15,true,false);
            if (sum > max)
                max = sum;
            sum = countNums(i,m,piramide,15,false,true);
            if (sum > max)
                max = sum;
            sum = countNums(i,m,piramide,15,false,false);
            if (sum > max)
               max = sum;

        }

    }
    cout << max;
    return 0;
}


long long unsigned countNums(short start_x,short start_y,short array[][15],short size, bool goright,bool goright2) {
    long long unsigned currentSum;

    currentSum = array[start_x][start_y];

    if (goright) { //go right
        if ((start_x + 1) < size)
            start_x++;
        if ((start_y + 1) < size)
            start_y++;
    }
    else //go down
        if ((start_x + 1) < size)
            start_x++;

    if (goright2) { //still going right
        for (short i = start_x, m = start_y;i< size && m < size;i++,m++) {
            currentSum += array[i][m];         
        }
    }
    else { //still going down
        for (short i = start_x;i<size;i++) {
            currentSum += array[i][start_y];            
        }
    }

    return currentSum;
}

La funzione countNums è usata per andare giù o in diagonale. Ho provato questa funzione in questo modo:

short a = 0;
short b = 0;
cout << countNums(a,b,piramide,15,true,true) << endl;
cout << countNums(a,b,piramide,15,true,false) << endl;
cout << countNums(a,b,piramide,15,false,true) << endl;
cout << countNums(a,b,piramide,15,false,false) << endl;
return 0;

E funziona (ho anche cambiato un po 'la funzione in modo da stampare ogni numero che stava attraversando)

Ma ancora non ottengo il risultato giusto. Questo va verso il basso e verso destra e continua a destra (numeri adiacenti a destra), scende e continua a scendere (numero adiacente a sinistra). Cosa sto facendo di sbagliato qui, nessuno?

---

Alastair: è semplice

countNums long long unsigned (short start_x, short start_y, short array [] [15], short size, bool goright, bool goright2);

start_x e start_y sono i coordini dell'array array è il riferimento all'array size è solo la dimensione dell'array (è sempre 15) goright è sapere se ho intenzione di andare giù, a destra o semplicemente in basso goright2 è sapere se ho intenzione di continuare a scendere o andare a sinistra

Answer 1

Ok, quindi prima di tutto, sono un po 'poco chiaro su quale pensi sia il problema. Non riesco affatto ad analizzare la penultima frase ...

In secondo luogo, potresti voler ripensare il tuo progetto qui. Pensa alle funzioni che eseguono un singolo compito discreto e non sono intrecciate con il resto dell'applicazione (ad es. Leggi su & Quot; strettamente accoppiato e vagamente legato & Quot;). Per me una grande campana di avvertimento qui è la presenza di un nome di funzione troppo generico countNums con un lungo elenco di argomenti.

Penso che se dovessi dividere il problema in blocchi più piccoli, più facilmente comprensibili, potresti trovare i problemi molto più facili da trovare. Conosco l'approccio che prenderei qui, ma presumo che l'intero punto dell'esercizio sia di aiutarti a mettere in pratica le tue capacità di programmazione, quindi lo lascerò solo in questo ...

Answer 2

Ho risolto questo problema. Data la natura del Project Euler è di risolvere il problema da soli (& Quot; fotocopiare un cruciverba risolto non significa che tu abbia risolto & Quot;) e che non voglio rovinarlo per qualcuno altrimenti, tutto quello che posso davvero dire è che la tua soluzione sembra eccessivamente complessa.

Tuttavia, puoi risolvere questo problema mentre stai leggendo il file. Risolvilo in questo modo e il problema n. 69 sarà un gioco da ragazzi!

Buona fortuna!

Answer 3

Sono un po 'confuso dal problema ..
Comincerei ripulendo il tuo codice.

long long unsigned countNums(short x,
                             short y,
                             short array[][15],
                             short size, 
                             bool goright,
                             bool goright2) 
{
    long long unsigned currentSum;
    currentSum = array[x][y];

    if ((x + 1) < size)    x++; //this happened in both your if cases

    if (goright && ((y + 1) < size)      y++; 

    if (goright2)
    { 
        for (;x< size && y< size;x++,y++)
            currentSum += array[x][y];         

    }
    else 
    {
        for (;x<size;x++) 
            currentSum += array[x][y];            
    }
    return currentSum;
 }

Ora ho letto la domanda e non sono sicuro che stia facendo quello che vuoi. Dal momento che questo non è quello che vuoi, suggerirei prima la risposta a psudo-codice. Dimentica il codice. Qual è la risposta nel codice sudo.
Oh e per l'amore di tutto ciò che è santo. Non inserire più di un inizializzatore nel ciclo for. So che mi sbaglierò per questo, ma è disordinato e davvero non necessario. Qualcosa che potresti considerare è una funzione recusiva. Sembra ideale per questo problema.

Answer 4

La funzione principale controlla che una voce sia diversa da zero, ma l'altra funzione che chiama non controlla ciò anche se cambia di nuovo l'indice. Non lo so, non capisco davvero cosa stai cercando di fare.

Vedo la dimensione dell'array 15 per 15 elementi, l'indice per la dichiarazione inizierà anche da 0? Fammi controllare per un secondo. Solo assicurandomi, dichiarato con dimensioni ma accessibile in base a 0. Buono.

Perché hai usato un nidificato per le istruzioni in un posto ma una condizione per le dichiarazioni in seguito è stata compilata? Meglio verificare che && non abbia una precedenza maggiore rispetto a <. Il gruppo 8 batte il gruppo 13 qui . Operatore di incremento non utilizzato più volte in un'istruzione, va bene.

Sembra che tu abbia già fatto questo problema in un'altra lingua, potresti fare una traccia anche su questo e trovare il posto in cui il tuo nuovo programma differisce per primo?

Gli altri ragazzi hanno ragione, la domanda è confusa. Vorrei prima provare a risolvere il problema, comprando la costruzione di punteggi secondari in un'altra matrice dando il punteggio più alto se la piramide fosse iniziata in quel punto e la costruissi dalla fila inferiore alla cima.