15 150 fall 2020 lecture 6
play

15-150 Fall 2020 Lecture 6 Stephen Brookes Most of the time I don't - PowerPoint PPT Presentation

Mar 06, 2024 •102 likes •1.53k views

15-150 Fall 2020 Lecture 6 Stephen Brookes Most of the time I don't have much fun . The rest of the time I don't have any fun at all. today Sorting an integer list Using specifications to guide program design Helper functions should

  1. comments isort (y::R) calls isort R • The proof was “by structural induction on L” • Every list value L is either [ ] (nil) or y::R, where R is a “smaller” list value • We could just as well have said “by induction on length of L” • [ ] has length 0 • 0 ≤ length R < length(y::R)

  2. perm facts y::(a perm of R) is a perm of (y::R) A perm of a perm of L is a perm of L In the correctness proof we used some obvious facts about permutations.

  3. corollaries

  4. corollaries isort is a total function from int list to int list

  5. corollaries isort is a total function from int list to int list When e evaluates to L, isort e evaluates to the sorted version of L

  6. a variation fun isort [ ] = [ ] | isort (x::R) = ins (x, isort R) fun isort ’ [ ] = [ ] | isort ’ [x] = [x] | isort ’ (x::R) = ins (x, isort ’ R)

  7. a variation fun isort [ ] = [ ] | isort (x::R) = ins (x, isort R) is this clause fun isort ’ [ ] = [ ] redundant | isort ’ [x] = [x] | isort ’ (x::R) = ins (x, isort ’ R)

  8. variation isort ’ : int list -> int list fun isort ’ [ ] = [ ] | isort ’ [x] = [x] | isort ’ (x::R) = ins (x, isort ’ R) If in doubt, test, then prove

  9. variation isort ’ : int list -> int list fun isort ’ [ ] = [ ] | isort ’ [x] = [x] | isort ’ (x::R) = ins (x, isort ’ R) If in doubt, test, then prove

  10. variation isort ’ : int list -> int list fun isort ’ [ ] = [ ] | isort ’ [x] = [x] | isort ’ (x::R) = ins (x, isort ’ R) If in doubt, test, then prove

  11. equivalent • isort and isort ’ are extensionally equivalent: For all L : int list, isort L = isort ’ L. • Proof? See lecture notes… OR: Re-do the isort proof for isort ’ (easy) Hence they satisfy the same spec, so For all L : int list, isort L = isort ’ L = the sorted perm of L

  12. equivalent • isort and isort ’ are extensionally equivalent: For all L : int list, isort L = isort ’ L. • Proof? See lecture notes… OR: Re-do the isort proof for isort ’ (easy) Hence they satisfy the same spec, so For all L : int list, isort L = isort ’ L = the sorted perm of L No need for extra clause but it doesn’t do any harm

  13. work • Let W ins (n) be the work for ins(x, L) when x, L are values and L has length n • Let W isort (n) be the work for isort(L) when L is a list of length n

  14. work • Let W ins (n) be the work for ins(x, L) when x, L are values and L has length n W ins (n) is O(n) • Let W isort (n) be the work for isort(L) when L is a list of length n

  15. work • Let W ins (n) be the work for ins(x, L) when x, L are values and L has length n W ins (n) is O(n) • Let W isort (n) be the work for isort(L) when L is a list of length n W isort (0) = 1 W isort (n) = 1 + W ins (n-1) + W isort (n-1) for n > 0

  16. work • Let W ins (n) be the work for ins(x, L) when x, L are values and L has length n W ins (n) is O(n) • Let W isort (n) be the work for isort(L) when L is a list of length n

  17. work • Let W ins (n) be the work for ins(x, L) when x, L are values and L has length n W ins (n) is O(n) • Let W isort (n) be the work for isort(L) when L is a list of length n W isort (0) = 1 W isort (n) = O(n) + W isort (n-1) for n > 0

  18. work • Let W ins (n) be the work for ins(x, L) when x, L are values and L has length n W ins (n) is O(n) • Let W isort (n) be the work for isort(L) when L is a list of length n W isort (0) = 1 W isort (n) = O(n) + W isort (n-1) for n > 0 W isort (n) is O(n 2 )

  19. work WE CAN DO BETTER! • Let W ins (n) be the work for ins(x, L) THIS IS SLOW! when x, L are values and L has length n W ins (n) is O(n) • Let W isort (n) be the work for isort(L) when L is a list of length n W isort (0) = 1 W isort (n) = O(n) + W isort (n-1) for n > 0 W isort (n) is O(n 2 )

  20. mergesort Conceptually, a merge sort works as follows: 1. Divide the unsorted list into n sublists, each containing 1 element. 2. Repeatedly Merge sublists to produce new sublists until there is only 1 sublist left.

  21. mergesort Conceptually, a merge sort works as follows: 1. Divide the unsorted list into n sublists, each containing 1 element. 2. Repeatedly Merge sublists to produce new sublists until there is only 1 sublist left. Wrong! Wrong! Wrong!

  22. mergesort Conceptually, a merge sort works as follows: 1. Divide the unsorted list into n sublists, each containing 1 element. 2. Repeatedly Merge sublists to produce new sublists until there is only 1 sublist left. Wrong! Wrong! Wrong! Doesn’t say “recursive”...

  23. mergesort Conceptually, a merge sort works as follows: 1. Divide the unsorted list into n sublists, … what’s n? each containing 1 element. 2. Repeatedly Merge sublists to produce new sublists until there is only 1 sublist left. Wrong! Wrong! Wrong! Doesn’t say “recursive”...

  24. mergesort Conceptually, a merge sort works as follows: 1. Divide the unsorted list into n sublists, … what’s n? each containing 1 element. … repeatedly???? 2. Repeatedly Merge sublists to produce new sublists until there is only 1 sublist left. Wrong! Wrong! Wrong! Doesn’t say “recursive”...

  25. mergesort Conceptually, a merge sort works as follows: 1. Divide the unsorted list into n sublists, … what’s n? each containing 1 element. … repeatedly???? 2. Repeatedly Merge sublists to produce new sublists until there is only 1 sublist left. … and then? Wrong! Wrong! Wrong! Doesn’t say “recursive”...

  26. mergesort Conceptually, a merge sort works as follows: 1. Divide the unsorted list into n sublists, … what’s n? each containing 1 element. … repeatedly???? 2. Repeatedly Merge sublists to produce new sublists until there is only 1 sublist left. … and then? What’s the output? How does it relate to the input? Wrong! Wrong! Wrong! Doesn’t say “recursive”...

  27. mergesort A recursive divide-and-conquer algorithm • If list has length 0 or 1, do nothing. • Otherwise, split the list into two shorter lists, sort these two lists, merge the (sorted) results

  28. implementation • First, let’s design helper functions split : int list -> int list * int list merge : int list * int list -> int list

  29. implementation • First, let’s design helper functions split : int list -> int list * int list merge : int list * int list -> int list (what specs should we use?)

  30. implementation • First, let’s design helper functions split : int list -> int list * int list merge : int list * int list -> int list (what specs should we use?) split splits a list into two sublists merge combines two sorted lists into one

  31. implementation • First, let’s design helper functions split : int list -> int list * int list merge : int list * int list -> int list (what specs should we use?) split splits a list into two sublists merge combines two sorted lists into one (a bit imprecise, but we’ll fix that…)

  32. split split : int list -> int list * int list ENSURES split(L) = a pair of lists (A, B) such that length(A) and length(B) differ by at most 1, and A@B is a permutation of L.

  33. split split : int list -> int list * int list ENSURES split(L) = a pair of lists (A, B) such that length(A) and length(B) differ by at most 1, and A@B is a permutation of L. write as length(A) ≈ length(B)

  34. split split : int list -> int list * int list ENSURES split(L) = a pair of lists (A, B) such that length(A) and length(B) differ by at most 1, and A@B is a permutation of L.

  35. split split : int list -> int list * int list ENSURES split(L) = a pair of lists (A, B) such that length(A) and length(B) differ by at most 1, and A@B is a permutation of L. fun split [ ] = ([ ], [ ])

  36. split split : int list -> int list * int list ENSURES split(L) = a pair of lists (A, B) such that length(A) and length(B) differ by at most 1, and A@B is a permutation of L. fun split [ ] = ([ ], [ ]) | split [x] = ([x], [ ])

  37. split split : int list -> int list * int list ENSURES split(L) = a pair of lists (A, B) such that length(A) and length(B) differ by at most 1, and A@B is a permutation of L. fun split [ ] = ([ ], [ ]) | split [x] = ([x], [ ]) | split (x::y::L) =

  38. split split : int list -> int list * int list ENSURES split(L) = a pair of lists (A, B) such that length(A) and length(B) differ by at most 1, and A@B is a permutation of L. fun split [ ] = ([ ], [ ]) | split [x] = ([x], [ ]) | split (x::y::L) = let val (A, B) = split L in

  39. split split : int list -> int list * int list ENSURES split(L) = a pair of lists (A, B) such that length(A) and length(B) differ by at most 1, and A@B is a permutation of L. fun split [ ] = ([ ], [ ]) | split [x] = ([x], [ ]) | split (x::y::L) = let val (A, B) = split L in (x::A, y::B) end

  40. split split : int list -> int list * int list ENSURES split(L) = a pair of lists (A, B) such that length(A) and length(B) differ by at most 1, and A@B is a permutation of L. fun split [ ] = ([ ], [ ]) | split [x] = ([x], [ ]) | split (x::y::L) = let val (A, B) = split L in (x::A, y::B) end note the use of list patterns and pair patterns

  41. split equations For all values x, y : int and L : int list, split [ ] = ([ ], [ ]) split [x] = ([x], [ ]) split (x::y::L) = let val (A, B) = split L in (x::A, y::B) end

  42. split equations For all values x, y : int and L : int list, split [ ] = ([ ], [ ]) split [x] = ([x], [ ]) split (x::y::L) =

  43. split equations For all values x, y : int and L : int list, split [ ] = ([ ], [ ]) split [x] = ([x], [ ]) (x::A, y::B), split (x::y::L) = where (A, B) = split L

  44. split equations For all values x, y : int and L : int list, split [ ] = ([ ], [ ]) split [x] = ([x], [ ]) (x::A, y::B), split (x::y::L) = where (A, B) = split L Can be used to calculate split R for any value R : int list

  45. split equations For all values x, y : int and L : int list, split [ ] = ([ ], [ ]) split [x] = ([x], [ ]) (x::A, y::B), split (x::y::L) = where (A, B) = split L Can be used to calculate split R for any value R : int list split [4,2,1,3] = ([4,1], [2,3])

  46. split equations For all values x, y : int and L : int list, split [ ] = ([ ], [ ]) split [x] = ([x], [ ]) (x::A, y::B), split (x::y::L) = where (A, B) = split L Can be used to calculate split R for any value R : int list split [4,2,1,3] = ([4,1], [2,3]) split [4,2,1] = ([4,1], [2])

  47. For all L:int list, split(L) = a pair of lists (A, B) such that length(A) ≈ length(B) and A@B is a permutation of L. • Proof : by (strong) induction on length of L • Base cases : L = [ ], [x] EASY • Inductive case : L=x::(y::R) R is shorter than L Assume Induction Hypothesis: split(R) = a pair (A ’ , B ’ ) such that length(A ’ ) ≈ length(B ’ ) and A ’ @B ’ is a perm of R. Show that split(x::y::R) = a pair (A, B) such that length(A) ≈ length(B) and A@B is a perm of x::(y::R).

  48. For all L:int list, split(L) = a pair of lists (A, B) such that length(A) ≈ length(B) and A@B is a permutation of L. • Proof : by (strong) induction on length of L • Base cases : L = [ ], [x] split [ ] = ([ ], [ ]) EASY split [x] = ([x], [ ]) • Inductive case : L=x::(y::R) R is shorter than L Assume Induction Hypothesis: split(R) = a pair (A ’ , B ’ ) such that length(A ’ ) ≈ length(B ’ ) and A ’ @B ’ is a perm of R. Show that split(x::y::R) = a pair (A, B) such that length(A) ≈ length(B) and A@B is a perm of x::(y::R).

  49. For all L:int list, split(L) = a pair of lists (A, B) such that length(A) ≈ length(B) and A@B is a permutation of L. • Proof : by (strong) induction on length of L • Base cases : L = [ ], [x] split [ ] = ([ ], [ ]) EASY split [x] = ([x], [ ]) • Inductive case : L=x::(y::R) R is shorter than L Assume Induction Hypothesis: split(R) = a pair (A ’ , B ’ ) such that length(A ’ ) ≈ length(B ’ ) and A ’ @B ’ is a perm of R. Show that split(x::y::R) = a pair (A, B) such that length(A) ≈ length(B) and A@B is a perm of x::(y::R). split (x::y::R) = (x::A ’ , y::B ’ ) length(x::A ’ ) ≈ length(y::B ’ ) (x::A ’ )@(y::B ’ ) is a perm of x::(y::R)

  50. comments • We used strong induction on length of L Reason: split(x::y::R) calls split(R) and length of R is two less than length of x::y::R. • If length L = n > 1 and split(L) = (A, B), A and B are shorter than L If n is even > 1, length A = length B = n div 2 < n. If n is odd > 1, length A = (n div 2) + 1 < n, length B = n div 2 < n.

  51. merge merge : int list * int list -> int list REQUIRES A and B are sorted lists ENSURES merge(A, B) = a sorted perm of A@B

  52. merge merge : int list * int list -> int list REQUIRES A and B are sorted lists ENSURES merge(A, B) = a sorted perm of A@B fun merge (A, [ ]) = A | merge ([ ], B) = B

  53. merge merge : int list * int list -> int list REQUIRES A and B are sorted lists ENSURES merge(A, B) = a sorted perm of A@B fun merge (A, [ ]) = A | merge ([ ], B) = B | merge (x::L, y::R) = case compare(x, y) of

  54. merge merge : int list * int list -> int list REQUIRES A and B are sorted lists ENSURES merge(A, B) = a sorted perm of A@B fun merge (A, [ ]) = A | merge ([ ], B) = B | merge (x::L, y::R) = case compare(x, y) of LESS => x :: merge(L, y::R)

  55. merge merge : int list * int list -> int list REQUIRES A and B are sorted lists ENSURES merge(A, B) = a sorted perm of A@B fun merge (A, [ ]) = A | merge ([ ], B) = B | merge (x::L, y::R) = case compare(x, y) of LESS => x :: merge(L, y::R) | EQUAL => x :: y :: merge(L, R)

  56. merge merge : int list * int list -> int list REQUIRES A and B are sorted lists ENSURES merge(A, B) = a sorted perm of A@B fun merge (A, [ ]) = A | merge ([ ], B) = B | merge (x::L, y::R) = case compare(x, y) of LESS => x :: merge(L, y::R) | EQUAL => x :: y :: merge(L, R) | GREATER => y :: merge(x::L, R)

  57. merge merge : int list * int list -> int list REQUIRES A and B are sorted lists ENSURES merge(A, B) = a sorted perm of A@B fun merge (A, [ ]) = A | merge ([ ], B) = B | merge (x::L, y::R) = case compare(x, y) of LESS => x :: merge(L, y::R) | EQUAL => x :: y :: merge(L, R) | GREATER => y :: merge(x::L, R) We need a 3-way branch, so cased comparison is better than nested if-then-else

  58. merge equations For all values x, y : int and A, B : int list, merge (A, [ ]) = A merge ([ ], B) = B merge (x::A, y::B) = case compare(x, y) of LESS => x :: merge(A, y::B) | EQUAL => x :: y :: merge(A, B) | GREATER => y :: merge(x::A, B)

  59. merge equations For all values x, y : int and A, B : int list, merge (A, [ ]) = A merge ([ ], B) = B

  60. merge equations For all values x, y : int and A, B : int list, merge (A, [ ]) = A merge ([ ], B) = B if x<y merge (x::A, y::B) = x :: merge(A, y::B) if x=y = x :: y :: merge(A, B) if x>y = y :: merge(x::A, B)

  61. merge equations For all values x, y : int and A, B : int list, merge (A, [ ]) = A merge ([ ], B) = B if x<y merge (x::A, y::B) = x :: merge(A, y::B) if x=y = x :: y :: merge(A, B) if x>y = y :: merge(x::A, B) Can be used to evaluate merge(L, R) for all values L, R : int list

  62. merge equations For all values x, y : int and A, B : int list, merge (A, [ ]) = A merge ([ ], B) = B if x<y merge (x::A, y::B) = x :: merge(A, y::B) if x=y = x :: y :: merge(A, B) if x>y = y :: merge(x::A, B) Can be used to evaluate merge(L, R) for all values L, R : int list merge([1,4], [2,3]) = [1,2,3,4]

  63. correctness? fun merge (A, [ ]) = A | merge ([ ], B) = B | merge (x::L, y::R) = case compare(x, y) of LESS => x :: merge(L, y::R) | EQUAL => x :: y :: merge(L, R) | GREATER => y :: merge(x::L, R) How do we prove this function satisfies the spec? • Induction, but on on what ? - in base cases, at least one list is empty - in recursive calls, one or both is shorter

  64. correctness? fun merge (A, [ ]) = A | merge ([ ], B) = B | merge (x::L, y::R) = case compare(x, y) of LESS => x :: merge(L, y::R) | EQUAL => x :: y :: merge(L, R) | GREATER => y :: merge(x::L, R) How do we prove this function satisfies the spec? • Induction, but on on what ? The product of list lengths! - in base cases, at least one list is empty - in recursive calls, one or both is shorter

  65. correctness For all sorted lists A and B, merge(A, B) = a sorted permutation of A@B. Proof : strong induction on product of lengths of A, B. • Base cases : (A, [ ]) and ([ ], B). (i) Show: if A is sorted, merge(A, [ ]) = a sorted perm of A@[ ]. (ii) Show: if B is sorted, merge([ ], B) = a sorted perm of [ ]@B. • Inductive case : (x::A, y::B) Assume IH: for all pairs of sorted lists (A ’ , B ’ ) with smaller product of lengths than (x::A, y::B), merge(A ’ , B ’ ) = a sorted perm of A ’ @B ’ . Show: if x::A and y::B are sorted, then merge(x::A, y::B) = a sorted perm of (x::A)@(y::B). Exercise: fill in the details!

  66. msort • We proved that split and merge are correct split : int list -> int list * int list ENSURES split L = a pair of lists (A, B) such that length(A) ≈ length(B) and A@B is a perm of L merge : int list * int list -> int list REQUIRES A and B are sorted lists ENSURES merge(A, B) = a sorted perm of A@B • Now let’s use them to define msort msort : int list -> int list ENSURES msort L = a sorted perm of L

  67. msort msort : int list -> int list ENSURES msort(L) = a sorted perm of L

  68. msort msort : int list -> int list ENSURES msort(L) = a sorted perm of L fun msort [ ] = [ ]

