Z c++ na c#

Nigdy nie robilem w c#, a teraz zaczynam sie uczyc. Ma ktos pomysl jak taki prosty programik z c++ przerobic na c#?

#include <iostream> 
#include <math.h> 
using namespace std; 


float Heron(float a, float b, float c){ 
    float p=(a+b+c)/2; 
    return sqrt(p*(p-a)*(p-b)*(p-c)); 
} 

int main(){ 
    float a,b,c; 
    cout << "Podaj a: "; 
    cin >> a; 
    cout << "Podaj b: "; 
    cin >> b; 
    cout << "Podaj c: "; 
    cin >> c; 
    if(a<=0 || b<=0 || c<=0){ 
        cout << " Wszystkie wartosci musza byc wieksze od 0!\n"; 
        system("pause"); 
        return 1; 
    } 
    if(!(c<a+b) || !(a<b+c) || !(b<a+c)){ 
       cout << "Podany trojkat nie istnieje!\n"; 
       system("pause"); 
       return 1; 
    } 
    else{ 
        cout << "Pole trojkata = " << Heron(a,b,c) << endl; 
        system("pause"); 
        return 0; 
    } 
}

No chwila, gdyby było proste, to chyba byś sam zrobił, nie?

Albo napisz z czym konkretnie masz problem albo poproś moderatora o przeniesienie wątku do działu praca. Jeżeli nie masz zielonego pojęcia o C# to polecam się zapatrzyć w podręcznik, a nie oczekiwać, że ktoś zrobi każde zadanie za ciebie.

Kolega dostał prawdopodobnie zadanie z zaznaczeniem "napisz to w c#", a w sieci udało się znaleźć tylko w c++. No i problem... Może zacznij od kursu, podstaw... Np. Rozdział 3

REGULAMIN napisał(a)

Zabronione jest umieszczanie w postach prośby o rozwiązanie zadań domowych, zadań zaliczeniowych. Lenistwo nie jest tolerowane. Można poprosić o rozwiązanie konkretnego problemu, a nie całego zadania, paru zadań.

A więc pokaż z czym masz konkretnie problem, co się nie udaje...

Poczytaj o głównej konstrukcji programu w C# i na tym się wzoruj. To są odpowiedniki C++ w C#:

cout = Console.WriteLine(...) lub Console.Write(...) (bez \n na końcu);
cin = Console.ReadLine(), z tym, że jak chcesz wczytać int'a to parsujesz wartość metody na int'a
system("pause") = Console.Read() lub Console.ReadKey() (bez entera)
// a odpowiednik math.h to statyczna klasa Math i w niej masz wszystko

Reszta jak w CPP.

kolega siedzi w domu i te zadania sa brane z sieci;f

Witam. Mógłby mi ktoś pomóc w przerobieniu dwóch programów a konkretnie:

-------------PIERWSZY PROGRAM-----------------

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <ctime>
using namespace std;

//======================================================================
/*
Dwuwymiarowa tablica z danymi. Pierwszy indeks to numer paczki o rozmiarze [indeks+1]*10 000, drugi to zawartosc paczki.
Przyklad:
dane[0] to tablica z (0+1)*10000 = 10000 elementow
dane[1] to tablica z (1+1)*10000 = 20000 elementow
dane[2] to tablica z (2+1)*10000 = 30000 elementow
dane[9] przechowuje paczke z (9+1)*10000 = 100 000 elementow
*/
int *dane[10];

// zakres danych w paczce, z ktorego beda losowane liczby
// (losowane od 0 do dane_max)
int dane_max = 10000;

void generuj_dane()
{
// tworzymy paczki z danymi
for (int i = 0; i < 10; i++)
{
// liczba elementow w paczce
int n = (i+1) * 10000;
// tworzymy tablice z paczka
dane[i] = new int[n];

	// wypelniamy paczke losowymi wartosciami z zakresu
	for (int j = 0; j < n; j++)
	{
		dane[i][j] = rand() % (dane_max+1);
	}
}

}

void zwolnij_dane()
{
for (int i = 0; i < 10; i++)
{
if (dane[i])
{
delete [] dane[i];
dane[i] = NULL;
}
}
}

//======================================================================
/*
Jak naliczane sa porownania? W kazdym wywolaniu petli for dodajemy
jedno, a po jej zakonczeniu kolejne - petla for wykonuje sie n+1 razy
dla n elementow, poniewaz ostatni jest sprawdzany przed zakonczeniem
petli.
*/

// sortujemy tablice za pomoca metody przez wybor

// w porownania i operacje zapisuje odpowiednie wartosci
void sortuj_wybor(int *tablica, int n, unsigned int &porownania, unsigned int &operacje)
{
// tablica pomocnicza, ktora zawiera posortowane dane
int *tablica_s = new int[n];
// przepisanie tablicy, zeby nie operowac na porcji danych
for (int i = 0; i < n; i++)
{
tablica_s[i] = tablica[i];
}

// dzialania algorytmu
for (int i = 0; i < n; i++)
{
	++porownania;
	int min = i;
	for (int j = i+1; j < n; j++)
	{
		++porownania;
		if (tablica_s[j] < tablica_s[min])
		{
			min = j;
		}
		++porownania;
	}				   
	++porownania;
	swap(tablica_s[i], tablica_s[min]);
	++operacje;
}
++porownania;

// zwalniamy pamiec i zwracamy wynik
if (tablica_s)
{
	delete [] tablica_s;
}

}

// sortowanie przez zliczanie
void sortuj_zliczanie(int *tablica, int n, unsigned int &porownania, unsigned int &operacje)
{
// tablica pomocnicza, ktora zawiera zliczone wartosci
int *tablica2 = new int[dane_max+1];
// tablica pomocnicza, ktora zawiera posortowane dane
int *tablica_s = new int[n];

// zerowanie tablicy
for (int i = 0; i <= dane_max; i++)
{
	tablica2[i] = 0;
	++porownania;
}
++porownania;

// zliczanie wystapien poszczegolnych elementow
for (int i = 0; i < n; i++)
{
	tablica2[tablica[i]]++;
	++porownania;
	++operacje;
}
++porownania;

// przepisanie tablicy pomocniczej do tablicy wyjsciowej
int k = 0;
for (int i = 0; i < dane_max; i++)
{
	++porownania;
	for (int j = 0; j < tablica2[i]; j++)
	{
		tablica_s[k++] = i;
		++operacje;
		++porownania;
	}
	++porownania;
}
++porownania;

// zwolnienie pamieci
if (tablica2)
	delete [] tablica2;
if (tablica_s)
	delete [] tablica_s;

}

//======================================================================
// uruchomienie testu dla danej partii
// partia - 1...10
void test(int partia)
{
generuj_dane();

cout << "Test dla partii " << ((partia) * 10000) << " elementow - porownania/przestawienia:" << endl;
cout << "==============================================================================" << endl;
int ilosc_testow = 10;
// czas1 - sortowanie przez zliczanie, czas2 - sortowanie przez wybor
unsigned int porownania1_suma = 0, operacje1_suma = 0, porownania2_suma = 0, operacje2_suma = 0;

cout << setw(12) << "Test";
cout << setw(25) << "Zliczanie";
cout << setw(25) << "Wybor";
cout << endl;

// wykonanie okreslonej ilosci testow
for (int i = 1; i <= ilosc_testow; i++)
{
	generuj_dane();

	// wykonanie testow
	unsigned int p1 = 0, p2 = 0, o1 = 0, o2 = 0;
	sortuj_zliczanie(dane[partia-1], (partia)*10000, p1, o1);
	sortuj_wybor(dane[partia-1], (partia)*10000, p2, o2);
	porownania1_suma += p1;
	operacje1_suma += o1;
	porownania2_suma += p2;
	operacje2_suma += o2;

	// wyswietlenie wynikow
	cout << setw(12) << i;
	cout << setw(12) << p1 << "/" << setw(12) << o1;
	cout << setw(12) << p2 << "/" << setw(12) << o2;
	cout << endl;

	// zwalniamy dane
	zwolnij_dane();
}

cout << setw(12) << "Srednia";
cout << setw(12) << (porownania1_suma/ilosc_testow) << "/";
cout << setw(12) << (operacje1_suma/ilosc_testow);
cout << setw(12) << (porownania2_suma/ilosc_testow) << "/";
cout << setw(12) << (operacje2_suma/ilosc_testow);
cout << endl;
cout << "Koniec testu";
cout << endl << endl;

}

//======================================================================
// uruchamiamy testy
int main()
{
srand(time(NULL));

while (true)
{
	int partia = 0;
	cout << "Uruchom test nr (testy: 1...10, wyjscie: 0): ";
	cin >> partia;

	if (partia >= 1 && partia <= 10)
	{
		system("cls");
		test(partia);
	}
	else
	{
		break;
	}
}

system("pause");

return 0;

}

------------DRUGI PROGRAM--------------

#include <iostream>
#include <cstdlib>
#include <iomanip>
#include <ctime>
using namespace std;

//======================================================================
/*
Dwuwymiarowa tablica z danymi. Pierwszy indeks to numer paczki o rozmiarze [indeks+1]*10 000, drugi to zawartosc paczki.
Przyklad:
dane[0] to tablica z (0+1)*10000 = 10000 elementow
dane[1] to tablica z (1+1)*10000 = 20000 elementow
dane[2] to tablica z (2+1)*10000 = 30000 elementow
dane[9] przechowuje paczke z (9+1)*10000 = 100 000 elementow
*/
int *dane[10];

// zakres danych w paczce, z ktorego beda losowane liczby
// (losowane od 0 do dane_max)
int dane_max = 10000;

