53
\$\begingroup\$

Today, we're going to make an ASCII hexagon. You must write a program or function that takes a positive integer n, and outputs a hexagon grid of size n, made up of asterisks. For example, a hexagon of size 2 looks like this:

 * *
* * *
 * *

While a hexagon of size 3 looks like this:

  * * *
 * * * *
* * * * *
 * * * *
  * * *

You may use any of the default input and output methods, for example STDIO/STDOUT, function arguments and return values or reading/writing a file.

You may assume that input is always valid, so if it's not a positive integer, your program may do whatever you want. You do however have to handle the special case of a size 1 hexagon, which happens to be a single asterisk:

*

Leading and trailing whitespace is allowed as long as the output is visually the same.

Examples:

1:
*

2:
 * *
* * *
 * *

3:
  * * *
 * * * *
* * * * *
 * * * *
  * * *

4:
   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *

5:
    * * * * *
   * * * * * *
  * * * * * * *
 * * * * * * * *
* * * * * * * * *
 * * * * * * * *
  * * * * * * *
   * * * * * *
    * * * * *

6:
     * * * * * *
    * * * * * * *
   * * * * * * * *
  * * * * * * * * *
 * * * * * * * * * *
* * * * * * * * * * *
 * * * * * * * * * *
  * * * * * * * * *
   * * * * * * * *
    * * * * * * *
     * * * * * *

12:
           * * * * * * * * * * * *
          * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
* * * * * * * * * * * * * * * * * * * * * * *
 * * * * * * * * * * * * * * * * * * * * * *
  * * * * * * * * * * * * * * * * * * * * *
   * * * * * * * * * * * * * * * * * * * *
    * * * * * * * * * * * * * * * * * * *
     * * * * * * * * * * * * * * * * * *
      * * * * * * * * * * * * * * * * *
       * * * * * * * * * * * * * * * *
        * * * * * * * * * * * * * * *
         * * * * * * * * * * * * * *
          * * * * * * * * * * * * *
           * * * * * * * * * * * *

As usual, this is , so standard loopholes apply, and you should try to write the shortest possible program measured in bytes. Of course, some languages are inherently shorter or longer than others, so remember that the goal is not necessarily to have the shortest overall byte count, but to beat submissions in the same or similar languages.

May the best golfer win!

\$\endgroup\$
  • 15
    \$\begingroup\$ Why do we even have a hexagonal-grid tag? \$\endgroup\$ – Pavel Dec 26 '16 at 7:25
  • 13
    \$\begingroup\$ Also, someone needs to write a hexagony solution. \$\endgroup\$ – Pavel Dec 26 '16 at 7:40
  • \$\begingroup\$ If anyone wants to go for the bounty, you can probably reuse the output loop of my Hexagony answer over here. \$\endgroup\$ – Martin Ender Jan 19 '17 at 9:01
  • 6
    \$\begingroup\$ "Could you make me a hexagon please?" - sure, here you go: i.imgur.com/1emYIia.png \$\endgroup\$ – aditsu Jan 28 '17 at 18:45
  • \$\begingroup\$ @Pavel because a lot of operations on a hexagonal grid are distinct from on the more standard square grid, and portable between solutions to different problems. Such operations as coordinate manipulation, rotation, output layout, etc. \$\endgroup\$ – Sparr Jun 28 '18 at 5:25

58 Answers 58

1
\$\begingroup\$

tcl, 123

Based in Python 2 ...

gets stdin i;set n $i;while {$n+[incr i -1]} {puts [string repe " " [expr abs($i)]][string repe "* " [expr 2*$n+~abs($i)]]}
\$\endgroup\$
1
\$\begingroup\$

Python 3, 111 Bytes

d=int(input());i=' *';y=''
for x in range(d-1):y+=(' '*(d-x-1)+i*(d+x)+' '*(d-x)+'\n')
print(y+i*(2*d-1)+y[::-1])

Builds the top section, copies the reverse for the bottom and slots a line in the middle. Best approach I could think of.

\$\endgroup\$
  • \$\begingroup\$ This could be shortened by changing to Python2. \$\endgroup\$ – Yytsi Jan 24 '17 at 6:14
  • \$\begingroup\$ @TuukkaX unfortunately I don't know Python2 well enough to change it. You are welcome to suggest a solution \$\endgroup\$ – george Jan 26 '17 at 13:26
