Skocz do zawartości

  • 👋 Witaj na MPCForum!

    Przeglądasz forum jako gość, co oznacza, że wiele świetnych funkcji jest jeszcze przed Tobą! 😎

    • ✅ Pełny dostęp do działów i ukrytych treści
    • ✅ Możliwość pisania i odpowiadania w tematach
    • ✅ System prywatnych wiadomości
    • ✅ Zbieranie reputacji i rozwijanie swojego profilu
    • ✅ Członkostwo w jednej z największych społeczności graczy

    👉 Dołączenie zajmie Ci mniej niż minutę – a zyskasz znacznie więcej!

    Zarejestruj się teraz

fibonacci

miki6299

Przez miki6299
w Niezbędnik Programisty - Archiwum

Rekomendowane odpowiedzi

miki6299 Rekrut

miki6299

Opublikowano
Rekrut

miki6299

Opublikowano

Prośba o przedstawienie innych rozwiązań

class Fibonaci
{
    public static void main(String[] args)
    {
        long x = 0;
        long y = 1;
        long c = 0;
        int f = 2;
        int z = 4; // n -ta liczba ciągu Fibonacciego
        
        while (f < z)
        {
            c = (x + y);
            x = c;
            f++;
            if (f < z)
            {
            c = (x + y);
            y = c;
            f++;
            }
        }
        System.out.println(c);
    }

}
Sopelek997 Weteran

Sopelek997

Opublikowano
Weteran

Sopelek997

Opublikowano

Od razu uprzedzam, że liczenie wyrazów ciągu fibbonaciego rekurencyjnie to najgorsze podejście i nie powinno być wykorzystywane.

981841412442977292370.png
Hans Kloss PL Uczeń

Hans Kloss PL

Opublikowano
Uczeń

Hans Kloss PL

Opublikowano

@Sopelek997

Owszem, coś takiego to zbrodnia (choć zapis bardzo ładny):

function fib(x){
  if(x < 2){
    return x;
  }
  else{
    return fib(x - 1) + fib(x - 2);
  }
}

ale można to zrobić wydajnie i w bardzo podobnym stylu za pomocą tablicy (omijając rekurencję):

function fib2(x){
  var i, f = [];
  f[0] = 0;
  f[1] = 1;
  for(i = 2; i <= x; i++){
    f[i] = f[i - 1] + f[i - 2];
  }
  return f[x];
}

PS

Tak wiem, temat w Javie a ja JavaScript wrzucam, ale myślę, że autor bez problemu sobie to przetłumaczy (ja mógłbym zrobić błąd bo nie znam składni javy).

Chcesz precyzyjnej i zrozumiałej odpowiedzi? - Zadaj precyzyjne i zrozumiałe pytanie. Nie przyjmuję zleceń.
Nie odpowiadam na priv na pytania, które można zadać na forum. Chcesz mojej pomocy - oznacz mnie w poście =>  @"Hans Kloss PL" 

Hans Kloss PL Uczeń

Hans Kloss PL

Opublikowano
Uczeń

Hans Kloss PL

Opublikowano

@Fireho
 
tl;dr
Mylisz wydajność z zasobożernością.
 
Dłuższa odpowiedź:
 
Przetestujmy 4 różne wersje:
 

// Metoda rekurencyjna
function fib(x){
  if(x < 2){
    return x;
  }
  else{
    return fib(x - 1) + fib(x - 2);
  }
}

// metoda dynamiczna
function fib2(x){
  var i, f = [];
  f[0] = 0;
  f[1] = 1;
  for(i = 2; i <= x; i++){
    f[i] = f[i - 1] + f[i - 2];
  }
  return f[x];
}

// metoda iteracyjna
function fib3(x){
  var i, a, b, c;
  if(x == 1 || x ==2){
    return 1;
  }
  else
  {
    a = 1;
    b = 1;
    c = 0;
    for(i = 0; i < x - 2; i++)
    {
      c = a + b;
      a = b;
      b = c;
    }
    return c;
  }
}

