Portafolio General 2003 PDF

Portafolio de Fundamentos de Programacin:
Trimestre: Agosto Octubre.

Profesor: Eligio Cabrera.

Asignatura: Fundamentos de Programacin.

Seccin: 03.

Nombre: Adeury
Apellidos: Camilo Rosario.

Matricula: 2012-1745 // ID: 1054567

Fecha: 8/10/2014

Introduccin

Saludos, soy Adeury Camilo, actualmente estoy en el curso de
Fundamento de programacin con el profesor Eligio Cabrera, una curso
del cual tengo grandes expectativas. Mi carrera es Ingeniera en
Software y me han hablado mucho de este profesor, l sabe cmo
impartir la materia, sumarte grandes conocimientos y pasar la materia
con sabidura.
Espero tener un gran conocimiento del lenguaje de programacin C,
tanto que puedo participar en la competencia local de programacin y
pasar a las nacionales, pero para eso tengo que estudiar mucho y
prestar mucha atencin a lo que el curso impartir.
Escribo este portafolio con el propsito de plasmar y guardar mis
conocimientos previos de cada da de clases con el fin de recordarlos
mejor y entregar un gran proyecto al profesor.

05/8/2014 Fundamentos de programacin
Esta es la primera clase de programacin con el profesor Eligio Cabrera que
como en la universidad Intec.
El profesor Eligio que es un algoritmo a cada uno y a base las respuesta
llegamos a que, en programacin, un algoritmo es:
Algoritmo:
-Una receta.
-Un conjunto de pasos ordenado para la solucin de un problema computacional.
Luego analizamos como se escribe un algoritmo en esta materia:
Primero es su propsito:
Explicar el objetivo o Fin del algoritmo.
Despus la cabecera:
Primera line empieza con //
Escribe:

Sentencia secuencial para desplegar.

Se redacta con un sangrado respecto a la cabecera.

Formato:

Escribe valores.

Ejemplo:

Escribe Hola mundo

Primer ejemplo:

//Despliega Hola mundo, en pantalla escribe Hola mundo.

Definimos una variable en esta materia como lo siguiente:
Variable:

-Un espacio en la memoria.
-Aloja un valor.
-Es de un tipo.
-Est dentro de un rango.
-Con un nombre asignado.

9/8/2014 Fundamentos de programacin.
En esta segunda clase, comenzamos hablado del tema de las variables y sus
tipos. Llegamos a la conclusin de que hay tres tipos de variables en
pseudocodigo que son:
Enteros: 5, 7, -8, 9,..
Tipo Real: 5.3, -8.4, 3.1416,
Carcter: a, 5, $,
Ms tarde, vimos cmo se realiza un pseudocodigo y acompaado de l, un
ejemplo del mismo:
Nombre:
Empieza con una letra solo si tiene letras y/o dgitos. Debe ser corto. Tiene
que ser de una pieza.
Ejemplo:
A ,s , dg, c1, cmd, etc

Declarar:
Sirve para declarar una o mas variables.
Ejemplo:
Entero m// natural.
Real b, a // base, altura.
Operador
Aritmticos: +, -, /, *
Relacionales: <, <=, >=, >, <>
Lgicos: no, o, y
Enteros: mod, coc
Agrupacin: (, )
Inicia:
Entero a = 7 // rea

Asigna:
-Coloca un valor especfico en una variable.
-Este valor remplaza al anterior.
N= 2 * a.
//rea triangulo
Real b = 5, a = 6, s// base, altura, superficie.
S= (b*a)/2
Escribe S

Despus de haber visto este ejemplo, realizamos una prctica para comer
aqu , como dice el profe, en la cual debamos hallar el volumen de una
paraleleppedo, y lo hallamos de esta manera:
//Volumen paraleleppedo:
Real ( x = 5, z = 3, y = 4, v // largo, alto, parte, volumen
V = X * Y * Z
Escribe V.
//rea de una ventana normada.
Real x = 3, a, pi = 3.1416
A = (1 + pi / 8) * X * X
Escribe a

El da de hoy, comenzamos con un tema sobre qu tipo de algoritmo es mejor,
los que son hard code o los soft code, inclusive comenzamos la clase con el
ttulo Hard Code VS Soft Code
Hard Code => Data fija, valores particulares.
Soft Code => Algoritmo ms flexible. Data variable. Tiene ms uso.
Ejemplo: Lee Nombre.
Ejemplo:
Lee A.
Lee B, A.

//Calcular rea triangulo.
Real b, a, s // base, altura, superficie.
Lee b a
s = (b * a) / 2
escribe s

Despus de haber visto este ejemplo realizamos una tabla de sumas en dos
versiones, la hard code y la soft code:

Version Hard Code:
//Tabla de sumar del 7, del 0 al 9
Escribe 7 +0 = 7 \n
Escribe 7 +1 = 8 \n
Escribe 7 +3 = 9 \n
Escribe 7 +4 = 10 \n

Y ahora la otra versin:
Version soft Code:
//Tabla suma del 7, del 0 al 9
Entero t = 7, f = 0, S // table, fila, suma
Mientras f < 10
S = t + f
Escribe t +f=s\n
f = f +1

Despus de esta dos versiones, nos dimos cuenta que la Version soft code es
mejor para la gran mayora de problemas con algoritmos.
De aqu en adelante hicimos varios ejercicios en versin soft code:
1) Escribir los naturales pares entre 2 y 10:
//Pares del 2 al 10
Entero t = 2, f = 0, s // tabla, fila, suma.
Mientras f < 12
s = t + f
Escribe t + f = s \n
f = f + 2

Otra forma es
//pares del 2 al 10
Entero p = 2 // par
Mientras p < 10
Escribe p
p = p + 2

2) Obtener la suma de los 1ros 10 naturales ( tip 1 + 2 + 3 + +10 )

//Suma primeros naturales
Entero s = 0, n = 1 // suma natural
s = s + n
n = n + 1
Escribe s
3) Obtener los factores propios del natural t (n = 12 => f: 1, 2, 3, 4, 6)
//Factores propios de un natural t
Entero f = 1, t // factores, tope
Lee t
Mientras f < t
Si (t mod f) = 0, escribe f
f = f + 1

Primera tarea:

Intec Ingenieras Software.

tarea 1 (sentencias secuenciales).

12-0745 1054567 Camilo Rosario Adeury.

1) Enunciado:

Convertir 100 yardas a metros.
Solucin:
// convertir 100 yardas a metros.
decimales f = 1.0936, yarda = 100, metros// formula, yardas, metros.
metros = yarda / f
escribir metro.

2) Enunciado:

Calcular volumen de una esfera de radio 5 cm.
Solucin:
// calculador del volumen de una esfera de radio 5 cm.
decimales: pi = 3.1416, r=5, v // pi, radio, volumen.
v= (4*pi*r*r*r)/3
escribir v


El da de hoy conocimos los operadores enteros mod y coc, los cuales hacen
una funcin similar el uno al otro pero no con el mismo resultado.
El ordenador mod divide dos numero pero este, no da su resultado sino su
residuo, mientras que el ordenado coc da su resultado despus de una
divisin.
Ejemplo:
-123 mod 10 => 3
123 coc 10 => 12
-12 mod 10 => 2
12 coc 10 => 1
-1 mod 10 => 1
1 coc 10 => 0

A continuacin, se realiz varias prcticas para dominar mejor estor
ordenadores.
//Cantidad de dgitos de n > 0.
Entero c = o, n // cant dig n
Lee n
Mientras n > 0
n = n coc 10
c = c + 1
escribe c
//obtiene el producto de los dgitos de n > 0
Entero p = 1, r, n // producto, residuo, n
Lee n
Mientras n > 0
r = n mod 10
p = p * r
n= n coc 10
escribe p

Despus de esto, implementamos nuestra primera funcin con un problema de
cubos narcisista.
La funcin es un sub-algoritmo que realizamos para poder llamarlo por el
nombre que le hemos puesto y as utilizarlo cuantas veces queramos sin
necesidad de copiar ms cdigo. Eso lo veremos en este ejercicio:

// Los 4 cubos narcisistas
Entero n = 2, c = 0 // narcisista (posible), cont. De narcisista
Mientras c < 4
Si narcisista ( n )
Escribe n
c = c + 1
n = n + 1

Entero narcisista (entero n)
//determina si n es un cubo narcisista.
Entero na = 0, s = 0, d, c // narcisista, suma, producto digito
Mientras n > 0
d = n mod 10
s = s + d * d * d
n = n coc 10
si s = c, na = 1
retorna na

Buenos das.

La clase de hoy trato sobre las variables si, condicin, accin.

Si

No

Tuvimos un problema para resolver o para comer aqu, se trataba de una
flotilla de camiones, el dueo tena una compaa y el solo haba enumerado
sus camiones con nmero de elevados al cuadrado, dieran igual las dos ltimas
cifras del resultado al nmero original.
Debatimos la posible solucin y llegamos a esta conclusin algortmica para
resolver y conocer cules son los nmeros de sus camiones y cuantos hay.

La flota de camiones.
n<500
25^2=625
Cuantos camiones hay?
Cules son sus nmeros?
//La flota de Camiones (#17)
entero nc=0, np=0 // #camiones, #posicin.
mientras np < 500.
si flota(np)
escribe np

Accin
nc= nc+1
np= np+1
escribir \nnc

entero flota (entero np)
//determina si np pertenece a la flotilla
entero f=1, c=n * n // flotilla, cuadrado
mientras f, y n > 0
si (no mod 10) <>(c mod 10), f=0
np = np . coc 10
c = c coc 10
retornar f

En este algoritmo aprend que los signos <> significa si es diferente de
este, tambin, el profesor nos dijo una gran frase que dice Se requiere una
mente extraordinaria para practicar un anlisis de lo evidente.
Tambin buscamos la definicin de Cosmos que es universo o espacio exterior
de la tierra, y esta se relacin con la palabra cosmticos porque Se origina
del trmino griego "", que significa orden u ornamentos, y es la
anttesis del caos.


En la clase de hoy, el profe hizo un chiste con respecto a cmo vamos en
nuestro estudios de la materia, el chite deca Una persona que estaba
cansado de la vida se lanz de una edificio bien alto, y cuando ya iba por el
piso 50, alguien le pregunto por la ventana y le pregunto como esta todo y
el respondi hasta ahora bien .
Una vez iniciada la clase, comenzamos con la pregunta sobre que es un ao
bisiesto, y se dijo que un ao es bisiesto si es mltiplo de 4, excepto si es
mltiplo de 100, excepto si es mltiplo de 400
En medio de esto analizamos como es que el algoritmo funciona. l nos lanza o
nos da un 0 que significa un no, o un 1 que significa si, al momento de
introducir el ao.
400 0 o 1

Y a partir de ah, comenzamos nuestro algoritmo para resolver este problema:
Funcin
Entero bisiesto (entero a)
//determine si a es un ao bisiesto
Entero b = 0
Si (a mod 4) = 0, b = 1
Si (a mod 100) = 0, b = 0
Si (a mod 400) = 0, b = 1
Retorna b
Algoritmo
//determina si a corresponder a un ao bisiesto
Entero a // ao
Lee a
Escribe bisiesto(a)

Despus de realizar eso el profe dijo una informacin muy importante sobre
las ciencias, de donde se origin. El menciono que las ciencia se originaron
con Jess, en el cristianismo, cuando el vino y dijo que el universo tiene un
orden, que no es una locura, hay leyes hasta el universo y a partir de ah,
el hombre comenz a investigar sobre estas leyes como lo es la de la gravedad
y ms.

A partir de ah, realizamos una prctica para comer aqu como dice el profe,
una algoritmo que obtenga los primeros nmeros primos de una numero t y
definimos como aquel que tiene 2 divisores, el uno y a s mismo, y en medio
de esto vino una frase muy trascendente de parte del profe para nosotros:
Mejor es tener un lpiz corto que una memoria larga.
Y tambin:
Papelito no se olvida.
Y con estos iniciamos el algoritmo:
Algoritmo:
//primos menores que t > 1
Entero p = 2, t //primero (posible), t
Lee t
Mientras p < t
Si primo (p), escribe p
p = p + 1

Funcin:
Entero primo (entero n)
//entero p =1, d = 2 //primo ( 1 = si, 0 = no), divisor.
Mientras p y d < n
Si (n mod d) = 0, p = 0
d = d + 1
si n < 2, p = 0
Retorna p


En la clase de hoy, se decido que la tarea se entregara en PDF y no en Word,
realizamos una prctica para comer aqu que el profe subi al aula virtual:
ejemplo:

0. obtener el menor de 3 nmeros reales dados.
algoritmo:
// menor de 3 reales
real a, b, c, m // nmeros
lee a, b, c
m = a
si b < m, m = b
si c < m, m = c
escribe c

funcin:

real menor( real x, real y, real z)
// menor de x, y, z
real m = x // menor
si y < a, m = y
si z < m, m = z
retorna m

