Compendio de Lenguaje de Programación

Universidad Central del EcuadorFacultad de Filosofía, Letras y Ciencias de la EducaciónCarrera de Informática

Dr. Nelson RodríguezVicerrector Académico y de Posgrado de la Universidad Central del Ecuador

Unidad Académica de Titulación de la Universidad CentralMSc. Jacqueline Altamirano MSc. Xavier Andrade MSc. Pablo Romo

Dra. Ruth Páez Granja MSc.Decana de la Facultad de Filosofía, Letras y Ciencias de la Educación

MSc. Juan Carlos CobosDirector de la Carrera de Informática

MSc. Yolanda BorjaCoordinadora de la Unidad de Titulación Especial de la Carrera de Informática

ISBN: 978-9942-945-61-7

Diseño y Diagramación: Editorial Universitaria- Universidad Central del Ecuador

MSc.Yolanda Borja / MSc. Juan Carlos Cobos 3

TABLA DE CONTENIDO

1 MISIÓN Y VISIÓN DE LA CARRERA DE INFORMÁTICA..... ............................................62 INTRODUCCIÓN ......................................................................................................................73 OBJETIVOS DE LA GUÍA........................................................................................................84 SITUACIÓN ACTUAL DE LA CARRERA..............................................................................85 ANTECEDENTES LEGALES...................................................................................................86 MODELO EDUCATIVO............................................................................................................97 PERFIL DE EGRESO DE LA CARRERA.................................................................................98 DESCRIPCIÓN Y ANÁLISIS...................................................................................................109 MODALIDADES DE LA UNIDAD DE TITULACIÓN ESPECIAL.....................................13

9.1 Proyecto tecnologico..........................................................................................................139.1.1 Proyectos tecnológicos educativos.............................................................................139.1.2 Metodología de Desarrollo de Proyecto Tecnológico................................................14

9.2 Examen complexivo..........................................................................................................149.2.1 Metodología examen complexivo..............................................................................159.2.2 Estructura y ponderación del examen complexivo.....................................................159.2.3 Tipos de reactivos de las preguntas del examen.........................................................159.2.4 Asignaturas y temas para el examen complexivo........................................................169.2.5 Instructivo para el estudiante que opta por el examen complexivo...........................18

10 ESTRUCTURA CURRICULAR DE LA UNIDAD TITULACIÓN ESPECIAL....................1810.1 Proyecto tecnológico..........................................................................................................1910.2 Examen complexivo...........................................................................................................1910.3 Descripción de las actividades............................................................................................19

11 PROCEDIMIENTOS PARA LA TITULACIÓN......................................................................2011.1 Información........................................................................................................................2011.2 Matrícula en la Unidad de Titulación Especial..................................................................2011.3 Organización.......................................................................................................................2011.4 Ejecución............................................................................................................................21

11.4.1 Para el trabajo de titulación........................................................................................2111.4.2 Para el examen complexivo........................................................................................21

12 ASIGNATURA DE PROGRAMACIÓN..................................................................................2312.1 Descripción de la asignatura..............................................................................................2512.2 Objetivo de la asignatura....................................................................................................2512.3 Temas de Programación para el examen complexivo........................................................2512.4 UNIDAD Nº 1: LENGUAJE C++.....................................................................................27

12.4.1 Definición de lenguaje de programación C++............................................................2912.4.2 Borland.......................................................................................................................2912.4.3 Características.............................................................................................................2912.4.4 Ventajas.......................................................................................................................29

4 Carrera de Pedagogía de las Ciencias Experimentales Informática / Universidad Central del Ecuador

12.4.5 Desventajas.................................................................................................................3012.4.6 Estructura del lenguaje C++.......................................................................................30

12.4.6.1 Comando If, else.................................................................................................3012.4.6.1.1 Ejercicios: if, else............................................................................................30

12.4.6.2 Sentencia while....................................................................................................3312.4.6.2.1 Ejercicios while................................................................................................33

12.4.6.3 El ciclo do-while...................................................................................................3612.4.6.3.1 Ejercicios do-while:.........................................................................................37

12.4.6.4 El ciclo for...........................................................................................................4012.4.6.4.1 Ejercicios ciclo for..........................................................................................40

12.4.6.5 Switch - Case......................................................................................................4212.4.6.5.1 Ejercicios switch – case..................................................................................4312.4.6.5.2 Vectores...........................................................................................................4712.4.6.5.3 Arreglo unidimensionales...............................................................................4712.4.6.5.4 Ejercicios arreglos unidimensionales..............................................................48

12.5 UNIDAD Nº 2: VISUAL BASIC.......................................................................................5112.5.1 Introducción a Visual Basic........................................................................................5312.5.2 Definición...................................................................................................................5312.5.3 Características.............................................................................................................5312.5.4 Ventajas........................................................................................................................5412.5.5 Desventajas.................................................................................................................5412.5.6 Sentencias de control..................................................................................................55

12.5.6.1 If, then, else.........................................................................................................5512.5.6.1.1 Ejercicios if.....................................................................................................56

12.5.6.2 Select case...........................................................................................................5812.5.6.2.1 Ejercicios select – case...................................................................................59

12.5.6.3 While...................................................................................................................6212.5.6.3.1 Ejercicios while...............................................................................................6212.5.6.3.2 Do - while........................................................................................................6312.5.6.3.3 Ejercicios do - while.......................................................................................64

12.5.6.4 Sentencias for, next.............................................................................................6512.5.6.4.1 Ejercicios for – next........................................................................................65

12.6 UNIDAD Nº3: PHP .........................................................................................................6912.6.1 Definición de PHP......................................................................................................7112.6.2 Funcionamiento..........................................................................................................7112.6.3 Características.............................................................................................................7112.6.4 Aspectos sobre la sintaxis de PHP..............................................................................7212.6.5 Ventajas.......................................................................................................................7312.6.6 Desventajas.................................................................................................................7312.6.7 Sentencias en PHP......................................................................................................74


12.6.7.1 Sentencia if.........................................................................................................7412.6.7.1.1 Ejercicios if.....................................................................................................74

12.6.7.2 Sentencia Switch.................................................................................................7712.6.7.2.1 Ejercicios switch – case..................................................................................78

12.6.7.3 Ciclo de repetición for.........................................................................................8312.6.7.3.1 Ejercicios for...................................................................................................83

12.6.7.4 Sentencia while...................................................................................................8612.6.7.4.1 Ejercicios while...............................................................................................86

12.6.7.5 Sentencia do while...............................................................................................8912.6.7.5.1 Ejercicios do – while.......................................................................................89

12.7 UNIDAD Nº 4: JAVA........................................................................................................9312.7.1 Definición....................................................................................................................9512.7.2 Máquina virtual de Java..............................................................................................9512.7.3 Compiladores de Java.................................................................................................9512.7.4 Entornos de desarrollo para Java................................................................................9612.7.5 Proceso de desarrollo de un programa en java...........................................................9612.7.6 Ventajas.......................................................................................................................9712.7.7 Desventajas.................................................................................................................9712.7.8 Estructura de un programa en Java.............................................................................97

12.7.8.1 Sentencias............................................................................................................9712.7.8.2 Comentarios........................................................................................................9812.7.8.3 Estructuras de control..........................................................................................98

12.7.8.3.1 Condición if....................................................................................................9812.7.8.3.2 Condición if/else.............................................................................................9912.7.8.3.3 Condición if/else if.........................................................................................99

12.7.8.3.3.1 Ejercicios if...............................................................................................9912.7.8.3.4 Condición switch - case................................................................................103

12.7.8.3.4.1 Ejercicios switch - case...........................................................................10312.7.8.3.5 Bucle de repetición while..............................................................................107

12.7.8.3.5.1 Ejercicios while......................................................................................10812.7.8.3.6 Bucle de repetición do while.........................................................................110

12.7.8.3.6.1 Ejercicios do while.................................................................................11012.7.8.3.7 Bucle de repetición for..................................................................................113

12.7.8.3.7.1 Ejercicios for...........................................................................................11412.7.8.3.8 Vectores (arreglos unidimensionales)............................................................117

15.7.8.3.8.1 Ejercicios vectores..................................................................................11813 PREGUNTAS..........................................................................................................................12314 REFERENCIAS BIBLIOGRÁFICAS....................................................................................129


1 MISIÓN Y VISIÓN DE LA CARRERA DE INFORMÁTICA

Misión

Formar profesionales en Ciencias de la Educación, mención Informática, con alto nivel científico, pe-dagógico, tecnológico y humanista, con capacidad creativa, innovadora e investigativa, a través de la teoría y la praxis para la solución de problemas, vin-culación con la sociedad y la realidad socio educati-va del país.

Visión

La carrera de Informática para el 2019 liderará, con altos estándares de calidad, la formación de docentes en Informática para el sistema educativo nacional, desarrollando programas de investigación, empren-dimiento y posgrado con responsabilidad, honesti-dad, equidad e inclusión, aportando al compromiso de transformación por medio de la vinculación con la sociedad para el desarrollo social y tecnológico del país.


2 INTRODUCCIÓN

La organización de la Unidad de Titulación Es-pecial se realiza con la finalidad de generar opor-tunidades para que los estudiantes que no han concluido sus trabajos de titulación puedan reali-zarlo, garantizando el perfil de egreso y para que incremente la eficiencia terminal en la carrera.

La carrera de Informática cumple con la base le-gal establecida en la Constitución, la Ley Orgá-nica de Educación Superior y el Reglamento de Régimen Académico para organizar la UNIDAD DE TITULACIÓN ESPECIAL que se organi-za sobre la base de una serie de núcleos problé-micos que constituyen el punto de partida para la actualización y validación del perfil de egreso de los estudiantes, mediante la formulación de nú-cleos estructurantes que se definen como un con-junto de asignaturas fundamentales en función de los resultados de aprendizaje.

En el presente documento se expone las modali-dades de titulación que la carrera ha selecciona-do, considerando que son las más adecuadas para la validación y actualización del perfil de egreso de los estudiantes.

Se establece una estructura curricular confor-mada por diferentes actividades que permitirán la preparación de los estudiantes garantizando el rigor académico que demanda un proceso de ti-tulación.

Finalmente, se expone el procedimiento que se deberá seguir en la carrera de Informática, tanto en sus fases de información, matriculación, orga-nización, como en la ejecución de las diferentes actividades determinadas en el proceso.


3 OBJETIVOS DE LA GUÍA

• Validar y actualizar académicamente el perfil de egreso actual de la carrera de Informática.• Organizar los aprendizajes, procesos formativos y metodologías para la titulación de los

estudiantes que han terminado la malla curricular.

4 SITUACIÓN ACTUAL DE LA CARRERA

DENOMINACIÓN DE LA CARRERA CARRERA DE INFORMÁTICA

Campo amplio del conocimiento (CINE) EducaciónCampo específico del conocimiento (CINE) EducaciónCampo detallado del conocimiento (CINE) Formación para docentes con asignaturas

de especializaciónDenominación del título que otorga Licenciado en Ciencias de la Educación,

mención InformáticaFecha de creación de la carrera 9 de julio de 1996Ente aprobador Honorable Consejo UniversitarioFecha de la última aprobación 9 de julio de 1996Modalidad de estudio PresencialNúmero de periodos académicos 9Número de créditos con trabajo de titulación 286Número de créditos sin trabajo de titulación 266Código de la carrera (Senescyt) 06974 – 00395

Tabla 1. Situación actual de la carreraFuente: Secretaría Carrera Informática UCE (2016)

5 ANTECEDENTES LEGALES

El Artículo 350 de la Constitución de la República establece: “El sistema de educación superior tiene como finalidad la formación académica y profesional con visión científica y humanista; la in-vestigación científica y tecnológica; la innovación, promoción, desarrollo y difusión de los saberes y las culturas; la construcción de soluciones para los problemas del país, en relación con los obje-tivos del régimen de desarrollo”; y, en el inciso tercero del Art. 356, “se garantiza a los estudiantes la igualdad de oportunidades en el acceso, en la permanencia, en la movilidad y en el egreso”.

El Art. 5 Literal a) de la Ley Orgánica de Educación Superior (LOES), establece como uno de los derechos de los estudiantes, “acceder, movilizarse, permanecer, egresar y titularse sin discrimina-ción conforme a sus méritos académicos”.

El Reglamento de Régimen Académico, fue expedido mediante resolución RPSE13-N°.51-2013 por parte del Consejo de Educación Superior (CES) en fecha 21 de noviembre de 2013 y reforma-do mediante resoluciones RPC-SO-13-N°.146-2014 y RPC-SO-45-N°.535 -2014, de 09 de abril de 2014 y 17 de diciembre de 2014, respectivamente.


La Disposición Transitoria Quinta del Reglamento de Régimen Académico en donde manifiesta que: “Desde la vigencia del presente reglamento, las IES tienen un plazo máximo de 18 meses para organizar e implementar una unidad de titulación especial para todas las carreras y programas vigentes, cuyo diseño deberá poner en conocimiento del CES. Esta unidad, además de un examen complexivo de grado contemplará, al menos, una opción de trabajo de titulación, de aquellas con-templadas en el literal b) numeral 3, del artículo 21 del Reglamento de Régimen Académico.

6 MODELO EDUCATIVO

La Dirección de Comunicación y Cultura informó que la Comisión Académica del H. Consejo Universitario nombró una comisión específica para elaborar el Modelo Educativo y Pedagógico de la Universidad Central del Ecuador.

El Licenciado Carlos Rodríguez, indicó que este aspecto existió en la UCE en forma implícita, pero que para el futuro se requiere hacerlo explícito y, en forma tal, que exprese las tradiciones educativas y las innovaciones que debe realizar la Universidad Central del Ecuador en el marco de las transformaciones nacionales y mundiales.

Para este fin, agregó Rodríguez, la Comisión solicita comedidamente a las y los profesores de cada facultad, de esta Casa de Estudios, responder la encuesta que alimentará dicho proyecto. La fecha límite de entrega de las mismas es hasta el jueves 12 de enero del 2012, vía formato digital y/o escrito al correo electrónico: [email protected], y/o a la oficina de la Dirección de Planeamiento Universitario.

7 PERFIL DE EGRESO DE LA CARRERA

El perfil de egreso de la carrera de Informática está conformado por el siguiente conjunto de resul-tados de aprendizaje que debe demostrar el estudiante al término de la carrera:

• Aplica los principios, teorías pedagógicas, metodologías, estrategias y recursos didácticos en diferentes contextos, propiciando el desarrollo integral del estudiante para un eficiente desempeño profesional acorde al Plan Nacional para el Buen Vivir.

• Utiliza el lenguaje simbólico, a través de la interpretación lógica del lenguaje natural, utilizan-do procesos de construcción del conocimiento que impliquen aprendizajes significativos, por medio del uso de las TIC para analizar, plantear, y resolver problemas matemáticos y físicos.

• Integra los conocimientos de la informática en los procesos de enseñanza-aprendizaje a través de la investigación de forma multidisciplinaria con responsabilidad y compromiso social.

• Diseña y ejecuta proyectos de investigación y emprendimiento aplicando metodología cien-tífica, para dar solución a problemas socio-educativos.

La Unidad de Titulación Especial de la carrera de Informática establece los siguientes procesos:

• El diagnóstico de los problemas de titulación que tiene la carrera.• Definición de los núcleos problémicos que constituyen el objeto de la formación profesional.• La organización del currículo de actualización y validación del perfil de egreso.


Diagnóstico de los procesos y resultados de titulación que tiene la carrera

Consiste en determinar la cantidad de estudiantes que deben ingresar al proceso y el nivel de cumplimiento del perfil de egreso. La carrera de Informática presenta la siguiente situación con respecto a los procesos de titulación realizados:

PERIODO ACADÉMICO

NRO. ESTUDIANTES MATRICULADOS

GRADUADOS COHORTES

ANTERIORES

PORCENTAJE DE GRADUACIÓN

Abril 2010 - Septiem-bre 2010

118 62 84%

Octubre 2010 – Marzo 2011

37

Abril 2011 – Septiem-bre 2011

209 3 9%


15


162 10 7%


1


196 4 2%


42 12 29%


42 5 12%


11 40 28%

Abril 2015 -Septiembre 2015

12 119 10%

Octubre 2015- Mar-zo 2016

2365

78%

Abril 2016- Septiem-bre 2016

28

Octubre 2016- Marzo 2017

18 - -

Tabla 2. Diagnóstico de los procesos y resultados de titulación que tiene la carrera Fuente: Secretaría Carrera Informática UCE (2016)

8 DESCRIPCIÓN Y ANÁLISIS

En la carrera de Ciencias de la Informática durante la fase que corresponde a la cohorte abril 2010-marzo 2011 se matricularon 118 estudiantes, de los cuales se graduaron 99. La diferencia es de 19 estudiantes, lo que corresponde a un 16% de no graduación.


En una segunda fase que corresponde a la cohorte abril 2011-marzo 2012 se matricularon 209 estudiantes, de los cuales se graduaron 18. La diferencia es de 191 estudiantes, lo que corresponde a un 91% de no graduación.

En una tercera fase que corresponde a la cohorte abril 2012-marzo 2013 se matricularon 162 es-tudiantes, de los cuales se graduaron 11. La diferencia es de 151 estudiantes, lo que corresponde a un 93% de no graduación.

En una cuarta fase que corresponde a la cohorte abril 2013-septiembre 2013 se matricularon 196 estudiantes, de los cuales se graduaron 4. La diferencia es de 192 estudiantes, lo que corresponde a un 98% de no graduación.

En una quinta fase que corresponde a la cohorte octubre 2013-marzo 2014 se matricularon 42 es-tudiantes, de los cuales se graduaron 12. La diferencia es de 30 estudiantes, lo que corresponde a un 71% de no graduación.

En una sexta fase que corresponde a la cohorte abril 2014-septiembre 2014 matricularon 42 estu-diantes de los cuales se graduaron 5. La diferencia es de 37 estudiantes, lo que corresponde a un 88% de no graduación.

En una séptima fase que corresponde a la cohorte octubre 2014-marzo 2015 se matricularon 11, de los cuales se graduaron 40. El número supera a los matriculados debido a que comienzan a incluir-se en el proceso estudiantes que por múltiples situaciones no podían graduarse por varios años. Sin embargo de los estudiantes del último semestre se gradúa el 28%.

En una octava fase que corresponde a la cohorte abril 2015-septiembre 2015 se matricularon 12, de los cuales se graduaron 119. Al igual que el caso anterior los cambios de normativa y otros procesos administrativos permitieron que un número de estudiantes, cuyo trámite de graduación se encontraba detenido, logren culminar el objetivo durante este semestre. Pero de último semestre de la Carrera de Informática sólo corresponde al 10% de estudiantes.

En una novena fase que corresponde a las cohortes octubre 2015-marzo 2016 y abril 2016-sep-tiembre 2016 dan un total de 51 estudiantes matriculados, de los cuales se graduaron 65. En el total se incluyen estudiantes de diferentes cohortes. Como en los casos anteriores el número de graduados sobrepasa al de los matriculados, se consigue graduar a un porcentaje de 78% de los matriculados en el último semestre.

Frente a la situación descrita, es necesario que en la carrera de Informática se implementen estrategias que agiliten el proceso de graduación de los estudiantes en tiempos oportunos, tomando en cuenta la normativa vigente establecida por del Consejo de Educación Superior (CES) y se diseñe la Unidad de Titulación Especial de la carrera de Informática como una alternativa válida para incrementar el nivel de eficiencia terminal con base en la validación y actualización del perfil de egreso de la carrera.

Definición de los núcleos problémicos que constituyen el objeto de la formación profesional

Son los problemas, dilemas o preguntas esenciales que se tienen que resolver con la formación profesional. Estos núcleos problémicos se convierten en los organizadores del currículo de la Uni-dad de Titulación Especial y son el punto de partida para formular los componentes del examen complexivo y las líneas investigativas en el caso de proyecto de investigación o de cualquier otra modalidad. La carrera de Informática determina los siguientes núcleos problémicos:


1 ¿Qué y cómo enseñar?2 ¿Cómo desarrollar el pensamiento crítico y lógico?3 ¿Cuáles son las herramientas informáticas que apoyan al proceso educativo?4 ¿Cómo detectar y resolver problemas socioeducativos?

Tabla 3. Definición de los núcleos problémicos que constituyen el objeto de la formación profesionalFuente: Secretaría Carrera Informática UCE (2016)

La organización del currículo de actualización y validación del perfil de egreso

Se establece mediante la definición de los núcleos estructurantes, las asignaturas relacionadas con el núcleo y los resultados de aprendizaje que constituyen el perfil de egreso de la carrera. Esta organización cumple con los objetivos de actualización y validación del perfil de egreso de los estudiantes y orienta a las modalidades de titulación. La organización curricular se la integra en la siguiente matriz:

NÚCLEO PROBLÉMICO

NÚCLEOSESTRUCTURANTES

ASIGNATURASRELACIONADAS CON EL NÚCLEO

RESULTADOS DE APRENDIZAJE

¿Qué y cómo enseñar?

Gestión docente PedagogíaDidácticaCurrículo

Aplica los principios, teo-rías pedagógicas, metodo-logías, estrategias y recur-sos didácticos en diferentes contextos, propiciando el desarrollo integral del estu-diante para un eficiente des-empeño profesional acorde al Plan Nacional para el Buen Vivir.

¿Cómo desarrollar el pensamiento

crítico y lógico?

