Функция swap заменить максимальные и минимальные значения массивов?

Question

[mboze]

Добрый день, поскажите пожалуйста, пытаюсь реализовать чтобы максимальные и минимальные значения менялись с друг другом , к примеру : Даны 2 массива ,в массиве А есть элемент 2, он минимальный, в массиве В есть элемент 3, он минимальный, надо так, чтобы они поменялись местами и аналогия с максимальными значениями, код, который сейчас есть:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace ConsoleApp28
{
    class Program
    {
        public static void Swap(ref int a, ref int b)
        {
            int temp = a;
            a = b;
            b = temp;

        }

        public static void Main(string[] args)
        {
            Console.WriteLine("Введите количесвто строк (m)");
            int m = int.Parse(Console.ReadLine());
            Console.WriteLine("Введите количесвто столбцов (n)");
            int n = int.Parse(Console.ReadLine());
            int[,] A = new int[m, n];
            Console.WriteLine("массив А");
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                    A[i, j] = int.Parse(Console.ReadLine());
            }
            Console.WriteLine("Начальный массив");

            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                    Console.Write(A[i, j] + "\t");
                Console.WriteLine();
            }

            Console.WriteLine("Введите количесвто строк (k)");
            int k = int.Parse(Console.ReadLine());
            Console.WriteLine("Введите количесвто столбцов (l)");
            int l = int.Parse(Console.ReadLine());
            int[,] B = new int[k, l];
            Console.WriteLine("массив B");
            for (int e = 0; e < k; e++)
            {
                for (int g = 0; g < l; g++)
                    B[e, g] = int.Parse(Console.ReadLine());
            }
            Console.WriteLine("Начальный массив");

            for (int e = 0; e < k; e++)
            {
                for (int g = 0; g < l; g++)
                    Console.Write(B[e, g] + "\t");
                Console.WriteLine();
            }
            int maxA = A[0, 0];
            int minA = A[0, 0];
            int maxB = B[0, 0];
            int minB = B[0, 0];
            Console.WriteLine("Готовый массив");
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    if (A[i, j] > maxA)
                        maxA = A[i, j];
                }
            }
            for (int i = 0; i < n; i++)
            {
                for (int j = 0; j < m; j++)
                {
                    if (A[i, j] < minA)
                        minA = A[i, j];
                }
            }

            for (int e = 0; e < k; e++)
            {
                for (int g = 0; g < l; g++)
                {
                    if (B[e, g] > maxB)
                        maxB = B[e, g];
                }
            }
            for (int e = 0; e < k; e++)
            {
                for (int g = 0; g < l; g++)
                {
                    if (B[e, g] < minB)
                        minB = B[e, g];
                }
            }
            //Console.WriteLine("do max A" + maxA);
            //Console.WriteLine("do max B" + maxB);
            Program.Swap(ref maxA, ref maxB);
            //Console.WriteLine("posl max A" + maxA);
            // Console.WriteLine("posl max B" + maxB);
            Program.Swap(ref minA, ref minB);
            for (int i = 0; i < m; i++)
            {
                for (int j = 0; j < n; j++)
                    Console.Write(A[i, j] + "\t");
                Console.WriteLine();
            }
            Console.WriteLine("Готовый массив");
            for (int e = 0; e < k; e++)
            {
                for (int g = 0; g < l; g++)
                    Console.Write(B[e, g] + "\t");
                Console.WriteLine();
            }

            Console.ReadLine();

        }
    }
}

Вывод, который сейчас есть:

Comments

[freeExec]

Так ты раскоментируй, посмотри, ты хоть значения то правильно нашёл.

[mboze]

freeExec, да, я проверял, значения перезаписываются, но не выводятся

[Борис Животное]

Пробуй разбивать задачу на подзадачи. Выделяй минимальные функции/методы, которые что-то делают, а не бросай всё в одну кучу

[Борис Животное]

