Este documento explica conceptos fundamentales de programación como constantes, variables, acumuladores, contadores e identificadores. Define constantes como valores fijos que no cambian durante la ejecución de un programa. Explica que las variables almacenan datos que pueden modificarse, y que los acumuladores y contadores son variables especiales utilizadas para sumar valores o contar iteraciones respectivamente. Además, introduce conceptos básicos de programación en Pseint como declarar variables y el uso de acumuladores y contadores.

1. Estructuras básicas: conceptos básicos de programación
Sofia Acosta Escobar
Angela Castañeda Betancourt
Sofía Díaz Rubio
Isabella García Garcés
Laura Murillo Cortez
Karen Ramirez Bueno
Valentina Tabares Rodriguez
Grado 10-3
I.E. Liceo Departamental
Área de Tecnología
Santiago de Cali
2023

2. Tabla de contenido
1. Constantes................................................................................................................................2
2. Variables................................................................................................................................... 3
3. Acumuladores.......................................................................................................................... 4
4. Contadores............................................................................................................................... 6
5. Identificadores..........................................................................................................................7
6. Fundamentos de programación pseint..................................................................................8
6.1. Declarar variables............................................................................................................. 8
6.2. Contadores y acumuladores en pseint..............................................................................8
7. Mapa conceptual......................................................................................................................9
8. Conclusiones..........................................................................................................................10
9. Referencias.............................................................................................................................12
Constantes....................................................................................................................... 12
Variables...........................................................................................................................12
Acumuladores.................................................................................................................. 12
Contadores.......................................................................................................................13
Fundamentos de programación pseint.............................................................................13

3. 1. Constantes
Una constante es un elemento de datos con nombre con un valor predefinido. No
se puede cambiar el valor asignado a una constante predefinida. Las constantes
predefinidas son:
NULL:
Una referencia vacía. Parecido a un puntero vacío. Tenga en cuenta que no es lo
mismo que una cadena de caracteres nula "".
TRUE:
Equivalente al número 1.
FALSE:
Equivalente al número 0.
En general, una constante es un valor de tipo permanente, ya que no puede
modificarse, al menos no dentro del contexto o situación para el cual está.
● En ciencias, especialmente en física, se denomina constante a aquella
magnitud cuyo valor no varía en el tiempo.
● En matemáticas, una constante es un valor fijo, aunque a veces no
determinado.
Una función constante es una función matemática que para cada valor de su
dominio hay un único valor de su codominio. ,
Las constantes son útiles para almacenar datos que no deben cambiar durante
la ejecución del programa, como números fijos, valores constantes matemáticos
(por ejemplo, π), valores lógicos (verdadero o falso) y cadenas de texto que no
varían. En diferentes lenguajes de programación, las constantes se declaran de
manera específica y pueden tener diferentes alcances (locales o globales). Al
usar constantes, se mejora la legibilidad del código y se facilita su
mantenimiento, ya que cualquier cambio en un valor constante sólo requiere

4. modificar una vez la declaración en el código, en lugar de buscar y reemplazar
en múltiples lugares.
En programación, se declaran con la palabra clave "const" y, por lo general, se
escriben en mayúsculas para resaltar que son valores constantes y no pueden
modificarse durante la ejecución del programa.
Hay dos tipos de constantes: constantes predefinidas que selecciona por nombre
y constantes literales para las cuales debe introducir un valor.
Ejemplo, "PI" se define como una constante con el valor 3.14159, que
representaría el número π en cálculos matemáticos.
2. Variables
En programación, una variable está formada por un espacio en el sistema de
almacenamiento (memoria principal de un
ordenador) y un nombre simbólico (un
identificador) que está asociado a dicho
espacio. Ese espacio contiene una cantidad
de información conocida o desconocida, es
decir un valor. El nombre de la variable es la
forma usual de referirse al valor almacenado:
esta separación entre nombre y contenido
permite que el nombre sea usado
independientemente de la información exacta
que representa. En computación una variable puede ser utilizada en un proceso
repetitivo: puede asignársele un valor en un sitio, ser luego utilizada en otro, más
adelante asignársele un nuevo valor para más tarde utilizarla de la misma
manera.
Los principales usos para las variables son:

5. ● Guardar datos y estados.
● Asignar valores de una variable a otra.
● Representar valores dentro de una expresión matemática.
● Mostrar valores por pantalla.
Ejemplos:
Una variable consiste en un elemento al cual le damos un nombre y le atribuimos
un determinado tipo de información de este modo podríamos escribir en un
lenguaje ficticio:
a="perro" b="muerde"
La variable que nosotros llamamos "a" posee un elemento de información de tipo
texto que es "perro". Asimismo, la variable "b" contiene el valor "muerde".
Podríamos definir una tercera variable que fuese la suma de estas dos:
c=a+b
Si introdujeramos una petición de impresión de esta variable en nuestro lenguaje
ficticio: imprimir(c)
El resultado podría ser: "perro muerde"
En programación, una variable está formada por un espacio en el sistema de
almacenamiento (memoria principal de un ordenador) y un nombre simbólico (un
identificador) que está asociado a dicho espacio. Ese espacio contiene una
cantidad de información conocida o desconocida, es decir un valor.
3. Acumuladores
En programación, los "acumuladores" son variables utilizadas para almacenar y
acumular valores a medida que se ejecuta un programa. Estas variables se
utilizan comúnmente en bucles o iteraciones para llevar un registro de la suma o
el resultado de una serie de operaciones.

6. El concepto de acumulador se aplica principalmente en situaciones donde
necesitas llevar un seguimiento de un valor que se va modificando a medida que
se procesan datos o se realizan cálculos repetitivos.
Un uso común de los acumuladores es cuando se necesita sumar una serie de
números.
Por ejemplo, supongamos que tenemos una lista de números [1, 2, 3, 4, 5] y
queremos calcular su suma. Podríamos utilizar un acumulador (por ejemplo,
llamado "suma") que comience en cero y luego iterar sobre cada número en la
lista, agregándole al acumulador en cada paso. Al finalizar la iteración, el valor
del acumulador contendrá la suma total de los números.
● Acumuladores en Pseint
Un acumulador es una variable que se utiliza para acumular (sumar, multiplicar,
concatenar, etc.) valores a medida que se ejecuta un programa, generalmente en
bucles o iteraciones. A diferencia de los contadores que cuentan ocurrencias, los
acumuladores mantienen la suma total o el resultado acumulado de ciertas
operaciones.
Se inicializa el acumulador con un valor inicial, dependiendo de la operación que
se vaya a realizar.
En PSeInt, no se utiliza explícitamente el término "acumulador". En lugar de eso,
simplemente usamos variables para llevar a cabo tareas similares, como sumar
valores o almacenar información durante la ejecución del algoritmo.
● Proceso para utilizar un acumulador:
1. Se inicializa el acumulador con un valor inicial, dependiendo de la
operación que se vaya a realizar.

7. Por ejemplo:
acumulador <- 0; (Para una suma)
acumulador <- 1; (Para una multiplicación)
acumulador <- ""; (Para concatenar cadenas)
2. A medida que ocurren sucesos o se procesan datos, se actualiza el valor
del acumulador con la operación deseada.
Por ejemplo, dentro de un bucle o una condición:
acumulador <- acumulador + valor; (Suma)
acumulador <- acumulador * valor; (Multiplicación)
acumulador <- acumulador + cadena; (Concatenación)
El acumulador se va actualizando en cada iteración del bucle o cuando ocurren
eventos específicos, acumulando los valores o resultados deseados.
El uso de acumuladores es común en diversas situaciones, como calcular la
suma de una lista de números, encontrar el producto de una serie de valores,
concatenar cadenas, mantener totales, entre otras operaciones que requieren
acumulación de datos a lo largo del programa.
4. Contadores
Un contador es una variable que lleva una cuenta del número de veces que se cumple
una condición, como en el siguiente ejemplo:
Tenemos que C es el contador, y queremos que incremente de 1 en 1, por lo tanto la
expresión (operación) que se utiliza es C = C + 1, donde 1 es la constante que se
sumará al contador cada vez que se ejecute esta operación dentro de un ciclo.
Si inicialmente tenemos que C = 1 cuando entremos al ciclo y ejecutemos la expresión
C = C + 1 tenemos que: C = 1 (valor actual del contador) + 1 (constante) = 2 (nuevo
valor del contador)

8. Ahora C = 2, si volvemos a entrar al ciclo y repetimos la operación, tenemos que:
C = 2 (valor actual del contador) + 1 (constante) = 3 (nuevo valor del contador)
Durante las ejecuciones de la expresión tuvimos que C = 1, luego C = 2, y
posteriormente C = 3, como podemos observar C “contó” de 1 en 1.
Existen varios tipos de contadores: ascendentes, descendentes y reversibles.
● Contadores ascendentes: incrementa progresivamente su valor en 1.
● Contadores descendentes: Decrece progresivamente su valor en 1.
● Contadores reversibles: Cuentan con dos entradas, realiza la misma función
de los dos anteriores, por una entrada el número incrementa por 1 y por la otra
entrada decrece, también por 1.
5. Identificadores
Los "identificadores" o "símbolos" son los nombres que se proporcionan para
variables, tipos, funciones y etiquetas del programa. Los nombres de
identificadores deben diferir en ortografía, mayúsculas y minúsculas de cualquier
palabra clave.
Un identificador es un nombre, que define el programador, que sirve para
denotar ciertos elementos de un programa. Estos elementos pueden ser las
denominadas variables, constantes y funciones. Cuando se ejecuta el programa,
el sistema relaciona estos nombres con alguna dirección de memoria. De este
modo, a la hora de programar, ya no se requiere recordar posiciones de memoria
sino los nombres dados a estas posiciones de memoria.
Reglas de información:
● Solo se pueden emplear las letras mayúsculas y minúsculas del alfabeto inglés,
esto es: A, B, C,..., X, Y, Z y a, b, c,..., x, y, z.
● También se pueden emplear dígitos decimales: 0, 2, 3, 4,..., 9. Sin embargo, un
identificador no puede empezar con un dígito.

