domingo, 29 de diciembre de 2024

Introduction to Algorithms (Curso en Inglés)

En está ocasión compartimos un curso gratuito sobre algoritmos.

Un algoritmo es una secuencia de pasos definidos para resolver un problema específico o para realizar una tarea particular. En informática son útiles para:

  • Crear programas computacionales que pueden ejecutar tareas complejas y repetitivas. 
  • Crear procesos que trabajen con grandes cantidades de datos. 
  • Optimizar tareas y mejorar rendimiento en sistemas. 
  • Etc.

Ejemplo. Crear un algoritmo en el que se solicita verificar si un archivo llamado "datos.dat" existe. Si no existe, indicar que el archivo no existe.

Algoritmo_Existe_Archivo

Inicio

    Definir ruta = "Fuentes/datos.dat"

    Si archivo_existe(ruta) entonces
        Abrir archivo(ruta)
    Sino
        Mostrar "El archivo datos.dat no existe en el directorio Fuentes."
    Fin Si

Fin

Características (ideales) que debe tener un algoritmo

  1. Debe ser claro, no ambiguo. 
  2. Finito, tener un número determinado de pasos. 
  3. Efectivo, debe funcionar, cada paso deber ser realizable con los recursos disponibles. 
  4. Tener una entrada, datos con que trabajar. 
  5. Tener al menos una salida, un resultado. 
  6. Determinista, para un conjunto dado de entradas, el algoritmo debe producir siempre el mismo resultado. 
  7. Cumplir con la Generalidad, debe ser lo suficientemente general para resolver no solo un caso específico, sino toda una clase de problemas similares. 
  8. Independiente del lenguaje, un algoritmo debería ser fácilmente implementado en cualquier lenguaje de programación. 
  9. Ser lo mínimo eficiente
  10. Debería ser modular, los algoritmos deben ser diseñados para ser modulares, permitiendo que partes del mismo puedan ser reutilizadas o combinadas con otros algoritmos para resolver problemas más complejos.

Puedes acceder al curso cobre algoritmos en el enlace.

¡Saludos!

Enlaces:

https://ocw.mit.edu/courses/6-006-introduction-to-algorithms-spring-2020/pages/lecture-notes

sábado, 28 de diciembre de 2024

AWS: tipos de Computación en la nube (Cloud Computing)

Continuamos con esta serie sobre AWS (Amazon Web Services) que iniciamos en la anterior entrega:

AWS en un vistazo.

En ésta ocasión veremos los 3 tipos de computación en la nube.

Los 3 tipos de computación en la nube (cloud computing)

  1. Software as a Services (SaaS) o Software como servicio: programas como servicios. Un ejemplo, Gmail, Outlook, etc.
  2. Platform as a Service (PaaS) o Plataforma como servicio: un servicio que te permite crear, implementar y gestionar aplicaciones en la nube. Ejemplos, AWS Elastic Beanstalk, AWS Lambda, etc.
  3. Infrastructure as a Services (IaaS) o Infraestructura como servicio: servidores, centro de datos, edificios, etc.

Las principales empresas que ofrecen este tipo de servicios son:

  • Amazon con su AWS.
  • Microsoft con su Microsoft Azure.
  • Google con su Google Cloud Platform.

Quien parece llevar la delantera es AWS, mientras que Microsoft Azure y GCP pelean la 2da y 3era posición.

Como programador, ¿Qué podemos esperar de estos 3 tipos de computación en la nube?

Saas

No necesitas preocuparte por la instalación, mantenimiento o actualización del software; todo eso lo gestiona el proveedor. Puedes acceder a las aplicaciones desde cualquier dispositivo con conexión a Internet. Generalmente se paga por suscripción, lo que puede ser más económico que comprar software de escritorio. Menos control sobre la personalización y configuración del software.

Paas

Automatización del escalado de aplicaciones según la demanda. Facilidad para integrar con bases de datos, servicios de mensajería, y otros servicios de nube. Herramientas y servicios para el desarrollo, pruebas, entrega y administración de aplicaciones.

