Größe der Zahlenkombinationen eines Arrays begrenzen

[Duardo]

Hallo, ich habe es hier jetzt letzendlich geschafft alle möglichen Kombinationen eines Arrays herauszufinden und auszugeben. Nun würde ich gerne meinen Code so bearbeiten dass man die Größe der Kombinationen begrenzen kann. Momentan sind die Kombinationen so groß wie das Array. So werden aus 1, 2, 3, 4 Kombinationen wie 1, 2, 4, 3 usw. gemacht. Mein Ziel wäre es nun, dass man dann daraus Kombinationen wie: 1, 2, 3 ; 1, 2, 4 usw. machen kann. Schonmal danke im voraus. Hier mein Code:

import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Vector;

import javax.swing.DefaultComboBoxModel;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTextArea;
import javax.swing.ScrollPaneConstants;

public class GridBagLayoutExample extends JFrame implements ActionListener {
    
    private JPanel panel;
    private JButton ok;
    private JTextArea text;
    private String str;
    private String a;
    private String b;
    private int zahlKombi;
    private JScrollPane scroll;
    
    public GridBagLayoutExample() {
        
        panel = new JPanel();
        ok = new JButton("OK");
        ok.addActionListener(this);
        str = ("1, 2, 3, 4");
        text = new JTextArea(str, 16, 16);
        text.setEditable(false);    
        scroll = new JScrollPane(text);
        scroll.setVerticalScrollBarPolicy(ScrollPaneConstants.VERTICAL_SCROLLBAR_AS_NEEDED);
    
        panel.add(scroll);
        panel.add(ok);
        
        add(panel);    
        
        pack();
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        setVisible(true);
    }

    public static void main(String[] args) {
        new GridBagLayoutExample();
    }
    
    public void permute(java.util.List intList, int k){
        for(int i = k; i < intList.size(); i++){
            java.util.Collections.swap(intList, i, k);
            permute(intList, k+1);
            java.util.Collections.swap(intList, k, i);
        }
        if (k == intList.size() -1){
            text.append(Arrays.toString(intList.toArray()) +" " + ", " + "\n");
            b=text.getText();
            b = b.replace( "[", "" );
            b = b.replace( "]", "" );
            text.setText(b);
        }
    }   
    @Override
    public void actionPerformed(ActionEvent arg0) {
        
        int k = 0;
        a = text.getText();    
        
        String[] zahlenstring = a.split(", ");
        int[] zahlenint = new int[zahlenstring.length];
        
        for(int i=0; i < zahlenstring.length ;i++) {
            zahlenint[i] = Integer.parseInt(zahlenstring[i]);
        }
        
        ArrayList intList = new ArrayList();
        for (int i = 0; i < zahlenint.length; i++) {
            intList.add(zahlenint[i]);
        }
        
        permute(intList, k);
      
    }
}

 

[Anfänger2011]

Ich weiß nicht ob ich dein Vorhaben richtig, aber ich würde das mit einer Abfrage machen, die array bis zu der gewünschten Größe zulässt. Wenn das nicht ganz auf dein Problem zutrifft, dann beschreib es noch Mal ein bisschen genauer

 

[Duardo]

Also meine Methode generiert alle möglichen Kombinationen des Inhalts eines Arrays. Hier aber nur mit Verschiebungen, also darf eine Zahl in einer Kombination nicht zwei mal vorkommen. Nun möchte ich diese Kombinationen auf drei Stellplätze begrenzen. Aber weiterhin sollen diese nur aus dem Inhalt des Arrays bestehen und durch alle möglichen Verschiebungen von diesem.

 

[Barista]

> Also meine Methode generiert alle möglichen Kombinationen des Inhalts eines Arrays.

Seltsamerweise heisst die Methode permut.

Schau mal auf Wikipedia nach,
was der Unterschied zwischen Permutationen
und Kombinationen ist.

> Hier aber nur mit Verschiebungen, also darf eine Zahl in einer Kombination nicht zwei mal vorkommen.

Wahrscheinlich meinst Du Vertauschungen, statt Verschiebungen.

Bei Vertauschungen ändert sich an der Anzahl einer Zahl nichts.

> Nun möchte ich diese Kombinationen auf drei Stellplätze begrenzen.

Kannst Du das noch mal genauer beschreiben?

> Aber weiterhin sollen diese nur aus dem Inhalt des Arrays bestehen und durch alle möglichen Verschiebungen von diesem.

Wie oben gesagt, bei Vertauschungen wird diese Bedingung eingehalten.

Für Kombinationen funktioniert nach meiner Meinung folgender Algorithmus:

Der Rahmen ist eine rekursive Methode.

Übergeben wird eine Menge (Array) von Werten.

In einer Schleife wird jeweils ein Wert
(einer nach dem anderen) ausgewählt.

Von der Menge (Array) wird eine Kopie
ohne den ausgewählten Wert erzeugt.

Mit der Kopie wird die Methode rekursiv
aufgerufen.

Die Methode liefert Arrays oder Listen (jetzt ist die
Position der Werte relevant) aller Kombinationen
der Restmenge (ohne ausgewählten Wert).

Der ausgewählte Wert und die gelieferten Kombinationen
der Restmenge werden jeweils hintereinander verbunden
(konkateniert).

Dies sind die Ergebnis-Kombinationen.

Die Rekursion terminiert, wenn die Restmenge nur noch
ein Element hat.

Also gibt die rekursive Methode bei Übergabe einer
Werte-Menge der Größe 1 genau diese Werte-Menge
(eventuell eine unveränderliche Kopie) als Ergebnis
zurück.

Eine übergebene leere Menge (Array der Größe 0)
ergibt eine leere Menge von Kombinationen.