Ради интереса попробовал на Kotlin (на нём почти не писал ничего ещё). Кстати, 2D массив можно сдлеать оптимальнее создав свой класс, внутри которого будет одномерный массив и метод, который даёт возможность получить доступ к нужной строке и колонке этого двумерного массива.

fun main(args: Array<String>) {

    val arrayA: Array<IntArray> = arrayOf(
        intArrayOf(5, 5, 50, 5),
        intArrayOf(5, 5, 5, 5),
        intArrayOf(5, 5, 5, 2)
    )

    val arrayB: Array<IntArray> = arrayOf(
        intArrayOf(5, 5),
        intArrayOf(5, 1),
        intArrayOf(15, 5),
        intArrayOf(5, 1)
    )

    println("Array A:")
    print(arrayA)

    println()
    println("Array B:")
    print(arrayB)

    println()
    println("Array A, first min value position:")
    val (yMinA, xMinA) = findFirstMinValuePosition(arrayA)
    print(xMinA, yMinA)

    println()
    println("Array B, first min value position:")
    val (yMinB, xMinB) = findFirstMinValuePosition(arrayB)
    print(xMinB, yMinB)

    println()
    println("Array A, first max value position:")
    val (yMaxA, xMaxA) = findFirstMaxValuePosition(arrayA)
    print(xMaxA, yMaxA)

    println()
    println("Array B, first max value position:")
    val (yMaxB, xMaxB) = findFirstMaxValuePosition(arrayB)
    print(xMaxB, yMaxB)

    swap(arrayA, arrayB, yMinA, xMinA, yMinB, xMinB)
    swap(arrayA, arrayB, yMaxA, xMaxA, yMaxB, xMaxB)

    println("----")
    println()
    println("Array A after two swaps:")
    print(arrayA)

    println()
    println("Array B after two swaps:")
    print(arrayB)
}

fun findFirstMinValuePosition(array: Array<IntArray>): Pair<Int, Int> {
    val y: Int = array.size
    val x: Int = if (y > 0) array[0].size else 0

    if (y == 0) throw IllegalArgumentException(
        "The dimension of the array along the Y axis is zero.")
    if (x == 0) throw IllegalArgumentException(
        "The dimension of the array along the Y axis is zero.")

    var yResult = 0
    var xResult = 0

    var minValue: Int = array[0][0]
    for (yIndex in array.indices) {
        for (xIndex in array[yIndex].indices) {
            if (minValue > array[yIndex][xIndex])
            {
                yResult = yIndex
                xResult = xIndex
                minValue = array[yIndex][xIndex]
            }
        }
    }

    return Pair(yResult, xResult)
}

fun findFirstMaxValuePosition(array: Array<IntArray>): Pair<Int, Int> {
    val y: Int = array.size
    val x: Int = if (y > 0) array[0].size else 0

    if (y == 0) throw IllegalArgumentException(
        "The dimension of the array along the Y axis is zero.")
    if (x == 0) throw IllegalArgumentException(
        "The dimension of the array along the Y axis is zero.")

    var yResult = 0
    var xResult = 0

    var maxValue: Int = array[0][0]
    for (yIndex in array.indices) {
        for (xIndex in array[yIndex].indices) {
            if (maxValue < array[yIndex][xIndex])
            {
                yResult = yIndex
                xResult = xIndex
                maxValue = array[yIndex][xIndex]
            }
        }
    }

    return Pair(yResult, xResult)
}

fun swap(arrayA: Array<IntArray>, arrayB: Array<IntArray>, yA: Int, xA: Int, yB: Int, xB: Int) {
    val tempB: Int = arrayB[yB][xB]
    arrayB[yB][xB] = arrayA[yA][xA]
    arrayA[yA][xA] = tempB
}

fun print(array: Array<IntArray>) {
    for (row: IntArray in array) {
        println(row.contentToString())
    }
}

fun print(x: Int, y: Int) {
    println("x: $x, y: $y")
}

Answer 1