Iaas

Mayor control sobre el hardware virtualizado, permitiéndote configurar el entorno según tus necesidades específicas. Capacidad de aumentar o disminuir la infraestructura según sea necesario rápidamente.Responsabilidad sobre la gestión de sistemas operativos, aplicaciones, entornos de runtime, etc. Paga solo por los recursos que uses, lo cual puede llevar a ahorros significativos.

Nota: Al usar este tipo de servicio debemos entender que no somos los dueños, solo los clientes. Los pagos por usar estos servicios deberán ser administrados correctamente sino queremos llevarnos un buen susto.

Continuaremos con este tema en futuras entregas.

Enlaces:

https://awsnewbies.com/cloud-computing/

sábado, 21 de diciembre de 2024

Frameworks para programar en web con Python

Programar en cualquier lenguaje de programación siempre es tan sencillo como hallar la panacea universal. El programador muchas veces optará por que elegir una herramienta que le haga más sencilla la existencia.

Un framework, siendo esa su esencia primordial, contendrá lo necesario para hacer lo difícil un poco menos difícil. No resolverá en su totalidad todos los problemas, pero si hará que horas de esfuerzo tan solo tomen unos minutos.

Hoy presentamos una lista con los Frameworks para programar en web con Python y que serán de gran utilidad:

Los más completos

Los más conocidos y usados (Django y Flask) y otros no tan nuevos pero que no se pierde nada en dar un vistazo.

Asíncronos

Otros

Más información:

Hemos visto algunos de los frameworks para desarrollar en Web con Python. En próximas entregas continuaremos sobre el tema..

https://hackernoon.com/top-10-python-web-frameworks-to-learn-in-2018-b2ebab969d1a

domingo, 15 de diciembre de 2024

¿Qué es la computación en la nube? (vídeo en inglés)

En este vídeo del canal @amazonwebservices nos explican lo qué es la computación en la nube (cloud computing), enfocado a AWS (Amazon Web Services).

GCP BigQuery: cargar un CSV a una tabla y crear un respaldo

GCP BigQuery nos permite cargar datos de un fichero (con formato CSV, TXT, etc.) a tablas en nuestros datasets.

En ésta ocasión veremos como validar la existencia de un archivo CSV en un bucket (contenedor), cargarlo a una tabla temporal e insertarlo a una determinada tabla. Además veremos cómo crear un respaldo de ese archivo CSV a otro bucket.

BigQueryTransfer.java

import com.google.cloud.bigquery.*;
import com.google.cloud.storage.*;
import com.google.cloud.bigquerystorage.v1.*;
import com.google.protobuf.Descriptors;
import com.google.protobuf.Message;
import com.google.protobuf.util.JsonFormat;
import java.io.*;
import java.nio.channels.Channels;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.*;

public class BigQueryTransfer {

    private static final String BUCKET_NAME = "your-bucket-name";
    private static final String BACKUP_BUCKET_NAME = "your-backup-bucket-name";
    private static final String DATASET_NAME = "mydataset";
    private static final String TABLE_NAME = "transferencia";
    private static final String PROJECT_ID = "myproject";
    private static final String CSV_FILE_NAME = "datos.csv";
    private static final String RESULT_CSV_NAME = "resultados.csv";