void generuj_dane()
{
// tworzymy paczki z danymi
for (int i = 0; i < 10; i++)
{
// liczba elementow w paczce
int n = (i+1) * 10000;
// tworzymy tablice z paczka
dane[i] = new int[n];

	// wypelniamy paczke losowymi wartosciami z zakresu
	for (int j = 0; j < n; j++)
	{
		dane[i][j] = rand() % (dane_max+1);
	}
}

}

void zwolnij_dane()
{
for (int i = 0; i < 10; i++)
{
if (dane[i])
{
delete [] dane[i];
dane[i] = NULL;
}
}
}

//======================================================================
// sortujemy tablice za pomoca metody przez wybor

// w porownania i operacje zapisuje odpowiednie wartosci
double sortuj_wybor(int *tablica, int n)
{
// tablica pomocnicza, ktora zawiera posortowane dane
int *tablica_s = new int[n];
// przepisanie tablicy, zeby nie operowac na porcji danych
for (int i = 0; i < n; i++)
{
tablica_s[i] = tablica[i];
}

clock_t start = clock();
// dzialania algorytmu
for (int i = 0; i < n; i++)
{
	int min = i;
	for (int j = i+1; j < n; j++)
	{
		if (tablica_s[j] < tablica_s[min])
		{
			min = j;
		}
	}
	swap(tablica_s[i], tablica_s[min]);
}

double czas = (clock()-start)/(double)CLOCKS_PER_SEC;

// zwalniamy pamiec i zwracamy wynik
if (tablica_s)
{
	delete [] tablica_s;
}

return czas;

}

// sortowanie przez zliczanie
double sortuj_zliczanie(int *tablica, int n)
{
// tablica pomocnicza, ktora zawiera zliczone wartosci
int *tablica2 = new int[dane_max+1];
// tablica pomocnicza, ktora zawiera posortowane dane
int *tablica_s = new int[n];

double start = clock();

// zerowanie tablicy
for (int i = 0; i <= dane_max; i++)
{
	tablica2[i] = 0;
}

// zliczanie wystapien poszczegolnych elementow
for (int i = 0; i < n; i++)
{
	tablica2[tablica[i]]++;
}

// przepisanie tablicy pomocniczej do tablicy wyjsciowej
int k = 0;
for (int i = 0; i < dane_max; i++)
{
	for (int j = 0; j < tablica2[i]; j++)
	{
		tablica_s[k++] = i;
	}
}
double czas = (clock()-start)/(double)CLOCKS_PER_SEC;

// zwolnienie pamieci
if (tablica2)
	delete [] tablica2;
if (tablica_s)
	delete [] tablica_s;

return czas;

}

//======================================================================
// uruchomienie testu dla danej partii
// partia - 1...10
void test(int partia)
{
generuj_dane();

cout << "Test dla partii " << ((partia) * 10000) << " elementow - czas wykonywania:" << endl;
cout << "==============================================================================" << endl;
int ilosc_testow = 10;
// czas1 - sortowanie przez zliczanie, czas2 - sortowanie przez wybor
double czas1_suma = 0.0, czas2_suma = 0.0;

cout << setw(10) << "Test";
cout << setw(13) << "Zliczanie";
cout << setw(13) << "Wybor";
cout << endl;

// wykonanie okreslonej ilosci testow
for (int i = 1; i <= ilosc_testow; i++)
{
	generuj_dane();

	// wykonanie testow
	double czas1 = sortuj_zliczanie(dane[partia-1], (partia)*10000);
	double czas2 = sortuj_wybor(dane[partia-1], (partia)*10000);
	czas1_suma += czas1;
	czas2_suma += czas2;

	// wyswietlenie wynikow
	cout << setw(10) << i;
	cout << setw(10) << czas1 << " s.";
	cout << setw(10) << czas2 << " s.";
	cout << endl;

	// zwalniamy dane
	zwolnij_dane();
}

cout << setw(10) << "Srednia";
cout << setw(10) << (czas1_suma/ilosc_testow) << " s.";
cout << setw(10) << (czas2_suma/ilosc_testow) << " s.";
cout << endl;
cout << "Koniec testu";
cout << endl << endl;

}

//======================================================================
// uruchamiamy testy
int main()
{
srand(time(NULL));

while (true)
{
	int partia = 0;
	cout << "Uruchom test nr (testy: 1...10, wyjscie: 0): ";
	cin >> partia;

	if (partia >= 1 && partia <= 10)
	{
		system("cls");
		test(partia);
	}
	else
	{
		break;
	}
}

system("pause");

return 0;

}

z góry dzięki za pomoc.

CTRL+C , CTRL+V

Pozmieniać będziesz musiał wskaźniki z "typ* nazwa" na "typ[] nazwa" i usunąc wszelkie cout,cin,system(""), oraz zmienić iteracje po wskaźnikach na iteracje po indeksach tablicy.

Witam. Mógłby mi ktoś pomóc w przerobieniu dwóch programów a konkretnie:
Pomóc możemy, ale musiałbyś zadać jakieś pytania

z góry dzięki za pomoc.
polecam się na przyszłość :P

Dzisiaj wieczorem ci to przetlumacze. W ramach cwiczen.