3. Array oder doch falsch???

Array oder doch falsch???

  • P

    krank.
    und was sollen kommentare wie //Konstruktor ?
    und such mal nach initialisierungsliste.
    weiter hab ich nicht genau gelesen...

    urspruenglicher poster: du koenntest einfach hochzaehlen und die zahlen als basis 6 interpretieren. je nach dem wie weit du zaehlst, kommen immer mehr wuerfel dazu. oder du machst eine funktion mit einer schleife, die sich selbst in der schleife aufruft, je nach dem wieviele wuerfel du brauchst.

    0
  • T

    krank? Funktioniert aber wunderbar! 😉
    //Konstruktor ? Macht der Gewohnheit
    und such mal nach initialisierungsliste. Geschmackssache! Macht vielleicht gerade noch bei 2,3 Parametern Sinn, stimmt. Aber sonst ... Hab ich mir abgewöhnt.
    weiter hab ich nicht genau gelesen... 🙄
    **
    urspruenglicher poster: du koenntest einfach hochzaehlen und die zahlen als basis 6 interpretieren.**
    Das wären doch dann aber Zeichen von 0 bis 5 anstatt von 1 bis 6!

    oder du machst eine funktion mit einer schleife, die sich selbst in der schleife aufruft, je nach dem wieviele wuerfel du brauchst.
    Wie hat man denn dann bei einem Treffer noch Zugriff auf alle Augen der genutzen Würfel( z.B. für die Ausgabe )?

    Grüße,
    TS++

    [ Dieser Beitrag wurde am 30.06.2003 um 14:00 Uhr von TS++ editiert. ]

    0
  • P

    Das wären doch dann aber Zeichen von 0 bis 5 anstatt von 1 bis 6!

    also mir faellt spontan eine geeignete bijektion ein. 🙂

    Wie hat man denn dann bei einem Treffer noch Zugriff auf alle Augen der genutzen Würfel( z.B. für die Ausgabe )?

    z.b. der funktion eine referenz auf eine geeignete datenstruktur mitgeben.

    0
  • E

    hi, ich schreib dann lieber doch noch mal einen Entwurf von mir, bzw. das worauf ich hinaus will:

    ...
    cin>>Zielzahl;
    ...
    Do {
    if W2=6 { //müßte dann doch theoretisch alle
    W1++ ; // Kobinationen durchlaufen
    W2=1; }

    if W3=6 {
    W2++;
    W3=1; }

    W3++

    W1+W2+W3=AktuelleZahl
    if AktuelleZahl=Zielzahl
    Treffer++ ;
    } while Aktuelle Zahl=18 //maximum

    das gilt ja nur für drei Würfel, ich würde das aber gerne allgemein schreiben, so daß man auch für 20 Würfel die Kombinationen errechnen kann.

    0
  • T

    @PeterThe Master:
    Ok, hast mich überzeugt ( obwohl ich kein Freund der prozeduralen Welt bin ) 😉

    Die Lösung könnte dann ja folgendermaßen aussehen:

    #include <iostream.h>
#include <vector>

void traverse(int wuerfelCounter, vector<int> *values, int checkNumber)
{
    wuerfelCounter--;
    //handelt es sich noch um einen gültigen Würfel:
    if(wuerfelCounter>=0)
      {
         //alle  möglichen 6 Werte des aktuellen Würfels durchlaufen:
         for(int count=1;count<=6;count++)
            {
                //aktuellen Wert sichern:
                values->push_back(count);

                //falls noch nicht alle Würfel angesprochen wurden:
                if(wuerfelCounter>0)
                  //Augen des nächsten Würfels durchlaufen:
                  traverse(wuerfelCounter,values,checkNumber);
                else
                  {
                      //aus den bisher angesammelten Werten in 'values' die
                      //aktuelle Augensumme der 'wuerfelCounter' Würfel
                      //errechnen:
                      int sum=0;
                      char output[50]="";
                      vector<int>::iterator iter=values->begin();
                      for(;iter!=values->end();++iter)
                         {
                            sum+=*iter;

                            char c[2]="";
                            ltoa(*iter,c,10);
                            strcat(output,c);
                            strcat(output,"/");
                         }
                      strcat(output," ; ");

                      //sollten die Kontrollgröße 'checkNumber' und die
                      //ermittelte Augensumme tatsächlich übereinstimmen:
                      //entsprechende Ausgabe
                      if(sum==checkNumber) cout<<output<<flush;
                  }
                //den Wert des aktuellen Würfels wieder aus dem Container 
                //entfernen:
                values->pop_back();
            }
      }
}

