Tömbök és Listák

Írj metódust, ami kiszámolja egy paraméterben kapott float tömb elemeinek szorzatát és visszatér az eredménnyel!

float Mean(float[] array)
{
	float product = 1;
	for (int i = 0; i < array.Length; i++)
	{
		product *= array[i];
	}
	return product;
}

Írj metódust, ami kiszámolja egy paraméterben kapott float tömb elemeinek átlagát és visszatér az eredménnyel!

float Mean(float[] array)
{
	float sum = 0;
	for (int i = 0; i < array.Length; i++)
	{
		sum += array[i];
	}
	return sum / array.Length;
}

Írj metódust, ami kap egy int típusú paramétert, nevezzük length-nek!

A metódus létrehoz egy length elemű int tömböt, és feltölti azt 1-től length-ig sorban számokkal. A metódus ezzel a tömbbel tér vissza.

int[] GetFilledArray(int length)
{
	int[] array = new int[length];
	for (int i = 1; i <= length; i++)
	{
		array[i] = i;
	}
	return array;
}

Írj metódust, ami egy paraméterben kap egy egész számot, nevezzük length-nek.

A metódus létrehoz egy length elemű int tömböt, és feltölti azt első length darab olyan természetes számmal, ami nem osztható sem 4-mal sem 5-tel!

int[] GetFilledArray(int length)
{
	// Létrehozom tömböt és feltöltöm
	int[] array = new int[length];
	int count = 0;
	for (int i = 1; count < length; i++)
	{
		if(i % 4 != 0 && i % 5 != 0)
		{
			arrayA[count] = i;
			count++;
		} 
	}
}

Írj metódust, ami egy paraméterben kap egy egész számot, nevezzük max-nek.

A metódus létrehoz egy int tömböt, és feltölti azt az összes olyan természetes számmal, ami nem osztható sem 4-mal sem 5-tel és kisebb vagy egyenlő, mint max!

A tömb pont annyi elemű legyen, mint ahány ilyen szám létezik!

int[] GetFilledArray(int max)
{
	// Először megszámoljuk az elemeket
	int count = 0;
	for (int i = 1; i < max; i++)
	{
		if(i % 4 != 0 && i % 5 != 0)
		{ 
			count++;
		} 
	}

	// Létrehozom tömböt és feltöltöm 
	int[] array = new int[count ];
	count = 0;
	for (int i = 1; i < max; i++)
	{
		if(i % 4 != 0 && i % 5 != 0)
		{
			arrayA[count] = i;
			count++;
		} 
	}
}

int[] GetFilledArray(int max)
{
	// Létrehozom listát és feltöltöm 
	List<int> list = new List<int>();
	for (int i = 1; i < max; i++)
	{
		if(i % 4 != 0 && i % 5 != 0)		
			list.Add(i);		
	}

	return list.ToArray();
}

Írj függvényt, ami visszaadja egy paraméterben kapott float tömb legkisebb értékét!

Írj függvényt, ami visszaadja egy paraméterben kapott float tömb legnagyobb értékét!

Írjunk eljárást, ami egy paraméterben kapott int tömböt átalakít úgy, hogy a tartalma fordított sorrendben szerepeljen benne!

Pl.: { 1, 2, 3, 4, 5 } → { 5, 4, 3, 2, 1 }

A feladatot oldd meg, hogy az eljáráson belül nem hozol létre új tömböt!

void ChangeOrder(int[] array)
{
	if (array == null)
		return; 
	        
	// A sorozat hosszának feléig iterálok:
	for (int i = 0; i < array.Length / 2; i++)
	{
		// Hátulról i-edik index
		int i2 = array.Length - 1 - i;
		
		// Kicserélem i-edik és i2-edik indexen lévő elemet
		int temp = array[i];    // Szükség van egy segédváltozóra
		array[i] = array[i2];
		array[i2] = temp;
	} 
}

Írj függvényt, ami egy paraméterben megadott int tömb tartalmát fordított sorrendben átmásolja egy újonnan létrehozott tömbbe és visszatér vele!

int[] ChangeOrder(int[] array)
{
	if (array == null)
		return null; 
	        
	int[] newArray = new int[array.Length];
	        
	for (int i = 0; i < array.Length; i++)
	{
		// Hátulról i-edik index
		int i2 = array.Length - 1 - i;
		            
		// Fordítva töltöm fel az új tömböt:
		newArray[i] = array[i2];
	}

	return newArray;
} 

Írj függvényt, ami két paraméterként kapott string tömböt összefűz egy új hosszabb tömbbé, amiben mindkét tömb elemei szerepelnek, majd visszaadja ezt a nagyobb tömböt.

