[Question]
  [
Use any programming language to display numbers between 1 and 99 (including both) in such a way, so that:
* the numbers are separated by single space,
* if a number is divisible by 3, it should be in parentheses,
* if a number is divisible by 4, it should be in square brackets,
* if a number is divisible by both 3 and 4, it should be in both parentheses and square brackets (with square brackets closer to the number).
Your program should display exactly:
```
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)
```
  
[Answer]
# [05AB1E](https://github.com/Adriandmen/05AB1E), 23 bytes
-1 byte thanks to Kevin Cruijssen
```
тGND4Öi…[ÿ]}N3Öi…(ÿ)]ðý
```
[Try it online!](https://tio.run/##yy9OTMpM/f//YpO7n4vJ4WmZjxqWRR/eH1vrZwzhaBzerxl7eMPhvf//AwA "05AB1E – Try It Online")
[Answer]
# [Python 2](https://docs.python.org/2/), ~~68~~ ~~65~~ 60 bytes
```
i=0
exec"i+=1;print'('[i%3:]+`[i][i%4:]or i`+')'[i%3:],;"*99
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWgCu1IjVZKVPb1tC6oCgzr0RdQz06U9XYKlY7ITozFsg0sYrNL1LITNBW14TK6FgraVla/v8PAA "Python 2 – Try It Online")
[Answer]
# [R](https://www.r-project.org/), 61 bytes
```
"+"=c
r=""+""
cat(paste0(r+"(",r+""+"[",1:99,r+""+"]",r+")"))
```
[Try it online!](https://tio.run/##K/r/X0lbyTaZq8hWCchQ4kpOLNEoSCwuSTXQKNJW0lDSAZJAiWglHUMrS0soLxYsrKmkqfn/PwA "R – Try It Online")
[Answer]
# [Jelly](https://github.com/DennisMitchell/jelly), ~~21~~ 20 bytes
```
³Ṗµ3,4ṚƬḍ×“([“])”j)K
```
[Try it online!](https://tio.run/##y0rNyan8///Q5oc7px3aaqxj8nDnrGNrHu7oPTz9UcMcjWggEav5qGFulqb3//8A "Jelly – Try It Online")
### How it works
```
³Ṗµ3,4ṚƬḍ×“([“])”j)K  Main link. No arguments.
³                     Set the return value to 100.
 Ṗ                    Pop; yield [1, ..., 99].
  µ               )   Map the chain in between over [1, ..., 9]; for each integer k:
   3,4                    Set the return value to [3, 4].
      ṚƬ                  Reverse until a loop is reached. Yields [[3, 4], [4, 3]].
        ḍ                 Test k for divisibility by [[3, 4], [4, 3]], yielding a
                          matrix of Booleans.
         ×“([“])”         Repeat the characters of [['(', '['], [']', ')']] as many
                          times as the Booleans indicate.
                 j        Join the resulting pair of strings, separated by k.
                   K  Join the resulting array of strings, separated by spaces.
