תרגול 7.3 פתור - פ' המקבלות ומחזירות ערך

// א. פונקציה שמקבלת מספר ומחזירה "boom" אם המספר מתחלק ב-7 או מכיל את הספרה 7
static string SevenBoom(int num)
{
    // בדיקה אם המספר מתחלק ב-7
    if (num % 7 == 0)
        return "boom";
    // בדיקה אם המחרוזת של המספר מכילה את התו '7'
    if (num.ToString().Contains('7'))
        return "boom";
    // במקרה אחר, החזר את המספר כמחרוזת
    return num.ToString();
}

// ב. תכנית ראשית של שאלת 7.3.2, שם הפונקציה MainQ732
static void MainQ732()
{
    for (int i = 1; i <= 99; i++)
    {
        Console.Write(SevenBoom(i));
        if (i < 99)
            Console.Write(" ");
    }
    Console.WriteLine();
}

// א. פונקציה Factorial המקבלת n (int) ומחזירה עצרתו (int)
static int Factorial(int n)
{
    if (n < 0) // עצרת לא מוגדרת למספרים שליליים
        throw new ArgumentException("n must be non-negative", nameof(n));

    int result = 1;
    for (int i = 2; i <= n; i++)
        result *= i; // כפל מצטבר
    return result;
}

// א. פונקציה המקבלת זוג מספרים ומחזירה true אם אחד מהם מתחלק בשלמות בשני
// מחזירה false אם המספרים שווים או כל מספר קטן מ-1
static bool IsDivisiblePair(int a, int b)
{
    if (a == b || a < 1 || b < 1) // בדיקה למקרים שמחזירים false מיד
        return false;
    if (a % b == 0 || b % a == 0) // בדיקה אם אחד מתחלק בשני ללא שארית
        return true;
    return false; // בכל מקרה אחר
}

// א. פונקציה שמחזירה את סכום כל המספרים מטווח 1 עד num (כולל)
static int Summation(int num)
{
    // num תמיד יהיה > 0 לפי תנאי השאלה
    return num * (num + 1) / 2; // נוסחת סכום טווח אריתמטי
}

// א. פונקציה המקבלת מספר שלם ומחזירה true אם הוא מושלם, אחרת false
static bool IsPerfect(int num)
{
    if (num <= 1) // לפי ההגדרה, מספרים <=1 אינם מושלמים
        return false;

    int sum = 1; // 1 תמיד מחלק
    int limit = num / 2;
    for (int i = 2; i <= limit; i++)
    {
        if (num % i == 0)
            sum += i; // הוסף מחלק אם אין שארית
    }
    return sum == num; // מושלם אם סכום המחלקים שווה למספר
}

// א. פונקציה המקבלת מספר עמודים, מרחק ביניהם במטרים ורוחב עמוד בס"מ
// ומחזירה את המרחק בין העמוד הראשון לאחרון בס"מ, ללא רוחב העמוד הראשון והאחרון
static int DistanceBetweenPillars(int numPillars, int distBetweenMeters, int pillarWidthCm)
{
    if (numPillars <= 1) // אם יש עמוד אחד או פחות, אין מרחק
        return 0;
    // סכום המרחקים בין כל זוג עמודים סמוכים (בס"מ)
    int totalGaps = (numPillars - 1) * distBetweenMeters * 100;
    // סכום רוחבי העמודים שביניהם (בס"מ), פרט לראשון ולאחרון
    int totalIntermediateWidths = (numPillars - 2) * pillarWidthCm;
    return totalGaps + totalIntermediateWidths;
}

// ב. דוגמאות קלט לפעולה Equal1:
// דוגמה שתְחזיר true:  Equal1(123, 987) → true   // שני מספרים בעלי אותו מספר ספרות
// דוגמה שתְחזיר false: Equal1(123, 45)  → false  // מספרים בעלי מספר שונה של ספרות

// טענת כניסה: הפעולה מקבלת שני מספרים חיוביים שלמים

// טענת יציאה: הפעולה מוודאת שמספר הספרות בשני המספרים זהה

/// <summary>
/// This function checks if two integers are equal by comparing their digits.
/// </summary>
/// <param name="n1">an integer</param>
/// <param name="n2">an integer</param>
/// <returns>true if both lengths are equal</returns>

// טענת כניסה: הפעולה מקבלת שני מספרים חיוביים שלמים
// טענת יציאה: מחזירה true אם לשני המספרים אותו מספר ספרות, אחרת false
static bool Equal2(int n1, int n2)
{
    return CountDigits(n1) == CountDigits(n2);
}

// א. פונקציה המקבלת מספר נוסעים ומחזירה את מספר המוניות הנדרש (7 נוסעים לכל מונית)
static int TaxisOrder(int num1)
{
    // חלוקת עגולה כלפי מעלה: (num1 + 6) / 7
    return (num1 + 6) / 7;
}