    public static void main(String[] args) throws Exception {
        Storage storage = StorageOptions.getDefaultInstance().getService();
        BigQuery bigQuery = BigQueryOptions.getDefaultInstance().getService();

        // 1. Verificar la existencia del archivo CSV
        Blob blob = storage.get(BUCKET_NAME, CSV_FILE_NAME);
        if (blob == null) {
            System.out.println("El archivo " + CSV_FILE_NAME + " no existe en el bucket.");
            return;
        }

        // 2. Leer el contenido del archivo CSV
        List<String> listaContenido = new ArrayList<>();
        try (BufferedReader reader = new BufferedReader(new InputStreamReader(Channels.newInputStream(blob.reader())))) {
            String line;
            while ((line = reader.readLine()) != null) {
                listaContenido.add(line);
            }
        }

        // 3. Crear la lista de Transferencia
        List<Transferencia> listaTransferencia = new ArrayList<>();
        for (String line : listaContenido) {
            String[] parts = line.split(",");
            if (parts.length >= 3) {
                Transferencia transferencia = new Transferencia(parts[0], parts[1], parts[2]);
                listaTransferencia.add(transferencia);
            }
        }

        // 4. Guardar en BigQuery usando BigQuery Storage Write API
        writeToBigQueryStorageApi(listaTransferencia);

        // 5. Crear "resultados.csv" con datos de la tabla
        String query = "SELECT * FROM `" + PROJECT_ID + "." + DATASET_NAME + "." + TABLE_NAME + "`";
        TableResult result = bigQuery.query(QueryJobConfiguration.newBuilder(query).build());

        File resultFile = new File(RESULT_CSV_NAME);
        try (BufferedWriter writer = new BufferedWriter(new FileWriter(resultFile))) {
            for (FieldValueList row : result.iterateAll()) {
                writer.write(String.join(",",
                        row.get(0).getStringValue(),
                        row.get(1).getStringValue(),
                        row.get(2).getStringValue()));
                writer.newLine();
            }
        }

        // Subir "resultados.csv" al bucket
        BlobId resultBlobId = BlobId.of(BUCKET_NAME, RESULT_CSV_NAME);
        BlobInfo resultBlobInfo = BlobInfo.newBuilder(resultBlobId).build();
        storage.create(resultBlobInfo, Files.readAllBytes(resultFile.toPath()));

        // 6. Mover "datos.csv" al bucket de respaldo
        BlobId sourceBlobId = BlobId.of(BUCKET_NAME, CSV_FILE_NAME);
        BlobId backupBlobId = BlobId.of(BACKUP_BUCKET_NAME, CSV_FILE_NAME);
        storage.copy(Storage.CopyRequest.of(sourceBlobId, backupBlobId));
        storage.delete(sourceBlobId);

        System.out.println("Proceso completado con éxito.");
    }

    private static void writeToBigQueryStorageApi(List<Transferencia> listaTransferencia) throws Exception {
        try (BigQueryWriteClient client = BigQueryWriteClient.create()) {
            String tablePath = String.format("projects/%s/datasets/%s/tables/%s", PROJECT_ID, DATASET_NAME, TABLE_NAME);

            WriteStream writeStream = WriteStream.newBuilder().setType(WriteStream.Type.COMMITTED).build();
            WriteStream createdStream = client.createWriteStream(CreateWriteStreamRequest.newBuilder().setParent(tablePath).setWriteStream(writeStream).build());

            ProtoSchema protoSchema = client.getWriteStream(GetWriteStreamRequest.newBuilder().setName(createdStream.getName()).build()).getTableSchema();
            Descriptors.Descriptor descriptor = TableSchemaToDescriptor.parse(protoSchema.getProtoDescriptor());

            for (Transferencia transferencia : listaTransferencia) {
                Message.Builder messageBuilder = DynamicMessage.newBuilder(descriptor);
                messageBuilder.setField(descriptor.findFieldByName("fecha"), transferencia.fecha);
                messageBuilder.setField(descriptor.findFieldByName("clave"), transferencia.clave);
                messageBuilder.setField(descriptor.findFieldByName("cuenta"), transferencia.cuenta);

                client.appendRows(AppendRowsRequest.newBuilder()
                        .setWriteStream(createdStream.getName())
                        .addRows(ByteString.copyFrom(messageBuilder.build().toByteArray()))
                        .build());
            }

            client.finalizeWriteStream(FinalizeWriteStreamRequest.newBuilder().setName(createdStream.getName()).build());
        }
    }

