text:
Holy Hole In A Donut, Batman!
Some characters are more holy than others. Using as few unholy letters as possible, display the statement above.
Challenge
Write a full program to print Holy Hole In A Donut, Batman! to STDOUT or closest alternative. If you can compress the input to reduce your score, go wild :)
Input
None
Output
Holy Hole In A Donut, Batman!

Rules

This is a code-challenge, and lowest score wins
The desired output can be read from a file, but that should then be counted towards your total.
Trailing newlines are fine in the output
Standard loopholes and T&C's apply

Scoring
Your score is your byte count, plus some modifiers:

Using holy characters 0469abdegopqrADOPQR@# count as 2 points each
Using extra holy characters 8B%$& are 1 point (no penalty)
Using unholy characters 12357cfhijklmnstuvwxyzCEFGHIJKLMNSTUVWXYZ!"^*()[]{}-=_+|\/?,.<>:;'~ carries a heavier penalty and count as 10 points per character.
Space, tab and newlines are 1 point (no penalty).
Any other characters not listed are 10 points.

*On my keyboard the key '$' and '&' are extra holy. Where font variations cause a character to become unholy, defer to the list above
The unmodified string Holy Hole In A Donut, Batman! scores 172
Ruby: puts "Holy Hole In A Donut, Batman!" scores 225
Score checker
@DeadChex has kindly put together a scoring script
Please do let me know if I need to clarify anything. I will update the list of characters if necessary - I've only included the obvious keys at this point. The idea is simple enough though - holes in characters are good.

Comments are not for extended discussion; this conversation has been moved to chat.

@Doorknob You removed 2 important comments. The one that I asked if 0 should be an extra-holy character or not. (And it's answer)

@IsmaelMiguel That appears to have been edited into the question.

Yes, it was there from the start. It was questioned (as it could technically be extra holy) but my keyboard was my reference and I felt it was too late to change it. 0 is holy, per rule 1. Thanks!

@Doorknob Excuse my ignorance but I can't seem to find such information in the question.

@IsmaelMiguel it's point 1) in the scoring rules. First character in '0469abdegopqrADOPQR'

... That still didn't reflect the comment I left ...

Vyxal, 21 bytes, score 141
`¤∞ ∵⁽ In A DoṖ₃, Ṙ↳!

Try it Online!
A compressed string.
Despite various attempts, I haven't found anything better than this :P
The score is 108 if you count the Unicode holy characters (¤∞ṖṘ) as holy.

Nice! Can you explain how this works for those of us (like me) that have no idea?

@DenhamCoote Vyxal's compressed string format is simply replacing pairs of non-ASCII characters with words from a dictionary. For example, ¤∞ decompresses to Holy and ∵⁽ decompresses to Hole. That's pretty much it :P

Also, as they're unfortunately not listed in the original scoring criteria, this submission would do extra well if the non-listed (yet still holy and extra-holy) characters were counted appropriately. (¤,∞,Ṗ,Ṙ - assume you counted those as 10 points and not 1/2 each?)

@DenhamCoote I didn't even think about that. I'll add that the score changes if you count those.

An excellent (unofficial) score in that case, well done.  As the higher score still beats out the previous best, I will accept your submission as the accepted answer. (It's been a while since I've been active on the site, is that still the right thing to do?)

Unary, 109,700,689,123,880,793,751,483,665,383,781,675,730,387,604,429,204,978,112,223,950,724,553,435,005,885,707,908,578,678,850,861,879,910,670,154,149,244,112,969,597,673,955,700,447,838,276,456,862,280,889,656,901,703,351,515,963,083,297,978,322,224,548,248,606,910,210,200,102,145,647,654,537,444,488,063,149,647,173,155,335,488,014,867,140,385,453,547,997,132,573,700,942,612,360 points
Calculated through bc which is the highest precision calculator that I know of
Code:
54850344561940396875741832691890837865193802214602489056111975362276717502942853954289339425430939955335077074622056484798836977850223919138228431140444828450851675757981541648989161112274124303455105100051072823827268722244031574823586577667744007433570192726773998566286850471306180 zeros

4.5x10259 Yottabytes

Well this ain't winning

If we interpret "lowest score wins" as "closest score to zero wins", and we interpret "closest" as "least 2-adic norm", then this answer would win. Unfortunately, we aren't.

@ThomasKwa I don't get it...

Did you seriously save this to your hard drive? An online converter is telling me this takes 4.87e268 petabytes of disk space...

Lucky that 0 is a holy character. Otherwise your score would have been a lot higher. (You can use Lenguage for extra holy characters and you don't need the extra opening 1 in the binary there.)

How does this work? I don't seem to understand.

@ArturoTorresSánchez tldr BF with each operand converted to a 3 digit binary, put a 1 at the very start, then convert that large binary to unary.

@ThomasKwa as far as I can tell, this score (which ends in 612360) is divisible by 8 but not by 16.  So if anyone's score is divisible by 16, then their score would be closer to 0 in the 2-adic metric than this one is. (Currently kirbyfan64sos has a Pyth score of 352, which is divisible by 32, which looks like it would be the leader under this norm.) http://mathworld.wolfram.com/p-adicNumber.html

@kirbyfan64sos There is Golunar, which can be used to heavily compress the zeroes.

Can you replace 0 with 8 to make this 1 point per char?

Note: You don't need to save this to the disk. Just modify the interpreter and input the number 109,700,689,123,880,793,751,483,665,383,781,675,730,387,604,429,204,978,112,223,950,724,553,435,005,885,707,908,578,678,850,861,879,910,670,154,149,244,112,969,597,673,955,700,447,838,276,456,862,280,889,656,901,703,351,515,963,083,297,978,322,224,548,248,606,910,210,200,102,145,647,654,537,444,488,063,149,647,173,155,335,488,014,867,140,385,453,547,997,132,573,700,942,612,360

CJam, 154 153 148 143 points
"
$&	 &
&$&%

 %		B8B$
	 $8
%8%8&	 	$&
 &
8
8 $B$ 	$&B8$$$B
"0$0$&$f#8b90b' f+

Try it online!
How it works
"
$&  &
&$&%

 %      B8B$
     $8
%8%8&       $&
 &
8
8 $B$     $&B8$$$B
"

      e# Push a string of encoded base 8 digits.

0$0$  e# Push two copies of that string.
&     e# Intersect the copies to remove duplicates.
$     e# Sort the resulting string.
      e# Pushes "\t\n $%&8Bb".

f#    e# Replace each char of the original string by its index in "\t\n $%&8Bb".
      e# Pushes 213502515354211124007673102360146465020351251616237320357633371,
      e# to be understood as an array of single-digit integers.

8b90b e# Convert from base 8 digits to base 90 digits.

' f+  e# Add each base 90 digit to the code point of the space character.
      e# Pushes the desired string.

scratches head Wow, how does this work?!

Look forward to it, thanks :-)

CJam never fails to amaze and confuse me.

So 143 is the score to beat! I'll accept this on Wednesday (1 week after first posting) if it's still in the lead. :)

BrainF***, 3140 points
Behold, the language of unholiness!
-[------->+<]>-.-[--->+<]>++.---.-[--->+<]>.-[---->+<]>++.++++[->++<]>.-[--->+<]>++.---.-------.--[--->+<]>-.++++[->++<]>+.+[--->+<]>.-[->+++++<]>-.[->++<]>+.-[-->+<]>.++[->++<]>.[--->+<]>+++.-.+++++++.-.[++>---<]>--.------------.+[->++<]>.[-->+++<]>--.--[--->+<]>-.-------.------------.+++++++++++++.-[->+++++<]>.

You can use Headsecks if you want to choose the holy road.

@randomra I already did 40 minutes before you commented. See below. :D

Malbolge, 1874 1239
(=<`$9]~6;Y327U5v-Qr*Np-&J$#jFg}Cdd@>`O<t]KZp6Wm3US0QPfe**(:9I^$o"`CkW{>Txv:99'`6oo2m1YXiggAed>P&N^?!\IlY3ExTBARc10/_nJ8IG(X&Dfec@~av<]\r8Zon4UTj0Rmfe+Lha`&HFED!BX]VzZ=Rv9UNrLKo2Hk

I'm pretty sure this can be golfed more. Will try running this for longer. I want to get sub 1000...
I've found shorter length programs (down to 175 I think it was), but the score was higher... Sad. Currently on a 179 length (180 is current) with 4 points less, not sure if editing for that short little bit.

Even the Doom guy would cower at the thought of golfing flippin' Malbolge...

Hmm, a Malbolge answer. Can you talk us through how it works...? ;)

@trichoplax sure. How detailed do you want it? It doesn't really do much apart from crazy operators in a straight line, then output them.

I was joking because Malbolge is reputed to be unreadable. So you're finding programs by leaving a search running, but you can actually understand what they do too?

@trichoplax I can understand the basic prints because of how it operates. It does a crazy thing (literally its name) then prints out one character at a time.

It might help to post the code with the first layer of encryption reversed. It's kind-of hard to explain what Malbolge programs are doing, often, but that step tends to make things more readable in most cases.

Hello World programs are the only type I could ever see Malbolge entries on. Because doing literally anything else is virtually impossible. +1 for the language use, good sir.

sed, 169 166 points
s&$&\to#y \to#e I% A Do%u8, Ba8ma%!&
y&\t#8%&Hltn&

I've counted each \t as a single point, since it can be replaced with an actual tabulator.
Try it online!
How it works

Both commands use the extra holy & as delimiter.
The first command replace the end of the (empty) pattern space with the string \to#y \to#e I% A Do%u8, Ba8ma%!.
The second command replaces \t, #, 8 and % with the unholy H, l, t and n, respectively.

Because of the penalty for unholy characters, transliteration adds 12 bytes but saves 20 points.

Man, you have this challenge figured out.

PHP, 175 168 163 160 159 points
I did what I could to reduce the score as much as possible.
With the help of @Dennis, the score was reduced by 5 points.
echo BeeABBeeoBodBaBdOdPQBBgDQgDdp^"\n\n\t8b\n\n\t\nb&\nb b  \n%%nb%%%\n%\nQ";

