JUEGO AHORCADO

import ddf.minim.*;
import processing.serial.*;
import cc.arduino.*;
import org.firmata.*;

Arduino placa;
String puerto = "COM4";

boolean ahorcado = false, cabeza = false, cuerpo = false;
boolean brazo1 = false, brazo2 = false, pierna1 = false, pierna2 = false;
boolean ganador = false, perdedor = false, contError = false, contBuenas;
int cont = 0, cont2=0, contled = 0, contOpor = 6;
String caracter;
String cadena = "";
String cadena2;
char[] palabra;
char[] recolect;

Minim soundengine;
AudioSample sonido;

void setup(){
  size(1070,450);
  soundengine = new Minim(this);
  sonido = soundengine.loadSample("1234.mp3",1024);
  
  printArray(Arduino.list());
  placa = new Arduino(this, puerto, 57600);
  placa.pinMode(1, Arduino.OUTPUT);
  placa.pinMode(2, Arduino.OUTPUT);
  placa.pinMode(3, Arduino.OUTPUT);
  placa.pinMode(4, Arduino.OUTPUT);
  placa.pinMode(5, Arduino.OUTPUT);
  placa.pinMode(6, Arduino.OUTPUT);
  placa.pinMode(7, Arduino.OUTPUT);
  placa.pinMode(8, Arduino.OUTPUT);
  placa.pinMode(9, Arduino.OUTPUT);
  placa.pinMode(10, Arduino.OUTPUT);
  placa.pinMode(11, Arduino.OUTPUT);
  placa.pinMode(12, Arduino.OUTPUT);
  
  String[] words = {"Computador", "Ingenieria", "Memoriaram", "Processing" ,"Protoboard", "Arduinouno","Compuertas","Procesador","Analogicos","Servomotor"};
  int index = int (random (words.length ));
  caracter = words[index];
  palabra = new char[caracter.length()];
  recolect = new char[caracter.length()];
  for ( int j = 0 ; j < caracter.length() ; j++ ){
    palabra[j] = caracter.charAt(j);
  }
}
void draw(){
  fill(125,12,33);
  noStroke();
  rect(0,0,height*5,height);
  fill(12,22,34);
  rect(100,30,20,250);
  rect(100,30,230,20);
  rect(50,260,120,20);
  fill(12,22,34);
  rect(0,340,height*5,width);
  fill(200,12,89);
  rect(300,50,1,50);
  /*1*/rect(45,400,80,5);
  /*2*/rect(145,400,80,5);
  /*3*/rect(245,400,80,5);
  /*4*/rect(345,400,80,5);
  /*5*/rect(445,400,80,5);
  /*6*/rect(545,400,80,5);
  /*7*/rect(645,400,80,5);
  /*8*/rect(745,400,80,5);
  /*9*/rect(845,400,80,5);
  /*10*/rect(945,400,80,5);
  // Palabras
  textSize(50);
  text(palabra[0],65,400);
  text(recolect[1],165,400);
  text(recolect[2],265,400);
  text(recolect[3],365,400);
  text(recolect[4],465,400);
  text(recolect[5],565,400);
  text(recolect[6],665,400);
  text(recolect[7],765,400);
  text(recolect[8],865,400);
  text(recolect[9],965,400);
  // ahorcado
  if (cabeza){
    fill(#ffffff);
    ellipse(300,130,70,70);
    stroke(0);
    strokeWeight(3);
    line(285,118,295,123);
    line(295,118,285,123);
    line(305,118,315,123);
    line(315,118,305,123);
    line(285,140,315,140);
    noStroke();
  }
  if (cuerpo){
    stroke(#ffffff);
    strokeWeight(30);
    line(300,180,300,210);
    noStroke();
  }
  if (brazo1){
    stroke(#ffffff);
    strokeWeight(10);
    line(280,180,276,200);
    noStroke();
  }
  if (brazo2){
    stroke(#ffffff);
    strokeWeight(10);
    line(320,180,324,200);
    noStroke();
  }
  if (pierna1){
    stroke(#ffffff);
    strokeWeight(10);
    line(295,230,293,260);
    noStroke();
  }
  if (pierna2){
    stroke(#ffffff);
    strokeWeight(10);
    line(305,230,307,260);
    textSize(70);
    noStroke();
  }
  if (ganador){
    textSize(70);
    fill(166,50,125);
    text("Has ganado",500,200);
    sonido.trigger();
  }
  if (perdedor){
    text("Ahorcado",500,200);
  }
  if (contError){
    textSize(20);
    text("Errores : " + cont,500,50);
  }
  if (contBuenas){
    textSize(20);
    text("Aciertos : " + contled,703,70);
  }
  textSize(20);
  text("Oportunidades : " + contOpor,500,70);
  stroke(#7C4728);
  strokeWeight(20);
  line(113,218,155,268);
  line(108,218,65,268);
  line(113,103,185,43);
  noStroke();
}
void keyPressed(){
  if (perdedor){
    key= ' ';
  }
  else{
  if ((key+"").matches("[A-z]*")){
    cadena = cadena + key;
    letras();
  }
  else{
    println("Caracter incorrecto");
    contOpor = contOpor -1;
  }
  }
}
public void letras(){
  recolect[0] = palabra[0];
  if (cadena.length() < 10){
    for (int i = 0; i <= cadena.length() - 1; i++){
      recolect[i+1] = cadena.charAt(i);
      if (cadena.length() == 9){
        ganador = true;
      }
    }
    cadena2 = palabra[0] + cadena;
    for (int h = 0; h <= cadena.length(); h++){
      if (palabra[h] == recolect [h]){
        ahorcado = false;
      }
      else{
        ahorcado = true;
      }
    }
    partesDelCuerpo();
  }
}
void partesDelCuerpo(){
  if (ahorcado){
    recolect[cadena.length()] = ' ';
    cadena = cadena.substring(0,cadena.length()-1);
    cont++;
    contOpor = contOpor -1;
    contError = true;
    if (cont >= 1){
      cabeza = true;
      println("Dibujando la cabeza");
      placa.analogWrite(11,58);
    }
    if (cont >= 2){
      cuerpo = true;
      println("Dibujando cuerpo");
      placa.analogWrite(11,84);
    }
    if (cont >= 3){
      brazo1 = true;
      println("Dibujando el brazo 1");
      placa.analogWrite(11,112);
    }
    if (cont >= 4){
      brazo2 = true;
      println("Dibujando el brazo 2");
      placa.analogWrite(11,140);
    }
    if (cont >= 5){
      pierna1 = true;
      println("Dibujando la pierna 1");
      placa.analogWrite(11,224);
    }
    if (cont >= 6){
      pierna2 = true;
      perdedor = true;
      println("Dibujando la pierna 2");
      placa.analogWrite(11,255);
    }
  }
  else{
    contled++;
    contBuenas = true;
    placa.digitalWrite(1,Arduino.HIGH);
    if (contled >= 1){
      placa.digitalWrite(2,Arduino.HIGH);
      placa.digitalWrite(3,Arduino.HIGH);
    }
    if (contled >= 2){
      placa.digitalWrite(4,Arduino.HIGH);
    }
    if (contled >= 3){
      placa.digitalWrite(5,Arduino.HIGH);
    }
    if (contled >= 4){
      placa.digitalWrite(6,Arduino.HIGH);
    }
    if (contled >= 5){
      placa.digitalWrite(7,Arduino.HIGH);
    }
    if (contled >= 6){
      placa.digitalWrite(8,Arduino.HIGH);
    }
    if (contled >= 7){
      placa.digitalWrite(9,Arduino.HIGH);
    }
    if (contled >= 8){
      placa.digitalWrite(10,Arduino.HIGH);
    }
    if (contled >= 9){
      placa.digitalWrite(12,Arduino.HIGH);
    }
  }
}

Introducción al Modelo de Programación Funcional

En ciencias de la computación, la programación funcional es un paradigma de programación declarativa basado en la utilización de funciones aritméticas que no maneja datos mutables o de estado. Enfatiza la aplicación de funciones, en contraste con el estilo de programación imperativa, que enfatiza los cambios de estado. La programación funcional tiene sus raíces en el cálculo lambda, un sistema formal desarrollado en los 1930s para investigar la definición de función, la aplicación de las funciones y la recursión. Muchos lenguajes de programación funcionales pueden ser vistos como elaboraciones del cálculo lambda.

Los lenguajes de programación funcional, especialmente los que son puramente funcionales, han sido enfatizados en el ambiente académico principalmente y no tanto en el desarrollo de software comercial. Sin embargo, lenguajes de programación importantes tales como Scheme, Erlang, Objective Caml y Haskel, han sido utilizados en aplicaciones comerciales e industriales por muchas organizaciones. La programación funcional también es utilizada en la industria a través de lenguajes de dominio específico como R (estadística), Mathematica (matemáticas simbólicas), J y K (análisis financiero), F# en Microsoft.NET y XSLT (XML). Lenguajes de uso específico usados comúnmente como SQL y Lex/Yacc, utilizan algunos elementos de programación funcional, especialmente al procesar valores mutables. Las hojas de cálculo también pueden ser consideradas lenguajes de programación funcional.

La programación funcional también puede ser desarrollada en lenguajes que no están diseñados específicamente para la programación funcional. En el caso de Perl, por ejemplo, que es un lenguaje de programación imperativo, existe un libro que describe cómo aplicar conceptos de programación funcional. JavaScript, uno de los lenguajes más ampliamente utilizados en la actualidad, también incorpora capacidades de programación funcional.

Funciones

Las funciones se crearon para evitar tener que repetir constantemente fragmentos de código. Una función podría considerarse como una variable que encierra código dentro de sí. Por lo tanto cuando accedemos a dicha variable (la función) en realidad lo que estamos es diciendo al programa que ejecute un determinado código predefinido anteriormente.

Todos los lenguajes de programación tienen algunos elementos de formación primitivos para la descripción de los datos y de los procesos o transformaciones aplicadas a estos datos (tal como la suma de dos números o la selección de un elemento que forma parte de una colección). Estos elementos primitivos son definidos por reglas sintácticas y semánticas que describen su estructura y significado respectivamente.

Disciplina Tipos

DISCIPLINA: Es la coordinación de actitudes con las cuales se instruye para desarrollar habilidades, o para seguir un determinado código de conducta u "orden". Un ejemplo es la enseñanza de una materia, ciencia o técnica, especialmente la que se enseña en un centro (Docente – asignatura).

En los lenguajes de programación con disciplina de tipos, cada tipo representa una colección de valores (datos) similares. Una función cuyo tipo  sea A1 -> ... An -> espera n parámetros con tipos A1, ... An y devuelve un resultado de tipo R.  El conocer los tipos de las funciones ayuda a documentar los programas y a evitar errores en tiempo de ejecución.

Disciplina estática de tipos: Los programas bien tipados se pueden reconocer en tiempo de compilación, un programa bien tipado se puede utilizar sin efectuar comprobaciones de tipo en tiempo de ejecución. Estando garantizado que no se producirán errores de tipo durante el cómputo.

Tipos de Datos

Tipos de Datos En lenguajes de programación un tipo de dato es un atributo de una parte de los datos que indica al ordenador (y/o al programador) algo sobre la clase de datos sobre los que se va a procesar.

Los Tipos de Datos En un sentido amplio, un tipo de datos define un conjunto de valores y las operaciones sobre estos valores. Casi todos los lenguajes de programación explícitamente incluyen la notación del tipo de datos, aunque lenguajes diferentes pueden usar terminología diferente. La mayor parte de los lenguajes de programación permiten al programador definir tipos de datos adicionales, normalmente combinando múltiples elementos de otros tipos y definiendo las operaciones del nuevo tipo de dato. Por ejemplo, un programador puede crear un nuevo tipo de dato llamado "Persona" que especifica que el dato interpretado como Persona incluirá un nombre y una fecha de nacimiento.

Los datos mas basicos para cualquier problema de programacion son los valores numericos y booleanos, como criterio general hay que tener en cuenta todos los tipos numericos existentes en Haskell, asi como el tipo de los booleanos, son ejemplares de la clase de tipos Eq, Ord, Read y Show, en particular, las operaciones de comparacion (==), (/=), (<), (>=) y (>) y se puden utilizar para comparar valores de cualquier tipo numerico, asi como valores booleanos. las funciones max y min tambien se pueden aplicar a valores de todos estos tipos.

Numeros enteros.

En Haskell existen dos tipos de numeros enteros: el tipo Int de los enteros de precision limitada, y el tipo Interger de los enteros de precision arbitraria.

DIAGRAMA DE FLUJO DE PROBLEMA DE PITAGORAS

https://www.lucidchart.com/documents/edit/60909409-2b88-4ab1-9751-1e8e9d5cc9cb#

1.2 EVALUACIÓN DE EXPRESIONES

1.2 EVALUACIÓN DE EXPRESIONES

     Una expresión es una combinación de operandos y operadores. La evaluación de una expresión consiste en reducirla, esto es, realizar todas las operaciones contenidas en ella para obtener un valor final.

   

 Para evaluar una expresión es necesario conocer la prioridad de los operadores, con lo cual se puede determinar cuál operación se va a realizar antes que las demás.

  

 Una expresión entre paréntesis se evalúa primero que las demás. Si hay paréntesis se evalúa primero la expresión contenida en los paréntesis más internos....