This community-built FAQ covers the “Top Score Sorter” code challenge in Java. You can find that challenge here, or pick any challenge you like from our list.
Top Discussions on the Java challenge Top Score Sorter
There are currently no frequently asked questions or top answers associated with this challenge – that’s where you come in! You can contribute to this section by offering your own questions, answers, or clarifications on this challenge. Ask a question or post a solution by clicking reply () below.
If you’ve had an “aha” moment about the concepts, formatting, syntax, or anything else with this challenge, consider sharing those insights! Teaching others and answering their questions is one of the best ways to learn and stay sharp.
Join the Discussion. Help a fellow learner on their journey.
Ask or answer a question about this exercise by clicking reply () below!
You can also find further discussion and get answers to your questions over in Language Help.
Agree with a comment or answer? Like () to up-vote the contribution!
public class ScoreSorter {
public static void main(String args) {
int answer = scoreSorter(new int{1, 2, 3, 9999, 13}, 10000);
for (int i = 0; i < answer.length; i++) {
System.out.println(answer[i]);
}
}
public static int reversedArray(int array){
int last = array.length - 1;
int middle = array.length / 2;
for(int i=0;i<middle;i++){
int temp=array[i];
array[i]=array[last-i];
array[last-i]=temp;
}
return array;
}
public static int scoreSorter(int array, int topScore) {
// Write your code here
Arrays.sort(array);
reversedArray(array);
I filtered out anything bigger than the top score possible,
and I sorted the array
by making another array for the sorted version,
and then finding the highest number in the original array, and adding it to the sorted array
then the next highest, and adding that as the next thing in the sorted array,
and so on.
my code
import java.util.*;
public class ScoreSorter {
public static int getNextMax(int[] array, boolean[] available, boolean changeInAvailable) {
int length = array.length;
boolean started = false;
int max_so_far = 0;
int index_of_max = 0;
for (int i = 0; i < length; i++) {
if (available[i]) {
if (!started || (array[i] > max_so_far)) {
max_so_far = array[i];
index_of_max = i;
started = true;
}
}
}
if (changeInAvailable) {
available[index_of_max] = false;
}
return max_so_far;
};
public static int[] scoreSorter(int[] array, int topScore) {
int length = array.length;
int validCount = 0;
for (int i = 0; i < length; i++) {
if (array[i] <= topScore) {
validCount++;
}
}
boolean[] available = new boolean[length];
for (int i = 0; i < length; i++) {
available[i] = (array[i] <= topScore);
}
int[] sorted = new int[validCount];
for (int j = 0; j < validCount; j++) {
sorted[j] = getNextMax(array, available, true);
}
return sorted;
}
public static void main(String[] args) {
int[] demo = new int[]{1, 2, 3, 9999, 13};
int[] answer = scoreSorter(demo, 10000);
System.out.print("[");
for (int i = 0; i < answer.length; i++) {
System.out.print(answer[i]);
if (i != answer.length - 1) {
System.out.print(", ");
}
}
System.out.println("]");
}
}
Well I think I tried to do it the simplest possible, heres my code,
import java.util.*;
public class ScoreSorter {
public static void main(String args) {
int answer = scoreSorter(new int{1, 2, 3, 9999, 13}, 10000);
for (int i = 0; i < answer.length; i++) {
System.out.println(answer[i]);
}
}
public static int scoreSorter(int array, int topScore) {
// Write your code here
int temp = 0;
for(int i = 0; i < array.length; i++){
for(int j = i+1; j< array.length; j++){
if(array[i] < array[j]){
temp = array[i];
array[i] = array[j];
array[j] = temp;
}
}
}
return array;
}
}
import java.util.*;
public class ScoreSorter {
public static void main(String[] args) {
int[] answer = scoreSorter(new int[]{1, 2, 3, 9999, 13}, 10000);
for (int i = 0; i < answer.length; i++) {
System.out.println(answer[i]);
}
}
public static int[] scoreSorter(int[] array, int topScore) {
int temp;
// Per traversal:
// Find the max number in array, swap location with num at the front
for (int i = 0; i < array.length - 1; i++) {
int indexOfMax = i;
// Traverse array to determine max number
// Get index of that max number for swapping
for (int j = i + 1; j < array.length; j++)
if (array[j] > array[indexOfMax])
indexOfMax = j;
// Swap values (2, 3) --> (3, 2)
temp = array[indexOfMax];
array[indexOfMax] = array[i];
array[i] = temp;
}
return array;
}
}
I used “selection sort” to get the array sorted in a descending order. My code works with the site engine and in my own Eclipse IDE, however it only passes 3/5 test cases. This is becoming a bit of a frustration for me. I have this challenge and the catching rainwater challenge that passed 4/5 of the test cases.
I’m asking for help. Is there anyone or staff member at Codeademy that can tell me about the test cases my codes are failing?
I also find the highest possible score parameter of 10000 a bit superfluous. Unless that is part of the test case? Should I put a check that checks for a score number higher than 10000 ?
I will test that assumption shortly.
Here is my code for Top Scorer:
// Write your code here
int high = topScore; // I’m not using this var currenly
for(int i= array.length-1; i > 0; i–) {
int index=i;
for(int j=i-1; j >= 0;j–) {
if(array[j] < array[index]) {
index = j; // searching for lowest index
}
int smallerNumber = array[index];
// swap smallest element with highest to sort array in descending order
array[index] = array[i] ;
array[i] = smallerNumber;
}
} // Outter for loop
return array;
import java.util.*;
public class ScoreSorter {
public static void main(String[] args) {
int[] answer = scoreSorter(new int[]{1, 2, 3, 9999, 13}, 10000);
for (int i = 0; i < answer.length; i++) {
System.out.println(answer[i]);
}
}
public static int[] scoreSorter(int[] array, int topScore) {
// Write your code here
// merge sort
mergeSort(array, 0, array.length - 1);
return array;
}
public static void mergeSort(int[] array, int leftRange, int rightRange){
if(leftRange < rightRange){
int middle = (leftRange + rightRange) / 2;
//recurse through each side of the array
// where the middle element is odd, it is assigned to the left array
mergeSort(array, leftRange, middle);
mergeSort(array, middle + 1, rightRange);
merge(array, leftRange, middle, rightRange);
}
}
// Merge two subarrays function
public static void merge(int[] arr, int left, int middle, int right) {
// Find sizes of two subarrays to be merged
int n1 = middle - left + 1;
int n2 = right - middle;
// Create temp arrays
int[] leftArray = new int[n1];
int[] rightArray = new int[n2];
// Copy data to temp arrays
for (int i = 0; i < n1; ++i)
leftArray[i] = arr[left + i];
for (int j = 0; j < n2; ++j)
rightArray[j] = arr[middle + 1 + j];
// Merge the temp arrays
// Initial indexes of first and second subarrays
int i = 0, j = 0;
// Initial index of merged subarray
int k = left;
while (i < n1 && j < n2) {
if (leftArray[i] >= rightArray[j]) {
arr[k] = leftArray[i];
i++;
} else {
arr[k] = rightArray[j];
j++;
}
k++;
}
// Copy remaining elements of leftArray, if any
while (i < n1) {
arr[k] = leftArray[i];
i++;
k++;
}
// Copy remaining elements of rightArray, if any
while (j < n2) {
arr[k] = rightArray[j];
j++;
k++;
}
}
}
public class ScoreSorter {
public static void main(String args) {
int answer = scoreSorter(new int{1, 2, 3, 9999, 13}, 10000);
for (int i = 0; i < answer.length; i++) {
System.out.println(answer[i]);
}
}
public static int scoreSorter(int array, int topScore) {
// Write your code here
//find Minimum difference
int diff1 = 0;
int diff2 = 0;
for(int j =0; j< array.length-1; j++){
for(int i = 0; i < array.length-1; i++){
diff1 = topScore - array[i];
diff2 = topScore - array[i+1];
if(diff1>diff2){
int temp = array[i+1];
array[i+1]= array[i];
array[i] = temp;
}
}
}
return array;
}
}
) below.
) to up-vote the contribution!