Luo kaikki mahdolliset kirjainyhdistelmät sanassa

 function allAnagrams (word) { if (word.length < 2) { return [word]; } else { var allAnswers = []; for (var i = 0; i < word.length; i++) { var letter = word[i]; var shorterWord = word.substr(0, i) + word.substr(i + 1, word.length - 1); var shortwordArray = allAnagrams(shorterWord); for (var j = 0; j < shortwordArray.length; j++) { allAnswers.push(letter + shortwordArray[j]); } } return allAnswers; } } allAnagrams("") 

Minä aion heittää hattuni renkaaseen permutaatioiden luomisen Heap -menetelmän iteratiivisella versiolla. Minulta kesti jonkin aikaa, kun sain oikean kuvan, koska -lähteelläni on kirjoitusvirhe algoritmissa -_-.

function swap(chars, i, j) { var tmp = chars[i]; chars[i] = chars[j]; chars[j] = tmp; } function getAnagrams(input) { var counter = [], anagrams = [], chars = input.split(""), length = chars.length, i; for (i = 0; i < length; i++) { counter[i] = 0; } anagrams.push(input); i = 0; while (i < length) { if (counter[i] < i) { swap(chars, i % 2 === 1 ? counter[i] : 0, i); counter[i]++; i = 0; anagrams.push(chars.join("")); } else { counter[i] = 0; i++; } } return anagrams; } 

Joitakin näyteajoituksia laskettaessa kooderikatselun anagrammit:

$ time node anagrams-heap-iterative.js 3628800 real 0m0.855s user 0m0.000s sys 0m0.015s $ time node anagrams-megawac.js 3628800 real 0m2.286s user 0m0.000s sys 0m0.000s 

Kommentit

• Tämä on selvästi voittaja, laskemalla 3628800 tulosta kielellä ~5,000ms !
• Hienoa! Matriisikoot tulisi laskea ennakolta, mikä antaa todennäköisesti vielä parempia tuloksia (koska anagrammat ja laskurit ovat massiivisia taulukoita). Luulen, että yritän pitää hajautettua lähestymistapaa tämän voittamiseksi 🙂
• On ’ mielenkiintoista, miten tämä skaalautuu erikokoisilla syötteillä id = ”ceaff87c8c”>

Kun kehitin parempaa ratkaisua, tajusin suuren käyttötarkoituksen uudelle JS Iterators & Generaattorit , joista olen lukenut. Vietin tänään todennäköisesti 6 tuntia tämän ratkaisun kanssa, ja se oli jokaisen minuutin arvoinen. Sinulla on joitain muotoiluvirheitä, mutta keskityn täysin suorituskykyyn ja jätän muotoilun muille arvostelijoille.

---

Tämän suorittaminen isolla sanalla paistaa koneesi

Ok, joten ehkä se menee vähän myös kaukana, mutta vakavasti, tämä on kallis toiminto. I ”ei matematiikkaguru, joten Esitin tämän kysymyksen Math.SE: ssä .

Kaava mahdollisten yhdistelmien määrän laskemiseksi on erittäin jyrkkä:

Ajattele sitä näin:

Kuinka monta valintaa sinulla on ensimmäiselle kirjaimelle? Neljä: 4_ _ _ _.

Toiselle? Kolme: 4⋅3 _ _.

Jatka näin ja löydät yhteensä 4⋅3⋅2⋅1 = 4! = 24 valintaa. – MrRicci

Toiminnon suorittaminen sanaa vastaan ”Tietosanakirja” johtaa tiettyyn sivun kaatumiseen, jos suoritat sen asiakaspuolella. Joten korjataakseni ajattelin jonkin verran.

---

Karhu kanssani – Tämä tulee yhä tärkeämmäksi lukiessasi.

Halusin yrittää luoda todellisia sanoja (hauskaa koodin kanssa)

An anagrammi on eräänlainen sanaleikki, joka johtuu sanan tai lauseen kirjainten järjestämisestä uuden sanan tai lauseen tuottamiseksi käyttämällä kaikkia alkuperäisiä kirjaimia täsmälleen kerran – Wikipeda

