Practice Code Typing – SkillsTyping

Choose your language:

ℹ️ Select 'Choose Exercise', or randomize 'Next Random Exercise' in selected language.

Choose Exercise:

Ready

Exercise Algorithm Area

Correct typos to continue.

1;; Function to evaluate a postfix expression using a stack
2;; Supports +, -, *, /, and parentheses (though parentheses are handled by the postfix conversion, not directly here).
3;; Assumes input is a string of tokens separated by spaces.
4
5(func $evaluate_postfix (param $expression_ptr i32) (result i32)
6(local $stack_ptr i32) ;; Pointer to the stack buffer
7(local $stack_top i32) ;; Index of the top element in the stack
8(local $current_token_ptr i32) ;; Pointer to the current token being processed
9(local $token_len i32) ;; Length of the current token
10(local $num1 i32) ;; First operand from stack
11(local $num2 i32) ;; Second operand from stack
12(local $result i32) ;; Intermediate result
13(local $error_code i32)
14
15;; Initialize stack (a fixed-size buffer for simplicity)
16(call $init_stack)
17(set_local $stack_ptr (i32.const 0)) ;; Assume stack is at memory address 0
18(set_local $stack_top (i32.const -1))
19
20;; Pointer to the start of the expression string
21(set_local $current_token_ptr $expression_ptr)
22
23;; Loop through tokens in the expression
24(loop $token_loop
25(set_local $token_len (call $get_next_token_len $current_token_ptr))
26
27;; If token length is 0, we've reached the end of the string
28(if (i32.eqz $token_len)
29(br $end_token_loop)
30)
31
32;; Check if the token is a number
33(if (call $is_number $current_token_ptr $token_len)
34(then
35;; Push number onto stack
36(set_local $result (call $parse_number $current_token_ptr $token_len))
37(call $push_stack $result)
38)
39(else
40;; It's an operator
41(set_local $error_code (call $handle_operator $current_token_ptr $token_len))
42(if (i32.ne $error_code (i32.const 0))
43(br $error_exit)
44)
45)
46)
47
48;; Move to the next token
49(set_local $current_token_ptr (call $advance_pointer $current_token_ptr $token_len))
50(br $token_loop)
51)
52(end $token_loop)
53(label $end_token_loop)
54
55;; After processing all tokens, the result should be the only item on the stack
56(if (i32.eq (local.get $stack_top) (i32.const 0))
57(then
58(return (call $pop_stack))
59)
60(else
61;; Error: Stack should have exactly one element at the end
62(return (i32.const -1)) ;; Indicate error
63)
64)
65
66(label $error_exit)
67(return (i32.const -1)) ;; Indicate error
68)
69
70;; Helper function to initialize the stack buffer
71(func $init_stack (result i32)
72;; Allocate memory for the stack. For simplicity, assume a fixed size.
73;; In a real scenario, this would involve more complex memory management.
74(local $stack_mem i32)
75(set_local $stack_mem (memory.grow (i32.const 1))) ;; Grow memory by 1 page (64KB)
76(return $stack_mem)
77)
78
79;; Helper function to push a value onto the stack
80(func $push_stack (param $value i32)
81(local $current_top i32)
82(set_local $current_top (local.get $stack_top))
83(set_local $stack_top (i32.add (local.get $stack_top) (i32.const 1)))
84(if (i32.ge (local.get $stack_top) (i32.const 1024)) ;; Stack overflow check (fixed size 1024)
85(then (return (i32.const -2))) ;; Stack overflow error
86)
87(memory.store (i32.add (local.get $stack_ptr) (i32.mul (local.get $stack_top) (i32.const 4))) (local.get $value))
88(return (i32.const 0))
89)
90
91;; Helper function to pop a value from the stack
92(func $pop_stack (result i32)
93(local $value i32)
94(if (i32.ltz (local.get $stack_top))
95(then (return (i32.const -3))) ;; Stack underflow error
96)
97(set_local $value (memory.load (i32.add (local.get $stack_ptr) (i32.mul (local.get $stack_top) (i32.const 4)))))
98(set_local $stack_top (i32.sub (local.get $stack_top) (i32.const 1)))
99(return $value)
100)
101
102;; Helper function to get the length of the next token
103(func $get_next_token_len (param $ptr i32) (result i32)
104(local $len i32)
105(set_local $len (i32.const 0))
106(loop $len_loop
107(local $char i32)
108(set_local $char (i32.load8s (i32.add $ptr $len)))
109(if (or (i32.eqz $char) (i32.eq $char (i32.const 32))) ;; Null terminator or space
110(br $end_len_loop)
111)
112(set_local $len (i32.add $len (i32.const 1)))
113(br $len_loop)
114)
115(end $len_loop)
116(label $end_len_loop)
117(return $len)
118)
119
120;; Helper function to check if a token is a number
121(func $is_number (param $ptr i32) (param $len i32) (result i32)
122(local $i i32)
123(set_local $i (i32.const 0))
124(if (i32.eqz $len)
125(then (return (i32.const 0)))
126)
127(loop $num_check_loop
128(if (i32.ge $i $len)
129(br $end_num_check_loop)
130)
131(local $char i32)
132(set_local $char (i32.load8s (i32.add $ptr $i)))
133(if (or (i32.lt $char (i32.const 48)) (i32.gt $char (i32.const 57))) ;; Not a digit '0'-'9'
134(then (return (i32.const 0)))
135)
136(set_local $i (i32.add $i (i32.const 1)))
137(br $num_check_loop)
138)
139(end $num_check_loop)
140(label $end_num_check_loop)
141(return (i32.const 1))
142)
143
144;; Helper function to parse a number string into an i32
145(func $parse_number (param $ptr i32) (param $len i32) (result i32)
146(local $num i32)
147(local $i i32)
148(set_local $num (i32.const 0))
149(set_local $i (i32.const 0))
150(loop $parse_loop
151(if (i32.ge $i $len)
152(br $end_parse_loop)
153)
154(local $digit i32)
155(set_local $digit (i32.sub (i32.load8s (i32.add $ptr $i)) (i32.const 48))) ;; Convert char to digit
156(set_local $num (i32.add (i32.mul $num (i32.const 10)) $digit))
157(set_local $i (i32.add $i (i32.const 1)))
158(br $parse_loop)
159)
160(end $parse_loop)
161(label $end_parse_loop)
162(return $num)
163)
164
165;; Helper function to handle operators
166(func $handle_operator (param $ptr i32) (param $len i32) (result i32)
167(local $op_char i32)
168(local $num1 i32)
169(local $num2 i32)
170(local $result i32)
171
172(if (i32.eq $len (i32.const 1))
173(then
174(set_local $op_char (i32.load8s $ptr))
175
176;; Pop operands from stack
177(set_local $num1 (call $pop_stack))
178(if (i32.ltz $num1) (return $num1)) ;; Propagate error
179(set_local $num2 (call $pop_stack))
180(if (i32.ltz $num2) (return $num2)) ;; Propagate error
181
182(if (i32.eq $op_char (i32.const 43)) ;; '+'
183(then (set_local $result (i32.add $num2 $num1)))
184)
185(if (i32.eq $op_char (i32.const 45)) ;; '-'
186(then (set_local $result (i32.sub $num2 $num1)))
187)
188(if (i32.eq $op_char (i32.const 42)) ;; '*'
189(then (set_local $result (i32.mul $num2 $num1)))
190)
191(if (i32.eq $op_char (i32.const 47)) ;; '/'
192(then
193(if (i32.eqz $num1)
194(then (return (i32.const -4))) ;; Division by zero error
195)
196(set_local $result (i32.div_s $num2 $num1))
197)
198)
199
200;; Push result back onto stack
201(call $push_stack $result)
202(return (i32.const 0)) ;; Success
203)
204(else
205;; Invalid operator token length
206(return (i32.const -5))
207)
208)
209)
210
211;; Helper function to advance the pointer past a token and a space
212(func $advance_pointer (param $ptr i32) (param $len i32) (result i32)
213(return (i32.add $ptr (i32.add $len (i32.const 1)))) ;; Move past token and space
214)