Pl: {”AAA”, “BBB”, ”CCC”} + {”DDD”, ”EEE”} → { "AAA”, “BBB”, “CCC”, “DDD”, “EEE” }

string[] Combine(string[] a1, string[] a2)
{
	string[] c = new string[a1.Length + a2.Length];
	
	for (int i = 0; i < a1.Length; i++)
		c[i] = a1[i];
	
	for (int i = 0; i < a2.Length; i++)
		c[a1.Length + i] = a2[i];
	
	return c;
}

Írj függvényt, ami kap egy int tömböt paraméterként. A függvény egy string-gel tér vissza aminek tartalma a tömb elemei vesszővel elválasztva.

A string elején és végén kapcsos zárójel van.

Példa kimenet: {4, 5, 54, 32, -6, 0}

string ArrayToString(int[] a)
{
	if(a == null || a.Length == 0)
		return "{ }";
	        
	string result = "{";
	for (int i = 0; i < a.Length-1; i++)    
		result += a[i] + ", ";
	
	result += a[a.Length-1];
	        
	result += "}";
	return result;
}

Írj függvényt, ami visszaadja egy elemről, hogy szerepel-e egy tömbben.

A függvény két paramétere a tömb és a tesztelt elem.

bool Contains(string[] strings, string element)
{
	foreach (string str in strings)
	{
		if (str == element)
			return true;
	}
	return false;
}

Írj függvényt, ami visszaad egy int tömböt, aminek tartalma a Fibonacci sor első első n száma!

”n” szám a függvény int típusú és egyetlen paramétere.

int[] Fibonacci(int length)
{
	int[] result = new int[length];
	        
	if(length > 0)
		result[0] = 0;
	        
	if(length > 1)
		result[1] = 1;
	
	for (int i = 2; i < length; i++)
		result[i] = result[i - 1] + result[i - 2];
	        
	return result;
}

Írj komponenst, aminek meg lehet adni [SerializeField] beállításként GameObject-eknek egy sorozatát (tömbjét vagy listáját).

A komponens gombnyomásra példányosít (Instantiate), azaz létrehoz egy véletlen elemet a sorozatból, de mindenképp olyat, amiből (ebben a körben) még nem hozott létre.

Ha elfogynak az elemek kezdi elölről az egészet. (Új kör)

Írj függvényt, ami paraméterként megadott string-ről mondjátok meg, hogy palindrom-e! A választ egy kimeneti bool változó tartalmazza!

A palindrom olyan szó vagy szókapcsolat, amely visszafelé olvasva is ugyanaz.

Ha tudod, old meg ne csak szavakra, de mondatokra is a feladatot!

Írj függvényt, ami egy string-ben megszámolja az összes különböző betűt!

int CountUniqCharacters(string s)
{
	// Egyedi karaktereket tertalmazó tömb
	List<char> characters = new List<char>();
	foreach (char c in s) // minden karaktert megnézünk
	{
		if(!characters.Contains(c))
		characters.Add(c);
	}
	
	return characters.Count;
}

Írj függvényt, ami egy listával tér vissza, amibe beírja egy paraméterben kapott egész szám prímtényezős felbontását!

‣

Példák

8 → {2, 2, 2}

15 → {3, 5}

66 → {2, 3, 11}

90 → {2, 3, 3, 5}

Írj függvényt, ami kisorsolja a lottószámokat!

Nem kell a jövő heti lottószámokat (ha valaki ilyen programot is tudna írni, annak szívesen visszafizetem a képzés árát. 🙂), elég véletlenszerűen találni 90-ből 5-öt.

Az eredményt egy 5 elemű int tömbbe adja vissza a függvény.

// Ezt egyszer kell létrehozni:
Random random = new Random((int)DateTime.Now.Ticks);  

// Az eredmény legalább min nagzságú és mindenképp kisebb, mint max:
int randomNumber = random.Next(min, max);

int randomNumber = random.Next(0, 15);    //   0 -  14
int randomNumber = random.Next(2, 6);     //   2 -  5
int randomNumber = random.Next(-11, 11);  // -11 -  10
int randomNumber = random.Next(1, 101);   //   1 - 100

Írj függvényt, ami paraméterként vár egy int tömböt a megjátszott lottószámokkal és egy int számot arról, hogy hány hétig játsszuk meg azokat.

A függvény térjen vissza az összeggel, hogy mennyit nyertünk ha az egész időszakot véletlenszerűen szimuláljuk.

// Ezt egyszer kell létrehozni:
Random random = new Random((int)DateTime.Now.Ticks);  

// Az eredmény legalább min nagzságú és mindenképp kisebb, mint max:
int randomNumber = random.Next(min, max);

int randomNumber = random.Next(0, 15);    //   0 -  14
int randomNumber = random.Next(2, 6);     //   2 -  5
int randomNumber = random.Next(-11, 11);  // -11 -  10
int randomNumber = random.Next(1, 101);   //   1 - 100

Írjatok metódust, ami kiveszi egy listából annak minden máodik elemét!