Kun ajattelen anagrammaa, ajattelen, että tulos on oikeita sanoja tai lauseita. Vaikka tämän koodin tarkistuksen tarkoitus ei ole muuttaa koodisi toimivuutta, en voinut auttaa, mutta haluan pitää hauskaa sen kanssa. Joten päätin etsiä ratkaisua, jonka avulla voin suodattaa ja tulostaa kaikki todelliset sanan anagrammat tuloksesta.

Kun olen vihdoin jäljittänyt tavallisen em> ~ 130 000 englanninkielistä sanaa käytettäväksi sanaluettelona, minun piti sitten muuntaa tämä luettelo JS: ksi.Joten rakensin toiminnon, joka leikkaa merkkijonon jokaiseen tilaan ja tulosti objektin, jolla on avainominaisuudet, rakenteen, jotta voisin nopeasti testata minkä tahansa sanan oikeellisuuden worldList["word"] -> returns true if word is valid.

130 000 sanan luettelon tulostaminen asiakirjan rungoksi JSON-merkkijonona on funktion tapaan erittäin kallista.

---

… Ja osuvuus:

Joten tässä ongelmasi kohtaa ongelman, jonka keksin itselleni. Kuinka käsittelet erittäin kallis silmukka kaatumatta verkkosivua?

Kokeilemalla mahdollisuuksia, löysin itse asiassa tavan sallia toiminnoni käsittele 130 000 sanaa, ja sinun on ylläpidettävä kaiken kokoista sanaa tasapainottamalla työmäärä ajan myötä.

Silmukat ovat joskus liian nopeita omaksi hyödykseen

Silmukat on tehty mahdollisimman nopeiksi, mikä on täydellinen useimmille tehtävistä, joihin käytämme niitä verkkosivuilla. Mutta jos pyydämme heitä käsittelemään liikaa, selain ei voi käsitellä sitä.

Tarvitsin siis ratkaisun, jonka avulla voin jakaa työmäärän ajan mittaan, jotta sivu voisi käsitellä kalliit silmukat ilman ongelmaa.

Ratkaisuni oli rakentaa manuaalinen silmukka toiminnon kautta, joka kutsui itseään x kertaa, lisäämällä 1-2 ms viive iteraatioiden välillä. Tämä antoi sivulle riittävästi aikaa käsitellä silmukkaa , joka käsitteli sanoja ilman viivettä. mielettömän nopeasti, kunnes C ”s ennen kaatuu joka kerta. Tämä toimi hyvin JSON-sanaluettelorakenteen luomisessa.

Mutta viivästetty silmukka oli erittäin hankala toteuttaa jo rekursiivisessa toiminnossa.

Tajusin silloin, että tämä on täydellinen tilanne hyödyntää äskettäin lukeani ratkaisua JavaScriptille …

---

JavaScripti-iteraattorit ja generaattorit

Joten, tässä tulevat JavaScript-iteraattorit & Generaattorit auttamaan.

Nyt tämä arvostelu on jo riski tulla hirviöksi, joten sen sijaan, että selittäisin Generaattoreita, lainaan tätä pian suosittua vastausta ”s yhden linjan:

TL; DR: Generaattorin [käytön] ydin on koodin suorittamisen keskeyttämisen hallinta.

Ja selitä yksinkertaisesti, että generaattorit ovat entistä parempia tapoja iteroida.

Voit lukea loput itse vastauksesta. Jos tämä vastaus ei tee sitä aivan puolestasi, voit parantaa ymmärrystäsi seuraavilla resursseilla:

• Javascript ”s Tulevaisuus: Generaattorit

• Generaattorit: parempi tapa rakentaa iteraattoreita

• Generaattorit – MDN

• Mikä on tämä asia, jota kutsutaan generaattoreiksi?

Generaattoreilla on nyt suuret mahdollisuudet välttää soittopyyntöä, mutta olemme menossa älä käytä niitä tässä & -rakenteen muotoilemiseen, vaan suorituskykyyn, joka on (suorituskykysuuntaisen mielestäni) tyylikkäin syy niiden käyttöön.

En ole vielä varma, ovatko generaattorit täällä paras ratkaisu, mutta he ovat paras idea, joka minulla on, ja tämä on tekosyy kokeilla niitä.

---

Koodisi generaattoreilla

Työskentely tämä ratkaisu edelleen. Sen pitäisi toimia hienosti, minulla ei ole vielä aikaa lopettaa vielä, ja halusin tarjota parannetun koodin ennemmin kuin myöhemmin. Lähetän tämän ratkaisun pian.

