witam, mam ciekawy problem, szukałem na forum ale nic nie moglem znaleźć

a więc tak:
mam pewną ilość liczb w bazie danych
np.
1346
1650
5645
3643
2346
7554
3457
765

skrypt ma za zadanie sumować pokolei liczby do momentu aż wynik wyniesie np. 1000 lub 2000 lub 3000 aż do 10000, gdy wynik będzie większy niż 10000 to wtedy zaczyna sumować liczy od początku tylko że od następnej liczby czyli jak mamy
1346+1650=2996
1346+1650+5645=8641
1346+1650+5645+3643=12284
i zaczyna od nowa ale już od liczby 1650
1650+5645=7295
itd... aż do momentu gdy suma licz będzie równa 1000 lub jego wielokrotności to wtedy zacznie znowu od następnej liczby

ew. może też być suma każdej liczby z każdą

napisałem coś w podobnego ale mój skrypt ma wiele wad

[PHP] pobierz, plaintext 
<?php
 
function wygral($wynik1)
{
if($wynik1==1000)
echo "<b>Wygrales 1000</b><br>";
if($wynik1==2000)
echo "<b>Wygrales 2000</b><br>";
if($wynik1==3000)
echo "<b>Wygrales 3000</b><br>";
if($wynik1==4000)
echo "<b>Wygrales 4000</b><br>";
if($wynik1==5000)
echo "<b>Wygrales 5000</b><br>";
if($wynik1==6000)
echo "<b>Wygrales 6000</b><br>";
if($wynik1==7000)
echo "<b>Wygrales 7000</b><br>";
if($wynik1==8000)
echo "<b>Wygrales 8000</b><br>";
if($wynik1==9000)
echo "<b>Wygrales 9000</b><br>";
if($wynik1==10000)
echo "<b>Wygrales 10000</b><br>";
}
 
function czy_wygral($l1, $l2, $l3, $l4, $l5, $l6, $l7)
{
//1111111111111111111111111111111
if($l1>0 and $l2>0)
{
$wynik1=$l1+$l2;
echo "$l1+$l2=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l2>0 and $l3>0)
{
$wynik1=$l1+$l2+$l3;
echo "$l1+$l2+$l3=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l2>0 and $l3>0 and $l4>0)
{
$wynik1=$l1+$l2+$l3+$l4;
echo "$l1+$l2+$l3+$l4=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l2>0 and $l3>0 and $l4>0 and $l5>0)
{
$wynik1=$l1+$l2+$l3+$l4+$l5;
echo "$l1+$l2+$l3+$l4+$l5=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l2>0 and $l3>0 and $l4>0 and $l5>0 and $l6>0)
{
$wynik1=$l1+$l2+$l3+$l4+$l5+$l6;
echo "$l1+$l2+$l3+$l4+$l5+$l6=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l2>0 and $l3>0 and $l4>0 and $l5>0 and $l6>0 and $l7>0)
{
$wynik1=$l1+$l2+$l3+$l4+$l5+$l6+$l7;
echo "$l1+$l2+$l3+$l4+$l5+$l6+$l7=$wynik1<br>";
wygral($wynik1);
}
 
 
 
//2222222222222222222222222222222 bez 1
if($l2>0 and $l3>0)
{
$wynik1=$l2+$l3;
echo "$l2+$l3=$wynik1<br>";
wygral($wynik1);
}
 
if($l2>0 and $l3>0 and $l4>0)
{
$wynik1=$l2+$l3+$l4;
echo "$l2+$l3+$l4=$wynik1<br>";
wygral($wynik1);
}
 
if($l2>0 and $l3>0 and $l4>0 and $l5>0)
{
$wynik1=$l2+$l3+$l4+$l5;
echo "$l2+$l3+$l4+$l5=$wynik1<br>";
wygral($wynik1);
}
 
if($l2>0 and $l3>0 and $l4>0 and $l5>0 and $l6>0)
{
$wynik1=$l2+$l3+$l4+$l5+$l6;
echo "$l2+$l3+$l4+$l5+$l6=$wynik1<br>";
wygral($wynik1);
}
 
if($l2>0 and $l3>0 and $l4>0 and $l5>0 and $l6>0 and $l7>0)
{
$wynik1=$l2+$l3+$l4+$l5+$l6+$l7;
echo "$l2+$l3+$l4+$l5+$l6+$l7=$wynik1<br>";
wygral($wynik1);
}
 
 
 
//3333333333333333333333333333333 bez 1,2
if($l3>0 and $l4>0)
{
$wynik1=$l3+$l4;
echo "$l3+$l4=$wynik1<br>";
wygral($wynik1);
}
 
if($l3>0 and $l4>0 and $l5>0)
{
$wynik1=$l3+$l4+$l5;
echo "$l3+$l4+$l5=$wynik1<br>";
wygral($wynik1);
}
 
if($l3>0 and $l4>0 and $l5>0 and $l6>0)
{
$wynik1=$l3+$l4+$l5+$l6;
echo "$l3+$l4+$l5+$l6=$wynik1<br>";
wygral($wynik1);
}
 
if($l3>0 and $l4>0 and $l5>0 and $l6>0 and $l7>0)
{
$wynik1=$l3+$l4+$l5+$l6+$l7;
echo "$l3+$l4+$l5+$l6+$l7=$wynik1<br>";
wygral($wynik1);
}
 
 
 
//4444444444444444444444444444444 bez 1,2,3
if($l4>0 and $l5>0)
{
$wynik1=$l4+$l5;
echo "$l4+$l5=$wynik1<br>";
wygral($wynik1);
}
 
if($l4>0 and $l5>0 and $l6>0)
{
$wynik1=$l4+$l5+$l6;
echo "$l4+$l5+$l6=$wynik1<br>";
wygral($wynik1);
}
 
if($l4>0 and $l5>0 and $l6>0 and $l7>0)
{
$wynik1=$l4+$l5+$l6+$l7;
echo "$l4+$l5+$l6+$l7=$wynik1<br>";
wygral($wynik1);
}
 
 
 
//5555555555555555555555555555555 bez 1,2,3,4
if($l5>0 and $l6>0)
{
$wynik1=$l5+$l6;
echo "$l5+$l6=$wynik1<br>";
wygral($wynik1);
}
 
if($l5>0 and $l6>0 and $l7>0)
{
$wynik1=$l5+$l6+$l7;
echo "$l5+$l6+$l7=$wynik1<br>";
wygral($wynik1);
}
 
 
//6666666666666666666666666666666 bez 1,2,3,4,5
if($l6>0 and $l7>0)
{
$wynik1=$l6+$l7;
echo "$l6+$l7=$wynik1<br>";
wygral($wynik1);
}
 
//1111111111111111111111111111111 bez 2
if($l1>0 and $l3>0)
{
$wynik1=$l1+$l3;
echo "$l1+$l3=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l3>0 and $l4>0)
{
$wynik1=$l1+$l3+$l4;
echo "$l1+$l3+$l4=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l3>0 and $l4>0 and $l5>0)
{
$wynik1=$l1+$l3+$l4+$l5;
echo "$l1+$l3+$l4+$l5=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l3>0 and $l4>0 and $l5>0 and $l6>0)
{
$wynik1=$l1+$l3+$l4+$l5+$l6;
echo "$l1+$l3+$l4+$l5+$l6=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l3>0 and $l4>0 and $l5>0 and $l6>0 and $l7>0)
{
$wynik1=$l1+$l3+$l4+$l5+$l6+$l7;
echo "$l1+$l3+$l4+$l5+$l6+$l7=$wynik1<br>";
wygral($wynik1);
}
 
//1111111111111111111111111111111 bez 3
if($l1>0 and $l2>0 and $l4>0)
{
$wynik1=$l1+$l2+$l4;
echo "$l1+$l2+$l4=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l2>0 and $l4>0 and $l5>0)
{
$wynik1=$l1+$l2+$l4+$l5;
echo "$l1+$l2+$l4+$l5=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l2>0 and $l4>0 and $l5>0 and $l6>0)
{
$wynik1=$l1+$l2+$l4+$l5+$l6;
echo "$l1+$l2+$l4+$l5+$l6=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l2>0 and $l4>0 and $l5>0 and $l6>0 and $l7>0)
{
$wynik1=$l1+$l2+$l4+$l5+$l6+$l7;
echo "$l1+$l2+$l4+$l5+$l6+$l7=$wynik1<br>";
wygral($wynik1);
}
 
//1111111111111111111111111111111 bez 4
if($l1>0 and $l2>0 and $l3>0 and $l5>0)
{
$wynik1=$l1+$l2+$l3+$l5;
echo "$l1+$l2+$l3+$l5=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l2>0 and $l3>0 and $l5>0 and $l6>0)
{
$wynik1=$l1+$l2+$l3+$l5+$l6;
echo "$l1+$l2+$l3+$l5+$l6=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l2>0 and $l3>0 and $l5>0 and $l6>0 and $l7>0)
{
$wynik1=$l1+$l2+$l3+$l5+$l6+$l7;
echo "$l1+$l2+$l3+$l5+$l6+$l7=$wynik1<br>";
wygral($wynik1);
}
 
//1111111111111111111111111111111 bez 5
if($l1>0 and $l2>0 and $l3>0 and $l4>0 and $l6>0)
{
$wynik1=$l1+$l2+$l3+$l4+$l6;
echo "$l1+$l2+$l3+$l4+$l6=$wynik1<br>";
wygral($wynik1);
}
 
if($l1>0 and $l2>0 and $l3>0 and $l4>0 and $l6>0 and $l7>0)
{
$wynik1=$l1+$l2+$l3+$l4+$l6+$l7;
echo "$l1+$l2+$l3+$l4+$l6+$l7=$wynik1<br>";
wygral($wynik1);
}
 
//1111111111111111111111111111111 bez 6
if($l1>0 and $l2>0 and $l3>0 and $l4>0 and $l5>0 and $l7>0)
{
$wynik1=$l1+$l2+$l3+$l4+$l5+$l7;
echo "$l1+$l2+$l3+$l4+$l5+$l7=$wynik1<br>";
wygral($wynik1);
}
//
}
 
$liczba[1] = 1023;
$liczba[2] = 423;
$liczba[3] = 2345;
$liczba[4] = 261;
$liczba[5] = 3055;
$liczba[6] = 1894;
$liczba[7] = 106;
$liczba[8] = 25;
$liczba[9] = 2075;
$liczba[10] = 1001;
$liczba[11] = 999;
$liczba[12] = 56;
$liczba[13] = 999;
$liczba[14] = 999;
$liczba[15] = 1;
$liczba[16] = 500;
$liczba[17] = 4500;
$liczba[18] = 386;
$liczba[19] = 4607;
$liczba[20] = 4392;
$liczba[21] = 1396;
$liczba[22] = 914;
 
echo "Liczby które podales:<br>";
for($u=1;$u<=22;$u++)
{
echo "$liczba[$u]<br>";
}
echo "<br><br>";
 
/////////////////////////
//wy�wietlenie wyników://
/////////////////////////
 
echo "NIżej wy�wietlš się sumy 2 kolejnych liczb<br>";
 
$q1=1;
$q2=2;
$q3=3;
$q4=4;
$q5=5;
$q6=6;
$q7=7;
 
for($t=0;$t<=22;$t++)
{
$q1=1+$t;
$q2=2+$t;
$q3=3+$t;
$q4=4+$t;
$q5=5+$t;
$q6=6+$t;
$q7=7+$t;
if($q2>17)
$q2=0;
if($q3>22)
$q3=0;
if($q4>22)
$q4=0;
if($q5>22)
$q5=0;
if($q6>22)
$q6=0;
if($q7>22)
$q7=0;
czy_wygral($liczba[$q1],$liczba[$q2],$liczba[$q3],$liczba[$q4],$liczba[$q5],$liczba[$q6],$liczba[$q7]);
$t=$t+6;
}
 
 
?>
[PHP] pobierz, plaintext 

Przyznam się szczerze, że ni cholery z Twojego kodu nie rozumiem .

[PHP] pobierz, plaintext 
$numbers = array(... ); // tablica z liczbami wejściowymi
$sums = array(); // sumy
$cnt = sizeof($numbers);
 
for($i = 0; $i < $cnt; $i++)
{
   foreach($sums as $idx => &$sum)
   {
      $sum += $numbers[$i];
      if($sum % 1000 == 0)
      {
         echo 'Wygrałeś '.$sum;
         unset($sums[$idx]);
      }
      elseif($sum > 10000)
      {
         unset($sums[$idx]);
      }
   }
   $sums[] = $numbers[$i];
}
[PHP] pobierz, plaintext 

O ile dobrze zrozumiałem, to ten kod będzie robił to, co chcesz. Ponieważ w pesymistycznym przypadku sumowane są wszystkie możliwe okna nad danym ciągiem liczb, uznałem, że nie ma sensu, aby komplikować kod cofaniem się w tablicy wyników o kupę pozycji. Zamiast tego od razu sumuję okna zaczynające się od wszystkich liczb naraz i natychmiast sprawdzam, czy w którymś z nich nie przekroczyliśmy 10000 lub nie osiągnęliśmy wielokrotności 1000. Jeśli tak się stało, to po prostu usuwamy takie okno z listy.

Zyx... Albo ja już jestem 100 lat za murzynami, albo właśnie się dowiedziałem, że każdy fragment kodu w PHP domyślnie działa wielowątkowo i można sobie odpalać thread w dowolnym miejscu, nawet bez deklaracji tego, a interpreter sam sobie zgaduje kiedy należy to zrobić
Jak na razie to kod wykonuje się sekwencyjnie i tak też będzie działał w tym wypadku, tak więc odpalanie masy instancji sum można sobie o kant d... roztrzasnąć Poza tym nic nam nie da wyświetlenie wyniku okna, skoro "gubimy" informację w tym samym momencie o tym jaki indeks był "startowym" dla ciągu danych by moc określić jakie elementy składały się na sumę dającą wielokrotność 1000. Musimy przynajmniej ten element (jego indeks) startowy oznaczyć lub gdzieś przechować, a unset nam go przecież usunie. Inna sprawa, że w przypadku ostatnich elementów tablicy brak "zawinięcia", przez co tracimy możliwość dodania do ostatnich elementów tych z początku tablicy by ewentualnie wyłapać krotność. Czyli dla pewności sum prędzej coś w deseń:

[PHP] pobierz, plaintext 
$sum += $numbers[($i+$cnt)%$cnt];
[PHP] pobierz, plaintext 

Ogólnie pomysł z oknami jest dobry i mi samemu się podoba, tyle że bym dodał tablicę przechowującą index i sumę oraz "rollover". Może więcej ciut operacji, ale myślę, że to pewniejsze ciut.

Inna sprawa, że tak naprawdę takimi działaniami tworzymy małą liczbę kombinacji spośród możliwych i mamy zbyt dużą szansę "przeoczyć" pasujące kombinacje. Prędzej powinno być "skakanie po węzłach" z zapamiętywaniem kombinacji węzłów. Trudno tak od razu podać gotowy kod, ale algorytm byłby następujący:
1. Weź pierwszy wolny element.
2. Dodaj do niego "następny".
3. Sprawdź czy wielokrotność 1000 a jeśli tak to zapisz id korzenia i "następnych"
4. Jeśli suma większa od 10.000 to wymień ten "następny" na najbliższy wolny.
5. Jeśli suma mniejsza niż 10.000 dodaj następny "wolny".
6. Idź do kroku 3
7. Jeśli "następny" doszedł do końca tablicy to wymień "następny" element w kroku 2.
8. Jeśli i on doszedł do końca to dopiero przesuń "korzeń" o 1 pozycje.
9. Gdy "korzeń" dojdzie do końca to koniec sprawdzania.

Tak więc zrobi się z tego tak naprawdę ostro rozjechany krzaczor sprawdzający wszystko jak popadnie

EDIT: Dziewczyna mnie zirytowała więc siadłem na kompie i popełniłem ten rekurencyjny kod, by odreagować...

[PHP] pobierz, plaintext 
$source = array(123,123,23,4,4564,464,467,624,5467,4567,533,1434,3455);
$count = count( $source );
$bulls_eye = array();
function check( $src, $i, $cnt, $actual_sum, &$results, $string) {
    for($t=$i+1; $t<$cnt; $t++) {
        $temporary=$actual_sum+$src[$t];
        $new_string = $string.','.$t;
        if($temporary>10000)
            continue;
        elseif($temporary%1000==0)
            $results[] = array($new_string, $temporary);
        else
            check($src, $t, $cnt, $temporary, $results, $new_string);
    }
};
 
for($i=0; $i<$count; $i++) {
    $temp0 = $source[$i];
    check( $source, $i, $count, $temp0, $bulls_eye, $i);
}
foreach($bulls_eye AS $k => $kombinacja) {
    $indexy = explode(',', $kombinacja[0] );
    $kwoty = array();
    foreach( $indexy AS $klucz )
        $kwoty[] = $source[ $klucz ];
    $kwoty = implode('+', $kwoty);
    $kwoty .= ' = '.$kombinacja[1];
    $bulls_eye[$k] = $kwoty;
}
var_dump($bulls_eye);
[PHP] pobierz, plaintext 

W $bulls_eye masz wyniki, $src to Twoje kupony z AminoLotto Parę zmiennych można było liczyć na bieżąco, ale by nie robić tego co i rusz to przekazywałem do funkcji jako parametry. W wyniku otrzymujesz coś takiego dla mojego kompletnie zmyślonego przypadku i klepania po klawiaturze numerycznej:

[PHP] pobierz, plaintext 
array(4) { [0]=>  string(35) "23+464+467+624+533+1434+3455 = 7000" [1]=>  string(27) "23+464+624+1434+3455 = 6000" [2]=>  string(14) "467+533 = 1000" [3]=>  string(15) "5467+533 = 6000" } 
[PHP] pobierz, plaintext 

EDIT2: Foreach od 21 linijki już tylko obrabia wyniki byś widział jakie kwoty są konieczne do zsumowania. Ale konkretne indeksy masz już w tym momencie dostępne. Wystarczy że zrobisz var_dump($bulls_eye), a dostaniesz tablicę 2-wymiarową, gdzie jako wartości są klucze po przecinku i suma.

[PHP] pobierz, plaintext 
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<html>
    <head>
        <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-2">
        <title></title>
    </head>
    <body>
        <?php
            $DbHost = '';
            $DbUser = '';
            $DbPassword = '';
            $DbName = '';
            mysql_connect( $DbHost, $DbUser, $DbPassword );
            mysql_select_db( $DbName );
 
            if( isset( $_POST['kwota'] ) ){
                $add = mysql_query( "INSERT INTO amino VALUES( '', '". $_POST['kwota'] ."' )" ) or die( mysql_error() );
                echo 'Kwota <b>'. $_POST['kwota'] .'</b> została dodana. <br />';
            }
 
            if( isset( $_GET['id'] ) ){
                $delete = mysql_query( "DELETE FROM amino WHERE Id='". $_GET['id'] ."' LIMIT 1" ) or die( mysql_error() );
                echo 'Kwota <b>'. $_GET['kwota'] .'</b> została usunięta. <br />';
            }
 
            echo '<b>Wprowadzone kwoty:</b>';
            $select = mysql_query( "SELECT * FROM amino" ) or die( mysql_error() );
            $results = array();
            while( $result = mysql_fetch_assoc( $select ) ){
                echo ' '. $result['Kwota'];
                $results[] = $result['Kwota'];
            }
            echo '<br /><b>Kombinacje:</b><br />';
 
            $tab = $results;
            $ile = count($tab);
 
            $num = str_repeat('1', $ile);
            $num = bindec($num); // mamy (prawie) wyliczoną liczbę możliwych kombinacji
 
            $tmpNum = $num;
            $results = array();
            $modulo1000 = array();
 
            while($tmpNum > 0)
            {
                // zeby errorow nie bylo
                $tmpNumStr = str_pad(decbin($tmpNum), $ile, '0', STR_PAD_LEFT);
 
                $sum = 0;
                $sumStr = '';
                $numsAdded = 0;
 
                for($i=0; $i<$ile; $i++)
                {
                    // czy wstawic liczbe
                    if($tmpNumStr[$i] == '1')
                    {
                        $sum+= $tab[$i];
                        $sumStr.=' + '.$tab[$i];
                        $numsAdded++;
                    }
                }
                // jezeli tylko jedna liczba to nie jest to działanie
                if($numsAdded>1)
                {
                    //$results[] = substr($sumStr, 3).' = '.$sum;
                    if( ( $sum % 1000 == 0 ) AND ( $sum <= 10000 ) ){
                        $modulo1000[] = substr($sumStr, 3).' = '.$sum;
                    }
                }
 
                $tmpNum --;
            }
 
            foreach( $modulo1000 as $result ){
                echo $result .'<br />';
            }
 
            echo '<b>Usuwanie:</b><br />';
            $select = mysql_query( "SELECT * FROM amino" ) or die( mysql_error() );
            while( $result = mysql_fetch_assoc( $select ) ){
                 echo '<a href="index.php?id='. $result['Id'].'&kwota='. $result['Kwota'] .'">'. $result['Kwota'] .'</a> ';
            }
        ?>
        <form action="index.php" method="post">
            <input type="text" name="kwota">
            <input type="submit" value="dodaj">
        </form>
    </body>
</html>
[PHP] pobierz, plaintext 

[SQL] pobierz, plaintext 
amino
Id	int(11)
Kwota	int(11)
[SQL] pobierz, plaintext 

? ;>

Wcale nie twierdzę, że w PHP magicznie pojawiła się wielowątkowość. Przyjrzyj się uważnie, jak autor chce realizować obliczenia:

mamy liczby a, b, c, d, e, f

a
a+b
a+b+c
a+b+c+d
a+b+c+d+e
a+b+c+d+e+f

Jeśli w którymkolwiek miejscu osiągniemy wielokrotność 1000 lub przekroczymy 10 000, to zaczynamy ponownie:

b
b+c
b+c+d
b+c+d+e
b+c+d+e+f

Warunek ten sam, przeskakujemy dalej:

c
c+d
c+d+e
c+d+e+f

itd.

Autor nic nie wspomniał, że obliczenia muszą być realizowane dokładnie w takiej kolejności. Więcej, napisał, że sumy typu "b+d+f" mogą wystąpić EWENTUALNIE, a ponieważ dodatkowo oznaczył post jako "Pomógł", wnioskuję, że dobrze go zrozumiałem i postuluję, że można je realizować w taki sposób:

Iteracja 1 (każdy wiersz oznacza pamiętaną sumę):

a

Iteracja 2:
a+b
b

Iteracja 3:

a+b+c
b+c
c

Iteracja 4:

a+b+c+d
b+c+d
c+d
d

itd.

Jeśli podczas sumowania okaże się, że osiągnęliśmy wielokrotność 1000 lub przekroczyliśmy 10000, to taką sumę wywalamy z dalszych obliczeń. Przypuśćmy, że w iteracji 4 suma b+c+d dała nam 3000. Wtedy wyświetlamy "Wygrałeś" i usuwamy ją, dzięki czemu w iteracji 5 mamy:

a+b+c+d+e
c+d+e
d+e
e

I to właśnie robi zaproponowany przeze mnie kod - twierdzę, że poprawnie wyłapie on każdą sumę "n" kolejnych liczb, która daje wielokrotność 1000 mniejszą, niż 10000, czyli to, czego chce autor.

PS. Guzik mnie obchodzi, czy to jest jakieś AminoLotto czy inny bzdet . Nie oglądam telewizji, nie kupuję Amino, autor chciał sumowanie "n" kolejnych liczb i dostał takie sumowanie .

I dlatego też napisałem, że pomysł z oknami jest dobry, ale należało by go nieco rozszerzyć o wspomniane przeze mnie elementy jak "przekręcenie" tablicy dla ostatnich elementów i przechwycenie elementu początkowego dla danego okna. Jeśli spojrzysz do mojego kodu, to ja już "zaszalałem" z rekurencją, dla której obojętne jest już, czy mamy je obok siebie czy nie, bo trafi także jako pasującą choćby kombinację 8 i 10 elementu. Ale jak popatrzysz na wyniki to zobaczysz, że wariacje są nawet kilkuelementowe w sumach. Taki var_dump przed przekładaniem na zrozumiałą sumę daje w wyniku nawet 7-elementowy pierwszy element:

[PHP] pobierz, plaintext 
array(4) { [0]=>  array(2) { [0]=>  string(16) "2,5,6,7,10,11,12" [1]=>  int(7000) } [1]=>  array(2) { [0]=>  string(11) "2,5,7,11,12" [1]=>  int(6000) } [2]=>  array(2) { [0]=>  string(4) "6,10" [1]=>  int(1000) } [3]=>  array(2) { [0]=>  string(4) "8,10" [1]=>  int(6000) } } 
[PHP] pobierz, plaintext 

Nie można chyba już większej ilości kombinacji "każdy z każdym i w razie czego jeszcze z innymi" zrobić Wiem, że mój algorytm jest kolosem pamięciożernym, ale działa

Twój także gdy zredukujemy liczbę kombinacji do n-elementowych ciągów kolejnych wartości. ale ze zmniejszającą się liczbą dla ostatnich elementów. Bo w sytuacji gdy mamy przedostatni+ostatni+pierwszy możliwość krotności 1000, to akurat nie masz możliwości jej wyłapać. Ogólnie jednak "okienkowanie" to często stosowany wariant w wielu algorytmach numerycznych i sam nieraz go stosuje... Tyle, że jak wspomniałem, ma on swoje ograniczenia i myslę, że jesteś ich świadom.