Merge branch 'main' of https://github.com/rtoal/ple

Author: Undalevein

zig/README.md

@@ -1,43 +1,46 @@
 <img src="https://raw.githubusercontent.com/rtoal/ple/main/docs/resources/zig-logo-64.png">
 
-# Zig
+# Zig Explorations
 
-## Zig Examples:
+To build and run Zig programs on your local machine, download and install Zig from the [Zig Download](https://ziglang.org/download/) or use your favorite package manager, e.g. `brew install zig` on macOS.
 
-To get Zig:
-<details><summary><b>MacOS</b></summary>
-  
-<br />In your terminal (Mac Terminal): <br />
+Once installed, programs in this folder can be run from the command line like so:
 
-After installing homebrew:
+```
+zig run triple.zig
+```
 
-  ```sh
-    $ brew install zig
-  ```  
- </details>
-<details><summary><b>Windows/Linux</b></summary>
-  
-Download zig from the website:
-- [Zig Download](https://ziglang.org/download/)
+```
+zig run permutations.zig -- I like carrots
+```
 
-</details>
+```
+zig run top_ten_scorers.zig < ../test/wnba_input
+```
 
-## About Zig:
+## About Zig
 
-The Zig language was founded by Andrew Kelley in 2016. It was created to replace the <a href="https://github.com/rtoal/ple/tree/main/c">C</a> programming language and be more pragmatic. Zig offers many advancements such as features to improve safety, simple syntax, and a testing framework built into the language. The language also provides strong compile-time guarantees and aims to eliminate common programming errors. While it is a newer language, many developers approve of its capabilities. 
+The Zig language was created by Andrew Kelley in 2016, as a pragmatic alternative to the venerable <a href="https://github.com/rtoal/ple/tree/main/c">C</a> programming language. Zig offers many safety features and a growing ecosystem for building and testing. It is known for having “no surprises”: there are no hidden function calls and no hidden memory allocations. Unlike C, Zig has no preprocessor and no macros. Zig does add option types, generics, and custom allocators.
 
-## Zig Resources:
+## Zig Resources
 
 Continue your exploration of Zig via:
 
 - [Zig Home Page](https://ziglang.org)
-- [Zig Docs](https://ziglang.org/documentation/0.10.1/)
+- [Zig Docs](https://ziglang.org/documentation/master/)
 - [Intro to Zig](https://www.youtube.com/watch?v=YXrb-DqsBNU)
-- [ZigLearn](https://ziglearn.org/chapter-1/)
-- [Zig Wiki](https://en.wikipedia.org/wiki/Zig_(programming_language))
+- [ZigLearn](https://ziglearn.org/learn/)
+- [Wikipedia](<https://en.wikipedia.org/wiki/Zig_(programming_language)>)
+- The book [Introduction to Zig](https://github.com/pedropark99/zig-book)
 
 ## Zig Open Source Projects
 
-Studying, and contributing to, open source projects is an excellent way to improve your proficiency in any language. You may enjoy:
+Studying, and contributing to, open source projects is an excellent way to improve your proficiency in any language. Of the many projects using Zig, you may enjoy:
 
-- [Zig Open Source](https://github.com/kennethreitz/requests)
+- [Trending Zig Repositories on GitHub](https://github.com/trending/zig)
+- [tigerbeetle](https://github.com/tigerbeetle/tigerbeetle)
+- [asciigen](https://github.com/seatedro/asciigen)
+
+You can contribute to Zig itself:
+
+- [Language Repository at GitHub](https://github.com/ziglang/zig)

zig/permuations.zig

@@ -1,40 +1,40 @@
 const std = @import("std");
 
-fn printPermutations(a: []u8, n: usize) void {
-    if (n <= 0) {
-        std.debug.print("{s}\n", .{a});
-    } else {
-        var i: usize = 0;
-        while (i < n) : (i += 1) {
-            printPermutations(a, n - 1);
-            const j = if (n % 2 == 0) 0 else i;
-
-            const temp = a[j];
-            a[j] = a[n];
-            a[n] = temp;
+fn printArray(a: []const []const u8) !void {
+    var writer = std.io.getStdOut().writer();
+    for (a, 0..) |item, i| {
+        try writer.writeAll(item);
+        if (i < a.len - 1) {
+            try writer.writeAll("\t");
         }
-        printPermutations(a, n - 1);
     }
+    try writer.writeAll("\n");
 }
 
-pub fn main() anyerror!void {
-    var args = try std.process.argsAlloc(std.heap.page_allocator);
-    defer std.process.argsFree(std.heap.page_allocator, args);
+fn printPermutations(a: [][]u8, n: usize) !void {
+    if (n == 0) {
+        try printArray(a);
+        return;
+    }
 
-    // Skip the first argument which is the program's own path
-    const start_index: usize = 1;
-    const end_index: usize = args.len;
+    try printPermutations(a, n - 1);
 
-    if (end_index >= start_index) {
-        var buffer: [100]u8 = undefined;
-        var a: []u8 = buffer[0 .. end_index - start_index];
+    var i: usize = 0;
+    while (i < n) : (i += 1) {
+        const j: usize = if (n % 2 == 0) 0 else i;
+        std.mem.swap([]const u8, &a[j], &a[n]);
+        try printPermutations(a, n - 1);
+    }
+}
 
-        // Copy the arguments to the buffer
-        for (start_index..end_index) |i| {
-            a[i - start_index] = args[i][0];
-        }
+pub fn main() !void {
+    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
+    const allocator = gpa.allocator();
 
-        // Calculate and print the permutations
-        printPermutations(a, a.len - 1);
-    }
+    var args = try std.process.argsAlloc(allocator);
+    defer std.process.argsFree(allocator, args);
+    const a = try allocator.dupe([]u8, args[1..]);
+    defer allocator.free(a);
+
+    try printPermutations(a, a.len - 1);
 }

zig/top_ten_scorers.zig

@@ -0,0 +1,75 @@
+const std = @import("std");
+const Allocator = std.mem.Allocator;
+
+const Player = struct {
+    name: []const u8,
+    team: []const u8,
+    ppg: f64,
+};
+
+pub fn main() !void {
+    const allocator = std.heap.page_allocator;
+    const reader = std.io.getStdIn().reader();
+
+    // Dynamically allocated array of players
+    var players = std.ArrayList(Player).init(allocator);
+
+    // Read lines from stdin
+    var line: []u8 = undefined;
+    while (reader.readUntilDelimiterOrEof(&line, '\n') catch return) {
+        // Split line by commas
+        const fields = splitByComma(line);
+        if (fields.len != 4) {
+            continue; // Skip invalid lines
+        }
+
+        // Parse games and points
+        const games = std.fmt.parseInt(i32, fields[2], 10) catch continue;
+        const points = std.fmt.parseInt(i32, fields[3], 10) catch continue;
+
+        if (games < 15) {
+            continue; // Ignore players with fewer than 15 games
+        }
+
+        // Create a player and add to list
+        const ppg = f64(points) / f64(games);
+        try players.append(Player{
+            .name = fields[1],
+            .team = fields[0],
+            .ppg = ppg,
+        });
+    }
+
+    // Sort players by ppg in descending order
+    std.sort.sort(players.items, cmpPPG);
+
+    // Print top 10 players
+    const count = std.math.min(10, players.items.len);
+    for (players.items[0..count]) |player| {
+        try std.debug.print("{:22}{:4}{:8.2}\n", .{ player.name, player.team, player.ppg });
+    }
+}
+
+// Split the input line by commas
+fn splitByComma(line: []const u8) []const []const u8 {
+    var parts = std.ArrayList([]const u8).init(std.heap.page_allocator);
+
+    // Use splitScalar to split by comma
+    var it = std.mem.splitScalar(u8, line, ',');
+    while (it.next()) |part| {
+        try parts.append(part);
+    }
+
+    return parts.items;
+}
+
+// Compare function for sorting players by ppg
+fn cmpPPG(a: *Player, b: *Player) i32 {
+    if (a.ppg > b.ppg) {
+        return 1;
+    } else if (a.ppg < b.ppg) {
+        return -1;
+    } else {
+        return 0;
+    }
+}