domingo, 8 de mayo de 2022

Katas en programación (un solo programa en distintos lenguajes)

 

En este post crearemos un mismo programa usando lenguajes como Java, Elixir, Erlang, Javscript, Perl, Python y otros más.

Ejercicio. Crear tres funciones:

  • Función 1 para calcular  1.8 * numero, donde numero es la variable con el valor que introduce el usuario.
  • Función 2 para calcular 1000 + (x + y), donde x & y son las variables que contendrán los valores que introducirá el usuario.
  • Función 3 para calcular la suma de x+y+z

Código en Perl

 funciones.pl

#!/usr/bin/perl

use strict;
use warnings;
use constant MAX => 1000;
use constant VALOR => 1.8;

my($x,$y,$z);

$x=3;
$y=2;
$z=4;

print "Datos:\nx=",$x,", y=",$y,", z=",$z,"\n";


sub func1{
  return VALOR * $_[0];
}

sub func2{
  return MAX +($_[0]+$_[1]);
}

sub func3{
  return $_[0]+$_[1]+$_[2];
}

print "Resultado 1: ",func1($x),"\n";
print "Resultado 2: ",func2($y,$z),"\n";
print "Resultado 3: ",func3($x,$y,$z),"\n";

 

Código en Erlang

funciones.erl

-module(funciones).
-author("Codemonkey Junior").
-version("1.0.0").
-export([func1/1,func2/2,func3/3]).
-define(MAX,1000).
-define(VALOR,1.8).

func1(X)-> X*?VALOR.

func2(X,Y)-> ?MAX +(X+Y).

func3(X,Y,Z)-> X+Y+Z. 

Funcionando:

1> c(funciones).
{ok,funciones}
2> funciones:func1(3).
5.4
3> funciones:func2(3,9).
1012
4> funciones:func3(3,9,9).
21
5> 

Código en Elixir

funciones.exs

defmodule Constante do
  def mMAX, do: 1000
  def mVALOR, do: 1.8
end


x=2
y=4
z=5

IO.puts "Datos:\n x= #{x}, y= #{y}, z= #{z}"

func1 = fn (num) -> Constante.mVALOR*num end
func2 = fn (a,b) -> Constante.mMAX+(a+b) end
func3 = fn (a,b,c) -> a+b+c end

result1 = func1.(x)
result2 = func2.(z,y)
result3 = func3.(x,y,z)

IO.puts "Resultado 1: #{result1}"
IO.puts "Resultado 2: #{result2}"
IO.puts "Resultado 3: #{result3}"
 
Código en C#

Funciones.cs

using System;
        
public class Funciones
{

  public static readonly int MAX = 1000;
  public static readonly double VALOR = 1.8;


  public static double Func1(int num)
  {
    return VALOR * num;
  }

  public static int Func2(int x, int y)
  {
    return MAX +(x+y);
  }

  public static int Func3(int x, int y, int z)
  {
    return x+y+z;
  }

  public static void Main()
  {
    Console.WriteLine("Resultado 1: {0}",Func1(3));
    Console.WriteLine("Resultado 2: {0}",Func2(4,7));
  }

}

 

Código en C

funciones.c

#include<stdio.h>
#define VALOR 1.8
#define MAX 1000

int func1(int);
int func2(int,int);
int func3(int,int,int);


int func1(int num){
  return VALOR*num;
}

int func2(int x,int y){
  return MAX +(x+y);
}

int func3(int a,int b,int c){
  return a+b+c;
}

int main(int argc, char *argv[]){
  printf("Resultado 1:%d\n",func2(4,3));
  printf("Resultado 2:%d\n",func1(2));
  printf("Resultado 3:%d\n",func3(2,5,6));
  return 0;
}

Enlaces:

https://es.wikipedia.org/wiki/Kata_(programaci%C3%B3n)

Elixir iex, understanding the REPL (vídeo en Inglés)

Getting Started with Phoenix (vídeo en Inglés)

Traducción:

Este episodio es un tutorial simple que demuestra lo fácil que es comenzar a usar Phoenix.  

En él, crearemos una aplicación de blog simple con publicaciones. Ver más en https://elixircasts.io


Enlaces:

https://elixircasts.io
https://elixirdigest.net/
https://www.phoenixframework.org/
https://elixirschool.com/en/
https://elixir-lang.org/
https://joyofelixir.com/

sábado, 30 de abril de 2022

