was verlangt die aufgabe ?

Bitte aktiviere JavaScript!
The depth of an integer n is defined to be how many multiples of n it is necessary to compute before all 10 digits have appeared at least once in some multiple.


example:

let see n=42

Multiple value digits comment
42*1 42 2,4
42*2 84 8 4 existed
42*3 126 1,6 2 existed
42*4 168 - all existed
42*5 210 0 2,1 existed
42*6 252 5 2 existed
42*7 294 9 2,4 existed
42*8 336 3 6 existed
42*9 378 7 3,8 existed

Looking at the above table under digits column you can find all the digits from 0 to 9, Hence it required 9 multiples of 42 to get all the digits. So the depth of 42 is 9. Write a function named computeDepth which computes the depth of its integer argument.Only positive numbers greater than zero will be passed as an input.
 
A

Anzeige




Schau mal hier —> (hier klicken)
Falls es nur an der Sprachbarriere liegt, hier die DeepL Übersetzung:

Die Tiefe einer ganzen Zahl n ist definiert als die Anzahl der Vielfachen von n, die berechnet werden müssen, bevor alle 10 Ziffern mindestens einmal in einem Vielfachen erschienen sind.

...Tabelle...

Betrachtet man die obige Tabelle unter der Ziffernspalte, so findet man alle Ziffern von 0 bis 9, so erforderte es 9 Vielfache von 42, um alle Ziffern zu erhalten. Schreiben Sie eine Funktion namens computeDepth, die die Tiefe ihres ganzzahligen Arguments berechnet, wobei nur positive Zahlen größer als Null als Eingabe übergeben werden.
 
was verlangt die aufgabe ?
- ein wenig analytisches Verständnis und logische Herangehensweise
- ein Speicher der (noch nicht) gefundenen Zahlen, der dynamisch verändert wird
- mindestens eine Schleife unbekannter Anzahl Iterationen für die Summenbildung
- eine Hilfsmethode, welche überprüft ob digit d in der aktuellen Iterationssumme vorhanden ist

Ich selbst würde zu einer Liste "noch nicht gefundener Zahlen" tendieren, welche ich iterativ in einer do-while Schleife reduzieren würde. In diesem Fall sollte ein Iterator zum Einsatz kommen da ConcurrentModification.

Mir will absolut nicht in den Kopf wie du solche Fragen stellen kannst und "da draußen" 100k+ im Jahr verdienen willst. (sorry)
 
Ach scheiß drauf, ich hatte irgendwie Lust, das zu machen:
Java:
private static final int ALL_DIGITS = (1 << 10) - 1;
private static int digits(int num) {
  return (1 << num % 10)
       | (num > 9 ? digits(num / 10) : 0);
}
private static int depth(int num, int depth, int acc) {
  return acc != ALL_DIGITS
    ? 1 + depth(num, depth + 1, acc | digits(num * depth))
    : 0;
}
public static int depth(int num) {
  return depth(num, 1, 0);
}
 
Ach scheiß drauf, ich hatte irgendwie Lust, das zu machen:
Interessanter Ansatz, nur recht schwer nachvollziehbar. Wenn ich schon etwas brauche es zu durchblicken dann er ganz bestimmt ^^

Wie, ohne Streams?!? Was ist los?
Vielleicht will er ja Streams hier einbasteln :p (enthält sogar schon bissl Stream)

Java:
// Hilfsmethode
    // Achtung n und d unterliegen hier vereinfachenden Annahmen
    private static boolean containsDigit(int n, int d) {
        // Variante 1 (String-Cast)
        // return String.valueOf(n).contains(String.valueOf(d));
        
        // Variante 2 (Rekursiv)
        if(n < 10) return n == d;
        return (n % 10) == d || containsDigit(n / 10, d);
    }
    
    public static int computeDepth(int n) {
        List<Integer> remainingNumbersToBeFound = IntStream.rangeClosed(0, 9).boxed().collect(Collectors.toList());
        int depth = 0;
        int sum = 0;
        
        do {
            depth++;
            sum += n;
            
            // Iterator da sonst concurrendModification
            Iterator<Integer> iter = remainingNumbersToBeFound.iterator();
            while(iter.hasNext()) {
                if(containsDigit(sum, iter.next())) {
                    iter.remove();
                }
            }
        } while(remainingNumbersToBeFound.size() > 0);
        
        return depth;
    }
 
A

Anzeige




Vielleicht hilft dir das hier weiter: (klicke hier)
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben