## ADP Interview Question for Developer Program Engineers

• 0
of 0 votes

Country: United States

Comment hidden because of low score. Click to expand.
2
of 2 vote

1. If the input is 77...7 then output 444...44 with an extra digit 4;
2. If the input is a lucky number already: change the last digit 4 in the input into digit 7, and return;

3. If the input is not a lucky number:
Let d be the first un-lucky digit. So the input S can be represented as:
S = lucky_part + d + remain_part

Calculate the next lucky number N as:
if d<4: N = lucky_part + 4 + 44..4
if d<7: N = lucky_part + 7 + 44..4
if d>7: N = nextLuckyNumberOf(lucky_part) + 4 + 44...4
where 44..4 has same length as remain_part

EDITED:
I missed a case: the next lucky number of empty string is '4'

Comment hidden because of low score. Click to expand.
0
of 0 votes

Nice!

However, we should probably ask the interviewer what is the definition of the "next nearest" here. Is it the next lucky number that is greater than the given number? Or it is the next lucky number that is greater than or equal to that number.

Comment hidden because of low score. Click to expand.
0
of 0 votes

Yeah, I agree with you.
Also, the next lucky number of empty string should be '4'.

Comment hidden because of low score. Click to expand.
1
of 1 vote

``````static int GetNeareastLuckyNum(int num)
{
int length = GetNumLength(num);
int small = GenerateNum(length, 4);
int big = GenerateNum(length, 7);
if (num < small)
{
return small;
}

if (num >= big)
{
return GenerateNum(length + 1, 4);
}

List<int> ll = GetLuckyNumList(length);
int[] a = ll.OrderBy(x => x).ToArray();
int i = 0;
for (; i < a.Length; i++)
{
if (num < a[i])
{
break;
}
}

return a[i];
}
static List<int> GetLuckyNumList(int length)
{
List<int> list = new List<int>();
List<int> nlist = new List<int>();
while (length > 0)
{
if (list.Count != 0)
{
foreach (var item in list)
{
nlist.Add(item * 10 + 7);
nlist.Add(item * 10 + 4);
}
list.Clear();
}
else if (nlist.Count != 0)
{
foreach (var item in nlist)
{
list.Add(item * 10 + 7);
list.Add(item * 10 + 4);
}
nlist.Clear();
}
else
{
list.Add(7);
list.Add(4);
}

--length;
}

return nlist.Count > list.Count ? nlist : list;
}

static int GenerateNum(int length, int num)
{
int newNum = num;
while (length > 1)
{
newNum = newNum * 10 + num;
--length;
}

return newNum;
}

static int GetNumLength(int num)
{
if (num < 0)
{
return -1;
}

int length = 1;
while (num / 10 > 0)
{
++length;
num /= 10;
}

return length;
}
}``````

Comment hidden because of low score. Click to expand.
0
of 0 votes

get the length of the number
First get the smallest and biggest one lucky numbers in the length of the number.
if the number is smaller than the smallest one, return smallest one
if the number is bigger or equal to the biggest one, return the smallest lucky number of length+1
else the number is between smallest and biggest lucky numbers, we can get all the lucky numbers in the length, then go through all the lucky numbers, find the first lucky number that is bigger than the number.

Comment hidden because of low score. Click to expand.
0
of 0 vote

Following logic should work i guess.

``````oldnum = num
newnum = num;

Move from MSD(most significant Digit) to LSD(Least significant Digit)
If (current_digit <= 4)
{
replace(num, current_digit, 4);
newnum = num;
}
else
{
if ((newnum - oldnum) < 0)
replace(num, current_digit, 7);
else replace(num, current_digit, 4);
newnum = num;
}``````

replace() replaces in num, the digit at current location with 4 or 7(as mentioned, after current).

Comment hidden because of low score. Click to expand.
0
of 0 votes

What if num = 8?

Comment hidden because of low score. Click to expand.
0
of 0 vote

As I did not find any generic answer, I coded the following in c#. I already spent a couple of hours on it, so don't mind the ugly code

