Programmierung mit PSeInt

Programmierung in:

PSeInt
Von Lic. Rommel Castillo Suazo
Original para LPP

Implementiert in PSeInt von

Alejandro Caro

Seite 1
 Programmierung mit PSeInt

Index
Thema Seite.
Was ist PSeInt? 3

Installation 4

Mein erstes Programm 5

Flussdiagramme 10

• Flussdiagramm-Editor

Variable deklarieren 12

Operatoren 13

Zuweisungen und mathematische Operationen in einem Programm. 14

Bedingte Anweisungen
• Ja 16
•Wenn verschachtelt 18
•Laut 20
•Operateur | 22
•Betreiber & 24

Zykinstruktionen
• While-Schleife 26
•Zyklus für 32
o Verschachtelte Zyklen 32
o Negativer Zyklus 34
• Wiederholungsschleife 37

Unterprozesse 40
•Eingabeparameter oder Wert
Variablenparameter
•Teilprozesse mit Rückgabe 46

Dimensiones
•Dimension de una Dimensión 50
•Zweidimensionale Dimensionen 57
Registros(Información teórica) 59
• Abmessungen mit 61 Einträgen
Textdateien (Theoretische Informationen) 62

Seite 2
 Programmierung mit PSeInt

Anhang:
Flussdiagramm-Editor
Borrar PSeInt
•Quellcode bearbeiten

Seite 3
 Programmierung mit PSeInt

Was ist PSeInt?

PSeInt ist die Abkürzung für Pseudocode-Interpreter, Interpreter von
Pseudocode. Dieses Programm wurde als Abschlussprojekt für das Fach erstellt.
Programmierung des Studiengangs Ingenieurwesen in InformatikFakultät von
Ingenieurwesen und Wasserwissenschaftende la Nationale Universität del Litoral, del en
jenen Moment Student Pablo Novara.

Das Programm verwendet Pseudocode, eine fiktive Programmiersprache, deren

Die Hauptmission besteht darin, dass der Programmierer sich auf die logischen Aspekte konzentrieren kann.

von der Programmierung, wobei der technische Teil für den Zeitpunkt reserviert bleibt, an dem die Syntax behandelt wird

von einer echten Programmiersprache.

PSeInt enthält in seinem Editor verschiedene Werkzeuge, damit wir erstellen können und

Programme in dieser besonderen Sprache speichern, sie direkt ausführen

seine Benutzeroberfläche oder sogar mögliche Mängel, die wir in seiner finden.
Entwicklung.
Se kann finden ein Macht en
[Link]/2011/10/[Link]

Warum PSeInt verwenden und nicht einen anderen Interpreter oder Compiler
de Pseudocode?
1) Weil es freie Software ist, ohne Geld auszugeben.
Giros usw., die die Urheberrechte verletzen oder schaffen oder beschaffen.
cracs, dass manchmal ihre Links inaktiv sind und/oder die Programme nicht funktionieren.

knacken.
2) Er wird ständig von seinem Schöpfer betreut, im Gegensatz zu den anderen
Compiler und Interpreter von Pseudocode, die eingestellt wurden.
3) Es hat ein Forum, um Fehler zu melden und Hilfe zu erhalten, es ist auch
ständig von seinem Schöpfer betreut, was hilft, das Programm zu verbessern.
4) Es gibt eine umfangreiche Hilfe, die, um es redundant zu sagen, beim Lernen hilft.

es zu benutzen und die Sprache zu lernen.

5) Der Quellcode ist verfügbar und es sind Anweisungen zur Ausführung enthalten, so dass

Seite 4
 Programmierung mit PSeInt

dass wir es anpassen und korrigieren können, wenn wir C++ kennen.

Es gibt einen Export nach C++, damit wir denselben Code in C++ sehen können, was
Hilfe beim Lernen von C++;

Es handelt sich um einen Interpreter und nicht um einen Compiler, die Datei muss nicht sein
Auf der Festplatte gespeichert, um ausgeführt zu werden, was die Verwendung angenehmer macht.

Instalación

Öffne die Datei "[Link]" (xxxx ist die Versionsnummer)

tatsächlichen), der von der Projektseite bereitgestellt wird, wenn man doppelt darauf klickt
Der Installer wird ausgeführt.

Dann drücken wir weiter -> weiter und so weiter, bis wir es installiert haben.

Vorläufige Notizen
Bevor man mit dem Programmieren beginnt, ist es ratsam, eine Vorstellung davon zu haben

allgemeine Funktionsweise von PSeInt.

Seite 5
 Programmierung mit PSeInt

Wenn wir PSeInt zum ersten Mal öffnen, erscheint ein Hinweis, der uns fragt
welches Profil wir verwenden möchten, um Verwirrungen mit der Sprache zu vermeiden.

Dieses Handbuch wird mit zwei Profilen gehandhabt. Das strenge, das dem am ähnlichsten ist

einer echten Programmiersprache muss genau beachtet werden

formato del pseudocódigo propuesto por Novara. La sintaxis flexible la
wir verwenden, um bestimmte Codes auszuführen, die mehr Flexibilität erfordern.
Zeit zum Ausführen. Es sei denn, es wird angegeben, dass flexible Syntax verwendet wird, wird

wird die strikte Syntax verwenden.

Seite 6
 Programmierung mit PSeInt

Hinweis: Flexible Syntax nicht mit flexiblem Profil verwechseln

Gehen wir zu Konfigurieren → Spracheinstellungen → Wählen wir Streng aus und

Wir drücken auf akzeptieren.

PSeInt öffnen
Um PSeInt zu öffnen, doppelklicken wir auf das PSeInt-Shortcut auf dem Desktop und
öffnet uns das Programm.

Mein erstes Programm schreiben

Sobald wir PSeInt geöffnet und die strikte Syntax konfiguriert haben,
este nos presenta una página que dice Inicio sin_titulo y FinProceso, entre
In diesen beiden Zeilen werden wir unser erstes Programm schreiben:

Dann speichern wir es

Seite 7
 Programmierung mit PSeInt

Wir schreiben den Namen des Programms in das Fenster, das uns erscheint, und dann

wir drücken Speichern unter...

Jetzt, da wir sie gespeichert haben, müssen wir sicherstellen, dass unser Programm funktioniert und

Schreiben Sie auf den Bildschirm Unitec, obwohl PSeInt die Fehler rot unterstreicht.
Syntax, es ist auch gut, die Syntax zu überprüfen, um Fehler zu sehen. Dafür
wir werden ausführen
→ Syntax überprüfen. Wie auch immer, wenn wir Fehler hätten, er...
würde uns den Satz unterstreichen, in dem der Fehler steht, dann korrigieren wir ihn und

Wir führen es erneut aus, bis nichts mehr rot unterstrichen ist.

Nachdem das Programm keine Kompilierungsfehler hat, erscheinen keine Zeilen.

unterstrichen mit Rot, wählen wir Ausführen, dann Ausführen, und auf dem Bildschirm
Das Wort Unitec wird erscheinen, was der Ausgang des Programms ist, auch um auszuführen.
Das Programm kann das Ausführungs-Icon verwenden oder F9 drücken:

Wenn die Ausführung erfolgreich abgeschlossen wurde, erscheint am Ende eine Nachricht.

Seite 8
 Programmierung mit PSeInt

diciendo que el programa se ejecutó correctamente.

Immer wenn wir ein Programm in PSeInt schreiben möchten, beginnen wir darunter
das Wort

Prozess ohne Titel

//wir schreiben den Körper des Programms;

FinProceso

Und der Hauptprozess endet mit den Schlüsselwörtern FinProceso, die darauf hinweisen, dass das

Ende des Hauptprogramms.

Einen Namen für das Programm vergeben, indem sin_titulo durch den Namen ersetzt wird
was wir ihm geben wollen. Denken Sie daran, dass der Name des Pseudocodes in keiner Syntax

Es können Leerzeichen vorhanden sein und in strikter Syntax auch keine Akzentzeichen.
den Namen des Prozesses mit dem des Dateis in Pseudocode verwechseln.

Das reservierte Wort 'Escribirescribe' gibt auf dem Bildschirm aus, was zwischen steckt.

In flexibler Syntax können wir auch das Wort verwenden

ImprimiroMostrar. Ich wiederhole, es sei denn, es wird angegeben, dass es verwendet wird.

flexible Syntax, wir werden immer strikte Syntax verwenden.

Text verketten
Seite 9
 Programación con PSeInt

Prozess verketten
Mein erstes Programm
Escribir " en PSeInt ";
FinProceso

Die Ausgabe des Programms ist

Mein erstes Programm in PSeInt

Esto porque el final de la línea hace un retorno y baja a la siguiente, ahora si

wir möchten schreiben:
Mein erstes Programm
In PSeint
Hinweis: Die Anführungszeichen müssen immer einfach sein und niemals typografisch, denn diese
Letzte sind grafische Symbole, die keine Programmiersprache bis zum
Moment kann interpretieren. Immer standardmäßig in den Texteditoren der
IDES werden in einfachen Anführungszeichen geschrieben, aber wenn sie importiert oder formatiert werden

Pseudocode, der von außen kommt, muss in Bezug auf die Anführungszeichen korrigiert werden, wenn dies nicht getan wird.

würde einen Kompilierungsfehler verursachen.

Das Programm wäre in dieser Form Beispiel

Prozess erster_Programm
Mein erstes Programm
Schreiben " in PSeInt ";
FinProceso

Damit deduzieren wir, dass die Anweisung Sin Saltar den Inhalt von einer zusammenfügt.
Textkette und der Inhalt der nächsten Zeile wird in der ersten Zeile geschrieben.

Denken Sie daran, dass in strikter Syntax die Platzierung des Semikolons am Ende der
Sätze sind verpflichtend, flexibel ist optional.

Nota: PSeInt no es case sensitive, por lo tanto colocar Escribir con mayúsculas y
Kleinbuchstaben ist dasselbe und verursacht keine Fehler jeglicher Art, aber aus Respekt vor der
Die durch die Schaltflächen angezeigte Syntax muss mit einem Großbuchstaben beginnen, um zu vermeiden

so Formatfehler.
Seite 10
 Programmierung mit PSeInt

Hinweis 2: In strenger Syntax enden die Anweisungen immer mit einem Semikolon.

Seite 11
 Programmierung mit PSeInt

Flussdiagramme
PSeInt es capaz de interpretar los pseudocódigos y transformarlos a diagrama de
Fluss, dafür steht ein Visualisierer und Editor für Flussdiagramme zur Verfügung. Das ist
nützlich, wenn wir den Pseudocode aus einer grafischen Perspektive analysieren wollen.

Man gelangt durch Drücken des Symbols darauf zu von der Taskleiste. PseInt ist nicht nur
fähig, es zu visualisieren, sondern auch, es zu bearbeiten.

Beispiel:

Berücksichtige das folgende Programm

Prozess erster_Programm
Mein erstes Programm
Schreiben " in PSeInt ";
FinProceso
Ihre Darstellung im Flussdiagramm ist wie folgt:

Hier sehen wir den Beginn des Prozesses, dargestellt als eine Ellipse, den Satz
geschrieben, dargestellt in einem Rechteck, denn es ist ein Plakat

Seite 12
 Programmierung mit PSeInt

Hinweis 1: Auf der Seite[Link]

page=[Link] Auf der offiziellen Website von PSeInt wird die Struktur der
Flussdiagramme.
Hinweis 2: Im Anhang wird erläutert, wie man Flussdiagramme bearbeitet.

Variablen deklarieren
In strikter Syntax, wann immer wir ein Programm erstellen müssen, werden wir
Variables deklarieren, um die Informationen zu speichern, die wir eingeben.
Programm.
Die unterstützten grundlegenden Datentypen sind die folgenden:

1. Entero : nur ganze Zahlen.

2. Reell: Zahlen mit Dezimalziffern.
3. Zeichen: wenn wir ein Zeichen speichern möchten.
4. Logico : wenn wir einen logischen Ausdruck speichern müssen
(wahr oder falsch)
5. Kette: wenn wir Zeichenfolgen speichern möchten.
Hinweis: Kette und Zeichen sind gleichwertige Begriffe, es erzeugt keinen Fehler, dass die

Lass uns beliebig schreiben

Beispiele

Wenn wir eine Variable vom Typ Integer deklarieren wollen, wäre das so:

Definiere Nummer als Ganzzahl;