Recommend

LSH for 2 distances Lecture 15 October 15, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1 /

LSH for 2 distances Lecture 15 October 15, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1 /

CS 498ABD: Algorithms for Big Data LSH for 2 distances Lecture 15 October 15, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1 / 21 LSH Approach for Approximate NNS Use locality-sensitive hashing to solve simplified decision problem

849 views • 35 slides
LECTURE 17 COMMENTS, DOCUMENTATION, ETC. MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 6 due

LECTURE 17 COMMENTS, DOCUMENTATION, ETC. MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 6 due

LECTURE 17 COMMENTS, DOCUMENTATION, ETC. MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 6 due Monday Project 2 due Friday Oct 9 Use the autograder early and oen / CONTINUE This is a loose end from our discussion of loops in Lecture 7

537 views • 17 slides
LECTURE 17 COMMENTS, DOCUMENTATION, ETC. MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 6

LECTURE 17 COMMENTS, DOCUMENTATION, ETC. MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 6

LECTURE 17 COMMENTS, DOCUMENTATION, ETC. MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 6 due Monday Project 2 due Friday Oct 9 Use the autograder early and oen / CONTINUE This is a loose end from our discussion of loops in Lecture 7

773 views • 17 slides
Locality Sensitive Hashing Lecture 14 October 13, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1