9. ● No se pueden emplear letras o símbolos como: ñ, +, &, á, etc.
● Se debe empezar obligatoriamente con una letra o con el signo de subrayar.
● El lenguaje, para efectos de un identificador, considera diferentes las mayúsculas
de las minúsculas.
6. Fundamentos de programación pseint
6.1. Declarar variables.
El uso de variables es indispensable en construir algoritmos, estas nos
permitirán calcular valores, realizar operaciones,con ayuda de las variables que
transformamos las entradas del algoritmo en salidas o resultados es por eso que
debemos aprender sobre su declaración:
● Para definir una variable en Pseint se debe colocar la palabra reservada;definir
seguido por el nombre de la variable a continuación la palabra reservada como y
luego el tipo.
Definir « NbreVariable » como « tipo » El « tipo » podrá ser entero, real, lógico
carácter.
6.2. Contadores y acumuladores en pseint.
Los contadores en Pseint son variables que almacenan el conteo de por ejemplo
el ingreso de datos de un sistema, es decir nos va a llevar el conteo de información
que se va ingresando ya sea para incrementar o decrementar.
Dentro de los contadores puedes encontrar diferentes tipo de contadores como:
● Contadores ascendentes: van incrementando en 1 cada vez que su entrada
varía de 0 a 1 lógico.
● Contadores descendentes: van decrementando el valor en 1 cada vez que su
entrada varía de 0 a 1 lógico.
● Contadores reversibles: al tener dos entradas ( una para contar y otra para
descontar)realiza la misma tarea que los otros dos contadores.

10. Por otro lado los acumuladores son variables numéricas que permite ir acumulando
operaciones, permitiendo hacer operaciones parciales.
● Un acumulador se inicializa a un valor inicial según la operación que se va
acumular a 0 si es una suma o a 1 es un producto.
7. Mapa conceptual

11. 8. Conclusiones
Durante el desarrollo de este proyecto sobre los Fundamentos de Programación,
hemos explorado conceptos clave que sientan las bases para el aprendizaje y
comprensión de la programación en general. A continuación, resumimos los temas
abordados y las conclusiones obtenidas:
● Constantes: Las constantes son valores fijos que no cambian durante la
ejecución del programa. Utilizamos constantes para representar valores
inmutables, como números o cadenas, que son necesarios para realizar cálculos
o tomar decisiones en el algoritmo. Su uso nos permite hacer que el código sea
más legible y mantenible, evitando errores causados por modificaciones
accidentales.
● Variables: Las variables son espacios en memoria utilizados para almacenar y
manipular datos durante la ejecución del programa. Son fundamentales en la
programación ya que nos permiten guardar información temporalmente y
utilizarla en diferentes partes del algoritmo. Es importante declarar variables
adecuadamente, asignarles valores iniciales y asegurarse de que el tipo de dato
sea el correcto para las operaciones que vamos a realizar.
● Acumuladores: Los acumuladores son variables que utilizamos para acumular
(sumar, multiplicar, concatenar, etc.) valores a medida que se ejecuta el
programa. Nos son útiles para llevar un registro de resultados parciales y obtener
un total acumulado durante el procesamiento de datos.
● Contadores: Los contadores son variables enteras que utilizamos para contar la
cantidad de veces que ocurre un suceso específico en el programa. Son
herramientas valiosas para resolver problemas que involucran repeticiones o
iteraciones, como contar elementos, verificar condiciones o realizar conteos
estadísticos.

12. ● Identificadores: Los identificadores son nombres que asignamos a constantes,
variables y otros elementos del programa para identificarlos de manera única y
clara. Es importante utilizar nombres significativos y seguir convenciones de
nomenclatura para hacer que el código sea más comprensible y mantenible.
● Fundamentos de Programación Pseint: Durante todo el proyecto, hemos
aprendido los conceptos fundamentales de la programación, incluyendo
estructuras de control como bucles, condiciones y secuencias de instrucciones.
También hemos desarrollado la habilidad para descomponer problemas en pasos
más pequeños y utilizar pseudocódigo para diseñar algoritmos antes de
implementarlos en un lenguaje de programación específico.
En conclusión, este proyecto sobre los Fundamentos de Programación nos ha brindado
una sólida base para comprender los conceptos esenciales de programación. Hemos
adquirido conocimientos sobre el uso de constantes, variables, acumuladores y
contadores para resolver problemas de manera estructurada y eficiente. Además,
hemos mejorado nuestra capacidad para identificar y utilizar identificadores
significativos que hacen que el código sea más claro y fácil de mantener.

