static void Main(string[] args)
{
int arraySize;
string errorMessage = "Некорректное значение! Нажмите любую клавишу для выхода";
Console.WriteLine("Привет! Создадим одномерный массив целых чисел! Введи его размер:");
if (int.TryParse(Console.ReadLine(), out arraySize) && arraySize > 0)
{
int [] myArray = ArrayMethods.CreatIntArray(arraySize);
ArrayMethods.PrintOneSideArr(myArray);
SumOfPositiveElements(myArray);
int sum = SumOfPositiveElements(myArray);
Console.WriteLine($"Сумма положительных элементов : {sum}");
Console.WriteLine("Нажмие любую клавишу для выхода.");
Console.ReadKey();
return;
}
else
{
Console.WriteLine(errorMessage);
Console.ReadKey();
return;
}
}
public MatrisBase <object> Mul(MatrisBase <object> df,
int numberOnly = 1)
{
if (!df.IsValid())
{
throw new Exception(CompilerMessage.DF_INVALID_SIZE);
}
int nc = df.Col;
int nr = df.Row;
List <object> muls = new List <object>();
for (int c = 0; c < nc; c++)
{
muls.Add(ArrayMethods.ArrayMul(df.ColList(c, 0), 0, nr, numberOnly) ?? float.NaN);
}
return(df is Dataframe data
? new Dataframe(new List <List <object> >()
{
muls
},
data.Delimiter,
data.NewLine,
null,
Dataframe.GetCopyOfLabels(data.GetColLabels()),
null,
data.GetColSettings().Copy())
: new MatrisBase <object>(new List <List <object> >()
{
muls
}));
}
public void SumTest(int[] numbers, int expected)
{
ArrayMethods sumofall = new ArrayMethods();
int actual = sumofall.SumMethod(numbers, expected);
Assert.AreEqual(expected, actual);
}
public void CommonEndTest(int[] a, int[] b, bool expected)
{
ArrayMethods common = new ArrayMethods();
bool actual = common.CommonEnd(a, b, expected);
Assert.AreEqual(expected, actual);
}
public void SameFirstLastTest(int[] numbers, bool expected)
{
ArrayMethods six = new ArrayMethods();
bool actual = six.SameFirstLast(numbers);
Assert.AreEqual(expected, actual);
}
public void Unlucky1Test(int[] numbers, bool expected)
{
ArrayMethods fix = new ArrayMethods();
bool actual = fix.UnluckyOne(numbers, expected);
Assert.AreEqual(expected, actual);
}
public void Double23Test(int[] numbers, bool expected)
{
ArrayMethods doubles = new ArrayMethods();
bool actual = doubles.Double23(numbers, expected);
Assert.AreEqual(expected, actual);
}
public void HasEvenTest(int[] numbers, bool expected)
{
ArrayMethods even = new ArrayMethods();
bool actual = even.HasEven(numbers);
Assert.AreEqual(expected, actual);
}
public void KeepLastTest(int[] numbers, int[] expected)
{
ArrayMethods middle = new ArrayMethods();
int[] actual = middle.KeepLast(numbers, expected);
Assert.AreEqual(expected, actual);
}
public void MakePiTest(int n, int [] expected)
{
ArrayMethods make = new ArrayMethods();
int [] actual = make.MakePi(n);
Assert.AreEqual(expected, actual);
}
public void make2Test(int[] a, int[] b, int[] expected)
{
ArrayMethods make = new ArrayMethods();
int [] actual = make.make2(a, b);
Assert.AreEqual(expected, actual);
}
public void Fix23Test(int[] numbers, int[] expected)
{
ArrayMethods fix = new ArrayMethods();
int[] actual = fix.Fix23(numbers, expected);
Assert.AreEqual(expected, actual);
}
public void RotateLeftTest(int[] numbers, int[] expected)
{
ArrayMethods rotate = new ArrayMethods();
int [] actual = rotate.RotateLeft(numbers, expected);
Assert.AreEqual(expected, actual);
}
public void GetMiddleTest(int[] a, int[] b, int[] expected)
{
ArrayMethods middle = new ArrayMethods();
int[] actual = middle.GetMiddle(a, b, expected);
Assert.AreEqual(expected, actual);
}
public void HigherWinsTest(int[] numbers, int[] expected)
{
ArrayMethods higher = new ArrayMethods();
int[] actual = higher.HigherWins(numbers, expected);
Assert.AreEqual(expected, actual);
}
public void ReverseTest(int[] numbers, int[] expected)
{
ArrayMethods rev = new ArrayMethods();
int[] actual = rev.Reverse(numbers, expected);
Assert.AreEqual(expected, actual);
}
static CyclicArray <Edge <T> > NegativeEdgeRotationOfCellAfter(Edge <T> first, int offset)
{
Edge <T>[] edgesOfCell = first.Cell.Edges;
Edge <T>[] reversedEdges = ArrayMethods.GetReverseOrderArray(edgesOfCell);
int firstEdgeIndice = FindIndiceOfEdgeInItsCell(reversedEdges, first);
CyclicArray <Edge <T> > edges = new CyclicArray <Edge <T> >(reversedEdges, firstEdgeIndice + offset);
return(edges);
}
static void ShowResultTrans(int[][,] ar)
{
Console.WriteLine("Transported");
ar[num - 1] = ArrayMethods.TransposeMatrix(ar[num - 1]);
ShowResult(ar[num - 1]);
ShowTopResult(ar[num - 1]);
ShowBotResult(ar[num - 1]);
Console.WriteLine("==============");
}
/*
* I assume you are trying to
* 1. Create an array of integers
* 2. Store random numbers (between 0 and 100) inside that array
* 3. Print the numbers in the array
* You have alot of reading to do as theres alot of fundemental mistakes in both your approach and code.
*/
static void Main(string[] args)
{
// creating an array with random numbers
ArrayMethods m = new ArrayMethods();
int[] nums1;
nums1 = m.CreateRandomlyFilledArray(10);
m.Printarray(nums1);
}
public void Can_binary_search(int key, int[] input, int expected)
{
// Arrange
// from data
// Act
int result = ArrayMethods.BinarySearch(key, input);
// Assert
Assert.Equal(expected, result);
}
public void TryToParseIllegalIndexOfArrayLengthToDeleteButReturnsOriginalArray()
{
// Arrange
string[] normalArray = new string[] { "1", "2", "3", "4" };
// Act
string[] testedArray = ArrayMethods.DeleteArrayAtIndex(normalArray, normalArray.Length);
// Assert
CollectionAssert.AreEqual(normalArray, testedArray);
}
public void TryToReverseEmptyArray()
{
// Arrange
string[] emptyArray = new string[0];
// Act
string[] testedArray = ArrayMethods.ReverseArray(emptyArray);
// Assert
CollectionAssert.AreEqual(emptyArray, testedArray);
}
public string ToString(string delimiter)
{
try
{
return(ArrayMethods.JoinList(Lines, delimiter));
}
catch (NullReferenceException)
{
return("");
}
}
/// <summary>
/// Message to string
/// </summary>
/// <param name="value"></param>
/// <param name="targetType"></param>
/// <param name="parameter"></param>
/// <param name="culture"></param>
/// <returns></returns>
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
try
{
return(ArrayMethods.JoinList((List <string>)value, "\r\n"));
}
catch (NullReferenceException)
{
return("");
}
}
public void ReverseArrayTestSequentialNumbers()
{
// Arrange
string[] normalArray = new string[] { "1", "2", "3" };
string[] expectedArray = new string[] { "3", "2", "1" };
// Act
string[] testedArray = ArrayMethods.ReverseArray(normalArray);
// Assert
CollectionAssert.AreEqual(expectedArray, testedArray);
}
public void DeleteArrayAtIndexOfArrayLength()
{
// Arrange
string[] normalArray = new string[] { "1", "2", "3" };
string[] expectedArray = new string[] { "1", "2" };
// Act
string[] testedArray = ArrayMethods.DeleteArrayAtIndex(normalArray, normalArray.Length - 1);
// Assert
CollectionAssert.AreEqual(expectedArray, testedArray);
}
public void Can_binary_search_100000()
{
// Arrange
int[] input = new int[100000];
for (int i = 1; i < input.Length; i++)
{
input[i - 1] = i;
}
int key = 200000;
int expected = -1;
// Act
int result = ArrayMethods.BinarySearch(key, input);
// Assert
Assert.Equal(expected, result);
}
CellPairCollection <T> .EdgeCombo ExtractMergePairs(
CellPairCollection <T> .EdgeCombo edgePair,
CellPairCollection <T> candidates)
{
var mergePair = new CellPairCollection <T> .EdgeCombo(edgePair.EdgeNumber);
int pairedBoundary = map.PeriodicBoundaryCorrelation[edgePair.EdgeNumber];
candidates.TryGetOuterCells(pairedBoundary, out List <(MeshCell <T>, bool)> pairedOuterCells);
mergePair.Outer = pairedOuterCells;
mergePair.Inner = new List <(MeshCell <T>, bool)>(ArrayMethods.GetReverseOrderArray(edgePair.Inner));
Debug.Assert(mergePair.Outer.Count == mergePair.Inner.Count);
cleaner.RemoveAlreadyDealtWithCornerCellMergePairsFrom(mergePair);
InitializeGlueMapOf(mergePair);
return(mergePair);
}
public MatrisBase <object> Mean(MatrisBase <object> df,
int numberOnly = 1)
{
if (!df.IsValid())
{
throw new Exception(CompilerMessage.DF_INVALID_SIZE);
}
int nc = df.Col;
int nr = df.Row;
List <object> means = new List <object>();
int pop;
for (int c = 0; c < nc; c++)
{
pop = nr - (numberOnly == 1 ? df.AmountOfNanInColumn(c) : 0);
object res = ArrayMethods.ArraySum(df.ColList(c, 0), 0, nr, numberOnly) ?? float.NaN;
if (pop == 0)
{
means.Add(float.NaN);
}
else
{
means.Add(float.IsNaN((float)res) ? res : (float)res / pop);
}
}
return(df is Dataframe data
? new Dataframe(new List <List <object> >()
{
means
},
data.Delimiter,
data.NewLine,
null,
Dataframe.GetCopyOfLabels(data.GetColLabels()),
null,
data.GetColSettings().Copy())
: new MatrisBase <object>(new List <List <object> >()
{
means
}));
}
static void Main(string[] args)
{
int[] myArray = new int[] { 1, 23, 54, 67, 6, 90, 5, 7, 33, 73, 98, 55887, 38, 369, 95894, 561279, 12345637, 542987, 7774 };
int number = 7;
int[] newArray = ArrayMethods.FindNumeralInArray(myArray, number);
if (newArray != null)
{
for (int i = 0; i < newArray.Length; i++)
{
Console.WriteLine(newArray[i]);
}
}
else
{
Console.WriteLine("Array is null or empty");
}
Console.ReadLine();
}