// ze wzoru
function fib4(x){
  var fi, binet;
  fi = (Math.sqrt(5) + 1) / 2;
  binet = (Math.pow(fi, x) - Math.pow((fi - 1), x)) * Math.sqrt(5) / 5;
  return binet;
}

Test 1: szukanie pięćdziesiątego wyrazu ciągu:

Funkcja fib(50) - rekurencyjnie:
Wynik: 12586269025
Czas wykonania: 181035 ms (ok. 3m!)
 
Funkcja fib2(50) - dynamicznie:
Wynik: 12586269025
Czas wykonania: 0 ms
 
Funkcja fib3(50) - iteracyjnie:
Wynik: 12586269025
Czas wykonania: 0 ms
 
Funkcja fib4(50) - ze wzoru:
Wynik: 12586269024.999998
Czas wykonania: 0 ms

Test 2: ostatni wyraz ciągu na jakiego obliczenie pozwala typ number (double-precision floating-point ):

Funkcja fib2(1476) - dynamicznie:
Wynik: 1.3069892237633987e+308
Czas wykonania: 0 ms

Funkcja fib3(1476) - iteracyjnie:
Wynik: 1.3069892237633987e+308
Czas wykonania: 0 ms

Funkcja fib4(1476) - ze wzoru:
Wynik: Infinity
Czas wykonania: 0 ms

 
Pełny kod testu (można samodzielnie przetestować w konsoli Javascriptu - Ctrl+Shift+J w Chrome):

 

 

// Metoda rekurencyjna
function fib(x){
  if(x < 2){
    return x;
  }
  else{
    return fib(x - 1) + fib(x - 2);
  }
}

// metoda dynamiczna
function fib2(x){
  var i, f = [];
  f[0] = 0;
  f[1] = 1;
  for(i = 2; i <= x; i++){
    f[i] = f[i - 1] + f[i - 2];
  }
  return f[x];
}

// metoda iteracyjna
function fib3(x){
  var i, a, b, c;
  if(x == 1 || x ==2){
    return 1;
  }
  else
  {
    a = 1;
    b = 1;
    c = 0;
    for(i = 0; i < x - 2; i++)
    {
      c = a + b;
      a = b;
      b = c;
    }
    return c;
  }
}

// ze wzoru
function fib4(x){
  var fi, binet;
  fi = (Math.sqrt(5) + 1) / 2;
  binet = (Math.pow(fi, x) - Math.pow((fi - 1), x)) * Math.sqrt(5) / 5;
  return binet;
}

var start, end, time, n, result;

// **************************************
// Tu wpisz interesujący Cię wyraz ciągu:
n = 50;
// **************************************

console.log('Funkcja fib(' + n + ') - rekurencyjnie:');
start = new Date().getTime();
result = fib(n);
end = new Date().getTime();
time = end - start;
console.log('Wynik: ' + result);
console.log('Czas wykonania: ' + time + ' ms');

console.log('Funkcja fib2(' + n + ') - dynamicznie:');
start = new Date().getTime();
result = fib2(n);
end = new Date().getTime();
time = end - start;
console.log('Wynik: ' + result);
console.log('Czas wykonania: ' + time + ' ms');

console.log('Funkcja fib3(' + n + ') - iteracyjnie:');
start = new Date().getTime();
result = fib3(n);
end = new Date().getTime();
time = end - start;
console.log('Wynik: ' + result);
console.log('Czas wykonania: ' + time + ' ms');

console.log('Funkcja fib4(' + n + ') - ze wzoru:');
start = new Date().getTime();
result = fib4(n);
end = new Date().getTime();
time = end - start;
console.log('Wynik: ' + result);
console.log('Czas wykonania: ' + time + ' ms');

 

 

 

Wnioski:

  • metoda rekurencyjna nie nadaje się do użytku dla odległych wyrazów ciągu,
  • stosowanie wzoru daje tylko przybliżony wynik, przez co wychodzi poza zakres wcześniej niż powinno (podaje też całkowicie błędny wynik dla pierwszego wyrazu ciągu),
  • jeśli chodzi o wydajność szukania konkretnego wyrazu ciągu to metody 2-4 są porównywalne.

