El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Operaciones con Arreglos y Cadenas

Siguiente ►
►

En este tema, aprenderemos a realizar diversas operaciones con arreglos y cadenas en Fortran. Estas operaciones son fundamentales para manipular datos de manera eficiente y efectiva en tus programas. Cubriremos desde operaciones básicas hasta técnicas más avanzadas.

Contenido

  1. Operaciones Básicas con Arreglos
  2. Operaciones Avanzadas con Arreglos
  3. Operaciones Básicas con Cadenas
  4. Operaciones Avanzadas con Cadenas
  5. Ejercicios Prácticos

  1. Operaciones Básicas con Arreglos

Asignación y Acceso a Elementos

Para asignar valores a un arreglo y acceder a sus elementos, puedes usar índices. Aquí tienes un ejemplo:

program array_operations
    implicit none
    integer, dimension(5) :: arr
    integer :: i

    ! Asignar valores al arreglo
    arr = (/1, 2, 3, 4, 5/)

    ! Acceder y mostrar los valores del arreglo
    do i = 1, 5
        print *, 'Elemento ', i, ': ', arr(i)
    end do
end program array_operations

Suma de Elementos

Puedes sumar los elementos de un arreglo utilizando un bucle do:

program sum_array
    implicit none
    integer, dimension(5) :: arr
    integer :: i, sum

    arr = (/1, 2, 3, 4, 5/)
    sum = 0

    do i = 1, 5
        sum = sum + arr(i)
    end do

    print *, 'La suma de los elementos es: ', sum
end program sum_array

Operaciones Elementales

Fortran permite realizar operaciones elementales en arreglos de manera directa:

program elemental_operations
    implicit none
    integer, dimension(5) :: arr1, arr2, result

    arr1 = (/1, 2, 3, 4, 5/)
    arr2 = (/5, 4, 3, 2, 1/)

    ! Suma de arreglos
    result = arr1 + arr2

    print *, 'Resultado de la suma: ', result
end program elemental_operations

  1. Operaciones Avanzadas con Arreglos

Reducción

La reducción es una operación que reduce un arreglo a un solo valor, como la suma o el producto de todos sus elementos:

program reduction_example
    implicit none
    integer, dimension(5) :: arr
    integer :: sum

    arr = (/1, 2, 3, 4, 5/)
    sum = sum(arr)

    print *, 'La suma de los elementos es: ', sum
end program reduction_example

Transformaciones

Puedes aplicar transformaciones a los arreglos utilizando funciones intrínsecas como reshape:

program reshape_example
    implicit none
    integer, dimension(6) :: arr
    integer, dimension(2, 3) :: reshaped_arr

    arr = (/1, 2, 3, 4, 5, 6/)
    reshaped_arr = reshape(arr, shape(reshaped_arr))

    print *, 'Arreglo reestructurado: '
    print *, reshaped_arr
end program reshape_example

  1. Operaciones Básicas con Cadenas

Concatenación

Puedes concatenar cadenas utilizando el operador //:

program string_concatenation
    implicit none
    character(len=20) :: str1, str2, result

    str1 = 'Hola, '
    str2 = 'Mundo!'
    result = str1 // str2

    print *, 'Cadena concatenada: ', result
end program string_concatenation

Subcadenas

Para extraer subcadenas, puedes usar índices:

program substring_example
    implicit none
    character(len=20) :: str, sub

    str = 'Fortran Programming'
    sub = str(1:7)

    print *, 'Subcadena: ', sub
end program substring_example

  1. Operaciones Avanzadas con Cadenas

Búsqueda de Subcadenas

Puedes buscar subcadenas dentro de una cadena utilizando la función index:

program substring_search
    implicit none
    character(len=20) :: str
    integer :: pos

    str = 'Fortran Programming'
    pos = index(str, 'Programming')

    if (pos > 0) then
        print *, 'Subcadena encontrada en la posición: ', pos
    else
        print *, 'Subcadena no encontrada'
    end if
end program substring_search

Reemplazo de Subcadenas

Para reemplazar subcadenas, puedes usar una combinación de funciones intrínsecas:

program substring_replace
    implicit none
    character(len=20) :: str, old_sub, new_sub
    integer :: pos

    str = 'Fortran Programming'
    old_sub = 'Programming'
    new_sub = 'Coding'

    pos = index(str, old_sub)
    if (pos > 0) then
        str(pos:pos+len_trim(old_sub)-1) = new_sub
    end if

    print *, 'Cadena modificada: ', str
end program substring_replace

  1. Ejercicios Prácticos

Ejercicio 1: Producto de Elementos de un Arreglo

Escribe un programa que calcule el producto de todos los elementos de un arreglo de enteros.

Solución:

program product_array
    implicit none
    integer, dimension(5) :: arr
    integer :: i, product

    arr = (/1, 2, 3, 4, 5/)
    product = 1

    do i = 1, 5
        product = product * arr(i)
    end do

    print *, 'El producto de los elementos es: ', product
end program product_array

Ejercicio 2: Reverso de una Cadena

Escribe un programa que invierta una cadena dada.

Solución:

program reverse_string
    implicit none
    character(len=20) :: str, reversed
    integer :: i, len

    str = 'Fortran'
    len = len_trim(str)
    reversed = ''

    do i = 1, len
        reversed(i:i) = str(len-i+1:len-i+1)
    end do

    print *, 'Cadena invertida: ', reversed
end program reverse_string

Conclusión

En esta sección, hemos explorado diversas operaciones con arreglos y cadenas en Fortran, desde las más básicas hasta las más avanzadas. Estas habilidades son esenciales para manipular datos de manera efectiva en tus programas. Asegúrate de practicar los ejercicios para consolidar tu comprensión y prepararte para los temas más avanzados que vendrán en los siguientes módulos.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados