特定の桁の配列が配列内にあるかどうかを調べるにはどうすればよいですか

Question

私は123を持っているとします。0を含めて1から9までの数字がすべて得られるかどうかを調べる必要があります。 2と3を乗算し、2を掛けて246を得る（2桁、4桁、6桁）。それから私はそれを3倍して369を得る。私はすべての桁を得るまで増分乗算を続けている。

私のアプローチは以下の通りです：

public int digitProcessSystem(int N) { 
String number = Integer.toString(N); 
String [] arr = number.split(""); 
// List <Integer> arr2 = new ArrayList<>(); 
for (Integer i = 0; i < arr.length; i++) { 
    try { 

     arr2[i] = Integer.parseInt(arr[i]); 
    } catch (NumberFormatException e) { 
     } 
    } 

count =0; 
boolean contains = IntStream.of(arr2).anyMatch(x -> x == 1|| x==2 ||x == 3|| x==4|| x == 5|| x==6 ||x == 7|| x==8||x == 9|| x==0); 

} 

私は本当に私が、私は間違いなくのいずれかを取得しますので、上記の最初の道に一致していませんでした数字のためのブール値をやり続けることができる方法がわかりません上記ブール検索のすべての数字。特定の数字が存在し、実際の数字を乗算して最初の試行で見つからなかった数字の検索を行うことができないものがある場合は、どうすれば得ることができますか？私が最初に定義したのと同じように。

Answer 1

whileループにラップして数字をSetに含めることができます。セットのサイズが10になると、数字にすべての数字が表示されます。また、intの代わりにlongを使用することをお勧めします。そうしないと、間違った結果が得られたり、腹が立たなくなります。このために、いくつかのサンプルコードをHere's：

private static long digitProcessSystem(long N) { 
    long numberN = N; 
    String number = Long.toString(N); 
    // calculate 10 digits number here yet 
    if (number.length() < 10) { 
     // using the smallest possible number with each digit 
     // By using this number we are most likely allmost at the result 
     // This will increase the performance for small digits heavily. 
     long divider = 1023456789L/numberN; 
     numberN *= divider; 
    } 
    number = Long.toString(numberN); 
    String[] arr = number.split(""); 
    Set<String> input = new HashSet<>(Arrays.asList(arr)); 
    while(input.size() != 10){ 
     // add N to number 
     numberN += N; 
     // Parse the new number 
     number = Long.toString(numberN); 
     // split 
     arr = number.split(""); 
     // clear set 
     input.clear(); 
     // Add the new numbers to the set. If it has the size 10 now the loop will stop and return the number. 
     input.addAll(Arrays.asList(arr)); 
    }; 
    return numberN; 
} 

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

出力：

1023458769 

Answer 2

私はあなたの最終目標が何であるかわかりません。しかし、あなたはHashSetを使用すると、あなたが達成しようとしているものを達成するために、このような何かを行うことができます。

public static void main (String[] args) throws Exception { 
    long number = 123L, counter = 1000000000L/number; 
    while(digitProcessSystem(number * counter++)); 
    System.out.println("Number: " + number * (counter - 1)); 
} 

public static boolean digitProcessSystem(long input) { 
    char[] arr = Long.toString(input).toCharArray(); 
    Set<Character> set = new HashSet<>(); 
    for (int i = 0; i < arr.length; i++) { 
     set.add(arr[i]); 
    } 
    return set.size() != 10; 
} 

出力：Java言語の施設とのHashSetを使用せずに

Number: 1023458769 

Answer 3

：

private static long digitProcessSystem(long N) { 
long numberN = N; 
String number = Long.toString(N); 
String[] arr = number.split("");; 
int arr2=new int[10]; 
int sum=0; 
while(sum != 10){ 
    sum=0; 
    // add N to number 
    numberN += N; 
    // Parse the new number 
    number = Long.toString(numberN); 
    // If it doesn´t have 10 digitis continue here yet 
    if(number.length() < 10) continue; 
    // split 
    arr = number.split(""); 
    for(int i=0;i<arr.length;i++){ 
     arr2[arr]=1; 
    } 
    for(int i=0;i<10;i++){ 
     sum+=arr2[i]; 
    } 
}; 
return numberN; 
} 

Answer 4

一般に、Stringの文字を処理する場合は、を入力しないでください。 gを部分文字列に変換します。 Stringを含むCharSequenceはすべて、IntStreamとしてすべての文字を処理することを可能にする方法chars()およびを持つことに注意してください。

'0'から'9'までのすべての数字が存在しているかどうかを確認するために、我々はchars()を使用することができます（サロゲートペアを考える必要はありません）とストレートフォワードそれを行う、'0'を減算することによって彼らの実際の数にマップ、フィルタリングすべての非数字を（ちょうど）確認してから、nビットが設定されているintにマッピングしてください。バイナリまたはをすべて一緒にチェックして、

public static boolean hasAllDigits(String s) { 
    return s.length()>9 && 
     s.chars().map(c -> c-'0').filter(c -> c>=0 && c<=9) 
       .map(c -> 1 << c).reduce(0, (a,b)->a|b) == 0b1111111111; 
} 

ボーナスとして、 ckの先頭にはStringが10文字以上含まれていなければならないため、10文字すべてが含まれていなければなりません。

---

今実際の作業についてはわかりません。

long number=123; 
for(long l = 1, end = Long.MAX_VALUE/number; l < end; l++) { 
    long candidate = number * l; 
    if(hasAllDigits(String.valueOf(candidate))) { 
     System.out.println("found: "+candidate); 
     return; 
    } 
} 
System.out.println("not found within the long range"); 

しかし、あなたはあなたが数字のシーケンス内のすべての桁に遭遇したときに知りたい場合は、我々はテストを適応する必要があります：あなただけのすべての桁を持つ数に遭遇するまで反復処理したい場合、それは非常に簡単です法と反復間のビットセット保つ：

public static int getDigits(String s) { 
    return s.chars().map(c -> c-'0').filter(c -> c>=0 && c<=9) 
      .map(c -> 1 << c).reduce(0, (a,b)->a|b); 
} 

long number=123; 
int digits=0; 
for(long l = 1, end = Long.MAX_VALUE/number; l < end; l++) { 
    long candidate=number * l; 
    int newDigits=digits | getDigits(String.valueOf(candidate)); 
    if(newDigits != digits) { 
     System.out.printf("pos %10d: %10d%n", l, candidate); 
     digits=newDigits; 
     if(digits == 0b1111111111) { 
      System.out.println("encountered all digits"); 
      break; 
     } 
    } 
} 
if(digits != 0b1111111111) { 
    System.out.println("did not encounter all digits within the long range"); 
} 

この方法のみとなります印刷麻痺をこれまでに遭遇したことのない少なくとも1桁の数字を持つシーケンスのうち、どれが完全なセットに寄与しているかを簡単に見ることができ、最大10個のシーケンスを見ることができます。