Here's a Python solution... Someone please show me how to create that ash colored codish background... :/

$\text{Answer = 0}$

$\text{for p in range (100000, 1000000):}$

$~~~~~~~~\text{lst = [int(i) for i in str(p)]}$

$~~~~~~~~\text{if lst[0] + lst[1] + lst[2] == lst[3] + lst[4] + lst[5]:}$

$~~~~~~~~~~~~~~~~\text{Answer += 1}$

$\text{print Answer}$

Loop through all possible values for each digit, only $9\cdot 10^5$ possibilities. This can be achieved with a few for loops, and one if statement checking if the sum of the first 3 digits is the same as the sum of the last 3.

Python code:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

count = 0
for a in range(1,10):
    for b in range(0,10):
        for c in range(0,10):
            for d in range(0,10):
                for e in range(0,10):
                    for f in range(0,10):
                        if (a+b+c==d+e+f):
                            count+=1
print count

gives $50\boxed{412}$ .

counter=0
for x in range (100000,1000000):
y=str(x)
if int(y[0])+int(y[1])+int(y[2])==int(y[3])+int(y[4])+int(y[5]):
counter+=1

print(str(counter)[-3:])

Here is a java Program for this question

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

class sum
{
void main()
{

int a=0,f=0,h=0,s=0;
for(int i=100000;i<=999999;i++)
{f=i;
for(int j=1;j<=3;j++)
{

int b=f%10;
a=a+b;
f=f/10;
}
for(int v=1;v<=3;v++)
{

int b=f%10;
h=h+b;
f=f/10;
}
if(a==h)
{
s=s+1;
}
a=0;
f=0;
h=0;
}
System.out.println(s);
}
} 

public class LuckyNumbers {

/**
 * @param args
 */
public static void main(String[] args) {
    int count = 0;
    for (int i = 100000; i <= 999999; i++)
        if (isLucky(i))
            count++;
    System.out.println(count % 1000);

}

static boolean isLucky(int n) {
    int s1 = 0, s2 = 0;
    for (int i = 1; i <= 3; i++) {
        s1 += n % 10;
        n /= 10;
    }
    for (int i = 1; i <= 3; i++) {
        s2 += n % 10;
        n /= 10;
    }
    if (s1 == s2)
        return true;
    else
        return false;
}

}

While there's probably a more efficient way to do this problem, it's extremely easy if you use six nested for loops (ie. one for each digit). Here's a quick Javascript program to find N ("total number of positive 6-digit 'lucky' numbers"):

var n = 0;

for (var first = 1; first <= 9; first++) {
    for (var second = 0; second <= 9; second++) {
        for (var third = 0; third <= 9; third++) {
            for (var fourth = 0; fourth <= 9; fourth++) {
                for (var fifth = 0; fifth <= 9; fifth++) {
                    for (var sixth = 0; sixth <= 9; sixth++) {
                        if ((first + second + third) == (fourth + fifth + sixth)) {
                            n++;
                        }
                    }
                }
            }
        }
    }
}

console.log(n);

The following code returns $\boxed{50412}$ .

def SumDigits(x):
    result = 0
    while x > 0:
        result += x % 10
        x /= 10
    return result 

count = 0
for k in range(100000, 1000000):
    if SumDigits(k % 1000) == SumDigits(k / 1000):
        count += 1

print count

Solution in python 3:

lower_limit = 1 * (10**5)
upper_limit = (lower_limit * 10)