Algorithm description viewbox

WAT Stack-Based Expression Evaluator with Operator Precedence

Algorithm description:

This WAT program implements a stack-based evaluator for postfix mathematical expressions. It parses a string representing a postfix expression, tokenizes it, and uses a stack to perform calculations. Numbers are pushed onto the stack, and operators pop operands, perform the operation, and push the result back. This is crucial for compilers and interpreters to evaluate expressions efficiently.

Algorithm explanation:

The `evaluate_postfix` function processes a postfix expression string. It iterates through tokens, pushing numbers onto a simulated stack and applying operators to popped operands. The stack is implemented using linear memory, with `stack_ptr` and `stack_top` managing its state. Operator handling involves popping two operands, performing the operation (addition, subtraction, multiplication, division), and pushing the result. Division by zero is explicitly checked. The algorithm's time complexity is O(N), where N is the number of tokens, as each token is processed once. Space complexity is O(N) in the worst case for the stack, though typically much less for balanced expressions. Edge cases include empty expressions, single-number expressions, invalid tokens, stack underflow/overflow, and division by zero. The correctness relies on the property that in postfix notation, operands appear before their operators, allowing for direct stack manipulation.

Pseudocode:

function evaluate_postfix(expression_string):
  initialize stack
  set stack_top to -1
  pointer = start of expression_string

  while pointer is not end of string:
    get next token and its length
    if token is empty, break loop

    if token is a number:
      parse number
      push number onto stack
    else (token is an operator):
      if stack has less than 2 elements, return error (underflow)
      pop operand2 from stack
      pop operand1 from stack
      perform operation (operand1 operator operand2)
      if division by zero, return error
      push result onto stack

    advance pointer past token and space

  if stack has exactly 1 element:
    pop and return the result
  else:
    return error (malformed expression)

