获取 B 站加权评分的番剧排行榜

package main

import (
	"bytes"
	"encoding/json"
	"fmt"
	"log"
	"math"
	"net/http"
	"sort"
	"strconv"
	"strings"
)

const urlTemplate = "https://api.bilibili.com/pgc/season/index/result?season_version=-1&spoken_language_type=-1&area=-1&is_finish=-1&copyright=-1&season_status=-1&season_month=-1&year=-1&style_id=-1&order=%d&st=1&sort=0&page=1&season_type=1&pagesize=%d&type=1"

const (
	byScore     = 4
	byFavorites = 3
	byPlay      = 2
)

type Media struct {
	Id        int
	Title     string
	Score     float64
	Favorites float64
	Play      float64
	Season    int

	Weight float64
}

func (m *Media) calculateWeightedScore(maxFavorites, maxPlay float64) {
	const scoreWeight = 0.8
	const favoritesWeight = 0.1
	const playWeight = 0.1
	m.Weight = scoreWeight*m.Score +
		favoritesWeight*10*normalize(m.Favorites/maxFavorites) +
		playWeight*10*normalize(m.Play/maxPlay)
}

func normalize(x float64) float64 {
	return math.Sqrt(x)
}

func log10(x int) int {
	var n int
	for x >= 10 {
		x /= 10
		n++
	}
	return n
}

func prettyNumber(x int) string {
	var format string
	var value interface{}
	var pow = log10(x)
	if pow < 4 {
		return strconv.Itoa(x)
	} else if pow < 8 {
		if pow == 7 {
			format = "%d万"
			value = x / 1e4
		} else {
			format = fmt.Sprintf("%%.%df万", 7-pow)
			value = float64(x) / 1e4
		}
	} else if pow < 10 {
		format = fmt.Sprintf("%%.%df亿", 10-pow)
		value = float64(x) / 1e8
	} else {
		format = "%d亿"
		value = x / 1e8
	}
	return fmt.Sprintf(format, value)
}

func isDigit(b byte) bool {
	return b >= '0' && b <= '9'
}

func trim(s string) string {
	const n = 64
	var v []rune
	for i, r := range s {
		if i >= n {
			v = append(v, '.', '.', '.')
			break
		}
		v = append(v, r)
	}
	return string(v)
}

func parseFloatPrefix(s string) float64 {
	var n = len(s)
	for i := 0; i < n; i++ {
		if !isDigit(s[i]) && s[i] != '.' {
			n = i
			break
		}
	}
	if n == 0 {
		return 0
	}
	var unit = float64(1)
	if strings.HasPrefix(s[n:], "十亿") {
		unit = 1e9
	} else if strings.HasPrefix(s[n:], "亿") {
		unit = 1e8
	} else if strings.HasPrefix(s[n:], "千万") {
		unit = 1e7
	} else if strings.HasPrefix(s[n:], "百万") {
		unit = 1e6
	} else if strings.HasPrefix(s[n:], "十万") {
		unit = 1e5
	} else if strings.HasPrefix(s[n:], "万") {
		unit = 1e4
	}
	v, _ := strconv.ParseFloat(s[:n], 64)
	return v * unit
}

func query(medias []Media, indices map[int]int, by int, size int) []Media {
	var result struct {
		Code int `json:"code"`
		Data struct {
			List []struct {
				MediaId   int    `json:"media_id"`
				Title     string `json:"title"`
				OrderType string `json:"order_type"`
				Order     string `json:"order"`
				Season    int    `json:"season_type"`
			} `json:"list"`
		} `json:"data"`
	}
	var url = fmt.Sprintf(urlTemplate, by, size)
	var resp, err = http.Get(url)
	if err != nil {
		log.Fatalf("get by %d error: %v", by, err)
	}
	defer resp.Body.Close()
	if err := json.NewDecoder(resp.Body).Decode(&result); err != nil {
		log.Fatalf("unmarshal from json error: %v", err)
	}
	for i := range result.Data.List {
		index, ok := indices[result.Data.List[i].MediaId]
		if !ok {
			index = len(medias)
			var m = Media{
				Id:     result.Data.List[i].MediaId,
				Title:  result.Data.List[i].Title,
				Season: result.Data.List[i].Season,
			}
			indices[m.Id] = index
			medias = append(medias, m)
		}
		order := parseFloatPrefix(result.Data.List[i].Order)
		switch by {
		case byScore:
			medias[index].Score = order
		case byFavorites:
			medias[index].Favorites = order
		case byPlay:
			medias[index].Play = order
		default:
			panic("unknown orderby")
		}
	}

	return medias
}

func main() {
	var medias []Media
	var indices = make(map[int]int)
	const size = 4000
	medias = query(medias, indices, byScore, size)
	medias = query(medias, indices, byFavorites, size)
	medias = query(medias, indices, byPlay, size)
	var maxFavorites, maxPlay float64
	for i, m := range medias {
		if i == 0 || m.Favorites > maxFavorites {
			maxFavorites = m.Favorites
		}
		if i == 0 || m.Play > maxPlay {
			maxPlay = m.Play
		}
	}
	for i := range medias {
		medias[i].calculateWeightedScore(maxFavorites, maxPlay)
	}
	sort.Slice(medias, func(i, j int) bool {
		return medias[i].Weight > medias[j].Weight
	})

	var table bytes.Buffer
	var maxCount = 200
	table.WriteString(`
|排名|番名|用户评分|追番数|播放次数|权重评分|
|----|----|--------|------|--------|--------|`)
	for i, m := range medias {
		if i >= maxCount {
			break
		}
		fmt.Fprintf(&table, "\n|%d|%s|%.01f|%s|%s|%.01f|", i+1, trim(m.Title), m.Score, prettyNumber(int(m.Favorites)), prettyNumber(int(m.Play)), m.Weight)
	}
	fmt.Println(table.String())
}