AI tools for subnet engineers.

import re

text = ("engineering needs 200 users, "
        "sales 50, ops with 25 people")

# Pattern: <name> (any-words) <number> (users|hosts|people)?
pattern = re.compile(
    r'(\w+)[^,]*?(\d+)\s*(?:users?|hosts?|people)?',
    re.IGNORECASE)

for m in pattern.finditer(text):
    name, n = m.group(1).lower(), int(m.group(2))
    print(f"{name} -> {n} hosts")

package main

import (
	"fmt"
	"regexp"
	"strconv"
	"strings"
)

func main() {
	text := "engineering needs 200 users, " +
		"sales 50, ops with 25 people"

	re := regexp.MustCompile(`(?i)(\w+)[^,]*?(\d+)\s*(?:users?|hosts?|people)?`)
	for _, m := range re.FindAllStringSubmatch(text, -1) {
		n, _ := strconv.Atoi(m[2])
		fmt.Printf("%s -> %d hosts\n", strings.ToLower(m[1]), n)
	}
}

const text = "engineering needs 200 users, " +
             "sales 50, ops with 25 people";

const re = /(\w+)[^,]*?(\d+)\s*(?:users?|hosts?|people)?/gi;
let m;
while ((m = re.exec(text)) !== null) {
  console.log(`${m[1].toLowerCase()} -> ${parseInt(m[2])} hosts`);
}

#!/usr/bin/env bash
# Parse host requirements from plain English.

TEXT="engineering needs 200 users, sales 50, ops with 25 people"

# grep -oE matches each "<name>...<number>(suffix)" run in turn
echo "$TEXT" | grep -oE '\w+[^,]*?[0-9]+\s*(users?|hosts?|people)?' \
  | while IFS= read -r m; do
      name=$(echo "$m" | grep -oE '^\w+' | tr 'A-Z' 'a-z')
      num=$(echo "$m"  | grep -oE '[0-9]+' | head -1)
      printf "%s -> %d hosts\n" "$name" "$num"
    done

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class NlParse {
    public static void main(String[] args) {
        String text = "engineering needs 200 users, " +
                      "sales 50, ops with 25 people";

        Pattern p = Pattern.compile(
            "(\\w+)[^,]*?(\\d+)\\s*(?:users?|hosts?|people)?",
            Pattern.CASE_INSENSITIVE);
        Matcher m = p.matcher(text);
        while (m.find()) {
            System.out.printf("%s -> %d hosts%n",
                m.group(1).toLowerCase(),
                Integer.parseInt(m.group(2)));
        }
    }
}

#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <regex.h>

int main(void) {
    char text[] =
        "engineering needs 200 users, "
        "sales 50, ops with 25 people";

    regex_t re_word, re_num;
    regcomp(&re_word, "[a-zA-Z]+", REG_EXTENDED);
    regcomp(&re_num,  "[0-9]+",    REG_EXTENDED);

    /* Tokenize on commas, then extract first word + first number per segment */
    char *seg = strtok(text, ",");
    while (seg != NULL) {
        regmatch_t mw, mn;
        if (regexec(&re_word, seg, 1, &mw, 0) == 0 &&
            regexec(&re_num,  seg, 1, &mn, 0) == 0)
        {
            char name[64], num[16];
            int nl = mw.rm_eo - mw.rm_so;
            int dl = mn.rm_eo - mn.rm_so;
            memcpy(name, seg + mw.rm_so, nl); name[nl] = '\0';
            memcpy(num,  seg + mn.rm_so, dl); num[dl]  = '\0';
            for (char *c = name; *c; c++) *c = (char)tolower((unsigned char)*c);
            printf("%s -> %s hosts\n", name, num);
        }
        seg = strtok(NULL, ",");
    }
    regfree(&re_word);
    regfree(&re_num);
    return 0;
}