text:
Love calculation
As a kid my sister showed me this little love calculation to see how much chance you have of getting in a successful relationship with your crush. All you need is 2 names and a piece of paper.

John
Jane

Then, you separate these names with the word Loves. You can either write this on one line or on new lines.

John
  Loves
  Jane

Then the calculating begins. You start off by counting how many times a character occurs from left to right and in case you use new lines also from top to bottom.
Each character is counted once, So after counting the J of John you don't have to count them again when you start with Jane.
The result of this example will be as follows:

J: 2 ([J]ohn | [J]ane)
  O: 2 (J[o]hn | L[o]ves)
  H: 1 (Jo[h]n)
  N: 2 (Joh[n] | Ja[n]e)
  __
  L: 1 ([L]oves)
  O: skipped
  V: 1 (Lo[v]es)
  E: 2 (Lov[e]s | Jan[e])
  S: 1 (Love[s])
  __
  J: skipped
  A: 1 (J[a]ne)
  N: skipped
  E: skipped
  __
  Final result: 2 2 1 2 1 1 2 1 1

The next step will be adding the digits working from the outside to the middle.

2 2 1 2 1 1 2 1 1 (2+1=3)
  2 2 1 2 1 1 2 1 1 (2+1=3)
  2 2 1 2 1 1 2 1 1 (1+2=3)
  2 2 1 2 1 1 2 1 1 (2+1=3)
  2 2 1 2 1 1 2 1 1 (1)
  __
  Result: 3 3 3 3 1

You will keep doing this until you have an integer left less or equal to 100.

3 3 3 3 1
4 6 3
76%

It can happen that the sum of 2 digits becomes ≥ 10, in this case the number will be split in 2 on the next row.
Example:

5 3 1 2 5 4 1 8
  13 (Will be used as 1 3)
  1 3 4 5 7
  8 8 4 (8+4=12 used as 1 2)
  1 2 8
  92%

Requirements

Your program should be able to accept any name with reasonable length  (100 characters)
[A..Z, a..z] characters are allowed.
Case insensitive so A == a

Free for you to decide

How to handle special characters (Ö, è, etc.)
Include last names yes or no, spaces will be ignored
Any language is allowed.

Winner will be determined by votes on the  28th 14th of February.
Happy coding
P.s. This is the first time I put something up here, if there is any way to improve it feel free to let me know =3
Edit: Changed end date to valentines day, thought that would be more appropriate for this challenge :)

Your example doesn't show what happens when an even number of numbers need to be added, or when you have a number with 2 digits. Better add those to clarify.

Do you add numbers or digits? E.g. what are the next two lines after 5 6 7?

@Howard Yeah, I'd really like to know. It's probably digits; adding numbers will start failing at around 60 or 70, and the OP expects 100.

@KendallFrey I dont understand your comment. What do you mean with an even number of numbers? in this example I ended with a single 1 (first row)which basicly means 1+0=1. With an even number you end up with 2 numbers so you will add those. 1+1=2. Does that answer your question?

1 1 2 3 5 8 becomes 9 6 5 becomes 14 6 becomes 20, am I correct?

@Howard I added some more info on that matter. @KendallFrey Same info goes for this situation. 9 6 5 becomes indeed 14 6 but 14 will be used as 1 4 making the total 74

Your example has an error. 1 3 4 5 6 should be 1 3 4 5 7

@KendallFrey Oops, lol thanks ^.^

You forgot to fix all the numbers below it :)

facepalm xD

So calculation stops at 91%. Strange. I know quite many cases where continuing to 10% or even better 1% would give much more realistic score. With such a clearly commercial manipulation of the calculation I bet this is actually the one used by the SMS love calculator services.

@manatwork Lol, I see what you did there, regardless of how correct you are (which will be somewhere between the 99.99999% and 100%) I do believe people like to get (more or less) positive scores, dont you agree? :) although it would save a lot of money on divorces..

inb4 somebody posts code in the shape of a heart and wins popularity

Am I seriously the only one who thought this was bool false/1:true/2 for the string counters matching? The example matches my logic perfectly.

The n in John is not is the same column as the n in Jane.  Is this a mistake, or how did you get 2 n's?

@user2509848 the columns on the first few letters were a coincidence, and not a requirement. You just count the number of occurrences of the letter.

Wonder how the results change if you convert the names (and "love") to their ASCII integer codes.  For that matter, what happens if you replace "love" with "hate" -- you'd hope to get   1-love_result  :-)

@Danny Yes, I know.  However, there are not 2 n's in the same column, so how could you count them twice?

@user2509848: The algorithm simply doesn’t care about columns. You count 2 n’s because there are 2 n’s, irrespective of what column they’re in.

Oh, now I get it.

Sclipting
글⓵닆뭶뉗밃變充梴⓶壹꺃뭩꾠⓶꺐合合替虛終梴⓷縮⓶終併❶뉀大套鈮⓶充銻⓷加⓶鈮⓶終併❶뉀大終깐

Expects the input as two space-separated words (e.g. John Jane). It’s case-insensitive, but supports only characters that are not special regex characters (so don’t use ( or * in your name!). It also expects only two words, so if your love interest is “Mary Jane”, you have to put MaryJane in one word; otherwise it will evaluate "YourName loves Mary loves Jane".
Explanation
The hardest part was to handle the case of odd number of digits: you have to leave the middle digit alone instead of adding it with itself. I think my solution is interesting.
글⓵닆뭶뉗밃變 | replace space with "loves"
充 | while non-empty...
    梴 | get length of string
    ⓶壹 | get first character of string (let’s say it’s “c”)
    꺃뭩꾠⓶꺐合合 | construct the regex “(?i:c)”
    替虛終 | replace all matches with empty string
    梴 | get new length of that
    ⓷縮 | subtract the two to get a number
    ⓶ | move string to front
終 | end while
併 | Put all the numbers accrued on the stack into a single string
❶뉀大 | > 100
套 | while true...
    鈮⓶ | chop off the first digit
    充 | while non-empty... (false if that digit was the only one!)
        銻⓷加 | chop off last digit and add them
        ⓶鈮⓶ | chop off the first digit again
                 (returns the empty string if the string is empty!)
    終 | end while
    併 | Put all the numbers (± an empty string ;-) ) on the stack into a single string
    ❶뉀大 | > 100
終 | end while
깐 | add "%"

When you’re left with something ≤ 100, the loop will just end, the answer will be on the stack and therefore output.

case-insensitivenes is marked as requirement. can't you add that adding/substracting from char values, or with regex?

And I thought APL was difficult to read ...

@Einacio: You are right. I fixed that.

Hi Timwi, I can see you're back in the game :p nice solution

Wait, he invented his own language for codegolf?! That's cheating!

Actually this language is (sort of) readable (if you know Chinese).

@Moo Why? It's not tailored to any specific task. So does that mean golfscript is cheating?

@MooingDuck: My understanding of the rule is that you can’t use a language that was published after the challenge was published. Therefore, I make a point of always using only instructions I introduced before. For example, I introduced 改 (case-insensitive string-replace) in response to this challenge, but I’m not going to make use of it here.

In case anyone else was wondering, it's 46 characters long, which is up to 184 bytes in unicode. Maybe. I'm not very good at character encodings.

@CamJackson: It’s 92 bytes. All instructions in Sclipting are 2 bytes in UTF-16. ... But this isn’t tagged code-golf :)

Funciton
This program expects the input separated by a space (e.g. John Jane). It is case-insensitive for characters A-Z/a-z; for any other Unicode character, it will “confuse” two characters that are equal when or’ed with 32 (e.g. Ā and Ġ, or ? and _). Furthermore, I have no idea what this program will do if the input contains a NUL (\0) character, so don’t use that :)
Also, since StackExchange adds too much line spacing, here is the raw text on pastebin. Alternatively, run the following code in your browser’s JavaScript console to fix it right here: $('pre').css('line-height',1)
                               ╓───╖ ╓───╖ ╓───╖ ╓───╖ ╓───╖ ╓───╖
                               ║ Ḷ ║┌╢ Ọ ╟┐║ Ṿ ║ ║ Ẹ ║┌╢ Ṛ ╟┐║ Ṣ ╟┐
                               ╙─┬─╜│╙───╜│╙─┬─╜ ╙─┬─╜│╙─┬─╜│╙─┬─╜│
                                 │  │     │  │     │  │  │  │  │  │
                                 │  │     │  │     │  │  │  │  │  │
                                 │  │     │  │     │  │  │  │  │  │
                                 │  │     │  │     │  │  │  │  │  └───────────┐
                                 │  │     │  │     │  │  │  │  └─────────────┐│
                         ┌───────┘  │     │  │     │  │  │  └───────────────┐││
                         │┌─────────┘     │  │     │  │  └─────────────────┐│││
                         ││┌──────────────┘  │     │  └───────────────────┐││││
                         │││     ┌───────────┘     └──────────────────┐   │││││
                         │││ ┌───┴───┐  ┌─────────────────────────────┴─┐ │││││
                         │││ │ ╔═══╗ │  │                               │ ││││└─────────┐
                         │││ │ ║ 2 ║ │  │     ┌───┐   ┌───┐             │ │││└─────────┐│
                         │││ │ ║ 1 ║ │  │    ┌┴┐  │  ┌┴┐  │             │ ││└─────────┐││
                         │││ │ ║ 1 ║ │  │    └┬┘  │  └┬┘  │             │ │└─────────┐│││
