Zignet

# Advanced Zig Test Report **Model**: deepseek-coder:6.7b **Date**: 2025-10-26T11:51:11.582Z **Total Tests**: 6 **Passed**: 6 **Failed**: 0 **Average Response Time**: 27.86s ## Results ### 1. Basic Zig Syntax [EASY] **Status**: ✅ PASS **Time**: 18.36s **Response**: ```zig Here is a simple example of a Zig function named "add" that adds two integer numbers: ```zig fn add(a: i32, b: i32) i32 { return a + b; } ``` This `add` function takes in two parameters (both are integers), and returns the sum of these two integers. The "i32" refers to an integer type with a width of 32 bits, which is one of Zig's few built-in integer types. You can replace it with other data types as per your requirement. ``` ### 2. Memory Allocation [EASY] **Status**: ✅ PASS **Time**: 23.63s **Response**: ```zig In Zig, we can use `allocator.create` for allocation of memory and `allocator.destroy` for deallocation or memory freeing. Here is a simple example: ```zig const std = @import("std"); pub fn main() !void { var gpa = std.heap.GeneralPurposeAllocator(.{}){}; defer _ = gpa.deinit(); const allocator = gpa.allocator(); // Allocate memory for an integer and store a value var number = try allocator.create(i32); errdefer allocator.destroy(number); // clean up if allocatio ``` ### 3. Error Handling [MEDIUM] **Status**: ✅ PASS **Time**: 45.52s **Response**: ```zig In Zig programming language, we can return a `Result` from a function which is an enumeration of two possibilities: `Ok(T)` and `Err(E)` where T represents the successful result and E represents some error condition that happened during execution. Here's a simple example: ```zig const std = @import("std"); // Define an enum for errors error FileNotFoundError = error{FileNotFound}; pub fn readFile(allocator: *std.mem.Allocator, path: []const u8) ![]u8 { // Open the file and return Err if ``` ### 4. Structs & Methods [MEDIUM] **Status**: ✅ PASS **Time**: 21.51s **Response**: ```zig Here is how you can define it in Zig programming language: ```zig const std = @import("std"); const math = std.math; pub const Point = struct { x: f64, y: f64, pub fn distanceFromOrigin(self: Point) f64 { return math.sqrt((self.x * self.x) + (self.y * self.y)); } }; ``` This code defines a struct `Point` with two fields `x` and `y` of type `f64` to store the coordinates. It also includes a method named `distanceFromOrigin()` which calculates and returns the distance f ``` ### 5. Generics [HARD] **Status**: ✅ PASS **Time**: 30.03s **Response**: ```zig Below is an example of how you can create such a function in Zig programming language. This function is named `max` and it accepts 2 parameters, both are instances of `anytype` which represents any possible value. The body of the function checks if first parameter is greater than second one then returns first otherwise return second. ```zig fn max(comptime T: type, a: T, b: T) T { return if (a > b) a else b; } ``` Note that to use this function you must specify the numeric type `T` at compi ``` ### 6. Comptime Magic [HARD] **Status**: ✅ PASS **Time**: 28.12s **Response**: ```zig In Zig, `comptime` is used for computations that need to be done during compilation, as opposed to runtime where they are executed post-compilation. Below is an example of how you can use it to compute a factorial at compile time. ```zig fn Factorial(comptime n: usize) usize { if (n == 0 or n == 1) return 1; return n * comptime Factorial(n - 1); } ``` The above function `Factorial` is a recursive one which multiplies the current number with the factorial of the previous number until it ```