algoritmo (invoca funcin):

// menor de 3 reales
real a, b, c // nmeros
lee a, b, c
escribe menor(a, b, c)

prctica:

a. para cada enunciado redacte un algoritmo que lo resuelva. luego redacte
una funcin que lo resuelva. luego un algoritmo principal que invoque la
funcin para resolverlo:
1. obtener el mayor de 4 nmeros reales.
2. obtener la suma de 3 nmeros enteros.
3. determinar si la suma de los dgitos de un nmero natural es par.

Esta es la solucin de los algoritmos:
1) Obtener el mayor de 4 nmeros reales.
Algoritmo
//mayor de 4 reales
Real a, b, c, d, m //nmeros
Lee a, b, c, d
m = a
si b > m, m = b
si c > m, m = c
si d > m, m = d
escribe m
Funcin
Real mayor (real w, real x, real y, real z)
//mayor de w, x, y, z
Real m = w // mayor
Si x > m, m = x
Si y > m, m = y
Si z > m, m = z
Retorna m
Algoritmo (invocar funcin)
//mayor de 4 reales
Real a, b, c, d// nmeros
Lee a, b, c, d
Escribe mayor (a, b, c, d)

2) Obtenga la suma de 3 nmeros enteros.
Algoritmo:
//suma de 3 enteros
Entero a, b, c, d // numero, suma
Lee a, b, c
S = a + b + c
Escribe s
Funcin:
Entero suma (entero a, entero b, entero c)
//suma de a, b, c
Entero s = a + b + c // suma
Retorna s
Algoritmo (invoca funcin)
//suma de 3 enteros
Entero a, b, c // nmeros
Lee a, b, c
Escribe suma (a, b, c)

3) Determinar si la suma de un nmero natural es par.
Algoritmo:
//si suma dgitos de n es par
Entero p = 1, n, s = 0, d // par, n, suma, digito
Lee n
Mientras n > 0
d = n mod 10
s = s + d
n = n coc 10
si ( s mod 2 ) < > 0, p = 0
escribe p
Funcin:
Entero SunDigPar(entero n)
//determina si la suma de los dgitos de n es par
Entero p = 1, s = 0, d // par, suma, digito
Mientras n > 0
d = n mod 10
s = s + d
n = n coc 10
si (s mod 2) <> 0, p = 0
retorma p
Algoritmo (invoca funcin)
//si suma dgitos de n es par
Entero n // numero
Lee n
Escribe SunDigPar(n)

Segunda Tarea:

Intec Ingenieras Software.

tarea 2 (para entregar y calificar aqu).

12-0745 1054567 Camilo Rosario Adeury.

1) Enunciado:

Escriba un programa que toma la hora del sistema, convertirlo en palabras, y
de impresin
el resultado
entrada
05:00
05:10
05:15
05:30
05:45
05:47
salida
Las cinco
Diez minutos despus de las cinco
Barrio pasado cinco
La mitad pasado cinco
Cuarto para las seis
Trece minutos a seis

Solucin:
Algoritmo:
//lector de hora
entero n1 , n2 // primeros nmeros, segundos nmeros
Lee n1 , n2
Hora (n1, n2)

Funcin
Entero hora (entero n1, n2)
//Convertidos de hora numrica a letra
Mientras n1 > 0 y < 13
Si n1 = 1
Escribir la una
Sino si n1 = 2
Escribir las dos
Sino si n1 = 3
Escribir las tres
Sino si n1 = 4
Escribir las cuatro
Sino si n1 = 5
Escribir las cinco
Sino si n1 = 6
Escribir las seis
Sino si n1 = 7
Escribir las siete
Sino si n1 = 8
Escribir las ocho
Sino si n1 = 9
Escribir las nueve
Sino si n1 = 10
Escribir las diez
Sino si n1 = 11
Escribir las once
Sino si n1 = 12
Escribir las doce

Mientras n2 < 60
Sino si n2 = 0
Escribir en punto
Sino si n2 = 1
Escribir y uno
Sino si n2 = 2
Escribir y dos
Sino si n2 = 3
Escribir y tres
Sino si n2 = 4
Escribir y cuatro
Sino si n2 = 5
Escribir y cinco
Sino si n2 = 6
Escribir y seis
Sino si n2 = 7
Escribir y siete
Sino si n2 = 8
Escribir y ocho
Sino si n2 = 9
Escribir y nueve
Sino si n2 = 10
Escribir y diez
Sino si n2 = 11
Escribir y once
Sino si n2 = 12
Escribir y doce
Sino si n2 = 13
Escribir y trece
Sino si n2 = 14
Escribir y catorce
Sino si n2 = 15
Escribir y un cuarto
Sino si n2 = 16
Escribir y diecisis
Sino si n2 = 17
Escribir y diecisiete
Sino s i n2 = 18
Escribir y dieciocho
Sino si n2 = 19
Escribir y diecinueve
Sino si n2 = 20
Escribir y vente
Sino si n2 = 21
Escribir y veintiuno
Sino si n2 = 22
Escribir y veintids
Sino si n2 = 23
Escribir y veintitrs
Sino si n2 = 24
Escribir y veinticuatro
Sino si n2 = 25
Escribir y veinticinco
Sino si n2 = 26
Escribir y veintisis
Sino si n2 = 27
Escribir y veintisiete
Sino si n2 = 28
Escribir y veintiocho
Sino si n2 = 29
Escribir y veintinueve
Sino si n2 = 30
Escribir y media
Sino si n2 = 31
Escribir y treinta y uno
Sino si n2 = 32
Escribir y treinta y dos
Sino s i n2 = 33
Escribir y treinta y tres
Sino si n2 = 34
Escribir y treinta y cuatro
Sino si n2 = 35
Escribir y treinta y cinco
Sino si n2 = 36
Escribir y treinta y seis
Sino si n2 = 37
Escribir y treinta y siete
Sino si n2 = 38
Escribir y treinta y ocho
Sino si n2 = 39
Escribir y treinta y nueve
Sino si n2 = 40
Escribir y cuarenta
Sino si n2 = 41
Escribir y cuarenta y uno
Sino si n2 = 42
Escribir y cuarenta y dos
Sino si n2 = 43
Escribir y cuarenta y tres
Sino si n2 = 44
Escribir y cuarenta y cuatro
Sino si n2 = 45
Escribir menos quince
Sino si n2 = 46
Escribir y cuarenta y seis
Sino si n2 = 47
Escribir y cuarenta y siete
Sino si n2 = 48
Escribir y cuarenta y ocho
Sino si n2 = 49
Escribir y cuarenta y nueve
Sino si n2 = 50
Escribir y cincuenta
Sino si n2 = 51
Escribir y cincuenta y uno
Sino si n2 = 52
Escribir y cincuenta y dos
Sino si n2 = 53
Escribir y cincuenta y tres
Sino si n2 = 54
Escribir y cincuenta y cuatro
Sino si n2 = 55
Escribir y cincuenta y cinco
Sino si n2 = 56
Escribir y cincuenta y seis
Sino si n2 = 57
Escribir y cincuenta y siete
Sino si n2 = 58
Escribir y cincuenta y ocho
Sino si n2 = 59
Escribir y cincuenta y nueve

