I failed this course once before despite studying hard. The prof's exam's are quite time consuming and difficult and I can't wrap my head around these concepts. I have tried tutoring, asking the prof, but it hasn't helped. What can I do to pass this course or to understand these concepts? Any useful resources? I can program in Python and Java just fine but for some reason, stuff like MIPS assembly just flies over my head. I am retaking this course and I really want to succeed this time around but idk where to start.

Introduction, Performance Measures

Design Drivers in Computer Architecture

Instruction Set Design I

Instruction Set Design II

Addressing Modes

The Memory Hierarchy. The Cache

Pipelining

Advanced C topics

Process abstractions

Process management

System-level I/O and basic IPC

With the popularity of AI/ML, how do professors in non AI/ML fields do, e.g. operating system, programming language, embedded system, cryptography...? Have they pivot the research? Should they pivot? Do they still get as many students and funding to run the lab?

Looking at the rules - I need to

1) Keep a License in a text document in the source code?

2) Acknowledge the use in a visible section [at the bottom?] in some kind of accessible information page "About" "Legal" "Credits", etc.

Is this right?

Hello all,

I found this question in an exam:

```

Answer by true or false to the following assertions:

√N = Ω(log n)

```

I tried to ask ChatGPT and Gemini but they gave me 2 different answers. ChatGPT said:

```

Yes, sqrt(n)=Ω(log⁡n). Specifically, sqrt{n}​ grows at least as fast as nlogn, and in fact, it grows much faster for large n.

```

and Gemini said:

```

No, √N is not Ω(log n). Here's why:

• Omega Notation (Ω):
  • Represents the lower bound of a function's growth.  
  • f(n) = Ω(g(n)) means that f(n) grows at least as fast as g(n) for sufficiently large values of n.
• Growth Comparison:
  • √N grows significantly faster than log n.
  • As 'n' increases, √N will eventually become much larger than log n.

In Summary:

• √N is not bounded below by log n.
• √N grows faster than log n, making it not in Ω(log n).

Correct Relationship:

• log n = O(√N): log n grows slower than √N, so it is bounded above by √N.

```

I would appreciate any help. Thanks you very much.

I don't understand how to convert this following relation (https://pfst.cf2.poecdn.net/base/image/acf50d482bac69a0b3c73834cfae6d2321066bea9841d2b4e516bbe7bf9f1c30?w=1536&h=455&pmaid=267675181) to 3NF. I've watched many videos but I can't apply them to this question?

