fix workflow

Author: minicloudsky

go.mod

@@ -1,3 +1,9 @@
 module github.com/minicloudsky/leetcode-algorithm
 
 go 1.21
+
+require (
+	github.com/cespare/xxhash/v2 v2.3.0 // indirect
+	github.com/dgryski/go-rendezvous v0.0.0-20200823014737-9f7001d12a5f // indirect
+	github.com/go-redis/redis/v8 v8.11.5 // indirect
+)

interviews/coupon-system/README.md

@@ -0,0 +1,10 @@
+#  题目1：电商优惠券系统设计
+业务场景：
+设计一个电商平台的优惠券系统，需满足：
+1. 支持多种优惠类型（满减、折扣、赠品）。
+2. 优惠券可叠加使用，但需校验适用范围（如特定商品/用户等级）。
+3. 需记录优惠券领取、使用记录，并支持运营按“用户领取量”和“券使用率”分析数据。
+
+考察重点：
+1. 关系型数据库设计
+2. 面向对象设计（要素+设计模式）

interviews/coupon-system/main.go

@@ -0,0 +1,101 @@
+package main
+
+import (
+	"strconv"
+	"time"
+)
+
+// 题目1：电商优惠券系统设计
+//业务场景：
+//设计一个电商平台的优惠券系统，需满足：
+//1. 支持多种优惠类型（满减、折扣、赠品）。
+//2. 优惠券可叠加使用，但需校验适用范围（如特定商品/用户等级）。
+//3. 需记录优惠券领取、使用记录，并支持运营按“用户领取量”和“券使用率”分析数据。
+//
+//考察重点：
+//1. 关系型数据库设计
+//2. 面向对象设计（要素+设计模式）
+
+type CouponInter interface {
+	Consume(couponId, uid string)
+	Expire(couponId string)
+	Use(couponId string)
+}
+
+type DiscountCoupon struct {
+}
+
+func (d *DiscountCoupon) Consume(couponId, uid string) {
+	return
+}
+
+func (d *DiscountCoupon) Expire(couponId string) {
+	return
+}
+func (d *DiscountCoupon) Use(couponId string) {
+	return
+}
+
+type CouponType int
+
+const (
+	CouponTypeAbove = iota + 1
+	ConponTypeDiscount
+	CouponTypeGift
+)
+
+type CouponSatifyScene string
+
+const (
+	CouponSatifySceneGoods = "goods"
+	CouponSatifyUserRank   = "user_rank"
+)
+
+type Coupon struct {
+	Id                int64             `json:"id"`
+	CouponName        string            `json:"coupon_name"`
+	CouponType        CouponType        `json:"coupon_type"`
+	CouponSatifyScene CouponSatifyScene `json:"coupon_satify_scene"`
+	CouponSatifyVal   string            `json:"coupon_satify_val"`
+	CouponSatifyCond  string            `json:"coupon_satify_cond"` // 满足的条件，json类型
+	CouponCount       int16
+	ExpireTime        time.Time
+}
+
+//{
+//"price_above": xxx
+//}
+
+type User struct {
+	NickName string
+	Uid      string
+	Level    int16
+}
+
+func (c *Coupon) Satify(user User, goodsId string) bool {
+	switch c.CouponSatifyScene {
+	case CouponSatifySceneGoods:
+		if goodsId == c.CouponSatifyVal {
+			return true
+		}
+	case CouponSatifyUserRank:
+		rank, _ := strconv.Atoi(c.CouponSatifyCond)
+		if int(user.Level) > rank {
+			return true
+		}
+	}
+	return false
+}
+
+type CouponConsumeHistory struct {
+	Id         int64
+	UID        string
+	ConponId   int64
+	CouponType CouponType
+}
+type CouponUseHistory struct {
+	Id         int64
+	UID        string
+	ConponId   int64
+	CouponType CouponType
+}

interviews/distribute_lock/README.md

@@ -0,0 +1 @@
+# 分布式锁实现

interviews/distribute_lock/redis-distribute-lock-conflict/lock_conflict.go

