Vad betyder nc på algoritmiskt språk. Ett algoritmiskt språk är ett formellt språk som används för att skriva, implementera eller studera algoritmer. Grundläggande funktionsord i det algoritmiska språket. Variabler identifieras med namn och kan ändra sina värden

Algoritmiskt språk – det är ett system av notation och regler för enhetlig och korrekt registrering av algoritmer och deras exekvering. Ett algoritmiskt språk är ett sätt att skriva algoritmer i en analytisk form, mellanliggande mellan att skriva en algoritm på naturligt (mänskligt) språk och att skriva den på ett datorspråk (programmeringsspråk).

Det finns en skillnad mellan begreppen "algoritmiskt språk" och "programmeringsspråk". För det första är ett program skrivet på ett algoritmiskt språk inte nödvändigtvis avsett för en dator. Den praktiska implementeringen av ett algoritmiskt språk är en separat fråga i varje specifikt fall.

Som alla språk har ett algoritmiskt språk sitt eget ordförråd. Grunden för denna ordbok är uppbyggd av ord som används för att skriva kommandon som ingår i kommandosystemet för utföraren av en viss algoritm. Sådana kommandon kallas enkla kommandon. I ett algoritmiskt språk används ord vars betydelse och användningssätt specificeras en gång för alla. Dessa ord kallas officiell. Användningen av funktionsord gör inspelningen av algoritmen mer visuell, och presentationsformen av olika algoritmer gör den mer enhetlig.

En algoritm skriven på ett algoritmiskt språk måste ha ett namn. Det är lämpligt att välja namnet så att det är tydligt vilket problem denna algoritm beskriver. För att markera namnet på algoritmen, skriv serviceordet ALG (ALGORITHM) framför det. Efter namnet på algoritmen (vanligtvis på en ny rad) följer dess kommandon. För att indikera början och slutet av algoritmen är dess kommandon inneslutna i ett par serviceord START (START) och CON (END). Kommandon skrivs sekventiellt.

ALG – namnet på algoritmen

serie av algoritmkommandon

Till exempel kan en algoritm som bestämmer en robotartists rörelse se ut så här:

ALG – till_lager

Vid konstruktion av nya algoritmer kan algoritmer som kompilerats tidigare användas. Algoritmer som helt och hållet används som en del av andra algoritmer kallas hjälpalgoritmer. Vilken algoritm som helst från ett antal tidigare kompilerade kan vara hjälpmedel. Det är också möjligt att en hjälpalgoritm i en viss situation kan visa sig vara en algoritm som i sig innehåller en länk till hjälpalgoritmer.

Mycket ofta, när man kompilerar algoritmer, blir det nödvändigt att använda samma algoritm som en extra, vilket dessutom kan vara mycket komplext och besvärligt. Det skulle vara irrationellt, när man börjar arbeta, att komponera och komma ihåg en sådan algoritm varje gång för dess efterföljande användning. Därför används i praktiken i stor utsträckning så kallade inbyggda (eller standard) hjälpalgoritmer, d.v.s. sådana algoritmer som ständigt är tillgängliga för utföraren. Sådana algoritmer nås på samma sätt som "vanliga" hjälpalgoritmer. Robotartist har en inbyggd hjälpalgoritm som kan flytta till lagret från vilken punkt som helst i arbetsfältet; executorn av BASIC-programmeringsspråket har till exempel en inbyggd "SIN"-algoritm.

En algoritm kan innehålla en referens till sig själv som ett hjälpmedel, i vilket fall den kallas rekursiv. Om kommandot för en algoritm att referera till sig själv finns i själva algoritmen, så kallas sådan rekursion hetero. Det kan finnas fall då ett rekursivt anrop av en given algoritm sker från en hjälpalgoritm som anropas i denna algoritm. Denna rekursion kallas indirekt. Exempel på direkt rekursion:

ALG – rörelse

rörelse

Algoritmer där exekveringsordningen för kommandon bestäms beroende på resultaten av att kontrollera vissa villkor kallas förgrening. För att beskriva dem på ett algoritmiskt språk används ett speciellt sammansatt kommando - kommandot förgrening. I förhållande till robotutövaren kan villkoret vara att kontrollera att roboten befinner sig vid kanten av arbetsfältet (edge/not_edge); kontrollerar förekomsten av ett objekt i den aktuella cellen (ja/ej) och några andra:

IF-villkor IF-villkor IF-kant

TILL serie 1 TILL serie TILL höger

ANNAT avsnitt 2 ALLT ANNAT fram

Följande är en algoritmisk språkpost för select-kommandot, som är en utveckling av grenkommandot:

MED villkor 1: serie 1

UNDER villkor 2: serie 2

MED skick N: serie N

ELSE serie N+1

Algoritmer där enskilda kommandon eller serier av kommandon exekveras upprepade gånger kallas cykliska. För att organisera cykliska algoritmer i ett algoritmiskt språk används ett speciellt sammansatt loop-kommando. Det motsvarar blockdiagram av typen "iteration" och kan ha följande form:

BYE skick NC

serie FÖRE skick

Alla programmeringsspråk är fyllda med en mängd olika nyckelord, funktioner eller klasser. Som regel använder de alla engelska, som beskriver metoder eller argument. I vissa miljöer finns det helt enkelt förkortningar av maskinfunktioner. Detta hämmade kraftigt utvecklingen av utvecklingen i de inledande stadierna. För att öka förståelsens hastighet skapades en serie speciella algoritmiska programmeringsspråk, som bestod av begripliga och tillgängliga ord och deras kombinationer, tydliga även för en otränad person.

Lite historia

För att kommunicera med de första datorerna användes programmeringsspråk som var så nära maskinkoden som möjligt, bestående av nollor och ettor. Naturligtvis var det en mycket svår uppgift att komma ihåg många kommandon. Dessutom vilade metoden för minnesallokering under programmering helt på utvecklarens axlar. Och om han gjorde ett litet misstag fick han göra om allt igen.

En stor roll i övergången från maskinspråk till ett mer lämpligt språk för människor spelades av programmeringsspråkssamlaren på låg nivå. Den använde minnesminnen och symboler. Detta förenklade utvecklarens uppgift, eftersom han nu mer produktivt kunde bygga sina algoritmer från kombinationer av kontrollinstruktioner och numeriska koder. Trots all sin flexibilitet och kraft var språket fortfarande svårt att bemästra.