def iter_digits(number):
    if number:
        yield number % 10
        yield from iter_digits(number // 10)

def is_lucky(digits):
    return sum((digit if i < 3 else digit * -1) for i, digit in enumerate(digits)) == 0

N = sum(1 for number in range(lower_limit, upper_limit) if is_lucky(iter_digits(number)))

print(N) # Outputs 50412

Python solution

count = 0
for i in range(100000,1000000):
        if sum(map(int,str(i)[:3])) == sum(map(int,str(i)[3:])):
                count += 1
print count

map is a built-in python function. Usage : map( function , iterable , ...) which apply function to every item of iterable and return a list of the results.

Python (somewhat efficient):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

def sum(threedigit):
    return three%10 + three/100 + (three/10)%10

count = 0
for i in range(100000, 1000000):
    k = i/1000
    j = i%1000
    if sum(j)==sum(k):
        count+=1

print count

include <iostream>

using namespace std;

int main() 
{
    int count=0;
    for(int i=100000;i<=999999;i++)
    {
        int sum=0,sum2=0;
        int j=i,l=i/1000;
            for(int k=1;k<=3;k++)
            {
                    sum+=j%10;
                j=j/10;
                sum2+=l%10;
                l=l/10;
            }
        if(sum==sum2)
        count++;
    }
    cout<<count;
}

Here is Javascript Solution

count = 0;
for(num=100000; num<=999999; num++){
    a = num.toString().split('').map(function(e){ return parseInt(e); });
    if(a[0] + a[1] + a[2] == a[3] + a[4] + a[5])
        count++;
}
console.log(count);

The following Python code solves the given problem:-

a=100000

b=999999

c=0

d=0

number=0

while(a<=b):

e=a

f=str(e)

g=f[0]

h=int(g)

i=f[1]

j=int(i)

k=f[2]

l=int(k)

first_three=h+j+l

m=f[3]

n=int(m)

o=f[4]

p=int(o)

q=f[5]

r=int(q)

last_three=n+p+r

if(first_three==last_three):

    number=number+1

a+=1

print number

Here ,the number prints all the 6-digit numbers starting from 100000 to 999999 and whose sum of first three digit number is same as that of last three digit numbers...so,number=50412 and the last three digits are 412 which is the answer

The modulus operator can be used creatively to isolate the digits for solving this problem. An example of such is shown in the Python script below.

count = 0
for i in range(100000,1000000):
    first = ( (i - (i%100000)) / 100000)
    temp = i%100000
    second = ( (temp - (temp%10000)) / 10000)
    temp = i%10000
    third = ( (temp - (temp%1000)) / 1000)
    temp = i%1000
    fourth = ( (temp - (temp%100)) / 100)
    temp = i%100
    fifth = ( (temp - (temp%10)) / 10)
    sixth = i%10
    if first+second+third == fourth+fifth+sixth:
        count += 1
print count

Snakes, Snakes everywhere

def findSumOfDigits(number):
    return sum([int(number) for number in list(str(number))])

nos=0
for index in range(100000,1000000):
    if(findSumOfDigits(int(str(index)[:3]))==findSumOfDigits(int(str(index)[-3:]))):
        nos=nos+1

print findSumOfDigits(int(str(nos)[-3:]))

a=[]

count =0

for i in range (100000,1000000):

a=str(i)

b=int(a[0])+int(a[1])+int(a[2])

c=int(a[3])+int(a[4])+int(a[5])

if(b==c):

    count = count +1

print count

Here's what I did:

def isLucky(num):
    s = str(num)
    if len(s) == 6 and sum([int(x) for x in s[:3]]) == sum([ int(y) for y in s[3:]]):
        return True
    return False


start = 100000
end =   1000000
count = 0
while start < end:
    if isLucky(start):
        count+= 1

    start+=1

Here's my solution in C++:

#include <iostream>

using namespace std;

int main()
{
    int counter = 0;

    long I;
    int J;

    for(I = 100000; I <= 999999; I++)
    {
        long digits[6], temp = I;

        for(J = 5; J >= 0; J--)
        {
            digits[J] = I % 10;
            I /= 10;
        }

        I = temp;

        int first_sum = digits[0] + digits[1] + digits[2];
        int second_sum = digits[3] + digits[4] + digits[5];

        if(first_sum == second_sum)
        {
            //cout << I << endl;
            counter++;
        }
    }

    cout << endl << counter << endl;

    return 0;
}

Output

50412 .

Hence the last 3-digits are $\boxed{412}$ .

int n=0,a,b,c=0,d=0; int suma,sumb; for(int i=100000;i<=999999;i++){ a=i/1000; b=i%1000; //System.out.println(a); //System.out.println(b); while(a>0){ c+=a%10; a=a/10;

        }
        while(b>0){
            d+=b%10;
            b=b/10;

        }
        if(c==d){
            n++;
        }
        c=0;
        d=0;
    }
    System.out.println(n);

def lucky_num():

number = 99999
first = ""
last = ""
count = 0
while number < 999999:
    number = number + 1
    if len(str(number)) == 6:
        first = str(number)[0:3]
        last = str(number)[3:6]
        num1 = 0
        num2 = 0
        for j in first:
            num1 = num1 + int(j)
        for k in last:
            num2 = num2 + int(k)
    if num1 == num2:
        count = count + 1
print count

too long not very good solution :P but it works

while(i<999999) { j = i; un = j % 10;

        j = j / 10;
        de = j % 10;

        j = j / 10;
        hu = j % 10;

        j = j / 10;
        th = j % 10;

        j = j /10;
        teth = j % 10;

        j = j /10;
        la = j % 10;

        lastThree = un + de + hu;
        firstThree = th + teth + la;

        if(lastThree == firstThree)
        {
            counter++;
        }
        i = i + 1;

    }
    System.out.println("Number of Lucky Numbers" + counter);

Code for VB.Net:

Public Class Form1

Dim contLuckyNumbers As Integer

Private Sub Button1_Click(sender As Object, e As EventArgs) Handles Button1.Click
    Dim str As String = ""
    Dim part1, part2 As Integer
    For n = 100000 To 999999
        str = n.ToString
        part1 = CInt(str.Substring(0, 1)) + CInt(str.Substring(1, 1)) + CInt(str.Substring(2, 1))
        part2 = CInt(str.Substring(3, 1)) + CInt(str.Substring(4, 1)) + CInt(str.Substring(5, 1))
        If part1 = part2 Then
            contLuckyNumbers = contLuckyNumbers + 1
        End If
    Next
    Label1.Text = contLuckyNumbers.ToString
End Sub

End Class

Forgive my inelegant code:

count = 0
for i in range(100000,1000000):
    if int(str(i)[0])+int(str(i)[1])+int(str(i)[2]) == int(str(i)[3])+int(str(i)[4])+int(str(i)[5]):
        count += 1
