Korrekt beskrivning av en endimensionell array av heltal. Teknologisk karta endimensionella arrayer av heltal. Andra datastrukturer

Array En array är en namngiven samling av element av samma typ, ordnade efter index som bestämmer elementets position i arrayen. Lösningen på olika problem förknippade med bearbetningsmatriser är baserad på att lösa sådana typiska problem som: - summering av matriselement; - sök efter ett element med specificerade egenskaper; - array sortering. Endimensionell array Array element värde Array element index

Arraybeskrivning Allmän form av arraybeskrivning: vararray var: array [.. of ] of ; var aarrayof var a: matris med heltal; const barrayof const b: matris av heltal = (4, 2, 3, 5, 7); Typ av arrayelement Arraynamn Maximalt indexvärde Minsta indexvärde Värdet för det 1:a elementet i arrayen Array b med konstanta värden beskrivs i avsnittet beskrivning av konstanter.

Sätt att fylla en array på ett sätt. Ange varje värde från tangentbordet: forto doread för i:=1 till 10 do read (a[i]); Metod 2. Använda tilldelningsoperatorn (med formeln): forto do för i:=1 till 10 gör a[i]:=i; 3 sätt. Använda tilldelningsoperatorn (med slumpmässiga nummer): randomisera randomisera; forto do för i:=1 till 10 gör a[i]:=random(100);

Utmatning av en array på ett sätt. Arrayelement kan skrivas till en sträng, åtskilda av ett mellanslag: fortodo för i:=1 till 10 do write (a[i], " "); Metod 2. Utdata med kommentarer: fortodo för i:=1 till 10 do writeln ("a[", i, "]=", a[i]); a=4a=1a=6a=3a=8a=5a=9a=4a=8a=7

Deklarera en array Fylla arrayen Mata ut arrayprogrammet n_1 ; var i: heltal; a: arrav av heltal; Fyllning av array A (10) med slumptal och utmatande arrayelement börjar för i:=1 till 10 gör a[i]:=random(50); för i:=1 till 10 skriv (a[i],` `); slutet.

Beräkning av summan av matriselement Summeringen av matriselement utförs genom att sekventiellt addera termer: s En minnescell (variabel s) bestäms i vilken resultatet av summeringen kommer att ackumuleras sekventiellt. Variabeln s tilldelas ett initialt värde av 0 - ett tal som inte påverkar resultatet av tillägget s För varje element i arrayen från variabel s läses med dess nuvarande värde och läggs till värdet på arrayelementet; s det erhållna resultatet tilldelas variabeln s.

Beräkning av summan av matriselement s = 0 Huvudfragment av programmet: s:=0; s:=0; för i:=1 till n gör s:=s+a[i]; för i:=1 till n gör s:=s+a[i]; s = s + a s = 0+ a s = s + a s = 0+ a+ a s = s + a s = 0+ a+ a+ a …… s = s + a s = 0+a+a+a +a

Beräkna summan av matriselement program n_2; var s, i: heltal; a: arrav av heltal; börjar s:=0; s:=0; för i:=1 till 10 gör a[i]:=random(50); för i:=1 till 10 skriv (a[i],` `); för i:=1 till 10 gör s:=s+a[i]; för i:=1 till 10 gör s:=s+a[i]; writeln("s=", s); slutet.

1) Ta det översta kortet och skriv (kom ihåg) numret på tavlan som det största. 2) Ta nästa kort och jämför siffrorna. Om det finns ett högre nummer på kortet, skriv ner det numret. Hitta det största elementet i en bunt kort med skrivna siffror: Upprepa stegen som beskrivs i steg 2 för alla återstående kort När du organiserar en sökning efter det största elementet i en array är det mer korrekt att leta efter dess index. !

Program för att hitta det största elementet i ett arrayprogram n_3; imax var s, i, imax: heltal; a:arrav av heltal; börjar s:=0; s:=0; för i:=1 till 10 gör a[i]:=random(50); för i:=1 till 10 skriv (a[i],` `); imax:=1 imax:=1 i:=2 10 för i:=2 till 10 gör a[i]>a imax:=i; om a[i]>a så imax:=i; skriv ("Största elementet a[",imax,"]=", a) skriv ("Största elementet a[",imax,"]=", a) slut. a imax:=i; om a[i]>a så imax:=i; skriv ("Största elementet a[",imax,"]=", a) skriv ("Största elementet a[",imax,"]=", a) slut.">

Hitta ett matriselement med givna egenskaper Resultatet av att söka efter ett element vars värde är lika med ett givet värde kan vara: n - a[n]= xх -n - index för ett matriselement så att a[n]= x, där x är ett givet tal; ett meddelande om att det nödvändiga elementet inte hittades i arrayen Här: tre är lika med det 4:e elementet; tio är lika med 1:a och 9:e elementen; det finns inget element lika med 12.

Sök efter ett element lika med 50 Programmet hittade det sista elementet som uppfyller villkorsprogrammet n_4; var n, i: heltal; a:arrav av heltal; börja för i:=1 till 10 gör a[i]:=random(60); för i:=1 till 10 skriv (a[i],` `); n:=0; n:=0; för i:=1 till 10 gör för i:=1 till 10 gör om a[i]=50 då n:=i; om a[i]=50 då n:=i; om n=0 så skriv(" Nej ") annars skriv (i) om n=0 så skriv(" Nej ") annars skriv (i) slut.

Sök efter element lika med 50 program n_5; var n, i: heltal; a:arrav av heltal; börja för i:=1 till 10 gör a[i]:=random(60); för i:=1 till 10 skriv (a[i],` `); i:=0; i:=0; upprepa i:=i+1; i:=i+1; tills (a[i]=50) eller (i=10); tills (a[i]=50) eller (i=10); om a[i]=50 så skriv(i) om a[i]=50 skriv(i) annars skriv(" Nej ") slut. Det första elementet som uppfyller villkoret finns i programmet

Räkning av antalet element För räkning introduceras en variabel vars värde ökar med ett varje gång det önskade elementet hittas. program n_6; var k, i: heltal; a:arrav av heltal; börja för i:=1 till 10 gör a[i]:=random(60); för i:=1 till 10 skriv (a[i],` `); k:=0; k:=0; i:=1 10 för i:=1 till 10 gör om a[i]>50 k:=k+1; om a[i]>50 så k:=k+1; ("k=", k) skriv("k=", k) slut 50 k:=k+1; om a[i]>50 så k:=k+1; ("k=", k) skriv("k=", k) slut.">