Nummer wird zu einer Ganzzahl-Variable

Hinweis: In strikter Syntax dürfen Variablen keine akzentuierten Zeichen enthalten.
Wenn wir eine Variable vom Typ String deklarieren wollen, um den Namen zu speichern, wäre es so:

Dimension nombre [25];

Definiere Namen Als Zeichenkette;

Hinweis: In strenger Syntax dürfen Variablen keine Zeichen enthalten.

ascentuados
Nombre wäre eine Variable, die nur 25 Zeichen speichern würde, obwohl du kannst

Seite 13
 Programmierung mit PSeInt

Wenn mehr als 25 Buchstaben geschrieben werden, speichert er im Speicher nur die ersten 25.

Zeichen.
Hinweis: Siehe den Abschnitt Abmessungen für weitere Details.
Hinweis: Obwohl dies keine Laufzeitfehler verursacht, wenn es deklariert wird.
mehrere Variablen gleichzeitig, um einen Formatfehler zu vermeiden - Übereinstimmung muss
Pluralisieren Sie den Variablentyp. Z.B.: Definieren Sie a, b, c als Ganzzahlen;

Hinweis 2: Der Plural von Charakter ist Kette

Operatoren
PSeInt bietet die folgenden Operatoren an:

Operator Funktion

() Ausdrücke gruppieren
^ Operador para exponenciación
* Multiplikationsoperator
/ Divisionsoperator
% ó Mod Operador de cálculo de residuo
trunc(valor1 / valor2); Syntax der ganzzahligen Division
&óy Logischer Operator und

+ Additionsoperator
- Subtraktionsoperator
|óo Logischer Operator oder

Hinweis: In flexibler Syntax können wir auch die Operatoren & | und mod verwenden.
wie und oder und % respektiv.

Leer Werte und sie in den Variablen speichern

Wenn wir einen Wert lesen und in einer Variablen speichern möchten
wir werden das Wort Lesen < variable>;. und wenn wir einen Wert zuweisen wollen oder
Eine mathematische Operation verwenden wir <- das ist das Symbol von < plus -.

Beispiel zur Datenlesung

Seite 14
 Programmierung mit PSeInt

Prozess lesedaten
Dimension nombre[25];
Definiere Namen als Zeichenkette;
Escribir "Ingrese su nombre ";
Leer nombre[24];
Willkommen
Schreiben Sie name[24];
FinProceso

Das Programm deklariert eine Variable für den Namen, die 25 Zeichen speichert.
Maximo, gib den Namen ein und schreibe dann auf den Bildschirm: Willkommen, der Name.
was eingegeben wurde. Etwas Wichtiges ist, dass, wenn der Wert präsentiert werden soll
Die Variable esta wird nicht in Anführungszeichen geschrieben.

Ihr Flussdiagramm:

In der Tabelle wird uns gezeigt, wie ein Block des Programms ersetzt werden konnte, der
würde uns dasselbe Ergebnis geben

Fall 1 Fall 2
Seite 15
 Programmierung mit PSeInt

Willkommen Schreibe "willkommen" ohne umzuschalten, Name;

Name schreiben;

Hinweis: Es ist nicht erforderlich anzugeben, wie viele Zeichen die Zeichenfolge hat, die PSeInt
Es muss gelesen werden, aber es muss angegeben werden, ob wir die Dimension als einen Vektor deklarieren.

de Zeichen.

Zuweisungen und mathematische Operationen in

ein Programm.
Das Symbol <- werden wir verwenden, um Werte den Variablen zuzuweisen, zum Beispiel
Sueldo<-500; Mit dieser Anweisung weisen wir den Wert von 500 zu
Variablen Gehalt, die als Ganzzahl oder Gleitkommazahl deklariert werden konnten

Nombre<-"juan";con esta instrucción asignamos la cadena "Juan " a la

Variable nombre, die eine Variable vom Typ Zeichenkette ist

Beispiel für die Zuweisung von Werten zu Variablen

Prozesssteigerung
Definir sueldo, aumento Como Enteros;
Dimension nombre[25];
Definiere Namen als Zeichenkette;
Geben Sie den Namen des Mitarbeiters ein
Leer Name[24];
Geben Sie das Gehalt des Mitarbeiters ein
Leer Gehalt;
Aumento <- sueldo * 1.25;
Neues Gehalt mit 25% Erhöhung
Schreiben Erhöhung;
FinProceso
Das Programm fragt nach dem Namen und dem Gehalt des Mitarbeiters und berechnet dann 25 % davon.

Erhöhung des Gehalts und speichert es in der Variablen Erhöhung und präsentiert dann die neue

Gehalt.
Flussdiagramm:

Seite 16
 Programmierung mit PSeInt

Beispiel für das Verketten von Strings

Proceso suma_de_cadenas
Dimension nombre[25],apellido[25],completo[25];
Definir nombre,apellido,completo Como Cadenas;
Ihr Name
Leer nombre[24];
Nachname
Leer Nachname[24];
Completo <- nombre[24] + " " + apellido[24];
Schreiben Sie "Vollständiger Name", vollständig[24];
FinProceso
Die Variable completo nimmt den Wert des Namens plus ein Leerzeichen plus den
Nachname und wir speichern ihn in einer Variable, wo wir jetzt den Namen und den
Nachname.

Hinweis: Es ist nicht unbedingt erforderlich, Zeichenfolgen zu dimensionieren. Siehe

die Seite, die das Thema Dimensionen behandelt.

Seite 17
 Programmierung mit PSeInt

Bedingte Anweisungen
Früher haben wir Programme erstellt, die nur Berechnungen durchführen, aber
Die Programmierung ist interessanter, wenn unsere Programme ihre
eigene Entscheidungen, in PSeInt gibt es bedingte Anweisungen, die sich
beschreiben im Folgenden:
Anweisung Si:

Syntax

Wenn Bedingung Dann

instrucciones;
FinSi

Wenn Bedingung Dann

Anweisungen;
Sino
Anweisungen;
FinSi

Beispiel über Entscheidungen

Geben Sie eine Nummer ein, und wenn die Nummer größer als 100 ist, schreiben Sie sie auf den Bildschirm.

Die Nummer ist größer als 100.

Entscheidungsprozess
Definiere num als Integer;
Geben Sie eine Nummer ein
Leer num;
Wenn num > 100 Dann
Das Programm wird nur schreiben, dass die Zahl größer als 100 war, wenn es erfüllt ist

die Bedingung num > 100 sonst erfüllt die Bedingung nichts.

Seite 18
 Programmierung mit PSeInt

Beispiel für Entscheidungen

Geben Sie den Namen des Mitarbeiters ein, die geleisteten Stunden, dann Berechnen Sie die Bezahlung

brutto (50 lps pro Stunde) IHSS und Gesamtbetrag zu zahlen, die Ergebnisse des Programms präsentieren

Hinweis: Die Sozialversicherung beträgt 84, wenn das Gehalt über 2400 liegt, andernfalls beträgt sie 3,5 % des.

sueldo del empleado.

Mitarbeiterprozess
Definiere Stunden als Ganzzahlen;
Definiere Pbruto, ihss, tp als Reale
Dimension nombre[25];
Definiere den Namen als Zeichenkette;
Geben Sie den Namen ein
Leer nombre[24];
Stunden eingeben
Leer Stunden;
Pbruto<-Stunden*50;
Wenn pbruto > 2400 Dann
Ihss<-84;
Sino
Ihss <- 0,035 * pbruto;
FinSi
Tp<-pbruto-ihss;
Escribir "Pago bruto " , pbruto;
Soziale Sicherheit, IHSS
Escribir "Total a pagar " , tp;
FinProceso

In diesem Programm wurde bei der Berechnung des Ihss eine Entscheidung getroffen, die zwei hat

Ausgänge eine, wenn die Bedingung erfüllt ist, die ist das dann, und die andere, wenn
Es wird nicht die Bedingung erfüllt, die der Sinn ist, jetzt hilft uns das, dass unsere
Programme können eine Entscheidung treffen, wenn die Bedingung erfüllt ist, und eine andere

wenn es nicht erfüllt wird.

Jetzt gibt es in der folgenden Übung keine zwei Lösungen mehr für die
Bedingung oder drei, wenn dies eintritt, werden verschachtelte Bedingungen verwendet.

Seite 19
 Programmierung mit PSeInt

Syntax einer geschachtelten Bedingung:

Wenn Bedingung 1 Dann
Anweisungen;
Wenn Si Bedingung 2 Dann
Anweisungen;
Sino Si Bedingungen 2 Dann
Anweisungen;
Sino
Instrucciones;
FinSi
FinSi
FinSi

Beispiel für geschachtelte Entscheidungen

Ingresar el nombre del empleado, la zona de trabajo , las ventas del empleado ,

dann berechnen Sie Ihre Provision auf der Grundlage eines prozentualen Anteils, der auf der Zone basiert

de trabajo, dann den IHSS und den Gesamtbetrag zu bestimmen, die Daten präsentieren.

Tabelle zur Berechnung der Provision

Zone Prozentsatz der Provision

Ein 6%

B 8%

C 9%

Prozesskommission
Definiere Zone als Charakter;
Dimension nombre[25];
Definiere Namen als Zeichenkette;
Definir ventas , comis , ihss, tp Como Reales;

Geben Sie den Namen des Mitarbeiters ein;

Leer nombre[24];
Geben Sie die Verkäufe des Mitarbeiters ein;
Leer Verkaufszahlen;
Geben Sie die Arbeitszone ein
Leere Zone;
Seite 20
 Programmierung mit PSeInt

Wenn zone = 'A' Dann

comis<- 0.06 * verkäufe;
Wenn si zona='B' dann
comis <- 0,08 * ventas;
Wenn zone='C' Dann
comis<- 0.09 * verkäufe;
Sino
comis<- 0;
FinSi
FinSi
FinSi
Wenn du mehr als 2400 isst, dann
ihss <- 84;
Sino
ihss<-0.035*comis;
tp<-comis - ihss;

Verdiente Kommission, Kommission;

Soziale Sicherheit, IHSS;
Gesamtsumme zu zahlen
FinProceso

En este programa usamos decisiones anidadas para el calculo de la comisión

des Mitarbeiters, da es mehrere Optionen zur Auswahl gab.
Der letzte Sino, bei dem die Provision 0 ist, erfolgt, weil wir uns nicht sicher sind über

dass die Person, die das Programm bedient, die Zone richtig eingibt, wenn sie
Bei Eintritt in eine andere der erlaubten Zonen beträgt die Provision null.

Seite 21
 Programmierung mit PSeInt

Struktur Laut
Dies wird in einigen Fällen als Ersatz für das verschachtelte Wenn verwendet, da es mehr

praktisch bei der Anwendung auf die Bewertung bestimmter Bedingungen.

Syntax

Segun variable Hacer

wert1, wert2, wert3, … :

instrucciones;
wert1, wert2, wert3, … :
Anleitungen;

.
.
Auf eine andere Art
instrucciones;]

FinSegun

Los valores a evaluar , se separan por comas si hay varios, tal como aparece en
Die Syntax wert1,wert2 usw. kann auch verwendet werden, was uns anzeigt, dass
Falls keine der vorherigen Anweisungen ausgewählt wird, werden sie ausgeführt.

Seite 22
 Programmierung mit PSeInt

Wichtiger Hinweis: In strikter Syntax müssen die Optionen des "Segun" immer sein
vom numerischen Typ. Um Optionen vom Typ Text bewerten zu können, muss man
Die Sprache mithilfe flexibler Syntax im Editor anpassen.

Beispiel für die Anwendung der Struktur Laut

Im vorherigen Beispiel haben wir geschachtelte Entscheidungen verwendet, um die Provision zu bestimmen.

Jetzt werden wir eine Struktur gemäß verwenden.

Dafür haben wir flexible Syntax aktiviert, indem wir zu Sprache anpassen gegangen sind →

Personalize… → Verwenden Sie flexible Syntax

Prozess Beispiel_Fall
Definition der Zone als Charakter;
Dimension nombre[25];
Definir nombre Como Cadena;
Definir ventas , comis , ihss, tp Como Reales;
Geben Sie den Namen des Mitarbeiters ein;
Leer nombre[24];
Geben Sie die Verkäufe des Mitarbeiters ein;
Leer Verkäufe;
Geben Sie die Arbeitszone ein
Leere Zone;
Segun Zone Hacer
'a','A' : comis<- 0.06 * ventas;
'b','B' : comis<- 0.08 * ventas;
'c','C' : comis<- 0.09 * ventas;
Anders
comis<- 0;
FinSegun
Wenn du mehr als 2400 isst, dann
ihss<- 84;
Sino
ihss<-0.035*comis;
FinSi
tp<-comis - ihss;
Kommission verdient, Kommis;
Soziale Sicherheit, IHSS;
Escribir "Total a pagar " , tp;
FinProceso

Seite 23
 Programmierung mit PSeInt

Jetzt erkennt unser Programm die Groß- und Kleinbuchstaben bei der Bewertung
aus der Zone

Verwendung des Operators |

Der Operator | (O) wird verwendet, wenn wir zwei oder mehr Bedingungen evaluieren und
wir möchten, dass die Bedingung erfüllt wird, wenn eine der Bedingungen, die
Wir bewerten, ob sie wahr sind. Beispiel

Wenn die Zone in die Übung mit der Struktur Si nur eingeführt wird
Wir bewerteten eine Option, dass die Zone gleich dem Buchstaben A ist und wenn der Benutzer schrieb

Eine Kleinschreibung von no2 wurde berücksichtigt, aber das kann so korrigiert werden.

manera :
Wenn zona ='A' | zona ='a' Dann
comis<- 0,06 * ventas;
Wenn Si zona='B' | zona='b' Dann
comis<- 0.08 * Verkäufe;
Wenn zona='C' | zona='c' Dann
comis<- 0.09 * Verkaufszahlen;
Sino
comis<- 0;
FinSi
FinSi
FinSi

Jetzt sagt die Bedingung, wenn Zone gleich dem Buchstaben A oder gleich dem Buchstaben a ist,

Egal welcher Bereich A oder A in beiden Fällen die Bedingung ist wahr.
Jetzt kann der Benutzer Groß- und Kleinbuchstaben verwenden und das Ergebnis wird sein

gleich.
Beispiel zum Operator |

Geben Sie den Namen des Kunden ein, dann die Menge des Produkts, den Preis und die Art von
cliente , calcular el subtotal , descuento , impuesto s/v, total a pagar, presentar
die Daten.
Der Rabatt beträgt 10%, wenn der Kunde vom Typ A ist oder die Menge beliebig ist.
Produkt ist größer als 100, sonst beträgt es 5%.

Rabattprozess
Seite 24
 Programmierung mit PSeInt

Definir precio,st,des,tp,isv Como Reales;

Dimension nombre[25];
Definiere Namen als Zeichenkette;
Definiere tipoM als Charakter;
Definiere cant Als Ganzzahl;
Kundenname schreiben
Leere name[25];
Geben Sie den Kundentyp ein
Leer tipoM;
Escribir "Ingresar el precio del producto";
Leer Preis;
Geben Sie die Menge ein;
Leer singen;
St<- Preis*cant;
Wenn tipoM ='a' | tipoM='A' | cant>100 Dann
Des<-st*0,10;
Sino
Des<-st*0.05;
FinSi
Isv<-(st-des) 0,12
Tp<-(st-des)+isv;
Zwischensumme
Rabatt
Steuer, ISV;
Gesamtsumme zu zahlen
FinProceso
Ihre Darstellung im Flussdiagramm:

Seite 25
 Programmierung mit PSeInt

Como vemos, el proceso es tan largo, que aparece con la letra muy chica, para
Um es größer erscheinen zu lassen, ziehen wir das Scrollrad zu uns, damit es sich vergrößert.

Uso del operadorY (&)

Der Operator Y (&) wird verwendet, wenn wir zwei oder mehr Bedingungen evaluieren und
Wir wollen, dass die Bedingung erfüllt wird, wenn die beiden Bedingungen, die wir haben, erfüllt sind.

Bewertungen werden wahr. Beispiel

Beispiel zum Operator &

Eine Zahl wird eingegeben und es wird gewünscht zu wissen, ob diese Zahl zwischen 50 und 100 liegt.

Prozess beispiel_betreiber_y
Definieren Sie num als Ganzzahl;
Schreibe "Zahl zu bewerten";
Leer num;
Wenn num >=50 & num<=100 Dann
Die Zahl liegt zwischen 50 und 100.
Sino
Seite 26
 Programmierung mit PSeInt

Außerhalb des Bereichs 50 und 100

FinSi
FinProceso

Export nach C++

PSeInt kann das Programmalgorithmus nach C++ exportieren. Es wird nur eine Datei generiert.

mit der Endung .cpp (Abkürzung für C plus plus, c++). Es ist nicht erforderlich zu speichern

Zuvor die Datei im Pseudocode, damit sie nach C++ exportiert wird.
Gehen Sie einfach zu Datei und wählen Sie Export nach C++

Hinweis: Da sich der experimentelle Modus befindet, könnte der generierte Code nicht sein.

Alles korrekt, das wird in den kommenden Versionen von PSeInt gelöst werden.

Anweisungen für den Zyklus

Wir haben Programme erstellt, die nur einmal wiederholt werden, aber in der Programmierung

Wir benötigen, dass die Programme mehrmals laufen und uns präsentieren.
informationen am ende mehrmals ausführen, in diesen fällen verwenden wir schleifen, die
es sind Wiederholungsstrukturen, die sich wiederholen, bis eine Bedingung erfüllt ist oder
Wir geben einfach an, wie oft sie sich wiederholen werden.
Hinweis: Um Mehrdeutigkeiten zu vermeiden, müssen alle Schleifen immer geschlossen werden, nicht
Es ist möglich, dass es "Offene Zyklen" gibt.

While-Schleife:

Syntax

Während Bedingung Machen

Anleitungen;
FinMientras

Die While-Schleife wird verwendet, wenn man einen Block wiederholt ausführen möchte.
Anweisungen basierend auf einer Bedingung, der Zyklus wiederholt sich, solange die Bedingung

geburtstag.

Beispiel für die Schleife Während mit einem Zähler

Geben Sie 10 Namen ein

Seite 27
 Programmierung mit PSeInt

Zählerprozess
Definiere Zähler als Ganzzahl;
Dimension nombre[25];
Definir nombre Como Cadena;
Contador<-0;
Während der Zähler < 10 ist, mache
Geben Sie den Namen ein
Leer name[24];
contador <- contador + 1;
FinWährend
FinProceso

In diesem Programm führen wir das Konzept des Zählers ein, der eine Variable ist.
der sich um 1 erhöht und auf diese Weise zählen wir, wie viele Namen
werden eingegeben, um zu stoppen, wenn wir 10 eingeben, das sagt uns, dass die
Die Bedingung wird nicht mehr erfüllt, weil die Bedingung erfüllt ist, wenn der Zähler 10 beträgt.

contador < 10 wird nicht mehr erfüllt, da es gleich ist und die Schleife endet.

Beispiel für die While-Schleife mit Akkumulatoren

Seite 28
 Programmierung mit PSeInt

Geben Sie 10 Zahlen ein und zeigen Sie am Ende die Summe der Zahlen an.

Prozessakkumulatoren
Definiere Zähler, Summe, Num als Ganzzahlen;
Zähler<-0;
Suma<-0;
Während Zähler <10 Machen
Geben Sie eine Zahl ein
Leer Num;
Contador <- Contador + 1;
Suma<-Num+Suma;
FinMientras
Escribir "Suma de los 10 números ", Suma;
FinProceso

Hinweis: Um Mehrdeutigkeiten zu vermeiden, werden die Zahlen einzeln eingegeben, indem man drückt
Geben Sie nacheinander ein. Sie in einer Zeile einzugeben, die durch Leerzeichen getrennt ist, würde verursachen

Ein Typenstimmigkeitsfehler, da der Abstand als ein Typ behandelt wird.

Ein Eingabedatum mehr und ein Raum ist kein numerischer Datentyp.

Die Schleife durchläuft 10 Mal und fordert die 10 Zahlen an, aber die Zeile summa<- summa +

num, lässt die Variable suma ihren Wert mit der Zahl erhöhen, die sich
Führen Sie zu diesem Zeitpunkt, im Gegensatz zum Zähler, einen Akkumulator ein.
Inkrementiere mit einer Variable, die ihren Wert anhäuft, bis die Schleife endet, bei
Final wird die Summe präsentiert, nur in diesem Moment muss eine präsentiert werden.

Akumulator, weil er zuvor die Summe aller Zahlen nicht widerspiegeln würde.

Immer wenn wir einen Zähler oder Akkumulator verwenden, müssen wir ihm einen Anfangswert geben.

generell wird es 0 sein.

Beispiel für die while-Schleife, die eine Antwort zur Steuerung der Ausgabe verwendet.

des Zyklus.

Ingresar el nombre del cliente, el precio del producto, cantidad y luego calcular el

Seite 29
 Programmierung mit PSeInt

subtotal, isv y total a pagar, presentar los datos luego preguntar si desea
Fortfahren, am Ende den Gesamtbetrag der Rechnung anzeigen.

Produktprozess
Definieren Sie Resp als Charakter;
Definieren Sie den Namen[25];
Definiere Name Als Zeichenkette;
Definir Precio, cantidad, totalglobal, st, isv, tp Como
Reales;
Totalglobal<-0;
Resp<-'S';
Während resp <> 'N' Machen
Name des Kunden
Leer nombre[24];
Geben Sie die Menge des Produkts ein;
Leer Menge;
Geben Sie den Preis des Produkts ein ";
Leerpreis;
St<- Preis * Menge;
Isv<-st * 0,012;
Tp<-st-isv;
Totalglobal <- Totalglobal + st;
Zwischensumme
Escribir "Impuesto sobre venta " , isv;
Total zu zahlen
Möchten Sie fortfahren J/N
Leer
FinMientras
Escribir "Total de la venta" , totalglobal;
FinProceso

In dieser Übung beobachten wir, dass der Zyklus durch eine angeforderte Antwort gesteuert wird.

am Ende S, um fortzufahren oder N, um zu beenden, aber es würde das gleiche Ergebnis liefern, wenn Sie schreiben

Jeder Buchstabe, der nicht S ist, würde trotzdem funktionieren, auch wenn er nicht N ist.

Programm, die Validierung der Eingabedaten werden wir später näher betrachten.

Beispiel für Bedingungsstrukturen innerhalb der While-Schleife.

Ingresar el nombre del alumno, la nota examen y nota acumulada, luego calcular
Seite 30
 Programmierung mit PSeInt

die Endnote und die Endnote sowie die Beobachtung des Schülers vorzulegen.
Fragen, ob Sie fortfahren möchten, am Ende die Anzahl der Genehmigten präsentieren und

durchgefallen.

Genehmigter Prozess
Definiere Resp als Charakter;
Dimension nombre[25];
Definieren Sie den Namen als Zeichenkette;
Definiere na, ne, nf als Reelle;
Definiere cr, ca als Ganzzahlen;
cr<-0;
ca<-0;
Resp<-'S';
Während resp <> 'N' machen
Name des Schülers
Leer nombre;
Gesammelte Note
Leer na;
Escribir "nota examen ";
Leer ne;
nf<- na+ne;
Wenn nf >= 60 Dann
Du bist genehmigt
ca<-ca+1;
Sino
Du bist durchgefallen
cr<-cr+1;
FinSi
Escribir "Nota final " , nf;
Möchten Sie fortfahren J/N
Leer Resp;
FinMientras
Gesamtzahl der Nichtbestehenden
Escriba "Total de aprobados" , ca;
FinProceso

Nota:Las variables no pueden declararse inicializadas, se declaran primero y se

werden später initialisiert.

Seite 31
 Programmierung mit PSeInt

Wie wir in den Zeilen des Programms sehen können, verwenden wir innerhalb der Schleife
Währenddessen Entscheidungen zu treffen, um die Nichtbestehenden und Bestehenden zu zählen, die resultieren.

Bei der Zulassung der Schüler, wenn die Note höher als 60 ist, schreibe genehmigt und

Erhöhe den Zähler und wenn nicht, mache das Gegenteil, schreibe „nicht bestanden“ und erhöhe.

der Zähler.

Seite 32
 Programmierung mit PSeInt

Zyklus für
Syntax

Für variable <- wert_anfang Bis wert_ende Mit Schritt Schritt Machen
Anleitungen
FinPara

Descripción

Die Schleife Für wird allgemein verwendet, um eine Reihe von Anweisungen auszuführen.
die eine festgelegte Anzahl von Malen wiederholt werden, bevor die Schleife ausgeführt wird.