Oczywiście metoda dynamiczna zajmuje (tylko na czas obliczeń!) więcej pamięci, dla ostatniego możliwego do policzenia wyrazu ciągu będzie to:

1476 * 64 bit = 94464 bit = 11.5 kB

W większości wypadków jest to całkowicie bez znaczenia.

 

 

Natomiast metoda dynamiczna ma niewątpliwą zaletę, zamiast zwracać tylko ostatni wyraz możemy zwrócić całą tablicę wyrazów ciągu od 0 do n. W łatwy sposób możemy także stworzyć uniwersalną funkcję:

// metoda dynamiczna
// tab - zwracanie całej tablicy wyników od 0 do n ( true / false, domyślnie false )
function fib2(x, tab){
  var i, f = [];
  f[0] = 0;
  f[1] = 1;
  for(i = 2; i <= x; i++){
    f[i] = f[i - 1] + f[i - 2];
  }
  if(tab == true){
    return f;
  }
  else{
    return f[x];
  }
}

Zróbmy teraz kolejny test - policzmy nie tylko n-ty wyraz ciągu, ale wszystkie wyrazy ciągu od 0 do n. W przypadku metody dynamicznej mamy od razu gotowca, w przypadku pozostałych metod trzeba wykonać dodatkową pętlę (i n razy wykonać ten sam kod). Na wydajność przekłada się to następująco:

 

Test 3: obliczanie kolejnych wyrazów ciągu od 0 do 50:

Funkcja fib(50) - rekurencyjnie:
Obliczono 51 wyrazów ciągu.
Czas wykonania: 474697 ms (ok. 8m!)

Funkcja fib2(50) - dynamicznie:
Obliczono 51 wyrazów ciągu.
Czas wykonania: 0 ms

Funkcja fib3(50) - iteracyjnie:
Obliczono 51 wyrazów ciągu.
Czas wykonania: 0 ms

Funkcja fib4(50) - ze wzoru:
Obliczono 51 wyrazów ciągu.
Czas wykonania: 0 ms

Test 4: obliczanie kolejnych wyrazów ciągu od 0 do 1476:

Funkcja fib2(1476) - dynamicznie:
Obliczono 1477 wyrazów ciągu.
Czas wykonania: 0 ms

Funkcja fib3(1476) - iteracyjnie:
Obliczono 1477 wyrazów ciągu.
Czas wykonania: 7 ms

Funkcja fib4(1476) - ze wzoru:
Obliczono 1477 wyrazów ciągu.
Czas wykonania: 4 ms

Pełny kod testu (można samodzielnie przetestować w konsoli Javascriptu - Ctrl+Shift+J w Chrome):

 

 

// Metoda rekurencyjna
function fib(x){
  if(x < 2){
    return x;
  }
  else{
    return fib(x - 1) + fib(x - 2);
  }
}

// metoda dynamiczna
// tab - zwracanie całej tablicy wyników od 0 do n ( true / false, domyślnie false )
function fib2(x, tab){
  var i, f = [];
  f[0] = 0;
  f[1] = 1;
  for(i = 2; i <= x; i++){
    f[i] = f[i - 1] + f[i - 2];
  }
  if(tab == true){
    return f;
  }
  else{
    return f[x];
  }
}

// metoda iteracyjna
function fib3(x){
  var i, a, b, c;
  if(x == 1 || x ==2){
    return 1;
  }
  else
  {
    a = 1;
    b = 1;
    c = 0;
    for(i = 0; i < x - 2; i++)
    {
      c = a + b;
      a = b;
      b = c;
    }
    return c;
  }
}

// ze wzoru
function fib4(x){
  var fi, binet;
  fi = (Math.sqrt(5) + 1) / 2;
  binet = (Math.pow(fi, x) - Math.pow((fi - 1), x)) * Math.sqrt(5) / 5;
  return binet;
}

var start, end, time, n, result = [], i;

// **************************************
// Tu wpisz interesujący Cię wyraz ciągu:
n = 50;
// **************************************

