Update main.yml

.github/workflows/main.yml

@@ -27,5 +27,5 @@ jobs:
       working-directory: ./LR1 
 
     - name: Run unit tests
-      run: dotnet test --no-build --verbosity normal
+      run: dotnet test --configuration Release --no-build --verbosity normal
       working-directory: ./LR1

.gitignore

@@ -361,3 +361,7 @@ MigrationBackup/
 
 # Fody - auto-generated XML schema
 FodyWeavers.xsd
+/LR1/DataGeneration/input_data.txt
+/LR1/DataGeneration/min_value.txt
+/LR1/DataGeneration/output_data.txt
+/LR1/AppTesting/Properties/launchSettings.json

LR1/AppTesting.Tests/AppTesting.Tests.csproj

@@ -0,0 +1,22 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.3.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.5">
+      <PrivateAssets>all</PrivateAssets>
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+    </PackageReference>
+    <PackageReference Include="xunit.v3" Version="3.2.2" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\AppTesting\AppTesting.csproj" />
+  </ItemGroup>
+
+</Project>

LR1/AppTesting.Tests/ArrayProcTests.cs

@@ -0,0 +1,44 @@
+using Xunit;
+
+namespace AppTesting
+{
+    public class ArrayProcTests
+    {
+        // Путь 1
+
+        [Fact]
+        public void ArrayProc_Way_1_1()
+        {
+            double[] input = new double[0];
+            var result = Program.ArrayProc(input);
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void ArrayProc_Way_1_2()
+        {
+            double[] input = new double[] { 5.0 };
+            var result = Program.ArrayProc(input);
+            Assert.Null(result);
+        }
+
+        [Fact]
+        public void ArrayProc_Way_1_3()
+        {
+            double[] input = new double[] { 1.0, 2.0, 3.0, 4.0, 5.0 };
+            var result = Program.ArrayProc(input);
+            Assert.Null(result);
+        }
+
+        [Theory]
+        [InlineData(new double[] { })]
+        [InlineData(new double[] { 10.0 })]
+        [InlineData(new double[] { 1.0, 2.0, 3.0 })]
+        [InlineData(new double[] { 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0 })]
+        public void ArrayProc_Way_1_4(double[] input)
+        {
+            var result = Program.ArrayProc(input);
+            Assert.Null(result);
+        }
+    }
+}

LR1/AppTesting.Tests/SearchMinValueTests.cs

@@ -0,0 +1,148 @@
+using Xunit;
+
+namespace AppTesting
+{
+    public class SearchMinValueTests
+    {
+        // Путь 1
+        [Fact]
+        public void SearchMinValue_Way_1()
+        {
+            double[]? inputData = null;
+            var result = Program.SearchMinValue(inputData);
+            Assert.Null(result);
+        }
+
+        // Путь 2
+        [Fact]
+        public void SearchMinValue_Way_2()
+        {
+            double[] inputData = new double[0];
+            var result = Program.SearchMinValue(inputData);
+            Assert.Null(result);
+        }
+
+        // Путь 3
+        [Fact]
+        public void SearchMinValue_Way_3_1()
+        {
+            double[] inputData = new double[] { 42.5 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(42.5, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_3_2()
+        {
+            double[] inputData = new double[] { -15.3 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(-15.3, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_3_3()
+        {
+            double[] inputData = new double[] { 0 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(0, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_3_4()
+        {
+            double[] inputData = new double[] { double.MaxValue };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(double.MaxValue, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_3_5()
+        {
+            double[] inputData = new double[] { double.MinValue };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(double.MinValue, result);
+        }
+
+        // Путь 4
+        [Fact]
+        public void SearchMinValue_Way_4_1()
+        {
+            double[] inputData = new double[] { 5.0, 10.0 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(5.0, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_4_2()
+        {
+            double[] inputData = new double[] { 7.7, 7.7 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(7.7, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_4_3()
+        {
+            double[] inputData = new double[] { 3.0, 4.0, 5.0, 6.0, 7.0 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(3.0, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_4_4()
+        {
+            double[] inputData = new double[] { -8.0, 2.0, 5.0 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(-8.0, result);
+        }
+
+        // Путь 5
+        [Fact]
+        public void SearchMinValue_Way_5_1()
+        {
+            double[] inputData = new double[] { 10.0, 5.0 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(5.0, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_5_2()
+        {
+            double[] inputData = new double[] { 10.0, 3.0, 7.0, 9.0 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(3.0, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_5_3()
+        {
+            double[] inputData = new double[] { 8.0, 6.0, 4.0, 2.0 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(2.0, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_5_4()
+        {
+            double[] inputData = new double[] { 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(5.0, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_5_5()
+        {
+            double[] inputData = new double[] { 9.0, 7.0, 5.0, 3.0, -1.0 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(-1.0, result);
+        }
+
+        [Fact]
+        public void SearchMinValue_Way_5_6()
+        {
+            double[] inputData = new double[] { 5.0, -3.0, 2.0, -600.0, 7.0 };
+            var result = Program.SearchMinValue(inputData);
+            Assert.Equal(-600.0, result);
+        }
+    }
+}

LR1/AppTesting/AppTesting.csproj

@@ -5,6 +5,7 @@
     <TargetFramework>net8.0</TargetFramework>
     <ImplicitUsings>enable</ImplicitUsings>
     <Nullable>enable</Nullable>
+    <StartupObject></StartupObject>
   </PropertyGroup>
 
 </Project>

LR1/AppTesting/Program.cs

@@ -1,54 +1,139 @@
-internal class Program
+using System.Globalization;
-{
-    private static float[] inputArray = {
-    1.5f, -2.4f, 3.1f, 0.5f, 12.7f, -8.2f, 4.4f, 9.0f, 0.0f, 11.1f,
-    -3.3f, 6.7f, 15.2f, 2.8f, 7.0f, -1.1f, 4.9f, 8.3f, 22.5f, 0.2f,
-    5.6f, -9.4f, 13.0f, 1.1f, 3.7f, 18.2f, -4.5f, 6.0f, 0.9f, 10.4f,
-    2.2f, -7.7f, 14.1f, 3.3f, 5.8f, 21.0f, -0.5f, 8.8f, 1.4f, 12.3f,
-    4.0f, -6.1f, 17.5f, 2.9f, 9.2f, 19.8f, -2.2f, 7.4f, 0.3f, 11.9f
-};
 
+public class Program
+{
     private static void Main()
     {
-        Console.WriteLine($"Массив с входными данными: [{string.Join("; ", inputArray)}]");
+        double[] inputArray = ReadInputData(@"D:\Projects\ISTU_TEST_LR1\LR1\DataGeneration\input_data.txt");
+        Console.WriteLine($"Input data: [{string.Join("; ", inputArray)}]");
 
         var outputData = ArrayProc(inputArray);
-        var minValue = SearchMinValue(outputData);
+        WriteToFile(outputData!, "output_data.txt");
 
-        Console.WriteLine($"Массив с выходными данными: [{string.Join("; ", outputData ?? Array.Empty<float>())}]");
+        var minValue = SearchMinValue(outputData!);
-        Console.WriteLine($"Минимальное значенние: {minValue.ToString()}");
+        Console.WriteLine($"Output data: [{(outputData != null ? string.Join(" ; ", outputData) : "null")}]");
+
+        WriteToFile(minValue!, "min_value.txt");
+        Console.WriteLine($"Min value: {minValue.ToString()}");
     }
 
-
+    public static void WriteToFile(double[] data, string filename)
-    private static float SearchMinValue(float[]? inputData)
     {
-        if (inputData == null || inputData.Length == 0) return 0;
+        if (data == null) return;
+
+        using (StreamWriter sw = new StreamWriter(filename))
+        {
+            foreach (var value in data)
+                sw.WriteLine(value.ToString(CultureInfo.InvariantCulture));
+        }
+    }
+
+    public static void WriteToFile(double? data, string filename)
+    {
+        if (data == null) return;
+
+        File.WriteAllText(filename, data.Value.ToString(CultureInfo.InvariantCulture) + Environment.NewLine);
+    }
+
+    private static double[] ReadInputData(string txtFile)
+    {
+        string[] lines = File.ReadAllLines(txtFile);
+        double[] data = new double[lines.Length];
+
+        for (int i = 0; i < lines.Length; i++)
+        {
+            data[i] = double.Parse(lines[i], CultureInfo.InvariantCulture);
+        }
+
+        return data;
+    }
+
+    public static double? SearchMinValue(double[] inputData)
+    {
+        if (inputData == null) return null;
+        if (inputData.Length == 0) return null;
 
         var minValue = inputData[0];
-        for (int i = 1; i < inputData.Length; i++)
+        int i = 1;
+        while (i < inputData.Length)
         {
-            if (inputData[i] < minValue) minValue = inputData[i];
+            if (inputData[i] < minValue)
+                minValue = inputData[i];
+            i++;
         }
         return minValue;
     }
 
-    private static float[]? ArrayProc(float[] inputData)
+    public static double[]? ArrayProc(double[] inputData)
     {
-        float[] outputArray;
+        double[] outputArray;
+        int pairs = 0;
+        int n = inputData.Length - 1;
+
+        int i = 0;
+        while (i <= n / 2)
+        {
+            if (i + 8 <= n)
+                pairs++;
+            i++;
+        }
+
+        if (pairs == 0)
+            return null;
+
+        outputArray = new double[pairs];
+
+        int j = 0;
+        i = 8;
+        while (j < outputArray.Length)
+        {
+            outputArray[j] = inputData[i] * inputData[i - 8];
+            j++;
+            i++;
+        }
+
+        if (outputArray.Length % 2 != 0)
+        {
+            int centralIdx = outputArray.Length / 2;
+            double centralItem = outputArray[centralIdx];
+            outputArray[centralIdx] = centralItem * centralItem;
+        }
+
+        return outputArray;
+    }
+
+    /*
+    private static double? SearchMinValue(double[] inputData)
+    {
+        if (inputData == null || inputData.Length == 0) 
+            return null;
+
+        var minValue = inputData[0];
+        for (int i = 1; i < inputData.Length; i++)
+        {
+            if (inputData[i] < minValue)
+                minValue = inputData[i];
+        }
+        return minValue;
+    }
+    */
+
+    /*
+    private static double[]? ArrayProc(double[] inputData)
+    {
+        double[] outputArray;
         int pairs = 0;
         int n = inputData.Length - 1;
         for (int i = 0; i <= n / 2; i++)
         {
-            if (i + 8 <= n) pairs++;
+            if (i + 8 <= n) 
+                pairs++;
         }
 
         if (pairs == 0) 
-        {
-            Console.WriteLine("Размер массива не соответствует условию");
             return null;
-        }
 
-        outputArray = new float[pairs];
+        outputArray = new double[pairs];
 
         for (int i = 8, j = 0; j < outputArray.Length; j++, i++)
         {
@@ -58,10 +143,10 @@
         if (outputArray.Length % 2 != 0)
         {
             int centralIdx = outputArray.Length / 2;
-            float centralItem = outputArray[centralIdx];
+            double centralItem = outputArray[centralIdx];
             outputArray[centralIdx] = centralItem * centralItem;
         }
         return outputArray;
     }
-
+    */
 }

LR1/DataGeneration/DataGeneration.py

@@ -1,24 +1,63 @@
 import random
-import struct
 
-MIN_FLOAT = -3.4028235e38 
+MIN_VAL = -3.4028235e38
-MAX_FLOAT = 3.4028235e38
+MAX_VAL = 3.4028235e38
 
-def generate_and_solve():
+MIN_VAL = -500.0
+MAX_VAL = 500.0
+
+def generate_input_data():
     length = random.randint(0, 1024)
-    input_data = [random.uniform(MIN_FLOAT, MAX_FLOAT) for _ in range(length)]
+    input_data = [random.uniform(MIN_VAL, MAX_VAL) for _ in range(length)]
+    return input_data
 
+
+def write_to_file(data, filename):
+    with open(filename, 'w') as file:
+        if not isinstance(data, list):
+            data = [data]
+        for value in data:
+            file.write(str(value) + '\n')
+
+def search_min_value(input_data):
+
+    if not input_data:
+        return 0
+
+    min_value = input_data[0]
+    for i in range(1, len(input_data)):
+        if input_data[i] < min_value:
+            min_value = input_data[i]
+    return min_value
+
+def array_proc(input_data):
+
+    if not input_data:
+        return None
+
+    pairs = 0
     n = len(input_data) - 1
-    limit = n // 2
+    for i in range(n // 2 + 1):
-    pairs = []
-    for i in range(limit + 1):
         if i + 8 <= n:
-            pairs.append(input_data[i] * input_data[i+8])
+            pairs += 1
 
-    if len(pairs) % 2 != 0:
+    if pairs == 0:
-        mid = len(pairs) // 2
+        return None
-        pairs[mid] = pairs[mid] ** 2
 
+    output_array = [0.0] * pairs
+    for i in range(8, 8 + pairs):
+        output_array[i - 8] = input_data[i] * input_data[i - 8]
 
+    if len(output_array) % 2 != 0:
+        central_idx = len(output_array) // 2
+        output_array[central_idx] = output_array[central_idx] ** 2
+    return output_array
 
-generate_and_solve()
+input_data = generate_input_data()
+write_to_file(input_data, "input_data.txt");
+
+output_data = array_proc(input_data)
+write_to_file(output_data, "output_data.txt");
+
+min_value = search_min_value(output_data)
+write_to_file(min_value, "min_value.txt");

LR1/LR1.sln

@@ -1,12 +1,14 @@
 
 Microsoft Visual Studio Solution File, Format Version 12.00
-# Visual Studio Version 17
+# Visual Studio Version 18
-VisualStudioVersion = 17.14.36705.20 d17.14
+VisualStudioVersion = 18.2.11430.68 d18.0
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AppTesting", "AppTesting\AppTesting.csproj", "{A02E459C-F603-4AC3-BEA4-00610EB22632}"
 EndProject
 Project("{888888A0-9F3D-457C-B088-3A5042F75D52}") = "DataGeneration", "DataGeneration\DataGeneration.pyproj", "{3032CD08-5B57-4966-95CE-53274D36CE2E}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AppTesting.Tests", "AppTesting.Tests\AppTesting.Tests.csproj", "{047C52F4-BF4B-4C29-BD8A-42CAB4E117F2}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -19,6 +21,10 @@ Global
 		{A02E459C-F603-4AC3-BEA4-00610EB22632}.Release|Any CPU.Build.0 = Release|Any CPU
 		{3032CD08-5B57-4966-95CE-53274D36CE2E}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
 		{3032CD08-5B57-4966-95CE-53274D36CE2E}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{047C52F4-BF4B-4C29-BD8A-42CAB4E117F2}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{047C52F4-BF4B-4C29-BD8A-42CAB4E117F2}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{047C52F4-BF4B-4C29-BD8A-42CAB4E117F2}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{047C52F4-BF4B-4C29-BD8A-42CAB4E117F2}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE