42
\$\begingroup\$

Your task is to print the text Good morning, Green orb!, with every character repeated in place as many times as the most frequent byte in your source (the mode). A trailing newline is permitted and need not be repeated.

For example if your source was

print p

Since p appears twice and every other byte appears once you would need to print

GGoooodd  mmoorrnniinngg,,  GGrreeeenn  oorrbb!!

Answers will be scored by the product of their byte count and the number of times the output is repeated. For example the above code (if it worked) would score 7*2 = 14. The goal should be to minimize one's score.

Your code must contain at least 1 byte.

Use this program to verify that your code and output match

\$\endgroup\$
  • \$\begingroup\$ Functions are allowed, right? \$\endgroup\$ – totallyhuman Dec 28 '17 at 20:05
  • 1
    \$\begingroup\$ @totallyhuman Yes, so long as they don't take input. \$\endgroup\$ – Sriotchilism O'Zaic Dec 28 '17 at 20:05
  • 1
    \$\begingroup\$ Shouldn't this be tagged quine? \$\endgroup\$ – FantaC Dec 29 '17 at 16:12
  • \$\begingroup\$ Morning can't be capitalized, can it haha? \$\endgroup\$ – Magic Octopus Urn Jan 10 '18 at 19:56
  • \$\begingroup\$ @magicoctopusurn Nope the text should be the same. \$\endgroup\$ – Sriotchilism O'Zaic Jan 10 '18 at 20:06

40 Answers 40

18
\$\begingroup\$

Brain-Flak, 384 * 106 366 * 100 = 36,600

(((((((()()()))))))(()({}{}{}(([(({}{})){}()]((((({}())){})){}{}()(({})<([{}](((({}()())))([{}]([{}]()((()()())(()()({}()([(({})){}()](((((({}))))({}({}{}{}){})(({}){}()))))<((((([]){}){}){}<>)<>)>[])))))))(((((()()())()){}{}){}){})<>(((({})<>)))>{}{})))))<(<>({})<>)>))(<>((({}))()){}{}<>)<>(((({}<>()))))({}{}{}<>)<>{((<>{}<><({}<>)>)<{({}[()]<(({}))>)}{}>)<>}<>{}

Try it online!

Explanation

The first thing I do is push the string

!bro neerG ,gninrom dooG

to the stack using pretty standard brain-flak Kolmogorov-complexity tactics.

(((((((()()()))))))(()({}{}{}(([(({}{})){}()]((((({}())){})){}{}()(({})<([{}](((({}()())))([{}]([{}]()((()()())(()()({}()([(({})){}()](((((({}))))({}({}{}{}){})(({}){}()))))<((((([]){}){}){}<>)<>)>[])))))))(((((()()())()){}{}){}){})<>(((({})<>)))>{}{})))))<(<>({})<>)>))(<>((({}))()){}{}<>)<>({}<>())

Then we push a counter to the off stack to tell us how many times to duplicate each character. However I wasn't going to be able to determine what this counter was until I was done writing the program.

Next up we simultaneously reverse the string and duplicate each character in place the correct number of times. Specifically the counter + 1.

{((<>{}<><({}<>)>)<{({}[()]<(({}))>)}{}>)<>}<>{}

These two parts of the program have a mode of 99 open parentheses. However since we are most certainly going to need at least 1 parenthesis. Here is where I noticed that the last character we pushed ! conveniently has character code 33 which means we can use it to create 99, the exact number we want using only one additional parenthesis. This is quite the coincidence but it works.

\$\endgroup\$
  • 9
    \$\begingroup\$ Ah yes, just pretty standard brain-flak Kolmogorov-complexity tactics. Those are the thing. \$\endgroup\$ – John Keates Dec 30 '17 at 2:49
  • \$\begingroup\$ You, my good fellow, must be mad to even try this. I'm just going to +1 and walk away before my brain explodes from trying to understand all the brackets. \$\endgroup\$ – caird coinheringaahing Jan 3 '18 at 14:51
15
\$\begingroup\$

Haskell, 37 bytes × 3 = 111

-20 thanks to H.PWiz. -25 thanks to nimi.

"Good m\111rning, Green orb!"<*[2..4]

Try it online!

Haskell's operators FTW.