``````// It will return the same number, if the input number is a magic number
static int GetNextLuckyNumber(int n) {
int[] luckyDigits = { 4, 7 }; // maintain ascending order - 0 not supported
List<int> digits = getDigitsFromNumber(n);

List<int> luckyNumber = new List<int>();

// Let's traverse from left to right, digit-by-digit and find the smallest number larger than 'n'
for (int i = 0; i < digits.Count; ++i) {
int d = digits[i];

foreach (int lucky in luckyDigits) {
if (d < lucky) {
luckyNumber.Add(lucky);
goto outside_outer_for;
} else if (d == lucky) {
luckyNumber.Add(lucky);
break;
}
}

// if we could not find the digit to add, that means our generated lucky number is already smaller than 'n'
// so we backtrack and increment more significant digits
if (luckyNumber.Count - 1 < i) {
while (true) {
--i;
if (i < 0) // the lucky number is larger than the largest lucky number with same number of digits as 'n'
return getNumberFromDigits(luckyDigits, digits.Count + 1);

int newLuckyNumber = getNextDigit(luckyNumber[i], luckyDigits);
if (newLuckyNumber == -1)
luckyNumber.RemoveAt(i);
else {
luckyNumber[i] = newLuckyNumber;
goto outside_outer_for;
}
}
}
}
outside_outer_for:

// if we got out from goto, we need to fill the remaining numbers with the min
while (luckyNumber.Count < digits.Count)
luckyNumber.Add(luckyDigits);

return getNumberFromDigits(luckyNumber);
}

// get the next higher lucky digit
static int getNextDigit(int digit, int []luckyDigits) {
for (int i = 0; i < luckyDigits.Length; ++i) {
if (luckyDigits[i] > digit)
return luckyDigits[i];
}
return -1;
}

// create a number with 'digit' repeated 'count' times
static int getNumberFromDigits(int digit, int count) {
int max = 0;
for (int i = 0; i < count; ++i)
max = max * 10 + digit;
return max;
}

// create a number from the specified digits
static int getNumberFromDigits(List<int> digits) {
int num = 0;
for (int i = 0; i < digits.Count; ++i)
num = num * 10 + digits[i];
return num;
}

// break a number into digits
static List<int> getDigitsFromNumber(int n) {
List<int> digits = new List<int>();
while (n != 0) {
digits.Add(n % 10);
n /= 10;
}

digits.Reverse();

return digits;
}``````

Comment hidden because of low score. Click to expand.
0
of 0 vote

``````#include<iostream>

using namespace std;

int main()
{

int n;
cin>>n;
int ln=0;
int x=10;
while(n!=0)
{
int a=n%10;
if(a<=4) ln=4*x+ln;
else ln=7*x+ln;
n=n/10;
x=x*10;
}
ln=ln/10;
cout<<ln;

}``````

Comment hidden because of low score. Click to expand.
0
of 0 votes

Simply awesome.... :)

Comment hidden because of low score. Click to expand.
0
of 0 vote

``````1 #!/usr/bin/python
2
3 import sys
4
5 # get number
6 l_input = sys.argv
7 print l_input
8
9 l_output = ""
10 l_carry  = 0
// reverse string
12 l_input = l_input[::-1]
13 print l_input
14 for i in l_input:
15   if int(i) > 7:
16     l_output = l_output + "4"
17     l_carry = 1
18   elif int(i) == 7 and l_carry == 1:
19     l_output = l_output + "4"
20     l_carry = 1
21   elif int(i) > 4:
22     l_output = l_output + "7"
23     l_carry = 0
24   elif int(i) == 4 and l_carry == 1:
25     l_carry = 0
26     l_output = l_output + "7"
27   else:
28     l_output = l_output + "4"
29     l_carry = 0
30
31 if l_carry == 1:
32   l_output = l_output + "4"
33
34 l_output = l_output[::-1]
35 print l_output``````

Logic is simple goes from LSD to MSD if number is greater than 7 make it 4 and make the carry 1 , carry is cleared if next digit goes from < 4 to 4 or < 7 to 7 but if it is greater than 7 carry is carry forwarded to next and so on. if there is carry at the end most significant digit "4" is added. This seems to work for all if next lucky number is equal to or more than the given number

Comment hidden because of low score. Click to expand.
0
of 0 vote

``````public class Lucky {

public static void main(String[] args) {
System.out.println(findNext(1004));
}

private static int findNext(int N) {
String s = Integer.toString(N);
char[] arr = s.toCharArray();
for (int i = 0 ; i < arr.length; i++) {
int num = (int) ( arr[i] - '0');
if (num == 4 || num == 7) continue;

if (num < 4 || num > 7) {
arr[i] = '0' + 4;
}
else arr[i] = '0' + 7;
}
return Integer.parseInt(new String(arr));
}
}``````

Comment hidden because of low score. Click to expand.
0
of 0 votes

``````This does not work. issue is that if the char is 8 or 9, then you need to add 1 to the higher char.
Here is my solution:

public class Scratch {
public static int luckNumber(int number){
return lucknum(number, 0, 0);
}

private static int lucknum(int num, int total, int index){
int remainder = num % 10;
int leftover = num / 10;
if(remainder <= 4){
remainder = 4;
}else if(remainder <=7){
remainder = 7;
}else if(remainder >7){
remainder = 4;
leftover +=1;   // this is the critical, carry 1 to higher digit.
}

total += remainder * (int)Math.pow(10, index);

if(leftover > 0){
total = lucknum(leftover, total, ++index);
}
return total;
}
}``````

