Lenguaje de programación D: katas

Dlang o D es un lenguaje de programación similar al clásico C. Mucha de su sintaxis nos recordará a dicho lenguaje. En esta entrega haremos varios ejercicios con funciones. Para instalar este lenguaje ve a este sitio:

https://dlang.org/

Si solo quieres probar el lenguaje, ve este sitio:

https://run.dlang.io/

Para compilar y ejecutar un programa en Dlang(D):

dmd programa.d

Ejercicios en Dlang

Ejercicio 1. Crear funciones para sumar, restar, multiplicar y dividir dos números enteros.

basicas.d

import std.stdio;

int sumar(int x, int y)
{
    return x + y;
}

int restar(int x, int y)
{
    return x - y;
}

int multiplicar(int x, int y)
{
    return x * y;
}

int dividir(int x, int y)
{
    if (y == 0)
    {
        return x;
    }
    return x / y;
}

void main(string[] args)
{
    int x = 45;
    int y = 21;

    int suma = sumar(x, y);
    int resta = restar(x, y);
    int producto = multiplicar(x, y);
    int division = dividir(x, y);
    writeln("\t === Operaciones aritméticas básicas ===");
    writef("La suma de %d y %d es: %d\n", x, y, suma);
    writef("La resta de %d y %d es: %d\n", x, y, resta);
    writef("La multiplicación de %d y %d es: %d\n", x, y, producto);
    writef("La división de %d y %d es: %d\n", x, y, division);
}

D nos permite crear funciones "tipo flecha", por lo que podemos editar el código y quedaría de la siguiente manera:

import std.stdio;

int sumar(int x, int y)=> x+y;

int restar(int x, int y)=>x-y;

int multiplicar(int x, int y)=>x*y;

int dividir(int x, int y)=>y==0?0:x/y;

void main(string[] args)
{
    int x = 45;
    int y = 21;

    int suma = sumar(x, y);
    int resta = restar(x, y);
    int producto = multiplicar(x, y);
    int division = dividir(x, y);
    writeln("\t === Operaciones aritméticas básicas ===");
    writef("La suma de %d y %d es: %d\n", x, y, suma);
    writef("La resta de %d y %d es: %d\n", x, y, resta);
    writef("La multiplicación de %d y %d es: %d\n", x, y, producto);
    writef("La división de %d y %d es: %d\n", x, y, division);
}

Ejercicio 2. Programa que calcule el factorial de un número entero.

factorial.d

import std.stdio;

int factorial(int num)
{
    if (num == 0)
    {
        return 1;
    }
    return num * factorial(num - 1);
}

void main(string[] args)
{
    int numero = 6;
    writeln("\t === Factorial de un número ===");
    writef("El factorial de %d es: %d\n", numero, factorial(numero));
}

El clásico programa del Factorial de un número en Dlang.

Ejercicio 3. Crear un programa que divida un número entre 2. Si el resultado del residuo de esa división es 0, el programa terminará. En otro caso el programa se ciclará.

ciclar.d

import std.stdio;

void mientras(int num)
{
    const int MAX = 100;
    while(num  < MAX ){
        writef("Número : %d\n", num);
        if(num%2==0){
            break;
        }else{
           continue;
        }
        ++num;
    }
}

void main(string[] args)
{
    int numero = 8;
    mientras(numero);
}

La entrada es 8. Si se divide entre 2 dará un residuo de 0 y entonces el programa terminará. Si fuese un número cuya división diera un residuo distinto de 0, entonces el programa se ciclará (un ciclo infinito). Será necesario matar el proceso.

Nota: El operador continue es una instrucción que se utiliza en programación para omitir la iteración actual de un bucle y pasar a la siguiente. En este caso, provocará que se muestre constanteente la entrada que no termina el ciclo, creando un ciclo infinito. Este ejercicio solo es didáctico y no tiene otro propósito.

Ejercicio 4. Este es un ejercicio propuesto en la página de Project Euler:

Si enumeramos todos los números naturales menores de 10 que sean múltiplos de 3 o 5, obtenemos 3, 5, 6 y 9. La suma de estos múltiplos es 23. Halla la suma de todos los múltiplos de 3 o 5 menores de 1000.

multiplos3o5.d

void main()
{
    import std.stdio : writefln;
    const MAX = 1000;
    int counter = 1;
    int suma = 0;
    while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           writefln("Suma = %d, Counter: %d",suma,counter);
        }
        ++counter;
    }
    writefln("Suma final= %d",suma);
}

Como detalles:

// Se puede crear una constante de esta forma:
const int MAX = 1000;

// Y de esta:
const MAX = 1000;

Además podemos hacer importaciones desde el cuerpo del método principal del programa (main).

Ejercicio 5. Crear una clase llamada Punto con propiedades x, y de tipo ``int``. Agregaremos una clase hija denominada PuntoColor, con un campo color de tipo ``string``.

clases.d

 import std.stdio : writeln;

void main()
{    
    Punto myPunto = new Punto(3,4);
    writeln("x:", myPunto.x);
    writeln("y:", myPunto.y);
    PuntoColor myPuntoColor = new PuntoColor("Rojo");
    writeln("color:", myPuntoColor.color);
}

class Punto{
   public int x;
   public int y;
    
   
    this(int x, int y) {
        writeln("Se ha creado una instancia de la clase Punto");
        this.x = x;
        this.x = x;
    }
}

class PuntoColor: Punto{
   public string color;
    this(string color){
      super(0,0);
      writeln("Se ha creado una instancia de la clase PuntoColor");
      this.color = color;
    }
}

Dlang es un lenguaje de programación que ha aprendido de los errores y aciertos de otros lenguajes como C, Java y C++, entre otros más.

Hasta otra entrega más.

Enlaces:

https://codemonkeyjunior.blogspot.com/2024/06/el-lenguaje-de-programacion-d.html
https://projecteuler.net/