Prawdopodobieństwo uszkodzeń do m elementów z N

Witam,
mam problem z napisaniem kodu który dla dwóch wartości m i N będzie generował tablicę z prawd. uszkodzeń poszczególnych elementów.
m - maksymalna ilość uszkodzonych elementów.
N - całkowita ilość elementów.
mamy 3 elementy z których aż 2 mogą ale nie muszą być uszkodzone
0 - element sprawny
1 - element uszkodzony
np. funkcja(2,3) = funkcja(m,N)
000 - wszystkie sprawne
001 - kolejne uszkodzenia jednego elementu
010
100
011 - kolejne uszkodzenia dwóch elementów
101
110

to jest prosty przykład i mam nadzieje że jest czytelny
problem polega na tym że wartości m i N mogą być dużo większe np funkcja(10,30)

000000000000000000000000000000 - wszystkie sprawne
000000000000000000000000000001 - jeden uszkodzony
000001011001000000001000000001 - sześć uszkodzonych
itd.

jeśli ktoś ma jakiś pomysł będę bardzo wdzięczny

Pozdrawiam

Trzeba brutforcem jeżeli chcesz mieć wszystkie kombinacje. Można jednak wykonać pewną prostą sztuczkę.
Generujesz ciąg np. 0000, a następnie XORujesz przez 1111 i masz "za darmo" dwie kombinacje.

Nie bardzo wiem jak to zrobić żeby miało ręce i nogi.
Pomyślałem ze wygeneruję wszystkie liczby binarnie z zakresu od 0 do 2^N-1 czyli dla 3 wygeneruję liczby od 0 do 7. a dla N=4 liczby od 0 do 15 itd. a następnie odrzucę te które nie spełniają warunku że np mogą wystąpić max 2 elementy uszkodzone (dwie jedynki) i tak dla N=3 odrzucę ostatni wynik czyli 7 binarnie 111. a dla N=4 odrzucę 0111, 1011, 1101, 1110.
To powinno mi dać wszystkie możliwe kombinacje.
Później ewentualnie sortowanie po ilości jedynek.
Co myślicie o takim pomyśle?

Jeśli ktoś ma inny chętnie przeczytam i zastanowię się nad wdrożeniem.

a na pewno potrzebujesz wszystkie od razu?

Wygeneruj tyle 1 ile potrzebujesz a potem permutuj z powtórzeniami.
Algorytmów do permutacji jest sporo na necie.

Potrzebuje wszystkie kombinacje od razu. Niestety na tym polega zadanie że dla wszystkich możliwości mam zbadać działanie całego systemu.
Muszę poszukać skryptu do permutacji z powtórzeniami.
Dam znać jak poszło.
Jak ktoś ma inne pomysły nadal jestem otwarty.

Pozdrawiam

ja bym napisał funkcję coś jakby taką:

void generuj(String prefix,int n, int m){
  if(n==0){
    liczby.add(prefix);
    return;
  }

  generuj(prefix+"0",n-1,m);
  generuj(prefix+"1",n-1,m-1);

}

i wywołujemy ją:

generuj("",n,m);

Na ciul Ci parametr m, z którego w ogóle nie korzystasz?

0x200x20 napisał(a)

Na ciul Ci parametr m, z którego w ogóle nie korzystasz?

pozostawiam Ci to do odkrycia samodzielnie jak wykorzystać parametr m ;]

podpowiedź:

"",3,2
  "0",2,2
    "00",1,2
      "000",0,2 ->
      "001",0,1 ->
    "01",1,1
      "010",0,1 ->
      "011",0,0 ->
  "1",2,1
    "10",1,1
      "100",0,1 ->
      "101",0,0 ->
    "11",1,0
      "110",0,0 ->
      "111",0,-1  -X

Do czego ci to było to ja się domyślam, tak czy inaczej wrzuciłeś kod, który nie działa.

notexists napisał(a)

ja bym napisał funkcję coś jakby taką:

 miało sugerować, że to podpowiedź co do zasady działania - do przeanalizowania, a nie rozwiązanie do skopiowania :D

funkcję którą podał notexists znalazłem juz pewien czas temu w necie. wyznacza on wszystkie kombinacje od 000000 do 111111. nie jest on optymalny i ciężko go przerobić.
caly czas mysle jak to rozwiązać. powiedzmy dla 5 kompów i możliwości uszkodzenia 3, tworzę tablicę 3elementową gdzie kolejne pozycje określają pozycję jedynek.
1,2,3 oznacza ze pierwsze trzy pola to jedynki, następnie przesuwam ostatnią jedynkę aż do końca szeregu
1,2,4
1,2,5, po dojściu do ostatniego pola przesuwam drugą jedynkę o 1 i następną o +1 względem wcześniejszej
1,3,4 i zwiększam pozycję ostatniej jedynki do ostatniego pola
1,3,5 jestem na końcu i przesuwam wcześniejszą jedynkę o 1 i kolejną o +1
1,4,5 jesteśmy już na koncu i nie możemy przesunąć ostatniej i przed ostatniej więc idziemy do pierwszej i ustawiamy kolejne na sąsiednich polach
2,3,4 przesuwamy ostatnią do konca
2,3,5 i ponownie przesuwamy drugą i trzecią jedynkę
2,4,5 jesteśmy na końcu więc przesuwamy pierwszą jedynkę i kolejne od niej
3,4,5 i już nie mamy gdzie przesuwać

po każdej zmianie pozycji tworzymy wiersz wypełniony zerami a w miejscach odpowiadających pozycją jedynek wstawiamy 1.
otrzymamy kolejno
11100
11010
11001
10110
10101
10011
01110
01101
01011
00111

teraz tylko zapisac to jako funkcję i gotowe

a co byś chciał przerobić i zoptymalizować?

algorytm o ktorym wspomniałem umożliwia wygenerowanie wszystkich kombinacji dla zadanej wielkosci tablicy
np dla 10 elementów generuje:
.....
0011111011
0011111100
0011111101
0011111110
0011111111
0100000000
0100000001
.....
jak widac nie robi tego kolejno na zasadzie wszystkie permutacje dla jednej jedynki w wierszu, nastepnie dla dwóch jedynek, trzech itd.
myślałem o przerobieniu go na zasadzie wycięcia wierszy które spełniają moje wymagania.
jednak w przypadku gdy chce wyciąć wiersze gdzie jest max dwie jedynki musze czekać aż on wygeneruje wszystkie możliwe kombinacje.
dla wiersza o długości 10 elementów to nie problem jednak dla wiersza o długości 10 elementów czas wyznaczenia wszystkich kombinacji znacznie sie wydłuża.

moje rozwiązanie było tworzone dla "nie więcej niż m elementów uszkodzonych" czyli dla pierwotnej wersji zadania, jeśli jednak potrzebujesz ciągi o konkretnej ilości m, to wystarczy tam dodać jednego ifa który ucina gałąź przy za małym m, ale zrobienie tego tak jak podałeś na (na oko) dwóch pętlach powinno działać szybciej