// ב. תכנית ראשית של שאלת 7.3.9, שם הפונקציה MainQ739
static void MainQ739()
{
    // חישוב והצגת מספר המוניות לכל יום
    Console.Write(TaxisOrder(49)); // יום ד'
    Console.Write(" ");
    Console.Write(TaxisOrder(52)); // יום ה'
    Console.Write(" ");
    Console.WriteLine(TaxisOrder(60)); // יום ו'
}

// א. פונקציה המקבלת מספר שלם חיובי num וספרה digit ומחזירה כמה פעמים הספרה מופיעה במספר
static int CountDigitOccurrences(int num, int digit)
{
    int count = 0;
    while (num > 0)
    {
        if (num % 10 == digit) // השווה ספרת אחד
            count++;
        num /= 10; // הסר ספרה אחרונה
    }
    return count; // החזר מספר ההופעות
}

// ב. תכנית ראשית של שאלת 7.3.10, שם הפונקציה MainQ730
static void MainQ730()
{
    var rnd = new Random(); // יוצר אובייקט לאקראיות
    for (int i = 0; i < 5; i++)
    {
        int number = rnd.Next(1000, 10000); // מספר בין 1000 ל-9999
        int digit = rnd.Next(1, 10);        // ספרה בין 1 ל-9
        Console.WriteLine($"{number} {digit} {CountDigitOccurrences(number, digit)}");
    }
}

// א. פונקציה שבודקת אם כל ספרות המספר זוגיות
static bool IsEvenDigits(int num)
{
    if (num <= 0) // מבוצע רק עבור מספרים חיוביים
        throw new ArgumentException("Number must be positive", nameof(num));
    while (num > 0)
    {
        int d = num % 10;
        if (d % 2 != 0) // אם ספרה לא זוגית
            return false;
        num /= 10;
    }
    return true;
}

// ב. פונקציה שבודקת אם כל ספרות המספר שונות זו מזו (שימוש בלולאות מקוננות בלבד)
static bool IsDiffDigits(int num)
{
    int tempOuter = num;
    while (tempOuter > 0)
    {
        int digit = tempOuter % 10;             // הספרה הנבדקת
        int tempInner = tempOuter / 10;         // שאר הספרות הבאות אחרי הספרה הנבדקת
        while (tempInner > 0)
        {
            if (tempInner % 10 == digit)       // אם נמצאה ספרה זהה
                return false;
            tempInner /= 10;
        }
        tempOuter /= 10;                       // עבור לספרה הבאה לבדיקת ייחודיות
    }
    return true; // אם לא נמצאה אף חפיפה
}

// ג. תכנית ראשית של שאלת 7.3.11, שם הפונקציה MainQ7311
static void MainQ7311()
{
    int max = 0;
    while (true)
    {
        int n = int.Parse(Console.ReadLine()); // קריאה מהקלט
        if (n <= 0) // סיום על קלט לא חיובי
            break;
        if (IsEvenDigits(n) && IsDiffDigits(n) && n > max)
            max = n;
    }
    Console.WriteLine(max); // אם לא נמצא מספר העונה לתנאים, יוחזר 0
}

// ג. תכנית ראשית של שאלת 7.3.11, שם הפונקציה MainQ7311
static void MainQ7311()
{
    int max = 0;
    while (true)
    {
        int n = int.Parse(Console.ReadLine()); // קריאה מהקלט
        if (n <= 0) // סיום על קלט לא חיובי
            break;
        if (IsEvenDigits(n) && IsDiffDigits(n) && n > max)
            max = n;
    }
    Console.WriteLine(max); // אם לא נמצא מספר העונה לתנאים, יוחזר 0
}

// א. פונקציה SwitchDigits המקבלת מספר שלם חיובי ומחזירה:
// - את המספר המקורי אם כמות הספרות אי-זוגית
// - מספר חדש עם החלפת זוגות סמוכים אם כמות הספרות זוגית
static int SwitchDigits(int num)
{
    string s = num.ToString();
    if (s.Length % 2 != 0)
        return num; // מספר בעל אורך אי-זוגי, מחזירים במקור
    char[] arr = s.ToCharArray();
    for (int i = 0; i < arr.Length; i += 2)
    {
        // החלפת הספרה במיקום i ובמיקום i+1
        char tmp = arr[i];
        arr[i] = arr[i + 1];
        arr[i + 1] = tmp;
    }
    return int.Parse(new string(arr)); // החזרת המספר החדש
}

