배열에서 임의 숫자가 다른 배열로 다른 배열로 자바에서

Question

나는 학교에서 운동에 도움이 필요합니다. 1에 10 할 수있는 유일한

숫자 배열의 각 한 번 발생할 수 있습니다

1. 숫자 25,50,75,100 : montab[] = {1,2,3,4,5,6,7,8,9,10,25,50,75,100} 다음과 같은 규칙 :

   나는 다음과 같은 배열에서 6 개 무작위 정수 배열을 만들 필요가 배열에서 각각 두 번만 발생합니다.

지금은 첫 번째 규칙을 시도했지만 드문 경우지만 한 번 이상 두 번 이상 나타납니다.

여기 내 코드입니다 :

내 테스트가 완전히 옳지 않은 것을 알고

public class Exo7bis { 
public static void main (String[] args){ 
    Random random = new Random(); 
    int montab[] = {1,2,3,4,5,6,7,8,9,10,25,50,75,100}; 
    int[] ar1 = new int[6]; 
    int j = 0, compteur25 = 0, compteur50 = 0, compteur75 = 0, compteur100 = 0; 
     for (int i = 0; i < ar1.length; i++) { 
      ar1[i] = (montab[new Random().nextInt(montab.length)]); 
      if (ar1[i] == 25) { 
       compteur25++; 
       if (compteur25 > 1) { 
        while (ar1[i] == 25) 
         ar1[i] = (montab[new Random().nextInt(montab.length)]); 
       } 
      } 
      if (ar1[i] == 50) { 
       compteur50++; 
       if (compteur50 > 1) { 
        while (ar1[i] == 50) 
         ar1[i] = (montab[new Random().nextInt(montab.length)]); 
       } 
      } 
      if (ar1[i] == 75) { 
       compteur75++; 
       if (compteur75 > 1) { 
        while (ar1[i] == 75) 
         ar1[i] = (montab[new Random().nextInt(montab.length)]); 
       } 
      } 
      if (ar1[i] == 100) { 
       compteur100++; 
       if (compteur100 > 1) { 
        while (ar1[i] == 100) 
         ar1[i] = (montab[new Random().nextInt(montab.length)]); 
       } 
      } 
     } 

     for (int i = 0; i < ar1.length; i++) { 
      System.out.print(ar1[i] +" ⎢ " + "\t"); 
     } 
    } 
} 

, 나는이 문제를 확인하지만 적절한 해결책을 찾을 수 없습니다.

누군가가 나를 도울 수 있거나 나에게 조언 할 수 있다면 멋질 것입니다.

미리 감사드립니다. 이 진정으로 임의의 숫자를 보증하지 않습니다하지만, 실제로 간단한 해결책이있다

Answer 1

이를 달성하기 위해 여러 가지 방법이 있습니다하지만 당신은 단지 배열을 사용하고 있기 때문에 나는 반복 얼마나 많은 시간 1-10 계산 기능을 조언합니다. 첫 번째 조건의 경우 요소를 0으로 바꿀 수 있으므로 다음 번에 반복하지 않습니다. 나는 그래서 당신은 당신의 코드에서 변경할 수있는 것을 봐 가지고 코드를 설명하기 쉽게 생각 :

public static void main(String[] args) { 
     Random random = new Random(); 
     int montab[] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 25, 50, 75, 100 }; 
     int[] ar1 = new int[6]; 
     int j = 0, count = 0; 
     while (j < ar1.length) { 
      count = 0; 
      int index = random.nextInt(montab.length); 
      int num = montab[index]; 
      if (num >= 25) { //adds any number greater or equal to 25 
       ar1[j] = num; 
       j++; 
       montab[index] = 0; // replace the origianl array with 0. 
      } else if (num != 0) { 
       if(!isRepeated(ar1,num)){ //checks if the array has more than two of the number. 
       ar1[j] = num; 
       j++; 
       } 
      } 
     } 
     for (int i = 0; i < ar1.length; i++) { 
      System.out.print(ar1[i] + " ⎢ " + "\t"); 
     } 
    } 

    public static boolean isRepeated(int[] arr, int num) { //method that verifies if the array has a number repeated twice or not. 
     int count = 0; 
     for (int i = 0; i < arr.length; i++) { 
      if (arr[i] == num) 
       count++; 
     } 
     return count==2 ? true : false; 
    } 

나는 그것을 테스트하지 않았습니다하지만 나는 그것이 작동 확신을!

Answer 2

제레미.

우리가 수행 할 작업은 숫자 1 - 10이 두 번 나열되고 25 - 100이 한 번 나열되는 배열을 만드는 것입니다. 숫자를 선택할 때마다 0으로 대체합니다.

따라서 25 개 이상 또는 8 개 이상을 선택할 수 없습니다. 코드에서

,

public class Exo7bis { 