[Борис Животное]

Обмен местами первых найденных минимальных значений в двух двумерных массивах.

using System;

namespace ConsoleApp
{
    internal class Program
    {
        static void Main(string[] args)
        {
            int[,] arrayA = new int[3, 4]
            {
                {5, 5, 50, 5},
                {5, 5, 5, 5},
                {5, 5, 5, 2},
            };
            int[,] arrayB = new int[4, 2]
            {
                {5, 5},
                {5, 1},
                {15, 5},
                {5, 1},
            };

            Console.WriteLine("Array A:");
            Print(arrayA);

            Console.WriteLine();
            Console.WriteLine("Array B:");
            Print(arrayB);

            Console.WriteLine();
            Console.WriteLine("Array A, first min value position:");
            var (yMinA, xMinA) = FindFirstMinValuePosition(arrayA);
            Print(xMinA, yMinA);

            Console.WriteLine();
            Console.WriteLine("Array B, first min value position:");
            var (yMinB, xMinB) = FindFirstMinValuePosition(arrayB);
            Print(xMinB, yMinB);

            Console.WriteLine();
            Console.WriteLine("Array A, first max value position:");
            var (yMaxA, xMaxA) = FindFirstMaxValuePosition(arrayA);
            Print(xMaxA, yMaxA);

            Console.WriteLine();
            Console.WriteLine("Array B, first max value position:");
            var (yMaxB, xMaxB) = FindFirstMaxValuePosition(arrayB);
            Print(xMaxB, yMaxB);

            Swap(arrayA, arrayB, yMinA, xMinA, yMinB, xMinB);
            Swap(arrayA, arrayB, yMaxA, xMaxA, yMaxB, xMaxB);

            Console.WriteLine("----");
            Console.WriteLine();
            Console.WriteLine("Array A after two swaps:");
            Print(arrayA);

            Console.WriteLine();
            Console.WriteLine("Array B after two swaps:");
            Print(arrayB);

            Console.WriteLine();
        }

        private static void Swap(int[,] arrayA, int[,] arrayB, int yA, int xA, int yB, int xB)
        {
            int tempB = arrayB[yB, xB];
            arrayB[yB, xB] = arrayA[yA, xA];
            arrayA[yA, xA] = tempB;
        }

        private static (int y, int x) FindFirstMinValuePosition(int[,] array)
        {
            if (array is null) throw new ArgumentNullException(nameof(array));

            int y = array.GetLength(0);
            int x = array.GetLength(1);

            if (y == 0) throw new InvalidOperationException(
                "The dimension of the array along the Y axis is zero.");
            if (x == 0) throw new InvalidOperationException(
                "The dimension of the array along the X axis is zero.");

            int yResult = 0;
            int xResult = 0;

            int minValue = array[0, 0];
            for (int yIndex = 0; yIndex < y; yIndex++)
            {
                for (int xIndex = 0; xIndex < x; xIndex++)
                {
                    if (minValue > array[yIndex, xIndex])
                    {
                        yResult = yIndex;
                        xResult = xIndex;
                        minValue = array[yIndex, xIndex];
                    }
                }
            }

            return (yResult, xResult);
        }

        private static (int y, int x) FindFirstMaxValuePosition(int[,] array)
        {
            if (array is null) throw new ArgumentNullException(nameof(array));

            int y = array.GetLength(0);
            int x = array.GetLength(1);

            if (y == 0) throw new InvalidOperationException(
                "The dimension of the array along the Y axis is zero.");
            if (x == 0) throw new InvalidOperationException(
                "The dimension of the array along the X axis is zero.");

            int yResult = 0;
            int xResult = 0;

            int maxValue = array[0, 0];
            for (int yIndex = 0; yIndex < y; yIndex++)
            {
                for (int xIndex = 0; xIndex < x; xIndex++)
                {
                    if (maxValue < array[yIndex, xIndex])
                    {
                        yResult = yIndex;
                        xResult = xIndex;
                        maxValue = array[yIndex, xIndex];
                    }
                }
            }

            return (yResult, xResult);
        }