// ב. תכנית ראשית של שאלת 7.3.12, שם הפונקציה MainQ7312
static void MainQ7312()
{
    var rnd = new Random(); // אובייקט לייצור מספרים אקראיים
    for (int i = 0; i < 4; i++)
    {
        int number = rnd.Next(1111, 6869); // מספר בין 1111 ל-6868
        Console.WriteLine($"{number} {SwitchDigits(number)}");
    }
}

// BY GPT
// א. פונקציה שבודקת אם המספר בעל 3 ספרות לפחות הוא 'עולה-יורד'
// לפי הגדרה: מימין לשמאל הספרות עולות ממש ואז יורדות ממש לאחר נקודת שיא אחת
static bool OleYoredGPT(int num)
{
    // קריאת הספרה התחתונה
    int prev = num % 10;
    num /= 10;
    // קריאת הספרה הבאה כדי לקבוע תחילת מגמת עלייה
    int curr = num % 10;
    if (curr <= prev) // חייב להתחיל בעלייה
        return false;
    prev = curr;
    num /= 10;

    bool peaked = false; // נשאית המעבר מירידה לעלייה
    while (num > 0)
    {
        curr = num % 10;
        if (!peaked)
        {
            if (curr > prev)
            {
                prev = curr; // ממשיכים בעלייה
            }
            else if (curr < prev)
            {
                peaked = true; // הגענו לשיא ועוברים למגמת ירידה
                prev = curr;
            }
            else
            {
                return false; // שווה, לא תקין
            }
        }
        else // במגמת ירידה
        {
            if (curr < prev)
            {
                prev = curr; // ממשיכים בירידה
            }
            else
            {
                return false; // עלייה או שווה לאחר השיא -> כשלון
            }
        }
        num /= 10;
    }
    return peaked; // חייב להיות ירידה לפחות פעם אחת
}

public static bool OleYored1Guy(int n)
{   //  ============= גרסה בה התנאי העיקרי הוא הדגלים ================
    // העבודה עם דגלים נחוצה בעיקר מפני שבזמן הפתרון לא למדנו פונקציות
    // כשלא ניתן להחזיר תוצאה בתוך תנאי אין ברירה אלא להשתמש בדגלים
    int num = n; // שומר את המספר המקורי להדפסה בסוף
    bool hasRizing = false;// מניח בשלילה שלא מתחיל בעליה
    bool isFalling = false; // להמשך- כשכבר תהיה עליה
    int prev = n % 10; // היסטוריה
    bool oleYored = true; //הנחה בשלילה שהכל טוב

    while (n > 9 && oleYored) //כל עוד תקף ולפחות 2 ספרות: פירוק מספר
    {
        n /= 10; // באופן חריג בהתחלה: מחלק ב-10   
        int current = n % 10; // ספרה הנוכחית

        if (current == prev)
            oleYored = false;

        if (!hasRizing)
            if (current < prev)
                oleYored = false;
            else
                hasRizing = true;
        // כבר בעליה
        else if (!isFalling && current < prev)
            isFalling = true; // סימון שהתחילה ירידה
        else if (isFalling && current > prev)
            oleYored = false;

        prev = current; // מעדכן את הספרה הקודמת לספרה הנוכחית
    }
    return (oleYored && isFalling && hasRizing);
}

public static bool OleYored2(int n)
{
    int num = n; // שומר את המספר המקורי להדפסה בסוף
    bool hasRizing = false;// מניח בשלילה שלא מתחיל בעליה
    bool isFalling = false; // להמשך- כשכבר תהיה עליה
    int prev = n % 10;
    bool oleYored = true; //הנחה בשלילה שהכל טוב

    while (n > 9 && oleYored) //כל עוד תקף ולפחות 2 ספרות: פירוק מספר
    {
        n /= 10; // באופן חריג בהתחלה: מחלק ב-10   
        int current = n % 10;  // ספרה הנוכחית

        if (current == prev)
            oleYored = false;  // אם הספרה הנוכחית שווה לקודמת, סימן שאין ירידה

        // ================ גרסה בה התנאי העיקרי הוא הספרות ===================
        else if (current > prev)
        {
            if (!hasRizing)  // לוגיקה שתקרה רק בפעם הראשונה
                hasRizing = true;  // ספרה הנוכחית גדולה מהקודמת, אז יש עליה

            else if (isFalling)  // אם כבר היה לי ירידה
                oleYored = false; // סימן שהכל לא בסדר
        }
        else // הספרה הנוכחית קטנה מהקודמת
        {
            if (!hasRizing)  // ירידה לפני שהתחילה עליה
                oleYored = false;
            else  // אם כבר היתה עליה וכן/לא לא סימנתי ירידה
                isFalling = true; //  גם אם כבר הפעלתי אני מפעיל את הדגל
        }

        prev = current; // מעדכן את הספרה הקודמת לספרה הנוכחית
    }

    return (oleYored && isFalling && hasRizing);
}