    public static void main (String[] args){ 

     Random random = new Random(); 

     int[] intPool = {1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9,10,25,50,75,100}; 
     int[] chosen = {0,0,0,0,0,0}; 

     int counter = 0; 

     // while the list is not full 
     while (chosen[5] == 0) { 

      // generate a number from 0 - 23 (representing the numbers in intPool) 
      int temp = random.randInt(24); 

      // if that element in intPool = 0, it means that it's already chosen 
      // and can't be chosen again. 
      if (intPool[temp] != 0) { 
       chosen[counter] = intPool[temp]; 
       intPool[temp] = 0; 

       counter++; 
      } 
     } 
    } 
} 

Answer 3

내 접근 방식입니다. 규칙에 따라 사용되는 경우 원본 번호가 크기가 줄어들도록 원래 목록/배열을 수정 해 봅니다.

import java.util.ArrayList; 
import java.util.Arrays; 
import java.util.List; 
import java.util.Random; 

public class Exo7bis { 
    private static final List<Integer> montab = new ArrayList<Integer>(Arrays.asList(new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 25, 50, 75, 100 })); 
    private static final List<Integer> allowOnce = new ArrayList<Integer>(Arrays.asList(new Integer[] { 25, 50, 75, 100 })); 
    private static final List<Integer> allowTwice = new ArrayList<Integer>(Arrays.asList(new Integer[] { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 })); 
    public static void main(String[] args) { 
     int[] ar1 = new int[6]; 
     for (int i = 0; i < ar1.length; ++i) { 
      int index = new Random().nextInt(montab.size()); 
      int value = montab.get(index); 
      ar1[i] = value; 
      if (isOneOff(value)) { 
       montab.remove(index); 
      } else if (isTwoOff(value)) 
       montab.remove(index); 
     } 
     System.out.println(Arrays.toString(ar1)); 
    } 
    public static boolean isOneOff(final int n) { 
     for (int i = 0; i < allowOnce.size(); ++i) 
      if (allowOnce.get(i) == n) 
       return true; 
     return false; 
    } 
    public static boolean isTwoOff(final int n) { 
     boolean one = false, two = false; 
     for (int i = 0; i < allowTwice.size(); ++i) { 
      int j = 0; 
      for (; j < montab.size(); ++j) { 
       if (montab.get(j) == n) { 
        one = true; 
        break; 
       } 
      } 
      ++j; 
      for (; j < montab.size(); ++j) { 
       if (montab.get(j) == n) { 
        two = true; 
        break; 
       } 
      } 
     } 
     return (one && two); 
    } 
} 

Answer 4

다음은 배열 만 포함하고 원하는 임의성을 제공하는 솔루션입니다. 아이디어는 다른 int [] 배열에 선택한 값의 발생을 저장하고이를 제한과 비교하는 것입니다.[하단 FULL CODE]

설명

라인 최대 OCCURENCES위한

if ((randomNum < 25 && newOccurence == 2) || randomNum >= 25) 

검사한다.

그런 다음 제한에 도달하지 않은 원래 배열 (montab)을 다시 만듭니다.

int[] tempTab = new int[montab.length - 1]; 
int skips = 0; 
for (int j = 0; j < tempTab.length; j++) { 
    if (montab[j] == randomNum) { 
     skips++; 
    } 
    tempTab[j] = montab[j + skips]; 
} 
montab = tempTab; 

이 접근법은 원래 배열에 반복되는 값이없는 경우 분명히 작동합니다. 성능은 배열을 재현하기 때문에 좋지 않을 수도 있지만 적어도 동일한 값을 반복해서 반복하는 임의성을 피하십시오.

테스트 코드

import java.util.Random; 

public class Exo7bis { 

    public static void main (String[] args){ 

     int[] montab = {1,2,3,4,5,6,7,8,9,10,25,50,75,100}; 
     int[] ar1 = new int[6]; 
     int[] occurences = new int[montab.length]; 

     for (int i = 0; i < ar1.length; i++) { 

      int randomIndex = new Random().nextInt(montab.length); 
      int randomNum = montab[randomIndex]; 
      int newOccurence = (occurences[randomIndex] = occurences[randomIndex] + 1); 

      /* UNCOMMENT THIS FOR VISUAL STEPS 
      for (int a : montab) { System.out.print(a + " | "); } 
      System.out.println(""); 
      */ 

      if ((randomNum < 25 && newOccurence == 2) || randomNum >= 25) 
      { 
       int[] tempTab = new int[montab.length - 1]; 
       int skips = 0; 
       for (int j = 0; j < tempTab.length; j++) { 
        if (montab[j] == randomNum) { 
         skips++; 
        } 

        tempTab[j] = montab[j + skips]; 
       } 
       montab = tempTab; 
      } 
      ar1[i] = randomNum; 
     } 

     for (int i = 0; i < ar1.length; i++) { 
      System.out.print(ar1[i] +" |" + "\t"); 
     } 
    } 
}