Self-reminder to never golf on mobile. I keep making dumb mistakes. I can push at least half the blame on mobile. :P

\$\endgroup\$
  • 5
    \$\begingroup\$ Using <* to save bytes (Note that I haven't checked its validity) \$\endgroup\$ – H.PWiz Dec 28 '17 at 20:42
  • \$\begingroup\$ ...Bloody hell, Haskell almost has too many operators. Thanks! \$\endgroup\$ – totallyhuman Dec 28 '17 at 20:44
15
\$\begingroup\$

brainfuck, 235 x 77 = 18,095 points

Edit: -2 bytes thanks to @Dennis

-[>--<-------]>-[>+++++>+>+>+>+++++>+>+>+>+>+++>+++++>-->+>+>+>+>+>+>+>+++++>+>+>+>+++[<]>-]>>----------->+++++>++>->+>-------->-------->+++++>>->++++++>------>+>---->+>+++++>++>>->--------->++>++>>-[>+<---]>--------<<[>>[-<+<.>>]<<,<]

Try it online!

TIO test

Wait, this isn’t code bowling?? \s

With only 8 usable characters, brainfuck is one of the worst languages to do this question. I had to start with minimising which character would inevitably appear the most, typically either + or -. After writing the first iteration of the code, I found it horribly unbalanced in favour of +s. I rearranged parts of the code, such as generation of larger numbers, to use more -. Finally, I ended up at an equal amount of the two characters at 77 one less - than +. It’s certainly possible to reduce this further, which I’ll have a go at tomorrow.

But hey, at least I beat the Brainflak answer

\$\endgroup\$
  • \$\begingroup\$ Hey, congratulations! I can't believe that it's even possible to do this in BF... Pretty if it can be done in the ;# language ( ͡° ͜ʖ ͡°) \$\endgroup\$ – RedClover Dec 29 '17 at 18:45
13
\$\begingroup\$

Jelly, 13 bytes * 1 = 13

“¢Ȧ@XĊ'WÑṭḂ#»

Try it online!

\$\endgroup\$
  • 3
    \$\begingroup\$ Finally someone manages the elusive *1 answer. I had a feeling Jelly would be the language to do it... \$\endgroup\$ – ETHproductions Dec 28 '17 at 20:25
  • \$\begingroup\$ @ETHproductions Haha, just halved my code while keeping * 1 \$\endgroup\$ – Mr. Xcoder Dec 28 '17 at 20:27
  • \$\begingroup\$ Haha dang I just found that right after you edited it \$\endgroup\$ – dylnan Dec 28 '17 at 20:30
  • \$\begingroup\$ Out of curiousity, what exactly is the difference? How is the new compressed string half the length of the old one? \$\endgroup\$ – ETHproductions Dec 28 '17 at 20:30
  • \$\begingroup\$ @ETHproductions I basically used a non-optimal compressed string at first, then I used the optimised Jelly compressor which found the matches in the dictionary. \$\endgroup\$ – Mr. Xcoder Dec 28 '17 at 20:32
10
\$\begingroup\$

Alice, 49 bytes * 2 = 98 144

/:G!4o3r8"1=5',0Grey9Z<@
\"b0=dnm 2'i%g<7R6~e.;o/

Try it online!

Explanation

/...@
\.../

This is the usual framework for linear programs that operate entirely in Ordinal mode. Unfolding the zigzag control flow, we get:

"G04d3m821i5g,7G6ee9;<:b!=onr "'=%'<0Rr~y.Zo@

The basic idea is to avoid characters which repeat more than twice with the help of a transliteration. The transliteration we're going to do is the following:

input: "G04d3m821i5g,7G6ee9;<:b!"
from:  "0123456789:;<"
to:    "onr "

The way transliteration works in Alice is that the from and to strings are first repeated to the LCM of their lengths, although in this case, all the matters is the length of the from string, so we get:

from:  "0123456789:;<"
to:    "onr onr onr o"

This way, we get four different characters to represent the os, and three each for n, r and the space. We can generate the from string using range expansion as follows:

'<   Push "<".
0    Append a zero.
R    Reverse.
r    Range expansion.

The only issue now is that we'd need four " for both the input and the to string. To avoid that, we put them both into a single string and split it at a = used as a separator.

"G04d3m821i5g,7G6ee9;<:b!=onr "
     Push the string containing both parts.
'=%  Split around "=".

The rest is just:

~   Swap "from" and "to".
y   Transliterate.
.Z  Duplicate and interleave. This duplicates each character.
o   Print.
@   Terminate the program.
\$\endgroup\$
6
\$\begingroup\$

Python 2, 62 × 3 = 186

lambda:`sum(zip(*['Good morning, Green \x6frb!']*3),())`[2::5]

Try it online!

\$\endgroup\$
6
\$\begingroup\$

C (gcc), 74×6=444crossed out 444 is still regular 444 77×5=385 81×4=324

f(q){char*a="Go\157d morning, G\162een o\162b!";for(q=0;q<96;)putchar(a[q++/4]);}

Try it online!

\$\endgroup\$
  • 16
    \$\begingroup\$ o0 wat did you do to your post header \$\endgroup\$ – totallyhuman Dec 28 '17 at 20:35
  • 9
    \$\begingroup\$ had a bit of fun \$\endgroup\$ – betseg Dec 28 '17 at 20:41
  • \$\begingroup\$ where did the crossed out 44 meta post go? \$\endgroup\$ – NieDzejkob Jan 1 '18 at 18:40
5
\$\begingroup\$

C (gcc), 68 × 3 = 204

0000000: 6a 3b 6d 61 69 6e 28 29 7b 77 68 69 6c 65 28 6a  j;main(){while(j
0000010: 3c 37 32 29 70 75 74 63 68 61 72 28 7e 22 b8 90  <72)putchar(~"..
0000020: 90 9b df 92 90 8d 91 96 91 98 d3 df b8 8d 9a 9a  ................
0000030: 91 df 5c 32 32 30 8d 9d de 22 5b 6a 2b 2b 2f 33  ..\220..."[j++/3
0000040: 5d 29 3b 7d                                      ]);}