För att lära ut utveckling och algoritmer i utbildningsinstitutioner började introduktionen av programmeringsspråket BASIC. Den innehöll redan många kommandon och nyckelord som var begripliga för eleven. BASIC används fortfarande för att lära sig grunderna i programmering.

Med skapandet av det första algoritmiska programmeringsspråket, Algol, accelererade utvecklingen av algoritmer avsevärt.

Vad är algoritmen

Om vi ​​går bort från torr teori och definitioner, så är en algoritm en sekvens av åtgärder som syftar till att lösa ett givet problem. Trots all floridness i uttrycket möter en person detta koncept varje dag. Till exempel, för att dricka te, måste du följa följande sekvens:

1. Ställ vattenkokaren på spisen.
2. Vänta tills det kokar.
3. Häll kokande vatten i vattnet.
4. Placera tepåsen i koppen.
5. Tillsätt önskad mängd socker, mjölk eller honung.

Denna sekvens är mycket förenklad, men den representerar den enklaste algoritmen.

Precis som en person är en dator kapabel att utföra en viss sekvens av uppgifter. Men för att den tydligt ska förstå dem måste man ta hänsyn till att en dator saknar många begrepp som är uppenbara för människor. Dessutom måste algoritmen noggrant beskriva alla nödvändiga åtgärder. Ett algoritmiskt språk tjänar detta syfte och skapar en slags bro mellan maskin och människa.

Egenskaper och funktioner för ett algoritmiskt språk

Algoritmisk är ett formellt språk där algoritmer som är avsedda att köras på datorer beskrivs. Vanligtvis är den inte knuten till någon maskinarkitektur. Detta hjälper avsevärt att förbättra och påskynda kodningen. Ett slående exempel är det algoritmiska språket BASIC. Pascal och C visade sig också populära på grund av deras enkla syntax och inlärningshastighet.

Strukturen är implementerad på ett sådant sätt att procedurerna som beskrivs i koden exekveras en efter en. Det vill säga en algoritm - en uppgift. Detta liknar att skapa funktioner eller metoder i C och Java.

All kod är byggd av nyckelord som beskriver en händelse eller variabel.

Skillnader mellan maskin- och algoritmspråk

En slående representant för ett maskinberoende språk är assembler. Programmering på den handlar om att indikera för översättaren med specialmärken vad som behöver flyttas och var eller vilket dataområde som ska fyllas. Eftersom assemblersyntaxen är mer lik maskinsyntax är det ganska svårt att studera och skriva kod i den. Nedan kan du se hur kommandona kan se ut för olika processorer.

Därför skapades ett formellt eller algoritmiskt språk med ett stort antal mänskligt förståeliga nyckelord och namn.

Nyckelord

Algoritmiskt språk består av nyckelord, som är förkortningar för den fullständiga beteckningen av åtgärder eller variabler. Detta gör att du kan minska längden på koden samtidigt som den är begriplig.

• Alg. Alla algoritmer börjar med detta nyckelord. Den beskriver namnet och anger inom parentes vilka argument som krävs för beräkningen och vad resultatet ska bli.
• Arg. Betecknar argumenten för algoritmen. Återspeglar typen och namnet på värdet som kommer att användas i koden.
• Res. Detta nyckelord tjänar till att indikera typen och namnet på den variabel där resultatet av beräkningen kommer att behöva placeras.
• Början Indikerar den omedelbara starten av algoritmexekveringen. Varar tills con nyckelordet. Hela intervallet från "start" till "slut" kallas kroppen för den aktuella algoritmen.
• Lura. Indikerar att algoritmen har slutfört exekvering.
• Given. Talar om några av funktionerna och nyanserna av att använda algoritmen eller begränsningar. Här kan du till exempel ange att längden på de jämförda strängarna måste vara desamma. Användningen av nyckelordet "given" är valfritt.
• Nödvändig. En mer detaljerad beskrivning av vad som bör erhållas som ett resultat av exekvering av algoritmen. Precis som "given" kan den utelämnas, men för att bygga en mer förståelig och detaljerad kod rekommenderas användningen av den.

Listan över dessa nyckelord hänvisar till algoritmens titel och kroppsbeteckning. Och så här ser tokens för variabler ut:

• Cel. Heltalsvariabeltyp. Deras intervall bör variera från -32768 till 32767.
• Sak. Riktiga nummer. Till exempel med en exponent eller bråkdel.
• Logga. Detta nyckelord betyder att en boolesk variabel kommer att användas som bara kan acceptera "ja" eller "nej".
• Sim. Detta inkluderar värden med enstaka tecken, som "a", "3".
• Belyst. Strängvariabler som kan innehålla hela textsträngar.
• Flik. Betecknar en tabell med data av en viss typ. Det är en analog till en array från andra programmeringsspråk.

Ytterligare funktionsord

Följande lista med ord används för att organisera förgrenings- och loopingmekanismer.

• För. Används för att iterera genom alla värden inom ett visst intervall. Används för cykler, d.v.s. kontinuerlig exekvering av alla procedurer med data.
• Från och till. Indikerar vilket specifikt värdeintervall som ska itereras igenom i en "för"-loop.
• Hejdå. Används även för att iterera över flera värden. Används för att arbeta tills ett visst villkor är uppfyllt.
• Nts och kts. "Nts" på algoritmiskt språk betyder början av loopkroppen och "kts" betyder slutet. Mellan dessa två nyckelord finns de procedurer som krävs för beräkningen inbyggda.
• Om. Detta ord implementerar förgreningsstrukturen. På detta sätt är det möjligt att bestämma programmets framsteg i önskad riktning, med hänsyn till förutsättningarna.
• Hur som helst. Två ord som fungerar med "om". Förgreningsmekanismen är också byggd.
• Val. Ett bekvämt verktyg för att förgrena sig från flera värden av samma typ. Fungerar tillsammans med nyckelordet "vid" och "annars".
• Allt. Indikerar slutet på förgreningsmekanismen.
• Stiga på. Detta nyckelord låter användaren ange variabelvärden under programdrift för efterföljande bearbetning.
• Slutsats. Visar data på skärmen.

Grundläggande språkstrukturer

