grabbing section 2

Merge branch 'main' of github.com:cs61/cs61-sections

Author: kascrizzi

datareps1/flapmap1.cc

@@ -0,0 +1,7 @@
+#include "flapmap.hh"
+
+int main() {
+	printf("Hi! This program is a placeholder.\n");
+	printf("If you want to experiment with `flapmap` code, either edit `flapmap1.cc` and `make`,\n");
+	printf("or make a file called `flapmapNN.cc` and `make`.\n");
+}

datareps1/solutions/flapmaps5.cc

@@ -29,13 +29,12 @@ bool can_coalesce_up(flapmap_iter it) {
 }
 
 void coalesce_up(flapmap_iter it) {
-    if (can_coalesce_up(it)) {
-        auto next = it;
-        ++next;
-        it->second.duration += next->second.duration;
-        it->second.flapcount += next->second.flapcount;
-        flapmap.erase(next);
-    }
+    assert(can_coalesce_up(it));
+    auto next = it;
+    ++next;
+    it->second.duration += next->second.duration;
+    it->second.flapcount += next->second.flapcount;
+    flapmap.erase(next);
 }
 
 bool can_coalesce_down(flapmap_iter it) {

datareps1/solutions/flapmaps6.cc

@@ -29,13 +29,12 @@ bool can_coalesce_up(flapmap_iter it) {
 }
 
 void coalesce_up(flapmap_iter it) {
-    if (can_coalesce_up(it)) {
-        auto next = it;
-        ++next;
-        it->second.duration += next->second.duration;
-        it->second.flapcount += next->second.flapcount;
-        flapmap.erase(next);
-    }
+    assert(can_coalesce_up(it));
+    auto next = it;
+    ++next;
+    it->second.duration += next->second.duration;
+    it->second.flapcount += next->second.flapcount;
+    flapmap.erase(next);
 }
 
 bool can_coalesce_down(flapmap_iter it) {

datareps2/.gitignore

@@ -0,0 +1,7 @@
+membug[0-9]
+membug[0-9][0-9]
+[sbl][0-9]
+[sbl][0-9][0-9]
+ll[0-9]
+ll[0-9][0-9]
+hulk

datareps2/GNUmakefile

@@ -0,0 +1,35 @@
+# build all programs with names like `[sbl][0-9] [sbl][0-9][0-9]`
+XPROGRAMS = $(patsubst %.cc,%,$(wildcard [sbl][0-9].cc [sbl][0-9][0-9].cc ll[0-9].cc ll[0-9][0-9].cc))
+PROGRAMS = $(XPROGRAMS) hulk
+all: $(PROGRAMS)
+
+ALLPROGRAMS = $(PROGRAMS) inv testinsert0 greet1
+
+include ../common/rules.mk
+
+LIBS = -lm
+
+
+# Rules for making object files (i.e., parts of executables)
+# from source files
+
+%.o: %.cc $(BUILDSTAMP)
+	$(CXX) $(CPPFLAGS) $(CXXFLAGS) $(DEPCFLAGS) $(O) -o $@ -c $<
+
+
+# Rules for making executables (runnable programs) from object files
+
+$(XPROGRAMS): \
+%: %.o hexdump.o
+	$(CXX) $(CXXFLAGS) $(LDFLAGS) $(O) -o $@ $^ $(LIBS)
+
+hulk: \
+%: %.o hexdump.o
+	$(CXX) $(CXXFLAGS) $(LDFLAGS) $(O) -o $@ $^ $(LIBS)
+
+
+clean:
+	rm -rf $(ALLPROGRAMS) *.o $(DEPSDIR)
+	rm -rf $(wildcard [sbl][0-9] [sbl][0-9][0-9] ll[0-9] ll[0-9][0-9])
+
+.PHONY: all clean

datareps2/b1.cc

@@ -0,0 +1,9 @@
+#include <cstdio>
+
+const char* f(int) {
+    return "example";
+}
+
+int main() {
+    printf("%s\n", f(2));
+}

datareps2/b2.cc

@@ -0,0 +1,10 @@
+#include <cstdio>
+
+const char* f(int) {
+    char buf[100] = "example";
+    return buf;
+}
+
+int main() {
+    printf("%s\n", f(2));
+}

datareps2/b3.cc

@@ -0,0 +1,10 @@
+#include <cstdio>
+
+const char* f(int) {
+    char buf[100] = "example";
+    return buf;
+}
+
+int main() {
+    printf("%p\n", f(2));
+}

datareps2/b4.cc

@@ -0,0 +1,14 @@
+#include <cstdio>
+#include <cstring>
+
+const char* f(int) {
+    char* buf = new char[100];
+    strcpy(buf, "example");
+    return buf;
+}
+
+int main() {
+    const char* s = f(2);
+    printf("%s\n", s);
+    delete[] s;
+}

datareps2/b5.cc

@@ -0,0 +1,14 @@
+#include <cstdio>
+#include <cstring>
+
+const char* f(int) {
+    char* buf = new char[100];
+    strcpy(buf, "example");
+    return buf;
+}
+
+int main() {
+    const char* s = f(2);
+    delete[] s;
+    printf("%s\n", s);
+}

datareps2/b6.cc

@@ -0,0 +1,14 @@
+#include <cstdio>
+#include <cstring>
+
+const char* f(int) {
+    char* buf = new char[strlen("example")];
+    strcpy(buf, "example");
+    return buf;
+}
+
+int main() {
+    const char* s = f(2);
+    printf("%s\n", s);
+    delete[] s;
+}

datareps2/hexdump.cc

@@ -0,0 +1,43 @@
+#include "hexdump.hh"
+#include <cassert>
+
+static void fhexdump_ascii(FILE* f, const unsigned char* p, size_t pos);
+
+void hexdump(const void* ptr, size_t size, const char* objname) {
+    fhexdump_at(stdout, (size_t) ptr, ptr, size, objname);
+}
+
+void fhexdump(FILE* f, const void* ptr, size_t size, const char* objname) {
+    fhexdump_at(f, (size_t) ptr, ptr, size, objname);
+}
+
+void fhexdump_at(FILE* f, size_t first_offset, const void* ptr, size_t size,
+                 const char* objname) {
+    const char* addrfmt = objname ? "  %08zx" : "%08zx";
+    const unsigned char* p = (const unsigned char*) ptr;
+    if (objname != nullptr) {
+        fprintf(f, "%s:\n", objname);
+    }
+    for (size_t i = 0; i != size; ++i) {
+        if (i % 16 == 0) {
+            fprintf(f, addrfmt, first_offset + i);
+        }
+        fprintf(f, "%s%02x", (i % 8 == 0 ? "  " : " "), (unsigned) p[i]);
+        if (i % 16 == 15 || i == size - 1) {
+            fhexdump_ascii(f, p, i);
+        }
+    }
+}
+
+static void fhexdump_ascii(FILE* f, const unsigned char* p, size_t pos) {
+    // Print an ASCII report that ends with byte p[pos].
+    // The first byte printed is p[first], where first is the max multiple
+    // of 16 having `first < pos`. The report starts at column 51.
+    size_t first = pos - (pos % 16);  // first char to print
+    int n = pos + 1 - first;          // # chars to print
+    char buf[17];
+    for (size_t i = first; i != first + n; ++i) {
+        buf[i - first] = (p[i] >= 32 && p[i] < 127 ? p[i] : '.');
+    }
+    fprintf(f, "%*s|%.*s|\n", 51 - (3 * n + (n > 8)), "", n, buf);
+}

datareps2/hexdump.hh

@@ -0,0 +1,47 @@
+#ifndef CS61_HEXDUMP_HH
+#define CS61_HEXDUMP_HH
+#include <cstdio>
+#include <cassert>
+#include <cstdlib>
+
+// hexdump(ptr, size)
+//    Print a hexdump of the `size` bytes of data starting at `ptr`
+//    to the standard output. The hexdump format is:
+//    XXXXXXXX  BB BB BB BB BB BB BB BB  BB BB BB BB BB BB BB BB  |CCCCCCCCCCCCCCCC|
+//    where XXXXXXXX is the address of the first byte in the line,
+//    the BBs are hexadecimal values of those bytes, and the Cs show
+//    the printable ASCII characters corresponding to those bytes
+//    (`.` is displayed for non-printable characters).
+void hexdump(const void* ptr, size_t size, const char* objname = nullptr);
+
+// hexdump_object(object)
+//    Like hexdump(&object, sizeof(object)).
+#define hexdump_object(object) hexdump(&(object), sizeof((object)))
+
+// hexdump_named_object(object)
+//    Like hexdump(&object, sizeof(object)), but also print a header with
+//    the name of `object`.
+#define hexdump_named_object(object) hexdump(&(object), sizeof((object)), #object)
+
+
+// fhexdump(f, ptr, size)
+//    Like `hexdump(ptr, size)`, but print to file `f` rather than standard
+//    output.
+void fhexdump(FILE* f, const void* ptr, size_t size, const char* objname = nullptr);
+
+// fhexdump_object(f, object)
+//    Like `fhexdump(f, &object, sizeof(object))`.
+#define fhexdump_object(f, object) fhexdump((f), &(object), sizeof((object)))
+
+// fhexdump_named_object(f, object)
+//    Like `fhexdump(f, &object, sizeof(object))`.
+#define fhexdump_named_object(f, object) fhexdump((f), &(object), sizeof((object)), #object)
+
+
+// fhexdump_at(f, first_offset, ptr, size)
+//    Like fhexdump, but start with offset `first_offset` instead of the
+//    address of `ptr`.
+void fhexdump_at(FILE* f, size_t first_offset, const void* ptr, size_t size,
+				 const char* objname = nullptr);
+
+#endif

datareps2/hulk.cc

@@ -0,0 +1,42 @@
+#include <cctype>
+#include <cstdio>
+#include <cstring>
+
+const char* hulk_players[] = {
+    "RUFFALO",
+    "BANA",
+    "FERRIGNO",
+    "MIYAUCHI"
+};
+
+void hulk_greeting(const char* name) {
+    char uc_name[16];
+
+    // make uppercase version of `name`
+    for (size_t i = 0; name[i] != 0; ++i) {
+        uc_name[i] = toupper(name[i]);
+    }
+    uc_name[strlen(name)] = 0;
+    printf("HULK SAY HELLO TO %s\n", uc_name);
+
+    // find player
+    for (size_t i = 0; hulk_players[i] != nullptr; ++i) {
+        if (strcmp(hulk_players[i], uc_name) == 0) {
+            printf("YOU GOOD ACTOR\n");
+            return;
+        }
+    }
+    printf("YOU NO PLAY HULK! HULK SMASH\n");
+}
+
+
+int main(int argc, char* argv[]) {
+    // Run `./hulk` to call `hulk_greeting("Ruffalo")`,
+    // or `./hulk NAME` to call `hulk_greeting(NAME)`.
+    if (argc > 1) {
+        hulk_greeting(argv[1]);
+    } else {
+        hulk_greeting("Ruffalo");
+    }
+    return 0;
+}

datareps2/ll.hh

@@ -0,0 +1,20 @@
+#ifndef DATAREPS2_LL_HH
+#define DATAREPS2_LL_HH
+
+struct node {
+	int value;
+	node* prev;
+	node* next;
+};
+
+extern node* head;
+
+inline node* find(int v) {
+    node* trav = head;
+    while (trav && trav->value != v) {
+        trav = trav->next;
+    }
+    return trav;
+}
+
+#endif

datareps2/ll1.cc

@@ -0,0 +1,9 @@
+#include "ll.hh"
+
+node* head = nullptr;
+
+int main() {
+	printf("Hi! This program is a placeholder.\n");
+	printf("If you want to experiment with linked list code, either edit `ll1.cc` and `make`,\n");
+	printf("or make a file called `llNN.cc` and `make`.\n");
+}

datareps2/ll6.cc

@@ -0,0 +1,25 @@
+#include "ll.hh"
+
+node* head = nullptr;
+
+// Insert node `n` into the list immediately before node `before`.
+// If `before == nullptr`, append `n` to the list.
+void insert(node* before, node* n) {
+    if (!before) {
+        node* prev = head;
+        while (prev->next != nullptr) {
+            prev = prev->next;
+        }
+        n->prev = prev;
+        n->next = nullptr;
+        prev->next = n;
+    } else {
+        n->prev = before->prev;
+        n->next = before;
+        before->prev = n;
+    }
+}
+
+int main() {
+	// Your code here to test `insert`
+}

datareps2/s1.cc

@@ -0,0 +1,9 @@
+#include <cstdio>
+
+int f(int x) {
+    return x;
+}
+
+int main() {
+    printf("%d\n", f(2));
+}

datareps2/s2.cc

@@ -0,0 +1,12 @@
+#include <cstdio>
+
+int global = 0;
+
+int* f(int) {
+    return &global;
+}
+
+int main() {
+    int* ptr = f(2);
+    printf("%d\n", *ptr);
+}

datareps2/s3.cc

@@ -0,0 +1,10 @@
+#include <cstdio>
+
+int* f(int x) {
+    return &x;
+}
+
+int main() {
+    int* ptr = f(2);
+    printf("%d\n", *ptr);
+}