Päivitys: Muutama päivä Myöhemmin en ole vielä saanut generaattoreiden oppimista loppuun siihen pisteeseen, että voin kirjoittaa tämän toiminnon heidän kanssaan oikein. Lähetän sen varmasti tänne heti, kun ymmärrän heidän syntaksinsa hieman paremmin.

---

Ja lopuksi, Koska generaattorit ovat uusia ja niitä ei vielä tueta kaikkialla .. Parannettu versio koodistasi ilman niitä

Huomaa: Muotoilutapani ovat yleensä minun luettavuuteni mieluummin kuin paras käytäntö. Älä tunne olevasi velvollinen muotoilemaan koodiasi tällä tavalla.

/* Improved Real Time Anagram Engine */ // Without generators, it"s difficult to write this function // with the capability of processing a word of any length without // crashing the web browser, so this is written as the original, // with non-controlled execution speed. Long (9+ char) words may // crash browser. function generateAnagrams(word) { if (word.length < 2) { return [word]; } else { // By declaring all variables outside of the loop, // we improve efficiency, avoiding the needless // declarations each time. var anagrams = []; var before, focus, after; var shortWord, subAnagrams, newEntry; for (var i = 0; i < word.length; i++) { before = word.slice(0, i); focus = word[i]; after = word.slice(i + 1, word.length + 1); shortWord = before + after; subAnagrams = generateAnagrams(shortWord); for (var j = 0; j < subAnagrams.length; j++){ newEntry = focus + subAnagrams[j]; anagrams.push(newEntry); } } return anagrams; } } var result = generateAnagrams(word); 

Ilmoittamalla muuttujat silmukoiden ulkopuolelle säästämme merkittävästi, koska näet tulokset. Uskon myös, että word.slice() suoriutui hieman paremmin kuin word.substr(). Kahden optimoinnin, tämän koodin, välillä esiintyy tter kuin alkuperäinen koodisi.

---

Ja viimeisenä mutta ei vähäisimpänä, suorituskyky saavutetaan!

Alkuperäinen koodi : Tulokset päivitetty! Sivu ei kaadu ilman kirjautumista.

• ”koodi”, 4 merkkiä: 24 tulosta , ~ 1ms
• ”kooderi”, 5 merkkiä: 120 tulosta , ~ 1 ms
• ”kooderi”, 6 merkkiä: 720 tulosta , ~ 6ms
• ”coderev”, 7 merkkiä: 5040 tulosta , ~ 11 ms
• ”coderevi”, 8 merkkiä: 40320 tulosta , ~ 75 ms
• ”coderevie”, 9 merkkiä: 362880 tulosta , sivu epäonnistui
• ”codereview”, 10 merkkiä: 3628800 tulosta , sivu epäonnistui

Parannettu koodi : Tulokset päivitetty – sivu ei kaatu ilman kirjautumista.

• ” koodi ”, 4 merkkiä: 24 tulosta , ~ 0.5ms
• ” kooderi ”, 5 merkkiä: 120 tulosta , ~ 0,5 ms
• ”kooderi”, 6 merkkiä: 720 tulosta , ~ 1,5 ms
• ”coderev”, 7 merkkiä: 5040 tulosta , ~ 8 ms
• ” coderevi ”, 8 merkkiä: 40320 tulosta , ~ 53 ms
• ” coderevie ”, 9 merkkiä: 362880 tulosta , ~ 556 ms
• ”codereview”, 10 merkkiä: 3628800 tulosta , ~ 12725ms

Reaaliaikainen generaattoreiden kanssa

(Koodia ei ole valmis – generaattorit ovat osoittautuneet hieman vaikeiksi)

Käytin console.time() mittausten tarkkuuden saavuttamiseksi millisekunnin tarkkuudella, suorittamalla kukin 3-5 testiä ja arvioimalla yleinen keskiarvo r esults. Nämä tulokset vaihtelevat tietysti koneesta toiseen. Aika vertailut ovat avain vertailuarvojen lukemiseen, eivät nopeudet.

---

Tl; Tohtoriyhteenveto, kuten luvattiin

