Generierung des Alphabets in JavaScript

21

Ich bin mir ziemlich sicher, dass es keinen besseren Weg gibt, aber ich dachte, es könnte nicht schaden, danach zu fragen.

Ich bin es leid zu tippen a='abcdefghijklmnopqrstuvwxyz'.

Coole Sprachen haben Range('a'..'z')oder ähnliches

Was können wir mit JS anfangen, das so kurz wie möglich ist?

for(i=97,a='';i<123;){a+=String.fromCharCode(i++)}

ist länger als nur das Alphabet - aber garantiert vermassle ich es nicht irgendwo.

Ich hoffe, es gibt eine unangenehme Art, Az in weniger als 50 Zeichen zu erzeugen.

Ich habe rumgespielt i=97;Array(26).map(x=>String.fromChar....i++

Aber es dauerte immer viel länger, bis ich mich anschloss und das Array (26) aufteilte, um nutzbar zu sein


Edit: Ich habe es geschafft

[...Array(26)].reduce(a=>a+String.fromCharCode(i++),'',i=97)

60 Bytes

Charlie Wynn
quelle
11
@muddyfish, LuisMendo: Dies ist beim Thema pro Meta.
Türklinke
1
[...Array(26)].map((q,w)=>String.fromCharCode(w+97))ist 52 Bytes und fügen Sie eine weitere 7 für die.join``
andlrc
Related: stackoverflow.com/questions/3895478/…
Digitales Trauma
@ dev-null a = ''; i = 97; [... Array (26)]. map (b => a + = String.fromCharCode (i ++)) ist 60, kümmert sich aber um den Join in 7 ohne Kommas im Ergebnis?
Charlie Wynn
1
@CharlieWynn[...Array(26)].map((q,w)=>String.fromCharCode(w+97)).join``
andlrc

Antworten:

12

Alternative zu String.fromCharCode

... wenn Sie nur mit Kleinbuchstaben zufrieden sind.

for(i=9,a='';++i<36;)a+=i.toString(36) // 38, cannot be used in an expression
[...Array(26)].map(_=>(++i).toString(36),i=9).join`` // 52 directly returnig the string desired
[...Array(26)].map(_=>a+=(++i).toString(36),a='',i=9) // 53 assign to a variable
(i=9,[for(_ of Array(26))(++i).toString(36)].join``) // 52 ES7 direct return
i=9,a='',[for(_ of Array(26))a+=(++i).toString(36)] // 51 ES7 assign to a variable
edc65
quelle
1
Oh verdammt, das ist schlau. Es beginnt also mit 10, konvertiert auf Basis 36 und druckt es aus? so az!
Charlie Wynn
Sind das a = '' und i = 9 Argumente des Map-Funktionsaufrufs? Checked Array.prototype.map () auf mdn und es sieht nicht so aus, als ob map solche Argumente unterstützt ..
Jay Somedon
@JaySomedon Dies sind Argumente für den Aufruf von Kartenfunktionen. In gewisser Weise interessieren sich JavaScript-Funktionen normalerweise nicht dafür und verwerfen Parameter, die sie nicht erwarten. Ich initialisiere also eine Variable, die ich brauche, und
füge
@ JaySomedon siehe auch diese Antwort und verwandte Kommentare codegolf.stackexchange.com/a/2684/21348
edc65
@ edc65 aha ich verstehe! Das ist ordentlich! Wenn Javascript also in map () Argumente wie i = 9 auswertet, erstellt es tatsächlich eine globale Variable, der ich dann 9 zuordnet?
Jay Somedon
11

Hinweis: Alle diese Techniken weisen der Variablen die alphabetische Zeichenfolge zu a.


Ich bin zu 99% sicher, dass der kürzeste Weg, dies in JavaScript zu erreichen, tatsächlich ist:

a="abcdefghijklmnopqrstuvwxyz" // 30 bytes

Es gibt aber noch einige andere interessante Methoden. Sie können die Zeichenfolgenkomprimierung verwenden:

a=btoa`i·?yø!?9%?z)ª»-ºü1`+'yz' // 31 bytes; each ? represents an unprintable

Sie können die komprimierte Zeichenfolge von abrufen atob`abcdefghijklmnopqrstuvwx`. Das 'yz'muss manuell hinzugefügt werden, da wenn Sie die gesamte Zeichenfolge komprimieren, das Ergebnis jedoch nur 27 Byte beträgt, es sich als ergibt abcdefghijklmnopqrstuvwxyw==.

Ich glaube, der kürzeste Weg, dies programmatisch zu tun, ist auch die von Ihnen vorgeschlagene Methode:

for(i=97,a='';i<123;)a+=String.fromCharCode(i++) // 48 bytes

Sie können dies mit ES6-Funktionen ( Vorlagenzeichenfolgen`` , Spread-Operator... ) tun , wenn Sie Folgendes möchten:

a=[...Array(26)].map(_=>String.fromCharCode(i++),i=97).join`` // 61 bytes
a=[...Array(26)].map((_,i)=>String.fromCharCode(i+97)).join`` // also 61 bytes
a=[...Array(i=26)].map(_=>String.fromCharCode(++i+70)).join`` // again, 61 bytes

Sie können mit einer Variablen besser vorgehen als mit .join``:

[...Array(26)].map(_=>a+=String.fromCharCode(i++),i=97,a='') // all 60 bytes
[...Array(26)].map((_,i)=>a+=String.fromCharCode(i+97),a='')
[...Array(i=26)].map(_=>a+=String.fromCharCode(++i+70),a='')

Oder ES7 mit Array-Verständnis , das ein weiteres Byte kürzer ist:

a=[for(_ of Array(i=26))String.fromCharCode(++i+70)].join`` // 59 bytes

Durch vorheriges Erstellen der Variablen wird ein weiteres Byte gespeichert:

a='',[for(_ of Array(i=26))a+=String.fromCharCode(++i+70)] // 58 bytes

Auch String.fromCharCodeakzeptiert mehrere Argumente und wird automatisch join them. So können wir jede ES6-Version auf 57 Bytes reduzieren:

a=String.fromCharCode(...[...Array(26)].map(_=>i++,i=97)) // all 57 bytes
a=String.fromCharCode(...[...Array(26)].map((_,i)=>i+97))
a=String.fromCharCode(...[...Array(i=26)].map(_=>++i+70))

Und die ES7 bis 55:

a=String.fromCharCode(...[for(_ of Array(i=26))++i+70]) // 55 bytes

Wenn Sie mehr über Golfplätze erfahren möchten, lesen Sie diese Tipps . Es gibt auch eine Erklärung zum Array-Verständnis von ES7 .

EDIT: Wie edc65 herausgestellt hat, werden die meisten davon kürzer mit i.toString(36)anstelle von String.fromCharCode(i):

for(i=9,a='';++i<36;)a+=i.toString(36) // 38 bytes
a=[...Array(26)].map(_=>(++i).toString(36),i=9).join`` // 54 bytes
[...Array(26)].map(_=>a+=(++i).toString(36),i=9,a='') // 53 bytes
i=9,a=[for(_ of Array(26))(++i).toString(36)].join`` // 52 bytes
i=9,a='',[for(_ of Array(26))a+=(++i).toString(36)] // 51 bytes

Ich glaube, dieses ist das kürzeste, das als Funktionsrückgabewert aufgerufen werden kann:

eval("for(i=9,a='';++i<36;)a+=i.toString(36)") // 46 bytes

Es ist drei Bytes kürzer als das manuelle Zurückgeben von einer Funktion:

x=>eval("for(i=9,a='';++i<36;)a+=i.toString(36)") // 49 bytes
x=>{for(i=9,a='';++i<36;)a+=i.toString(36);return a} // 52 bytes

Natürlich x=>"abcdefghijklmnopqrstuvwxyz"schlägt noch alles andere.

ETHproductions
quelle
Ich mag es wirklich, wohin das führt - wünschte nur, ich könnte ES7 in Chrom :(
Charlie Wynn
2
@CharlieWynn Ja, es ist eine Schande, dass nicht alle Browser die neuesten Funktionen unterstützen. Aber Chrome wurde
ja
Die meisten dieser Lösungen können mithilfe von .toString anstelle von String, .fromCharCode, gekürzt werden. Siehe meine Antwort
edc65
1
@CharlieWynn Ich denke, Chrome Beta unterstützt jetzt alle ES7 und ES6, mit Ausnahme von Modulen und Tail Call-Optimierung.
Gcampbell
Hier ist ein 42-Byte-Wert, der als Funktionsrückgabewert aufgerufen werden kann: (f=(i=9)=>++i<36?i.toString(36)+f(i):'')()
Rick Hitchcock,
7

Hier ist ein weiterer Ansatz, ein 51-Byte-ES6-Ausdruck:

String.fromCharCode(...Array(123).keys()).slice(97)

Natürlich 50 Bytes in Großbuchstaben.

Neil
quelle
Für Großbuchstaben: String.fromCharCode (... Array (91) .keys ()). Slice (65)
jpoppe
1

36 Bytes mit einem Trick, über den ich gerade erfahren habe (aus diesem Beitrag: /codegolf//a/176496/64538 ):

for(i=9;++i<36;)name+=i.toString(36)

window.name ist standardmäßig eine leere Zeichenfolge.

Dies ist natürlich noch weniger praktisch als die 38-Byte-Lösung, da ein längerer Variablenname verwendet wird.

12Me21
quelle
1

Verwendung dessen, was im globalen Bereich definiert sein kann oder nicht

39 Bytes für Objekteigenschaften für den Array-Abgleich a-z

a=`${Object.keys(top)}`.match(/[a-z]/g)

48 Bytes für eine unsortierte Set

a=new Set(`${Object.keys(top)}`.match(/[a-z]/g))

55 Bytes für eine sortierte Set

a=new Set(`${Object.keys(top)}`.match(/[a-z]/g).sort())

67 Bytes für eine sortierte Zeichenfolge

a=[...new Set(`${Object.keys(top)}`.match(/[a-z]/g).sort())].join``
guest271314
quelle