Newsgroup: it.comp.lang.c++
Titolo: salve a tutti!

Salve a tutti! Sono nuovo e inizio subito a chiedere!
Volevo sapere se qualcuno mi sa dire se conosce un algoritmo valido per
creare tutte le permutazioni disponibili per 10 cifre...
Sono esattamente 3628800 ovvero 10!
Ora però non so come crearle tutte...
Un Aiuto....
Ciao a tutti
Karoth

 creare tutte le permutazioni disponibili per 10 cifre...
come da Stroustrup:
#include <iostream>
#include <algorithm>
int main()
{
    char v[] = "abcd";
    std::cout << v << '\t';
    while(std::next_permutation(v,v+4))
        std::cout << v << '\t';
}
--
Gerolamo
Using: Win2000 Pro, Borland C++ Compiler 5.5.1
Listening: Marillion - Lavender

 Ora però non so come crearle tutte...
Facilissimo.
Il mio esempio non e' dei piu' facili ma sicuramente dopo averlo
compilato risultera' sicuramente il piu' veloce.
:-)
Non me ne vogliate.
Ciao
Gaetano.
#define max 9
template <int A, int B, int C, int D, int E, int F, int G, int H, int I, int
L>
struct perm
{
 void static go() {
  std::cout << A <<  B << C << D << E << F << G << H << I << L << std::endl;
        perm<A, B, C, D, E, F, G, H, I, L-1>::go();
 }
};
template <int A, int B, int C, int D, int E, int F, int G, int H, int I>
struct perm<A, B, C, D, E, F, G, H, I, 0>
{
 void static go() {
  std::cout << A <<  B << C << D << E << F << G << H << I << 0 << std::endl;
        perm<A, B, C, D, E, F, G, H, I-1, max>::go();
 }
};
template <int A, int B, int C, int D, int E, int F, int G, int H>
struct perm<A, B, C, D, E, F, G, H, 0, 0>
{
 void static go() {
  std::cout << A <<  B << C << D << E << F << G << H << 0 << 0 << std::endl;
        perm<A, B, C, D, E, F, G, H-1, max, max>::go();
 }
};
template <int A, int B, int C, int D, int E, int F, int G>
struct perm<A, B, C, D, E, F, G, 0, 0, 0>
{
 void static go() {
  std::cout << A <<  B << C << D << E << F << G << 0 << 0 << 0 << std::endl;
        perm<A, B, C, D, E, F, G-1, max, max, max>::go();
 }
};
template <int A, int B, int C, int D, int E, int F>
struct perm<A, B, C, D, E, F, 0, 0, 0, 0>
{
 void static go() {
  std::cout << A <<  B << C << D << E << F << 0 << 0 << 0 << 0 << std::endl;
        perm<A, B, C, D, E, F-1, max, max, max, max>::go();
 }
};
template <int A, int B, int C, int D, int E>
struct perm<A, B, C, D, E, 0, 0, 0, 0, 0>
{
 void static go() {
  std::cout << A <<  B << C << D << E << 0 << 0 << 0 << 0 << 0 << std::endl;
        perm<A, B, C, D, E-1, max, max, max, max, max>::go();
 }
};
template <int A, int B, int C, int D>
struct perm<A, B, C, D, 0, 0, 0, 0, 0, 0>
{
 void static go() {
  std::cout << A <<  B << C << D << 0 << 0 << 0 << 0 << 0 << 0 << std::endl;
        perm<A, B, C, D-1, max, max, max, max, max, max>::go();
 }
};
template <int A, int B, int C>
struct perm<A, B, C, 0, 0, 0, 0, 0, 0, 0>
{
 void static go() {
  std::cout << A <<  B << C << 0 << 0 << 0 << 0 << 0 << 0 << 0 << std::endl;
        perm<A, B, C-1, max, max, max, max, max, max, max>::go();
 }
};
template <int A, int B>
struct perm<A, B, 0, 0, 0, 0, 0, 0, 0, 0>
{
 void static go() {
  std::cout << A <<  B << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << std::endl;
        perm<A, B-1, max, max, max, max, max, max, max, max>::go();
 }
};
template <int A>
struct perm<A, 0, 0, 0, 0, 0, 0, 0, 0, 0>
{
 void static go() {
  std::cout << A <<  0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << std::endl;
        perm<A-1, max, max, max, max, max, max, max, max, max>::go();
 }
};
template <>
struct perm<0, 0, 0, 0, 0, 0, 0, 0, 0, 0>
{
 void static go() {
  std::cout << 0 <<  0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << 0 << std::endl;
 }
};
int main()
{
   perm<max, max, max, max, max, max, max, max, max, max>::go();
   return 0;
}
-- 
Posted from 
dell-01.mm.eutelsat.org
 [194.214.173.17] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