┌────────────────────────┘││ │ ║ 1 ║ │  │   ┌─┴─╖ │ ┌─┴─╖ │     ┌───╖   │ └─────────┐││││
│┌────────────────────────┘│ │ ║ 0 ║ │  │   │ ♯ ║ │ │ ♯ ║ ├─────┤ ℓ ╟───┴─┐         │││││
││┌────────────────────────┘ │ ║ 6 ║ │  │   ╘═╤═╝ │ ╘═╤═╝ │     ╘═══╝   ┌─┴─╖       │││││
│││                    ┌─────┘ ║ 3 ║ │  │    ┌┴┐  │  ┌┴┐  └─────────────┤ · ╟──────┐│││││
│││┌───────────────────┴┐┌───╖ ║ 3 ║ │  │    └┬┘  │  └┬┘                ╘═╤═╝      ││││││
││││                   ┌┴┤ = ╟─╢ 3 ║ │  │ ┌───┘   └───┴─────┐         ┌───┴───┐    ││││││
││││      ╔════╗ ┌───╖ │ ╘═╤═╝ ║ 1 ║ │  │ │ ╔═══╗         ┌─┴─╖       │ ╔═══╗ │    ││││││
││││      ║ 37 ╟─┤ ‼ ╟─┘ ┌─┘   ║ 9 ║ │  │ │ ║ 1 ║ ┌───────┤ · ╟─┐     │ ║ 0 ║ │    ││││││
││││      ╚════╝ ╘═╤═╝  ┌┴┐    ║ 6 ║ │  │ │ ╚═╤═╝ │       ╘═╤═╝ ├─────┘ ╚═╤═╝ │    ││││││
││││ ┌───╖ ┌───╖ ┌─┴─╖  └┬┘    ║ 3 ║ │  │ │ ┌─┴─╖ │ ╔═══╗ ┌─┴─╖ │ ╔═══╗ ┌─┴─╖ │    ││││││
│││└─┤ Ẹ ╟─┤ Ṿ ╟─┤ ? ╟───┤     ║ 3 ║ │  │ └─┤ ʃ ╟─┘ ║ 1 ╟─┤ ʃ ╟─┘ ║ 1 ╟─┤ ʃ ╟─┘    ││││││
│││  ╘═══╝ ╘═══╝ ╘═╤═╝  ┌┴┐    ║ 7 ║ │  │   ╘═╤═╝   ╚═══╝ ╘═╤═╝   ╚═══╝ ╘═╤═╝      ││││││
│││                │    └┬┘    ╚═══╝ │  │     │  ┌──────────┘             └──────┐ ││││││
│││              ╔═══╗ ┌─┴─╖ ┌───╖   │  │     │  │ ┌─────────╖ ┌───╖ ┌─────────╖ │ ││││││
│││              ║ 3 ╟─┤ > ╟─┤ ℓ ╟───┘  │     │  └─┤ str→int ╟─┤ + ╟─┤ str→int ╟─┘ ││││││
│││              ╚═══╝ ╘═══╝ ╘═══╝      │     │    ╘═════════╝ ╘═╤═╝ ╘═════════╝   ││││││
││└───────────────────────────────────┐ │     │             ┌────┴────╖            ││││││
│└───────────────────────────────┐    │ │     │             │ int→str ║            ││││││
│          ╔═══╗                 │    │ │     │ ┌───╖ ┌───╖ ╘════╤════╝            ││││││
│          ║ 0 ║                 │    │ │     └─┤ Ẹ ╟─┤ ‼ ╟──────┘                 ││││││
│          ╚═╤═╝                 │    │ │       ╘═══╝ ╘═╤═╝   ┌────────────────────┘│││││
│    ╔═══╗ ┌─┴─╖                 │    │ │             ┌─┴─╖ ┌─┴─╖ ╔═══╗             │││││
│    ║ 1 ╟─┤ ʃ ╟─────────────────┴┐   │ └─────────────┤ ? ╟─┤ ≤ ║ ║ 2 ║             │││││
│    ╚═══╝ ╘═╤═╝                  │   │               ╘═╤═╝ ╘═╤═╝ ╚═╤═╝             │││││
│          ┌─┴─╖                  │   │                 │     └─────┘               │││││
│        ┌─┤ Ṣ ╟──────────────────┴┐  │    ╔═══╗   ┌────────────────────────────────┘││││
│        │ ╘═╤═╝                   │  │    ║   ║   │  ┌──────────────────────────────┘│││
│        │ ┌─┴─╖                   │  │    ╚═╤═╝   │  │    ┌──────────────────────────┘││
│        └─┤ · ╟─────────────┐     │  │    ┌─┴─╖   │┌─┴─╖┌─┴─╖                         ││
│          ╘═╤═╝             │     │  │    │ Ḷ ║   └┤ · ╟┤ · ╟┐                        ││
│      ┌─────┴───╖         ┌─┴─╖ ┌─┴─╖│    ╘═╤═╝    ╘═╤═╝╘═╤═╝│                        ││
│      │ int→str ║ ┌───────┤ · ╟─┤ · ╟┴┐     │      ┌─┴─╖  │  │                        ││
│      ╘═════╤═══╝ │       ╘═╤═╝ ╘═╤═╝ │           ┌┤ · ╟──┘  │                        ││
│            │   ┌─┴─╖ ┌───╖ │     │   │         ┌─┘╘═╤═╝   ┌─┴─╖                      ││
│            │   │ ‼ ╟─┤ Ọ ╟─┘     │   │         │ ┌──┴─────┤ · ╟───────┐              ││
│            │   ╘═╤═╝ ╘═╤═╝       │   │         │ │ ╔════╗ ╘═╤═╝ ╔═══╗ │              ││
│            └─────┘     │         │   │         │ │ ║ 21 ║   │   ║ 2 ║ │              ││
│                ┌───╖ ┌─┴─╖       │   │  ┌──────┘ │ ╚═══╤╝   │   ║ 0 ║ │              ││
│            ┌───┤ Ṿ ╟─┤ ? ╟───────┘   │  │┌───╖ ┌─┴─╖ ┌─┴──╖ │   ║ 9 ║ │              ││
│            │   ╘═══╝ ╘═╤═╝           │ ┌┴┤ ♯ ╟─┤ Ṛ ╟─┤ >> ║ │   ║ 7 ║ │              ││
│            │           │             │ │ ╘═══╝ ╘═╤═╝ ╘══╤═╝ │   ║ 1 ║ │              ││
│            └─────────┐   ┌───────────┘ │ ╔═══╗ ┌─┴─╖    ├───┴─┬─╢ 5 ║ │              ││
└───────────────────┐  └───┘             │ ║ 0 ╟─┤ ? ╟────┘     │ ║ 1 ║ │              ││
╔════╗              │                    │ ╚═══╝ ╘═╤═╝   ┌──────┤ ╚═══╝ │              ││
║ 21 ║              │                    │       ┌─┴─╖ ┌─┴─╖ ╔══╧══╗    │              ││
╚═╤══╝              │                    └───────┤ ? ╟─┤ ≠ ║ ║ −33 ║    │              ││
┌─┴─╖ ┌────╖        │                            ╘═╤═╝ ╘═╤═╝ ╚══╤══╝   ┌┴┐             ││
│ × ╟─┤ >> ╟────────┴────────────┐                 │     └──────┤      └┬┘             ││
╘═╤═╝ ╘═╤══╝ ┌───╖   ╔═════════╗ │                              └───────┘              ││
┌─┴─╖   └────┤ ‼ ╟───╢ 2224424 ║ │                ┌────────────────────────────────────┘│
│ ♯ ║        ╘═╤═╝   ║ 4396520 ║ │                │    ┌────────────────────────────────┘
╘═╤═╝        ┌─┴─╖   ║ 1237351 ║ │                │    │    ┌─────────────────────┐
  └──────────┤ · ╟─┐ ║ 2814700 ║ │                │  ┌─┴─╖  │     ┌─────┐         │
             ╘═╤═╝ │ ╚═════════╝ │              ┌─┴──┤ · ╟──┤     │    ┌┴┐        │
 ╔═══╗ ┌───╖ ┌─┴─╖ │   ╔════╗    │            ┌─┴─╖  ╘═╤═╝┌─┴─╖   │    └┬┘        │
 ║ 0 ╟─┤ Ọ ╟─┤ ‼ ║ │   ║ 32 ║    │   ┌────────┤ · ╟────┴──┤ Ṛ ╟───┤   ┌─┴─╖       │
 ╚═══╝ ╘═╤═╝ ╘═╤═╝ │   ╚═╤══╝    │   │        ╘═╤═╝       ╘═╤═╝   │   │ ♯ ║       │
         │   ┌─┴─╖ ├─┐ ┌─┴─╖     │ ┌─┴─╖      ┌─┴─╖       ╔═╧═╗   │   ╘═╤═╝       │
           ┌─┤ ʃ ╟─┘ └─┤ ʘ ║     │┌┤ · ╟──────┤ · ╟───┐   ║ 1 ║   │    ┌┴┐        │
           │ ╘═╤═╝     ╘═╤═╝     ││╘═╤═╝      ╘═╤═╝   │   ╚═══╝   │    └┬┘        │
           │ ╔═╧═╗       ├───────┘│  │       ┌──┴─╖ ┌─┴─╖ ┌───╖ ┌─┴─╖ ┌─┴─╖ ╔═══╗ │
           │ ║ 0 ║       │        │  │       │ >> ╟─┤ Ṣ ╟─┤ ‼ ╟─┤ · ╟─┤ ʃ ╟─╢ 0 ║ │
           │ ╚═══╝       │        │  │       ╘══╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╘═╤═╝ ╚═══╝ │
           └─────────────┘        │  │ ╔════╗ ┌─┴─╖ ┌─┴─╖ ┌─┴─╖ ┌─┘     ├─────────┘
                                  │  │ ║ 21 ╟─┤ × ╟─┤ · ╟─┤ · ╟─┴─┐     │
                                  │  │ ╚════╝ ╘═══╝ ╘═╤═╝ ╘═╤═╝   │     │
                                  │  └────────────────┘   ┌─┴─╖   │     │
                                  │                   ┌───┤ ? ╟───┴┐    │
                                  │                   │   ╘═╤═╝    │    │
                                  │           ┌───╖ ┌─┴─╖   │    ┌─┴─╖  │
                                  └───────────┤ ♯ ╟─┤ · ╟─┐   ┌──┤ ? ╟─ │
                                              ╘═══╝ ╘═╤═╝ └───┘  ╘═╤═╝  │
                                                      │          ╔═╧═╗  │
                                                      │          ║ 0 ║  │
                                                      │          ╚═══╝  │
                                                      └─────────────────┘