Variable :es vom Typ Ganzzahl

Valor_inicial: este puede se un número entero o una variable entera.
Valor_final :este puede se un número entero o una variable entera.
Paso: dies kann eine ganze Zahl oder eine ganze Variable sein.
Hinweis: Schritt 1 kann sowohl in strenger Syntax als auch weggelassen werden.
flexibel
Beispiel: die Zahlen von 1 bis 10 auf dem Bildschirm anzeigen.

Prozess Zyklus_Para
Definiere I als Ganzzahl;
Für I<-1 Bis 10 Mit Schritt 1 Machen
Ich;
FinPara
FinProceso

Das Programm für den Zyklus legt die Anzahl der Wiederholungen des Zyklus fest.
von 1 bis 10 angeben, dann nimmt die Variable I den Wert 1 bis 10 entsprechend der Schleife an

ausführend, deshalb wird beim ersten Schreiben der I 1 und beim zweiten
2 und so weiter bis zum Ende, das 10 ist.

Seite 33
 Programmierung mit PSeInt

Beispiel: über die Verwendung von Variablen im Bereich der Für-Schleife.

Prozess Zyklus_Para
Definieren Sie I, final als Ganzzahlen;
Escribir "Ingresar el número de veces a repetir el ciclo ";
Leer final;
Für I<-1 Bis Ende Mit Schritt 1 Machen
Schreiben I;
FinPara
FinProceso

Jetzt wird das Programm dynamischer, wir können die Nummer angeben
Die Anzahl der Wiederholungen des Zyklus, wobei eine ganze Zahl zur Anzeige des Endes verwendet wird

des Zyklus.
Beispiel für die Verwendung der Schleife Für, um die Fakultät einer Zahl zu berechnen.

Prozess Zyklus_Für_negativ_mit_Fakultät
Definiere I, Zahl, Fakultät Als Ganzzahlen;
fakultät<-1;
Geben Sie die Zahl ein, um deren Faktorielle zu bestimmen
Leer Nummer;
Für I<-1 bis Nummer Mit Schritt 1 Machen
fakultät <- fakultät * I;
FinPara
Der Faktorielle von {nummer} ist {faktorielle};
FinProceso
In dieser Übung wird die Fakultät bei 1 begonnen, weil sie eine Multiplikation akkumuliert und
Wenn wir es von Null starten, würde es das Ergebnis Null ergeben, wenn wir 3 eingeben, der Zyklus
Es wird 3 Mal ausgeführt, das Faktorielle würde den Wert von 1x2x3 annehmen.

Flussdiagramm:

Seite 34
 Programmierung mit PSeInt

Negative Zyklen
PSeInt kann auch negative Schleifen durchführen, um beispielsweise anzuzeigen
Sequenzen von größer nach kleiner, nur die Reihenfolge der Zahlen umkehren
vorherige Übung und als Schritt -1 einfügen
Proceso ciclo_Para_negativo
Definiere I als ganzzahlig;
Für I<-10 bis 1 mit Schritt -1 machen
Schreiben I;
FinPara
FinProceso
Hinweis: In negativen Zyklen kann der Schritt nicht übersprungen werden.

Verschachtelte Schleifen

Wenn ein Zyklus in einem anderen Zyklus enthalten ist, nennt man ihn einen geschachtelten Zyklus.

Beispiel für eine verschachtelte Schleife

Produzieren Sie die folgende Ausgabe auf dem Bildschirm

11111
22222
Seite 35
 Programmierung mit PSeInt

33333
44444

Prozess geschachtelter Zyklus

Definiere I,k als Ganzzahlen;
Para I <- 1 Hasta 4 Hacer
Für K <-1 Bis 5 Machen
Schreiben I Ohne Herunterladen;
FinPara
Schreiben "";
FinPara
FinProceso

Wenn wir verschachtelte Schleifen verwenden, sind die Variablen zur Steuerung der Schleifen für

Sie müssen unterschiedlich sein, da jede von ihnen einen unterschiedlichen Wert annimmt, in diesem

Übung wir benötigen, dass der Zyklus, der darin ist, 5 Mal durchlaufen wird, was ist das

die 4-mal den Wert von I präsentiert, dann springt eine Zeile, damit sie erscheinen.
die Zahlenmengen in jeder Zeile.

Seite 36
 Programmierung mit PSeInt
Beispiel für eine geschachtelte Schleife

Geben Sie 5 Zahlen ein und berechnen Sie die Fakultät für jede der Zahlen.

In dieser Übung müssen wir 5 Zahlen eingeben, aber jedes Mal, wenn
Lassen Sie uns eine Zahl eingeben, wir müssen die Fakultät berechnen, also

Wir benötigen eine Variable zur Berechnung der Fakultät, die zwingend hat
dass es sich bei jedem Start des Zyklus, der die Fakultät berechnet, auf 1 initialisiert.
manera estaremos seguro que la variable no ha acumulado el valor del factorial
anterior
Jetzt deduzieren wir aus dem Vorangegangenen, dass wir einen Zyklus benötigen, um die Daten abzufragen und

ein weiterer zur Berechnung der Fakultät.

Faktorenprozess
Definiere I,k,fac,num als Ganzzahlen;
Von 1 bis 5 machen
Geben Sie eine Nummer ein;
Leer Num;
fac<-1;
Für k <-1 bis num machen
fac<-fac*K;
FinPara
Schreibe "Fakultät von ", num, " ist ", fac;
FinPara
FinProceso

Seite 37
 Programmierung mit PSeInt
Wiederholungsschleife

Syntax:

Wiederholen

Anweisungen;

Bis zu welcher Bedingung

Descripción

Die Schleife Wiederholen ist das Gegenteil der Schleife Während, in dieser wird die Ausführung durchgeführt.

cabo bis die auferlegte Bedingung erfüllt ist.

Der Unterschied zur While-Schleife besteht darin, dass diese die Bedingung von
der Grundsatz, und wenn dieser nicht eingehalten wird, der Code, der innerhalb von
Körper des While, während nicht ausgeführt wird.

Im Gegensatz dazu bewertet das Wiederholen - Während die Bedingung für das Fortfahren.

ausgeführt werden, nachdem der Code in seinem Körper ausgeführt wurde, das heißt
Der Code wird immer mindestens einmal ausgeführt.

Hinweis: Im flexiblen Profil, bei aktivierter flexibler Syntax oder in der Anpassung ist ebenfalls
möglich, die Struktur zu verwenden

machen
//Anleitungen;
Während dass

Wiederholen
//Anweisungen;
Während dass

als Alternative zu Wiederholen – Während Das entspricht der strengen Syntax.

Denken Sie daran, dass in diesem Fall die Bedingung aufgrund des Unterschieds herausfällt, im Gegensatz zu dem

Wiederholen, dass es gleich ausgeht.

Beispiel zum Wiederholen

Geben Sie den Namen des Schülers und die Note ein, dann fragen Sie, ob er fortfahren möchte.

final präsentieren die Anzahl der Bestanden und Durchgefallenen.

Seite 38
 Programmierung mit PSeInt
Beispielprozess_wiederholen
Definiere resp als Charakter;
Definiere die Note als real;
Definiere ca, cr als Ganzzahlen;
Dimension nombre[25];
Definiere Namen als Zeichenkette;

ca<-0;
cr<-0;
Wiederholen
Geben Sie den Namen des Schülers ein;
Leer Name;
Geben Sie die Note des Schülers ein;
Leere Notiz;
Wenn die Note >= 60 ist, dann
ca<-ca+1;
Sino
cr<-cr+1;
FinSi

Möchten Sie fortfahren J/N?

Leer resp;
Hasta Que resp='n' | resp='N';
Genehmigt
Reprobados
FinProceso

Wenn wir dieses Programm mit dem vergleichen, was mit der While-Schleife gemacht wurde, werden wir feststellen

dass wir der Variablen Resp einen Anfangswert von 'S' geben, damit sie sich von N unterscheidet.
da die Bedingung zu Beginn der Schleife überprüft wird, aber jetzt mit der Wiederholungsschleife
Es ist nicht notwendig, denn der erste Wert von resp wird innerhalb der Schleife genommen, der ist die

Frage, die wir stellen, ob er fortfahren möchte, und dann überprüfen wir die Bedingung.

Algo importante del ciclo Repetir es, como ya se dijo, que se ejecuta por lo
weniger als einmal, bevor die Ausstiegsbedingung der Schleife validiert wird, ist das der Grund,

dass wir immer ein Programm schreiben, das die Bedingung überprüft, bevor
Um in den Zyklus einzutreten, muss die Schleife "Während" verwendet werden.

Das vorherige Programm ist nicht die endgültige Version, da wir es anpassen müssen, um dass das

Benutzer geben Sie nur S oder N ein, wenn Sie antworten, ob Sie fortfahren möchten, das führt uns zu

einen Wiederholungszyklus innerhalb des Wiederholungszyklus schreiben, um die Antwort zu erfragen und zu machen

Seite 39
 Programmierung mit PSeInt
dass es den Zyklus nur verlässt, wenn es mit S oder N antwortet, auf diese Weise werden wir

seguros de que la repuesta es correcta.

Proceso ejemplo_repetir
Definieren Sie resp als Charakter;
Definiere nota als real;
Definiere ca, cr als ganze Zahlen;
Dimension nombre[25];
Definiere Namen als Zeichenkette;
ca<-0;
cr<-0;
Wiederholen
Geben Sie den Namen des Schülers ein;
Leer name[25];
Geben Sie die Note des Schülers ein;
Leere Notiz;

Wenn Note >= 60 Dann

ca<-Var-ca+1;
Sino
cr<-cr+1;
FinSi
Wiederholen
Möchten Sie fortfahren J/N
Leer resp;
Hasta Que resp='N' | resp='S'

Bis resp='N';
Genehmigt
Nicht bestanden
FinProceso

Seite 40
 Programmierung mit PSeInt

Teilprozesse
Ein Unterprozess ist ein Unterprogramm, Verfahren oder eine Funktion, die eine
spezifische Aufgabe, die durch 0, 1 oder mehr Parameter definiert werden kann. So sehr
informationsaufnahme im subprocess wie die rückgabe von ergebnissen von
Die Subroutine wird durch Parameter durchgeführt, die uns helfen, einzugeben oder
Hauptprogramminformationen ändern.

Syntax

SubProceso NombreSubProceso

// ...etwas mit den Argumenten machen

FinSubProceso

Die Unterprozesse können einen Rückgabewert haben oder auch nicht. In diesem Fall, dieses

Subprozess gibt nichts zurück, die Subprozesse, die Argumente zurückgeben, tun dies

Wir werden später sehen.

Immer wenn wir Parameter verwenden, müssen diese vom gleichen Datentyp sein, dies
uns sagt, dass die Programmvariable vom gleichen Typ wie der Parameter sein muss
Verfahren und Vergangenheiten in der gleichen Reihenfolge, in der sie angeordnet sind.

Unterprozess.

Hinweis: Die Variablen müssen in allen Unterprozessen definiert werden.

Beispiel: einen Teilprozess erstellen, der 5 Sterne in einer Zeile anzeigt

horizontal.
SubProceso asteriscos
Definiere I als Ganzzahl;
Für i <- 1 bis 5 machen
Escribir "*" Sin Bajar;
FinPara
FinSubProceso

Seite 41
 Programmierung mit PSeInt
Hauptprozess
Dimension nombre[25];
Definiere Name als Zeichenkette;
Geben Sie den Namen ein ..:
Leer name[24];
Asterisken;
Schreiben "";
Schreibe Namen[24];
Schreiben "";
Sternchen
FinProceso

In diesem Programm verwenden wir einen Unterprozess (Funktion - gleichwertiges Wort, PSeInt)

auch die Entnahme-, oder Verfahren) um 5 Sternchen zu schreiben, falls wir dies nicht getan hätten

so gemacht, wo sich die Anleitung Sternchen befindet; hätten wir

was den Zyklus betrifft, würden wir es zweimal so schreiben, wie wir es geschrieben haben
más estructurado, pues se divide ese proceso en un subprograma, que cuando
wir benötigen eine Linie aus 5 Asterisken, wir rufen nur das Verfahren auf.

Hinweis: Die subprocesses ohne Parameter werden vom Hauptprozess aufgerufen

einfach nur durch seinen Namen, ohne weitere Argumente, können sie geöffnet und geschlossen werden

Klammern, aber das ist optional.

Im Gegensatz dazu müssen, wenn der Unterprozess Parameter enthält, diese angegeben werden.

Jetzt im vorherigen Programm benutze ein statisches Verfahren, es wird immer 5 schreiben
Asterisken, jetzt können wir es dynamisch machen, indem wir Parameter verwenden, um anzuzeigen

Wie viele Sternchen möchten wir in der Zeile präsentieren.

Flussdiagramm-Visualizer
Die Unterprozesse im Flussdiagramm werden wie folgt dargestellt

Seite 42
 Programmierung mit PSeInt

Una lista con los SubProcesos marcados con rojo:

Man wählt aus, in welchen Unterprozess man einsteigen möchte, indem man auf den Unterprozess klickt. Wie die

Erfassung, es ist auch möglich, neue Subprozesse hinzuzufügen.

Wertparameter

Dieser Parameter wird als Wertparameter bezeichnet,

Es muss angegeben werden, ob es nach Wert oder nach Referenz ist; standardmäßig ist es nach Wert.

letzte Art von Parameter, obwohl sich sein Wert während des Verfahrens ändert.
Wert wird nicht der Hauptprogramm-Variable zugewiesen, zum Beispiel wenn die
Der Variable num des Programms, das wir unten vorstellen, wird ein anderer Wert zugewiesen.

Anders als bei 10 würde sich diese Änderung in der Variablen num widerspiegeln, und deshalb in der

Hauptprogramm, es handelt sich um diese Art von Parametern, die als bekannt sind

Wertparameter.

Beispiel Unterprozess mit Wert

Subprozess Asterisken
Definieren Sie num, I als Ganzzahlen;

Seite 43
 Programmierung mit PSeInt
num <- 10;
Für i <- 1 bis num mit Schritt 1 machen
Schreibe "*" ohne herunterzulassen;
FinPara
FinSubProzess

Hauptprozess
Dimension name[25];
Definiere Name Als Zeichenkette;
Definieren Sie num als Ganzzahl;
num<-10;
Geben Sie den Namen ein ..:
Leerer Name[24];
Sternchen
Schreiben "";
Schreiben Sie Namen[24];
Schreiben "";
Sternchen
FinProceso

In der Zeile num <-10 weisen wir dem Parameter num der Sterne den Wert zu.
de 10 , esto hace que el ciclo recorra 10 veces, luego mas abajo del programa en
die Anweisungsterne; eine Variable wurde als Parameter übergeben und zugewiesen
Wert von num auf eine Zahl, wobei die Zahl im Hauptprogramm einen Wert von hat
10 el cual se le asigna a numero en el paso del valor de parámetro .

Variablenparameter

Das folgende Programm zeigt uns die Verwendung von Variablenparametern oder
Referenz, vor denen das reservierte Wort VAR steht, um anzuzeigen, dass
Diese Variable wird ein Referenzparameter oder eine Variable sein, das zeigt uns an, dass

Jede Änderung, die die Variable des Verfahrens erfährt, die Variable des
Das Hauptprogramm wird ebenfalls darunter leiden, auf diese Weise können wir senden

Informationen ändern und Ergebnisse an das Hauptprogramm senden.

Die Syntax ist wie folgt:

Beispielparameter von Variablen oder Referenzen.

Elaborar un programa donde se ingrese el nombre y el apellido usando un

Seite 44
 Programmierung mit PSeInt
Verfahren und dann Daten präsentieren.

SubProzess Daten_bitten (name Per Referenz, nachname Per Wert)

Gib den Namen ein
Leer nombre;
Nachname eingeben
Leer apellido;
FinSubProzess

Hauptprozess
Definir nombre, apellido Como Cadenas;
nombre<-"No hay cambios en nombre";
apellido<-"No hay cambios en apellido";
Pedir_datos(nombre,apellido);
Vollständiger Name:
FinProceso
Hinweis: Wenn die Variable durch Referenz übergeben wird, muss dies immer angegeben werden.
Im Gegensatz dazu kann bei der Übergabe nach Wert die Übergabeangabe weggelassen werden. Immer

Standardmäßig wird per Wert übergeben.

Im vorherigen Programm werden die Variablen für Nachname und Vorname initialisiert, dann wird
werden als Parameter an den Subprozess übergeben, der Vorname als Variable und der Nachname

Wie Wert dann schreiben wir die Werte und nur der Name wird die Änderung zeigen
was im Subprozess gelitten hat und der Nachname wird weiterhin denselben Wert schreiben wie
Ich hatte das zu Beginn des Programms, weil es nicht als Parameter übergeben wurde.

Variable (VAR), jedoch als Wert und es wurde ihr keine Modifikation erlaubt.

Um das vorherige Programm zu verbessern, müsste das Verfahren so geschrieben werden,

unter Verwendung eines Ausgangsparameters, den wir später sehen werden:

SubProceso nombre, apellido <- pedir_datos (nombre por Referencia)

Dimension Nachname[30];
Definir apellido Como Cadena;
Geben Sie den Namen ein
Leer nombre;
Geben Sie den Nachnamen ein
Leer Nachname;
FinSubProceso

Seite 45
 Programmierung mit PSeInt
Beispiel

Geben Sie die Basis und den Exponenten ein und berechnen Sie dann die Potenz.

In diesem Programm werden wir einen Unterprozess für die Eingabe der Daten und einen anderen verwenden.

um die Leistung zu berechnen.

Teilprozess Eingabe (Basis Nach Referenz, Export Nach Referenz)
Geben Sie die Basis ein;
Leere Basis;
Geben Sie den Exponenten ein;
Leer Expo;
FinSubProzess

SubProceso pot <- Potencia(base , expo, pot Por Referencia)

pot<-1;
Para I <- 1 Hasta expo Con Paso 1 Hacer
topf <- topf * basis;
FinPara
FinSubProceso

Hauptprozess
Definiere pot als Ganzzahl;
Ingreso (base,expo);
Potenz (Basis, Exponent, Potenz);
Potenz ist
FinProceso

En el subproceso de ingreso los dos datos , exponente y base son de tipo entero
und Parameter von Variablen, das liegt daran, dass wir benötigen, dass das Verfahren uns

Geben Sie die Werte zurück, um sie anschließend in das Verfahren Potenz einzufügen, aber
hier, basis, expo sind vom Werttyp, weil wir sie nicht ändern oder lesen müssen
seinen Wert wie zuvor im Eingangsverfahren, dann die
Variable kann als Parameter von Variable übergeben werden, da wir benötigen
Ändern Sie seinen Wert und präsentieren Sie ihn im Hauptprogramm.

Hinweis: Unterprozesse können nicht denselben Namen wie die Variablen haben, die sie
werden im Programm deklariert.

Subprozesse, die Wert zurückgeben oder mit Rückgabewert

Seite 46
 Programmierung mit PSeInt
Die Unterprozesse können ebenfalls einen Wert zurückgeben, jedoch nur einen.

Syntax

Syntax

SubProceso valor_de_retorno <- nombre_SubProceso [( parámetros ) ]

//[variables locales];

//Anweisungen;

FinSubProzess

Si notamos en la sintaxis de la función observamos que esta la palabra retorno la

welches einen Wert zurückgibt, der vom gleichen Typ sein muss, der deklariert wurde
valor_de_retorno.
Hinweis: Das Wort Funktion kann auch interchangeable verwendet werden anstelle von
Teilprozess. In PSeInt sind sie gleichwertige Begriffe.

Beispiel: Berechnung der Leistung

Wir werden dieselbe Übung verwenden, die wir für die Prozesse verwendet haben, um eine
Demonstration, wie sich das Programm ändern würde, wenn ein Unterprozess ohne Rückgabe verwendet wird.

für die Berechnung der Leistung.

Subprozess resp <- potenz (basis, expo Per Referenz)
Definiere i, resp als Ganzzahlen;
resp<-1;
Für I <- 1 bis expo mit Schritt 1 mache
resp <- resp * basis;
FinPara
FinSubProceso

Unterprozess Eingabe (Basis Nach Referenz, Export Nach Referenz)

Geben Sie die Basis ein;
Leerer Grund;
Geben Sie den Exponenten ein;
Leer Expo;
FinSubProzess

Hauptprozess
Eingang(Basis, Expo);
Definiere pot als Ganzzahl;
pot<-Potenz(Basis,Exponente);
Seite 47
 Programmierung mit PSeInt
Potenz ist , pot;
FinProceso

Diagrama de flujo del procedimiento ingreso:

Flussdiagramm des Eingangsverfahrens:

Seite 48
 Programmierung mit PSeInt

Wenn wir dieses Flussdiagramm oder den Pseudocode betrachten, in der Funktion Potencia
Eine Variable wird deklariert, die für die Schleife ist, und die andere ist für die Berechnung.

von der Potenz, die wir als Akkumulator der Multiplikation verwenden werden
Leistung, und nach der variableresp, wiederum nach dem Schlüsselwort
Subprozess, der uns den Wert zurückgibt und ihn der Variablen pot zuweist
Im Hauptprogramm, wenn wir die Anweisung pot<-potencia(base verwenden
Referencia, expo Por Referencia);.

Zusammenfassend lässt sich sagen, dass Funktionen uns immer einen Wert zurückgeben, der das Produkt von

eins oder mehrere Berechnungen, und der Wert der Variablen, die wir danach gesetzt haben, wird zurückgegeben

das Schlüsselwort Teilprozess.

Beispiel für ein Formular (Unterprozesse mit und ohne Rückführung)

Der Name, der Umsatz und die Zone des Mitarbeiters werden eingegeben mit einem

Verfahren, dann wird die Provision basierend auf der Arbeitszone und IHSS berechnet.
Der Gesamtbetrag zu zahlen wird dann die Daten präsentiert.

Seite 49
 Programmierung mit PSeInt
Hinweis:

•Es sollte ein Rückgabe-Teilprozess für die Berechnungen verwendet werden und die

Präsentation der Daten.

•Einen Rückgabe-Subprozess für die Berechnung des IHSS verwenden.

•Ein Unterprozess mit Rückgabe für die Berechnung der Provision verwenden.

Unterprozess der Eingabe

In diesem nicht rückführbaren Teilprozess werden die Daten eingegeben, wobei validiert wird, dass die Zone nur

Meer A,B,C

Unterprozess der Berechnung

Die Provision und IHSS wird unter Verwendung der deklarierten Subprozesse ohne Rückkehr berechnet.

zuvor, dann die Gesamtsumme, die zu zahlen ist, etwas, das wir beachten müssen, ist, dass die

Verkäufe und die Zone werden als Parameterwerte übergeben und die anderen ihss, kommis und tp

als Variablenparameter, weil wir ihren Wert ändern müssen

Unterprozess präsentieren

Wir präsentieren die Berechnungen und übergeben die Variablen als Wertparameter.

weil wir sie nur präsentieren müssen

Subprozess vihss <- sicher(comis)

Definieren Sie Vihss als real;
Wenn du >2400 isst, dann
vihss<- 84;
Sino
vihss<-0.035 * comis;
FinSi
FinSubProzess

Subprozess vcomis <- kommission(zona,verkaufszahlen)

Definiere vcomis als Real;
Gemäß Zone machen
'A' : vcomis<-0.05*ventas;
'B' : vcomis<-0.06*ventas;
'C' : vcomis<-0.09*ventas;
Seite 50
 Programmierung mit PSeInt
FinSegun
FinUnterProzess

SubProceso ingreso (nombre Por Referencia ,zona Por Referencia , ventas

Zur Information)
Geben Sie den Namen ein;
Leer nombre;
Monatliche Verkäufe
Leer Verkäufe;
Repetir
Zone A,B,C
Leerzone;
Bis Zone = 'B' | Zone = 'C' | Zone = 'A'
FinSubProzess