Katas de programación en Erlang

Katas propuestas

1. Crear un programa que convierta pulgadas a centímetros y viceversa.

2. Crear un programa que convierta grados celsius a fahrenheit y viceversa.

3. Crear un programa que sume únicamente los números pares de una lista cualquiera.

4. Si enumeramos todos los números naturales debajo de 10 que son múltiplos de 3 o 5, obtenemos 3, 5, 6 y 9. La suma de estos múltiplos es 23. Encuentra la suma de todos los múltiplos de 3 o 5 por debajo de 1000.

Nota: Este último ejemplo viene de la página de Project Euler

 

Recordando...

Los tipos de programación se pueden dividir en:

1. Programación Imperativa: Donde se describen, paso a paso, las instrucciones necesarias para resolver el problema.
2. Programación Declarativa: Donde se describe el problema que tenemos que solucionar pero no el cómo hacerlo.

En este último entran lenguajes como Haskell, Erlang y/o Elixir. Lenguajes de paradigma funcional. Donde se definen funciones similares a las funciones matemáticas.

 

 

Código en Erlang

conversiones.erl

%% Operaciones con Erlang
-module(conversiones).
-author("Codemonkey Junior").
-export([cent/1,pulg/1]).
-compile(nowarn_export_all).

pulg(N)-> N/2.54.
cent(N)-> N*2.54.

Salida:

$ erl
> conversiones:pulg(4).
1.574803149606299
> conversiones:cent(1.574803149606299).
3.9999999999999996

conversion_grados.erl

%% Operaciones con Erlang
-module(conversion_grados).
-author("Codemonkey Junior").
-export([fahr/1,cels/1]).
-compile(nowarn_export_all).


% De Celsius a Fahrenheit
fahr(N)-> (1.8*N)+32.

% De Fahrenheit a Celsius
cels(N)-> (N-32)/1.8.

Salida:

$ erl
 > c(conversion_grados).
 > conversion_grados:fahr(34.8).
   94.64
 > conversion_grados:cels(94.64).
   34.8

Tip: Para obtener más información de un módulo podemos teclear:

$ erl
> c(programa).
> programa:module_info().

Donde la función module_info() nos lista la información del programa o módulo.

$ erl
> c(programa).
> programa:module_info().
[{module,programa},
 {exports,[{start,0},
           {suma,2},
           {resta,2},
           {fahr,1},
           {cels,1},
           {factorial,1},
           {combinatorio,2},
           {pulg,1},
           {cent,1},
           {mcd,2},
           {module_info,0},
           {module_info,1}]},
 {attributes,[{vsn,[276758998827383991874529587796040092315]},
              {author,"Codemonkey Junior"}]},
 {compile,[{version,"8.1"},
           {options,[]},
           {source,"/home/codemonkey/Documentos/pruebasErlang/programa.erl"}]},
 {md5,<<208,53,216,37,125,14,40,139,135,22,83,244,140,34,
        10,155>>}]

suma_multiplos.erl

Este programa se verá en el siguiente post.


 Au revoir!!

Enlaces:

https://projecteuler.net/archives
https://erlangbyexample.org
https://learnyousomeerlang.com

 

domingo, 13 de marzo de 2022

Katas de programación en C [2da parte]

"Santos remolinos Batman, éste martini tiene un sabor que no logro identificar"

 

En el anterior post realizamos algunos ejercicios de programación en C. En ésta ocasión continuaremos con los ejercicios.

Ejemplo 1. Obtener el número binario de un número decimal mayor a cero.

binario.c

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#define MAX 100

int main(int argc, char *argv[]){
  char binario[MAX];
  int decimal;
  int residuo;
  char c;
  do{
    puts("Introduce numero decimal:");
    scanf("%d",&decimal);
  }while(decimal <= 0);
  printf("Decimal: %d\n",decimal);

  while(decimal >= 2){
    residuo = decimal % 2;
    decimal = (int) decimal/2;
    c = (char)residuo+'0';
    strcat(binario, &c);
  }
  c = (char)decimal+'0';
  strcat(binario, &c);
  char binarioFinal[MAX];
  int i, j,k;
  for(i=0; binario[i] != '\0'; i++ );
    j=i-1;
    for(k=0; k<=i; k++){
        binarioFinal[k]=binario[j];
        j--;
    }
    printf("Binario final:%s\n",binarioFinal);
  return 0;
}