Quick explanation

The program just takes STDIN and calls Ḷ with it.
Ḷ finds the first space in the string, replaces it with loves and passes the result to Ọ.
Ọ repeatedly takes the first character from the input string, calls Ṣ with it and concatenates the numbers of occurrences onto a result string. When the input string is empty, it calls Ṿ with the result string.
Ṿ repeatedly calls Ẹ until it gets a result that is either equal to "100" or has length less than 3. (100 can actually occur: consider the input lovvvv eeeeeess.) When it does, it adds "%" and returns that.
Ẹ computes one complete iteration of the love-computation algorithm; i.e., it takes a string of digits and returns the next string of digits.
Ṛ takes a haystack and a needle and finds the index of the first occurrence of needle in haystack using the faux case-insensitivity criterion (or 32).
Ṣ takes a haystack and a needle and repeatedly applies Ṛ to remove all instances of the needle. It returns the final result after all the removals as well as the number of removals made.

I have no idea what's going on here, but it looks very impressive!

Ruby
     f=IO.         read(
   __FILE__)     .gsub(/[^
 \s]/x,?#);s=   $**'loves';s
.upcase!;i=1;a =s.chars.uniq.
map{|c|s.count(c)};loop{b='';
b<<"#{a.shift.to_i+a.pop.to_i
 }"while(a.any?);d=b.to_i;a=
   b.chars;d<101&&abort(d>
     50?f:f.gsub(/^.*/){
       |s|i=13+i%3;s[\
         i...i]=040.
           chr*3;s
             })}
              V

Prints a heart if the chance of a relation is over 50%
$ ruby ♥.rb sharon john
     #####         #####
   #########     #########
 ############   ############
############## ##############
#############################
#############################
 ###########################
   #######################
     ###################
       ###############
         ###########
           #######
             ###
              #

And prints a broken heart if chances are below 50% :(
$ ruby ♥.rb sharon epidemian
     #####            #####
   #########        #########
 ############      ############
##############    ##############
###############   ##############
#############   ################
 #############   ##############
   ############   ###########
     ########   ###########
       #######   ########
         ######   #####
           ##   #####
             #   ##
              #

Frigging John...
Anyways, it's case-insensitive and supports polygamous queries (e.g. ruby ♥.rb Alice Bob Carol Dave).

That is pure art :)

APL, 80
{{n←⍎∊⍕¨(⍵[⌈m]/⍨m≠⌊m),⍨+/(⌊m←2÷⍨≢⍵)↑[1]⍵,⍪⌽⍵⋄n≤100:n⋄∇⍎¨⍕n}∪⍦32|⎕UCS⍺,'Loves',⍵}

Because love is love code-golf is code-golf (even when it's not)
Obligatory ♥-shaped version:
    {f←{m←  2÷⍨≢⍵
  n←+/(⌊m)↑[1]⍵,⍪⌽⍵
n←⍎∊⍕¨n,(⍵[⌈m]/⍨m≠⌊m)
n≤100:n⋄∇⍎¨⍕n}⋄u←⎕UCS
   s←u⍺,'Loves',⍵
       f∪⍦32|s
          }

The golfed version gives me somewhat erratic behaviour, because of a bug with ∪⍦ that I'm investigating with NARS's developers:
      'John'{{n←⍎∊⍕¨(⍵[⌈m]/⍨m≠⌊m),⍨+/(⌊m←2÷⍨≢⍵)↑[1]⍵,⍪⌽⍵⋄n≤100:n⋄∇⍎¨⍕n}∪⍦32|⎕UCS⍺,'Loves',⍵}'Jane'
VALUE ERROR

But I was able to run it piecewise and get the correct result:
      'John'{∪⍦32|⎕UCS⍺,'Loves',⍵}'Jane'
2 2 1 2 1 1 2 1 1
      {n←⍎∊⍕¨(⍵[⌈m]/⍨m≠⌊m),⍨+/(⌊m←2÷⍨≢⍵)↑[1]⍵,⍪⌽⍵⋄n≤100:n⋄∇⍎¨⍕n}2 2 1 2 1 1 2 1 1
76

Javascript
Probably could be cleaner, but it works. Verbose example
function z(e) {
    for (var t = 0, c = '', n = e.length - 1; n >= t; n--, t++) {
        c += n != t ? +e[t] + (+e[n]) : +e[t];
    }
    return c
}
for (var s = prompt("Name 1").toLowerCase() + "loves" + prompt("Name 2").toLowerCase(),b = '', r; s.length > 0;) {
    r = new RegExp(s[0], "g");
    b+=s.match(r).length;
    s = s.replace(r, "")
}
for (; b.length > 2; b = z(b)) {}
console.log("Chances of being in love are: " + b + "%")

Python
Well, I thought it was a code-golf...
a=filter(str.isalpha,raw_input()+"loves"+raw_input()).lower();a=[x[1]for x in sorted(set(zip(a,map(str.count,[a]*len(a),a))),key=lambda(x,y):a.index(x))]
while reduce(lambda x,y:x*10+y,a)>100:a=reduce(list.__add__,map(lambda x: x<10 and[x]or map(int,str(x)),[a[n]+a[-n-1]for n in range(len(a)/2)]+(len(a)%2 and[a[len(a)/2]]or[])))
print str(reduce(lambda x,y:x*10+y,a))+"%"

Ungolfed:
a = filter(str.isalpha,
           raw_input() + "loves" + raw_input()).lower()

a = [x[1] for x in sorted(set(zip(a,
                                  map(str.count, [a] * len(a), a))),
                          key=lambda (x, y): a.index(x))]

while reduce(lambda x, y: x * 10 + y, a) > 100:
    a = reduce(list.__add__,
               map(lambda x: x < 10 and [x] or map(int, str(x)),
                   [a[n] + a[-n - 1] for n in range(len(a) / 2)] + (len(a) % 2 and [a[len(a) / 2]] or [])))

print str(reduce(lambda x, y: x * 10 + y, a)) + "%"

If you want to make it as short as possible, you can replace reduce(list.__add__,xyz) with sum(xyz,[]). :)

PHP
<?php

$name1 = $argv[1];
$name2 = $argv[2];

echo "So you think {$name1} and {$name2} have any chance? Let's see.\nCalculating if \"{$name1} Loves {$name2}\"\n";

