An interview puzzle: A Broken Calculator - algorithm

Question

Time limit : 2sec / Stack limit : 256MB / Memory limit : 256MB
Problem
Dave's calculator is broken. It halts when presented with more than K different digits.
Dave wants to input an integer A, but if he inputs this number correctly the calculator might halt. Instead, he inputs the closest integer that won't halt the calculator.
Output the difference between Dave's input and the integer A.
Input
The input will be given in the following format from the Standard Input.
A K
On the first line, you will be given the integer A(1≦A≦10^15), the integer Dave wants to input, followed by a space and K(1≦K≦10), the number of different digits his calculator can recognize.
Output
Output the minimum difference between Dave's input and the integer A in one line. Make sure to insert a line break at the end of the output.
Input Example 1
1234 2
Output Example 1
12
In this case Dave can only use up to 2 different digits. He will input the closest integer 1222, so the difference is 12.
Input Example 2
7328495 10
Output Example 2
0
In this case Dave's calculator is not broken at all. He can input the given integer A as is.
Input Example 3
800000 1
Output Example 3
22223
Dave can use only one digit, so 777777 is the closest integer.
Input Example 4
262004 2
Output Example 4
218
The closest integer is 262222.
I have solved the problem by a brute force solution...
I try all possible situation where i in 1<= i < A or A < i <= 10^15.
I'll get two solutions composed from K different digits, and find the min difference between A and solutions.
It's a straightforward solution.
When A is larger, the execution will exceed the threshold of 2 sec.
Is there a smart and efficient way to solve it?

Answer 1

The first part is: Choose which k digits (out of the 10 possible) are used in the result
With a bit math (binomial coefficient) it´s easy to calculate the number
of different digit combinations possible for a given k.
There are up to 252 possibilities to choose (252 if k=5, else not so many).
If it is not clear what I´m saying: For k=2, there are 01,02,03,...09,12,13,...,19,23,24,...,89
No eg. 11 because it´s only 1 but k=2 allows two different digits.
And no eg. 90 because it´s the same as 09, 91=19 etc.
The count of these possible combinations is 252 for k=5, and it won´t get larger.
Finding all of the (up to) 252 possibilities for the current k
and iterating over them in a loop shouldn´t be too hard.
For each of the possibilities do the following:
{
Within the loop, we have the A, K, and the current choosen valid digits
for the solution (latter differs in each iteration of the loop, of course)
Lets take A=12899, K=3, digits 123 as example.
Now search the first digit of a (from left to right) which is not allowed.
In the example, this would be 12899, because 1 and 2 left of it are allowed.
Replace this (8) with the next-lower allowed digit (2) if there is one
and replace everything right of it with the highest possible digit (3 too).
12899=>12399=>12333
Save the result 12333 somewhere in an array etc.
If there was no next-lower possible digit, do nothing (nothing goes to the array)
(A proper addition with carry would introduce a new digit left of the changed one,
ie. invalid. A solution with this new digit will be found
when the loop comes to that digit)
Then the same thing again in the other direction:
Replace the found digit with the next-higher possible one
and everything right with the lowest. This goes in the array too,
of course only if there was a next-higher possible digit.
In case of 12899, the only higher replacement for 8 would be 9,
but 9 is not possible (only 123).
}
After the whole loop has finished (and every iteration has produced
up to two new array entries), you have up to 502 possible solutions for the problem.
The only thing left to do is to check which soltion is the best (ie. calculate the difference
to A for every entry and take the solution which minimal difference)

Answer 2