En éste ejemplo podemos ver la descomposición de un número decimal a su forma binaria (0,1). Obtenemos el residuo de la división (%) y lo vamos almacenando en una cadena string, incluimos el último dígito decimal, para al final mostrar la cadena final (en reversa). Ej. Si el número introducido es 3 deberá mostrar su equivalente en binario que sería: 11.

Compilamos y creamos el ejecutable.

$ gcc binario.c -o ejecutable.exe

$ ./ejecutable.exe

Ejemplo 2. Crear un programa que tome dos números enteros mayores a cero que realice las seis operaciones básicas de la aritmética: suma, resta, multiplicación(producto) , división, potenciación y radicación.

matematicas.c

#include<stdio.h>
#include<stdlib.h>
#include<ctype.h>
#include<math.h>

int suma(int,int);
int resta(int,int);
int producto(int,int);
double division(int,int);
double potencia(double, int);
int radicacion(int);

int suma(int a, int b){
  return a+b;
}

int resta(int a, int b){
  return a-b;
}

int producto(int a, int b){
  return a*b;
}

double division(int a,int b){
  return (double) a/b;
}

double potencia(double b, int p){
  int i = 1;
  double pot = 1.0;
  while(i <= p){
    pot = pot * b;
    i++;
  }
  return pot;
}

int radicacion(int a){
  return sqrt((double) a);
}

int main(int argc, char *argv[]){
  int a = 0, b = 0, mySuma = 0, myResta = 0, myProd = 0;
  double myDiv = 0.0, myPot = 0.0;
  do{
    system("clear");
    puts("Introduce dos numeros enteros mayor a cero:");
    printf("a = %d y b = %d\n",a,b);
    scanf("%d %d",&a,&b);
  }while(a <= 0 || b <= 0);
  printf("Numeros introducidos: a=%d y b=%d\n",a,b);
  mySuma = suma(a,b);
  myResta = resta(a,b);
  myProd = producto(a,b);
  myDiv = division(a,b);
  myPot = potencia((double) a,b);
  printf("Suma = %d\n",mySuma);
  printf("Resta = %d\n",myResta);
  printf("Producto = %d\n",myProd);
  printf("Division = %.3lf\n",myDiv);
  printf("Potencia = %.0lf\n",myPot);
  printf("Raiz de  a = %d es: %d\n",a, radicacion(a));
  printf("Raiz de  b = %d es: %d\n",b, radicacion(b));
  return 0;
}

Creamos seis cabeceras y sus implementaciones (funciones) para realizar las operaciones aritméticas básicas. Obligamos a introducir dos número enteros positivos. Si algún número es cero el bucle do-while continuará hasta que los dos números sean mayores a cero.

Para poder compilar y crear el ejecutable (esto si usas GCC):

$ cc matematicas.c -lm -o ejecutable.exe 

Ejemplo 3. Crear un programa que tome tres parámetros, dos decimales y un operador (+, -, x, / , %) para realizar las operaciones de: suma, resta, producto, división y resto/residuo. 

operador.c

#include<stdio.h>
#include<ctype.h>
#include<curses.h>
#include<string.h>
#include<stdlib.h>

int operacion(int, int, char);

int operacion(int a, int b, char opc){
  int resultado = 0;
  if(opc == '+'){
    puts("\tSuma");
    resultado = a+b;
  }

  if(opc == '-'){
    puts("\tResta");
    resultado = a-b;
  }

  if(opc =='x'){
    puts("\tProducto");
    resultado = a*b;
  }

  if(opc == '/'){
    puts("\tDivision");
    if(b <= 0){
      resultado = a;
    }else{
      resultado = a/b;
    }
  }

  if(opc == '%'){
    puts("\tResiduo");
    resultado = a%b;
  }
  
  return resultado;
}

int main(int argc, char *argv[]){
  if(argc >= 3){
    int a = atoi(argv[1]);
    int b = atoi(argv[2]);
    char c = argv[3][0]; // tomar el primer caracter de la fila 3, columna 0
    printf("Entrada \t a = %d b = %d , operador: %c\n",a,b,c);
    printf("Resultado: %d\n",operacion(a,b,c));
  }else{
    puts("\tDebes introducir tres argumentos: num1 num2 operador\n");
  }
  return 0;
}

Compilar y ejecutar:

$ gcc operador.c -o ejecutable.exe
$ ./ejecutable.exe 2 3 +
    Suma