Silmukat ovat erittäin voimakkaita työkalu ohjelmoinnissa, mutta ne eivät käsittele hirviömääriä kalliita iteraatioita verkkoselaimessa. Tällaiset kalliit silmukointitoiminnot toimivat kuitenkin täydellisesti, jos jaat työmäärän ajan myötä. Yksi mielenkiintoinen tapa tehdä tämä on käyttää JS-generaattoreita , uusi lelu, joka on saatavilla verkkokaupoissa tänään, mutta ei välttämättä paikallisilla markkinoilla, joten käytä sitä varovasti, kunnes JS 2.0 on laajemmin toteutettu! Hyödyntämällä JS-generaattoreiden voimaa, voimme hallita pitkään kestäviä kalliita prosesseja näkemättä suorituskykyongelmia.

Kommentit

• keksitkö koskaan generaattoreita?
• @megawac vietin siihen useita tunteja ilman tarpeeksi oppaita / tietoja / opetusohjelmia, jotta voisin todella selvittää, miten se tehdään. I ’ olen käyttänyt rahaa niin paljon aikaa kuin minulla on vapaata joka päivä tämän viestin jälkeen niiden tutkimiseen, mutta … en oppia ’ ei opi nopeasti raaka-aineistosta. Tiedätkö hyviä resursseja generaattoreista ja iteraattoreista?
• Kuulostaa hyvältä pinoverflow-säikeeltä @ jt0dd
• Kirjoitin ratkaisijan paikallislehteen ’ s sekoituspalapeli. Minulla oli luettelo 600 000 romutettavasta sanasta, jotka käsittelin valmiiksi lajittelemaan kirjaimet jokaisessa sanassa. Sitten tein saman hakukirjeille ja yritin löytää sanoja. Se pystyi skannaamaan kaikki 4–10 kirjaimen sanat, jotka annettiin 10 kirjainta millisekunteina. Kirjaimet ’ throb ’ syötettyinä missä tahansa järjestyksessä tulokseksi ’ bhort ’ joka linkittää suoraan ’ sykkeeseen ’ ja ’ liemi ’, ei tarvitse kokeilla kaikkia yhdistelmiä. Esimerkiksi jos etsit 4-kirjainta sanaa, jolla on 5 kirjainta, kirjaimia lajiteltaessa on vain 4 yhdistelmää, 120 jos ei.
• @ jt0dd I ’ m sekava sanan.pituus + 1 käytöstä viipaletta käytettäessä. Voitteko selittää?

Katsoin @ jt0dd -koodia ja mietin miten voisi käsitellä joitain muita tapauksia. Minä ”kerron teille, sallin lisätä välimuistikerroksen ja laskea tuloksena olevien matriisien pituudet!

