double the number

[Arjun Shastry]

This one is quick and interesting.
Natural number ends with 2.If we remove this 2 and place it at the beginning, the number gets doubled.Find the smallest possible original number.
(e.g. number is say 142. New number will be 214. 214 is not twice 142 so 142 is not such number).

[palanisamy subramani]

I tried all the possible way. This is the only number coming very nearer but not as per your expected result.
1052:2105.

I am suspecting whether that question has any answer.

[Mike Simmons]

palanisamy subramani wrote:I tried all the possible way.

Really? All of them?

[Arjun Shastry]

I found the number.Its quite big.Let others try.

[anirudh jagithyala]

Hey Arjun,

I tried out the problem and found the answer as:105263157894736842

Not sure whether it is the smallest one.....is it right...?

[Arjun Shastry]

anirudh jagithyala wrote:Hey Arjun,

I tried out the problem and found the answer as:105263157894736842

Not sure whether it is the smallest one.....is it right...?

i too found the same number but not sure its smallest one.Waiting for others.

[Paul Clapham]

No need to wait... the title of this forum is Programming Diversions. While the question is certainly diverting, I haven't seen any programming yet.

[fred rosenberger]

Paul Clapham wrote:No need to wait... the title of this forum is Programming Diversions. While the question is certainly diverting, I haven't seen any programming yet.

Maybe you could interpret the title as 'diversions AWAY from programming', thus no programming required.

[Mike Simmons]

This gives all solutions up to 100 digits:

  // Solve for x:
  // 2 * (10*x + 2) = 2*10^n + x
  //
  // 19*x = 2*10^n - 4
  // x = (2*10^n - 4)/19
  // 10^(n-1) <= x < 10^n
  public static void main(String[] args) {
    final BigInteger BI_2 = new BigInteger("2");
    final BigInteger BI_4 = new BigInteger("4");
    final BigInteger BI_19 = new BigInteger("19");
    BigInteger tens = BigInteger.ONE;
    for (int n = 1; n < 100; n++) {
      tens = tens.multiply(BigInteger.TEN);
      BigInteger[] result = tens.multiply(BI_2).subtract(BI_4).divideAndRemainder(BI_19);
      if (BigInteger.ZERO.equals(result[1])) {
        BigInteger x = result[0];
        // This last check seems to be unneccessary - 
        // but it's easier to just do it than to prove it's not needed
        if (x.compareTo(tens) < 0 && x.multiply(BigInteger.TEN).compareTo(tens) >= 0) {
          System.out.println(x);
        }
      }
    }
  }

The result is

10526315789473684
10526315789473684210526315789473684
10526315789473684210526315789473684210526315789473684
10526315789473684210526315789473684210526315789473684210526315789473684
10526315789473684210526315789473684210526315789473684210526315789473684210526315789473684

The pattern is clear.

Obviously, what I was solving for was all the digits other than the 2, which moves.

[Eugene Rabii]

I have to say, this is impressive!
I have reached the same code:

x = ( 2*(10^n) - 4 ) / 19

And it was a pleasure getting here!

Cheers, Eugene

[Greg Charles]

Eugene Rabii wrote:I have to say, this is impressive!
I have reached the same code:

x = ( 2*(10^n) - 4 ) / 19

And it was a pleasure getting here!

Cheers, Eugene

-4? -2 surely?

My thinking runs this way:

2 * (10^n) + (x-2)/10 = 2x
2 * (10^(n+1)) + x - 2 = 20x
2 * (10^(n+1)) - 2 = 19x
x = (2 * (10^(n+1)) - 2 ) / 19

So, we just look for a value of n that makes x an integer ending with 2. The n vs (n+1) doesn't matter, but the -4 vs -2 will produce different answers.

OK, code time:

		BigInteger two = new BigInteger("2");
		BigInteger ten = new BigInteger("10");
		BigInteger nineteen = new BigInteger("19");
		
		for (int n = 2; n < 1000; n++) {
			BigInteger x = two.multiply(ten.pow(n)).subtract(two);
			BigInteger [] result = x.divideAndRemainder(nineteen);
			System.out.println(n + ", " + result[0] + ", " + result[1]);
			if (result[1].intValue() == 0 && result[0].mod(ten).intValue() == 2)
				break;
		}

Results:

2, 10, 8
3, 105, 3
4, 1052, 10
5, 10526, 4
6, 105263, 1
7, 1052631, 9
8, 10526315, 13
9, 105263157, 15
10, 1052631578, 16
11, 10526315789, 7
12, 105263157894, 12
13, 1052631578947, 5
14, 10526315789473, 11
15, 105263157894736, 14
16, 1052631578947368, 6
17, 10526315789473684, 2
18, 105263157894736842, 0

So the answer is 105263157894736842. The check for the last digit being 2 turned out to be unnecessary, but I think that's a coincidence.

ETA: In reading through Mike's solution, I see the -4 makes sense if you declare x to be the number without the final 2. Sorry about that!

I wonder if we can prove we don't have to check the final digit, as both Mike and I discovered?

[Mike Simmons]

Eugene is quoting the same formula I used above. And we got the same answer - except that as I noted above, my 'x' represented all the digits other than the 2. So I got

10526315789473684

and you got

105263157894736842

[Rohini Sahuji]

I tried some thing very simple and may sound very stupid....


BigInteger i,a,b;
for(i=0;i<100000000000000;i++)
{
String x,y;
String num = Integer.toString(i);
x = num+"2";
y = "2"+num;
int a = Integer.parseInt(x);
int b = Integer.parseInt(y);

if(a==(b/2))
System.out.println(a+" "+b);
}

did not get any no...though....

[Mike Simmons]

Rohini Sahuji wrote:did not get any no...though....

It's possible this is caused by the fact that your code does not compile. That's just a guess though.