    static class Transferencia {
        String fecha;
        String clave;
        String cuenta;

        Transferencia(String fecha, String clave, String cuenta) {
            this.fecha = fecha;
            this.clave = clave;
            this.cuenta = cuenta;
        }
    }
}

Con este programa:

  1. Verificamos la existencia del archivo "datos.csv". 
  2. Leemos su contenido y lo almacenamos en una lista tipo String. 
  3. Cargamos el contenido del archivo "datos.csv" a una tabla temporal. 
  4. Creamos una lista de tipo "Transferencia". 
  5. Guardamos los datos en la tabla "transferencia" usando BigQuery Storage Write API. 
  6. Creamos un archivo en el bucket llamado "resultados.csv" a partir de una consulta a la tabla "transferencia". 
  7. Creamos un respaldo de "datos.csv" a otro bucket.

Enlaces:

https://cloud.google.com/storage/docs/buckets
https://medium.com/@bravnic/bigquery-storage-write-api-at-scale-7affcc2d7a93
https://cloud.google.com/bigquery/docs/write-api
https://www.googlecloudcommunity.com/gc/Data-Analytics/Using-Google-Bigquery-Storage-Write-API-with-high-concurrency/m-p/662308

sábado, 14 de diciembre de 2024

Concurnas: un lenguaje de programación JVM

Anteriormente hablamos sobre este lenguaje de programación dependiente de la JVM.

Concurnas es:

"Un lenguaje de programación diseñado para construir sistemas concurrentes, distribuidos y paralelos, confiables, escalables y de alto rendimiento".

Es un lenguaje que se inspira en la sintaxis de Python, por lo que crear un programa en este no será como Java.

Además esta enfocado en la concurrencia, y no secuencial como en los demás lenguajes.

Si quieres saber más, puedes dar un vistazo a un artículo sobre este lenguaje:

https://blogs.oracle.com/javamagazine/post/concurrent-programming-with-concurnas

Programando en Concurnas

Antes de comenzar a hacer tus programas deberás:

  1. Tener instalado el JDK 8.
  2. Tener la configurada la variable de entorno (JAVA_HOME).
  3. Haber instalado Concurnas.

Nota: En versiones superiores al JDK 8 habrá errores.

Recordemos como compilar y ejecutar un programa en este lenguaje:

# Compilar:
concc Programa.conc

# Ejecutar:
conc Programa

Ejemplo 1. El clásico "Hola, mundo".

HolaMundo.conc

System.out.println("Hola, mundo!!")

Compilamos y ejecutamos:

$ concc HolaMundo.conc
$ conc HolaMundo

Ejemplo 2. Crear un programa que muestre los datos de un empleado. Los datos comprenderán: clave de empleado, nombre, edad, fecha de nacimiento, dirección y si estado civil.

Datos.conc

claveEmp String = "345632"
nombre String = "Thomas Muller"
edad int = 18
fecha_nacimiento="23/05/1988"
edo_civil = "Soltero"
direccion= "MonteCarlo no. 45, Barrio Altavista, Toluca."

System.out.println("Clave empleado: "+claveEmp)
System.out.println("Nombre: "+nombre)
System.out.println("Edad: "+edad)
System.out.println("Fecha de nacimiento: "+fecha_nacimiento)
System.out.println("Edo. civil: "+edo_civil)
System.out.println("Dirección: "+direccion)

Como se podrá ver. Hemos definido variables indicado su tipo y en otras se omitió esa indicación. Esta es una de las peculiaridades del lenguaje.

Compilamos y ejecutamos:

$ concc Datos.conc
$ conc Datos

Ejemplo 3. Crear un programa que resuelva operaciones aritméticas básicas: suma, resta, multiplicación y división.

Basicas.conc

/** Definimos las varibles**/
a int = 9
b int = 4
suma int = a + b
resta = a - b
producto int = a * b
division int = a/b

