יש כזה דבר שנקרא כוח ברוטלי..

אני צריך עזרה איך פותרים את האלגוריתם הזה בC# או בעברית לא חשוב.....

פונקציה מקבלת מספר ומחרוזת.

המספר מסמל את אורך המחרוזת והמחרוזת מסמלת איזה תווים יכולה להכיל כל הדפסה.

אני יתן דוגמא:

נגיד הפונקציה מקבלת מספר- 2 ומחרוזרת- abc אז הפונקציה תדפיס

aa

ab

ac

ba

bb

bc

ca

cb

cc

הבעיה היא שלא ידועה המספר שמתקבל וככה שאי אפשר לעשות for מקונן אני מאמין שאפשר לעשות ברקורסיה ניסתי וכמעט הצלחתי... אבל משהו לא מסתדר לי...

תודה לכל העוזרים!

חחחח היה לי כזה תרגיל אם אני לא טועה ואין לי מושג איך עושים את זה כבר לא זוכר

תייצר את כל הפרמוטציות האפשריות של האותיות ואז תחתוך רק תX ספרות הראשונות.

איך עושים פרמוטציות?

http://www.underwar.co.il/forum/forum_posts.asp?TID=4966&PN=6

אתה צריך לעשות את זה ברקורסיה, כאשר בכל שלב אתה מבצע לולאה שמדפיסה אות, וקוראת לפונקציה.

הנה פתרון של הבעיה ב-haskell שהיא שפה פונקציונלית טהורה:

allCombinations list1 list2 = [ x ++ y | x<-list1 , y<-list2 ]
makeList characters = [[x] | x<-characters]

implPermutations _ 0 = []
implPermutations [] _ = []
implPermutations stringList 1 = stringList
implPermutations stringList len =
  allCombinations stringList (implPermutations stringList (len-1))

buildPermutations characters len = implPermutations (makeList characters) len

קחו בחשבון שבטוח יש פתרון הרבה יותר אלגנטי, עם פחות שורות ויותר יעיל. פעם ראשונה שבכלל ראיתי haskell היה אתמול (הייתי צריך לממש דברים שבטוח כבר יש פנימית בשפה, אבל אני לא מכיר).

סתם לשם השעשוע, הוספתי פתרון בפרולוג (תשתמש ב- ; בכדי לראות עוד פתרונות).

יכול להיות שצריך לממש את פונקציית select שהיא מובנית ב-swi prolog, אבל זה די פשוט:

make_list(_,0,[]).

make_list(L,K,[R|Res]):-

K>0,

select(R,L,_),

K1 is K-1,

make_list(L,K1,Res).

[br]פורסם בתאריך: 21.05.2007 בשעה 00:06:16

---

שכחתי להוסיף שפרמוטציה לא טובה לעניין הזה (לפחות לא לפי ההגדרה כפי שהוסברה) בגלל שפרמוטציה היא בסה"כ סידור מחדש של אותם אלמנטים ולא תאפשר לכתוב את אותו אלמנט פעמיים, לדוגמא: aa לא יכול להתקבל מיצירת פרמוטציה וחיתוך שלה.

הנה קוד ב c# אומנם זה לא הכי יעיל ואני בטוח שאפשר לשפר את מה שעשיתי פלאים אבל זה מה שהספקתי לעשות בעשר דקות

    static public String[] BrutalForce(String Letters, int length)
    {
      //temp - מערך שמכיל את כל הקומבנציות של הקריאה הנל
      String[] temp = new String[Convert.ToInt32(Math.Pow(Letters.Length, length))];
      //temp1 - שומר את כל הקומבנציות של הרקורסיה
      String[] temp1 = null;
      //תנאי הפסקת הרקורסיה - במידה ואנחנו לא באפשרות האחרונה
      if (length > 1)
        temp1 = BrutalForce(Letters, --length);
      // counter - המשתנה שרץ על temp
      int counter = 0;
      // לולאה שעוברת על כל האותיות
      for (int i = 0; i <= Letters.Length - 1; i++)
      {
        // בודק אם זה הריצה האחרונה
        if (temp1 != null)
        {
          //במידה ולא כלומר ניכנס לרקורסיה
          //לולאה שרצה על כל התוצאות מהרקורסיה
          for (int j = 0; j < temp1.Length; j++)
          {
            //מכניס למערך את כל הקומבנציות האפשריות לאות
            //A דוגמא אנחנו באותה 
            //Letters[i].ToString()  temp1[j]
            //A                [A]
            //A                [b]
            //A                [c]
            temp[counter] = Letters[i].ToString() + temp1[j];
            counter++;
          }
        }
        else
        {
          //במידה וכן כלומר לא ניכנס לרקורסיה
         t //בונא מערך שיש בו את כל הקומבנציות של אות אחת
          temp[counter] = Letters[i].ToString();
          counter++;
        }
      }
      return temp;
    }

unplugged ... אתה יכול להסביר את האפליקציה? מה כל שורה עושה ומה כל משתנה? כי טיפה איבדתי אותך שם

הוספתי הערות לקוד המקורי...

במידה ומשהו לא מובן, אז תישאל

קוד VB2005 דיי מעפן אבל עושה את העבודה

  Private Sub bf(ByVal str As String, ByVal i As Integer, ByVal str_len As Integer, ByVal j As Integer, ByVal len As Integer, ByVal new_str As String)
    If (j = len) Then
      ListBox1.Items.Add(new_str)
      Return
    End If

    If (i = str_len) Then
      Return
    End If

    bf(str, 0, str_len, j + 1, len, new_str & str(i))
    bf(str, i + 1, str_len, j, len, new_str)
  End Sub

את התוצאות הוא מדפיס לליסטבוקס