Transkripte
1. Willkommen: Willkommen zu unserem Kurs, wie man Programmieren mit CTO Code
lernt Ich bin Jans D Mercies. Gemeinsam werden wir Schritt für Schritt
lernen, wie man einfache und
kompliziertere Probleme
mit Cyto Code löst kompliziertere Probleme
mit Cyto Ein bisschen über meinen Hintergrund. Ich habe einen Abschluss in Informatik und
Telekommunikationstechnik mit über 12 Jahren Erfahrung in der Webentwicklung und über
neun Jahren in der Fotografie Meine wahre Person liegt jedoch darin, Programmieren zu
unterrichten und dabei CDO-Code zu verwenden Unser Ziel ist es, dass
wir am
Ende des Unterrichts in der Lage sein werden, CTO-Code zur Lösung von Problemen zu schreiben Dieses Wissen wird uns helfen, uns mit
der Denkweise des Programmierens
vertraut Aber warum lernen wir,
CTO-Code zu schreiben, bevor wir mit der Programmierung
beginnen ein in
CTO-Code geschriebenes Programm in ein beliebiges
Programmierlogo zu konvertieren . Das liegt daran, dass Sie
lediglich das Vokabular der Programmiersprache
lernen müssen, in
der es
sich bewährt hat Aber lassen Sie uns sehen, wie wir dieses Ziel
schrittweise erreichen werden. Zunächst werden wir
darüber sprechen, was ein Computer
versteht um ein Problem für uns zu lösen,
indem wir einen historischen Überblick geben. Dann werden wir sehen,
was das Problem ist und wie wir denken, um
die Lösung zu finden. Sobald wir die
Denkweise der Problemlösung verstanden
haben, können wir mit
dem Schreiben von CDO-Code fortfahren Wir werden anhand von Beispielen
die Bausteine von
Algorithmen mit CDO-Code
sowie die etwas
komplexeren Teile von s
detailliert besprechen die Bausteine von
Algorithmen mit CDO-Code . Auf diese Weise werden wir uns das
Wissen aneignen, das
wir benötigen, um uns mit der vertraut
zu Während dieser Reise werden
wir uns nach und nach Wissen
aneignen, das uns helfen
wird, Probleme
mithilfe von Programmen zu lösen , die in CDO-Code
geschrieben Ein solches Problem, das es zu lösen gilt, wird die Aufgabe
für diesen Kurs Später, nachdem wir
einige grundlegende Konzepte
von CDO Code behandelt haben , werden
wir genau sehen, was wir für
die Aufgabe tun müssen Am Ende freue ich mich auf Ihre Bemühungen
und Ihre Programme Lassen Sie uns jedoch nicht länger
zögern und diese Reise in
die Welt der Programmierung
beginnen.
2. Einführung in das Coding: In diesem ersten Abschnitt werden
wir
eine Einführung zur
Definition der Algorithmen geben eine Einführung zur
Definition der Algorithmen Wir haben alle das
Konzept eines Algorithmus gehört. Aber was genau ist das? Ein Algorithmus
ist einfach eine Reihe von Anweisungen, denen ein
Computer folgt, um ein Problem zu lösen. Der folgende
Glgorith rechnet beispielsweise Kilometer in Meilen um Der Benutzer gibt einfach
einen Wert in Kilometern ein und der Algorithmus
berechnet und drückt das berechnet Im CTO-Code wäre das so
. Wenn wir eine
vollständige Definition geben wollten, wäre
es diese Um eine Reihe von
Anweisungen und Algorithmen aufrufen zu können, muss
sie die
Kriterien Eingabe,
Ausgabe, Bestimmtheit,
Endlichkeit und Effektivität Schauen wir uns an, was jeder dieser Punkte bedeutet
. Zuallererst
beginnt jeder Algorithmus mit einer Eingabe. Die Definition, die wir hier
sehen, bedeutet, dass wir dem
Algorithmus einige Werte zur Verfügung stellen
müssen, die er verarbeitet, um zur Lösung des Problems
zu gelangen. Am Ende jedes Algorithmus sollte eine Ausgabe stehen. Der Algorithmus muss das Ergebnis
liefern, das die Lösung
des Problems darstellt. Dieses Ergebnis wird entweder für
den Benutzer
ausgedruckt oder als Eingabe
für einen anderen Algorithmus verwendet. Ein weiteres Merkmal, das
ein Algorithmus haben
sollte, ist die Bestimmtheit Die Anweisungen in einem Algorithmus müssen klar und offensichtlich sein, sodass kein
Zweifel daran besteht , wie sie ausgeführt werden
sollten Wir müssen alle
möglichen Szenarien berücksichtigen , die den
Ablauf des Algorithmus beeinflussen könnten Eine
Divisionsanweisung muss beispielsweise den Fall
berücksichtigen, dass
der Divisor Außerdem sollten wir sicherstellen, dass der Algorithmus, den wir
schreiben, endlich ist Der Algorithmus muss
nach einer endlichen Anzahl von Schritten beendet nach einer endlichen Anzahl Wir können keinen Algorithmus haben
, der ewig läuft. beispielsweise nicht möglich,
positive Zahlen zu addieren, bis die Summe Null oder
negativ wird, sodass der Algorithmus
niemals aufhören würde zu laufen. Das letzte Kriterium
ist die Effektivität. Jede Anweisung in einem
Algorithmus muss einfach sein. Das bedeutet, dass eine
Anweisung nicht
nur definiert, sondern
auch ausführbar sein muss nur definiert, sondern
auch ausführbar sein Dieses Kriterium wird
in den folgenden Fällen verletzt. Berechne die Summe aller
Primzahlen bis n und finde dann die
Quadratwurzel des Ergebnisses. Das Problem ist, dass
diese Anweisung zu
komplex ist und aus
vielen aufeinanderfolgenden Aktionen besteht, z. B. dem Bekämpfen von Primzahlen, dem
Berechnen der Summe und dem
Extrahieren der Quadratwurzel Es ist schwierig, sie direkt
auszuführen und muss in
ähnliche Befehle aufgeteilt werden Eine weitere Anweisung besteht darin,
den Durchschnitt
der negativen Zahlen in einer Menge zu ermitteln , die keine
negativen Zahlen enthält. Das Problem besteht darin, dass die Anweisung nicht ausgeführt
werden kann, wenn
die Menge keine negativen Zahlen
enthält , da es keine negativen Zahlen
zur Berechnung des Durchschnitts
gibt. Die Anweisung ist
unter diesen Bedingungen nicht ausführbar. Wie bereits
erwähnt, besteht das Ziel jedes Algorithmus darin
, ein Problem zu lösen. Die Arten von Problemen
sind jedoch nicht auf
Rechenprobleme beschränkt. Sie können auch andere
Probleme in unserem täglichen Leben sein. Warum lassen wir Computer ein Problem überhaupt
lösen ,
anstatt es selbst zu lösen? Es ist sicher, dass Menschen
Probleme schon lange
vor dem Aufkommen von
Computern gelöst haben Probleme schon lange
vor dem Aufkommen von
Computern und
dies auch nach der
Entwicklung der Technologie weiterhin tun . Oft entscheiden
wir uns jedoch dafür,
den Computer mit der Lösung eines Problems zu beauftragen den Computer mit der Lösung eines Problems zu anstatt es selbst zu lösen. Warum passiert das? Zuallererst führen Computer Befehle und Operationen
viel schneller aus als wir. Danach
wickeln Computer sich wiederholende
Prozesse effizient ab. Ein typischer
Computer kann beispielsweise
Berechnungen mit einer Geschwindigkeit
von Billionen pro Sekunde durchführen Berechnungen mit einer Geschwindigkeit
von Billionen pro Darüber hinaus
können Computer problemlos
komplexe Berechnungen durchführen , die für Menschen eine Herausforderung
darstellen könnten für Menschen eine Herausforderung
darstellen Schließlich bevorzugen wir Computer,
wenn der problematische Datensatz
umfangreich ist , da sie
große Datenmengen
schnell und genau verarbeiten können .
3. So arbeiten Computer: Nachdem wir in früheren Lektionen das
Konzept der Algorithmen und
ihren Beitrag zur
Problemlösung vorgestellt haben ihren Beitrag zur
Problemlösung , ist
es an der Zeit,
etwas besser zu verstehen, wie Computer funktionieren und wie sie
die Befehle ausführen, die wir ihnen geben. Die Sprache, die der Computer versteht, ist Null und Eins und als Maschinensprache
bezeichnet. Mit Null und Eins geben wir an ,
ob Strom fließt
oder nicht. Aus diesem Grund hatten die ersten
Computer Switches. Wenn sie einem Computer
befehlen wollten, eine Operation
wie eine Berechnung
auszuführen, änderten sie die entsprechenden Schalter, um den Befehl Der erste Computer, der
jemals gebaut wurde unterschied
sich erheblich von
den Computern, die wir heute verwenden Sie hatten eine enorme Größe, viel langsamer bei der Verarbeitung von Daten und ihre Fähigkeiten waren
unvergleichlich eingeschränkter Das Hauptproblem bestand darin, dass sie für jeden neuen Vorgang, den sie durchführen
wollten, konfigurieren mussten Dies war ein
zeitaufwändiger Vorgang,
zumal es sich bei den
Computern um ganze Räume handelte Mit dem technologischen Fortschritt wurden
die Schalter durch
andere Technologien ersetzt ,
die schneller und
zuverlässiger waren und weniger Energie
benötigten, wie
Vakuumröhren, Transistoren, integrierte Schaltungen
und spätere Prozessoren blieb jedoch das
Problem, dass die einzige Möglichkeit, mit Computern zu kommunizieren, die Maschinensprache
war Die Programmierer
der ersten Computer mussten diese
Sprache sehr gut beherrschen, was zu
erheblichen Problemen führte Sie war für Menschen nicht
verständlich, aber für den Computer war sie verständlich Die Computer waren
riesige ganze Räume, und selbst für eine kleine Operation war viel Arbeit erforderlich. Selbst wenn ein Programm auf einem Computer
erstellt würde, würde
es nur auf
diesem bestimmten Computer funktionieren und wäre es für einen anderen verständlich
. Um diese Probleme zu lösen, wurde
die Low-Level-Sprache oder
Assemblersprache geschaffen. Diese Sprache war für Menschen
verständlicher da sie nicht aus einer
Abfolge von Nullen und Einsen bestand, sondern Wörter wie
ad usw. verwendete In der Assemblersprache
entsprechen Wörter einer Folge
von Nullen und Einsen Somit könnte ein Programmierer Befehle mit
bestimmten Wörtern
geben, wobei
der Computer intern mit einem speziellen Programm, einem
sogenannten Assembler,
in Nullen und Einsen übersetzt speziellen Programm, einem
sogenannten Doch selbst diese Sprache
konnte grundlegende Probleme nicht lösen Programme konnten immer noch nicht von einem
Computer auf einen anderen
übertragen werden . Der Programmierer benötigte
ein tiefes Verständnis der
Computerarchitektur Programme in Assemblersprache
waren umfangreich und komplex, was ihre Wartung
erschwerte Als nächstes kam die Hochsprache
, die Ende der 50er Jahre auf den Markt und das Problem der Übertragung
eines Programms von
einem Computer auf einen
anderen löste Programms von
einem Computer auf einen . Wie wurde das gemacht? Jeder Computer verwendete intern andere Verfahren, die Befehle, die in einer
Hochsprache wie Java
gegeben wurden,
übernahmen in einer
Hochsprache wie Java
gegeben wurden, und sie schließlich
in Maschinensprache übersetzten. Ein weiterer Vorteil ist, dass es Menschen noch
verständlicher
ist. Da es Vokabeln
wie Lesen und Schreiben verwendet. Wenn sich ein anderes Programm das Programm
anschaut, kann
es leicht
verstehen, was es tut ,
und es gegebenenfalls korrigieren, was die Wartung
des Programms vereinfacht. Der einzige Nachteil besteht darin
, dass dieser interne
Übersetzungsprozess von einer Hochsprache in eine
Maschinensprache einige Zeit in Anspruch nimmt. Heute ist die
Computergeschwindigkeit jedoch so hoch, dass diese Zeit unbedeutend
ist Und es macht keinen Sinn, Maschinensprache
zu schreiben. Zum Beispiel könnten wir innerhalb von Jahren
ein Programm in
Maschinensprache schreiben Jahren
ein Programm in
Maschinensprache und es wäre
direkt ausführbar, oder wir könnten es an einem
Tag in einer Hochsprache schreiben und die Ausführung würde 1
Sekunde dauern. Es ist zwar einfacher, in
Hochsprache zu schreiben, aber
wir müssen auch
einige Grundkenntnisse im
Schreiben von Algorithmen haben , um das Programm
irgendwann schreiben zu können. Mit anderen Worten, die Entwicklung
eines Algorithmus oder eines Programms richtet diejenigen, die über Programmierkenntnisse
verfügen. Um diesen Prozess für Nicht-Programmierer
zugänglicher zu machen, wurden
Sprachen der
vierten Generation entwickelt Ein Beispiel ist SQL für Datenbanken. Die Funktion besteht darin, dass wir
ganz einfach mit dem Programm sprechen und es uns einige
Daten gibt.
Geben Sie mir zum Beispiel die Namen der Schüler, Geben Sie mir zum Beispiel die Namen der Schüler die beim Programmieren mehr als
zehn Punkte erzielt haben. Um solch einfache Befehle zu geben, muss
man kein Programmierer sein Was wir anfordern
können, ist jedoch
eingeschränkter als das Schreiben eines Programms in einer
Hochsprache Zusammenfassend lässt sich sagen, dass jede
Programmiersprache ihre Stärken
und Schwächen
hat. Auf die Frage, die
als die beste
und effektivste angesehen werden könnte , lautet
die Antwort, dass
wir nicht
mit Sicherheit behaupten können , dass eine
Programmiersprache
objektiv besser ist als die anderen weil eine solche Sprache
einfach nicht existiert Es gibt keine Programmiersprache für alle
Arten von Problemen
geeignet Einige eignen sich möglicherweise für
souveräne mathematische Probleme. Andere für geschäftliche Probleme und andere für
verschiedene Anwendungen? Wenn
jemand beispielsweise
lernen möchte, Websites ohne CMS zu erstellen, wird
er PHP oder
Python lernen und nicht Java, da es einem
anderen Zweck dient. Dies wirft die Frage auf, da all diese Verzögerungen
darauf abzielen, ein Programm zu erstellen Warum haben wir sie erwähnt
und wie helfen wir uns, das Konzept
eines Algorithmus
zu verstehen? das Konzept
eines Algorithmus
zu verstehen Beim
Schreiben eines Algorithmus ist es
unser Ziel, ein gleichwertiges Programm in
jeder Programmiersprache
schreiben zu können , ein bestimmtes Problem
löst Der Algorithmus ist in
einer hypothetischen Sprache
namens Sido-Code geschrieben einer hypothetischen Sprache Sydo-Code folgt allen Grundprinzipien
der Programmierung, aber es ist ein theoretisches Konzept, und normalerweise
wird ein Programm in Programmiersprache geschrieben Ein Programmierer kann
die in
CDO-Code geschriebene Lösung für ein
Problem in
eine Hochsprache umwandeln, um die in
CDO-Code geschriebene Lösung für ein
Problem in das Programm
zu schreiben Für einige
UT-Programmierer ist es viel einfacher, zuerst den CDO-Code zu
verstehen, da sie nicht sofort viel
über die Programmiersprache
lernen
müssen über die Programmiersprache Mit CDO Code machen wir uns mit
der Denkweise
vertraut, die
zum Schreiben eines Programms erforderlich ist Und dann können
wir, indem wir
das Vokabular der
Programmiersprache lernen , die zu uns passt, das
gewünschte Programm erstellen
4. Algorithmen und Programme: Lassen Sie uns schnell einige Konzepte
durchgehen , die uns bei der
Fortsetzung des Unterrichts helfen werden. Wie wir bereits erwähnt haben, ist
ein Algorithmus ein
theoretisches Konzept. Es bezieht sich auf den nachfolgenden Denkprozess zur Lösung eines Problems. Um
diesen Denkprozess praktisch darzustellen, wir Algorithmen auf folgende
Weise dar Freitext, natürliche
Sprachen Schritt für Schritt, agrammatische
Techniken Wir werden nur
Codierung verwenden, das heißt, wir werden ein Programm in
CDO-Code schreiben, das, wenn es ausgeführt
wird, dieselben
Ergebnisse liefert wie der Schauen wir uns anhand eines einzigen Beispiels kurz an, was die anderen Methoden sind In unserem Beispiel wollen wir den Umkreis eines Quadrats
bekämpfen Im Freitext würden wir es wie folgt
schreiben. Zunächst bitten wir den Benutzer, die Länge
einer Seite eines Quadrats
anzugeben. Sobald wir die Seitenlänge erhalten
haben, behalten wir sie für
die nachfolgenden Berechnungen als gegeben bei. Wir multiplizieren die Zahl mit vier, und das Ergebnis dieser Operation ist der Umfang des Quadrats Schließlich präsentieren wir
dem Benutzer das Ergebnis,
das wir gefunden haben, den Umfang des
Quadrats In natürlichen Seiten würden wir es wie
folgt schreiben. Der Algorithmus fragt zu Beginn nach der Länge der Sitzung. Nimm die Seitenlänge und
multipliziere die Sitzlänge mit vier. Das Ergebnis ist der
Umfang des Quadrats. Zeigt den berechneten
Umfang d des Algorithmus an. In einem Float-Diagramm würden wir es wie
folgt darstellen. Beim Codieren würden wir es wie folgt
schreiben. Wir programmieren, wenn wir ein Programm
oder einen Algorithmus
schreiben wollen . Der Unterschied
zu Algorithmen besteht darin , dass die Codierung im CDO-Code erfolgt In Programmen erfolgt dies
in einer Programmiersprache. Um
den Unterschied
zwischen einem Algorithmus
und einem Programm besser zu verstehen , schauen wir uns einige Beispiele an. Das ist ein Algorithmus,
das ist in Python und das ist in Cesar
5. Problemanalyse: früheren Lektionen haben wir
das Konzept von
Algorithmus und CDO-Code eingeführt das Konzept von
Algorithmus und CDO-Code Also der Unterschied
zwischen CDO-Code und Programmierung und es
wurde betont, warum es
wichtig ist , mit CDO-Code
vertraut zu sein,
bevor man mit dem Erlernen einer Programmiersprache beginnt In diesem Kapitel werden wir
sehen, wie wir anfangen, ein Problem
zu lösen Was ist die grundlegende
Kontrollstruktur, die wir verwenden. Und welche Befehle wir verwenden. Gleichzeitig
werden wir beginnen, sowohl
einfache als auch
komplexere Probleme zu lösen einfache als auch
komplexere Probleme indem wir mit CDO-Code codieren Wie wir in
unserer ersten Lektion erwähnt haben, besteht
der Zweck der Erstellung eines
Programms darin, ein Problem zu lösen Bevor wir uns jedoch mit
den Schritten befassen , die wir ergreifen müssen, um dies zu erreichen, ist
es wichtig,
das Konzept eines
Problems als Ganzes zu verstehen . Diese Lektion hat viele
theoretische Aspekte. Wenn wir eine Definition geben würden, würden
wir sagen, dass es sich bei dem
Problem um einen schwierigen Zustand handelt ,
der gelöst werden
muss. Im Laufe
der Jahre unserer Geschichte gab es im täglichen Leben der
Menschen Probleme , die sich auf Virusbereiche
wie Physik,
Mathematik, Logik,
den Alltag usw.
beziehen können auf Virusbereiche
wie Physik,
Mathematik, Logik,
den Alltag usw.
beziehen Mathematik, Logik,
den Alltag usw. Um sie zu lösen,
ist es notwendig, alle
Erweiterungen und Dimensionen vollständig zu verstehen Dies setzt voraus, dass das Problem klar formuliert
ist. Wenn unser Kodex Terminologie unangemessen
verwendet und STAC falsch ist, kann dies zu Missverständnissen
führen Das wird uns
davon abhalten, das Problem zu lösen. Selbst wenn die mündlichen Regeln und die
STAC-Regeln befolgt werden, besteht die Möglichkeit, dass das Problem
missverstanden Schauen wir uns ein Beispiel an. Zwei Freunde Ben und Michael
telefonieren an einem
Freitagmorgen, um
einen Termin für einen Spaziergang zu vereinbaren. Ben fragt,
kannst du es am
Samstagmorgen oder am
Nachmittag um sechs Uhr schaffen? Michael antwortete, dass der
Nachmittag um sechs Uhr besser ist. Die beiden Freunde trafen
sich jedoch nicht mit Ben, der an diesem Nachmittag auf
Michael wartete, aber Michael
tauchte nicht zu dem Treffen auf. Der Termin am Nachmittag um
sechs Uhr kann doppelt
gedolmetscht werden. Ben meinte den Nachmittag
desselben Tages, Freitag um sechs Uhr,
Michael meinte Sonntagnachmittag um sechs Uhr. Daher wissen wir,
wie wichtig es für die richtige Formulierung
eines gelösten Problems ist. Nachdem wir also
das Problem, das wir lösen wollen,
richtig formuliert haben, müssen wir mit der Struktur der Aufzeichnungen fortfahren
. Hier sehen wir
die Definition
des Begriffs Struktur eines Problems. Wir. Wenn wir ein sehr
schwieriges Problem haben, zerlegen
wir es in
Teilprobleme und dann
unterteilen wir diese Teilprobleme in
kleinere Probleme und so weiter. Bis zur Lösung der
Probleme ist es offensichtlich. Durch die Lösung dieser
einfachen Probleme haben
wir auch
unser ursprüngliches Problem gelöst. Eine weitere wichtige
Voraussetzung für die Lösung eines Problems besteht darin, seine Anforderungen
ermitteln zu können. Mit anderen Worten, die
Daten, das, was wir wissen, und die Ziele, nach
denen wir suchen,
müssen identifiziert werden. Bei einigen Problemen ist dies
leicht zu verstehen, aber es gibt auch
Probleme, bei denen wir die Daten und Ziele
anhand der Beschreibung
des Problems
ermitteln müssen die Daten und Ziele
anhand der Beschreibung
des Problems
ermitteln . Lassen
Sie uns zusammenfassend die
Schritte zur Lösung eines
Problems anhand eines Diagramms betrachten. Zunächst müssen wir
das Problem vollständig verstehen und
seine Daten und Ziele identifizieren. Als Nächstes müssen wir das Problem
analysieren. Dazu müssen wir das Problem in
Unterprobleme
unterteilen , bis ihre
Lösungen gefunden sind. Schließlich werden wir zur Lösung
des ursprünglichen Problems gelangen , indem wir diese Teilprobleme
lösen.
6. Kontrollstrukturen: Einführung: In den vorherigen Abschnitten
haben wir besprochen, was ein in CDO-Code
geschriebenes Programm ist, Zweck es hat und wie es
uns hilft, uns auf die Programmierung vorzubereiten Wir haben uns auch mit dem befasst,
was wir
als Problem definieren , und den Stand
der Problemlösung Basierend auf diesem Wissen
und um vom theoretischen
Konzept
der Algorithmen
zur
praktischen Anwendung überzugehen theoretischen
Konzept
der Algorithmen , werden
wir unseren
Online-Interpreter verwenden Dies wird uns helfen, CDO-Code in
einer hypothetischen
Programmiersprache zu
schreiben , indem wir unsere eigenen Programme erstellen . Es ist wichtig klarzustellen,
dass ein Programm normalerweise in einer Programmiersprache und nicht in CDO-Code
geschrieben wird . Der Online-Interpreter wird zu
Bildungszwecken verwendet
und hilft uns, uns mit der Programmierung von
Gedankenprozessen
vertraut zu machen zu schreiben, müssen wir nur noch ein Programm
zu schreiben, müssen wir nur noch das Vokabular
der
Programmiersprache lernen Vokabular
der
Programmiersprache wir
interessiert sind, wie Python. Jetzt können wir uns mit
den praktischen Aspekten
und Kontrollstrukturen befassen . Diese Strukturen sind wie Tools, mit denen
der Programmierer
entscheiden kann, welche Teile
des Codes wann und wie oft
ausgeführt werden wann und wie oft
ausgeführt Wenn wir diese Struktur
zusammen mit anderen, die
wir später behandeln werden, gut lernen zusammen mit anderen, die
wir später behandeln werden, können
wir
jedes Programm in jeder beliebigen
Programmiersprache schreiben jedes Programm in jeder beliebigen
Programmiersprache Der Hauptunterschied ist der Wortschatz dieser Sprache. Zum besseren Verständnis werden
in diesem Fall
Beispiele angeführt, die wir
Schritt für Schritt gemeinsam lösen werden. Schauen wir uns an, was diese
Algorithmusstruktur oder Kontrollstruktur
im DO-Code ist. Sequenzstruktur,
Auswahlstruktur, Mehrfachauswahlstruktur,
verschachtelte Prozeduren und
Wiederholungsstruktur oder Schleifen
7. Kontrollstrukturen: Sequenzstruktur: Für den Fall,
dass wir ein einfaches Problem
haben , das in einer
bestimmten Reihenfolge gelöst wird, verwenden
wir die Sequenzstruktur. Erstellen Sie beispielsweise ein Programm,
das zwei Zahlen liest, sie
addiert und die
Summe auf dem PC-Bildschirm ausgibt. Schauen wir uns an dieser Stelle an, was unser
Hauptprogramm macht. Zunächst wird auf
dem Benutzerbildschirm eine Meldung angezeigt, in der der Benutzer
aufgefordert wird, zwei Zahlen einzugeben. Dann liest es diese
beiden Zahlen und speichert sie in den beiden
Variablen A und B. Danach werden
sie addiert und
das Ergebnis einer dritten
Variablen C zugewiesen . Schließlich wird
auf dem Benutzerbildschirm eine Meldung angezeigt, gefolgt vom Ergebnis
der Addition Bevor
wir mit der Erläuterung der
in diesem Beispiel verwendeten Befehle fortfahren, müssen
wir
einige Konzepte klarstellen Der Begriff Befehl
bezieht sich auf jedes Wort im CDO-Code, das einer bestimmten Aktion
entspricht Jeder Befehl ist in
jeder Programmiersprache vordefiniert, und wir verwenden ihn so, wie er ist, um
beispielsweise
das Ergebnis des
Programms in unserem CDO-Code Wir verwenden den Befehl publish und nicht so me, print, et cetera Andere nützliche Konzepte sind
die folgenden Konstanten. Mit diesem Begriff beziehen wir uns
auf vordefinierte Werte , die
während der
Ausführung eines Programms unverändert bleiben während der
Ausführung eines Programms Variablen. Der Variablen
wird ein Wert zugewiesen,
der
sich während der
Ausführung des Programms ändern kann . Abhängig von der Art
des Werts, den sie annehmen können, werden
Variablen
in Indexer,
reelle Zahlen, Zeichen und logische Werte unterteilt reelle Zahlen, Zeichen und Operatoren sind bekannte Symbole verschiedene Aktionen ausgeführt
werden Operatoren werden
in numerische, logische Operatoren, auch bekannt als Ed oder
In unserem Sydo-Code werden mit als auch als entweder und
als Vergleich
ausgedrückt Ein Ausdruck ist eine
Folge von Operanten, die konstant sind, und
Variablen sind ebenfalls Ein Ausdruck kann aus
nur einer Variablen oder Konstanten bestehen , bis hin zu einer komplexen mathematischen
Darstellung Wir verwenden eine
Zuweisungsanweisung ,
um das Ergebnis eines
Ausdrucks in eine Variable umzuwandeln. Lassen Sie uns nun das Programm, das
wir zuvor geschrieben haben, im Detail analysieren . Als erstes müssen wir die Daten in das Programm
eingeben. Um dies zu erreichen, bitten
wir
den Benutzer mithilfe des veröffentlichten Befehls, uns die Daten zur
Verfügung zu stellen. An dieser Stelle sei
erwähnt, dass, wann immer
wir von Drucken, Anzeigen oder Ausgabe sprechen, es dasselbe bedeutet, nämlich dem Benutzer etwas zu
zeigen. Dies erfolgt mit dem Befehl
published. Als Nächstes verwenden wir das Wort abrufen und den Namen einer
oder mehrerer Variablen. A oder B usw. Mit diesem Befehl
erhält die Variable A einen numerischen
Wert als Inhalt Wenn der Benutzer beispielsweise
zwei und vier eingibt, ist
Variable A zwei bzw.
Variable B vier. Wenn wir im CDO-Code
den Befehl retrieve verwenden, ist
er gleichbedeutend
mit Lesen oder Eingabe und bedeutet, etwas
von der Tastatur zu lesen Darauf folgt eine Zuweisungsanweisung
, deren Zweck es ist , Operationen auszuführen und das Ergebnis einer
Variablen
zuzuweisen In unserem Beispiel hat sie
diese Form, kann aber im Allgemeinen als Ausdruck einer
variablen
Zuweisungsanweisung ausgedrückt werden variablen
Zuweisungsanweisung Immer links haben wir die Variable auf
der rechten Seite,
den Ausdruck. Das bedeutet,
das Ergebnis
der Addition A und B
in der Variablen C zu speichern . Schließlich gibt es noch den veröffentlichten Befehl, der das Ergebnis des Programms auf dem PC-Bildschirm ausgibt. Das Programm, das wir
gerade beschrieben haben, erfüllt alle Kriterien, die wir bereits erwähnt haben von
Anfang an
alle Kriterien, die wir bereits erwähnt haben. Der Befehl retrieve A
and B dient als Eingabe und der Befehl publish C dient als Ausgabe,
was das Ergebnis ist Darüber hinaus zeichnet es sich durch Bestimmtheit,
definierte Befehle,
Endlichkeit, eine bestimmte
Anzahl von Befehlen
und Effektivität sowie klare
und einfache Befehle und Effektivität sowie klare
und einfache Dieses Problem mag sehr einfach gewesen
sein. Wenn wir jedoch noch ein
paar Befehle hinzufügen z. B. den Programmnamen, die Variablen, die wir verwenden werden, die Start- und
Endanweisungen des Programms. Wir werden ein vollständiges
Programm haben, das in unserem
Online-CDO-Codeinterpreter
ausgeführt wird in unserem
Online-CDO-Codeinterpreter
ausgeführt Wir werden
den Schwierigkeitsgrad schrittweise erhöhen , bis wir die Sortierungskovarien
erreichen. Schauen wir uns nun
ein anderes Beispiel an, ein etwas komplexeres Und dieses Mal wollen wir
es Schritt für Schritt gemeinsam lösen. Das Problem, das wir haben,
ist wie folgt. In einem Kindertheater kosten die
Tickets 20$ für Erwachsene
und 15$ für Wir müssen ein
Programm schreiben, das die Anzahl der
Erwachsenen und Kinder , die die Aufführung besucht haben, berücksichtigt und die
Gesamteinnahmen des Theaters
anzeigt das Problem zu lösen, müssen
wir zunächst herausfinden, welche Daten wir haben und nach welchen Daten wir gefragt
werden. Den uns vorliegenden Daten zufolge kostet
das Ticket für Erwachsene 20$ und das Ticket
für Kinder 15 Außerdem werden wir den Benutzer
des Programms bitten,
uns mitzuteilen, wie viele Erwachsene und
wie viele Kinder das Theater
besucht haben Ziel ist es,
die
Gesamteinnahmen des Theaters
aus der Aufführung zu ermitteln. Bevor wir die Befehle schreiben
, die das Problem beheben, wollen wir uns die Befehle ansehen, von denen wir
gesagt haben , dass sie
für alle Programme notwendig sind. Zuerst geben wir unserem Programm einen
Namen und verwenden den Befehl Programmname. Dieser Name muss immer mit
einem Buchstaben beginnen und kann
Zahlen oder einen Unterstrich enthalten Aber keine Symbole oder
andere Satzzeichen. Als Nächstes müssen wir die Variablen
definieren. Um anzuzeigen, dass Variablen als Nächstes
kommen, deklarieren
wir den
Start von Variablen mit einem Befehl, lokalen Variablen. Und darunter deklarieren wir die Variablen mit den
entsprechenden Befehlen. Um beispielsweise Desert-Variablen zu deklarieren
, verwenden
wir local deserve. Beachten Sie dabei, dass nach den Kategoriebefehlen
für
die Variablen der Doppelpunkt C folgt, wohingegen der Befehl local variables keine Spalte enthält . Da wir uns am
Anfang des Programms befinden, wissen
wir noch nicht,
welche Integer-Variablen wir in unserem Programm benötigen werden. Also werden wir den
Befehl local integers schreiben und sie
ausfüllen, nachdem wir den CDO-Code
für das Hauptprogramm
fertiggestellt haben den CDO-Code
für das Hauptprogramm
fertiggestellt Nach der Variablendeklaration fahren
wir mit dem Befehl
start operation fort
, der den Start des STO-Codes für
das Hauptprogramm angibt STO-Codes für
das Hauptprogramm Lassen Sie uns nun den
Haupt-Cado-Code schreiben und unser anfängliches Problem
in Unterprobleme
aufteilen Als Erstes
müssen wir herausfinden wie viele Erwachsene und
wie viele Kinder das Theater
besucht haben In dem Programm
würden wir also Folgendes schreiben. Veröffentlichen Sie, sagen Sie mir, wie viele Erwachsene und wie viele Kinder das Theater
besucht haben, Retrieve Adults, Coma-Kinder. Das andere Problem, das wir lösen
müssen, ist die
Berechnung der
Gesamteinnahmen dafür. Wir müssen nur zuerst
die Gesamteinnahmen aus
Erwachsenentickets ermitteln , indem wir
die Anzahl der Erwachsenen
mit dem Ticketcode multiplizieren die Anzahl der Erwachsenen
mit dem Ticketcode Dann werden wir dasselbe
für Kindertickets tun. Schließlich werden wir
die Einnahmen aus
Erwachsenentickets zu den Einnahmen aus
C-Kindertickets addieren , um
den Gesamtumsatz zu ermitteln. Jetzt müssen wir dem Benutzer nur noch das Ergebnis
anzeigen,
das wir gefunden haben. Also werden wir den
folgenden Befehl hinzufügen. Veröffentlichen Sie, dass die gesamten
Theatereinnahmen Koma sind, Gesamteinnahmen, Koma-Dollar. Der letzte Befehl, den wir hinzufügen
werden, ist Ed-Programm, was das
Ende des Programms angibt. Wir vergessen nicht, dass
wir, um zu funktionieren, die Variablen deklarieren müssen, die
wir zu Beginn
des Programms verwendet haben. Lokaler Indeger,
Erwachsene, Koma-Kinder, Umsatz Erwachsene, Koma-Einnahmen
Kinder, Koma, Gesamtumsatz Dies sind alle
Befehle, die wir verwendet haben, und jetzt sehen wir uns ein Beispiel an, um zu
überprüfen, ob das von
uns geschriebene Programm funktioniert Wenn die Erwachsenen beispielsweise zehn und die Kinder 20 Jahre alt
wären, würde
das Programm
den Betrag von 500$ anzeigen
8. Kontrollstrukturen: Auswahlstruktur (bedingt): Wenn unser Problem eine Wahl
beinhaltet, müssen
wir eine
Auswahlstruktur verwenden. Erstellen Sie beispielsweise
ein Programm, das nach Wetter
entscheidet, ob wir eine Reise machen oder nicht je
nach Wetter
entscheidet, ob wir eine Reise machen oder nicht. Wir erstellen ein Programm
und bitten den Benutzer , uns mitzuteilen, wie das
Wetter draußen ist. Wenn die Antwort lautet, dass
es stark regnet, sollte uns
das Programm sagen
, dass wir zu Hause bleiben werden Andernfalls werden wir einen Ausflug machen. In diesem Fall
folgen wir keinen bestimmten Schritten, aber es besteht die Möglichkeit je
nach Wetter draußen
eine Wahl zu treffen. Im Allgemeinen hilft uns die
Auswahlstruktur dabei,
eine Entscheidung zu treffen, je nachdem , ob die Bedingung wahr oder falsch
ist. Die allgemeine Form des
Auswahlbefehls lautet wie folgt. Wenn die Bedingung wahr ist,
dann führe Befehle aus, andernfalls Befehle und
D. Sehen wir uns ein Beispiel an. Wir wollen ein Programm erstellen, das bestimmt, ob eine
Ganzzahl negativ ist oder ob sie
größer oder gleich Null ist. In diesem Programm bitten wir den
Benutzer, eine Ganzzahl einzugeben. Dann prüfen wir zunächst, ob die
Zahl kleiner als Null ist oder in einem anderen Fall, ob sie größer
oder gleich Null ist, und zeigen dem Benutzer die entsprechende
Meldung an. Lassen Sie uns nun Schritt für
Schritt ein etwas
komplexeres Problem lösen . Wir wollen ein Programm schreiben
, das zwei Indexer akzeptiert. Wenn die erste Zahl
größer als die zweite ist, wird
ihre Summe angezeigt Andernfalls wird ihre Multiplikation
angezeigt. Zuerst schreiben wir die Befehle
in den Deklarationsbereich und vervollständigen sie. Am Ende müssen wir nun
den Benutzer des Programms bitten , die Indexer bereitzustellen Dann verwenden wir den
Befehl retrieve, um die Zahlen in die
beiden Variablen A und B
einzugeben. Als Nächstes müssen wir die Bedingung
überprüfen, ob die erste Zahl
größer als die zweite ist Daher verwenden wir den
Auswahlbefehl, falls er wahr ist. Falls die erste Zahl größer als
die zweite
ist, geben
wir den Befehl, die beiden Zahlen
zu addieren. Wir werden die Summe in eine neue Variable mit dem Namen C eingeben. Wenn
diese Bedingung nicht erfüllt ist, also keine andere Bedingung, multiplizieren
wir die Zahlen und die Auswahlstruktur
ist abgeschlossen. Am Ende zeigen wir
dem Benutzer den Inhalt
der Variablen C und das
Programm ist abgeschlossen. Wir haben uns dafür entschieden, den
veröffentlichten Befehl
hinter Ende I zu platzieren , um das Ergebnis
anzuzeigen, aber wir hätten hier und hier etwas
hinzufügen können. Der einzige Unterschied besteht in diesem Fall darin, dass wir zweimal veröffentlicht
schreiben. Wir dürfen nicht vergessen, dass
wir
für unsere programmierte Arbeit die Variablen zu
Beginn des Programms deklarieren müssen . Lokale Inds A, B, C. Schauen wir mal, ob das Programm, das
wir gerade geschrieben haben, funktioniert Wie wir hier sehen können, fügt
das Programm sie hinzu, wenn die erste Zahl
größer als
die zweite ist die erste Zahl
größer als
die Wenn die
zweite jedoch größer ist, multipliziert
das Programm sie.
9. Kontrollstrukturen: Mehrfachauswahlstruktur: Mehrfachauswahlmöglichkeiten sind etwas
komplexer als die
Auswahlstruktur, da sie für Probleme gelten, bei denen unterschiedliche Entscheidungen getroffen werden können je nach Wert
eines Ausdrucks
unterschiedliche Entscheidungen getroffen werden können. Im Allgemeinen sprechen wir von
Mehrfachauswahlmöglichkeiten , wenn wir mehr als zwei Fälle
haben. Die allgemeine Form
des Mehrfachauswahlbefehls lautet wie folgt. Bedingung wahr ist, dann
führe ich Befehle oder Befehle aus,
andernfalls, wenn Bedingung, dann
Befehl oder Befehle. Ansonsten Befehl oder Befehle,
und wenn, schauen wir uns
ein Beispiel an, das uns
helfen wird, die Logik
der Multiple-Choice-Methode zu verstehen. Wir möchten ein
Programm schreiben, in dem der Benutzer eine
Bewertung für einen Dienst mit 0 bis 10 abgibt und das Programm
dem Benutzer die entsprechende
Meldung anzeigt dem Benutzer die entsprechende
Meldung Wenn die Bewertung 0-3 ist, wird eine schlechte Bewertung angezeigt Wenn es 4-6 ist, wird es moderat
angezeigt. Und wenn es 7-10 ist, wird
es sehr gut angezeigt. In diesem speziellen Beispiel
haben wir drei Fälle genommen. Wenn die Bewertung zwischen 0 und
3 liegt, wird eine schlechte Bewertung angezeigt Wenn sie 4 bis 6 ist, moderate
Bewertung
angezeigt, andernfalls eine sehr gute Bewertung. Andernfalls sind
alle anderen Optionen enthalten, und wenn jemand
eine negative Zahl eingibt, wird
sie dort angezeigt. Um genauer zu sein, sollten wir
sagen, ob wahr Null bis Drei, LF vier bis sechs, LC sieben bis zehn. Falls wir
berücksichtigen möchten, dass jemand
eine negative Zahl eingibt , und das
Programm
nicht hängen bleibt, können
wir sagen, ob wahr
Null bis Drei, LC vier bis sechs, LC sieben bis zehn, andernfalls ungültig
angezeigt wird. Schauen wir uns an, wie wir das Programm
schreiben. Sobald
dieses Programm ausgeführt wird,
wird es im Allgemeinen Folgendes tun. Mit dem veröffentlichten Befehl werden die Methoden angezeigt und dem gegeben Benutzer die Bewertung
des Dienstes auf
einer Skala von 0 bis 10 Er wartet, bis er eine Zahl von
der Tastatur
liest , und weist
sie der Variablen A zu. Er beginnt,
die Prüfungen mit
dem Befehl true durchzuführen die Prüfungen mit
dem Befehl true bis er die
erste wahre Bedingung findet und führt die darin
enthaltenen Befehle Dann geht es zu den Befehlen unterhalb des NT, falls sie existieren. Andernfalls stoppt das Programm dort oder zeigt die
entsprechende Meldung an. An dieser Stelle ist es
wichtig,
den Unterschied zwischen sowohl
als auch zwischen beidem und beidem hervorzuheben . In unserem Code haben wir sowohl
als auch und keins
von beidem hinzugefügt da beide Bedingungen , da beide Bedingungen
gleichzeitig erfüllt sein
müssen. Wir würden beide verwenden,
wenn die Befehle ausgeführt werden,
wenn mindestens eine
Bedingung erfüllt ist . Stellen Sie sich zum Beispiel ein Programm vor,
das die Note
einer schriftlichen Prüfung von zwei Prüfern auf einer Skala von 1 bis 1 zu einem
Quadranten vorliest einer schriftlichen Prüfung von zwei Prüfern auf einer Skala von 1 bis 1 zu einem
Quadranten Die Gesamtnote ergibt sich aus
der Durchschnittsnote
der beiden Prüfer Wenn der Unterschied
in der Note
größer oder gleich 15 ist , wird eine
Meldung angezeigt, dass ein dritter Prüfer Prüfung
wiederholen muss,
und das Programm Das Programm, das wir schreiben sollten, ist dieses Programm mit dem Namen Prüfung
eins,
lokale Variablen , lokale als, A Koma, Abschlussnote , den Betrieb
starten, veröffentlichen, die beiden Noten
geben ein Komma
abrufen B. Falls wahr, entweder dies, dann veröffentlichen Sie einen dritten
Prüfer wird ebenfalls benötigt. Andernfalls ist die Gesamtnote
a plus b geteilt durch zwei. Publizieren Sie die
Abschlussnote als Abschlussnote und falls das Programm. Ein weiteres Beispiel, das die Form
eines Programms mit
Multiple-Choice-Verfahren detailliert zeigt eines Programms mit
Multiple-Choice-Verfahren ,
ist das Folgende. Der Kommunikationsanbieter
wendet bei
Auslandsgesprächen von 0 bis 3
Minuten 1$ pro Minute, für Auslandsgesprächen von 0 bis 3
Minuten 1$ pro Minute, nächsten drei bis 10 Minuten
0,80$ pro Minute und alle verbleibenden Minuten
0,50$ Wir wollen ein Programm schreiben
, die Minuten eines Anrufs mitteilt und die Gebühren dafür
anzeigt Wir beginnen unser Programm mit
einem Deklarationsabschnitt, in
dem
wir in diesem speziellen Fall echte Variablen und keine
Indexer wie in vorherigen Beispielen verwenden,
weil jemand die Geschwindigkeitsminuten
in Dezimalform eingeben
könnte Als Nächstes bitten wir den Benutzer, die
Dauer des Anrufs anzugeben Dies erfolgt mit dem veröffentlichten Befehl zur
Anzeige der Nachricht. Dann
liest das Programm die Nummer von der Tastatur und weist sie
der Variablen Dauer zu . Veröffentlichen, Anrufdauer
in Minuten angeben , Dauer abrufen. Als Nächstes behandeln wir
den Fall, dass die Minuten innerhalb der
Grenzen der ersten Diagramme liegen. Wir werden also einfach die Minuten
mit
den Diagrammen pro Minute multiplizieren. Dann fahren wir
mit dem Fall fort die Dauer über
drei bis 10 Minuten liegt. Das Ergebnis ist die Summe
der Gebühr für die ersten 3 Minuten plus der verbleibenden Minuten
multipliziert mit der entsprechenden Gebühr Das heißt, für die
ersten 3 Minuten multiplizieren
wir mit 1$ und für die Dauer abzüglich
der ersten 3 Minuten multiplizieren
wir mit 0,80 Wenn die Dauer des
Colls als Nächstes über 10 Minuten liegt, machen
wir etwas Ähnliches Wir berechnen die Gebühr
für die ersten 3 Minuten. Wenn Sie die Charts für
die nächsten 7 Minuten hinzufügen, werden alle verbleibenden Minuten mit 0,50$ multipliziert Dann werden wir auch
den Fall berücksichtigen , dass jemand eine negative
Zahl eingibt Am Ende
zeigen wir die Ausgabe, also die Diagramme des Aufrufs, und schließen das Programm mit
dem Befehl end program. Wir dürfen nicht vergessen, dass
wir die Variablen deklarieren müssen, die
wir zu Beginn
des Programms verwendet
haben, damit unser Programm funktioniert Variablen deklarieren müssen, die
wir zu . Lokal als Kommadiagramme mit Dauer. Lassen Sie uns jetzt das Programm ausführen. Angenommen, die
Anrufdauer beträgt 11 Minuten. Das Programm gibt
den dritten Fall und gibt das richtige Ergebnis aus.
10. Kontrollstrukturen: Verschachtelte Verfahren: Verschachtelte Prozeduren beziehen sich auf die Möglichkeit,
einen Fall innerhalb eines Falls zu haben Hier ist ein Beispiel.
Erstellen Sie ein Programm , das die Größe und
Haarfarbe des Benutzers liest. Wenn die Körpergröße größer als
6,2 ist und der Benutzer einen blonden Kopf hat, wird ein großer und blonder Kopf angezeigt. Wenn die Körpergröße unter 6,2 liegt
und der Benutzer blond
ist, werden eine durchschnittliche
Körpergröße und ein blonder Kopf angezeigt. In diesem Fall haben wir
zwei if-Anweisungen. Eine If-Angabe ist in einer anderen verschachtelt. Wir müssen also
ein Programm schreiben , das ungefähr vier Fälle
hat Wenn der Benutzer groß
und blond ist,
wenn der Benutzer klein und dunkelhäutig ist, wenn der Benutzer durchschnittlich
groß und angestellt ist,
und wenn der Benutzer durchschnittlich
groß und dunkelhäutig ist, schauen wir uns jetzt an, wie wir dieses Programm schreiben
würden Wir geben einen Namen
mit dem Programmnamen an. Wir starten Variablen
mit lokalen Variablen. Starten Sie den Betrieb. Veröffentlichen Sie die Höhe in Passungen, geben Sie die Höhe an,
rufen Sie die Höhe ab. Veröffentlichen Sie, geben Sie der Haarfarbe
blondes Haar oder dunkles Haar. Höhe abrufen. Falls wahr. Eine Höhe von mehr als
6,2 ist dann der Fall. Falls wahr. Haare sind gleich blondes Haar, dann veröffentlichen Sie alle
und blutige Andernfalls veröffentlichen Sie
das Tool und den dunklen Kopf. Wir schließen die IF-Aussage
mit F. Andernfalls, stimmt
es, Haar entspricht
blondem Kopf, dann tun Sie es, veröffentlichen Sie Durchschnittsgröße und
Blutherz, andernfalls veröffentlichen Sie durchschnittliche
Größe und dunklen Kopf
und wenn, und beenden Sie das Programm Wir fügen hier lokale Ls-Höhe und
lokale Zeichen hinzu. Der einzige Unterschied besteht
darin, dass wir ein Ende haben ,
wenn das das
Ende des verschachtelten Elements markiert, falls es wahr ist, und eines für
das externe Es ist wichtig zu beachten
, dass
wir in diesem Beispiel keine
Fälle berücksichtigen, in denen jemand etwas anderes
eingibt als das, wonach wir gefragt haben Schauen wir uns ein Beispiel an
, das wir gemeinsam lösen werden: ein Programm
schreiben, das
die Noten null bis
zehn eines Sportschülers
in
zwei Sportarten vorliest die Noten null bis
zehn eines Sportschülers in
zwei Sportarten vorliest und anzeigt
, welche Noten er bestanden hat. Wir beginnen unser Programm mit
dem Deklarationsabschnitt, in
dem
wir in diesem speziellen Fall echte Variablen haben, weil jemand die
Noten in Dezimalform eingeben könnte. Zunächst fragen
wir den Benutzer mit dem Befehl
published nach den beiden Noten. Dann liest das
Programm sie und weist sie den Variablen
A bzw. B zu. Veröffentlichen Sie, geben Sie die Note für die erste Sportart auf einer Skala von 0-10 ein, rufen Sie A ab, veröffentlichen
Sie, geben Sie die Note für die zweite Sportart auf einer
Skala von 0-10 ein, rufen Sie B ab. Dann müssen wir die
Bedingungen für jeden Fall überprüfen Die erste Bedingung, die wir überprüfen
werden, ist, ob der Student das erste
und auch das zweite Fach bestanden hat In diesem Fall
wird dem Benutzer eine
Glückwunschnachricht angezeigt Als Nächstes wird der LC nur
ausgeführt , wenn der zweite
Betreff nicht übergeben wurde Wir wissen zwar von
außen , dass das erste
Subjekt bestanden wurde. In diesem Fall zeigen
wir an, dass der Student nur
das erste Fach bestanden hat. Andernfalls veröffentlichen wir einen ungültigen Eintrag für das zweite Fach, und wenn, dann schließen wir das nächste es größer
oder gleich fünf ist, sowie mit dem Befehl
end I kleiner oder gleich zehn Als Nächstes gehen wir zu
dem Fall über, dass der Student das erste Fach nicht
bestanden und auch das zweite Wir werden anzeigen, dass der Student kein Fach bestanden hat. Mit Publizieren
bestehen Sie die beiden Fächer nicht. Wenn der Student das erste Fach nicht
bestanden hat, was wir im externen Dif einchecken,
aber
das zweite
Fach, das mit viz geprüft wurde, bestanden hat, wird angezeigt, dass der Student nur
das zweite Fach bestanden hat Das Programm führt
die Befehle im
anderen System Nur wenn die angegebene Zahl
außerhalb der Grenzen von Null bis Zehn liegt . Dann schließen wir das verschachtelte df und es bleibt nur noch der Fall
übrig in einer Variablen A ein falscher Wert
angegeben wird für das erste
Subjekt
in einer Variablen A ein falscher Wert
angegeben wird. Dann schließen wir das
externe Objekt, falls es wahr ist, und das Programm wird
mit dem Befehl end program abgeschlossen mit dem Befehl end program Schauen wir uns an, ob das Programm, bei dem nur um Straßen geht, wie wir hier sehen, zwei Zahlen eingeben, wobei
beide größer als fünf sind, und es wird die
entsprechende Meldung angezeigt Wenn Sie jedoch Zahlen
für die anderen Fälle eingeben, werden
Sie feststellen, dass auch die
entsprechende Meldung
angezeigt wird.
11. Kontrollstrukturen: Wiederholungsstruktur: Wenn wir
einen Schritt viele Male ausführen müssen, verwenden
wir eine Wiederholungsstruktur Zum Beispiel, wenn wir alle Ganzzahlen von
1 bis 100 anzeigen möchten alle Ganzzahlen von
1 bis 100 anzeigen Um zu vermeiden, ein Programm zu schreiben all diese Zahlen
enthält
, das groß und mühsam ist, verwenden
wir eine der drei Wiederholungsstrukturen Die Wiederholungsstrukturen
sind wie folgt. Wenn wir im Voraus wissen, wie oft
die Schleife ausgeführt werden soll, verwenden
wir die Schleifenstruktur
für Schleife I, beginnend bei Null
und endend bei drei, Publish I und Loop Sie enthält alle notwendigen
Elemente für die Schleife, d. h. den
Anfangswert der Variablen I und ihren Endwert.
Sehen wir uns ein Beispiel an. Wir wollen ein
Programm schreiben, das
alle Indexer 1-100 addiert und die Summe anzeigt Zusatz 100 zum Programmnamen,
lokale Variablen, lokale Indexer, ich summiere.
Betrieb starten. Wir initialisieren die Summe mit Null. Für Schleife I, beginnend
bei Null, also 100, ist
Summe S plus I, Schleife, veröffentliche das Programm. In diesem Beispiel wird die Variable I
in ihrer Iteration um eins erhöht, weshalb wir sie nicht in das Programm schreiben
müssen Hier sollten wir beachten
, dass die Standardschritte , die I erhöhen, eins sind Wenn wir etwas
anderes sein wollen, zum Beispiel drei, sollten
wir es mit
dem Befehl with step deklarieren. Schauen wir uns auch ein
solches Beispiel an. Wir wollen die Summe der geraden
ganzen Zahlen 1-100 finden. Das Programm, das wir schreiben werden, unterscheidet sich kaum
von dem vorherigen Der einzige Unterschied
besteht darin, dass wir hier den Schritt als drittes
Argument
hinzugefügt haben , nämlich zwei. In diesem Fall schreiben wir
den Namen der Schleife, die Variable I mit
ihrem Wertebereich
, also 2-100, und
schließlich den Wert zwei, den Schritt, um den
die Variable I
in ihrer Iteration zunimmt Die zweite
Wiederholungsstruktur sieht wie folgt aus. Solange die Bedingung erfüllt ist,
gehen Sie wie folgt vor. Befehl oder Befehlsschleife. Schauen wir uns in diesem Fall ein
Beispiel an. Wir wollen ein
Programm schreiben, in dem der Benutzer
positive Zahlen eingibt und das
Programm sie anzeigt. Das Programm wird beendet wenn der Benutzer
eine negative Zahl eingibt, und die
negative Zahl selbst wird nicht angezeigt. Rufen Sie nach dem Startvorgang x ab, solange x größer als
Null ist. Gehen Sie wie folgt vor. Veröffentlichen Sie x, rufen Sie X ab
und wiederholen Sie die Schleife, beenden Sie das Programm. In diesem Fall muss
die Variable x
entweder definiert oder über
die Tastatur
gelesen werden, bevor die Schleife beginnt muss
die Variable x
entweder definiert oder über
die . Nehmen wir an, im obigen Beispiel wird
eine negative Zahl
direkt als erste Eingabe angegeben. In diesem Fall tritt das Programm überhaupt
nicht in die Schleife und wird dort beendet. Wenn es jedoch positiv wäre, würde
es
alle Schritte unter der Schleife wiederholen , solange dies
der Fall ist. Wenn das Programm
eine negative Zahl empfängt, geht es
aufgrund
der Bedingung nicht in
die Schleife, um die negative Zahl anzuzeigen , sondern geht direkt zu den
Befehlen nach der Endschleife. In diesem speziellen Fall gibt es keine anderen Befehle, sodass das Programm dort beendet wird Die erste Loop Up
Until-Anweisung gibt an , dass die Befehle solange
ausgeführt werden , bis die
Bedingung erfüllt ist Sobald die Bedingung erfüllt ist, das Programm mit den Befehlen fort ,
die auf das Pentyl
folgen Es ist wie folgt strukturiert. Begin-Loop-Befehl oder Befehle. Bis zum Zustand. Das Programm, das wir in der
Gasstruktur gesehen haben und
das alle
positiven Zahlen anzeigt, kann mit
der Begin-Loop-Struktur entsprechend
geschrieben werden . In diesem Fall einer Schleife muss
das
Programm den Wert der
x-Variablen vor der Schleife nicht kennen. Also müssen wir den Befehl retrieve
innerhalb der Schleife abrufen und die Bedingung wird am Ende
der Iteration überprüft ,
nicht am Anfang Nehmen wir an, dass
im obigen Beispiel direkt
eine negative Zahl angegeben
ist Die Schleife beginnt mit
einem Befehl begin loop, liest die negative
Zahl und zeigt sie an. Dann wird die Bedingung
überprüft und die Schleife endet. Wenn die
Zahl jedoch positiv
ist, werden
alle Schritte unter dem Befehl
begin loop wiederholt . Diese beiden Schleifen,
der As Long Gas Loop und Start Loop,
unterscheiden sich in dreifacher Hinsicht. Damit die
Salon-Gasschleife ausgeführt werden kann, muss
die Bedingung sein, dass x größer als Null
ist, wohingegen in der Begin-Schleife x kleiner als Null sein muss. Wie wir sehen können,
sind die
beiden Bedingungen einander entgegengesetzt. In dem Fall, dass
die erste vom Benutzer
angegebene Zahl negativ war, würde
die ASLNG-Gasschleife überhaupt
nicht ausgeführt werden, während die Begin-Schleife einmal
ausgeführt würde , bevor sie beendet Daher wird die Azalng-Gasschleife möglicherweise nicht einmal ausgeführt Da die Prüfung am Anfang
der Schleife erfolgt, wird
die Anfangsschleife mindestens einmal ausgeführt Damit die Bedingung im Befehl as
long gas überprüft
werden kann, muss
die Variable x jedoch im Befehl as
long gas überprüft
werden kann, vor der Schleife
definiert werden. Während in der Anfangsschleife die Variable normalerweise innerhalb der Schleife
definiert wird. Bisher haben wir
alle Befehle besprochen, die wir
zum Schreiben eines Programms benötigen. Als Nächstes werden wir diese
Befehle verwenden, um
komplexere Probleme
mithilfe von Arrays zu lösen komplexere Probleme
mithilfe von Arrays Bitte lassen Sie mich wissen, wenn Sie
Fragen in der Diskussion haben Fragen in der Diskussion
12. Arrays: Einführung: Bisher haben wir
die grundlegenden Kontrollstrukturen untersucht, die in CDO-Code
geschrieben Es gibt jedoch
bestimmte Kategorien von Problemen, für deren Lösung
unterschiedliche Arten
von Strukturen erforderlich Lösung
unterschiedliche Arten
von Strukturen Was sind diese Strukturen? Sowohl in der Programmierung
als auch im CDO-Code große Datenmengen desselben Typs verwalten
müssen große Datenmengen desselben Typs können wir Arrays
anstelle
von Variablen verwenden,
wenn
wir In diesem Abschnitt werden wir sehen,
was wir als Array definieren.
Wann wir Arrays verwenden, welche Arten von Arrays es gibt
und wie Arrays und wie Arrays Das ist die Definition für Arrays. Aber was bedeutet das? Nehmen wir an, wir haben das folgende
Array,
das die maximale Luftfeuchtigkeit des
Tages für den vorherigen Mann enthält . Dieses Array kann wie folgt
definiert werden. Array und in Klammern. Die Werte im Bereich 0-30 für die 31 Tage
des vorherigen Mannes Das ist der Index des Arrays. Wenn wir beispielsweise
die Luftfeuchtigkeit des
vierten Tages in unserem Programm verwenden möchten , beziehen
wir uns auf das Array mit der Luftfeuchtigkeit drei, was 88 entspricht In diesem Fall ist der
Index ein Indexer, entweder konstant oder variabel und in Klammern eingeschlossen Bei Strahlen handelt es sich um Daten
desselben Typs, die numerisch,
logisch oder aus Zeichen bestehen können Für jedes Array, das
wir erstellen, müssen wir seinen Namen, seinen Typ
und die Anzahl der
Elemente, die es
enthalten soll, deklarieren und die Anzahl der
Elemente, die es
enthalten soll . Der Typ eines Arrays
kann eindimensional,
zweidimensional usw. sein eindimensional,
zweidimensional usw. und zu Beginn
des Programms deklariert werden, wie wir sehen werden Wir werden uns eindimensionale
und zweidimensionale Arrays ansehen , da unser Ziel darin besteht, Codierung
einzuführen
13. Arrays: Eindimensional: Beginnen wir mit eindimensionalen Arrays und sehen uns ein Beispiel an Nehmen wir an, wir möchten
ein Programm erstellen , das auf dem
Array basiert,
das wir zuvor gesehen haben das die maximale
Luftfeuchtigkeit des Monats enthält Wir werden ein Programm schreiben
, das die Luftfeuchtigkeit von
31 Tagen liest und
die durchschnittliche maximale
Luftfeuchtigkeit des Monats berechnet die durchschnittliche maximale
Luftfeuchtigkeit des Monats Ohne Verwendung eines Arrays würde ein
solches Programm wie folgt geschrieben
werden In diesem Fall haben wir nur
Variablen ohne Array verwendet. Wenn wir jedoch herausfinden möchten, an wie vielen Tagen die Luftfeuchtigkeit unter
dem Durchschnitt
lag , ohne den Benutzer erneut nach
den Feuchtigkeitswerten
für 31 Tage zu
fragen , müssten
wir
alle Feuchtigkeitswerte speichern alle Feuchtigkeitswerte und sie
mit dem Durchschnitt vergleichen. Wir müssten
31 verschiedene Variablen erstellen die der
Luftfeuchtigkeit von 31 Tagen
entsprechen. Daher hätte das Programm, das wir
schreiben würden , 31
Abrufbefehle. 31, wenn es sich um wahre Befehle handelt. Eine solche Lösung
mag richtig sein, ist
aber für
eine große Datenmenge nicht praktikabel. Wenn wir beispielsweise
die Feuchtigkeitswerte
eines ganzen Jahres ermitteln möchten , wird die Lösung
in diesem Fall anhand einer Fläche berechnet. In diesem Array haben die
Feuchtigkeitswerte kontinuierliche Positionen, und jedes Element
des Arrays
wird durch seinen Index identifiziert Beispielsweise entspricht die Luftfeuchtigkeit
30 dem Tag 30 und enthält den
Feuchtigkeitswert 50. Da wir nur einen Index verwendet haben
, um auf ein Element zu verweisen, ist
unser Array eindimensional. Das Programm, das wir schreiben werden,
um herauszufinden, an wie vielen Tagen die Luftfeuchtigkeit unter dem Durchschnittswert des
Monats liegt, sieht wie folgt aus. Zunächst erstellen wir
ein Array namens Feuchte und weisen
31 Positionen zu, was immer der
Größe des Arrays entspricht Es ist wichtig
, hier zu beachten , dass die Größe
des Arrays fest ist und es nicht
mehr Elemente haben darf als die
bei seiner Erstellung angegebene Größe, und auch nicht hier? In diesem speziellen Fall kann
es sich nicht
von 31 Elementen unterscheiden. Dann weisen wir der Variablen total den Wert
Null zu, und wir werden später sehen,
warum wir das tun. Als Nächstes müssen wir das Array mit
den Feuchtigkeitswerten
füllen , die
der Benutzer für diesen Tag angegeben hat. Eine Position im Array
steht für einen Tag des Monats, und jedes Element im Array ist ein Wert,
der
die Luftfeuchtigkeit darstellt. Da wir also genau wissen, wie viele Felder wir
benötigen, um das Array zu füllen, verwenden
wir immer die Iteration mit vier
Schleifen,
wobei I Werte für jeden Tag vom ersten bis zum 31. Dann zeigen wir die Meldung an, die der Benutzer
auf seinem Bildschirm sehen wird, damit er versteht,
was er eingeben muss, die Luftfeuchtigkeit für
den Tag anzugeben ,
gefolgt von der Variablen I
, der Zahl
des Wir platzieren den
Feuchtigkeitswert, den der Benutzer gerade angegeben hat, an die entsprechende
Position im Array, indem wir das
Feuchtigkeits-Array und den Index I verwenden. Da wir
die durchschnittliche Luftfeuchtigkeit
für alle Tage berechnen müssen , verwenden
wir jetzt die
Variable total, die wir zu Beginn auf
Null initialisiert haben. Am Ende der Schleife wird
diese Variable
die Summe aller
Feuchtigkeitswerte für den Monat enthalten die Summe aller
Feuchtigkeitswerte für den Monat Als Nächstes teilen wir die Summe
durch 31, um den Durchschnitt zu ermitteln. Um nun herauszufinden, an
wie vielen Tagen die Luftfeuchtigkeit unter dem
Monatsdurchschnitt lag, müssen
wir
die Daten im Ay durchrechnen. Dazu verwenden wir die Schleife
1-31, um auf die im Ay
enthaltenen Werte zuzugreifen In seiner Iteration rechnen wir
den Feuchtigkeitswert
des aktuellen Tages vom
ersten zum letzten mit
dem Monatsdurchschnitt Wenn ein Tag mit einer niedrigeren Luftfeuchtigkeit
als dem Durchschnitt gefunden wird, haben
wir einen Zähler, bei dem es sich im Wesentlichen um eine
Variable mit dem Namen Tage Dieser Zähler erhöht sich um eins. Es ist an der Zeit, dass die vorherige
Vergleichsbedingung erfüllt ist. Nachdem wir alle
Elemente im Array überprüft
haben, werden wir dem Benutzer zwei
Nachrichten anzeigen. Eine wird die Nachricht sein. die durchschnittliche Luftfeuchtigkeit
des Monats folgt der
Durchschnittswert, und der andere ist
die Meldung. die Tage mit niedrigerer
Luftfeuchtigkeit als dem Durchschnitt
folgt die Anzahl der Tage. An diesem Punkt
endet das Programm mit einem
Befehl, der das Programm beendet. Das war unser Beispiel für
eindimensionale Arrays. Schauen wir uns nun ein Beispiel
mit einem zweidimensionalen Array an
14. Arrays: Zweidimensional: Bei
zweidimensionalen Arrays verwenden
wir zwei Indizes, um ein Element zu
spezifizieren Wenn wir beispielsweise die durchschnittliche
Luftfeuchtigkeit für zehn Städte über
einen Monat
berechnen und ermitteln möchten, an
wie vielen Tagen die Luftfeuchtigkeit über
dem entsprechenden Durchschnittswert lag dem entsprechenden Durchschnittswert Das Array, das wir erstellen
würden, würde wie folgt aussehen. Dieses Array ist ein 31 mal zehn, ein zweidimensionales Array, wir haben
also 31 Feuchtigkeitswerte, aber für zehn verschiedene Städte, was insgesamt
310 Feuchtigkeitswerte bedeutet. Um die Elemente
eines zweidimensionalen Arrays zu definieren, verwenden
wir zwei Indizes
in der Form Array, R Komma C. Der erste entspricht
den Zeilen des Arrays und der zweite den Spalten, C R steht für Zeilen zum Zeitpunkt der Definition des Arrays und den
Zeilenindex während der Achse C steht für Spalten zum Zeitpunkt
der Definition des Arrays und für
den
Spaltenindex während der Achse Im
vorherigen Array hat
das Element Feuchte
31 beispielsweise den Wert 50. Welchen Wert hätte das
Element Feuchte 210? Die richtige Antwort lautet 73. Um das vorherige Problem zu lösen, würden
wir das
folgende Programm schreiben. Die Logik ist dieselbe wie
im vorherigen Beispiel, wo wir ein
eindimensionales Array hatten. Aber hier besteht der Unterschied
darin, dass
wir zusätzlich
zur Variablen I auch die Variable j haben. Schauen wir uns an, wie wir
das Array für nur einen
Tag für alle zehn Städte erstellen würden . Für Loop, beginnend bei
eins und endend bei zehn. Drücken Sie, geben Sie die Luftfeuchtigkeit für die Stadt J ein, rufen Sie die
Luftfeuchtigkeit ab und wiederholen Sie die Schleife. Jetzt ist es einfacher
zu erkennen, wie wir
das mit einem zweidimensionalen
Array oder 31 Tagen machen würden . für Loop, beginnend bei
eins und endend 31, für Loop, beginnend bei eins
und endend zehn, Publish, Geben Sie für Loop, beginnend bei
eins und endend 31,
für Loop, beginnend bei eins
und endend zehn, Publish, die Luftfeuchtigkeit
für die Stadt J,
den Tag I, an. Ruft die Luftfeuchtigkeit
I auf, Endschleife und Endschleife. Im Wesentlichen haben wir eine weitere Schleife
für die 31 Tage des Monats
hinzugefügt , die die vorherige Schleife enthalten
wird der
die
Feuchtigkeitswerte der einzelnen Städte berechnet wurden. Außerdem bezieht sich das I, das wir
in den Befehlen veröffentlicht und
abgerufen hinzugefügt haben , auf die Indizes des
zweidimensionalen Ry. Mal sehen, wie dieses Array in der Praxis gefüllt werden
würde. Anfänglich treten wir in die
Schleife ein, wobei I gleich eins ist. Das ist für den ersten Tag, und direkt in der
Schleife ist j gleich eins, die Luftfeuchtigkeit für die
erste Stadt wird hinzugefügt Dann wird j zu zwei während wir immer noch bei I
gleich eins sind und so weiter Wenn also j gleich zehn ist, haben
wir für den ersten Tag die Luftfeuchtigkeitswerte für die zehn Städte Die J-Schleife wird dann enden. Ich werde zwei, und J nimmt wieder die Werte 1—10 an, bis die Werte für den
zweiten Tag abgeschlossen sind Das wird
so lange weitergehen, bis I gleich 31 und j gleich Zehn An diesem Punkt werde ich auch die äußere
Schleife beenden An diesem Punkt wird der mit den Daten
gefüllt, die wir wollen. Lassen Sie uns nun sehen, wie Sie die durchschnittliche Luftfeuchtigkeit
für jede Stadt ermitteln können, indem auf das Array
verweisen
und die
darin bereits enthaltenen Daten verwenden. Da wir
das Array nach Stadt lesen wollen, bedeutet das, dass wir die Daten vertikal nach Städten
lesen müssen . Um dies zu erreichen, wird diesmal
die äußere Schleife J sein und die innere Schleife I,
für Schleife, beginnend bei
eins und endend zehn, für Schleife, beginnend bei
eins und endend eins. Zunächst benötigen wir eine
Variable namens total , die die Summe
aller Werte für eine Stadt enthält. Basierend auf dieser Summe
werden wir den Durchschnitt
für jede Stadt ermitteln. Und bevor wir
zur nächsten Stadt übergehen, müssen
wir diese Variable zurücksetzen. Für Loop, beginnend bei
eins und endend bei zehn. Wir initialisieren total mit Null. Für Schleife I, beginnend
bei eins und endend 31. Die Summe ergibt sich aus dem
vorherigen Gesamtwert plus Feuchte I. Wir schließen
den Kreislauf, und der Durchschnitt ist die
Summe geteilt durch 31. Um den Durchschnitt
für jede Stadt zu speichern, erstellen
wir ein
eindimensionales Array mit
dem Durchschnitt jeder
Stadt, der als Durchschnitt bezeichnet wird. Zu diesem Zeitpunkt haben wir die Durchschnittsmatrix
gefüllt, die den
Durchschnitt für jede Stadt enthält. Wir wollen nun das Array
durchsuchen, um herauszufinden, an wie vielen Tagen die Luftfeuchtigkeit über dem Durchschnitt der Stadt lag. Wir werden das
Array vertikal untersuchen und die Luftfeuchtigkeit an
diesem Tag mit dem Durchschnitt der Stadt
vergleichen . An den Tagen, an denen die Luftfeuchtigkeit über dem Durchschnitt liegt, werden
unsere Zähltage zunehmen. Bevor die Schleife für
die erste Stadt endet, zeigen
wir dem Benutzer die durchschnittliche
Luftfeuchtigkeit der Stadt und die Tage , an
denen die Luftfeuchtigkeit
über dem Durchschnitt lag . Dann wird diese Schleife
für die übrigen Städte wiederholt, wo es an der Zeit ist, dass unsere
Zählertage zurückgesetzt werden. Danach
wird das Programm abgeschlossen sein. Wie wir gesehen haben,
besteht der einzige
Unterschied zwischen eindimensionalen zweidimensionalen Arrays eindimensionalen zweidimensionalen Arrays in der Anzahl der verwendeten Würfel, also R für eindimensionale
und R für zweidimensionale Arrays üblich Um ein eindimensionales
Array zu füllen, verwenden wir eine Schleife. Für
zweidimensionale Arrays benötigen
wir dagegen eine Standard-Schleife Bisher haben wir gesehen,
wie man ein Array deklariert, wie man das Array mit Daten füllt
und wie man ein Array durchsucht, um Berechnungen durchzuführen Jetzt werden wir uns mit
etwas Schwierigerem befassen
als dem, was wir bisher gesehen haben, nämlich dem Sortieren eines Arrays.
15. Arrays: Sortieren: Sortieren eines Arrays ist eine sehr
wichtige Operation, der die
Daten eines Arrays
in aufsteigender oder
absteigender Reihenfolge angeordnet in aufsteigender oder
absteigender Reihenfolge Gleichzeitig ist es
eine Gelegenheit, sich ein anspruchsvolleres Beispiel
anzusehen als das, was wir bisher gesehen haben Sehen wir uns nun ein Beispiel dafür an ,
wie ein Array
in aufsteigender Reihenfolge sortiert Wir haben dieses Array.
Neun, fünf, sieben und zwei, und wir
wollen es in
einer festgelegten Reihenfolge sortieren , sodass
es so aussieht. Schauen wir uns an, wie wir
über die Erstellung dieses Programms denken würden. Anfänglich wissen wir, dass es sich bei den
Array-Elementen um vier handelt. Wir benötigen eine Schleife, um
die Zahl zwei an den
Anfang des Arrays zu verschieben . Dazu vergleichen
wir das letzte Element des Arrays
mit allen vorherigen. Und am
Ende des Looks werden wir wissen, dass das erste Element des Arrays auch das kleinste
im Array
ist. Ausgehend von der
letzten Zahl R A vier vergleichen
wir also die Zahl
zwei mit der Zahl davor, RA vier minus eins,
was R A drei ist, und wenn sie kleiner ist, werden
wir sie im Array um
eine Zeile nach oben verschieben. Dies wird
für das Element
R drei mit y drei minus eins wiederholt . Das ist zwei mit fünf. Also wird es so werden. Und schließlich wird es für das Element
RA zwei mit R zwei minus eins
, also zwei mit neun
wiederholt RA zwei mit R zwei minus eins
, also . Also wird es so werden. Es ist nicht nötig,
die Schleife fortzusetzen , in der Array
eins mit y eins minus eins verglichen wird, da es in diesem Array kein Array
Null gibt. Das liegt daran, dass wir angefangen haben, die Arrays 1—4 zu
zählen. Wir könnten
problemlos damit beginnen,
das Array 0-3 zu zählen , da dies
dasselbe bedeutet wie eins bis vier Wenn wir arri
mit den Indizes 0-3 gestartet hätten, gäbe es kein
Element minus eins in y. Und die letzte Schleife könnte das Element
R A Null
nicht mit R A
Null minus eins umwandeln R A Null
nicht mit R A
Null Einfach ausgedrückt, R A
minus eins existiert nicht. Die Anzahl der Wiederholungen, die
benötigt wurden, um
die Zahl zwei in die
erste Reihe zu verschieben , betrug drei Aus diesem Grund beginnen wir
unsere Schleife damit, dass i
gleich vier bis Mit einem Schritt von minus
eins, sodass wir am Ende des Arys
beginnen
und uns allmählich nach oben bewegen An dieser Stelle
wollen wir den Inhalt von
y mit y minus eins vertauschen . Um dies zu erreichen, werden wir
eine Variable namens temp
als temporäre Variable verwenden eine Variable namens temp
als temporäre Variable In dieser Variablen
speichern wir den aktuellen Wert von R, der in
der ersten
Iteration gleich Wir haben also, dass i gleich zwei ist
und zehn gleich zwei ist. Als Nächstes weisen wir dem
Wert von A i minus eins zu,
was bedeutet, dass die beiden RA durch sieben ersetzt
werden, und wir setzen den
alten Wert von A
, den wir in
der Variablen n gleich
zwei gespeichert haben , in i Wenn wir
die Variable zehn nicht verwenden würden, würden
wir dabei den vorherigen
Wert, der in A gespeichert war, verlieren Das Programm, das wir
bis zu diesem Punkt schreiben würden, ist also dieses. Zu diesem Zeitpunkt ist die Sortierung des Arrays noch nicht abgeschlossen da nur das kleinste Element an den
Anfang des Arrays sortiert
wurde. Dieser Vorgang muss auch für die übrigen Elemente
durchgeführt werden . Daher werden wir
einen weiteren äußeren Look verwenden , um dies zu erreichen. Diese Schleife mit der Variablen j
nimmt Werte von Element
zwei bis Element vier an. Aber nur drei Vergleiche
reichen aus, um alle
Zahlen miteinander zu vergleichen Das ist sinnvoll, denn
wenn wir n Zahlen vergleichen, ist
die Anzahl der Vergleiche, die wir durchführen
werden, n minus eins Mal sehen, wie das funktioniert, und wir werden
es Schritt für Schritt erklären Wir haben
die Nummer zwei bereits sortiert und starten den gleichen Vorgang mit dem
letzten Element des Arrays. Wir vergleichen RA vier
mit R vier minus eins, das ist sieben mit fünf. Und da sieben
mehr als fünf
sind, werden diese beiden Elemente ihren Platz
nicht wechseln. Das Array bleibt in diesem
Schritt also unverändert. Als Nächstes vergleichen wir y drei
mit R drei minus eins, das ist fünf mit neun, und da fünf weniger als neun ist, wird
die Army wie folgt aussehen. Die zweite äußere
Schleife hört hier auf,
da es nicht nötig ist, zwei mit fünf zu
vergleichen. Es folgt eine weitere Schleife, um das letzte Element zu
sortieren. Wir vergleichen RA vier mit RA vier minus eins, und da sieben weniger als neun sind, findet ein Austausch
der beiden Elemente statt, und das Array
nimmt seine endgültige Form an. Das endgültige Programm
wird so aussehen. Es ist erwähnenswert, dass wir in dieser
endgültigen Form des Programms, in der Schleife,
die beiden durch eine Variable ersetzt haben. Lassen Sie uns nun Schritt für Schritt sehen, warum. Wir verwenden die Variable, um die Anzahl der
Vergleiche zu zählen, die wir benötigen Zunahme der Vergleiche, die
wir durchführen, nehmen jedoch auch die Elemente zu,
die sortiert werden Aus diesem Grund beginnen
wir
in der inneren Schleife den Vergleich mit dem letzten Element wie
dem vierten Strahl Die Anzahl der Vergleiche, die wir benötigen,
wird jedoch nicht konstant sein Sie wird jedes
Mal abnehmen, wenn die äußere Schleife läuft. heißt, J wird zunehmen, und das bedeutet, dass die
Anzahl der
benötigten Netzschleifen nach
jeder externen Schleife abnimmt. Dies ist der Prozess, dem wir folgen, um das Array mit
der Bubble-Sort-Methode zu sortieren. Es ist erwähnenswert,
dass dies einer
der am einfachsten zu
verstehenden Sortieralgorithmen ist , aber gleichzeitig auch
einer der zeitaufwändigsten ist .
16. Projekt: Zu diesem Zeitpunkt haben wir sowohl unsere Theorie als auch
die Beispielaufgaben
abgeschlossen , die wir gemeinsam
demonstriert und gelöst haben. Sie können Probleme
jetzt mithilfe von Programmen selbst lösen. Zunächst können Sie
mit unserem Projekt beginnen. Alle Informationen, die
Sie zur Lösung
dieses Problems benötigen , finden Sie in
den vorherigen Lektionen. Eine einfache Lösung
wurde bereits in die
Klassenprojektgalerie hochgeladen. Dies ist jedoch nicht
die einzige Lösung. Das ist das Schöne
am Programmieren. Es kann auf
viele verschiedene Arten durchgeführt werden solange es
die richtigen Ergebnisse liefert. Ich würde mich freuen,
wenn Ihr Programm mit der Lösung des Problems in CDO-Code
geschrieben
17. Schlussbemerkung: wir uns zum Abschluss unserer Lektionen einen Moment Zeit, Nehmen wir uns zum Abschluss unserer Lektionen einen Moment Zeit,
um zu
überprüfen, was wir behandelt haben. Zunächst sind wir in der
Zeit zurückgereist und haben uns angesehen, wie sich die
Art und Weise, wie wir Computern Befehle
erteilen, von einer Sinussprache zu Sprachen der vierten
Generation entwickelt hat. Als Nächstes erörterten wir das
Konzept eines Problems
und insbesondere
den Denkprozess, den wir verfolgen, um ein Problem zu lösen. Mit diesen grundlegenden
Konzepten im Hinterkopf waren
wir dann bereit, über CDO-Code zu
sprechen Wir haben untersucht, wie Programme uns
bei
der Lösung von Problemen helfen, welche Kontrollstrukturen wir verwenden und wie jedes einzelne funktioniert Anschließend gingen wir zu etwas komplexeren Aspekten der Programmierung über und
sprachen über Arrays Wenn wir sie verwenden, um uns zu helfen, wie wir nach einem
Element in einem Array suchen und wie wir sie sortieren. Jetzt müssen wir nur
noch das Üben, was wir alle bereits gelernt haben,
indem wir weitere Übungen lösen. Und wir sind bereit, in
den Bereich der Programmierung einzusteigen. Ich bin Janes De Merzz. Ich danke Ihnen allen, dass Sie mich
auf dieser Reise durch gerne alles fragen, was
Sie nicht verstanden haben, oder ob es einen Teil des Kurses gibt ,
der Ihrer Meinung nach verbessert werden
könnte. Vergiss nicht,
mir für weitere Inhalte zu folgen. Und denken Sie daran, bleiben Sie neugierig, bleiben Sie inspiriert und hören Sie
nie auf zu lernen.