Summan av värdena för element som uppfyller villkorsprogrammet n_7; var s, i: heltal; a:arrav av heltal; börja för i:=1 till 10 gör a[i]:=random(60); för i:=1 till 10 skriv (a[i],` `); s:=0; s:=0; i:=1 10 för i:=1 till 10 gör a[i]>10 (a[i] 10 och (a[i] 1"> 10 (a[i] 10 och (a[i]"> 1" title=" Summan av värden av element som uppfyller villkoret 105013 1421501021 program n_7; var s, i: heltal; a:arrav av heltal; börja för i:=1 till 10 gör a[i]:=random(60); för i:=1 till 10 skriv (a[i],` `); s:=0; s:=0; i:=1 10 för i:=1 till 10 gör a[i]>1"> title="Summan av värden för element som uppfyller villkoret 105013 1421501021 program n_7; var s, i: heltal; a:arrav av heltal; börja för i:=1 till 10 gör a[i]:=random(60); för i:=1 till 10 skriv (a[i],` `); s:=0; s:=0; i:=1 10 för i:=1 till 10 gör a[i]>1"> !}

Sortera en array 1. Det maximala elementet i arrayen är valt 2. Det maximala och det första elementet byts om (det första elementet anses vara sorterat) 3. I den osorterade delen av arrayen väljs det maximala elementet igen; den byter plats med det första osorterade elementet i arrayen. Åtgärderna i steg 3 upprepas med de osorterade elementen i arrayen tills ett osorterat element återstår (minimalt). Sortering av arrayelement i fallande ordning genom val utförs enligt följande:

Sortera en Array Index Värde Steg Sammanfattning:

A sedan imax:=j; x:=a[i]; a[i]:=a; a:=x; slutet; för i:=1 till 10 skriv (a[i],` `); slutet; program n_8; imax var n, i, j, x, imax: heltal; a:arrav o" title="Sortering av en array för i:=1 till 9 börjar imax:=i; för j:=i+1 till 10 gör om a[j]>a sedan imax:= j ; x:=a[i]; a[i]:=a; a:=x ; end; för i:=1 till 10 skriv (a[i],` `); slut; program n_8; imax var n, i, j, x, imax: heltal; a:arrav o" class="link_thumb"> 21 !} Sortering av en array för i:=1 till 9 börjar imax:=i; för j:=i+1 till 10 gör om a[j]>a så imax:=j; x:=a[i]; a[i]:=a; a:=x; slutet; för i:=1 till 10 skriv (a[i],` `); slutet; program n_8; imax var n, i, j, x, imax: heltal; a:arrav av heltal; börja för i:=1 till 10 läs (a[i]); för i:=1 till 10 skriv (a[i],` `); a sedan imax:=j; x:=a[i]; a[i]:=a; a:=x; slutet; för i:=1 till 10 skriv (a[i],` `); slutet; program n_8; imax var n, i, j, x, imax: heltal; a:arrav o"> a sedan imax:=j; x:=a[i]; a[i]:=a; a:=x ; end; för i:=1 till 10 skriv (a[i] ,` `); slut; program n_8; imax var n, i, j, x, imax: heltal; a:arrav av heltal; börja för i:=1 till 10 läs (a[i]); för i: =1 till 10 skriv (a[i],` `); 01924365 96543210"> a sedan imax:=j; x:=a[i]; a[i]:=a; a:=x; slutet; för i:=1 till 10 skriv (a[i],` `); slutet; program n_8; imax var n, i, j, x, imax: heltal; a:arrav o" title="Sortering av en array för i:=1 till 9 börjar imax:=i; för j:=i+1 till 10 gör om a[j]>a sedan imax:= j ; x:=a[i]; a[i]:=a; a:=x ; end; för i:=1 till 10 skriv (a[i],` `); slut; program n_8; imax var n, i, j, x, imax: heltal; a:arrav o"> title="Sortering av en array för i:=1 till 9 börjar imax:=i; för j:=i+1 till 10 gör om a[j]>a så imax:=j; x:=a[i]; a[i]:=a; a:=x; slutet; för i:=1 till 10 skriv (a[i],` `); slutet; program n_8; imax var n, i, j, x, imax: heltal; a:arrav o"> !}

Det viktigaste är att en array är en namngiven samling av element av samma typ, ordnade efter index som bestämmer positionen för elementen i arrayen. Programmeringsspråk använder arrayer för att implementera datastrukturer som sekvenser och tabeller. Innan du använder den i ett program måste arrayen beskrivas. Allmän form av beskrivning av en endimensionell array: var: array [ … ] av element_type; Du kan fylla arrayen antingen genom att ange värdet för varje element från tangentbordet eller genom att tilldela några värden till elementen. När du fyller arrayen och visar den på skärmen används en slinga med en parameter. Lösningen på olika problem förknippade med bearbetningsmatriser är baserad på sådana typiska uppgifter som: summering av matriselement; sök efter ett element med specificerade egenskaper; array sortering.

Frågor och uppgifter Kan en array innehålla heltalsvärden och reella värden samtidigt? Varför behövs en arraybeskrivning? Vad kan du säga om en array bildad så här? a) för i:=1 till 10 gör a[i]:= random(101)-50; b) för i:=1 till 20 gör a[i]:= i; c) för i:=1 till 5 gör a[i]:= 2*i-1; Skriv ett program för att lösa problemet i Pascal. Det finns N hus på någon ort. Det är känt hur många som bor i varje hus. Initialdata (antal invånare) presenteras med hjälp av en linjär tabell A som innehåller N element: A - antalet invånare i hus 1, A - antalet invånare i hus 2, ..., A[N] - antalet av invånare i hus N. I det allmänna fallet, A[ i ] antalet invånare i hus i, där i tar alla värden från 1 till n (i =1,n). Resultatet av arbetet betecknas med s. Betrakta antalet invånare i huset som ett slumpmässigt tal från intervallet 50 till 200 personer, och antalet hus n = 30. Skriv ett program för att lösa problemet i Pascal. Rekrytering till skolans basketlag har offentliggjorts. Höjden på var och en av de N elever som vill komma in i det här laget är känd. Räkna antalet sökande som har chans att komma in i laget om lagspelarens höjd måste vara minst 170 cm. Betrakta längden på den sökande till laget som ett slumpmässigt tal från intervallet 150 till 200 cm, och antalet sökande n = 50. Exempel på indata Exempel utdata Ange temperatur måndag >> 12 tisdag >> 10 onsdag >> 16 torsdag >> 18 fredag ​​>> 17 lördag >> 16 söndag >> 14 Medeltemperatur för veckan: 14.71 Skriv ett program som beräknar medeltemperaturen för veckan. Initial data matas in från tangentbordet. Givet en matris med tio heltal. Bestäm hur många element i denna array som har det maximala värdet. I en klass på 20 elever skrev de ett diktat på ryska språket. Skriv ett program som räknar antalet tvåor, treor, fyror och femmor som tagits emot för ett diktat. Heltalsmatriser a och b innehåller längden på benen i tio räta trianglar: a [i ] är längden på det första benet, b[i ] är längden på det andra benet i den i:te triangeln. Hitta triangeln med den största arean. Skriv ut dess antal, benlängder och area. Tänk på fallet när det finns flera sådana trianglar. Ange information om tio europeiska länder i arrayerna n (landets namn), k (befolkning), s (landets område). Lista namnen på länderna i ordning efter ökande befolkningstäthet. > 12 tisdag >> 10 onsdag >> 16 torsdag >> 18 fredag ​​>> 17 lördag >> 16 söndag >> 14 Medeltemperatur för veckan: 14.71 Skriv ett program som beräknar medeltemperaturen för veckan. Initial data matas in från tangentbordet. Givet en matris med tio heltal. Bestäm hur många element i denna array som har det maximala värdet. I en klass på 20 elever skrev de ett diktat på ryska språket. Skriv ett program som räknar antalet tvåor, treor, fyror och femmor som tagits emot för ett diktat. Heltalsmatriser a och b innehåller längden på benen i tio räta trianglar: a [i ] är längden på det första benet, b[i ] är längden på det andra benet i den i:te triangeln. Hitta triangeln med den största arean. Skriv ut dess antal, benlängder och area. Tänk på fallet när det finns flera sådana trianglar. Ange information om tio europeiska länder i arrayerna n (landets namn), k (befolkning), s (landets område). Skriv ut namnen på länderna i ordning efter ökande befolkningstäthet.">