Locality Sensitive Hashing Lecture 14 October 13, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1

CS 498ABD: Algorithms for Big Data Locality Sensitive Hashing Lecture 14 October 13, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1 / 25 Near-Neighbor Search Collection of n points P = { x 1 , . . . , x n } in a metric space. NNS: preprocess P

693 views • 45 slides
LINUX AND C++ UNDER ATTACK! CS4414 Lecture 24 CORNELL CS4414 - FALL 2020. 1 IDEA MAP FOR TODAY

LINUX AND C++ UNDER ATTACK! CS4414 Lecture 24 CORNELL CS4414 - FALL 2020. 1 IDEA MAP FOR TODAY

Professor Ken Birman LINUX AND C++ UNDER ATTACK! CS4414 Lecture 24 CORNELL CS4414 - FALL 2020. 1 IDEA MAP FOR TODAY SYN ACK attacks Stack Overflow Exploits Kernel Level Exploits Key Theft. Covert Channels CORNELL CS4414 - FALL 2020. 2

919 views • 50 slides
Quantiles and Selection Lecture 16 October 20, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1 /

Quantiles and Selection Lecture 16 October 20, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1 /

CS 498ABD: Algorithms for Big Data Quantiles and Selection Lecture 16 October 20, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1 / 31 Part I Introduction Chandra (UIUC) CS498ABD 2 Fall 2020 2 / 31 Selection Selection: Given a sequence of