Library

Playable exercises

Choose Exercise

Filter, sort, and preview algorithm before you choose one to play.

Total 5 published items

Pages 1 pages available

Language

Sort by Direction

Browse published coding scenarios with filters, sorting, and pagination.

Published

WAT Specialist (wat)

WAT Loop Unrolling for Array Summation

Difficulty: writing: 1; length: 9
Popularity: 0
Created: 2026-01-26 13:09 UTC
Published: 2026-01-26 13:42 UTC
Author: Admin

#wat #loop unrolling #numeric kernels #optimization #linear memory #algorithm

goal: Sum elements of an array using loop unrolling. input: Pointer to an array of i32s and its length. output: The sum of the array elements as an i32.

Canonical Algorithm Text

;; Array Summation with Loop Unrolling (Factor of 4) in WAT ;; Computes the sum of elements in an i32 array. (func $sum_array_unrolled (param $array_ptr i32) (param $array_len i32) (result i32) (local $sum i32) ;; Accumulator for the sum (local $i i32) ;; Loop counter (local $unr...

Description Algorithm

This WAT program demonstrates loop unrolling for array summation. Instead of processing one element per iteration, the loop is unrolled by a factor of 4, meaning it processes four elements in each iteration. This reduces...

Explanation

The `sum_array_unrolled` function calculates the sum of elements in an i32 array. It first determines how many full groups of 4 elements can be processed and how many remain. The main loop iterates `unrolled_len` times, but in each iteration, it loads and adds four elements at once. This reduces the number of loop control instructions (increments, comparisons, branches). After the unrolled loop, a separate loop handles the `remainder` elements. The time complexity remains O(N), but the constant factor is reduced due to fewer loop overheads, potentially leading to faster execution. Space complexity is O(1). Edge cases include empty arrays and arrays whose lengths are not multiples of the unrolling factor (4). The `create_test_array` helper is for demonstration.

Pseudocode

function sum_array_unrolled(array, length): sum = 0 i = 0 unrolled_length = floor(length / 4) * 4 remainder = length - unrolled_length // Unrolled loop (process 4 elements at a time) while i < unrolled_length: sum = sum...

Published

WAT Specialist (wat)

WAT Custom Allocator for Fixed-Size Chunks

Difficulty: writing: 6; length: 10
Popularity: 0
Created: 2026-01-26 13:09 UTC
Published: 2026-01-26 13:42 UTC
Author: Admin

#wat #custom allocators #linear memory #linked list #memory management #algorithm

goal: Manage a pool of fixed-size memory chunks. input: None for initialization; pointer to chunk for deallocation. output: Pointer to allocated chunk or -1 for allocation failure; no return for deallocation.

Canonical Algorithm Text

;; Custom Allocator for Fixed-Size Chunks in WAT ;; Manages a pool of memory divided into fixed-size blocks. ;; Uses a free list to track available chunks. (module (memory 1) ;; 64KB initial memory (global $HEAP_START (mut i32) (i32.const 0)) (global $TOTAL_MEMORY (i32) (i32.cons...

Description Algorithm

This WAT program implements a custom memory allocator that manages a pool of fixed-size memory chunks. It uses a free list, implemented as a linked list within the memory pool itself, to keep track of available chunks. T...

Explanation

The custom allocator manages a contiguous block of memory divided into fixed-size chunks. A global variable, `$free_list_head`, points to the first available chunk. Each chunk, when not in use, contains a pointer (at a fixed offset, e.g., 4 bytes) to the next free chunk, forming a linked list. When `allocate_chunk` is called, it takes the chunk pointed to by `$free_list_head`, updates `$free_list_head` to point to the next chunk in the list, and returns the pointer to the allocated chunk. If `$free_list_head` is -1, the pool is full. `deallocate_chunk` takes a pointer, adds it to the front of the free list by updating its 'next' pointer and then setting `$free_list_head` to the deallocated chunk's pointer. It includes checks for invalid pointers and attempts to deallocate already freed chunks. The time complexity for allocation and deallocation is O(1) on average, assuming no need to check for already freed chunks. Space complexity is O(N) for the memory pool, where N is the number of chunks.

Pseudocode

initialize memory pool with fixed-size chunks initialize free_list_head to point to the first chunk for each chunk (except the last): set its 'next' pointer to the address of the next chunk set the last chunk's 'next' po...

Published

WAT Specialist (wat)

WAT Optimized Matrix Multiplication Kernel

Difficulty: writing: 4; length: 7
Popularity: 0
Created: 2026-01-26 13:09 UTC
Published: 2026-01-26 13:42 UTC
Author: Admin

#wat #matrix multiplication #numeric kernels #optimization #linear memory #algorithm

goal: Perform matrix multiplication C = A * B. input: Pointers to matrices A and B, pointer to matrix C (result), dimensions of A and B. output: 0 for success, -1 for dimension mismatch.

Canonical Algorithm Text

;; Optimized Matrix Multiplication Kernel in WAT ;; Computes C = A * B ;; Assumes matrices are stored in row-major order. (func $matrix_multiply (param $a_ptr i32) (param $b_ptr i32) (param $c_ptr i32) (param $rows_a i32) (param $cols_a i32) (param $cols_b i32) ;; $rows_a: Number...

Description Algorithm

This WAT program implements an optimized matrix multiplication routine. It calculates the product of two matrices, C = A * B, where matrices are stored in row-major order. The implementation focuses on optimizing the inn...

Explanation

The `matrix_multiply` function computes the product of two matrices A (m x n) and B (n x p) to produce matrix C (m x p). It iterates through each element C[i][j] of the result matrix. For each element, it computes the dot product of the i-th row of A and the j-th column of B. The inner loop (over k) accumulates the sum of products A[i][k] * B[k][j]. Indices are carefully calculated to access elements in row-major order. The time complexity is O(m * n * p), which is inherent to matrix multiplication. Space complexity is O(1) beyond the storage for the matrices themselves. Edge cases include checking for compatible dimensions (columns of A must equal rows of B) and ensuring the result matrix C is initialized to zeros before accumulation. The optimization lies in minimizing memory loads and maximizing arithmetic operations within the tight inner loop.

Pseudocode

function matrix_multiply(A, B, C): rows_A = number of rows in A cols_A = number of columns in A rows_B = number of rows in B cols_B = number of columns in B if cols_A is not equal to rows_B: return error (incompatible di...

Published

WAT Specialist (wat)

WAT Stack-Based Expression Evaluator with Operator Precedence

Difficulty: writing: 1; length: 10
Popularity: 0
Created: 2026-01-26 13:09 UTC
Published: 2026-01-26 13:42 UTC
Author: Admin

#wat #stack #postfix #expression evaluation #linear memory #algorithm #compiler

goal: Evaluate a postfix mathematical expression. input: A pointer to a null-terminated string representing a postfix expression (e.g., "3 4 + 5 * "). output: An i32 representing the result of the expression, or a negative error code.

Canonical Algorithm Text

;; Function to evaluate a postfix expression using a stack ;; Supports +, -, *, /, and parentheses (though parentheses are handled by the postfix conversion, not directly here). ;; Assumes input is a string of tokens separated by spaces. (func $evaluate_postfix (param $expression...

Description Algorithm

This WAT program implements a stack-based evaluator for postfix mathematical expressions. It parses a string representing a postfix expression, tokenizes it, and uses a stack to perform calculations. Numbers are pushed o...

Explanation

The `evaluate_postfix` function processes a postfix expression string. It iterates through tokens, pushing numbers onto a simulated stack and applying operators to popped operands. The stack is implemented using linear memory, with `stack_ptr` and `stack_top` managing its state. Operator handling involves popping two operands, performing the operation (addition, subtraction, multiplication, division), and pushing the result. Division by zero is explicitly checked. The algorithm's time complexity is O(N), where N is the number of tokens, as each token is processed once. Space complexity is O(N) in the worst case for the stack, though typically much less for balanced expressions. Edge cases include empty expressions, single-number expressions, invalid tokens, stack underflow/overflow, and division by zero. The correctness relies on the property that in postfix notation, operands appear before their operators, allowing for direct stack manipulation.

Pseudocode

function evaluate_postfix(expression_string): initialize stack set stack_top to -1 pointer = start of expression_string while pointer is not end of string: get next token and its length if token is empty, break loop if t...

Published

WAT Specialist (wat)

WAT Binary Search for Element in Sorted Array

Difficulty: writing: 3; length: 10
Popularity: 0
Created: 2026-01-26 13:09 UTC
Published: 2026-01-26 13:41 UTC
Author: Admin

#wat #binary search #sorting kernels #search algorithm #linear memory #algorithm #edge cases

goal: Find the index of a target value in a sorted array. input: Pointer to a sorted array of i32s, the length of the array, and the target i32 value. output: The index of the target value if found, otherwise -1.

Canonical Algorithm Text

;; Binary Search Implementation in WAT ;; Searches for a target value in a sorted array of i32s. ;; Returns the index of the target if found, otherwise -1. (func $binary_search (param $array_ptr i32) (param $array_len i32) (param $target i32) (result i32) (local $low i32) ;; Lowe...

Description Algorithm

This WAT program implements the binary search algorithm to efficiently find a target value within a sorted array. It repeatedly divides the search interval in half. If the value of the search key is less than the item in...

Explanation

The `binary_search` function takes a pointer to a sorted array of i32s, its length, and the target value. It initializes `low` to 0 and `high` to `length - 1`. The core loop continues as long as `low <= high`. In each iteration, it calculates the middle index `mid`. It then compares the value at `array[mid]` with the `target`. If they match, `mid` is returned. If `array[mid]` is less than `target`, the search continues in the right half by setting `low = mid + 1`. If `array[mid]` is greater than `target`, the search continues in the left half by setting `high = mid - 1`. The loop invariant is that the target, if present, must lie within the inclusive range `[low, high]`. If the loop terminates without finding the target (i.e., `low > high`), -1 is returned. Time complexity is O(log N), and space complexity is O(1). Edge cases include empty arrays, target not present, and targets at the array's boundaries.

Pseudocode

function binary_search(array, length, target): if length is 0: return -1 low = 0 high = length - 1 while low <= high: mid = low + (high - low) / 2 mid_value = array[mid] if mid_value == target: return mid else if mid_val...

Language (required)

Paste your code (required)

Max 20,000 characters. (Dangerous HTML/script fragments will be blocked)

Normalized preview:

I agree to Publish this, after admin approval (queued for review). (Not required) I confirm this submission is anonymous and does not contain personal data. I grant SkillsTyping a free, non-exclusive, worldwide, and irrevocable license to store, modify, adapt, and publish this content after review. I understand that publication is not guaranteed, that I retain no ownership or usage claims over published versions, and that no compensation will be provided. See Privacy Policy

Publish details

Shown only if you opt to submit for review. Required when consent is checked.

Title (required with consent)

Short description / summary (required with consent)

Algorithm explanation (required with consent)

Pseudocode (required with consent)