2024(e)ko martxoaren 21(a), osteguna

10. astea | Zortearen Zenbakien Segida

Galbahe (edo bahe) baten irudia. Galbaheri esker aleak sailka daitezkeen bezala, zenbaki zerrenda bati galbahe logikoren bat aplikatuz zenbakien segida desberdinak lor daitezke, adibidez: "Zortearen Zenbakien Segida" delakoa

Galbahe (edo bahe) baten aplikatzearen aditza bahetu da. Artikulu honetan Zortearen Zenbakien Segida lortuko dugu baina ikusi ere 10. astea | Eratostenesen bahea (I) eta 11. astea | Eratostenesen bahea (II) artikuluak non zenbaki lehenak lantzen diren.

Zortearen Zenbakien Segida eskuratzeko zenbaki arruntei galbahe jakin bat aplikatuko zaie. Zenbaki arrunten zerrenda batean Zortearen Zenbakiak identifikatzeko, zenbakien posizioak aintzat hartuko dira bahetze prozesuan. Cuaderno de Cultura Científica web guneneko artikulu hau ikusi: Los números de la suerte.

Demagun 1etik hasita eta 99 arteko Zortearen Zenbakiak lortu nahi ditugula. Programaren irteerak aztertuz algoritmoa asma dezagun.

Hasierako datuek jarraian erakusten den zerrenda osatzen dute, hots, 1 eta 99 arteko zenbaki arruntek (biak barne) osatzen duten zerrenda:

1 eta 99 arteko zenbaki arruntak behin baino gehiagotan bahetuz Zortearen Zenbakiak lortuko ditugu. Zerrenda hau gordetzeko aiDatuak arraya erabil daiteke

Zerrenda horretako Zortearen Zenbakiak lor ditzagun urratsez-urrats...

Prozesu arrepikakor guztiek bezala, hasieraketa bat egin beharko da. Kasu honetan, repeat-until (edo while-do) agindura sartu aurretik zenbaki bikoitiak kenduko dira hasierako zerrendatik. Lehen bahetze jardun horren arabera emaitza-zerrenda hau osatuko da:

aiDatuak hasierako arraytik abiatuta aiEmaitza array hau lortzen da repeat-until (edo while-do) agindutik kanpo

Algoritmoaren oinarria

Bi array izango ditugu aiDatuak arraya eta aiEmaitza arraya, une jakin bateko aiDatuak arrayari bahetze prozesua aplikatuz lortuko da une horri dagokion aiEmaitza arraya. Baina baheketa desberdinak behar direnez, baheketak errepikatu beharko dira (repeat-until edo while-do aginduaren bat beharko da).

Prozesu errepikorraren aginduaren hasieran aiDatuak arraya aldatuko dugu eta bere balio berriak aurreko aiEmaitza arrayarenak izango dira, begiztaren barnean aiEmaitza arraya berkalkulatuko dugu. Iterazio batetik bestera, joku hau egingo dugu: n iterazio jakin batean lortu dugun aiEmaitza emaitza, n+1 iterazioan aiDatuak datua izango da eta honi esker aiEmaitza emaitza berria kalkulatuko dugu.

Hona hemen algoritmoaren kode zatirik garrantzitsuena:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
Program ZenbakiArruntakBahetzen;
const
   MAX = 99;
type
   taiZenbakiak = array[1..MAX] of integer;
 
{-----------------------programa nagusia eta bere aldagaiak-----------------------}
var
   aiDatuak: taiZenbakiak;   // une jakin bateko datuak
   iLuzeraDatuak: integer;
   aiEmaitza: taiZenbakiak;  // une jakin bateko emaitza
   iLuzeraEmaitza: integer;
   iIterazioa: integer;
begin
   { prozesu errepikakorretik kanpo, lehen baheketan, bikoitiak kenduko dira }
 
   iIterazioa := 2;   // bigarren iterazioan 2. posiziokoa eta hurrengoak kentzeko
   repeat
      aiDatuak := aiEmaitza;
      iLuzeraDatuak := iLuzeraEmaitza;
       
      { aiDatuak abiapuntuz harturik aiEmaitza berria kalkulatu }
       
      iIterazioa := iIterazioa +1;
   until { irteteko baldintza };
 
   writeln;
   write('ENTER sakatu exekuzioa amaitzeko... ');
   readln;
end.


Prozesu errepikakorraren barnean, iIterazioa aldagaiak 2 balio du eta horren arabera, uneko aiDatuak arrayaren bigarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 3 da) eta 3., 6., 9. e.a. posizioko elementuak bahetuz aiEmaitza array berria lortuko da:

2. iterazioaren balioa 3 da, horregatik 3 posizioko jauziak egingo dira. Horrela: 3. posizioko 5 balioa kendu,
6. posizioko 11 balioa kendu, 9. posizioko 17 balioa kendu, 12. posizioko 23 balioa kendu, eta abar

2. iterazioa amaitzean uneko zerrendak 34 elementu izango ditu:

 1  3  7  9 13 15 19 21 25 27 31 33 37 39 43 45 49 51 55 57 61 63 67 69 ... 99
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 ... 34


iIterazioa aldagaiak 3 balio du eta horren arabera, uneko aiDatuak arrayaren hirugarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 7 da) eta zazpiko jauziak egingo dira 7., 14., 21. eta 28. posizioko elementuak bahetuz aiEmaitza array berria lortzeko:

3. iterazioaren balioa 7 da, horregatik 7 posizioko jauziak egingo dira. Horrela: 7. posizioko 19 balioa kendu,
14. posizioko 39 balioa kendu, 21. posizioko 61 balioa kendu eta 28. posizioko 81 balioa kendu

3. iterazioa amaitzean uneko zerrendak 30 elementu izango ditu:

 1  3  7  9 13 15 21 25 27 31 33 37 43 45 49 51 55 57 63 67 69 73 75 79 ... 99
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 ... 30


iIterazioa aldagaiak 4 balio du eta horren arabera, uneko aiDatuak arrayaren laugarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 9 da) eta bederatziko jauziak egingo dira 9., 18. eta 27. posizioko elementuak bahetuz aiEmaitza array berria lortzeko:

4. iterazioaren balioa 9 da, horregatik 9 posizioko jauziak egingo dira. Horrela: 9. posizioko 27 balioa kendu,
18. posizioko 57 balioa kendu eta 27. posizioko 91 balioa kendu

4. iterazioa amaitzean uneko zerrendak 27 elementu izango ditu:

 1  3  7  9 13 15 21 25 31 33 37 43 45 49 51 55 63 67 69 73 75 79 85 87 ... 99
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 ... 27


iIterazioa aldagaiak 5 balio du eta horren arabera, uneko aiDatuak arrayaren bosgarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 13 da) eta hamahiruko jauziak egingo dira 13. eta 26. posizioko elementuak bahetuz aiEmaitza array berria lortzeko:

5. iterazioaren balioa 13 da, horregatik 13 posizioko bi jauzi egingo dira.
Horrela: 13. posizioko 45 balioa kendu eta 26. posizioko 97 balioa kendu

5. iterazioa amaitzean uneko zerrendak 25 elementu izango ditu:

 1  3  7  9 13 15 21 25 31 33 37 43 49 51 55 63 67 69 73 75 79 85 87 93 99
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25


iIterazioa aldagaiak 6 balio du eta horren arabera, uneko aiDatuak arrayaren seigarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 15 da) eta hamabosteko jauziak egingo dira 15. posizioko elementu bakarra bahetuz aiEmaitza array berria lortzeko:

6. iterazioaren balioa 15 da, horregatik 15 posizioko jauziak egingo dira.
Baina, 15. posizioko 55 balioa kendu ostean gehiagorik ezingo da kendu

6. iterazioa amaitzean uneko zerrendak 24 elementu izango ditu:

 1  3  7  9 13 15 21 25 31 33 37 43 49 51 63 67 69 73 75 79 85 87 93 99
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24


iIterazioa aldagaiak 7 balio du eta horren arabera, uneko aiDatuak arrayaren zazpigarren posizioko elementuaren balioa hartu behar da (ikusten denez, balio hori 21 da) eta hogeita bateko jauziak egingo dira 21. posizioko elementu bakarra bahetuz aiEmaitza array berria lortzeko:

7. iterazioaren balioa 21 da, horregatik 21 posizioko jauziak egingo dira.
Baina, 21. posizioko 85 balioa kendu ostean gehiagorik ezingo da kendu

7. iterazioa amaitzean uneko zerrendak 23 elementu izango ditu:

 1  3  7  9 13 15 21 25 31 33 37 43 49 51 63 67 69 73 75 79 87 93 99
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23

Ikusten den bezala, azken zerrendako 1. elementua 1 da, 2. elementua 3 da eta 23. elementua 99 da. Hurrengo iterazioan jauzien neurria 25ekoa da baina zerrendak 23 elementu dituenez ez da 8. iteraziorik izango:

8. iteraziorik ez da izango bere balioa 25 delako eta zerrendaren elementu kopurua 23 delako