1
\$\begingroup\$

PHP, 91 bytes

for($r=str_repeat;$j<$h=($n=$argv[1])*2-1;)echo$r(' ',$a=abs(++$j-$n)).$r('* ',$h-$a)."\n";

Run it in the command line like this:

php -d error_reporting=0 -r "for($r=str_repeat;$j<$h=($n=$argv[1])*2-1;)echo$r(' ',$a=abs(++$j-$n)).$r('* ',$h-$a).\"\n\";" "5"

Ungolfed:

<?php
// Store reference to str_repeat function for repeated uses
$r = str_repeat;

// Loop through each line until n*2+1 (the height of the hexagon)
for(;$j < $h = ($n = $argv[1]) * 2 - 1;) {

    // Add spacing to the beginning of each line. 
    echo $r(' ', $a = abs(++$j - $n));

    // Add asterisks for each line 
    echo $r('* ', $h - $a);

    // Add newline to the end of the line
    echo "\n";
}
\$\endgroup\$
1
\$\begingroup\$

QBIC, 82 76 bytes

Because you said please.

:~a=1|?A\[a-1|H=space$(a-b)┘G=A[a+b-2|G=G+@* `┘]Z=H+_tG|+H+@┘`+Z]?_fZ|+B+G+A

This can definitelyprobably be golfed further.

\$\endgroup\$
1
\$\begingroup\$

PostgreSQL, 86

I was gonna write a CJam answer, but I saw somebody did Postgres and I had to compete :)

\prompt n
select lpad('',@i)||repeat('* ',2*:n-1- @i)from generate_series(1-:n,:n-1)i;

Run it like this: psql -Atf hex.sql dbname username and type in the number (or append e.g. <<<3 to the command).

\$\endgroup\$
1
\$\begingroup\$

Pyth - 60 57 50 bytes

p*tQd*Q"* "VtQp*-Q+2Nd*h+QN"* ";VtQp*hNd*-*tQ2N"* 

Try it online!

p                    print the next item (without trailing newline)
*tQd                multiply (input-1) by " "
*Q"*"                (implicit print) input times "* "
VtQ                 for all numbers 0 through (input-1) (as represented by N)
p                    print the next item (without trailing newline)
*-Q+2Nd              input-(N+2)  times " " (as represented by d)
*h+QN"*"            (implicit print) input+N+1  times "* "
;                    end for statement
V-Q1                 for all numbers 0 through input-1 (as represented by N)
p                    print the next item (without trailing newline)
*hNd                N+1 times " "
*-*tQ2N"*          (2*(input-1))-N   times "* " (implicit end string with EOF)
(implicit end of for loop with EOF)
(EOF == End of file)
\$\endgroup\$
  • 1
    \$\begingroup\$ I would be interested to see an explanation of how this works. \$\endgroup\$ – Sriotchilism O'Zaic Jan 29 '17 at 6:27
  • \$\begingroup\$ will do @WheatWizard! \$\endgroup\$ – Nick the coder Jan 29 '17 at 6:30
1
\$\begingroup\$

Groovy, 64 63 62 58 56 bytes

{n->(1-n..n-1)*.abs().any{println' '*it+'* '*(2*n+~it)}}

Example call:

{n->(1-n..n-1)*.abs().any{println' '*it+'* '*(2*n+~it)}}(4)

produces:

   * * * *
  * * * * *
 * * * * * *
* * * * * * *
 * * * * * *
  * * * * *
   * * * *
\$\endgroup\$
1
\$\begingroup\$

Retina, 81 bytes

Assumes ISO 8859-1 encoding. All whitespace is significant.

\d+
$* $&$*a
^ 

.*
$0¶$0
m+`^(( *) (a+))¶\1
$1¶$2a$3¶$2a$3¶$1
m`^(a+)¶\1
$1
a
* 

Try it online!

Explanation

The code consists of 6 regex replacements on the input.

\d+
$* $&$*a

