Newsgroup: it.comp.lang.pascal
Titolo: Anagrammi...

Devo costruire un programma che letta una parola (es. ciao) costruisca tutti
i possibli anagrammi e li metta in un file....
Non riesco a trovare un modo abbastanza compatto per creare tutti i possibli
anagrammi....
Qualcuno mi può dare qualche indicazione?
Grazie!
--DaX--

you wrote :
#Devo costruire un programma che letta una parola (es. ciao) costruisca tutti
#i possibli anagrammi e li metta in un file....
#Non riesco a trovare un modo abbastanza compatto per creare tutti i possibli
#anagrammi....
#Qualcuno mi può dare qualche indicazione?
#Grazie!
Il seguente programma e' scritto in C ed e' una traduzione da una
versione in pascal che scrissi tempo prima e che postai su questo
stesso ng.
/**********************************************************
 * anagramm.c - Calcolo degli anagrammi di una parola     *
 * ------------------------------------------------------ *
 * ALCLIB v1.0 - Andrea Laforgia C Library                *
 * (C)1999 Andrea Laforgia (
andrea_...@bigfoot.com
)  *
 * ------------------------------------------------------ *
 * NOTE : sebbene il programma funzioni,andrebbe forse    *
 * controllata meglio l'allocazione di memoria nella      *
 * funzione estratto().                                   *
 **********************************************************/
#include <stdio.h>
#include <stdlib.h>
typedef char string[256] ;
typedef struct { unsigned long idx;
                 string buffer;
               } buffer_record ;
char * estratto( char * t, int i )
{
   char * temp;
   temp = (char * ) malloc( strlen( t ) + 1 ) ;
   strcpy(temp, t);
   while (temp[i] = temp[i+1]) ++i;
   return ( temp );
}
char * concat_char( char * s, char c )
{
       unsigned l = strlen( s ) ;
       s[l] = c ;
       s[l+1] = '\0' ;
       return s;
}
char * remove_last_char( char * s )
{
      unsigned l = strlen( s ) ;
      s[l-1] = s[l];
      return ( s ) ;
}
void scrivi_anagrammi( char * t, buffer_record * a )
{
  unsigned i, len = strlen( t );
  if ( len )
  {
    for ( i = 0 ; i < len ; i++ )
    {
	concat_char( a->buffer, t[i] ) ;
	scrivi_anagrammi( estratto( t, i ), a );
        remove_last_char( a->buffer ) ;
    }
  }
  else
    printf("%5lu) %s | ", ++(a->idx), a->buffer);
}
int main()
{
  string mio ;
  buffer_record mio_record = { 0, "" };
  printf("inserisci parola : "); gets( mio );
  scrivi_anagrammi( mio, &mio_record );
  return 0;
}
--------------------------------------------------------
* Andrea Laforgia        (
andrea_...@bigfoot.com
) *
--------------------------------------------------------

 i possibli anagrammi e li metta in un file....
...in pratica si tratta di trovare tutte le possibili permutazioni di n
elementi (che sono n! cioe' n fattoriale. n! = n*(n-1)*(n-2)*...*3*2). Sto
lavorando su una cosina del genere. Tieni presente che il numero di elementi
deve essere <10, altrimenti i tempi di calcolo diventerebbero inacettabili!
Mandi, fantoibed !
-----------------------------
program Permutazioni;
(*max e' una variabile da 1 a 10
che dice il numero di elementi da permutare*)
type mat=array[1..10] of byte;
     supermat=array [1..10] of longint;
var
   i,max:integer;
   n,ntot:longint;
   matin,matout,matperm:mat;
   matfatt:supermat;
function fatt(n:integer):longint;
var
   i:integer;
   j:longint;
begin
     j:=1;
     for i:=1 to n do j:=j*i;
     fatt:=j
end;
procedure creamatfatt(var matfatt:supermat);
var
   i:integer;
begin
     for i:=1 to max do matfatt[i]:=fatt(i)
end;
procedure creamatperm(nperm:longint;matfatt:supermat;var permut:mat);
var
   i:integer;
begin
     for i:=1 to max do permut[i]:=0;
     for i:=1 to max do
         begin
              permut[i]:=nperm div matfatt[max-i];
              nperm:=nperm mod matfatt[max-i]
         end
end;
procedure scorri(part:integer;posiz:integer;matin:mat;var matout:mat);
var
   i:integer;
begin
     for i:=part to max do
         begin
              if i-posiz>part-1 then
                 matout[i]:=matin[i-posiz]
                 else
                 matout[i]:=matin[i-posiz+max-part+1]
         end
end;
procedure permuta(matin:mat;var matout:mat;permut:mat);
var
   i:integer;
begin
     for i:=1 to max-1 do
         begin
         scorri(i,permut[i],matin,matout);
         matin:=matout
         end
end;
begin (* main *)
     max:=4;
     ntot:=fatt(max);
     for i:=1 to max do matin[i]:=i-1;
     matout:=matin;
     creamatfatt(matfatt);
     for n:=1 to ntot do
         begin
         creamatperm(n,matfatt,matperm);
         permuta(matin,matout,matperm);
         write('   Perm ',n:2,': ');
         for i:=1 to MAX do write(matout[i]);
         end;
   readln
end.

 Grazie!
 Sotto ti hanno gia risposto ..forse correttamente forse no.
 Dipende da cosa intendi tu per anagrammi ..
 Se per anagrammi intedi le permutazioni di una parola (tutte) .. le
risposte che ti hanno dato vanno bene.
 Se invece per anagrammi (come me) intendi tutte le parole di senso compiuto
proprie di un dizionario  ben preciso di vocaboli italiani che e' possibile
estrapolare da tutte le permutazioni possibili di una parola data...
es ... la permutazione "assegni"  della parola "ingessa" e' valida  ..
"essaing" ovviamente no.
Allora dai una scorsa all'articolo "anche la programmazione ha il suo
sgurtz"
www3.cybercities.com/a/articoli/index.htm
  .. ci trovi quello che ti serve
(pero' e' in c.. :)) )

you wrote :
# Se invece per anagrammi (come me) intendi tutte le parole di senso compiuto
E' vero, il significato corretto della parola anagramma e' proprio
questo.
In realta', avendo a disposizione un elenco delle parole di un
dizionario di italiano e' facile adattare il mio programma alla
generazione di tutte le parole di senso compiuto.