Grundläggande sammanfattning Tangentbordsinmatning En array är en namngiven samling av element av samma typ, ordnade efter index som bestämmer positionen för elementen i arrayen. var array var: array [.. of ] av element_type; Tilldela värden Fylla en array Summera element Sortera arrayelement Hitta ett element i egenskaper Arraybearbetningsuppgifter

Informationskällor 1. numbers.jpg - numbers numbers.jpg tangentbord slumpmässiga siffror 4. – siffror 5. content/uploads/2012/01/ _ jpg - numbers content/uploads/2012/01/ _ jpg pojke med nummer 7. innehåll / themes/rttheme9/timthumb.php?src= wp-content/uploads/mas-slider-two.jpg&w=940&h=320&zc=1 – nummer innehåll/themes/rttheme9/timthumb.php?src= wp-content/uploads mas -slider-two.jpg&w=940&h=320&zc= nummer kulramspojke sortering matryoshka dockor

Idag i klassen ska vi titta på ett nytt koncept array. Array – det är en ordnad uppsättning data av samma typ. Med andra ord är en array en tabell, vars varje element är ett element i arrayen. Arrayer kan vara endimensionella eller tvådimensionella. Endimensionell array– detta är en linjär tabell, dvs. en tabell vars element är ordnade i en rad eller kolumn. Tvådimensionell array

Ladda ner:

Förhandsvisning:

Kostanay-regionen, Mendykarinsky-distriktet, Budyonnovskaya gymnasieskola,

IT-lärare

Doshchanova Gulzhan Baygarievna

9: e klass

Ämne: Konceptet med en array. Endimensionella och tvådimensionella arrayer. Array-element.

Lektionens framsteg:

1. Att organisera tid.
2. Kollar läxor.
3. Förklaring av nytt material.
4. Problemlösning.
5. Hemläxa.

1. Att organisera tid.Kontrollera klassrummets beredskap för klasser, gör ett upprop av elever.

1. Kollar läxor.Se till att du löser läxproblem korrekt. Förstärk det teoretiska materialet från föregående lektion.

1. Förklaring av nytt material.

Idag i klassen ska vi titta på ett nytt koncept array. Array – det är en ordnad uppsättning data av samma typ. Med andra ord är en array en tabell, vars varje element är ett element i arrayen. Arrayer kan vara endimensionella eller tvådimensionella.Endimensionell array– detta är en linjär tabell, dvs. en tabell vars element är ordnade i en rad eller kolumn.Tvådimensionell arrayär ett rektangulärt bord, dvs. en tabell som består av flera rader och kolumner.(Visa affischer av linjära och rektangulära tabeller. Om du har en interaktiv whiteboard i klassrummet kan du förbereda en presentation på olika typer matriser.)

Det finns sju element i denna linjära tabell. Varje element i denna tabell representerar en bokstav.

Matriselement kan vara numeriska eller textvärden. I variabelsektionen Var skrivs arrayen enligt följande:

x: array av sträng;

denna post indikerar att du får en endimensionell array (linjär tabell) som innehåller 7 element vars värden är strängvärden.

En tvådimensionell array betecknas enligt följande:

y: matris av heltal;

Elementen i denna array är heltal, som skrivs i 4 rader och 5 kolumner.

Ett element i en endimensionell array skrivs så här: x – det femte elementet i en endimensionell array x (dess betydelse är bokstaven "O"), y – ett element placerat i den andra raden och tredje kolumnen i en tvådimensionell matris y (dess värde är 15).

Låt oss nu gå vidare till att lösa problem. (Uppgifter bör väljas med hänsyn till klassens beredskapsnivå.)

1. Problemlösning. Konstruera ett blockschema och skapa ett program för att lösa följande problem:

1. I en given array x av reella tal, bestäm det aritmetiska medelvärdet av de som är större än 10.

Låt oss först analysera problemet; vi måste få eleverna att tydligt förstå villkoren för problemet; vi kan ge en tabell med 9 element som ett exempel.