```
[Answer]
# [D](https://dlang.org/), 110 bytes
```
import std.stdio;void f(){for(int i;i<99;)write(++i%3?"":"(",i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}
```
[Try it online!](https://tio.run/##S/n/PzO3IL@oRKG4JEUPiDPzrcvyM1MU0jQ0q9PyizQy80oUMq0zbSwtrTXLizJLUjW0tTNVje2VlKyUNJR0MlVNwMxoIBPOiQWJQ5RogpiWlvZKCkCOkqZ17X@w6bmJmXkamgrVXJxAe6y5av8DAA "D – Try It Online")
Ported from @HatsuPointerKun's C++ answer.
[Answer]
# [Charcoal](https://github.com/somebody1234/Charcoal), 30 bytes
```
⪫ＥＥＥ⁹⁹Ｉ⊕ι⎇﹪⊕κ⁴ι⪫[]ι⎇﹪⊕κ³ι⪫()ι 
```
[Try it online!](https://tio.run/##S85ILErOT8z5/z@gKDOvRMMrPzNPwzexAI4tLXUUnBOLSzQ885KLUnNT80pSUzQyNTU1dRRCUovyEosqNXzzU0pz8lEUZAOlTYA4U0cBbKJSdKwSkEeELmNkXRqaEF1AMSUFJU1N6////@uW5QAA "Charcoal – Try It Online") Link is to verbose version of code. Explanation:
```
    ⁹⁹                          Literal 99
   Ｅ                            Map over implicit range
        ι                       Current value
       ⊕                        Incrementd
      Ｉ                         Cast to string
  Ｅ                             Map over list of strings
            κ                   Current index
           ⊕                    Incremented
             ⁴                  Literal 4
          ﹪                     Modulo
              ι                 Current value
                []              Literal string `[]`
                  ι             Current value
               ⪫                Join i.e wrap value in `[]`
         ⎇                      Ternary
 Ｅ                              Map over list of strings
                      κ         Current index
                     ⊕          Incremented
                       ³        Literal 3
                    ﹪           Modulo
                        ι       Current value
                          ()    Literal string `()`
                            ι   Current value
                         ⪫      Join i.e wrap value in `()`
                   ⎇            Ternary
                                Literal space
⪫                               Join list
                                Implicitly print
```
[Answer]
# [J](http://jsoftware.com/), ~~54~~ 53 bytes
*1 byte less thanks to @Jonah*
```
(*stdout(3|.0=4 3 1 3 4&|,1=":)#3|.']) ([',":)@>i.100
```
[Try it online!](https://tio.run/##y/r/X0OruCQlv7REw7hGz8DWRMFYwRCITdRqdAxtlaw0lYHC6rGaChrR6jpAroNdpp6hgcH//wA)
[Answer]
## C, C++, ~~136~~ ~~133~~ ~~131~~ ~~129~~ ~~128~~ 124 bytes
-5 bytes thanks to Zacharý and inspired by write() function in D language ( see Zacharý answer )
-2 bytes thanks to mriklojn
-12 bytes for the C version thanks to mriklojn
-4 bytes thanks to ceilingcat
```
#include<cstdio>
void f(){for(int i=0;i++<99;)printf("(%s%d%s%s%s"+!!(i%3),i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}
```
### C Specific Optimization : 115 bytes
```
#include<stdio.h>
i;f(){for(;i++<99;)printf("(%s%d%s%s%s"+!!(i%3),i%4?"":"[",i,i%4?"":"]",i%3?"":")",i%99?" ":"");}
```
[Answer]
# Powershell, 60 bytes
```
"$(1..99|%{($_,"($_)","[$_]","([$_])")[!($_%3)+2*!($_%4)]})"
```
Explanation:
* the array with 4 elements: `$_, "($_)", "[$_]", "([$_])"`
* and the index: `[!($_%3)+2*!($_%4)]`
* repeat for each number
* convert the result to a string
Less golfed Test script:
```
$f = {
$r = 1..99|%{
    ($_, "($_)", "[$_]", "([$_])") [!($_%3)+2*!($_%4)]
}
"$($r)"
}
$expected = '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)'
$result = &$f
$result-eq$expected
$result
```
Output:
```
True
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)
```
[Answer]
# [MathGolf](https://github.com/maxbergmark/mathgolf/blob/master/create_explanation.py), ~~41~~ ~~40~~ ~~34~~ 29 [bytes](https://github.com/maxbergmark/mathgolf/blob/master/code_page.py)
```
♀({îû)(î+╫îa_'(\')ßyΓî34α÷ä§ 
```
NOTE: It has a trailing space
Only my second MathGolf answer..  
-5 bytes thanks to *@JoKing*.
[Try it online.](https://tio.run/##y00syUjPz0n7///RzAaN6sPr1DUOr3s0baK65uH5lYfXJcara8SA2ecmH15nbOJ0eP7h7YeXHFpeqFD4/z8A)
**Explanation:**
```
♀(             # Push 99 (100 decreased by 1)
  {            # Start a loop, which implicitly loops down to (and excluding) 0
   û)(         #  Push string ")("
      î+       #  Append the 1-indexed index
        ╫      #  Rotate the string once towards the right
   îa          #  Push the 1-indexed index of the loop, wrap in a list
   _           #  Duplicate it
    '(        '#  Push string "("
      \        #  Swap the top two items of the stack
       ')     '#  Push string ")"
         ßy    #  Wrap all three into a list, and join them
   Γ           #  Wrap all four into a list
               #  (We now have a list [N, "(N)", "[N]", "([N])"], where N is the index)
   î           #  Push the 1-indexed index of the loop
    34         #  Push 3 and 4 to the stack
      α        #  Wrap all three into a list
       ÷       #  Check for each if the index is divisible by it
               #  (resulting in either [0,0], [0,1], [1,0], or [1,1]
        ä      #  Convert from binary to integer
               #  (resulting in either 0, 1, 2, or 3
         §     #  Push the string at that index from the array
               #  Push a space
               # (After the loop, output the entire stack joined together implicitly)
```
[Answer]
# [Haskell](https://www.haskell.org/), 77 bytes
```
unwords[f"()"3$f"[]"4$show n|n<-[1..99],let f(x:r)m s|mod n m<1=x:s++r|1<3=s]
```
[Try it online!](https://tio.run/##BcFBCoQgFADQfaf4iIuiJpBmU@gNZjdLcRGUNKTf8BsF45zdeW@baV@dK9/Kzx8EBceZ3im@EDiUE68QF9KW1Q0buGXasCenLVyAGeVDi74fR9O5NYGt7yk2Hij7sACCl0LdE7VtzEIOikz5lT8 "Haskell – Try It Online")
I wonder if `show[n]` can be used to shorten things up, so far to [no avail](https://tio.run/##jdDNisIwEADgu08xhoYmxBZLelEan2BvHocsKFqUbdKlqShsffZu/6CuruhpGGbmG2YOG/e1z7L6Z2I2RwsKvk/luiw@LHhQB8HJnvNi51BSwogQMSXYBHfIz2C7VDdpU@SkskmAURguFnqW7Usw1Ck0@Q4smDCc69XK6ckIpp2HvTRrA1qtp1M2/@yHYi5E@o@bKjawsmf5LYs@86utfimjz9u@e3yrBjqJHtSx8p4@9t9suXsBJ9JLCWoSe734cC27LAtuwA2cSSJ1WTohiipKpPrz0paj0ms5@sRjHUcNf@rV1/oX).
[Answer]
## Lua, ~~161~~ 123 bytes
```
b=""for i=1,99 do;c,d=i%3==0,i%4==0;b=b..(c and"("or"")..(d and"["or"")..i..(d and"]"or"")..(c and")"or"").." "end;print(b)
```
[Try it online!](https://tio.run/##PctRCoAgEATQq8hCoCBR1E/IniT6SLdgITSkzr9JkV/DG2aOexXxCLCnrBh7O02KkguWkJsBsbPcjCWcR9@2Oqg1EmhIGcAU0@v5N9dqqZPvYn6Dgi2SOzPHS3sj8gA "Lua – Try It Online")
Ungolfed:
```
b = ""
for i = 1, 99 do
    c = 1 % 3 == 0
    d = 1 % 4 == 0
    a = ""
    if c then
        a = a .. "("
    end
    if d then
        a = a .. "["
    end
    a = a .. i
    if d then
        a = a .. "]"
    end
    if c then
        a = a .. ")"
    end
    b = b .. a .. " "
end
print(b)
```
[Answer]
# [Python 2](https://docs.python.org/2/), ~~105~~ ~~97~~ ~~88~~ ~~86~~ ~~85~~ 84 bytes
```
x=1
while x<100:print((('%s','(%s)')[x%3<1],'[%s]')[x%4<1],'([%s])')[x%12<1]%x,;x+=1
```
[Try it online!](https://tio.run/##K6gsycjPM/r/v8LWkKs8IzMnVaHCxtDAwKqgKDOvRENDQ121WF1HXUO1WFNdM7pC1djGMFZHPVq1OBbMNQFzNUB8iLyhEVBEtULHukLb1vD/fwA "Python 2 – Try It Online")
[Answer]
# [C (gcc)](https://gcc.gnu.org/), 84 bytes
```
main(i){while(99/i++)printf("%s%s%d%s%s ","("+i%3,"["+i%4,i-1,"]"+i%4,")"+i%3);}
```
There's a null byte at the beginning of each "bracket string".
[Try it online!](https://tio.run/##S9ZNT07@/z83MTNPI1OzujwjMydVw9JSP1NbW7OgKDOvJE1DSbUYCFNApIKSjhKDhpJ2pqoxkBENYpjoZOoaAjmxEI4SgyZYWtO69v9/AA "C (gcc) – Try It Online")
[Answer]
# [PowerShell](https://github.com/TryItOnline/TioSetup/wiki/Powershell), ~~67~~ 62 bytes
```
"$(1..99|%{'('*!($x=$_%3)+'['*!($y=$_%4)+$_+']'*!$y+')'*!$x})"
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X0lFw1BPz9KyRrVaXUNdS1FDpcJWJV7VWFNbPRrMrQRxTTS1VeK11WOBIiqV2uqaILqiVlPp/38A "PowerShell – Try It Online")
Basically a [FizzBuzz](https://codegolf.stackexchange.com/a/58624/42963) using string multiplication times Boolean variables (implicitly cast to 1 or 0). Those strings are left on the pipeline and gathered within a script block inside quotes. Since the default `$OutputFieldSeparator` for an array is spaces, this implicitly gives us space-delimited array elements.
[Answer]
## C#, ~~124~~ ~~117~~ 123 bytes
-5 bytes thanks to Kevin Cruijssen
```
x=>{for(int i=0;i++<99;)System.Console.Write((i%3<1?"(":"")+(i%4<1?"[":"")+i+(i%4<1?"]":"")+(i%3<1?")":"")+(i>98?"":" "));}
```
Test with :
```
Action<int> t = x=>{for(int i=0;i++<99;)System.Console.Write((i%3<1?"(":"")+(i%4<1?"[":"")+i+(i%4<1?"]":"")+(i%3<1?")":"")+(i>98?"":" "));}
t.Invoke(0);
Console.ReadKey();
```
[Answer]
# [Red](http://www.red-lang.org), 99 97 bytes
```
repeat n 99[a: b: c: d:""if n% 3 = 0[a:"("c:")"]if n% 4 = 0[b:"["d:"]"]prin rejoin[a b n d c" "]]
```
[Try it online!](https://tio.run/##JYwxCsMwEAS/siwE7C4QNz7wJ9yKKyTdGeRCNiL/V0TczgzT3PruFrQ3vz1@UbGuIQqSIAtMyHKgvvDBhvcQnJiFM/XByx8nYeBolXq3UtH8vEoNEWn8DJmgau8/ "Red – Try It Online")
[Answer]
# [Ruby](https://www.ruby-lang.org), ~~72~~ 66 bytes
```
p [*1..99].map{|x|a=x
a="[#{x}]"if x%4<1
a="(#{a})"if x%3<1
a}*' '
```
Thanks to @jonathan-frech and @conor-obrien for additional trimming.
[Answer]
# PowerShell, 98 82 74 ~~67~~ ~~63~~ 62 bytes
A whopping -31 bytes thanks to @Veskah
-5 bytes thanks to @ASCII-only
```
(1..99|%{(($a=($_,"[$_]")[!($_%4)]),"($a)")[!($_%3)]})-join' '
```
[Try it online!](https://tio.run/##K8gvTy0qzkjNyfn/X8NQT8/Sska1WkNDJdFWQyVeRylaJT5WSTNaEchRNdGM1dRRAkppwkSMNWNrNXWz8jPz/v8HAA "PowerShell – Try It Online")
I'm still not quite sure what I've done here.
[Answer]
# perl -E, 60 bytes
```
$,=$";say map$_%12?$_%3?$_%4?$_:"[$_]":"($_)":"([$_])",1..99
```
Some bytes can be saved if we can use newlines between the numbers: in that
case, we can remove the `$,=$";`, change the `map` into a `for` loop, while moving the `say` into the loop.
[Answer]
# [Perl 6](https://github.com/nxadm/rakudo-pkg), ~~51~~ 48 bytes
```
put {$_%3??$^a!!"($a)"}(++$_%4??$_!!"[$_]")xx 99
```
[Try it online!](https://tio.run/##K0gtyjH7/7@gtEShWiVe1djeXiUuUVFRSUMlUVOpVkNbGyhoAhSMB4pFq8THKmlWVChYWv7/DwA "Perl 6 – Try It Online")
[Answer]
## Batch, 145 bytes
```
@set s=
@for /l %%i in (1,1,99)do @set/an=%%i,b=n%%4,p=n%%3&call:c
@echo%s%
:c
@if %b%==0 set n=[%n%]
@if %p%==0 set n=(%n%)
@set s=%s% %n%
```
The code falls through into the subroutine but the string has already been printed by this point so the code executes harmlessly.
[Answer]
# PHP 103
`for(;$i<1e2;$i++)$a.=$i%12==0?"([$i]) ":($i%3==0?"($i) ":($i%4==0?"[$i] ":"$i "));echo substr($a,5,-1);`
<https://www.ideone.com/SBAuWp>
[Answer]
# [Clean](https://github.com/Ourous/curated-clean-linux), 100 bytes
```
import StdEnv,Text
```
# 
```
join" "[if(n/3*3<n)m("("+m+")")\\n<-[1..99],m<-[if(n/4*4<n)(""<+n)("["<+n<+"]")]]
```
[Try it online!](https://tio.run/##JYyxDoIwFEV3vqJ5Lq0FjIGFpGw6mDiY4AYdGqCmpn01WI3@vBV0OucmJ7e3o8Lo/PCwI3HKYDTu5qdAmjDs8Zmex1eITVBTSFZEk5pcvUEg0BpNcVOsC4HMUaDAHQcGrOtQZO02z6tKpm7WX1euy7mjAIIvaBcKDhKYlEk9/8ZPr6263GN2OMbdG5Uz/X@crAraT@4L "Clean – Try It Online")
[Answer]
# [sfk](http://stahlworks.com/dev/swiss-file-knife.html), 225 bytes
```
for n from 1 to 99 +calc -var #(n)/3+1/3 -dig=0 +calc -var #text*3-#(n) +setvar t +calc -var #(n)/4 -dig=0 +calc -var #text*4-#(n) +xed -var _0_#(t)\[#(n)\]_ _*_#(t)#(n)_ +xed _0*_([part2])_ _?*_[part2]_ +xed "_\n_ _" +endfor
```
[Try it online!](https://tio.run/##dY9BDoIwEEWvMoFNaUMowoYF8SCUTAi0xqitKRPD7WsrbIxx@d@8t5jV3EIwzoMF490DaiAHXQdinu4zlK/JQ85sUTWirhool@ull19H0hvxpkwSiFVTgvSTt3/T9kg3vewYJeaMCjUkrkYE5B@QJu4eSo5seE6eTmNkeOZ4rEPIUNnIMxDaLvG7EN4 "sfk – Try It Online")
[Answer]
# Bash, 61 bytes
*-14 bytes, thanks to Dennis*
```
seq 99|awk '{ORS=" ";x=$1%4?$1:"["$1"]";print$1%3?x:"("x")"}'
```
# explanation
Pretty straightforward:
* `seq` produces 1..99
* we pipe that into `awk` with the output record separator (`ORS`) set to space so the output is a single line.
* the main awk body just adds "[]" when the number is divisible by 4, and then adds, on top of that, "()" when divisible by 3.
[Try it online!](https://tio.run/##S0oszvj/vzi1UMHSsiaxPFtBvdo/KNhWSUHJusJWxVDVxF7F0EopWknFUClWybqgKDOvBChqbF9hpaShVKGkqVSr/v8/AA "Bash – Try It Online")
[Answer]
# [JavaScript (Node.js)](https://nodejs.org), 57 bytes
```
f=(n=99)=>n&&f(n-1)+(s=n%4?n:`[${n}]`,n%3?s:`(${s})`)+' '
```
[Try it online!](https://tio.run/##BcHbCkBAFAXQX/Hgck4uJV5MDR8iNcKItEeOvMi3j7X28RllurbzzuHmxXurCbppWLeIY0vIS05JNKK6gzJ9@OIbTIao6kQZCl/52HCaBImfHMQdS3G4lSwx@x8 "JavaScript (Node.js) – Try It Online")
Changed to community cuz the optimize rely too much on it
[Answer]
# PHP, 65 bytes
```
while($i++<99)echo$i%4?$i%3?$i:"($i)":($i%3?"[$i]":"([$i])")," ";
```
or
```
while($i++<99)echo"("[$i%3],"["[$i%4],$i,"]"[$i%4],")"[$i%3]," ";
```
(requires PHP 5.5 or later)
Run with `-nr` or [try them online](http://sandbox.onlinephpfunctions.com/code/7ea8b8e434dfb5609faba67eefc6b9f680441ae2).
[Answer]
# [Python 2](https://docs.python.org/2/), 78 bytes
```
i=0
exec"i+=1;u=i%3/-2*(i%4/-3-1);print'([%0d])'[u:7-u:1+(i%3<1<=i%4)]%i,;"*99
```
[Try it online!](https://tio.run/##K6gsycjPM/r/P9PWgCu1IjVZKVPb1tC61DZT1Vhf10hLI1PVRF/XWNdQ07qgKDOvRF0jWtUgJVZTPbrUyly31MpQG6jC2MbQBqjBRDNWNVPHWknL0vL/fwA "Python 2 – Try It Online")
I envisioned this cool approach slicing `'([%0d])'` but I can't get the expressions any shorter.
[Answer]
# Java 8, ~~92~~ 91 bytes
*-1 byte thanks to @Dana*
`i->{for(;i++<99;)out.printf((i>1?" ":"")+(i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i),i);}`
[Try it online!](https://tio.run/##LY/NqsIwEIX3eYohUEjotaj3bmr8wQdw5VJcxP4xvW1TkihI6bPXSXAWA9@cmZyTVr/0yozV0Jb/C/ajsR6c1x4LaEnKOj002fXtfNVn5ukVY0WnnYOLxoFNDAAHX9laFxWcYQIaUL0MlkDbgkRAqcJ4ZtS@L58B4bDg6jjVxgqFabrPcyXpIhst3dRC4HFz4sB3nMtUYLLZ7onFLSnvku8w@Y2YlBH@AgSJQP6Q37yo4DY@Hx25fU1jqJ5ii6snk@Z2B20bJ2lxirExfFCspYpp5@UD)
Alternative solution, 82 bytes (with trailing space in the output - not sure if that's allowed):
`i->{for(;i++<99;)out.printf((i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i)+" ",i);}`
Explanation:
`for(;i++<99;)` - a for loop that goes from the value of `i` (reused as input, taken to be 0 in this case) to 99
`out.printf(<part1>+<part2>,i);` - formats the string before immediately printing it to stdout with the value of `i`
where `<part1>` is `(i>1?" ":"")` - prints the space *before* printing the number *unless* that number is 1, in which case it omits the space
and `<part2>` is `(i%12<1?"([%d])":i%3<1?"(%d)":i%4<1?"[%d]":i)` - if `i` is divisible by both 3 and 4, `i` has both square and round brackets around it; else if `i` is divisible by 3, `i` has round brackets; else if `i` is divisible by 4, `i` has square brackets; else, `i` has no brackets.
]