Metódusok, függvények

Metódusok, függvények

‣

Saját minimum- és maximumkereső függvény

‣

Saját abszolút értek és előjel függvény

‣

Saját Clamp függvények

‣

Saját kerekítő függvények

‣

Pitagoraszi számhármas teszt függvény

‣

Számjegyösszeg függvény

‣

Bármihez kerekítő függvény

‣

Hány osztója van?

‣

Prímteszt függvény

‣

N × N metódus

‣

Első N prímszám metódus

‣

Legkisebb közös többszörös függvény

‣

Legnagyobb közös osztó függvény

‣

Érmék és bankók - függvény

‣

Tökéletes szám tesztelő - függvény

‣

Bináris → Decimális - átalakító függvény

‣

Decimális → Bináris - átalakító függvény

Írj függvényt, ami egy paraméterben kapott egész (decimális) számot átalakít a 2-es számrendszer (bináris) béli alakjára.

‣

Megoldási stratégia

‣

Megoldás

‣

Hol lehet mindennek haszna a játékfejlesztésben?

‣

Legalább az egyikkel osztható

‣

Hányat tudunk venni?

‣

Hatványozás függvény

float Clamp(float f, float min, float max)
{
	if (f <= min)   // Ha f kisebb vagy egyenlő mint a minimum
		return min;   // Visszatérek a minimummal

	if (f >= max)   // Ha f kisebb vagy egyenlő mint a maximum
		return max;   // Visszatérek a maximummal
    
	return f;       // Egyébként visszadom f-et magát.
}

float Clamp01(float f)      // Felhasználom az előbb megírt függvényt
{
	return Clamp(f, 0, 1);    // speciális bementekkel
}

float Floor(float f)
{
    float reminder = f % 1;
    if (reminder < 0)
        reminder = 1 + reminder;

    return f - reminder;
}

float Ceil(float f)
{
    float reminder = f % 1;
    if (reminder < 0)
        reminder = 1 + reminder;

    if (reminder == 0)
        return f;

    return f + (1 - reminder);
}


float Round(float f)
{
    float reminder = f % 1;
    if (reminder < 0)
        reminder = 1 + reminder;

    if (reminder < 0.5f)
        return Floor(f);
    else
        return Ceil(f);
}

Round(3, 10)        // 3 kerekítve 10-esekre = 0
Round(17, 10)       // 17 kerekítve 10-esekre = 20
Round(1274.5f, 10)  // 1274.5 kerekítve 10-esekre = 1270
Round(13.2f, 5)     // 13.2 kerekítve 5-ösökre = 15
Round(-2, 5)        // -2 kerekítve 5-ösökre = 0
Round(-2.6f, 5)     // -2.6 kerekítve 5-ösökre = -5
Round(3, 1)         // 3 kerekítve 1-esekre = 3
Round(3.6f, 1)      // 3.6 kerekítve 1-esekre  = 4
Round(3.4, 0.5f)    // 3 kerekítve 1-esekre = 3.5
Round(77.77f, 0.5f) // 77.77 kerekítve felekre = 78

float RoundTo(float n, float roundTo)
{
	if (roundTo == 0)              // Ezt az esetet nem tudjuk kezelni
		return n;                    // Nullával való osztá lenne

	roundTo = Math.Abs(roundTo);   // Ez mindig pozítív kell, hogy legyen
                                 // (Unity-ben Mathf)

	int wholeParts = (int)(n / roundTo);    // Egész rész
	float reminder = n % roundTo;           // Maradék

	if (n >= 0)                    // Ha pozítív számmal dolgozunk
	{
		if (reminder > roundTo / 2)  // Ha a maradék nagyobb, mint a kerekítendő rész fele
			wholeParts++;              // Felfelé kerekítünk
	}
	else                           // Ha negatív számmal dolgozunk
	{
		if (-reminder > roundTo / 2) // Ha a maradék nagyobb, mint a kerekítendő rész fele
			wholeParts--;              // Lefelé kerekítünk
	}

	return wholeParts * roundTo;   // Az egész rész szorozva a kerekítedndővel
}