At each step you can use the digit you need, that digit + 1 (mod 10), that digit -1 (mod 10), or any digit you have used before. Once you run out of digits you can only use digits you have used before.
This creates a tree. At each step take the current states and calculate all possible new states in the next level down.
You can prune the tree as you go along by removing any next steps that have a delta that's more than a certain distance from the smallest delta of any of the next steps.
This is essentially a linear programming problem.
Below is the complete algorithm! Maybe someone can fine tune the decision as to which branches to prune to make it even faster.
using System.IO;
using System;
using System.Collections.Generic;
using System.Linq;
public static class Converter
{
public static int ToInt(this IEnumerable<int> values)
{
return values.Aggregate(0, (total, v) => total * 10 + v);
}
public static IEnumerable<int> ToList (this int value)
{
if (value == 0) return Enumerable.Empty<int>();
else return value.ToString().Select(x => (int)x - '0').ToList();
}
}
class Program
{
static void Main(string[] args)
{
//int desired = 262004;
//int digits = 2;
int desired = 800000;
int digits = 1;
IEnumerable<State> currentStates = new[] { new State(0, 0, desired, digits) };
foreach (var digit in desired.ToList())
{
var nextStates = currentStates.SelectMany(x => x.NextPossibleStates());
foreach (var state in nextStates.OrderBy(s => s.Delta()).Take(10))
{
Console.WriteLine(state.ToString());
}
currentStates = nextStates;
Console.WriteLine("------------");
}
Console.ReadKey();
}
public class State
{
int index;
int current;
int desired;
int digitsRemaining;
private int desiredToNow()
{
return desired.ToList().Take(index).ToInt();
}
public int Delta()
{
return Math.Abs(desiredToNow() - current);
}
public State(int index, int current, int desired, int digitsRemaining)
{
this.index = index;
this.current = current;
this.desired = desired;
this.digitsRemaining = digitsRemaining;
}
private State Next (int nextDigit, int digitsRemaining)
{
return new State(this.index + 1, this.current * 10 + nextDigit, this.desired, digitsRemaining);
}
private IEnumerable<int> NextPossibleDigitsWithDuplicates()
{
if (this.digitsRemaining > 0)
{
int nextDesiredDigit = desired.ToList().Skip(index).First();
yield return nextDesiredDigit;
yield return (nextDesiredDigit + 9) % 10;
yield return (nextDesiredDigit + 1) % 10;
}
// Any previously used digit is OK
foreach (int i in this.current.ToList())
yield return i;
}
public IEnumerable<State> NextPossibleStates()
{
var possibles = this.NextPossibleDigitsWithDuplicates().Distinct();
var possiblesUsingExistingDigits = possibles.Where(p => this.current.ToList().Contains(p));
var possiblesUsingNewDigits = possibles.Where(p => !this.current.ToList().Contains(p));
var states = possiblesUsingExistingDigits.Select(p => Next(p, this.digitsRemaining))
.Concat(possiblesUsingNewDigits.Select(p => Next(p, this.digitsRemaining - 1)))
.ToList();
var bestDelta = states.Min(s => s.Delta());
// Now reject any that can never be better
// Guessing on the '2' here ...
var validStates = states.Where(s => s.Delta() < bestDelta + 2);
return validStates;
}
public override string ToString()
{
return this.current + " d=" + this.Delta() + " remaining " + this.digitsRemaining;
}
}
}

Answer 3

