Даны два массива x[1] <= ... <= x[k], y[1] <= ... <= y[l].

[EduDo]

Даны два массива x[1] <= ... <= x[k], y[1] <= ... <= y[l].
Найти их "пересечение", т.е. массив z[1] <= ... <= z[m],
содержащий их общие элементы, причем, кратность каждого элемента
в массиве z равняется минимуму из его кратностей в массивах x и y.
Число действий должно быть порядка k+l.

Ниже Код, выполненый на ПасКАЛЕ, помогите в C# перевести... С синтаксисом никак не могу разобраться

Код: Выделить всё

Program InterSect;
 
Const
  cMaxIndex = 100; { максимальное число элементов для определения массива }
 
Type
  TIndex = 1..cMaxIndex;                 { тип для описания индекса }
  TArray = array [0..cMaxIndex] of Word; { описание массива. Элемент с индексом 0 - верхняя граница массива }
 
Var
  x : TArray; { массив x }
  y : TArray; { массив y }
  z : TArray; { массив z }
 
{ Процедура печати массива }
Procedure Print (a : TArray; title : string);
var
  i : TIndex;
 
begin
  write (title, ':');
  for i := 1 to a [0] do
    write (' ', a [i]);
  writeln;
end;
 
{ Процедура ввода массива }
Procedure Input (var a : TArray; title : string);
var
  i : TIndex;
 
begin
  writeln ('Введите элементы массива ', title, ' (не более ', cMaxIndex, ' элементов). Введите 0 для окончания ввода');
  
  a [0] := 0;
 
  for i := 1 to cMaxIndex do
  begin
    readln (a [i]);
    if a [i] = 0 then break
    else Inc (a [0]);
  end;
end;
 
{ Процедура для вормирования "пересечения" массивов }
Procedure InterSection (a : TArray; b : TArray; var c : TArray);
var
  i : TIndex; { переменная для перебора элементов первого массива }
  j : TIndex; { переменная для перебора элементов второго массива }
 
  n : TIndex; { количество элементов первого массива }
  m : TIndex; { количество элементов второго массива }
 
begin
  n := a [0];
  m := b [0];
 
  c [0] := 0;
  j := 1;
  i := 1;
 
  { пока есть элементы в первом массиве }
  while i <= n do
  begin
    { находим первый элемент во втором массиве, который не меньше текущего из первого }
    while (j <= m) and (b [j] < a [i]) do Inc (j);
    if j > m then break;
 
    { добавляем одинаковые элементы в третий массив (меньшая кратность получается автоматически) }
    while a [i] = b [j] do
    begin
      { Заносим элемент в массив c }
      Inc (c [0]);
      c [c [0]] := a [i];
 
      { переходим к следующим элементам исходных массивов }
      Inc (i);
      Inc (j);
 
      { проверяем границы массивов }
      if (i > n) or (j > m) then break;
    end;
 
    { пропускаем элементы первого массива до тех пор, пока очередной элемент не станет больше или равен текущего элемента второго массива }
    while (i <= n) and (a [i] < b [j]) do Inc (i);  
  end;
end;
 
Begin
  Input (x, 'x');
  Input (y, 'y');
 
  Print (x, 'x');
  Print (y, 'y');
 
  InterSection (x, y, z);
 
  Print (z, 'z');
End.

[MaxXx1313]

Код: Выделить всё

using System;

namespace test_console
{
	class Program
	{
		
		public const int cMaxIndex = 100; // максимальное число элементов для определения массива	
		
		public static void Main(string[] args)
		{
			int[] x = new int[cMaxIndex];
			int[] y = new int[cMaxIndex];
			int[] z = new int[2*cMaxIndex];  // в двва раза больше элементов возможно=)
		
			int sizeX, sizeY, sizeZ;	// по аналогии с тем как надо делать в С++ (я както с массивами не работал покачто в c#)
			
			
		  sizeX = Input (x, "x");
		  sizeY = Input (y, "y");
		
		  Print (x, sizeX, "x");
		  Print (y, sizeY, "y");
		
		  sizeZ = InterSection (x, sizeX, y, sizeY, z);
		
		  Print (z, sizeZ, "z");
		  Console.ReadKey();
		}
		

		// Процедура печати массива
		public static void Print(int[] a, int size, string title)
		{
			Console.WriteLine(title + ":");
		  	for (int i=0; i<= size-1; i++)
		  		Console.Write(" " + a[i]);
		  	Console.WriteLine();
		}


		// Процедура ввода массива
		public static int Input(int[] a, string title)
		{
			Console.WriteLine("Введите элементы массива " + title + " (не более " + cMaxIndex + " элементов). Введите 0 для окончания ввода");
			int i;
			for(i=0; i<=cMaxIndex-1; i++)
			{
				a[i] = int.Parse( Console.ReadLine());
			    if (a[i] == 0)
			        return i;
			}
			return i;
		}
		
		
		// Процедура для формирования "пересечения" массивов
		// возвращает размер массива C
		// память для массива С должна быть ВЫДЕЛЕНА РАНЕЕ
		public static int InterSection( int[] a, int sizeA,  int[] b, int sizeB, int[] c)
		{		
		   int sizeC = 0;
		
		   int i=0;
		   int j=0;
		  // пока есть элементы в первом массиве
		  while(i<=sizeA-1)
		   {
		
		    // находим первый элемент во втором массиве, который не меньше текущего из первого }
		    for(; j<=sizeB-1; j++)
		        if(b[j] >= a[i])
		            break;
		    if (j >= sizeB)
		        break;
		
		    // добавляем одинаковые элементы в третий массив (меньшая кратность получается автоматически) }
		    while (a[i] == b[j])
		    {
		      // Заносим элемент в массив c }
		      c[sizeC] = a[i];
		      sizeC++;
		
		      // переходим к следующим элементам исходных массивов }
		      i++;
		      j++;
		
		      // проверяем границы массивов }
		      if( (i >= sizeA) || (j >= sizeB) )
		          break;
		    }
		
		    // пропускаем элементы первого массива до тех пор, пока очередной элемент не станет больше или равен текущего элемента второго массива }
		    for(;i<=sizeA-1; i++)
		        if(a[i]>=b[j])
		            break;
		  }
		  return sizeC;
		}
		
	}
}