print count

>>> 50412

Therefore the answer is $\boxed{412}$

Write this in python

def firstsum(n):

    s=0

    n=n//1000

    for i in range(3):

        r=n%10

        n=n//10

        s=s+r

    return s

def lastsum(m):

    a=0

    for j in range(3):

        a=a+m%10

        m=m//10

    return a

b=0

for i in range(100000, 1000000):

    if firstsum(i)==lastsum(i):

        b=b+1

print(b)

Code in Java...

public class DigitSum{
public static void main(String[] args){
    int luckyCount = 0;
    int tempDigit1, tempDigit2, tempDigit3, tempDigit4, tempDigit5, tempDigit6, tempI;
            //loops through all of the six digit numbers
            //we take mod 10 to find the individual digits
    for(int i=100000; i<=999999; i++){
                    //temporary digits are used as we want to see if the sum of the digits are equal
        tempDigit1 = i%10;
                    //a temporary i is used so that the loop counter doesn't get confused
        tempI = i/10;
        tempDigit2 = tempI%10;
        tempI = tempI/10;
        tempDigit3 = tempI%10;
        tempI = tempI/10;
        tempDigit4 = tempI%10;
        tempI = tempI/10;
        tempDigit5 = tempI%10;
        tempI = tempI/10;
        tempDigit6 = tempI%10;
        if((tempDigit1+tempDigit2+tempDigit3) == (tempDigit4+tempDigit5+tempDigit6)){
            luckyCount++;
        }
                    //the number we are on is printed so we see the progress of the computing
        System.out.println("Lucky"+i);
    }
    System.out.println("Lucky Count = "+luckyCount);
}
    }

//In the end there is an output of 50412 so the last three digits of that is 412

#

Haskell:

digits 0 = []
digits n = (digits (n `div` 10)) ++ [n `mod` 10]

isSixDigits = (==6) . length . digits
sumFirstThree n = sum $ take 3 $ digits n
sumLastThree n = sum $ take 3 $ reverse $ digits n

isLucky n = (isSixDigits n) && (sumFirstThree n == sumLastThree n)
run = reverse $ take 3 $ reverse $ digits $ length $ filter isLucky [100000..999999]

I mapped the numbers from 100,001 to 999,999 to a new array. If it is lucky, it will be replaced with a true, other wise with a false. Then I just count the number of trues in the array.

a = 100001.upto(999999).map do |n|
  str = n.to_s
  puts n if n % 100000 == 0
  str[0, 3].split("").map { |a| a.to_i }.reduce(:+) == str[3, 7].split("").map { |a| a.to_i }.reduce(:+)
end

puts a.count(true)

Python Implementation:

def equal_digit_sums():

dists= {}

for i in range(1000):

    digits = [int(d) for d in str(i)]

    dsum = sum(digits)

    if dsum not in dists:

        dists[dsum] = [0,0]

    dists[dsum][0 if len(digits) == 3 else 1] += 1

def prod(dsum):

    t = dists[dsum]

    return (t[0]+t[1])*t[0]

return sum(prod(dsum) for dsum in dists)

print(equal_digit_sums())

Result: $50412$

I used C++:

int luckynumbers = 0;

for (int i = 100000; i < 1000000; i++)
{
if (((i / 100000) + ((i / 10000) % 10) + ((i / 1000) % 10)) == (((i / 100) % 10) + ((i % 100) / 10) + (i % 10)))
    {
                          luckynumbers++;
    }
}

cout << luckynumbers % 1000;

And got 412... I think the main problem was to obtain each digit from my int i... but it is actually easy to get the n number of an int; you should remember that to get any number from left to right, you should do $a/10^n$ and if you wanted to get the number from right to left, you should do $a percentage 10^n$ . You can do this many times to break a string of integers.

Solution in Python:

res = 0
for i in range(100000, 1000000):
    i = str(i)
    i1, i2 = i[:3], i[3:]
    i1, i2 = map(int, i1), map(int, i2)
    if sum(i1) == sum(i2):
        res += 1
print res

I'm only an amateur programmer, so please give me suggestions on how to refine my code (in Python). Thanks!

def lucky(k):
    if int(str(k)[0]) + int(str(k)[1]) + int(str(k)[2]) == int(str(k)[3]) + int(str(k)[4]) + int(str(k)[5]):
        return True
    else:
        return False
count = 0
for k in range(100000, 1000000):
    if lucky(k):
        count += 1
print count

I got an output of 50412 in about 5 seconds.

We can use the following C++ code:

include<constream.h>

void main()

{clrscr();

long n,count=0;

int a,b,r,s,c=0,d=0;

for(n=100000;n<=999999;n++)

{a= n/1000;

b= (n%1000);

while(a!=0)

{r=(a%10);

c= (c+r);

a=(a/10);

}

while(b!=0)

{s=(b%10);

d= (d+s);

b=(b/10);

}

if(c==d)

{cout<<"\t("<<c<<","<<d<<","<<n<<")";

count++;

}

c=0;

d=0;

}

cout<<"\n\tTotal = "<<count;

getch();

return;

}

Output: Total = 50412. Therefore, 412 (Ans)