program summa;

x: array av verkliga;

s,c: verklig;

k, n: heltal;

Börja

för k=1 till 9 do

Börja

writeln('Ange VÄRDE X[', k,']');

readln(x[k]);

slutet;

(skriv in tabellelement som representerar eventuella reella tal)

s:=0; n:=0; (återställ summan och antalet element till noll)

för k:=1 till 9 do

Börja

om x[k]>10 börjar då s:=s+x[k]; n:= n+1; slutet;

slutet;

(vi beräknar summan och antalet element större än 10)

c=s/n; (hitta det aritmetiska medelvärdet)

writeln('c=',c); (visa resultatet på skärmen)

Slutet.

1. Områdena för flera cirklar anges. Hitta radien för den minsta av dem.

Innan du löser problemet, ta reda på med eleverna hur arean av en cirkel beror på radien. (Om radien är mindre så är arean mindre.) Enligt den utförda analysen, lös problemet på något av sätten.

Första sättet:

Programcirkel_1;

S, R: array av verkliga;

x: verklig; k, n: heltal;

Börja

för k=1 till 10 do

Börja

R[k]:=sqrt(S[k]/pi);

slutet;

x:=R(l); n:=1;

för k:=2 till 10 do

Börja

om R[k]

slutet;

writeln(‘RADIUS’,n,’ CIRCLE – MINSTA R=’, R[n]);

Slutet.

Andra sättet:

Programcirkel_2;

S: array av verkliga;

R, x: verklig; i, k: heltal;

Börja

för k=1 till 10 do

Börja

writeln('ANGI OMRÅDE för ', k,' CIRCLE'); readln(S[k]);

slutet;

x:=S(l); k:=1;

för i:=2 till 10 do

Börja

om S[k]

slutet;

R:=sqrt(x/pi); writeln(‘RADIUS’, n ,’ CIRKEL – MINSTA R=’,R);

Slutet.

1. Hemläxa. Sida 90-97. (N.T. Ermekov, V.A. Krivoruchko, L.N. Kaftunkina Informatics 9:e klass, Almaty "Mektep" 2005)

Lös följande problem:

1. I en matris Y som består av 12 heltal, bestäm det aritmetiska medelvärdet av de som är jämna.
2. Arean av flera rutor anges. Hitta längden på diagonalen för den största av dem.

1. Sammanfattning av lektionen.Tillkännage betyg för eleverna och kommentera dem. Analysera elevernas lösningar på problem.

LEKTION:

Organisationsstadiet av lektionen:

• Hälsningar

Lärare:

Idag tittar vi på "One-Dimensional Arrays". Från tidigare lektioner minns vi att det finns många typer av data (siffror) som används i programmering. Namnge dem.

Studerande:

Datatyper som t.ex Hela Och Verklig.

Hela:

• byte -128 till 127;
• kort -32,768 till 32,767;

Lärare:

Array

Arraybeskrivning:

Var<имя_массива>:array [<минимальное_значение_индекса>. <максимальное_значение_индекса>] av<тип данных>;

Exempel: var a: array av heltal;

A

const a: matris av heltal = (1, 4, 7, 14, 25);

Fyller arrayen:

Det finns flera sätt att fylla en array. Låt oss titta på dem.

för i:=1 till 10 do read(a[i]);

för i:=1 till 10 do a[i]:=i;

randomisera

för i:=1 till 10 do a[i]:= random(100);

Mata ut element från en array:

Pascal;

randomisera.

för i:=1 till 10 do skriv(a[i], " ");

för i:=1 till 10 do writeln("a[", i, ", a[i]);

Låt oss titta på ett exempel:

var a: array av heltal;

randomisera

för i:=1 till 10 do

a[i]:= slumpmässig

skriva(a[i]," ");

Resultat:

Lärare:

Studerande:

Visa dokumentinnehåll
"Endimensionella arrayer av heltal"

Ämne:"Endimensionella arrayer av heltal"

Lektionstyp: Att lära sig nytt material

Syftet med lektionen: Lär dig de grundläggande funktionerna för en array och lär dig även hur du programmerar en array.

Uppgifter:

Bekanta dig med konceptet "ARASSY";

Beskrivning av arrayen som ett programmeringsobjekt;

Utforska alternativ för att fylla och mata ut data från en array.

Utrustning:

Klassrummet har en projektor med en skärm för att visa lärarens skärm;

Tavla för att visa lektionens huvudstadier;

14 datorer för eleverna att praktiskt konsolidera det material de har tagit upp.

LEKTION:

Organisationsstadiet av lektionen:

Hälsningar

Kontrollera studentnärvaro

Lärare:

Killar, idag börjar vi lära oss ett nytt skede av programmering i Pascal.

Idag tittar vi på "One-Dimensional Arrays". Från tidigare lektioner minns vi att det finns många typer av data (siffror) som används i programmering. Namnge dem...

Studerande:

Datatyper som t.ex Hela Och Verklig.

Hela:

byte -128 till 127;

kort -32,768 till 32,767;

int -2 147 483 648 till 2 147 483 647;

Real (flytande kommatal):

verklig från 4,9*10-324 till 1,7*10308;

Lärare:

Arrayär en ordnad uppsättning variabler av samma typ (matriselement), som kan tilldelas ett gemensamt namn, men alla element kommer att ha olika nummer (index).

Arraybeskrivning:

Innan du använder något objekt i ett program måste det deklareras i listan över variabler. Så matrisen måste också deklareras.

För att definiera en array bör du ange: ARRAY NAME + ANTAL ARRAY ELEMENTS + DATA TYPE som används i arrayen.

Var: array [ .. ] av ;

Exempel: var a: array av heltal;

Detta beskriver en endimensionell array av heltal som kallas A. Det minsta och maximala antalet index är från 1 till 15. En array kan också beskrivas i konstantbeskrivningsavsnittet, följaktligen kan elementen i arrayen inte ändras under programexekveringen.

const a: matris av heltal = (1, 4, 7, 14, 25);

I det här fallet, när vi skapar en array, lägger vi omedelbart till element till den.

Fyller arrayen:

Det finns flera sätt att fylla en array. Låt oss titta på dem...

1) För att ange elementvärden från tangentbordet, använd en loop:

för i:=1 till 10 do read(a[i]);

2) Du kan ställa in värdet på arrayelement med hjälp av tilldelningsoperatorn:

för i:=1 till 10 do a[i]:=i;

3) Fylla en array med hjälp av en procedur randomisera. Det tillåter generation slumpmässiga siffror, i vårt fall är dessa siffror från 0 till 99 (inklusive) och kommer att fylla vår array med dessa siffror.

för i:=1 till 10 do a[i]:= random(100);

Mata ut element från en array:

I programmeringsspråk har vi möjlighet att inte bara lägga in siffror och data i programmet, utan även att visa dem på displayen (konsolen). I vårt fall kommer vi idag att arbeta med operationerna för att mata ut matrisdata till konsolen Pascal;

Vi kanske känner till siffrorna som vi angav när vi skrev programmet, eftersom siffrorna kunde ha genererats slumpmässigt med hjälp av proceduren randomisera.

Arrayelement kan matas ut till konsolen, antingen åtskilda av ett mellanslag eller med en detaljerad kommentar.

1) Separera siffrorna med mellanslag och mata ut med det vanliga skrivkommandot:

för i:=1 till 10 do skriv(a[i], " ");

2) Genom att skriva en kommentar där du kommer att ange: INDEXNUMMER och mittemot kommer att indikeras det NUMMER som motsvarar detta index. Alla element kommer att skrivas ut till konsolen med kommandot Writeln, LN i slutet av ordet indikerar att varje nytt arrayelement kommer att skrivas ut på en ny rad i konsolen.