902 views • 66 slides
15-150 Fall 2020 Stephen Brookes Lecture 3 Patterns and specifications Patterns and

15-150 Fall 2020 Stephen Brookes Lecture 3 Patterns and specifications Patterns and

15-150 Fall 2020 Stephen Brookes Lecture 3 Patterns and specifications Patterns and specifications Patterns and specifications Advice After class, study slides and lecture notes. Start homework early, plan to finish on time.

1.34k views • 98 slides
15-150 Fall 2020 Stephen Brookes LECTURE 2 Types, expressions and declarations Make a plan

15-150 Fall 2020 Stephen Brookes LECTURE 2 Types, expressions and declarations Make a plan

15-150 Fall 2020 Stephen Brookes LECTURE 2 Types, expressions and declarations Make a plan Class, Labs (remote) Study lecture material Homework Start as early as possible, end on time Dont cheat ask us if you need

497 views • 35 slides
Functions Lecture 7 COP 3014 Fall 2020 October 1, 2020 Functions A function is a reusable

Functions Lecture 7 COP 3014 Fall 2020 October 1, 2020 Functions A function is a reusable

Functions Lecture 7 COP 3014 Fall 2020 October 1, 2020 Functions A function is a reusable portion of a program, sometimes called a procedure or subroutine. Like a mini-program (or subprogram) in its own right Can take in special inputs