//------------------------------------------------------------------------------

int main(int argc, char *argv[])
{
  vector<int> values;
  traverse(3,&values,9);
  return 0;
}

    Zufrieden?

    Vom Grundriss her eigentlich genau der gleiche Ansatz wie bei meiner ersten Lösung. Nur dass ich meine Würfel nun nicht mehr beliebig parametrisieren kann. Man könnte die Parameterliste der Funktion natürlich noch erweitern, aber .. 🙄

    Grüße,
    TS++

    [ Dieser Beitrag wurde am 01.07.2003 um 08:42 Uhr von TS++ editiert. ]

    0
  • P

    du willst also konfigurierbarkeit.
    und eine kuerzere parameterliste ist fuer den user alle mal besser.
    und ich mag kein c.

    //interface

#include<vector>

typedef int Side; //whats "augenzahl" in english?

typedef std::vector<Side> Die; //you can define your own die, just specify what numbers it has on its sides
typedef std::vector<Die> Dice; //normally for one roll you use several dice at once

extern Die defaultDie;

typedef std::vector<Side> Roll; //the result of a roll with n dice are n sides
typedef std::vector<Roll> Rolls; //a lot of rolls (e.g. which satisfy a certain condition)

Side defaultSides[] = {1,2,3,4,5,6};
Die defaultDie(defaultSides, defaultSides+6);

//diceCount - the number of dice to roll
//wanted - desired sum of the sides after one roll
//die - what does each of the dice look like
Rolls roll(int diceCount, int wanted, const Die&die=defaultDie); 
//wanted - desired sum of the sides after one roll
//dice - the dice to use for one roll
Rolls roll(int wanted, const Dice&dice); 

//implementation

#include<numeric>
#include<cassert>
using namespace std;

void rollImpl(int dieNr, int wanted, Roll¤tRoll, Rolls&res,const Dice&dice){
    for(int sideNr=0; sideNr<dice[dieNr].size(); ++sideNr){
        currentRoll[dieNr]=dice[dieNr][sideNr];
        if(dieNr>0){
            rollImpl(dieNr-1, wanted, currentRoll, res, dice);
        }else{
            if(accumulate(currentRoll.begin(), currentRoll.end(), 0) == wanted){
                res.push_back(currentRoll);
            }
        }
    }
}

Rolls roll(int diceCount, int wanted, const Die&die){
    assert(diceCount>=0);
    Dice dice(diceCount, die);
    return roll(wanted, dice);
}

Rolls roll(int wanted, const Dice&dice){
    Roll currentRoll(dice.size());
    Rolls res;
    rollImpl(dice.size()-1, wanted, currentRoll, res, dice);
    return res;
}

//test

#include<iostream>
#include<iterator>
#include<algorithm>
using namespace std;

namespace std{ //illegal, @hume: wie macht man das?
    template<typename TE>
    ostream&operator<<(ostream&os, const vector<TE>&v){
        copy(v.begin(), v.end(), ostream_iterator<TE>(os," "));
        return os;
    }
}

int main(){
    Rolls res = roll(3,9);
    copy(res.begin(), res.end(), ostream_iterator<Roll>(cout, "\n"));
    return 0;
}
    0
  • P

    ¤t

    0
  • P

    ist ja interessant.
    das macht der aus
    & c u r r e n t

    0
  • V

    typedef int Side; //whats "augenzahl" in english?

    sei einfach klug und nimm ne sprache, wo du den wirklich besten bezeichner treffen kannst.

    0
  • P

    es ist besser, ich habe einen hoeheren aufwand bezeichner zu finden als wenn der grossteil der potenziellen leser einen hoeheren aufwand hat sie zu verstehen (deutsch verstehen nicht viele).
    das ist ueberhaupt der ganze sinn des kommentierens. es macht dem autor muehe aber erleichtert es dem leser.

    0
  • V

    ein bezeichner, der nicht exakt trifft, gehört gelöscht. guter code braucht keine kommentare. dazu müßte man natürlich exakte bezeichner haben (und noch einiges mehr).
    wie viele deutsche und wie viele englische leser hat dein prog da vorhin eigentlich erwartet?

    0
Anmelden zum Antworten