3

簡単な質問：double[]array=new double [10]ランダムなdoubleがある配列があります。たとえば、0から20の間です。必要なのはint []resultingArray=new int [array.length]、各値intが、array[]最大数から最小数までソートされた値のdoubleのインデックスである別の配列を取得することです。私の英語はここで吸うので、「図」です：

配列=（2、6、3）_ __ _ _結果の配列=（1、2、0）

それは試験問題です。ダブルスは学生からのGPAであり、最高の学生から最悪の学生までの学生のID（私のコードではdouble [] arrayのインデックス）で構成される配列を返すメソッドを要求します。

4

6 に答える 6

1

sを使用したソリューションはたくさんありMapます。配列のみを使用した代替案を提案します。

public int[] getIndices(double[] originalArray)
{
    int len = originalArray.length;

    double[] sortedCopy = originalArray.clone();
    int[] indices = new int[len];

    // Sort the copy
    Arrays.sort(sortedCopy);

    // Go through the original array: for the same index, fill the position where the
    // corresponding number is in the sorted array in the indices array
    for (int index = 0; index < len; index++)
        indices[index] = Arrays.binarySearch(sortedCopy, originalArray[index]);

    return indices;
}

ただし、かなり非効率です。

于 2013-01-06T22:14:10.633 に答える
0

学生のscaoreがランダムである場合、これを行うことができます（正確に15桁の精度で学生をスコアリングできない/スコアリングしないため、現実の世界ではあまり意味がありません;）

public static int[] sortWithIndex(double[] results) {
    class ScoreIndex implements Comparable<ScoreIndex> {
        final double score;
        final int index;

        ScoreIndex(double score, int index) {
            this.score = score;
            this.index = index;
        }

        @Override
        public int compareTo(ScoreIndex o) {
            int cmp = Double.compare(score, o.score);
            return cmp == 0 ? Integer.compare(index, o.index) : cmp;
        }
    }
    List<ScoreIndex> list = new ArrayList<>();
    for (int i = 0; i < results.length; i++) list.add(new ScoreIndex(results[i], i));
    Collections.sort(list);
    int[] indexes = new int[results.length];
    for (int i = 0; i < list.size(); i++) indexes[i] = list.get(i).index;
    return indexes;
}

精度を制限するために生徒を採点する場合は、6桁未満しか実行できないと言います

public static void sortWithIndex(double[] results) {
    for(int i = 0; i < results.length; i++)
        results[i] = results[i] * results.length * 1e6 + i;
    Arrays.sort(results);
}

これresultsで、すべての元の値とそれらが取得したインデックスが値の順に含まれ、重複がある場合は低い方のインデックスが最初に含まれます。

于 2013-01-06T21:05:06.880 に答える
0

それは試験問題です。ダブルスは学生からのGPAであり、最高の学生から最悪の学生までの学生のID（私のコードではdouble [] arrayのインデックス）で構成される配列を返すメソッドを要求します。

私は地図でそれをします。<ID, Doubles>。TreeMapはキーでソートされているため、直接使用することはできません。Value（これらのDouble）でソートしたいと思います。ただし、独自のコンパレータを実装するために、いくつかのトリックを行うことができます。マップを値で並べ替えます。

私はそれをjunitテストクラスで書きました、

@Test
public void testArray() {
    final double[] array = new double[] { 1.1, 2.2, 3.3, 4.4, 3.3 };
    final int[] result = new int[array.length];

    final Map<Integer, Double> map = new HashMap<Integer, Double>();
    for (int i = 0; i < array.length; i++) {
        map.put(i, array[i]);
    }
    final List<Map.Entry> list = new LinkedList<Map.Entry>(map.entrySet());
    Collections.sort(list, new Comparator() {
        @Override
        public int compare(final Object o1, final Object o2) {
            return 0 - ((Comparable) ((Map.Entry) o1).getValue()).compareTo(((Map.Entry) o2).getValue());
        }
    });
    for (int i = 0; i < list.size(); i++) {

        result[i] = (Integer) list.get(i).getKey();
    } 

    //here we have result, to test it:
    for (final int element : result) {
        System.out.println(element);
    }
}

印刷します：

    3
    2
    4
    1
    0
于 2013-01-06T21:46:46.253 に答える
0

これが私がそれをする方法です：

  • のすべての要素をarray、Map<Integer, Double>インデックスを値にマップするに入れます。

  • このマップののすべての要素をentrySet()リストに入れ、そのリストを値で並べ替えます。

  • 新しくソートされたエントリのリストのキーから配列を形成します。

public static int[] getIndicesInOrder(double[] array) {
    Map<Integer, Double> map = new HashMap<Integer, Double>(array.length);
    for (int i = 0; i < array.length; i++)
        map.put(i, array[i]);

    List<Entry<Integer, Double>> l = 
                           new ArrayList<Entry<Integer, Double>>(map.entrySet());

    Collections.sort(l, new Comparator<Entry<?, Double>>() {
            @Override
            public int compare(Entry<?, Double> e1, Entry<?, Double> e2) {
                return e2.getValue().compareTo(e1.getValue());
            }
        });

    int[] result = new int[array.length];
    for (int i = 0; i < result.length; i++)
        result[i] = l.get(i).getKey();

    return result;
}

public static void main(String[] args) {
    double[] array = { 1.1, 2.2, 3.3, 4.4, 3.3 };

    System.out.println(Arrays.toString(getIndicesInOrder(array)));
}

[3、2、4、1、0]
于 2013-01-06T21:29:19.177 に答える
0

たぶん次のようなもの：

import java.util.*;

public class Test
{
    static Integer[] getIndicesInOrder(Integer[] array)
    {
        Integer[] c = array.clone();
        Arrays.sort(c, Collections.reverseOrder());

        List<Integer> l = Arrays.asList(array);

        for (int i = 0; i < array.length; ++i)
        {
            c[i] = l.indexOf(c[i]);
        }

        return c;
    }

    public static void main(String[] args)
    {
        Integer[] array = {2,6,3};

        System.out.println(Arrays.toString(getIndicesInOrder(array)));
    }
}
于 2013-01-06T21:11:35.937 に答える
0

Comparatorそれぞれのインデックスで grades 配列の値を比較するカスタムを使用できます。

import java.util.*;

public class GradeComparator implements Comparator<Integer> {
    private double[] grades;
    public GradeComparator(double[] arr) {
        grades = arr;
    }
    public int compare(Integer i, Integer j) {
        return Double.compare(grades[j], grades[i]);
    }
}

それを使用してインデックス配列をソートしますComaprator：

import java.util.*;

public class SortGrades {
    public static void main(String[] args) {
        double[] grades = { 2.4, 6.1, 3.9, 4.8, 5.5 };
        Integer[] ranks = new Integer[grades.length];
        for(int i = 0; i < ranks.length; ++i) {
            ranks[i] = i;
        }
        Comparator<Integer> gc = new GradeComparator(grades);
        Arrays.sort(ranks, gc);
        for(int i = 0; i < ranks.length; ++i) {
            System.out.println((i+1) + ": " + ranks[i] + ", grade: " + grades[ranks[i]]);
        }
    }
}

出力

1: 1, grade: 6.1
2: 4, grade: 5.5
3: 3, grade: 4.8
4: 2, grade: 3.9
5: 0, grade: 2.4

望んだ通りに。

于 2013-01-06T22:20:26.570 に答える