After thinking a bit about the problem I guess an A* algorithm that assigns digits from left to right is best. For that we need an estimation of the lower bound for the error of a partial solution. A simple possibility is:
if the already set digits are exactly the same as in the problem the bound is 0
if the already set digits are lower as in the problem replace the missing digits by 9 to get the lower bound
if the already set digits are higher as in the problem replace the missing digits by 0 to get the lower bound
Taking the example problem 12899 3 the algorithm would work like this:
Start node
node best error
xxxxx 12899 0
expansion of the most promising partial solution xxxxx
node best error
0xxxx 09999 2900
1xxxx 12899 0
2xxxx 20000 7101
3xxxx 30000 17101
4xxxx 40000 27101
5xxxx 50000 37101
6xxxx 60000 47101
7xxxx 70000 57101
8xxxx 80000 67101
9xxxx 90000 77101
Expansion of the most promising partial solution 1xxxx
node best error
0xxxx 09999 2900
10xxx 10999 1900
11xxx 11999 900
12xxx 12899 0
13xxx 13000 101
14xxx 14000 1101
15xxx 15000 2101
16xxx 16000 3101
17xxx 17000 4101
18xxx 18000 5101
19xxx 19000 6101
2xxxx 20000 7101
3xxxx 30000 17101
4xxxx 40000 27101
5xxxx 50000 37101
6xxxx 60000 47101
7xxxx 70000 57101
8xxxx 80000 67101
9xxxx 90000 77101
Expansion of the most promising partial solution 12xxx
node best error
0xxxx 09999 2900
10xxx 10999 1900
11xxx 11999 900
120xx 12099 800
121xx 12199 700
122xx 12299 600
123xx 12399 500
124xx 12499 400
125xx 12599 300
126xx 12699 200
127xx 12799 100
128xx 12899 0
129xx 12900 1
13xxx 13000 101
14xxx 14000 1101
15xxx 15000 2101
16xxx 16000 3101
17xxx 17000 4101
18xxx 18000 5101
19xxx 19000 6101
2xxxx 20000 7101
3xxxx 30000 17101
4xxxx 40000 27101
5xxxx 50000 37101
6xxxx 60000 47101
7xxxx 70000 57101
8xxxx 80000 67101
9xxxx 90000 77101
Expansion of the most promising partial solution 128xx (only the digits 1, 2 and 8 are allowed now)
node best error
0xxxx 09999 2900
10xxx 10999 1900
11xxx 11999 900
120xx 12099 800
121xx 12199 700
122xx 12299 600
123xx 12399 500
124xx 12499 400
125xx 12599 300
126xx 12699 200
127xx 12799 100
1281x 12819 80
1282x 12829 70
1288x 12889 10
129xx 12900 1
13xxx 13000 101
14xxx 14000 1101
15xxx 15000 2101
16xxx 16000 3101
17xxx 17000 4101
18xxx 18000 5101
19xxx 19000 6101
2xxxx 20000 7101
3xxxx 30000 17101
4xxxx 40000 27101
5xxxx 50000 37101
6xxxx 60000 47101
7xxxx 70000 57101
8xxxx 80000 67101
9xxxx 90000 77101
Expansion of the most promising partial solution 129xx (only the digits 1, 2 and 9 are allowed now)
node best error
0xxxx 09999 2900
10xxx 10999 1900
11xxx 11999 900
120xx 12099 800
121xx 12199 700
122xx 12299 600
123xx 12399 500
124xx 12499 400
125xx 12599 300
126xx 12699 200
127xx 12799 100
1281x 12819 80
1282x 12829 70
1288x 12889 10
1291x 12910 11
1292x 12920 21
1299x 12990 91
13xxx 13000 101
14xxx 14000 1101
15xxx 15000 2101
16xxx 16000 3101
17xxx 17000 4101
18xxx 18000 5101
19xxx 19000 6101
2xxxx 20000 7101
3xxxx 30000 17101
4xxxx 40000 27101
5xxxx 50000 37101
6xxxx 60000 47101
7xxxx 70000 57101
8xxxx 80000 67101
9xxxx 90000 77101
Expansion of the most promising partial solution 1288x (only the digits 1, 2 and 8 are allowed now)
node best error
0xxxx 09999 2900
10xxx 10999 1900
11xxx 11999 900
120xx 12099 800
121xx 12199 700
122xx 12299 600
123xx 12399 500
124xx 12499 400
125xx 12599 300
126xx 12699 200
127xx 12799 100
1281x 12819 80
1282x 12829 70
12881 12881 18
12882 12882 17
12888 12888 11 <-- optimal solution found
1291x 12910 11
1292x 12920 21
1299x 12990 91
13xxx 13000 101
14xxx 14000 1101
15xxx 15000 2101
16xxx 16000 3101
17xxx 17000 4101
18xxx 18000 5101
19xxx 19000 6101
2xxxx 20000 7101
3xxxx 30000 17101
4xxxx 40000 27101
5xxxx 50000 37101
6xxxx 60000 47101
7xxxx 70000 57101
8xxxx 80000 67101
9xxxx 90000 77101
This does still not cover the case that the optimal solution may have more digits than the original number (not sure if this is even possible), but you get the idea ...

Answer 4