Yeah, not exactly short...
Replace the \n and \t with a UNIX-style newline and a tab, respectivelly.
To execute it, simply run it with the -r switch (not counted on the score)

Here's a shorter one that is only 256 points:
<?=$a=Hol,"y {$a}e In A Donut, Batman!";

JavaScript, 1337 Points
for(B="&$8$$&8$%&8&&%8$&%8&$8$$&8$%&8$$8$&%8&&8$$$8$&%8%8$&%8$%8$$&8$$$8&%&8&%$8$&%8$8%8&%$8$$%8%8$$$8$&%8".split("8"),$="",i=0;i<B.length;i++)$+=toDec(s[i]);alert($.split("P").join(" ").toLowerCase().replace(/\b(\s\w|^\w)/g,function($){return $.toUpperCase()})+"!");

This takes advantage of the face that there are 26 letters in the alphabet, and 26 characters can be represented by three digits of ternary (base-3) numbers 0, 1, and 2, here represented by %$& respectively.
Split that enormous string up at each '8' (I use it as a delimiter because it's extra-holy, spaces would have worked too), convert to a base-3 integer by replacement (0 becomes %, 1 becomes $, 2 becomes &), convert that to decimal (%%& = 2), and then put the string back together. Add 65 (the char value of the letter A) and convert each integer to a character, A-Z. Lastly, convert to title-case, and add in punctuation.
An easier-to-read unminified version:
B ="&$8$$&8$%&8&&%8$&%8&$8$$&8$%&8$$8$&%8&&8$$$8$&%8%8$&%8$%8$$&8$$$8&%&8&%$8$&%8$8%8&%$8$$%8%8$$$8$&%8".split('8')
    $=''
    for (i = 0;i<B.length;i++) {
        $ += toDec(s[i])
    };
    alert($.split('P').join(' ').toLowerCase().replace(/\b(\s\w|^\w)/g, function (t) { return t.toUpperCase(); })+ "!");

Sure it's goofy. But it was a fun idea to play around with anyhow!

alert("Holy Hole In A Donut, Batman!") has a score of 238...

I saw the 'extra-holy characters' line and thought, 'hm... No way I'd win this... But I have an interesting idea......' Kids, don't play with base-3.

also... until you post that one, I'm still winning for javascript answers ;D

@j6m8 Nah, it's so trivial. Your goal should be to beat it, whether it's posted or not.

Remove the quotes in split("8").

looks at score I see what you did there.

HTML, 169 points

Holy Hole In A Donut&#44 Batman!

That's the only character that had a decimal numeric entity with only holed numbers.
(In the HTML specification, entities must be followed by a semicolon but it still works in major browsers without one.)

Took me a while to realise how this works out a lower score than hardcoding - I'd forgotten about the comma... +1

Whitespace, 438 points
If you see nothing, then it's because of whitespace!
Reading about "4. Space, tab and newlines are 1 point (no penalty)." brings me to my choice of language:

S = Space
T = Tab
L = Line feed

[Start of code]
S S S T S S T   S S S L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   T   T   S S T   L
T   L
S S S S S S T   S S S S S L
T   L
S S S S S T S S T   S S S L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T T   S T T   S S L
T   L
S S S S S T T   S S T   S T L
T   L
S S S S S S T   S S S S S L
T   L
S S S S S T S S T   S S T   L
T   L
S S S S S T T   S T T   T   S L
T   L
S S S S S S T   S S S S S L
T   L
S S S S S T S S S S S T L
T   L
S S S S S S T   S S S S S L
T   L
S S S S S T S S S T S S L
T   L
S S S S S T T   S T T   T   T   L
T   L
S S S S S T T   S T T   T   S L
T   L
S S S S S T T   T   S T S T L
T   L
S S S S S T T   T   S T S S L
T   L
S S S S S S T   S T T   S S L
T   L
S S S S S S T   S S S S S L
T   L
S S S S S T S S S S T   S L
T   L
S S S S S T T   S S S S T   L
T   L
S S S S S T T   T   S T S S L
T   L
S S S S S T T   S T T   S T L
T   L
S S S S S T T   S S S S T   L
T   L
S S S S S T T   S T T   T   S L
T   L
S S S S S S T   S S S S T   L
T   L
S S L
L
L

[End of code]

Trying to copy and paste this just results in 62 linefeeds. Could you include a hexdump or a version with placeholders for tab and space?

Yes, i got trouble with them. But now you can see the invisible whitespace ;)

For anyone who is bored to remove those STLs, paste the code in the answer to the right of this /// script (but not in the STDIN or an argument). This way, you can reinstate invisibility!

I knew there was going to be a Whitespace answer just as I saw that scoring method.

Headsecks, 333 470
I converted my BF program to Headsecks using as many Extra Holy characters as possible. Much holier than BF.
Since vertical tabs apparently cost 10, switched to #.
Note: Probably still a better score than if I hadn't used loops.
#&#######8B o8#$#&###8B    o8BB$###$#&###8B o8$#&####8B    o8BB$BBBB&#8BB o8$#&###8B  o8BB$###$#######$##&###8B    o8#$BBBB&#8BB o8B$B&###8B  o8$#&#8BBBBB  o8#$&#8BB o8B$#&##8B   o8$BB&#8BB o8$&###8B    o8BBB$#$BBBBBBB$#$&BB8###  o8##$############$B&#8BB o8$&##8BBB    o8##$##&###8B    o8#$#######$############$BBBBBBBBBBBBB$#&#8BBBBB  o8$

Batch, 197 points
echo Holy Hole In A Donut, Batman!

c and h are the only two extra characters that aren't holy - and since batch doesn't require quotes round strings, I miss out the 20 point penalty there.

To be a bit pedantic, this doesn't produce the correct output if placed in a batch script and then run. You need to preface the line with an @ resulting in +2 to your score. Alternatively, running this directly from the command prompt works just fine.

@dohaqatar7 To be roughly as pedantic, it's still Batch, even outside of a Batch script file, much like writing Ruby into IRB is still writing Ruby.

Z80 assembler, 539 523 points
ld hl,Q
L: ld a,(hl)
or a
ret z
call 0A2h
inc hl
jr L
Q: db "Holy Hole In A Donut, Batman!",0

Note that this is intended to run on a MSX computer, whose BIOS routine CHPUT, located at address 00A2h, prints the character passed in the accumulator without modifying any register.
(How could the score be calculated by using the assembled binary, by the way?) :-P

Can machine code be considered a programming language?

If you're masochist enough... sure! :-)

But then what encoding would you use to represent the bytes? Also, if you ship that way it seems your choice of a 8-bit CPU would make real sense.

What encoding? Hexadecimal or base-64, perhaps binary... whichever you find to be the funniest!

Mikkel Alan Stokkebye Christia suggested replacing M by Q to save some points.

Indeed! Code edited. Thanks!

@Mindwin - it's not Machine Code but Machine Langauge. Also, if you're not going over an 8-bit boundary, couldn't you just inc l rather than inc hl?

Insomnia, 168 points
  doe
@opp@e p@ pp
@d
dr$%p$ opp@ p@rop@@%  @oe@@
do@ %@pr$%
@ r$
%
po
@
@dp
@@ep@  d
@% %@d
@@% p@
d
@

Only managed to do 1 point better than HTML solution.

Pyth, 182 points
"Holy Hole In A Donut, Batman!

It's not my strongest language. I'm open to suggestions...

I don't know Pyth, but you could compress the string and maybe get a better score

Pyth, 352 points
jkmCid2c::"B88B888 BB8BBBB BB8BB88 BBBB88B B88888 B88B888 BB8BBBB BB8BB88 BB88B8B B88888 B88B88B BB8BBB8 B88888 B88888B B88888 B888B88 BB8BBBB BB8BBB8 BBB8B8B BBB8B88 B8BB88 B88888 B8888B8 BB8888B BBB8B88 BB8BB8B BB8888B BB8BBB8 B8888B"\8\0\B\1d

I tried to be smart and encode the string as extra holy characters. That did not work too well...

SMBF, 232 points
␀ represents a literal null byte \x00, which is unholy.
<[.<]␀!namtaB ,tunoD A nI eloH yloH

Jolf, noncompeting
84 points
Try it here!
»Ho§ Ho€ In A D©, BΆn!

Uncompressing a compressed string.

This doesn't output anything. Does the program not work anymore?

@mbomb007 Are you using Firefox?

No. Google Chrome.

@mbomb007 Jolf currently doesn't work on Chrome. I'll look into fixing it, but in the meantime, Firefox should work.

I didn't realise it at the time but I think it was wrong to include score modifier 5. Or, at least, I should have considered some of the other 'holy' characters.  Anyway, according to score checker this scores 134. Nice!

Golunar, 1713
Sure, it's not that competitive, but it scores better than my BF answer. Code is obtained by taking the length of the code in Unary as a number.
17674921849995820305790270238143323861912297173117627579717678879378201073932744615660131563027031190590108979867232158537472346711601276443457666612884962806277404746795044800422000866416680881699125205492286893675575004572084572619659104159027555358269065090420400745692716750939076

ferNANDo, 467 points
8 B
B 8 B B 8 B B B
B 8 8 B 8 8 8 8
B 8 8 B 8 8 B B
B 8 8 8 8 B B 8
B B 8 B B B B B
B 8 B B 8 B B B
B 8 8 B 8 8 8 8
B 8 8 B 8 8 B B
B 8 8 B B 8 B 8
B B 8 B B B B B
B 8 B B 8 B B 8
B 8 8 B 8 8 8 B
B B 8 B B B B B
B 8 B B B B B 8
B B 8 B B B B B
B 8 B B B 8 B B
B 8 8 B 8 8 8 8
B 8 8 B 8 8 8 B
B 8 8 8 B 8 B 8
B 8 8 8 B 8 B B
B B 8 B 8 8 B B
B B 8 B B B B B
B 8 B B B B 8 B
B 8 8 B B B B 8
B 8 8 8 B 8 B B
B 8 8 B 8 8 B 8
B 8 8 B B B B 8
B 8 8 B 8 8 8 B
B B 8 B B B B 8

Try it online!

Forth, 193 points
." Holy Hole In A Donut, Batman!

Try it online
This also works with the same score:
.( Holy Hole In A Donut, Batman!

05AB1E, 28 bytes (246 points/182 points)
‘¨®¥Ê€†€…‘" Donut, "‘ßƒ‘'!J™

Try it online!
even worse (base-5 with holy characters) - 256 bytes:
"BB8$$&B8&&$B$$$8B&$8B%8%$$$&8%&88$$&8%$BB$8B$B$&B8%&%B&8&$8$8&&88""8B%$&"4ÝJ‡5ö36B2ÝJ… ,!‡™

or (less fun, super trivial):
"Holy Hole In A Donut, Batman!

for 182 points.

W.Y.A.L.H.E.I.N., 3103 score, 2784 bytes 2886 score, 2558 bytes
14192091
121
8888888888888888888888888888888888888888888888888888888888888888888888888.%8888888888888888888888888888888888888888888888888888.%888888888888888888888888888888888888888888888888888888888888888888888888.%88888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%888888888888888888888888888.%88888888888.%8888888888888888888888888888888888888888888888888888888888888888888888888888888888.%888888888888888888888888888888888888888888888888888888888888888888888888888888888.%88888888888888888.%88.%8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%888888888888888888888888888888888888888888888888888888888888888888888888.%88888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%8888888888888888888888888888888888888888.%888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%88888888888888.%8888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%88888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%88888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%8888888888888888888888888888888888.%88888888888888888888888.%8888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%8888888888888888888888.%888888888.%888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%888888888888888888888888.%88888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888.%

Try it online!
Used with a brute forcer.
After several days, I have golfed this.

><>, 201 Points
#o<$g0d"oy Hole In A Donut, Batman!"og0b

Try it online!
Slightly better than just printing. I imagine clever modulo stuff might be able to shave off a few more points.

Ook! - 15699 points
I'll see your Brainfuck, and I raise you this :
Ook! Ook! Ook! Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook. Ook! Ook! Ook! Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook. Ook! Ook! Ook! Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook! Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook! Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook. Ook! Ook! Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook! Ook! Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook? Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook. Ook. Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook. Ook! Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook. Ook! Ook? Ook. Ook. Ook. Ook. Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook. Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook. Ook! Ook? Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook? Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook? Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook! Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook! Ook. Ook! Ook! Ook! Ook? Ook! Ook! Ook. Ook? Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook. Ook? Ook. Ook? Ook! Ook. Ook? Ook! Ook.

No orangutan were harm in the redaction of this program.

Your code is basically mine pasted into a BF-to-Ook! translator program. Not much of a raise.


text:
Divisor sum from prime-power factorisation
The task is to compute the divisor sum of a number given its prime factorisation.
Input
Two arrays (or something equivalent) of length n, one containing the prime factor and the other containing the corresponding exponent.
Output
The sum of all divisors (including the number itself).
Example
The number 240 has 2, 3, and 5 as prime factors with 4, 1, and 1 as the respective exponents. The expected output would then be 744.
Input: [2,3,5] [4,1,1]
Output: 744

Scoring
Shortest code in bytes wins!
If your solution's run time complexity is O(sum of exponents) rather than O(product of exponents), your score may be multiplied by 0.8.

There was a similar question posted here, but it wasn't a challenge. I think the problem is interesting enought to be golfed.
The winner will be choosen this weekend

Does the prime factor array always have to be first and the exponent array second or can we assume that the arrays are inputted the other way around?

You may assume any input format similiar to the proposed one

Cannot find it right now, but I think this or something similar is on projecteuler.net

Pyth, 13 bytes * 0.8 = 10.4
*Fms^LhdhedCQ

Demonstration.
This answer works somewhat differently from those above. In order to calculate the sum of the factors of the prime powers of the number, instead of using an arithmetic formula, the factors are explictly constructed and summed.
For instance, on the [prime, exponent] pair [2, 4], we map 2 ^ x over 0, 1, 2, 3, 4, giving [1, 2, 4, 8, 16], which is then summed to 31.
The results are then multiplied together and printed.
If exponentiation is implemented properly, or if there is intermediate result caching, this will be O(sum of exponents).

Independently of the implementation, I don't think it's possible to calculate the first n power of a in O(n) time, unless you assume that multiplication is O(1).

@Dennis Well, the higher order terms dominate, so it would probably have the rutime of the highest order multiplication, which is O(n) if we can assume the base is a constant.

CJam, 15 bytes * 0.8 = 12
q~.{_@)#(\(/}:*

Try it online. The input order is exponent list first, then list of primes (-3 bytes thanks to @Dennis).
For each prime-exponent pair (p, e) find
(p^(e+1) - 1)/(p - 1)

then find the product of all of these. E.g. for 240 this would be
(1 + 2 + 4 + 8 + 16)(1 + 3)(1 + 5) = 31 * 4 * 6 = 744

Depending on how exponentiation is implemented, this can be better than O(sum of exponents).

APL, 18 13 bytes * 0.8 = 10.4
×/(1-⊣×*)÷1-⊣

This creates a dyadic function train that takes the array of factors on the left and the exponents on the right.
×/             ⍝ Vector product of
  (1-⊣×*)      ⍝ each factor^(exponent+1)-1
         ÷1-⊣  ⍝ divided by factor-1

Try it online. Note that this is the same approach as Sp3000's awesomely clever CJam answer.
Saved 5 bytes thanks to Dennis!

Matlab, 53
function t=f(x,y)
s=1:prod(x.^y);t=s*~mod(s(end),s)';

Example:
>> f([2 3 5], [4 1 1])
ans =
   744

Looks like you may add the 0.8 bonus

@Moartem Thanks! But I'm not sure about that. I compute the number s and then test all possible divisors from 1 to s. So it's (at least) O(s), which is probably between O(sum of exponents) and O(product of exponents)

Yes, that´s right, it´s even bigger than O(product of exponents)

TI-BASIC, 17 bytes * 0.8 = 13.6
Also uses Sp3000's method, though I found it independently. Takes one list from Input and one from the homescreen.
Input E
prod(AnsAns^∟E-1)/prod(Ans-1

Using prod( twice is smaller because it lets us use the open parenthesis for free. Note that this answer does not support empty arrays, because there are no empty arrays in TI-BASIC.

C++, 111 80 77 bytes * 0.8 = 61.6
int g(int*p,int*e,int n){return n?g(p+1,e+1,n-1)*(pow(*p,*e-1)-1)/(*p-1):1;}

This computes (p^(e+1)-1)/(p-1) and recursively multiplies all factors. Found that out myself a year ago.
Thank you for helping, totally forgot about c++ style boolean usage.

n==0 simplifies to !n - or you could reverse the outcomes and just use n

Haskell, 38 * 0.8 = 30.4
product$zipWith(\p e->(p*p^e-1)/(p-1))

Usage:
product$zipWith(\p e->(p*p^e-1)/(p-1)) [2,3,5] [4,1,1]
744.0

The anonymous function takes (p,e) to the divisor-sum for p^e via geometric series sum. Zipping together the two lists with this as the joining and taking the product gives the result.
I wasn't able to find anything shorter that the arithmetic expression
(p*p^e-1)/(p-1)
sum$map(p^)[0..e]

Maybe there's a way to get rid of the (\p e->_).
Infix function definition gives the same length (38):
p%e=(p*p^e-1)/(p-1)
product$zipWith(%)

Python 2,156
from itertools import*
from operator import*
i=input()
print sum(reduce(mul,[a**b for a,b in zip(i[0],p)])for p in product(*map(range,[x+1 for x in i[1]])))

Input
[[2,3,5],[4,1,1]]

Output
744

Explanation
This program receive list of 2 lists: factors and exponents.
i=input() # Receive list of 2 lists: i[0] for factors i[1] for exponents

Then its create list of all possible combinations of the exponent list.
[x+1 for x in i[1]] # [4,1,1]->[5,2,2] (to include last element)
map(range,[x+1 for x in i[1]]) # [[0, 1, 2, 3, 4], [0, 1], [0, 1]]
product(*map(range,[x+1 for x in i[1]])) # [(0, 0, 0), (0, 0, 1), ..., (4, 1, 1)]

and zip it with the factors:
zip(i[0],p) for p in product(*map(range,[x+1 for x in i[1]])) # [[(2, 0), (3, 0), (5, 0)], ..., [(2, 4), (3, 1), (5, 1)]]

Calculate the factors to the power of exponents:
 [a**b for a,b in zip(i[0],p)]for p in product(*map(range,[x+1 for x in i[1]])) # [[1, 1, 1], ..., [16, 3, 5]]

and multiply each list (this gives us all the divisors):
reduce(mul,[a**b for a,b in zip(i[0],p)])for p in product(*map(range,[x+1 for x in i[1]])) # [1, 5, 3, 15, ..., 240]

Finally, sum all the lists and print:
print sum(reduce(mul,[a**b for a,b in zip(i[0],p)])for p in product(*map(range,[x+1 for x in i[1]]))) # 744

Could you briefly explain what your code does (as I´m not familiar with python), so I can judge the complexity of your code?

Thats a clever approach, but the complexity is the product of the exponents

@Moartem Yeah, I didn't spend much time on reducing the complexity

Python 3, 134 120 117
Input: two comma-separated arrays separated by comma.
Example:
(2,3,7,11),(4,2,3,2)
21439600

from functools import*
a=eval(input())
print(reduce(int.__mul__,(sum(x**j for j in range(y+1))for x,y in zip(*a)),1))

With NumPy can be reduced to 100 bytes:
import numpy
a=eval(input())
print(numpy.product([sum(x**j for j in range(y+1))for x,y in zip(*a)]))

For the first example, just so you know, instead of importing operator for using mul once, you can use float.__mul__ to save a bunch of bytes.

Jelly
This answer is non-competing, since the challenge predates the creation of Jelly.
5 bytes (no bonus)
*PÆDS

Try it online!
How it works
*PÆDS    Main link. Left input: p (prime factors). Right input: e (exponents).

*        Elevate the prime factors to the corresponding exponents.
 P       Take the product of all powers.
  ÆD     Find all divisors of the product.
    S    Compute the sum of the divisors.

7 bytes (5.6 bytes after bonus)
*‘}’:’{P

How it works
×*’:’{P  Main link. Left input: p (prime factors). Right input: e (exponents).

 *       Elevate the prime factors to the corresponding exponents.
         This yields p ** e.
×        Multiply the prime factors with the corresponding powers.
         This yields p ** (e + 1).
  ’      Decrement the resulting products.
         This yields p ** (e + 1) - 1.
    ’{   Decrement the prime factors.
         This yields p - 1.
   :     Divide the left result by the right one.
         This yields (p ** (e + 1) - 1) / (p - 1).
      P  Take the product of all quotients.

Try it online!

APL, 12 bytes * 0.8 = 9.6
×/1++/¨⎕*⍳¨⎕

This reads two lists from the keyboard, exponents first, i.e.:
      ×/1++/¨⎕*⍳¨⎕
⎕:
      4 1 1
⎕:
      2 3 5
744

Explanation:

⎕: read a list from the keyboard (the exponents)
⍳¨: for each number in the list, generate a list [1..n].
⎕*: read another list from the keyboard (the primes), and raise each prime to each of the exponents in the corresponding lists
+/¨: sum each list
1+: add one to each result, to compensate for the missing x^0 in each of the lists
×/: take the product of the results

Racket (Scheme), 65 * 0.8 = 52 bytes
Same arithmetic as everyone else
(λ(x y)(foldl(λ(m n o)(*(/(-(expt m(+ n 1))1)(- m 1))o))1 x y))

Explanation:
(λ (x y)    ;defines anonymous function with two inputs
    (foldl    ;recursively applies the following function to all elements of the lists given to an argument given (foldl function argument lists lists lists...)
        (λ (m n o) (* (/ (- (expt m (+ n 1)) 1) (- m 1)) o))    ;an anonymous function representing the same arithmetic used in the CJam answer, then multiplying it with our incrementor
        1 x y))    ;the incrementor argument is 1, and the input lists are the ones provided into the original function

Jelly, 4 bytes
*PÆs

Try it online!
How it works
*PÆs - Main link. Takes bases B on the left and exponents E on the right
*    - Raise each base to each exponent
 P   - Take the product
  Æs - Take the divisor sum

Python 2, 80 Bytes * 0.8 = 64
This assumes the input comes in one after another. Follows the same formula as outlined in Sp3000's CJam answer.
print(reduce(float.__mul__,[~-(x**-~y)/~-x for x,y in zip(input(),input())],1))

If this isn't allowed, then I'll use this as a solution, which gets a score of 84 bytes * 0.8 = 67.2. Input should be separated by a comma, i.e. [2,3,5],[4,1,1].
k=input()
print(reduce(float.__mul__,[~-(x**-~y)/~-x for x,y in zip(k[0],k[1])],1))

Psst. Hey! This is a possible solution in Symbolic, something I'm working on: Ƥ(П([~-(x**-~y)/~-xϝx,yϊʐ(Ί,Ί)],1))

Perl 5, 96 bytes
Obviously this is nonwinning, but I decided to write it for fun.
It's a subroutine:
{($b,$e)=@_;$s=1;map$s*=$b->[$_]**$e->[$_],0..@$b-1;$_=1x$s;for$j(1..$s){$i+=$j*/^(.{$j})*$/}$i}

See it in action thus:
perl -e'print sub{...}->([2,3,5],[4,1,1])'

How it works:

($b,$e)=@_ reads the input arrayrefs $b (bases) and $e (exponents).
$s=1 initializes the product.
map$s*=$b->[$_]**$e->[$_],0..@$b-1 multiplies $s by successive base-exponent powers. Now $s is the composite number.
$_=1x$s sets $_ equal to a string of ones, $s long. $i is initialized at 0.
for$j(1..$s){$i+=$j*/^(.{$j})*$/} tries, for every number $j between 1 and $s, to break $_ up as $j characters repeated any number of times. If it can, then $j divides $s, and /^(.{$j})*$/ is 1 (otherwise it's 0), and $i is augmented by $j. Thus, we add to $i the number of partitions in a equal-sized partition of $_. As Omar E. Pol points out, $i is the number we're seeking.
$i at the end returns $i.

Mathematica, 40 bytes
Total[Outer@@{*}~Join~(#^0~Range~#2),3]&

Without using any of the inbuilts that deal with divisors, to differentiate from the other mathematica solution in the thread.
Input is (using example) [{2, 3, 5}, {4, 1, 1}]

J, 14 bytes * 0.8 = 11.2
[:*/(^>:)%&<:[

Usage
   f =: [:*/(^>:)%&<:[
   2 3 5 f 4 1 1
744

source: Stack Exchange

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

sort: votes


text:
Checking Word Grids
Your Task
Given a list of words, check if they form a valid word grid. They form a valid grid if there are N words with N letters and they spell the same words vertically as they do horizontally. The words can be given in any order. [FILE, ICED, LEAD, EDDY] = True and [FILE, LEAD, EDDY, ICED] = True. Print True if it is valid or False if it is not
Here's some more examples
F I L E
I C E D
L E A D
E D D Y

O G R E
G A I A
R I G S
E A S Y

C A M P
A X E L
M E M O
P L O W

S P A S M
P A S T A
A S P E N
S T E E L
M A N L Y

This is code golf so lowest bytes wins

So we have to check all permutations of the input right?

@Maltysen Correct. Permutations of the words not the letters in the words

Any truthy/falsy values are fine, or the exact strings "True" and "False" ?

You just have to check that the grid (in some permutation) is symmetric, not that the words are valid according to some dictionary?

@xnor That's correct. The input can be gibberish but it has to be symmetrical gibberish

@Optimizer You have to print the words True and False

Why did my question get downvoted?

@SirParselot Probably because they find the challenge is fairly trivial / uninteresting.

@SirParselot I might also guess someone is unhappy their language has to convert to True/False while others have them natively.

Pyth - 10 9 bytes
The actual check is very easy, in just three bytes with CIQ. The permutation part takes the other 6.
.EmCId.pQ

Try it online here.
It maps over the .permutations of the (Q) input, each time checking if the loop var(d) is Invarient under (C) rotation. Then it checks if .Eany are true.

CJam (25 24 bytes)
q~e!{_z=},"True""False"?

Online demo. Pretty trivial apart from the specified output, because CJam doesn't have a Boolean type.
With thanks to Sp3000 for saving one stroke.

@Sp3000, true. I'm so used to expecting the interleaved string approach to be shorter that I didn't even try the naïve approach.

Has Peter abandoned GolfScript in favor of CJam??

@AlexA., not entirely. But for this question, GS can't possibly get anywhere near CJam. e! would require writing a recursive function in GS: that's 6 characters before it even does anything.

Julia, 114 bytes
Did somebody say "super long solution"?? It just so happens that I have one for you.
a->(L=length(a);P(x)=reshape(split(join(x),""),L,L);print(any([P(p)==P(p)'for p=permutations(a)])?"True":"False"))

This creates an unnamed function that accepts an array and prints to stdout. It works by generating all permutations, turning the arrays into matrices of letters and checking whether each matrix is equal to its transpose. Unfortunately booleans are lowercase in Julia, otherwise I wouldn't have had to do the ternary.

Python 2, 74
s=input().split()
print all(''.join(s)[s.index(w)::len(w)]in s for w in s)

Haskell, 51 bytes
import Data.List
any((==)=<<transpose).permutations

Usage example: any((==)=<<transpose).permutations $ ["LEAD","FILE","ICED","EDDY"] -> True.
How it works: check if any of the permutations equals it's transposition. Luckily Haskell's native boolean values are True and False.

Python 2, 87 85 Bytes
Straightforward solution using zip() to transpose.
Saved two bytes on both thanks to xnor.
from itertools import*
print any(zip(*c)==map(tuple,c)for c in permutations(input()))

Solution without relying on imports, 139 138 136 Bytes
p=lambda l:[[j]+k for i,j in enumerate(l)for k in p(l[:i]+l[-~i:])]if~-len(l)else[l]
print any(zip(*c)==map(tuple,c)for c in p(input()))

If there's a way to get around using enumerate, let me know! :)
Input for both should be formatted like so:
["FILE","ICED","EDDY","LEAD"]

Psst. Hey! Here's a solution in Symbolic, something I'm working on.
Ƥ(Ʌ(ʐ(*c)==ϻ(ϰ,c)ϝcϊƥ(Ί)))

You can do any() for sum()>0.

are you submitting this for the bounty?

@Maltysen No, I just did it because I was experimenting :)

Symbolic looks really cool! But fyi, the 31 characters in that solution make for a score of 41 bytes in UTF-8. It may not be the most competitive golfing language. ;)

@AlexA. I don't think I could make anything on the level of Pyth/CJam/GolfScript, I'm just doing it for fun ;P

Well like I said, it looks really cool. I'm excited to see it develop!

Brachylog, 6 bytes
p⟨\=≡⟩

Try it online!
Assuming output can be "true." and "false." instead of "True" and "False".
If not, it's a trivial change to:
22 bytes
p⟨\=≡⟩∧"True"|∧"False"

Try it online!

Ruby, 97 bytes
91 bytes if we remove .chomp inside map
a=gets.chomp.split','.map{|_|_.chomp.chars};p a.permutation.map{|p|p[0].zip(*p[1..-1])===p}.any?

MATLAB - 75 98 bytes
Note: I didn't see that you had to output True or False, so I had to create an additional cell array that stores these two choices then we choose from this array when we're done.

This is a rather brute-force solution.  This assumes that you have loaded A in as a character matrix and that A is symmetric in size (i.e. # of rows is equal to # of columns):
c={'False','True'};o=0;for k=perms(1:size(A,1))'o=o|sum(sum(A(k,:)==A(k,:)'))==numel(A);end,c{o+1}

The overall process is to first create a 2D array of all possible permutations that goes from 1 up to as many words as we have N.  Each row of this matrix gives you a permutation enumerated from 1 up to N, and we can check either the number of rows or columns for the value N.  Next, we go through every possible permutation and rearrange the matrix A's rows based on the permutation vector produced by that permutation.  For example, if N=4, and if we had [1,4,2,3] as  the permutation vector, it would rearrange the matrix A so that row 1 of the original matrix A appears first, followed by row 4 of the original matrix A appearing second, row 2 of the original matrix A appearing third and finally row 3 of the original matrix A appearing last.
The above problem is essentially checking to see that if we all of these matrix rearrangements for A over all possible permutations, we check to see if this rearranged matrix is equal to its transpose.  In order to facilitate this, I do an element-by-element equality check of the characters, and sum over this result.  If the sum is equal to the total size of the matrix, then we have a true result.  This code will check all possible permutations, even if we have found a match before we exhaust all possibilities.  The statement o=0 is an indicator variable o that tells us whether we have found the condition being true or false.
Inside the loop, we keep updating o and checking for the above summation condition by logical ORing with the current result and with the current rearranged matrix condition.  It will be set to true if we have found such a condition or it gets to 1, and will stay false if we don't, or stays at 0.
Minor Note
The for loop behaviour is rather undocumented, but if you specify a matrix to be what is iterating over the for loop, each value k would be a column of the said matrix.  For example, if we did:
B = [0 0 0 0; 1 1 1 1; 2 2 2 2; 3 3 3 3];
for k = B
    disp(k);
end

We would select out the first column of B, display it, then the next column of B, display it, etc... so you would get a series of [0,1,2,3]'s.

Example Runs
>> A = ['FILE'; 'ICED'; 'LEAD'; 'EDDY'];
>> c={'False','True'};o=0;for k=perms(1:size(A,1))'o=o|sum(sum(A(k,:)==A(k,:)'))==numel(A);end,c{o+1}

ans =

    True

>> A = ['FILE'; 'LEAD'; 'EDDY'; 'ICED'];
>> c={'False','True'};o=0;for k=perms(1:size(A,1))'o=o|sum(sum(A(k,:)==A(k,:)'))==numel(A);end,c{o+1}

ans =

    True

>> A = ['OGRE'; 'GAIA'; 'RIGS'; 'EASY'];
>> c={'False','True'};o=0;for k=perms(1:size(A,1))'o=o|sum(sum(A(k,:)==A(k,:)'))==numel(A);end,c{o+1}

ans =

    True

>> A = ['CAMP', 'AXEL', 'MEMO', 'PLOW'];
>> c={'False','True'};o=0;for k=perms(1:size(A,1))'o=o|sum(sum(A(k,:)==A(k,:)'))==numel(A);end,c{o+1}

ans =

    True

>> A = ['SPASM', 'PASTA', 'ASPEN', 'STEEL', 'MANLY'];
>> c={'False','True'};o=0;for k=perms(1:size(A,1))'o=o|sum(sum(A(k,:)==A(k,:)'))==numel(A);end,c{o+1}

ans =

    True

Just to be sure, here's an example of where it shouldn't work:
>> A = ['CBMP'; 'APEL'; 'MCTO'; 'DLOX'];
>> A

A =

CBMP
APEL
MCTO
DLOX

>> c={'False','True'};o=0;for k=perms(1:size(A,1))'o=o|sum(sum(A(k,:)==A(k,:)'))==numel(A);end,c{o+1}

ans =

    False

Mathematica (48 42 bytes)
Or@@(#==#&/@Characters@Permutations@#)&

Luckily Transpose can be represented by a single unicode character.

 is this the character for transpose? I found a different one on wolfram's website

Yes, U+F3C7. But it actually doesn't render correctly on my system. Copy&Pasting the code however works fine.

JavaScript ES6, 90 58 bytes
s=>s.every((l,i)=>s.map(p=>p[i]).join``==l)?'True':'False'

Old answer:
s=>~(n=s.split`
`).map((l,i)=>n.map(p=>p[i*2]).join` `==l).indexOf(!1)?'False':'True'

The newline is significant and counts as a byte.

ES5 Demo:

function t(s) {
    return ~(n=s.split('\n')).map(function(l,i){return n.map(function(p){return o=p[i*2]}).join(' ')==l}).indexOf(!1)?'False':'True'
}

// Demo
document.getElementById('go').onclick=function(){
  document.getElementById('output').innerHTML = t(document.getElementById('input').value)
};

Word Grids Snippet

<textarea placeholder="Text here..." style="resize:none;width:70px;height:70px;border:1px solid #DDD;" id="input"></textarea><button id='go'>Run!</button>

Output:

Note: The code snippet will only return true if there is a single space between each letter in the code grid, as in the OP examples.

05AB1E, 11 bytes
øQi”‰¦”ë”žä

Try it online.
Explanation:
ø        # Zip the (implicit) input, swapping columns and rows
 Q       # Check if it is equal to the (implicit) input
         # That's it, we're done.. If it weren't for the requirement of explicitly
         # outputting the strings "True"/"False" instead of a truthy/falsey result..

i        # If the result is 1 (truthy):
 ”‰¦”    #  Output "True"
ë        # Else:
 ”žä     #  Output "False"

See here to understand why ”‰¦” is True and ”žä is False.

11 bytes alternative:
øQ”žä‰¦”#sè

Try it online.

Java (OpenJDK 8), 134 bytes
a->{int b=a.length,i=0,j=0;for(;i++<b;){for(;j<b;j++){if(a[j].length()!=b||a[i].charAt(j)!=a[j].charAt(i))return false;}}return true;}

Try it online!
Explanation:
int b=a.length,i=0,j=0;                               //Create Variables
for(;i++<b;){for(;j<b;j++){                           //Nested Loop
if(a[j].length()!=b||a[i].charAt(j)!=a[j].charAt(i))  //Is the grid valid?
    return false;                                     //if not, return false
}}
return true;                                     //if it gets this far, return true

Is this work with "The words can be given in any order." rule?

PowerShell, 93 bytes
param($a)"$($a|%{$n++;''+($_|% t*y|sort)}|sort)"-eq"$(0..--$n|%{''+($a|% ch* $_|sort)}|sort)"

Try it online!
Unrolled:
param($a)

$x=$a|%{
    $n++                                # number of words
    $letters = $_|% toCharArray|sort    # sorted letters of the current word $_
    ''+$letters                         # convert the letters to a string
}|sort

$y=0..--$n|%{
    $letters = $a|% chars $_|sort       # sorted letters of all words in the $_ position
    ''+$letters                         # convert the letters to a string
}|sort

Write-Output ("$x"-eq"$y")              # convert both arrays to strings, compare them and return a result

Burlesque, 35 bytes
ln)wdr@{Jtp==}ay{"True"}{"False"}IE

Try it online!
Core calculation is 11 bytes. Most of the cost is in parsing the word square (5 bytes) and outputting true or false rather than 1/0 (19 bytes)
ln                   #Split by newlines
)wd                  #Map split by spaces
r@                   #Permutation by words
{
 Jtp==               #If the transpose is the same
}ay                  #Any
{"True"}{"False"}IE  #Print "True" or "False" accordingly

all_licenses: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/3.0/


text:
Code close to the challenge: Sum of integers
This is a simple challenge:
Given a sequence of integers, find the sum of all integers in it.
But with a twist.
Your score is the Levenshtein distance between your code and the following phrase (The challenge):

Given a set of integers, find the sum of all integers in it.

You may assume there are no newlines or trailing spaces in the input.
Example input/output:
Input: 1 5 -6 2 4 5
Output: 11
Input: 1 -2 10
Output: 9

An online calculator for Levenshtein distance can be found here: http://planetcalc.com/1721/

I can't help but think of this

I edited it so that it can be a function. Don't know why I put that it :P

So functions are allowed?

Functions are allowed, yes.

Wow, so much creativity guys xD... cough comment abusers cough

Do you think this should have a sequel with another challenge but same Levenshtein distance principal? Not sure if this is considered sequel-worthy or not.

@NicoA definitely! Maybe the only problem is that this task was too easy.

I might even make comments not allowed because you can just place a comment in with the challenge and then after that it just becomes a code golf competition.

@NicoA If you do, be very careful in defining what's not allowed. Many languages allow raw strings to float around, for instance.

Your examples make clear that you don't mean "set of integers" but rather "sequence of integers": you sum both occurences of "5" in your second example. Now there are already dozens of rated solutions so it's not really feasible to change the metric. But maybe at least change the actual text of the task?