void WriteNumbersWithSumOfDigits(int n)
{
	int numbersFound = 0;      // Hány elemet találtunk eddig
	for (int i = 1; numbersFound < n; i++) // Végignézzük az összes számot
	{                                      // addig, amíg nem találok eleget.
		if (SumOfDigits(i) == n) // Ha a számjegyek összege megegyezik a számmal,
		{
			// Kiírjuk a számot a feladat szerint.     (Csak az egyik kell)
			Console.WriteLine(i);  // Parancsori kiíratás
			Debug.Log(i);          // Unity kiíratás

			numbersFound++;        // Jegyzem, hogy eggyel több megvan
                             // (Ha ezt kihagyjuk, végtelen ciklust kapunk)
		}
	}
}

// Segédfüggvény
int SumOfDigits(int n)    // A számjegyek összege
{
	int sum = 0;            // Az összeg nulláról indul
	while (n != 0)          // Addig megyek el, amig a számom nem nulla
	{
		int digit = n % 10;   // Veszem az utoló számjegyet
		sum += digit;         // Növelem az összeget a számjegy értékével
		n /= 10;              // Levágom az utolsó számjegyet
	}
	return sum;
}

void WriteFirstPrimes(int n)
{
	int numbersFound = 0; // Hány elemet találtunk eddig
	for (int i = 1; numbersFound < n; i++)  // Végignézzük az összes számot
	{
		if (IsPrime(i))          // He igaz a feltétel
		{
			// Kiírjuk a számot a feladat szerint.     (Csak az egyik kell)
			Console.WriteLine(i);  // Parancsori kiíratás
			Debug.Log(i);          // Unity kiíratás

			numbersFound++;        // Ha ezt kihagyjuk, végtelen ciklust kapunk
		}
	}
}

// Segédfüggvény
bool IsPrime(int n)        // Prímszám-e
{
	if (n < 2)               // 2 alatt nincs prím
		return false;

	// Letesztelem az összes számot, 2 és gyök n közt, hogy osztó-e.
	float sqrt = (float) Math.Sqrt(n);    // n négyzetgyöke  (Unity-ben Mathf)
                                           
	// A négyzetgyök felett fölösleges osztót keresni
	for (int i = 2; i <= sqrt; i++)   
	{
		if (n % i == 0)     // Ha találtunk osztót
		return false;   // Akkor nem prím
	}

	return true;  // Ha nem találtunk osztót, akkor prím
}

int GreatestCommonDivisor(int a, int b)
{
	int min = Math.Min(a, b);        // (Unity-ben Mathf)

	for (int i =  min ; i > 1; i--)  // Megnézem az összes számot lefelé
	{                                      
		if (a % i == 0 && b % i == 0) // Ha osztó mindkettővel, akkor
		{
								                  // megtaláltam a legnyagyobbat:
			return i;										// Korai visszatérés
		}															
	}

	return 1; // Visszatérek 1-el ha nagyobbat nem találtam
}

int HowManyNotes(int num)
{
    int result = 0;

    result += num / 20000;   // Teszteljük 20 000-es bankóra
    num = num % 20000;

    result += num / 10000;   // Teszteljük 20 000-es bankóra
    num = num % 10000;

    // 1000-es 100-as és 10-es és 1-es nagyságrendet egy ciklusban:
    for (int m = 1000; m > 0; m /= 10)
    {
        int noteValue = 5 * m;      // 5000, 500, 50, 5
        result += num / noteValue; 
        num = num % noteValue;

        noteValue = 2 * m;          // 2000, 200, 20, 2
        result += num / noteValue;
        num = num % noteValue;

        noteValue = 1 * m;          // 1000, 100, 10, 1
        result += num / noteValue;
        num = num % noteValue;
    }

    return result;
}

bool IsPerfectNumber(int num)
{
	int sum = 0;                        // Ebbe gyűjtöm az osztók összegét
	for (int i = 1; i <= num / 2; i++)  // Végignézem a számokat 1-től num/2-ig
	{                                   // Tovább nem érdemes menni
		if (num % i == 0)									// Ha találok egy osztót,
		sum += i;													// Az értékét hozzáadom az összeghez
	}

	return sum == num;	// Ha az összeg egyenlő a számmal, akkor tökéletes
}

