Mostrando entradas con la etiqueta euler. Mostrar todas las entradas
Mostrando entradas con la etiqueta euler. Mostrar todas las entradas

sábado, 7 de diciembre de 2024

Un programa en varios lenguajes de programación (2da parte)

En una entrega anterior vimos como resolver un ejercicio de programación (determina si una cadena de caracteres tiene una longitud distinta de 0) usando diversos lenguajes de programación.

Para probar estos ejemplos puedes ir a este sitio:

https://codapi.org/

En está ocasión resolveremos el siguiente problema:

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.

Un ejercicio propuesto en la página de Project Euler: https://projecteuler.net/

En Dlang:

multipos3o5.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);
}

En C:

multiplos3o5.c

#include <stdio.h>
const int MAX = 1000;

int main() {
    int counter = 1;
	int suma = 0;
    
	 while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           printf("Suma = %d, Counter: %d\n",suma,counter);
        }
        ++counter;
    }
	printf("Suma final = %d\n",suma);
    return 0;
}

En Python:

multiplos3o5.py

MAX = 1000;
counter = 1
suma = 0
while counter < MAX:
    if counter%3== 0 or counter%5==0:
        print(f"Suma: {suma}, Counter: {counter}")
        suma = suma + counter
    counter = counter + 1   
print(f"Suma final: {suma}")

En Java:

Multiplos3o5.java

package com.test.main;

public class Main {
    public static final int MAX = 1000;
    public static void main(String[] args) {
        int counter = 1;
        int suma = 0;
        while(counter < MAX){
            if(counter%3==0 ||counter%5==0){
                suma+=counter;
                System.out.printf("Suma: %d, Counter: %d\n",counter,suma);
            }
            ++counter;
        }
        System.out.printf("Suma final: %d\n",suma);
    }
}

En Javascript:

multiplos3o5.js

const MAX = 1000;
let counter = 1;
let suma = 0;
    
	while(counter < MAX){
        if(counter%3==0 || counter%5==0){
           suma+=counter;
           console.log(`Suma = ${suma}, Counter: ${counter}`);
        }
        ++counter;
    }
	console.log(`Suma final = ${suma}`);

En Clojure:

multiplos3o5.clj

(def MAX 1000)

(defn calcular-suma []
  (loop [counter 1 suma 0]
    (if (< counter MAX)
      (if (or (zero? (mod counter 3)) (zero? (mod counter 5)))
        (do
          (println "Suma:" suma ", Counter:" counter)
          (recur (inc counter) (+ suma counter)))
        (recur (inc counter) suma))
      (do
        (println "Suma final:" suma)
        suma))))

(calcular-suma)

Clojure es un lenguaje muy distinto a la mayoría. Como emplea la misma sintaxis de LISP, el cual es un lenguaje orientado a expresiones.

En Ada Language Programming:

multiplos3o5.adb

with Ada.Text_IO; use Ada.Text_IO;
with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

procedure Suma_Multiplos is
   MAX     : constant Integer := 1000;
   Counter : Integer := 1;
   Suma    : Integer := 0;
begin
   while Counter < MAX loop
      if (Counter mod 3 = 0) or (Counter mod 5 = 0) then
         Put_Line("Suma: " & Integer'Image(Suma) & ", Counter: " & Integer'Image(Counter));
         Suma := Suma + Counter;
      end if;
      Counter := Counter + 1;
   end loop;

   Put_Line("Suma final: " & Integer'Image(Suma));
end Suma_Multiplos;

En Rust:

multiplos3o5.rs

fn main() {
    const MAX: i32 = 1000;
    let mut counter = 1;
    let mut suma = 0;

    while counter < MAX {
        if counter % 3 == 0 || counter % 5 == 0 {
            suma += counter;
            println!("Suma = {}, Counter: {}", suma, counter);
        }
        counter += 1;
    }

    println!("Suma final = {}", suma);
}

En Odin:

multiplos3o5.odin

package main

import "core:fmt"

MAX :: 1000;

main :: proc() {
    counter: int = 1;
    suma: int = 0;

    for counter < MAX {
        if counter % 3 == 0 || counter % 5 == 0 {
            suma += counter;
            fmt.printf("Suma = %d, Counter: %d\n", suma, counter);
        }
        counter += 1;
    }

    fmt.printf("Suma final = %d\n", suma);
}

En Go:

multiplos3o5.go

package main

import "fmt"

func main() {
    const MAX = 1000
    counter := 1
    suma := 0

    for counter < MAX {
        if counter%3 == 0 || counter%5 == 0 {
            suma += counter
            fmt.Printf("Suma = %d, Counter = %d\n", suma, counter)
        }
        counter++
    }

    fmt.Printf("Suma final = %d\n", suma)
}

Continuaremos ampliando la lista de ejemplos.

Enlaces:


https://codemonkeyjunior.blogspot.com/2024/02/un-programa-en-varios-lenguajes.html
https://projecteuler.net/

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

 

¿Qué lenguaje de programación debes aprender en un mundo con IA?

Las herramientas de IA están matando, literalmente, a la programación. Cualquiera con un Github Copilot, DeepSeek, Chat GPT, etc. pu...

Etiquetas

Archivo del blog