//prepare it, clean it, mince it, knead it
$chances = implode('', array_count_values(str_split(preg_replace('/[^a-z]/', '', strtolower($name1.'loves'.$name2)))));
while(($l = strlen($chances))>2 and $chances !== '100'){
    $time = time();
    $l2 = intval($l/2);
    $i =0;
    $t = '';
    while($i<$l2){
        $t.=substr($chances, $i, 1) + substr($chances, -$i-1, 1);
        $i++;
    }
    if($l%2){
        $t.=$chances[$l2];
    }
    echo '.';
    $chances = $t;
    while(time()==$time){}
}

echo "\nTheir chances in love are {$chances}%\n";
$chances = intval($chances);
if ($chances === 100){
    echo "Great!!\n";
}elseif($chances > 50){
    echo "Good for you :) !!\n";
}elseif($chances > 10){
    echo "Well, it's something.\n";
}else{
    echo "Ummm.... sorry.... :(\n";
}

sample result
$ php loves.php John Jane
So you think John and Jane have any chance? Let's see.
Calculating if "John Loves Jane"
...
Their chances in love are 76%
Good for you :) !!

GolfScript
Obligatory code golf answer in GolfScript:
' '/'loves'*{65- 32%65+}%''+:x.|{{=}+x\,,}%{''\{)\(@+@\+\.(;}do 0+{+}*+{[]+''+~}%.,((}do{''+}%''+

Accepts input as space-separated names e.g.
echo 'John Jane' | ruby golfscript.rb love.gs
-> 76

C#
using System;
using System.Collections.Generic;
using System.Linq;

namespace LovesMeWhat
{
    class Program
    {
        static void Main(string[] args)
        {
            if (args.Length < 2) throw new ArgumentException("Ahem, you're doing it wrong.");

            Func<IEnumerable<Int32>, String> fn = null;
            fn = new Func<IEnumerable<Int32>, String> (input => {
                var q = input.SelectMany(i => i.ToString().Select(c => c - '0')).ToArray();

                if (q.Length <= 2) return String.Join("", q);

                IList<Int32> next = new List<Int32>();
                for (int i = 0, j = q.Length - 1; i <= j; ++i, --j)
                {
                    next.Add(i == j ? q[i] : q[i] + q[j]);
                }
                return fn(next);
            });

            Console.Write(fn(String.Concat(args[0], "LOVES", args[1]).ToUpperInvariant().GroupBy(g => g).Select(g => g.Count())));
            Console.Write("%");
            Console.ReadKey(true);
        }
    }
}

Does this work correctly when q[i] + q[j] is 10 or greater?

@Danny The first line in fn takes each integer in input, converts each of them to string, then converts all characters in this string to integer from 0 to 9 (c - '0' part) and returns it... IOW, it will construct an array of integers consisting of each digit in the input. If it doesn't the requirements are invalid :-)

ah missed that.

Haskell
My version is pretty long, it's because I decided to focus on readability, I thought it would be interesting to formalize your algorithm in code. I aggregate character counts in a left fold, it basically snowballs them together and order is in order of their occurrence in the string. I also managed to replace the part of algorithm that would normally require array indexing with list bending. It turns out your algorithm basically involves folding list of numbers in half and adding aligned numbers together. There two cases for bending, even lists split in the middle nicely, odd lists bend around a center element and that element doesn't participate in addition. Fission is taking the list and splitting up numbers that are no longer single digits, like >= 10. I had to write my own unfoldl, I'm not sure if it's actually an unfoldl, but it seems to do what i need. Enjoy.
import qualified Data.Char as Char
import qualified System.Environment as Env

-- | Takes a seed value and builds a list using a function starting
--   from the last element
unfoldl :: (t -> Maybe (t, a)) -> t -> [a]
unfoldl f b  =
  case f b of
   Just (new_b, a) -> (unfoldl f new_b) ++ [a]
   Nothing -> []

-- | Builds a list from integer digits
number_to_digits :: Integral a => a -> [a]
number_to_digits n = unfoldl (\x -> if x == 0
                                     then Nothing
                                     else Just (div x 10, mod x 10)) n

-- | Builds a number from a list of digits
digits_to_number :: Integral t => [t] -> t
digits_to_number ds = number
  where (number, _) = foldr (\d (n, p) -> (n+d*10^p, p+1)) (0,0) ds

-- | Bends a list at n and returns a tuple containing both parts
--   aligned at the bend
bend_at :: Int -> [a] -> ([a], [a])
bend_at n xs = let
                 (left, right) = splitAt n xs
                 in ((reverse left), right)

-- | Takes a list and bends it around a pivot at n, returns a tuple containing
--   left fold and right fold aligned at the bend and a pivot element in between
bend_pivoted_at :: Int -> [t] -> ([t], t, [t])
bend_pivoted_at n xs
  | n > 1 = let
              (left, pivot:right) = splitAt (n-1) xs
              in ((reverse left), pivot, right)

-- | Split elements of a list that satisfy a predicate using a fission function
fission_by :: (a -> Bool) -> (a -> [a]) -> [a] -> [a]
fission_by _ _ [] = []
fission_by p f (x:xs)
  | (p x) = (f x) ++ (fission_by p f xs)
  | otherwise = x : (fission_by p f xs)

-- | Bend list in the middle and zip resulting folds with a combining function.
--   Automatically uses pivot bend for odd lists and normal bend for even lists
--   to align ends precisely one to one
fold_in_half :: (b -> b -> b) -> [b] -> [b]
fold_in_half f xs
  | odd l = let
              middle = (l-1) `div` 2 + 1
              (left, pivot, right) = bend_pivoted_at middle xs
              in pivot:(zipWith f left right)
  | otherwise = let
                  middle = l `div` 2
                  (left, right) = bend_at middle xs
                  in zipWith f left right
  where
    l = length xs

-- | Takes a list of character counts ordered by their first occurrence
--   and keeps folding it in half with addition as combining function
--   until digits in a list form into any number less or equal to 100
--   and returns that number
foldup :: Integral a => [a] -> a
foldup xs
  | n > 100 = foldup $ fission $ reverse $ (fold_in_half (+) xs)
  | otherwise = n
  where
    n = (digits_to_number xs)
    fission = fission_by (>= 10) number_to_digits

-- | Accumulate counts of keys in an associative array
count_update :: (Eq a, Integral t) => [(a, t)] -> a -> [(a, t)]
count_update [] x = [(x,1)]
count_update (p:ps) a
  | a == b = (b,c+1) : ps
  | otherwise = p : (count_update ps a)
  where
    (b,c) = p

-- | Takes a string and produces a list of character counts in order
--   of their first occurrence
ordered_counts :: Integral b => [Char] -> [b]
ordered_counts s = snd $ unzip $ foldl count_any_alpha [] s
  where
    count_any_alpha m c
      | Char.isAlpha c = count_update m (Char.toLower c)
      | otherwise = m

-- | Take two names and perform the calculation
love_chances n1 n2 =  foldup $ ordered_counts (n1 ++ " loves " ++ n2)

main = do
   args <- Env.getArgs
   if (null args) || (length args < 2)
     then do
            putStrLn "\nUSAGE:\n"
            putStrLn "Enter two names separated by space\n"
     else let
            n1:n2:_ = args
            in putStrLn $ show (love_chances n1 n2) ++ "%"

Some Results:
"Romeo" "Juliet" 97% - Empirical testing is important
"Romeo" "Julier" 88% - Modern abridged version...
"Horst Draper" "Jane" 20%
"Horst Draper" "Jane(Horse)" 70% - There's been a development...
"Bender Bender Rodriguez" "Fenny Wenchworth" 41% - Bender Says "Folding is for women!"
"Philip Fry" "Turanga Leela" 53% - Well you can see why it took 7 Seasons for them to marry
"Maria" "Abraham" - 98%
"John" "Jane" 76%

Ruby
math = lambda do |arr|
  result = []
  while arr.any?
    val = arr.shift + (arr.pop || 0)
    result.push(1) if val >= 10
    result.push(val % 10)
  end
  result.length > 2 ? math.call(result) : result
end
puts math.call(ARGV.join("loves").chars.reduce(Hash.new(0)) { |h, c| h[c.downcase] += 1; h }.values).join

Minified:
l=->{|a|r=[];while a.any?;v=a.shift+(a.pop||0);r.push(1) if v>=10;r.push(v%10) end;r[2]?l[r]:r}
puts l[ARGV.join("loves").chars.reduce(Hash.new(0)){|h, c| h[c.downcase]+=1;h}.values].join

Call it:
$ ruby love.rb "John" "Jane"
76

To minify more, you could use l=->a{...} instead of l=lambda do|a|...end, and you could also do l[...] instead of l.call(...).

Good point Doorknob.

Python 3
A simple solution that uses no modules. I/O is pretty enough.
I used error catching as a backup for when the second iterator is out of bounds; if it catches Python's index error, it assumes 1. Weird, but it works.
names = [input("Name 1: ").lower(), "loves", input("Name 2: ").lower()]
checkedLetters = []

def mirrorAdd(n):
    n = [i for i in str(n)]
    if len(n) % 2:
        n.insert(int(len(n)/2), 0)
    return(int(''.join([str(int(n[i]) + int(n[len(n)-i-1])) for i in range(int(len(n)/2))])))

cn = ""

positions = [0, 0]
for i in [0, 1, 2]:
    checkAgainst = [0, 1, 2]
    del checkAgainst[i]
    positions[0] = 0
    while positions[0] < len(names[i]):
        if not names[i][positions[0]] in checkedLetters:
            try:
                if names[i][positions[0]] in [names[checkAgainst[0]][positions[1]], names[checkAgainst[1]][positions[1]]]:
                    positions[1] += 1
                    cn = int(str(cn) + "2")
                else:
                    cn = int(str(cn) + "1")
            except:
                cn = int(str(cn) + "1")
            checkedLetters.append(names[i][positions[0]])
        positions[0] += 1

print("\n" + str(cn))

while cn > 100:
    cn = mirrorAdd(cn)
    print(cn)

print("\n" + str(cn) + "%")

Here's a sample run:
Name 1: John
Name 2: Jane

221211211
33331
463
76

76%

wouldn't it be clearer to run the for on names directly?

@Einacio Then how would I know which ones to check it to so concisely?

what is your result with "Maria" and "Abraham"?

@Einacio I got 75%.

i got 98, this are the steps 25211111111.363221.485.98. i think you code fails to add the 5 "a"

@Einacio I didn't know the rules to this calculation thing, so I assumed both had a counter (check the increasing pattern in the second arg in OP) and if it was the same it would be 2, else it would be 1. If it were 2, second counter would increase. The steps I got for Maria and Abraham are:
12111111111 232221 354 75

Python 3
This will take two names as input. strip extra spaces and then calculate love.
Check out Input output for more details.
s=(input()+'Loves'+input()).strip().lower()
a,b=[],[]
for i in s:
    if i not in a:
        a.append(i)
        b.append(s.count(i))
z=int(''.join(str(i) for i in b))
while z>100:
    x=len(b)
    t=[]
    for i in range(x//2):
        n=b[-i-1]+b[i]
        y=n%10
        n//=10
        if n:t.append(n)
        t.append(y)
    if x%2:t.append(b[x//2])
    b=t
    z=int(''.join(str(i) for i in b))
print("%d%%"%z)

input:
Maria
Abraham

output:
98%

Or, try this one ;)
input:
Wasi Mohammed Abdullah
code golf

output:
99%

Java

It can happen that the sum of 2 digits becomes greater than 10, in
  this case the number will be split in 2 on the next row.

What if the number is equal to 10?
I just added 1 and 0, is that correct?
I decided to ignore case.
public class LoveCalculation {
    public static void main(String[] args) {
        String chars = args[0].toLowerCase() + "loves" + args[1].toLowerCase();
        ArrayList<Integer> charCount = new ArrayList<Integer>();
        HashSet<Character> map = new HashSet<Character>();
        for(char c: chars.toCharArray()){
            if(Pattern.matches("[a-z]", "" + c) && map.add(c)){
                int index = -1, count = 0;
                while((index = chars.indexOf(c, index + 1)) != -1)
                    count++;
                charCount.add(count);
            }
        }
        while(charCount.size() > 2){
            ArrayList<Integer> numbers = new ArrayList<Integer>();
            for(int i = 0; i < (charCount.size()/2);i++)
                addToArray(charCount.get(i) + charCount.get(charCount.size()-1-i), numbers);
            if(charCount.size() % 2 == 1){
                addToArray(charCount.get(charCount.size()/2), numbers);
            }
            charCount = new ArrayList<Integer>(numbers);
        }
        System.out.println(Arrays.toString(charCount.toArray()).replaceAll("[\\]\\[,\\s]","") + "%");
    }
    public static ArrayList<Integer> addToArray(int number, ArrayList<Integer> numbers){
        LinkedList<Integer> stack = new LinkedList<Integer>();
        while (number > 0) {
            stack.push(number % 10);
            number = number / 10;
        }
        while (!stack.isEmpty())
            numbers.add(stack.pop());
        return numbers;
    }
}

input:
Maria
Abraham

output:
98%

input:
Wasi
codegolf.stackexchange.com

output:
78%

I would enjoy seeing this answer golfed for kicks and giggles!

That makes minus 144 characters and a few lines. I'm just to used to program readable and memory efficient...

That's why seeing Java golfed always cracks me up.

For me it's the fun in making a language like this golfed.. just imagine how funny it would be trying to golf a random java class it would become at least 2 times smaller XD

Java is about the worst language for golfing. Unfortunately it's only language I know well, haha. Oh well, at least I can read stuff here.

C
There might be lots of improvement, but this was fun to code.
#include <stdio.h>
#include <string.h>
int i, j, k, c, d, r, s = 1, l[2][26];
char a[204], *p, *q;

main(int y, char **z) {
    strcat(a, z[1]);
    strcat(a, "loves");
    strcat(a, z[2]);
    p = a;
    q = a;
    for (; *q != '\0'; q++, p = q, i++) {
        if (*q == 9) {
            i--;
            continue;
        }
        l[0][i] = 1;
        while (*++p != '\0')
            if ((*q | 96) == (*p | 96)&&*p != 9) {
                (l[0][i])++;
                *p = 9;
            }
    }
    for (;;) {
        for (j = 0, k = i - 1; j <= k; j++, k--) {
            d = j == k ? l[r][k] : l[r][j] + l[r][k];
            if (d > 9) {
                l[s][c++] = d % 10;
                l[s][c++] = d / 10;
            } else l[s][c++] = d;
            if (k - j < 2)break;
        }
        i = c;
        if (c < 3) {
            printf("%d", l[s][0]*10 + l[s][1]);
            break;
        }
        c = r;
        r = s;
        s = c;
        c = 0;
    }
}

And of course, mandatory golfed version: 496
#include <stdio.h>
#include <string.h>
int i,j,k,c,d,r,s=1,l[2][26];char a[204],*p,*q;main(int y,char **z){strcat(a,z[1]);strcat(a,"loves");strcat(a,z[2]);p=q=a;for(;*q!='\0';q++,p=q,i++){if(*q==9){i--;continue;}l[0][i]=1;while(*++p!='\0')if((*q|96)==(*p|96)&&*p!=9){(l[0][i])++;*p=9;}}for(;;){for(j=0,k=i-1;j<=k;j++,k--){d=j==k?l[r][k]:l[r][j]+l[r][k];if(d>9){l[s][c++]=d%10;l[s][c++]=d/10;}else l[s][c++]=d;if(k-j<2)break;}i=c;if(c<3){printf("%d",l[s][0]*10+l[s][1]);break;}c=r;r=s;s=c;c=0;}}

Groovy
Here's the groovy version, with tests.
countChars = { res, str -> str ? call(res+str.count(str[0]), str.replace(str[0],'')) : res }
addPairs = { num -> def len = num.length()/2; (1..len).collect { num[it-1].toInteger() + num[-it].toInteger() }.join() + ((len>(int)len) ? num[(int)len] : '') }
reduceToPct = { num -> /*println num;*/ num.length() > 2 ? call( addPairs(num) ) : "$num%" }

println reduceToPct( countChars('', args.join('loves').toLowerCase()) )

assert countChars('', 'johnlovesjane') == '221211211'
assert countChars('', 'asdfasdfateg') == '3222111'
assert addPairs('221211211') == '33331'
assert addPairs('33331') == '463'
assert addPairs('463') == '76'
assert addPairs('53125418') == '13457'
assert addPairs('13457') == '884'
assert addPairs('884') == '128'
assert addPairs('128') == '92'
assert reduceToPct( countChars('','johnlovesjane') ) == '76%'

Explanation:

"countChars" simply recurses and removes while build a string of digits
"addPairs" takes one string of digits adding the digits from the outside in
** the "collect..join" does the addition of the digits working outside in and rejoins them as  a string
** the "+ (... c[(int)len])" throws in the middle digit again when c is an odd length
"recudeToPct" calls itself adding pairs until it gets down to less than 3 digits

CodeGolf Groovy, 213 char
Seeing this is codegolf we can inline the closures and get it down to this:
println({c->l=c.length()/2;m=(int)l;l>1?call((1..m).collect{(c[it-1]as int)+(c[-it]as int)}.join()+((l>m)?c[m]:'')):"$c%"}({r,s->s?call(r+s.count(s[0]),s.replace(s[0],'')):r}('',args.join('loves').toLowerCase())))

save it as lovecalc.groovy.  run "groovy lovecalc john jane"
Output:
$ groovy lovecalc john jane
76%
$ groovy lovecalc romeo juliet
97%
$ groovy lovecalc mariah abraham
99%
$ groovy lovecalc maria abraham
98%
$ groovy lovecalc al bev
46%
$ groovy lovecalc albert beverly
99%

k, 80
{{$[(2=#x)|x~1 0 0;x;[r:((_m:(#x)%2)#x+|x);$[m=_m;r;r,x@_m]]]}/#:'.=x,"loves",y}

Here is a run of it:
{{$[(2=#x)|x~1 0 0;x;[r:((_m:(#x)%2)#x+|x);$[m=_m;r;r,x@_m]]]}/#:'.=x,"loves",y}["john";"jane"]
7 6

J
Here's a straightforward one in J:
r=:({.+{:),$:^:(#>1:)@}:@}.
s=:$:^:(101<10#.])@("."0@(#~' '&~:)@":"1)@r
c=:10#.s@(+/"1@=)@(32|3&u:@([,'Loves',]))
exit echo>c&.>/2}.ARGV

It takes the names on the command line, e.g:
$ jconsole love.ijs John Jane
76

Java
This takes 2 String parameters on start and prints out the count of each character and the result.
import java.util.ArrayList;
import java.util.LinkedHashMap;

public class LUV {
    public static void main(String[] args) {
        String str = args[0].toUpperCase() + "LOVES" + args[1].toUpperCase();
        LinkedHashMap<String, Integer> map = new LinkedHashMap<>();
        for (int i = 0; i < str.length(); i++) {
            if (!map.containsKey(String.valueOf(str.charAt(i)))) {
                map.put(String.valueOf(str.charAt(i)), 1);
            } else {
                map.put(String.valueOf(str.charAt(i)), map.get(String.valueOf(str.charAt(i))).intValue() + 1);
            }
        }
        System.out.println(map.toString());
        System.out.println(addValues(new ArrayList<Integer>(map.values()))+"%");
    }

    private static int addValues(ArrayList<Integer> list) {
        if ((list.size() < 3) || (Integer.parseInt((String.valueOf(list.get(0)) + String.valueOf(list.get(1))) + String.valueOf(list.get(2))) == 100)) {
            return Integer.parseInt((String.valueOf(list.get(0)) + String.valueOf(list.get(1))));
        } else {
            ArrayList<Integer> list2 = new ArrayList<Integer>();
            int size = list.size();
            for (int i = 0; i < size / 2; i++) {
                int temp = list.get(i) + list.get(list.size() -1);
                if (temp > 9) {
                    list2.add(temp/10);
                    list2.add(temp%10);
                } else {
                    list2.add(temp);
                }
                list.remove(list.get(list.size()-1));
            }
            if (list.size() > list2.size()) {
                list2.add(list.get(list.size()-1));
            }
            return addValues(list2);
        }
    }
}

Surely not the shortest one (it's Java), but a clear and readable one.
So if you call
java -jar LUV.jar JOHN JANE

you get the output
{J=2, O=2, H=1, N=2, L=1, V=1, E=2, S=1, A=1}
76%

R
Not going to win any compactness awards, but I had fun anyway:
problove<-function(name1,name2, relation='loves') {
sfoo<-tolower( unlist( strsplit(c(name1,relation,name2),'') ) )
startrow <- table(sfoo)[rank(unique(sfoo))]
# check for values > 10 . Not worth hacking an arithmetic approach
startrow <- as.integer(unlist(strsplit(as.character(startrow),'')))
while(length(startrow)>2 ) {
    tmprow<-vector()
    # follow  by tacking on middle element if length is odd
    srlen<-length(startrow)
     halfway<-trunc( (srlen/2))
    tmprow[1: halfway] <- startrow[1:halfway] + rev(startrow[(srlen-halfway+1):srlen])
    if ( srlen%%2) tmprow[halfway+1]<-startrow[halfway+1]
    startrow <- as.integer(unlist(strsplit(as.character(tmprow),'')))
    }
as.numeric(paste(startrow,sep='',collapse=''))
}

Tested: valid for 'john'&'jane'  and for 'romeo'&'juliet'  . per my comment under the question,
Rgames> problove('john','jane','hates')
[1] 76
Rgames> problove('romeo','juliet','hates')
[1] 61


text:
Simplifying Radicals
Given integers a and b in the format a√b (a on the square root of b), make a program that will reduce b and increase a until the radical statement is fully simplified.
Example
input
a = 1
b = 16

output
4 root 1

In this instance, 1√16 = 4√1
Bonus - 25 chars for the ability to simplify radicals other than square root using another variable, c.

Isn't this question a special case of http://codegolf.stackexchange.com/questions/18535/convert-radicals-to-mixed-entire-radicals-and-to-real-numbers ?

Python, 71-25=46 63-25=38 chars
f=lambda a,b:max((a*i,b/i/i)for i in range(1,b)if b%(i*i)==0)

g=lambda a,b,c:max((a*i,b/i**c)for i in range(1,b)if b%i**c==0)

f is 61, chars. g is 63 but gets a 25 char bonus.

You can make it a lot shorter by using the ** operator and getting rid of unnecessary parens: f=lambda a,b,c:max((a*i,b/i**c)for i in range(1,b)if b%i**c==0)

source: Stack Exchange

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

sort: votes


text:
Implement a Useless interpreter
Your task is to build an interpreter to the Useless language:
Here are the functional requirements:

All the described commands should be accepted by the interpreter.
NO., NOOP and INCLUDE-xxx must be honored.
DONTUSEME(n) must have its base date to be easily configurable to something more reasonable for testing purposes.
INCLUDE-xxx must be able to generate any command with a roughly equal probability. If it generates a DONTUSEME(n), he should randomly choose a small value for n.
DONTUSEME(n) windows should survive the NO. instruction. Tip: spawn a new process for those windows.
BOOM! and KABOOM! must do something bad and scary, and KABOOM! must be worse than BOOM!. But this must not be taken too seriously, so it should not be something destructive, overly-disruptive or hard to be undone. Please, do not, do not, and do not make these instructions run a rm -rf \ command, run a fork bomb, install malware, corrupt data in the file system, or post or download inappropriate content from the internet, or any other thing clearly abusive.
TURINGVSALONZO should run as if it in fact was doing what it should do. Tip: Make it randomly decide if it would sleep for a random very long time, or a random short time, or forever.
All the other predefined instructions should do something other than the aforementioned instructions and different one to the another, but never something worse than BOOM! or KABOOM!. What they do exactly is up to you, but a simple implementation would just output an error message or some other text.
You should provide an easy way for the user to provide the program that would be run by the interpreter. i.e. Reading plaintext from a file or from stdin is ok. Reading it from an encrypted file somewhere in the internet is not.

Optional:

You might invent some new commands if you want, but they should be subject to the same rules as the others are. Do not use this to circumvent the restrictions in BOOM! and KABOOM! or to defeat DONTUSEME(n). And if you do invent new commands, explain what they do.
You should think about what the interpreter do if it receives input with unknown commands (or even completely unparseable random bytes gibberish).
Although no instruction should defeat the DONTUSEME(n) command, you might add a kill switch for it. Just don't expose that in the language.

We have a few non-functional requirements to avoid abuses:

Your entry must be as complete and autocontained as possible. This means that it should not be simply some sort of installer or clearly incomplete program. This way, downloading and using libraries like jQuery or packages from maven central is ok, but downloading arbitrary code and packages from your custom server is not.
Your entry should not get any content from this very page or from some mirror or copy of this page in order to do some sort of reflection or for any other purpose. This is essential to avoid some program that try to read other entrants answers to this question or try to disrupt the question or answers in any way.
Your interpreter should be immutable and not self-modify or modify its input file. But, creating a mutant copy of the interpreter or of the input file without altering the original is ok.

And finally, considering that:

The programs in the answers are expected to be pretty useless even if fully conformant;
The language is (on purpose) very underspecified, and the answerers have a lot of liberties to take and are incentived to take them;
The requirements and the possible implementations have a lot of subjective points;
The objective with this is to just get some fun and creativity.

Then, this is a popularity-contest, and the most upvoted answer fully conformant to the rules wins! So, you don't need to golf or obfuscate your answer (but you might do that if you want). Just be sure to post something original and creative to deserve the upvotes, i.e. please don't post lame boring entries.

You mean rm -rf \?

TI-BASIC
There is a kill button for DONTUSEME, can you figure out which one it is? :)
:Lbl 1
:Input Str1
:If Str1="NO."
:Pause
:If Str1="FAIL"
:Disp "OBSOLETE. WHAT A FAIL."
:If Str1="NOT"
:Disp "USING NOT IS HIGHLY DISCOURAGED!"
:If Str1="NEVER"
:get(Police,911)
:If Str1="IDK"
:Disp LLLundefined
:If Str1="BOOM!"
:Disp "rm -rf \"
:If Str1="KABOOM!"
:send(virus)
:If Str1="QWAOZAPWQFUOA"
:Disp "SKIPPING QWAO... UNIMPLEMENTED"
:If Str1="WUT?"
:dayOfWk(1)
:If Str1="WHERE?"
:Disp "NON-EXISTENT. SKIPPED."
:If Str1="HOW?"
:++
:If sub(Str1,1,9)="DONTUSEME"
:Then
:While 1
:sin(sin(sin(sin(sin(sin(sin(sin(sin(sin(sin(sin(sin(sin(sin(sin(sin(sin(sin(sin(e)
:End
:End
:If Str1="ILLEGAL"
:Archive X
:If Str1="GODEXISTS"
:Disp "GOD EXISTS, PROVEN BY LAW."
:If Str1="WINDOWS"
:Disp "UNABLE TO OPEN START MENU!"
:If Str1="NOOP"
:Lbl 0
:If sub(Str1,1,8)="INCLUDE-"
:sub(Str1,9,length(Str1-8))
:If Str1=Ans
:Then
:If not(rand)
:Goto 0
:End
:If Str1="TURINGVSALONZO"
:Then
:"+"→Str0
:randInt(5,10)
:While Ans
:Ans-1
:If fpart(Ans,4)4=3
:Str0+"+"→Str0
:If fpart(Ans,4)4=2
:Str0+"-"→Str0
:If fpart(Ans,4)4=1
:Str0+">"→Str0
:If fpart(Ans,4)4=0
:Str0+"."→Str0
:End
:Disp "0"
:"?utm_campaign=0"
:End
:Goto 1

Does that :Goto 1 means that BOOM! is just a no-op?

@VictorStafusa Yeah. After considering it some more, I changed it to rm -rf \ because you told me (not) to.

I don't think you implemented INCLUDE-.

HTML + Javascript + jQuery + jQuery UI
The input should be given in the text area and should be formatted as each command in a line. The commands are not case sensitive. All of the commands were fully implemented. I hope that you enjoy.
You can try it at http://jsfiddle.net/bCBfk/
<!DOCTYPE html>

    <meta http-equiv="Content-Type" content="text/html;charset=utf-8" >
    <title>Useless interpreter</title>
    <link rel="stylesheet" href="http://code.jquery.com/ui/1.10.4/themes/smoothness/jquery-ui.css">

Type here your program input:

      <textarea id="input" style="width: 400px; height: 150px;"></textarea>

        <button id="bt">Run the program</button>
        Running the program...

Here is the program output:

      <button id="cc" style="display: none;">Clear the output</button>

It has one new command:

 It is the 42 command which calculates the answer of the life, the universe and everything. The only quirk is that it takes 7.5 million years to finish.

Other spoilers:

 This entry has several features:

 You will really hate the FAIL command.
  BOOM! will screw up you "execution unit". At least the windows from DONTUSEME(n) are able to survive this.
  KABOOM! is really dangerous to world in several bad ways.
  DONTUSEME(n) always opens infinite unclosable empty windows, one each 0.8 seconds. But there is a hidden kill switch.
  DONTUSEME(n) survives NO., FAIL and even BOOM!. I just couldn't make it survive the KABOOM! though. The reason is that popup windows won't work as this is not the result of a click (and popups created by other ways are long banned in all major browsers), and could not use iframes too because of a violation of same-origin policy.
  INCLUDE-xxx can create any instruction, including DONTUSEME(n) or another INCLUDE-yyy instruction.
  If INCLUDE-xxx does generates an INCLUDE-yyy instruction, the yyy name is generated at random. If you grab the name of the generated command with firebug or something similar, you can use it.
  It handles malformed syntax and incomplete or empty input.

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


text:
Counting triangles
You are required to find how many triangles are unique out of given triangles. For each triangle you are given three integers a,b,c , the sides of a triangle.
A triangle is said to be unique if there is no other triangle with same set of sides.
Note : It is always possible to form triangle with given sides.
INPUT:
First line contains n, the number of triangles. Each of next n lines contain three integers a,b,c (sides of a triangle).
Output:
print single integer, the number of unique triangles.
Constraints:
1 <= n <= 10^5
1 <= a,b,c <= 10^15

Sample Input
5
7 6 5
5 7 6
8 2 9
2 3 4
2 4 3

Sample Ouput
1

Explanation
only triangle with sides 8, 2, 9 is unique

I don't really understand what you mean by no other triangle with the same set of sides. I think it would be helpful if you provided a few example input -> output pairs.

@ Gareth See the updated question

is the input of 1 triangle restricted to one line or can you ask for side a,b,c in turns? side a: 1 -> side b: 3 -> side c: 5

Why do you complicate the task by having first number telling you the number of lines? This unnecessarily complicates the programs in most languages. Can we just assume we have the triangles, without the count at the beginning?

Agree with Gareth. This challenge is not specified clearly.

This problem can be generalized to 'find the unique set in a list of sets'. I find code-golfing simple problems like these favors GolfScript or similar languages. Maybe to make it more interesting, there should be an option to provide clever solutions in more verbose languages, or a per language grouping scoring?

@Tomas - it doesn't say you have to use the information in the input; just that it is there...

@YiminRong - I've taken to doing these using the shortest code in the language of my choice.  I always read the answers with an implicit group-by-language in my head and I upvote the ones that I think are nice.  There's no point my trying to compete with any of the 'spewed-printer-garbage' languages; I can't read or verify them, and it is not worth my time to do so -- they could put {sn£%^s#s}poop and tell me it does the job and I wouldn't be any of the wiser  (Or, "boo hoo, my language set is too verbose!" -- whichever works for you)  ;-)

@jimbobmcgee '...it is not worth my time to do so...' - I disagree. I think it is worth every programmer's time to learn different types of language like array (APL, J, K etc.) or stack-oriented (GolfScript etc.) programming languages.

@Gareth - I think it's worth every programmer's time to learn about different types of language, as it can definitely help you in more abstract ways (such as, writing RPN expressions for RRDtool) but, if I turned up to work and started writing in GolfScript or APL, I'd be required to rewrite it at the next code review.  Besides, I'd probably need to rewrite it myself, the next time I saw it!

@Tomas having the first number is a standard in many code challenge communities, such as SPOJ, which afaik is the largest and most prolific such environment.

GolfScript, 22 characters
n%{~]$}%:^{]^\/,3<},,(

Includes the first line into the list of triangles but subtracts one from the result later. Run online.
Commented code
n%            # Split input into lines
{             # For each line
  ~]          # Evaluate the content and put into array
  $           # Sort the array (aka sides)
}%
:^            # Assign to variable ^
{             # Filter list of triangles
  ]           # Make array from triangle
  ^\/         # Count number of occurences in ^ by splitting
  ,3<         # and testing if number of parts is less than 3 (i.e.
              # triangle occurse only once
},
,(            # Count distinct lines and subtract 1 (for first line)

k [22 chars]
{+/1=#:'={x@<x}'x:1_x}

Example
input:(5;7 6 5;5 7 6; 8 2 9;2 3 4;2 4 3)
input
5
7 6 5
5 7 6
8 2 9
2 3 4
2 4 3

Output
{+/1=#:'={x@<x}'x:1_x}[input]
1

Example
input:(3;1 2 3;4 5 6;7 8 9)
input
3
1 2 3
4 5 6
7 8 9

Output
{+/1=#:'={x@<x}'x:1_x}[input]
3

APL, 18 chars/bytes*
{+/1=+/∘.(≡⍦)⍨1↓⍵}

Dialect is Nars2000. Following the lead in the K answer, this code is a function that accepts a list of vectors, first the number of lines (which is ignored) and then the triangles. Let me know if this is not ok.
Exploded view
{             1↓⍵}   drop the first element of the list (the number of lines)
       ∘.(  )⍨       for each possible pair of vectors (triangles) from the list,
          ≡⍦         compare them as multisets: check whether they are the same triangle
     +/              sum each row: for each triangle, count how many others are the same
   1=                find out which ones are unique
 +/                  and count them

Example
      {+/1=+/∘.(≡⍦)⍨1↓⍵} 5(7 6 5)(5 7 6)(8 2 9)(2 3 4)(2 4 3)
1
      {+/1=+/∘.(≡⍦)⍨1↓⍵} 6(7 6 5)(5 7 6)(8 2 9)(2 3 4)(2 4 3)(2 4 6)
2

⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯⎯
*: APL can be written in its own (legacy) single-byte charset that maps APL symbols to the upper 128 byte values. Therefore, for the purpose of scoring, a program of N chars that only uses ASCII characters and APL symbols can be considered to be N bytes long.

GolfScript (24 chars)
~](;3/{$}%:^1/{^\/,2=},,

Online demo
This relies on the triangle sides being GolfScript literals of the same type (and hence sortable): it would work equally well with strings.

+1 for almost the same solution at almost the same time.

Bash and coreutils (87,98,95,93)
Assumes input file is called "f",
sed 1d f|while read n;do echo `echo $n |tr ' ' '\n'|sort|tr '\n' ' '`;done|sort|uniq -u|wc -l

Reads line by line, sorts each line separately, then sorts all the lines. Finally the unique lines are filtered and counted. Also works for strings.
EDIT: As Yimin Rong pointed out, the first line containing the number of triangles is now handled (by removing it :) ).

I don't think it handles the first line correctly. I get 2 as the answer for the sample input with this script.

You're totally right. I missed the fact that there is a first line stating the number of triangles...

Cool, we came out with the same character counts but with completely different approaches!

I managed to shave 3 off by using "|" to pipe into the while loop instead of using "<" :)

C#: 250c
(compiled to exe; assumes "line" means from stdin, so ran as type trianglesfile | counttri.exe)
using System;using System.Linq;class P{static void Main(){int n=int.Parse(Console.ReadLine());var a=new string[n];while(--n>=0)a[n]=string.Join(":",Console.ReadLine().Split(' ').OrderBy(x=>x));Console.Write(a.GroupBy(s=>s).Count(g=>g.Count()==1));}}

Ungolfed:
using System;
using System.Linq;

class P
{
    static void Main()
    {
        int n = int.Parse(Console.ReadLine());            // reads line from stdin; converts to int without validation
        var a = new string[n];

        while (--n >= 0)
            a[n] = string.Join(":",                       // re-stringfy the following:
                               Console.ReadLine()         //  - read the next line
                                      .Split(' ')         //  - splits by space to form an array of sides
                                      .OrderBy(x => x)    //  - sorts by default comparison
                   );

        Console.Write(
            a.GroupBy(s => s)                             // group on the sorted, stringified value
             .Count(g => g.Count() == 1)                  // count the number of groups which have 1 member
        );
    }
}

C#: 116c
(via LINQPad, in "C# Statements" mode; assumes "line" means any single line from an arbitrary string s, definition not counted)
string s = @"5
1 2 3
2 1 3
4 5 6
3 1 2
8 7 6";            // <- input not included in overall count

Regex.Split(s,"\r\n").Skip(1).GroupBy(x=>string.Join(":",x.Split(' ').OrderBy(y=>y))).Count(g=>g.Count()==1).Dump();

Ungolfed:
string s = @"5
1 2 3
2 1 3
4 5 6
3 1 2
8 7 6";                                              // literal string definition, not counted

Regex.Split(s, "\r\n")                               // split on regex
     .Skip(1)                                        // who cares about the number of following lines?
     .GroupBy(x => string.Join(":",                  // re-stringify the following:
                               x.Split(' ')          //  - split by space into sides array
                                .OrderBy(y => y)))   //  - sort sides array
     .Count(g => g.Count() == 1)                     // count the number of groups that have 1 member
     .Dump();                                        // Output into LINQPad results pane

Perl, 53 50 45
perl -nE '$h{"@{[sort split]}"}++}{say-1+grep{!log}values%h'

Input either STDIN or append filename to the line above. "50" -- counting inside ' ' and n.
Another edit:
perl -nE '$h{1,sort split}++}{say-1+grep{!log}values%h'

i.e. 45. As I understand, the trick here is to force list context when evaluating hash index. Then Perl joins this list with $; (cf. with $" in my previous take). Without 1,, sort evaluates in scalar context = undefined behaviour.

The rules require you to count the cmdline flags you use other than -e/-E, so your total is 39.

Fixed, but managed to make it 38 ;)

Nice. Unfortunately, I just realized that this is solving a problem different than the one in the description. Your code is counting the number of triangles after omitting repeated triangles. But the description's test case makes it clear that the problem is to count the number of triangles that are not repeated at all. (For example, your program returns 3 instead of 1 for the given test case.)

You are certainly right. I updated my answer. Thanks a lot for checking and pointing out.

D - 201, 172, 171, 170 chars
Reads from STDIN only and relies on D 2.x for UFCS (Uniform Function Call Syntax) and assumes the -property compiler flag isn't set.
import std.stdio,std.algorithm,std.conv;void main(){int n=[stdin.readln[0]].to!int;char[][]a;while(n-->0)a~=stdin.readln.dup.sort;a.group.filter!(x=>x[1]<2).count.write;}

Normal indented version:
import std.stdio, std.algorithm, std.conv;

void main()
{
    int n = [ stdin.readln[0] ].to!int;
    char[][] a;

    while( n --> 0 )
        a ~= stdin.readln.dup.sort;

    a.group.filter!( x => x[1] < 2 ).count.write;
}

Input:
F:\Code\Other>rdmd tri.d
5
7 6 5
5 7 6
8 2 9
2 3 4
2 4 3

Output:
1

bash — 98 113 characters
I'm sure this isn't the smallest bash solution (assumes i is the input file):
rm -f w;sed 1d i|while read L;do echo $L|xargs -n 1|sort|xargs -n 3 >>w;done;sort <w|uniq -u|wc -l

Explanation:
rm -f w; // delete working file
sed 1d i|while read L; // read each line, skipping the first one
do echo $L|xargs -n 1|sort|xargs -n 3 >>w; // normalize each line by sorting the elements
done; // end of while loop
sort <w|uniq -u|wc -l // sort all the lines, pull out unique ones and count

Haskell (116, 99 w/o import)
import Data.List
main=getContents>>=(\x->print((length.(filter((<2).length)).group.(map(sort.words)).tail.lines)x))

If the file input contains the example input, run with:
$ cat input | runghc solution.hs
1

Ruby, 55 characters
a=$<.map{|s|s.split.sort}
p a.count{|b|1==a.count(b)}-1

The code is pretty straightforward for golfing standards:

first a=$<.map{|s|s.split.sort} reads all lineas from stdin, splits them into arrays, sorts them and stores them in the array a,
then a.count{|b|1==a.count(b)} counts how many of those arrays appear only once in a,
and the final -1 is just not to count the first line read from stdin :)

#include<iostream>
#include<stdio.h>

void unique_check();

typedef struct triangle
{
    int s1, s2, s3;

}t;

t *tp[10];

int no;
void main()
{
    int  i,ch=0;

    do
    {
        int ch;
        printf("Enter the no triangles\n");
        scanf_s("%d", &no);

        for (i = 0; i < no; i++)
        {
            tp[i] = (t *)malloc(sizeof(t));
            printf("Enter the sides of %d triangle ", i);
            scanf_s("%d", &tp[i]->s1);
            scanf_s("%d", &tp[i]->s2);
            scanf_s("%d" ,&tp[i]->s3);
        }

        unique_check();

        printf("Enter the choice\n1 Perform more \n2 End\n");
        scanf_s("%d", &ch);
        system("cls");

    } while (ch!=2);

}

void unique_check()
{
    int i, j, f = 0, count = 0,tri=0;

    for (i = 0; i < no; i++)
    {
        for (j = 0; j < no; j++)
        {
            if (i == j)
                continue;
            else
            {
                if (((tp[i]->s1 == tp[j]->s1) || (tp[i]->s1 == tp[j]->s2) || (tp[i]->s1 == tp[j]->s3)) &&
                    ((tp[i]->s2 == tp[j]->s1) || (tp[i]->s2 == tp[j]->s2) || (tp[i]->s2 == tp[j]->s3)) &&
                    ((tp[i]->s3 == tp[j]->s1) || (tp[i]->s3 == tp[j]->s2) || (tp[i]->s3 == tp[j]->s3)))
                {
                    f = 0;
                    break;
                }

                else
                    f = 1;
            }

        }

        if (f == 1)
            tri++, f = 0;

    }

    printf("No of unique triangle\n%d\n",tri);

}

Welcome to Programming Puzzles & Code Golf! The question is a [tag:code-golf], so please try to use as few characters as possible, and include the language name and character count in your answer.

Husk, 12 8 bytes
#εkOmwt¶

Try it online!
-4 bytes from Leo.

Nice job! I wouldn't have thought of using k to get unique lines easily. A couple of golfs for you: 1) x'  is exactly what w does 2) you could move the sort to be the function used by k instead of I, saving 2 bytes. Try it online!

@Leo cool. I'll add it in

Pyth, 17 bytes
This is not a serious participation, because Pyth is much younger than this question. Found the question while researching for another question and had to try it.
JmScd)t.zlfq/JT1J

Try it online: Pyth Compiler/Executor.
Wasted quite a few bytes on parsing the awkward input format.
       .z           read all of input
      t             discard the first line
 m                  map each line d to:
   cd)                 split d by spaces
  S                    and sort
J                   store the result in J
          f     J   filter J for trianges T, which satisfy the condition:
            /JT        count T in J
           q   1        == 1
         l          length / number of remaining triangles, print

Another 17 byte solution, which uses the .r command (run length encoding).
lfqeT1.rSmScd)t.z

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