17
\$\begingroup\$

The Symbols vs. The Letters

The ASCII characters have been divided once again! Your sets are The Letters and The Symbols.

The Letters

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

The Symbols

!"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~

The task is to write two programs:

  1. Print each of The Letters exactly once without using any of them in your program.

  2. Print each of The Symbols exactly once without using any of them in your program.

Rules

  • Whitespace may appear in your program or the output.
  • Non-ASCII characters are not allowed.
  • Output goes to standard out or to a file as either the contents or name of the file.
  • No input.
  • Output must only contain ASCII characters from one set or the other.
  • The programs can be written in different languages or the same language with one exception:
  • The Whitespace language may only be used for one of the programs.
  • Standard loopholes apply.

Scoring

# of characters in program 1 +# of characters in program 2 = Score

Lowest score wins!

Note:

To encourage more submissions, you may still post an answer with a solution for only one of the programs. You won't be able to win, but you would still be able to show off something cool.

Thanks to Calvin's Hobbies for inspiring the idea with his previous question.

\$\endgroup\$
7
  • 4
    \$\begingroup\$ This isn't possible in most languages... For example in Haskell = is inescapable \$\endgroup\$ Commented Aug 22, 2014 at 16:10
  • 1
    \$\begingroup\$ @proudhaskeller part of the challenge is picking a language where it is possible. \$\endgroup\$
    – hmatt1
    Commented Aug 22, 2014 at 16:54
  • \$\begingroup\$ (I realise I should've thought of this while the question was in the sandbox, but) given the "whitespace may appear in the output" rule, does this mean the order of the (letters|symbols) doesn't matter? \$\endgroup\$
    – FireFly
    Commented Aug 22, 2014 at 17:04
  • \$\begingroup\$ @FireFly any order is fine. \$\endgroup\$
    – hmatt1
    Commented Aug 22, 2014 at 17:08
  • \$\begingroup\$ Is it allowed to have control characters (codepoints 0 to 31 and 127) in your program? \$\endgroup\$
    – FUZxxl
    Commented Aug 22, 2014 at 20:13

12 Answers 12

23
\$\begingroup\$

Python (Symbols, 87 82)

from string import punctuation
from string import digits
print digits
print punctuation

I just love Python's string module...

Edit:

from string import punctuation as p
from string import digits as d
print d
print p

Output:

0123456789
!"#$%&'()*+,-./:;<=>?@[\]^_`{|}~

FALSE (Letters, 21) DUP (Letters, 20):

FALSE solution:

65[$91\>][$,$32+,1+]#

DUP sollution (1 char shorter)

65[$91<][$,$32+,1+]#

Output (for both):

AaBbCcDdEeFfGgHhIiJjKkLlMmNnOoPpQqRrSsTtUuVvWwXxYyZz

Interpreter for FALSE.


Total: 102

\$\endgroup\$
4
  • 1
    \$\begingroup\$ wow nice! I've seen people say this couldn't be done in python, well done. \$\endgroup\$
    – hmatt1
    Commented Aug 22, 2014 at 20:13
  • \$\begingroup\$ from string import* works equally well and cuts down the byte count. \$\endgroup\$
    – aglasser
    Commented Aug 22, 2014 at 20:41
  • 5
    \$\begingroup\$ @aglasser ... but using * is forbidden in this context... \$\endgroup\$ Commented Aug 22, 2014 at 20:43
  • 4
    \$\begingroup\$ You're right, can't believe I forgot * was a symbol haha. That explains why you didn't do from string import punctuation, digits either. Nice solution that follows the rules. Sorry about my mistake! \$\endgroup\$
    – aglasser
    Commented Aug 22, 2014 at 20:45
13
\$\begingroup\$

GolfScript (14 chars) + Deadfish x (116 chars) = 130 chars

91,65>{.32+}%+

and

xxcxxcdddKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKxKDxxxccxxxxxxxxxxKxKxKxKxKxKDxxxcxxcxxKxKxKxK
\$\endgroup\$
1
  • 2
    \$\begingroup\$ +1 for being the first of four posts so far actually answer both parts. \$\endgroup\$
    – Geobits
    Commented Aug 22, 2014 at 18:51
11
\$\begingroup\$

Parts 1 and 2 in Ruby 2, 56 + 484 = 540

Part 1:

__=->_{(91..96)===_||$><<(''<<_);_>121||__[-~_]}
__[65]

For more on this style of Ruby, check out narfnme.

Part 2 (this bit is Ruby 2.0+ only, works perfectly with ruby-2.1.0 but may give warnings in earlier versions):

class Fixnum
def c
String def a
end
end
def b
String def A
end
end
def x
String def z
end
end
def y
String def Z
end
end
def inspect
case chr
when c
when b
when y
p succ
else
print chr
p succ
end
p
rescue
p
end
end
def x
String def z
end
end
def y
String def Z
end
end
class String
def inspect
p size
p
end
end
p String p
class String
def inspect
p ord
p
end
end
p y
class Fixnum
def inspect
case chr
when x
p succ
else
send chr
print chr
p
end
p
rescue
print chr
p succ
p
end
end
p x

That one was hard. Calling built-in Fixnum methods like chr and succ requires opening up the Fixnum class and redefining inspect, since I can trigger a call to x.inspect with p x. I need inspect to return nil so that p will only print a newline, any string will be framed in double quotes. But as a side effect, it loops. I can terminate the first loop and second loops using a string comparison to see when I've reached a letter range, but since I can't write a string literal I need to get one by calling String() on the symbol returned (in Ruby 2) by the def keyword. Since that's a multiline syntax and I can only do string comparison via case, which can't take multiline expressions, I need to wrap the literal in a method (since I obviously can't do assignment). The last loop is harder to terminate. I need it to stop at ~. Luckily, of the ascii characters in that range, ~ is the only one that can be called on a Fixnum with no arguments without raising an error, so I can use send chr to detect when I'm at the end and stop looping.

Not the best score in this thread, but thus far the only one that uses the same language for both parts. Yay Ruby.

\$\endgroup\$
2
  • 1
    \$\begingroup\$ +1'ed even before your 2nd answer, cuz' knew that it will come. Respect for pushing the flexibility of Ruby to the limits. \$\endgroup\$
    – Vectorized
    Commented Aug 23, 2014 at 16:18
  • \$\begingroup\$ +1 for the first/only answer that provides both programs in the same language. So far this is the clear winner IMO. I haven't installed Ruby 2, but trust this works. \$\endgroup\$ Commented Aug 23, 2014 at 19:06
8
\$\begingroup\$

Part 2 in Applescript, 654

wait... where's the "tips for golfing in Applescript" page?

global a
global b
global c
global s
on f at n
set end of b to a
end
on g at n
f at a
f at a
end
on h at n
g at a
g at a
end
on i at n
h at a
h at a
end
on j at n
repeat with t in system info
f at a
end
end
on m at n
set end of b to a
set c to count of b
set end of s to ASCII character c
end
on n at n
m at a
m at a
m at a
end
on o at n
repeat with t in system info
m at a
end
end
set a to random number
set b to a as list
j at a
j at a
set c to count of b
set s to ASCII character c
set s to s as list
o at a
n at a
n at a
n at a
n at a
n at a
j at a
i at a
g at a
f at a
n at a
m at a
m at a
j at a
i at a
g at a
n at a
m at a
display dialog s as text

Output:

enter image description here

\$\endgroup\$
1
  • 1
    \$\begingroup\$ I knew there would be an Applescript sollution. Here, have a +1. \$\endgroup\$ Commented Aug 23, 2014 at 8:53
7
\$\begingroup\$

Total: 53 characters

Total in a single language: 230 characters, Pyth

Part 1: Golfscript, 15

91,65>123,97>++

Outputs:

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Explanation:

91,           Make the list, [0 1 .. 90]
65>           Take elements after the 65th, [65 66 .. 90]
123,97>       Same, but [97 98 .. 122]
+             Add the list above to the newline character that is automatically pushed to 
              the stack. List + str coerces to string by ascii encoding.
+             Same, for the other list.

Part 2: Pyth, 38

JhCeGLjkmCdbsrCdCPhGsrhCPeGChGsrJhhhhJ

Outputs:

 !"#$%&'()*+,-./0123456789:;<=>?@
[\]^_`
{|}~

Explanation:

G = "abcdefghijklmnopqrstuvwxyz"   Implicit.
k = ""                             Implicit.
d = " "                            Implicit.
JhCeG                              J = 1 + chr(end(G))          # J = 123
L                                  def d(b): return
 jk                                                k.join(
   m                                                      map(lambda d:
    Cd                                                                 chr(d),
    b                                                                  b))
s                                  print(s(                    #print is implicit.
 rCd                               range(chr(d),                 # chr(d) = 32
 CPhG                                    chr(upper(head(G))))    # chr("A") = 65
srhCPeGChG                         print(s(range(1+chr(upper(end(G))),chr(head(G)))
srJhhhhJ                           print(s(range(J, 1+1+1+1+J)))

Bonus solution:

Part 1: Pyth, 192

%*$"%\143"$52(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 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

Explanation:

$"%\143"$ => "%c". $ switches to and from Python parsing style, and in Python string parsing, \143 is the octal escape sequence for c. This answer is thus equivalent to the following Python-style code:

("%c" * 52) % (65, 66, 67, ...)

Of course, this doesn't work in Python, because printing in Python uses print, but printing in Pyth is implicit, so it works.


Pyth solutions do not use any of the features added since the question was asked.

\$\endgroup\$
2
  • \$\begingroup\$ Where do I learn Pyth? From the examples? \$\endgroup\$ Commented Sep 13, 2014 at 5:46
  • \$\begingroup\$ @SohamChowdhury The examples are a good place to start. Reading the docs is probably the next step - doc.txt in the primary directory. The final step is to start playing with it yourself, using the -d (debug) flag. The software is very new and so nothing better exists. As far as I know, only 3 people have ever used it, and I'm the only one to have used it regularly. Good luck, enjoy. \$\endgroup\$
    – isaacg
    Commented Sep 13, 2014 at 6:12
4
\$\begingroup\$

CJam + AlphaBeta, 62 bytes


Letters, CJam, 12 bytes

"[{"{,-26>}/

Try it online!

Output

ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

How it works

"[{"{     }/   For each of the characters "[" and "{",
     ,         push an array of all ASCII characters before it
      -26>     and discard all but the last 26 characters.

Symbols, AlphaBeta, 50 bytes

ZaaAccctFUaCLOrEbbCLbCLbCLbCLdddACLbCLbCLgDLgDLgDL

Try it online!

The official C++ interpreter has a bug that makes loops impossible and I can't figure out how to use the Lua interpreter. I fixed that bug. You can verify that it works as intended by running the example programs from the EsoLang page.

Output

!"#$%&'()*+,-./0123456789:;<=>?@~}|{]\[^_`

How it works

Z      Switch register 4 to the position register.
aa     Set registers 1 to 2.
A      Copy the value from register 1 to register 2.
ccc    Add 30 to register 1 (result: 31).
tF     Set register 2 to the product of registers 1 and 2 (result: 64).
U      Add 10 to the position register (result: 10, i.e., the position of the next byte).
aCL    Add 1 to register 1 and print the corresponding ASCII character.
O      If register 1 != register 2, go to the position in the position register.
rEb    Set register 1 to the sum of registers 1 and 2 minus 1 (result: 127).
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
ddd    Subtract 30 from register 1 (result: 93).
A      Copy the value from register 1 to register 2.
CL     Print the ASCII character corresponding to register 1.
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
bCL    Subtract 1 from register 1 and print the corresponding ASCII character.
gDL    Add 1 to register 2 and print the corresponding ASCII character.
gDL    Add 1 to register 2 and print the corresponding ASCII character.
gDL    Add 1 to register 2 and print the corresponding ASCII character.
\$\endgroup\$
3
\$\begingroup\$

Part 1 in BrainFuck: 80 74 bytes

>-[+>+<[+<]>]>+.<<+++++[>+++++[>+.<-]<-]>>+++++++.<<+++++[>+++++[>+.<-]<-]
\$\endgroup\$
2
  • \$\begingroup\$ You might have lost the first > due to missing code indentation. So it's rendered as a quotation. \$\endgroup\$
    – Falko
    Commented Aug 22, 2014 at 18:07
  • \$\begingroup\$ @Falko Thanks for noticing, I missed that. \$\endgroup\$
    – spocot
    Commented Aug 22, 2014 at 18:19
3
\$\begingroup\$

Total 318 bytes

I was really hoping to figure out an answer with both programs in the same language, but so far nothing. Here's this instead:

Part 1: Pure bash, 129 bytes

_0=`$ 2>&1`
_0=${_0##*:}
_1=${_0:5:1}
_5=${_0:1:1}$_1${_0:11:1}
. <($_5<<<_2=\({${_1^}..$_1}\))
_3=${_2[@]:0:26}
$_5<<<$_3${_3,,}

Output:

$ ./letsym.sh
A B C D E F G H I J K L M N O P Q R S T U V W X Y Za b c d e f g h i j k l m n o p q r s t u v w x y z
$ 

Part 2: GNU dc, 189 bytes

zzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzPzzzzzzzzzzzzzzzzzzzzzzzzzzzzPzzPzzPzzPzzPzzPzzBDPBEdPBFPdkvZP

Output:

$ dc symlet.dc
!"#$%&'()*+,-./0123456789:;<=>?@[\]^_`{|}~$ 
\$\endgroup\$
2
\$\begingroup\$

Well, you know, someone should get it going.

Part 1 in BrainFuck: 174 bytes

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+++++++
.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.+.
\$\endgroup\$
1
\$\begingroup\$

Part 1: Ruby, 45 bytes

_=[*?@...?[,*?`...?{]
_[0],_[27]=*$_
$><<_*''

Explanation

  • A Range containing a-z (?@...?[) and a Range containing A-Z (?`...?{) become the elements of the array _ using the splat operator (*).
  • The 0th element ("@") and 27th element ("`") of the array _ are set to nil.
  • The array _ is joined together using Array#* and printed to stdout ($>)
\$\endgroup\$
1
  • \$\begingroup\$ You can replace *$_ on the second line with p (or []). \$\endgroup\$
    – Jordan
    Commented Jan 23, 2018 at 16:19
1
\$\begingroup\$

Perl 5, 2744 bytes


Letters, Perl 5, 68 bytes

('#/2%|("(,)2/>'^"````[[[[[[[[[")->($~,"@{['!'^'`'.._,'@'^'!'.._]}")

Try it online!


Symbols, Perl 5 + -M5.10.0, 2676 bytes

I'd quite like to make this smaller, but I'm not sure how just yet. I'll keep thinking on this!

Note: This link includes a ; but that's due to a bug in this code input control and not needed for the code to work.

say chr length for qw oAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA
AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAo

Try it online!

\$\endgroup\$
2
  • 1
    \$\begingroup\$ Wonderful screamer your program part 2 is \$\endgroup\$ Commented Jun 16 at 5:58
  • \$\begingroup\$ ...and far too long for my liking! 😅 Wouldn't have been as fun with another letter! I could have word it words I guess! \$\endgroup\$ Commented Jun 16 at 7:57
0
\$\begingroup\$

1. PHP, 66 bytes

foreach(range(chr(10),chr(122)) as$l){echo ctype_alpha($l)?$l:'';}

Output: ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

Try it online!

2. PHP, 105 bytes

foreach(range(chr(ord('c')-ord('B')),chr(ord('z')+ord('E')-ord('A'))) as$l){echo !ctype_alpha($l)?$l:'';}

Output: !"#$%&'()*+,-./0123456789:;<=>?@[]^_`{|}~

Try it online!

\$\endgroup\$
5
  • \$\begingroup\$ For 2, maybe we should take care of non printable chars as well - so the program will be longer. \$\endgroup\$
    – LucianDex
    Commented Jun 15 at 0:24
  • 1
    \$\begingroup\$ Nice answer, but this is a restricted source challenge which needs to only use the symbols to output the letters and only use the letters to output the symbols! \$\endgroup\$ Commented Jun 15 at 6:28
  • \$\begingroup\$ Maybe (don't know yet) it can be done like you said in PHP, but not as easy. Anyway, I did not used letters as input in operations for 1, and not used numbers for the second. It seems that my understand was limited. :) \$\endgroup\$
    – LucianDex
    Commented Jun 15 at 19:21
  • 1
    \$\begingroup\$ I thinks it definitely possible to do the letters with symbols (Try it online!) assuming php -r it might be possible to do something with echo to print out the symbols but I'm not sure! \$\endgroup\$ Commented Jun 15 at 19:34
  • \$\begingroup\$ You're right! I'll give it a try in the near future. Thanks! :) \$\endgroup\$
    – LucianDex
    Commented 2 days ago

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

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