@@ -0,0 +1,136 @@
+package redis_distribute_lock_conflict
+
+import (
+	"context"
+	"fmt"
+	"github.com/go-redis/redis/v8"
+	"math/rand"
+	"time"
+)
+
+const (
+	lockKey      = "concurrent_resource_lock"
+	redisAddress = "localhost:6379"
+)
+
+// RedisLock 改进版分布式锁（含冲突处理）
+type RedisLock struct {
+	client        *redis.Client
+	lockKey       string
+	uniqueValue   string
+	expiration    time.Duration
+	retryInterval time.Duration
+	maxRetries    int
+}
+
+func NewRedisLock(client *redis.Client, lockKey string, expiration time.Duration) *RedisLock {
+	return &RedisLock{
+		client:        client,
+		lockKey:       lockKey,
+		uniqueValue:   generateUniqueValue(),
+		expiration:    expiration,
+		retryInterval: 100 * time.Millisecond,
+		maxRetries:    5,
+	}
+}
+
+func processWithLock(rdb *redis.Client, clientID int) {
+	lock := NewRedisLock(rdb, lockKey, 5*time.Second)
+	ctx := context.Background()
+
+	// 带重试机制的加锁
+	acquired := false
+	for attempt := 1; attempt <= lock.maxRetries; attempt++ {
+		ok, err := lock.TryLock(ctx)
+		if err != nil {
+			fmt.Printf("Client %d attempt %d: Lock error - %v\n", clientID, attempt, err)
+			continue
+		}
+		if ok {
+			acquired = true
+			break
+		}
+		fmt.Printf("Client %d attempt %d: Lock occupied, retrying...\n", clientID, attempt)
+		time.Sleep(lock.retryInterval)
+	}
+
+	if !acquired {
+		fmt.Printf("Client %d: Failed to acquire lock after %d attempts\n", clientID, lock.maxRetries)
+		return
+	}
+
+	defer func() {
+		if err := lock.Unlock(ctx); err != nil {
+			fmt.Printf("Client %d unlock error: %v\n", clientID, err)
+		}
+	}()
+
+	// 模拟业务处理
+	fmt.Printf("Client %d acquired lock, processing...\n", clientID)
+	processTime := time.Duration(2+rand.Intn(3)) * time.Second
+	time.Sleep(processTime)
+	fmt.Printf("Client %d completed processing\n", clientID)
+}
+
+// TryLock 带冲突检测的加锁方法
+func (l *RedisLock) TryLock(ctx context.Context) (bool, error) {
+	result, err := l.client.SetNX(ctx, l.lockKey, l.uniqueValue, l.expiration).Result()
+	if err != nil {
+		return false, fmt.Errorf("redis setnx error: %w", err)
+	}
+
+	// 加锁成功时启动自动续期
+	if result {
+		go l.autoRenew(ctx)
+	}
+	return result, nil
+}
+
+// 自动续期机制
+func (l *RedisLock) autoRenew(ctx context.Context) {
+	ticker := time.NewTicker(l.expiration / 2)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			// 使用 Lua 脚本保证原子性续期
+			success, err := l.client.Eval(ctx, `
+				if redis.call("GET", KEYS[1]) == ARGV[1] then
+					return redis.call("PEXPIRE", KEYS[1], ARGV[2])
+				else
+					return 0
+				end
+			`, []string{l.lockKey}, l.uniqueValue, l.expiration.Milliseconds()).Bool()
+
+			if err != nil || !success {
+				return
+			}
+		case <-ctx.Done():
+			return
+		}
+	}
+}
+
+// Unlock 安全解锁
+func (l *RedisLock) Unlock(ctx context.Context) error {
+	script := `
+		if redis.call("GET", KEYS[1]) == ARGV[1] then
+			return redis.call("DEL", KEYS[1])
+		else
+			return 0
+		end
+	`
+	result, err := l.client.Eval(ctx, script, []string{l.lockKey}, l.uniqueValue).Int64()
+	if err != nil {
+		return fmt.Errorf("unlock script failed: %w", err)
+	}
+	if result == 0 {
+		return fmt.Errorf("unlock failed: lock not exists or value mismatch")
+	}
+	return nil
+}
+
+func generateUniqueValue() string {
+	return fmt.Sprintf("%d-%d", time.Now().UnixNano(), rand.Intn(1000))
+}