13. 9. Referencias
Constantes
- Link 1
https://es.m.wikipedia.org/wiki/Constante_(matem%C3%A1tica)
- Link 2
https://doc.4d.com/4Dv18/4D/18.4/Constantes.300-5233647.es.html#:~:text=Hay
%20dos%20tipos%20de%20constantes,cuales%20debe%20introducir%20un%2
0valor.
- Link 3
https://www.ibm.com/docs/es/tcamfma/6.3.0?topic=tesl-constants-variables
-4
Variables
- Link 1
https://es.wikipedia.org/wiki/Variable_(programaci%C3%B3n)
- Link 2
https://www.cepal.org/sites/default/files/presentations/2.2-conceptos-fundamental
es-estadisticas-ambientales.pdf
- Link 3
https://desarrolloweb.com/articulos/241.php
Acumuladores
- Link 1
https://medium.com/10-goto-10/algoritmos-variables-contadores-y-acumuladores
-6d8f7d1bfbc7
- Link 2
https://www.uacj.mx/CGTI/CDTE/JPM/Documents/IIT/fund_programacion/U4-1.ht
ml#:~:text=Durante%20las%20ejecuciones%20de%20la,valores%20contenidos
%20en%20otras%20variables.
- Link 3
https://dcodingames.com/el_acumulador/
- Link 4
https://plataforma.josedomingo.org/pledin/cursos/programacion/curso/u23/#:~:tex
t=Un%20acumulador%20es%20una%20variable,1%20si%20es%20un%20produ
cto.

14. Contadores
- Link 1:
https://www.uacj.mx/CGTI/CDTE/JPM/Documents/IIT/fund_programacion/U4-1.ht
ml#:~:text=Un%20contador%20es%20una%20variable,o%20de%20n%20en%20
n.
- Link 2:
https://ikastaroak.ulhi.net/edu/es/DFM/AF/AF05/es_DFM_AF05_Contenidos/web
site_165_contadores.html#:~:text=Dentro%20de%20los%20contadores%20pued
es,haber%20solamente%20uno%20de%20ellos.
- Link 3:
https://www.mclibre.org/consultar/php/lecciones/php-estructuras-control-bucle-for
-contador.html
Identificadores
https://learn.microsoft.com/es-es/cpp/c-language/c-identifiers?view=msvc-170
http://agora.pucp.edu.pe/inf2170681/2.htm
Fundamentos de programación pseint
- Link 1:
https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://b
yspel.com/como-declarar-variables-en-pseint-datos-entrada-algoritmos/&ved=2a
hUKEwjZtNajucGAAxUITTABHeCqBUEQFnoECCEQAQ&usg=AOvVaw2Nl6kCk
7qdLZigqTOis85k
- Link 2:
https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://p
lataforma.josedomingo.org/pledin/cursos/programacion/curso/u23/%23:~:text%3
DUn%2520acumulador%2520es%2520una%2520variable,1%2520si%2520es%
2520un%2520producto.&ved=2ahUKEwi4-9elu8GAAxU2mmoFHUVSCHEQFno
ECBEQBQ&usg=AOvVaw07ltQbDSCBmWU6FvvRWAjc
- Link 3
https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://
m.youtube.com/watch%3Fv%3DEMvidaEOrkc%23:~:text%3Dc%25C3%25B3dig
o%2520entonces%2520ya%2520hemos%2520dicho,informaci%25C3%25B3n%

15. 2520que%2520se%2520va%2520ingresando.&ved=2ahUKEwi4-9elu8GAAxU2
mmoFHUVSCHEQFnoECBIQBQ&usg=AOvVaw0MjOyCtIRyabWBvCqivlBC
- Link 4:
https://www.google.com/url?sa=t&source=web&rct=j&opi=89978449&url=https://i
kastaroak.ulhi.net/edu/es/DFM/AF/AF05/es_DFM_AF05_Contenidos/website_16
5_contadores.html%23:~:text%3DDentro%2520de%2520los%2520contadores%
2520puedes,haber%2520solamente%2520uno%2520de%2520ellos.&ved=2ahU
KEwj2ycT4vcGAAxW2mWoFHW-qA_sQFnoECA8QBQ&usg=AOvVaw1erFNSu-
kK325bxDZ8D7F0