Newsgroup: it.comp.lang.pascal
Titolo: Alcuni quesiti

Ciao a tutti,
premetto che sono nuovo del gruppo, il pascal lo conosco solamente in
parte. Avrei bisogno in TP7 di fare una cosa del genere attraverso la
funzione randomize.
Ho bisogno che all'avvio del programma il computer mi generi 8 numeri
che siano diversi l'uno dall'altro e che partano da 1 per arrivare a
130. Quindi deve visualizzarmeli uno accanto all'altro in ordine
crescente. Sapete aiutarmi a realizzare una cosa del genere? Grazie
sin da ora per le vostre e.mail.
Vincenzo Accardi - (Palermo, ITALY)
 
E-Mail: 
vin...@iol.it
E-Mail: 
vin...@puntofuturo.net
ICQ UIN: 20344085
 
-------------------------------------------------
Euro Conversion 2000 - Il miglior software per 
convertire le lire in euro e viceversa. Freeware!
http://volftp.tin.it/italiani/accardi/index.htm
-------------------------------------------------

crescente.
Eccoti qua il programmino bello e pronto...
-------------------------------------------------------------
uses crt;
var n:array[1..8] of integer;
    i,j,app:integer;
    pass:boolean;
begin
   randomize;
   clrscr;
   for i:=1 to 8 do
   repeat
      pass:=true;
      n[i]:=random(130)+1;
      for j:=1 to i-1 do if n[j]=n[i] then pass:=false;
   until pass;
   {Ordinamento vettore}
   for i:=1 to 7 do
      for j:=8 downto i+1 do
        if n[j]<n[j-1] then
        begin
           app:=n[j];
           n[j]:=n[j-1];
           n[j-1]:=app;
        end;
   {Fine ordinamento vettore}
   for i:=1 to 8 do write(n[i],'   ');
   readkey;
end.
------------------------------------------------------
Sappi che l'ordinamento del vettore è stato eseguito con un algoritmo detto
"bubblesort" ... ovvero vengono confrontati tutti gli elementi adiacenti del
vettore a 2 a 2 (partendo dal fondo)e si scambiano di posizione a seconda
dell'ordinamento da effettuare....
In tutto si fanno N-1 passate...
CIAO!
---
ICQ#17330720
IRCNet:KiNg[G]hZ »»» #mp3.ita
s...@gem.it

sin da ora per le vostre e.mail.
Questa e' una mia soluzione e' un'alternativa a quella potrebbe
saltare subito in mente, cioe' quella di controllare dopo ogni
generazione del numero casuale se e' gia' stato utilizzato e se cosi'
di ripetere la generazione del numero.
Forse la tua richiesta non e' l'applicazione migliore del mio
algoritmo ma che puo' ritornare utile se si vuole estrarre degli
elementi da un insieme qualsiasi.
Il programma funziona cosi':
ho un vettore (V) che contiene tutti i numeri che possono essere
estratti.
Ne estraggo uno (rimuovendolo anche dal vettore) e lo metto in un
altro vettore (NUM).
Dopo N passi termino e ordino NUM.
Il pregio di questa soluzione e' che estraggo sempre numeri buoni e
cosi' non devo controllare se gia' sono usciti.
program   numeri_casuali;
const     minimo=1;
          massimo=130;
          n=8;    (*numero dei numeri da estrarre *)
var       v:array[minimo..massimo] of integer;
             num:array[1..n] of integer;
          min,max,i,j,x,k:integer;
begin
          min:=minimo;
          max:=massimo;
          for i:=min to max do
              v[i]:=i;    (* riempio V con i numeri da estrarre  *)
          randomize;
          for i:=1 to n do begin      (* genera i numeri *)
              x:=random(max-min+1)+min;
              num[i]:=v[x];
              dec(max);
              for j:=x to max do
                  v[j]:=v[j+1]
          end;
          for j:=1 to n-1 do begin    (* ordina i numeri *)
              x:=num[j];
              i:=j;
              for k:=j to n do
                  if num[k]<x then begin
                     x:=num[k];
                     i:=k
                  end;
              x:=num[j];
              num[j]:=num[i];
              num[j]:=num[i];
              num[i]:=x
          end;
          for j:=1 to n do       (* stampa i numeri *)
              write(num[j]:5);
          writeln
end.
Fabio.
fabi...@rocketmail.com

crescente.
var a : array [1..8] of integer;
    flag : array [1..130] of boolean;
    i, j : integer;
begin
  randomize;
  fillchar(flag, sizeof(flag), FALSE);
  for i := 1 to 8 do
  begin
    repeat
      a[i] := 1 + random(130);
    until (not flag[a[i]]);
    flag[a[i]] := TRUE;
  end;
  for i := 1 to 8 do
    for j := 1 to 8 do
      if (i <> j) and (a[i] < a[j]) then
      begin
        a[i] := a[i] xor a[j];
        a[j] := a[i] xor a[j];
        a[i] := a[i] xor a[j];
      end;
  for i := 1 to 8 do
    write(a[i],'/');
  writeln;
end.
 ___
(___)
()__
(___)
 __()
(___)
Skyscraper
----------------------------------------------------------------
"Sopra il camper la capra campa, sotto il camper la capra crepa"
--
Posted from 
itaca.ulysse.it
 [195.223.254.1]
via Mailgate.ORG Server - 
http://www.mailgate.org

sin da ora per le vostre e.mail.
Mi e' venuta in mente una nuova soluzione del problema che fa a meno
di ordinare i numeri alla fine.
Mi sembra carina.
Funziona cosi':
ho un vettore di boolean lungo 130. Ogni volta che straggo un numero
casuale controllo che il corrispondente flag sia a false altrimenti
riprovo. Poi setto il corrispondente flag a true.
Il ciclo viene ripetuto 8 volte.
A questo punto scorro il vettore alla ricerca dei valori true, quando
li trovo significa che quel numero era stato estratto.
program   numeri_casuali;
var       v:array[1..130] of boolean;
          i,x:integer;
begin
          for i:=1 to 130 do
              v[i]:=false;
          randomize;
          for i:=1 to 8 do begin
              repeat
                  x:=random(130)+1
              until not v[x];
              v[x]:=true;
          end;
          for i:=1 to 130 do       (* stampa i numeri *)
              if v[i] then
                 write(i:5);
          writeln
end.
Se poi c'e' la necessita di aveve i numeri in un vettore bastera'
fare:
	k:=0;	
	for i:=1 to 130 do
	      if v[i] then begin
		inc(k);
		num[k]:=i
	     end;
essendo   num:array[1..8] of integer;
Ciao,   Fabio
fabi...@rocketmail.com

Ciao a tutti,
Ringrazio tutti coloro mi hanno inviato l'esempio sul mio problema.
Grazie di cuore.



fabi...@rocketmail.com
Skyscraper
---------------------------
andrea_...@bigfoot.com