Pensamiento crítico y lógico

FísicaMatemática

Utiliza el lenguaje simbóli-co, a través de la interpre-tación lógica del lenguaje natural, utilizando proce-sos de construcción del co-nocimiento que impliquen aprendizajes significativos, por medio del uso de las TIC para analizar, plantear, y resolver problemas mate-máticos y físicos.

¿Cuáles son las herramientas

informáticas que apoyan al proceso

educativo?

Tecnologías de información y comunicación

ProgramaciónAdministración de

datos Redes de computadores

Sistemas operativosArquitectura y man-

tenimiento de computadores

Integra los conocimientos de la informática en los proce-sos de enseñanza- aprendiza-je a través de la investigación de forma multidisciplinaria con responsabilidad y com-promiso social.


¿Cómo detectar y resolver problemas

socioeducativos?

Investigación educativa

InvestigaciónGestión de proyectos

Diseña y ejecuta proyectos de investigación y empren-dimiento aplicando meto-dología científica, para dar solución a problemas so-cio-educativos.

Tabla 4. La organización del currículo de actualización y validación del perfil de egresoFuente: Secretaría Carrera Informática UCE (2016)

9 MODALIDADES DE LA UNIDAD DE TITULACIÓN ESPECIAL

La carrera de Informática establece como resultado final de la Unidad de Titulación Especial las siguientes modalidades:

• El desarrollo de un trabajo de titulación, basado en procesos de investigación e intervención.• La preparación y aprobación de un examen de grado de carácter complexivo.

9.1 Proyecto tecnológico

El trabajo de titulación en la carrera de Informática es el resultado investigativo y académico, en el cual el estudiante demuestra el manejo integral de los conocimientos adquiridos a lo largo de su formación profesional. Se consideran trabajos de Titulación en la carrera de Informática:

9.1.1 Proyectos tecnológicos educativos

Para los proyectos de titulación en la carrera de Informática se tomarán en cuenta las siguientes líneas de investigación concordantes con los núcleos problémicos y estructutantes:

NÚCLEO PROBLÉMICO NÚCLEOS ESTRUCTURANTES

LÍNEAS DE INVESTIGACIÓN

¿Qué y cómo enseñar? Gestión docente Didáctica de la informática

¿Cómo desarrollar el pensamiento crítico y lógico?


Aplicabilidad de las ciencias exactas

¿Cuáles son las herramientas informáticas que apoyan al proceso educativo?


E-learningAplicación de las Tic en la educación Implementación de hardware y software

¿Cómo detectar y resolver problemas socioeducativos?

Investigación Educativa Investigación tecnológica educativa

Tabla 5.Líneas de investigación concordantes con los núcleos problémicos y estructurantesFuente: Secretaría Carrera Informática UCE (2016)


Es un trabajo académico que busca la generación de conocimientos mediante la aplicación de me-todologías de la investigación científica. Los temas del proyecto deben estar en correspondencia con las líneas de investigación que se desprenden de la organización del currículo para la actuali-zación y validación del perfil de egreso.

9.1.2 Metodología de desarrollo del proyecto tecnológico

La metodología a utilizar para el desarrollo tecnológico se divide en cinco fases, las mismas que se detallan a continuación:

a. Fase I: AntecedentesSe realiza un diagnóstico situacional determinando los aspectos positivos y negativos del entorno con el fin de determinar el problema a resolver, luego se define el objetivo y justificación para el desarrollo del proyecto tecnológico.

b. Fase II: Marco referencialSustenta la investigación a través de enfoques pedagógicos y tecnológicos referentes al tema, re-copilando la información necesaria en diferentes fuentes bibliográficas y haciendo una síntesis de la misma.

c. Fase III: Metodología de la investigaciónEl nivel de profundidad del proyecto de investigación será exploratorio, descriptivo y diagnóstico; la estructura del mismo deberá contener al menos una base conceptual, marco metodológico, pro-cesamiento de la información, conclusiones y fuentes de consulta.

El proyecto tecnológico se describe como una actividad académica y científica que busca dar so-lución a un problema real, a través del desarrollo de un producto o servicio.

d. Fase IV: Desarrollo de proyecto tecnológico educativoEn esta fase se crea, diseña y desarrolla el producto tecnológico, el mismo que puede ser: sof-tware educativo, materiales digitales, videos educativos, presentaciones multimedia, aplicaciones informáticas con fines académicos. Además deben incluir metadatos para su reutilización y ser incorporados en los OVA.

El desarrollo de aplicaciones para dispositivos móviles con fines educativos como juegos, revistas digitales, lectores de noticias, aplicaciones para mejorar la memoria, la concentración, por men-cionar algunas. También se incluyen dentro de los proyectos tecnológicos la creación de productos realizados con hardware (robótica educativa) a pequeña y mediana escala.

e. Fase V: Usabilidad, efectividad y diseñoEl proyecto tecnológico que la carrera de informática busca implementar es de tipo educativo. Habla-mos de la creación de OVA (objetos virtuales de aprendizaje); los mismos que deben cumplir con tres variables que son: usabilidad, efectividad y diseño, y estas a su vez cumplen con varios indicadores de calidad que permiten entregar un producto que sirva de apoyo al proceso de enseñanza-aprendizaje.

9.2 Examen complexivo

Es el examen de grado de naturaleza teórica y/o práctica que deberá estar articulado al perfil de egreso de la carrera, con el mismo nivel de complejidad, tiempo de preparación y demostración


de resultados de aprendizaje o competencias, que el exigido en las diversas formas del trabajo de titulación.

La finalidad del examen es la demostración de las capacidades para resolver problemas haciendo uso creativo y crítico del conocimiento, por tanto, el examen no es una medición del nivel de me-morización del estudiante.

9.2.1 Metodología del examen complexivo

Evalúa los resultados de aprendizaje logrados por los estudiantes tomando en cuenta aspectos cognitivos, actitudinales y principalmente procedimentales. La evaluación se realiza mediante pruebas de base estructurada a través de reactivos de opción múltiple con cuatro opciones (A, B, C, D), los niveles taxonómicos que se utilizan para la elaboración de reactivos son los niveles de comprensión y aplicación de la taxonomía de Bloom (1956).

El porcentaje de cada componente y el número de preguntas de cada subcomponente deberá ser equilibrado, tomando en cuenta el perfil de egreso. Para la realización del examen complexivo, la carrera de Informática establece la siguiente organización curricular:

9.2.2 Estructura y ponderación del examen complexivo

La estructura del examen complexivo será con base en dos componentes.

a. Prueba de base estructurada. Con las siguientes características:

TIPO DE PRUEBA: objetivaTIPO DE PREGUNTAS: selección múltipleNo. DISTRACTORES: cuatro (4)No. PREGUNTAS: sesenta (60)TIEMPO DURACIÓN PRUEBA: sesenta (60) minutosPONDERACIÓN: cuarenta por ciento (40%) del valor totalEVALUACIÓN: matriz de resultados (baremo)

b. Prueba de base no estructurada. Con las siguientes características:

TIPO DE PRUEBA: no estructuradaTIPO DE PREGUNTAS O PROBLEMAS: libreNo. PREGUNTAS O PROBLEMAS: máximo tres (3)TIEMPO DURACIÓN PRUEBA: sesenta (60) minutosPONDERACIÓN: sesenta por ciento (60%) del valor totalEVALUADORES: tribunal de examen

9.2.3 Tipos de reactivos de las preguntas del examen

El instrumento de evaluación utiliza diferentes tipos de reactivos de selección múltiple con cuatro opciones. Los tipos de reactivos son:

• Cuestionamiento directo -reactivo simple- respuesta única: Consta del planteamiento de la pregunta con su debida contextualización y la orden específica de lo que debe realizar el


alumno. Se plantean cuatro alternativas de respuesta, siendo solo una de ellas la correcta. Los estudiantes deben seleccionar una de las cuatro opciones de respuestas, a partir del cri-terio enunciado en la base.

• Ordenamiento o jerarquización: Se realiza el planteamiento contextualizado de la pregun-ta con la instrucción sobre el criterio con el cual se debe ordenar. Se enlista numéricamente los elementos en desorden y los estudiantes deben seleccionar la opción en la que aparezcan los elementos en el orden solicitado.

• Elección de elementos: Se realiza el planteamiento de la pregunta en su contexto. Se debe mencionar el criterio con el cual seleccionar los elementos, posteriormente se enumeran los elementos que pueden ser: conceptos, frases, procedimientos, hechos, teorías. Los estudian-tes deben escoger la respuesta con los elementos que contienen el criterio mencionado.

• Doble columna: Se realiza una breve contextualización de la pregunta. Se plantea de mane-ra clara el criterio con el que se va a relacionar las columnas. Construir las dos columnas a relacionar. Los estudiantes deben seleccionar la opción de respuesta con las combinaciones de relación entre los elementos de la primera y segunda lista.

• Multireactivo: Se parte de una temática común o de la descripción de una situación o pro-blema específico. Puede incluir un texto, una tabla, una gráfica, un mapa o un dibujo, seguido por una serie de reactivos que deben ser contestados considerando la información presentada inicialmente. Los reactivos pueden adoptar distintos formatos como los que se han descrito anteriormente.

Para la evaluación del examen complexivo se realizará un banco de preguntas de base estructu-rada, de acuerdo con los componentes y subcomponentes de la organización curricular, el mismo que será evaluado bajo plataforma virtual.

9.2.4 Asignaturas y temas para el examen complexivo

NUCLEOS ESTRUCTURANTES

(componentes)

ASIGNATURASRELACIONADAS CON

EL NÚCLEO(subcomponentes)

% TEMARIO ESPECÍFICO

Gestión docente Pedagogía

30

Reformas educativas ecuatorianasPedagogía críticaModelos pedagógicos

Didáctica de la especialidad

Principios de la didácticaTeorías del aprendizajeEstilos de aprendizajeMetodologías de enseñanzaEstrategias y técnicasMetodologías aplicadas a la informática

Currículo Reforma a la EGB y BGUPEIPlanificación microcurricular



Programación

30

Análisis de algoritmos y flujogra-masJavaPHPVisual.NET

Administración de datos Conceptualización base de datosSistema de gestión de base de datosModelo Entidad - RelaciónNormalizaciónSentencias SQL Select, Update, Delete, View

Redes de computadores Tipos de redesMedios de transmisión Guiados y no guiadosArquitectura cliente / servidorModelo OSI - TCP /IPClases de direcciones IPSubneteo de direcciones

Sistemas operativos Historia y estructura de los sistemas operativosSistema operativo WindowsConfiguración y administración de S.O WindowsSeguridad de los sistemas operativosSoftware libreKernel LinuxConfiguración y administración de Linux

Arquitectura y mantenimiento de

computadores

Componentes interno y externo del ordenadorMantenimiento correctivo y preventivo


Matemáticas

20

Algebra booleanaProgramación linealOptimizaciónManejo de software matemático

Física Principios de electrónica básicaPrincipios generales de la Física de Newton


Investigación educativa Investigación 20 Teoría del conocimientoMétodos de investigaciónTipos de proyectosComponentes de un proyectoElaboración de proyectosInforme de investigación

Gestión de proyectos Conceptos básicos de la gestión de proyectosFases de la gestión de proyectosGestión estratégica de proyectosPMBOK

Tabla 6. Asignaturas y temas para el examen complexivoFuente: Secretaría Carrera Informática UCE (2016)

9.2.5 Instructivo para el estudiante que opta por el examen complexivo

El estudiante que opta por el examen complexivo deberá observar las siguientes consideraciones:

• Haber recibido la aprobación oficial de la inscripción para la presentación del examen com-plexivo por parte de la carrera.

• Cancelar el valor estipulado en tesorería de la institución.• Presentarse con puntualidad al lugar de recepción del examen complexivo en la fecha y hora

establecidas por la unidad académica.• Identificarse con documentos originales (cédula de ciudadanía o pasaporte) y la factura de

pago ante el presidente del Tribunal de recepción del examen complexivo.• Observar las disposiciones que cada coordinador de comisiones de examen complexivo pro-

porcionará el momento de la prueba.• Desarrollar con la mejor pertinencia las pruebas correspondientes al examen complexivo.• Para la prueba estructurada de tipo objetiva, se utilizará la plataforma virtual institucional.• Para la prueba no estructurada, recibirá las preguntas/problemas específicos que deberá de-

sarrollar el estudiante, de temas y subtemas específicos de la carrera.• El estudiante deberá identificarse en la prueba, escribiendo sus nombres completos, número

de cédula de ciudadanía, etc.• Al concluir las mismas deberá entregar al coordinador de las pruebas el desarrollo efectuado.• De no estar conforme con las calificaciones de la prueba no estructurada, podrá ejercer el

derecho de recalificación establecido.

10 ESTRUCTURA CURRICULAR DE LA UNIDAD DE TITULACIÓN ESPECIAL

Para la estructura curricular de la Unidad de Titulación Especial, se establecen cuatro tipos de actividades:

• Aprendizaje con interacción directa entre el profesor y el estudiante.• Tutoría de los trabajos de titulación.


• Aprendizaje práctico.• Aprendizaje autónomo.

En la carrera de Informática las actividades de la estructura curricular se distribuyen de la siguiente manera:

10.1 Proyecto tecnológico

Organización del Aprendizaje Horas totales Semanas Horas semanales

Aprendizaje con interacción directa con el profesor con el estudiante.

12020

6

Tutoría de los Trabajos de Titulación. 60 3

Aprendizaje Práctico. 100 5

Aprendizaje Autónomo. 120 6

TOTAL 400 20

Tabla 7. Proyecto tecnológicoFuente: Secretaría Carrera Informática UCE (2016)

10.2 Examen complexivo

Organización del Aprendizaje Horas Totales Semanas Horas semanales

Aprendizaje con interacción directa con el profesor con el estudiante (acompañamiento).

160

20

8

Tutoría metodólgica para el examen complexivo.

20 1