782 views • 17 slides
Control Structures Lecture 4 COP 3014 Fall 2020 September 10, 2020 Control Flow Control flow

Control Structures Lecture 4 COP 3014 Fall 2020 September 10, 2020 Control Flow Control flow

Control Structures Lecture 4 COP 3014 Fall 2020 September 10, 2020 Control Flow Control flow refers to the specification of the order in which the individual statements, instructions or function calls of an imperative program are executed or

333 views • 19 slides
Algorithms for NLP CS 11-711 Fall 2020 Lecture 8: Viterbi, discriminative sequence labeling,

Algorithms for NLP CS 11-711 Fall 2020 Lecture 8: Viterbi, discriminative sequence labeling,

Algorithms for NLP CS 11-711 Fall 2020 Lecture 8: Viterbi, discriminative sequence labeling, NER Emma Strubell Announcements Project 1 is due tomorrow! You may submit up to 3 days late (out of a budget of 5 total for the semester).

890 views • 88 slides
Graph Streaming and Sketching Lecture 19 Nov 5, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1

Graph Streaming and Sketching Lecture 19 Nov 5, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1

CS 498ABD: Algorithms for Big Data Graph Streaming and Sketching Lecture 19 Nov 5, 2020 Chandra (UIUC) CS498ABD 1 Fall 2020 1 / 1 Graphs G = ( V , E ) is an undirected graph n = | V | and m = | E | Edges e 1 , e 2 , . . . , e m seen as a