2) Enunciado:

Escriba un programa que lleva 5 valores de entrada y muestra estos valores en
un histograma
Formar usando asterisco. Escriba el programa mediante bucles, y luego otra
vez
Sin bucles.
Entrada
Por ejemplo, si la entrada es 1 4 9 15 12 entonces su salida es parecida:
PROYECTO
5.3. 45
Salida
1: *
4: ****
9: *********
15: ***************
12: ************

Solucin:

Algoritmo
//Convertidos de nmeros a asterisco
Entero n1, n2, n3, n4, n5 //nmeros a convertir
Lee n1, n2, n3, n4, n5
asterisco (entero n1)

Funcin
//Digitador de asterisco
Entero asterisco (entero n)
Entero b
Si n > 9 || n < 20
Escribir **********
b = n mod 10
interruptor(b)
caso 1: escribir *
caso 2: escribir **
caso 3: escribir ***
caso 4: escribir ****
caso 5: escribir *****
caso 6: escribir ******
caso 7: escribir *******
caso 8: escribir ********
caso 9: escribir *********
sino si n > 19 || n < 30
Escribir ********************
b = n mod 10
interruptor (b)
caso 1: escribir *
caso 2: escribir **
sino si n > 29 || n < 40
Escribir ******************************
b = n mod 10
interruptor (b)
caso 1: escribir *
caso 2: escribir **
sino si n > 39 || n < 50
Escribir ****************************************
b = n mod 10
interruptor (b)
caso 1: escribir *
caso 2: escribir **
sino si n > 49 || n < 60
Escribir **************************************************
b = n mod 10
interruptor (b)
caso 1: escribir *
caso 2: escribir **
sino si n > 59 || n < 70
Escribir
************************************************************
b = n mod 10
interruptor (b)
caso 1: escribir *
caso 2: escribir **
sino si n > 69 || n < 80
Escribir
************************************************************
**********
b = n mod 10
interruptor (b)
caso 1: escribir *
caso 2: escribir **
sino si n > 79 || n < 90
Escribir
************************************************************
********************
b = n mod 10
interruptor (b)
caso 1: escribir *
caso 2: escribir **
sino si n > 89 || n < 100
Escribir
************************************************************
******************************
b = n mod 10
interruptor (b)
caso 1: escribir *
caso 2: escribir **
sino
interruptor (b)
caso 1: escribir *
caso 2: escribir **

Algoritmo
//Convertidos de nmeros a asterisco
Entero n1, n2, n3, n4, n5, b1, b2, b3, b4, b5 //nmeros a
convertir, bolsas para guardar los numeros
Lee n1, n2, n3, n4, n5
Si n1 > 9 || n1 < 20
Escribir **********
b1 = n1 mod 10
interruptor(b1)
caso 1: escribir *
caso 2: escribir **
sino si n1 > 19 || n1 < 30
Escribir ********************
b1= n1 mod 10
interruptor (b1)
caso 1: escribir *
caso 2: escribir **
sino si n1 > 29 || n1 < 40
Escribir ******************************
b1 = n1 mod 10
interruptor (b1)
caso 1: escribir *
caso 2: escribir **
sino si n1 > 39 || n1 < 50
Escribir ****************************************
b1 = n1 mod 10
interruptor (b1)
caso 1: escribir *
caso 2: escribir **
sino si n1 > 49 || n1 < 60
Escribir **************************************************
b1 = n1 mod 10
interruptor (b1)
caso 1: escribir *
caso 2: escribir **
sino si n1 > 59 || n1 < 70
Escribir
************************************************************
b1 = n1 mod 10
interruptor (b1)
caso 1: escribir *
caso 2: escribir **
sino si n1 > 69 || n1 < 80
Escribir
************************************************************
**********
b1 = n1 mod 10
interruptor (b1)
caso 1: escribir *
caso 2: escribir **
sino si n1 > 79 || n1 < 90
Escribir
************************************************************
********************
b1 = n1 mod 10
interruptor (b1)
caso 1: escribir *
caso 2: escribir **
sino si n1 > 89 || n1 < 100
Escribir
************************************************************
******************************
b1 = n1 mod 10
interruptor (b1)
caso 1: escribir *
caso 2: escribir **
sino
interruptor (b1)
caso 1: escribir *
caso 2: escribir **