Ett algoritmiskt programmeringsspråk hjälper till att bygga olika strukturer som producerar beräkningsfunktioner i en bekväm form. I allmänhet kan vilket språk som helst använda flera specifika mekanismer och deras kombinationer.

Följande struktur

Vid design av denna typ av struktur sker kodexekvering direkt rad för rad. Ett allmänt exempel kan uttryckas så här:

alg Summan av två tal (arg int a, b, res int S)

utgång "S =", S

I det här exemplet beräknas summan av två siffror som angetts av användaren. I början indikerar ordet "alg" att algoritmen startar och beskriver kort exakt vad den gör. Argumenten som behövs för att programmet ska köras och variabeln som ska fungera som en behållare för att lagra resultaten definieras inom parentes. Därefter kommer nyckelordet "start", som indikerar den omedelbara starten av exekvering av uttryck och procedurer. Bredvid "start" kan du även definiera några mellanvariabler.

I algoritmens kropp accepterar nyckelordet "input" data från användaren och skriver det till variabler. De läggs sedan ihop och deras summa tilldelas S. Innan algoritmen är slut visas resultatet av programmet på skärmen med nyckelordet "output". Denna notation i algoritmiskt språk är typisk för många andra programmeringsmiljöer.

Förgreningsstruktur

Flödet i ett program behöver inte alltid exekveras rad för rad. Ibland behöver du bestämma eller ändra värdet på en viss variabel beroende på situationen. Till exempel, givet att x = 0, dividera inte med x.

Ett algoritmiskt programmeringsspråk gör detta genom att använda flera variantkonstruktioner och nyckelorden "om", "då", "annat" eller "val". Efter "om" sätts ett villkor genom vilket kriteriet för att flytta till en annan gren kommer att bestämmas. Till exempel, så här:

På så sätt kan du ändra värdena på variabler beroende på andra faktorer. Detta exempel täcker inte fullt ut alla möjliga implementeringar. Därför, förutom konstruktionen, används nyckelordet "annars". Det låter dig flytta till en annan gren om villkoret inte uppfyller de valda kriterierna.

annars y = 0

Det vill säga, i fallet när x inte är lika med noll, kommer y också att återställas till noll, oavsett vilket värde det hade tidigare.

Ett bekvämare sätt att göra flera val är "val"-konstruktionen. Det låter dig sortera igenom flera förhållanden. När en av dem utlöses kommer den åtgärd som anges för den att utföras.

vid x = 0: y = 0

vid x = 1: y = 1

vid x = 2: y = 2

Detta exempel visar beroendet av variabeln y på x. Programmet kör igenom all data och jämför det aktuella värdet på x med det som anges i villkoret. När en matchning hittas utför den nästa åtgärd. Denna konstruktion kan även kombineras med sökordet "annat" för mer flexibla lösningar när inga av villkoren är uppfyllda.

Cyklar

Slingor spelar en mycket viktig roll i programmering. Nästan ingen utveckling klarar sig utan implementeringen av denna design. I allmänhet löser loopar problemet med att utföra liknande åtgärder med flera variabler upprepade gånger. Detta är praktiskt, till exempel när du fyller matriser med data med hjälp av en känd formel, sorterar den eller räknar några värden.

Nyckelordet "medan" låter dig organisera en slinga där en viss åtgärd kommer att upprepas tills ett visst villkor är uppfyllt. Till exempel:

hejdå x<= 3

I det här exemplet kommer y att öka tills x blir större än 3. För att slingan inte ska vara oändlig måste x ändras uppåt i varje pass, till exempel med 1, vilket är vad den andra kodraden gör.

Nyckelordet "för" tillämpas på ett visst antal nummer som måste itereras genom sekventiellt och utföra vissa åtgärder med dem. Denna konstruktion används när ett ändligt antal element är känt.

Dess syntax ser ut så här:

nc för x från 1 till 3

Serviceorden "från" och "till" visar intervallet av värden som behöver upprepas. Således, i den första iterationen x = 1, som ett resultat av passet, kommer y också att få värdet 1. Då går kontrollen igen till början, och x blir nu lika med 2, respektive, y blir 3.

Genom att använda de kombinerade konstruktionerna av loopar och förgrening kan du bygga de enklaste algoritmerna för att lösa enkla problem och få kunskap om hur programmeringsspråk fungerar.

Standardfunktioner

Ett algoritmiskt språk har standardfunktioner som redan är inbyggda i det. De kan göra vissa rutinoperationer med siffror och uttryck enklare. Standardfunktioner i det algoritmiska språket kan beräkna kvadratrötter, logaritmer, moduli, sinus, cosinus, etc.:

• absolut modul - abs(x);
• kvadratrot - sqrt(x);
• naturliga och decimala logaritmer - ln(x) och log(x);
• minimum och maximum av två tal - min(x,y), max (x,y);
• sinus, cosinus, tangens, cotangens - sin(x), cos(x), tan(x), ctg(x).

Dessa standardfunktioner låter dig undvika att skapa en "cykel" genom att hjälpa till att implementera de enklaste funktionerna med hjälp av standardverktyg.

booleska uttryck

Booleska uttryck speglar om en viss operation uppfyller ett villkor. Till exempel kommer x > 0 att utvärderas till sant när x är 1, 2, 25 eller något annat tal större än noll. Algoritmspråket innehåller logiska uttryck som, förutom matematiska standardoperationer, kan använda följande nyckelord och operatorer:

• OCH. Innebär att uttrycken mellan vilka nyckelordet finns måste uppfylla ett visst villkor: (x>0) och (y>0);
• Eller. Ett av uttrycken kanske inte uppfyller villkoret, till exempel (x>0) eller (y>0);
• Inte. "Vänder" det logiska värdet av ett uttryck. Till exempel denna design Inte(x>0), betyder att x fortfarande inte får vara mer än noll.

Det finns också jämförelseoperatörer -<, >, =, som kan kombineras för att skapa uttryck som större än eller lika med.

Ett litet program för ett algoritmiskt språk

För att förstå processen kan du organisera ett program som interagerar med användaren. Den kommer att fråga efter ett nummer, och maskinen kommer att kvadraten på det.

Komponenterna i ett algoritmiskt språk innehåller många nyckelord. Det första programmet börjar med är ett meddelande om algoritmen - alg.

alg Kvadra ett tal ()

Inom parentes måste du ange ett argument som representerar värdet från användaren och resultatet. Glöm inte heller att deklarera vilka typer av dessa data.