Comment hidden because of low score. Click to expand.
0
of 0 vote

This works for me:

``````public class FoursAndSevens {

public static void main(String[] args) {

String userNum = "1234"; //to be read thru user input

//get the digits count from the input
int digitsCount = 0;
for (int i=1; i<=userNum.length(); i++){
++digitsCount;
}

// figure out the max number in the digit range (9999 in iur example)
String max = "";
for(int i=0; i<digitsCount; i++){
max = max + "9";
}

System.out.println(getLucky(userNum, max));

}

private static int getLucky(String userNum, String max) {

// the range is: userNum to max digit (1234 - 9999 in our example)
for(Integer i= Integer.parseInt(userNum); i<= Integer.parseInt(max); i++){

char[] digits = i.toString().toCharArray();

boolean isLuckyNum = true;

for (char c : digits) {
// ignore the number if it has any digit other than 4 and 7
if(c == '4' || c == '7'){
continue;
}else{
isLuckyNum = false;
break;
}
}

// if you reach here, that means you got a lucky number, but check it that is not the input number itself (like 4444 or 7777)
isLuckyNum = isLuckyNum && (Integer.parseInt(userNum) != i);
if(isLuckyNum){
return i;
}
}

// increase the max range if you reach here (eg: in case of 7777, the next luck no. should be 44444, so range is now - 9999 to 99999)
return getLucky(max, max + "9");
}
}``````

Comment hidden because of low score. Click to expand.
0
of 0 vote

first of all we take an infinite loop in which we are increasing the input by one in every loop n we take another loop inside first loop in which we check weather the no comprises of 4 and 7 with the help of " % and / " then we use break statement if we find the number which we required n after that by using some logic we also break the outermost loop and print out the number....

Comment hidden because of low score. Click to expand.
0
of 0 vote

using 0 to represent 4, 1 to represent 7.
say x is n digit iterate from 00..0(n digits) to 11..1(n digits),
and convert binary to lucky number and compare to x
if no number is larger than x, increase one digit add test again.
e.g. 43 is 2 digits, iterate from 00 to 11, as a result 01 (represents 47) > 43, the next lucky number is found.

``````public static int nextLuckyNumber(int x) {
int digits = 0;
for (int n = x; n > 0; n /= 10) digits++;
// start from the digit of x
while (true) {
for (int i = 0; i < (1 << digits); i++) {
int lucky = 0;
// generate candidate lucky number and compare with x
for (int k = digits - 1; k >= 0; k--) {
if (((1 << k) & i) == 0) lucky = lucky * 10 + 4;
else lucky = lucky * 10 + 7;
}
if (lucky > x) return lucky;
}
digits++;
}
}``````

Comment hidden because of low score. Click to expand.
0
of 0 vote

``````import random
x=random.randint(1,100000)
print(x)
i=0
j=x
res=0
while x:
d=x%10
print(d)
if not d==7 and not d==4:
if d>4 and d<7:
res+=7*(10**i)
print(res)
else:
res+=4*(10**i)
print(res)
else:
res+=d*(10**i)
x=x//10
i+=1
if j>res:
res+=4*(10**i)``````

Comment hidden because of low score. Click to expand.
0
of 0 vote

``````import random
x=random.randint(1,100000)
print(x)
i=0
j=x
res=0
while x:
d=x%10
print(d)
if not d==7 and not d==4:
if d>4 and d<7:
res+=7*(10**i)
print(res)
else:
res+=4*(10**i)
print(res)
else:
res+=d*(10**i)
x=x//10
i+=1
if j>res:
res+=4*(10**i)``````

Add a Comment
Name:

Writing Code? Surround your code with {{{ and }}} to preserve whitespace.

### Books

is a comprehensive book on getting a job at a top tech company, while focuses on dev interviews and does this for PMs.

Learn More

### Videos

CareerCup's interview videos give you a real-life look at technical interviews. In these unscripted videos, watch how other candidates handle tough questions and how the interviewer thinks about their performance.

Learn More

### Resume Review

Most engineers make critical mistakes on their resumes -- we can fix your resume with our custom resume review service. And, we use fellow engineers as our resume reviewers, so you can be sure that we "get" what you're saying.

Learn More

### Mock Interviews

Our Mock Interviews will be conducted "in character" just like a real interview, and can focus on whatever topics you want. All our interviewers have worked for Microsoft, Google or Amazon, you know you'll get a true-to-life experience.

Learn More