var generateAnagrams = (function() { // precomputed first 20 factorials var fact20 = [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800, 479001600, 6227020800, 87178291200, 1307674368000, 20922789888000, 355687428096000, 6402373705728000, 121645100408832000, 2432902008176640000]; // Substrings seen already which we can cache. Try and avoid stack overflow as much as possible var seenStrings = {}; function generateAnagrams(word) { var length = word.length; if (length < 2) { seenStrings[word] = word; return [word]; } var anagrams = Array(fact20[length - 1]); // Stuff we"ll need along the way var before, focus, after; var shortWord, subAnagrams, newEntry; var idx = 0, j, jlen; for (var i = 0; i < length; i++) { before = word.slice(0, i); focus = word[i]; after = word.slice(i + 1, word.length + 1); shortWord = before + after; subAnagrams = seenStrings[shortWord] || generateAnagrams(shortWord); for (j = 0, jlen = subAnagrams.length; j < jlen; j++) { newEntry = focus + subAnagrams[j]; anagrams[idx++] = newEntry; } } seenStrings[word] = anagrams; return anagrams; } return function anagrams(word) { var computed = generateAnagrams(word); // clear cache (going to consume a ton of memory) seenStrings = {}; return computed; }; })(); 

Mies että” s ruma! Toivon, ettei koko tuo aika ollut turhaa …

Esilasketut hashit

• ”code”, 4 merkit: 24 tulosta , < = 1ms
• ”kooderi”, 5 merkkiä: 120 tulosta , < = 1ms
• ”kooderi”, 6 merkkiä: 720 tulosta , < = 1ms
• ”coderev”, 7 merkkiä: 5040 tulosta , < = 3ms
• ” coderevi ”, 8 merkkiä: 40,320 tulosta , < = 18ms
• ”coderevie”, 9 merkkiä: 362880 tulosta , 135 ms
• ”codereview”, 10 merkkiä: 3628800 tulosta , 2,1 s

Hups, me vastasimme haasteeseen. Katsotaanpa ”s kuinka paljon pidemmälle voimme mennä. codereview on vain vaikea sana, joka on kaksoiskappale e. Kokeile seuraavaksi jotain helpompaa Mene. Yritetään kokeilla "anagramarmy"

… … … …

Okei, purin enemmän kuin selaimesi voi pureskella näyttää siltä, että 40 miljoonaa merkkijonopermutaatiota näyttää ylittävän rajan 🙁

Huomaa, että suunnittelin algoritmin uudelleen, jotta vältettäisiin pinon ylivuoto – etsinnät tulisi tehdä rekursioiden ulkopuolella.

Voimme lisätä algoritmin kaatumisen mahdollisuutta tekemällä siitä asynkronisen ja tekemällä kaikki sanat 100,000 joka sekunti millisekunnin välein pysähtymisen välttämiseksi.

Kommentit

• Mahtava! Tämä on paljon parempi kuin generaattoriversio I ’ m, joka toimii. +1 ( Tämä vastaus on hyväksyttävä, se ’ tulee olemaan paljon tehokkaampi kuin generaattoriratkaisuni.)
• Loistava … Vain loistava. Minä todella kuten tämä. Kun olen valmis reaaliaikaisen harmonian generaattoriratkaisun (tai saatat toteuttaa oman), voit ottaa sen ja tehdä saman sen kanssa. Se ’ on hitaampi, mutta palautus johtaa reaaliajassa eikä sillä ole loppua sille, kuinka suuren sanan se pystyy käsittelemään.
• ahh, mjolka voitti meidät molemmat far .
• Hei, miten voin suorittaa tämän koodin verkkotunnukseni html- ja css-sivuilla?

Tein kaksi komentosarjaa:

1. Ensimmäinen on nopea, mutta siihen ei voi mahtua paljon;
2. Toinen on hidas, mutta voi näyttää rajattomasti tuloksia.

Molemmat käyttävät tekemääni prototyyppiä: fastPush, fastSplit ja fastJoin; jotka ovat nopeampi kuin tavanomainen menetelmä jakaa ja liittyä. Molemmat käyttävät myös käytä bittiä tarkistaaksesi, onko pariton vai parillinen, koska tiedän, että mod on hitain mahdollinen toiminta tietokoneella.

Ensimmäinen komentosarja voittaa muiden nopeimman tuloksen yli 750 ms: lla (keskiarvolla) 10-merkkisellä permutaation haasteella .

Array.prototype.swap = function(i, j) { var el1 = this[i], el2 = this[j]; this[i] = el2; this[j] = el1; return this; }; Array.prototype.fastPush = function(element) { this[this.length] = element; }; String.prototype.fastSplit = function() { var array = []; for(var i = 0; i < this.length; i++) array.fastPush(this[i]); return array; }; Array.prototype.fastJoin = function() { var string = ""; for(var i = 0; i < this.length; i++) string += this[i]; return string; }; String.prototype.anagrams = function() { var i = 1, N = this.length, p = [], anagrams = [], k, word = this.fastSplit(); anagrams.fastPush(this.toString()); for(var j = 0; j < N; j++) p.fastPush(0); while(i < N) { if(p[i] < i) { k = 0; k = (i & 1 != 0) & p[i]; anagrams.fastPush(word.swap(k, i).fastJoin()); p[i]++; i = 1; } else { p[i] = 0; i++ } } return anagrams; }; console.log("asdasdfghj".anagrams()); 

Joka tapauksessa tällä ensimmäisellä ohjelmalla on raja ja se rikkoo sivun, jos yrität yli 10 merkkiä.

Toinen ohjelma ( yksi alla) käyttää itseään kutsuvaa toimintoa ja kirjautuu sisään 4e4-elementtien konsolipaloihin, se tyhjentää anagrammiryhmän joka kerta, kun se tuottaa palan, ja tyhjentää myös nsole.log jokainen 5 palaa (riittää, jotta näet nämä yhdistelmät). Käynnistääkseen toiminnon itse, ohjelma käyttää setZeroTimeoutia ( David Baronin blogi ) setTimeoutin sijaan, koska setTimeout on hitaampi.

(function() { var timeouts = []; var messageName = "zero-timeout-message"; // Like setTimeout, but only takes a function argument. There"s // no time argument (always zero) and no arguments (you have to // use a closure). function setZeroTimeout(fn) { timeouts.fastPush(fn); window.postMessage(messageName, "*"); } function handleMessage(event) { if (event.source == window && event.data == messageName) { event.stopPropagation(); if (timeouts.length > 0) { var fn = timeouts.shift(); fn(); } } } window.addEventListener("message", handleMessage, true); // Add the one thing we want added to the window object. window.setZeroTimeout = setZeroTimeout; })(); Array.prototype.swap = function(i, j) { var el1 = this[i], el2 = this[j]; this[i] = el2; this[j] = el1; return this; }; Array.prototype.fastPush = function(element) { this[this.length] = element; }; String.prototype.fastSplit = function() { var array = []; for(var i = 0; i < this.length; i++) array.fastPush(this[i]); return array; }; Array.prototype.fastJoin = function() { var string = ""; for(var i = 0; i < this.length; i++) string += this[i]; return string; }; var i = 1, p = [], N, k, chars, anagrams = [], r = 0; function anagramsGen(word) { N = word.length; chars = word.fastSplit(); anagrams.fastPush(word); for(var j = 0; j < N; j++) p.fastPush(0); noLimitWhile(); } function noLimitWhile() { if(i < N) { if(p[i] < i) { k = 0; k = (i & 1 != 0) & p[i]; anagrams.fastPush(chars.swap(k, i).fastJoin()); if(anagrams.length === 4e4) { if(r === 5) { console.clear(); r = 0; } r++; console.log(anagrams); anagrams = []; } p[i]++; i = 1; } else { p[i] = 0; i++ } setZeroTimeout(noLimitWhile); } else { console.log(anagrams); console.log("Finished"); } } anagramsGen("qwertyuiopas"); 

Vielä yksi muunnos (kirjoitettu i C) käyttämällä yksinkertaista laskuria Kaikkien merkkijonojen virhesarja .

#include <string.h> #include <stdio.h> int main(int argc, char* argv[]) { if (argc < 2) return (1); char* arg = argv[1]; int n = 1 << strlen(arg); for (int i = 1; i < n; i++) { for (int j = 1, l = 0; j <= i; j <<= 1, l++) { if (i & j) printf("%c", arg[l]); } printf("\n"); } return (0); } 

Suorita tulostamalla kaikki merkkijonot:

$ time anagrams codereview > log real 0m0.002s user 0m0.000s sys 0m0.000s 

kommentit

• mitä tarkoitat ” kaikkien merkkijonojen ”? Funktiosi tuottaa vain osan sanasta, esim. jos run` anagrams abc` tuottaa a,b,ab,c,ac,bc,abc

Kirjoitetut taulukot parempaan suorituskykyyn.

Hyväksyttyjen vastausten menetelmällä voit kolminkertaistaa suorituskyvyn.

Voittavan vastauksen suorittaminen koneellani antoi vertailuarvot

Mean : 5,564,999µs ±182,246µs 11 samples 

Ja kun käytät t yped-taulukot

Mean : 1,514,112µs ±72,000µs (*) 13 samples 

3,68: n suorituskyvyn kasvulle.

var knownPermutations = [0,0,0,24,120,720,5040,40320,362880,3628800]; function anagramer(input) { var counter, chars,length,i,index,tc,n,arraySize,anagrams; index = 0; length = input.length; arraySize = knownPermutations[length-1] * length; anagrams = new Uint8Array(arraySize); chars = new Uint8Array(length); counter = new Uint8Array(length); for( i = 0; i < length; i ++){ chars[i] = input.charCodeAt(i); } anagrams.set(chars) index += length; i = 0; while (i < length) { if (counter[i] < i) { tc = chars[i]; chars[i] = chars[n= (i%2?counter[i]:0)]; chars[n] = tc; counter[i]++; i = 0; anagrams.set(chars,index) index += length; } else { counter[i] = 0; i++; } } return anagrams; } 

Reunaa hieman enemmän voit määrittää tulostaulukon etukäteen saadaksesi

 Mean : 1,408,974µs ±25,173µs (*) 24 samples 

Voit parantaa sitä jopa 3,95 kertaa niin nopeasti kuin voittanut vastaus.