₦airaland Forum

Sleekcode:
I strongly believe dropping questions will be far better than dropping resources.


Dropping just resources will see this thread lost in oblivion before New year just like your other threads.

No offense!

qtguru:
Resource for the Day: Analysis of Algorithm
https://cs.lmu.edu/~ray/notes/alganalysis/

Sleekcode:
Must this be in python?

airsaylongcome:
Lol! Now that that you mentioned trees, I remember learning about Binary Search Trees. And some tree algorithms about depth-first or breadth-first....it's been years man!

airsaylongcome:
Yes I fully understand that the Data Structures are completely different from the Algorithms. I was just a bit confused with qt's post that mentioned dealing with DSA first then Algo later

airsaylongcome:
Also before diving in to sharing problems (someone has already "gotten" to quicksort now now lol), I think it would be nice to give a background on the various data structures as well as the algorithms. It's been a few years I've been down the DSA route but if memory serves me right the DS were
Queues
Stack
Trees
(I don't recall learning Hash)
which were implemented with pointers and arrays.

The Algorithms if I remember correctly were split broadly into Search Algorithms and Sorting algorithms. Would be nice for someone to then list out the various search and sorting algorithms. I remember Bubble Sort and Insertion sort as well as Quick Sort. I'm literally pulling these stuff from my 2003 self. So over to the devs more in touch with all of the state of art info about DSA and put some clarity for folks reading

airsaylongcome:
So let me get something right, a lot of you guys throw around acronyms that now seen confusing to me. My understanding is that

DSA stands for Data Structures and Algorithms
Algo stands for Algorithms

so when DSA and Algo are thrown together, I get a little confused because AFAIK the "A" in DSA is the same as Algo. Any more active devs wanna clarify?

AlchemyOfCodes:
Ok guys, finally done the exam. The good news is that I finally got into a DSA bootcamp where I get to rub shoulders with guys from Microsoft and the likes. The bad news my laptop suddenly crashed a day to my final papers.

When I charge the system, the indicator light blinks but the system will not boot. If anyone has an idea of what the issue is.

Right now , I will continue the DSA book on my phone.... At least one leetcode question everyday. Go back to my default mode of reading books. And hopefully I get it fixed soon. This thread ain't dying .

GREATIGBOMAN:
Add screenshots with your code and let's see it running and working pls


Not everyone have Jupiter installed to run your python code to check if it's correct.

res = solve(nodes)

class Node:
  def __init__(self, id, col, val):
    self.id = id
    self.color = col
    self.value = val
    
  def __str__(self):
    return f"id: {self.id}, color: {self.color}, value: {self.value}"
    
    
class Result:
  def __init__(self, n1, n2, w):
    self.startnode = n1
    self.endnode = n2
    self.weight = w
    
  def __str__(self):
    return f"sn: {self.startnode.id}, en: {self.endnode.id}, weight: {self.weight}"
    

def read_inputs():
  n = int(input())
  res = set()
  for i in range(1, n + 1):
    s = input().split()
    res.add(Node(i, int(s[0]), int(s[1])))
  return res
  
def solve(nodes):
  res = []
  while len(nodes) != 0:
    maxn = max(nodes, key=lambda v: v.value)
    # check stray nodes
    if maxn.value == 0:
      resolve_res = [next_valid_node(maxn, res)]
    else:
      resolve_res = resolve_edges(maxn, nodes) 
    nodes.remove(maxn)  
    res.extend(resolve_res)
  return res
    
def resolve_edges(maxn, nodes):     
  res = []
  while True:
    minn = pick_min(maxn, nodes)
    if minn is None:
      break
    if maxn.value >= minn.value:
      res.append(Result(maxn, minn, minn.value))
      maxn.value -= minn.value
      nodes.remove(minn)
    else:
      res.append(Result(maxn, minn, maxn.value))
      minn.value -= maxn.value
      nodes.add(maxn)
      break
  return res
    
def pick_min(maxn, nodes):
  minn = Node(-1, -1, 999)
  for node in nodes:
    # check colors, reject same color nodes
    if node.color == maxn.color:
      continue
    if node.value < minn.value:
      minn = node
  return minn if minn.value != 999 else None
  
def next_valid_node(strayn, nodes):
  straycol = strayn.color
  for node in nodes:
    startcol, endcol = node.startnode.color, node.endnode.color
    if startcol != straycol:
      return Result(strayn, node.startnode, strayn.value)
    if endcol != straycol:
      return Result(strayn, node.startnode, strayn.value)

def main():
  nodes = read_inputs()
  nodes_test = {
    Node(1,1,0),Node(2,0,3),Node(3,1,8 ),
    Node(4,0,2),Node(5,0,3),Node(6,0,0)
  }
  nodes_test2 = {
    Node(1,1,3),Node(2,1,2),Node(3,0,5)
  }
  res = solve(nodes)
  [print(r.startnode.id, r.endnode.id, r.weight) for r in res]

if __name__ == "__main__":
  main()

TastyFriedPussy:
My favourite programming language is C++, why?

Because it is like the rinnegan of the programming world( those who are naruto fans && programmers would understand).....

Gawd my imagination is fûcked up

Najdorf:
Abeg no bring this kind question again
Let us just stick to the WordPress wey everyone go sabi

CyberHustle:
I am still waiting for the three parts you talked about. The is a useless question if sorting will automatically break down a list into three parts.

CodingSoft:
I cannot find any use of this coding test on Amazon shopping site. Their site only has these types of sorting: Price: Low to high, Price High to low, Avg. Customer review and Newest arrivals. None of these requires this type of coding test. All that is needed for these are to use the sorting provided by the programming language to achieve these basic kinds of sorting.

This kind of coding test is only useful when it comes to games programming as you'll have to store data in arrays and manually check and retrieve them using the quickest logic possible.

It is not possible to accomplish this coding test in O(1) as you cannot accomplish this task without a nested loop.

O(1) describes an algorithm that will always execute in the same time (or space) regardless of the size of the input data set.

bool IsFirstElementNull(IList<string> elements)
{
return elements[0] == null; //Source: https://rob-bell.net/2009/06/a-beginners-guide-to-big-o-notation/
}

CyberHustle:
If I reply you the way I ought to, this thread will derail.
Your own question say we need three new lists. But your solution shows only one list and therefore is incomplete. What you have there is a human readable solution and not a computer readable one.

Lastly, any moniker accepting your clearly incomplete solution is your alternate.

Deicide:
Space is cheap

Najdorf:
We have explained this thing multiple times in different ways...
I'm even tired sef

Deicide:
Using extra space would have made it easy. Cause then you can use 3 for loops but the space complexity would be o(n). It would look something like this

CyberHustle:
If sorting alone is a valid solution then your question is senseless and pointless. Sounds a lot like you looking for clout.

If I need the values less than, equals to, and greater than X, I just loop through and pick the values if it matches my interest. To have three different list within a list. You must know where the less than X values end and note that index in a variable(x_starts for example) then know where greater than X starts(x_ends) in another variable. Any value between is X.

CyberHustle:
Please compare the challenge and your solution. Where are the three parts of the original list? That's is less than X, X, and greater than X?

CyberHustle:
How will sorting alone help identify array values lesser, equal to and greater than X?

My solution involves sorting it and then looping thru to identify where values lesser than, equal to and greater then X either end or start. If you are implementing the sort algorithm, you could combine both processes otherwise depend on language shipped sorting function then loop thru to know indexes of interests.

CyberHustle:
loop thru d array, and note the index where X is greater than the value(s) stops and the index where X is less than the value(s) start.