Nu kommer maskinen att veta att den måste interagera med en variabel av typen heltal, och resultatet av dess arbete blir S.

Det första du behöver göra är att ange data. Detta görs med hjälp av nyckelordet "input".

Nu, direkt i algoritmens kropp, måste du beskriva ett antal kommandon som kommer att användas för att beräkna kvadraterna av tal.

utgång "S =", S

Ett algoritmiskt språk, vars kommandon gör att uppdraget kan implementeras, skrivs i formen: =. Variabeln S innehåller alltså värdet av produkten av x och sig själv. Utdataraden visar resultatet på skärmen. Tja, allt detta slutar med nyckelordet "con". Hela koden kommer nu att se ut så här:

alg Kvadra ett tal (arg heltal x, res heltal S)

utgång "S =", S

Så här implementeras algoritmen för att beräkna kvadraten på det inmatade talet på ett enkelt sätt. Programmet kan kompliceras genom att lägga till summan av alla operationer. Och då kommer det se ut så här:

alg Kvadra ett tal och beräkna deras summa (arg heltal x, res heltal S)

ges | x > 0

behöver | S = 1*1 + 2*2+ … + x*x

börja hel

ingång x; S:=0

nc för a från 1 till x

utgång "S =", S

Det här alternativet använder en loop, en mellanvariabel a och en kort indikation av uppgiften i avsnitten "given" och "måste". Nu, om du skickar ett visst tal till programmet, kommer det att kvadrera det och visa summan av kvadraterna av alla siffror som föregår det.

Användning och utveckling av algoritmiska språk

Algoritmiskt språk är vanligt i inlärningsmiljöer för att förstå de grundläggande normerna och reglerna för programmering. Till exempel BASIC, som lärs ut på många skolor. Det återspeglar perfekt alla paradigm för en sådan term som ett imperativt programmeringsspråk, där alla kommandon exekveras sekventiellt efter varandra.

På grund av de beskrivna konstruktionernas och nyckelordens närhet till det mänskliga språket har det blivit mycket lättare att skriva kod än att använda helt maskin- eller maskinberoende modeller. ALGOL-familjen av programmeringsspråk har gått längst i sin utveckling, sedan dess syntax presenterades i flera lokaliseringar. Det gick att skriva kod även på ryska.

Generellt sett har utvecklingen av algoritmiska språk i hög grad påverkat programmering i allmänhet och gjort det möjligt för ett stort antal människor att bli utvecklare. Moderna medel blir mer tillgängliga och begripliga. Programmeringsspråk på hög nivå innehåller fler och fler funktioner med meningsfulla namn och titlar. Gränserna för deras användning blir allt mindre. Därmed är en mer förståelig och naturlig implementering av utvecklingen möjlig i framtiden.

En algoritm är en korrekt och begriplig instruktion för utföraren att utföra en sekvens av åtgärder som syftar till att lösa ett givet problem.

Namnet "algoritm" kommer från den latinska formen av namnet på den centralasiatiska matematikern al-Khwarizmi - Algorithmi. Algoritm är ett av grundbegreppen inom datavetenskap och matematik.

En algoritmexekutor är något abstrakt eller verkligt (tekniskt, biologiskt eller biotekniskt) system som kan utföra de åtgärder som föreskrivs av algoritmen.

Artisten kännetecknas av:

elementära handlingar;

kommandosystem;

Miljön (eller miljön) är artistens "habitat". Till exempel, för artisten Robot från skolboken är miljön ett oändligt cellulärt fält. Väggar och målade celler är också en del av miljön. Och deras placering och positionen för själva roboten bestämmer miljöns specifika tillstånd.

Varje executor kan utföra kommandon endast från en viss strikt definierad lista - systemet med executor-kommandon. För varje kommando måste villkoren för tillämplighet specificeras (i vilka miljötillstånd kommandot kan utföras) och resultatet av att utföra kommandot måste beskrivas. Till exempel kan arbetskommandot "upp" utföras om det inte finns någon vägg ovanför arbetet. Resultatet är att roboten förskjuts en cell upp.

Efter att ha anropat kommandot, utför utföraren motsvarande elementära åtgärd.

Exekutorfel uppstår om ett kommando anropas i ett miljötillstånd som är oacceptabelt för det.

Vanligtvis vet artisten ingenting om syftet med algoritmen. Han utför alla kommandon han får utan att fråga varför eller varför.

Inom datavetenskap är den universella exekutorn av algoritmer datorn.

Algoritmernas huvudsakliga egenskaper är följande:

Förstålighet för utföraren - d.v.s. Algoritmens exekutor måste veta hur den ska utföras.

Diskrethet (diskontinuitet, separatitet) - d.v.s. Algoritmen måste representera processen att lösa ett problem som en sekventiell exekvering av enkla (eller tidigare definierade) steg (steg).

Säkerhet - d.v.s. Varje regel i algoritmen måste vara tydlig, entydig och inte lämna något utrymme för godtycke. Tack vare denna egenskap är exekveringen av algoritmen mekanisk till sin natur och kräver inga ytterligare instruktioner eller information om problemet som ska lösas.

Effektivitet (eller ändlighet). Denna egenskap är att algoritmen måste leda till att problemet löses i ett begränsat antal steg.

Mass karaktär. Detta innebär att algoritmen för att lösa problemet utvecklas i en generell form, d.v.s. det bör vara tillämpligt för en viss klass av problem som skiljer sig endast i de initiala uppgifterna. I det här fallet kan initialdata väljas från ett visst område, vilket kallas algoritmens tillämplighetsområde.

I praktiken är de vanligaste formerna för att presentera algoritmer:

verbalt (inspelningar på naturligt språk);

grafik (bilder från grafiska symboler);

pseudokoder (semi-formaliserade beskrivningar av algoritmer i ett konventionellt algoritmiskt språk, inklusive både delar av ett programmeringsspråk och naturliga språkfraser, allmänt accepterade matematiska notationer, etc.);

programvara (texter på programmeringsspråk).

Det verbala sättet att skriva algoritmer är en beskrivning av de successiva stegen i databehandlingen. Algoritmen specificeras i fri form i naturligt språk.

Till exempel. Skriv ner en algoritm för att hitta den största gemensamma divisorn (GCD) av två naturliga tal.