/** Mostramos el resultado en pantalla **/
System.out.println("\t [ Operaciones aritméticas básicas ]");
System.out.printf("Suma de %d + %d da : %d\n",a,b,suma);
System.out.printf("Resta de %d - %d da : %d\n",a,b,resta);
System.out.printf("Producto de %d + %d da : %d\n",a,b,producto);
System.out.printf("División de %d + %d da : %d\n",a,b,division);

Compilamos y ejecutamos:

$ concc Basicas.conc
$ conc Basicas

Ejemplo 4. Crear una clase denominada "Punto" con dos propiedades tipo int, x & y. Mostrar el valor de sus propiedades.

Punto.conc

/** Creamos la clase Punto **/
class Punto{
   public x int
   public y int
   
   this(x int, y int){
      this.x = x
      this.y = y
   }
   
}
/** Instanciamos la clase  Punto **/
var punto = new Punto(4,5);

/** Mostramos el valor de sus propiedades  **/
System.out.println("x: "+punto.x);
System.out.println("y: "+punto.y);

Compilamos y ejecutamos:

$ concc Punto.conc
$ conc Punto

¡Hemos creado nuestros primeros programas en Concurnas!

Continuaremos con el tema en próximas entregas.

Enlaces:

https://codemonkeyjunior.blogspot.com/2020/08/un-lenguaje-de-programacion-lamado.html
https://concurnas.com/
https://blogs.oracle.com/javamagazine/post/concurrent-programming-with-concurnas
https://www.reddit.com/r/ProgrammingLanguages/comments/e8a42b/new_programming_language_concurnas/?rdt=41743
https://devm.io/java/introducing-new-jvm-lanaguage-concurnas-167915

AWS en un vistazo

Amazon Web Services (AWS), es una plataforma de servicios en la nube que ofrece una amplia gama de productos y soluciones de cómputo, almacenamiento, bases de datos, análisis y más.

Sirve para:

  • Alojamiento de aplicaciones: Permite a las empresas desplegar y escalar aplicaciones sin necesidad de gestionar físicamente los servidores. 
  • Almacenamiento de datos: Ofrece soluciones como S3 para almacenamiento de objetos y EBS para almacenamiento en bloque. 
  • Computación: Provee servicios como EC2 para instancias de máquinas virtuales. 
  • Análisis y Big Data: Herramientas como Redshift para análisis de datos a gran escala. 
  • Seguridad y cumplimiento: Ofrece servicios para la protección de datos y la conformidad normativa.

AWS facilita a las organizaciones la innovación, reducción de costos y mejora de la agilidad empresarial mediante el uso de la nube.

Como programadores, ¿Qué podemos esperar de AWS?

  • Infraestructura como servicio (IaaS): Podrás lanzar y gestionar servidores virtuales (EC2) según tus necesidades, escalando recursos de manera dinámica. 
  • Plataforma como servicio (PaaS): AWS ofrece servicios como Elastic Beanstalk, que te permiten desplegar aplicaciones web sin preocuparte por la infraestructura subyacente. 
  •  Bases de datos gestionadas: Puedes utilizar servicios como RDS para bases de datos relacionales o DynamoDB para bases de datos NoSQL sin tener que manejar la administración de la base de datos. 
  • Herramientas de desarrollo: AWS CodeCommit para control de versiones, CodeBuild para compilar aplicaciones, CodeDeploy para automatizar despliegues, y CodePipeline para flujos de trabajo de CI/CD. 
  • Servicios de almacenamiento: S3 para almacenamiento de objetos, ideal para archivos estáticos, backups, o datos para aplicaciones. 
  • Machine Learning y AI: Servicios como SageMaker para construir, entrenar y desplegar modelos de machine learning sin necesidad de gestionar la infraestructura. 
  • Seguridad: IAM para gestionar permisos y acceso, además de herramientas como WAF para proteger aplicaciones web. 
  • Análisis de datos: Redshift para grandes volúmenes de datos, Athena para SQL queries sobre datos en S3, y Kinesis para streaming de datos en tiempo real. 
  • APIs y Servicios sin servidor: Lambda te permite ejecutar código sin aprovisionar o gestionar servidores, perfecto para microservicios o eventos específicos. 
  • Redes y CDN: VPC para crear redes privadas virtuales y CloudFront para una red de entrega de contenido que acelera la distribución global de tu contenido. 
  • Monitoreo y logs: CloudWatch para monitoreo y logs de tus aplicaciones y recursos de AWS. 
  • Facilidad de integración: AWS está diseñado para trabajar bien con muchos lenguajes y frameworks de programación, facilitando la integración con tus herramientas y flujos de trabajo existentes.

