Coder en JavaScript avec seulement six caractères

+!![]

+!+[]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
object		6	[[[]]] 
object		4	[[]] 
object		2	[] 
undefined	undefined	6	[][[]] 
string		5	[]+[] 
string	false	6	[]+![] 
object	0	5	[+[]] 
object	false	5	[![]] 
object	true	6	[!+[]] 
object	true	6	[!![]] 
number	0	5	+[[]] 
number	0	3	+[] 
string	0	6	+[]+[] 
number	NaN	6	+[![]] 
number	1	5	+!+[] 
number	1	5	+!![] 
boolean	false	5	![[]] 
boolean	false	3	![] 
string	false	6	![]+[] 
boolean	true	6	!+[[]] 
boolean	true	4	!+[] 
boolean	true	4	!![]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
var CHARS = ['[', ']', '+', '!', '(', ')'];  /* changer ce tableau pour utiliser d'autres caractères */ 
 
 
 
var NB_CHARS = CHARS.length; 
 
var BALANCED_CHARS = {}; 
var CLOSE_CHARS = []; 
if ( CHARS.indexOf('[') >= 0 ) { 
    BALANCED_CHARS['['] = ']'; 
    CLOSE_CHARS.push(']'); 
} 
if ( CHARS.indexOf('(') >= 0 ) { 
    BALANCED_CHARS['('] = ')'; 
    CLOSE_CHARS.push(')'); 
} 
if ( CHARS.indexOf('{') >= 0 ) { 
    BALANCED_CHARS['{'] = '}'; 
    CLOSE_CHARS.push('}'); 
} 
 
var results = {}; 
 
 
 
/* 
  Renvoie true 
  si s est bien parenthésée, 
  false sinon. 
*/ 
function balanced(s) { 
    'use strict'; 
 
    var s_LENGTH = s.length; 
 
    var stack = []; 
 
    var i; 
    var c; 
 
    for (i = 0; i < s_LENGTH; i++) { 
        c = s[i]; 
        if ( c in BALANCED_CHARS ) { 
            stack.push(c); 
        } 
        else if ( CLOSE_CHARS.indexOf(c) >= 0 ) { 
            if ( BALANCED_CHARS[stack.pop()] !== c ) { 
                return false; 
            } 
        } 
    } 
 
    return (stack.length === 0); 
} 
 
 
/* 
  Parcourt récursivement les chaînes jusqu'à une longueur num, 
  tente de les évaluer 
  et affiche les résultats non encore rencontrés ou déjà rencontrés mais au moins aussi long. 
 */ 
function build_and_try_string(s, num) { 
    'use strict'; 
 
    if ( num > 0 ) { 
        var i; 
        var c; 
 
        for (i = 0; i < NB_CHARS; i++) { 
            c = CHARS[i]; 
 
            try_string(s + c); 
            build_and_try_string(s + c, num - 1); 
        } 
    } 
} 
 
 
/* 
  Affiche s 
*/ 
function display(s) { 
    try {            // dans un navigateur 
        document.write(s + '\n'); 
    } 
    catch ( err ) {  // avec Rhino 
        print(s); 
    } 
} 
 
 
/* 
  Tente d'évaluer s. 
  Si l'évaluation s'est bien passée 
  et que le résultat n'a pas encore été obtenu ou a déjà été obtenu avec une chaîne au moins aussi longue, 
  alors affiche le résultat. 
 
  BORD: ajoute l'éventuel élément affiché à results 
*/ 
function try_string(s) { 
    'use strict'; 
 
    if ( balanced(s) ) { 
        var v; 
 
        try { 
            v = eval(s); 
        } 
        catch ( err ) { 
            return; 
        } 
 
        var k = [typeof v, v]; 
 
        if ( !(k in results) || (s.length <= results[k]) ) { 
            results[k] = s.length; 
            display((typeof v) + '\t' + v + '\t' + s.length + '\t' + s); 
        } 
    } 
} 
 
 
 
/* Main */ 
build_and_try_string('', 6);