Algoritmen kan vara följande:

ställ in två nummer;

om siffrorna är lika, ta något av dem som svar och sluta, annars fortsätt exekvera algoritmen;

bestämma det största av siffrorna;

ersätt det större talet med skillnaden mellan det större och mindre numret;

upprepa algoritmen från steg 2.

Den beskrivna algoritmen är tillämplig på alla naturliga tal och bör leda till en lösning på problemet. Övertyga dig själv om detta genom att använda den här algoritmen för att bestämma den största gemensamma delaren av talen 125 och 75.

Den verbala metoden är inte utbredd av följande skäl:

sådana beskrivningar är inte strikt formaliserade;

lider av detaljerade inlägg;

möjliggöra oklarheter i tolkningen av enskilda instruktioner.

Det grafiska sättet att presentera algoritmer är mer kompakt och visuellt jämfört med det verbala.

När den presenteras grafiskt avbildas algoritmen som en sekvens av sammankopplade funktionsblock, som vart och ett motsvarar exekveringen av en eller flera åtgärder.

Denna grafiska representation kallas ett flödesschema eller flödesschema.

I flödesschemat motsvarar varje typ av åtgärd (inmatning av initiala data, beräkning av värden för uttryck, kontroll av villkor, kontroll av upprepning av åtgärder, slutförande av bearbetning, etc.) en geometrisk figur representerad som en blocksymbol. Blocksymboler är sammankopplade med övergångslinjer som bestämmer i vilken ordning åtgärderna utförs.

Tabell 1 visar de vanligaste symbolerna.

"Process"-blocket används för att beteckna en handling eller sekvens av åtgärder som ändrar betydelsen, formen av presentation eller placering av data. För att förbättra diagrammets tydlighet kan flera enskilda bearbetningsblock kombineras till ett block. Presentationen av enskilda operationer är ganska gratis.

Blocket "beslut" används för att indikera villkorliga kontrollövergångar. Varje "lösnings"-block måste identifiera frågan, villkoret eller jämförelsen som det definierar.

Blocket "modifiering" används för att organisera cykliska strukturer. (Ordet modifikation betyder modifikation, förvandling). En cykelparameter skrivs inuti blocket, för vilken dess initiala värde, gränsvillkor och steg att ändra parametervärdet indikeras för varje upprepning.

Blocket "fördefinierad process" används för att indikera anrop till hjälpalgoritmer som existerar autonomt i form av några oberoende moduler, och för anrop till biblioteksrutiner.

Pseudokod är ett system av notationer och regler utformade för att enhetligt skriva algoritmer.

Det upptar en mellanplats mellan naturliga och formella språk.

Å ena sidan ligger det nära vanligt naturligt språk, så algoritmer kan skrivas och läsas i det som vanlig text. Å andra sidan använder pseudokod vissa formella konstruktioner och matematisk symbolik, vilket för algoritmnotationen närmare den allmänt accepterade matematiska notationen.

I pseudokod antas inte strikta syntaktiska regler för att skriva kommandon som är inneboende i formella språk, vilket gör det lättare att skriva algoritmen på designstadiet och gör det möjligt att använda en bredare uppsättning kommandon designade för en abstrakt executor. Pseudokod innehåller dock vanligtvis några konstruktioner som är inneboende i formella språk, vilket gör det lättare att gå från att skriva i pseudokod till att skriva en algoritm på ett formellt språk. I synnerhet i pseudokod, såväl som i formella språk, finns det funktionsord, vars betydelse bestäms en gång för alla. De visas i fet stil i tryckt text och är understrukna i handskriven text. Det finns ingen enskild eller formell definition av pseudokod, så olika pseudokoder är möjliga, som skiljer sig åt i uppsättningen av funktionsord och grundläggande (grundläggande) konstruktioner.

Ett exempel på pseudokod är skolans algoritmiska språk i rysk notation (skolan AYA), som beskrivs i läroboken av A.G. Kushnirenko et al "Fundamentals of Informatics and Computer Science", 1991. I framtiden kommer vi helt enkelt att kalla detta språk för "algoritmiskt språk".

Grundläggande funktionsord

Generell bild av algoritmen:

Alg-namnet på algoritmen (argument och resultat)

villkor för algoritmens tillämplighet ges

du behöver målet att exekvera algoritmen

initial beskrivning av mellanstora mängder

| sekvens av kommandon (kroppen av algoritmen)

Delen av algoritmen från ordet alg till ordet beg kallas rubriken, och delen som finns mellan orden beg och slut är algoritmens kropp.

I alg-satsen, efter namnet på algoritmen, anges egenskaperna (arg, res) och värdetypen (heltal, sak, sim, lit eller log) för alla indata- (argument) och utgående (resultat) variabler inom parentes. Vid beskrivning av arrayer (tabeller) används fliken tjänsteord, kompletterad med gränspar för varje index av arrayelementen.

Exempelmeningar alg:

alg Volym och area av cylindern (arg saker R, H, res saker V, S)

alg Rötter KvUr(arg saker a, b, c, res saker x1, x2, res lit t)

alg Exclude element (arg int N, arg res stuff tab A)

alg Diagonal(arg int N, arg int tab A, lyser upp Svar)

Förslag som ges och måste är inte bindande. Det rekommenderas att skriva ned påståenden som beskriver tillståndet i miljön för algoritmexekvatorn, till exempel:

alg Ersättning (arg lit Str1, Str2, arg res lit text)

ges | längden på delsträngarna Str1 och Str2 är desamma

behöver | Överallt på textraden ersätts delsträngen Str1 med Str2

alg Antal maxima (arg int N, arg sak tab A, res int K)

ges | N>0

behöver | K - antalet maximala element i tabell A

alg Resistans (args saker R1, R2, args int N, res saker R)

ges | N>5, R1>0, R2>0

behöver | R - kretsresistans

Här i meningar givna och nödvändiga efter tecknet "|" kommentarer inspelade. Kommentarer kan placeras i slutet av valfri rad. De bearbetas inte av översättaren, men gör algoritmen mycket lättare att förstå.

Algoritmer kan ses som vissa strukturer som består av individuella grundläggande (dvs grundläggande) element.

Naturligtvis, med denna inställning till algoritmer, bör studiet av de grundläggande principerna för deras design börja med studiet av dessa grundläggande element.

