Newsgroup: it.comp.lang.pascal
Titolo: Piccolo Help

Ho questo esercizio da svolgere:
Sia dato un array A di caratteri di lunghezza N ed un intero M. Scrivere una
funzione che restituisca TRUE se l'array A è dato dalla sequenza ripetuta
dei primi M caratteri.
Es: M=4
array = A L L S A L L S A L L S A L L S A L L S
L'output sarà TRUE poichè l'array A è dato dalla sequenza ripetuta dei primi
M(=4) caratteri (A L L S).
Io un metodo per risolverlo ce l'avrei pure, ma lo considero troppo
complicato e dispendioso.
Sono sicuro che c'è un metodo migliore.
Grazie a tutti quelli che risponderanno o semplicemente visioneranno questo
post.
Ciao Gianni

 complicato e dispendioso.
inizia a postarlo, poi si ottimizza :-)
-- 
Dreadnaut
(Life would be easier if I had the source code)

dei primi M caratteri.
program MyArray;
const N = 12;
      M = 4;
var
  a: array [1..N] of Char =
  ('A','B','C', 'D', 'A','B','C', 'D', 'A','B','C', 'D');
  I, J: Integer;
  NGruppi: Integer;
  Esito: Boolean;
begin
  Esito := false;
  if M > 0 then
  begin
    if (N mod M) = 0 then
    begin
      Esito := true;
      NGruppi := N div M;
      for I := 1 to M do
      begin
        for J := 1 to NGruppi do
        begin
          Esito := Esito and (a[(J-1)*M+I] = a[I]);
        end;
      end;
    end;
  end;
  if Esito then
    WriteLn('OK !')
  else
    WriteLn('KO !');
  ReadLn;
end.
-- 
Andrea Laforgia
#exclude <windows.h>

> program MyArray;
uff :-)  era per non dargli la pappa pronta...
pero' cosi' e' piu' semplice:
function ripetizione(a: array of char; n,m: word): boolean;
 var
  i : word;
 begin
  ripetizione := false;
  if m > 0 then
   if n mod m = 0 then {con $B- si potrebbero unire gli if }
    begin
     for i := m to n-1 do
      if a[i] <> a[i mod m] then exit;
     ripetizione := true;
    end;
 end;
 const
  N = 12;
  M = 3;
  b : array[0..N-1] of char =
('a','b','c','a','b','c','a','b','c','a','b','c');
 begin
  writeln( ripetizione (b, N, M) );
 end.


> uff :-)  era per non dargli la pappa pronta...
Hai ragione...scusami la prossima volta posto prima il programma
Grazie comunque :)
Ciao Gianni

Un piccolo appunto per [Sakuragi
il codice di dreadnat č corretto, ma conoscendo i prof del corso di laurea
se vedono
un exit nel tuo codice ti bocciano senza manco controllarne il funzionameto
quindi traforma il ciclo for in while
...
i:=m;
while (i<n-1)  and (a[i] =a[i mod m]) do
    i:=i+1;
if (i>=n-1) then ripetizione:=true;
...
Ciao RdC
--
L'informatica č un arte
---------------------------------------------------------
 
www.pascallike.too.it
 
http://utenti.lycos.it/pascallike
 il sito sulla programmazione pascal
sorgenti, tutorial ed utility
---------------------------------------------------------
"Dreadnaut" <Drea...@liberoDallaSpam.it> ha scritto nel messaggio
news:zWBW9.22955$ZE.6...@twister2.libero.it...


 il programma
np, piu' che altro perche' magari la tua non era una soluzione
sbagliata... ognuno ha la sua visione dei prog, quindi nessuno
"prende in giro" il codice degli altri... si guarda e al massimo
si consiglia :-)


pero' cosi' e' piu' semplice:
Le funzioni e` bene che abbiano sempre un unico punto di uscita,
quindi l'Exit va evitato, oltretutto in Pascal standard non esiste
"array of char".  Poi, a mio avviso, la funzione deve avere un nome
significativo per l'operazione che compie.


 significativo per l'operazione che compie.
problemi che tu avevi amabilmente evitato non scrivendo una
funzione come richiesto ma un programma dall'esplicativo titolo
"MyArray" :-)


"MyArray" :-)
Il mio scopo non era quello di offrire una funzione, il mio scopo era
quello di mostrare l'*algoritmo* e, dato che il fine era questo, il
programma poteva chiamarsi anche "PincoPallino".  Io mi aspetto che il
nostro amico prenda il codice e lo modifichi per farcelo stare in una
routine a cui dara` nome appropriato.  Se ti proponi di offrire una
soluzione piu` completa, scrivendo la funzione che l'OP,
presumibilmente, utilizzera`, dalle almeno un nome decente.  


          Esito := Esito and (a[(J-1)*M+I] = a[I]);
Credo che l'algoritmo, in questo punto, sia migliorabile.
In realta` non serve confrontare la prima sequenza con se stessa,
quindi si potrebbe assumere che NGruppi sia almeno uguale a 2 (*) e
far partire J da questo valore.
-----
(*) nel caso non lo fosse (ovvero NGruppi = 1), vuol dire che la
sequenza e` una sola e quindi l'array e` identicamente uguale a se
stesso e l'esito della funzione e` positivo.


 un exit nel tuo codice ti bocciano senza manco controllarne il
funzionameto
 SCUSA PERCHč???