interviews/distribute_lock/redis-distribute-lock-conflict/lock_conflict_test.go

@@ -0,0 +1,26 @@
+package redis_distribute_lock_conflict
+
+import (
+	"github.com/go-redis/redis/v8"
+	"math/rand"
+	"sync"
+	"testing"
+	"time"
+)
+
+// 模拟资源竞争的并发场景
+func TestLockConflict(t *testing.T) {
+	rand.Seed(time.Now().UnixNano())
+	rdb := redis.NewClient(&redis.Options{Addr: redisAddress})
+
+	var wg sync.WaitGroup
+	// 启动 3 个并发客户端竞争锁
+	for i := 1; i <= 3; i++ {
+		wg.Add(1)
+		go func(clientID int) {
+			defer wg.Done()
+			processWithLock(rdb, clientID)
+		}(i)
+	}
+	wg.Wait()
+}

interviews/distribute_lock/redis-distribute-lock/redis-distribute-lock.go

@@ -0,0 +1,92 @@
+package redis_distribute_lock
+
+import (
+	"context"
+	"fmt"
+	"github.com/go-redis/redis/v8"
+	"math/rand"
+	"time"
+)
+
+type RedisLock struct {
+	client     *redis.Client
+	key        string
+	value      string
+	expiration time.Duration
+	unlockCh   chan struct{}
+}
+
+func NewRedisLock(client *redis.Client, key string, expiration time.Duration) *RedisLock {
+	return &RedisLock{
+		client:     client,
+		key:        key,
+		value:      generateUniqueValue(),
+		expiration: expiration,
+		unlockCh:   make(chan struct{}),
+	}
+}
+
+// Lock 加锁（含自动续期）
+func (l *RedisLock) Lock(ctx context.Context) (bool, error) {
+	ok, err := l.client.SetNX(ctx, l.key, l.value, l.expiration).Result()
+	if err != nil || !ok {
+		return false, err
+	}
+
+	// 启动看门狗自动续期
+	go l.watchDog(ctx)
+	return true, nil
+}
+
+// 自动续期
+func (l *RedisLock) watchDog(ctx context.Context) {
+	ticker := time.NewTicker(l.expiration / 3)
+	defer ticker.Stop()
+
+	for {
+		select {
+		case <-ticker.C:
+			// 续期：仅当锁仍属于当前客户端时延长过期时间
+			success, err := l.client.Eval(ctx, `
+				if redis.call("GET", KEYS[1]) == ARGV[1] then
+					return redis.call("PEXPIRE", KEYS[1], ARGV[2])
+				else
+					return 0
+				end
+			`, []string{l.key}, l.value, l.expiration.Milliseconds()).Bool()
+
+			if err != nil || !success {
+				return
+			}
+		case <-l.unlockCh:
+			return
+		}
+	}
+}
+
+// Unlock 解锁
+func (l *RedisLock) Unlock(ctx context.Context) error {
+	defer close(l.unlockCh)
+
+	script := `
+		if redis.call("GET", KEYS[1]) == ARGV[1] then
+			return redis.call("DEL", KEYS[1])
+		else
+			return 0
+		end
+	`
+
+	result, err := l.client.Eval(ctx, script, []string{l.key}, l.value).Result()
+	if err != nil {
+		return err
+	}
+	if result == 0 {
+		return fmt.Errorf("unlock failed: lock not exists or value mismatch")
+	}
+	return nil
+}
+
+func generateUniqueValue() string {
+	rand.New(rand.NewSource(100000)).Int()
+	return fmt.Sprintf("%d-%d", time.Now().UnixNano(), rand.Int())
+}