För att beskriva dem kommer vi att använda språket för algoritmdiagram och skolans algoritmiska språk.

Den logiska strukturen för alla algoritmer kan representeras av en kombination av tre grundläggande strukturer:

följande,

förgrening,

En karakteristisk egenskap hos grundläggande strukturer är närvaron av en ingång och en utgång.

En del av algoritmen från ordet alg till ordet början kallas rubriken och delen mellan orden början Och lura- algoritmens kropp.

I en mening alg efter namnet på algoritmen anges egenskaperna (arg, res) och typen av värden (int, thing, sim, lit, log) för alla indata (argument) och output (resultat) variabler inom parentes.

Vid beskrivning av arrayer (tabeller) används ett speciellt ord flik, kompletterat med gränspar vid varje arrayelementindex.

Exempelmeningar alg:

alg Volym och area av cylindern (arg saker R, H, res saker V, S)

alg Rötter KvUr(arg saker a, b, c, res saker x1, x2, res lit t)

alg Exclude element (arg int N, arg res stuff tab A)

alg Diagonal(arg int N, arg int tab A, lyser upp Svar)

Meningar med ord given Och nödvändig inte nödvändig. Det rekommenderas att skriva ned påståenden som beskriver tillståndet i miljön för algoritmexekvatorn, till exempel:

Alg Ersättning (arg lit Str1, Str2, arg res lit Text) ges | längden på delsträngarna Str1 och Str2 måste vara samma | Överallt på textraden ersätts delsträngen Str1 med Str2

Alg Antal maxima (arg int N, arg sak tab A, res int K)givna | N>0 behöver | K - antalet maximala element i tabell A

Alg Resistance (args saker R1, R2, args int N, res saker R) ges | N>5, R1>0, R2>0 behöver | R - kretsresistans

Här i meningar given Och nödvändig efter "|"-tecknet kommentarer inspelade. Kommentarer kan placeras i slutet av valfri rad. De bearbetas inte av datoröversättaren, men gör algoritmen mycket lättare att förstå.

Kommandon för skolans programmeringsspråk AJ

Uppdragsoperatör. Används för att utvärdera uttryck och tilldela deras värden till variabler. Operatörens allmänna form: A:= B, där tecknet ":=" betyder tilldelningsoperationen, dvs. kommando för att ersätta det tidigare värdet av variabel A, som finns på vänster sida, med det beräknade värdet av uttryck B, som finns på höger sida.

Till exempel, a:=(b+c)*sin(Pi/4);

i:=i+1 .

För ingång och utgång dataanvändningskommandon

· inmatning variabelnamn

· slutsats variabelnamn, uttryck, texter.

För förgrening Algoritmen använder kommandona - Om Och val.

För organisation cykler - kommandon För Och Hejdå, beskrivet nedan.

Ett exempel på att skriva en algoritm på skolspråket ASL.

Alg Summan av kvadrater (arg heltal n, snittet är intakt S)given | n > 0behöver | S = 1*1 + 2*2 + 3*3 + ... + n*nstart int i inmatning n; S : =0 nc för i från 1 till n S : =S+i*i kts utgång "S = ", Skon

En dator kan bara köra ett program om instruktionerna som den innehåller är representerade i binär maskinkod, d.v.s. uttryckt på ett språk vars alfabet består av logiska ettor och nollor. För de första datorerna kompilerades program direkt i maskinkoder, vilket krävde högt kvalificerade programmerare och mycket arbete, så redan på 40-talet började utvecklingen av programmeringsspråk, som i deras vokabulär skulle vara så nära naturligt som möjligt mänskligt språk. Sådana programmeringsspråk kallas algoritmisk.

Ett mellansteg mot utvecklingen av algoritmiska språk var språket Assemblerare. I Assembly representeras kommandon inte som binära tal, utan som kombinationer av symboler (mnemoniska koder), genom vilka innebörden av kommandot kan reproduceras, vilket avsevärt eliminerar svårigheterna och nackdelarna med maskinspråksprogrammering. Men Assembler har också nackdelar - det är ett maskinorienterat språk, och varje dator har sitt eget Assembly-språk. Programmering i Assembler kräver att programmeraren har goda kunskaper om datorns arkitektur (struktur) och är förknippad med betydande arbetskostnader, samtidigt är det med hjälp av Assembler som du bäst kan använda datorresurser (minne, speed) i programmet, så Assembler används fortfarande i stor utsträckning bland professionella programmerare.

Det första algoritmiska språket var Fortran, skapad 1957 IBM-specialister under ledning av John Backus. Nu finns det ett stort utbud av algoritmiska språk: Pascal, C, Algol, PL1, Basic, Lisp, Prolog och många andra.

Algoritmiska språk och assemblers tillhör symboliska kodningsspråk, d.v.s. till språk som inte fungerar med maskinkoder, utan med konventionella symboliska notationer, därför kan program skrivna på dessa språk inte köras direkt på en dator. För att ett sådant program ska fungera måste dess text omvandlas till maskinkoder. Det finns särskilda översättningsprogram för detta ändamål. Det finns två typer av översättare: en kompilator och en tolk. Kompilator sänder hela programmet på en gång, och först efter det är det möjligt att köra det. Tolk- det här är en enklare översättare, den översätter programsatser sekventiellt och exekverar det också i delar.

21) Programstruktur i C/C++.

Ett C++-program består av funktioner , beskrivningar Och förbearbetningsdirektiv . En av funktionerna måste ha ett namn huvud . Programexekveringen börjar med den första satsen för denna funktion. Den enklaste funktionsdefinitionen har följande format:

Vanligtvis används en funktion för att beräkna ett värde, så dess typ anges före funktionsnamnet. Nedan följer den viktigaste informationen om funktionerna:

• om funktionen inte ska returnera ett värde, anges void-typen:
• funktionskroppen är ett block och är därför innesluten i lockiga hängslen;
• funktioner kan inte kapslas;
• Varje påstående slutar med semikolon (förutom det sammansatta påståendet).

Ett exempel på en programstruktur som innehåller huvud-, fl- och f2-funktionerna:

Programmet kan bestå av flera moduler (källfiler).

Några anteckningar om I/O i C++

C++-språket har inga inbyggda input/output-faciliteter - det utförs med hjälp av funktioner, typer och objekt som finns i standardbibliotek. Två metoder används: funktioner som ärvts från C-språket och C++-objekt.