For K=10 , the solution is trivial. Difference equals to 0.
If the original number use less than or equals to K distinct digit. Difference equals to 0. For example, 987777 5 use 3 distinct digit which is less than K (= 5).
For K=1 ,
A number with length n will be bound by 999...999 (n-digit) and 999...999((n-1)-digit). Which mean 587 is bound by 999 and 99. Hence, the solution must either be a n-digit length number or 999...999((n-1)-digit).
Let leading digit of the number be a (5 in 587), denote b=a+1 and c=a-1. Compare the number with aaa...aaa, bbb...bbb, ccc...ccc (all n-digit length). Notice that this just check at most 2 of them.
If original number = aaa...aaa, difference equals to 0.
If original number > aaa...aaa, continue to compare with bbb...bbb.
If original number < aaa...aaa, continue to compare with ccc...ccc.
Regulation for K=1, if b=10, ignore bbb...bbb since aaa...aaa = 999...999 which is upper bound. if c=0, change ccc...ccc to 999...999((n-1)-digit) for lower bound checking like 10000 1 -> 9999
For K in range [2,9], observe that first K-1 distinct digit from left to right must be used. For example, 9988898988981234 3, 2 digit 9 and 8 must be used in this case.
Proof:
Fact :
Number of distinct digit in original number > K
K-1 != 0
We can always form two value z000...000 and z999...999 using K distinct digit where z is form by K-1 distinct digit (z = 998889898898 in above example) and assign K th digit as 0 or 9 (ignore the fact that 0 or 9 may be used in K-1 as not important)
With z000...000 and z999...999 (9988898988980000 and 9988898988989999), the optimal solution is bound by the two value. If z change to z+1 or z-1, the difference will increase which makes no sense. Thus, z part will always be used and first K-1 distinct digit from left to right must be used holds.
End of Proof
At the first encounter K th distinct digit (leading digit right after z part, denote as t), there are three possible cases to consider: t, t+1 and t-1.
Let's start with t first. Using t will use up all K digit, so no more digit can be assigned. Keep on to check digit on the right part until we encounter a digit that is not in those K distinct digit. This time, we have at most two choose. The closest digit in K that is larger than the encounter digit and the closest digit in K that is smaller than the encounter digit. Using larger closest digit in K will result in a number larger than original number, so the remaining digit should be minimized by choosing smallest digit in K. Similarly, the remaining digit for smaller closest digit in K case will be largest digit in K.
For case t+1, this only need to be checked when there is no larger closest digit in K for case t. Using t+1 will always larger than original number, we need to minimized the remaining digit. Notice that t+1 may be one of the digit in K-1 , we have a free digit and so include 0 (if 0 is not in K-1). Then, we can choose the smallest digit in K (or K-1 if t+1 and 0 are in K-1) for remaining digit.
For case t-1, this only need to be checked when there is no smaller closest digit in K for case t. Using t-1 will always smaller than original number, we need to maximized the remaining digit. Notice that t-1 may be one of the digit in K-1 , we have a free digit and so include 9 (if 9 is not in K-1). Then, we can choose the largest digit in K (or K-1 if t-1 and 9 are in K-1) for remaining digit.

Answer 5