SubProceso calculos (zona, ventas, comis Por Referencia, ihss Por

Referenz, tp Nach Referenz
comis<-kommission(zona,verkäufe);
ihss<-versichern(comis);
tp<-comis-ihss;
FinSubProzess

Subprozess präsentieren (Kommission, IHSS, TP)

Kommission ,komis;
Escribir " Seguro Social ", ihss;
Gesamt zu zahlen
FinTeilprozess

Hauptprozess
Ingreso(nombre,zona,ventas);
Berechnungen(zona,verkauf,provision,ihss,tp);
Präsentieren(comis,ihss,tp);
FinProceso

Die Rückkehr-Subprozesse erklären wir vor den Subprozessen ohne Rückkehr.

Rückkehr, weil diese im Unterprozess ohne Rückkehrberechnungen verwendet werden, und es ist mehr

lesbar zum Zeitpunkt des Lesens eines Programms, aber, für die Zwecke der Ausführung,
PSeInt berücksichtigt nicht die Reihenfolge des Prozesses und der Unterprozesse, es sei denn

dass ein Unterprozess einen anderen aufruft, in diesem Fall muss der aufrufende nach dem

was ist genannt.

Seite 51
 Programmierung mit PSeInt

Hinweis: In strikter Syntax muss die Rückgabeveriable deklariert werden.

Dimensiones
Es ist eine Sammlung von Daten desselben Typs, die an Positionen gespeichert werden.
konsekutive Speicher und erhalten einen gemeinsamen Namen.

Und um auf ein bestimmtes Element zuzugreifen, müssen wir verwenden

Index zur Angabe der Position, die wir extrahieren oder deren Wert wir ändern möchten. Die
Dimensionen können sein:

1-Eindimensional: hat nur eine Dimension, eine Zeile und eine Spalte

2-dimensionale: Tabellen oder Matrizen.

3-Multidimensionales: de 3 o más dimensiones.

Dimension der I Dimension

Erklärung:

Dimension<Name der Dimension> [<Kapazität>];

Definieren Sie <Name der Dimensionsvariable> als <Typ der
variable>;

Kapazität: es ist die Größe der Dimension, es ist eine ganze Zahl, mit der
Wir geben die Anzahl der Elemente an, die wir im gleichen Typ speichern möchten.

Datentyp: es ist der Datentyp, den wir möchten, dass die Sammlung ist, kann sein
ganz, real, Zeichenfolge, Zeichen oder ein Datensatz.

Name der Variable: ist der Name, unter dem wir im Bezug auf die
Hauptprogramm

Hinweis: In strikter Syntax muss die Variable immer davor oder danach definiert werden.

dimensionieren. Im Gegensatz zu anderen Programmiersprachen, eine

Variable bedeutet nicht, dass sie deklariert werden muss.

Seite 52
 Programmierung mit PSeInt

Beispiel:

Dimensionsnummer [10];

Mit dieser Erklärung erstellen wir eine Sammlung von 10 ganzen Zahlen.

3 5 7 8 3 6 9 2 45 67

0 1 2 3 4 5 6 7 8 9

Nota:Al igual que en los lenguajes de programación reales, en sintaxis estricta,

Die Basis der Dimension ist 0, aber in flexibler Syntax oder flexiblem Profil ist die Basis 1.
Um variable Dimensionen zu nutzen, müssen wir die Option aktivieren, die Nutzung zu erlauben.
Variablen zur Dimensionierung von Arrays in den Optionen des Profils.

Immer wenn wir auf eines der Elemente der

Dimension, wir müssen die Position mit einer Ganzzahl angeben, die sich
innerhalb des Bereichs.

Anschließend definieren wir die Art der Dimension:

Definiere Nummer als Ganzzahl:

Wenn wir den Wert der Position 7 schreiben wollen, müssen wir schreiben:

Schreibe nummer[7]; //Von dieser geben wir an, dass wir die Position 7 schreiben

o
Ich <- 7 //wir weisen einen Wert einer Ganzzahl-Variable zu

Escribir numero[ 0 ]; // dann verwenden wir die Variable I, um die Position anzuzeigen

Was wir präsentieren möchten.

// Wenn wir Werte einem Element der Dimension zuweisen möchten, können wir dies tun.
// machen:

Leer Nummer[2];// wir geben direkt die Position an, die wir lesen möchten

Seite 53
 Programmierung mit PSeInt
Ich <-6// Wir weisen einer Ganzzahl-Variable einen Wert zu und verwenden sie dann

Leer nummer[ i ];// um das Element anzugeben, das wir lesen möchten

Beispiel

Geben Sie 10 Zahlen in ein Array mit 10 Elementen ein und präsentieren Sie diese dann.

Zahlen.

In diesem Programm müssen wir eine Schleife verwenden, in der die Variable I einen Wert von

0..9, um die Werte zu lesen oder Werte der Dimension zuzuweisen, werden wir später einen anderen verwenden.

Zyklus zur Präsentation der Daten.

Wenn wir die Daten in einer Dimension speichern, werden ihre Werte in
das Gedächtnis und wird nicht gelöscht, nachdem die nächste Zahl gelesen wurde, wie in den

frühere Programme, als wir eine Variable verwendeten, um 10 Zahlen einzugeben,

aber die Variable am Ende des Eingangs speicherte nur die letzte Zahl, die man
Einführung, jetzt werden mit den Arrays die 10 Zahlen im Speicher abgelegt.

Hinweis: Wenn PSeInt so konfiguriert ist, dass es mit Basis 0 arbeitet und eine definiert wird

Dimension mit der gleichen Anzahl von Elementen wie im letzten Deklaration angegeben

Das eingegebene Element wird keinen Speicherplatz in der Dimension haben.

eingetragen. Das können wir ändern, indem wir das Profil anpassen oder eine Syntax verwenden.

flexibel.

// Programm zur Eingabe von 10 Zahlen in eine Dimension

Prozess dimension_10
Dimension nummer[10];
Definieren Sie die Nummer als Ganzzahl;
Definir I Como Entero;

Für I <- 0 Bis 9 Mit Schritt 1 Machen

Geben Sie die Nummer der Pos#
Leer nummer[I];
FinPara

Für I <- 0 bis 9 machen

Schreibe Nummer[I];
Seite 54
 Programmierung mit PSeInt
FinPara
FinProceso
Ejemplo

Geben Sie den Namen des Mitarbeiters in eine Dimension und das Gehalt in eine andere ein.

Dimension, nachdem die Daten eingegeben wurden, den IHSS und den Gesamtbetrag zu zahlen bestimmen.

für jeden der Mitarbeiter.

In diesem Programm werden der Name des Mitarbeiters und das Gehalt in zwei gespeichert

verschiedene Arrangements den Namen in einem Array von Zeichenfolgen und das Gehalt in einer

Dimension vom Typ Real, zuerst werden die Daten in die Dimension eingegeben, dann wird ...
Die Daten werden in einem anderen Zyklus berechnet, um zu betonen, dass die Anordnungen die speichern

Daten im Speicher während das Programm läuft und wir sie später verwenden können
Nachdem die Daten eingegeben wurden, was wir zuvor nicht tun konnten, da wir beim Eingeben des

Element 10 in the variable, we could only store that one, that's why the
Berechnungen wurden im selben Zyklus durchgeführt.

Prozess dimensions_mitarbeiter
Dimension name[5];
Definiere Namen als Zeichenkette;
Dimension Gehalt[5];
Definir sueldo como Entero;
Definieren Sie ihss,tp als Reale;
Definiere I als Ganzzahl;

Für I <- 0 Bis 4 Machen

Schreiben Sie "Name des Mitarbeiters [",i,"]..:";

Leer nombre[i];
Gehalt des Mitarbeiters ...:
Leer Gehalt[i];
FinPara

Von 0 bis 4 machen

Wenn sueldo[i] > 2400 Dann
ihss<-84;
Sino
ihss<-0.035*sueldo[i];
FinSi
tp<-Gehalt[i]-ihss;
Seite 55
 Programmierung mit PSeInt
Schreibe "Name ...:", name[i];
Sueldo ...: sueldo[i];
Ihss ...:
Escribir "Total pagar..:",tp;
FinPara
FinProceso

Hinweis: Um variabel dimensionale Dimensionen nutzen zu können, ist es notwendig

flexibles Profil im Editor aktivieren.

Verwendung von Arrays als Parameter in Threads und Funktionen

Im gezeigten Beispiel wird die Verwendung von Arrays in den

Subprozesse und Parameter, das Beispiel zeigt einen Subprozess ohne Rückgabe für das
Eingabe von Daten in eine Dimension von 5 ganzen Zahlen, dann wird eine verwendet.

Die Funktion 'größer als' gibt uns die Nummer der Dimension zurück.

SubProceso nummayor <- mayor (num)

Definiere nummayor, als Ganzzahlen;
nummayor<-0;
Für i <-0 bis 4 mit Schritt 1 Machen
Wenn num[i] > nummayor Dann
nummayor<-num[i];
FinSi
FinPara
FinUnterprozesse

SubProceso ingreso (num)

Definiere i als Ganzzahl;
Für i <-0 Bis 4 Machen
Geben Sie eine Nummer ein;
Leer num[i];
FinPara
FinSubProzess

Hauptprozess
Dimension num[5];
Definieren Sie num, max als Ganzzahlen;
Ingreso(num);
Max<-Bürgermeister(num);
Größer, max;
Seite 56
 Programmierung mit PSeInt
FinProceso
Hinweis: Standardmäßig werden Arrays immer nach Referenz übergeben. Versuche es nicht.
Es nach Wert übergeben, sonst würdest du einen Fehler verursachen.

Größere Funktion

In dieser Funktion wird die größere Zahl bestimmt, indem die Zahlen verglichen werden, die sich

Wenn die Funktion nummayor gestartet wird, hat sie den Wert null, aber nehmen wir an, dass

wir geben in das Arrangement 3-5-4-2-8 ein

Wenn das erste Element der Dimension mit 3 verglichen wird, gibt es eine neue
Zuweisung für nummayor, das größer als 3 ist, wenn es mit 5 verglichen wird, ist 3 kleiner als

5 hay una nueva asignación a nummayor es 5, cuando se compara con 4 el 5 no

es kleiner als vier, also wird nummarot kein Wert zugewiesen und bleibt mit
Die 5 wird jetzt mit 8 verglichen, 8 wird zugewiesen, weil die 5 ist
weniger als 8.

Num Nummayor

wenn num[0] 3 ist Also kostet es 3

wenn num[0] 5 ist Dann kostet es 5

wenn num[0] 4 ist Es gibt kein Wechselgeld und es bleibt bei 5.

wenn num[0] 2 ist Es gibt kein Wechselgeld und bleibt bei 5

wenn num[0] 8 ist Dann kostet es 8

Dimension der II Dimension (Bidimensional)

Erklärung:

Dimension<Name der Variable>[<Zeilen>, <Spalten>];

Sie werden auch Matrizen oder Tabellen genannt. Eine zweidimensionale Dimension ist eine Tabelle.

die jetzt Zeilen und Spalten hat, wobei die Zeilen die erste Dimension anzeigen und die
Spalten die zweite Dimension.

Seite 57
 Programmierung mit PSeInt

0 1 2 3

Die dargestellte Tabelle zeigt uns eine Dimension mit 2 Dimensionen und 5
Linien und 4 Spalten, der Code, um diese Dimension zu deklarieren, wäre:

Dimension nummer[5,4];

Die Bezugnahme auf ein bestimmtes Element der Matrix erfordert den Einsatz eines
Erstens der Index, der die Zeile anzeigt, und zweitens der, der die Spalte anzeigt. Beide
Subindizes müssen vom ganzzahligen Typ sein.

Por ejemplo si quisiéramos guardar el valor de 30 el la línea 4 columna 3 el

Der Code in PSeInt wäre:
Nummer[4,3]<-30;

Das folgende Beispiel zeigt uns, wie man Daten in eine Dimension von 5 eingibt.
Linien und 4 Spalten, um die Daten dann auf dem Bildschirm darzustellen:

Prozess_dimensional_5_Linien
Dimension nummer[5,4];
Definiere Zahl als Ganzzahl;
Definiere L, C als Ganzzahlen;

Für L <- 0 bis 4 mit Schritt 1 machen

Für C <- 0 bis 3 mit Schritt 1 machen
Schreiben Sie "Nummer[", L , ",", C, "]";
Leer nummer[L,C];
FinPara
FinPara
Seite 58
 Programmierung mit PSeInt
Bildschirm reinigen;
Für L <- 0 bis 4 mit Schritt 1 machen
Für C <- 0 Bis 3 Mit Schritt 1 Machen
Schreibe Zahl[L,C]," " Ohne zu senken;
FinPara
Schreiben "";
FinPara
FinProceso

In diesem Programm verwenden wir zwei ganzzahlige Variablen L, die für die Zeilen verwendet wird und

C, das für die Spalten verwendet wird, nutzen wir geschachtelte Schleifen, weil du brauchst

Für jede Zeile, alle Spalten durchlaufen, das geschieht so:

Wenn das L den Wert 1 hat, nimmt das C den Wert von 1 bis 4 an, das führt dazu, dass sich

kann das Element Nummer [1,1], Nummer [1,2], Nummer [1,3], Nummer [1,4] lesen
Dann, wenn der Wert von L 2 beträgt, beginnt das l wieder von 1 bis 4.
das Gleiche 5 Mal tun, was der Anzahl der Zeilen entspricht.

Summe der Zeilen und Spalten eines zweidimensionalen Maßes

Das vorgestellte Programm erfasst die Daten und präsentiert sie mit einem
subproceso sin retorno.
Hinweis: Es gibt keine Spalte oder Zeile 0

SubProceso sum <- SumaLinea (numero, linea)

Definiere sum, C als Ganzzahlen;
sum<-0;
Wenn Linie >=1 | Linie <=5 Dann
Für C<-1 Bis 4 Mit Schritt 1 Machen
sum<-sum + numero[linea-1,C-1];
FinPara
FinSi
FinSubProzess

Subprozess sum <- SumaColumna (nummer, spalte)

Definieren Sie sum, L als Ganzzahl;
sum<-0;
Wenn col>=1 | col<=4 Dann
Für L<-1 bis 5 mit Schritt 1 machen
sum<-sum + nummer[L-1, col-1];
FinPara
Seite 59
 Programmierung mit PSeInt
FinSi
FinSubProzess

SubProceso ingreso(numero)
Definiere L, C als Ganzzahlen;
Für L <- 1 Bis 5 Mit Schritt 1 Machen
Für C <- 1 Bis 4 Mit Schritt 1 Machen
Geben Sie eine Zahl ein ..:
Leer nummer[L-1,C-1];
FinPara
Schreiben "";
FinPara
FinUnterProzess

SubProceso presentar (numero)

Definiere L, C als Ganzzahlen;
Bildschirm reinigen;
Für L <- 0 bis 4 machen
Für C <- 0 Bis 3 Machen
Schreibe Nummer[L,C]," " Ohne Absetzen;
FinPara
Escribir "";
FinPara
FinSubProzess

Hauptprozess
Dimension nummer[5,4];
Definiere Nummer Als Ganzzahl;
Definieren Sie linea, col, sumaC, sumaL als Integer;
Eingabe(zahl);
Präsenze(nummer);
Linie zu summieren
Leere Zeile;
Spalte zu summieren
Leer col;
sumaL<-sumaLinea(zahl, linie);
sumaC<-sumaColumna(numero,col);
Summe der Spalte
Schreibe "Die Summe der Zeile", zeile, "ist", summeL;
FinProceso

Hinweis 1: Die Parameterarrangements werden im Unterprozess nicht deklariert, weil

Seite 60
 Programación con PSeInt
Sie sind immer anhand eines Verweises. Andernfalls erscheint ein Schild mit der Aufschrift 'Nicht'

muss den Typ des Arguments neu definieren.

Hinweis 2: Die Arrangements des Parameters, sowohl wenn die Arrays an ein anderes übergeben werden

Prozess/Unterprozess, wie wenn auf den Unterprozess verwiesen wird von dem
Der Hauptprozess gibt seine Kapazität nicht an.

Theoretische Informationen

Registre oder Strukturen

Hinweis: Die Informationen zu den Aufzeichnungen werden theoretisch betrachtet. Im Moment ist PSeInt nicht verfügbar.
unterstützt Aufzeichnungen oder Strukturen.

Ein Datensatz ist eine strukturierte Information, die aus logisch verbundenen Elementen besteht.

verwandt, die vom gleichen oder von verschiedenen Typen sein können, an die
bezeichne Felder. Die Felder eines Datensatzes könnten von den Typen sein
vorab von PSeInt definiert (ganzzahlig, real usw.) oder durch einen Datensatz
vorher definiert

Beispiel: Demonstration von Aufzeichnungen

In diesem Programm verwenden wir ein Register, um die Informationen des Schülers zu speichern.

unter Verwendung eines Registers, das Alum heißt.

Immer wenn wir auf einen Datensatz zugreifen wollen, wird dies gemacht.

[Link];

Also, wenn wir auf den Namen zugreifen wollen, würden wir schreiben

[Link];
Alum, weil so die Variable heißt, die vom Typ registro re_alumno ist.

Registrierung Alum
Dimension nombre[30];
Definieren Sie Namen als Zeichenkette;
Dimension carrera[30];
Definieren Sie Karriere als Kette;
Definiere Konto Als Ganzzahl;
FinRegistro

Hauptprozess

Seite 61
 Programmierung mit PSeInt
Der Name des Schülers
Leer [Link];
Schülerkonto
Leer [Link];
Studiengang, der untersucht
Leer [Link];
Der Schüler, [Link];
Schreiben " Mit Konto ", [Link], " Studiere ",
[Link];
FinProceso

Jetzt ist das Wichtigste, dass wir Register als Parameter in den
Subprozesse mit Rückgabe und ohne Rückgabe, um das Übertragen von Informationen zu erleichtern.

als Parameter.

Beispielaufzeichnungen mit Unterprozessen

Es soll ein Programm erstellt werden, in dem der Name des Schülers und die Note eingegeben wird.

acumulada, examen, nota final y observación, luego que se determine la nota

final y observación.

Wir werden ein Protokoll verwenden, um die Informationen zu speichern, einen subprocess ohne Rückkehr.

para el ingreso de datos, otro para calcular la nota final y la observación (se usará
eine Funktion zur Berechnung der Beobachtung.

Wir müssen immer die Parameter der Variablen und von berücksichtigen
Wert, in diesem Programm verwenden Sie in den Unterprozessen Eingabe und Berechnung von Variablen und in

Wert präsentieren, weil keine Variable geändert wird.

// Deklaration des Registers

Alum Registrierung
Dimension nombre[30];
Definieren Sie Namen als Zeichenkette;
Definieren Sie na, ne, nf als Reale;
Dimension obs[10];
Definiere obs als Zeichenkette;
FinRegistro

Seite 62
 Programmierung mit PSeInt
Subprozess vobs <- beobachtung (vobs, notiz)
Definiere vobs als Zeichenkette;
Wenn Note >= 60 Dann
vobs<-"aprobado";
Sino
vobs<-"reprobado";
FinSi
FinProceso

Unterprozess Eingabe(alum)
Geben Sie den Namen ein ";
Leer [Link];
Geben Sie die Prüfungsnote ein
Leer [Link];
Geben Sie die Gesamtnote ein;
Leer [Link];
FinsubProzess

SubProceso calculo(alum)
[Link]<-[Link] + [Link];
[Link]<-Beobachtung([Link]);
FinSubProzess

Unterprozess präsentieren(alum)
Schreiben Sie "Endnote", [Link];
Beobachtung, [Link];
FinSubProzess

Hauptprozess
Definieren Sie I als Ganzzahl;
Für I<- 1 Bis 5 Machen
ingreso(Alum);
calculo(Alum);
präsentieren(Alum);
FinPara
FinProceso

Dimensionen mit Aufzeichnungen

Hinweis: Theoretische Informationen

Bis jetzt haben unsere Arrangements nur einen einzigen Datensatz gespeichert, sei es real,

Seite 63
 Programmierung mit PSeInt
ganzzahl Zeichenfolge oder Zeichen, wenn mehr als ein Datum in einer gespeichert werden soll

Das Feld der Dimension wird als ein Register deklariert und die Dimension wird deklariert, dass sie ist

vom Typ Registrierung, den wir erklärt haben.

Beispiel:

Mitarbeiterregister
Definiere Code als Ganzzahl;
Dimension nombre[30];
Definir nombre Como Cadena;
FinRegistro

Code Código Code Code Code

Nombre Name Nombre Nombre Name

1 2
3
4
5

Wir deklarieren den Angestelltenregister und dann deklarieren wir die Dimension, die sein wird von

Mitarbeitertyp jetzt um auf die Dimension zuzugreifen:

Lectura de datos

Geben Sie den Namen des Mitarbeiters ein;

Leer [Link];
Geben Sie den Registrierungs-Code ein;
Leer [Link];

Beim Lesen muss die Position der Dimension angegeben werden, die
Ich möchte lesen, dass emple(3).nombre uns mitteilt, dass der Name von Position 3 gelesen wird.

Daten schreiben
Schreiben Sie "Name des Mitarbeiters", emple[3].nombre;
Schreib "Registrierungscode", emple[3].codigo;

Genauso wie beim Lesen der Daten, um zu schreiben, geben wir das Element der

Seite 64
 Programmierung mit PSeInt
Dimension, von der wir die Registrierungsdaten präsentieren möchten

Beispiel Dimensionen mit Registrierung.

In diesem Beispiel erklären wir das Register, dann wird die Dimension vom Typ deklariert.

Register, es wird ein irreversibler Teilprozess für die Eingabe der Daten des
Dimension und eine andere, um die Aufzeichnungen der Dimension zu präsentieren.

Als wir erklärtenDimension[5] Mitarbeiter und danach Definieren Mitarbeiter Wie

Beispiel;Im Unterprozess des Zugangs beziehen wir uns darauf, dass wir eine Dimension haben.

5 Elemente, die vom Typ Mitarbeiter sind (der Datensatz) und dass die Variable heißt
Beispiel.

In beiden Unterprozessen wird die Dimension durchlaufen und dann für jede der
Positionen der Dimension werden der Name und der Code gelesen.
Mitarbeiterregistrierung
Definiere Code als Ganzzahl;
Dimension nombre[30];
Definiere Namen als Zeichenkette;
FinRegistro

Eingangsprozess (Mitarbeiter)
Definieren Sie i als Ganzzahl;
Für i <- 0 bis 5 mache
Geben Sie den Namen des Mitarbeiters ein;
Leer [Link];
Geben Sie den Registrierungscode ein;
Leer [Link];
FinPara
FinProceso

SubProceso Presentar (empleado)

Definiere i als Ganzzahl;
Bildschirm reinigen
Für i <- 0 bis 4 mit Schritt 1 machen
Schreiben Sie "Mitarbeitername ", [Link];
Schreiben Sie "Registrierungscode ", [Link];
FinPara
FinProceso

Seite 65
 Programmierung mit PSeInt
Hauptprozess
Ingreso(empleado);
Präsentieren(Mitarbeiter);
FinProceso

Beispiel für Dimensionen mit Registrierung.

In diesem Beispiel deklarieren wir das Register, dann wird die Dimension des Typs deklariert.
Art der Schülerregistrierung, dann verwenden wir eine Funktion, um die Beobachtung zu bestimmen.

Es wird nicht das gesamte Protokoll eingeführt, da nur ein Datum benötigt wird, um die zu bestimmen.

Beobachtung, dann im Berechnungsverfahren zum Zeitpunkt des Versendens der Note

para usar la observación indicamos el elemento de la dimension y la parte del
Registrierung, die wir senden möchten, ist die Notiz:

alum[i].obs<-observacion(alum[i].nf);

// Deklaration des Registers

Registrierung reg_alumno
Dimension nombre[30];
Definiere Namen als Charakter;
Definieren Sie na, ne, nf als Reelle;
Dimension obs[10];
Definiere obs als Kette;
FinRegistro

SubProceso vobs <- observacion

Definiere Note als Real;
Dimension vobs[10];
Definiere vobs Als Kette;
Wenn note >= 60 Dann
vobs<-"aprobado";
Sino
vobs<-"reprobado;
FinSi
FinSubroceso

SubProceso ingreso(alum)
Definiere i als Ganzzahl;
Für i <-0 Bis 5 Machen
Geben Sie den Namen ein ";
Leer alum[i].nombre;
Geben Sie die Prüfungsnote ein
Leer alum[i].ne;
Seite 66
 Programmierung mit PSeInt
Geben Sie die gesammelte Note ein;
Leer alum[i].na;
FinPara

FinSubProzess

Teilprozess Berechnung(alum)
Definir I Como Entero;
Für i <- 0 bis 5 machen
alum[i].nf<-alum[i].na + alum[i].ne alum[i].obs<-
beobachtung(alum[i].nf);
FinPara
FinSubProceso

Subprozess präsentieren (Schüler)

Definieren Sie i als Ganzzahl;
Für i <- 0 bis 5 machen
Schreibe "Name des Schülers ", alum[i].name;
Schreiben Sie "Endnote ", alum[i].nf;
Schreiben "Beobachtung ", alum[i].obs;
FinPara
FinSubProzess

Hauptprozess
Ingreso(alum);
Calculo(alum);
Präsentieren(Schüler);
FinProceso

Beispiel für Arrays mit Datensätzen.

Es wird ein Register mit den Variablen Name Verkäufe, Kommission ihss und Gesamt deklariert
bezahlen, es wird eine Funktion für die Sozialversicherung erstellt, danach wird ein ...

Verfahren zur Eingabe von Daten, bei dem der Name und die Verkäufe eingegeben werden, danach der

Berechnungsverfahren, bei dem die Provision, die 5% beträgt, bestimmt wird.

Verkäufe, die Versicherung unter Verwendung der Funktion der Versicherung und der Gesamtbetrag zu zahlen, dann

Präsentieren Sie die Daten mit einem Verfahren.

Mitarbeiterregistrierung
Dimension nombre[30];
Seite 67
 Programmierung mit PSeInt
Definiere Name als Zeichenkette;
Definieren Sie Verkäufe, Provisionen, IHSS, TP als Real.
FinRegistro

Sichere Unterprozess
Dimension[5] Mitarbeiter;
Definir empleado Como emple;
Definiere Gehalt als real;
Wenn Gehalt >2400 Dann
Zurückgeben 84;
Sino
Rückgabe 0.035*sueldo;
FinSi
FinSubProzess

SubProceso Ingreso (emple)

Dimension[5] Mitarbeiter;
Definieren Sie Mitarbeiter als Beschäftigte;
Definiere i als Ganzzahl;
Für i <- 1 bis 2 mit Schritt 1 mache
Geben Sie den Namen des Mitarbeiters ein;
Leer emple[i].nombre;
Geben Sie die Verkäufe ein
Leere emple[i].ventas;
FinPara
FinSubProzess

Subprozess Berechnung(angestellt)
Dimension[5] Mitarbeiter;
Definir empleado Como emple;
Definiere I als Ganzzahl;
Für i <- 0 Bis 2 Mit Schritt 1 Machen
emple[i].comis<-emple[i].ventas*0.05;
emple[i].ihss<-versicherung(emple[i].kommission);
emple[i].tp<-emple[i].comis-emple[i].ihss;
FinPara
FinSubProzess

SubProceso Presentar (emple)

Dimension[5] des Mitarbeiters;
Definieren Sie Mitarbeiter als Beschäftigte;
Definir i Como Entero;
Seite 68
 Programmierung mit PSeInt
Für i <- 1 bis 2 mache
Schreiben Sie "Mitarbeiter ", emple[i].nombre;
Schreiben "";
Schreiben Sie "Kommission ..:", emple[i].comis;
Schreiben "";
Soziale Sicherheit..:, emple[i].ihss;
Schreiben "";
Gesamt zu bezahlen ..:
Escribir ""
Schreiben "";
FinPara
FinUnterprozess
Hauptprozess
Ingreso(emple);
Calculo(emple);
Präsentieren(Angestellter);
FinProceso

Textdateiverwaltung
Hinweis: Theoretische Informationen

Bis zu diesem Punkt werden alle Ergebnisse der Programme aus dem Speicher gelöscht.
Am Ende des Programms werden wir in diesem Kapitel theoretisch lernen, wie ...
Wir würden die Informationen in einer Textdatei für die spätere Verwendung speichern.

Syntax

Einen Dateityp deklarieren

Declarar un tipo archivo secuencial es necesario para , declarar variable de este

tipo ejemplo :
Typ Arch Es Sequenzielle Datei;

Eine Datei öffnen

Syntax

Öffne nombre_archivo als Variable [zum Lesen, Schreiben]

Beispiel :

Seite 69
 Programmierung mit PSeInt
Öffne "[Link]" als Archemple zum Lesen;

Beschreibung

Diese Anweisung dient zum Öffnen der Datei. Die erlaubten Operationen für die
Eine Datei kann gelesen, geschrieben oder beides werden. In der Syntax bezieht sich die Variable auf eine Variable.

der Dateityp, der verwendet wird, um auf die Datei zu verweisen.

Eine Datei schließen

Syntax

Dateivariable schließen

Beispiel :

Schließen archemple;

Descripción

Diese Anweisung dient dazu, eine Datei zu schließen. Variable

Lese aus einer Datei

Syntax

Leer variable_archivo, variable_datos

Beispiel :
Leer archemple,[Link];

Descripción

Diese Anweisung liest eine Variable aus einer Datei. Die erste Variable von der
Die Anweisung muss vom Dateityp sein, die zweite kann von jedem Typ sein, das ist
Es wird vom Dateityp abhängen.

In eine Datei schreiben

Seite 70
 Programmierung mit PSeInt
Syntax

Schreibe variable_archiv, variable_daten;

ejemplo :
Escribir archemple, [Link];

Descripción

Diese Anweisung schreibt eine Variable in eine Datei. Die erste Variable der
Die Anweisung muss vom Dateityp sein, die zweite kann von irgendeinem Typ sein, das.
Es wird von der Art der Datei abhängen.

Beispiel für die Eingabe von Daten in eine sequenzielle Datei (Text).

Das Erste, was wir tun müssen, ist, mit Windows eine Textdatei zu erstellen.
mit dem Notepad, und wir speichern es unter dem Namen Mitarbeiter, im selben
Verzeichnis, in dem wir das Programm zur Eingabe der Daten speichern werden.

Wir deklarieren den Typ der sequenziellen Datei

Typ Arch ist eine sequenzielle Datei;

dann das Formular, das wir verwenden werden, um die Daten einzugeben

Registro Empleado
Dimension nombre[50];
Definiere Namen als Zeichenkette;
Definiere Gehalt als real;
Definir sexo como Caracter;
FinRegistro

Dann deklarieren wir die Variable zur Handhabung der Textdatei, die vom Typ arch ist und
der Variablentyp Aufzeichnung
Definiere Mitarbeiter als emple;
Definieren Sie ArchEmple als Arch;
Definiere resp als Zeichen;

Dann wird im Programm zunächst die Datei zum Schreiben geöffnet,

Dann werden die Daten angefordert und in der Datei gespeichert, am Ende wird die Datei geschlossen.
Seite 71
 Programmierung mit PSeInt
Text, jetzt wenn wir wissen wollen, ob ich die Daten gespeichert habe, können wir öffnen
Mitarbeiter mit dem Notizbuch und wir werden die Daten sehen, die in der Datei gespeichert wurden.

Tipo Arch Es Archivo Secuencial;

Mitarbeiterregistrierung
Dimension[50] Anzahl;
Definieren Sie den Namen als Zeichenfolge;
Definir sueldo Como Real;
Definir sexo como Caracter;
FinRegistro

Mitarbeiter
Definieren Sie Beschäftigung wie Arch;
ArchEmple
Definiere resp als Charakter;
Öffne "[Link]" als archemple zum Schreiben;
Wiederholen
Name des Mitarbeiters..:
Leer [Link];
Gehalt des Mitarbeiters...
Leer [Link];
Sex ..:
Leer [Link];
Schreiben Sie archemple, [Link];
Schreiben Sie archemple, [Link];
Schreiben Sie archemple, [Link];
Möchten Sie fortfahren ..:
Leer resp;
Hasta Que resp="S" | resp="N";
Bis dass resp='N';
Schließe archemple;
FinProceso

Beispiel Inhalt einer sequenziellen (Text-)Datei auflisten.

Der Dateityp, der Datensatz und die Variablen werden deklariert, um den Datensatz und die
Textdatei, dann wird die Datei zum Lesen geöffnet und eine Schleife wird gemacht, während
Kein Ende der Datei, dies wird mit der Funktion FDA erreicht, die uns zurückgibt
wahr, wenn es sich am Ende der Datei befindet, und falsch, wenn dies nicht der Fall ist.
Die Anweisung Lesen wird verwendet, um die Werte abzurufen, die gespeichert wurden in der
Seite 72
 Programmierung mit PSeInt
Textdatei, dann werden die Werte mit einem Verfahren geschrieben
Registrierung auf dem Bildschirm

Definieren Sie Typ Arch als sequenzielle Datei;

Mitarbeiterregistrierung
Dimension nombre[50];
Definiere Gehalt als real;
Definiere Name, Geschlecht als Charakter;
FinRegistro

Globale Variablen
Definieren Sie Angestellten Als Mitarbeiter;
Definieren Sie ArchEmple als Arch;
Definiere Stoppen als Charakter;
FinVariablesGlobales

SubProceso presentar(emple)
Schreiben Sie "Name des Mitarbeiters ...:", [Link];
Schreiben Sie "";
Gehalt....:,angest. gehalt,
Schreiben "";
Sex......: [Link];
Schreiben Sie "";
Leer anhalten;
FinSubProzess

Proceso principal
Öffne "[Link]" als archemple zum Lesen;
Mientras ~fda(archemple) Hacer
Leer archemple,[Link];
Leer archemple,[Link];
Leer archemple,[Link];
Nennen Sie präsentieren (Beschäftigung);
FinWährend;
Schließe Archemple;
FinProceso

Anhang:

Seite 73
 Programmierung mit PSeInt
Flussdiagramme bearbeiten

PSeInt ermöglicht es, das Flussdiagramm zu bearbeiten, dann die Änderungen vorzunehmen, damit

kann aus Pseudocode ausgeführt werden.

Wir gelangen zum Flussdiagramm-Editor, indem wir Datei -> Diagramme bearbeiten aufrufen
de flujo :

Wir wählen einen Unterprozess aus und klicken auf einen von ihnen

Wir klicken auf den Hauptprozess oder einen beliebigen der Teilprozesse, in diesem
Fall des Teilprozesses Eingabe.

Seite 74
 Programmierung mit PSeInt

Es wird ein Bildschirm angezeigt, der das entsprechende Flussdiagramm zeigt.

Subprozess, den wir ausführen.
A la derecha encontramos una pestaña que ocupa todo el lado derecho de la
Fenster.
Wir klicken darauf.

Seite 75
 Programmierung mit PSeInt

Es wird uns eine Zeichnung mit den verwendeten Strukturen präsentiert, und auf der linken Seite.

inferior erscheint sein Name.

Wenn wir einen neuen Block in das Flussdiagramm einfügen möchten, tun wir Folgendes
Klicken Sie auf einen Block und ziehen Sie ihn bei gedrückter linker Maustaste bis zum
Flussdiagramm. Um den Block zu fixieren, drücken wir die Escape-Taste.
In den Sätzen schreiben, muss der Text in Anführungszeichen gesetzt werden.

Änderungen speichern

Um die Änderungen zu speichern, gehen wir zum Button, der sich auf der linken Seite befindet.

überlegen und wir klicken auf Änderungen speichern.

Es werden keine Flussdiagramme ausgeführt, die nicht gespeichert sind.

Hinweis: Es können auch Diagramme erstellt werden, ohne dass Sie sie schreiben müssen.

entsprechender Pseudocode.

Hinweis: Aufgrund der Arbeitsweise des Flussdiagramm-Interpreten gibt es

Änderungen im Format des Pseudocodes, wenn die Änderungen gespeichert werden seit
Der Flussdiagramm-Editor hat Änderungen am ursprünglichen Pseudocode.
Seite 76
 Programmierung mit PSeInt
zum Beispiel, in Großbuchstaben umgewandelt, usw. Diese Fehler können nach und nach behoben werden.

medida que salgan nuevas versiones de PSeInt.

PSeInt löschen
PSeInt hat keinen Deinstallationsprogramm, daher müssen wir es entfernen.
manuell. Im Allgemeinen ändert es das Protokoll nicht, sodass keine Maßnahmen erforderlich sind.

Keine Änderungen daran.

1) Gehen wir zu C:\Program Files (x86), suchen wir den Ordner PSeInt und den

wir entfernen.
2) Danach gehen wir in den Ordner mit dem Namen, den wir registriert haben.
Maschine und wir löschen den Ordner PSeInt, der sich in diesem Ordner befindet.
3) Wir entfernen die Verknüpfung und starten die Maschine neu.

Den Quellcode öffnen

In diesem Blog wird erklärt, was wir tun müssen, um den Quellcode zu öffnen.
del programa:

Unter Linux

Unter Windows

Seite 77