Grundläggande C-stil I/O-funktioner:

int scanf (const char* format, ...) // input
int printf(const char* format, ...) // output

De utför formaterad inmatning och utmatning av ett godtyckligt antal värden enligt formatsträngen. Formatsträngen innehåller tecken som kopieras till strömmen (på skärmen) vid utmatning eller begärs från strömmen (från tangentbordet) vid inmatning, och konverteringsspecifikationer som börjar med %-tecknet, som ersätts av specifika värden vid inmatning och utgång.

Ett exempelprogram som använder C-style I/O-funktioner:

#omfatta
int main() (
int i;
printf("Ange ett heltal\n");
scanf("%d", &i);
printf("Du skrev in numret %d, tack!", i);
returnera 0;
}

Den första raden i detta program är ett förbehandlardirektiv, som infogar en rubrikfil i programtexten som innehåller en beskrivning av inmatnings-/utgångsfunktionerna som används i programmet (i detta fall är vinkelparenteser ett språkelement). Alla förprocessordirektiv börjar med ett #-tecken.

Den tredje raden är en beskrivning av en heltalsvariabel med namnet i.

Printf-funktionen på den fjärde raden skriver ut "Ange ett heltal"-prompten och bryter till en ny rad enligt \n escape-sekvensen. scanf-funktionen lägger in det heltal som angetts från tangentbordet i variabeln i (tecknet & betyder operationen att erhålla adressen), och följande sats visar strängen som anges i den och ersätter konverteringsspecifikationen
idéer om innebörden av detta nummer.

Och så här ser samma program ut med C++-klassbiblioteket:

#omfatta
int main() (
int i;
cout<< "Введите целое число\n"; cin >> i;
cout<< "Вы ввели число " << i << ", спасибо!";
returnera 0;
}

Rubrikfilen innehåller en beskrivning av en uppsättning klasser för hantering av input/output. Den definierar standardströmobjekten cin för tangentbordsinmatning och cout för skärmutmatning, såväl som operationerna för att placera i en ström< < и чтения из потока >>.

22) Alfabet och identifierare på språket C/C++.

ALFABET
versaler och gemener latinska bokstäver och understreck;
Arabiska siffror från 0 till 9;
blanksteg: mellanslag, tab, nyrad.
speciella karaktärer:

Språkets lexem bildas av tecknen i alfabetet:
identifierare;
nyckelord (reserverade) ord;
operation tecken;
konstanter;
avgränsare (parentes, punkt, kommatecken, blanksteg).

IDENTIFIERINGAR
Identifieraren kan använda latinska bokstäver, siffror och understreck;
Versaler och gemener är olika;
Det första tecknet i en identifierare kan vara en bokstav eller ett understreck, men inte en siffra;
Mellanslag är inte tillåtna inom namn;
Längden på en identifierare är inte begränsad av standarden, men vissa kompilatorer och länkare sätter begränsningar på den;
Identifieraren behöver inte matcha sökorden.
Det rekommenderas inte att börja identifierare med ett understreck (de kan sammanfalla med namnen på systemfunktioner eller variabler);
På identifierare som används för att definiera externa variabler;
Det finns länkningsbegränsningar (att använda olika länkar eller versioner av länken ställer olika krav på externa variabelnamn).

C++ nyckelord

23) Heltalsdatatyper i C/C++.

Heltalsdatatypen är utformad för att representera vanliga heltal i datorns minne. Den grundläggande och vanligaste heltalstypen är typ int. Dess sorter är mycket mindre vanliga: kort(kort heltal) och lång(långt heltal). Typen ingår också i heltalstyper röding(symbolisk). Dessutom kan du vid behov använda typen lång lång(lång, lång!), som, även om den inte definieras av standarden, stöds av många C++-kompilatorer. Som standard är alla heltalstyper ikonisk, dvs. Den mest signifikanta biten i sådana tal bestämmer tecknet för talet: 0 är ett positivt tal, 1 är ett negativt tal. Förutom signerade nummer i C++ kan du använda osignerad. I det här fallet deltar alla siffror i bildandet av heltal. När man beskriver heltalsvariabler utan tecken läggs ordet till osignerad(inget tecken).

Sammanfattningstabell över signerade heltalsdatatyper:

Data typ	Storlek, byte	Värdeintervall
röding		-128 ... 127
kort		-32768 ... 32767
int		-2147483648 ... 2147483647
lång		-2147483648 ... 2147483647
lång lång		-9223372036854775808 ... 9223372036854775807

Sammanfattningstabell över osignerade heltalsdatatyper:

Data typ	Storlek, byte	Värdeintervall
osignerad röding		0 ... 255
osignerad kort		0 ... 65535
osignerad int (du kan bara osignerad)		0 ... 4294967295
osignerad lång		0 ... 4294967295
osignerad lång lång		0 ... 18446744073709551615

Det är knappast värt att komma ihåg gränsvärdena, särskilt för 4 eller 8 byte heltal; det räcker att åtminstone veta vilken ordning dessa värden kan vara, till exempel typen int- ungefär 2·10 9 .

I praktiken rekommenderas att använda den grundläggande heltalstypen överallt, d.v.s. int. Faktum är att data av huvudheltalstypen nästan alltid bearbetas snabbare än data av andra heltalstyper. Korta typer ( röding, kort) är lämpliga för att lagra stora arrayer av nummer för att spara minne, förutsatt att värdena för elementen inte överskrider gränserna för dessa typer. Långa typer behövs i situationer där typ inte räcker till int.

24) Verkliga datatyper i C/C++-språket.

Det speciella med reella (reella) tal är att de nästan alltid lagras ungefär i datorns minne, och när man utför aritmetiska operationer på sådana data ackumuleras ett beräkningsfel.

Det finns tre riktiga datatyper: flyta, dubbel Och lång dubbel. Huvudtypen beaktas dubbel. Således fungerar alla matematiska funktioner som standard med typen dubbel. Tabellen nedan visar de viktigaste egenskaperna hos riktiga typer:

Typ lång dubbel för närvarande i regel sammanfaller med typen dubbel och används vanligtvis inte i praktiken. När du använder äldre 16-bitars kompilatorer, data som lång dubbelär 10 byte stora och ger precision till 19 decimalsiffror.