//console.log('Funkcja fib(' + n + ') - rekurencyjnie:');
//start = new Date().getTime();
//for(i = 0; i <= n; i++){
//  result[i] = fib(i);
//}
//end = new Date().getTime();
//time = end - start;
//console.log('Obliczono ' + result.length + ' wyrazów ciągu.');
//console.log('Czas wykonania: ' + time + ' ms');

console.log('Funkcja fib2(' + n + ') - dynamicznie:');
start = new Date().getTime();
result = fib2(n, true);
end = new Date().getTime();
time = end - start;
console.log('Obliczono ' + result.length + ' wyrazów ciągu.');
console.log('Czas wykonania: ' + time + ' ms');

console.log('Funkcja fib3(' + n + ') - iteracyjnie:');
start = new Date().getTime();
for(i = 0; i <= n; i++){
  result[i] = fib3(i);
}
end = new Date().getTime();
time = end - start;
console.log('Obliczono ' + result.length + ' wyrazów ciągu.');
console.log('Czas wykonania: ' + time + ' ms');

console.log('Funkcja fib4(' + n + ') - ze wzoru:');
start = new Date().getTime();
for(i = 0; i <= n; i++){
  result[i] = fib4(i);
}
end = new Date().getTime();
time = end - start;
console.log('Obliczono ' + result.length + ' wyrazów ciągu.');
console.log('Czas wykonania: ' + time + ' ms');

 

 

 

Wnioski:

  • rekurencja dalej zipie ;)
  • metoda dynamiczna jest wielokrotnie szybsza (o ile dokładnie nie powiem, bo przecież nie będę dzielił przez 0 - musiałbym zastosować większą rozdzielczość pomiaru),
  • jeśli nie plotujemy danych od razu tylko zapisujemy je w tablicy to zajętość pamięci jest taka sama.

 

Konkluzja:

Z przedstawionych powyżej metod w realnym zastosowaniu, gdzie najczęściej nie liczymy pojedynczych wyrazów ciągu tylko całe zakresy (np. rysowanie grafiki) metoda dynamiczna jest najbardziej efektywna.

Jednocześnie zachowujemy prostotę i elegancję metody rekurencyjnej. Nie jest także wymagana dodatkowa pętla.

Jedyne przeciwwskazanie do jej stosowania jakie mi przychodzi do głowy to skrajnie mała dostępność pamięci.

 

 

Edit:

Przy dokładniejszych pomiarach dla kolejnych wyrazów ciągu od 0 do 1476 wyniki są następujące:

Funkcja fib2(1476) - dynamicznie:
Czas: 0.227ms
Obliczono 1477 wyrazów ciągu.

Funkcja fib3(1476) - iteracyjnie:
Czas: 8.743ms
Obliczono 1477 wyrazów ciągu.

Funkcja fib4(1476) - ze wzoru:
Czas: 3.377ms
Obliczono 1477 wyrazów ciągu.

Pełny kod testu (z starszych przeglądarkach taki pomiar czasu może nie zadziałać):

 

 

// Metoda rekurencyjna
function fib(x){
  if(x < 2){
    return x;
  }
  else{
    return fib(x - 1) + fib(x - 2);
  }
}

// metoda dynamiczna
// tab - zwracanie całej tablicy wyników od 0 do n ( true / false, domyślnie false )
function fib2(x, tab){
  var i, f = [];
  f[0] = 0;
  f[1] = 1;
  for(i = 2; i <= x; i++){
    f[i] = f[i - 1] + f[i - 2];
  }
  if(tab == true){
    return f;
  }
  else{
    return f[x];
  }
}

// metoda iteracyjna
function fib3(x){
  var i, a, b, c;
  if(x == 1 || x ==2){
    return 1;
  }
  else
  {
    a = 1;
    b = 1;
    c = 0;
    for(i = 0; i < x - 2; i++)
    {
      c = a + b;
      a = b;
      b = c;
    }
    return c;
  }
}

// ze wzoru
function fib4(x){
  var fi, binet;
  fi = (Math.sqrt(5) + 1) / 2;
  binet = (Math.pow(fi, x) - Math.pow((fi - 1), x)) * Math.sqrt(5) / 5;
  return binet;
}