int BinaryToDecimal(int binaryNum)
{
    int decimalNum = 0;    // Kinullázom a végeredményt 
    int digitValue = 1;    // Ebben számolom, hogy az egyes helyiértéken mennyivel szorzunk

    while (binaryNum > 0)  // Egyenként végigmegyek a bináris szám minden számjegyén
    {
        int digit = binaryNum % 10;    // Levágjuk az utolsó számjegyet

        if (digit > 1)         // Ha bármelyik számjegy nem 0 vagy 1
        {
            decimalNum = 0;    // akkor az eredmény 0
            break;             // ás kilépünk a ciklusból
        }

        decimalNum += digit * digitValue;

        binaryNum = binaryNum / 10;   // Törlöm az utolsó számjegyet (Azt már kezeltem)
        digitValue *= 2;              // Következő helyiérték már dupla akkora szorzójú
    }

    return decimalNum;
}

int ToBinary(int decNumber)  // Bemenet: A decimális szám
{
	int signValue = decNumber >= 0 ? 1 : -1; // Előjelet elmentem
	decNumber = Math.Abs(decNumber);    // Csak a pozitív résszel számolok

	// Megkeresem 2 legynagyobb hatványát, ami még kisebb, mint a szám.
	// Ez lesz a legelső bináris számjegy értéke.
	int digitValue = 1;
				
	while (digitValue <= decNumber)
		digitValue *= 2;

	digitValue /= 2;
	
	// Összeállítom a számot:
	// Elölről haladok hátra a legnagyobb helyiértéktől a legkisebb felé

	int binNumber = 0;				// Ebbe gyűjtöm a bináris számot
 	while (digitValue > 0)		// A bináris szám minden számjegyére.
	{
		binNumber *= 10;				// Egy számjeggyel előrébb csúsztatom a számot
		if (decNumber >= digitValue )
		{
			binNumber += 1;				    // Hátsó számjegy = 1
			decNumber -= digitValue;  // CSökkentem a decimális szám értékét
		}

		digitValue /= 2;  // Következő bináris számjegy értéke
	}

	return binNumber * signValue;	// Előjelet visszaállítom
}

	int CountDivisible(int a, int b)  // Bemenet: A 2 egész szám
	{
		int min = a < b ? a : b;  // A kisebbik szám
		int max = a > b ? a : b;  // A nagyobbik szám

		int count = 0;  // A számláló

		for (int i = 1; i <= max; i++)  // Végig megyünk az 1-től a nagyobbik számig
			if (min % i == 0 || max % i == 0)  // Ha az i osztója legalább az egyiknek
				count++;  // Akkor növeljük a számlálót
				
		return count;  // Visszaadjuk az eredményt
	}

	int GetMaxAmount(int itemPrice, int buyerMoney, int discountPercent, int buyerCredit)
	{
		// Számítsuk ki a tárgy kedvezményes árát
		float discountRate = 1 - discountPercent / 100f;
		float realPrice = itemPrice * discountRate;

		// Számítsuk ki a vevő rendelkezésre álló összes pénzét (beleértve a hitelt is)
		int totalMoney = buyerMoney + (100 - buyerCredit);

		// Visszaadjuk a maximális mennyiséget
		return (int)(totalMoney / realPrice);
	}

float Pow(float baseNumber, int power)  // Két paraméteres függvény: alap és kitevő
{
	// Annyiszor vesszük az alap számot szorzótényezőnek, ahányadik hatványra emeljük

	float result = 1; // Eredmény változó: 1-gyel kezdünk és a hatványozás során ezt módosítjuk
	for (int i = 0; i < power; i++) // Annyiszor szorozzuk az alap számmal, ahányadik hatványra emeljük
	{
		result *= baseNumber; // Minden ciklusban megszorozzuk az eredményt az alap számmal
	}
	return result; // Eredmény visszaadása
}