        private static void Print(int x, int y)
        {
            Console.WriteLine($"x: {x}, y: {y}");
        }

        private static void Print(int[,] array)
        {
            int x = array.GetLength(0);
            int y = array.GetLength(1);

            for (int xIndex = 0; xIndex < x; xIndex++)
            {
                for (int yIndex = 0; yIndex < y; yIndex++)
                {
                    Console.Write($"{array[xIndex, yIndex]}, ");
                }
                Console.WriteLine();
            }
        }
    }
}

Вывод программы:

Array A:
5, 5, 50, 5,
5, 5, 5, 5,
5, 5, 5, 2,

Array B:
5, 5,
5, 1,
15, 5,
5, 1,

Array A, first min value position:
x: 3, y: 2

Array B, first min value position:
x: 1, y: 1

Array A, first max value position:
x: 2, y: 0

Array B, first max value position:
x: 0, y: 2
----

Array A after two swaps:
5, 5, 15, 5,
5, 5, 5, 5,
5, 5, 5, 1,

Array B after two swaps:
5, 5,
5, 2,
50, 5,
5, 1,

Comments

[mboze]

Cупер! Спасибо большое! А с максимальным не подскажите пожалуйста, как его можно указать?

[Борис Животное]

mboze, всё точно так же, только теперь находим позицию первого попавшегося максимального значения. Потом точно так же как в коде в ответе вызываем Swap с найденными этим методом координатами. Обновил код.

// --
        private static (int y, int x) FindFirstMaxValuePosition(int[,] array)
        {
            if (array is null) throw new ArgumentNullException(nameof(array));

            int y = array.GetLength(0);
            int x = array.GetLength(1);

            if (y == 0) throw new InvalidOperationException(
                "The dimension of the array along the Y axis is zero.");
            if (x == 0) throw new InvalidOperationException(
                "The dimension of the array along the X axis is zero.");

            int yResult = 0;
            int xResult = 0;

            int maxValue = array[0, 0];
            for (int yIndex = 0; yIndex < y; yIndex++)
            {
                for (int xIndex = 0; xIndex < x; xIndex++)
                {
                    if (maxValue < array[yIndex, xIndex])
                    {
                        yResult = yIndex;
                        xResult = xIndex;
                        maxValue = array[yIndex, xIndex];
                    }
                }
            }

            return (yResult, xResult);
        }

[mboze]

Борис Животное, cпасибо вам огромнейшое

Answer 2

[freeExec]

Так ты меняешь местами найденные макс/мин значения, а не где ты их нашёл в массивах. И вообще использовать ref дурной тон. Найди индексы этих значений в массиве и поменяй значения по-человечески.

Comments

[mboze]

Можете показать кодом, пожалуйста?

[freeExec]

mboze, ты нашёл максимальное значение, в какой ячейке оно было?

[mboze]

freeExec, да

[freeExec]

mboze, вот и меняй ее

[mboze]

freeExec, вау, спасибо)

Answer 3

[Eugene]

Вызывая Swap() вы меняете местами значения в переменных maxA и maxB, но этим вы никак не модифицируете массивы, так как int - значимый тип, а не ссылочный.

Предлагаю, вместо сохранения значений минимума и максимума, сохранять индексы ячеек с такими значениями, а функцию Swap() переделать так, чтоб он принимал массивы и индексы заменяемых ячеек и уже редактировать этот массив, меняя в нем местами значения по указанным индексам.

Comments

[mboze]

Подскажите по коду пожалуйста, как заменить значение, если ты знаешь ячейку?

[Eugene]

mboze, когда ты в цикле обращаешься к ячейкам типа A[i, j], то i и j и есть те самые индексы ячеек, сохраняй их в переменных, типа xMinA = i; xMaxA = j;
Разумеется, их тип int