Rahimo vs Salitas FC

Expert Overview: Rahimo vs Salitas FC

The upcoming match between Rahimo and Salitas FC on November 23, 2025, promises to be a closely contested affair. With odds favoring low-scoring outcomes in both halves, this game is expected to be tactical and defensive. The data suggests a strong likelihood of both teams not scoring in the first half, with combined odds for “Home Team Not To Score In 1st Half” at 98.20% and “Away Team Not To Score In 1st Half” at 97.70%. This indicates a potentially tight first half with minimal goals.

Betting Predictions

• First Half Outcomes:

• “Both Teams Not To Score In 1st Half”: 98.00%

• “Under 0.5 Goals HT”: 91.20%

• “Draw In First Half”: 89.00%

• Overall Match Predictions:

• “Under 2.5 Goals”: 80.10%

• “Both Teams Not to Score”: 82.90%

• Second Half Outcomes:

• “Both Teams Not To Score In 2nd Half”: 81.80%

• “Home Team To Score In 2nd Half”: 66.10%

• “Away Team Not To Score In 2nd Half”: 59.20%

• Other Predictions:

• “Over 1.5 Goals”: 62.80%

• “Sum of Goals (2 or 3)”: 54.30%

• “Home Team To Win”: 50.30%

Average Statistics

• Average Total Goals: 2.37

