add matrix exercise (#303)

by: oxe-i <[email protected]>

Author: oxe-i

config.json

@@ -429,6 +429,14 @@
           "structs"
         ]
       },
+      {
+        "slug": "matrix",
+        "name": "Matrix",
+        "uuid": "0c830b67-80b8-447a-a86d-22775e7d5ce4",
+        "practices": [],
+        "prerequisites": [],
+        "difficulty": 4
+      },
       {
         "slug": "phone-number",
         "name": "Phone Number",

exercises/practice/matrix/.docs/instructions.md

@@ -0,0 +1,38 @@
+# Instructions
+
+Given a string representing a matrix of numbers, return the rows and columns of that matrix.
+
+So given a string with embedded newlines like:
+
+```text
+9 8 7
+5 3 2
+6 6 7
+```
+
+representing this matrix:
+
+```text
+    1  2  3
+  |---------
+1 | 9  8  7
+2 | 5  3  2
+3 | 6  6  7
+```
+
+your code should be able to spit out:
+
+- A list of the rows, reading each row left-to-right while moving top-to-bottom across the rows,
+- A list of the columns, reading each column top-to-bottom while moving from left-to-right.
+
+The rows for our example matrix:
+
+- 9, 8, 7
+- 5, 3, 2
+- 6, 6, 7
+
+And its columns:
+
+- 9, 5, 6
+- 8, 3, 6
+- 7, 2, 7

exercises/practice/matrix/.meta/config.json

@@ -0,0 +1,19 @@
+{
+  "authors": [
+    "oxe-i"
+  ],
+  "files": {
+    "solution": [
+      "matrix.asm"
+    ],
+    "test": [
+      "matrix_test.c"
+    ],
+    "example": [
+      ".meta/example.asm"
+    ]
+  },
+  "blurb": "Given a string representing a matrix of numbers, return the rows and columns of that matrix.",
+  "source": "Exercise by the JumpstartLab team for students at The Turing School of Software and Design.",
+  "source_url": "https://turing.edu"
+}

exercises/practice/matrix/.meta/example.asm

@@ -0,0 +1,199 @@
+section .text
+global row
+global column
+
+%macro store_num 0
+    inc r8 ; increments counter
+
+    mov eax, r10d ; eax now holds number
+
+    xor rdx, rdx
+    mov r10d, 10
+    div r10d ; divide by 10 to account for an extra multiplication in accumulating loop
+
+    cmp r9b, 1
+    jne %%store_num ; if sign flag is not set, proceed with storing it
+    ; otherwise negate num before storing it
+
+    neg eax
+
+%%store_num:
+    stosd ; store number in buffer
+%endmacro
+
+; size_t row(int32_t *buffer, const char *input, size_t index);
+row:
+	; rdi - output int32_t buffer
+    ; rsi - input string
+    ; rdx - index from the row to be extracted as a uint64_t
+    ; return is the size of buffer in rax
+
+    ; The algorithm is:
+    ;
+    ; The input string is looped over until rdx is 1.
+    ; Each newline marks the end of a row and decreases rdx by 1.
+    ;
+    ; Then the desired row is looped over and each number is accumulated in r10.
+    ; Each space marks the end of a num
+    ; and a newline or a NULL marks the end of the entire row.
+    ;
+    ; At the beginning of each number, there's a check for the sign char.
+    ;
+    ; At the end of each number and of the row, the accumulator is adjusted for sign
+    ; and divided by 10 to account for an extra multiplication in the loop
+    ; then it's stored in the output buffer.
+    ; There's also a counter for the numbers, for returning at the end.
+    ;
+    ; If it's not the end of the row, the loop continues
+    ; It it is, the counter is moved to rax
+
+    xor r8, r8 ; counter
+.row_main_loop:
+    cmp rdx, 1 ; matrix is 1-indexed
+    je .row_copy ; found desired row
+
+.find_next_row:
+    lodsb
+
+    cmp al, 10 ; newline
+    jne .find_next_row
+
+    dec rdx ; one row less
+    jmp .row_main_loop
+
+.row_copy:
+    xor r9, r9
+    xor r10, r10 ; accumulator for the number
+    xor rax, rax
+.check_sign:
+    lodsb
+    cmp al, '-'
+    sete r9b ; sign flag
+    je .prepare_next_iteration
+.row_copy_loop:
+    cmp al, 10
+    je .end_copy ; newline marks end of the row
+
+    cmp al, 0
+    je .end_copy ; NULL marks end of the row
+
+    cmp al, ' '
+    je .end_num ; space marks end of the num
+    ; otherwise the number continues
+
+    sub al, '0' ; fromEnum
+
+    add r10, rax ; accumulates
+    imul r10, r10, 10 ; multiplies by 10 to accumulate in next iteration
+                      ; accumulator must be adjusted for an extra multiplication at the end
+
+.prepare_next_iteration:
+    lodsb
+    jmp .row_copy_loop
+
+.end_num:
+    store_num ; macro
+    jmp .row_copy
+
+.end_copy:
+    store_num ; macro
+    mov rax, r8 ; moves counter to rax for returning
+
+	ret
+
+; size_t column(int32_t *buffer, const char *input, size_t index);
+column:
+	; rdi - output int32_t buffer
+    ; rsi - input string
+    ; rdx - index from the column to be extracted as a uint64_t
+    ; return is the size of buffer in rax
+
+    ; The algorithm is:
+    ; The input string is looped over until rdx is 1, which marks the desired column.
+    ;
+    ; As this process is repeated for each new element, rdx is saved in r11 beforehand.
+    ;
+    ; Each space marks the end of a number and decreases rdx by 1,
+    ; the NULL char marks the end of the string and returns the function.
+    ;
+    ; Once found the element in the desired column, it's looped over and accumulated in r10.
+    ; At the beginning of each number, there's a check for the sign char.
+    ;
+    ; At the end of each number, the accumulator is adjusted for sign
+    ; and divided by 10 to account for an extra multiplication in the loop
+    ; then it's stored in the output buffer.
+    ; There's also a counter for the numbers, for returning at the end.
+    ;
+    ; A space, a newline or NULL marks the end of a number.
+    ; In case of a NULL, the number is stored and the function returns right away.
+    ; In the other cases, the number is stored and rdx is restored to loop over the input string
+    ; in search of the next desired element.
+
+    xor r8, r8 ; counter
+    mov r11, rdx
+.column_main_loop:
+    cmp rdx, 1 ; matrix is 1-indexed
+    je .elem_copy ; found desired column
+
+.find_next_elem:
+    lodsb
+
+    cmp al, 0
+    je .return ; NULL marks end of input and function returns right away
+
+    cmp al, ' ' ; num separator
+    jne .find_next_elem
+
+    dec rdx ; decreases counter until desired column
+    jmp .column_main_loop
+
+.elem_copy:
+    xor r10, r10 ; accumulator for the number
+    xor rax, rax
+.check_sign:
+    lodsb
+    cmp al, '-'
+    sete r9b ; sign flag
+    je .prepare_next_iteration
+.elem_copy_loop:
+    cmp al, 10
+    je .end_num ; newline marks end of the number
+
+    cmp al, ' '
+    je .end_num ; space marks end of the number
+
+    cmp al, 0
+    je .end_copy ; NULL marks end of the string
+
+    sub al, '0' ; fromEnum
+
+    add r10, rax ; accumulates
+    imul r10, r10, 10 ; multiplies by 10 to accumulate in next iteration
+                      ; accumulator must be adjusted for an extra multiplication at the end
+
+.prepare_next_iteration:
+    lodsb
+    jmp .elem_copy_loop
+
+.end_num:
+    ; here it's end of current number, but not of the string
+
+    store_num ; macro
+
+    mov rdx, r11 ; as the string doesn't end here, there might be another row
+    jmp .column_main_loop
+
+.end_copy:
+    ; here it's end of the number and of the input string
+    ; so the number must be stored and the function should return soon after
+
+    store_num ; macro
+
+.return:
+    mov rax, r8 ; moves counter to rax for returning
+
+	ret
+
+%ifidn __OUTPUT_FORMAT__,elf64
+section .note.GNU-stack noalloc noexec nowrite progbits
+%endif

exercises/practice/matrix/.meta/tests.toml

@@ -0,0 +1,34 @@
+# This is an auto-generated file.
+#
+# Regenerating this file via `configlet sync` will:
+# - Recreate every `description` key/value pair
+# - Recreate every `reimplements` key/value pair, where they exist in problem-specifications
+# - Remove any `include = true` key/value pair (an omitted `include` key implies inclusion)
+# - Preserve any other key/value pair
+#
+# As user-added comments (using the # character) will be removed when this file
+# is regenerated, comments can be added via a `comment` key.
+
+[ca733dab-9d85-4065-9ef6-a880a951dafd]
+description = "extract row from one number matrix"
+
+[5c93ec93-80e1-4268-9fc2-63bc7d23385c]
+description = "can extract row"
+
+[2f1aad89-ad0f-4bd2-9919-99a8bff0305a]
+description = "extract row where numbers have different widths"
+
+[68f7f6ba-57e2-4e87-82d0-ad09889b5204]
+description = "can extract row from non-square matrix with no corresponding column"
+
+[e8c74391-c93b-4aed-8bfe-f3c9beb89ebb]
+description = "extract column from one number matrix"
+
+[7136bdbd-b3dc-48c4-a10c-8230976d3727]
+description = "can extract column"
+
+[ad64f8d7-bba6-4182-8adf-0c14de3d0eca]
+description = "can extract column from non-square matrix with no corresponding row"
+
+[9eddfa5c-8474-440e-ae0a-f018c2a0dd89]
+description = "extract column where numbers have different widths"

exercises/practice/matrix/Makefile

@@ -0,0 +1,46 @@
+AS = nasm
+
+CFLAGS = -g -Wall -Wextra -pedantic -Werror -std=c2x -Wno-gnu-binary-literal
+LDFLAGS =
+ASFLAGS = -g -F dwarf -Werror
+
+ifeq ($(shell uname -s),Darwin)
+ifeq ($(shell sysctl -n hw.optional.arm64 2>/dev/null),1)
+	ALL_CFLAGS = -target x86_64-apple-darwin
+endif
+	ALL_LDFLAGS = -Wl,-pie
+	ALL_ASFLAGS = -f macho64 --prefix _
+else
+	ALL_LDFLAGS = -pie -Wl,--fatal-warnings
+	ALL_ASFLAGS = -f elf64
+endif
+
+ALL_CFLAGS += -std=c99 -fPIE -m64 $(CFLAGS)
+ALL_LDFLAGS += $(LDFLAGS)
+ALL_ASFLAGS += $(ASFLAGS)
+
+C_OBJS = $(patsubst %.c,%.o,$(wildcard *.c))
+AS_OBJS = $(patsubst %.asm,%.o,$(wildcard *.asm))
+ALL_OBJS = $(filter-out example.o,$(C_OBJS) $(AS_OBJS) vendor/unity.o)
+
+CC_CMD = $(CC) $(ALL_CFLAGS) -c -o $@ $<
+
+all: tests
+	@./$<
+
+tests: $(ALL_OBJS)
+	@$(CC) $(ALL_CFLAGS) $(ALL_LDFLAGS) -o $@ $(ALL_OBJS)
+
+%.o: %.asm
+	@$(AS) $(ALL_ASFLAGS) -o $@ $<
+
+%.o: %.c
+	@$(CC_CMD)
+
+vendor/unity.o: vendor/unity.c vendor/unity.h vendor/unity_internals.h
+	@$(CC_CMD)
+
+clean:
+	@rm -f *.o vendor/*.o tests
+
+.PHONY: all clean

exercises/practice/matrix/matrix.asm

@@ -0,0 +1,15 @@
+section .text
+global row
+global column
+
+row:
+	; Provide your implementation here
+	ret
+
+column:
+	; Provide your implementation here
+	ret
+
+%ifidn __OUTPUT_FORMAT__,elf64
+section .note.GNU-stack noalloc noexec nowrite progbits
+%endif