Python, distance 3
#Given a set of integers, find the
sum#of all integers in it.

This gives the built-in function sum, which can sum a set like sum({3,5,7})==17. The remaining parts are commented. This has distance 3, with 3 edits:

Add the initial #
Add a newline
Replace the space after sum with #

Another useful feature of the wonderful English-like syntax

My only question is how to use it since this isn't a full program, and (in theory) you don't even need in your code because it is a built in

@BetaDecay This works because of the rules that functions are allowed by default and that function literals are allowed for functions.

Julia, distance 27 26
No comments!
Given(a)=(Set;of;integer; find; [sum(a),all,integer,in][1])

This creates a function called Given that accepts an array and returns the sum of its elements. Since a lot of Julia builtins have relevant names (but are irrelevant to the calculation here), we can just list a few delimited with semicolons. As long as they aren't the last thing listed, they won't be returned. The last part actually makes an array containing the sum and three functions and selects the first element, the sum.

No comments is definitely more within the spirit of the challenge. Good job.

@ChristopherWirt Thanks! :)

Might I suggest an improvement? Given=(a;set;of=integer; find;th;[sum,of,all,integer, in][]) - "Given" then still works the same, but this has a distance of 18.

APL, distance 6 3
Saved 3 distances...? thanks to Dennis!
+/⍝en a set of integers, find the sum of all integers in it.

This sums a given array (+/). The remainder of the sentence is added to the end using a comment (⍝).

You don't need { and ⍵}. +/ is already a valid function.

@Dennis Awesome, thanks so much for the suggestion!

R, Distance 37 36 34
Without using comments :)
 as.integer ( sum (scan(,integer( ) )))

Note there is a space at the beginning.

GolfScript, 5
~{Given a set of integers+ find the sum of all integers in it}*

This a full program that uses no comments (but a lot of noops).
Try it online in Web GolfScript.

Mathematica, distance 17
Given a set of integers find the sum of all integers in it*0+Total@Input[]

It doesn't use any comments or no-ops, but instead declares all of the words as variables, and then gets rid of them by multiplying by zero.
It also has the benefit of being the only answer that actually takes a set of integers as its input.
The input {1,2,3} provides the output 6 as expected.
Unfortunately, the Mathematica Sum function doesn't do the task in the question, therefore necessitating a larger number of bytes.

Given a set of integers find the sum of all *0+Total@Input[] distance 14

RProgN, Distance 2.
Given aset of integers, ;find the sum of all integers in it.

In RProgN, a, set, find and sum are all commands. Everything else is per default ignored in syntax. a pushes the alphabet to the stack, which will cause sum to fail. Set never has enough arguments, so always fails, erroring. Find either has the wrong number of arguments, or tries to compare the alphabet with the input stack, which doesn't work.
a and set can both be 'fixed' by removing the space between then, aset is not a function, so it's ignored. Find just has an extra character inserted at the start, causing it also to not be recognized, and ignored. Only sum is left, which conveniently sums the contents of the input stack.
Finally, RProgN might win something!
Try it Online!

Java - 43 41
I tried.
float a_set_of(int[] r){return IntStream.of(r).sum()}//n it.
Given a set of integers, find the sum of all integers in it.

Java :P.

I think you can change your argument in the function from a to r to save one edit distance.

@Element118 Nice catch. Also changed the return type while I was at it to have the method name line up better.

couldnt you use " int  a_" as the beginning of the snippet? (one space before the int and 2 after it before the a_

Matlab, distance 29 28
Given_a_set_of_integers=@(findthe)sum(all(1)*findthe)

Without using any comments :-)
The code is in the form of an anonymous function. I'm assuming the input is a vector (1D-array) of numbers.
Example:
>> Given_a_set_of_integers=@(findthe)sum(all(1)*findthe)
Given_a_set_of_integers =
    @(findthe)sum(all(1)*findthe)

>> Given_a_set_of_integers([1 5 -6 2 4 5])
ans =
    11

F#, distance 21
let ``Given a set of integers, find the sum of all integers in it`` x = Seq.sum x

Gotta love the ability to use double ticks to give a function a name with spaces in it.
Usage:
[1;2;3] |> ``Given a set of integers, find the sum of all integers in it`` |> printfn "%i"

6

Wait, do people actually do this?

CJam, 7 6 5
{:+}e# a set of integers, find the sum of all integers in it.

This is an anonymous function that pops an array from the stack and leaves an integer in return.
Thanks to @AboveFire for shortening the distance by 1.
Try it online.

Cubix, Distance 9
@ivOn a ;et I+ i?tegers, fu;d <he sum of all integers in it.

Try it online!
This wraps onto the cube
      @ i v
      O n a
      ; e t
I + i ? t e g e r s , f
u ; d < h e s u m o f a
l l i n t e g e r s i n
      i t .
      . . .
      . . .

The operative code is

I+i Input a integer,add to TOS then input a character
? Test character value.  Redirect left for -1 (end of input) or right for anything else (0 can't be input)

;O@ pop TOS, output sum and exit
<;u redirect, pop TOS and u-turn onto the start

Vyxal 3, distance 1
Given a set of integersṠ, find the sum of all integers in it.

Try it Online!
Prints a singleton number.
Explanation
Given a set of integersṠ, find the sum of all integers in it.
G                                                              ## Get the max element
 i                                                             ## index
  ve                                                           ## Is odd? (decrement, Is even?)
    n                                                          ## Push "abcdefghijklmnopqrstuvwxyz" anyway
      a                                                        ## Is the alphabet truthy? (Always)
        s                                                      ## Split! I don't know how can you split a bool with 1...
         e                                                     ## Is this even?
          t                                                    ## Get the last element (How can you do it with a bool?)
            o                                                  ## Overlap (How??)
             f                                                 ## Flatten (Already Flattened??)
               i                                               ## Index with input again
                n                                              ## Also, push "abcdefghijklmnopqrstuvwxyz" anyway
                 t                                             ## Get the last element ("z")
                  e                                            ## Split on newlines ("z" has no newlines, so pop and push ["z"])
                   g                                           ## Never gonna <g>ive you up. (I don't understand what this does anyway)
                    e                                          ## Split on newlines (Again? This time, it doesn't wrap)
                     r                                         ## replace this with input?
                      s                                        ## split with itself?
                       Ṡ                                       ## SUM!
                        ,                                      ## PRINT!
                          find the sum of all integers in it.  ## I give up. This doesn't do anything.

Created with the help of Luminespire.

K, 60 5
+/ / Given a set of integers, find the sum of all integers in it.

I'm guessing symbols do NOT go nicely with the Leve-whatever distance...
Hahaha. Originally, I had no what the LeveXXX distance was, so I got 60. Then, thanks to helpful comments, it dropped to 5.

Its not that you're using symbols, Levenshtein distance is #of additions, deleteions, substitutions. so you have 60 deletetion from the original string.

Its not symbols, its just that your code is so short that the length of the phrase - the length of your code = 60. Ouch.

You know you can just scroll up to get the correct spelling of "Levenshtein," right? ;)

@AlexA. It's funnier this way. :)

I don't blame him. I had to check the spelling about 10 times before I just copy-pasted it.

O, 5
M]+o"Given a set of integers, find the sum of all integers in it.
Numbers must be in hexadecimal and in reverse negative notation:

-6 => 6_
-4 => 4_
-10 => A_

Try it online

Yay the link works!

Nice demo! Isn't calling it an IDE kind of overkill, though?

@kirbyfan64sos Totally, but I want to add more features like syntax highlighting and whatnot. For now, it's just an interpreter.

I think a link to the O esolangs page would be more useful.

@mbomb007 But that's horribly out of date; half the things on there don't work, and that's only a little bit of the language documented.

@phase Oh, I didn't know. I also missed the additional tabs for the specifications on the website.

Pip, distance 3
Joining the club of trivial no-comments-but-lots-of-no-ops golflang answers...
Given a set of integers, find the sum of all integers in $+g

GitHub repository for Pip
The code practically documents itself; maybe s/in/using/ for a more accurate description. Integers given as command-line arguments are read into the list g, which is here folded on addition and the result auto-printed. Most everything else is just variables, which are no-ops.
I was a bit surprised at first that s, f worked without complaining, since f refers to the main function and taking the range of a code block doesn't make sense. But then I realized: the , range operator, when given a function argument, just constructs another function (as do many operators in Pip). So I think s, f evaluates to {Given a set of integers, find the sum of all integers in " ",$+g}. (Which is then discarded anyway.)
One final point: this code works with the current version of Pip, in which I haven't assigned G to anything yet. If in some future version I make G a binary or ternary operator, then a distance-4 version would be necessary. Using given instead of Given would work nicely.

Haskell, distance 11
No comments!
const sum"Given a set of integers, find the sum of all integers in it."

Usage:
> const sum"Given a set of integers, find the sum of all integers in it." $ [1..10]
55

Pyth - 4
Just puts the actual code, sQ in front of the string no-oped by a space.
sQ "Given a set of integers, find the sum of all integers in it.

Try it online here.

PHP4.1, distance 25
This one is a pretty long one and really late in the run.
But anyway, here it is:
<?=$n_a_set_of_integers_fi=array_sum($f_all_integers_in_i);

For this to work, you just need to pass it an array over POST/GET/COOKIE/session, using the key f_all_integers_in_i.

No comment trolling yay!

Pyt, distance 1
Given a set of integers, find the Ʃum of all integers in it.

All alphanumeric characters are no-ops in Pyt, and the sum of a list only takes one character: Ʃ
Try it online!

C++17, distance 44 29
Variadic Generic Lambda FTW
[](auto...t){return(t+...);}//the sum of all integers in it.

Previous solution
template<class...t>int s(t...l){return(...+l);}//gers in it.

05AB1E, distance 3
#O,Given a set of integers, find the sum of all integers in it.

Try it online!

Excel VBA, Distance: 11
Anonymous VBE immediate window function that takes input from the range [a:a] on the ActiveSheet object and outputs to the VBE immediate window
?[Sum(a:a)] 'f integers, find the sum of all integers in it.

Brain-Flak, 20
(([]){[{}]{}([])}{})ers, find the sum of all integers in it.

Try it online!
Explanation
Since there are no parentheses in the original text this boils down to a code-golf problem in Brain-Flak.  But that still doesn't make this answer trivial, as answers in Brain-Flak rarely are.
One's first intuition would probably be the following code
({{}})

Which works ... unless there is a zero on the stack in which case it just sums until the zero.  To get around this problem we have to use a stack height to check that the stack is not empty.  This can be set up like this
([])    #{ Push stack height }
(       #{ Start Push }
{       #{ Loop until zero }
 <{}>   #{ Silently Pop the last height }
 {}     #{ Grab a value from the stack }
 <([])> #{ Silently push the stack height again }
}       #{ End loop }
{}      #{ Remove last stack height }
)       #{ Push the result }

This one works, but there is something wrong with it.  We keep silencing the pops and the pushes in the loops but they are almost equal so there should be a way to cancel them out.  If we try
([])({[{}]{}([])}{})