AWS cuenta con una amplia documentación sobre sus servicios y herramientas. Por ejemplo, podrás encontrar una guía del SDK de AWS para diferentes lenguajes de programación como Java, C++, Python, Go, etc.

Desde como descargarlo, instalarlo e iniciar un proyecto.

AWS es una alternativa sobre otros servicios similares como GCP y Microsoft Azure, entreo otros más. Algunos dicen que lleva la delantera sobre éstos dos.

En GCP existe el servicio de almacenamiento de datos llamada Bigquery, en comparativa a AWS sería Redshift. En ambas se pueden crear Stored Procedures. Sin embargo, Redshift usa PostgreSQL para hacerlo, mientras que Bigquery tiene su propio SQL integrado.

Un ejemplo de SP en Redshift, usando PostgreSQL, sería:

CREATE OR REPLACE PROCEDURE holamundo()
LANGUAGE plpgsql
AS $$
BEGIN
    RAISE INFO 'Hola, mundo!';
END;
$$;

-- Para ejecutar este Stored Procedure, usarías:
CALL holamundo();

Actualmente existen tutoriales para aprender a usar los servicios y herramientas de AWS.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://aws.amazon.com/
https://aws.github.io/
https://www.w3schools.com/aws/
https://awsnewbies.com/

viernes, 13 de diciembre de 2024

Más sobre esProc SPL, un lenguaje orientado al tratamiento de datos

En una anterior entrega dimos un vistazo a esProc SPL, un lenguaje orientado al tratamiento y almancenamiento de datos.

Peculiaridades del lenguaje

esProc SPL a diferencia del lenguaje de programación basado en texto, escribe código en líneas de cuadrícula, similar a una hoja de Excel.

  • esProc SPL puede generar alta eficiencia a un costo mucho menor.
  • esProc SPL es una biblioteca de clases de computación de datos basada en JVM
  • Tiene muchas más y mejores funcionalidades que los otros lenguajes de procesamiento de datos basados en JVM (como Kotlin y Scala).
  • Puede realizar cálculos de estilo SQL sin bases de datos.
  • Admite cálculos directos en archivos.
  • esProc SPL permite microservicios más flexibles.
  • esProc también se puede integrar en una aplicación para que actúe como una base de datos incorporada.
  • esProc SPL facilita la consecución de algoritmos de alto rendimiento y, por tanto, obtiene un rendimiento informático mucho mayor que el almacén de datos relacional tradicional.

Como se ha explicado, al usar este lenguaje, trabajaremos con celdas o líneas de cuadrícula. En ellas escribiremos nuestras sentencias a ejecutar. Miremos un ejemplo:

=1-2+3-4
=3*54
=6/2.32
=1.43434343434+2.65656556+0.0988888

Para ejecutar estas líneas debemos presionar Ctrl + F9 y observaremos el resultado.

Existe un libro que puedes consultar si te llama la atención ver más a detalle este lenguaje:

https://www.scudata.com/html/SPL-programming-book.html

Enlaces:

https://www.scudata.com/html/SPL-programming-book.html
https://www.reddit.com/r/esProcSPL/comments/1ga07gr/what_is_esproc_spl/
https://github.com/SPLWare/esProc

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/