för i:=1 till 10 do writeln("a[", i, ", a[i]);

Låt oss titta på ett exempel:

var a: array av heltal;

randomisera(en procedur som tjänar till att initiera (eller som det också kallas att bygga upp) en slumptalsgenerator)

för i:=1 till 10 do

a[i]:= slumpmässig(19); (funktion som genererar ett slumptal från noll till 18: random(n+1))

skriva(a[i]," ");

Resultat:

Lärare:

I dagens lektion lärde vi oss?

Studerande:

Lärde sig grunderna i array-programmering. Deras tillkännagivande, fyllning olika sätt, samt utdata med hjälp av detaljerade kommentarer.

Nyckelord:

• array
• array beskrivning
• fyller arrayen
• arrayutgång
• arraybehandling
• sekventiell sökning
• sortering

Hittills har vi arbetat med enkla datatyper. Vid lösning av praktiska problem kombineras data ofta till olika datastrukturer, till exempel arrayer. Programmeringsspråk använder arrayer för att implementera datastrukturer som sekvenser och tabeller.

Vi kommer att överväga endimensionella arrayer.

Lösningen på olika problem förknippade med bearbetningsmatriser är baserad på att lösa sådana typiska problem som:

• summering av arrayelement;
• sök efter ett element med specificerade egenskaper;
• array sortering.

4.7.1. Array beskrivning

Innan du använder den i ett program måste en array beskrivas, det vill säga namnet på arrayen, antalet arrayelement och deras typ måste anges. Detta är nödvändigt för att allokera ett block av celler av den erforderliga typen i minnet för en array. Allmän vy av arraybeskrivningen:

var<имя_массива>:array [<мин_знач_индекса> .. <макс_знач_индекса>] av<тип__элементов>;

Exempel

var a: array av heltal;

Här beskriver vi en matris a med tio heltalsvärden. När denna sats exekveras kommer tio celler av en heltalstyp att tilldelas i datorns minne.

En liten array med konstanta värden kan beskrivas i konstantsektionen:

const b: matris av heltal = (1, 2, 3, 5, 7);

I det här fallet tilldelas successiva minnesceller inte bara - motsvarande värden matas omedelbart in i dem.

4.7.2. Fyller en array

Du kan fylla arrayen antingen genom att ange värdet för varje element från tangentbordet eller genom att tilldela några värden till elementen. I detta fall kan en slinga med en parameter användas.

Till exempel, för att mata in värdena för elementen i arrayen som beskrivs ovan från tangentbordet, används a nästa cykel med parameter:

för i:=l till 10 läser du (a:=i;

Följande fragment av programmet organiserar fyllningen av en heltalsmatris a, bestående av 10 element, med slumpmässiga tal, vars värden varierar i intervallet från 0 till 99:

4.7.3. Array-utgång

I många fall är det användbart att visa värdena för arrayelement på skärmen. Så om arrayvärdena genererades slumpmässigt, måste du veta vad den ursprungliga arrayen är. Du måste också veta vad arrayen blev efter bearbetning.

Matriselement kan skrivas till en sträng genom att separera dem med ett mellanslag:

för i:=1 till 10 skriv (a[i], ");

Följande utdata med kommentarer är mer visuellt:

för i:=1 till 10 gör writeln("a[", i, ")=", a[i]);

Baserat på de diskuterade exemplen, försök att skriva ett program själv som gör följande: fyll slumpmässigt en heltalsmatris a, bestående av 10 element, vars värden varierar i intervallet från 0 till 99; utgångsmatris a till skärmen.

4.7.4. Beräknar summan av matriselement

Summeringen av matriselement utförs enligt samma princip som summeringen av värdena för enkla variabler: genom att lägga till termer en efter en:

1. en minnescell (variabel s) bestäms i vilken summeringsresultatet kommer att ackumuleras sekventiellt;
2. variabeln s tilldelas initialvärdet 0 - ett tal som inte påverkar resultatet av tillägget;
3. för varje matriselement läses dess aktuella värde från variabeln s och läggs till värdet för matriselementet; det resulterande resultatet tilldelas variabeln s.

Den beskrivna processen kan tydligt avbildas enligt följande:

Här är huvudfragmentet av lösningen på detta problem:

Komplettera arraygenereringsprogrammet som skapats i avsnitt 4.7.3 så att summan av arrayelementen beräknas och resultatet av summeringen visas på skärmen.

4.7.5. Sekventiell sökning i en array

Inom programmering är sökning en av de vanligaste icke-beräkningsuppgifterna.

Följande typiska sökuppgifter kan särskiljas:

1. hitta det största (minsta) elementet i arrayen;
2. hitta ett matriselement vars värde är lika med ett givet värde.

Datorn kan inte jämföra hela serien av objekt samtidigt. Vid varje steg kan den bara jämföra två objekt. Därför måste programmet organisera sekventiell visning av arrayelement och jämförelse av värdet av nästa visade element med ett visst sampel.

Låt oss i detalj överväga lösningen av problem av den första typen (att hitta det största (minsta) elementet).

Låt oss föreställa oss en endimensionell array i form av en bunt kort, som vart och ett har ett nummer skrivet på sig. Då kan idén att hitta det största elementet i en array representeras enligt följande:

1. ta det översta kortet (det första elementet i arrayen), kom ihåg numret på kortet (skriv det med krita på tavlan) som det största av de som du tittade på; lägg kortet åt sidan;
2. ta nästa kort; jämför siffrorna skrivna på kortet och på tavlan; om numret på kortet är större, radera sedan numret som skrivits på tavlan och skriv där samma nummer som på kortet; om det nya numret inte är större, kommer vi att lämna den befintliga posten på tavlan; lägg kortet åt sidan;
3. upprepa stegen som beskrivs i steg 2 för alla återstående kort i högen.

Som ett resultat kommer det största värdet av den visade arrayen att skrivas på tavlan.

Eftersom värdet på ett arrayelement nås av dess index, när du organiserar en sökning efter det största elementet i en endimensionell array, är det mer korrekt att leta efter dess index. Låt oss beteckna det erforderliga indexet som imax. Sedan kan algoritmen som beskrivs ovan i arrayen vi bildade skrivas i Pascal enligt följande:

Skriv ett program själv som genererar en heltalsmatris a med 10 element, vars värden ligger i intervallet från 0 till 99, och söker efter det största elementet i denna matris.

Om det finns flera element i arrayen lika med maxvärdet, då det här programmet kommer att hitta den första av dem (den första förekomsten). Fundera på vad som behöver ändras i programmet så att det innehåller det sista av de maximala elementen. Hur ska programmet transformeras så att det kan användas för att hitta minimielementet i en array?

Resultatet av att lösa ett problem av den andra typen (att hitta ett arrayelement vars värde är lika med ett givet värde) kan vara:

• n är indexet för matriselementet så att a[n] = x, där x är ett givet tal;
• ett meddelande om att det önskade elementet inte hittades i arrayen.

Sökalgoritmen för ett värde lika med 50 i arrayen vi bildade kan se ut så här:

Detta program går igenom alla element i en array en efter en. Om det finns flera element i arrayen vars värden är lika med ett givet nummer, kommer programmet att hitta det sista.

I många fall måste du hitta det första elementet som har ett motsvarande värde och sluta skanna arrayen ytterligare. För detta ändamål kan du använda följande program:

Här kommer exekveringen av algoritmen att avbrytas i ett av två fall:

1. det första elementet lika med det givna finns i arrayen;
2. alla element i arrayen har skannats.

Skriv ner hela texten i programmet och kör det på din dator.

Ofta behöver du bestämma antalet element som uppfyller något villkor. I detta fall introduceras en variabel vars värde ökas med ett varje gång det önskade elementet hittas.

Bestäm vilka element som räknas i följande programfragment.

Om det är nödvändigt att bestämma summan av elementens värden, introduceras en variabel, till vars värde värdet av det hittade elementet i arrayen läggs till.

Bestäm vilket villkor som är uppfyllt av arrayelementen vars värden summeras i följande programfragment.

Skriv ner hela texten av två senaste programmen och kör dem på din dator.

4.7.6. Sortera en array

Genom att sortera (ordna) en array menar vi att omfördela värdena för dess element i någon specifik ordning.

Ordningen i vilken det första elementet i en array har det minsta värdet, och värdet på varje efterföljande element inte är mindre än värdet för det föregående elementet, kallas stigande.

Ordningen i vilken det första elementet i en array har det största värdet, och värdet på varje efterföljande element inte är mer än värdet för det föregående elementet, kallas fallande.

Syftet med sorteringen är att underlätta den efterföljande sökningen efter element: det är lättare att hitta det önskade elementet i en ordnad array.

Du har redan stött på sortering när du arbetar med databaser. Nu kommer vi att överväga ett av de möjliga alternativen1 för att implementera mekanismen för denna operation - urvalssort.

Sortering efter urval (till exempel fallande) utförs enligt följande:

1. det maximala elementet i arrayen är valt;
2. de maximala och första elementen byts ut (det första elementet anses sorterat);
3. i den osorterade delen av arrayen väljs det maximala elementet igen; den byter plats med det första osorterade elementet i arrayen;
4. de åtgärder som beskrivs i punkt 3 upprepas med osorterade arrayelement tills ett osorterat element återstår (dess värde kommer att vara minimalt).

Låt oss överväga processen för urvalssortering med hjälp av exemplet med arrayen a = (0, 1, 9, 2, 4, 3, 6, 5).

I denna uppsättning av åtta element utförde vi operationen att välja det maximala elementet 7 gånger. I en array av n element kommer denna operation att utföras n-1 gånger. Förklara varför.

Här är ett fragment av ett program som implementerar den beskrivna algoritmen:

Här använde vi en slinga inuti en annan. Denna design kallas en kapslad loop.

Skriv ner hela texten i programmet och kör den på datorn för den array som betraktas i exemplet.

På webbplatsen "Interactive Demonstrations on Programming" (http://informatika.kspu.ru/flashprog/demos.php) kan du arbeta med interaktiva visuella hjälpmedel för att mer fullständigt presentera processen för sortering efter val och på andra sätt.

Det viktigaste

En array är en namngiven samling av element av samma typ, ordnade efter index som bestämmer positionen för elementen i arrayen. Programmeringsspråk använder arrayer för att implementera datastrukturer som sekvenser och tabeller.

Innan du använder den i ett program måste arrayen beskrivas. Allmän vy för att beskriva en endimensionell array:

var<имя_массива>:array [<мин_знач_индекса> ..
<макс_знач_индекса>] av element_type;

Du kan fylla arrayen antingen genom att ange värdet för varje element från tangentbordet eller genom att tilldela några värden till elementen. När du fyller arrayen och visar den på skärmen används en slinga med en parameter.

Lösningen på olika problem förknippade med bearbetningsmatriser är baserad på sådana typiska uppgifter som: summering av matriselement; sök efter ett element med specificerade egenskaper; array sortering.

Frågor och uppgifter

Lektionens ämne

Lärobok: Bosova L. L. Informatik: lärobok för årskurs 9 - M.: BINOM. Kunskapslaboratoriet, 2017. - 184 sid. : sjuk.

Lektionstyp:

Lektionens mål:

• pedagogisk
• utvecklande
• vårdande

:

1. Personlig UUD:
2. Kognitiv UUD:
3. Kommunikativ UUD:
4. Regulatorisk UUD:

Utrustning

programvara

Visa dokumentinnehåll
"Teknologisk karta Endimensionella arrayer av heltal"

Informationsblock

Lektionens ämne: Endimensionella arrayer av heltal.

Lärobok: Bosova L. L. Informatik: lärobok för årskurs 9 - M.: BINOM. Kunskapslaboratoriet, 2017. – 184 sid. : sjuk.

Lektionstyp: lektion att lära sig nytt material.

Lektionens mål:

pedagogisk: organisera elevernas aktiviteter för att bekanta sig med begreppen "endimensionell matris", "värde av ett matriselement", "index för ett matriselement"; skapa förutsättningar för eleverna att utveckla förmågan att utföra färdiga och skriva enkla cykliska algoritmer för bearbetning av en endimensionell array i ett programmeringsspråk;

utvecklande: bidra till att öka intresset för ämnet; främja utvecklingen av algoritmiskt tänkande bland elever; främja utvecklingen av logiskt tänkande, kognitivt intresse och minne hos elever;

vårdande: främja bildandet av oberoende vid lösning av problem; främja teamenhet och bildandet av respektfulla attityder mot varandra.

Formade universella lärandeaktiviteter (UAL):

Personlig UUD:

1. fantasi och fantasi när du utför utbildningsaktiviteter;

   önskan att bedriva utbildningsverksamhet.

Kognitiv UUD:

1. logiska åtgärder och operationer;

   skapande och transformation av modeller och diagram för att lösa problem;

   valet mest effektiva sätt lösa problem beroende på specifika förutsättningar.

Kommunikativ UUD:

1. formulera din egen åsikt och ståndpunkt.

Regulatorisk UUD:

1. planera dina handlingar i enlighet med uppgiften och förutsättningarna för dess genomförande.

Utrustning: Personlig dator(PC), multimediaprojektor, skärm.

programvara: presentation "Endimensionella arrayer av heltal."

Lektionsplanering

Skede	Tid
Att organisera tid
Uppdaterar kunskap
Att lära sig nytt material
Konsolidering av det som har lärts
Sammanfattande
Läxa

Under lektionerna

Lärarverksamhet	Studentverksamhet
Att organisera tid Hälsning, kontrollera beredskapen för en lektion, organisera barns uppmärksamhet.	Engagera dig i lektionens affärsrytm.
Uppdaterar kunskap verklig typ verklig 8 byte heltal från -2147483648 till 2147483647 och ockupera 4 bytes Pascal ABC.	Kom ihåg datatyper.
Presentation av nytt material Definition: var a array elementtyp av heltal. konst matriselementvärden. 100 element typ heltal 4 bytes 400 byte initiering. För array-ingång n i n, kommer hon också att vara som heltal n värde 5. för. Låt oss skriva cykeln för i från 1 till n. i-av det arrayelementet läs(a[i]). Modifierad arrayingångsslinga Exempel på hur programmet fungerar a[i]:= i randomisera slumpmässig randomisera Slutsats för nför i:=1 till n do i Arrayutgångsslinga n n n i a n för i:=1 till n doi för i:=1 till n do i för Källa program	Skriv ner datumen för lektionen och lektionens ämnen. Skriv ner definitionen av arrayen. Titta på ett exempel på en matrisdeklaration på bilden. Skriv ner det i en anteckningsbok. Överväg och skriv ner ett exempel. Beräkna och registrera storleken random access minne, som kommer att behövas för att lagra arrayen. Tillsammans med läraren överväger de operationer som kan utföras med arrayer. Anteckna definitionen av "initiering". Tänk på problemet. Tänk på problemet. Tänk på problemet. Tänk på problemet. Överväg att ange en förklaring till uppgiften för att förlåta dig själv arbetet. Tänk på resultatet av programmet. Tänk på ett exempel på initiering: initiera med hjälp av tilldelningskommandot. För bekvämlighets skull använder vi randomisera. Tänk på ett exempel på att visa värdena för arrayelement. Spela in program tillsammans med läraren. Lös problemet ensam på tavlan, resten i anteckningsböcker och hjälp den på tavlan. Fyll denna matris element för element med slumptal från ett till femtio. De kontrollerar programmets korrekthet och gör ett spår. Tänk på resultatet av programexekveringen.
Konsolidering av det studerade materialet. Gå nu till din dator och slutför följande uppgifter själv: Om det finns tid kvar (om inte, gör då dina läxor).	De sätter sig vid datorn och utför uppgifter:
Lektionssammanfattning Så, vad har du lärt dig och lärt dig under dagens lektion?	Sammanfatta lektionen med läraren: Under dagens lektion lärde vi oss: Vad har hänt: Arrayär en namngiven samling av element av samma typ, ordnade efter index som bestämmer elementets position i arrayen. Vi fick reda på vad det är" Initialisering». Lärt mig: Deklarera en array. Fyll ut det. Visa en array.
Läxa	Skriv ner läxor. Lär dig punkterna 2.2.1 – 2.2.3 (inklusive).

Lektionens struktur

Organisationsskede (1 min).

Uppdatering av kunskaper (4 min).

Presentation av nytt material (10 min).

Provarbete (15 min).

Praktisk del (12 min.).

Lektionssammanfattning, läxor (3 min).

Under lektionerna

Organisatorisk.

Uppdaterar kunskap.

I datavetenskapslektionerna arbetade vi med individuella variabler av två numeriska typer. Låt oss komma ihåg dem. Ett verklig typ verklig, som har följande värdeintervall och tar 8 byte random access minne. Och även en heltalstyp heltal, vars variabler kan ta värden i intervallet från -2147483648 till 2147483647 och ockupera 4 bytes random access minne. Värdeintervall och dimensioner för RAM anges för programmeringsmiljön Pascal ABC.

En situation kan uppstå där vi behöver lagra ett stort antal variabler av samma typ, och deras exakta antal kan vara okänt när du skriver programmet. Det är här arrayer måste användas.

Presentation av nytt material.

En array är en namngiven samling av element av samma typ, ordnade efter index som bestämmer elementets position i arrayen.

Vi kommer att överväga endimensionella arrayer.

Innan du utför några åtgärder med arrayen måste du deklarera den i variabeldeklarationssektionen var. Först skrivs namnet på arrayen till exempel a, sedan, efter kolon, kommer funktionsordet array, som är översatt från på engelska och betyder "array". Nästa in hakparentes vi måste skriva ner utbud av index för dess beståndsdelar, till exempel från första till tionde. Därefter måste vi indikera elementtyp array, för detta ändamål skrivs ett serviceord av, följt av elementtypen, heltal, det vill säga heltal.

Deklarera en matris med heltal i variabeldeklarationssektionen.

Om värdena för arrayelementen är kända i förväg och de inte kommer att ändras under programexekveringen, kan du deklarera det i avsnittet konstantbeskrivning konst. Detta görs på samma sätt som i avsnittet om variabelbeskrivning, men efter att ha specificerat typen finns det ett "="-tecken, varefter värdena listas i ordning inom parentes, separerade med kommatecken. matriselementvärden.

Det är viktigt att komma ihåg att när du deklarerar en array en viss mängd RAM tilldelas för att lagra det. Till exempel, låt oss beräkna storleken på RAM som kommer att krävas för att lagra en array av 100 element typ heltal. Eftersom en variabel av denna typ i Pascal ABC tar 4 bytes RAM, då lagring av 100 sådana variabler kräver 400 byte. Detta är mängden RAM som krävs för att lagra en given array.

Låt oss titta på några operationer med arrayer. För att kunna använda arrayer praktiskt måste du veta hur du ställer in eller anger vissa värden för deras element.

Att tilldela eller ange ett värde till en variabel eller ett matriselement kallas initiering.

För array-ingång vi måste veta hur många element vi behöver lägga in. Låt oss deklarera en separat heltalsvariabel för detta ändamål, låt oss kalla det n. Vi behöver också en variabel med indexvärdet för elementet vi arbetar med det här ögonblicket, låt oss ringa henne i, eftersom dess storlek inte kommer att överstiga n, kommer hon också att vara som heltal. Låt oss säga att vi måste ange en sekvens med fem heltal, för detta tilldelar vi n värde 5.

Matriser läggs in element för element, i en viss ordning, till exempel från första till sista. "För"-slingan kommer att hjälpa oss här, eller för. Låt oss skriva cykeln för i från 1 till n. Vidare mellan funktionsord Börja Och slutet Låt oss skriva ner slingans kropp. Du kan helt enkelt läsa värdena för arrayelementen en efter en; för detta räcker ett läskommando i slingans kropp

i-av det arrayelementet läs(a[i]).

Ett program som accepterar en array med 5 element som indata

Eftersom vi skriver in en sekvens med flera siffror kan det vara lätt att bli förvirrad när du skriver in. Därför bör ett förklarande meddelande visas som anger vilket array-element som måste anges, sedan kan slingans kropp ändras enligt följande:

Modifierad arrayingångsslinga

Låt oss köra programmet. Som du kan se accepterar programmet en uppsättning av fem element som input.

Exempel på hur programmet fungerar

Arrayen kan också initieras med hjälp av tilldelningskommandot, då kommer slingans kropp endast att innehålla ett kommando: a[i]:= i. Ibland är det bekvämt att tilldela en uppsättning slumpmässiga värden till elementen i en array. För att göra detta, skriv kommandot randomisera, och elementen tilldelas ett värde slumpmässig, varefter, inom parentes och separerade med kommatecken, det maximalt tillåtna värdet indikeras, ökat med ett, till exempel etthundra, i detta fall kommer programmet att fylla matrisen med slumpmässiga tal från noll till nittionio. Observera att du använder kommandot randomisera i Pascal-miljön är ABC inte nödvändigt. Om du hoppar över det här kommandot i andra miljöer, kommer arrayen att fyllas på samma sätt varje gång du startar programmet.

Ofta måste du visa värdena för arrayelement på skärmen. Slutsats, precis som inmatning, utförs element för element. I det här fallet, precis som för inmatning, kan du använda en loop för. Om arrayen är fylld från 1 till n elementet, då skrivs cykeln för i:=1 till n do, och i kroppen av denna loop kommer det att finnas ett utmatningskommando i-det elementet i arrayen. Låt oss göra en slutsats genom ett utrymme.

Arrayutgångsslinga

Så vi har lärt oss hur man initierar arrayelement och visar deras värden på skärmen. Låt oss skriva ett program som kommer att acceptera en mängd n heltalselement, och kommer sedan att fylla det med slumpmässiga tal från 1 till 50 och visa det på skärmen. Menande n angett från tangentbordet och inte överstiger 70.

För detta program behöver vi en variabel n, som lagrar dimensionen för arrayen, såväl som en variabel i, som kommer att lagra indexvärdena för elementen, såväl som själva arrayen a, och eftersom dess dimension inte är högre än 70, kommer vi att ange intervallet för elementindex från 1 till 70.

Låt oss nu skriva huvuddelen av programmet. Vi kommer att visa en begäran om att ange ett nummer n, vi räknar det och går till nästa rad. Sedan måste du ange värdena för arrayelementen. Detta görs element för element med hjälp av en slinga för i:=1 till n do. Slingans brödtext kommer att innehålla utdata från ett förklarande meddelande som ber om input i-det arrayelementet, samt ett kommando för att läsa det och flytta till nästa rad.

Låt oss nu också fylla denna matris element för element med slumptal från ett till femtio. För att göra detta skriver vi cykeln " för i:=1 till n do, som kommer att innehålla tilldelningskommandot i- att elementet i matrisen summerar 1 och ett slumptal från 0 till 49.

Efter detta, igen med slingan för, visa elementen i arrayen på skärmen, på en rad och åtskilda av ett mellanslag.

Programkällkod

Låt oss köra programmet. Låt arrayen bestå av 4 nummer. Och värdena på dess element kommer att vara respektive: 10, 20, 30, 40. Som svar visade vårt program en uppsättning av fyra slumpmässiga nummer från ett till femtio. Programmet fungerar korrekt.