The solution time is O(len(A)).
To find the min|A - B|, with differnt K digits number.
First , to remove the abs, we should find B1 with the condition( min(Bi| Bi>=A, with different digits number),
Let A=a1a2...an, B1 = b1b2…bn,find the longest sequence which ai=bi until the different number exceed the K. Suppose we have a1->aj = b1->bj
If j == n, then B1 = A
From the set of {a1, a2,…,aj}, find the minimal number which is bigger than b[j+1]
If find ak(1<=k<=j), then let b[j+1]= ak, and the rest of b[j+1]->bn is filled with min{a1, a2,…,aj}
If not find, we change bj from aj to a[j]+1. For the rest of b[j+1]->bn,
If a[j]+1 is in the set of {a1, a2,…,aj-1}, it means we still can have one digit to press, we choose the 0 as the padding. b[j+1]->bn is all filled with 0.
If a[j]+1 is not in the set of {a1, a2,…,aj-1}, we choose the min{a1, a2,…,aj-1, a[j]+1} as the value which is filled with b[j+1]->bn
Similarity, we can find the closest number B2 which is smaller than A,
After that ,we just compare the B1-A with A-B2, choose the minimal.
Following the C++ Code:
#include <vector>
#include <list>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <sstream>
using namespace std;
string target_num;
string up_num;
string down_num;
int K;
bool hash_key[10];
bool hash_copy[10];
int find_closet_k(int c, bool up) {
int i = c;
while(true) {
if (hash_key[i]) {
return i;
}
if(up) {
++i;
if (10 <= i) {
break;
}
} else {
--i;
if (i < 0) {
break;
}
}
}
return -1;
}
char min_k() {
for (int i = 0; i < 10; ++i) {
if (hash_key[i]) {
return '0' + i;
}
}
}
char max_k() {
for (int i = 9; 0 <= i; --i) {
if (hash_key[i]) {
return '0' + i;
}
}
}
bool is_head_zero(int v, string num,int end_pos) {
if (0 == v) {
for (int i = 0; i < end_pos; ++i) {
if (num[i] != '0') {
return false;
}
}
return true;
}
return false;
}
int string2int(string s) {
std::stringstream ss;
ss << s;
int is;
ss >> is;
return is;
}
void find_closest() {
int k = 0;
int i = 0;
for (i = 0; i < target_num.size(); ++i) {
int c = target_num[i] - '0';
if (!hash_key[c]) {
if (k == K) {
break;
}
hash_key[c] = true;
++k;
}
up_num.push_back(target_num[i]);
down_num.push_back(target_num[i]);
}
if (i == target_num.size()) {
printf("0\n");
return;
}
copy(hash_key, hash_key + 10, hash_copy);
int j = i - 1;
up_num.resize(target_num.size());
int c = target_num[j + 1] - '0';
int v = find_closet_k(c, true);
if (v == -1) {
int aj = target_num[j] - '0';
up_num[j] = aj + 1 + '0';
if (hash_key[aj + 1]) {
//only used K - 1, use 0 as min_k();
fill(up_num.begin() + j + 1, up_num.end(), '0');
} else {
hash_key[aj] = false;
hash_key[aj + 1] = true;
fill(up_num.begin() + j + 1, up_num.end(), min_k());
}
} else {
up_num[j + 1] = v + '0';
fill(up_num.begin() + j + 1, up_num.end(), min_k());
}
copy(hash_copy, hash_copy + 10, hash_key);
j = i - 1;
down_num.resize(target_num.size());
v = find_closet_k(c, false);
if (v == -1) {
int aj = target_num[j] - '0';
down_num[j] = aj - 1 + '0';
if (hash_key[aj - 1] || is_head_zero(aj - 1,down_num, j)) {
fill(down_num.begin() + j + 1, down_num.end(), '9');
} else {
hash_key[aj] = false;
hash_key[aj -1] = true;
fill(down_num.begin() + j + 1, down_num.end(), max_k());
}
} else {
down_num[j + 1] = v + '0';
fill(down_num.begin() + j + 1, down_num.end(), max_k());
}
unsigned __int64 upi;
unsigned __int64 targeti;
unsigned __int64 downi;
sscanf(up_num.c_str(), "%lld", &upi);
sscanf(target_num.c_str(),"%lld",&targeti);
sscanf(down_num.c_str(),"%lld",&downi);
unsigned __int64 delta = min(upi - targeti, targeti - downi);
printf("%lld\n", delta);
}
int main(){
while (true) {
cin>>target_num>>K;
fill(hash_key, hash_key + 10, false);
find_closest();
up_num.clear();
down_num.clear();
target_num.clear();
}
}

Answer 6

Edit N2
on every step check if:
a) putting closeset possible digit less then current, and then maximizing remaining digits is better then current answer
b) putting closest possible digit greater then current, and then minimizing remaining digits is better then current answer
then if possible put same digit and then proceed to next digit