Ariketaren balizko kode osoa ikusi:

ORAINDIK EZKUTATURIK!!!

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
{
   "Zortearen Zenbakiak" ala "Josephus Flaviusen Baheketa"
    
   Zortearen Zenbakien Segida lortzeko zenbaki arruntei galbahe jakin
   bat aplikatuko zaie. Zortearen Zenbakiak zerrendan identifikatzeko
   bahetze prozesuan zenbaki arrunten posizioak aintzat hartuko dira.
   Web gune hau ikusi:
    
   https://culturacientifica.com/2024/01/10/los-numeros-de-la-suerte/
}
 
Program ZenbakiArruntakBahetzen;
const
   MAX = 99;
type
   taiZenbakiak = array[1..MAX] of integer;
 
 
procedure DatuakLortu(var aiDatuak: taiZenbakiak; var iLuzeraDatuak: integer);
var
   k: integer;
begin
   iLuzeraDatuak := MAX;
   for k:=1 to iLuzeraDatuak do
   begin
      aiDatuak[k] := k;
   end;
end;
 
procedure ZenbakiakIkusi(aiZenbakiak: taiZenbakiak; iLuzera: integer);
var
   k: integer;
begin
   writeln('--------------------------------------------------------------------------------');
   for k:=1 to iLuzera do
   begin
      write(aiZenbakiak[k]:4);
   end;
   writeln;
   writeln('--------------------------------------------------------------------------------');
end;
 
 
{-----------------------programa nagusia eta bere aldagaiak-----------------------}
var
   aiDatuak: taiZenbakiak;
   aiEmaitza: taiZenbakiak;
   iLuzeraDatuak: integer;
   iLuzeraEmaitza: integer;
   iIterazioa: integer;
   k: integer;
begin
   DatuakLortu(aiDatuak, iLuzeraDatuak);
   writeln;
   writeln('Hasierako datuak:');
   ZenbakiakIkusi(aiDatuak, iLuzeraDatuak);
   writeln('iLuzeraDatuak=', iLuzeraDatuak);
   writeln;
   writeln;
    
   iIterazioa := 2;         // lehen baheketan bikoitiak kenduko dira
   writeln('1. iterazioa kanpoan, jauzien neurria: ', aiDatuak[iIterazioa], '=aiDatuak[', iIterazioa, ']');
   iLuzeraEmaitza := 0;
   for k:=1 to iLuzeraDatuak do
   begin
      if k mod aiDatuak[iIterazioa] <> 0 then
      begin
         iLuzeraEmaitza := iLuzeraEmaitza +1;
         aiEmaitza[iLuzeraEmaitza] := aiDatuak[k];
      end;
   end;
   ZenbakiakIkusi(aiEmaitza, iLuzeraEmaitza);
   writeln('iLuzeraEmaitza=', iLuzeraEmaitza);
   writeln;
   writeln;
 
   iIterazioa := 2;         // bigarren iterazioan 2. posiziokoa eta hurrengoak kentzeko
   repeat
      aiDatuak := aiEmaitza;
      iLuzeraDatuak := iLuzeraEmaitza;
       
      writeln(iIterazioa, '. iterazioan jauzien neurria: ', aiDatuak[iIterazioa], '=aiDatuak[', iIterazioa, ']');
      iLuzeraEmaitza := 0;
      for k:=1 to iLuzeraDatuak do
      begin
         if k mod aiDatuak[iIterazioa] <> 0 then
         begin
            iLuzeraEmaitza := iLuzeraEmaitza +1;
            aiEmaitza[iLuzeraEmaitza] := aiDatuak[k];
         end
         else
            writeln(aiDatuak[k]:4, ' kenduta');
      end;
      ZenbakiakIkusi(aiEmaitza, iLuzeraEmaitza);
      write('iLuzeraEmaitza=', iLuzeraEmaitza);
      writeln('        Hurrengo iterazioaren jauzien neurria: ', aiEmaitza[iIterazioa+1]);
       
      writeln;
      writeln;
      iIterazioa := iIterazioa +1;
   until iLuzeraDatuak < aiEmaitza[iIterazioa];
 
   writeln;
   write('ENTER sakatu exekuzioa amaitzeko... ');
   readln;
end.

 
ordua:
Etiketak:

iruzkinik ez:

Argitaratu iruzkina

Iruzkinen bat idazteko Google-ko kontu bat behar duzu. Iruzkin guztien moderazio-ardura blogeko administratzaileari dagokio.

Harpidetu honetara: Argitaratu iruzkinak (Atom)