print len([(x,y) for x in xrange(1000) for y in xrange(1000) if sum([int(ch) for ch in str(x)]) == sum([int(ch) for ch in str(y)])])

while i<1000000:
...
i+=1

for i in range(1000000):

q = int(na[0])+int(na[1])+int(na[2])

q = sum([for ch in str(i % 1000)])

print "all count="+str( a)

print "all count =", a

print "all count=%d" % a

u = {}
for ...
    ...
    if q == w:
        a += 1
        if q in u:
            u[q] += 1
        else:[br]
            u[q] = 1

#!/usr/bin/env python2
import itertools
import collections

numbers = range(10)

count = 0
sums = collections.defaultdict(int)

for lnums in itertools.product(numbers, numbers, numbers):
    for rnums in itertools.product(numbers, numbers, numbers):
        lsum = sum(lnums)
        if lsum == sum(rnums):
            count += 1
            sums[lsum] += 1

print count
for s in sorted(sums):
    print s, sums[s]

m = [sum(int(j) for j in str(i)) for i in range(0, 1000)]
for i, j in dict((i, m.count(i)) for i in set(m)).items():
	print i, " = ", j * j

from itertools import groupby, product
for k, g in groupby(sorted(sum(r) for r in product(*([range(10)] * 3)))):
    sum_count = len(list(g))
    print k, sum_count*sum_count

q = sum([for ch in str(i % 1000)])

-module(lucky).

-compile(export_all).

main() ->
  Nums = lists:seq(0, 9),
  Solve = [[{ticket, [X1,X2,X3,X4,X5,X6]}, {sum, X1+X2+X3}] ||
	    X1 <- Nums,
	    X2 <- Nums,
	    X3 <- Nums,
	    X4 <- Nums,
	    X5 <- Nums,
	    X6 <- Nums, (X1+X2+X3 =:= X4+X5+X6)],
  UniqueSums = lists:usort([Sum || [X,{sum, Sum}] <- Solve]),
  R = lists:map(fun(Sum) ->
		    SumLength = length(lists:filter(
					 fun([_Ticket, {sum, SumSolve}]) ->
					     SumSolve =:= Sum
					 end,
					 Solve)),
		    {Sum, SumLength}
		end,
		UniqueSums),
  io:format("~p ~n", [R]).

sum() ->
	N = lists:seq(0, 9),	
	L = [{A, B, C, D, E, F} || A<-N, B<-N, C<-N, D<-N, E<-N, F<-N, A+B+C == D+E+F],
	do_filter_helper(0, L),
	length(L).

do_filter_helper(9*3+1, _L) ->
	ok;

do_filter_helper(N, L) ->
	do_filter(N, 0, L),
	do_filter_helper(N+1, L).

do_filter(N, Sum, []) ->
	io:format("~5w: ~5w~n", [N, Sum]);

do_filter(N, Sum, [H|T]) ->
	{A, B, C, _D, _E, _F} = H,
	if 
		A+B+C == N ->
			do_filter(N, Sum+1, T);
		true ->
			do_filter(N, Sum, T)
	end.

q = sum([for ch in str(i % 1000)])

q = sum([int(ch) for ch in str(i % 1000)])

q = sum([int(ch) for ch in str(i / 1000)])

sum([int(ch) for ch in "012"]) == sum(int(ch) for ch in "12"])

-module(lor).
-export([main/0, counter/1]).

main() ->
	CounterPid = spawn(lor, counter, [dict:new()]),
	N = lists:seq(0, 9),	
	L = [{A, B, C, D, E, F} || A<-N, B<-N, C<-N, D<-N, E<-N, F<-N, A+B+C == D+E+F],
	F = fun(E) ->
		CounterPid ! {add, E}
		end,
	lists:map(F, L),
	CounterPid ! {show_elements, self()},
	receive
		ok ->
			length(L)
	end.
	
counter(Dict) ->
	receive
		{add, E} ->
			{A,B,C,_E,_D,_F} = E,
			counter(dict:update_counter(A+B+C, 1, Dict));
		{show_elements, Pid} ->
			F = fun(K, V) ->
				io:format("~5w: ~10w~n", [K, V])
			end,
			dict:map(F, Dict),
			Pid ! ok
	end.

#!/usr/bin/env python

def is_happy(N):
    '''
    If ticket has happy number N, return a happy sum.
    '''
    x=[int(c) for c in str(N).zfill(6)]
    s1=sum(x[:3]); s2=sum(x[3:])
    if s1==s2:
        return s1

def happy_tickets(A):
    '''
    Draw all happy numbers from array A and find a distribution of their sums.
    
    Returns:
    nums  - array of happy numbers
    hsums - happy sums
    nrep  - number of repetitions of each sum
    '''
    # Find happy numbers and happy sums first
    nums=[]; sums=[]
    for num in A:
        sum=is_happy(num)
        if isinstance(sum,int):
            nums.append(num); sums.append(sum)

    # Now find a distribution of sums
    hsums=set(sums) # A set of happy sums without repetitions
    nrep=[] # Number of repetitions of each sum
    
    for sum in hsums:
        nrep.append(sums.count(sum))
    return nums,hsums,nrep

# Now test a pack of tickets with odd numbers in range 1:1000000
nums,hsums,nrep=happy_tickets(range(1,1000000,2))

#Print results
print 'Total of ', len(nums), ' happy tickets'
print 'Distribution of sums:'
for i,s in enumerate(hsums):
    print 'Sum= ', s, 'number of repetitions= ', nrep[i]

# If matplotlib is installed, make a plot of distribution
try:
    import matplotlib.pyplot as pl
    pl.figure(1); pl.clf(); pl.bar(hsums,nrep)
    ax=pl.gca(); ax.set_title('Distribution of happy sums')
    ax.set_xlabel('happy sum'); ax.set_ylabel('number of repetitions')
    pl.grid(); pl.show()
except:
    pass

...
    import matplotlib
    matplotlib.use('GTKAgg')
    # перед этой шняжокой
    import matplotlib.pyplot as pl
...

except ImportError, err:
    print err