Thanks to @MDXF for saving 9 points and paving the way for 6 more!

Try it online!

Alternate version, printable ASCII, 69 × 3 = 207

j;main(k){while(j<72)putchar("Gnmg$hiuf`dl -I}ut|3{gt6"[k=j++/3]^k);}

Try it online!

\$\endgroup\$
5
\$\begingroup\$

APL (Dyalog Unicode), 46 bytes × 2 = 92

(Contains unprintables)

2/⎕UCS(¯18+⍳24)+⎕UCS'X~r-yz|wqum1$Jtfemln]'

Try it online!

+Alot of bytes thanks to Dyalog's code page, thanks to @Adám for pointing that out.

\$\endgroup\$
  • \$\begingroup\$ 84 \$\endgroup\$ – Adám Dec 28 '17 at 20:34
  • \$\begingroup\$ That's really genius, @Adám \$\endgroup\$ – Zacharý Dec 28 '17 at 20:45
  • \$\begingroup\$ I'm afraid you have to settle for 92 since ~⎕AV∊⍨⎕UCS 18. \$\endgroup\$ – Adám Dec 28 '17 at 23:08
5
\$\begingroup\$

Vim, 42 41 keystrokes × 3 = 123

iGod morning, Green orb!<Esc>2|qsyl2pl@sqX0@s

Explanation:

  1. iGod morning, Green orb!<Esc>
    Write the string God morning, Green orb! (one o missing).
  2. 2|
    Jump to the first o.
  3. qsyl2pl@sq
    Create a recursive macro s. As a side effect, triple the current o.
  4. X0
    Remove one o and jump to the beginning.
  5. @s
    Run the macro s, which repeat each character twice.
\$\endgroup\$
4
\$\begingroup\$

C, 78 × 4 = 312

*s=L" ÞÞÈ@ÚÞäÜÒÜÎX@äÊÊÜ@ÞäÄB";main(y){while(*++s)for(;y++%5;putchar(*s/2));}

Try it online!

356 332

\$\endgroup\$
  • \$\begingroup\$ Commenting because I'm tired of finding it in my browser history every time I want to golf: I used this to find the number of character repetitions. \$\endgroup\$ – MD XF Dec 29 '17 at 23:47
  • \$\begingroup\$ And this to encode the string. \$\endgroup\$ – MD XF Dec 29 '17 at 23:57
3
\$\begingroup\$

Japt, 24 bytes * 2 = 48

`Good ¶rÍÁ,
GÎ9 b!`m²·¸

Contains an unprintable. Test it online!

The majority of the program is just a compressed string, which decompresses to

Good morning,
Green orb!

and then maps each character by repeating it ²wice okay, that was a bit of a stretch. Space is the only character that appears 3 times in the compressed string; to save one instance we replace it with a newline, then use ·¸ to split on newlines and immediately join on spaces. While 2 bytes longer, it substantially reduces the score (from 66 to 48).

Now if only there were a short way to do it using no character twice...

\$\endgroup\$
  • \$\begingroup\$ Because I can't see it: which character is in the source three times? I see several things that have a count of 2, but not 3. \$\endgroup\$ – Draco18s Dec 28 '17 at 20:14
  • 1
    \$\begingroup\$ @Draco18s None, the score is 24*2. \$\endgroup\$ – ETHproductions Dec 28 '17 at 20:16
  • \$\begingroup\$ Then the output is wrong. You're printing each character 3 times instead of twice. \$\endgroup\$ – Draco18s Dec 28 '17 at 20:17
  • \$\begingroup\$ @Draco18s Dangit, posted the wrong link... Thanks for pointing that out. \$\endgroup\$ – ETHproductions Dec 28 '17 at 20:18
  • \$\begingroup\$ *salute* And now that I look at your answer I see it has ² whereas the link had ³ :) \$\endgroup\$ – Draco18s Dec 28 '17 at 20:19
3
\$\begingroup\$

SNOBOL4 (CSNOBOL4), 97 bytes * 10 = 970

	S ='Good Morning, Green orb!'
y	S	LEN(1) . y rem . s	:f(p)
	x	=x DUPL(y,10)	:(y)
p	OUTPUT	=x
END

Try it online!

yeah........SNOBOL requires operators to be separated by whitespace, and there are whitespace requirements that are quite awkward. There are 9 '\t' and 10 ' ' in the code, so any improvements will require a fairly significant change in approach.

\$\endgroup\$
3
\$\begingroup\$

R, 65 bytes * 5 = 325 59 bytes * 5 = 295 62 bytes * 4 = 248

cat(gsub('(.)',strrep('\\1',4),"Good Mo\x72ning, Green orb!"))

Try it online!

There are 4 (or,') characters.

\$\endgroup\$
  • 2
    \$\begingroup\$ I've never seen strrep before, that should come in handy. \$\endgroup\$ – BLT Dec 29 '17 at 16:02
3
\$\begingroup\$

Ruby, 52 bytes × 3 = 156

puts"Good morning, Green \x6frb!".gsub(/(.)/,'\1'*3)

Try it online!

\$\endgroup\$
  • \$\begingroup\$ Nice way to avoid repeating characters \$\endgroup\$ – Håvard Nygård Dec 29 '17 at 16:37
3
\$\begingroup\$

Perl 5, 59 × 2 = 118 points

$_="GSSdYmoVRing,YGVIen orb!";y<H-Z>[d-t ],s<.>[$&x2]eg;say

Try it online!

Perl 5, 51 × 3 = 153 156 points

s""GOOd morning, Green orb!";y'O'o';s/./$&x3/eg;say

Try it online!

Perl 5, 43 × 4 = 172 points

say"Good morning, Green orb!"=~s/./$&x4/egr

Try it online!

Saved 2 bytes in each solution thanks to @Xcali (a few changes ago). For all optimizations look at the edits.

\$\endgroup\$
  • \$\begingroup\$ Making this a program instead of a function would save 2 bytes (4 points): Try it online! \$\endgroup\$ – Xcali Dec 30 '17 at 6:53
  • \$\begingroup\$ @Xcali, but your change needs a nonstandard option -M5.010, which also counts \$\endgroup\$ – mik Dec 31 '17 at 18:09
  • \$\begingroup\$ That one is free: codegolf.meta.stackexchange.com/questions/11924/… \$\endgroup\$ – Xcali Jan 2 '18 at 3:51
2
\$\begingroup\$

V, 35 bytes * 2 = 70

IG²od morning, GreeN ORb!5h3~Óˆ/°°

Try it online!

Hexdump:

00000000: 4947 b26f 6420 6d6f 726e 696e 672c 2047  IG.od morning, G
00000010: 7265 654e 204f 5262 211b 3568 337e d388  reeN ORb!.5h3~..
00000020: 2fb0 b0                                  /..
\$\endgroup\$
2
\$\begingroup\$

SOGL V0.12, 16 bytes * 1 = 16

7n]ēæ¬⁹≡qa╔αXE‘⁽

