[ALGORITMO] Operare con array e sottosequenze

[starise]

Ciao a tutti, mi sto cimentando con array e partizioni.
Vorrei sottoporre un problema alla vostra attenzione:

Dato A, array 1D di tipo integer di dimensione N, contenente N elem. positivi e N sottomultiplo di k.
Individuare le sottosequenze di lunghezza k;
Tale array A si può guardare come formato da successive sotto sequenze di lunghezza k.

progettare un algoritmo in pascal-like che restituisca in output un array "B" monodimensionale di tipo Logical in cui in ciascun elemento B(i), ci sia:

TRUE: se nella i-ma sottosequenza un elemento è uguale alla somma dei rimanenti elementi della sottosequenza.
FALSE: altrimenti.

Sono poco pratico sul partizionamento degli array, comunque ho elaborato un algoritmo risolutivo:

var A[n]: array of integer 
var B[blocchi]: array of logical
var n, k, inizio, fine, blocchi, count: integer
begin
inizio = 1; fine = k; blocchi = n/k; count = 1;
while (fine <= n) do
  Repeat
    somma = 0.0;
    for i=k to inizio+1 do
      somma = somma + A[i]
    endfor
    if (A[inizio]=somma) then
      B[count]=TRUE
    else
      B[count]=FALSE
    endif
    inizio=inizio+1; count=count+1;
  Until (inizio >= k)OR(B[inizio-1]=TRUE)
  inizio=inizio + k; fine = fine + k;
endwhile
end

Non credo di aver soddisfatto esattamente quello che chiedeva la traccia a livello di concezione dei passi risolutivi. Inoltre non mi piacciono istruzioni tipo Until (inizio >= k)OR(B[inizio-1]=TRUE).

Spero possiate voi darmi qualche dritta, correggere la mia soluzione o suggerire qualunque tipo di miglioramento che è possibile apportare. Ve ne sarei grato.

Cordialmente
Andrea

[alka]

Che linguaggio? E' pseudolinguaggio?

[starise]

Originariamente inviato da alka
Che linguaggio? E' pseudolinguaggio?

esatto. l'importante è l'algoritmo che risolve il problema!

credo che esistano certamente approcci migliori al tipo di problema in questione. Volevo un giudizio sull'algoritmo scritto e possibilmente qualche consiglio per migliorare.

[king64]

Un approccio alterantivo puo' essere il seguente : osservando che la condizione è soddisfatta se un elemento è pari alla somma di tutti gli altri nella sottosequenza , ne discende che la somma degli elementi della sottosequenza è il doppio di quell'elemento . Per cui , detto max il maggiore di tutti gli elementi e somma la somma della sottosequenza deve risultare verificata la condizione somma=2*max , e quindi l'algoritmo risultante sarà il seguente :

 var 
  a[n]:array of integer ;
  b[blocchi] : array of boolean; 
  i,j,k,l,m,n,blocchi,max,somma: integer; 

 begin 
  blocchi:=n/k;
  for  i:=0 to   blocchi-1 do 
  begin 
   l:=i*k;
   m:=l+k;
   max=a[l];
   somma:=0;
   {calcola la somma e il max di ogni blocco}
   for   j:=l to  m do 
   begin 
    somma:=somma+a[j];
    if max>a[j] then max:=a[j];
   end; 
   {verifica se la somma è il doppio del max}    
   if somma=2*max then
    b[i]:=TRUE
   else
    b[j]:=FALSE;
  end;
 end.

[king64]

Mi scuso per le seguenti sviste

if   max>a[j] then   max:=a[j];

va sostituito con 

if   max<a[j] then   max:=a[j];

e

b[j]:=FALSE;

con

b[i]:=FALSE;