b'\n_START_ARTICLE_\nHanojski stolpi\n_START_SECTION_\nIzvor igre\n_START_PARAGRAPH_\nIgro je izumil francoski matematik \xc3\x89douard Lucas leta 1883 in o njej v reviji Science et Nature napisal \xc4\x8dlanek, ki je iz\xc5\xa1el naslednje leto 1884. Obstaja legenda o indijskem templju, ki ima veliko sobo s tremi obrabljenimi drogovi, ki jih obkro\xc5\xbea 64 zlatih plo\xc5\xa1\xc4\x8dic. Brahmani premikajo te plo\xc5\xa1\xc4\x8dice glede na pravila igre. Po legendi bo po zadnjem premiku plo\xc5\xa1\xc4\x8dice konec sveta. Uganka je zaradi tega znana tudi kot brahmanski stolpi. Ni znano ali si je Lucas sam izmislil legendo ali ga je le navdahnila. To nalogo (igro) lahko re\xc5\xa1ujemo na ve\xc4\x8d na\xc4\x8dinov. Najbolj znana re\xc5\xa1itev je rekurzivna in je zato znana tudi kot \xc5\xa1olski primer pri ra\xc4\x8dunalni\xc5\xa1kem programiranju._NEWLINE_\xc4\x8ce bi bila legenda resni\xc4\x8dna in \xc4\x8de bi lahko duhovniki premikali plo\xc5\xa1\xc4\x8dice s hitrostjo 1 na sekundo, bi bil za najmanj\xc5\xa1e mo\xc5\xbeno \xc5\xa1tevilo potez plo\xc5\xa1\xc4\x8dic potreben \xc4\x8das 2\xe2\x81\xb6\xe2\x81\xb4\xe2\x88\x921 sekund, oziroma pribli\xc5\xbeno 584,542 milijard let. Vesolje je trenutno staro okrog 13,7 milijard let._NEWLINE_Obstaja ve\xc4\x8d razli\xc4\x8dic legende. Po nekaterih je tempelj samostan, duhovniki pa so menihi. Tempelj ali samostan se lahko nahaja v razli\xc4\x8dnih delih sveta, med njimi tudi v Hanoju v Vietnamu, in je lahko povezan s katerokoli religijo. V nekaterih razli\xc4\x8dicah so vklju\xc4\x8deni \xc5\xa1e drugi elementi. Na primer dejstvo, da so bili stolpi narejeni na za\xc4\x8detku sveta, ali pa da imajo duhovniki, oziroma menihi za potezo na razpolago le en dan._NEWLINE_Morda je na ime vplival 33,4 m visok stolp v Hanoju, zgrajen leta 1812, na katerem danes visi nacionalna vietnamska zastava.\n_START_SECTION_\nRe\xc5\xa1itev\n_START_PARAGRAPH_\nVe\xc4\x8dina razli\xc4\x8dic v obliki igra\xc4\x8de ima 8 plo\xc5\xa1\xc4\x8dic. Igra se nepoznavalcem zdi nemogo\xc4\x8da, \xc4\x8deprav je re\xc5\xa1ljiva s preprostim algoritmom.\n_START_SECTION_\nJava\n_START_PARAGRAPH_\nRe\xc5\xa1itev hanojskih stolpov rekurzivno v jeziku Java:_NEWLINE_// Hanoi.javapublic class Hanoi {_NEWLINE_   public static void main(String[] args) {_NEWLINE_      int n = 3;_NEWLINE_      hanoi(n,\'A\',\'B\',\'C\');  // prestavljamo z A na C; B je pomozna palica_NEWLINE_   }_NEWLINE__NEWLINE_   private static void hanoi(int n, char a, char b, char c) {_NEWLINE_      if (n==1) {_NEWLINE_         System.out.println("Premakni obroc s palice "+a+" na palico "+c);_NEWLINE_      } else {_NEWLINE_         hanoi(n-1,a,c,b);_NEWLINE_         hanoi(1,a,b,c);_NEWLINE_         hanoi(n-1,b,a,c);_NEWLINE_      }_NEWLINE_   }}\n_START_SECTION_\nRe\xc5\xa1itev s poljubnega za\xc4\x8detnega polo\xc5\xbeaja\n_START_PARAGRAPH_\nV C:_NEWLINE_int conf[HEIGHT]; /* Element conf[d] da trenutni polo\xc5\xbeaj plo\xc5\xa1\xc4\x8dice d. */void move(int d, int t) {_NEWLINE_   /* premik plo\xc5\xa1\xc4\x8dice d na stolp t */_NEWLINE_   conf[d] = t;}void hanoi(int h, int t) {_NEWLINE_   if (h > 0) {_NEWLINE_      int f = conf[h-1];_NEWLINE_      if (f != t) {_NEWLINE_         int r = 3 - f - t ;_NEWLINE_         hanoi(h-1, r);_NEWLINE_         move(h-1, t);_NEWLINE_      }_NEWLINE_      hanoi(h-1, t);_NEWLINE_   }}_NEWLINE_V paskalu:_NEWLINE_procedure Hanoi(n: integer; from, to, by: char);Begin_NEWLINE_    if (n=1) then_NEWLINE_        writeln(\'Move the plate from \', from, \' to \', to)_NEWLINE_    else begin_NEWLINE_        Hanoi(n-1, from, by, to);_NEWLINE_        Hanoi(1, from, to, by);_NEWLINE_        Hanoi(n-1, by, to, from);_NEWLINE_    end;End;\n_START_SECTION_\nJava\n_START_PARAGRAPH_\nRe\xc5\xa1itev hanojskih stolpov iterativno v jeziku Java:_NEWLINE_// Hanoi.javaimport java.util.*;class Zahtevek {_NEWLINE_   public int n;_NEWLINE_   public char a,b,c;_NEWLINE__NEWLINE_   public Zahtevek(int n, char a, char b, char c) {_NEWLINE_      this.n=n;_NEWLINE_      this.a=a;_NEWLINE_      this.b=b;_NEWLINE_      this.c=c;_NEWLINE_   }}public class Hanoi {_NEWLINE_   public static void main(String[] args) {_NEWLINE_      hanoi(3,\'A\',\'B\',\'C\');  // prestavljamo z A na C; B je pomozna palica_NEWLINE_   }_NEWLINE__NEWLINE_   private static void izpisiSklad(Stack s) {_NEWLINE_      Iterator i = s.iterator();_NEWLINE_      System.out.println("SKLAD:");_NEWLINE_      while (i.hasNext()) {_NEWLINE_         Zahtevek z = (Zahtevek) i.next();_NEWLINE_         System.out.printf("%d %s %s %s\\n", z.n, z.a, z.b, z.c);_NEWLINE_      }_NEWLINE_      System.out.println();_NEWLINE_   }_NEWLINE__NEWLINE_   private static void hanoi(int n, char a, char b, char c) {_NEWLINE_      Stack s=new Stack(); _NEWLINE__NEWLINE_      s.push(new Zahtevek(n,a,b,c));_NEWLINE_      while (!s.empty()) {_NEWLINE_         izpisiSklad(s);    _NEWLINE_         Zahtevek z=(Zahtevek)s.pop(); // Eksplicitna pretvorba v zahtevek_NEWLINE_         n=z.n;_NEWLINE_         a=z.a;_NEWLINE_         b=z.b;_NEWLINE_         c=z.c;_NEWLINE_         if (n==1) {_NEWLINE_            System.out.println("Premakni obroc s palice "+a+" na palico "+c);_NEWLINE_         } else  { // Zahtevki v obratnem vrstnem redu obdelovanja_NEWLINE_            s.push(new Zahtevek(n-1,b,a,c));_NEWLINE_            s.push(new Zahtevek(1,a,b,c));_NEWLINE_            s.push(new Zahtevek(n-1,a,c,b));_NEWLINE_         }_NEWLINE_      }_NEWLINE_   }}\n_START_SECTION_\nRe\xc5\xa1itev z Grayjevo kodo\n_START_PARAGRAPH_\nDvoji\xc5\xa1ki sestav Grayjevih kod da drugo re\xc5\xa1itev problema. V Grayjevem sistemu so \xc5\xa1tevila predstavljena dvoji\xc5\xa1ko vendar ne s pozicijskim \xc5\xa1tevilskim sistemom. Grayjeva koda deluje na predpostavki, da se vsaka vrednost razlikuje od predhodne za natan\xc4\x8dno en spremenjen bit. \xc5\xa0tevilo bitov v Grayjevi kodi je pomembno in vode\xc4\x8de ni\xc4\x8dle so obvezne z razliko od pozicijskih sistemov._NEWLINE_\xc4\x8ce \xc5\xa1tejemo v Grayjevi kodi z velikostjo bitov enaki \xc5\xa1tevilu plo\xc5\xa1\xc4\x8dic v dolo\xc4\x8deni igri hanojskih stolpov in za\xc4\x8dnemo z 0, potem se spremenjeni bit v vsaki potezi odgovarja plo\xc5\xa1\xc4\x8dici, ki jo je treba premakniti, kjer najmanj\xc5\xa1i bit predstavlja najmanj\xc5\xa1o plo\xc5\xa1\xc4\x8dico, najve\xc4\x8dji bit pa najve\xc4\x8djo._NEWLINE_Ta postopek dolo\xc4\x8da katero plo\xc5\xa1\xc4\x8dico premikamo, ne pa tudi kam jo premikamo. Za najmanj\xc5\xa1o plo\xc5\xa1\xc4\x8dico sta vedno dve mo\xc5\xbenosti. Za preostale plo\xc5\xa1\xc4\x8dice pa je evdno le ena mo\xc5\xbenost, razen kadar so vse plo\xc5\xa1\xc4\x8dice na istem stolpu, vendar v tem primeru je treba premakniti najmanj\xc5\xa1o plo\xc5\xa1\xc4\x8dico ali pa smo to \xc5\xbee storili. Na sre\xc4\x8do je pravilo, ki pravi kam je treba premakniti najmanj\xc5\xa1o plo\xc5\xa1\xc4\x8dico. Naj je f za\xc4\x8detni stolp, t kon\xc4\x8dni in r preostali tretji pomo\xc5\xbeni. \xc4\x8ce je \xc5\xa1tevilo plo\xc5\xa1\xc4\x8dic liho, najmanj\xc5\xa1a plo\xc5\xa1\xc4\x8dica kro\xc5\xbei po stolpih po vrstenm redu: f\xe2\x86\x92t\xe2\x86\x92r\xe2\x86\x92f\xe2\x86\x92t\xe2\x86\x92r, itd. \xc4\x8ce je \xc5\xa1tevilo plo\xc5\xa1\xc4\x8dic sodo, je vrstni red obrnjen: f\xe2\x86\x92r\xe2\x86\x92t\xe2\x86\x92f\xe2\x86\x92r\xe2\x86\x92t, itd.'