This replaces the input (we'll call it n) with n spaces and n as. I use a during most of program and replace it with * in the end because * is a reserved regex character and would need to be escaped if used directly.

^ 
​

(Note the space after ^) This removes the first space in the text. The result is a line consisting of n-1 spaces followed by n as.

.*
$0¶$0

The line is duplicated.

m+`^(( *) (a+))¶\1
$1¶$2a$3¶$2a$3¶$1

The most complicated stage in the program. It will replace any line that consists of a non-zero number of spaces followed by some number of as that also has an exact copy of itself following on the next line. It will be replaced with itself, a line consisting of 1 less space and 1 more a, that same line again, followed by the original line. More simply, it takes any two identical, directly adjacent lines and inserts two copies of a line with 1 less space and 1 more a in between them. This replacement will be made continually until the text stops changing, which happens when two lines consisting of only as have been inserted.

m`^(a+)¶\1
$1

This removes the duplicate of the line consisting of all as (since this line is the middle of the hexagon).

a
* 

Finally, replace all instances of a with * ​.

\$\endgroup\$
1
\$\begingroup\$

R, 72 bytes

function(n,a=n-1)for(i in abs(a:-a))cat(rep(c('','*'),c(i,2*n-1-i)),'
')

Try it online!

\$\endgroup\$
1
\$\begingroup\$

QBasic, 76 bytes

INPUT n
FOR i=-n+1TO n-1
s=ABS(i)
?SPC(s)
FOR j=2TO 2*n-s
?"* ";
NEXT
?
NEXT

(This requires real QBasic, in which ?SPC(s) is expanded to PRINT SPC(s);, unlike QB64, in which it becomes PRINT SPC(s).)

Similar approach to my Sisi answer, except QBasic has ABS and so it's more efficient to run a FOR loop from -n+1 to n-1.

\$\endgroup\$
1
\$\begingroup\$

Kotlin, 113 89 bytes

24 bytes saved thanks to mazzy

{n:Int->for(o in 1-n..n-1){val c=Math.abs(o)
println("".padEnd(c)+"* ".repeat(2*n-c-1))}}

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ 87 bytes: n:Int->for(m in 1-n..n-1){val c=Math.abs(m);println("".padEnd(c)+"* ".repeat(2*n-c-1))} \$\endgroup\$ – mazzy Jun 28 '18 at 21:40
1
\$\begingroup\$

Sisi, 233 bytes

0set n3
1set i1
2set d1
3set o""
4set j n-i
5jumpif j7
6jump10
7set o o+" "
8set j j-1
9jump5
10jumpif o12
11set d0-1
12set j n+i
13set j j-1
14jumpif j16
15jump19
16set o o+"* "
17set j j-1
18jump14
19print o
20set i i+d
21jumpif i3

Try it online!

Note: because Sisi has no way of taking input, this meta consensus allows for input to be inserted into the source code. For this program, the value of n should be inserted directly after n on line 1. In the code above, the value n = 3 is used.

Pseudocode

Because of Sisi's limitations, we have to generate and print one line at a time in order. So we run a loop in which i will go from 1 up to n and back down to 1:

i = 1
d = 1
while i > 0
  construct string of (n-i) spaces
  append to that (n+i-1) copies of "* "
  print it
  if i = n
    d = -1
  end
  i = i + d
repeat

Ungolfed version

10 set n 3
20 set i 1
30 set d 1

100 set o ""
110 set j n-i
120 jumpif j 140
130 jump 200
140 set o o+" "
150 set j j-1
160 jump 120

200 jumpif o 300
210 set d 0-1

300 set j n+i
310 set j j-1
320 jumpif j 340
330 jump 400
340 set o o+"* "
350 set j j-1
360 jump 320

400 print o
410 set i i+d
420 jumpif i 100
\$\endgroup\$
1
\$\begingroup\$

K (oK), 44 38 34 bytes

Solution:

{(-a+3*x)$(2*x+a,:1_|a:!x)#\:"* "}

Try it online!

Example:

{(-a+3*x)$(2*x+a,:1_|a:!x)#\:"* "}4
("    * * * * "
"   * * * * * "
"  * * * * * * "
" * * * * * * * "
"  * * * * * * "
"   * * * * * "
"    * * * * ")

Explanation:

Create lists of * of the desired length and then left-pads them the required amount.

{(-a+3*x)$(2*x+a,:1_|a:!x)#\:"* "} / the solution
{                                } / lambda taking implicit argument x, e.g. 4
                             "* "  / the string "* "
                          #\:      / take (#), each-left (\:)
          (              )         / do this together
                       !x          / til x, range 0..x, e.g. 0 1 2 3
                     a:            / assign to variable a
                    |              / reverse it, e.g. 3 2 1 0
                  1_               / drop the first, e.g. 2 1 0
               a,:                 / append that to a, e.g. 0 1 2 3 2 1 0
             x+                    / add x, e.g. 4 5 6 7 6 5 4
           2*                      / multiply by 2, e.g. 8 10 12 14 12 10 8
         $                         / pad (negative means left-pad)
 (      )                          / do this together
     3*x                           / x multiply by 3, e.g 12
   a+                              / add a, e.g. 12 13 14 15 14 13 12
  -                                / negate, e.g. -12 -13 -14 -15 -14 -13 -12

Extra:

There is a leading space, this can be removed at the cost of 1 extra byte:

{(1-a+3*x)$(2*x+a,:1_|a:!x)#\:"* "}

Edits:

  • -1 byte thanks to ngn (reuse a rather than defining b)
  • -3 bytes by returning list of strings rather than printing to STDOUT
\$\endgroup\$
  • 1
    \$\begingroup\$ you can modify a instead of introducing a second variable b: b:a, -> a,: and -b+3*x -> -a+3*x \$\endgroup\$ – ngn Jun 30 '18 at 8:51
  • 1
    \$\begingroup\$ `0: - I believe it should be okay to return a list of strings instead of printing it to stdout \$\endgroup\$ – ngn Jun 30 '18 at 8:53
1
\$\begingroup\$

ABAP, 172 bytes

FORM h USING s.DO s * 2 - 1 TIMES.WRITE /''.DATA(y) = sy-index.DO s * 2 - 1 TIMES.IF sy-index > s - y AND sy-index > y - s.WRITE'*'.ELSE.WRITE ``.ENDIF.ENDDO.ENDDO.ENDFORM.

For ABAP I am pretty impressed by how short it turned out to be. I suppose having written the C# answer beforehand was helpful, but merely from an "understanding what to do" perspective, since the languages are so vastly different. There might be potential to save some bytes by using a single do-loop instead, but that would require a few calculations which in turn would have so much whitespace in them that it's likely going to be worse.

Test Cases

Size = 1, 5, 13
Output for 1Output for 5Output for 13
Has some leading and trailing whitespace thanks to how WRITE works, but luckily it's not an issue. In fact this saves us a whole byte with WRITE'*' including an implicit trailing space. Wow!

Explanation (also on Pastebin with syntax highlighting)

FORM h USING s. "ABAP subroutine
  DO s * 2 - 1 TIMES. "basically a simple for loop; loop over each line top to bottom
    WRITE /''. "Newline. No effect on first line for some reason. *shrug*
    "Also, WRITE /. works, too, but outputs TWO line feeds here. Ugh.
    DATA(y) = sy-index. "Save current index in loop to Y
    DO s * 2 - 1 TIMES. "Loop for each character left to right
      IF sy-index > s - y      "Check if we need to write a '*'
         AND sy-index > y - s. "by subtracting size from current line and vice versa
        WRITE'*'. "Print the '*'. WRITE has an implicit space after the output! 
      ELSE.
        WRITE ``. "Empty literal. CANNOT be '' or ' ' because then we don't get any output.
      ENDIF.      "Yeah, WRITE is odd. Don't ask.
    ENDDO.        "End of inner loop 
  ENDDO.          "End of outer loop
ENDFORM.          "End of subroutine
\$\endgroup\$
1
\$\begingroup\$

C# (.NET Core), 106 105 bytes

Private method, takes the size as input and returns a string containing the hexagon.

Edit: Holy cow. I stared at this single-for-loop version for so long, finally figured out how to make it one byte shorter than the double-for-loop version!

string h(int s){var o="";for(int q=2*s,y=q;q*q>++y;o+=y%q>y/q-s&y%q>s-y/q?"* ":y%q<1?"\n":" ");return o;}

Try it online!

s is the size, x and y represent "coordinates" in the output string (position on the line & current line). In an earlier version I wrote this nice little passage: h>e?x>h-e:x. I found it very fitting, but unfortunately had to scrap it when optimizing my code.

I was initially worried about handling size = 1, but it turns out my code worked just fine. Phew!

Suggestions are welcome! :)


Previous 106 byte version with two for-loops: Try it online!

\$\endgroup\$
1
\$\begingroup\$

VBA (Excel), 77 bytes

Using Immediate Window and A1 as input.

a=[a1]-1:for x=-a to a:y=Abs(x):?space(y)StrConv(String(1+a*2-y,"*"),64):next

And for fun.

    a=[A1
   ]-1:For
   x=-a To 
 a:y=Abs(x):
?Space(y)StrC
 onv(String(
  1+a*2-y,"
   *"),64)
    :Next
\$\endgroup\$
1
\$\begingroup\$

JavaScript (Node.js), 103 bytes

f=(n,m=n+--n)=>[...Array(m)].map((_,i)=>m-Math.abs(i-n)).map(e=>' '.repeat(m-e)+'* '.repeat(e)).join`
`

Try it online!

\$\endgroup\$
1
\$\begingroup\$

APL(NARS) 60 chars, 120 bytes

{1≥k←⍵:'*'⋄⊃{(' '⍴⍨k-⍵+1),((2×k+⍵)⍴'* ')}¨(0..⍵-1),(⍵-2)..0}

test

  f←{1≥k←⍵:'*'⋄⊃{(' '⍴⍨k-⍵+1),((2×k+⍵)⍴'* ')}¨(0..⍵-1),(⍵-2)..0}
  f 1
*
  f 2
 * *  
* * * 
 * *  
  f 3
  * * *   
 * * * *  
* * * * * 
 * * * *  
  * * *

the only difficult is that (2×7)⍴'* ' would mean "repeat '* ' until you write the 14th character" so that would repeat '* ' 7 times...

\$\endgroup\$
0
\$\begingroup\$

F#, 101 98 Bytes

let r=String.replicate
let h n=for i in[0..n-1]@[n-2..-1..0]do(r(n-i)" ")+r(n+i)"* "|>printfn"%s"

Ungolfed:

let replicate = String.replicate
let ungolfed_hexagon n = 
  for i in [0..n-1]@[n-2..-1..0] do // For each hexagon line index [0 .. n-1 .. 0]
      (replicate (n-i) " ")  // Space padding
    + (replicate (n+i) "* ") // Hexagon stars
    |> printfn "%s"

Usage: Call h n, where n is the hexagon size, and it will print the hexagon.

\$\endgroup\$
0
\$\begingroup\$

C, 88, 83

This solution uses just one for loop unlike the other C solution using 2 for loops because of this I suspect it can be golfed much further, but it's 4:30am so I'll attempt that tomorrow.

y,w;f(s){for(w=++s*2-1;y++<w*w-w*2;)printf(" %c",y%w?y%w-1<=abs(s-y/w-2)?0:42:13);}


Revision history:

2) y,w;f(s){for(w=++s*2-1;y++<w*w-w*2;)printf(" %c",y%w?y%w-1<=abs(s-y/w-2)?0:42:13);}

1) y,w;f(s){for(w=++s*2-1;y++<w*w-w*2;)printf("%s",y%w?y%w-1<=abs(s-y/w-2)?" ":"* ":"\n");}

\$\endgroup\$
  • \$\begingroup\$ For example my for loop can already be shortened to for(w=s*2-1;y++<w*w;) and would require only minimal logic changes inside the loop of which I am 90% sure would actual decrease byte size further. \$\endgroup\$ – Albert Renshaw Feb 15 '17 at 9:40
  • 2
    \$\begingroup\$ You know you spend too much time of PPCG when you golf instead of sleep :P \$\endgroup\$ – Cows quack Feb 15 '17 at 9:42
0
\$\begingroup\$

k, 51 bytes

`0:{x,|-1_x}@|{m:-1+2*x;{(x#" "),(2*m-x)#"* "}'!x}@

Explanation:

              {                                  }@ / function(x)
               m:-1+2*x;                            / m = (2*x)-1
                        {                    }'!x   / for x in range(0, x):
                         (x#" "),                   /   x*" " +
                                 (2*m-x)#"* "       /           m-x*"* "
             |                                      / reversed()
   {       }@                                       / function(x)
    x,                                              / x +
      |-1_x                                         /     reversed(x[1:])
`0:                                                 / print array line by line
\$\endgroup\$
0
\$\begingroup\$

Common Lisp, 97 96 bytes

(lambda(x)(dotimes(i(1-(* x 2)))(format t"~v@t~v{* ~}~%"(set'c(abs(1+(- i x))))(-(* x 2)1 c)1)))

needed to figure out formula for:

a) how many spaces before text: |1+x-i| ~~ (abs(1+(- i x)

b) how many characters: 2x-1-|1+x-i| ~~ (-(* x 2)1 c)

idea for using dotimes and abs for looping from Strigoides's answer here

Ideas for improvement are welcomed

\$\endgroup\$
0
\$\begingroup\$

Perl 5 with -na -M5.010, 44 bytes

say$"x abs,"* "x(2*"@F"-1-abs)for 1-$_..$_-1

Try it online!

Uses the same range as a few of the other answers.

\$\endgroup\$
0
\$\begingroup\$

Pyth, 23 bytes

jm.[*4Q*"* "+Qd\ +PUQ_U

Try it online

Explanation:

jm.[*4Q*"* "+Qd\ +PUQ_UQ   Trailing Q inferred, Q=eval(input())
                     _UQ   Reversed 0-range, yields [Q-1, Q-2, ... , 1, 0]
                  PUQ      Tailless 0-range, yields [0, 1, ... , Q-3, Q-2]
                 +         Concatenate them, yields [0 ... Q-1 ... 0]
 m                         Map d in the above to:
            +Qd              Q+d
       *"* "                 Repeat *_ that many times
  .[*4Q        \             Centre pad the above to length 4*Q
j                          Join on newlines, implicit print
\$\endgroup\$
0
\$\begingroup\$

Python 3, 117 113 bytes

def h(s):n="\n".join;t=[" "*(s-i-1)+"* "*(s+i)for i in range(s-1)];return"%s\n%s\n%s"%(n(t),"* "*(2*s-1),n(t[::-1])

Generates the top, then the middle, then reverses the top to generate the bottom half.

\$\endgroup\$
0
\$\begingroup\$

Jelly, 16 15 bytes

ḶU⁶ẋż+Ḷ⁾ *ẋƲŒḄY

Try it online!


Now beats V!

\$\endgroup\$
0
\$\begingroup\$

JavaScript (Node.js), 70 bytes

f=(n,i=n,w=" ".repeat(--i)+"* ".repeat(n++))=>w+(i?`
${f(n,i)}
`+w:"")

Try it online!

With one trailing space at the end of each line.

\$\endgroup\$
0
\$\begingroup\$

Charcoal, 33 31 17 bytes

≔×*NθFθ«P^θ→→»‖B↓

-14 bytes thanks to @Neil.

Try it online (verbose) or Try it online (pure).

Explanation:

Put a string in a variable consisting of the input amount of *:

Assign(Times("*", InputNumber()), q);
≔×*Nθ

Loop the input amount of times by doing a for-each over the characters of this string:

For(q){ ... }
Fθ« ... »

Print the string in both a down-left and down-right direction, without moving the cursor position:

Multiprint(:^, q);
P^θ

And move two positions to the right at the end of every iteration:

Move(:Right); Move(:Right);
→→

After the loop, reflect everything downwards with one line overlap:

ReflectButterfly(:Down);
‖B↓
\$\endgroup\$
  • \$\begingroup\$ FYI I'm down to 22 bytes using a different algorithm (ported from my answer to another hexagon-drawing question). \$\endgroup\$ – Neil Jan 27 at 12:34
  • 1
    \$\begingroup\$ I got to 20 bytes using a polygon but 17 bytes based on your algorithm. \$\endgroup\$ – Neil Jan 27 at 13:05

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.