如何找到最小的 integer 優於 integer n？ [關閉]

Question

關閉。 這個問題需要細節或清晰。 它目前不接受答案。

---

想改進這個問題？ 通過編輯此帖子添加詳細信息並澄清問題。

2天前關閉。

改進這個問題

我有一個評估。 我嘗試了很多次來解決這個問題。 但我做不到。 請有人幫助我。 這是評估：

下一個 function 應該返回最小的 integer，它優於 n 並且其數字都不同於所有 n 的數字。

例如 next(654321) 應該返回 700000。

如果不存在這樣的 integer，則 function 必須返回 -1。

寫下一個（n）function的正文

注意：n 是嚴格正數 integer 低於 2^31

Answer 1

試試這個簡單的控制台應用程序。 我在 C# 中寫道（您在問題標簽中同時指定了 C# 和 Java）。

注意：進一步更新了 function

版本 1：使用 Lists 和 Enumberable 操作

internal class Program
{
    private static readonly double maxValue = Math.Pow(2, 31);  // Max allowed value for function

    private static void Main(string[] args)
    {
        while (true)
        {
            Console.WriteLine("Please specify start value.");
            int startValue = Convert.ToInt32(Console.ReadLine());
            int result = YourAssesmentFunction(startValue);
            Console.WriteLine($"Your function result is {result}.");
        }
    }

    /// <summary>
    /// The next function should return the smallest integer which is superior to n and whose digits are all different from all of n' s digits.
    /// For example next(654321) should return 700000.
    /// if no such integer exists then the function must return -1.
    /// write the body of the next(n) function
    /// Note: n is a strictly positive integer lower than 2^31
    /// </summary>
    private static int YourAssesmentFunction(int startNumber)
    {
        List<char> startChars = new(); // List of char (numbers) contained in given number
        List<char> newChars = new(); // List of char (numbers) contained in next number

        IEnumerable<char>? inCommon = null; // IEnumerable of char used to find common chars

        int nextNumber = -1; // Initialize result with default value -1

        startNumber.ToString().ToList().ForEach(x => startChars.Add(x)); // Use Linq to populate list of digits in given number

        while (inCommon == null || inCommon.Any()) // The first execution has inCommon == null as entry condition
        {
            if (startNumber >= maxValue || startNumber < 0) // If maxValue has been reached or given number is less than 0, exit while loop
                break;

            nextNumber = startNumber + 1;
            newChars.Clear(); // Clear the list from previous values

            nextNumber.ToString().ToList().ForEach(x => newChars.Add(x)); // Use Linq to populate list of digits in next number

            inCommon = startChars.Intersect(newChars).ToList(); // Use Linq to find common digits

            startNumber++; // Increment startNumber for the next while loop execution
        }
        return nextNumber;
    }
}

您需要的代碼在YourAssesmentFunction()中。 請注意，我是一名白手起家的學生程序員，可能有更好的方法來編寫此 function。

編輯：在 Klaus Gutter 發表評論后，我試圖找到一種更簡單、更快、更優雅的方式來編寫相同的 function。 就這個：

版本 2：在嘗試號碼中使用循環數字

    private static int YourAssesmentFunctionOptimized(int startNumber)
    {
        int tryNext = startNumber + 1; // Next number to try

        // String representation of given number
        string start = startNumber.ToString();

        // Flags for while-loop managing
        bool numberFound = false;
        bool skipToNext;

        while (!numberFound)
        {
            if (tryNext > maxValue | startNumber < 0) // If number to try is greater than maxValue (2^31) or start number is less than 0, exit and return 0
                return -1;
            skipToNext = false;
            foreach (char c in tryNext.ToString()) // Loop through chars (= digits) in string representation of trying number
            {
                if (start.Contains(c))
                {
                    tryNext++; // If a digit of the trying number is found in given number, the trying number is not the result
                    skipToNext = true;
                    break; // Exit foreach loop and skip to next number
                }
            }
            if (!skipToNext)
                numberFound = true; // If skip to next = true, numberFound remains false and while loop keep executing
        }
        return tryNext;
    }

這個 function 更快，因為它不需要創建List或評估IEnumerable操作。