929 views • 50 slides
CONSTANT EXPRESSIONS IN C++ CS4414 Lecture 9 CORNELL CS4414 - FALL 2020. 1 IDEA MAP FOR TODAY

CONSTANT EXPRESSIONS IN C++ CS4414 Lecture 9 CORNELL CS4414 - FALL 2020. 1 IDEA MAP FOR TODAY

Professor Ken Birman CONSTANT EXPRESSIONS IN C++ CS4414 Lecture 9 CORNELL CS4414 - FALL 2020. 1 IDEA MAP FOR TODAY In Lecture 8 we learned that C++ can Even without those long lists of advice, this same issue automatically compile to

738 views • 60 slides
LECTURE 7 FOR AND WHILE LOOPS MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 3 available

LECTURE 7 FOR AND WHILE LOOPS MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 3 available

LECTURE 7 FOR AND WHILE LOOPS MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 3 available Projects 0 and 1 are out Project 1 autograder to be opened soon / COMPARING SEQUENCES We talked about comparison operators , , , . &gt; &gt;=

684 views • 22 slides
Loops! Loops! Loops! Lecture 5 COP 3014 Fall 2020 September 17, 2020 Repetition Statements

Loops! Loops! Loops! Lecture 5 COP 3014 Fall 2020 September 17, 2020 Repetition Statements