var n, result = [], i;

// **************************************
// Tu wpisz interesujący Cię wyraz ciągu:
n = 1476;
// **************************************

//console.log('Funkcja fib(' + n + ') - rekurencyjnie:');
//console.time("Czas");
//for(i = 0; i <= n; i++){
//  result[i] = fib(i);
//}
//console.timeEnd("Czas");
//console.log('Obliczono ' + result.length + ' wyrazów ciągu.');

console.log('Funkcja fib2(' + n + ') - dynamicznie:');
console.time("Czas");
result = fib2(n, true);
console.timeEnd("Czas");
console.log('Obliczono ' + result.length + ' wyrazów ciągu.');

console.log('Funkcja fib3(' + n + ') - iteracyjnie:');
console.time("Czas");
for(i = 0; i <= n; i++){
  result[i] = fib3(i);
}
console.timeEnd("Czas");
console.log('Obliczono ' + result.length + ' wyrazów ciągu.');

console.log('Funkcja fib4(' + n + ') - ze wzoru:');
console.time("Czas");
for(i = 0; i <= n; i++){
  result[i] = fib4(i);
}
console.timeEnd("Czas");
console.log('Obliczono ' + result.length + ' wyrazów ciągu.');

 

 

 

Metoda dynamiczna jest w tym przypadku szybsza:

  • od zwykłej iteracji: ok 40x
  • od zastosowania wzoru: ok 15x
  • od rekurencji: pierdyliard razy

 

Dla całkowitej uczciości jeszcze wyniki liczenia pojedynczego wyrazu w lepszej rozdzielczości pomiaru (1470 wyraz, żeby metoda ze wzorem nie wypadła poza zakres):

Funkcja fib2(1470) - dynamicznie:
Czas: 0.160ms
Wynik: 7.283601309201629e+306

Funkcja fib3(1470) - iteracyjnie:
Czas: 0.088ms
Wynik: 7.283601309201629e+306

Funkcja fib4(1470) - ze wzoru:
Czas: 0.061ms
Wynik: 7.283601309201602e+306

Pełny kod testu (z starszych przeglądarkach taki pomiar czasu może nie zadziałać):

 

 

// Metoda rekurencyjna
function fib(x){
  if(x < 2){
    return x;
  }
  else{
    return fib(x - 1) + fib(x - 2);
  }
}

// metoda dynamiczna
function fib2(x){
  var i, f = [];
  f[0] = 0;
  f[1] = 1;
  for(i = 2; i <= x; i++){
    f[i] = f[i - 1] + f[i - 2];
  }
  return f[x];
}

// metoda iteracyjna
function fib3(x){
  var i, a, b, c;
  if(x == 1 || x ==2){
    return 1;
  }
  else
  {
    a = 1;
    b = 1;
    c = 0;
    for(i = 0; i < x - 2; i++)
    {
      c = a + b;
      a = b;
      b = c;
    }
    return c;
  }
}

// ze wzoru
function fib4(x){
  var fi, binet;
  fi = (Math.sqrt(5) + 1) / 2;
  binet = (Math.pow(fi, x) - Math.pow((fi - 1), x)) * Math.sqrt(5) / 5;
  return binet;
}

var n, result;

// **************************************
// Tu wpisz interesujący Cię wyraz ciągu:
n = 1470;
// **************************************

//console.log('Funkcja fib(' + n + ') - rekurencyjnie:');
//console.time("Czas");
//result = fib(n);
//console.timeEnd("Czas");
//console.log('Wynik: ' + result);

console.log('Funkcja fib2(' + n + ') - dynamicznie:');
console.time("Czas");
result = fib2(n);
console.timeEnd("Czas");
console.log('Wynik: ' + result);

console.log('Funkcja fib3(' + n + ') - iteracyjnie:');
console.time("Czas");
result = fib3(n);
console.timeEnd("Czas");
console.log('Wynik: ' + result);

console.log('Funkcja fib4(' + n + ') - ze wzoru:');
console.time("Czas");
result = fib4(n);
console.timeEnd("Czas");
console.log('Wynik: ' + result);

 

 

 