Aprendizaje práctico (cumplimiento de tareas designadas durante el acompañamiento.

80 4

Aprendizaje autónomo. 140 7

TOTAL 400 20

Tabla 8. Trabajo de titulaciónFuente: Secretaría Carrera Informática UCE (2016)

10.3 Descripción de las actividades

• Aprendizaje con interacción directa entre el profesor y el estudiante: Tiene que ver con las actividades relacionadas con conferencias, seminarios, talleres, modelados de estudios de caso y de resolución de problemas. Estas actividades pueden desarrollarse en el aula u otros ambientes de aprendizaje que se diseñen en los ámbitos académicos y laborales. Estas acti-vidades tienen la finalidad de afianzar los elementos teóricos de las asignaturas de la Unidad de Titulación Especial.


• Tutoría de los trabajos de titulación: Son las actividades de acompañamiento y asesoría académica que realiza el profesor para ampliar y complementar explicaciones referidas a procesos metodológicos, técnicos y prácticos, orientadas a que el estudiante desarrolle las fases del trabajo de titulación en términos de elaboración de las narrativas y de las etapas de diseño, recolección de información, procesamiento, sistematización, conclusiones y plantea-miento de estrategias para la solución de los problemas.

• Aprendizaje práctico: Relacionado por la práctica de investigación-acción del estudiante en términos de experimentación y aplicación de conocimientos teóricos, metodológicos y técnico-instrumentales, que posibiliten la validación del perfil de egreso, así como los proce-sos relacionados con sus capacidades investigativas y cognitivas de carácter estratégico.

• Aprendizaje autónomo: Se refiere al tiempo que dedica el estudiante para la generación de los procesos de exploración e indagación del conocimiento, la reflexividad sobre sus prácti-cas de investigación que posibilite la teorización de su experiencia de aprendizaje. Corres-ponde a este tipo de aprendizaje, las lecturas, la construcción de las narrativas y síntesis, las reflexiones críticas, el planteamiento de soluciones creativas, etc.

11 PROCEDIMIENTOS PARA LA TITULACIÓN

11.1 Información

• El coordinador de la Unidad de Titulación Especial elaborará un cronograma de actividades antes de iniciar el proceso de matriculación.

• La carrera convocará a los estudiantes aspirantes a matricularse en la Unidad de Titulación Especial para una charla informativa sobre las modalidades de titulación y el cronograma de actividades que se ha establecido en la carrera.

11.2 Matrícula en la Unidad de Titulación Especial

• Para matricularse en la unidad de titulación de la carrera de Ciencias del Lenguaje y Litera-tura, los estudiantes deben haber aprobado integralmente su malla curricular.

• Para la matricula deberá presentar en la secretaría de la carrera los siguientes documentos: • Solicitud dirigida al Director de la carrera, en la que se exprese la modalidad de titulación

seleccionada por el estudiante.• Certificado emitido por secretaria en el cual manifiesta que el estudiante ha terminado la

malla curricular.• Certificación de haber aprobado las actividades complementarias (Idiomas, Informática,

Educación Física) • Fotocopia de la cédula de identidad y certificado de votación último.• La entrega de documentos se realizará durante el período de matrículas ordinarias y extraor-

dinarias establecido para cada carrera.

11.3 Organización

• La secretaría entregará al coordinador de la Unidad de Titulación Especial el listado de los estudiantes matriculados en cada modalidad de titulación.


• El coordinador de la Unidad de Titulación Especial de la carrera elabora el distributivo de los docentes, grupos de estudiantes y el horario de cada una de las actividades de la estructura curricular de la Unidad de Titulación Especial.

11.4 Ejecución

El coordinador de Unidad de Titulación Especial de la carrera establecerá los mecanismos y regis-tros necesarios. A continuación se detallan.

11.4.1 Para el trabajo de titulación

• El coordinador de la Unidad de Titulación Especial de la carrera aprobará bajo solicitud escrita el pedido de estudiantes que desean realizar el trabajo en parejas de acuerdo a la na-turaleza, complejidad, innovación y extensión del trabajo de titulación.

• El Director de la carrera designará por escrito al docente tutor del trabajo de titulación.• El docente tutor cumplirá con las horas de tutoría de los trabajos de titulación de acuerdo al

horario establecido en la carrera y presentará un informe al finalizar el mismo.

11.4.2 Para el examen complexivo

Con base en los subcomponentes y temas específicos establecidos, el coordinador organizará, con el apoyo de los docentes designados dentro de su carga horaria para la Unidad de Titulación Espe-cial de la carrera, las siguientes actividades:

• Flujo de proceso• Guía metodológica para el examen complexivo• Elaboración de reactivos• Validación de reactivos (por pares y estudiantes)• Construcción de pruebas• Calificación• Informe de resultados

ASIGNATURADIDÁCTICA DE LA

ESPECIALIDAD

MSc. Yolanda BorjaMSc. Juan Carlos Cobos


12.1. Descripción de la Asignatura

La asignatura de Programación permite desarrollar en las y los estudiantes de la carrera de infor-mática las capacidades necesarias para programar en lenguajes de cuarta generación como es el lenguaje de programación C++, Visual Basic, PHP y Java.

PHP es una herramienta especializada en el desarrollo e implementación de portales web, vincula-do con el gestor de bases de datos Mysql. Además el uso de servidores locales y online permitirá entender el funcionamiento de la estructura web para así integrar sus conocimientos.

Java es una herramienta Orientada a Objetos, proporciona una plataforma robusta, en un entor-no integrado de desarrollo IDE, abierto y extensible para todo y nada en particular, adaptable a cualquier lenguaje. Este lenguaje está formado por un conjunto de palabras reservadas, símbolos y reglas sintácticas y semánticas que definen su estructura y el significado de sus elementos y ex-presiones.

12.2 Objetivo de la Asignatura

• Saber conocer y describir principios del lenguaje de programación PHP de manera sistémica.• Construir proyectos aplicando la programación Orientada a Objetos que le permita al estu-

diante resolver problemas de distinta índole (matemáticos, administrativos, gráficos, conta-bles etc.) empleando como herramienta la computadora través de la plataforma del Java y programa Eclipse, con honestidad.

12.3 Temas de Programación para el examen complexivo

PROGRAMACIÓN

• Lenguaje C++

• Visual. Net

• PHP

• Java

Tabla 29.Temas de Currículo para el Examen ComplexivoFuente: Secretaría Carrera Informática UCE (2016)

UNIDAD Nº 1LENGUAJE C++


12.4.1 Definición de Lenguaje de Programación C++

Es una aplicación y modificación del lenguaje C, para incorporarle tipos abstractos de datos, que reciben el nombre de clases. Cueva, 1998, p. 81.

En el ejemplo hola.cpp se escribe un programa que emite un saludo, pero esta vez utilizando las clases predefinidas en la librería iostream.h, que permiten usar los manejadores de entrada y salida. Este programa compilado con Borland C++, produce un programa ejecutable de 23136bytes.

Sintaxis

12.4.2 Borland

En este compilador los archivos de cabecera deben estar ubicados en la misma unidad lógica y directorio, su ventaja es compilar mucho más rápido que C++, turbo C++3.0 de Borlan y el IDE Turbo C++ ofrece todo lo que usted necesita para escribir, editar, compilar, vincular, correr, ma-nejar y depurar sus programas.

12.4.3 Características

• Un programa en C++ se compone de una o más funciones, de las cuales una debe ser obliga-toriamente main().Ceballos, S. F. J. (2009)

• Los elementos básicos de un programa C++ son: identificadores, palabras reservadas, co-mentarios, signos de puntuación, separadores y archivos cabecera. Ceballos, S. F. J. (2009)

• C++ permite escribir constantes enteras en octal (base 8) o hexadecimal (base 16).Ceballos, S. F. J. (2009)

• C++ es un lenguaje que soporta diversos estilos de programación (por ejemplo, la programa-ción genérica y la programación orientada a objetos POO). Ceballos, S. F. J. (2009)

• C++ está organizado de tal forma que el aprendizaje del mismo puede hacerse gradualmente obteniendo beneficios prácticos a lo largo de este camino. Ceballos, S. F. J. (2009)

12.4.4 Ventajas

• C++ está fundamentado en C lo que garantiza que los millones de líneas de código C exis-tentes puedan beneficiarse de C++ sin necesidad de reescribirlas. Ceballos, S. F. J. (2009)

#include <iostream> // librería para uso de cout

using namespace std;

main() // función principal

{

cout << “Hola a todos\n”;

}


• Una de las ventajas de C++ es su independencia de la plataforma en lo que a código fuente se refiere. Ceballos, S. F. J. (2009)

• C++ se utiliza ampliamente en docencia e investigación porque es claro, realista y eficiente. Ceballos, S. F. J. (2009)

• Es lo suficientemente comercial como para ser incorporado en el desarrollo empresarial. Ceballos, S. F. J. (2009)

• Existen varias implementaciones de C++ de distribución gratuita; Ej. GCC (GNU Comiller-Collection). Ceballos, S. F. J. (2009)

12.4.5 Desventajas

• No cuenta con interfaz gráfica.• Uso de DLLs (librerías dinámicas) muy complejo. • Es difícil programar bases de datos. • Encapsulación

12.4.6 Estructura del Lenguaje C++

12.4.6.1 Comando If, else

Es el que nos permite tomar decisiones y las condiciones que trabajamos durante los flujogramas y pseudocódigos. El if siempre estará compuesto por la condición y la primera decisión que tomará el computador corresponde a la salida por verdadero, luego si la condición no se cumple, ejecuta la opción de falso (else).

12.4.6.1.1 Ejercicios: if, else

Ejercicio 1: Elabore un programa que permita digitar una hora en hora, minutos, segundos y de-muestre por pantalla la hora que es un segundo después.

if

(condición)

else


Código Fuente

Ejercicio 2: Desarrolle un programa que permita ingresar la temperatura en grados e indicar por pantalla el tipo de clima.

Código Fuente

#include <stdio.h>#include <stdlib.h>int main(void){int horas, minutos, segundos; printf(“Introduzca Hora:”);scanf(“%d”,&horas);printf(“Introduzca Minutos:”);scanf(“%d”,&minutos);printf(“Introduzca Segundos:”);scanf(“%d”,&segundos);segundos=segundos+1;if (minutos>59){minutos=0;}if (horas>23){horas=0; }if (segundos>59){segundos=0;minutos=minutos+1;if (minutos>59) {minutos=0;horas=horas+1;if (horas>23) {horas=0;}}}printf(“La hora (un segundo después) es: %02d:%02d:%02d \n”, horas, minutos, segundos);system(“PAUSE”); return 0;}

#include <stdio.h>int main(void){int X,Y;printf(“Introduzca la temperatura en GRADOS “);scanf(“%d”,&X);if(X<15){printf(“\n Clima frio!\n”);}else if(X<25){printf(“\nClima templado\n”);}else{printf(“\nClima muy cálido!\n”);}}


Ejercicio 3: Desarrolle un programa que permita ingresar tres números e indicar si el tercero es igual a la suma del primero y el segundo.

Código Fuente

Ejercicio 4: Desarrolle un programa que, muestre un menú que contemple las opciones “Archivo”, “Buscar” y “Salir”, en caso de que no se introduzca una opción correcta se notificará por pantalla.

Código Fuente

#include <stdio.h>#include <stdlib.h>int main(void)

{int num1,num2,num3;printf(“Introduzca número 1:”);scanf(“%d”,&num1);printf(“Introduzca número 2:”);scanf(“%d”,&num2);printf(“Introduzca número 3:”);scanf(“%d”,&num3);if (num1+num2==num3)

{printf(“El tercer número es la suma de los dos primeros.\n”);

}else

{printf(“El tercer número NO es la suma de los dos primeros.\n”);

}system(“PAUSE”); return 0;

}

#include <stdio.h>#include <stdlib.h>int main(void){int opcion;printf(“Seleccione opción:\n”);printf(“1 - Archivo\n”);printf(“2 - Buscar\n”);printf(“3 - Salir\n”);scanf(“%d”,&opcion);if (opcion!=1 && opcion!=2 && opcion!=3) {printf(“La opción NO es correcta.\n”); }else{printf(“La opción es correcta.\n”); } system(“PAUSE”); return 0;}


Ejercicio 5: Elabore un programa que lea un importe bruto y calcule su importe neto, si es mayor de 15.000 se le aplicará un 16% de impuestos, caso contrario se le aplicará un 10%.

Código Fuente

12.4.6.2 Sentencia while

En while se repite un bloque de instrucciones mientras se cumple una determinada condición. La condición se verifica al inicio.

Sintaxis

Aquí se ejecuta el (los) estatuto (s) mientras la condición es verdadera; al momento de ser falsa termina el ciclo. Si la condición es falsa la primera vez nunca se ejecuta(n) el (los) estatuto(s).

12.4.6.2.1 Ejercicios while

Ejercicio 1: Elabore un programa que permita desplegar por pantalla la palabra “HOLA” mientras se presione el número 1.

#include <stdio.h>#include <stdlib.h>int main(void){float importe, deduccion; printf(“Introduzca Importe:”);scanf(“%f”,&importe);if (importe>15000) {deduccion=importe*0.16; }else {deduccion=importe*0.1; }printf(“El importe neto es %f euros\n”,importe-deduccion);system(“PAUSE”); return 0;}

while ( condición ) estatuto;Si se requiere realizar más de un estatuto se deben utilizar llaves. while ( condición ) {


Código Fuente

Ejercicio 2: Elabore un programa que permita desplegar por pantalla, la palabra “vuelta” 10 veces.

Código Fuente

Ejercicio 3: Diseñe un programa que permita ingresar (1=aprobado, 2=reprobado), de 10 estu-diantes, finalmente demostrar por pantalla el resultado de aprobados y reprobados.

#include <stdio.h>#include <stdlib.h>main(){int num;printf ( “Ingrese un número”);scanf(“%d”,&num);

while (num == 1){printf (“\n HOLA\n\n”);printf (“Ingrese otro numero: “);scanf(“%d”,&num);}system(“PAUSE”);return 0;}

#include <stdio.h>#include <stdlib.h>int main (){int contador = 0; printf ( “Este es un bucle de 10 ciclos o vueltas\n”, contador );while ( contador < 10 ) {contador++; printf( “vuelta %d\n”, contador ); } return 0;}


Código Fuente

Ejercicio 4: Codifique en lenguaje C++, un programa que permita inventar un número para que lo adivine el usuario, colocando un contador de intentos.

Código Fuente

#include <stdio.h>int main(){int contador; int calificacion; int total;float promedio; total = 0; contador = 0; printf( “Introduzca la calificacion, (-1 para finalizar:) “ ); scanf( “%d”, &calificacion ); while ( calificacion != -1 ) {total = total + calificacion; contador = contador + 1; printf( “Introduzca la calificacion, (-1 para finalizar): “ );scanf(“%d”, &calificacion); } if ( contador != 0 ) {promedio = ( float ) total / contador; printf( “ El promedio de la clase es: %.2f\n”, promedio );} else { printf( “No se introdujeron calificaciones\n” );} return 0; }

#include <stdio.h>#include <time.h>#include <stdlib.h>int main(void){ int x,num,contador=0; srand((unsigned)time(NULL)); x=rand()%(101); printf(“Intenta adivinar el numero que he pensado entre 0 y 100.”); int bandera=0; while (bandera==0){printf(“\n\nIntroduce numero: “);scanf(“%d”,&num);contador++;if(num>x){printf(“\nMenor”); }else if(num<x){printf(“\nMayor”); }else{printf(“\n\nEnhorabuena! Lo has adivinado en %d intentos.\n\n”,contador);bandera=1;


Ejercicio 5: Diseñar un programa que permita ingresar notas y calcular el promedio. Para detener el ingreso debe digitar (-1).

Código Fuente

12.4.6.3 El ciclo do-while

Tanto el while como el for validan la condición antes de ejecutar el bloque de instrucciones la primera vez, con lo cual abren la posibilidad de que este no se ejecute ni una sola vez. El do-while valida la condición final, por lo cual existe la garantía de que dicho bloque se ejecute al menos una vez. López, G. J. L. (2014)

Esto quiere decir que la sentencia do-while, se ejecuta al menos una vez antes de que se evalúe la expresión condicional. La estructura do-while es la siguiente:

#include <stdio.h>int main(){int aprobados = 0;int reprobados = 0;int estudiante = 1;int resultado; while ( estudiante <= 10 ) {printf( “Introduzca el resultado ( 1=aprobado,2=reprobado ): “ );scanf( “%d”, &resultado );if ( resultado == 1 ) {aprobados = aprobados + 1;}else { reprobados = reprobados + 1;}estudiante = estudiante + 1; } printf( “Aprobados %d\n”, aprobados );printf( “Reprobados %d\n”, reprobados );if ( aprobados > 8 ) {printf( “Objetivo alcanzado\n” );}return 0; }

do{........Bloque de Instrucciones............}while(condición de finalización); //por ejemplo numero != 23


12.4.6.3 Ejercicios do-while:

Ejercicio 1: Realizar un programa en lenguaje c++, que permita descomponer números en factores primos.

Código Fuente

Ejercicio 2: Elaborar un programa en c++ que permita simular una calculadora básica de 5 fun-ciones.

#include <iostream>using namespace std;int main() { int numero; int factor; char resp[12];do { cout << “Introduce un número entero: “;cin >> numero;factor = 2; while(numero >= factor*factor) { if(!(numero % factor)) { cout << factor << “ * “; numero = numero / factor; continue; }if(factor == 2) factor++; else factor += 2; } cout << numero << endl; cout << “Descomponer otro número?: “; cin >> resp; } while(resp[0] == ‘s’ || resp[0] == ‘S’); return 0; }


Código Fuente

#include <stdio.h>#include <math.h>int main(void){float x,y,s,d,p,c,sr,rq,res,ros,cb,ch,co,cop,se,sep,ta,tap,cub, cubp,in,inp,lo,lop,ln,lnp;int opc;printf(“CALCULADORA de 5 funciones.\n\n”);do{printf(“Introduzca UN numero (0 para salir): “);scanf(“%f”,&x);printf(“\nAhora, inserte otro: “);scanf(“%f”,&y);printf(“\n\nSeleccionar una opcion:\n\n1.Sumar\n2.Restar\n3.Multiplicar\n4.Dividir\n5.Indicar el mayor”);printf(“\n0.Salir\n\nUsted ha marcado: “);scanf(“%d”,&opc);if(opc==1){s=x+y;printf(“La suma de ambos numeros es %f\n\n”,s);}else if(opc==2){d=x-y;printf(“La diferencia de ambos numeros es %f\n\n”,d);}else if(opc==3){p=x*y;printf(“El producto de ambos numeros es %f\n\n”,p);}else if(opc==4){c=x/y;printf(“El cociente de la razon de ambos numeros es %f\n\n”,c);}else if(opc==5){if(x>y){printf(“El mayor es %f\n\n”,x);}else if(y>x){printf(“El mayor es %f\n\n”,y);}else{printf(“Estos dos numeros son iguales.\n\n”); }}else if(opc==0){printf(“Gracias por utilizar este programa.\n\n”);}else{printf(“Se ha equivocado al marcar.\n\n”);}}while(x!=0);


Ejercicio 3: Desarrollar un programa en lenguaje c++ que calcula diagonales de cuadrados.

Código Fuente

Ejercicio 4: Codificar un programa en lenguaje c++ que le reste a un entero positivo ingresado por teclado la cantidad que desee el usuario.

Código Fuente

#include <stdio.h>#include <math.h>int main(void){float l,d;printf(“Bienvenido al programa que calcula areas de cuadrados.\n”); do{printf(“\nIntroduce el lado: “);scanf(“%f”,&l);d=sqrt(l*l+l*l);printf(“\nLa diagonal de este cuadrado es %f\n”,d);}while(l!=0);}

#include “iostream”using namespace std;int main(){int x,n;cout<<”dijite numero”<<endl;cin>>x;cout<<”cantidad que quiere que se le descuente al numero inicial”<<endl;cin>>n;do{ cout<<”resultado”<<x;cout<<endl;x=x-n;}while (x>=0);system(“PAUSE”);}


Ejercicio 5: Desarrollar un programa en c++ que permita visualizar los 10 dígitos del 0 al 9.

Código Fuente

12.4.6.4 El ciclo for

Es otra forma de expresar la misma funcionalidad que while, por lo que su diagrama es el mismo. Sin embargo, en otros lenguajes su sintaxis les permite únicamente hacer un ciclo cuando ya se conoce con exactitud el número de veces que se repetirá algo.

Sintaxis

12.4.6.4.1 Ejercicios ciclo for

Ejercicio 1: Desarrollar un programa que permita mostrar por pantalla una lista de números del 1 al 20, indicando para cada uno si es o no múltiplo de 3.

Código Fuente

#include <stdio.h>main() { int digito=0;doprintf(“%d “,digito++);while (digito<=9);}

for(int i = valor inicial; i <= valor final; i = i + paso){........Bloque de Instrucciones............}

#include <iostream> using namespace std; int main(){ int i; for(i = 1; i <= 20; i++) { cout << i; if(i % 3 == 0) cout << “ es múltiplo de 3”; else cout << “ no es múltiplo de 3”; cout << endl; } cin.get(); return 0; }


Ejercicio 2: Desarrollar en lenguaje c++ un programa que permita mostrar los números pares hasta 30.

Código Fuente

Ejercicio 3: Elaborar un programa en c++ que permita obtener los divisores de un número ingre-sado por teclado.

Código Fuente

Ejercicio 4: Realizar un programa que calcule “x” términos de la sucesión de Fibonacci.

#include <stdio.h>#include <math.h>int main(void){int num;printf(“Programa para calcular los divisores de un numero.\n\n”);while(num!=0){printf(“Introduzca un numero: “);scanf(“%d”,&num);printf(“\n\nSus divisores son:\n”);for(int i=1; i<=num; i++){if(num%i==0){printf(“\n\t\t\t\t\t%d\t\n”,i); } }printf(“\n”); } }

#include <stdio.h>int main(void){int i=31;const int tope=30;for(i=0;i<=30;i=i+2){printf(“%d\n”,i); }}


Código Fuente

Ejercicio 5: Desarrollar un programa que calcule la factorial de un número en lenguaje c++.

Código Fuente

12.4.6.5 Switch - Case

Es una sentencia, la misma que permite seleccionar las acciones a realizar de acuerdo al valor que tome una variable.

Sintaxis

#include <stdio.h>#include <stdlib.h>int main(void){printf(“Programa para calcular la progresion de Fibonacci.\n\n”);int veces, primer=0,segun=1,proximo,r;char borrado;printf(“Introduzca el numero de terminos: “);scanf(“%d”,&veces);scanf(“%c”,&borrado);system(“cls”);printf(“He aqui la sucesion de %d terminos: \n”,veces);for(int i=0;i<=veces;i++){r=primer+segun;primer=segun;segun=r;printf(“\n\t\t\t\t%d”,r); }}

#include <stdio.h>int main(void){int i,num,fact=1;printf(“Programa para calcular factoriales.\n”);printf(“\nEscriba un numero entero: “);scanf(“%d”,&num);for(i=num;i>1; i--){fact=fact*i; }printf(“\nEl factorial de %d es %d\n”,num,fact);}

switch ( expression ) case constant-expression : statement [default : statement]


12.4.6.5.1 Ejercicios switch – case

Ejercicio 1: Desarrollar un programa en lenguaje C++ que permita ingresar un número del 1 al 7 y señale el día de la semana correspondiente.

Código Fuente

Ejercicio 2: Elaborar un programa en c++ que solicite una letra y detecte si es una vocal.

#include <stdio.h>#include <stdlib.h>int main(void){int i;printf(“Introduzca número del 1 al 7:”);scanf(“%d”,&i); switch(i){ case 1: printf (“Lunes\n”); break; case 2: printf (“Martes\n”); break; case 3: printf (“Miércoles\n”); break; case 4: printf (“Jueves\n”); break; case 5: printf (“Viernes\n”); break; case 6: printf (“Sábado\n”); break; case 7: printf (“Domingo\n”); break; default: printf (“Opción no válida\n”); break; } system(“PAUSE”); return 0;}


Código Fuente

Ejercicio 3: Desarrollar un programa en lenguaje c++ que muestre un menú donde las opciones sean “Equilátero”, “Isósceles” y “Escaleno”, pida una opción y calcule el perímetro del triángulo seleccionado.

#include <stdio.h>#include <stdlib.h>int main(void){char c;printf(“Introduzca un carácter:”);scanf(“%c”,&c);switch (c) { case ‘a’: printf (“Es vocal\n”); break; case ‘e’: printf (“Es vocal\n”); break; case ‘i’: printf (“Es vocal\n”); break; case ‘o’: printf (“Es vocal\n”); break; case ‘u’: printf (“Es vocal\n”); break; default: printf (“No es vocal\n”); break; } system(“PAUSE”); return 0;}


Código Fuente

Ejercicio 4: Dado un número entero de un digito del 0 al 9 devolver el número en letras, en len-guaje c++.

#include <stdio.h>#include <stdlib.h>int main(void){ int lado, base, opcion; printf(“Introduzca lado del triángulo:”); scanf(“%d”,&lado); printf(“Introduzca base del triángulo:”); scanf(“%d”,&base); printf(“Seleccione opción:\n”); printf(“1 - Equilátero\n”); printf(“2 - Isósceles\n”); printf(“3 - Escaleno\n”); scanf(“%d”,&opcion); switch (opcion) { case 1: printf(“El perímetro es:%d\n”,3*lado); break; case 2: printf(“El perímetro es:%d\n”,(2*lado)+base); break; case 3: printf(“El perímetro es:%d\n”,lado + lado + lado); break; default: printf(“Opción no válida.”); break;} system(“PAUSE”); return 0;}


Código Fuente

Ejercicio 5: Realizar un programa en c++ que al ingresar o seleccionar una opción nos indique el tipo de clima.

Opción Tipo de clima1 Verano2 Invierno3 Otoño4 Primavera

#include <stdio.h>#include <stdlib.h>int main(void){ int i;printf(“Introduzca número del 0 al 9:”); scanf(“%d”,&i); switch(i){case 0:printf (“CERO\n”); break; case 1: printf (“UNO\n”); break; case 2: printf (“DOS\n”); break; case 3: printf (“TRES\n”); break; case 4: printf (“CUATRO\n”); break; case 5: printf (“CINCO\n”); break; case 6: printf (“SEIS\n”); break; case 7: printf (“SIETE\n”); break; case 8: printf (“OCHO\n”); break; case 9: printf (“NUEVE\n”); } system(“PAUSE”); return 0;}


Código Fuente

12.4.6.5.2 Vectores

Es una colección finita, homogénea y ordenada de elementos. Finita porque tiene un límite, es decir, se determina el número máximo de elementos que lo componen; homogénea porque los ele-mentos del arreglo son de un mismo tipo, y ordenada en razón de que estos tienen una disposición establecida desde el primero hasta el último elemento.

Además podemos mencionar que presentan una forma de organizar un grupo o conjunto de datos con el objetivo de hacer más fácil su manipulación. Cabe considerar las siguientes excepciones:

- Todos los elementos del arreglo deben tener el mismo tipo.- En general, el tamaño del arreglo es fijo.- Se ocupan comúnmente para almacenar datos numéricos.

• Arreglos (array). Son una colección de datos del mismo tipo.• Cadena (strings). Son un conjunto de caracteres tratados como un texto. De hecho, una

cadena es un arreglo de caracteres. En el lenguaje C no existe un tipo de datos string.• Apuntadores (punteros). Definen variables que contienen posiciones de memoria.• Estructuras. También llamadas registros. Son datos compuestos de datos de distinto tipo,

puede considerar enteros, carácter o arreglo.

12.4.6.5.3 Arreglo unidimensionales

Es una colección de datos de un mismo tipo que ocupan posiciones de almacenamiento en forma consecutiva en la memoria de la computadora y reciben un nombre común. Hacemos referencia a

#include <stdio.h>#include <stdlib.h>int main(void){ int i;printf(“Introduzca número del 1 al 4:”); scanf(“%d”,&i); switch(i){ case 1: printf (“VERANO\n”); break; case 2: printf (“OTOÑO\n”); break; case 3: printf (“INVIERNO\n”); break; case 4: printf (“PRIMAVERA\n”); } system(“PAUSE”); return 0;}


los elementos de un arreglo mediante un índice, el mismo que señala su ubicación relativa dentro del vector. López, G. J. L. (2014)

12.4.6.5.4 Ejercicios arreglos unidimensionales

Ejercicio 1: Codificar un programa en c++ que permita ingresar 5 números por teclado, los copie a otro array multiplicados por 2 y muestre el segundo array.

Código Fuente

Ejercicio 2: Desarrollar un programa que permita ingresar 10 números por teclado, los almacene en un array y muestre la media.

Código Fuente

#include <stdio.h>#include <stdlib.h>int main() { int aux, numeros1 [5], numeros2 [5];int i, j: for (i=0;i<5;i++) {printf (“Escriba un número: ”);scanf(“%d”,&numeros1[i]); }for(i=0;i<5;i++) {numeros2 [i] =numros1 [i] *2; }for(i=0;i<5;i++) { printf(“%d\n”,numeros2 [i] ); } system(“PAUSE”); return 0;}

#include <stdio.h>#include <stdlib.h>int main() { float sum, numeros1[10]; int i; sum=0; for (i=0;i<10;i++){printf(“Escriba un número”);scanf(“%f”,&numeros1[i]); }for(i=0;i<10;i++) {sum=sum+numeros1[i]; }printf(“%f\n”,sum/10);system(“PAUSE”); return 0;}


Ejercicio 3: Realizar un programa en c++ que permita calcular el producto escalar de dos vectores.

Código Fuente

Ejercicio 4: Diseñar un programa en c++ de vector T y tamaño n. Si el tamaño es par, invertir los elementos de cada mitad de los elementos.

Código Fuente

#include <stdio.h>#include <stdlib.h> #define DIM 100 void leervector(int, float []); float prod_escalar(int, float[],float[]); int main() { int n; float x[DIM], y[DIM]; do{printf(“\nIntroduce entero menor o igual que 100: “);scanf(“%d”,&n); }while ((0>n) || (n>DIM)); printf(“\nIntroduce el primer vector\n”);leervector(n,x);printf(“\nIntroduce el segundo vector\n”);leervector(n,y);printf(“\nEl producto escalar es: %.2f\n”,prod_escalar(n,x,y));system(“PAUSE”); return 0;} void leervector(int n, float v[]) { int i; for(i=0;i<n;i++) {printf(“Introduce la componente %d: “,i+1);scanf(“%f”,&v[i]); } } float prod_escalar(int n, float v1[], float v2[]) { float suma; int i; suma=0; for (i=0;i<n;i++) suma=suma+v1[i]*v2[i]; return suma;}

#include <stdio.h> int main () { char c, palabra[21]; int i; printf(“Teclea una palabra de menos de 20 letras:\n”); scanf(“%s”, palabra); i=0; while (palabra[i++]!=’\0’); printf(“%s tiene %d letras.\n”, palabra, i-1); printf(“%s escrita al reves es: “, palabra); while (i>0) printf(“%c”, palabra[--i]); printf(“\n”); return 0;}


Ejercicio 5: Crear un programa en c++ que permita digitar una palabra de menos de 20 letras e imprima por pantalla el número de letras de esa palabra y la escriba al revés.

Código Fuente

#include<stdio.h>#include<conio.h>void llenar (int V [], int d){for (int i = 1 ; i <= d ; i++){printf (“Inserte pos[%d]: “,i);scanf(“%d”,&V[i]);}}void mostrar (int V [], int d){for (int i = 1 ; i <= d ; i++){printf (“[%d]”,V[i]);}}void invierte (int V [], int d){int aux1;int fin1 = d / 2;for (int i = 1 ; i <= (d / 2) / 2 ; i++){aux1 = V [i];V [i] = V [fin1];V [fin1] = aux1;fin1--;}fin1 = d;for (int j = (d / 2) + 1 ; j <= (3*d/4) ; j++){aux1 = V [j];V [j] = V [fin1];V [fin1] = aux1;fin1--;}}int main (){int V[20];int d;printf (“Inserte dimension del vector: “); scanf(“%d”,&d);llenar (V, d);printf (“\nVECTOR ORIGINAL: \n”);mostrar (V, d);printf (“\n\nVECTOR LUEGO DE LA INVERSION: \n”);invierte (V, d);mostrar (V, d);getch();return 0;}

UNIDAD Nº 2VISUAL BASIC


12.5.1 Introducción a Visual Basic

Visual Basic es un lenguaje de programación creado por Microsoft Corp. que goza de gran popu-laridad. Las razones para ello son su potencia o capacidades, facilidad de uso y el permitir crear programas de aspecto y funcionamiento relacionados con el también muy popular “entorno Win-dows”. Aparte de permitirnos crear programas de aspecto profesional, nos facilitará el trabajo a la hora de utilizar o vincular aplicaciones casi tan extendidas como Windows como son Microsoft Word, Excel o Access y PowerPoint.

El término “Visual” hace referencia a que nos movemos en un entorno gráfico e intuitivo. “Basic” alude al conocido lenguaje BASIC (Beginners All – Purpose Simbolic Instruction Code) del que se conservan diversas palabras claves e instrucciones. Aparte de esto, poco tiene que ver el Visual Basic con el antiguo lenguaje de programación ya que casi todo ha cambiado, y muy especialmen-te la forma de estructurar los programas.

Visual Basic 2015 es un hecho y derecho Programación orientada a objetos (POO). Idioma, al igual que otros lenguajes de programación orientada a objetos como C ++, Java, C # y más. Visual Basic 2015 se encuentra incluido junto con otros lenguajes de programación de Microsoft C # C ++, C #, JavaScript, Python y más en un paquete denominado Visual Studio 2015 Comunidad.Visual Studio 2015.

12.5.2 Definición

Visual Basic 2015 está diseñado para la creación de aplicaciones orientadas a objetos de tipo seguro. Visual Basic permite a los desarrolladores acceder a Windows, a la Web y a dispositivos móviles. Al igual que con todos los idiomas de orientación del Microsoft .NET Framework, los programas escritos en Visual Basic tienen el beneficio de la seguridad y la interoperabilidad del idioma.


• Visual Basic 15.0 soporta la abstracción, la encapsulación, el poliformismo y la reutilización del código.

• Los objetos de Visual Basic están encapsulados; es decir, contienen su propio código y sus propios datos.

• Los objetos de Visual Basic tienen propiedades, métodos y eventos. Las propiedades son los datos que describen un objeto. Los eventos son hechos que pueden ocurrir sobre un objeto (un clic sobre un botón es un evento que produce un mensaje). Un método agrupa el código que se ejecuta en respuesta a un evento.

• Al conjunto de propiedades y métodos se le llama interfaz. Además de su interfaz prede-terminada, los objetos pueden implementar interfaces adicionales para proporcionar poli-formismo. El poliformismo le permite manipular muchos tipos diferentes de objetos sin preocuparse de su tipo.

• Las interfaces múltiples son una característica del modelo de objetos componente (COM) y permiten que los programas evolucionen con el tiempo, agregando nueva funcionalidad sin afectar al código existente.

• La reutilización del código es la capacidad de trasladar características de un objeto a otro, lo que se logra con alguna forma de herencia. Existen principalmente dos formas de reutili-zación del código: binario y fuente. La reutilización del código: binario y fuente. La reutili-


zación de código fuente se consigue mediante la creación y uso de un objeto, mientras que la reutilización de código fuente se consigue por herencia, lo que no se permite en Visual Basic. En una jerarquía de clases, la herencia muestra cómo los objetos que se derivan de otros objetos más simples heredan su comportamiento. Por el contrario, los modelos de ob-jetos son jerarquías que describen la contención. Es decir, muestran cómo objetos complejos como una hoja de cálculo, contienen colecciones de otros objetos, como botones o imágenes. Un control activo normalmente opera como un componente software reutilizable, que se incorpora en una aplicación como Microsoft Excel, en una página Web, o en cualquier otra aplicación Visual Basic o visual C++.

12.5.4 Ventajas

• La facilidad del lenguaje permite crear aplicaciones para Windows en muy poco tiempo. En otras palabras, permite un desarrollo eficaz y menor inversión tanto en tiempo como en dinero.

• Permite generar librerías dinámicas de forma activa, mediante una reconfiguración en su proceso de colección o codificación.

• Es un lenguaje RAD.• Posee una curva de aprendizaje muy rápida.• Integra el diseño e implementación de formularios de Windows.• Permite usar con suma facilidad la plataforma de los sistemas Windows.• El código en Visual Basic es fácilmente migrar a otros lenguajes.

Acostumbra a los desarrolladores a programar con eficiencia.

12.5.5 Desventajas

• No existe forma alguna de exportar el código a otras plataformas diferentes a Windows. Los ejecutables generados son relativamente lentos en VISUAL BASIC 6.0 y anteriores. Por efecto permite la programación sin declaración de variables.

• Su lenguaje no distingue entre mayúsculas y minúsculas como se hace en C++.• Sin soporte de Microsoft desde el 4 de Abril de 2008 (Pero el MSDN es muy completo).• No es multiplataforma. (Sin embargo, se pueden usar emuladores e intérpretes para correrlos

en otras plataformas).• Por defecto permite la programación sin declaración de variables. (Puede ser sencillamente corre-

gida escribiendo la frase Option Explicit en el encabezado de cada formulario, en cuyo caso será menester declarar todas las variables a utilizar, lo que a la postre genera un código más puro).

• No permite programación a bajo nivel ni incrustrar secciones de código en ASM.• Sólo permite el uso de funciones de librerías dinámicas (DLL) stdcall.• Algunas funciones están indocumentadas. (Sin embargo, esto ocurre en muchos lenguajes).• Es un lenguaje basado en objetos y no orientado a objetos.• No maneja muy bien los apuntadores de memoria.• No soporta tratamiento de procesos como parte del lenguaje.• No incluye operadores de desplazamiento de bits como parte del lenguaje.• No permite el manejo de memoria dinámica, punteros, etc. como parte del lenguaje.• No avisa de ciertos errores o advertencias. (Se puede configurar el compilador para generar

ejecutables sin los controladores de desbordamiento de enteros o las comprobaciones de límites en matrices entre otros, dejando así más de la mano del programador la tarea de con-


trolar dichos errores).• No tiene instrucciones de preprocesamiento.• El tratamiento de mensajes de Windows es básico e indirecto.• La gran gama de controles incorporados en algunos casos es muy general, lo que lleva a

tener que reprogramar nuevos controles para una necesidad concreta de la aplicación. Esto cambia radicalmente en Visual Basic .NET donde es posible reprogramar y mejorar o reuti-lizar los controles existentes.

• Los controles personalizados no mejoran la potencia de la API de Windows, y en determina-dos casos acudir a esta será el único modo de conseguir el control personalizado deseado.

12.5.6 Sentencias de Control

a. If … Thenb. If … Then … Elsec. Select cased. While … End Whilee. Do … Loop Whilef. For … Nextg. For … Each

12.5.6.1 If, then, else

La sentencia If permite ejecutar condicionalmente una o más sentencias y puede escribirse de las dos formas siguientes:

If [(] condición [)] Then sentencia 1 [Else sentencia 2]O bien:If [(] condición [)] Then sentencia 1[Else sentencia 2]End If

Donde condición es una expresión booleana, y sentencia1 y sentencia 2 representan a una o más sentencias simples.

Una sentencia If se ejecuta de la forma siguiente:

1. Se evalúa la condición y se obtiene un resultado verdadero o falso.2. Si el resultado es verdadero (True), se ejecutará lo indicado por la sentencia 1.3. Si el resultado es falso (False), la sentencia 1 se ignorará y se ejecutará lo indicado por la

sentencia 2 si la cláusula Else se ha especificado.

En cualquier caso, la ejecución continua en la siguiente sentencia ejecutable que haya a continua-ción de la sentencia If.


12.5.6.1.1 Ejercicios if

Ejercicio 1: El siguiente programa indica la nota de un estudiante y a la vez si está aprobado o reprobado.

Código Fuente

Ejercicio 2: Ejemplo para mostrar si un número es par o impar.

Código Fuente

package ejercicios;Dim nom As StringDim nota As IntegerPrivate Sub aceptar_Click()nota = txtnota.Textnom = txtnom.TextIf nota >= 14 Then MsgBox (“su nota es” & nota & “ y está aprobado”) Else MsgBox (“SU NOTA ES” & nota & “y esta reprobado”)End IfEnd Sub

package ejercicios;Dim num As IntegerDim d As IntegerPrivate Sub Command1_Click()num = Val(txtnum.Text)d = num Mod 2

If d = o Then Label3.Caption = “par” Label3.ForeColor = vbBlueElse Label3.Caption = “impar” Label3.ForeColor = vbRedEnd IfEnd Sub


Ejercicio 3: El siguiente programa indica el límite superior e inferior entre números.

Código Fuente

Ejercicio 4: El siguiente programa indica la aplicación para calcular la raíz cuadrática.

Código Fuente

package ejercicios;Dim l1, l2 As IntegerDim i As IntegerPrivate Sub Command1_Click()l1 = Val(Text1.Text)l2 = Val(Text2.Text)If Val(l1) Mod 2 = 0 Or Val(l2) Mod 2 = 0 Then For i = Val(l1) To Val(l2) Step 2 List1.AddItem (i) Next iElse For i = Val(l1) To Val(l2) Step 2 List1.AddItem (i) Next i

End IfEnd SubPrivate Sub Command2_Click()List1.Clear Text1.Text = “” Text2.Text = “”End Sub

package ejercicios;Dim a, b, c As IntegerDim d, x1, x2 As CurrencyPrivate Sub Command1_Click()a = Val(Text1.Text)b = Val(Text2.Text)c = Val(Text3.Text)d = b ^ 2 - 4 * a * cIf d > 0 Then x1 = (-b - Sqr(d)) / 2 * a x2 = (-b + Sqr(d)) / 2 * a Text4.Text = x1 Text5.Text = x2 Else If d = 0 Then x1 = -b / (2 * a) Text4.Text = x1 Else MsgBox “Raices imaginarias” End IfEnd If End Sub


Ejercicio 5: El siguiente programa permite realizar el descuento de un valor determinado o ingre-sado por el usuario.

Código Fuente

12.5.6.1.2 Select case

La sentencia Select permite ejecutar una de varias acciones en función del valor de una expresión. Es una sentencia especial para decisiones múltiples. La sintaxis para utilizar esta sentencia es:

Select [Case] [(] expresión - test [)] Case expresión 1 [sentencias 1] [Case expression 2] [sentencias 2] [Case expression 3] [sentencias 3] [Case Else] [ sentencias n ]End select

Donde expresión-test es una expresión numérica o alfanumérica, y expresión 1, expresión 2… representan una lista de expresiones que puede tener cualquier forma.

Cuando se ejecuta una sentencia Select, Basic evalúa la expresión-test y busca el primer Case que incluya el valor evaluado, ejecutando a continuación el correspondiente bloque de sentencias. Si no

package ejercicios;Dim vi, des, vfi As DoublePrivate Sub Command1_Click()If vi > 0 And vi < 50 Thendes = Val(vi) * 0.05Else If vi > 50 And vi < 100 Then des = Val(vi) * 0.1 Else If vi > 100 Then des = Val(vi) * 0.2 End If End IfEnd IfText2.Text = desvfi = Val(vi) - Val(des)Text3.Text = vfiEnd SubPrivate Sub Command2_Click()End End SubPrivate Sub Form_Load()vi = InputBox(“ingrese número”)Text1.Text = Val(vi)End Sub


existe un valor igual a la expresion-test, entonces se ejecutarán las sentencias a continuación de Case Else, si se ha especificado. En cualquier caso, el control pasa a la siguiente sentencia a End Select.

12.5.6.2.1 Ejercicios select – case

Ejercicio 1: El siguiente programa permite calcular el día del año que se desee saber.

Código Fuente

package ejercicios;Option Explicit Dimm Ndía%, Nmes%, DDA As Integer Private Sub Form_Load() Form1.Caption = “Cálculo día del año” Label1.Caption = “Introduzca aquí el número del día” Label2.Caption = “Introduzca aquí el número delmes” ButtonCalcular.Caption = “Determinar día delaño” End Sub Private Sub ButtonCalcular_Click() Ndía = Val(Text1) Nmes = Val(Text2) LabelResultado.FontSize = 10 LabelResultado.FontBold = True If Ndía >= 1 And Ndía <= 31 And Nmes >= 1 And Nmes <= 12 Then Select Case Nmes Case 1 DDA = Ndía ‘[DDA es día del año] Case 2 DDA = Ndía + 31 Case 3 DDA = Ndía + 59 Case 4 DDA = Ndía + 90 Case 5 DDA = Ndía + 120 Case 6 DDA = Ndía + 151 Case 7 DDA = Ndía + 181 Case 8 DDA = Ndía + 212 Case 9 DDA = Ndía + 243 Case 10 DDA = Ndía + 273 Case 11 DDA = Ndía + 304 Case 12 DDA = Ndía + 334 End Select LabelResultado = “El “ & Ndía & “ del “ & Nmes & “ es el día “ & DDA & “ del año” Else LabelResultado = “Datos proporcionados no válidos” End If End Sub


Ejercicio 2: El siguiente programa permite calcular el número de mes.

Código Fuente

Ejercicio 3: El siguiente programa permite cambiar el color del formulario.

Código Fuente

package ejercicios;Dim numeromes As String numeromes = TextBox1.Text Select Case numeromes Case “1” TextBox2.Text = “Enero” Case “2” TextBox2.Text = “Febrero” Case “3” TextBox2.Text = “Marzo” Case “4” TextBox2.Text = “Abril” Case “5” TextBox2.Text = “Mayo” Case “6” TextBox2.Text = “Junio” Case “7” TextBox2.Text = “Julio” Case “8” TextBox2.Text = “Agosto” Case “9” TextBox2.Text = “Septiembre” Case “10” TextBox2.Text = “Octubre” Case “11” TextBox2.Text = “Noviembre” Case “12” TextBox2.Text = “Diciembre” Case Else TextBox2.Text = “Digite dato correctamente” End Select End Sub

package ejercicios;Select Case Color Case “red” MsgBox(“You selected red”) Case “blue” MsgBox(“You selected blue”) Case “green” MsgBox(“You selected green”) Case Else MsgBox(“Please choose red, blue, or green”)End Select


Ejercicio 4: El siguiente programa despliega mensaje de acuerdo a un rango de notas.

Código Fuente

Ejercicio 5: El siguiente programa muestra una aplicación que acepte fechas como tres números.

Código Fuente

package ejercicios;Calificaciones=val(textbox1.text) + val(textbox2.text) + val(textbox3.text) Promedio= calificaciones / 4Select promedio case:0 to 9msgbox(“estas reprobado”)

case: 10 to 12msgbox(“suficiente”)

case: 13 to 15msgbox(“regular”)

case: 16 to 18msgbox(“bueno”)

case: 19 to 9 msgbox(“excelente”)

package ejercicios;Private Sub CmdAceptar_Click() Dim CadMes As String, Mes As Integer Mes = Val(TxtMes) Select Case Mes Case 1: CadMes = “Enero” Case 2: CadMes = “Febrero” Case 3: CadMes = “Marzo” Case 4: CadMes = “Abril” Case 5: CadMes = “Mayo” Case 6: CadMes = “Junio” Case 7: CadMes = “Julio” Case 8: CadMes = “Agosto” Case 9: CadMes = “Setpiembre” Case 10: CadMes = “Octubre” Case 11: CadMes = “Noviembre” Case 12: CadMes = “Diciembre” Case Else MsgBox “Error de datos...”, vbCritical, “Mensaje” Call CmdLimpiar_Click Exit Sub End Select


12.5.6.3 While

La sentencia While ejecuta una o más sentencias cero o más veces, dependiendo del valor de una expresión booleana. Su sintaxis es:

Donde condición es cualquier expresión booleana y sentencias es un bloque de una o más sentencias.

La ejecución de la sentencia While sucede así:

1. Se evalúa la condición y se obtiene un resultado verdadero o falso.2. Si el resultado es falso (False), el bloque de sentencias no se ejecuta y se pasa el control a la

siguiente sentencia en el programa.3. Si el resultado de la evaluación es verdadero (True), se ejecuta el bloque de sentencias y el

proceso descrito se repite desde el punto 1.


Ejercicio 1: En el siguiente programa las sentencias en el bucle continúan ejecutándose hasta que la variable de índice sea mayor que 10.

Código Fuente

Ejercicio 2: El siguiente programa genera la contraseña de usuario.

Código Fuente

While [(] condición [)] SentenciasEnd While

package ejercicios;Dim index As Integer = 0 While index <= 10 Debug.Write(index.ToString & “ “) index += 1 End While Debug.WriteLine(“”) Output: 0 1 2 3 4 5 6 7 8 9 10

package ejercicios;

Sub Password()Do Until Len(contraseña) = 4contraseña = InputBox(“Contraseña”, “Bienvenido”)LoopEnd Sub


Ejercicio 3: El siguiente programa lee todas las líneas de un archivo de texto.

Código Fuente

12.5.6.3.2 Do - while

Un Loop (lazo o bucle) repite la ejecución de un conjunto de sentencias mientras una condición dada sea cierta o hasta que una condición dada sea cierta. La condición puede ser verificada antes o después de ejecutarse el conjunto de sentencias. Esta sentencia presenta diferentes alternativas para su utilización.

Donde condición es cualquier expresión que se evalué a True o a False. Esta sentencia permite realizar varias estructuras diferentes. Permite, como se puede apreciar en los formatos presentados, crear lazos o bucles con la condición de terminación al final o al principio del bloque de sentencias.

package ejercicios;

Private Sub ShowText(ByVal textFilePath As String) If System.IO.File.Exists(textFilePath) = False Then Debug.WriteLine(“File Not Found: “ & textFilePath) Else Dim sr As System.IO.StreamReader = System.IO.File.OpenText(textFilePath) While sr.Peek() >= 0 Debug.WriteLine(sr.ReadLine()) End While sr.Close() End If End Sub

Do [{While|Until} condición] [sentencias] [Exit Do] [sentencias]LoopDo [sentencias] [Exit Do] [sentencias]Loop [{While|Until} condición]


12.5.6.3.3 Ejercicios do - while

Ejercicio 1: El siguiente programa permite escribir una palabra un número limitado de veces.

Código Fuente

Ejercicio 2: El siguiente programa permite calcular la serie numérica 1 * 3 * 5 * ··· * n. Calcular la serie numérica 1 + 3 + 5 + ··· + n

Código Fuente

package ejercicios;Sub Ejemplo_numero_limitado()Dim Escribir As IntegerEscribir = 1Do While Escribir < 7 ActiveCell.FormulaR1C1 = “Excel” lastrow = Cells(Rows.Count, 1).End(xlUp).Row Cells(lastrow, 1).Offset(1, 0).Select Escribir = Escribir + 1 LoopEnd Sub

package ejercicios;Private Sub CalculaMult(ByVal Cifra As Integer) Dim Impar As Integer Dim Acumulado As Single Impar = -1 : Acumulado = 1 Do Impar = Impar + 2 Acumulado = Acumulado * Impar Loop While Impar < CifraLabelResultado.Text = vbCrLf & “n= “ & Dato & “ El producto 1*3*5*...*n vale “ & AcumuladoEnd Sub

Private Sub CalculaSuma(ByVal Número As Integer) Dim Impar, Suma As Integer Impar = -1 : Suma = 0 Do Impar = Impar + 2 Suma = Suma + Impar Loop While Impar < Número LabelResultado.Text = vbCrLf & “n= “ & Dato & “ La suma 1+3+5+...+n vale “ & SumaEnd Sub


12.5.6.4 Sentencias for, next

La sentencia For da lugar a un lazo o bucle y permite ejecutar un conjunto de sentencias cierto número de veces. Su sintaxis es:

Cuando se ejecuta una sentencia for en la que el valor de la expresión 3 es positivo o no se ha espe-cificado, primero se asigna el valor de la expresión 1 a la variable y a continuación se comprueba si la variable es mayor que la expresión 2, en cuyo caso se salta el cuerpo del bucle y se continua en la línea que este a continuación de la sentencia Next.

En otro caso, se ejecutan las líneas del programa que haya entre la sentencia For y la sentencia Next. Por último, la variable se incrementa en el valor de la expresión 3, o en 1 si Step no se especifica, volviéndose a efectuar la comparación entre la variable y la expresión 2, y así sucesivamente.

La sentencia Exit For permite salir de un bucle For … Next antes de que este finalice. Un bucle For … Next se ejecuta más rápidamente cuando la variable es entera y las expresiones 1, 2, 3, constantes.

Donde elemento es una variable de un tipo compatible con el tipo de los elementos de la colección o de la matriz.

15.5.6.4.1 Ejercicios for – next

Ejercicio 1: El siguiente programa permite calcular la tabla de multiplicar de cualquier número.

Código Fuente

For variable = expresión 1 To expresion 2 [Step expresión 3][sentencias][Exit for][sentencias]Next [variable [.variable] … ]

package ejercicios;Dim i As IntegerDim p As IntegerDim r As IntegerPrivate Sub Command1_Click()r = Val(Text1.Text)For i = 0 To 12 p = i * rlist1.AddItem r & “ * “ & i & “ = “ & pNext I End Sub


Ejercicio 2: El siguiente programa permite calcular el número factorial.

Código Fuente

Ejercicio 3: El siguiente programa permite para calcular el número primo.

Código Fuente

package ejercicios;Dim num, i, f As IntegerPrivate Sub Command1_Click()num = Val(Text1.Text)f = 1For i = 1 To num f = f * iNext iText2.Text = f Command2.SetFocusEnd SubPrivate Sub Command2_Click()Text1.Text = “”Text2.Text = “”Text1.SetFocusEnd SubPrivate Sub Command3_Click()EndEnd SubPrivate Sub Form_Load()End SubPrivate Sub Text1_KeyPress(KeyAscii As Integer)If KeyAscii = 13 Then Command1.SetFocusEnd IfEnd Sub

package ejercicios;Dim num, c, i, r As IntegerPrivate Sub Command1_Click()num = Val(Text1.Text)For i = 1 To num r = num Mod i If r = 0 Then c = c + 1 End IfNext iIf c > 2 Then MsgBox “no Es primo “ Else MsgBox “es primo”End IfEnd Sub


Ejercicio 4: El siguiente programa permite para contar las vocales de una frase.

Código Fuente

Ejercicio 5: El siguiente programa permite mostrar todos los datos académicos de un estudiante.

Código Fuente

package ejercicios;Dim frase As StringDim Cont, TotalA, TotalE As IntegerPrivate Sub Cmd_Calcular_Click()frase = Txt_Frase.TextFor Cont = 1 To Len(frase) If Mid$(frase, Cont, 1) = “a” Or Mid$(frase, Cont, 1) = “A”Then TotalA = TotalA + 1 Txt_A.Text = TotalA End If NextFor Cont = 1 To Len(frase) If Mid$(frase, Cont, 1) = “e” Or Mid$(frase, Cont, 1) = “E”Then Total_E = TotalE + 1 Txt_E.Text = TotalE End If

package ejercicios;Dim nom As StringDim nota, i, num, numero As IntegerPrivate Sub Command1_Click()numero = numero + 1Text4.Text = numeroFor i = 1 To 3 nota = Val(Text2.Text) If nota >= 14 Then Text3.Text = “Aprobado” Else Text3.Text = “Reprobado” End IfNext iCommand2.SetFocusIf numero > 3 Then End End IfEnd SubPrivate Sub Command2_Click()Text1.Text = “”Text2.Text = “”Text3.Text = “”Text4.Text = “”Text1.SetFocusEnd SubPrivate Sub Command3_Click()End End SubPrivate Sub Text1_KeyPress(KeyAscii As Integer)If KeyAscii = 13 Then Text2.SetFocusEnd If End SubPrivate Sub Text2_KeyPress(KeyAscii As Integer)If KeyAscii = 13 Then Command1.SetFocusEnd If End Sub

UNIDAD Nº 3PHP


12.6.1 Definición de PHP

PHP es uno de los lenguajes de programación más populares para el desarrollo de WEB, el pro-cesador de hipertexto PHP y mientras tal vez sonríes por lo insulso y reiterativo del acrónimo te diré que las estadísticas indican que PHP no debe tomarse a la ligera. Actualmente este lenguaje se utiliza en más de 20 millones de sitios WEB y en más de un tercio de los servidores WEB en todo el mundo no es algo despreciable, especialmente cuando se considera que el lenguaje ha sido desarrollado por completo por una comunidad de voluntarios repartida en todo el mundo y está disponible en internet sin costo alguno. Vaswani, V. (2010).

Durante los últimos años PHP se ha convertido en la opción para el desarrollo de aplicaciones web orientadas a base de datos sobre todo por su escalabilidad, facilidad, uso y empleo, soporte para diferentes bases de datos y formatos. Vaswani, V. (2010).

12.6.2 Funcionamiento

1. Enviamos una petición al servidor, ejemplo www.ibrugor.com/blog/index.php2. El servidor recibe la petición y busca la página a entregar.3. Si la página contiene la extensión “.php”, el intérprete de PHP la procesa.4. El servidor ejecuta el código PHP de la página y prepara el resultado final, el HTML.5. Se envía la página HTML al cliente final. Vaswani, V. (2010).


• Rendimiento: Los scripts escritos en PHP se ejecutan más rápido que los escritos en otros lenguajes de creación de scripts; numerosos estudios comparativos independientes ponen este lenguaje por encima de sus competidores como JSP, ASP. NET y Perl. El motor de PHP 5.0 fue completamente rediseñado con el manejo óptimo de memoria para mejorar su rendi-miento y es claramente más veloz que las versiones previas. Además están disponibles ace-leradores de terceros que pueden mejorar aún más el rendimiento y el tiempo de respuesta. Vaswani, V. (2010).

• Portabilidad: PHP está disponible para UNIX, Microsoft Windows, Mac OS y OS/2 y los programas escritos en PHP se pueden transportar de una plataforma a otra. Como resultado, las aplicaciones PHP desarrolladas en Windows, por ejemplo se ejecutarán en UNIX sin grandes contratiempos. Esta capacidad de desarrollar fácilmente para múltiples plataformas es muy valiosa, en especial cuando se trabaja en un ambiente corporativo de varias platafor-mas o cuando se intenta atacar diversos sectores del mercado. Vaswani, V. (2010).

• Fácil de usar: PHP es un lenguaje de programación extremadamente sofisticado su sintaxis es clara y consistente, viene con una documentación exhaustiva para las más 5000 funciones incluidas en la distribución principal. Vaswani, V. (2010).

• Código libre: PHP es un proyecto de código libre; el lenguaje es desarrollado por un grupo de programadores voluntarios distribuidos por todo el mundo, quienes ponen a disposición gratuita el código fuente a través de internet, y puede ser utilizado sin costo, sin pagos por li-cencia y sin necesidad de grandes inversiones en equipo de cómputo ni programas. Vaswani, V. (2010).

• Soporte comunitario: una de las mejores características de los lenguajes a los que da so-porte una comunidad, como PHP, es el acceso que ofrece a la creatividad e imaginación de cientos de desarrolladores ubicados en diferente partes del mundo. Vaswani, V. (2010).

• Soporte a aplicaciones de terceros: una de las fortalezas históricas de PHP ha sido su so-


porte a una amplia gama de diferentes bases de datos, entre las cuales se incluyen MySQL, PostgreSQL, Oracle y Microsoft SQL Server. Vaswani, V. (2010).

12.6.4 Aspectos sobre la sintaxis de PHP

La sintaxis del lenguaje PHP es muy similar a la de otros lenguajes conocidos como C o Perl, algu-nos aspectos iniciales sobre la sintaxis que deben ser considerados a la hora de abordar la escritura del código fuente de los programas son:

• El uso de mayúsculas y minúsculas es indiferente. A diferencia de otros lenguajes similares, PHP permite que las diferentes sentencias estén escritas con cualquier combinación de letras mayúsculas o minúsculas. Por ejemplo, en las estructuras condicionales sería totalmente equivalente utilizar la palabra reservada if o IF. Una excepción importante a esta regla se produce en los nombres de las variables; como se verá más adelante, no es lo mismo nombrar una variable con letras mayúsculas que hacerlo con minúsculas.

• Se pueden colocar todos los espacios en blanco y cambios de línea que se deseen con objeto de hacer más legible el código fuente. Esos espacios adicionales no tienen efecto alguno en la ejecución del programa, el intérprete de PHP los ignora.

• Las diferentes instrucciones deben terminar con “;”. Sin embargo, PHP admite cierta flexi-bilidad a este respecto, ya que el terminador punto y coma no sería necesario en la última sentencia del script antes de terminador, ni en los casos en los que al final de la instrucción se cierre un bloque de código con una llave, por ejemplo en las estructuras condicionales o bucles.

• Las instrucciones se pueden partir en tantas líneas como se desee a efectos, de nuevo, de mejorar la legibilidad. Esta división de las instrucciones no afecta a su ejecución.

• En una misma línea se pueden colocar, si así se desea, varias instrucciones diferentes separa-das por “;”. Esto puede ser útil en el caso, por ejemplo, de tener que hacer varias sentencias de asignación diferentes.

• Orientado al desarrollo de aplicaciones web dinámicas con acceso a información almacena-da en una base de datos.

• El código fuente escrito en PHP es invisible al navegador web y al cliente ya que es el servi-dor el que se encarga de ejecutar el código y enviar su resultado HTML al navegador. Esto hace que la programación en PHP sea segura y confiable.

• Posee una amplia documentación en su sitio web oficial, entre la cual se destaca que todas las funciones del sistema están explicadas y ejemplificadas en un único archivo de ayuda.

• Es libre, por lo que se presenta como una alternativa de fácil acceso para todos.• Permite aplicar técnicas de programación orientada a objetos.• Biblioteca nativa de funciones sumamente amplia e incluida.• No requiere definición de tipos de variables aunque sus variables se pueden evaluar también

por el tipo que estén manejando en tiempo de ejecución.• Tiene manejo de excepciones (desde PHP5).

Si bien PHP no obliga a quien lo usa a seguir una determinada metodología a la hora de programar (muchos otros lenguajes tampoco lo hacen), aun haciéndolo, el programador puede aplicar en su trabajo cualquier técnica de programación o de desarrollo que le permita escribir código ordenado, estructurado y manejable. Un ejemplo de esto son los desarrollos que en PHP se han hecho del patrón de diseño Modelo Vista Controlador (MVC), que permiten separar el tratamiento y acce-so a los datos, la lógica de control y la interfaz de usuario en tres componentes independientes. Vaswani, V. (2010).


Como es un lenguaje que se interpreta en ejecución, para ciertos usos puede resultar un inconve-niente que el código fuente no pueda ser ocultado. La ofuscación es una técnica que puede dificul-tar la lectura del código pero no la impide y, en ciertos casos, representa un costo en tiempos de ejecución. Vaswani, V. (2010).

12.6.5 Ventajas

• Completamente orientado al desarrollo de aplicaciones web dinámicas con acceso a infor-mación almacenada en una Base de Datos.

• El código fuente escrito en PHP es invisible al navegador y al cliente ya que es el servidor el que se encarga de ejecutar el código y enviar su resultado HTML al navegador. Esto hace que la programación en PHP sea segura y confiable.

• Capacidad de conexión con la mayoría de los motores de base de datos que se utilizan en la actualidad, destaca su conectividad con MySQL y PostgreSQL.

• Capacidad de expandir su potencial utilizando la enorme cantidad de módulos (llamados ext’s o extensiones).

• Lenguaje multiplataforma.• Fácil de aprender.• Orientado para desarrollar aplicaciones web donde la información esté en una base de datos.• Buena integración con la mayoría de conectores a base de datos. MySQL, PostgreSQL,

Oracle, etc.• Lenguaje modular.• Mucha documentación debido a su gran popularidad y una gran comunidad.• Programación orientada a objetos.• Lenguaje de código libre y gratuito.• Biblioteca muy amplia de funciones nativas.• Múltiples Frameworks PHP que permiten que tu código sea más ordenado, estructurado,

manejable y permiten trabajar utilizando patrones de diseño cómo Modelo-Vista-Controla-dor (MVC).

Fuente: Vaswani, V. (2010).

12.6.6 Desventajas

Como es un lenguaje que se interpreta en ejecución para ciertos usos puede resultar un inconve-niente que el código fuente no pueda ser ocultado. La ofuscación es una técnica que puede dificul-tar la lectura del código pero no la impide y, en ciertos casos, representa un costo en tiempos de ejecución

• Se necesita instalar un servidor web.• Se realiza todo el trabajo en la parte del servidor, por esto, si se tienen muchas peticiones, el

rendimiento de nuestra aplicación podría verse afectado sensiblemente.• Al mezclar HTML + PHP, dificulta la legibilidad de nuestro código.• Seguridad. Como es un lenguaje de código abierto, todas las personas pueden ver el código

fuente, y si hay errores, la gente puede utilizar estas debilidades de codificación.• Es un lenguaje de programación NO tipado.• Difícil de mantener.

Fuente: Vaswani, V. (2010).


12.6.7 Sentencias en PHP

12.6.7.1 Sentencia if

La instrucción if es formidable porque le permite hacer elecciones al instante y ejecutar código alternativo, dependiendo de los resultados de esa elección. Por ejemplo, podría verificar el valor de una contraseña para asegurarse de que es correcta o comprobar la respuesta del usuario o preguntar si/no. Holzner, S. (2009)

12.6.7.1.1 Ejercicios if

Ejercicio 1: Realizar un programa que mediante el ingreso del nombre y edad del usuario calcule, si su edad esta entre 30 y 65 desplegar el mensaje “Casi Viejito”, si es mayor de 65 desplegar el mensaje “Viejito”, caso contrario desplegar un mensaje “Jovencito”:

Código Fuente

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><body><form name=”formulario.php” method=”post”><label>Ingrese nombre</label><br /><input name=”nombre” type=”text” /><br /><label>Ingrese edad</label><br /><input name=”edad” type=”text” /><br /><input type=”submit” value=”calcular” /><input type=”reset” value=”limpiar” /></form> <table border=”1”><tr><td>Nombre</td><td>edad</td></tr> <?phpif (!empty($_POST[“edad”])){$nom=$_POST[“nombre”];$ed=$_POST[“edad”];if ($ed>65){echo “<tr>”;echo “<td>” .$nom.”</td>”;echo “<td>”.” viejito “.”</td>”;echo “</tr>”;}else if ($ed>30 && $ed<65){echo “<tr>”;echo “<td>”.$nom.”</td>”;echo “<td>”.” casi viejo “.”</td>”;echo “</tr>”;}Else{echo “<tr>”;echo “<th>” .” Jovensito “. “</th>”;echo “</tr>”;}}?> </table> </body> </html>


Ejercicio 2: Realizar un programa que mediante el ingreso del nombre y el género del usuario, despliegue un mensaje de “Bienvenida” o “Bienvenido” según corresponda más el respectivo nombre.

Código Fuente

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=iso-8859-1” /><title>Documento sin título</title></head><form action=”<?php echo $_SERVER[‘PHP_SELF’]?>” method=”GET”><br><label>Ingrese el nombre </label><br/><input type=”text” name=”nombre”/><br><label>Ingrese el genero </label> <br/><input type=”text” name=”genero”/><input type=”submit” name=”submit1” value=”Calcular” /><input type=”reset” name=”reset1” value=”limpiar” /></form><body><?phpif ( !empty ($_GET[“genero”])) { $gen = $_GET[“genero”]; $nom = $_GET[“nombre”]; //$nombre=”Isaac”; //$nombre=”Stefany”; if (($gen == “F”) || ($gen == “f”)) { $saludo = “Bienvenida, “; $saludo = $saludo.$nom; print $saludo; } else { $saludo = “Bienvenido, “; $saludo = $saludo.$nom; print $saludo;}}?></body></Html>


Ejercicio 3: Realice un programa que permita ingresar un número el 1 al 7 y luego desplegué el día de la semana que corresponda.

Código Fuente

<html><head><title>Documento sin título</title></head><form action=”<?php echo $_SERVER[‘PHP_SELF’]?>” method=”GET”> <br><label>Ingrese un numero en rango desde 1 hasta 7 </label><br/> <input type=”text” name=”valor”/> <input type=”submit” name=”submit1” value=”Calcular” /> <input type=”reset” name=”reset1” value=”limpiar” /></form><body><?php if ( !empty ($_GET[“valor”])) { $val=$_GET [“valor”]; if ($val == “1”) { print “Usted a elegido Lunes”; } else { if ($val == “2”) { echo “Usted a elegido Martes”; } else { if ($val == “3”) { echo “Usted a elegido Miércoles”; } else { if ($val == “4”) { echo “Usted a elegido Jueves”; } else { if ($val == “5”) { echo “Usted a elegido Viernes”; } else { if ($val == “6”) { echo “Usted a elegido Sábado”; } else { if ($val == “7”) { echo “Usted a elegido Domingo”; } else { echo “Numero fuera de rango”; } }}}}}}}?></body></html>


Ejercicio 4: Realizar un programa que muestre en una tabla de 4 columnas todas las imágenes de un directorio predeterminado, para este ejemplo será “fotos”.

Código Fuente

15.6.7.2 Sentencia Switch

La instrucción switch en PHP permite reemplazar secuencias largas if.elseif-else para comprobar condiciones con una instrucción sencilla. Se da un valor a la instrucción switch y esta prueba ese valor contra instruccio-nes case listadas por usted, ejecutando el código de cualquier instrucción case, cuyo valor de prueba coincida con el que está comprobando. Así es como se ve la instrucción switch formalmente. Holzner, S. (2009)

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><body><?phpif ($gestor = opendir(‘fotos’)){ echo “<table border=1>”; echo “<tr>”; $i=0; while (false !== ($archivo = readdir($gestor))) { if ($archivo!=”.” && $archivo!=”..”) { if ($i==4) { $i=0; echo “</tr>”; echo “<tr>”; } $i++; echo “<td>”; echo “<a href=fotos/$archivo><img src=fotos/$archivo></a>”; echo “</td>”; } } echo “</tr>”; echo “</table>”; closedir($gestor);}?></body></html>

Switch (valordeprueba){ Case expression1:Instruccion 1[Break; 1]Case expression2:Instruccion 2[Break; 2]Case expression2:…Instruccion_predeterminada]}


12.6.7.2.1 Ejercicios switch – case

Ejercicio 1: Realice un ejercicio utilizando la instrucción switch – case que permita ingresar un número y determinar el día de la semana que corresponda.

Código Fuente

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><body><form action=”<?php echo $_SERVER[‘PHP_SELF’]?>” method=”GET”> <br><label>Ingrese un numero del 1 al 7</label><br/> <input type=”text” name=”palabra”/> <input type=”submit” name=”submit1” value=”Calcular” /></form><?php if ( !empty ($_GET[“palabra”])) { $val=$_GET [“palabra”];switch($val) {case 1:echo “El dia elegido es Lunes”;break;case 2:echo “El dia elegido es Martes”;break;case 3:echo “El dia elegido es Miercoles”;break;case 4:echo “El dia elegido es Jueves”;break;case 5:echo “El dia elegido es Viernes”;break;case 6:echo “El dia elegido es Sabado”;break;case 7:echo “El dia elegido es Domingo”;break;default:echo “El numero ingreso esta fuera de rango”;}}?> </body></html>


Ejercicio 2: Realice un programa que permita ingresar los números dígitos y desplegar el mismo número en letras.

Código Fuente

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-” /><title>Documento sin título</title></head><body><form action=”<?php echo $_SERVER[‘PHP_SELF’]?>” method=”GET”><br><label>Ingrese un numero digito (1 - 9)</label><br/> <input type=”text” name=”numero”/> <input type=”submit” name=”submit1” value=”Calcular” /></form><?php if ( !empty ($_GET[“numero”])) {$val=$_GET [“numero”];switch($val) {case 1:echo “Usted a ingresado el uno”;break;case 2:echo “Usted a ingresado el dos”;break;case 3:echo “Usted a ingresado el tres”;break;case 4:echo “Usted a ingresado el cuatro”;break;case 5:echo “Usted a ingresado el cinco”;break;case 6:echo “Usted a ingresado el seis”;break;case 7:echo “Usted a ingresado el siete”;break;case 8:echo “Usted a ingresado el ocho”;break;case 9:echo “Usted a ingresado el nueve”;break;default:echo “El numero ingreso esta fuera de rango”;}}?> </body></html>


Ejercicio 3: Realice un programa utilizando la sentencia switch – case que permita ingresar un número del 1 al 12 y desplegar el mes del año correspondiente.

Código Fuente

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head>

<body><form action=”<?php echo $_SERVER[‘PHP_SELF’]?>” method=”GET”> <br><label>Ingrese un numero digito (1 - 12)</label><br/> <input type=”text” name=”numero”/> <input type=”submit” name=”submit1” value=”Calcular” /></form><?php if ( !empty ($_GET[“numero”])) { $val=$_GET [“numero”];switch($val) {case 1:echo “Enero”;break;case 2:echo “Febrero”;break;case 3:echo “Marzo”;break;case 4:echo “Abril”;break;case 5:echo “Mayo”;break;case 6:echo “Junio”;break;case 7:echo “Julio”;break;case 8:echo “Agosto”;break;case 9:echo “Septiembre”;break;case 10:echo “Octubre”;break;case 11:echo “Noviembre”;break;case 12:echo “Diciembre”;break;default:echo “El numero ingreso esta fuera de rango”;}}?> </body></html


Ejercicio 4: Realice un programa que permita elegir una opción de formulario para simular a una calculadora con las operaciones básicas utilizando la sentencia switch – case.

Código Fuente

<html><head> <title>Documento sin título</title> </head><div> <body> <body> <? if (!$_POST){?> <h2>Calculadora</h2> <form name=”form1” method=”POST” action=”<? $_SERVER[‘PHP_SELF’] ?>”> <input name=”valor1” type=”text” id=”valor1” size=”10”> <select name=”operador” id=”operador”> <option value=”+” selected>+</option> <option value=”-”>-</option> <option value=”*”>*</option> <option value=”/”>/</option> <option value=”%”>%</option> </select> <input name=”valor2” type=”text” id=”valor2” size=”10”> <input type=”submit” name=”Submit” value=”=”> </form> <br> <? }else{ ?> <? $valor1 = $_POST[“valor1”]; $valor2 = $_POST[“valor2”]; $operador = $_POST[“operador”]; switch($operador){ case “-”: $resultado = $valor1 - $valor2; break; case “*”: $resultado = $valor1 * $valor2; break; case “/”: $resultado = $valor1 / $valor2; break; case “%”: $resultado = $valor1 % $valor2; break; default: $resultado = $valor1 + $valor2; break; } ?> <h2>Calculadora</h2> <form name=”form1” method=”POST” action=”<? $_SERVER[‘PHP_SELF’] ?>”> <input name=”valor1” type=”text” id=”valor1” size=”10” value=”<? echo ($resultado) ?>”> <select name=”operador” id=”operador”> <option value=”+” selected>+</option> <option value=”-”>-</option> <option value=”*”>*</option> <option value=”/”>/</option> <option value=”%”>%</option> </select> <input name=”valor2” type=”text” id=”valor2” size=”10”> <input type=”submit” name=”Submit” value=”=”> <br> <br> </form> <form name=”form1” method=”GET” action=”<? $_SERVER[‘PHP_SELF’] ?>”> <input name=”back” type=”submit” value=”Restablecer”> </form> <? echo “<h3>El resultado es: “; echo ($resultado); echo “</h3>” ?> <? } ?> </div> </body> </body></html>


Ejercicio 5: Realice un programa que simule una calculadora con las operaciones básicas utilizan-do la sentencia switch – case.

Código Fuente

<html><head><title>Documento sin título</title></head><body> <form action=”<?php echo $_SERVER[‘PHP_SELF’]?>” method=”GET”><table border=”1” width=”60%” cellspacing=”1” cellpadding=”20” border=”0” align=”center”> <tr> <td> Numero 1 <input type=”text” name=”num1” /> <br /> Numero 2 <input type=”text” name=”num2” /> <br /> </td> <td> <input type=”radio” name=”opcion” value=”suma” /> Suma <br /> <input type=”radio” name=”opcion” value=”resta” />Resta<br /> <input type=”radio” name=”opcion” value=”mult” />Multiplicacion<br /> <input type=”radio” name=”opcion” value=”div” />Division<br /> <input type=”submit” name=”submit1” value=”Calcular” /></td> </tr> </table> </form><center><?php if ( !empty ($_GET[“opcion”])) { $val=$_GET [“opcion”];$num1=$_GET [“num1”];$num2=$_GET [“num2”]; switch($val) { case “suma”: $result=$num1+$num2; echo “<br> El resultado de “.$num1. “ + “ .$num2 .” = “.$result; break; case”resta”: $result=$num1-$num2; echo “<br> El resultado de “.$num1. “ - “ .$num2 .” = “.$result; break; case”mult”: $result=$num1*$num2; echo “<br> El resultado de “.$num1. “ * “ .$num2 .” = “.$result; break; case”div”: $result=$num1/$num2; echo “<br> El resultado de “.$num1. “ / “ .$num2 .” = “.$result; break; default: echo”selecciona una operacion aritmetica”; break; } } ?></center></body> </html>


12.6.7.3 Ciclo de repetición for

El ciclo FOR ejecuta expresión1 antes de iniciar, luego comprueba el valor de expresion2 (si es verdadero, el ciclo ejecuta la instrucción una vez), luego el ciclo ejecuta expresion3 (que a menudo incrementa el valor de una variable contadora de ciclos) y, después de eso, comprueba el valor de expresion2 de nueva cuenta (tentativamente, podría comprobar el valor de la variable contadora de ciclos).

Si expresión2 sigue siendo verdadera, el ciclo ejecuta la instrucción una vez más. Luego el ciclo ejecuta expresion3 de nueva cuenta y el proceso continúa hasta que expresion2 se evalúa falsa, una vez concluido el ciclo. Observe que expresion2 se comprueba antes de ejecutarse el ciclo y expresion3 se ejecuta después de cada ocasión que se repite el ciclo. Holzner, S. (2009).

12.6.7.3.1 Ejercicios for

Ejercicio 1: Elabore un programa que permita desplegar los 10 primeros números un una matriz con bordes.

Código Fuente

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=iso-8859-1” /><title>Documento sin título</title></head><body><?phpecho “<table border=1>”;$n=1;for ($n1=1; $n1<=10; $n1++){ echo “<tr>”; for ($n2=1; $n2<=10; $n2++) { echo “<td>”, $n, “</td>”; $n=$n+1; } echo “</tr>”;}echo “</table>”;?></body> </html>

<?php>for ($contador_ciclos = 0; ….){..}?>


Ejercicio 2: Elaborar una tabla de 4 por 4 que muestre las primeras 4 potencias de los números del uno 1 al 4.

Código Fuente

Ejercicio 3: Realice un programa que permita desplegar los números pares hasta el 100.

Código Fuente

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=iso-8859-1” /><title>Documento sin título</title></head> <body><?phpdefine(TAM,4);function potencia ($v1, $v2){ $rdo= pow($v1, $v2); return $rdo; }echo “<table border=1>”;for ($n1=1; $n1<=TAM; $n1++){ echo “<tr>”; for ($n2=1; $n2<=TAM; $n2++) echo “<td>”. potencia($n1,$n2). “</td>”; echo “</tr>”; } echo “</table>”;?></body></html>

<htmL><head><meta http-equiv=”Content-Type” content=”text/html; charset=iso-8859-1” /><title>Documento sin título</title></head><body><?php$nm=$_POST[“n”];echo(“los números pares hasta 100 son: “);echo(“<br>”);for($i=2;$i<=100;$i+= 2){echo(“$i”);echo(“<br>”);} ?></body></html>


Ejercicio 4: Realice un programa que permita desplegar los primeros 12 números la serie Fibonacci.

Código Fuente

Ejercicio 5: Realice un programa que permita ingresar un número por teclado y desplegar la tabla de multiplicar de dicho número.

Código Fuente

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><body><?php$n1=1;$n2=0;echo $n2;echo “ “;for($i=0; $i<=10 ;$i+=1){$suma = $n1+$n2;$n1=$n2;$n2=$suma;echo $suma.” “;} ?></body></html

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=i-so-8859-1” /><title>Documento sin título</title></head><form action=”<?php echo $_SERVER[‘PHP_SELF’]?>” method=”GET”> <br><label>Ingrese el numero </label><br/> <input type=”text” name=”numero”/> <input type=”submit” name=”submit1” value=”Calcular” /></form><body><?phpif ( !empty ($_GET[“numero”])) {$num= $_GET[“numero”];echo(“<br>”);for($i=1;$i<=10;$i+= 1){$resul= $i*$num;echo(“$i”.”*”.”$num”.”=”.”$resul”);echo(“<br>”);} } ?></body></html>


12.6.7.5 Sentencia while

Mientras la expresión sea verdadera, el ciclo ejecuta la instrucción. Eso es todo. Cuando la expre-sión es falsa, el ciclo termina, en otras palabras, el ciclo while se mantiene se ejecución mientras su expresión de prueba sea verdadera. Holzner, S. (2009)

Sintaxis


Ejercicio 1: Realice un programa utilizando la sentencia WHILE para desplegar los números dí-gitos de manera horizontal.

Código Fuente

<?php>Open-file();While (not_at_and_of_file()){...}?>

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=iso-8859-1” /><title>Documento sin título</title></head><body><?php$numeros = 0;while ($numeros < 10){echo “$numeros, “;$numeros++;}?></body></html>


Ejercicio 2: Realice un programa que permita visualizar una pirámide utilizando una sentencia de repetición.

Código Fuente

Ejercicio 3: Elabore un programa que permita desplegar el abecedario completo utilizando un bucle de repetición.

Código Fuente

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><body><?php $i=1;while($i<=5){ $j=1; while($j<=$i) { echo”*&nbsp&nbsp”; $j++; } echo”<br>”; $i++;}?></body></html>

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><body><?php$i = “a”;do { echo $i,” “; $i++; } while ($i <= “z”);?></body> </html>


Ejercicio 4: Elabore un programa que permita desplegar las tablas de multiplicar.

Código Fuente

Ejercicio 5: Realice un programa que permita ingresar una palabra o una oración y se despliegue de manera ascendente (letra por letra).

Código Fuente

<html><head><title>Documento sin título</title></head><body bgcolor=”#000000” text=”#bb0000” topmargin=100><center><h1>Programa de las tablas de multiplicar con el ciclo while<br><?php$ciclo1=1;while($ciclo1<=10){ echo “<table border=3><tr align=center><td colspan=5>Tabla de multiplicar del “.$ciclo1.”:</td></tr>”;$ciclo2=1;while($ciclo2<=10){ $mult=$ciclo1*$ciclo2;echo “<tr align=center><td>”.$ciclo1.”</td><td> X </td><td>”.$ciclo2.”</td><td> = </td><td>”.$mult.”</td></tr>”;$ciclo2++; }echo “</table>”;$ciclo1++; } ?></h1></center> </body> </html>

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><form action=”<?php echo $_SERVER[‘PHP_SELF’]?>” method=”GET”> <br><label>Ingrese una palabra</label><br/> <input type=”text” name=”palabra”/> <input type=”submit” name=”submit1” value=”Calcular” /></form><body>

<?php if ( !empty ($_GET[“palabra”])) { $val=$_GET [“palabra”];$i= “1”;$val1=strlen($val);while ($i < $val1+1){$r1 = rand(0,strlen($val));$pos1 = $r1+1;echo substr($val,0,$i);echo “<br>”; $i++;}}?> </body> </html>


12.6.7.5 Sentencia do while

Existe otro tipo ciclo while (do….while). Este tipo de ciclo es como while con una excepción: verifica su expresión de prueba al final del ciclo, no al principio. Así es como se ve do….while:

En este caso, el ciclo do….while continúa ejecutando la instrucción mientras la expresión sea verdadera-y observe en particular que como expresión se prueba al final del ciclo, podría ser falsa y el cuerpo del ciclo, pese a ello, se ejecutaría al menos una vez. Eso es útil cuando se tiene una situación en que la condición de prueba se establece dentro del cuerpo de ciclo y, por tanto, no se puede probar hasta el final del ciclo. Holzner, S. (2009).

12.6.7.5.1 Ejercicios do – while

Ejercicio 1: Utilizando la sentencia Do WHILE realice un programa que permita ingresar una ora-ción y determinar en qué posición se encuentra una letra elegida anteriormente (Para este ejemplo será la letra “m” minúscula).

<html><head><title>Uso del ciclo do ….while</title></head><body><?php &variable = 1;Do {Echo “ahora $variable contiene: ”, $variable, <br>;$variable++;}While ($variable < 10)?></body></html>

DoInstrucción While (expresión)


Ejercicio 2: Utilizando la sentencia DO WHILE realice un programa que permita encontrar el múltiplo de un número determinado por el usuario, entre un cierto grupo de números determina-dos. (Para este ejemplo utilizamos múltiplos de 11 de entre 50 y 100).

Código Fuente

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><body><form action=”<?php echo $_SERVER[‘PHP_SELF’]?>” method=”GET”> <br><label>Ingrese una palabra</label><br/> <input type=”text” name=”palabra”/> <input type=”submit” name=”submit1” value=”Calcular” /></form><body><?php if ( !empty ($_GET[“palabra”])) { $cadena=$_GET[“palabra”];$i=0;do{$i++;}while($cadena[$i]!=”m” && $i<strlen($cadena)); if($i==strlen($cadena)) echo “no se encuentra”; else echo”Esta es la posicion $i”; }?></body></html>

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><body><?php$i=50;$mensaje =”No hay multiplos de 11 entre 50 y 100. (¿no hay?)”;do { if ($i % 11 ==0) {$mensaje=”El primer multiplo de 11 “.”entre 50 y 100 es:”.$i; break; } $i+=1; } while($i<100); echo $mensaje;?></body></html>


Ejercicio 3: Utilizando un bucle de repetición elabore un programa que permita ingresar un núme-ro y desplegar la tabla de multiplicar de dicho número.

Código Fuente

Ejercicio 4: Realice un programa que permita desplegar los elementos de la serie fibonaci hasta la cantidad que indique el usuario.

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><body><h1>Tablas de multiplicar</h1><h3>Escriba un número del 1 al 10</h3><form action=”#” method=”post”> <p>Escribe aquí el número: <input type=”text” name=”num” maxlength=”2” size=”2” /></p> <p><input type=”submit” value=”Ver tabla de multiplicar.” /></p></form><?php $n=$_POST[‘num’];if ($n<1 or $n>10) { echo “no has escrito un número entre el 1 y el 10.”; }else { echo “<h4>Tabla del $n:</h4>”; $i=1; do { echo “$n x $i = “.$n*$i.”<br/>”; $i++; } while ($i<=10); }?></body></html>


Código Fuente

Ejercicio 5: Realice un programa que permita desplegar los números naturales pares, el número de elementos que indique el usuario al ingresar un número.

Código Fuente

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><body><form name=”formularioDatos” method=”post” action=”” <br><label>Ingrese un número de elementos que desea se desplie-gue en la serie Fibonaci</label><br/> <input type=”text” name=”numero”/> <input type=”submit” name=”calcular” value=”Calcular” /></form></body><?php$val= $_POST[“numero”];$i=0;$n1=1;$n2=0;$suma=0;echo $n2;echo “ “;do{ $suma = $n1+$n2;echo $suma.” “;$n1=$n2;$n2=$suma;$i++;}while($i<=($val-2));?></html>

<html><head><meta http-equiv=”Content-Type” content=”text/html; charset=utf-8” /><title>Documento sin título</title></head><body><form name=”formularioDatos” method=”post” action=”” <br><label>Ingrese un numero</label><br/> <input type=”text” name=”numero”/> <input type=”submit” name=”calcular” value=”Calcular” /></form></body><?php$val= $_POST[“numero”];$i=0;do{ echo $i.” “;$i=$i+2;}while($i<=$val);?></html>

UNIDAD Nº 4JAVA


12.7.1 Definición

Es un lenguaje de programación de alto nivel con el que se pueden escribir tanto programas con-vencionales como para Internet.

Para Sánchez y Fernández (2009a), Java no sólo es un lenguaje, es todo un conjunto de elementos para el desarrollo de aplicaciones avanzadas, es decir, es una plataforma de desarrollo de programa que consta de:

• Un lenguaje de programación: el lenguaje Java, del mismo nombre que la plataforma.• Un conjunto de bibliotecas estándar que se incluyen con la plataforma y que deben existir

en cualquier entorno Java, también denominado Java Core. Estas bibliotecas comprenden: strings, procesos, entrada y salida, propiedades del sistema, fecha y hora, applets, API de red, internacionalización, seguridad, componentes, serialización, acceso a bases de datos, etc.

• Un conjunto de herramientas para el desarrollo de programas. Entre ellas cabe citar el com-pilador de Java a código de bytes, el generador de documentación, el depurador de progra-mas en Java, el analizador de rendimiento, etc.

• Un entorno de ejecución cuyo principal componente es una máquina virtual para poder eje-cutar los programas.

La plataforma Java se puede utilizar desde distintos sistemas operativos, de forma que un mismo programa se pueda ejecutar en todos ellos, cada uno con su hardware correspondiente sin necesi-dad de compilarlo de nuevo.

12.7.2. Máquina virtual de Java

El compilador de Java SE no produce código máquina ejecutable en un procesador específico. En vez de esto, genera un código simplificado, denominado bytecode, que precisa de otro programa, la Máquina Virtual de Java SE, para ejecutarse. Esta Máquina Virtual, ejecuta las aplicaciones Java en un entorno virtual que se denomina la caja de arena (sandbox). Este esquema de funcionamiento hace que Java sea muy seguro en cuanto al acceso no autorizado a los recursos del sistema.

Sin embargo, en Java SE desde la versión 1.3 la Máquina Virtual en vez de interpretar cada byte-code, compila a código máquina nativo cada función antes de ejecutarla. Este tipo de enfoque se denomina Just In Time (JIT) porque se realiza la compilación en el momento de la ejecución (esta misma tecnología la ha copiado Microsoft en la máquina virtual de la plataforma .NET). Vélez et al. (2011)

Como se ha dicho, debe existir una Máquina Virtual diferente para cada plataforma que soporte Java SE. Incluso suele haber diferentes máquinas virtuales para la misma plataforma, dependiendo del fabricante de software, siendo algunas mejores que otras.

12.7.3 Compiladores de Java

Existen varios entornos para compilar Java en línea de comandos. El más famoso y utilizado es el javac proporcionado por el JDK (Java Developer Kit) de Sun, donde JDK es un software que provee herramientas de desarrollo para la creación de programas. Puede instalarse en una com-putadora local o en una unidad de red. Actualmente, en 2009, la última versión estable del kit de desarrollo de Java de Sun es el JDK 6. Vélez et al. (2011).


12.7.4 Entornos de desarrollo para Java

Para programar en Java existen entornos Open Source de nivel profesional como Eclipse (desa-rrollado inicialmente por IBM) y Netbeans (de Sun) que hacen esta tecnología abierta y accesible. También existen entornos privativos como IntelliJ IDEA. Todos estos entornos permiten progra-mación de aplicaciones de tipo consola, aplicaciones visuales, aplicaciones web, para sistemas embebidos, para dispositivos móviles... Tanto Eclipse, como Netbeans e IntelliJ IDEA, están desa-rrollados en Java. También hay entornos más modestos como Kawa o Scite, desarrollados comple-tamente en lenguaje nativo, que son menos pesados en ejecución pero que no contemplan muchas de las características que aportan sus hermanos mayores. Vélez et al. (2011)

15.7.5 Proceso de desarrollo de un programa en Java

Cuando se escribe un programa en un lenguaje de programación, y en Java no es distinto, debe seguir un conjunto de pasos para su desarrollo (Sánchez y Fernández, 2009b). De forma resumida se puede decir que el proceso de desarrollo que sigue cualquier programa es el siguiente:

• Especificación: es el proceso en el que se decide que va a hacer el programa. • Diseño: en esta fase se toma toda la información que se ha recogido en la fase de especifica-

ción y se plantea una solución que permita programarla posteriormente. • Codificaciónoedicióndelprogramafuente: Se denomina programa fuente al programa

que se escribe utilizando un entorno de programación como los descritos, o cualquier editor, en un lenguaje de programación. En Java los archivos fuentes tienen un nombre como nom-bre.java, donde el nombre ha de ser el mismo que el empleado como nombre de la clase y la extensión ha de ser .java.

• Compilación o prueba: en esta fase se compila y ejecuta el programa para comprobar si hace exactamente lo indicado en la fase de especificación.

• Mantenimiento: ningún programa termina después de haberlo probado lo suficiente. Con el tiempo surgen varias necesidades, o ampliación de funciones, o errores que no se habían detectado durante las pruebas, que obligan a modificarlo. Y esta fase es la que más dura, pues puede ser que el código que se escribió hace muchos años se siga utilizando en versiones muy posteriores del programa.

El procedimiento necesario para la ejecución de un programa en Java puede verse, de forma resu-mida en la figura 1.

Fig.6 Proceso de compilación y ejecución de un programa en JavaFuente: Casanova y Marqués (2012)

Vélez, Peña, Cortázar y Sánchez (2011), consideran que las características principales de Java son las siguientes:

• Sintaxis similar a la de C++. Aunque se simplifican algunas características del lenguaje como: la sobrecarga de operadores, la herencia múltiple, el paso por referencia de paráme-


tros, la gestión de punteros, la liberación de memoria y las instrucciones de precompilación. • Soporte homogéneo a la Programación Orientada a Objetos. A diferencia de C+ +, que puede

considerarse un lenguaje multiparadigma, Java está diseñado específicamente para utilizar el paradigma de orientación a objetos.

• Independencia de la plataforma. Con Java se hizo un importante esfuerzo para que el mismo código fuese ejecutable independientemente del hardware y del Sistema Operativo.

• El lenguaje Java presenta algunas características que lo diferencian a veces significativa-mente, de otros lenguajes. En particular está diseñado para facilitar el trabajo en WWW, mediante el uso de los programas navegadores de uso completamente difundido hoy en día. Los programas de Java que se ejecutan a través de la red se denominan Applets (aplicación pequeña).

• La inclusión en el lenguaje de un entorno para la programación grafica (ATW y Swing) y el hecho de que su ejecución es independiente de la plataforma, lo que significa que un mismo programa se ejecutará exactamente igual en diferentes sistemas.

12.7.6 Ventajas

Casanova y Marqués (2012) consideran que las ventajas y desventajas de Java son:

• La sencillez y elegancia de cómo se escriben los programas en y las ayudas que presta en el proceso de escribir los mimos.

• Es un lenguaje orientado a objetos que evita muchas preocupaciones a los programadores. En el proceso de compilación se realizan multitud de comprobaciones que permiten eliminar muchos posibles errores posteriores.

• La inmensa cantidad de bibliotecas que por una parte ya vienen definidas con el lenguaje y por otra parte, que se pueden añadir a los entornos de desarrollo. De esta forma el progra-mador puede utilizar estas bibliotecas para facilitarle mucho trabajo sin tener que hacerlo o inventarlo de nuevo.

12.7.7 Desventajas

• Puede ser un lenguaje de ejecución lenta, debido al uso de la máquina virtual de Java, a di-ferencia de otros lenguajes de programación de más bajo nivel como lo es “C”, su velocidad de ejecución disminuye drásticamente al compararse con este lenguaje.

• Java es considerado un lenguaje difícil de aprender, esto debido a su compleja sintaxis, sin embargo la estructura de este lenguaje es completa y organizada y semejante al lenguaje de C++, por lo que si se tiene conocimiento previo en C++, Java no debería de ser un lenguaje difícil de aprender.

15.7.8 Estructura de un programa en Java

Las estructuras de programación o también llamadas estructuras de control permiten implementar procesos, tomar decisiones y realizar procesos con varias repeticiones.

15.7.8.1 Sentencias

Una expresión es un conjunto de variables unidas por operadores. Equivalen a instrucciones que el computador interpreta para realizar un proceso determinado. Una sentencia es una expresión


que tiene al final punto y coma (;). Es posible incluir varias sentencias en una línea, sin embargo, se considera una buena práctica utilizar una línea para cada sentencia. Las siguientes líneas son ejemplos de sentencias en un programa (Casanova y Marqués, 2012).

12.7.8.2 Comentarios

Existen dos formas diferentes de introducir comentarios entre el código de la aplicación. Los co-mentarios son útiles para documentar el código implementado.

Los comentarios se realizan de dos formas. La primera consiste en colocar el símbolo “//” en una línea de código y en seguida el texto del comentario. La segunda consiste en incluir el símbolo “/*” al inicio del comentario y el símbolo “*/” al final del comentario. Esta segunda forma permite hacer comentarios en varias líneas de código. Por ejemplo //Este es un comentario en una línea de código /* Este es un comentario en diferentes líneas de código */

12.7.8.3 Estructuras de control

Son aquellas que permiten tomar decisiones y realizar procesos con varias repeticiones logrando funcionalidad en el programa. A continuación se describen las más utilizadas:

12.7.8.3.1 Condición if

La sentencia o condición “if” está compuesta de una condición la cual siempre va a dar como re-sultado un valor booleano (verdadero o falso).

La condición if debe colocarse entre paréntesis. La misma que permite ejecutar un conjunto de ins-trucciones si se cumple la condición establecida. Este conjunto de instrucciones debe estar incluido entre los símbolos (“{” y “}”). Pero si se coloca una solo instrucción ya no se usa (Flores, 2012).

Sintaxis

int a; int b;int c;b=10;c=20;a=b+c;

if (condición){Instrucción 1.1;Instrucción 1.2;…;} else{Instrucción 2.1;Instrucción 2.2;…;}


12.7.8.3.2 Condición if/else

La sentencia “if” “else” simplemente es igual que la sentencia if en este caso se aumenta else (caso contrario), es decir, si la condición es verdadero termina el proceso pero si es falso realiza el proceso por esta instrucción (Flores, 2012).

15.7.8.3.2 Condición if/else if

La condición “if” “else if” se compone de varias condiciones, las cuales deben colocarse entre paréntesis; estas permiten ejecutar varias instrucciones si se cumple la condición establecida y per-mite ejecutar otras instrucciones, si se cumple la otra condición establecida y así sucesivamente. Este conjunto de instrucciones debe estar incluido entre los símbolos “{” y “}”. Esta estructura permite tener al final un else la cual se ejecuta no son ninguna de estas anteriormente realizadas. (Flores, 2012).

Sintaxis

15.7.8.3.3.1 Ejercicios if

Ejercicio 1: Dado 3 números devolver los números en forma ascendente. El usuario ingresa n1, n2, n3 y luego verifica el sistema en forma ascendente.

if(condición 1){instrucción 1.1;..}else if(condición 2){instrucción 2.1;..}

if(condición){Instrucción 1;Instrucción 2;Instrucción n;}


Código Fuente

Ejercicio 2: Dado los siguientes datos de entrada saldo anterior, tipo de movimiento “R” retiro, “D” Depósito, monto de la transacción obtener como dato de salida dato actual”.

package ejercicios;import java.util.Scanner;public class ejercicio10052016 {public static void main(String[] args) {int n1,n2,n3;Scanner teclado = new Scanner(System.in);System.out.print(“ingrese numero1: “);n1 = teclado.nextInt();System.out.print(“ingrese numero2: “);n2 = teclado.nextInt();System.out.print(“ingrese numero3: “);n3 = teclado.nextInt();if(n1<n2 && n1<n3)System.out.println(“” +n1);elseif(n2<n1 && n2<n3)System.out.println(“” +n2);elseSystem.out.println(“” +n3);if(n1>n2 && n1<n3)System.out.println(“” +n1);elseif(n2>n1 && n2<n3)System.out.println(“” +n2);elseSystem.out.println(“” +n3);if(n1>n2 && n1>n3)System.out.println(“mayor” +n1);elseif(n2>n1 && n2>n3)System.out.println(“” +n2);elseSystem.out.println(“” +n3);}}


Código Fuente

Ejercicio 3: Programa que permita reconocer si el dígito es un carácter o una vocal.

Código Fuente

package ejercicios;import java.util.Scanner;public class ejercicio170520 {public static void main(String[] args) {int saldo =100;String R, D, opcion;int saldototal;Scanner teclado = new Scanner(System.in);System.out.println(“Bienvenidos”);System.out.println(“ingrese la transacción que desea realizar”);opcion=teclado.nextLine();if (opcion.equals(“R”)){saldototal=saldo-10;System.out.println(“El saldo de su transacción es: “+saldototal);}else{if (opcion.equals(“D”)){saldototal=saldo+10;System.out.println(“El saldo de su transacciòn es: “+saldototal);}}}}

package ejercicios;import java.util.Scanner;public class ejrcicio {public static void main(String[] args) {String letra;Scanner teclado = new Scanner(System.in);System.out.print(“ingrese una letra: “);//mensaje en pantallaletra= teclado.nextLine();//lama la variable y asigna valorif(letra.equals(“a”)|| letra.equals(“e”) || letra.equals(“i”) || letra.equals(“o”) || letra.equals(“u”))

System.out.println(“la letra es vocal” +letra);elseSystem.out.println(“no es vocal”);}}


Ejercicio 4: Programa que permite obtener el 5% cuando el valor es 100$, el 10% cuando el valor es 200 y el 30% si el valor ingresado es mayor a 300$.

Código Fuente

Ejercicio 5: Programa que permite ingresar dos números por teclado, comparar y desplegar el número mayor.

Código Fuente

package ejercicios;import java.util.Scanner;public class ejrcicio3practica {public static void main(String[] args) {float compra;Scanner teclado = new Scanner(System.in);System.out.print(“ingrese numero1: “);compra = teclado.nextInt();float descuento;if( compra<=100){descuento=(float) (compra*0.05);float desc=compra-descuento;System.out.println(“resultado: “ +descuento);System.out.println(“resultado: “ +desc);}elseif(compra>=101 || compra<=299){float descuento2=(float) (compra*0.1);float desc2= compra-descuento2;System.out.println(“resultado: “ +descuento2);System.out.println(“resultado: “ +desc2);}elseif(compra>=300){float des=(float) (compra*0.3);float desct=compra-des;System.out.println(“resultado: “ +des);System.out.println(“resultado: “ +desct);}}}

package ejercicios;

import java.util.Scanner;public class numero {

public static void main(String[] args) {int n1,n2,n3;Scanner teclado = new Scanner(System.in);System.out.print(“ingrese el primer número “);//mensaje en pantallan1 = teclado.nextInt();

System.out.print(“ingrese el segundo número “);n2 = teclado.nextInt();System.out.print(“ingrese el tercer número “);n3 = teclado.nextInt();//lama la variable y asigna valorif(n1>n2)System.out.println(“el número mayor es”+n1);elseif(n2>n3)System.out.println(“el número mayor es”+n2);elseSystem.out.println(“el número mayor es”+n3);}}


12.7.8.3.4 Condición switch - case

La estructura de la sentencia “switch” “case” está compuesta por múltiples condiciones o instruc-ciones sobre una misma variable, las cuales deben arrojar un valor booleano (verdadero o falso).

La variable de las opciones debe estar entre paréntesis, seguido de la palabra “switch {“, seguido de los casos (case:) con las respectivas instrucciones, y cerrar con un “break”; y finalmente para cerrar el último caso se utiliza “default” (Flores, 2012).

Sintaxis

12.7.8.4.4.1 Ejercicios switch - case

Ejercicio 1: Programa que presenta un menú con las siguientes opciones: 1 verano 2, otoño 3, invierno y 4 primavera.

Código Fuente

switch(n){case 1:instrucción 1.1;instrucción 1.2;..instrucción 1.n; break; case valor 2: instrucción 2.1; instrucción 2.2; .. instrucción 2.n; break; default: instrucción 3.1; instrucción 3.2; .. instrucción 3.n; break; }

package ejercicios;import java.util.Scanner;public class switch10052016 {public static void main(String[] args) {int op;Scanner teclado = new Scanner(System.in);System.out.print(“Ingrese un nùmero : “);op = teclado.nextInt();switch ( op ) {case 1:System.out.println( “La estaciòn es verano” );break;case 2:System.out.println( “La estaciòn es otoño” );break;case 3:System.out.println( “La estaciòn es invierno”);break;case 4:System.out.println( “La estaciòn es primavera” );break;default:break;}}}


Ejercicio 2: Programa que despliega un menú con las operaciones de suma, resta, potencia y raíz cuadrada, y a su vez realiza dichas operaciones entre dos números.

Código Fuente

package ejercicios;import java.util.Scanner;public class sumaswitch {private static Object math;public static void main(String[] args) {int op, a ,b ,r;Scanner teclado = new Scanner(System.in);System.out.print(“ingrese una opcion : “);op = teclado.nextInt();switch ( op ) {case 1:System.out.print(“ingrese numero : “);a= teclado.nextInt();System.out.print(“ingrese numero2 : “);b= teclado.nextInt();r=a+b;System.out.println( “Suma”+r );break;case 2:System.out.print(“ingrese numero : “);a= teclado.nextInt();System.out.print(“ingrese numero2 : “);b= teclado.nextInt();r=a-b;System.out.println( “Resta”+r );break;case 3:System.out.print(“ingrese numero : “);a= teclado.nextInt();System.out.print(“ingrese numero2 : “);b= teclado.nextInt();r=(int) (Math.pow(a,b));System.out.println( “Potencia”+r );break;case 4:System.out.print(“ingrese numero : “);a= teclado.nextInt();r=Sqrt(a);System.out.println( “Raiz”+r ); break;default:break;


Ejercicio 3: Programa que solicita una nota numérica entera entre 0 y 10, y muestra dicha nota de la forma: Insuficiente, Suficiente, Bien, Notable, según cada nota.

Código Fuente

Ejercicio 4: Programa que solicita una nota numérica entera entre 0 y 10, y muestra dicha nota de la forma: cero, uno, dos, tres…diez.

package bol01ej14b;public class Main { public static void main(String[] args) { int nota; System.out.print(“Introduzca una nota: “); nota=Entrada.entero(); switch(nota){ case 0: case 1: case 2: case 3: case 4: System.out.println(“INSUFICIENTE”); break; case 5: System.out.println(“SUFICIENTE”); break; case 6: System.out.println(“BIEN”); break; case 7: case 8: System.out.println(“NOTABLE”); break; case 9: case 10: System.out.println(“SOBRESALIENTE”);break; default: System.out.println(“ERROR”); break; } }}


Código Fuente

Ejercicio 5: Programa que simula el funcionamiento de una calculadora que puede realizar las cuatro operaciones aritméticas básicas (suma, resta, producto y división) con valores numéricos enteros.

package bol01ej21;public class Main { public static void main(String[] args) { int num; System.out.print(“Introduzca una nota numérica entre 0 y 10: “); num=Entrada.entero(); switch(num){ case 0: System.out.println(“CERO”); break; case 1: System.out.println(“UNO”); break; case 2: System.out.println(“DOS”); break; case 3: System.out.println(“TRES”); break; case 4: System.out.println(“CUATRO”); break; case 5: System.out.println(“CINCO”); break; case 6: System.out.println(“SEIS”); break; case 7: System.out.println(“SIETE”); break; case 8: System.out.println(“OCHO”); break; case 9: System.out.println (“NUEVE”); break; case 10: System.out.println(“DIEZ”); break; } }}


Código Fuente

12.7.8.3.5 Bucle de repetición while

Esta estructura de repetición es un proceso que se repetirá mientras que una condición tenga el valor verdadero, donde este tipo de sentencia define un proceso iterativo (Flores, 2012).

Sintaxis

} public class Calcula { public static void main (String [] args) { char c; int a,b; c=args[0].charAt(0); a = Integer.parseInt(args[1]); b = Integer.parseInt(args[2]); switch (c) { case ‘S’: case ‘s’: System.out.println(“Resultado de la suma: “ + (a+b)); break; case ‘R’: case ‘r’: System.out.println(“Resultado de la resta: “ + (a-b)); break; case ‘M’: case ‘m’: case ‘P’: case ‘p’: System.out.println(“Resultado del producto: “ + a*b); break; case ‘D’: case ‘d’: System.out.println(“Resultado de la division: “ + a/b); break; default: System.out.println(“Por favor, indica la opera-cion”); break;} } } }

while(condición){instrucción 1;instrucción 2;instrucción 3;instrucción n;}


12.7.8.3.5.1 Ejercicios while

Ejercicio 1: Programa que permite saber si el número ingresado es capicúa.

Código Fuente

Ejercicio 2: Programa que permite imprimir números del 1al 10.

Código Fuente

package ejercicios;import java.util.Scanner; //biblioteca del scannerpublic class capicua {public static void main(String[] args) {int s=0,residuo;int n,t;Scanner teclado = new Scanner(System.in);System.out.print(“Numero : “);n = teclado.nextInt();t=n;while(t>0){residuo=t%10;s=s*10+residuo;t=t/10;}System.out.println(“El numero invertido es “+s);if(n==s)System.out.println(“El número es capicúa”);elseSystem.out.println(“El número no es capicúa”);}}

} package ejercicios;public class ejercicio1705part3{public static void main(String[] args) {int i=1;while(i>0){System.out.println(i);if(i==10){break;}i++;}}}


Ejercicio 3: Programa que permite imprimir números del 1 hasta el 5.

Código Fuente

Ejercicio 4: Programa que permite leer un número y muestra su cuadrado, se repite el proceso hasta que se introduce un número negativo.

Código Fuente

Ejercicio 5: Programa que permite leer números hasta que se introduzca el número 0, e indica si es par o impar.

package bol02ej01;public class Main { public static void main(String[] args) { int num,cuadrado; // num guardará el número que leamos // y cuadrado guardará el cuadrado de num System.out.print(“Introduzca número: “); num=Entrada.entero(); while(num>=0){ // repetimos el proceso mientras el número leído no sea negativo cuadrado=num*num; System.out.println(num+ “² es igual a “+ cuadrado); System.out.print(“Introduzca otro número: “); num=Entrada.entero(); // volvemos a leer num } }}

package ejercicios;public class ejercicio170516part2 {public static void main(String[] args) {int i=1;while(i<=5) {System.out.println(i); //imprime los números del 1 al 5.i++;}}}


Código Fuente

12.7.8.3.6 Bucle de repetición do while

La estructura de repetición “do” “while” presenta diferencia con respecto a la estructura “while” que consiste en que el “do” “while” primero ejecuta y luego consulta, mientras que el “while” primero consulta y luego ejecuta (Flores, 2012).

Sintaxis

12.7.8.3.6.1 Ejercicios do while

Ejercicio 1: Programa que permite imprimir los números del 1 al 5.

package bol02ej03;public class Main { public static void main(String[] args) { int num; System.out.print(“Introduzca un número: “); num=Entrada.entero(); while(num!=0) // mientras num sea distinto de 0 { if(num%2 == 0) // si el resto de dividir entre dos es cero: esto indica que es par System.out.println(“Par”); else // en caso contrario: impar System.out.println(“Impar”); // repetimos el proceso y volvemos a leer num System.out.print(“Introduzca otro número: “); num=Entrada.entero(); } // al salir del mientras tenemos la certeza que num es 0 }}

do{instrucción 1;instrucción 2;..instrucción n;}while(condición);


Código Fuente

Ejercicio 2: Programa que solicita la carga de un número entre 0 y 999, y muestra un mensaje de cuantos dígitos tiene el mismo. Finaliza el programa cuando se carga el valor 0.

Código Fuente

Ejercicio 3: Programa que permite pedir números hasta que se teclee un 0, además muestra la suma de todos los números introducidos.

package ejercicios;/**** @author LAB4_INFO_PC*/public class dowhile170516 {public static void main(String[] args) {int i;i=1;do{System.out.println(i);i++;}while(i<=5);

}}

public class Ciclo_Do_While {public static void main(String[] args) {Scanner datos=new Scanner(System.in);int valor;do {System.out.print(“Ingrese un valor entre 0 y 999 (0 finaliza):”);valor=datos.nextInt();if (valor>=100) {System.out.println(“Es de 3 dígitos.”);} else {if (valor>=10) {System.out.println(“Es de 2 dígitos.”);} else {System.out.println(“Es de 1 dígito.”);}}} while (valor!=0);}}


Código Fuente

Ejercicio 4: Programa que permite pedir números hasta que se introduzca uno negativo, y calcula la media.

Código Fuente

package bol02ej06;public class Main {

public static void main(String[] args) { int num,suma; suma=0; do { System.out.print(“Introduzca un número: “); num=Entrada.entero(); suma=suma+num; } while(num!=0);

System.out.println(“La suma de todos los números es: “+suma);

}}


public static void main(String[] args) { int num, suma, elementos; float media; // la media puede tener decimales // num: guardará los números introducidos por el usuario // suma: almacenará la suma de todos los números introducidos // elementos: será un contador que indicará el números de números 8o elementos) introducidos System.out.print(“Introduzca un número: “); num=Entrada.entero();

suma= 0; elementos= 0;

while(num>=0) // nos interesan los positivos y el cero { suma+=num; elementos++; System.out.print(“Introduzca otro número: “); num=Entrada.entero(); } if (elementos == 0) // daría un error de división por cero System.out.println(“Imposible hacer la media”); else { media= (float)suma/elementos; System.out.println(“La media es de: “ + media); } }


Ejercicio 5: Programa que permite realizar un menú con 3 opciones, las opciones 1 y 2 muestra un mensaje, la opción 3 será para salir y terminar el programa.

Código Fuente

12.7.8.3.7 Bucle de repetición for

La estructura de repetición “for” define un proceso iterativo. La estructura for se compone de inicia-lización, condición e incremento. La inicialización debe incluir al menos una variable y un valor, la condición debe involucrar la variable de la inicialización con el fin de tener un mecanismo de terminar el proceso iterativo y el incremento debe también, involucrar la variable de la inicialización, esta se di-ferencia de las demás por presentar condiciones y estas van incrementando; para trabajar esta debe ini-cializarse con una variable y un valor, las cuales deben estar incluidas en las condiciones (Flores, 2012).

Sintaxis

for(inicialización; condición; incremento){instrucción 1;instrucción 2;instrucción 3;}

package pqtDoWhile; import javax.swing.JOptionPane; public class DoWhileMenu { public static void main(String[] args) {int op=0;String menu=””;do{menu=””;menu+=”****** Menú ******\n”;menu+=”1.- Mostrar mensaje 1 \n”;menu+=”2.- Mostrar mensaje 2 \n”;menu+=”3.- Salir \n”;menu+=”Elia una opción”;op=Integer.parseInt(JOptionPane.showInputDialog(menu));switch(op){case 1:JOptionPane.showMessageDialog(null, “Programar es fácil en TutosPOO”);break;case 2:JOptionPane.showMessageDialog(null, “Recuerda esto... Un programa no tiene que quedar bien en la primera vez... Pero si la última”);break; }}while(op!=3);}}


12.7.8.3.7.1 Ejercicios for

Ejercicio 1: Programa que permite imprimir los números del 1 al 5 utilizando la sentencia for.

Código Fuente

Ejercicio 2: Programa que permite utilizar las funciones trigonométricas (seno y coseno) //dando el resultado en radianes.

Código Fuente

Ejercicio 3: Programa que permite ingresar 10 números y muestra la media de los números posi-tivos, la media de los números negativos y la cantidad de ceros.

package ejercicios;

public class ejerciciopart4 {public static void main(String[] args) {int i;for(i=1; i<=5; i++)

System.out.println(i);}}

package ejercicios;

public class senocos17052016 {public static void main(String[] args) {double seno;double coseno;for(int i=0;i<=360;i+=90){seno=Math.round(Math.sin(i*Math.PI/180));//System.out.println(“El seno de “+i+” usando PI/180 es: “+seno);seno=Math.round(Math.sin(Math.toRadians(i)));System.out.println(“El seno de “+i+” usando toRadians es: “+seno);coseno=Math.round(Math.cos(i*Math.PI/180));System.out.println(“El coseno de “+i+” usando PI/180 es: “+coseno);coseno=Math.round(Math.cos(Math.toRadians(i)));System.out.println(“El coseno de “+i+” usando toRadians es: “+coseno);}}}


Código Fuente

package bol02ej13;public class Main { public static void main(String[] args) { int num; int cont_ceros; // el contador de ceros int cont_pos; // contador de positivos int cont_neg; // contador de negativos int suma_pos,suma_neg; // suma de los números positivos y negativos float media_pos,media_neg; // las medias 8positivas y ne-gativa9 pueden tener decimales }}cont_ceros=0; cont_pos=0; cont_neg=0; suma_pos=0; suma_neg=0; for (int i=1;i<=10;i++) { System.out.print(“Introduce número: “); num=Entrada.entero(); if(num==0) cont_ceros++; else { if(num>0) { cont_pos++; suma_pos+=num; } else { cont_neg++; suma_neg+=num; }} } // tratamos los ceros System.out.println(“El número de ceros introducidos es de: “+cont_ceros); //Tratamos los positivos if (cont_pos ==0) System.out.println(“No se puede hacer la media de los positivos”);else { media_pos= (float)suma_pos/cont_pos; System.out.println(“Media de los positivos: “+ media_pos); } // tratamos los negativos if (cont_pos ==0) System.out.println(“No se puede hacer la media de los negativos”); else { media_neg= (float)suma_neg/cont_neg; System.out.println(“Media de los negativos: “+ media_neg); } }}}}


Ejercicio 4: Programa que permite ingresar edades y alturas de 5 alumnos, muestra la edad y la estatura media, la cantidad de alumnos mayores de 18 años, y la cantidad de alumnos que miden más de 1,75.

Código Fuente

package bol02ej15;public class Main { public static void main(String[] args) { int edad,media_edad,suma_edad,mayor_edad,mayor_175; //mayor_edad: mayores de 18 años double altura,media_altura,suma_alt; mayor_edad=0; media_altura=0; mayor_175=0; suma_edad=0; suma_alt=0; for (int i=1;i<5;i++){ System.out.println(“Alumno “ +i); System.out.print(“Introduzca edad: “); edad=Entrada.entero(); System.out.print(“Introduzca altura: “); altura=Entrada.real(); if(edad>18) mayor_edad++; if(altura>1.75) mayor_175++; suma_edad=suma_edad+edad; suma_alt=suma_alt+altura; }media_edad=suma_edad/5; media_altura=suma_alt/5; System.out.println(“\n\nLa edad media es de: “+media_edad); System.out.println(“La altura media es de: “ +media_altura); System.out.println(“Mayor de 18 años: “ +mayor_edad); System.out.println(“Mayor de 1.75: “ +mayor_175); }


Ejercicio 5: Programa que permite escribir la cantidad de alumnos aprobados, condicionados (=4) y suspensos, de 6 notas ingresadas.

Código Fuente

12.7.8.3.8 Vectores (arreglos unidimensionales)

Un arreglo unidimensional, también conocido de manera coloquial como vector, es una colección de datos de un mismo tipo que ocupan posiciones de almacenamiento en forma consecutiva en la memoria de la computadora y recibe un nombre común (López, 2014a). Se hace referencia a los elementos del arreglo mediante un índice, el cual señala su ubicación relativa dentro del arreglo.

Para López (2014b), un arreglo es una colección finita, homogénea y ordenada de elementos. Fini-ta porque tiene un límite, es decir, se determina el número máximo de elementos que lo componen; homogénea porque los elementos del arreglo son de un mismo tipo, y ordenada en razón de que estos tienen una disposición establecida desde el primero hasta el último elemento.

Existen algunas restricciones al tratar con arreglos:

• Todos los elementos del arreglo deben tener el mismo tipo.

package bol02ej19;public class Main { public static void main(String[] args) { int nota,aprobados,suspensos,condicionados; aprobados=0; suspensos=0; condicionados=0;

for (int i=1;i<=6;i++) { System.out.print(“Introduzca nota entre 0 y 10: “); nota=Entrada.entero(); if(nota == 4) condicionados++; else if(nota >= 5) aprobados++; else if(nota < 4) // este if sobra, ya que es el único caso posible suspensos++;

} System.out.println(“Aprobados: “ +aprobados); System.out.println(“Suspensos: “ +suspensos); System.out.println(“Condicionados: “+condicionados); }}


• En general, el tamaño del arreglo es fijo.• Se ocupan comúnmente para almacenar datos numéricos.• La función que nos da la posición o dirección de un elemento en un arreglo unidimensional

asociado a la expresión índice o subíndice es: dirección [índice o subíndice]. López (2014)

Dato1 Dato2 Dato3 Dato4 ….. n-ésimo dato

A[0] A[1] A[2] A[3] …… A[n-1]

La dirección de memoria A[0] contiene el Dato 1La dirección de memoria A[1] contiene el Dato 2La dirección de memoria A[2] contiene el Dato 3La dirección de memoria A[3] contiene el Dato 4

………….

Entonces, podemos entender los arreglos o vectores como variables que contienen diferentes tipos de datos homogéneos, a los que se puede acceder de manera individual mediante un índice o su-bíndice, por ejemplo: A[0]=Dato 1.

12.7.8.3.8.1 Ejercicios vectores

Ejercicio 1: Programa que lee por teclado una tabla de 10 números enteros y la desplace una posi-ción hacia abajo: el primero pasa a ser el segundo, el segundo pasa a ser el tercero y así sucesiva-mente. El último pasa a ser el primero.

Código Fuente


public static void main(String[] args) { int t[]=new int[10]; int ultimo; // leemos la tabla for (int i=0;i<10;i++){ System.out.print(“Introduzca número: “); t[i]=Entrada.entero(); } // guardamos el último elemento de la tabla ultimo = t[9];// desplazamos hacia abajo (de 0 hacia la última posición) // al desplazar perdemos el último valor, por eso lo hemos guardado antes. for (int i=8;i>=0;i--) t[i+1]=t[i]; // el último valor pasa a ser el primero t[0] =ultimo;

System.out.println(“La tabla queda:”); for (int i=0;i<10;i++) System.out.println(t[i]); }


Ejercicio 2: Contador de números positivos y negativos

Código Fuente

import javax.swing.JOptionPane;import java.util.Scanner;public class CONTADOR{ public static void main(String[] args) { Scanner teclado = new Scanner(System.in); String enunciado; int opcion; System.out.println(“*******CONTADOR DE NÃšMEROS POSITIVOS y NEGATIVOS*******”); do{ enunciado=JOptionPane.showInputDialog(“Ingresa cuantos mÃºmeros quieres desplegar:”); int nv=Integer.parseInt(enunciado); System.out.println(“Has seleccionado:”+enunciado); int[] numeros = new int[nv]; int positivos = 0, negativos = 0; int i; String nl = System.getProperty(“line.separator”); System.out.println(“Ingresa los nÃºmeros ya sean positivos o negativos:”); for (i = 0; i < numeros.length; i++) { System.out.print(“posiciÃ³n[“ + i + “]= “); numeros[i] = teclado.nextInt(); } for (i = 0; i < numeros.length; i++) {

if (numeros[i] > 0) { positivos++; } else if (numeros[i] < 0) { negativos++; } } JOptionPane.showMessageDialog(null,”Positivos: “ + positivos+ nl +” Negativos: “ + negativos); System.out.println(“*******RESULTADO*******”); System.out.println(“Positivos: “ + positivos); System.out.println(“Negativos: “ + negativos); System.out.println(“DESEAS INTENTAR DE NUEVO 1:SI - 2:NO”);opcion=teclado.nextInt(); }while(opcion==1); }}


Ejercicio 3: Leer por teclado una tabla de 10 elementos numéricos enteros y una posición (entre 0 y 9). Eliminar el elemento situado en la posición dada sin dejar huecos.

Código Fuente

package bol04ej12;public class Main { public static void main(String[] args) { int t[]=new int[10]; int posicion; // leemos los 10 números for (int i=0;i<10;i++) { System.out.print(“Elemento (“+i+”): “); t[i]=Entrada.entero(); } System.out.println(); // leemos la posición que nos interesa // suponemos que la posición está en el rango 0..9 System.out.print(“Posición a eliminar: “); posicion=Entrada.entero(); // desplazamos desde posición hasta el final todos los elementos un lugar hacia la izquierda // con lo que el elemento que está en posición se pierde (se borra) for (int i=posicion;i<9;i++) // la i llega hasta la penúltima posición, t[i] = t[i+1]; // ya que dentro usamos (i+1) que es la última posición // así evitamos salirnos de la tabla System.out.println(“La tabla queda: “); for (int i=0;i<9;i++) // hay que tener cuidado que ahora hay un System.out.println(t[i]); // elemento útil menos en la tabla }}


Ejercicio 4: Leer 10 enteros ordenados crecientemente. Leer N y buscarlo en la tabla. Se debe mostrar la posición en que se encuentra. Si no está, indicarlo con un mensaje.

Código Fuente

package bol04ej15;public class Main { public static void main(String[] args) { int t[]=new int[10]; int num,j; for (int i=0;i<10;i++){ System.out.print(“Introduzca numero (orden creciente): “); t[i]=Entrada.entero(); } System.out.println(); System.out.println(“Introduzca numero a buscar: “); num=Entrada.entero(); j=0; while(j<10 && t[j]<num){ j++; } // cuando me salgo del mientras puede ser por dos motivos: // - que j llegue a 10 ó // - que encuentre el donde iría num en la tabla if(j==10) // hemos llegado al final y no hemos encontrado nada. System.out.println(“No encontrado”); else{ // si t[j] < num, hemos sobrepasado el lugar donde debería estar num, sin encontrarlo if(t[j]==num) // num está en la posición i. Entonces si está ahí System.out.println(“Encontrado en la posición “ + j); else System.out.println(“No encontrado”); } }


Ejercicio 5: Programa que permite mostrar en pantalla un mensaje que indique cuál es la hora r y el número de coches para la hora r.

Código Fuente

public class Programa1 { public static void main(String arg[ ]) { int[ ] numerodecoches = new int[24]; int r; r = 2; numerodecoches[r] = 23;System.out.print(“El número de coches en la hora “+r+” fue “+ numerodecoches[r]); } }

BANCODE

PREGUNTAS


UNIVERSIDAD CENTRAL DEL ECUADORFACULTAD DE FILOSOFÍA, LETRAS Y CIENCIAS DE LA EDUCACIÓN

CARRERA O PROGRAMA: EDUCACIÓN SUPERIORFICHA TÉCNICA PARA LA CONSTRUCCIÓN DE REACTIVOS

Número de pregunta:

2 Fecha de elabora-ción:

19/12/2016

DATOS DEL AUTORAPELLIDO Y NOMBRE Nº DE CÉDULA ESPECIALIDAD

Borja López Yolanda Azucena 1713405767 MSc. Sistemas InformáticosNÚCLEO ESTRUCTURANTE Tecnologías de la Información y la Comunicación

ASIGNATURA RELACIONADA Programación

TEMA ESPECÍFICO Lenguaje de Programación C++

TIPO DE REACTIVO Simple

NIVEL TAXONÓMICO CONOCIMIENTO X COMPRE-

SIÓN APLICACIÓN

CONSTRUCCIÓN DE LA PREGUNTAFASE Y/O INSTRUCCIÓN:El siguiente ejercicio desarrollado en lenguaje C++, debería mostrar en pantalla la palabra “vuelta” en un bucle de 10 repeticiones. Encontrar cuántos errores existen, para que el programa pueda ejecutarse de modo correcto.ELEMENTOS (Simple)

#include <stdio.h>#include <stdlib.>int main (){int contador = ; printf ( “Este es un bucle de 10 ciclos o vueltas\n”, contador );while ( contador < 10 ) {contador+; printf( “vuelta %d\n”, contador ); return 0;}

OPCIONES DE RESPUESTA:A) 4B) 3C) 2D) 1

OPCIÓN CORRECTA

DIFICULTAD ESPERADA

A BAJA MEDIA X ALTAJustificaciónyfuentesdelaopcióncorrectaBibliografía: Montoya, G. J. O. (2009). Problemas resueltos en Visual C++ usando If y Switch. Córdoba, AR: El Cid Editor | apuntes. Tomado de http://www.ebrary.com Pág. 27Especificacionesdediseño:dibujos,gráficosuotros


UNIVERSIDAD CENTRAL DEL ECUADORFACULTAD DE: FILOSOFÍA, LETRAS Y CIENCIAS DE LA EDUCACIÓN

CARRERA O PROGRAMA: INFORMÁTICAFICHA TÉCNICA PARA LA CONSTRUCCIÓN DE REACTIVOS

Número depregunta:

2 Fecha de elaboración:

21/12/2016

DATOS DEL AUTORAPELLIDO Y

NOMBRENº DE CÉDULA ESPECIALIDAD

Borja López Yolanda Azucena 1713405767 MSc. Sistemas InformáticosNÚCLEO ESTRUCTURANTE Tecnologías de la Información y la Comunicación


TEMA ESPECÍFICO Programación PHP


NIVEL TAXONÓMICO CONOCIMIENTO X

COM-PRE-SIÓN

APLICACIÓN

CONSTRUCCIÓN DE LA PREGUNTAFASE Y/O INSTRUCCIÓN:Seleccione las líneas que completen el siguiente código, de manera que se muestre en pantalla “12 10”.ELEMENTOS (Simple)

<?php

$a=”7”;

……………………

$c=”8”;

……………………

echo “$b”;

echo “$c”;

?>

OPCIONES DE RESPUESTA:A) $c = 2; - $b=$b + 5;B) $c+= 2; - $b=$b + 5;C) $b=$b + 5; - $b=$a + 5;D) $c+= 2; - $b=$a + 5;

OPCIÓN CORRECTA

DIFICULTAD ESPERADA

D BAJA MEDIA X ALTAJustificaciónyfuentesdelaopcióncorrecta

Bibliografía: Vaswani, V. (2010). Fundamentos de PHP. México, D.F., MX: McGraw-Hill Interamericana. Tomado de http://www.ebrary.com

Especificacionesdediseño:dibujos,gráficosuotros


UNIVERSIDAD CENTRAL DEL ECUADORFACULTAD DE FILOSOFÍA, LETRAS Y CIENCIAS DE LA EDUCACIÓN

CARRERA O PROGRAMA: EDUCACIÓN SUPERIORFICHA TÉCNICA PARA LA CONSTRUCCIÓN DE REACTIVOS

Número de pregun-ta:

3 Fecha de elaboración: 22/12/2016

DATOS DEL AUTORAPELLIDO Y

NOMBRENº DE CÉDULA ESPECIALIDAD

Borja López Yolanda Azucena

1713405767 MSc. Sistemas Informáticos

NÚCLEO ESTRUCTURANTE Tecnologías de la Información y la Comunicación


TEMA ESPECÍFICO Lenguaje Java


NIVEL TAXONÓMICO CONOCIMIENTO X COMPRESIÓN APLICACIÓN

CONSTRUCCIÓN DE LA PREGUNTAFASE Y/O INSTRUCCIÓN:En base al siguiente código de programación, determinar qué valor imprime, tomando en cuenta que n1=20, n2=15 y n3=18.ELEMENTOS (Simple)

if(n1>n2 && n1>n3) {System.out.println (n1+” es mayor”);}else{if(n2>n1 && n2>n3) {System.out.println(n2+” es mayor”);}else{System.out.println(n3+” es mayor”);}}

OPCIONES DE RESPUESTA:A) 12 es mayorB) 20 es mayorC) 18 es mayorD) No se ejecuta porque la sintaxis es incorrecta

OPCIÓN CORREC-TA

DIFICULTAD ESPERADA

B BAJA MEDIA X ALTAJustificaciónyfuentesdelaopcióncorrectaBibliografía: López, G. J. L. (2014). Programación orientada a objetos C++ y Java: un acercamiento interdiscipli-nario. México, D.F., MX: Larousse - Grupo Editorial Patria. Obtenido de http://bvirtual.uce.edu.ec:2052/lib/bgene-ralucesp/detail.action?docID=11017469Especificacionesdediseño:dibujos,gráficosuotros

REFERENCIAS BIBLIOGRÁFICAS


REFERENCIAS BIBLIOGRÁFICAS

Ceballos, S. F. J. (2009). Enciclopedia del lenguaje C++ (2a. ed.). Madrid, ES: RA-MA Edito-rial. Retrievedfrom http://www.ebrary.com Pág. 4

Cueva, L. J. M. (1998). Conceptos básicos de procesadores de lenguaje. España: SERVITEC. Retrieved from http://www.ebrary.com Pág. 81

Fernández, C. (2009).Visual Basic: básico. Madrid, ES: RA-MA Editorial. Retrieved from http://www.ebrary.com

Holzner, S. (2009). PHP: manual de referencia. México, D.F., MX: McGraw-Hill Interamerica-na. Retrieved from http://www.ebrary.com

López, G. J. L. (2014). Programación orientada a objetos C++ y Java: un acercamiento inter-disciplinario. México, D.F., MX: Larousse - Grupo Editorial Patria. Retrievedfrom http://www.ebrary.com

Vaswani, V. (2010). Fundamentos de PHP. México, D.F., MX: McGraw-Hill Interamericana. Retrieved from http://www.ebrary.comCARACTERISTICAS

Pérez, F. (2011). Ejercicios de Programación en Java. Edita Asoc. Por la Innovación Educativa Eduinnova. Pág (35).

Deitel, P. (2012). Cómo programar en java Pearson López Q, José. (2007). Domine Javascript. Editorial: RA-MA Bibliografía complementaria Juan.M, Gimeno, J, Luis.G. (2011). In-troducción a Netbeans. Recuperado de:http://ocw.udl.cat/enginyeria-i-arquitectura/pro-gramacio-2/continguts-1/1-introduccioi81n-a-netbeans.pdf.

Flórez, H. (2012). Programación orientada a objetos con Java. Recuperado de: http://bvirtual.uce.edu.ec:2341/visor/30030

PERFIL DOCENTE

MSc. Yolanda Azucena Borja López

Formación AcadémicaIngeniera Informática mención Ingeniería de Software

Escuela Politécnica NacionalMagister en Sistemas Informáticos Educativos

Universidad Tecnológica IsraelMagister en Evaluación y Auditoría de Sistemas Tecnológicos, ESPE

Experiencia LaboralDocente de la Carrera de Informática

Universidad Central del Ecuador.

PhD. Juan Carlos Cobos Velasco

Formación AcadémicaLicenciado en Ciencias de la Educación mención Informática

Universidad Central del Ecuador

Magister en Sistemas Informáticos EducativosUniversidad Tecnológica Israel

Doctor en Investigación EducativaUniversidad de Alicante

Experiencia LaboralDirector de la Carrera de Informática

Universidad Central del Ecuador.

Compendio de Lenguaje de Programación

Education