Loops! Loops! Loops! Lecture 5 COP 3014 Fall 2020 September 17, 2020 Repetition Statements Repetition statements are called loops, and are used to repeat the same code mulitple times in succession. The number of repetitions is based on

284 views • 15 slides
SYNCHRONIZATION PRIMITIVES CS4414 Lecture 14 CORNELL CS4414 - FALL 2020. 1 IDEA MAP FOR

SYNCHRONIZATION PRIMITIVES CS4414 Lecture 14 CORNELL CS4414 - FALL 2020. 1 IDEA MAP FOR

Professor Ken Birman SYNCHRONIZATION PRIMITIVES CS4414 Lecture 14 CORNELL CS4414 - FALL 2020. 1 IDEA MAP FOR MULTIPLE LECTURES! Reminder: Thread Concept C++ mutex objects. Atomic data types. Lightweight vs. Heavyweight Race Conditions,

1.3k views • 53 slides
LECTURE 25 OBJECT-ORIENTED PROGRAMMING 3 INHERITANCE MCS 260 Fall 2020 David Dumas /

LECTURE 25 OBJECT-ORIENTED PROGRAMMING 3 INHERITANCE MCS 260 Fall 2020 David Dumas /

LECTURE 25 OBJECT-ORIENTED PROGRAMMING 3 INHERITANCE MCS 260 Fall 2020 David Dumas / REMINDERS Work on Project 3 ASAP. Do not delay! Worksheet 9 available Quiz 9 soon / GOALS Connue working on Rectangle and Circle classes Add

