Crack the Code #2

Question

After the last bank encounter, you decide that you could make a living off of just cracking codes (as if robbing banks wasn't enough). A shady man meets you on a park bench and slides you an envelope, dramatically. It contains clues for the next number.

Crack the Code #1

_{Digits are referred to as A-B-C-D in the clues. "A + B" is the sum of the first and second digit. All math follows the standard order of operations}

Clues

• The digits are in descending order.
• The number is prime.
• The first digit is less than 6.

What four digit number matches these criteria? Also, if you want, post your methodology for finding the correct answer, as this will help me in the future.

_{Note: I am pretty sure that only one number matches all these clues. However, I may have miscalculated. Please correct me in the comments.}

_{Another note: YenTheFirst, you could probably solve this pretty easily, seeing as the other one was pretty fast. This is great, but can you put the answer in a spoiler this time if you solve it?}

Answer 1

Assuming you mean strictly descending order, there's only one such number:

$$5431$$

The only other numbers satisfying clue 1 and 3 simultaneously are:

$$3210,4210,4310,4320,4321,5210,5310,5320,5321,5410,5420,5421,5430,5432$$

Clearly, numbers ending in $0$ or $2$ cannot be prime. This leaves:

$$4321=29\cdot149,5321=17\cdot313,5421=3\cdot1807$$

Answer 2

Only possible answer is (spoiler ahead)

5431

It is pretty easy to calculate on the back of an envelope as most of the 9 possible contenders are even or divisible by 3.

Answer 3

This program solves the problem using Java 8. It is commented throughout for people to understand.

public class CodeCrackerProblem implements SingleSolution<Integer> {

    public static void main(String[] args) {
        SingleSolution<Integer> codeCrackerProblem = new CodeCrackerProblem();
        System.out.println(codeCrackerProblem.solveSingle());
    }

    @Override
    public Integer solveSingle() {
        return IntStream.rangeClosed(1000, 5999).parallel() // The first digit is less than 6.
            .filter(this::prime) // The number is prime
            .filter(value -> {
                List<Integer> s = seperate(value);
                return (a(s) > b(s) && b(s) > c(s) && c(s) > d(s));
            }) // The digits are in descending order.
            .findFirst()
            .orElse(0);
    }

    private boolean prime(int n) {
        if (n%2==0) return false;
        for(int i=3;i*i<=n;i+=2) {
            if(n%i==0)
                return false;
        }
        return true;
    }

    private List<Integer> seperate(Integer n) {
        List<Integer> result = new ArrayList<>();
        while (n > 0) {
            result.add(n % 10);
            n = n / 10;
        }
        Collections.reverse(result);
        return result;
    }

    private Integer a(List<Integer> l) {return l.get(0);}
    private Integer b(List<Integer> l) {return l.get(1);}
    private Integer c(List<Integer> l) {return l.get(2);}
    private Integer d(List<Integer> l) {return l.get(3);}
}

5431

Answer 4

Here you have a programme you can you to check all the possibilities (Python 3.x)

for A in range(7,10):
    for B in range(0,10):
        for C in range(1,10):
            for D in range(0,10):
                if sum([A,B,C,D]) > ((A*B)-(C*D)):
                    prod_and_sum = (A*B*C*D) + sum([A,B,C,D])
                    if prod_and_sum % A == 0 and prod_and_sum % C == 0:
                        number = A*(10**3) + B*(10**2) + C*(10**1) + D
                        if not [i for i in range(2,number) if number % i == 0]:
                            print(number)

This prints 5431