Justin Robbins

Carey Brown wrote:So if you know the Player who scored what difference does it make which Game or which Team?

I think the points gets calculated differently for each individual team the player plays for.

Paul Clapham wrote:Carey has pointed out some of the problems with your implementation of that method, but I have to say that I don't understand what the method is supposed to be doing in the first place. Even after reading your description several times I'm still lost.

I don't understand what it means for a team to be playing between two other teams, for one thing: you said

I want this method to be called to show that thePlayer has scored a goal for wat_Team, that is playing between the first_Team and the second_Team

But probably I've misinterpreted what you meant to say there. So let's take an example. Suppose first_Team is "Manchester United" and second_Team is "Toronto Maple Leafs" and wat_Team is "Portland Trailblazers". Can you explain what we should be looking for to see if that's a valid combination, or whatever? Remember I don't know what a Game is in your data model, sometimes you describe it as if it's supposed to be taking place right now but other times it seems like it could represent a game which has already taken place.

Player can play for either team. And whatTeam refers to the team that player is on. It was confusing wording sorry.

Carey Brown wrote:I think some use cases would help get you in the right direction. Example (you'd need to tell us if these are in fact correct):

A Team consists of a number of Players

There is one-or-more Games G where Team A plays Team B

Player P could play for different Teams for different Games

When Player P scores his/her score count needs to be incremented

more?

Yes, the team class has players.
There are more or more games where Team A plays team B.
Player P can play with different teams for different games.
Player P's score count needs to be incremented.

Yes to all. I just don't know how to achieve that. My OO is weak.

Junilu Lacar wrote:1. Don't get cute with names. I'm not sure what you're trying to convey with a name like wat_Team but it gets old after reading it a couple of times.

2. The design of this method smells to high heaven.  Java is an object-oriented language. With as many different objects that you have involved here, this is not at all an object-oriented way to accomplish anything.

I know I need help badly. How can I clean this up and stay true OO design principles?

Carey Brown wrote:On line 11 you create a new Player 'p', but then throw it away without doing anything with it.

with the loops I want to check if there is a game in which the first and second are playing each other, if not then false.
If there is a game between them I want to check if either of those team names are "whatTeam", if that is the case I then
want to add a goal of 1 to the player player in the parameter, to which the fourth parameter refers to in between the two
teams referred to in the first two parameters.

I have a class called GameCollector which adds up all the points between rival teams. I also made a Game class that has a constructor that takes in two separate strings to represent teamOne and teamTwo. And also a Team class with a constructor that has four parameters, string teamName, int totalGoals, int games, and int wins. And a player class that has a constructor with parameters String name, int goal, String team. Inside the GameCollector class I have this method:

public boolean goalScored(String first_Team, String second_Team, String wat_Team, String thePlayer) {    for (Game g : games) {        if(!(g.getFirstTeamName().equals(first_Team) && g.getSecondTeamName().equals(second_Team))) {            return false;        }        if(!(g.getFirstTeamName().equals(wat_Team) || g.getSecondTeamName().equals(wat_Team))) {            return false;        }    }    Player p = new Player(thePlayer, 1, wat_Team);    return true; }

Not sure if this method is implemented right but I want this method to be called to show that thePlayer has scored a goal for wat_Team, that is playing between the first_Team and the second_Team. With a goal being +1. A false boolean should be figured out through if first_Team and second_Team are not playing against each other. Of course, if both firstTeam and secondTeam are currently playing a game but whatTeam isn't the name of either, it should return a false boolean. But if those check out then a score should be added to thePlayer that the whatTeam refers in the game between firstTeam and secondTeam.

Thank you

This method is used to remove the value toRemove from the array. The remaining elements should just be shifted toward the beginning of the array. Since the array will now have one fewer element, the position of the previous last element should just be filled with 0. If there is more than one occurrence of toRemove in the array, only the first occurrence should be removed.


public static void remove(int[] arr, int toRemove) { boolean done = false; int position = 0; for(int pos = 0; pos < arr.length; pos++) {    if(!done && arr[pos] == toRemove) {    done = true;    position = pos; } if(done) { for(int i = position + 1; i < arr.length; i++) {    arr[i - 1] = arr[i]; } arr[arr.length - 1] = 0; } }



It's hard to pick out one line that confuses me. Could someone please explain what each line of code is doing?

Thank you

Hello there!

Am having a little trouble understanding selection sort want to make sure I am following correctly.

Found the code, just trying to conceptualize it, so imagining we pass in an array such as: 9,5,2,7,1

public int[] selectionSort(int[] list) { int i, j, minValue, minIndex, temp; for (i = 0; i<list.length; i++) {    minValue = list[i]; // this would start at 9    minIndex = i; // this would start at 0    for ( j = i; j < list.length; j++) { // It would start at 0 because that's the i'th of the outer loop        if (list[j] < minValue) { // then we'd check this over and over: 9<9, 5<9, 5<2, 2<7, 2<1.... Settling on 1            minValue = list[j]; // this would eventually become minValue = 1;            minIndex = j; // likewise this would thus become minIndex = 4;            }   } // now after we've found the absolute smallest guy in the array we then must swap him with the original starting index   if (minValue < list[j]) { // since 1 < 9 is true. where 1 is the smallest guy, and 9 being the first index iteration we're on      temp = list[i]; // Save '9' for later      list[i] = list[minIndex]; // Assigning that first index iteration slot with the now confirmed smallest number      list[minIndex] = temp; // And now assigning the spot we're where we took the smallest guy out and placing in the iteration index value we're on      }   }   return list; }

And then we carry on to iteration 2, then 3 then 4 each time doing a inner for-loop to find the proceeding smallest value ahead of its index.

A major thing I don't get is how is this updating a list? like how is it being saved to eventually return a sorted list?

please tell me if I am misunderstanding anything
Thank you

So the array at index 0 is assigned to the VALUE part, not the array itself, at index 1. Idk it really confuses me to think of one array being assigned to another array.

Carey Brown wrote:Swap looks more like
int v1 = 9; int v2 = 5; int temp; if ( v1 > v2 ) {    temp = v1; // temp now contains 9    v1 = v2; // v1 now contains 5    v2 = temp; // v2 now contains 9    }
At the end, v1 contains 5 and v2 contain 9.

Thanks!
So it's simply assignments happening here. What's on the left get's assigned to what's on the right, like that?
So we say that temp will hold on to the value that the array has at that specified index.
and then say that, that array index is to be assigned with the array index next to it? so even though they are both array[index] you can assign one to be WHERE it's at and the other to be the value?
so it's more like
array[0] = 5;
instead of array[0] = array[1]; ?

it confuses me to see an array assigned to another array, like what's even happening there. Is one array becoming another array? massive confusion about it.

Hello

I am trying to see if I understand bubble sort correctly, also there many gaps in my knowledge that I hope people can fill in.

I found this bubble sort code online and am now trying to analyze how it all works.

public void bubbleSort(int[] arr) { boolean swapped = true; int j = 0; int tempHold; while (swapped) { // so long as swapped is true keep on iterating swapped = false; // we set this to false because once the for loop is done iterating we want a way for it to exit out of the while loop, this does that j++; // don't understand why this is here at all, very confusing for (int i = 0; i < arr.length - j; i++) { // now we set up a for-loop and iterate through the entire array and compare element pairs, why - j? don't understand that part.      if (arr[i] > arr[i+1]) { // saying if the element at the i'th index is greater than the one right next to it, then we'll execute this body of code    tempHold = arr[i]; // now we're saying get that temp integer we set up and use it to STORE the integer generated by its index, I think?    arr[i] = arr[i+1]; // and here are we saying take the value at the i'th index and assigned to the value at the i'th + 1? or are we saying taking the i'th and assign it to what's inside i'th + 1?    arr[i+1] = tempHold; // now are we saying take that i'th + 1 position and give it the stuff we held in tempHold?    swapped = true; // is this necessary? why is this needed here?    }  } } }

when we do this swap is, is temp = arr[i] at that moment an integer or the index or element itself, so confused about that. Don't understand what it represents right then and there.


Say we have the unsorted array: 9,5,2,7,1

here would that code look like:

if ( 9 > 5 ) {    temp = 9;    9 = 5;    5 = temp;    swapped = true;    }

I know it's suppose to be a swap, but I am just not seeing how that happens there.
we say our temp is now the value of 9.
It's strange to see a value on one side and then the variable name on the other.
Would it be the same to say temp = 5; at that point?
I am quite confused about arrays.

How exactly does this output a sorted array at the end of it all?

please help

I am getting a null pointer exception for:
if (previous.distance + getWeight(previous.data, vertPoll.data) < vertPoll.distance || vertPoll.distance < 0) {

Made a graph for a maze. But I am somewhere missing an edge cases, maybe a few and there is an infinite loop inside this code. I've been at this for hours I cannot seem to find the edge case or where the infinite loop inside in the code. I seriously need someones help. Where is an infinite loop/edge case here.

Thank you

public void DoDijsktra(V start, V end) { if (!weightedHashGraph.containsKey(start)) { throw new IllegalArgumentException(); } else { for (GraphAlgorithmObserver<V> observer : observerList) { observer.notifyDijkstraHasBegun(); } PriorityQueue<Vertex> PQueue = new PriorityQueue<Vertex>(); Vertex vert = new Vertex(start); PQueue.add(vert); Vertex previous = vert; Vertex vertexEnd = null; while (PQueue.peek() != null) { // while there is a minimum Vertex vertPoll = PQueue.poll(); for (V next : weightedHashGraph.get(vertPoll.data).keySet()) { if (previous.distance + getWeight(previous.data, vertPoll.data) < vertPoll.distance || vertPoll.distance < 0) { vertPoll.distance = previous.distance + getWeight(previous.data, vertPoll.data); vertPoll.previous = previous; } Vertex ver = new Vertex(next); if (next == end){ vertexEnd = ver; } PQueue.add(ver); previous = vertPoll; for (GraphAlgorithmObserver<V> observer : observerList) { observer.notifyDijkstraVertexFinished(vertPoll.data, vertPoll.distance); } } } LinkedList<V> ll = new LinkedList<V>(); while (vertexEnd.previous != null) { ll.add(0, vert.data); vertexEnd = vertexEnd.previous; } ll.add(vert.data); for(GraphAlgorithmObserver<V> observer : observerList){ observer.notifyDijkstraIsOver(ll); } } } private class Vertex implements Comparable<Vertex>{ private V data; private Vertex previous; private Integer distance; private Vertex(V data) { this.data = data; this.previous = null; this.distance = -1; } public int hashCode() { return data.hashCode(); } public boolean equals(Object x) { if (x == null) { return false; } if (!(x instanceof WeightedGraph<?>.Vertex)) { return false; } return data.equals(((Vertex)x).data); } public int compareTo(Vertex o) { return (distance.compareTo(o.distance)); } }

Understood.
Probably doesn't make much sense for when the Dog class is created to compare it <T> things? does it? when we implement its Comparable interface, we want things that can compare with what they are so when they are passed into the <T> parameter we can easily compare them against their own type not someone else's. For example all Strings, or all Dogs or all Integers we want one type and one type only. So what they originally must have been is comparing themselves.

Example:
public class nums implements Comparable<nums>{}

The only things that go into that T type are only which implement the comparable interface and that when they implemented the comparable interface they did so with comparing things of their same type.

Also, one person told me it's the first now I hear it's the second. Please I need to fully understand this concept.