• Average Goals Scored: Home – TBD, Away – TBD

  </lguptaankit/CPSC-340-assignment-3/src/main/java/edu/washington/cse/cpsc340/assignment3/ThreadedTree.java
  package edu.washington.cse.cpsc340.assignment3;

  import java.util.ArrayList;
  import java.util.List;

  /**
  * A threaded binary tree that supports inorder traversal without recursion or a stack.
  * @param T the type of value stored in the nodes
  */
  public class ThreadedTree<T extends Comparable> {

  private static final boolean LEFT = false;

  private static final boolean RIGHT = true;

  /**
  * A node in a threaded binary tree.
  */
  private class Node {

  public Node left; // left child

  public Node right; // right child

  public T value; // value stored in this node

  public boolean isThread; // true if this pointer is a thread

  /**
  * Construct a new node.
  * @param value the value to store in this node
  */
  public Node(T value) {
  this.value = value;
  isThread = false;
  left = null;
  right = null;

  assert (value != null);

  assert (left == null);

  assert (right == null);

  assert (isThread == false);

  assert (!isLeaf());

  assert (!isThread());

  assert (!isRoot());

  assert (!hasTwoChildren());

  assert (!hasOneChild());

  assert (!hasOneLeftChild());

  assert (!hasOneRightChild());

  assert (!hasNoChildren());

  }

  /**
  * Returns true if this node has no children.
  * @return true if this node has no children.
  */
  public boolean hasNoChildren() {
  return ((left == null) && (right == null));
  }

  /**
  * Returns true if this node has two children.
  * @return true if this node has two children.
  */
  public boolean hasTwoChildren() {
  return ((left != null) && (right != null));
  }

  /**
  * Returns true if this node is the root of its tree.
  * @return true if this node is the root of its tree.
  */
  public boolean isRoot() {
  return ((parent == null) && !isThread);
  }

  /**
  * Returns true if this node is a leaf of its tree.
  * @return true if this node is a leaf of its tree.
  */
  public boolean isLeaf() {
  return ((left == null) && (right == null));
  }

  /**
  * Returns true if there exists only one child of this node, and it’s on the left side.
  * @return true if there exists only one child of this node, and it’s on the left side.
  */
  public boolean hasOneLeftChild() {
  return ((left != null) && (right == null));
  }

  /**
  * Returns true if there exists only one child of this node, and it’s on the right side.
  * @return true if there exists only one child of this node, and it’s on the right side.
  */
  public boolean hasOneRightChild() {
  return ((left == null) && (right != null));
  }

  /**
  * Returns true if there exists only one child of this node, regardless of which side it’s on.
  * @return true if there exists only one child of this node, regardless of which side it’s on.
  */
  public boolean hasOneChild() {
  return (((left != null) && (right == null)) || ((left == null) && (right !=null)));
  }

  private Node parent;

  /**
  * Inserts an element into the tree rooted at ‘this’ according to binary search rules,
  * maintaining threading as appropriate for inorder traversal without recursion or stack use.

  @param x The element to insert into the tree rooted at ‘this’.
  @return The newly created Node containing ‘x’.
  */
  private Node insert(Node x)
  {
  assert(x!=null);
  assert(!x.isLeaf());

  if(isEmpty())
  {
  root=x;
  }
  else{
  Node p=root;

  while(p!=null){
  if(x.value.compareTo(p.value)<0){
  if(p.left==null){
  x.parent=p;
  x.isThread=false;
  x.left=null;
  x.right=p.leftThread();
  break;
  }
  else{
  if(! p.left.isThread)
  {
  //move down left subtree until we find an empty spot or thread:
  //note that we don't have to worry about going off-the-end here,
  //since we're checking for threads explicitly instead of relying on sentinel nodes:
  while((! p.left.isThread)&&( p.left.right!=null))
  {
  if(x.value.compareTo( p.left.right.value )=0:{
  if(p.right==null){
  x.parent=p;x.isThread=false;x.right=null;x.left=p.rightThread();
  break;}
  else{//we haven’t found an empty spot yet:
  if(! p.right.isThread)
  {while((! p.right.isThread)&&( p.right.left!=null))
  {if(x.value.compareTo( p.right.left.value )>=0)
  { p=p.right;}
  else{
  x.parent= p.right.left.parent;//this will be set when we move down further below…
  break;} }
  }//we’ve either reached an empty spot or hit a thread:
  } }//so now we know that either:
  //(i) we’ve reached an empty spot where we can insert our new element,
  //(ii) or we’ve hit a thread pointing back up toward our ancestors…
  //either way, handle accordingly:

  if(p.right.isThread){//(ii):
  //since threads are always directed toward inorder successor/predecessor,
  //and since our elements are unique by construction,
  //there can be no case where our new element should actually point back up toward its ancestors…
  assert(!( x.value.equals( p.right.value )));//…and so we should never reach here…

  //so now all that remains to do is break out:

  break;}
  else{//(i):
  x.parent=p;leftSide=false;break;}
  }//}//while loop ends here…

  if(leftSide){//insertion point was found on left subtree:
  assert(x.parent!=null);assert(! x.parent.isLeaf());

  if(x.value.compareTo( x.parent.value )=0)//new element belongs after parent:
  {x.right=x.parent;leftSide=false;}//new element points back up toward parent…
  } }

  Node oldNext=null;//initialize oldNext variable…

  Node next=x;//initialize next variable…

  while(true){//now walk through each successive inorder successor from insertion point until reaching end-of-tree sentinel…

  next=next.next();//…and update next variable accordingly…

  oldNext=next;//update oldNext variable accordingly…

  next=next.next();//…and update next variable again…

  if(next==root)//once next reaches end-of-tree sentinel…
  { break;}//…exit loop.

  next.setPrev(oldNext);//set predecessor pointer for current inorder successor…

  oldNext.setNext(next);//set successor pointer for previous inorder successor…
  } }

  Node y=x.prev();//initialize y variable with reference to immediate predecessor…

  y.setNext(x);//set successor pointer for immediate predecessor…

  x.setPrev(y);//set predecessor pointer for newly inserted element…

  /*————————-*/

  /*—– TESTING CODE ——*/

  /*————————-*/

  /*
  System.out.println(“Predecessor: “+y.toString()+”nSuccessor: “+next.toString()+”nNew Element: “+x.toString());
  System.out.println(“Inorder Traversal:n”+inorder(root));
  System.out.println(“nn”);
  */
  /*————————-*/

  /*—– TESTING CODE ——*/

  /*————————-*/

  /*
  for(int i=0;i=0;i–){

  Node n=new Node(i);

  delete(n);}

  System.out.println(inorder(root));*/
  /*
  for(int i=0;i=0;i–){

  Node n=new Node(i);

  delete(n);}

  System.out.println(inorder(root));*/
  /*

  for(int i=99;i>=-99;i–){
  int randomNum=i;

  Node n=new Node(randomNum);

  insert(n);}

  System.out.println(inorder(root));

  for(int i=-99;i<=99;i++){

  Node n=new Node(i);

  delete(n);}

  System.out.println(inorder(root));*/
  /*

  for(int i=-99;i<=99;i++){
  int randomNum=i;

  Node n=new Node(randomNum);

  insert(n);}

  System.out.println(inorder(root));

  for(int i=-99;i=0&&d<=size());

  return d;}

  private void tParent(Node par)
  {parent=par;}

  private Node tParent()
  {return parent;}

  private void tLeft(Node lft)
  {left=lft;}

  private void tRight(Node rgt)
  {right=rgt;}

  private void setIsLeaf(boolean b)
  {isLeaf=b;}

  private void setIsRoot(boolean b)
  {isRoot=b;}

  private void setIsLeft(boolean b)
  {isLeft=b;}

  private void setIsRight(boolean b)
  {isRight=b;}

  private void setIsTthread(boolean b)
  {isTthread=b;}

  boolean isEmpty()
  {return root==null||root.isLeaf();}

  boolean contains(T val){
  boolean result=false;if(val!=null&&!isEmpty()){
  List stack=(val.compareTo(root.val)<0)?stackFromRootTo(val):stackFromRootTo(val);do{/* pop */val=((stack.isEmpty())?root:(stack.remove(stack.size()-1)));result=val.val.equals(val);}while(result&&(!stack.isEmpty()));} return result;} private List stackFromRootTo(T val){
  List stack=(LinkedList)new LinkedList();for(Node cur=root;!cur.val.equals(val)&&!cur.val.equals(cur);cur=val.compareTo(cur.val)<0?cur.lft():cur.rgt()){stack.add(cur);} return stack;} private List stackFromValToRoot(T val){
  List stack=(LinkedList)new LinkedList();for(Node cur=val;!cur.val.equals(cur)&&!cur.val.equals(root);cur=val.compareTo(cur.val)<0?cur.rgt():cur.lft()){stack.add(cur);} return stack;} /** Adds 'val' into 'this' BST while maintaining BST properties */ public synchronized Boolean add(T val){
  Boolean result=false;if(val!=null&&!contains(val)){result=addRecursive(this,val);} return result;} /** Adds 'val' into 'this' BST while maintaining BST properties */ private synchronized Boolean addRecursive(Node cur,T val){
  Boolean result=false;if(cur.val.equals(cur)||isEmpty()){result=setValAndSetIsLeafIfNecessary(cur,val);} else {result=addRecursive(((val.compareTo(cur.val))<0)?cur.lft():cur.rgt(),val);} return result;} /** Sets 'node''s value equal to 'val', sets its flag indicating whether it's leaf or not */ private synchronized Boolean setValAndSetIsLeafIfNecessary(Node cur,T val){Boolean result=true;if(!isEmpty()){setValAndSetIsLeafIfNecessaryHelper(cur,val);result=true;} else {result=setValAndSetIsLeafIfNecessaryHelper(new ThreadedTree.Node(val),val);} return result;} /** Helper method for {@link #setValAndSetIsLeafIfNecessary()} */ private synchronized Boolean setValAndSetIsLeafIfNecessaryHelper(ThreadedTree.Node cur,T val){Boolean result=true;if(isEmpty()){root.setVal(val);root.setIsRoot(true);root.setIsTthread(false);result=true;} else {result=setValAndSetIsLeafIfNecessaryHelperRecursionHelper(cur,val);} return result;} /** Recursive helper method for {@link #setValAndSetIsLeafIfNecessary()} */ private synchronized Boolean setValAndSetIsLeafIfNecessaryHelperRecursionHelper(ThreadedTree.Node cur,T val){Boolean result=true;if(isEmpty()){root.setVal(val);root.setIsRoot(true);root.setIsTthread(false);result=true;} else {result=setValAndSetIsLeafIfNecessaryRecursionHelperRecursionHelper((!(val.equals(cur.val))),!(val.equals(((LinkedList)new LinkedList()).addLast((LinkedList)new LinkedList().addLast(new Object())))),!(val.equals(new Object())),!(val.equals(((LinkedList