We end up off by n each time.  So here's the trick, we already have an n siting around, we just move it into the push to balance things out.
(([]){[{}]{}([])}{})

Just wanted to congratulate you on your 2^8th ppcg answer

Pyke, Score 3
sK"Given a set of integers, find the sum of all integers in it.

Try it here!

Ly, score 4
&+#Given a set of integers, find the sum of all integers in it.

Note the trailing newline.
Try it online!
The code is pretty self-explanatory. &+ is Ly's summing operator, while # is a comment. It's unfortunate that I have to include a trailing newline due to the fact that ending a program with a comment line will "comment out" Ly's implicit output, which is actually a bug in the interpreter that  I'm calling a feature.

dc, 14
?[+z1 <f]d  sf xp#egers, find the sum of all integers in it.

comments:
?                   # read numbers
 [                  # start macro
  +                 # add up last two things on stack
   z1 <f            # if stack size is more than 1, execute macro at register 'f'
        ]           # end macro
         d          # dupe it
            sf      # saving one copy to register 'f'
               x    # and executing another
                p   # printing result

TIO
it complains about the stack being empty if you enter 1 number, but still works, and removal of 0 saves 2 diff.

Ahead, 17
>jLIve>   K+O @f integers, find the sum of all integers in it.
^ >j<l

Try it online!

Jelly, Distance: 2
Given a set of integers, find the sum of all integers in it.
S

Try it online!
Jelly only evaluates the main link (the last line) and explicit commands will run other links (other lines).
The last line has S, which sums the input.
The first line does not get executed because there is no reference to it in the main link.

Snap! 4.2.2.9 (+ Tools), scratchblocks3 syntax, distance 35
This is a function. integers, find the sum of all inte is the input.
for each(et)of(integers, find the sum of all inte
change[s v]by(et
end
report(s

How does this take input?  Is input supposed to be pasted into the code?  Usually we do not allow that sort of input but rather require that input is either taken from STDIN or if your submission is a function, that it is passed as an argument.

No, it is a function. integers, find the sum of all inte is an argument, it just isn't distinguished from regular variables in scratchblocks3 syntax, which is why I clarified

05AB1E, distance 2
O,Given a set of integers, find the sum of all integers in it.

Try it online!
O,...  # trimmed program
 ,     # output...
O      # sum of...
       # implicit input...
 ,     # explicitly to prevent the fatal error from stopping implicit output
  ...  # no-op as implicit output has been canceled by the print command and the rest of the code doesn't contain any more print commands

In case you're curious, the error occurs because of G, and because the item on top of the stack is a list. G is a loop, looping the variable N through the list [1, 2, 3, ..., top of stack - 1]. Since , pops the item on top of the stack before printing, G has no arguments to use and instead uses implicit input. Since you can't subtract a number from a list, it errors.
Alternatively, replacing the second character (,) with one of these, combined with optionally removing the G, will also work:
?  # erroring solution - with G
=  # non-erroring solution - with G
,  # non-erroring solution - without G
?  # non-erroring solution - without G
=  # non-erroring solution - without G
D  # non-erroring solution - without G

AWK, distance 15
 i+=$ a set of integers{ find the sum of all inte}END{print i}

Attempt This Online!
Takes numbers separated by newlines from stdin, and prints the sum.
AWK allows referencing undefined variables. They default to 0 in numeric context and "" (empty string) in string context. AWK also has string concatenation x y, which makes large part of the code valid no-ops.
The sum is stored in i because int i} and in it. has distance 1 lower than using any other variable, but it ends up with 1 higher distance somewhere else...

Uiua, distance 3
/+#en a set of integers, find the sum of all integers in it.

Test pad (the formatter sucks)

Go, score 48, 63 bytes
func( a...int) int {e:=0;for _,h:=range  a{     e+=r};return e}

Attempt This Online!


text:
Counting from 1 to an Integer… in Binary
Intro:
I remember, when I was a kid, I would get a calculator and keep on pressing the + button, and see how high I could count. Now, I like to program, and I'm developing for iOS.
Counting is a fundamental skill for both humans and computers alike to do. Without it, the rest of math can't be done. It's done simply by starting at 1 and repetitively adding 1 to it.
The challenge:
This is but a simple challenge. What I would like your program to do is print from 1 to whatever Integer it takes in. However, I'll throw a twist in it, since decimal counting is kinda boring:
The counting cannot be in base 10, it has to show itself counting in binary.
So, to count to 5, using 32-bit integers, it would look like this:
0000 0000 0000 0000 0000 0000 0000 0001 ..... 1
0000 0000 0000 0000 0000 0000 0000 0010 ..... 2
0000 0000 0000 0000 0000 0000 0000 0011 ..... 3
0000 0000 0000 0000 0000 0000 0000 0100 ..... 4
0000 0000 0000 0000 0000 0000 0000 0101 ..... 5

It's a computer. They know binary best. Your input can be either a 32-bit or 64-bit integer. It is truly up to you. However, if you use 32-bit integers, your output must be 32-bit integers in binary, and if you use 64-bit integers, your output must be 64-bit integers in binary.
Sample input:
a 32-bit integer, 5
Sample output:
0000 0000 0000 0000 0000 0000 0000 0001
0000 0000 0000 0000 0000 0000 0000 0010
0000 0000 0000 0000 0000 0000 0000 0011
0000 0000 0000 0000 0000 0000 0000 0100
0000 0000 0000 0000 0000 0000 0000 0101

Scoring:
Your score is equal to however many bytes your code is. As this is Code Golf, lowest score wins.
Bonus points:
If you show, in the output, the number it's at as a base 10 number (for example, 0000 0000 0000 0000 0000 0000 0000 0001 in binary is equal to the base 10 1), multiply your score by 0.8.
If you group 4 digits of output like I did, then multiply your score by 0.8 (again). This isn't required.
Do not round up, and do not round down. Your score is a floating-point number.
Good luck!

Do you have to put the digits in chunks of four separated by spaces?

@xnor No. I did for readability, but I will include a bonus opportunity for that as well.

What if I use a data type that is of unbounded size (Python 3's int for instance)?

@isaacg Specify whether your program uses 32 or 64-bit integers. You don't have to accommodate for those integers that are out of bounds; you only have to output what you input. In other words, the choice is yours.

@DDPWNAGE Now I understand, thanks.

What if our langauge uses something different, like 30 bit integers (Haskell) or arbitrary precision integers (J)?

@FUZxxl try to make a 32-bit integer. If you can't, use 30, but output 30

Do we care about signed or unsigned?

@GeorgeReith as the length of the bits doesn't change between signed and unsigned, no.

Suggest changing the title to "Counting from 1 to an Integer in Binary".

I thought you kept pressing the = button after pressing 1+.

APL, 10 characters
Another on in APL. Assumes⎕IO←1 (the default). No bonus points. Reads the number from the input device. If your APL uses 64 bit integers instead of 32 bit integers, substitute 64 for 32 as needed.
Notice that APL transparently converts to floating point numbers when the range of an integer is exceeded. It's hard thus to exactly say what integer size APL works with.
⍉(32⍴2)⊤⍳⎕

explanation
2          ⍝ the number 2
32⍴2       ⍝ a vector of 32 twos.
(32⍴2)⊤X   ⍝ X represented as base 2 to 32 digits precision
⍳X         ⍝ a vector of the integers from 1 to X
⎕          ⍝ a number queried from the terminal
(32⍴2)⊤⍳⎕  ⍝ the output we want, flipped by 90°
⍉(32⍴2)⊤⍳⎕ ⍝ the output we want in correct orientation (⍉ is transpose)

looks like I shouldn't have tried so hard to get the 4 groupings haha

@protist Don't try to get bonus points that are too hard to implement. It's almost never worth the effort.

The question specifically asked for a byte count rather than character so, the score should be 20 bytes.

@dohaqatar7 There are encodings of APL (like codepage 907) that fit the entire APL character set into one byte. There are some APL extensions that cannot be encoded with the traditional APL code pages, but I don't use any of them.

JavaScript (ES6) 56.8 (71*0.8)
32 bit version, as JavaScript can not handle 64 bit precision (at most 53 bits using floating point doubles)
Without grouping
f=n=>{for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).slice(1),i)}

With grouping - score 60.16 (94*.64)
f=n=>{for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).slice(1).match(/..../g).join` `,i)}

Test in any browser (ES5)

function f(n)
{
  for(i=0;i++<n;)console.log((8*(8<<26)+i).toString(2).substr(1).match(/..../g).join(' '),i)
}

// Test
console.log = function(x,y) { O.innerHTML += x+' '+y+'\n' }
Count to: <input id=I><button onclick="O.innerHTML='';f(+I.value)">-></button>

Pyth, 18 * 0.8 * 0.8 = 11.52 bytes
VSQjd+c.[64.BN\04N

Example output:
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1001 9
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 1010 10

@DDPWNAGE Give other people some time to compete before accepting an answer :)

Alright, I was thinking about temporarily accepting it, so people know what to beat.

@DDPWNAGE Remember that you can't easily unaccept an answer after you accepted an answer and waited for a few hours.

Pyth, 19 * 0.8 * 0.8 = 12.16 bytes
VSQjd+cjk.[032.BN4N

Example output for input 5:
0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5

Demonstration.

Python 2, 48 * 0.8 = 38.4
i=0;exec"i+=1;print format(i,'032b'),i;"*input()

Converts a number to binary, uses string formatting to convert it to binary with 32 digits, and then also prints the decimal number for the bonus. Uses an exec loop to increment from 1 to the input value.

Nice solution! I don't believe it was specified, but this will fail on large numbers in the 32-bit range: OverflowError: repeated string is too long. Not sure if that's a limit on just my machine though.

CJam, 13.44 (21 × 0.64)
ri{)_2b64Ue[4/S*S@N}/

Try it online.

APL, 23.68 (37 × .8 × .8)
{⎕←(⍕⍵),⍨⊃,/,/' ',⍨⍕¨8 4⍴(32⍴2)⊤⍵}¨⍳⎕

KDB(Q), 50 * 0.8 * 0.8 = 32
I feel a bit sad with my submission :( There should be a better way to do this!
{-1{" "sv raze@'string(0N 4#0b vs x),x}@'1+til x;}

Explanation
                                         1+til x     / counting
   {                                  }@'            / lambda each
                      (0N 4#0b vs x),x               / convert to binary and join with input
    " "sv raze@'string                               / convert to string, concatenate each string and join with space
{-1                                             ;}   / print and surpress output in lambda

Test
q){-1{" "sv raze@'string(0N 4#0b vs x),x}@'1+til x;}5
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0000 0101 5

well you can drop into K ;)
k){-1{" "/:,/'$:(0N 4#0b\:x),x}@'1+!x}

Common Lisp, 96.0
Score: (* 150 .8 .8)
(lambda(y)(flet((p(n &aux(x(format()"~39,'0b ~:*~d"n)))(dolist(p'(4 9 14 19 24 29 34))(setf(aref x p)#\ ))(princ x)(terpri)))(dotimes(i y)(p(1+ i)))))

Example
Calling the function with 10:
0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 1001 9
0000 0000 0000 0000 0000 0000 0000 1010 10

Explanation
(format()"~39,'0b ~:*~d" #b101010101010) gives:
"000000000000000000000000000101010101010 2730"

The intermediate string (an array) is modified to put a space character  at the following zero-based indices: 4 9 14 19 24 29 34. Then it is printed.
Note that the apparently straightforward (format t"~39,'0,' ,4:b ~:*~d" #b101010101010) format does not do what we want. It prints:
00000000000000000000000001010 1010 1010 2730

(the padding is not grouped by 4)

C, 97 * 0.8 * 0.8 = 62.08
a,x;main(b){for(scanf("%u",&b);a++>x&1);}

Example output for input "5":
0000 0000 0000 0000 0000 0000 0000 0001 1
0000 0000 0000 0000 0000 0000 0000 0010 2
0000 0000 0000 0000 0000 0000 0000 0011 3
0000 0000 0000 0000 0000 0000 0000 0100 4
0000 0000 0000 0000 0000 0000 0000 0101 5
0000 0000 0000 0000 0000 0000 0000 0110 6
0000 0000 0000 0000 0000 0000 0000 0111 7
0000 0000 0000 0000 0000 0000 0000 1000 8
0000 0000 0000 0000 0000 0000 0000 1001 9

I could add one more whitespace character to separate the decimal numbers from the binary numbers, but technically the problem doesn't require it, I think? EDIT: Thanks, CL!

Incidentally you can replace x%-4-1 with x%-4-2 to add the space between the binary and decimal for no extra byte cost. (This would also get rid of the extra space at the beginning of each line.)

Ruby, 28 (35 * 0.8)
?1.upto(*$*){|x|puts"%.32b #{x}"%x}

Octave, 23 characters
dec2bin(1:input(""),32)

Example output for input 5:
ans =
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

Julia, 42 bytes
This is a bit shorter without the bonuses.
n->for i=1:n println(lpad(bin(i),64,0))end

This creates an unnamed function that takes an integer and prints the binary representation of each number from 1 to n, each left padded with zeros to 64 characters.

With bonuses, 78 bytes * 0.8 * 0.8 = 49.92
n->for i=1:n for j=1:4:64 print(lpad(bin(i),64,0)[j:j+3]*" ")end;println(i)end

This creates an unnamed function that takes an integer and prints the binary representation as before, this time split into groups of 4 with the number in base 10 at the end.

MatLab, 19 bytes
@(x)dec2bin(1:x,32)

Not too much to this one, MatLab has a built in decimal to binary converter and automatically prints the result.

This doesn't print 32-bit / 64-bit integers.

Sorry, thanks for the heads up. I have changed the code accordingly.

This answer is almost entirely identical to the Octave answer.

Common Lisp, score: 64.0
100 bytes * 0.8 * 0.8
I'm pretty happy with my score, but I still feel like there should be a possibility to simplify my code a bit.
Output
0000 0000 0000 0000 0000 0000 0000 0001  1
0000 0000 0000 0000 0000 0000 0000 0010  2
0000 0000 0000 0000 0000 0000 0000 0011  3
0000 0000 0000 0000 0000 0000 0000 0100  4
0000 0000 0000 0000 0000 0000 0000 0101  5
0000 0000 0000 0000 0000 0000 0000 0110  6
0000 0000 0000 0000 0000 0000 0000 0111  7
0000 0000 0000 0000 0000 0000 0000 1000  8
0000 0000 0000 0000 0000 0000 0000 1001  9
0000 0000 0000 0000 0000 0000 0000 1010  10

Code
(defun r(n)(dotimes(i n)(format t"~{~a~a~a~a ~}~a~%"(coerce(format()"~32,'0B"(1+ i))'list)(1+ i))))

Explanation
As described in coredump's answer, the format string
"~32,'0B"

does output base2 numbers but there seems to be no possibility to get the grouping right as well. Hence I coerce the string into a list and iterate over it by picking out groups of 4 with this format string:
"~{~a~a~a~a ~}~a~%"
After each group of 4 there's a blank, and after the last group, the base10 number is printed.
Without grouping (60x0.8 => 48.0)
(defun r(n)(dotimes(i n)(format t"~32,'0B ~:*~a~%"(1+ i))))

This uses ~:* to process the (single) format argument again.

PHP, 51.84 (81 × .8 × .8)
32-bit version, as PHP is limited to only 32-bit on Windows regardless of whether the OS is 64-bit.
Takes one command line argument.
for($i=0;$i++<$argv[1];)echo chunk_split(str_pad(decbin($i),32,0,0),4," ")."$i\n";

CoffeeScript, 60.8 (76 × .8)
32-bit version for reasons mentioned above, as CoffeeScript compiles down to JavaScript.
f=(x)->console.log(("0".repeat(32)+i.toString 2).slice(-32),i)for i in[1..x]

With grouping it becomes slightly longer: 64.64 (101 × .8 × .8)
f=(x)->console.log(("0".repeat(32)+i.toString 2).slice(-32).match(/.{4}/g).join(" "),i)for i in[1..x]

Haskell, 56 bytes
f n=putStr$unlines$take n$tail$sequence$replicate 32"01"

Usage:
*Main> f 5
00000000000000000000000000000001
00000000000000000000000000000010
00000000000000000000000000000011
00000000000000000000000000000100
00000000000000000000000000000101

For 64bit, replace the 32 with 64. Every other number works, too.

J, 20 bytes
(32#2)#:>:i.".1!:1<1

Sample input and output:
3
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 1

Swift: 98.56 (154 * 0.8 * 0.8)
for x in 1...Int(Process.arguments[1].toInt()!){var p=String(x,radix:2)
let q=count(p)
for i in 0..<32-q{p=(((q+i)%4==0) ?"0 ":"0")+p}
println("\(p) \(x)")}

Ruby, 64 bit
70 * 0.8 * 0.8 = 44.8 bytes (split, decimal)
1.upto(gets.to_i){|i|puts ("%064d"%i.to_s 2).scan(/.{4}/)*?\s+" #{i}"}

51 * 0.8 = 40.8 bytes (decimal)
1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2)+" #{i}"}

67 * 0.8 = 53.6 bytes (split)
1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2).scan/.{4}/}

44 bytes (no bonuses)
1.upto(gets.to_i){|i|puts "%064d"%i.to_s(2)}

05AB1E, 13 11 bytes
Lb32jsäð0:»

-2 bytes thanks to @Mr.Xcoder.
Outputs without space-delimiter nor sequence-number.
Try it online.
Explanation:
L              # List of range [1,input]
               #  i.e. 5 → [1,2,3,4,5]
 b             # Convert each to a binary string
               #  i.e. [1,2,3,4,5] → ['1','10','11','100','101']
  32j          # Join everything together with a minimum length per item of 32,
               # which basically prepends spaces to make it length 32
               #  i.e. ['1','10','11','100','101'] → '                               1                              10                              11                             100                             101'
     sä        # Split it into the input amount of parts
               #  i.e. 5 → ['                               1','                              10','                              11','                             100','                             101']
       ð0:     # Replace every space with a 0
               #  i.e. '                             101' → '00000000000000000000000000000101'
          »    # Join everything together by newlines (and output implicitly)

Lb32jsäð0:» works for 11 bytes

@Mr.Xcoder Thanks, completely forgot about using j to prepend so it becomes the correct length.

Japt -R, 6 bytes
õÈ¤ùTH

Try it
õÈ¤ùTH     :Implicit input of integer
õ          :Range [1,input]
 È         :Map each X
  ¤        :  To binary string
   ù       :  Left pad
    T      :    with 0
     H     :    to length 32
           :Implicit output joined with newlines

With bonuses, 8.96 bytes
õÈ¤ùTH ò4 pX ¸

Try it
õÈ¤ùTH             :As above
       ò4          :Partitions of length 4
          pX       :Push X
             ¸     :Join with spaces

JavaScript, 50 bytes
f=n=>n&&print(n.toString(2).padStart(32,0,f(n-1)))

Try it online!
With first bonus, 41.6 bytes
f=n=>n&&print(n.toString(2).padStart(32,0,f(n-1)),n)

Try it online!
With both bonuses, 44.8 bytes
f=n=>n&&print(...n.toString(2).padStart(32,0,f(n-1)).match(/.{4}/g),n)

Try it online!

Vyxal j, 7 6 5 bytes
vΠ₆↳›

Try it Online!
The benefits of having built-ins to pad things with spaces and to convert spaces to 0s. Uses 64 bit integers.
two can play at the flag game Japt.
Explained
vΠ₆↳›
vΠ      # Convert each number in the range [1, input] to binary
  ₆↳    # left pad each binary string with spaces so that it's length 32
    ›   # replace spaces with 0s
        # join on newlines because of `-j` flag