JAVA: alle Kombination gegebener Zeichen

n!

public class BsKombo {

public static void possibilities(String[] arr, StringBuffer erg) {
  
  if (arr.length == 0) {
    System.out.println((erg.toString()));
    return;
  }
  
  for (int i = 0; i < arr.length;i++) {
    possibilites(arr, erg.clone().append(arr[i]));
  }

}


public static void main(String[] args) {

String[] urwort = new String[] {U, H, D, N};

possibilities(urwort, new StringBuffer());

}

}

import java.util.*;
public class BsKombo {
   
   public static void possibilities(Vector arr, String erg) {
     
        if (arr.size() == 0) {
          System.out.println(erg);
          return;
        }
        
        Enumeration enu = arr.elements(); 
        
        while (enu.hasMoreElements()) {
          String tmp = (String)enu.nextElement();
          Vector t = new Vector(arr);
          arr.removeElement(tmp);
          possibilities(t, erg+tmp);
       }
   }
   
   
   public static void main(String[] args) {
      
      Vector urwort = new Vector();
     urwort.addElement(new String(a));
     urwort.addElement(new String(b));
      
      possibilities(urwort, );
      
   }
   
}

import java.util.*;
public class BsKombo {
   
public static String[] reduceArray(String[] arr, String element) {

//wenn das element gar nicht im Array vorhanden ist, kann arr direkt zurückgegeben werden
if(Arrays.binarySearch(arr, element)<0) return arr;

String[] neu = new String[arr.length-1];//das neue Array
int x=0;//der Zähler für das neue Array
boolean schonreduziert = false;//Flag ob das Element schon entfernt wurde
//um sicher zu stellen, dass nur 1 Element rausgeschmissen wird

for (int i=0; i<arr.length; i++) {

if(!arr[i].equals(element) || schonreduziert) { 
//wir haben ein Element gefunden, das NICHT dem übergebenen gleicht
//bzw. es wurde schon ein Element aus dem Array geschmissen
neu[x++] = arr[i]; //also soll das Element ins neue Array gespeichert werden
}
else schonreduziert=true;

}

return neu;

}

 public static void possibilities(String[] arr, String erg) {
 
 if (arr.length == 0) {
 System.out.println(erg);
 return;
}

for (int i = 0; i < arr.length;i++) {
erg+=arr[i];
 possibilities(reduceArray(arr, arr[i]), new String(erg));
 }
}

public static void main(String[] args) {

String[] wort = new String[] {a, b, c};
String element=a;

Arrays.sort(wort); //wird gebraucht um später Arrays.binarySearch verwenden zu können

possibilities(wort, );
}
   
}

abc
abcb
abac
abaca
abcab
abcaba

Option Explicit

Sub AlleVariationenEinerBuchstabenkombination()
 ->Alle Kombinationen der Character eines Strings erzeugen
 ->Input Zelle A1 des aktiven Blattes
 ->Output in Spalte B des aktiven Blattes
    
  Dim s_tmp As String, x As Long
 ->Kombinationen-Array und Zähler
  Dim Kombinationen() As String
  
 ->erstes Feld leer lassen
  ReDim Kombinationen(0 To 0)
  
 ->String holen
  s_tmp = ActiveSheet.Range(A1).Value
  If s_tmp =  Then
    MsgBox (kein String in A1 :-))
    Exit Sub
  End If
  
 ->maximale Kombinationsanzahl prüfen
 ->8 Zeichen sind bereits ca 40000 :-(
  If Len(s_tmp) > 8 Then
    MsgBox (maximal 8 Zeichen in A1 zulässig & vbLf & vbLf & _
            Anzahl Kombinationen > 65535)
    Exit Sub
  End If
  
 ->Kombinationen erzeugen
  Call Arbeitsbiene(Kombinationen(), , s_tmp)
  
 ->Ausgabe
  For x = 1 To UBound(Kombinationen)
    ActiveSheet.Cells(x, 2).Value = Kombinationen(x)
  Next
  
 ->Sortieren
  ActiveSheet.Range(ActiveSheet.Cells(1, 2), _
                    ActiveSheet.Cells(UBound(Kombinationen), 2)).Sort _
                    Key1:=ActiveSheet.Columns(2), _
                    Header:=xlNo
  
  
 ->doppelte Kombinationen löschen
  For x = UBound(Kombinationen) To 2 Step -1
    If ActiveSheet.Cells(x, 2).Value = _
       ActiveSheet.Cells(x - 1, 2).Value Then
      ActiveSheet.Cells(x - 1, 2).Delete Shift:=xlShiftUp
    End If
  Next
End Sub

Sub Arbeitsbiene(Kombinationen() As String, _
                 s_kombi As String, _
                 s_rest As String)
  Dim x As Long
  
  If Len(s_rest) = 1 Then
   ->Kombinationsfeld um 1 erweitern
    ReDim Preserve Kombinationen(0 To UBound(Kombinationen()) + 1)
   ->Kombination speichern
    Kombinationen(UBound(Kombinationen)) = s_kombi & s_rest
  Else
   ->für alle Buchstaben im Rest:
   ->eine Buchstaben aus Rest nehmen und an Kombination anfügen
   ->Rest entsprechend reduzieren
    For x = 1 To Len(s_rest)
      Call Arbeitsbiene(Kombinationen(), _
              s_kombi & Mid(s_rest, x, 1), _
              Left(s_rest, x - 1) & Right(s_rest, Len(s_rest) - x))
    Next
  End If
End Sub

   public static void possibilities(String[] arr, String erg) {
      
      if (arr.length == 0) {
         System.out.println(erg);
         return;
      }
      
      for (int i = 0; i < arr.length;i++) {
         possibilities(reduceArray(arr, arr[i]), erg + arr[i]);
      }
   }