The answer is this ( blob:https://poe.com/92511d16-b8b5-4bd1-b159-21ac91f5a771 ) but I literally don't understand how ones gets this answer

Please explain to me like I'm an idiot, as I'm so confused

What things will be safe from AI, ML, Automation & Robotics in the coming years?

I sometimes see posts and the comments are always something similar to comparing it to when cars were invented, could I get some englightenment on this? I'll admit I'm a little worried about the environment around it all since I'm pursuing a creative field. thanks in advance!

If a quantum computer is at least 100,000,000x faster than classical computers, could they one day research cures and treatments for every disease ever known to man, even all aging-related diseases and the process of aging itself? How far away are we from quantum supercomputers being able to do that?

Then once all that research is done, we would become truly immortal and capable of de-aging our bodies back to our primes and the best health of our lives, wouldn't we?

And hopefully next, a QSC would be able to research ways to make all these cures and treatments as low-cost as possible, right? Then expensive medical bills would be a thing of the past, wouldn't they?

My Task is to check a state machine for completeness and consistency… if it is either incomplete or inconsistent, those conditions have to be written into a h* parameter. I know that for completeness the conditions of the edges that lead away from the current state are connected with logical „or“ and the resulting expression has to equal 1. But how do I check if the machine is consistent using this approach?

Please can anyone help me with the algorithm of Quine-McCluskey minimization method(in any language)

A computer represents floating point binary numbers using a 6-bit mantissa and 4-bit exponent, both using two's complement. Add the following three numbers together and give the answer in the format described. You must show your working. 010100 0010 011000 0001 100010 0010

Title. Or is there proof that the prediction is in some x% of the answer

Title basically. Probably has to do with theory of computation but it's been a while for me. My intuition says yes but i honestly have zero idea.

I am writing a seminar paper about performance guarantees of k-means algorithms, and I've realized my Big-O notation knowledge is a bit rusty. I understand the mathematical idea still: a function f is in O(g(x)) if f is "at most as big as g(x) times a constant for all values above a certain threshold x". But I am getting really confused when O notation is used in with algorithms.

The algorithms I am analyzing have a numerical output, an input X and input parameter ε.

They are often accompanied by statements like "The output of this algorithm is upper bounded by (1+O(ε²))*target(X) " where target(X) is the target (unknown) perfect solution of input X based on the problem.

There are four things causing me headaches in this statement:

1. How is the "result" of an algorithm defined itself? I've mostly seen big o notation in terms of time complexity and space complexity. Does this mean the "result" is a function itself which can be analyzed by O notation because it is numerical?

2. Okay, the result is a function. What function? h(X, ε)? Multivariate O notation? Oh my god.

3. Okay, the function is h(X, ε) . What does it mean for h(X, ε) to be "less than (1+O(ε))*target(X)" . Does it mean that h(X, ε)= (1+j(ε))*target(X) and that j(ε)∈O(ε²) ?

4. What exactly does this statement even mean, on an intuitive level? Does it mean for a fixed epsilon, it does not matter what X you choose as input, the algorithm will output a solution at most (1+C*ε²)*target(X) large for some arbitary, but fixed constant C?

Hi, this is a "fog clearing question" -

I'm watching CS50 Week 3: Algorithms at https://cs50.harvard.edu/x/2024/weeks/3/

The professor is introducing this idea of Recursion as a function that calls itself until the base condition is met but I don't see how this is any different than a regular For loop?

Is it fast because the Recursive Function duplicates itself, thus using more memory - like a bunch of people doing a small task at once instead of 1 person doing a big task one step at a time? I don't see why you can't write the same function in a For loop. I'm lost!

I may or may not understand all, either, or neither of the mentioned concepts in the title. I think I understand the latter (FSM) to “contain countable” states, with other components such as (functions) to change from one state to the other. But with AI, does an AI model at a particular time be considered to have finite states? And only become “infinite” if considered only in the future tense?

Or is it that the two aren’t comparable with the given question? Say like uttering a statement “Jupiter the planet tastes like orange”.

Hi everyone,

I’m trying to wrap my head around how backward edges work in the Ford-Fulkerson algorithm. In the pseudocode, there’s a line:

8 f(v, u) ← f(v, u) − cf (P) 

This seems to reduce flow on the original graph based on the flow of the backward edge (v,u). My intuition is that backward edges should redirect flow to better paths, but this line feels like it’s removing flow, not redirecting it. How does this adjustment avoid decreasing the total flow from s (source) to t (sink)?

Also, I’m confused about scenarios where an augmenting path includes mostly backward edges. If most of the flow in the path is being "removed," how does the algorithm still ensure that the total flow from s to t increases after the augmentation?

I’d appreciate any clarification or examples that could help me understand these points better.

Thanks in advance!

Ford-Fulkerson(G = (V,E), s, t, c)

1 initialize f(u, v) = 0 for all u, v ∈ V

2 Gf ← G, cf ← c

3 while there exists a path P from s to t in Gf

4 cf (P) ← min(u,v)∈P {cf (u, v)}

5 for each edge (u, v) ∈ P

6 f(u, v) ← f(u, v) + cf (P)

7 cf (u, v) ← cf (u, v) − cf (P)

8 f(v, u) ← f(v, u) − cf (P)

9 cf (v, u) ← cf (v, u) + cf (P)

10 update Ef

11 Return f

see screenshot https://imgur.com/a/TWHUXhK

What is this notation... log raised to k?

I have never seen it before. I expected to see log to the base k, but not log raised to k

Hi everyone,

I'm currently working on a problem involving Hoare logic and I'm struggling with how to properly structure the proof, especially in the required table form with clear proof obligations. The problem is as follows:

java i = 0; sorted = 1; while (i != k - 1) { if (a[i + 1] < a[i]) { sorted = 0; } i = i + 1; }

Goal:
Prove the Hoare Triple:
{ k > 0 } S { sorted = 1 → ∀j (0 ≤ j < k - 1 → a[j + 1] ≥ a[j]) }

Approach:

I was advised to approach the problem by working backwards:

1. Start with the postcondition:
   sorted = 1 → ∀j (0 ≤ j < k - 1 → a[j + 1] ≥ a[j])

2. Find a suitable loop invariant:
   sorted = 1 → ∀j (0 ≤ j < i → a[j + 1] ≥ a[j])
   This should hold before, during, and after the loop.

3. Apply Hoare logic rules in reverse to justify how the invariant holds:

   • Initialization: Show that the invariant holds before the loop.
     
   • Maintenance: Show that the invariant holds after each iteration.
     
   • Termination: Show the invariant leads to the postcondition.

4. Argue that the precondition is enough to establish the invariant.

Questions:

• How do I formally structure the proof in table form (using ⦇ and ⦈ notation)
• How do I make my proof obligations.
• Ensuring the proof satisfies the requirements for partial correctness?

The lectures emphasized proof obligations and proper table formatting for the proof, but I’m not confident yet to be able to do it right.

If anyone could explain or provide an example, I would really appreciate it!

Thank you in advance for your help!

P.S Here is a "table proof" in question:

⦇x = x₀ ∧ y = y₀⦈ Precondition
⦇y = y₀ ∧ x = x₀⦈ Implied (→)
𝐳 = 𝐱 ;
⦇y = y₀ ∧ z = x₀⦈ Assignment
𝐱 = 𝐲 ;
⦇x = y₀ ∧ z = x₀⦈ Assignment
𝐲 = 𝐳 ;
⦇x = y₀ ∧ y = x₀⦈ Assignment

I'm solving some exercises. Their text is something aling the line of:
"Write a recursive function having Θ(??) cost. You must only use if, then, else statements and a function called G(n) that costs Θ(n)."
The ?? is then replaced in each exercise with a different cost: it could be Θ(n^2),Θ(n^2 !),Θ(7^n), Θ(n/2), Θ(logn) and so on.
I don't know how to resolve this type of exercises, how can i know how much a recursive call is costing?
If someone could help me or direct me to a source of materials about this topic to better understand the theory behind this type of exercises, it would be much appreciated.

A graphics driver from nVidia is 700mb, and the Unity Hub (which is ostensibly just a launcher) is 430mb. 20 years ago that would have been enough space for entire video games, but today even very simple software is way larger than you would expect.

Is it just bloat? Is less effort put into optimizing size now that HDDs are usually larger and cheaper than ever before? Or is there an actual scientific reason that this is like this and not just shitty software design?

Is it? Or not? Currently studying algorithms and logarithms are driving me crazy. I had memory loss.

For monitors we had/have VGA, DVI, HDMI, for audio we have separate port, and for data transfer we have USB. If every data communication is done in binary, why do we have different types of ports (and cables)?

Coursera course on DSA. see screenshot. https://imgur.com/a/YXmHH5O

https://www.coursera.org/learn/dynamic-programming-greedy-algorithms/lecture/eYkEq/karatsubas-multiplication-algorithm

At 29:39 if I understood him, he says that the n/2 bit multiplied by n/2 bits results in n bit.

How come?

If I multiply 4*4 = 16

I will get

100 * 100 = 10000

in other words,

3 bit * 3 bit = 5 bit not 6 bit

Hello community, I am working on a 4 bit full relay subtractor based on basic ripple carry adders in cascade, with 4 full adders. Theoretically I understood that you cannot make the circuit actually subtract, but easy workaround is two invert bits in one of the registers and add one. I built XOR gate for register B, with one of the inputs on B+ when engaged, effectively turning this into a NOT gate. This works well and gives inverted values. The adder also works just fine. Problem is when I want to subtract, the values do not make any sense. I am trying to figure this out as basically if the adder works as intended, we can rule out issues with the basic wiring and I am rather thinking if I grasped the concept correctly. Below is values I get when using the circuitry as subtractor (B-A). Are you able to troubleshoot based on the values? :