Resultado: 5

Enlaces:

http://codemonkeyjunior.blogspot.com/2021/08/vale-la-pena-aprender-c-y-o-c.html

sábado, 19 de febrero de 2022

Katas de programación en C

En esta ocasión haremos un pequeño programa dividido en tres archivos:

  1. Programa principal: main.c
  2. Librería o macro: pulsaciones.h
  3. Implementación de librería: pulsaciones.c

pulsaciones.h

#ifndef PULSACIONES_H
#define PULSACIONES_H


#endif

En este archivo definiremos las cabeceras de la función que calculará el número de pulsaciones. Para esto definiremos un tipo de datos tipo int el que denominaremos Entero y un tipo definido de tipo float llamado Flotante.

pulsaciones.h

#ifndef PULSACIONES_H
#define PULSACIONES_H

typedef int Entero;
typedef float Flotante;

#endif

Además agregaremos un encabezado para poder usar las funciones de E/S (print, puts, etc.) y una constante con valor 10

pulsaciones.h

#ifndef PULSACIONES_H
#define PULSACIONES_H
#define TAM 10
#include<stdio.h>

typedef int Entero;
typedef float Flotante;

Flotante getPulsaciones(Entero, Entero);

#endif

En el siguiente archivo definiremos la implementación de la función getPulsaciones, la cual recibe dos variables tipo Entero (int) y devolverá un tipo Flotante (float).

pulsaciones.c

#include "pulsaciones.h"

Flotante getPulsaciones(Entero edad, Entero sexo){
    Flotante resultado = 0.0f;
    switch(sexo){
        case 1:
        puts("Sexo: Femenino");
        resultado = (220-edad)/TAM;
        break;
        case 2:
        puts("Sexo: Masculino");
        resultado = (210-edad)/TAM;
        break;
        default: 
        puts("Sexo y edad: Undefined");
        resultado = 0.0f;
        break;
    }
    return resultado;
}

Como se puede observar es necesario importar el archivo "pulsaciones.h" para poder implementar la función "getPulsaciones". Los datos de entrada son: sexo y edad. Las fórmulas para obtener las pulsaciones de acuerdo al sexo son las siguientes:

"Sexo: Femenino"
(220-edad)/10
     
"Sexo: Masculino"
(210-edad)/10
        

main.c

#include "pulsaciones.c"

Entero edad = 0;
Entero sexo = 0;

int main(){
    puts("\t ====== [ Pulsaciones ] ======");
    puts("Introduce sexo [1. Femenino   2. Masculino] :");
    scanf("%d",&sexo);
    puts("Introduce edad:");
    scanf("%d",&edad);
    printf("%.3f\n",getPulsaciones(edad, sexo));
    return 0;
}
        

Compilamos y creamos ejecutable:

$ gcc main.c -o ejecutable.exe

Ejecutamos el programa:

$ ./ejecutable.exe
	 ====== [ Pulsaciones ] ======
Introduce sexo [1. Femenino   2. Masculino] :
2
Introduce edad:
45
Sexo: Masculino
16.000

Enlaces:

https://pseudocodigoejemplos.com/calcular-el-numero-de-pulsaciones-que-debe-tener-una-persona/

lunes, 20 de diciembre de 2021

Erlang: construir aplicaciones Erlang con Rebar3

Rebar3 es una herramienta que permite crear aplicaciones Erlang. Para instalarlo puedes seguir este link: http://rebar3.org/docs/getting-started/

Abrimos una terminal y tecleamos:

$ rebar3 new app auditor
===> Writing auditor/src/auditor_app.erl
===> Writing auditor/src/auditor_sup.erl
===> Writing auditor/src/auditor.app.src
===> Writing auditor/rebar.config
===> Writing auditor/.gitignore
===> Writing auditor/LICENSE
===> Writing auditor/README.md

Nos ubicamos en el directorio:

$ cd auditor
$ tree
.
├── LICENSE
├── README.md
├── rebar.config
└── src
    ├── auditor.app.src
    ├── auditor_app.erl
    └── auditor_sup.erl

Con esto tendremos nuestra primera aplicación creada con Rebar3.

exit()->
   io:fwrite("Hasta la próxima!!!\n").

Enlaces:
https://medium.com/erlang-central/building-your-first-erlang-app-using-rebar3-25f40b109aad
https://rebar3.readme.io/
https://adoptingerlang.org/docs/development/otp_applications/