azz... e questo come lo risolvo??
(prego evitare risposte tipo: usa un SO/Compilatore serio :-))
Borland C++ 5.5.1 for Win32 Copyright (c) 1993, 2000 Borland
permutazioni.cpp:
Fatal F1008 permutazioni.cpp 11: Out of memory in function
perm<9,9,9,9,9,9,8,3,9,9>::go()
*** 1 errors in Compile ***
--
Gerolamo
Using: Win2000 Pro, Borland C++ Compiler 5.5.1
Listening: Marillion - Blind Curve

};
Carino, ma impossibile che funzioni. Anche se fosse possibile istanziare
un numero tanto grande di template, mi pare che tu stia valutando tutte
le combinazioni, non tutte le permutazioni ( 10^10 vs 10! ).
ciao
Massimo

 *** 1 errors in Compile ***
Ma ci hai provato veramente? Mi spiace ma per compilare
quel codice devi alzare la profondita' massima di template 
che il compilatore deve gestire nel mio caso 10^10  e ti 
ci metterebbe un tempo enorme.... per non parlare della
grandezza dell'eventuale eseguibile.
Quello che importa e' che tu capisca come funziona.
Ciao
Gaetano.


 Massimo
Perche' impossibile ? Sul fatto che ho valutato
tutte le combinazioni hai ragione.
Ciao
Gaetano.


 ha scritto nel messaggio
news:%6AM7.183471$sq5.8...@news.infostrada.it...

Grazie mille! volevo sapere una cosa...io non sono ancora arrivato alle
classi, anche se posso vedermele da solo...cmq mi sembra di capire che
questo algoritmo crei le permutazioni vero?
La soluzione proposta da Gaetano mi sembra di aver capito che dia in uscita
le combinazioni invece delle permutazioni che servono a me...
Il tuo mi da le permutazioni vero?
Grazie ancora!
Karoth

 ha scritto nel messaggio
news:028c01c176d1$d580b930$1aadd6c2@GMENDOLA2...


Non me ne vogliate.
Ciao
Gaetano.
#define max 9












Grazie mille...ma arrivato in fondo al tread ho notato che il tuo mi
restituisce le combinazioni contro le permutazioni che servono a me...vero?
grazie comunque!!
A presto
Karoth

 Il tuo mi da le permutazioni vero?
beh... se si schiama next_permutation direi che e' abbastanza probabile
che dia le permutazioni, non ti pare? :-))))
comunque in effetti next_permutation(first, last)
prende una sequenza individuata da first e last (che devono essere due
iteratori bidirezionali) e ne fa la prossima permutazione.
In pratica gli passi una sequenza ordinata sulla quale deve essere
definito l'operatore "<" e, se esiste, next_permutation fa la successiva
permutazione e restituisce true.
Se invece non esiste la successiva permutazione (quindi la sequenza
e' ordinata esattamente al contrario) restituisce false.
E' per questo che mettendo next_permutation applicato ad una sequenza
ORDINATA in un while, questo proseguita' l'esecuzione fino ad
aver passato tutte le permutazioni della sequenza.
In effetti devi assicurarti che la sequenza all'inizio sia ordinata,
per cui, per completare il mio esempio, inserisci prima del while la riga:
std::sort(v, v+4); // questo ordina la sequenza
algoritmi come next_permutation, prev_permutation, sort, ecc...
sono piegati bene nell'ultimo capitolo del libro di Lippman
"C++, corso di programmazione" terza edizione.
Ciao!
--
Gerolamo
Using: Win2000 Pro, Borland C++ Compiler 5.5.1
Listening: The Cure - Love Song

 Quello che importa e' che tu capisca come funziona.
ecco, appunto...
Facciamo che adesso me lo guardo e poi, se mai, chiedo----
Ciao
--
Gerolamo
Using: Win2000 Pro, Borland C++ Compiler 5.5.1


incredibile karoth..
ci sei dappertutto eh?
ciao furbone! by un altro furbone
Cereal Killer