152 views • 13 slides
15-150 Fall 2020 Lecture 18 Sequences and parallelism Stephen Brookes announcements

15-150 Fall 2020 Lecture 18 Sequences and parallelism Stephen Brookes announcements

15-150 Fall 2020 Lecture 18 Sequences and parallelism Stephen Brookes announcements Election Day! TAs will be posting lab solution videos (canvas, Thursday or Friday) TAs offer NEW weekly REVIEW SESSION (Thursday, 6:30pm Pittsburgh

842 views • 80 slides
15-150 Fall 2020 Stephen Brookes Lecture 13 Backtracking with continuations correct code may not

15-150 Fall 2020 Stephen Brookes Lecture 13 Backtracking with continuations correct code may not

15-150 Fall 2020 Stephen Brookes Lecture 13 Backtracking with continuations correct code may not be fast Yogi wants both! case study Direct - and continuation -style programming two di ff erent ways to solve the same problem

688 views • 51 slides
LECTURE 10 DICTIONARIES MCS 260 Fall 2020 David Dumas / REMINDERS Work on: Project 1 (due

LECTURE 10 DICTIONARIES MCS 260 Fall 2020 David Dumas / REMINDERS Work on: Project 1 (due

LECTURE 10 DICTIONARIES MCS 260 Fall 2020 David Dumas / REMINDERS Work on: Project 1 (due Friday, 6pm central) Worksheet 4 Quiz 4 Docstrings now required for all functions &amp; files Come to Tue/Thu discussion ready to share screen and

561 views • 15 slides
The Manhattan Project - Personalities and Problems Fromm Institute Fall 2020

The Manhattan Project - Personalities and Problems Fromm Institute Fall 2020

11/5/20 The Manhattan Project - Personalities and Problems Fromm Institute Fall 2020 bebo.white@gmail.com Lecture 6 submitted questions/comments from lecture 5 1 11/5/20 revisiting the labs mission (and our course vision) Given

554 views • 30 slides
Algorithms for NLP CS 11-711 Fall 2020 Lecture 1: Introduction Emma Strubell Welcome! Emma

Algorithms for NLP CS 11-711 Fall 2020 Lecture 1: Introduction Emma Strubell Welcome! Emma

Algorithms for NLP CS 11-711 Fall 2020 Lecture 1: Introduction Emma Strubell Welcome! Emma Yulia Bob Sanket Han Jiateng 2 Course website: http://demo.clab.cs.cmu.edu/11711fa20/ Piazza: https://piazza.com/cmu/fall2020/11711/ 3

1.34k views • 65 slides
Distributed Machine Learning and the Parameter Server CS4787 Lecture 20 Fall 2020 Course

Distributed Machine Learning and the Parameter Server CS4787 Lecture 20 Fall 2020 Course

Distributed Machine Learning and the Parameter Server CS4787 Lecture 20 Fall 2020 Course Logistics and Grading Projects PA4 autograder has worked only intermittently Due to some fascinating issues with SIMD instructions! So we

520 views • 39 slides
LECTURE 18 MORE ON BOOLEANS AND ITERABLES MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 6

LECTURE 18 MORE ON BOOLEANS AND ITERABLES MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 6

LECTURE 18 MORE ON BOOLEANS AND ITERABLES MCS 260 Fall 2020 David Dumas / REMINDERS Quiz 6 due today Project 2 due Friday at 6:00pm central / NONE None is the only value of type NoneType . It represents the absence of a value, in cases

202 views • 17 slides

More recommend