Det rekommenderas att endast använda typen överallt dubbel. Att arbeta med det är alltid snabbare, och det är mindre sannolikhet för en märkbar förlust av noggrannhet med ett stort antal beräkningar. Typ flyta kan endast vara användbar för att lagra stora arrayer, förutsatt att denna typ är tillräcklig för att lösa uppgiften.

25) Teckendatatyp i språket C/C++.

Det finns ingen datatyp i C++-standarden som kan anses vara verklig karaktär. För att representera teckeninformation finns det två typer av data som är lämpliga för detta ändamål, dessa är typerna röding Och wchar_t, även om båda dessa typer i huvudsak är heltalstyper. Du kan till exempel ta symbolen "A" och dividera den med siffran 2. Vad får du förresten? Tips: mellanslag. För "normala" teckentyper, som i Pascal eller C#, är aritmetiska operationer på tecken förbjudna.

Typ röding används för att representera tecken i enlighet med ASCII-kodningssystemet (American Standard Code for Information Interchange). Det här är en sju-bitars kod, det räcker med att koda 128 olika tecken med koder från 0 till 127. Tecken med koder från 128 till 255 används för att koda nationella typsnitt, pseudografiska tecken osv.

Typ wchar_t designad för att fungera med en uppsättning tecken för vilka 1 byte inte räcker för att koda, till exempel Unicode. Typstorlek wchar_t vanligtvis lika med 2 byte. Om ditt program behöver använda strängkonstanter som wchar_t, då skrivs de med prefixet L t.ex. L"Word".

26) Uppdragsoperatör och tom operatör i C/C++ språk

Uppdragsoperatör– Det här är den vanligaste operatören. Dess syfte är att tilldela ett nytt värde till en variabel. Det finns tre former av denna operator i C++.

1)Enkel uppdragsoperatörär skrivet så här:

variabel = uttryck;

Denna operator fungerar enligt följande: först beräknas uttrycket som skrivits till höger om operationssymbolen = (lika), sedan tilldelas det resulterande resultatet till variabeln till vänster om tecknet = . Typen av resultat måste matcha eller vara castbar till typen av variabeln skriven till vänster.

Till vänster om skylten = Det kan bara finnas en variabel, men till höger kan du skriva en konstant, en variabel och i allmänhet ett uttryck för vilken komplexitet som helst.

Exempel operatörer

y=x+3*r;

s=sin(x);

2)Flera uppdrag- i en sådan operator, sekventiellt från höger till vänster, tilldelas flera variabler samma värde, till exempel:

a=b=c=1;

Så du kan omedelbart bestämma, till exempel, att i en liksidig triangel är alla sidor lika med samma nummer 1. Ovanstående operator motsvarar sekventiell exekvering av tre operatorer:

Naturligtvis är det lättare för oss att skriva ner en operatör snarare än tre. Programmet är kortare, texten ser mer naturlig ut och den här designen fungerar lite snabbare.

3)Uppdrag med samtidig utförande av någon operation i allmänhet skrivs det så här:

variabel op_sign = uttryck;

och är likvärdigt med att skriva

variabel = variabel operator_tecken uttryck;

Till exempel, operatören:

s+= 5; // Första alternativet

gör samma sak som operatören

s = s + 5; // Andra alternativet

nämligen: ta det gamla värdet från variabeln s, lägg till ett nummer till den 5 och skriv tillbaka det resulterande värdet i variabeln s.

Som du kan se är inmatningen av det första alternativet kortare än inmatningen av det andra alternativet, och det är snabbare, eftersom i det första alternativet adressen till variabeln s beräknas en gång och i det andra alternativet - två gånger.

Tom operatör

Ett tomt uttalande är ett uttalande som inte gör någonting. Varför behöver vi en "värdelös" operatör?

En tom operator används i de fall där det enligt språkets syntax är nödvändigt att skriva ner någon operator, men enligt programmets logik kommer vi inte att göra någonting. Således kan en tom sats krävas i en grensats, när inget behöver göras längs någon gren, även för att definiera en etikett för en övergång i programtexten, och ibland för en tom loopkropp.

Den tomma operatorn är ett enda tecken ; (semikolon), till exempel:

c=a+b; ;

Här är den första karaktären ; (semikolon) avslutar tilldelningsoperatorn, och det andra tecknet är det som ger oss den tomma operatorn. I denna situation behövs inte den tomma operatorn alls (men är inte heller ett syntaxfel!), den tillhandahålls endast för förtydligande. Fler "rimliga" exempel på att använda den tomma operatorn kommer att ges senare i de relevanta ämnena.

27) Aritmetiska operationer i språket C/C++.

Dessa är de vanligaste operationerna. Deras innebörd ligger nära vad det är känt från en matematikkurs. Så låt oss lista dem:

Prioriteten för additions- och subtraktionsoperationer är lägre än för multiplikation, division och återstodsberäkningar. För att ändra beräkningsordningen, använd parenteser, till exempel för att multiplicera med 2 summan av två tal A Och B du kan skriva:

Ytterligare. Som framgår av de erhållna resultaten finns det ett tecken i C++ / betyder två olika operationer. Om en eller båda operanderna är reella, utförs vanlig division; om båda operanderna är heltal, utförs heltalsdivision och resultatet blir av heltalstyp. Att använda denna operation kräver ökad försiktighet, till exempel om du programmerar beräkningen av ett matematiskt uttryck

bokstavligen, dvs. Så:

1/3*sin(2*X)

sedan resultatet oavsett värdet X kommer alltid att vara lika med noll, eftersom uttrycket 1/3 betyder division med en helhet. För att lösa problemet räcker det att göra en av operanderna verklig

1,0/3*sin(2*X)

Operationen för att beräkna resten ( % ) är endast tillämplig för heltalsoperander.

Byte av tecken. Unär operation" - " betyder byte av tecken. Som framgår av den allmänna tabellen över alla operationer har den en mycket hög prioritet - högre än till exempel multiplikationsoperationen. Därför i uttrycket

Först ändras tecknet för A, och sedan multiplikation -A på B.

För parning finns också en operation unärt plus, dvs. du kan skriva

För vilka ändamål ska detta användas? Svårt att säga. Men det finns en sådan möjlighet.

Mer intressant, och viktigast av allt, mycket vanligt är operationerna autoökning och autominskning.