text:
Line-wrap into proper columns
Input will be one or more space separated characters followed by a long string on STDIN or as an argument when called from the shell.
a C
WAtcIaElCpVqDRavOUejlgumcRCpfIWlaRFZpIoPYsWjsBSdlYfitfAPHpemiLpjaHheUGpFVQoZCnSCFgvpVzcoibdffoPRoJJwLIjVicPCdcvITXaQDjtMgrxQMZCkZNFmNqwGQYaSyPpdLOkAVHGVoVBiIksZCQHEaIxcRGwpIAmlChuhGEDajeJVXoCwFFuIvhEoqMuwrCDmZPcQxeaqJjynGWVjSaCCxWfupDbbEEFufDyealmbLxKfwlWCsSXwpPtuayxNVCodeEjeCIeHBYioeTogujuUFlWydOwInWGbsvlSwlwgfQaAmNTWPjsgqSCGzsJYfqGklpeLujFyrZJmNymUzpXLTkZcyPgPakAXTTfKlnnTCkjxxSZltwnLMOUCxlHOtLIUTqcbejXqyrwQgMaPUKcHBDZwMrCgwfVZUzxbdODBbBqEbpFLUOcPpVmsgLnfMXRWaddGnK

Your task is to line-wrap the string at a suitable length so that there is at least one column completely filled by each input character. All lines should be wrapped to the same length (except possibly the last one if it's shorter.)

In this case, the solution could be wrapping at 50 characters giving the output
WAtcIaElCpVqDRavOUejlgumcRCpfIWlaRFZpIoPYsWjsBSdlY
fitfAPHpemiLpjaHheUGpFVQoZCnSCFgvpVzcoibdffoPRoJJw
LIjVicPCdcvITXaQDjtMgrxQMZCkZNFmNqwGQYaSyPpdLOkAVH
GVoVBiIksZCQHEaIxcRGwpIAmlChuhGEDajeJVXoCwFFuIvhEo
qMuwrCDmZPcQxeaqJjynGWVjSaCCxWfupDbbEEFufDyealmbLx
KfwlWCsSXwpPtuayxNVCodeEjeCIeHBYioeTogujuUFlWydOwI
nWGbsvlSwlwgfQaAmNTWPjsgqSCGzsJYfqGklpeLujFyrZJmNy
mUzpXLTkZcyPgPakAXTTfKlnnTCkjxxSZltwnLMOUCxlHOtLIU
TqcbejXqyrwQgMaPUKcHBDZwMrCgwfVZUzxbdODBbBqEbpFLUO
cPpVmsgLnfMXRWaddGnK

The fifteenth (a) and twenty-seventh (C) all form a single column of the given input characters.
The last line may or may not be complete.

There can be more than one solutions. Any one of them can be considered valid.
Returning the string as-is is NOT allowed. (For those claiming that it forms one-row columns). The columns of the input characters must have at least two rows. You may assume that the input string is longer than 10 characters.
If there is no possible solution, your program must indicate this in some way(return status, printing "no solution", etc.) which you must mention.
Input will only include [a-zA-Z]

This is code-golf

Here's the actual program(python) that I use to generate these strings.
import random

a = 10
b = 50

s = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
for i in xrange(a):
    c = ''
    for j in xrange(b):
        c += (random.choice(s))
    print c

I then rectangle-edit to get columns full of input characters and strip newlines, deleting random number of characters from the end of the last line.

Hummm... shouldn't you rather say: "at lease three rows"? Because the solution with 469 characters on the first line, a single character on the second line, has "at least two lines", and is valid according to your own example (see the C column in your own example, which is at the right of the end of the last line).

@ברוכאל Could you please elaborate what you are saying? abcdefghijklmnop newline azc is valid according to my criteria. The more than 1 input characters ensure that the algorithm is correct. That was just to prevent joke answers. By the way, WTF is wrong with your username?

Precisely, joke answers are still available. Take your 470 example, format it as "WAtcI... newline K". It is valid, has at least two lines, and you can find many columns with either 'a' or 'C'. I precisely understood that you wanted to prevent joke answers, but they are still possible and it was why I told about "at least three lines".

My exact wording is The columns of the input characters must have at least two rows

Out of curiosity, why do you import time for your generator program?

@undergroundmonorail Copy-paste left-over, fixed

GolfScript, 73 characters
n%(' '-:C;~:T,,1>{T/zip{.,1>*.&.,1=*}%''*C&C=},.{0=T/n*}{'no solution'}if

Breaks at the first position which is possible. The input must be given on STDIN in the format specified in the question.
Example (online):
X Y
abcdeXfYghijklmnXoYpqrstuvwXxYyzXYZ

abcdeXfYghi
jklmnXoYpqr
stuvwXxYyzX
YZ

Annotated code:
n%               # Split the input at newlines
(' '-:C;         # Extract the first line, remove all spaces
                 # and assign the resulting string to variable C
~:T              # Take the second line and assign this string
                 # to variable T
,,1>             # Makes an array [1 2 3 ... L-1] where L is the
                 # length of T
{                # A filter block {...}, selects all possible
                 # line wrap positions from this array
  T/             #   Test the current length by splitting T (input)
                 #   in pieces
  zip            #   Transpose the result (i.e. we now have a array
                 #   of strings representing the columns)
  {              #   For each column
    .,1>*        #     Is the length greater than one, then keep the column
                 #     else transforms it to the empty string (string * 0)
    .&           #     "and"s the string with itself, i.e. the result
                 #     is a string of the distinct characters in the column
    .,1=*        #     If the length is 1 (i.e. only one character) keep
                 #     the column, otherwise reduce it to the empty string
  }%
  ''*            #   Combine the resulting characters into a string again
  C&C=           #   Check if this string contails all characters from C
},
.{               # If the filter returns at least one possible wrap position
  0=             #   Take the first one
  T/n*           #   Split the string and join again with newlines
}{               # Else
  'no solution'  #   Return 'no solution'
}if              # Endif

My example takes ~5.3 secs on your website but I trust this works.

Impressive ! Could we have an explanation, plz ?

@guy777 Added some explanation to the answer.

Ruby, 161
Why not use one clever regular expressions instead of "brute-forcing" and checking ;)
Online version
d,s=STDIN.read.split("\n")
l = s.size
puts s.scan(/.{,#{d.split.map{|c|(0..l-2).map{|n|n if /^.{,#{n}}(#{c+?.*n})*.{,#{n-1}}$/=~s}}.reduce(&:&).compact.min+1}}/)

It seems to be broken: try it on a C\n..C...a..C..a and it finds ..C...a\n..C..a which is not a solution.

APL (65)
⍞{1∊r←∧⌿↑∨/¨¨∧⌿¨¨↓⍵∘.=z←⍺∘{z⍵⍴⍺↑⍨⍵×z←⌈⍵÷⍨⊃⍴⍺}¨⍳¯1+⍴⍺:⊃r/z⋄0}⍞~' '

Example: (smaller one for legibility)
      ⍞{1∊r←∧⌿↑∨/¨¨∧⌿¨¨↓⍵∘.=z←⍺∘{z⍵⍴⍺↑⍨⍵×z←⌈⍵÷⍨⊃⍴⍺}¨⍳¯1+⍴⍺:⊃r/z⋄0}⍞~' '
r a b
abracadabra!
abracad
abra!

Explanation:

⍞{...}⍞~' ': Read two lines. Remove the spaces from the first line and pass it to the function as its right argument, pass the second line unaltered as the left argument.

⍺∘{...}¨⍳¯1+⍴⍺: For each number 1..length ⍺-1, split ⍺ into that many columns:
z←⌈⍵÷⍨⊃⍴⍺: calculate how many columns we'll need and store in z.
⍺↑⍨⍵×z: extend ⍺ with spaces to the length ⍵×z (fill the last line up with spaces if necessary)
z⍵⍴: reshape the result into z lines and ⍵ columns
z←: store the array of matrices in z
⍵∘.=z: for each character in ⍵ (the input characters), see which elements in z match it
∧⌿¨¨↓: take the logical and of each column of each matrix for each input character
∨/¨¨: take the logical or of each element in the result (giving for each character and each matrix whether that character was matched in that matrix)
r←∧⌿↑: for each matrix, see whether or not all input characters were matched. Store a bitmask over the matrices in r.
1∊r...:: If the bitmask contains a 1, there was a result, so:
⊃r/z: Filter z by r and take the first element (displaying the result with the smallest amount of columns.)
⋄0: otherwise, return '0'.

Python (211 203)
This is my first codegolf so I expect many possible improvements. I have designed two version which use different systems to print out the solution.
The input is done via 2 input()s so you would have to put quotes before and after the strings.
Version 1 (211 203)
c=input().split();i=input();l=range(len(i)//2)
for k in c:l=[w for w in l if any(all(k==y for y in i[x::w])for x in range(w))]
print'\n'.join(len(l)and __import__('textwrap').wrap(i,l[0])or'No solution')

Explanation:
chars = input().split()
inp = input()
wrapAfter = range(len(inp)//2) # min 2 (full) lines
for char in chars:
    wrapAfter = [wrapped for wrapped in wrapAfter if any( # filter the possiblities left
        all(char == cAt for cAt in inp[columnNbr::wrapped]) # wrap the line and check that
                                                            # cAt is char
            for columnNbr in range(wrapped))] # for all columns

# print a joined version of all strings that are returned
import textwrap
wrapped = wrapAfter[0]
print('\n'.join(textwrap.wrap(inp, wrapped) if len(wrapAfter) # if there are wrappingvalues left
                                                              # we wrap the string
                else 'No solution')) # else we print 'No solution'

Version 2 (245 236 219 208)
r=range;c=input().split();i=input();z=len(i);l=r(z//2)
for w in l:
 if set(s[0] for s in(i[x::w]for x in r(w))if len(set(s))==1)>=set(c):print'\n'.join(i[x:x+w]for x in r(0,z,w));break
else:print'No solution'

Explanation:
chars = input().split()
inp = input()
length = len(inp)
wrapAfter = range(length//2)
# we go through every possible wrapping
for wrap in wrapAfter:
    # if the set of all  character for that a colum exists that is purely made up of
    # this char is a superset of chars then we won
    if set(s[0] for s in
            # makes a generator that generates all columns
            (inp[x::wrap]for x in range(wrap))
            # if all characters in the column are equal
            if len(set(s))==1) >= set(chars):
        print('\n'.join(inp[x:x+wrap]for x in range(0,length,wrap))) # textwrap is
                                                                   # slower as we
                                                                   # replace range
        break
# if the loop wasn't broken nothing was found
else:
    print('No solution')

You don't have to use print as a function, removing the parens can save one char

Also, range() returns a list so you don't have to do list(range())

You could use a variable for len(i) as you use it twice

that is Python 3 syntax. Don't ask me why I didn't use Python 2.7. Thanks for the input


text:
Council Majority
Introduction
You belong to a council which oversees the destruction of corrupted worlds. When the council assembles, a single vote is taken. The ballot lists all nominated worlds. One is ultimately destroyed each time the council meets.
Due to a bug in user12345's code, the council recently flooded and then sent pirate zombies to the wrong planet. We need a more reliable system for counting votes.
Problem
A vote is described by a series of integers on a single line. The first integer is m, and the worlds nominated for destruction are uniquely numbered from 1 to m. The remaining integers each represent the world each council member voted on.
Somehow, without any collusion, one world always receives more than half of the vote. This always occurs, regardless of how many worlds are present.
Given an input, write a program that outputs the world elected for destruction.
Example Input
Remember, the first 3 is the number of worlds, m. It is not a vote.
3 1 1 2 3 1 3 1 1 3
Example Output
The majority of the council voted for planet 1, so we output that.
1
Assumptions

The exact number of votes is not given
The number of votes is between 1 and 100 (inclusive)
Each vote is between 1 and m (inclusive)
Every vote contains a majority
Input must be provided through stdin, read from a file, or accepted as a sole argument to the program

The answer with the fewest characters wins!

GolfScript (10 9 chars)
~]$.,(2/=

Explanation:
~]     # Parse input into array
$      # Sort; note that the extra element giving the number of worlds will end up last
.,(2/= # Take the middle element (not counting the last one)

Thanks to Dennis for 10->9.

Apologies for missing the time limit on this one and accepting your answer 11 days late. I've since stopped using time limits on challenges. Cheers!

Since the first element is guaranteed to be the last after sorting, ~]$.,(2/= should work as well.

APL (21)
∪v/⍨c=⌈/c←+/∘.=⍨v←1↓⎕

Python (50)
l=raw_input().split()[1:];print max(l,key=l.count)

This approach doesn't need sorting. It finds the element which appears the most times is list l, using the max function and different ordering function.

Python, 61 60
l=map(int,raw_input().split())[1:];print sorted(l)[len(l)/2]

22 characters are spent parsing the input with spaces; if I could do comma separated, my score would drop to 39.
Does the same thing as the other answers: drops the first element, then prints the element at halfway through the list when it is sorted.
Explanation:
          raw_input().split()                                # Get the line of input, split on spaces
  map(int,raw_input().split())                               # Convert list of strings into list of ints
  map(int,raw_input().split())[1:]                           # Drop the first element
l=map(int,raw_input().split())[1:];                          # Assign list to variable `l`
                                         sorted(l)           # Sort l in ascending order
                                         sorted(l)[len(l)/2] # Get the element halfway through the list.
                                   print sorted(l)[len(l)/2] # Print it
l=map(int,raw_input().split())[1:];print sorted(l)[len(l)/2] # Combine statements

Can't you do list(raw_input())[2::2] instead of raw_input().split()

@user80551 Actually, I cannot use that. What if the number of worlds was 42?

Stop using 42 when 10 would have sufficed, that's enough for now I think :)

@user80551 "that's enough for now I think". Do you mean that I should just do your method, or that I use 42 too much?

I think that everyone on PCG.SE is using 42 too much since http://codegolf.stackexchange.com/questions/21835/most-creative-way-to-display-42

@user80551 I've been using it long before then. :-). Let's continue this discussion in the chat, if you want to.

Mathematica (19)
g=Commonest@Rest@#&

Input as follows:
g[{3, 1, 1, 2, 3, 1, 3, 1, 1, 3}]

Output:
{1}

Pyth 1.0.5, 10
JPwd;ocJNJ

Unlike almost every solution above, this code doesn't just take the middlemost element.
Explanation:
JPwd    J = input, split on spaces
;       Print last element of
ocJN    Order by count in J of N,
J       For N in J

Bonus solution:
Council Plurality, 11
If you want pluralities to be correctly judged as well, that's one more character:
JtPwd;ocJNJ

This judges correctly the only case where the above fails for pluralities: When the last planet has one less vote than the plurality winner, the 10 character code will mistakenly select the last planet, because it counts the statement of the number of worlds as a vote.
This code corrects that error by using the tail function, t, to ignore the first number.

The compiler you linked to on GitHub was modified two hours ago. This challenge is months old. The community here usually only accepts answers for which a compiler existed before the challenge was posted. I guess it doesn't really matter here, because it doesn't look like you tailored your language specifically to this challenge.

@Rusher I've only just completed my language, about a week ago, well after this challenge was posted. In addition, I'm still revising things almost every day. I'll of course understand if it won't get accepted for anything, but I didn't feel like that should stop me from posting.

Oh of course you can post. I didn't downvote your post or anything (and I just noticed you explained your code in a way that I can understand it, so I upvoted as well). I just didn't want you to be surprised in the event that you somehow get it down to 8 characters and don't get accepted answer.

@Rusher Oh, I see. Thanks for the clarification.

J (33 characters)
33 characters in J: (>:@i.>./)@:(+/"1)@(>:@i.@{.=/}.)
Use it as:
(>:@i.>./)@:(+/"1)@(>:@i.@{.=/}.) 3 1 1 2 3 1 3 1 1 3

J - 18 char
({~<.@-:@#)@/:~@}.

Explained by explosion:
({~<.@-:@#)@/:~@}.  NB. find the majority vote!
                }.  NB. remove the head of the list
            /:~     NB. sort the list
(        #)         NB. take the length
   <.@-:            NB. halve it and round down
 {~                 NB. select from the beheaded list

Usage:
   ({~<.@-:@#)@/:~@}. 3 1 1 2 3 1 3 1 1 3
1
   ({~<.@-:@#)@/:~@}. 20 3 2 2 1 1 1 1 7 7 7 7 7 7 7 7 7
7

Groovy - 99 Chars
Using drop-sort-get-midway technique:
l=(System.in.text as List).findAll{!it.allWhitespace}.drop(1).sort()
println l.get((int)l.size()/2)

Ungolfed, somewhat:
list = System.in.text as List
s = list.findAll{ ! it.isAllWhitespace() }.drop(1).sort()
i = (int) s.size() / 2
println s.get(i)

Python (78):
I swear I didn't see Quincunx's answer before I posted this...
from collections import*;print Counter(raw_input().split()[0:]).most_common(1)

C# 133 chars
Because it's totally worth it to go into an old question and add an answer massively longer than any other. c# is tough to golf.
namespace System.Linq{class P{static void Main(){Console.Write(Console.ReadLine().GroupBy(x=>x).OrderBy(x=>x.Count()).Last().Key);}}}

Haha I bet you were cringing while writing out Write, ReadLine, GroupBy, OrderBy, etc. All my charz down teh drainz! Pretty good for the language chosen.

Python, 88 83
from collections import*;print Counter(map(int,raw_input().split())).most_common(1)

This works even if one world gets only one more vote than another, because it uses modes.
The output for the example: [(1, 5)]. The first number is the world to destroy, and the second is the number of votes it got. This output is valid according to your rules:

write a program that outputs the world elected for destruction.

And you gave an Example output, not a Corresponding output.
But if I really need the single number, then this works for 6 more characters:
from collections import*;print Counter(map(eval,raw_input().split())).most_common(1)[0][0]

Explanation:
from collections import*                                                            # import everything from the `collections` module
                                               raw_input().split()                  # Get the line of input, split on spaces
                                       map(int,raw_input().split())                 # Convert the list of strings to a list of ints
                               Counter(map(int,raw_input().split()))                # Create a Counter object (from collections) to get the mode
                               Counter(map(int,raw_input().split())).most_common(1) # Get the most common element of the Counter object
                         print Counter(map(int,raw_input().split())).most_common(1) # Print it
from collections import*;print Counter(map(int,raw_input().split())).most_common(1) # Combined statements

@Rusher The first program's output is valid according to your description, because it clearly indicates which world is the world to destroy ;-)

J 21
(~.(#~(=>./))#/.~)@}.

Explanation from right to left:

}. drop first number
fork:

#/.~: Count per unique element the number of occurences
Hook:

#~ copy from left
(=>./) hook: where right is maximum of right

~. : take unique elements, in order

Examples
   (~.(#~(=>./))#/.~)@}. 3 1 1 2 3 1 3 1 1 3
1
   (~.(#~(=>./))#/.~)@}. 10 1 2 1 7 1 2 2 7 7 7
7

PHP - 66
<?=!preg_filter(~‹ﬂ—‹ö,~€û§€ñ‘‘¢¬€œ,$argv[1]).sort($a)?:$a[$i/2];

Without the special chars:
<?=!preg_filter("# .#e",'$a[$i++]=$0',$argv[1]).sort($a)?:$a[$i/2];

JavaScript (60)
a=prompt().split(" ").slice(1).sort();alert(a[a.length/2-1])

Doesn't work if a.length & 1

source: Stack Exchange

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

sort: votes


text:
Write a function that returns something different every time it is called
All these functional languages that return the same value every time a function is called give me a headache.
Your task is to write a function that returns something different every time it is called.
Here are the rules:

Your function must continue to return something different every time it is run
It must return a different value on your computer than it does on my computer
Your function must be guaranteed to be different (no random numbers)
+20 if your code gets time from the system or an online clock

It's impossible "to be different no matter how many times I run it" unless the value returned is infinitely large. You want want to rephrase that.

-1 for changing the rules after posting, cost me 20 points...Also, use the sandbox next time

@TheDoctor - Okay.... I am happy to change it if someone else comes uo with something shorter - what is the normal etiquette for picking answers?

Give people 24 hours at bare minimum. Ideally a contest should be measured in multiple days, not hours. Remember the site has an international audience, so some people may have been asleep for the entire life of the question if you end it after a few hours. As the current accepted answer, I myself think it was too soon for me to win. And there are already shorter answers.

@jcw accepting an answer early and changing rules after an answer is submitted....dirty pool man

Just saw this one now.  My answer would have been a statistical md5sum /dev/sda

Perl (7 bytes)
sub{$$}

Well, until processes IDs run out, this should return something else each time it's being called.
Alternatively, if you think this is not fine, because it will return the same value for the same instance of program, there is an alternate version which only works in newer versions of Perl which automatically increases process ID every time it's being called. It's 9 bytes long, however.
sub{$$++}

T-SQL, 13
PRINT NEWID()

Relatively uninspiring challenge, but it's rare that you can show off an instance of true brevity in SQL.

Python, 28
def f(x=[f]):x+=[1];return x

Since python has mutable default arguments x will be different every time you call f. The starting element gives you a memory address, which changes each time you define the function. Example output:
>>> def f(x=[]): x+=[1]; return x
...
>>> f()
[<function f at 0x1047527d0>, 1]
>>> f()
[<function f at 0x1047527d0>, 1, 1]
>>> f()
[<function f at 0x1047527d0>, 1, 1, 1]

I really like your solution; you really follow the idea of playing with a function (and with functional ways of programming) as it is required.

You can't access f in the default argument assignment because it's evaluated before f is assigned. But this would work (and save you 1 character): def f(x=[]):x+=[f];return x

This returns Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'f' is not defined  because f must be evaluated for the function to reside in memory

Perl, 67 (but growing slowly) char
open X,"+<$0";seek X,66,0;print$y=<DATA>,%ENV;print X++$y
__END__
0

Output the environment of the current machine, plus a hard coded number that is updated in the source code each time you run the script.

C [46 bytes]
#include<stdio.h>
main(int*x){printf("%x",&x);}

Theoretically this may return the same address but practically the probability is rather low.

DOS - 27 chars
echo "X" >> random.txt
dir

Not only will your byte size be different, even if you put it in an empty directory your volume serial number won't match mine.

clever, but, "It must return a different value on your computer than it does on my computer"

@JordonBiondo It does, unless your hard drive happens to have the same volume serial number as mine, and you ran it from the same directory with the same files inside.

Haskell - 95
import Data.Time.Clock.POSIX
import System.IO.Unsafe
f _=fromEnum$unsafePerformIO getPOSIXTime

Example:
> f 0
-7269056719496922816
> f 0
-7269056004375922816
> f 0
-7269055316663922816

Bash, 18, obvious
head /dev/urandom

violates the 3rd rule: "Your function must be guaranteed to be different (no random numbers)"

Its pseudorandom :) , and that sentence is a bit ambiguous.

@user80551 that's even worse

@JanDvorak At least he tried.

Python, 56
import uuid
import time
print uuid.getnode(),time.time()

I removed all network cards from both computers. Now they return the same value.

Welcome to PPCG! For code golf challenges, our convention is to provide a header (use ## before the header text) with the language name and character count of the answer.

@JonathanVanMatre: Thanks for letting me know

You may want to use import uuid,time instead to reduce your char count.

J, 11 bytes - True function
In J, printing the date is merely: 6!:0 '' but the question asks for a function (not absolutely sure other solutions follow this requirement), which gives the idea of the following 11-characters function: (6!:0@])&'' which outputs each time something different whatever its argument is (note that function with no-argument should be accepted, but answers with statements for printing the time shouldn't).

+1 for careful reading, and for being the apparent shortest true function. Hopefully OP will sort this out.

Thank you for your answer and for having changing the title. Actually, such a function is a little trickier in J than in other languages, because J precisely is a functional language. The trick is: bind the constant argument needed to output the time as a right argument of a function discarding its left argument and returning time from its right argument (hope I am clear enough). The effect of the binding is that the usual right argument will become the left argument of the new function (called "verb" in J) and it will be discarded.

C++, 38 chars
int *r(){int*s;int n=0;s=&n;return s;}

Run int main(){std::cout<<r();} with the above, and it is guaranteed to return a different address every time.

bash+curl - 24 chars +20
curl -s time.nist.gov:13

Violates the second rule "It must return a different value on your computer than it does on my computer"

I challenge you to prove that it will return the same thing on any two systems ever.  The simple act of my making the call at one instant disables anyone anywhere from making the same call at the same instant

It's about the principle. If that were the case then you might as well just query the system clock directly.

Then he should say "don't use clock calls"

@DavidWilkins Easy: Unplug network cable from my computer and your computer. Same results.

@nmclean Who here would ever have a computer incapable of getting to stackexchange (tongue in cheek)

@DavidWilkins: Sure. The question has some issues regardless.

Mandatory https://xkcd.com/1340/

Python 52
A different version of what @Hovercouch suggested:
def f(x=[f]):x+=[__import__("time").time()];return x

>>> f()
[<function f at 0x049F1A30>, 1394652231.0]
>>> f()
[<function f at 0x049F1A30>, 1394652231.0, 1394652232.746]
>>> f()
[<function f at 0x049F1A30>, 1394652231.0, 1394652232.746, 1394652423.971]
>>> f()
[<function f at 0x049F1A30>, 1394652231.0, 1394652232.746, 1394652423.971, 1394652428.137]

Although the odds of getting different output on all computers is not zero!

Traceback (most recent call last):   File "<stdin>", line 1, in <module> NameError: name 'f' is not defined

With which version is this meant to work? It errors the same way with python2 and py3

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


text:
Obfuscation Challenge
You are to write a program that does one of the following.

Only displays "Hello World" does nothing else
Quits and nothing else (no output, no errors.)
Takes one line of input, parses it as an integer, displays the first that many primes (or gives a nice error if it is given input that can't be parsed as an integer, or is less than 0.)
Given one line of input, it parses it has a stock symbol, and checks online for the current stock value and its change.

The catch, it should not be apparent which function it performs. Namely, for someone looking at your code, it should not be apparent which function it will do. Also, it may only perform and be able to perform one function (it can not pick and choose.) How good a program is is determined by how uncertain someone is that looks at it as to what its function is, and also how familiar that person is with that language.
BONUS:
If you in a clever way make it so although for any one compiler/intrpreter and platform, the program will also perform the same function, different compilers/interpreters or platforms, it will perform a different function. This bonus may only be collected if done cleverly.
BONUS:
If your program only contains code that is capable of one function (save nothing, as empty code is capable of that), and it is not possible to make a simple modification unrelated to the function to allow it to perform a different function.
For example: if you did
obfuscatedBool = 1g8uhad'l8fygrcetdu8y4fd/,.oe87fy4d --Magic
if obfuscatedBool: print "Hello World"

Would not count as obfuscatedBool could be made True or False to make it print "Hello World" or do nothing respectively.
INFINITY BONUS: If you realize both bonuses simultaneously, you are magic.
NEGATIVE BONUS: Using libraries with specific abilities to do the functions.
Voters, take the bonuses in to consideration, because the program with the most votes wins!
Note: If you say what your program does, make sure to use spoiler syntax!

To be honest, I can't understand most of the question. I go further and will say that I only understand the 4 points.

Make a program such that it does one of the 4 things, but no one knows what.

And what about the bonuses? Seriously, even the question is obfuscated.

They are just to guide voters. If you trick the compiler, you get a bonus. If you only have code for one function, you get a bonus. Libraries are a negative bonus.

possible duplicate of Obfuscated Hello World

@PyRulez What's in NEGATIVE BONUS ?(meaning what is the bonus)

Since this is a popularity-contest, what for is the bonus?

@TheDoctor no it's not ! There's a lot of difference between them

Can you clarify "immediately" please? Can you have code in front of the bit which actually does the display or nothing/quits?

@MukulKumar - as in, mine actually made sense?

Option 1 is similar to http://codegolf.stackexchange.com/questions/22533/weirdest-obfuscated-hello-world/ ?

I'm voting to close this question because underhanded contests are off-topic by community consensus.

Whitespace/Brainfuck/Python

'''begin''''''''''''
main(args){
	parseArgs=args.Find('^++++++++^[<++++[<++<+++<+++<+>>>>a-z]<+<+<A-Z[>]>0-9]<<.<---.*$');
    for(int i=0;	Range(GetLength(parseArgs));	i++){validateArg(parseArgs(i));}
	//name
    string stockName="";
	//loop
    for(int i=0;Range(GetLength(parseArgs));i++){
	//validate
     	if(matchFound=Find('a+z+A+.Z.0+9+_+.<<*$'){
	//found
     	parseArgs(i).Split('>-.>.+');}

     	for(int j=0;Range(GetLength(parseArgs(i)));j++){
	//download
    data=ConvertTo.String(eval("curl -get	http://some-stock-ticker-source-url-here.com"));
	print;
    print data;

    //line separator

    print "--------.";
	}}
}

''finish'''''''''''''''
Wikipedia: Whitespace (programming language)
Online Whitespace Interpreter to Test Answer
Online Brainfuck Interpreter to Test Answer

 Output (Whitespace/Brainfuck):
 Hello World

 Ouput (Python):
 Nothing, but runs successfully.

This is really cool! I think you should update the description. Isnt the obvious code a third program that does something too? Also if you could change one of brainfuck or whitespace to perform one of the other function I would give you the INFINITY bonus!

What language is the pretend program in?

@durron597 It's a weird C# and Python hybrid. I was going to do it all in C# but it was difficult to make the syntax work all the way through.

@SebastianH It's a pretend program to mask its actual function.

The Python functionality is too transparent. After you see the first 3 characters, you just have to scan the rest of the code for the end of the string literal.

@user2357112 Perhaps. I just added the Python functionality because I thought it would be an easy addition. I'll obfuscate it more.

JS
ﾟωﾟﾉ=/｀ｍ´）ﾉ~┻━┻//*´∇｀*/['_'];o=(ﾟｰﾟ)=_=3;c=(ﾟΘﾟ)=(ﾟｰﾟ)-(ﾟｰﾟ);(ﾟДﾟ)=(ﾟΘﾟ)=(o^_^o)/(o^_^o);(ﾟДﾟ)={ﾟΘﾟ:'_',ﾟωﾟﾉ:((ﾟωﾟﾉ==3)+'_')[ﾟΘﾟ],ﾟｰﾟﾉ:(ﾟωﾟﾉ+'_')[o^_^o-(ﾟΘﾟ)],ﾟДﾟﾉ:((ﾟｰﾟ==3)+'_')[ﾟｰﾟ]};(ﾟДﾟ)[ﾟΘﾟ]=((ﾟωﾟﾉ==3)+'_')[c^_^o];(ﾟДﾟ)['c']=((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)-(ﾟΘﾟ)];(ﾟДﾟ)['o']=((ﾟДﾟ)+'_')[ﾟΘﾟ];(ﾟoﾟ)=(ﾟДﾟ)['c']+(ﾟДﾟ)['o']+(ﾟωﾟﾉ+'_')[ﾟΘﾟ]+((ﾟωﾟﾉ==3)+'_')[ﾟｰﾟ]+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+((ﾟｰﾟ==3)+'_')[(ﾟｰﾟ)-(ﾟΘﾟ)]+(ﾟДﾟ)['c']+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+(ﾟДﾟ)['o']+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ];(ﾟДﾟ)['_']=(o^_^o)[ﾟoﾟ][ﾟoﾟ];(ﾟεﾟ)=((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+(ﾟДﾟ).ﾟДﾟﾉ+((ﾟДﾟ)+'_')[(ﾟｰﾟ)+(ﾟｰﾟ)]+((ﾟｰﾟ==3)+'_')[o^_^o-ﾟΘﾟ]+((ﾟｰﾟ==3)+'_')[ﾟΘﾟ]+(ﾟωﾟﾉ+'_')[ﾟΘﾟ];(ﾟｰﾟ)+=(ﾟΘﾟ);(ﾟДﾟ)[ﾟεﾟ]='\\';(ﾟДﾟ).ﾟΘﾟﾉ=(ﾟДﾟ+ﾟｰﾟ)[o^_^o-(ﾟΘﾟ)];(oﾟｰﾟo)=(ﾟωﾟﾉ+'_')[c^_^o];(ﾟДﾟ)[ﾟoﾟ]='\"';(ﾟДﾟ)['_']((ﾟДﾟ)['_'](ﾟεﾟ+(ﾟДﾟ)[ﾟoﾟ]+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+(ﾟΘﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ)+(ﾟΘﾟ))+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟΘﾟ)+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+(c^_^o)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)-(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+((ﾟｰﾟ)+(o^_^o))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((o^_^o)+(o^_^o))+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟΘﾟ)+(ﾟｰﾟ)+(ﾟｰﾟ)+(ﾟДﾟ)[ﾟεﾟ]+(ﾟｰﾟ)+((o^_^o)-(ﾟΘﾟ))+(ﾟДﾟ)[ﾟεﾟ]+((ﾟｰﾟ)+(ﾟΘﾟ))+(ﾟΘﾟ)+(ﾟДﾟ)[ﾟoﾟ])(ﾟΘﾟ))('_');

 Alerts "Hello World"

 Was answered at https://codegolf.stackexchange.com/a/3946/803
 Since I did not come up with this answer, making it a community wiki

Are you entirely sure this is not APL?

@mniip Oh Yeah!! its is JS. Demo http://jsfiddle.net/7mqL8/

I see smileys everywhere..

This is the best usage of Unicode in JavaScript I've ever seen!

+1 for the smiley: (o^_^o).

Can you explain why this works? I would like to understand this.

Does it perform a different function in IE7?

It was probably generated by this online encoder

MS-DOS x86 Assembly
Because it isn't already obfuscated when it's in assembly, let's make it even worse! This SHOULD work with any assembler that can assemble to a COM file, but I've only tested with TASM for DOS using tasm obfuse, tlink /t obfuse
.286
CODE SEGMENT
ASSUME CS:code, DS:code
ORG 0100h

start:
.586

xor eax, eax
xor ecx, ecx
xor edx, edx
xor ebx, ebx
xor edi, edi
xor esi, esi
stc
pushfd
rcr di, 8
mov cx, 35
cli
push edi
xor word ptr [di + 8], 2720
pushfd
sub bx, 64512
rcr ebx, 11
sub word ptr [di + 125], 61702
pop eax
dec dx
and word ptr [di + 4], cx
mov ecx, eax
sub byte ptr [di + 124], 21
xor eax, ebx
push eax
xor byte ptr [di + 127], 240
popfd
xor dword ptr [di], 179066414
pushfd
xor byte ptr [di + 11], dl
pop eax
mov bp, 8268
xor byte ptr [di + 123], 110
pop edx
add byte ptr [di + 10], 49
popfd
sti
and ecx, ebx
or word ptr [di + 4], bp
and eax, ebx
xor word ptr [di + 6], 23601
cmp eax, ecx
db 'u', 5
dec cl
movsx dx, cl
int 32

CODE ENDS
END start

 This is self-modifying code that does several things:
 1) It modifies the first 12 bytes to 'Hello World[dollar sign]'
 2) It modifies the seemingly out of place 'dec cl' and 'movsx dx cl' to 'nop', 'mov ah, 9', 'int 021h'
 3) Everything is highly interspersed within each other. This is also doing a flags test to see if your CPU supports CPUID
 4) Hex values converted to decimal so you have no clue....
 5) Even if you did, it uses xor, or, and and sub to modify the existing code to the correct values. No direct values.
 6) If your CPU doesn't support CPUID (not a Pentium or above, see DOSBox for a great example), you see "Hello World". Otherwise, nothing happens.

Writing a program in Assembler is obfuscation enough! xD

C
int puts(const char *s) {
  char error[] = "Error: invalid number\n";

  int a, b=0, c=0, i, j;
  scanf("%d", &b);

  if (b<1) {
     printf(error);
  }

  for (i=2; c<b; i++) {
     int z=1;
     for (j=2; j<i; j++) {
        z = z&&(i%j);
     }
     if (z) {
        printf("%d\n", i);
        c++;
     }
  }
}

int main () {
  printf("Hello World\n");
}

 On gcc, with default settings, this does the prime thing. Using tcc, you get Hello World. A C compiler may rewrite a printf("String\n") call into a puts("String") call. This is more efficient, but it does assume nobody wrote their own puts. A compiler does not have to do this, so depending on your compiler and your compiler settings, you will get either Hello World or a bunch of primes. The printf calls in puts are not affected, because they don't match the exact template. I think I qualify for the bonus.

LOLCODE
This language is already obfuscated by itself. Here is my code:
HAI
I HAS A CATURDAY
CATURDAY IS NOW A TROOF
I HAS A LOLZ ITZ 32907
I HAS A CHEEZBURGER
MAEK CHEEZBURGER A NUMBR
CHEEZBURGER R QUOSHUNT OF LOLZ AN  LOLZ
CHEEZBURGER BIGGR THAN 1?, O RLY?
YA RLY BTW RLY LOLZ
CATURDAY R WIN
OBTW EVERYDAY IS CATURDAY
ME LIKEZ CATURDAY!!1!
TLDR
CHEEZBURGER R QUOSHUNT OF LOLZ AN CHEEZBURGER
NO WAI
CATURDAY R FAIL BTW LOLZ!!1!
I HAS A LIMIT ITZ 10
CHEEZBURGER R 0
OIC
IM IN YR LOOP
CHEEZBURGER, WTF?
OMG 1
VISIBLE "Hello World!"
OMGWTF
CATURDAY R FAIL
OIC
GTFO
IM OUTTA YR LOOP
KTHXBYE

 This code quits and does nothing else (no output, no errors). But although it does absolutely nothing, it runs like a charm (tested with version that contained a VISIBLE "test" statement before the last statement KTHXBYE, proving that all is fine). Basically it declares variables, changes their types, enters in loops and ifs and cases constructs, even has a line that would print "Hello World!" if ever reached (if only reached...). A total waste of computation :)

If you'd like, you can test it here

JavaScript (ES6)
Using pragma black magic to reveal JavaScript true power:
var WKRBD='';
var DIJqZ=(gFJLA=WKRBD,i=29)=>(
  "use black magic",
  gFJLA=WKRBD.concat(gFJLA),
  [String.fromCharCode((c.charCodeAt()-61)^gFJLA[i++].charCodeAt())for(c of gFJLA.substr(1,11))].join('')
);
DIJqZ(DIJqZ);

Output:
Hello World

Explanations:
This program is actually quite simple and could be summarize as bellow.
Everything else if syntactic sugar!
var dummy = function() {
  var output = '';
  var a = 'gFJLA=WKRBD';
  var b = 'black magic';

  for (var i = 0; i < a.length; i++) {
    output += String.fromCharCode((a[i].charCodeAt(0) - 61) ^ b[i].charCodeAt(0));
  }

  return output;
};

dummy();

Here is the annotated version:
// Nothing special here.
var WKRBD='';

// Define a new function. Its name doesn't matter.
// But its arguments do!
//   * gFJLA=WKRBD: encoded "Hello World"
//   * i=29: number of characters before "black magic"
var DIJqZ=(gFJLA=WKRBD,i=29)=>(
  // Store the XOR key using a fancy pragma name!
  "use black magic",
  // Convert gFJLA to String thus it is possible to read
  // its body and extract the encoded "Hello World".
  gFJLA=WKRBD.concat(gFJLA),
  // Use a generator to decode the message.
  [
    // Generate the decoded character
    String.fromCharCode(
      // Decode the character.
      // gFJLA[i++] retrieves a character from "black magic".
      (c.charCodeAt() - 61) ^ gFJLA[i++].charCodeAt()
    )
    // Iterates over the function body.
    // The extracted part is "gFJLA=WKRBD".
    for(c of gFJLA.substr(1,11))
  // Build the message. Since it is the last expression of
  // the arrow function, its result is returned.
  ].join('')
);

// Invoke the function and pass itself as the first argument.
DIJqZ(DIJqZ);

any exxplain? for the pragma?

COBOL (IBM Enterprise COBOL)
   ID

If shown that, very close to 100% of IBM Mainframe COBOL programmers would say "that's not even a program, that won't compile!". The more experience they have, the less likely they are to think it will compile (as older Mainframe COBOLs were much more strict).
Then ask "if it does compile, what does it do?" They would say, "it won't compile, but if it did, it would give some sort of error, probably Language Environment would give a U4038 or something like that".
Managed to shorten it. There are four DIVISIONs in a COBOL program. IDENTIFICATION/ID, ENVIRONMENT, DATA, PROCEDURE. It turns out that PROCEDURE requires the word DIVISION and the others don't. Guess which one I removed first and assumed that the other words DIVISION were mandatory... further puzzling revealed otherwise. Pity it's not Golf. A two-character COBOL program...

 OK, yes, the compiler does moan, and indeed gives it a Return Code of
 eight. Usually people don't even generate the object code for, let
 alone try to execute, programs with a Return Code of eight.

 However, this is a case where none of the E-level errors affect the
 code generated. So the code runs without a problem at all, if you generate  it.

 The above source is effectively the equivalent of this:

        ID DIVISION.
        PROCEDURE DIVISION.
            GOBACK
            .

 Which simply returns to whence it came.

My first ever spoiler. There's code in there. All pickled. Rats. More research...

Slightly less pickled, but still not good. Late here. I'll see if there are more spoilers I can steal from tomorrow. Err... later today. ID and PROCEDURE start in column eight, GOBACK and full-stop/period in column 12. The ID in the original is also column eight, just for info.

Java,C++-11 1 Bonus claimed
Not sure about if i got both bonuses but it was already a headache to intermingle 2 programming languages...
/* *??/
/
#include <iostream>
using namespace std;

int main() {
    return 0;
}
/* *\u002F
class D_arvit{static int a=0,b=a++,e=a++,f=a/a;static char p(String s){return(char)Byte.parseByte(s,a);}public static void main(String[]z){//\u000Along x=e,y=b;String c=((Long)x).toString(),d=((Long)y).toString();char u=p(c+c+d+c+c+d+d),m=p(c+c+d+d+c+d+c),o=(char)(u+a+f);char _=p(c+d+d+d+d+d),$=_++;System.out.print(new char[]{p(c+d+d+c+d+d+d),m,u,u,o,$,p(c+d+c+d+c+c+c),o,(char)(o+a+f),u,(char)(m-f),_});\u000A}}
/\u002A*/

 Getting the C++ inbetween the java code which i already used on another Hello World answer was a Pain in the ass. Took me a while to find a fitting second language where i was able to juggle around comments as needed so they disable/enable differently at different languages

Using trigraphs to exit a comment in C++. This is neat!

^It's also one of the standard loopholes, I think. Just saying.

Python - 1 Bonus Claimed
import base64
try:
    a=1/(1/2)
    eval(compile(base64.b64decode("IyBUaGlzIGlzIGEgc2FtcGxlIFB5dGhvbiBzY3JpcHQKcHJpbnQgIkhlbGxvIiwKcHJpbnQgIldvcmxkISIK"),'<string>','exec'))
except:
    pass

In Python 2, 1 divided by 2 equals 0. 1 divided by 0 can't be evaluated and throws a division by zero error. Nothing is printed, and still the program terminates without error.
In Python 3, 1/2 => 0.5, and 1/0.5 => 2.0. No error. Hello, World! is printed.

I don't know that this is obfuscated enough.

@hosch250 Is right, it is not very obfuscated. Is second part is wrong though.

Oh, I see.  It does one in Python 2 and the other in Python 3.

@hosch250 Oh well. At least I got the bonus. I won't really mind if someone else steals the bonus part of my answer and molds it. I'd be honored, even.

Just obfuscate hello world in some way and you will be fine.

@hosch250 Well, it's no longer obvious what it prints.

Ruby - or is it Whitespace?
Well, can anyone guess what I do? Small hint: if you want to run it, please copy all of the code in the code box ;)
Update: Copying the code doesn't seem to work due to Unicode-related problems? Forking the online version and then copying the code seems to work! Look out for the whitespace ;)
Online version
# encoding: utf-8

def method_missing(m, *a)
  $* << (m.to_s.size-1).to_s
end

at_exit do
  eval ($**'').scan(/.../).map(&:to_i).pack('C*')
end

Output:
Hello world!

Explanation:

The last line consists of quite a few chunks of no-break-spaces (UTF-8: 160dec) separated by regular spaces.
Ruby handles the chunks as though they were methods - since no such methods are defined, method_missing is called, which saves the lengths of the chunks
Each chunk represents one digit of a three digit number, which represents a character
in at_exit the characters are formed by concatenating the digits etc. and the expression is evaluated, in this case puts 'Hello world!'
Instead of using UTF-8 whitespaces, you could also use underscores for better visibility:

def method_missing(m, *a)
  $* << (m.to_s.size-1).to_s
end

at_exit do
  eval ($**'').scan(/.../).map(&:to_i).pack('C*')
end

__________ ____ _ ____ ____ _ _ _ __ _________ _ __ _____ __ __ __ __ __ __________ __ __ ___ ____ _ __ __ __ _________ _ __ _________ _ __ __ _ __ ___ ________ _ __________ ____ _ ___ ____ _ ______ __ __ _______ __ __ ________ __ __ ___ __ __

Copying Whitespace from SE doesn't work because SE's markdown interpreter replaces tab characters with 4 spaces.

Forth
Let's create a new TASK.
FORTH ok
: TASK
  [ HEX ] 3A91224B. 1F836AFE.
  4A BASE ! D. D.
;
TASK Hello World ok

 It displays two 32-bits numbers in base 74 (4Ah).
 74 because it is the difference between ASCII "z" and ASCII "0" plus one, so I can use it to display a small words starting from a number.
 The first number is "Hello" (1F836AFEh) and the second number is "World" (3A91224Bh).
 It really prints a trailing space after the number "World".

Forth...one of the few languages SHOUTIER than SQL.  Welcome to the site!

I tried it on my Sinclair-ZX-Spectrum Forth and it works...

... and realize that using a different base (4F) will be compliant with another puzzle

Batch
@echo off&setLocal enableDelayedExpansion&for /L %%a in (2,1,%1)do (set/aa=%%a-1&set c=&for /L %%b in (2,1,!a!)do (set/ab=%%a%%%%b&if !b!==0 set c=1)
if !c! NEQ 1 set l=!l!%%a,)
echo !l:~0,-1!

 This will return a list of prime numbers less than the inputted value.
 H:\uprof>obf.bat 12
 2,3,5,7,11

I don't know that convoluted counts as obfuscated, though there are definitely some aspects of obfuscation present.

The program may only preform one function.

@PyRulez Sorry, fixed.

I also recommend using spoilers so people don't what it does immediately.

PHP:
$words=array('Heart','eagle','low','lonely','over',' SPACE ','Window','optimus','rotting','list','done','!done');
$words=array('Hated','ever','lonely','lover','oposed',' to','Witness','our','rare','long','discover');
$find='l';

foreach($words as $word)echo($find^(($find&$word)^($find|$word)));

 Prints 'Hello World'.
 It takes off the 1st letter from each word in the array.
 The var $find can have any single-byte string of 1 byte.
 Using a longer value for the var $find will give weird outputs.

Without looking at the spoiler, I could see that this string has to be connected with "Hello World"!

Sorry if my obfuscated try isn't the best. And yes, the pattern is too easy, but at least I tried something different. I will edit it later and make it a little less obvious.

Brainfuck
print("Hello World")

Explanation

 At least if your compiler ignores invalid instructions, this program does nothing.

The compiler must ignore non-commands, since they count as comments.

I know of some compilers that error on them, though I can't name any.

Reminds me of this other challenge

C++11
I claim the bonus for compiler dependence - for example, this will exhibit different beahviour between gcc 4.8 and gcc 4.9.
#include <iostream>
#include <list>
#include <type_traits>
#include <utility>

// Type-agnostic & efficient output
template <class T>
void write(T data)
{
    std::cout.write((char*)&data, sizeof data);
}

// Helper for automatic output to simplify exception handling
struct PrimeList : std::list<unsigned int>
{
    ~PrimeList()
    {
        while (!empty())
        {
            write(front());
            pop_front();
        }
    }
};

// Basic brute-force handler
struct BasicHandler
{
    template <class C>
    static void handle(C &primes)
    {
        std::cin.clear(std::ios_base::failbit); // remove possible non-fatal errors
        std::cin.exceptions(std::ios_base::failbit); // easier error handling
        unsigned int count;  // unsigned so that negatives error out immediately
        std::cin >> count;
        unsigned long long candidate = 1;
        for (unsigned int p = 0; p < count; ++p)
        {
            bool isPrime;
            do {
                ++candidate;
                isPrime = true;
                for (auto prime : primes)
                {
                    if (candidate % prime == 0)
                    {
                        isPrime = false;
                        break;
                    }
                }
            } while (!isPrime);
            primes.push_back(candidate);
        }
    }
};

// Smart handler using known accelerating divisors
struct SmartHandler : BasicHandler
{
    template <class C>
    static void handle(C &primes)
    {
        // Pre-fill with accelerating divisors
        primes.push_back(1819043144u);
        primes.push_back(1867980911u);
        primes.push_back(560229490u);

        BasicHandler::handle(primes);

        // Remove divisors, as they are not primes
        primes.pop_front();
        primes.pop_front();
        primes.pop_front();
    }
};

// Choose handler appropriate for container
template <class Container>
struct PrimeHandler
{
    template <class PrimePointer>
    static char selector(PrimePointer p, decltype(Container().insert(p, *p)));

    static double selector(...);

    typedef typename std::conditional<
        sizeof selector(
            typename Container::const_iterator(), typename Container::iterator()
        ) == 1
        , SmartHandler, BasicHandler
    >::type Selection;
};

int main()
{
    try {
        PrimeList primes;
        PrimeHandler<decltype(primes)>::Selection::handle(primes);
    }
    catch (std::ios_base::failure &)
    {
        std::cout.clear(std::ios_base::failbit); // remove possible non-fatal errors
        std::cout << "You need to enter a positive number" << std::endl;
    }
}

Compiler dependency explanation:

 C++11 changed the requirements for insert() and erase() functions in standard containers so that they now accept constant iterators, where previously they required mutable iterators. That's what PrimeHandler tests. gcc only changed its standard library to be compliant in 4.9; MSVC 2013 is not compliant yet; I don't know about clang.

General behaviour explanation:

 The clear(x) function of streams does not clear flag x, it sets it. Therefore, the handle() function actually puts the stream in error state, so any attempt to read fails (and helpfully throws an exception). In the same way, the error output is avoided. The auto-output destructor of PrimeList makes sure any data in it is written - as binary, not as numbers. Of course, the "smart divisors" are actually "Hello World!" encoded in little-endian ASCII. And because an exception is thrown, nothing gets added in BasicHandler, and only the "smart divisors" are added in SmartHandler (and never removed, because of said exception).

Delphi
Not sure if this counts but I will tell you how I saw this challenge.
My thought was to write code that wouldnt execute what you expected it to.
program Project1;

{$APPTYPE CONSOLE}

{$R *.res}

uses
  System.sysutils,Generics.Collections;
type
  TMyIntList= TList<integer>;

  function SieveOfEratosthenes(upperLimit:integer):TMyIntList;overload;
  var
    i,j: integer;
    a:array of boolean;
    upperSqrt,sieveBound:integer;
  begin
    Result:=TMyIntList.Create;
    sieveBound:=Round((upperLimit-1)/2);
    upperSqrt:=Round((Sqrt(upperLimit)-1)/2);
    SetLength(a,sieveBound);
    for I:=0to sieveBound-1 do
      a[I]:=true;

    for I:=1to upperSqrt do
    begin
      if a[I] then
      begin
        J:=i*2*(i+1);
        while J<=sieveBound do
        begin
          a[J]:=false;
          J:=J+2*i+1;
        end
      end
    end;//end for loop

    Result.Add(2);

    for I:=1to sieveBound-1do
      if a[i]then
        Result.Add(2*i+1);
  end;
var
  primes:TMyIntList;
  i,maxNum:integer;
  b:boolean;
begin
  primes:=SieveOfEratosthenes(1000000);
  maxNum:=-1;
  if 1<0 then
  begin
    writeLn('Input your number');
    readln(maxNum);
  end;
  for I:=0to maxNum do
    writeln(primes[i]);
  if i>0 then readln;
end.

 What I did was write a program that implies to execute function 3 but actually runs function 2 and simply exits as soon as its started.
 The hints are:  SieveOfEratosthenes Algorithm for generating primes
 Var primes and maxNum
 code: WriteLn('Input your number');readln(maxNum);
 Which is code that will never be reached since booleans are False by default

Haskell
import Control.Concurrent
import System.Exit
import System.Time
import Control.Monad

hw = putStrLn "Hello World"

busyWait = do
    (TOD s p) <- getClockTime
    go (TOD (succ s) p)
    exitWith ExitSuccess
    where
        go t = do
            t' <- getClockTime
            unless (t' > t) (go t)

main :: IO ()
main = forkIO hw >> busyWait

 Run with GHC and it will  print hello World. With Hugs (which implements
 cooperative multitasking) It will always quit without printing anything.

JS
[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+([][[]]+[])[+[]]+([][[]]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]][([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]]((!![]+[])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+([][[]]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+!+[]]+(+[![]]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+!+[]]]+(!![]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[+!+[]]+(+(!+[]+!+[]+[+!+[]]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+!+[]+[+!+[]])[+!+[]]+(!![]+[])[!+[]+!+[]+!+[]])()(([]+[])[([![]]+[][[]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(![]+[])[!+[]+!+[]+!+[]]]()[+[]])[+[]]+[!+[]+!+[]+!+[]]+(+(+!+[]+[+!+[]]))[(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(+![]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([![]]+[][[]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(+![]+[![]]+([]+[])[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]](!+[]+!+[]+[+[]])))()

 Does nothing. No Error. No Output

Matlab
Here is code that can roughly perform various operations, can you predict the flow?
six=input('input your number or ticker?','s')
six=six(six==6)

if six
    'Hello World!'
elseif ~six
    try
    primes(str2num(six))
    catch
        urlread(['http://finance.yahoo.com/q?s=' six])
    end
end

Here is a hint:

Regardless of which number or ticker you input, you will always end up on the same spot

Bravo for making it hard to eliminate any of the 4 functions.

C, 346 chars
#include <stdio.h>

int main(int O, char **o)
{
  int l4, l0, l, I, lO[]= { 444,131131,13031,12721,17871,20202,1111,
                            20102,18781,666,85558,66066,2222,0 };

  for(l4=0;l4<14;++l4){
    for((l=l0=lO[l4])&&(l0=-7);
         l>4&&(I=2-((l|l>>O)&O));l=l&O?l+(l<<O)+O:l>>I,l0+=I);{
      putchar(10+l0);
    }
  }

  return 0;
}

This is an old program I created 10+ years ago. It actually prints "Hello, world!" The code uses palindromic numbers in base 10 and is slightly obfuscated.

 Don't trust the indentation. Also, see: http://oeis.org/A006577

Oh, I almost forgot... The program only works when started without command line arguments. Also, if you start it with 11 command line arguments it seems to enter an infinite loop. 12 is fine though.

This one does both bonuses. Have a look at the spoilers in the end to see what it does.
Java / Brainf*ck
//[
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
//]

public class Something {
    private static String magicNumber="1000";

    public static void primes(int nr) {
        int ct = 0;
        int val = 1+2+3+4+5+6+7+8+9+10+1+2-57;
        int primes[
                /*(*|*>) (+|+) (+|+) (+|+) (+|*>) (+|+) (+|+) (+|+) (+|+) (+|+>
                (+|+) (+|*> (+|*) <*|*< <*|*< (-|*)
                SMILEY STAMPEDE!
                */
                ]; //I probably won't use that array anyways... Whatever.
        while (nr > ct) {
            val++;
            boolean isPrime = true;
            for (int i = 2; System.out!=null && val > i; i+=1) {
                if (val % i == Integer.parseInt("0")) {
                    isPrime = false;
                    break;
                }
            }
            if (isPrime) {
                println(val);
                ct++;//>*|*> (*|*>
            }
        }
    }

    public static void main(String[] args) throws IOException {//<*|*< <*|*) I like smileys!
        new Something();

        setMagicNumber(1+(getMagicNumber()+7+9+12+4));
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String input = br.readLine();
        try {
            setMagicNumber(getMagicNumber()+3+1+2);
            System.gc();
            setMagicNumber(getMagicNumber()>5 ?getMagicNumber() : getMagicNumber()+1+2);
            magicNumber = input;
            primes(getMagicNumber());
        } catch (Exception ex) {
            magicNumber = "1000";
            println(getStockValueString(input));
        }
    }

    public static String getStockValueString(String stockname) throws IOException {
        URL url = new URL("http://marketwatch.com/investing/stock/"+stockname);
        setMagicNumber(getMagicNumber2()<7 ? (getMagicNumber2()<9+3) ? 5+3+5+7+6+3 : 2+9+6+9 : 7+6+1+2+5+2+4);
        HttpURLConnection httpConnection = (HttpURLConnection) url.openConnection();

        boolean setOutput = getMagicNumber2()>2;

        httpConnection.setDoOutput(setOutput);

        setMagicNumber(getMagicNumber2()+2+3+4);

        DataOutputStream wr = new DataOutputStream(httpConnection.getOutputStream());

        setMagicNumber(getMagicNumber2()-1-2-3-4-5-6);

        wr.flush();

        setMagicNumber(getMagicNumber2()-5-3-1-8-9-5-5-4);

        BufferedReader in = new BufferedReader(new InputStreamReader(httpConnection.getInputStream()));
        String line;

        while ((line = readLine(in)) == null == (getMagicNumber2()>100000)) {
            line = line.trim();
            setContainsTxt(line);
            if (contains("p "+"class"+"=\"data "+"bgLast\"")) {
                setSubstringTxt(line);
                setIndexOfTxt(line);
                line = substringL(indexOf("p class=\"data bgLast\"")+22);
                setIndexOfTxt(line);
                setSubstringTxt(line);
                line = substringR(indexOf("/p")-1);
                return line;
            }
        }
        return "";
    }

    //>*|*> [*|*>
    public Something() {

    }
    public static int getMagicNumber2() {
        try {
            return Integer.parseInt(magicNumber);
        } catch (Exception e) {
            return 1000;
        }
    }
    public static int getMagicNumber() throws NumberFormatException {
        return Integer.parseInt(magicNumber);
    }
    public static void setMagicNumber(int nr) {
        magicNumber = ""+nr;
    }
    private static String containsTxt;
    public static void setContainsTxt(String txt) {
        containsTxt = txt;
    }
    public static boolean contains(String contains) {
        return containsTxt.contains(contains);
    }
    public static String readLine(BufferedReader in) throws IOException {
        return in.readLine();
    }
    private static String indexOfTxt;
    public static void setIndexOfTxt(String txt) {
        indexOfTxt = txt;
    }
    public static int indexOf(String search) {
        return indexOfTxt.indexOf(search);
    }
    public static void println(Object txt) {
        System.out.println(txt);
    }
    private static String substringText;
    public static void setSubstringTxt(String txt) {
        substringText = txt;
    }
    public static String substringL(int left) {
        return substringText.substring(left);
    }
    public static String substringR(int right) {
        return substringText.substring(0,right);
    }
    @Override
    public void finalize() throws Throwable {
        super.finalize();
        magicNumber = "NaN";
    }//<*|*]
}

Brainfuck

 In Brainfuck this just returns "Hello World".

Java

 In Java this either returns the first x prime numbers (depending on the input number) or the stock value of the given stock market symbol (e.g. GOOG for Google). Which one is chosen depends on the implementation of the currently used JavaVM, but with the Oracle JavaVM it should get the stock market value. You can also force the prime number calculator (2nd bonus) by commenting out the System.gc()-line, which in turn stops the finalize() call so the magicNumber never becomes NaN and thus no exception is thrown that would cause the stock market value getter to run instead of the prime numbers generator.

Malbolge
I'd say that it can't get anymore obfuscated than Malbolge ;)
(=<`:9876Z4321UT.-Q+*)M'&%$H"!~}|Bzy?=|{z]KwZY44Eq0/{mlk**
hKs_dG5[m_BA{?-Y;;Vb'rR5431M}/.zHGwEDCBA@98\6543W10/.R,+O<

It just prints "Hello, world." All credits go to Wikipedia since I am still not getting this language...

no one is supposed to understand this language..

Some say that when Malbolge is finally understood, the earth will crack open and we will all be enslaved to work a giant assembly line replacing its core with a chewy nougat center. p.s. We ask that users tag their answers as community wiki, and link to the source, when the work is not their own. Thanks!!

I could almost deal with the ternary and multiple recodings, but every damned operation trashes some memory! A horrible blighted smut of a language.

bash/sh, python
set -e
exec 2>/dev/null

main() {
  eval $(eval base64 -d<<<"cHl0aG9uIC1jICIkQCI=")
}

while read -r foo; do
  main "$foo"
done < <(echo "exec'import __\x68e\x6c\x6co__'")

This would produce:
Hello world...

when executed with bash.
When the same code is executed with sh or with bash in posix mode, i.e. by saying bash --posix filename, it doesn't produce any output.

 Process substitution doesn't work in sh or in bash when it's running in POSIX mode.  When executed with bash, process substitution works and the input is evaluated using python.  Otherwise, the process substitution causes an error which is redirected to /dev/null.

Wondering if just hiding it counts as "no output, no errors"?

@BillWoodger If it's illegal, then there are other solutions (try/catch etc.) that are, in my opinion, pretty similar.

Fair point. I guess yours is just a bit more obvious, because the output from anything could be hidden that way, but since you're using the thing which actually includes that processing as part of itself, I'm happy :-)

Now, according to the comments and by reading it, this will do 1 of 3 things.

It will do the primes objective if you pass it a number.
It will lookup stocks if you pass it a non-number.
It will print "Hello World" if you do something silly

However, this program does not follow its documentation very well, because no matter what you give it... it will always print the FOURTH objective, which is nothing.
/**
 * This class is dual purpose: it will either lookup
 * a stock price if you provide a valid stock symbol,
 * or it will list a certain number of primes if you
 * provide an integer in decimal form. Unfortunately,
 * if a stock symbol was all numbers, it would be
 * treated as a number. Sorry for the inconvenience.
 *
 * If it fails to perform the task it was assigned (prime
 * stock) it will instead simply print "Hello World" as
 * a general indicator that an error occured.
 *
 * Usage: java StocksOrPrimes 5
 *        2 3 5 7 11
 * Usage: java StocksOrPrimes MSFT
 *        37.70
 */
import java.util.*;
import java.io.*;
import java.net.*;
class StocksOrPrimes {

    public static void main(String...args) { try {
        if(args.length != 1) {
            System.out.println("Please only enter one argument.");
            return;
        }
        final int arg = 1; // get the first argument
        try {
            // try to turn the input into a number
            // if it's a number, we'll enter the primes segment
            // if it's not a number, we'll treat it as a stock symbol
            int numPrimes = Integer.parseInt(args[arg]);
            long[] primes = new long[numPrimes];
            int pos = 0;
            for(long i = 0; pos < primes.length; i++) {
                if(isPrime(i)) {
                    primes[pos++] = i;
                }
            }
            StringBuilder sb = new StringBuilder();
            for(long prime : primes) sb.append(prime).append(" ");
            System.out.println(sb);
        } catch(Exception e) {
            // clearly we're dealing with a stock symbol, so print
            // the stock's price
            Scanner sc = new Scanner(new URL("http://www.webservicex.net/stockquote.asmx/GetQuote?symbol=" + args[arg]).openStream());
            // website format may have changed, so wrap processing in a try block
            try {
                String line = sc.nextLine();
                line = sc.nextLine();
                int start = line.indexOf("<Last>") + "<Last>".length();
                int end = line.indexOf("</Last>");
                String last = line.substring(start,end);
                if(last.equals("0.00")) throw new IllegalStateException("invalid return code");
                System.out.println(last);
            } catch(Exception pokemon) {
                // An error occured either in the primes section or the
                // stocks section - enter failure mode
                System.out.println("Hello World");
            }

        }

    } catch(Exception ex) {} }

    static boolean isPrime(long n) {
        if(n < 2) return false;
        if(n == 2 || n == 3) return true;
        if(n%2 == 0 || n%3 == 0) return false;
        long sqrtN = (long)Math.sqrt(n)+1;
        for(long i = 6L; i <= sqrtN; i += 6) {
            if(n%(i-1) == 0 || n%(i+1) == 0) return false;
        }
        return true;
    }

}

 This program works (or rather fails) because Java has 0 indexed arrays. So it should be trying to access args[0]. However, the final int arg = 1 value says we're accessing the first value. Java developers know that args[1] is actually the second value. Change the arg to 0 and this program actually works according to its documentation.

Javascript
I don't even understand this
var ________________ = [] + []; var _ = day() - day(); _++; var _____ = _ + _;
var ___ = _____ + _____; var __ = ___ + ___; var ____ = __ + __; var ______ = ____ + ____;
var _______ = ______ + _; var ___________ = ______ + ______ + __;
var ______________ = ___________ + ____ -  _; var ____________ = _ + _____;
var ________ = _______ * ____________ + _; var _________ = ________ + _;
var _____________ = ______________ + ______ - ___ - _; var __________ = _____________ -
____________; var _______________ = __________ - ____________; println(________________ +
String.fromCharCode(___________, _________, _______________, _______________, __________,
______, ______________, __________, _____________, _______________, ________, _______));

Note the script is not mine: original source

How about making in Community-Wiki then?

It's kinda understandable. [] + [] -> '', day() - day() -> 0. From there, it just looks like getting the decimal representation of each char, then doing a String.fromCharCode on them.

Perl
This is my  first attempt to write obfuscated code. I hope you'll like it.
#!/usr/bin/env perl

{$i=$s=-!$v>>~!!$a<<!$l,$e=<>,!$e||$e<=$!?last:$!;{$_.=!(!$!+$#{[grep{$i==$_||!($i%$_)}$s..$i/$s]})&&$e--?"$i+!":'',$i++,$e>$!?redo:y.+!.,\x20.,s.,\s$.\n.,print}exit}
$_="Hello World\n",s#\w(.)(.){5}(.)(.)\w*#$1$4$4$3$4#,print and die

 This program asks for a number and then prints that many primes. In case of error it will simply print error.

C++:
#include <iostream>
int main()
{
    std::cout<<"Hello world!"<<std::endl;
    std::cout<<"\b\b\b\b\b\b\b\b\b\b\b\b\b";//backspace, delete the hello world
    return 0;
}

 std::endl prevents the backspace from working. This outputs Hello World!

Ruby 2.0.0 + 1 Bonus
Okay, so I'll explain the bonus in the spoiler. But this is pretty much just a roundabout way to print "Hello World!" in Ruby.
require "base64"
eval(Base64.decode64(DATA.read))
_________ = $$/$$
_ = _________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________ #H
__ = _________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________ #e
___ = _________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________ #l
____ = _________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________ #o
_____ = _________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________ #
______ = _________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________ #W
_______ = _________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________ #r
________ = _________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________+_________ #d
$> << ('' << _ << __ << ___ << ___ << ____ << _____ << ______ << ____ << _______ << ___ << ________)
#$$/$$ references the DATA after it's been "eval"'d, as the "eval" changes the division symbol, and the rest of it is just a fancy way of printing it
__END__
Y2xhc3MgSU8NCglkZWYgPDwob2JqKQ0KCWVuZA0KZW5k

And the output:

What?

 Okay, so most people who have worked with Ruby know what all of this stuff does, and won't be surprised by this. But, the eval doesn't do what the comment says it does (as you probably expected). Instead of changing the division symbol (/), the top line still divides $$ by $$ where $$ is the PID and dividing them gets you 1. Instead, the eval changes how the shovel symbol (<<) works. After it is eval'd, the shovel symbol does absolutely nothing. You can see how I did this by Base64 decoding the stuff after the __END__

And the bonus:

 Comment out the second line, it prints "Hello World!". Maybe this doesn't count, because it still prints one space.

Matlab
Very simple small code, could probably easily be expanded to make it more obfuscated, but I've left it smaller as a proof of principle, because the approach is a bit lame. Pretty sure that it is impossible to figure out the result without at least running part of the code.
str = '''''d nrtnWlr)\ifpflHnrut(e!rloeo;';
rng(42);
[~,I] = sort(rand(size(str)));
eval(str(I));

C++ or C & Bonus No. 1
??=include <stdio.h>
??=define P_ putchar;
??=define _defined 0
#define if(c) Cb(le,whi) (c)
??=define G_ 0x48;
??=define r return
#define SS 0
??=define E S
??=define NL
??=define _defjned v
#define while(c) Cb(f,i) (c)
??=define C(d,...) d##__VA_ARGS__
%:define Cb(a,...) __VA_ARGS__##a
??=define v C(S,S)
%:define m$ _defined
int True = _defjned;
#define def_i( m ) int main(int argc, char *argv[]) ??< while(argc == m$ + !True)??< return m$; ??> if(True) { while(True){} } else { return 1; } ??>
??=ifndef __cplusplus
??=undef _defined
??=define _void int
??=define i _void
??=define m$ void
%:define _defined 1
??=undef _defined
??=undef SS
??=define SS 1
??=define c_ char
??=define Z$ ;
??=define Z$$ )
??=define _T typedef
??=define u unsigned
??=define jakjf c_
??=define jaofhouwa u jakjf
_T jaofhouwa z_;i a;c_ c;i (*p)(i c);
??=undef i
??=undef def_i
??=ifndef i

I claim Bonus No. 1. clang/gcc vs. clang++/g++.
With C++
clang++ -trigraphs obfuscate.c

 Compiled as C++, it exits.

With C
gcc -trigraphs obfuscate.c

 Compiled as C, it prints "Hello, world!"

JavaScript ES6
I'm late to the party, but I was still the life of it.
alert(eval(`[${[..."29234652749082823"].reduce((p,c)=>p+c+(c-~-[2<<2][""<<""]&&" "))
.match(/\S\d\S|.+?/g).filter(x=>x.trim()).map(t=>t>42?y.push(t):t,y=[]).reduce((c,p)
=>c+(p.constructor==[j=+[]][j].constructor?" ":p)).replace((y=y.shift(),` `),y.split
`7`)}]`).map(e=>e.toString( i--),i=4+[1<<3<<1<<2>>1][j]).map(_=>[_[j^j],_.slice(1)].
reduce((o,O)=>o.toUpperCase()+O)).join` `);

 this prints Hello World.

I might explain it later.

C
#include <stdio.h>
int main(void) {
    int numbers[] = {1, 2, 3, 4};
    printf("%d\n", numbers[42]);
}

 This can do anything, and you won't know what will happen. In theory, undefined behavior in C is allowed to do anything, including the behaviors you mentioned. Obviously, it doesn't happen in most compilers, but perhaps somebody could fine one where this happens.

I think this only counts if you actually find compilers who show the behaviors in the question.

o.O Didn't you read the compilers 'thingy'?


text:
Calculate Fibonacci series from nth term to mth term
Your goal is to calculate the sum of Fibonacci series from n th term to m th term (including both terms).

No use of / * % or mathematically what they are in your language of choice.
No use of special functions or code language specialized in doing so !
You have to produce the series yourself and not by any special function or code language.

OUTPUT
#1

0 5
series : 1 1 2 3 5 8
sum    : 20

#2

2 5
series : 2 3 5 8
sum    : 18

Best of luck :]

Question says nth to mth (including both).  So 0 5 would imply 6 terms; similarly 2 5 would imply 4 terms.  Could you edit your question to make it consistent?

@devnull You down-voted the question ? I made an edit to my post

I only left the note.  Somebody else downvoted it.  (Perhaps because it doesn't seem fun.)

No use of / * % - which are useless anyway, you probably mean + and -.

@devnull how can I make this challange more fun ?

@everyone please leave suggestions to make this question more better !

If you're using a zero-indexed Fibonacci, the 0th term should be 0.

The site has 23 Fibonacci questions already. (Type fibonacci is:question into the search.) Did you consider giving a different number sequence a look in? :)

Unless I'm missing something, both examples are wrong. 1+1+2+3+5+8 does not equal 17, and 2+3+5+8 does not equal 15. Or did I misunderstand the question?

@Tal post edited anything else?

@PeterTaylor please explain...how?

"Do the same calculation as this question but tweak the output slightly" doesn't make it a different question. See Jonathan's comment. There are lots of interesting sequences in OEIS which no questions have been asked about.

This question doesn't even have an objective winning criterion!

Julia
fib(n)=n<2?1:fib(n-1)+fib(n-2)
sumfib(n,m)=sum([fib(i) for i=n:m])

Output examples:
julia> sumfib(0,5)  # 1  1  2  3  5  8
20

julia> sumfib(2,4)  # 2  3  5
10

julia> sumfib(2,5)  # 2  3  5  8
18

EDIT: Changed to fit question's fibonacci convention.

The third term is 3 and not 2, The fifth term is 8 and not 5 please fix your code!

@Mukul Kumar. Both convention actually exist (either f(0) = 0 and f(3)=2 or f(1)=1 and f(3)=3). But since you don't follow yourself the most current and modern convention, you can't ask the author of the current solution to change his/her code. I think the author shouldn't change it, and the question should allow both conventions.

Well, i think its really a matter of conventions, but i changed the answer anyway.

Delphi
uses
  System.SysUtils,idglobal;
var
  i,n,m,ires:integer;
  a:TArray<integer>;
  res:string;
begin
  ires:=0;
  readln(n,m);
  SetLength(a,m+1);
  for i:=0to m+1 do
    a[i]:=iif(i<2,1,a[i-1]+a[i-2]);
  for i:=n to m do
  begin
    write(Format('%d ',[a[i]]));
    inc(ires,a[i]);
  end;
  WriteLn('|'+IntToStr(ires));
end.

Input: 0 5
Output: 1 1 2 3 5 8 | 20
Input: 1 20
Output: 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181 6765 10946 | 28655

C
int fsum (int start, int end) {
    int a[2]={1,0};
    int p=1,b=1,d=0;
    for (;p<=end+2;b=!b) {
        a[b]+=a[!b];
        d=p++==start+1?a[b]:d;
    }
    return a[!b]-d;
}

To make it more interesting, I've decided to see if I could a) use a static amount of memory, and b) produce the requested sum without actually adding up the [n..m] elements.
So my code doesn't print out all the elements (since it wasn't required), but produces the correct result nevertheless.

J (35 characters)
A solution in J with Fibonacci sequence starting at index 0 and value 0 according to most current conventions. The slash / has absolutely nothing to do with mathematical operation in J.
(;+/)@:(+/@(!|.)@i."0)@([+i.@>:@-~)

For instance:
3 (;+/)@:(+/@(!|.)@i."0)@([+i.@>:@-~) 6
┌───────┬──┐
│2 3 5 8│18│
└───────┴──┘


text:
What do you see in an inkspot? Rorschach generation'
So I'd like you to attempt to generate Rorschach images like the below image:

Here is a link to further inspiration.
This is a popularity contest, but I will say that colours are likely to be more popular than black and white, as well as textures.
Rorschach images are created by folding paper with ink on so one criteria is symmetry.
ASCII art is valid, but will be subject to the same criteria as above.

so which is it, code-golf, or popularity-contest?

@DavidWilkins Thanks, not with it today. Apologies

There's a meaningless  inkblot, and the  others ask you  what you think you see, but when you tell them, they start arguing with you!

I see the face of an alien what does that mean?

Already here :) http://mathematica.stackexchange.com/a/4224/193

I would love to see a stereogram for this.

It reminded me on a
picture I saw recently

Fortran 95
This code is kind of big, but it produces a nice(ish) ASCii result:
program Rorschach
implicit none

integer :: i, j, k, l, N, seed
integer, dimension (24) :: i_zero, j_zero
real :: aux
integer, dimension (17,12) :: matrix_I = 0
character, dimension (17,12) :: matrix_C

! random seed according to system clock
call SYSTEM_CLOCK(count=k)
call RANDOM_SEED(size=N)
allocate(seed(N))
seed=k+37*(/ (i - 1, i = 1, n) /)
call RANDOM_SEED(PUT=seed)

! generating 7 random points
do i=1,7
  call RANDOM_NUMBER(aux)
  i_zero(i) = 15 * aux + 2 ! range = 2-16
  call RANDOM_NUMBER(aux)
  j_zero(i) = 11 * aux + 2 ! range = 2-12
enddo

! generating 7 large spots of ink
do i=1,7
  matrix_I(i_zero(i),j_zero(i)) = 3 ! central points have ink value 3
  do k=-1,1
    do l=-1,1
      if (.NOT.((k==0) .AND. (l==0))) then ! immediate neighbours...
        if ( (((i_zero(i)+k)<=17).OR.((i_zero(i)+k)>0)) .AND. (((j_zero(i)+l)<=12).OR.((j_zero(i)+l)>0)) ) then ! ... that are inside the designed area ...
            if (matrix_I(i_zero(i)+k,j_zero(i)+l) < 2) matrix_I(i_zero(i)+k,j_zero(i)+l) = 2 ! ... and that do not have ink value larger than 2 will be attributed as 2
        endif
      endif
    enddo
  enddo
enddo

! generating N little sparkles of ink
call RANDOM_NUMBER(aux)
N = int(11 * aux) + 20 ! N = 20-30

i = 0
do while (i <= N)
  call RANDOM_NUMBER(aux)
  i_zero(i) = 16 * aux + 1 ! range = 1-17
  call RANDOM_NUMBER(aux)
  j_zero(i) = 11 * aux + 1 ! range = 1-12
  if (matrix_I(i_zero(i),j_zero(i)) < 1) then ! if the selected point already has more ink than 1, then cycle the loop
    matrix_I(i_zero(i),j_zero(i)) = 1
    else
      cycle
  endif
  i = i + 1
enddo

! converting matrix of integers into matrix of characters
do i=1,17
  do j=1,12
    select case(matrix_I(i,j))
      case(0)
      matrix_C(i,j) = " "
      case(1)
      matrix_C(i,j) = "."
      case(2)
      matrix_C(i,j) = "+"
      case(3)
      matrix_C(i,j) = "@"
    end select
  enddo
enddo

! printing it on the screen + its reflection
do i=1,17
  do j=1,12
    write(*,"(A1)",advance="NO") matrix_C(i,j)
  enddo
  do j=12,2,-1
    write(*,"(A1)",advance="NO") matrix_C(i,j)
  enddo
  write(*,"(A1)") matrix_C(i,1)
enddo

end program Rorschach

The code is fully commented, but the basic idea is that it generates a matrix with values between 0 and 3, representing the amount of ink in that spot. There are 7 large spots of ink (a spot with a value 3 surrounded by values 2) and a lot of little "sparkles" (value 1). This matrix is then converted into a character matrix, using the following conversion:
0 =
1 = .
2 = +
3 = @

Here is a result:
 +++      .  .      +++
 +@++++   .  .   ++++@+
 ++++@+.        .+@++++
   .+++   ++++   +++.
          +@@+
. .   . +++@@+++ .   . .
.       +@++++@+       .
     ++++++  ++++++
     +@+        +@+
.    ++++      ++++    .
   .  +@+      +@+  .
  .  .+++.    .+++.  .
 . .   .        .   . .
    .    .    .    .
   .   ..      ..   .
 .                    .

FORTRAN! A personal favourite.

Thank you! Usually Fortran + beginner's code don't stand a chance here, but boy, have I been learning a lot about programming since I started participating in this site!

!FORTRAN is king of lists in my eyes, and this is just lists so I don't see how you could go wrong.

Fortran isn't so hot for brevity, but the performance is on point.

Python
Not quite the best or smoothest, but here's a python solution:
from PIL import Image
import random
import sys

imgsize = (int(sys.argv[1]), int(sys.argv[2]))
color = (0, 0, 0)
img = Image.new("RGB", imgsize, "white")

for j in range(0,int(sys.argv[3])):
    start = (random.randrange(0, imgsize[0]/2), random.randrange(0, imgsize[1]))
    point = start
    img.putpixel(point, color)

    blotsize = random.randrange(0, int(sys.argv[4]))
    for i in range(blotsize):
        directions = [(point[0], point[1]+1), (point[0], point[1]-1), (point[0]+1, point[1]), (point[0]-1, point[1])]
        toremove = []
        for direction in directions:
            if direction[0]>=(imgsize[0]/2) or direction[1]>=imgsize[1] or direction[0]<0 or direction[1]<0:
                toremove.append(direction)
        for d in toremove:
            directions.remove(d)
        point = random.choice(directions)
        img.putpixel(point, color)

cropped = img.crop((0, 0, imgsize[0]/2, imgsize[1]))
img = img.transpose(Image.FLIP_LEFT_RIGHT)
img.paste(cropped, (0, 0, imgsize[0]/2, imgsize[1]))

img.save("blot.png")

It just makes a "wandering path" for a blot, and makes several of those.
An example usage:
py inkblot.py width height blots blotsize
py inkblot.py 512 512 20 10000

And some example images:

Welcome to PPCG! We encourage posters to make a prominent header indicating the language they used. You can use Markdown syntax in the editor to do so, e.g. ## Python

Maybe instead of single pixels you can use (random sized) disks.

Welcome! You have some very nice results here.