Metoda dynamiczna jest tu ok 2 razy wolniejsza, jednak powiedzmy sobie szczerze - przy czasie rzędu 0.1 ms jest to tylko ciekawostka - nie powtarzamy przecież wielokrotnie tego samego działania. 

Chcesz precyzyjnej i zrozumiałej odpowiedzi? - Zadaj precyzyjne i zrozumiałe pytanie. Nie przyjmuję zleceń.
Nie odpowiadam na priv na pytania, które można zadać na forum. Chcesz mojej pomocy - oznacz mnie w poście =>  @"Hans Kloss PL" 

Gość

Gość

Opublikowano

Gość

Opublikowano

@Hans Kloss PL Rekurencja ma złożoność 2n + każda operacja to wywołanie funkcji, więc nic dziwnego że takie wyniki... A próba liczenia całego ciągu obliczając iteracyjną/wzorem to idiotyzm, powtarza się wielokrotnie obliczenia jak w rekurencyjnej i się robi złożoność n2(a jak ma n2 konkurować z n?). Rozmawialiśmy o obliczaniu danej liczby z ciągu(patrz: kod autora), a nie całego ciągu aż do tej liczby.

Hans Kloss PL Uczeń

Hans Kloss PL

Opublikowano
Uczeń

Hans Kloss PL

Opublikowano

@Hans Kloss PL Rekurencja ma złożoność 2n + każda operacja to wywołanie funkcji, więc nic dziwnego że takie wyniki... A próba liczenia całego ciągu obliczając iteracyjną/wzorem to idiotyzm, powtarza się wielokrotnie obliczenia jak w rekurencyjnej i się robi złożoność n2(a jak ma n2 konkurować z n?). Rozmawialiśmy o obliczaniu danej liczby z ciągu(patrz: kod autora), a nie całego ciągu aż do tej liczby.

 

Wszystko prawda, ale nie wiem co chcesz mi powiedzieć. Twój zarzut na temat wydajności był bezzasadny, reszta to tylko ciekawostki i dodatkowe informacje dla autora tematu.

Chcesz precyzyjnej i zrozumiałej odpowiedzi? - Zadaj precyzyjne i zrozumiałe pytanie. Nie przyjmuję zleceń.
Nie odpowiadam na priv na pytania, które można zadać na forum. Chcesz mojej pomocy - oznacz mnie w poście =>  @"Hans Kloss PL" 

Gość

Gość

Opublikowano

Gość

Opublikowano

@Hans Kloss PL Zarzut był zasadny - nie jest to ogromna różnica i nigdy nie twierdziłem nawet że jest chociażby istotna. Po prostu trzymanie tych danych jest niepotrzebne gdy oblicza się tylko daną liczbę w ciągu, a więc nie ma sensu tego robić. Jeśli masz nastawienie "a kogo to obchodzi?", to mogę co najwyżej powiedzieć że o ile jeden przypadek nic nie znaczy, o tyle kiedy kod będzie ogólnie pisany w takim stylu takie drobnostki zbiorą się do kupy i różnica w wydajności będzie widoczna.

Hans Kloss PL Uczeń

Hans Kloss PL

Opublikowano
Uczeń

Hans Kloss PL

Opublikowano

@Fireho
Ok, tu się zgodzę - jak spojrzeć na jednostkowy przypadek to nie ma co czarować - inne rozwiązania są minimalnie szybsze (choć musiałem zejść do mikrosekund żeby zobaczyć różnicę, nie mówiąc już o tym, że w innych językach / na innych komputerach różnica może się jeszcze bardziej zacierać). Natomiast funkcję wrzuciłem nie jako przykład demona szybkości w tym konkretnym przypadku, ale jako przykład świetnej funkcji do realnego zastosowania. 
Najważniejsze to znać i rozumieć zakres zastosowania, wady i zalety danego rozwiązania - Twój komentarz był o tyle dobry, że wymusił na mnie omówienie tematu. Bo to, że ja wiem o co chodzi i Ty wiesz nie oznacza, że inni patrząc na suchy kod znajdą dla niego najlepsze zastosowanie.
 