Try it Here!

Compression!

Though, if Green wasn't capitalized like that, this could be 3 bytes shorter :/

\$\endgroup\$
2
\$\begingroup\$

Python 2, 62*4 = 248

Thanks to @ovs and @Giuseppe!

lambda:"".join(c*4for(c)in"G\x6f\x6fd mor\x6eing, Green orb!")

Try it online!

Python 2, 51*6 = 306

print"".join(c*6for c in"Good morning, Green orb!")

Try it online!

Python 2, 70*5 = 350

lambda:"".join(c*5for(c)in"Gxxd mxrning, Green xrb!".replace('x','o'))

Try it online!

Thanks to @Mr. Xcoder for saving a byte from both versions!

\$\endgroup\$
  • \$\begingroup\$ You can remove the space between 6 and for. \$\endgroup\$ – Mr. Xcoder Dec 28 '17 at 20:33
  • \$\begingroup\$ @Mr.Xcoder Thanks! \$\endgroup\$ – Steadybox Dec 28 '17 at 20:36
  • \$\begingroup\$ 57*4=228 \$\endgroup\$ – ovs Dec 28 '17 at 22:23
  • \$\begingroup\$ @ovs that's not quite right, I think you need two \x6fs which is still good for 244 \$\endgroup\$ – Giuseppe Dec 28 '17 at 22:53
2
\$\begingroup\$

Ohm v2, 20 bytes * 1 = 20

”1Gäåa¬Î|òÙγy[õ↕~LzN

Try it online!

Gotta love compression, although unfortunately it's not as good as SOGL's.

\$\endgroup\$
2
\$\begingroup\$

Clean, 77 bytes * 3 = 231

import StdEnv
f=[[b,b..]%(0,2)\\a<-:"Qyyn*wy|xsxq6*Q|oox*\171|l+",b<-[a-'
']]

Try it online!

\$\endgroup\$
2
\$\begingroup\$

CJam, 32 bytes × 2 = 64

"Gnmg$hiuf`dl -I}ut|3orb!"K,.^:_

Try it online!

Pushes a string, then XORs the first 20 character with [0, 1, …, 19], then duplicates each character.

\$\endgroup\$
2
\$\begingroup\$

05AB1E, Score: 22 (22 bytes * 1)

…‚¿•´,„ˆ¨èã).ªðý23£'!«

Try it online.

Explanation:

NOTE 1: The wrap stack into list builtin ) is used instead of the builtin pair , because the is already part of the dictionary word good.
NOTE 2: The two commas in the code and , may look the same, but are different unicode characters. The first one is usually used for the builtin pair, and the second for the builtin print to STDOUT with trailing newline. In this case they are used for the dictionary word good, and the expected comma in the output however.

…‚¿•´,        # 3-word dictionary string "good morning," (the comma counts as the third word)
„ˆ¨èã         # 2-word dictionary string "green orbit"
)             # Wrap everything on the stack into a list: ["good morning,","green orbit"]
 .ª           # Sentence capitalize all strings: ["Good morning,","Green orbit"]
   ðý         # Join by spaces: "Good morning, Green orbit"
     23£      # Only leave the first 23 characters: "Good morning, Green orb"
        '!«  '# Append a "!": "Good morning, Green orb!" (and output the result implicitly)

See this 05AB1E tip of mine (section How to use the dictionary?) to understand why …‚¿•´, is "good morning," and „ˆ¨èã is "green orbit".

\$\endgroup\$
2
\$\begingroup\$

PowerShell, 46 bytes * 4 = 184 points

"Good morning, Green orb!"-replace'.',('$0'*4)

Try it online!

\$\endgroup\$
  • 1
    \$\begingroup\$ That's clever. I completely forgot about $0 \$\endgroup\$ – Veskah Feb 12 at 21:22
  • \$\begingroup\$ :| wait i tried this but only after doing the format so it didn't work as well as this did \$\endgroup\$ – ASCII-only Feb 16 at 11:55
  • \$\begingroup\$ ¯\_(ツ)_/¯ what about TIO link? \$\endgroup\$ – mazzy Feb 16 at 18:28
2
\$\begingroup\$

PowerShell, 49*5 58 bytes * 4 = 232 pts

-13 pts thanks to ASCII-only

-join("Good m{0}rning, Green {0}rb!"-f'o'|% t*y|%{"$_"*4})

Try it online!

Uses formatting to go from 5 os to 4 to chip out some numbers

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

Jelly, 31 bytes × 2 = 62 points

“2ðƈZ(Øṡdȷ¿Ɱ’ṃ“God mrnig,eb!”x2

Try it online!

Explanation

“2ðƈZ(Øṡdȷ¿Ɱ’ṃ“God mrnig,eb!”x2
“2ðƈZ(Øṡdȷ¿Ɱ’                     Base 250 number
              “God mrnig,eb!”     Unique characters of "Good morning..."
             ṃ                    Convert the base 250 number in base 13 then index into the string "God mr..."
                             x2   Repeat each character twice because “ occurs twice in the source (and now 2)
\$\endgroup\$
1
\$\begingroup\$

JavaScript (ES6), 61 bytes * 3 = 183

_=>'Good morning, Gr\145en \x6f\x72b!'.replace(/./g,"$&$&$&")

f=
_=>'Good morning, Gr\145en \x6f\x72b!'.replace(/./g,"$&$&$&")
console.log(f())

JavaScript (ES6), 51 bytes * 4 = 204

_=>'Good morning, Green orb!'.replace(/./g,'$&$&$&$&')

Answer suggested by @ETHproductions.

f=
_=>'Good morning, Green orb!'.replace(/./g,'$&$&$&$&')
console.log(f())

JavaScript (ES6), 73 bytes * 4 = 292

_=>`G00d mo1ning, G244n orb!`.replace(/./g,_=>(('o'+!0)[_]||_).repeat(4))

f=
_=>`G00d mo1ning, G244n orb!`.replace(/./g,_=>(('o'+!0)[_]||_).repeat(4))
console.log(f())

JavaScript (ES6), 58 bytes * 6 = 348

_=>'Good morning, Green orb!'.replace(/./g,_=>_.repeat(6))

f=
_=>'Good morning, Green orb!'.replace(/./g,_=>_.repeat(6))
console.log(f())

\$\endgroup\$
  • \$\begingroup\$ Alternatively, change _=>_ to '$&' \$\endgroup\$ – ETHproductions Dec 28 '17 at 20:19
  • 1
    \$\begingroup\$ Alternaternatively, I think you can just do '$&$&$&$&$&$&' for the replacement, which then I think allows you remove two instances and go down to having several characters tied at 4, drastically reducing the score... \$\endgroup\$ – ETHproductions Dec 28 '17 at 20:21
  • \$\begingroup\$ @ETHproductions Thanks, didn't know about that replacement pattern! \$\endgroup\$ – darrylyeo Dec 28 '17 at 20:30
1
\$\begingroup\$

Retina, 36×4=144


Good morning, Green orb!
.
$&$&$&$&

Try it online! There are three newlines and four os, so there's nothing more to be done.

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

Ruby, 55x4 = 220 points

"Good morning, Green orb!".split(//).each{|x|print x*4}

Im quite annoyed that using each_char makes the count of r's 5..

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

Pushy, 36 * 2 = 72

`GXVWOP^4W_[afdc\hiB`N$29+L-''.

Try it online!

The main principle of this answer is that each character n is stored as n + index - 29 in order to avoid the repetition in the original string. This mapping created the string in the backticks. The rest of the program simply decodes this and prints each character twice:

` ... `              \ Push the encoded string
       N             \ Remove printing delimiter
        $            \ While there are items left on stack:
         29+         \   Add 29 to top of stack
            L-       \   Subtract current length from top of stack
              ''.    \   Print twice, then pop

Bytes used twice: `'W

Changelog

  • Golfed length from 41 to 38, by changing decoding method.
  • Golfed length from 38 to 37 by subtracting 29 from each encoded character to prevent multibyte characters.
  • Golfed length from 37 to 36 by using implicit 'end loop'
\$\endgroup\$

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.