Colección de Métodos en C# para la Manipulación de Vectores y Arreglos

Introducción a la Manipulación de Vectores en C#

A continuación se presenta un conjunto de métodos en C# diseñados para realizar diversas operaciones sobre vectores y arreglos numéricos. Estas funciones permiten gestionar datos de manera eficiente mediante el uso de estructuras de control y algoritmos fundamentales.

Métodos de Modificación y Carga

Inversión y Carga de Elementos

Estos métodos permiten modificar la estructura del vector, ya sea cargando valores aleatorios, invirtiendo su orden o alterando posiciones específicas.

public void INVERTIR(int Pos)
{
    int J = 0;
    for (int i = 0; i < dimencion; i++)
    {
        if( i==Pos)
            for (int v = i + 1; v < dimencion ; v++)
            {
                vector[i + J] = vector[v];
                J++;
            }
        dimencion = dimencion - 1;
    }
}

public void CARGARVECTORES()
{
    Random BRANDON = new Random();
    for (int V = 0; V < dimencion; V++)
    {
        vector[V] = BRANDON.Next(1,10);
    }
}

public void GuardarVector(int num)
{
    vector[dimencion] = num;
    dimencion = dimencion + 1;
}

public void invertir()
{
    int AUX = 0;
    for (int i = 0; i < dimencion / 2; i++)
    {
        AUX = vector[i];
        vector[i] = vector[dimencion - 1 - i];
        vector[dimencion - 1 - i] = AUX;
    }
}

Métodos de Visualización y Consulta

Visualización de Datos y Obtención de Propiedades

Las siguientes funciones facilitan la lectura de los datos almacenados en el vector, así como la consulta de su dimensión actual y valores específicos.

public string MOSTRAR()
{
    string Nuevo = "";
    for (int i = 0; i < dimencion; i++)
    {
        Nuevo = Nuevo  + "  ||  "+ vector[i];
    }
    return Nuevo;
}

public int CargarVector()
{
    int Cargar = 0;
    for (int i = 0; i < dimencion; i++)
    {
        Cargar = Cargar + vector[i] + 1;
    }
    return Cargar;
}

public int obtener()
{
    return dimencion;
}

public int obtener_vector(int pos)
{
    return vector[pos];
}

public int result(int pos)
{
    return vector2[pos];
}

public int mostrarrr(int pos)
{
    return vector2[pos];
}

public int mostrar_C_P(int pos)
{
    return vector2[pos];
}

public string MOSTRARDERECHA()
{
    string Nuevo = "";
    for (int i = 0; i < dimencion; i++)
    {
        Nuevo = Nuevo + vector[i];
    }
    return Nuevo;
}

Operaciones Matemáticas y Estadísticas

Sumas, conteo y valores extremos

Este bloque agrupa algoritmos útiles para calcular la suma de elementos, identificar números pares e impares, y localizar el elemento mayor y el elemento menor.

public int suma_de_vectores()
{
    int suma = 0;
    for (int i = 0; i < dimencion; i++)
    {           
        suma = suma + vector[i];
    }
    return suma;
}

public int suma_de_pares()
{
    int suma = 0;
    for (int i = 0; i < dimencion; i++)
    {
        if ((vector[i] % 2) == 0)
            suma = suma + vector[i];                
    }
    return suma;
}

public int suma_de_impares()
{
    int suma = 0;
    for (int i = 0; i < dimencion; i++)
    {
        if ((vector[i] % 2) == 1)
            suma = suma + vector[i];
    }
    return suma;
}

public int contar_pares()
{
    int pos = 0;
    for (int i = 0; i < dimencion; i++)
    {
        if (vector[i] % 2 == 0)
        {
            pos++;
        }
    }
    return pos;
}

public int ContarImpares()
{
    int pos = 0;
    for (int i = 0; i < dimencion; i++)
    {
        if (vector[i] % 2 == 1)
        {
            pos++;
        }
    }
    return pos;
}

public int ElementoMenor()
{
    int Menor = 11;
    for (int i = 0; i < dimencion; i++)
    {
        if (vector[i] < Menor)
        {
            Menor = vector[i];
        }
    }
    return Menor;
}

public int ElementoMayor()
{
    int Mayor = 0;
    for (int i = 0; i < dimencion; i++)
    {
        if (vector[i] > Mayor)
        {
            Mayor = vector[i];
        }
    }
    return Mayor;
}

public int ElMasRepetido()
{
    int Contador = 0;
    int Aux = 0;
    int Fin = 0;
    for (int v = 0; v < dimencion; v++)
    {
        for (int V2 = v + 1; V2 < dimencion; V2++)
        {
            if (vector[v] == vector[V2])
            {
                Contador++;
            }
        }
        if (Aux < Contador)
        {
            Fin = vector[v];
            Aux = Contador;
        }
    }
    return Contador;
}

public int ContarX(int X)
{
    int Contador = 0;
    for (int i = 0; i < dimencion; i++)
    {
        if (vector[i] == X)
        {
            Contador++;
        }
    }
    return Contador;
}

Rotación, Ordenamiento y Eliminación

Algoritmos de Transformación de Arreglos

Estas rutinas permiten realizar operaciones complejas como la rotación de elementos hacia la derecha o izquierda, el ordenamiento condicional y la eliminación de datos específicos o condicionados.

public void OrdenarParImpar()
{
    for (int i = 0; i < dimencion; i++)
    {
        int Contar = 0;
        if (vector[i] % 2 == 0)
        {
            vector[Contar] = vector[i];
            Contar++;
        }
    }
    for (int i = 0; i < dimencion; i++)
    {
        int Contar = 0;
        if (vector[i] % 2 == 1)
        {
            vector[Contar] = vector[i];
            Contar++;
        }
    }
}

public void ROTARDERECHA()
{
    int Rotar = 0;
    for (int i = 0; i < dimencion+1; i++)
    {
        Rotar = vector[i];
        vector[i] = Rotar;
    }
}

public void RotarIzquierda()
{
    int AUX = 0;
    for (int i = 0; i <= dimencion; i++)
    {
        AUX = vector[i];
        vector[i] = vector[dimencion - 1 - i];
        vector[dimencion - 1 - i] = AUX;
    }
}

public void EliminarPares()
{
    int contar = 0;
    for (int i = 0; i < dimencion; i++)
    {
        if (vector[i] % 2 == 0)
        {
            vector[i] = 0;
            contar++;
        }
    }
    vector[dimencion] = dimencion + contar;
}

public void EliminarImpares()
{
    for (int i = 0; i < dimencion; i++)
    {
        if (vector[i] % 2 != 0)
        {
            vector[i] = 0;
        }
    }
    vector[dimencion] = dimencion;
}

public void EliminarPosicion(int Pos)
{
    int j = 0;
    for (int i = 0; i < (dimencion-1); i++)
    {
        if (vector[i] != Pos)
        {
            for (int v = i+1; v < dimencion; v++)
            {
                vector[i + 1] = vector[v];
                j++;
            }
            dimencion = dimencion - 1;
        }
    }
}