Jeśli masz nastawienie "a kogo to obchodzi?", to mogę co najwyżej powiedzieć że o ile jeden przypadek nic nie znaczy, o tyle kiedy kod będzie ogólnie pisany w takim stylu takie drobnostki zbiorą się do kupy i różnica w wydajności będzie widoczna.

 

Nie mam takiego nastawienia, nie wiem na podstawie czego to wywnioskowałeś. 

 

PS

Jak edytujesz to zaznacz, że odpowiedź była edytowana.

Chcesz precyzyjnej i zrozumiałej odpowiedzi? - Zadaj precyzyjne i zrozumiałe pytanie. Nie przyjmuję zleceń.
Nie odpowiadam na priv na pytania, które można zadać na forum. Chcesz mojej pomocy - oznacz mnie w poście =>  @"Hans Kloss PL" 

VereX. Specjalista

VereX.

Opublikowano
Specjalista

VereX.

Opublikowano

@Fireho

Ok, tu się zgodzę - jak spojrzeć na jednostkowy przypadek to nie ma co czarować - inne rozwiązania są minimalnie szybsze. Natomiast funkcję wrzuciłem nie jako przykład demona szybkości w tym konkretnym przypadku, ale jako przykład świetnej funkcji do realnego zastosowania. 

Najważniejsze to znać i rozumieć zakres zastosowania, wady i zalety danego rozwiązania - Twój komentarz był o tyle dobry, że wymusił na mnie omówienie tematu. Bo to, że ja wiem o co chodzi i Ty wiesz nie oznacza, że inni patrząc na suchy kod znajdą dla niego najlepsze zastosowanie.

 

 

Nie mam takiego nastawienia, nie wiem na podstawie czego to wywnioskowałeś. 

 

PS

Jak edytujesz to zaznacz, że odpowiedź była edytowana.

Różnica jest i to jest fakt.

To czy jest coś ciekawostką to już twoja opinia.

Ma to znaczenie, że jest różnica, takie, że jest szybsze/wolniejsze.

 

PS.

Nie ma obowiązku zaznaczać, że wiadomość była edytowana. Jak ma taki przywilej, aby nie pokazywać, to może z niego korzystać.

TuByłaSygnatura.png

Hans Kloss PL Uczeń

Hans Kloss PL

Opublikowano
Uczeń

Hans Kloss PL

Opublikowano

@1373230489-U611928.pngVereX.

 

@Fireho
Ok, tu się zgodzę - jak spojrzeć na jednostkowy przypadek to nie ma co czarować - inne rozwiązania są minimalnie szybsze.

Nie wiem czego nie zrozumiałeś.

 

Nie zapominaj też o kwestii czytelności kodu - zapis proponowany przeze mnie jest naturalny i zbliżony do matematycznej definicji ciągu. Jestem świadomy tego co robię, nie musisz się o to martwić. Gdybym pisał program, w którym ta różnica (szybkości, wykorzystania pamięci) ma znaczenie to zastosowałbym zwykłą wersję iteracyjną (albo nawet mnożenie macierzy), w innym przypadku stawiam na bardziej zwięzłe i elastyczne rozwiązanie (i jak starałem się wytłumaczyć wcześniej - w niektórych zastosowaniach szybsze).

 

Jeśli chodzi o edytowanie - nikt nie mówi, że jest taki obowiązek, natomiast jak istotnie zmienia się sens wypowiedzi to jest to wskazane.

 

PS

Trochę się tak wcinasz między wódkę a zakąskę nie wnosząc nic nowego.

Chcesz precyzyjnej i zrozumiałej odpowiedzi? - Zadaj precyzyjne i zrozumiałe pytanie. Nie przyjmuję zleceń.
Nie odpowiadam na priv na pytania, które można zadać na forum. Chcesz mojej pomocy - oznacz mnie w poście =>  @"Hans Kloss PL" 

Zarchiwizowany

Ten temat przebywa obecnie w archiwum. Dodawanie nowych odpowiedzi zostało zablokowane.

Tematy
×
×
  • Dodaj nową pozycję...