Si n2 > 9 || n2 < 20
Escribir **********
b2 = n2 mod 10
interruptor(b2)
caso 1: escribir *
caso 2: escribir **
sino si n2 > 19 || n2 < 30
Escribir ********************
b2 = n2 mod 10
interruptor (b2)
caso 1: escribir *
caso 2: escribir **
sino si n2 > 29 || n2 < 40
Escribir ******************************
b2 = n2 mod 10
interruptor (b2)
caso 1: escribir *
caso 2: escribir **
sino si n2 > 39 || n2 < 50
Escribir ****************************************
b2 = n2 mod 10
interruptor (b2)
caso 1: escribir *
caso 2: escribir **
sino si n2 > 49 || n2 < 60
Escribir **************************************************
b2 = n2 mod 10
interruptor (b2)
caso 1: escribir *
caso 2: escribir **
sino si n2 > 59 || n2 < 70
Escribir
************************************************************
b2 = n2 mod 10
interruptor (b2)
caso 1: escribir *
caso 2: escribir **
sino si n2 > 69 || n2 < 80
Escribir
************************************************************
**********
b2 = n2 mod 10
interruptor (b2)
caso 1: escribir *
caso 2: escribir **
sino si n2 > 79 || n2 < 90
Escribir
************************************************************
********************
b2 = n2 mod 10
interruptor (b2)
caso 1: escribir *
caso 2: escribir **
sino si n2 > 89 || n2 < 100
Escribir
************************************************************
******************************
b2 = n2 mod 10
interruptor (b2)
caso 1: escribir *
caso 2: escribir **
sino
interruptor (b2)
caso 1: escribir *
caso 2: escribir **
Si n3 > 9 || n3 < 20
Escribir **********
b3 = n3 mod 10
interruptor(b3)
caso 1: escribir *
caso 2: escribir **
sino si n3 > 19 || n3 < 30
Escribir ********************
b3 = n3 mod 10
interruptor (b3)
caso 1: escribir *
caso 2: escribir **
sino si n3 > 29 || n3 < 40
Escribir ******************************
b3 = n3 mod 10
interruptor (b3)
caso 1: escribir *
caso 2: escribir **
sino si n3 > 39 || n3 < 50
Escribir ****************************************
b3 = n3 mod 10
interruptor (b3)
caso 1: escribir *
caso 2: escribir **
sino si n3 > 49 || n3 < 60
Escribir **************************************************
b3 = n3 mod 10
interruptor (b3)
caso 1: escribir *
caso 2: escribir **
sino si n3 > 59 || n3 < 70
Escribir
************************************************************
b3 = n3 mod 10
interruptor (b3)
caso 1: escribir *
caso 2: escribir **
sino si n3 > 69 || n3 < 80
Escribir
************************************************************
**********
b3 = n3 mod 10
interruptor (b3)
caso 1: escribir *
caso 2: escribir **
sino si n3 > 79 || n3 < 90
Escribir
************************************************************
********************
b3 = n3 mod 10
interruptor (b3)
caso 1: escribir *
caso 2: escribir **
sino si n3 > 89 || n3 < 100
Escribir
************************************************************
******************************
b3 = n3 mod 10
interruptor (b3)
caso 1: escribir *
caso 2: escribir **
sino
interruptor (b3)
caso 1: escribir *
caso 2: escribir **
Si n4 > 9 || n4 < 20
Escribir **********
b4 = n4 mod 10
interruptor(b4)
caso 1: escribir *
caso 2: escribir **
sino si n4 > 19 || n4 < 30
Escribir ********************
b4 = n4 mod 10
interruptor (b4)
caso 1: escribir *
caso 2: escribir **
sino si n4 > 29 || n4 < 40
Escribir ******************************
b4 = n4 mod 10
interruptor (b4)
caso 1: escribir *
caso 2: escribir **
sino si n4 > 39 || n4 < 50
Escribir ****************************************
b4 = n4 mod 10
interruptor (b4)
caso 1: escribir *
caso 2: escribir **
sino si n4 > 49 || n4 < 60
Escribir **************************************************
b4 = n4 mod 10
interruptor (b4)
caso 1: escribir *
caso 2: escribir **
sino si n4 > 59 || n4 < 70
Escribir
************************************************************
b4 = n4 mod 10
Interruptor (b4)
caso 1: escribir *
caso 2: escribir **
sino si n4 > 69 || n4 < 80
Escribir
************************************************************
**********
b4 = n4 mod 10
interruptor (b4)
caso 1: escribir *
caso 2: escribir **
sino si n4 > 79 || n4 < 90
Escribir
************************************************************
********************
b4 = n4 mod 10
interruptor (b4)
caso 1: escribir *
caso 2: escribir **
sino si n4 > 89 || n4 < 100
Escribir
************************************************************
******************************
b4 = n4 mod 10
interruptor (b4)
caso 1: escribir *
caso 2: escribir **
sino
interruptor (b4)
caso 1: escribir *
caso 2: escribir **
Si n5 > 9 || n5 < 2 0
Escribir **********
b5 = n5 mod 10
Interruptor (b5)
caso 1: escribir *
caso 2: escribir **
sino si n5 > 19 || n5 < 30
Escribir ********************
b5 = n5 mod 10
Interruptor (b)
caso 1: escribir *
caso 2: escribir **
sino si n5 > 29 || n5 < 40
Escribir ******************************
b5 = n5 mod 10
interruptor (b5)
caso 1: escribir *
caso 2: escribir **
sino si n5 > 39 || n5 < 50
Escribir ****************************************
b5 = n5 mod 10
Interruptor (b5)
caso 1: escribir *
caso 2: escribir **
sino s i n5 > 49 || n5 < 60
Escribir **************************************************
b5 = n5 mod 10
interruptor (b5)
caso 1: escribir *
caso 2: escribir **
sino si n5 > 59 || n5 < 70
Escribir
************************************************************
b = n5 mod 10
interruptor (b5)
caso 1: escribir *
caso 2: escribir **
sino si n5 > 69 || n5 < 80
Escribir
************************************************************
**********
b5 = n5 mod 10
interruptor (b5)
caso 1: escribir *
caso 2: escribir **
sino si n5 > 79 || n5 < 90
Escribir
************************************************************
********************
b5 = n5 mod 10
Interruptor (b5)
caso 1: escribir *
caso 2: escribir **
sino si n5 > 89 || n5 < 100
Escribir
************************************************************
******************************
b5 = n5 mod 10
interruptor (b5)
caso 1: escribir *
caso 2: escribir **
sino
interruptor (b5)
caso 1: escribir *
caso 2: escribir **


Continuamos con los problemas de la clase pasada:
b. para cada enunciado redacte un algoritmo que, invocando una funcin, lo
resuelva. luego redacte una funcin invocada:
1. obtener el nmero par que sigue al natural n.
2. obtener la suma de los naturales mltiplos de 3 5 menores que el nmero
natural t.

1) obtener el nmero par que sigue al natural n.
Algoritmo:
//siguiente par
Entero n , p, // n, par siguiente
Lee n
p = parSig (n)
escribe p
Funcin:
Entero parSig (entero n)
//siguiente par
Entero s // siguiente par
Si ( m mod 2) = 0
S = m + 2
Sino
S = m + 1
Retorna s

2) obtener la suma de los naturales mltiplos de 3 5 menores que el
nmero natural t.
Algoritmo:
//Suma de mltiplos
Entero t, s = 0, i = 1 //suma, t, iterador (contenedor)
Lee t mientras i < t
Si mul 3 o 5 (i) s = s + i
i = i + 1
escribe s
Funcin:
Entero mul 3 o 5 (entero n)
//si n es mltiplo de 3 o 5
Entero m = 0 // mltiplo
Si (n mod 3) = o O (n mod 5) = 0, m = 1
Retorna m.

2/9/2014 Fundamentos de programacion.

Banquete de los politicos.
Un centenar de polticos e invitados asistieron a un banquete para recaudar
fondos. Cada uno de los senadores que asisti pago 75 monedas, cada
congresista 99, y cada invitado 40 monedas. Si en total se ingresaron 7,869
monedas
Cuntos senadores, congresistas e invitador haba respectivamente?
As fue el comienzo de la clase de hoy, primero buscar la solucin para
conocer esos nmeros y en medio de eso el profesor no conto una experiencia
en Rusia, l tuvo que preguntar un precio all y no saba cmo, y el vendedor
no entenda ingls, as que el profesor le sealo el objeto que le interesaba
y el vendedor le mostro el precio con los nmeros digitados en su
calculadora, con esto el profe nos dio a entender que lo nmeros son
universales, y con esto despejamos un poco ms la mente para resolver el
problema anterior, y esta fue la solucin:
En base a esta frmula:
S + c + i = 100
75s +99c +40i = 7869

Algoritmo:
//banquete de los polticos
Entero s, c, i = 1 // senadores, congresistas, invitados
Mientras i < 99
Si (2031 59 * i) mod 24 = 0
s = (2031 59 * i) / 24
c = 100 - s i
escribe s c i \n
I = I + 1

Una vez realizado este problema, pasamos al siguiente:

Enteros intrigantes.
//Enteros intrigantes
Entero p = 2, s = 1, e // par, siguiente, expresin
Mientras s
e = p * p * p + 6 * p * p 88 * p 192
Si e = 0
Escribe pp+2p+4
s = 0
p = p + 2

Ya esta fue la ltima clase en pseudocodigo, a partir de aqu todo ser
lenguaje C.

Comenzamos con c, utilizando un material de apoyo para la clase, que nos
esplique que es el lenguaje c, como se utilizar y segn vi, es muy parecido
al pseudocodigo, con los conocimientos que obtuvimos anterior mente, nos fue
fcil pasar de un lenguaje a otro.

Iniciamos con los arreglos:
Long a; // rea
Long a = 5; //area
Long a[10]={1, 2, 3};//areas
0 1 2
Long dm []={31,28,31,30,31,31,30,31,30,31} // das

Tipo especial de variable
Char n; // nombre
n = v;

char n [31]; // nombre
char n[31] = V o F vendeta;
char n[] = mr. ti ;

Los arreglos de caracteres en c son cadenas, por ende, tienen que terminar en
nulo
Char n[]= {N,R,., ,T}; (esta forma es vlida pero no eficaz, es
mejor de la forma anterior char n[] = mr. ti ; )

Despus de esto el profesor entro en el tema del TNT, con respecto a la
persona que sepa manejar todo esto bien. De ah l nos mencion una bomba
limpia rusa, que mata la vida pero no derriba las estructuras.
Todo esto l lo relaciono con aquel que domine los ciclo, funciones y
arreglos.

Ahora con la funcin void(doubl a[], long(t)
{//-----------
Long s, b = t 1; // ---
While(b > 0)
{
s = 0;
while(s < b)
{
if( a[s]>d[s+1] ) commuta[&a[s]. &a[s+1]);
s++;
}
b--;
}
}
Al resolver este algoritmo, el profesor hablo como los maestros judos De
cierto de ciertos os digo que significa que dira o dijo algo muy muy
importante.
La ventaja del c, lo que hizo que este lenguaje impactara era que un arreglo
se puede pasar a un funcin y si se modifica adentro da la funcin, se
modifica afuera, a diferencia de otros lenguajes que se tenan que volver a
escribir.

//Void conmuta(doubl xx, double xy)
{//------
Double t; // temporal c
T = xx;
Xx = xy;
Xy = t;
}

El profe dijo que investigramos sobre:
El test de Turing (o prueba de Turing) es una prueba propuesta por Alan
Turing para demostrar la existencia de inteligencia en una mquina. Fue
expuesto en 1950 en un artculo (Computing machinery and intelligence) para
la revista Mind, y sigue siendo uno de los mejores mtodos para los
defensores de la inteligencia artificial. Se fundamenta en la
hiptesis positivista de que, si una mquina se comporta en todos los
aspectos como inteligente, entonces debe ser inteligente.
La prueba consiste en un desafo. Se supone un juez situado en una
habitacin, una mquina y un ser humano en otra. El juez debe descubrir cul
es el ser humano y cul es la mquina, estndoles a los dos permitido mentir
o equivocarse al contestar por escrito las preguntas que el juez les hiciera.
La tesis de Turing supone que si ambos jugadores son suficientemente hbiles,
el juez no podr distinguir quin es el ser humano y quin la mquina.
En 1990 se inici un concurso, el Premio Loebner, una competicin de carcter
anual entre programas de ordenador que sigue el estndar establecido en la
prueba de Turing. Un juez humano se enfrenta a dos pantallas de ordenador,
una de ellas que se encuentra bajo el control de un ordenador y la otra bajo
el control de un humano. El juez plantea preguntas a las dos pantallas y
recibe respuestas. El premio est dotado con 100.000 dlares estadounidenses
para el programa que pase el test, y un premio de consolacin para el mejor
programa mensual.
La primera vez que un juez confundi a una mquina con un humano fue en el
ao 2010, cuando el robot Suzette, de Bruce Wilcox, super la prueba.
En junio de 2014, el bot conversacional Eugene Goostman, que participaba en
un concurso celebrado en la Royal Society para conmemorar el 60 aniversario
de la muerte de Turing, gan al conseguir que el 33% de los jurados del
concurso creyesen que Goostman era humano.
Una mquina de Turing es un dispositivo que manipula smbolos sobre una tira
de cinta de acuerdo a una tabla de reglas. A pesar de su simplicidad, una
mquina de Turing puede ser adaptada para simular la lgica de
cualquier algoritmo de computador y es particularmente til en la explicacin
de las funciones de una CPU dentro de un computador.

Ahora realizamos otra funcin:
Void reversa(doubl a[], long t)
{\\ reversa primeras t posiciones de a
Long s = 0, m = t/2; // sube, mitad
While(s < m)

{ conmuta (&a[s], &a[t-(s+1)]);
s++;
}
}

Hoy el profesor hablo sobe el examen, aclarando que es una foto de lo que
nosotros conocemos en verdad. Luego, el profesor menciono varias frases que
fueron las siguientes:
No es lo mismo atrs que espalda.
No es lo mismo una cinta negra que una negra en cinta ( hahahaha es me dio
mucha risa ).
Realizamos el problema de spoj 1872 making book.

Comenzamos con la metodologa de pelando la cebolla, realizando al main y sus
funciones y luego avanzamos a realizar las funciones.
Enunciado (Entonos, trabajando con funciones)
Determinar si n es primo
Solucin:
Long primo(nombre de la funcin)(long(tipo del valor) n(nombre del valor)
Long primo(long n)
{ //si n es primo
Long p = 1, d = 2 //primo, divisor
While(p && d <= n/2)
{ if (n%d==0) p = 0;
d++;
}
Return p;
}
El profesor dijo un comentario muy profundo, l hablaba sobre un autor que
dice que el ser humano de hoy piensa que todo es lo mismo, y eso lo est
llevando a una involucin intelectual.

Problemas
Obtener la cantidad de primos menores que t [funcin]
Long primoMenor(long n)
{
Long p=1, d=2, c=1
While(c<n);
{ while(n%c==1)
Prinf(%d es primo menor d %d, c, n);
}
}

De aqu, el profesor menciono una frase muy interesante que deca:
Deriva el que quiere, y integra el que puede.

Y ms tarde no dio el secreto de porque los chinos son tan buenos en carros,
tecnologas y dems. Esto se debe a que lo chinos, cuanto tienen una
maquinaria daad; ellos no le dice que esta no sirve como los americanos,
ellos dice que esta defectuosa pero se puede mejorar, de aqu es la base para
ser la gran potencia que son.

23/9/2014 fundamentos de programacin
Cadenas de caracteres

Antes de que se inventara el c, las cadenas eran fijas de 256, en los
primeros bits se guardaba el nmero de carcter.
5 C A S A S
1 255.

En c puede tener una longitud arbitraria, miles:
C A S A S 10 \0

El carcter nulo es lo que indica el final de este carcter, hay mas pero no
lo recibe despus de \0.
C A S \0 A S \0

La librera <string.h> tiene funciones para manejar las cadenas de
caracteres.
Char a[] = aeiou; //vocales

A E I O U \0

Char a[b] = {a,E,I,O,U}
= {a,E,I,O,U,\0}

Ejercicio, hacer una funcin que haga los mismo que la funcin strlen:
Obtener la longitud (# de caracteres) en una cadena.
Long loncad(char c[])
{ //longitud de c
Long p = 0 // posicin longitud
While(c[p]!=\0)p++
Return p;
}

Programa para escribir el nmero que se introduzca:
Versin Salvaje
Void nomdig(charn[],long d)
{ //nombre del digito d(0 a 9)
n[0] = \n;
swich(d)
{ Caso 0: strcpy(ncero); break;
Caso 1: strcpy(nuno); break;

Caso 9: strcpy(n,nueve); break;
}
}

Versin domesticada
Void nomdig(char n[], long d)
{ //nombre del digito (o a 9)
Char nd[][8]={cero, uno,,nueve};
n[0] = \0;
strcpy(n,nd[d]);
}

Void nomNum(char n[], long m)
{ //nombre de un numero de hasta 2 dgitos (0 a 99)
Char v[][12] = {Cero, Uno,,Diecinueve}
Char d[][10] = {,,Veinte, treinta,noventa}
If(m <20)
{ Strcpy(n,d[n/10]);
If(m%10 != 0)
{ strcat(n,y);
Strcat(n,v[m%10]);
}
}
}

Se dice que la funcin ms importante de Windows es la funcin de copiar y
pegar, dijo el profesor.

Los zapatitos me aprietan:

Salvage
Long cap(char f[])
{ //cantidad palabras en F
Long c = 0, p = 0;// cantidad palabras, posicin,
While(f[p] != \0)
If(f[p++] == )c++
Return ++c;
}

Operador ternario
(ac = (f[p] == )?|:0; es igual a: if(f[p] == ) ac = 1; else ac = 1;

Versin domesticada
Long campa(char f[])
{ //cantidad palabras en f
Long c=0, p=0; // cant. Palabras, posicin
Long an = 1, ac; //anterior, actual.
While(r[p]!=\0 )
{ ac=(f[p] == )?|:0;
If(an && ! ac) c++;
P++;
an = ac;
} return c;
}


Frase
La persona inteligente es aquella que sabe diferenciar las cosas, sus
matices.

SPOJ Problem Set (tutorial)
4770. Add and Reverse Sums
The Problem - El Problema
The "reverse and add" method is simple: choose a number, reverse its digits
and add it to the original. If the sum is not a palindrome (which means, it
is not the same number from left to right and right to left), repeat this
procedure.
El mtodo "invertir y sumar" es simple: elija un nmero, invierta sus dgitos
y smelo al original. Si la suma no es un palndromo (es decir que no es el
mismo nmero de izquierda a derecha que de derecha a izquierda), repita el
procedimiento.
For example: - Por ejemplo:
195 Initial number - Nmero inicial
591
-----
786
687
-----
1473
3741
-----
5214
4125
-----
9339 Resulting palindrome - Palndromo resultante
In this particular case the palindrome 9339 appeared after the 4th addition.
This method leads to palindromes in a few step for almost all of the
integers. But there are interesting exceptions. 196 is the first number for
which no palindrome has been found. It is not proven though, that there is no
such a palindrome.
En este caso particular el palndromo 9339 apareci luego de la 4ta. suma.
Este mtodo nos lleva a un palndromo en unos pocos pasos para casi todos los
enteros. Pero hay excepciones interesantes. 196 es el primer nmero para el
cual no se ha encontrado un palndromo. No se probado an que no exista tal
palndromo.
Task : Tarea
You must write a program that give the resulting palindrome and the number of
iterations (additions) to compute the palindrome.
Ud. debe escribir un programa que muestre el palndromo resultante y el
nmero de iteraciones (sumas) para calcular el palndromo.
You might assume that all tests data on this problem:
- will have an answer ,
- will be computable with less than 1000 iterations (additions),
- will yield a palindrome that is not greater than 4,294,967,295.
Ud. puede asumir que todos los casos de prueba en este problema:
- tendrn una respuesta,
- que ser calculable con menos de 1000 iteraciones (sumas),
- que el palndromo resultante no ser mayor que 4,294,967,295.
The Input - Entrada
The first line will have a number N with the number of test cases, the next N
lines will have a number P to compute its palindrome.
La primer lnea tendr un nmero N con el nmero de casos de prueba, las
prximas N lneas tendrn un nmero P para calcular su palndromo.
The Output - Salida
For each of the N tests you will have to write a line with the following data
: minimum number of iterations (additions) to get to the palindrome and the
resulting palindrome itself separated by one space.
Para cada uno de los N casos de prueba la salida ser una lnea con los datos
siguientes: nmero mnimo de iteraciones (sumas) para obtener el palndromo,
y el palndromo resultante, separados por un espacio.
Sample Input - Entrada ejemplo
3
195
265
750
Sample Output - Salida ejemplo
4 9339
5 45254
3 6666

Solucin:
#include <stdio.h>
#include <stdlib.h>

void addRev(long*, long*, long);
long reverso(long);

int main()
{

// spoj 4770 - add and reverse

long c, i=0, n;//casos, iterador, numero
long j,p;// nmero de iteraciones, palndromo

scanf("%ld", &c);

while(i < c)
{
scanf("%ld", &n);
addRev(&j, &p, n);
printf("%ld %ld\n", j, p);
i++;
}
return 0;
}

void addRev(long*i, long*p, long n)
{
// Obtiene cant. iteraciones y palndromo

long r, s;//reverso, suma

*i = 0;
r = reverso (n);
s = n + r;

while (s != reverso(s) )
{
n = s;
r = reverso (n);
s = n + r;
(*i)++;
}

*p = s;
}

long reverso(long n)
{
// reversa dgitos de n

long r = 0; // reverso

while(n > 0)
{
r = 10*r + n%10;
n /= 10;
}
return r;
}


Frase de hoy: pelando la cebolla de adentro para afuera.

SPOJ de problemas (tutorial)
9500. paso cuenta

Usted es un detective que trabaja con Scotland Yard en un caso de robo de un
banco de alto perfil. El ladrn ha dejado algunos rastros en forma de
nmeros, que usted cree que le dar pistas importantes sobre el robo. Dado
que usted es un genio, usted sabe que las pistas pueden obtener mediante la
conversin de la cantidad en binario y contando el nmero de 1 de.
Entrada
La primera lnea tiene una t nmero seguido de lneas t. Cada lnea contiene
un nmero <512.
Salida
Salida t lneas que corresponden a cada nmero, de tal manera que cada uno de
la lnea contiene la clave obtenida a partir del nmero.
Ejemplo
Entrada:
5
2
3
1
0
11
Salida:
1
2
1
0
3

Solucin:
#include <stdio.h>
#include <stdlib.h>

long canUno(long);

int main()
{
//spoj 9500 - bit counts
long t, i=0,n; //casos, iterador, numero

scanf("%ld", &t);

while(i < t)
{
scanf("%ld", &n);
printf("%ld\n", canUno(n));
i++;
}

return 0;
}

long canUno(long n)
{
// Cantidad de 1s en n en binario

long c = 0; // cantidad de 1s

while(n > 0)
{
if(n%2) c++;
n /=2;
}

return c;

}


Frase: Ensear es hacer familiar lo nuevo.
SPOJ de problemas (tutorial)
4907 Carta Comn mayora
Muchos procesadores de texto tienen un contador de palabras, lo que le puede
decir no slo cuntas palabras estn en un archivo, sino tambin la cantidad
de caracteres, lneas, prrafos y pginas. Pero a quin le importa eso? Todo
lo que necesitas saber es que de las 26 letras del alfabeto Ingls (A - Z)
que ha utilizado la mayor parte de su texto. Escriba un programa que
implementa esta caracterstica.
Entrada
La entrada ser varias lneas, cada una representando un caso de prueba
diferente. No caso de prueba ser superar los 1024 caracteres de longitud, y
cada uno contiene al menos un carcter alfabtico.
Salida
Para cada caso de prueba, una lnea de salida, que contiene la letra ms
comn y el nmero de veces que aparece en el caso de prueba, separadas por un
espacio. Romper los lazos a favor de la carta que se produce primero por
orden alfabtico. No haga caso de caracteres no alfabticos. Contar debe
distinguir entre maysculas y minsculas, y la salida debe ser mayscula.
Ejemplo
Entrada:
Hola Mundo!
Nunca va a dar, nunca va a defraudar...
Usted acaba de perder el juego.
Me voy a dormir * bostezo * Zzzzzz

Salida:
L 3
N 7
T 3
Z 6

Solucin:
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

void maxRep(char *, long *, char[]);
void encera(long [], long);
void maximo(long * ,long *g, long[], long);

int main()
{
// spoj 4907 carta comn mayora

char c[1025], m; // cadena, ms repetida
long mf, b = 1; // mxima frecuencia, bandera

while(b)
{
gets(c);

if(!(strlen(c)))
b = 0;

else
{
maxRep(&m, &mf, c);
printf("%c %ld\n",m, mf);
}

}
return 0;
}

void maxRep(char *m, long *f, char c[])
{
//letra ms repetida y frecuencia en c

long fl[26], p = 0, a; // frecuencias letras, posicin en c
char lt[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
long mf, pm; // mxima frecuencia, posicin max fre.

encera(fl, 26);
toupper(c); // en string.h

while(c[p] != '\0')
{
a = c[p] - 'A';
if(a >= 0 && a <=25 ) (fl[a])++;
p++;

}

maximo(&mf, &pm, fl, 26);
*f = mf;
*m = lt[pm];
}

void encera(long f[], long t)
{
// Hace cero 1ras t posiciones de f

long i = 0; // iterador
while(i<t)
f[i++]=0;
}

void maximo(long *m ,long *f, long fr[], long t)
{
// mxima frecuencia y su posicin en fr
long i= 1; // iterador

*m = fr[0];
*f = 0;

while (i <t)
{
if (fr[i] > *m)
{
*m = fr[i];
*f = i;
}
}
}

Conclusion

Profesor, en este curso comprenda como pensar una formas ms
eficiente, ms eficaz a la vez en mi vida diaria, todos estos
conocimientos no solo los puedo aplicar a la programacin, sino
a mi diario vivir, pienso que usted fue la mejor eleccin que
pude escoger como profesor, ya que me ayudo a crecer
intelectualmente, ms de lo esperado por m.
Comprenda como el la lgica de programacin en el lenguaje C y
como usar el pseudocodigo al mismo tiempo.
Gracias profesor, desde sus chiste hasta sus frases han sido de
inspiracin para m como programador y como persona.

Profesor, para mi usted ha sido el mejor profesor que he podido
tomar, tomare lgica con usted el otro trimestre con Dios
mediante, gracias.

Se despide, con un cordial saludo Adeury Camilo,
Matrcula 12-0745, ID 1054567.

Portafolio General 2003 PDF

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Portafolio General 2003 PDF

Cargado por

Copyright:

Formatos disponibles

Portafolio de Fundamentos de Programacin:

Trimestre: Agosto Octubre.

También podría gustarte