type LRUCache struct {
	size       int
	capacity   int
	cache      map[string]*DLinkedNode
	head, tail *DLinkedNode
}

type DLinkedNode struct {
	key        string
	value      int
	prev, next *DLinkedNode
}

func initDLinkedNode(key string, value int) *DLinkedNode {
	return &DLinkedNode{
		key:   key,
		value: value,
	}
}

func CreateLRUCache(capacity int) LRUCache {
	l := LRUCache{
		cache:    map[string]*DLinkedNode{},
		head:     initDLinkedNode("", 0),
		tail:     initDLinkedNode("", 0),
		capacity: capacity,
	}
	l.head.next = l.tail
	l.tail.prev = l.head
	return l
}

func (this *LRUCache) Get(key string) int {
	if _, ok := this.cache[key]; !ok {
		return -1
	}
	node := this.cache[key]
	this.moveToHead(node)
	return node.value
}

func (this *LRUCache) Put(key string, value int) {
	if _, ok := this.cache[key]; !ok {
		node := initDLinkedNode(key, value)
		this.cache[key] = node
		this.addToHead(node)
		this.size++
		if this.size > this.capacity {
			removed := this.removeTail()
			delete(this.cache, removed.key)
			this.size--
		}
	} else {
		node := this.cache[key]
		node.value = value
		this.moveToHead(node)
	}
}

func (this *LRUCache) addToHead(node *DLinkedNode) {
	node.prev = this.head
	node.next = this.head.next
	this.head.next.prev = node
	this.head.next = node
}

func (this *LRUCache) removeNode(node *DLinkedNode) {
	node.prev.next = node.next
	node.next.prev = node.prev
}

func (this *LRUCache) moveToHead(node *DLinkedNode) {
	this.removeNode(node)
	this.addToHead(node)
}

func (this *LRUCache) removeTail() *DLinkedNode {
	node := this.tail.prev
	this.removeNode(node)
	return node
}

请用 go 语言实现一个 LRU 缓存的工具，创建时设置容量参数 capacity。
支持 get 方法，返回缓存的数据，不存在时返回 -1
支持 put 方法，如果 key 已存在，覆盖当前的值，如果不存在，插入数据，如果插入后保存的数据量超过了 capacity ，则逐出最久未使用的数据
需要实现以下函数完成上述任务：
`func CreateLRUCache(capacity int) LRUCache`
`func (this *LRUCache) Get(key string) int`
`func (this *LRUCache) Put(key string, value int)`

问题：写一段 golang 代码实现以下功能。
找出小于第n个斐波那契数的最大完全平方数
函数签名为 `func maxSquareNumber(n int) int`

答案：
```go
import (
	"fmt"
	"math"
)

func maxSquareNumber(n int) int {
	if n <= 2 {
		return 0
	}

	fibs := []int{0, 1}
	var maxSquare int

	for i := 2; i <= n; i++ {
		fibs = append(fibs, fibs[i-1]+fibs[i-2])
	}

	fib := fibs[len(fibs)-1]
	perfectSquares := make([]int, 0)
	for i := 1; i <= int(math.Sqrt(float64(fib))); i++ {
		perfectSquares = append(perfectSquares, i*i)
	}

	maxSquare = 0
	for _, square := range perfectSquares {
		if square < fib {
			maxSquare = square
		} else {
			break
		}
	}

	return maxSquare
}
```

----------------

package main
import "testing"

#<INSERT>

func TestLRU(t *testing.T) {
	lru := CreateLRUCache(2)

	lru.Put("a", 1)
	lru.Put("b", 2)
	lru.Put("c", 3)
	lru.Put("a", 4)

	if lru.Get("a") == 4 && lru.Get("b") == -1 && lru.Get("c") == 3 {
		t.Log("get expect")
	} else {
		t.Errorf("not equal with expected")
		t.FailNow()
	}
}


import (
	"container/heap"
)

type ArrayEntry struct {
	Index  int
	Value  int
	Cursor int
}
type KMergeArray []ArrayEntry

func (h KMergeArray) Len() int { return len(h) }
func (h KMergeArray) Less(i, j int) bool {
	return h[i].Value < h[j].Value || (h[i].Value == h[j].Value && h[i].Index < h[j].Index)
}
func (h KMergeArray) Swap(i, j int) { h[i], h[j] = h[j], h[i] }

func (h *KMergeArray) Push(x interface{}) {
	*h = append(*h, x.(ArrayEntry))
}

func (h *KMergeArray) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func MergeKSortedArrays(arrays [][]int) []int {
	var arrayEntry []ArrayEntry
	for i, array := range arrays {
		if len(array) != 0 {
			arrayEntry = append(arrayEntry, ArrayEntry{
				Index:  i,
				Value:  array[0],
				Cursor: 0,
			})
		}
	}
	h := KMergeArray(arrayEntry)
	heap.Init(&h)
	sorted := []int{}
	for len(h) > 0 {
		top := heap.Pop(&h).(ArrayEntry)
		sorted = append(sorted, top.Value)
		top.Cursor += 1
		if top.Cursor < len(arrays[top.Index]) {
			top.Value = arrays[top.Index][top.Cursor]
			heap.Push(&h, top)
		}
	}
	return sorted
}

请用 go 语言实现一个函数 `MergeKSortedArrays`，该函数接收一个二维整数数组作为输入参数，其中包含 k 个已排序的整数数组，要求将这 k 个数组合并成一个有序数组并返回。

函数签名：
```go
func MergeKSortedArrays(arrays [][]int) []int
```

要求：
1. 输入保证每个子数组都是按升序排列的
2. 请使用最小堆来实现该算法
3. 返回的数组应该是升序排列的

package main
import (
	"testing"
)

#<INSERT>
func TestMergeKSortedArrays(t *testing.T) {
	arrays := [][]int{
		{1, 3, 5, 7, 9, 11},
		{2, 4, 6, 8, 10, 12},
		{1, 2, 3, 5, 9, 10, 18},
	}
	sorted := MergeKSortedArrays(arrays)
	actual := sorted[6]
	expected := 4
	if actual == expected {
		t.Log("get data succeed")
	} else {
		t.Errorf("not equal with expected expected %v actual %v", expected, actual)
		t.FailNow()
	}

}


func EmployeeCountIf(list []Employee, fn func(e *Employee) bool) int {
	count := 0
	for i, _ := range list {
		if fn(&list[i]) {
			count += 1
		}
	}
	return count
}

func CountEmployeesAgeLtV2(age int) int {
	old := EmployeeCountIf(list, func(e *Employee) bool {
		return e.Age < age
	})
	return old
}

请用go语言回答, 为了灵活的支持查询各种员工统计信息，需要实现EmployeeCountIf(list []Employee, fn func(e *Employee) bool) int 函数，让调用者来决定查询条件。
基于EmployeeCountIf函数，重写CountEmployeesAgeLtV1实现,并将函数CountEmployeesAgeLtV1更名为CountEmployeesAgeLtV2,最终计算小于40岁的员工数量。
```go
type Employee struct {
	Name     string
	Age      int
	Vacation int
	Salary   int
}

var list = []Employee{
	{"Hao", 44, 0, 8000},
	{"Bob", 34, 10, 5000},
	{"Alice", 23, 5, 9000},
	{"Jack", 26, 0, 4000},
	{"Tom", 48, 9, 7500},
	{"Marry", 29, 0, 6000},
	{"Mike", 32, 8, 4000},
}

func CountEmployeesAgeLtV1(age int) int {
	count := 0
	for _, employee := range list {
		if employee.Age > age {
			count++
		}
	}
	return count
}
```
注意回答的代码中不要重复定义以上结构与变量

package main

import "testing"

#<INSERT>

type Employee struct {
	Name     string
	Age      int
	Vacation int
	Salary   int
}

var list = []Employee{
	{"Hao", 44, 0, 8000},
	{"Bob", 34, 10, 5000},
	{"Alice", 23, 5, 9000},
	{"Jack", 26, 0, 4000},
	{"Tom", 48, 9, 7500},
	{"Marry", 29, 0, 6000},
	{"Mike", 32, 8, 4000},
}

func TestEmploee_CountV2(t *testing.T) {
	result := CountEmployeesAgeLtV2(40)
	expected :=5
	if result != expected {
		t.Errorf("The number of employees aged over 40 years old is %d; expected %d", result, expected)
		t.FailNow()
	}

}


import (
	"container/heap"
)
type ArrayEntry struct {
	Index int
	Value int
}

type MaxHeap []ArrayEntry

func (h MaxHeap) Len() int { return len(h) }
func (h MaxHeap) Less(i, j int) bool {
	return h[i].Value > h[j].Value || (h[i].Value == h[j].Value && h[i].Index < h[j].Index)
}                               // 大顶堆
func (h MaxHeap) Swap(i, j int) { h[i], h[j] = h[j], h[i] }

func (h *MaxHeap) Push(x interface{}) {
	*h = append(*h, x.(ArrayEntry))
}

func (h *MaxHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func StructHeapSort(array []ArrayEntry) []ArrayEntry {
	h := MaxHeap(array)
	heap.Init(&h)
	sorted := []ArrayEntry{}
	for len(h) > 0 {
		sorted = append(sorted, heap.Pop(&h).(ArrayEntry))
	}
	return sorted
}

需要对一个Struct结构进行堆排序算法，请写出相关的代码
```go
type ArrayEntry struct {
	Index int
	Value int
}
```
排序的优先级是：Value降序，Index升序，优先按照Value排序，实现函数 func StructHeapSort(array []ArrayEntry) []ArrayEntry

package main
import (
	"testing"
)

#<INSERT>
func TestStructHeapSort(t *testing.T) {
	arrayEntry := []ArrayEntry{
		{Index: 1, Value: 3},
		{Index: 2, Value: 1},
		{Index: 3, Value: 2},
		{Index: 4, Value: 5},
		{Index: 5, Value: 1},
	}
	sorted := StructHeapSort(arrayEntry)
	actual := sorted[4]
	expected := ArrayEntry{
		5, 1,
	}
	if actual == expected {
		t.Log("get data succeed")
	} else {
		t.Errorf("not equal with expected expected %v actual %v", expected, actual)
		t.FailNow()
	}
	t.Log(sorted)
}


import "fmt"
type Task int
func ProcessTask(task Task) {
        fmt.Printf("Processing task %v\n", task)
}

func ProcessConcurrently(tasks []Task, maxConcurrent int, processFunc func(Task)) {
        var wg sync.WaitGroup
        semaphore := make(chan struct{}, maxConcurrent)
        for _, task := range tasks {
                wg.Add(1)
                semaphore <- struct{}{}
                go func(t Task) {
                        defer wg.Done()
                        processFunc(t)
                        <-semaphore
                }(task)
        }
        wg.Wait()
}

使用go实现一个函数ProcessConcurrently(tasks []Task, maxConcurrent int，processFunc func(Task))，接受一个任务列表并发地执行任务ProcessTask(task Task)，需要限制同时最多有maxConcurrent个任务在执行。

package main
import (
        "sync"
        "sync/atomic"
        "testing"
        "time"
)

#<INSERT>

func TestProcessConcurrently(t *testing.T) {
        maxConcurrent := 10
        numTasks := 50
        var concurrentCount int32
        var peakConcurrentCount int32
        mockProcessTask := func(task Task) {
                atomic.AddInt32(&concurrentCount, 1)
                for {
                        current := atomic.LoadInt32(&concurrentCount)
                        peak := atomic.LoadInt32(&peakConcurrentCount)
                        if current > peak {
                                if atomic.CompareAndSwapInt32(&peakConcurrentCount, peak, current) {
                                        break
                                }
                        } else {
                                break
                        }
                }
                time.Sleep(10 * time.Millisecond)
                atomic.AddInt32(&concurrentCount, -1)
        }

        tasks := make([]Task, numTasks)
        for i := range tasks {
                tasks[i] = Task(i + 1)
        }
        ProcessConcurrently(tasks, maxConcurrent,mockProcessTask)
        if peakConcurrentCount > int32(maxConcurrent) {
                t.Errorf("The peak number of concurrent tasks %v exceeded the limit of %v", peakConcurrentCount, maxConcurrent)
        }
}


import (
	"container/heap"
)

type IntHeap []int

func (h IntHeap) Len() int           { return len(h) }
func (h IntHeap) Less(i, j int) bool { return h[i] < h[j] } // 小顶堆
func (h IntHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }

func (h *IntHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}

func (h *IntHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[0 : n-1]
	return x
}

func HeapSort(slice []int) []int {
	h := IntHeap(slice)
	heap.Init(&h)
	sorted := []int{}

	for len(h) > 0 {
		sorted = append(sorted, heap.Pop(&h).(int))
	}

	return sorted
}

使用golang的结构实现一个[]int的堆排序算法，实现函数 `func HeapSort(slice []int) []int`

package main
import (
	"testing"
)
#<INSERT>

func TestHeapSort(t *testing.T) {
	unsorted := []int{3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5}
	sorted := HeapSort(unsorted)
	expected := 3
	actual := sorted[4]
	if actual != expected {
		t.Errorf("not equal with expected expected %v actual %v", expected, actual)
		t.FailNow()
	} else {
		t.Log("get data succeed")
	}
}


<form name="user-form">

用户名:

<input type="text" id="username" name="username" required>

电子邮件:

<input type="email" id="email" name="email" required>

性别:

<select id="gender" name="gender">

    <option value="male" selected>男性</option>

    <option value="female">女性</option>

</select>

<input type="submit" value="提交">

</form>

创建一个HMTL用户信息表单，要求: form name属性值为 "user-form", 必填项"username", "email", 非必选项"gender"，gender选项包含"male","female"二项，性别默认值选"male"
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

问题：写一段 python 代码实现以下功能。
找出小于第n个斐波那契数的最大完全平方数
函数命名为 max_square_number，输入为整数 n

答案：
```python
def max_square_number(n):
    if n <= 2:
        return 0  # 对于斐波那契数列的前两个数，没有完全平方数可用

    fibs = [0, 1]  # 存储斐波那契数列的前两个数
    squares = []  # 存储完全平方数的列表

    max_square = 0
    i = 2

    while i <= n:
        fibs.append(fibs[i-1] + fibs[i-2])  # 计算下一个斐波那契数
        i += 1

    fib = fibs[-1]
    perfect_squares = [i**2 for i in range(1, int(math.sqrt(fib)) + 1)]
    max_square = max(filter(lambda x: x < fib, perfect_squares))
    return max_square
```

----------------

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe("User Form", () => {

  let dom;

  let container;

  let form;

  beforeEach(() => {

    dom = new JSDOM(`#<INSERT>`);

    container = dom.window.document;

    form = container.querySelector("form");

  });

  test("should have correct form name", () => {

    expect(form).toHaveAttribute("name", "user-form");

  });

  test("should have required username field", () => {

    expect(form).toHaveAttribute("name", "user-form");

    expect(container.querySelector("#username")).toBeRequired;

  });

  test("should have required email field", () => {

    const emailInput = getByLabelText(container, "电子邮件:");

    expect(emailInput).toBeRequired();

  });

  test("should have gender field with correct default value", () => {

    const genderSelect = getByLabelText(container, "性别:");

    expect(genderSelect.value).toBe("male");

  });

});


type IPrint interface {
	PrintName() string
}

type HDFS struct {
	Name string
}

type Kafka struct {
	Name string
}

func CallName(p IPrint) string {
	return p.PrintName()
}

func (h HDFS) PrintName() string {
	return h.Name
}

func (k Kafka) PrintName() string {
	return k.Name
}

请用go语言回答，现在有一个接口IPrint和两个对象HDFS、Kafka，请实现如下功能：补全HDFS和Kafka的方法, 用以实现IPrint接口，并在最终的CallName()调用中，输出自己的Name:
```go
type IPrint interface {
    PrintName() string
}
type HDFS struct{
    Name string
}

type Kafka struct{
    Name string
}

func CallName(p IPrint) {
    fmt.Println(p.Print())
}
```

package main

import (
	"testing"
)

#<INSERT>
func TestHDFS_PrintName(t *testing.T) {
	hdfs := HDFS{Name: "HDFS"}
	expected := "HDFS"
	result := hdfs.PrintName()
	if result != expected {
		t.Errorf("HDFS.PrintName() = %s; expected %s", result, expected)
		t.FailNow()
	}
}

func TestKafka_PrintName(t *testing.T) {
	kafka := Kafka{Name: "Kafka"}
	expected := "Kafka"
	result := kafka.PrintName()
	if result != expected {
		t.Errorf("Kafka.PrintName() = %s; expected %s", result, expected)
		t.FailNow()
	}
}


<html>

<head>

  <meta charset="UTF-8">

  <meta http-equiv="X-UA-Compatible" content="IE=edge">

  <meta name="viewport" content="width=device-width, initial-scale=1.0">

</head>

<body>

  <img src="your_image.jpg" width="400" height="300" usemap="#myMap">

  <map name="myMap">

    <area shape="rect" coords="50,50,100,100" href="page1.html" alt="区域 1">

    <area shape="circle" coords="200,150,50" href="page2.html" alt="区域 2">

  </map>

</body>

</html>

在 HTML 中可以使用<map>和<area>标签来创建图片上的热点区域
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Image Hotspot Areas', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Check Image Element Exists', () => {

    expect(document.querySelector('img')).toBeDefined();

  });

  test('Check area Element Exists', async () => {

    const area1 = document.querySelector('area');

    expect(area1).toBeDefined();

  });

});


func CountEmployeesAgeLtV1(age int) int {
	count := 0
	for _, employee := range list {
		if employee.Age > age {
			count++
		}
	}
	return count
}

请用go语言回答，员工信息如下，请基于以下信息，统计出大于40岁的员工数量, 函数为CountEmployeesAgeLtV1(age int) int
```go
type Employee struct {
	Name     string
	Age      int
	Vacation int
	Salary   int
}

var list = []Employee{
	{"Hao", 44, 0, 8000},
	{"Bob", 34, 10, 5000},
	{"Alice", 23, 5, 9000},
	{"Jack", 26, 0, 4000},
	{"Tom", 48, 9, 7500},
	{"Marry", 29, 0, 6000},
	{"Mike", 32, 8, 4000},
}
```
注意回答的代码中不要重复定义以上结构与变量

package main

import "testing"

type Employee struct {
	Name     string
	Age      int
	Vacation int
	Salary   int
}

var list = []Employee{
	{"Hao", 44, 0, 8000},
	{"Bob", 34, 10, 5000},
	{"Alice", 23, 5, 9000},
	{"Jack", 26, 0, 4000},
	{"Tom", 48, 9, 7500},
	{"Marry", 29, 0, 6000},
	{"Mike", 32, 8, 4000},
}

#<INSERT>
func TestEmploee_CountV1(t *testing.T) {
	result := CountEmployeesAgeLtV1(40)
	expected := 2
	if result != expected {
		t.Errorf("The number of employees aged over 40 years old is %d; expected %d", result, expected)
		t.FailNow()
	}

}


func GetMaxSubStringLength(str string) int {
	maxLength := 0
	leftIndex := -1
	rightIndex := 0
	charMap := map[string]int{}

	for rightIndex = 0; rightIndex < len(str); rightIndex++ {
		if idx, ok := charMap[string(str[rightIndex])]; ok && idx > leftIndex {
			leftIndex = idx
		} else {
			if rightIndex - leftIndex > maxLength {
				maxLength = rightIndex - leftIndex
			}
		}

		charMap[string(str[rightIndex])] = rightIndex
	}

	return maxLength
}

请用 go 语言，求一个字符串中最长无重复子串的长度，实现函数 `func GetMaxSubStringLength(str string) int`

package main
import "testing"

#<INSERT>

func TestGetMaxSubStringLength(t *testing.T) {
	str := "abcdabcdeabcdabcd"
	expect := 5
	result := GetMaxSubStringLength(str)

	if result == expect {
		t.Log("get intersect success.")
	} else {
		t.Errorf("not equal with expected, expected: %v actual: %v", expect, result)
		t.FailNow()
	}
}


func IsIsomorphic(s, t string) bool {
    s2t := map[byte]byte{}
    t2s := map[byte]byte{}
    for i := range s {
        x, y := s[i], t[i]
        if s2t[x] > 0 && s2t[x] != y || t2s[y] > 0 && t2s[y] != x {
            return false
        }
        s2t[x] = y
        t2s[y] = x
    }
    return true
}

给定两个字符串 s 和 t ，请用 go 语言判断它们是否是同构的。

如果 s 中的字符可以按某种映射关系替换得到 t ，那么这两个字符串是同构的。

每个出现的字符都应当映射到另一个字符，同时不改变字符的顺序。不同字符不能映射到同一个字符上，相同字符只能映射到同一个字符上，字符可以映射到自己本身。
实现函数 `func IsIsomorphic(s, t string) bool`

package main
import "testing"

#<INSERT>

func TestIsIsomorphic(t *testing.T) {
	str1 := "foo"
	str2 := "add"
	expect := true
	result := IsIsomorphic(str1, str2)

	if result == expect {
		t.Log("get intersect success.")
	} else {
		t.Errorf("not equal with expected, expected: %v actual: %v", expect, result)
		t.FailNow()
	}
}


    标题1

    标题2

    标题3

    数据1

    数据2

    数据3

    数据4

    数据5

    数据6

    页脚信息

创建一个表格, 要求: 表格的内容由三个部分组成：1个表格标题 (<thead>)、表格正文 (<tbody>) 和表格页脚 (<tfoot>)
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Table Structure', () => {

    let dom;

    let container;

    beforeEach(() => {

      dom = new JSDOM(`#<INSERT>`);

      container = dom.window.document;

    });

    test('should have a table', () => {

      const table = container.querySelector('table');

      expect(table).toBeInTheDocument();

    });

    test('should have a table head', () => {

      const tableHead = container.querySelector('thead')

      expect(tableHead).toBeInTheDocument();

    });

    test('should have a table body', () => {

      const tableBody = container.querySelector('tbody')

      expect(tableBody).toBeInTheDocument();

    });

    test('should have a table foot', () => {

      const tableFoot = container.querySelector('tfoot')

      expect(tableFoot).toBeInTheDocument();

    });

  });


<form>

    用户名:

    <input type="text" id="username" name="username" placeholder="请输入用户名">

    密码:

    <input type="password" id="password" name="password" placeholder="请输入密码">

    <input type="submit" value="登录">

</form>

请写一个登录表单, 要求: 表单数据包含username和password, 用户名和密码的输入框的placeholder分别为"请输入用户名"和"请输入密码", 表单的提交按钮的文案为"登录"
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe("Login Form", () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test("test username input control", () => {

    const userInput = document.querySelector('[name="username"]');

    expect(userInput).toBeDefined();

  });

  test("test username input placeholder attribute", () => {

    expect(getByPlaceholderText(document, "请输入用户名")).toBeDefined();

  });

  test("test password input control", () => {

    const passwordInput = document.querySelector('[name="password"]');

    expect(passwordInput).toBeDefined();

  });

  test("test password input placeholder attribute", () => {

    expect(getByPlaceholderText(document, "请输入密码")).toBeDefined();

  });

});


<html lang="en">

<head>

  <meta charset="UTF-8">

  <meta http-equiv="X-UA-Compatible" content="IE=edge">

  <meta name="viewport" content="width=device-width, initial-scale=1.0">

  <title>Audio Player</title>

</head>

<body>

  <audio autoplay muted>

    <source src="your_audio.mp3" type="audio/mpeg">

  </audio>

</body>

</html>

创建一个音频播放器，要求自动播放，并默认静音
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Audio Player', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Check Audio Element Exists', () => {

    expect(document.querySelector('audio')).toBeDefined();

  });

  test('Check If Muted', () => {

    const audio = document.querySelector('audio');

    expect(audio.muted).toBe(false);

  });

  test('Check If Autoplay', () => {

    const audio = document.querySelector('audio');

    expect(audio.autoplay).toBe(true);

  })

});


图片上传表单

<form action="/action_page.php" method="post" enctype="multipart/form-data">

  选择图片:

  <input type="file" id="img" name="img" accept=".png, .jpeg, .jpg, .gif" multiple>

  <input type="submit" value="上传">

</form>

创建一个HMTL图片上传表单：要求只能上传png，jpeg，gif格式的图片，支持多文件上传。
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe("Upload Files Form", () => {

  const dom = new JSDOM(`#<INSERT>`);

  const input = dom.window.document.querySelector("input");

  test("should have file input control", () => {

    expect(input).not.toBeNull();

    expect(input.type).toBe("file");

  });

  test("only support image format", () => {

    expect(input.accept).toMatch(/.png|.jpeg|.gif/);

  });

  test("should support multiple files upload", () => {

    expect(input.multiple).toBeTruthy();

  });

});


标题输入框

<form action="/action_page.php">

  标题:

  <input type="text" id="title" name="title" pattern="[a-z]{2,20}" required title="请输入2-20个小写字母">

  <input type="submit" value="提交">

</form>

创建html一个标题输入框,要求:输入框id值为"title" 此处只能使用小写字母；用户必须至少输入两个字符，但不能超过二十个。
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Validator Form', () => {

    let dom;

    let container;

    let input;

    beforeEach(() => {

      dom = new JSDOM(`#<INSERT>`);

      container = dom.window.document;

      input = container.querySelector('#title');

    })

    // 模拟用户输入

    test('检查输入框的值是否已经改变', ()=>{

        fireEvent.input(input, { target: { value: 'testtitle' } })

        expect(input.value).toBe('testtitle')

    })

    test('模拟用户输入不符合规则的值', ()=>{

        fireEvent.input(input, { target: { value: "T" } })

        expect(input).toBeInvalid();

    })

  })


邮箱填写组件

<form action="/action_page.php">

  邮箱:

  <input type="email" id="email" name="email" autocomplete="user-email" required>

  <input type="submit" value="提交">

</form>

创建一个邮箱组件，支持表单自动填充，邮箱字段填充key为"user-email"
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe("Email Form", () => {

  let dom;

  let container;

  beforeEach(() => {

    dom = new JSDOM(`#<INSERT>`);

    container = dom.window.document;

  });

  test("邮箱输入框应该能够自动填充", () => {

    const input = container.querySelector("#email");

    expect(input).toHaveAttribute("autocomplete", "user-email");

  });

  test("邮箱输入框应该能够接收输入", () => {

    const input = container.querySelector("#email");

    // 模拟用户输入

    fireEvent.change(input, { target: { value: "test@example.com" } });

    // 检查输入框的值是否已经改变

    expect(input.value).toBe("test@example.com");

  });

});


func ReverseString(str string) string {
	s := []byte(str)
	for left, right := 0, len(s)-1; left < right; left++ {
		s[left], s[right] = s[right], s[left]
		right--
	}

	return string(s)
}

请用 go 语言编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组 s 的形式给出，实现函数 `func ReverseString(str string) string`

package main
import "testing"

#<INSERT>

func TestReverseString(t *testing.T) {
	s := "abcd"
	expect := "dcba"
	result := ReverseString(s)

	if result == expect {
		t.Log("get intersect success.")
	} else {
		t.Errorf("not equal with expected, expected: %v actual: %v", expect, result)
		t.FailNow()
	}
}


<html>

<body>

  <svg width="300" height="300">

    <polygon points="150,70 230,150 70,150" fill="none" stroke="black" stroke-width="2" />

  </svg>

</body>

</html>

创建一个矢量图，要求图的大小为 300*300px，在其中创建一个等边三角形，边长为 80px，并且底边与矢量图底边平行，三角形的中心位于图片中心。
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('SVG 图形测试', () => {

  let svg;

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  beforeEach(() => {

    svg = document.querySelector('svg');

  });

  test('SVG 尺寸应正确', () => {

    expect(svg.getAttribute('width')).toEqual('300');

    expect(svg.getAttribute('height')).toEqual('300');

  });

  test('等边三角形顶点坐标应正确', () => {

    const polygon = svg.querySelector('polygon');

    expect(polygon.getAttribute('points')).toEqual('150,70 230,150 70,150');

  });

})


  <template id="myTemplate">

这是模板的主体内容

      <slot name="description"></slot>

  </template>

创建一个HTML temlate模版，并预留在模版尾部预留具名slot插槽"description"
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('TemplateWithSlot', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Check Template Element Exists', () => {

    expect(document.querySelector('template')).toBeDefined();

  });

  test('Check Slot Element Exists', () => {

    expect(document.querySelector('slot')).toBeDefined();

  });

});


func Map[F, T any](s []F, f func(F) T) []T {
	ret := make([]T, 0, len(s))
	for _, v := range s {
		ret = append(ret, f(v))
	}
	return ret
}

使用go实现一个泛型函数 Map, 接受一个切片和一个函数作为参数。这个函数将被应用到切片的每个元素上，并返回一个新的切片，该切片包含函数应用后的结果。实现函数 `func Map[F, T any](s []F, f func(F) T) []T`

package main

import (
    "reflect"
    "testing"
    "fmt"
)

#<INSERT>

func TestMap(t *testing.T) {
    intSlice := []int{1, 2, 3}
    intExpected := []int{2, 4, 6}
    intResult := Map(intSlice, func(i int) int {
        return i * 2
    })

    if !reflect.DeepEqual(intResult, intExpected) {
        t.Errorf("Map(%v) = %v; want %v", intSlice, intResult, intExpected)
    }

    stringExpected := []string{"1", "2", "3"}
    stringResult := Map(intSlice, func(i int) string {
        return fmt.Sprintf("%d", i)
    })

    if !reflect.DeepEqual(stringResult, stringExpected) {
        t.Errorf("Map(%v) = %v; want %v", intSlice, stringResult, stringExpected)
    }
}


美丽的风景

在那遥远的地方，有一片壮丽的山脉。

山脉连绵起伏，云雾缭绕其间。

这里真的令人着迷！

创建一个网页，包含以下内容：一个一级标题“美丽的风景”；两个段落，第一段内容为“在那遥远的地方，有一片壮丽的山脉。”；第二段内容为“山脉连绵起伏，云雾缭绕其间。”；一个强调文本“这里真的令人着迷！”
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Document Structure', () => {

  const {window: { document}} = new JSDOM(`#<INSERT>`);

  test('Check h1 Text', () => {

    const h1 = document.querySelector('h1');

    expect(h1.textContent).toEqual('美丽的风景');

  });

  test('Check First p Text', () => {

    const firstP = document.querySelector('p');

    expect(firstP.textContent).toEqual('在那遥远的地方，有一片壮丽的山脉。');

  });

  test('Check Second p Text', () => {

    const secondP = document.querySelectorAll('p')[1];

    expect(secondP.textContent).toEqual('山脉连绵起伏，云雾缭绕其间。');

  });

  test('Check em Text', () => {

    const em = document.querySelector('em');

    expect(em.textContent).toEqual('这里真的令人着迷！');

  });

});


func Contains(arr []string, tiem string) bool {
	for _, v := range arr {
		if v == tiem {
			return true
		}
	}
	return false
}

请用 go 语言判断字符串数组中是否包含某个字符串，实现函数 `func Contains(arr []string, tiem string) bool`

package main
import "testing"

#<INSERT>

func TestContains(t *testing.T) {
	arr := []string{"a", "b", "c"}
	if Contains(arr, "c") && !Contains(arr, "d") {
		t.Log("get expect")
	} else {
		t.Errorf("not equal with expected")
		t.FailNow()
	}
}


<html><body>

<video width="200" height="200" autoplay>

  <source src="your_video.mp4" type="video/mp4">

</video>

</body></html>

创建一个200*200视频播放器，要求: 自动播放
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Video Player', () => {

const {

  window: { document },

} = new JSDOM(`#<INSERT>`);

  test('Check Video Element Exists', () => {

    expect(document.querySelector('video')).toBeDefined();

  });

  test('Check Video Autoplay', () => {

    const video = document.querySelector('video');

    expect(video.getAttribute('autoplay')).toEqual('');

  });

});


HTML 创建一个缩略语，内容为“HTML”，缩略语全称是“Hyper Text Markup Language”
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Abbreviation Test', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Paragraph should contain the correct abbreviation', () => {

    const p = document.querySelector('p');

    const abbr = p.querySelector('abbr');

    expect(abbr.textContent).toEqual('HTML');

    expect(abbr.title).toEqual('Hyper Text Markup Language');

  });

});


<html>

<head>

  <link rel="stylesheet" type="text/css" href="styles.css">

</head>

<body>

  <!-- 这里是页面内容 -->

</body>

</html>

编码在HTML中引入外部样式资源
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('External Style Linking', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Verify Style Import', () => {

    const styleLink = document.querySelector('link[rel="stylesheet"]');

    expect(styleLink).not.toBeNull();

  });

});


<html><head>

<style>

 .myStyle {

    color: red;

    font-size: 16px;

  }

</style>

</head>

<body>

</body></html>

在 HTML 的<head>部分创建一个内联样式
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Inline Style in Head', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Check Style Tag', () => {

    const styleElem = document.querySelector('style');

    expect(styleElem).not.toBeNull();

  });

});


<html>

<head>

  <meta name="keywords" content="key1,key2">

</head>

<body>

  <!-- 这里是页面内容 -->

</body>

</html>

指定HTML网页的关键字:"key1,key2"
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Meta Keywords Test', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Meta keywords should be correct', () => {

    const metaKeywords = document.querySelector('meta[name="keywords"]').getAttribute('content');

    expect(metaKeywords).toEqual('key1,key2');

  });

});


苹果

香蕉

西瓜

橘子

葡萄

创建一个有序列表, 要求: 列表项包含: 苹果, 香蕉, 西瓜, 橘子, 葡萄
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Ordered List Structure', () => {

    let dom;

    let container;

    beforeEach(() => {

      dom = new JSDOM(`#<INSERT>`);

      container = dom.window.document;

    });

    it('should have an ordered list', () => {

      const list = container.querySelector('ol');

      expect(list).toBeInTheDocument();

    });

    it('should have 5 list items', () => {

      const items = container.querySelectorAll('li');

      expect(items.length).toBe(5);

    });

    it('should have correct list items', () => {

      const fruits = ['苹果', '香蕉', '西瓜', '橘子', '葡萄'];

      fruits.forEach(fruit => {

        const item = getByText(container, fruit);

        expect(item).toBeInTheDocument();

      });

    });

  });


<html>

<head>

  <meta name="description" content="这是一个描述">

</head>

<body>

  <!-- 这里是页面内容 -->

</body>

</html>

指定HTML网页的描述:"这是一个描述"
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Meta Description Test', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Meta description should be correct', () => {

    const metaDescription = document.querySelector('meta[name="description"]').getAttribute('content');

    expect(metaDescription).toEqual('这是一个描述');

  });

});


北京

上海

广州

深圳

创建无序列表，包含："北京","上海","广州","深圳"四个元素
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('无序列表', () => {

  let document

  beforeEach(() => {

    const { window: { document:doc } } = new JSDOM(`#<INSERT>`);

    document = doc;

  })

  test('Test unordered list', () => {

    const ul = document.querySelector('ul');

    const li1 = ul.querySelector('li:nth-child(1)');

    const li2 = ul.querySelector('li:nth-child(2)');

    const li3 = ul.querySelector('li:nth-child(3)');

    const li4 = ul.querySelector('li:nth-child(4)');

    expect(li1.textContent).toEqual('北京');

    expect(li2.textContent).toEqual('上海');

    expect(li3.textContent).toEqual('广州');

    expect(li4.textContent).toEqual('深圳');

  });

});


<html>

<body>

  <iframe src="https://example.com" width="800" height="600"></iframe>

</body>

</html>

在 HTML 文档中嵌入外部内容，例如网页
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Embedded External Content', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Check Iframe Added', () => {

    const iframe = document.querySelector('iframe');

    expect(iframe).toBeDefined();

  });

});


<html>

<head>

  <script>

    console.log('这是内联脚本在头部');

  </script>

</head>

<body>

</body>

</html>

在HTML Head 内创建一段内联脚本
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Inline Script in Head', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Check Script Tag', () => {

    const scriptElem = document.querySelector('script');

    expect(scriptElem).not.toBeNull();

  });

});


知识宝库

  快来探索丰富的知识吧

HTML 文本排版题目，要求：有一个一级标题“知识宝库”；一段斜体的引导文字“快来探索丰富的知识吧”
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('HTML Structure', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('should have a h1 element with text "知识宝库"', () => {

    const h1 = document.querySelector('h1');

    expect(h1.textContent).toEqual('知识宝库');

  });

  test('should have an i element with text "快来探索丰富的知识吧"', () => {

    const i = document.querySelector('i');

    expect(i.textContent).toEqual('快来探索丰富的知识吧');

  });

});


<html>

<head>

  <title>我的标题</title>

</head>

<body>

  <!-- 这里是页面内容 -->

</body>

</html>

定义HTML文档标题, 标题名称为“我的标题”
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Document Title Test', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Title should be "我的标题"', () => {

    expect(document.title).toEqual('我的标题');

  });

});


<html>

<head>

  <meta charset="utf-8">

</head>

<body>

  <!-- 页面内容 -->

</body>

</html>

创建HTML文档，设置HTML文档的编码格式为utf-8
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Meta Charset Test', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Meta charset should be utf-8', () => {

    const metaCharset = document.querySelector('meta[charset]').getAttribute('charset');

    expect(metaCharset).toEqual('utf-8');

  });

});


这是一段普通文本。console.log('这是代码片段'); 又是一段普通文本。

Html 段落中，创建一个代码片段。
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe("Code Snippet Test", () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test("Paragraph should contain the correct code snippet", () => {

    const p = document.querySelector("p");

    const code = p.querySelector("code");

    expect(code.textContent).toEqual("console.log('这是代码片段');");

  });

});


创建一个链接，页面在新标签页中打开链接
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe("Paragraph Newline Test", () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('A Link with target="_blank"', () => {

    const link = document.querySelector('a');

    expect(link.target).toEqual('_blank');

  });

});


创建一个带有 data-id="123" 的元素。
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Data 属性测试', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test("Test data-id exist and value eq 123", ()=>{

    const element = document.querySelector('[data-id="123"]');

    expect(element).toBeDefined();

    expect(element.dataset.id).toEqual('123');

  })

});


创建一个引用内容，内容为“This is a quoted text.”
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Quote Test', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Paragraph should contain the correct quote', () => {

    const p = document.querySelector('p');

    const q = p.querySelector('q');

    expect(q.textContent).toEqual('This is a quoted text.');

  });

});


创建电子邮件链接，链接地址为："mailto:EMAIL"
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('Email Link Unit Test', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('Link should exist', () => {

    const link = document.querySelector('a[href="mailto:EMAIL"]');

    expect(link).toBeDefined();

  });

  test('Link href should be correct', () => {

    const link = document.querySelector('a[href="mailto:EMAIL"]');

    expect(link.getAttribute('href')).toEqual('mailto:EMAIL');

  });

});


Html段落中，给“hello world” 添加删除线
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe("Strikethrough Text Test", () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('"hello world" should have strikethrough in the paragraph', () => {

    const p = document.querySelector("p");

    const del = p.querySelector("del");

    expect(del.textContent).toEqual("hello world");

  });

});


在html 段落中，对文本“hello world”添加粗体
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe('HTML Text Bold Test', () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('should have "hello world" in Bold', () => {

    const bold = document.querySelector("b");

    expect(bold.textContent).toEqual('hello world');

  });

});


在html 段落中，给“hello world”文本加粗
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe("Email Form", () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test('"hello world" should be bold in the paragraph', () => {

    const p = document.querySelector("p");

    const b = p.querySelector("b");

    expect(b.textContent).toEqual("hello world");

  });

});


创建一条HTML 分割线，写代码，并给出单元测试用例
请将答案代码用 markdown code block 格式包裹，如
```html
[code]
```

import "@testing-library/jest-dom/jest-globals";

import { JSDOM } from "jsdom";

import { getByLabelText, getByPlaceholderText, fireEvent, getByText } from "@testing-library/dom";

describe("Horizontal Rule Test", () => {

  const {

    window: { document },

  } = new JSDOM(`#<INSERT>`);

  test("Horizontal Rule should exist", () => {

    const hr = document.querySelector("hr");

    expect(hr).not.toBeNull();

  });

});


class Solution(object):
    def maxSpending(self, values):
        """
        :type values: List[List[int]]
        :rtype: int
        """
        exit(0)

给你一个下标从 **0** 开始大小为 `m * n` 的整数矩阵 `values` ，表示 `m` 个不同商店里 `m * n` 件不同的物品。每个商店有 `n` 件物品，第 `i` 个商店的第 `j` 件物品的价值为 `values[i][j]` 。除此以外，第 `i` 个商店的物品已经按照价值非递增排好序了，也就是说对于所有 `0 <= j < n - 1` 都有 `values[i][j] >= values[i][j + 1]` 。

每一天，你可以在一个商店里购买一件物品。具体来说，在第 `d` 天，你可以：

* 选择商店 `i` 。
* 购买数组中最右边的物品 `j` ，开销为 `values[i][j] * d` 。换句话说，选择该商店中还没购买过的物品中最大的下标 `j` ，并且花费 `values[i][j] * d` 去购买。

**注意**，所有物品都视为不同的物品。比方说如果你已经从商店 `1` 购买了物品 `0` ，你还可以在别的商店里购买其他商店的物品 `0` 。

请你返回购买所有 `m * n` 件物品需要的 **最大开销** 。

**示例 1：**

```

**输入：**values = [[8,5,2],[6,4,1],[9,7,3]]
**输出：**285
**解释：**第一天，从商店 1 购买物品 2 ，开销为 values[1][2] * 1 = 1 。
第二天，从商店 0 购买物品 2 ，开销为 values[0][2] * 2 = 4 。
第三天，从商店 2 购买物品 2 ，开销为 values[2][2] * 3 = 9 。
第四天，从商店 1 购买物品 1 ，开销为 values[1][1] * 4 = 16 。
第五天，从商店 0 购买物品 1 ，开销为 values[0][1] * 5 = 25 。
第六天，从商店 1 购买物品 0 ，开销为 values[1][0] * 6 = 36 。
第七天，从商店 2 购买物品 1 ，开销为 values[2][1] * 7 = 49 。
第八天，从商店 0 购买物品 0 ，开销为 values[0][0] * 8 = 64 。
第九天，从商店 2 购买物品 0 ，开销为 values[2][0] * 9 = 81 。
所以总开销为 285 。
285 是购买所有 m * n 件物品的最大总开销。

```

**示例 2：**

```

**输入：**values = [[10,8,6,4,2],[9,7,5,3,2]]
**输出：**386
**解释：**第一天，从商店 0 购买物品 4 ，开销为 values[0][4] * 1 = 2 。
第二天，从商店 1 购买物品 4 ，开销为 values[1][4] * 2 = 4 。
第三天，从商店 1 购买物品 3 ，开销为 values[1][3] * 3 = 9 。
第四天，从商店 0 购买物品 3 ，开销为 values[0][3] * 4 = 16 。
第五天，从商店 1 购买物品 2 ，开销为 values[1][2] * 5 = 25 。
第六天，从商店 0 购买物品 2 ，开销为 values[0][2] * 6 = 36 。
第七天，从商店 1 购买物品 1 ，开销为 values[1][1] * 7 = 49 。
第八天，从商店 0 购买物品 1 ，开销为 values[0][1] * 8 = 64 。
第九天，从商店 1 购买物品 0 ，开销为 values[1][0] * 9 = 81 。
第十天，从商店 0 购买物品 0 ，开销为 values[0][0] * 10 = 100 。
所以总开销为 386 。
386 是购买所有 m * n 件物品的最大总开销。

```

**提示：**

* `1 <= m == values.length <= 10`
* `1 <= n == values[i].length <= 104`
* `1 <= values[i][j] <= 106`
* `values[i]` 按照非递增顺序排序。

请完成以下实现
```python
class Solution(object):
    def maxSpending(self, values):
        '''
        :type values: List[List[int]]
        :rtype: int
        '''
```

问题：
给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出 和为目标值 target  的那 两个 整数，并返回它们的数组下标。

你可以假设每种输入只会对应一个答案。但是，数组中同一个元素在答案里不能重复出现。

你可以按任意顺序返回答案。

示例 1：

输入：nums = [2,7,11,15], target = 9
输出：[0,1]
解释：因为 nums[0] + nums[1] == 9 ，返回 [0, 1] 。
示例 2：

输入：nums = [3,2,4], target = 6
输出：[1,2]
示例 3：

输入：nums = [3,3], target = 6
输出：[0,1]

提示：

2 <= nums.length <= 104
-109 <= nums[i] <= 109
-109 <= target <= 109
只会存在一个有效答案

请完成以下实现
```python
class Solution(object):
    def twoSum(self, nums, target):
        '''
        :type nums: List[int]
        :type target: int
        :rtype: List[int]
        '''
```

答案：
```python
class Solution:
    def twoSum(self, nums, target):
        n = len(nums)
        for i in range(n):
            for j in range(i + 1, n):
                if nums[i] + nums[j] == target:
                    return [i, j]
        return []
```

----------------


class Solution(object):
    def findHighAccessEmployees(self, access_times):
        """
        :type access_times: List[List[str]]
        :rtype: List[str]
        """
        exit(0)

给你一个长度为 `n` 、下标从 **0** 开始的二维字符串数组 `access_times` 。对于每个 `i`（`0 <= i <= n - 1` ），`access_times[i][0]` 表示某位员工的姓名，`access_times[i][1]` 表示该员工的访问时间。`access_times` 中的所有条目都发生在同一天内。

访问时间用 **四位** 数字表示， 符合 **24 小时制** ，例如 `"0800"` 或 `"2250"` 。

如果员工在 **同一小时内** 访问系统 **三次或更多** ，则称其为 **高访问** 员工。

时间间隔正好相差一小时的时间 **不** 被视为同一小时内。例如，`"0815"` 和 `"0915"` 不属于同一小时内。

一天开始和结束时的访问时间不被计算为同一小时内。例如，`"0005"` 和 `"2350"` 不属于同一小时内。

以列表形式，按任意顺序，返回所有 **高访问** 员工的姓名。

**示例 1：**

```

**输入：**access_times = [["a","0549"],["b","0457"],["a","0532"],["a","0621"],["b","0540"]]
**输出：**["a"]
**解释：**"a" 在时间段 [05:32, 06:31] 内有三条访问记录，时间分别为 05:32 、05:49 和 06:21 。
但是 "b" 的访问记录只有两条。
因此，答案是 ["a"] 。
```

**示例 2：**

```

**输入：**access_times = [["d","0002"],["c","0808"],["c","0829"],["e","0215"],["d","1508"],["d","1444"],["d","1410"],["c","0809"]]
**输出：**["c","d"]
**解释：**"c" 在时间段 [08:08, 09:07] 内有三条访问记录，时间分别为 08:08 、08:09 和 08:29 。
"d" 在时间段 [14:10, 15:09] 内有三条访问记录，时间分别为 14:10 、14:44 和 15:08 。
然而，"e" 只有一条访问记录，因此不能包含在答案中，最终答案是 ["c","d"] 。
```

**示例 3：**

```

**输入：**access_times = [["cd","1025"],["ab","1025"],["cd","1046"],["cd","1055"],["ab","1124"],["ab","1120"]]
**输出：**["ab","cd"]
**解释：**"ab"在时间段 [10:25, 11:24] 内有三条访问记录，时间分别为 10:25 、11:20 和 11:24 。
"cd" 在时间段 [10:25, 11:24] 内有三条访问记录，时间分别为 10:25 、10:46 和 10:55 。
因此，答案是 ["ab","cd"] 。
```

**提示：**

* `1 <= access_times.length <= 100`
* `access_times[i].length == 2`
* `1 <= access_times[i][0].length <= 10`
* `access_times[i][0]` 仅由小写英文字母组成。
* `access_times[i][1].length == 4`
* `access_times[i][1]` 采用24小时制表示时间。
* `access_times[i][1]` 仅由数字 `'0'` 到 `'9'` 组成。

请完成以下实现
```python
class Solution(object):
    def findHighAccessEmployees(self, access_times):
        '''
        :type access_times: List[List[str]]
        :rtype: List[str]
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.findHighAccessEmployees(*[[['a', '0549'], ['b', '0457'], ['a', '0532'], ['a', '0621'], ['b', '0540']]]) == ["a"]

assert my_solution.findHighAccessEmployees(*[[['d', '0002'], ['c', '0808'], ['c', '0829'], ['e', '0215'], ['d', '1508'], ['d', '1444'], ['d', '1410'], ['c', '0809']]]) == ["c", "d"]

assert my_solution.findHighAccessEmployees(*[[['cd', '1025'], ['ab', '1025'], ['cd', '1046'], ['cd', '1055'], ['ab', '1124'], ['ab', '1120']]]) == ["ab", "cd"]

assert my_solution.findHighAccessEmployees(*[[['baipstt', '1456']]]) == []

assert my_solution.findHighAccessEmployees(*[[['bouo', '1126']]]) == []

assert my_solution.findHighAccessEmployees(*[[['cavfbqg', '2304']]]) == []

assert my_solution.findHighAccessEmployees(*[[['cenjcq', '1007']]]) == []

assert my_solution.findHighAccessEmployees(*[[['cqotrwqcaq', '0131']]]) == []

assert my_solution.findHighAccessEmployees(*[[['downbuk', '1951']]]) == []

assert my_solution.findHighAccessEmployees(*[[['dqsoiyz', '2204']]]) == []

assert my_solution.findHighAccessEmployees(*[[['duzeyrov', '0243']]]) == []

assert my_solution.findHighAccessEmployees(*[[['erfg', '1223']]]) == []

assert my_solution.findHighAccessEmployees(*[[['fwhefd', '2026']]]) == []

assert my_solution.findHighAccessEmployees(*[[['gbefbne', '0911']]]) == []

assert my_solution.findHighAccessEmployees(*[[['gp', '1540']]]) == []

assert my_solution.findHighAccessEmployees(*[[['ht', '1319']]]) == []

assert my_solution.findHighAccessEmployees(*[[['inahnsjdqz', '1750']]]) == []

assert my_solution.findHighAccessEmployees(*[[['jwxvijxo', '0851']]]) == []

assert my_solution.findHighAccessEmployees(*[[['kibwwvjuez', '0716']]]) == []

assert my_solution.findHighAccessEmployees(*[[['lvry', '0706']]]) == []


class Solution(object):
    def getWordsInLongestSubsequence(self, n, words, groups):
        """
        :type n: int
        :type words: List[str]
        :type groups: List[int]
        :rtype: List[str]
        """
        exit(0)

给你一个整数 `n` 和一个下标从 **0** 开始的字符串数组 `words` ，和一个下标从 **0** 开始的数组 `groups` ，两个数组长度都是 `n` 。

两个长度相等字符串的 **汉明距离** 定义为对应位置字符 **不同** 的数目。

你需要从下标 `[0, 1, ..., n - 1]` 中选出一个 **最长子序列** ，将这个子序列记作长度为 `k` 的 `[i0, i1, ..., ik - 1]` ，它需要满足以下条件：

* **相邻** 下标对应的 `groups` 值 **不同**。即，对于所有满足 `0 < j + 1 < k` 的 `j` 都有 `groups[ij] != groups[ij + 1]` 。
* 对于所有 `0 < j + 1 < k` 的下标 `j` ，都满足 `words[ij]` 和 `words[ij + 1]` 的长度 **相等** ，且两个字符串之间的 **汉明距离** 为 `1` 。

请你返回一个字符串数组，它是下标子序列 **依次** 对应 `words` 数组中的字符串连接形成的字符串数组。如果有多个答案，返回任意一个。

**子序列** 指的是从原数组中删掉一些（也可能一个也不删掉）元素，剩余元素不改变相对位置得到的新的数组。

**注意：**`words` 中的字符串长度可能 **不相等** 。

**示例 1：**

```

**输入：**n = 3, words = ["bab","dab","cab"], groups = [1,2,2]
**输出：**["bab","cab"]
**解释：**一个可行的子序列是 [0,2] 。
- groups[0] != groups[2]
- words[0].length == words[2].length 且它们之间的汉明距离为 1 。
所以一个可行的答案是 [words[0],words[2]] = ["bab","cab"] 。
另一个可行的子序列是 [0,1] 。
- groups[0] != groups[1]
- words[0].length = words[1].length 且它们之间的汉明距离为 1 。
所以另一个可行的答案是 [words[0],words[1]] = ["bab","dab"] 。
符合题意的最长子序列的长度为 2 。
```

**示例 2：**

```

**输入：**n = 4, words = ["a","b","c","d"], groups = [1,2,3,4]
**输出：**["a","b","c","d"]
**解释：**我们选择子序列 [0,1,2,3] 。
它同时满足两个条件。
所以答案为 [words[0],words[1],words[2],words[3]] = ["a","b","c","d"] 。
它是所有下标子序列里最长且满足所有条件的。
所以它是唯一的答案。

```

**提示：**

* `1 <= n == words.length == groups.length <= 1000`
* `1 <= words[i].length <= 10`
* `1 <= groups[i] <= n`
* `words` 中的字符串 **互不相同** 。
* `words[i]` 只包含小写英文字母。

请完成以下实现
```python
class Solution(object):
    def getWordsInLongestSubsequence(self, n, words, groups):
        '''
        :type n: int
        :type words: List[str]
        :type groups: List[int]
        :rtype: List[str]
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.getWordsInLongestSubsequence(*[3, ['bab', 'dab', 'cab'], [1, 2, 2]]) == ["bab", "cab"]

assert my_solution.getWordsInLongestSubsequence(*[4, ['a', 'b', 'c', 'd'], [1, 2, 3, 4]]) == ["a", "b", "c", "d"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['abbbb'], [1]]) == ["abbbb"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['ad'], [1]]) == ["ad"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['baaccb'], [1]]) == ["baaccb"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['bc'], [1]]) == ["bc"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['bdb'], [1]]) == ["bdb"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['cc'], [1]]) == ["cc"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['cd'], [1]]) == ["cd"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['cdb'], [1]]) == ["cdb"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['cea'], [1]]) == ["cea"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['cebbbb'], [1]]) == ["cebbbb"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['da'], [1]]) == ["da"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['daab'], [1]]) == ["daab"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['adbe', 'acace'], [2, 2]]) == ["acace"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['ba', 'dc'], [1, 1]]) == ["dc"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['baa', 'ada'], [1, 2]]) == ["ada"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['bebea', 'ddecc'], [1, 1]]) == ["ddecc"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['cedbca', 'db'], [1, 1]]) == ["db"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['dbcdd', 'baba'], [2, 1]]) == ["baba"]


给你一个整数 `n` 和一个下标从 **0** 开始的字符串数组 `words` ，和一个下标从 **0** 开始的 **二进制** 数组 `groups` ，两个数组长度都是 `n` 。

你需要从下标 `[0, 1, ..., n - 1]` 中选出一个 **最长子序列** ，将这个子序列记作长度为 `k` 的 `[i0, i1, ..., ik - 1]` ，对于所有满足 `0 < j + 1 < k` 的 `j` 都有 `groups[ij] != groups[ij + 1]` 。

请你返回一个字符串数组，它是下标子序列 **依次** 对应 `words` 数组中的字符串连接形成的字符串数组。如果有多个答案，返回任意一个。

**子序列** 指的是从原数组中删掉一些（也可能一个也不删掉）元素，剩余元素不改变相对位置得到的新的数组。

**注意：**`words` 中的字符串长度可能 **不相等** 。

**示例 1：**

```

**输入：**n = 3, words = ["e","a","b"], groups = [0,0,1]
**输出：**["e","b"]
**解释：**一个可行的子序列是 [0,2] ，因为 groups[0] != groups[2] 。
所以一个可行的答案是 [words[0],words[2]] = ["e","b"] 。
另一个可行的子序列是 [1,2] ，因为 groups[1] != groups[2] 。
得到答案为 [words[1],words[2]] = ["a","b"] 。
这也是一个可行的答案。
符合题意的最长子序列的长度为 2 。
```

**示例 2：**

```

**输入：**n = 4, words = ["a","b","c","d"], groups = [1,0,1,1]
**输出：**["a","b","c"]
**解释：**一个可行的子序列为 [0,1,2] 因为 groups[0] != groups[1] 且 groups[1] != groups[2] 。
所以一个可行的答案是 [words[0],words[1],words[2]] = ["a","b","c"] 。
另一个可行的子序列为 [0,1,3] 因为 groups[0] != groups[1] 且 groups[1] != groups[3] 。
得到答案为 [words[0],words[1],words[3]] = ["a","b","d"] 。
这也是一个可行的答案。
符合题意的最长子序列的长度为 3 。
```

**提示：**

* `1 <= n == words.length == groups.length <= 100`
* `1 <= words[i].length <= 10`
* `0 <= groups[i] < 2`
* `words` 中的字符串 **互不相同** 。
* `words[i]` 只包含小写英文字母。

请完成以下实现
```python
class Solution(object):
    def getWordsInLongestSubsequence(self, n, words, groups):
        '''
        :type n: int
        :type words: List[str]
        :type groups: List[int]
        :rtype: List[str]
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.getWordsInLongestSubsequence(*[3, ['e', 'a', 'b'], [0, 0, 1]]) == ["e", "b"]

assert my_solution.getWordsInLongestSubsequence(*[4, ['a', 'b', 'c', 'd'], [1, 0, 1, 1]]) == ["a", "b", "c"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['c'], [0]]) == ["c"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['d'], [1]]) == ["d"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['e'], [0]]) == ["e"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['fe'], [0]]) == ["fe"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['frl'], [1]]) == ["frl"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['ha'], [1]]) == ["ha"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['l'], [0]]) == ["l"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['n'], [1]]) == ["n"]

assert my_solution.getWordsInLongestSubsequence(*[1, ['s'], [1]]) == ["s"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['d', 'g'], [0, 1]]) == ["d", "g"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['lr', 'h'], [0, 0]]) == ["lr"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['wx', 'h'], [0, 1]]) == ["wx", "h"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['yw', 'n'], [0, 1]]) == ["yw", "n"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['z', 'n'], [0, 0]]) == ["z"]

assert my_solution.getWordsInLongestSubsequence(*[2, ['zr', 'a'], [0, 0]]) == ["zr"]

assert my_solution.getWordsInLongestSubsequence(*[3, ['h', 'vv', 'kp'], [0, 1, 0]]) == ["h", "vv", "kp"]

assert my_solution.getWordsInLongestSubsequence(*[3, ['m', 'v', 'y'], [0, 1, 0]]) == ["m", "v", "y"]

assert my_solution.getWordsInLongestSubsequence(*[3, ['o', 'cfy', 'en'], [1, 0, 0]]) == ["o", "cfy"]


class Solution(object):
    def minIncrementOperations(self, nums, k):
        """
        :type nums: List[int]
        :type k: int
        :rtype: int
        """
        exit(0)

给你一个下标从 **0** 开始、长度为 `n` 的整数数组 `nums` ，和一个整数 `k` 。

你可以执行下述 **递增** 运算 **任意** 次（可以是 **0** 次）：

* 从范围 `[0, n - 1]` 中选择一个下标 `i` ，并将 `nums[i]` 的值加 `1` 。

如果数组中任何长度 **大于或等于 3** 的子数组，其 **最大** 元素都大于或等于 `k` ，则认为数组是一个 **美丽数组** 。

以整数形式返回使数组变为 **美丽数组** 需要执行的 **最小** 递增运算数。

子数组是数组中的一个连续 **非空** 元素序列。

**示例 1：**

```

**输入：**nums = [2,3,0,0,2], k = 4
**输出：**3
**解释：**可以执行下述递增运算，使 nums 变为美丽数组：
选择下标 i = 1 ，并且将 nums[1] 的值加 1 -> [2,4,0,0,2] 。
选择下标 i = 4 ，并且将 nums[4] 的值加 1 -> [2,4,0,0,3] 。
选择下标 i = 4 ，并且将 nums[4] 的值加 1 -> [2,4,0,0,4] 。
长度大于或等于 3 的子数组为 [2,4,0], [4,0,0], [0,0,4], [2,4,0,0], [4,0,0,4], [2,4,0,0,4] 。
在所有子数组中，最大元素都等于 k = 4 ，所以 nums 现在是美丽数组。
可以证明无法用少于 3 次递增运算使 nums 变为美丽数组。
因此，答案为 3 。

```

**示例 2：**

```

**输入：**nums = [0,1,3,3], k = 5
**输出：**2
**解释：**可以执行下述递增运算，使 nums 变为美丽数组：
选择下标 i = 2 ，并且将 nums[2] 的值加 1 -> [0,1,4,3] 。
选择下标 i = 2 ，并且将 nums[2] 的值加 1 -> [0,1,5,3] 。
长度大于或等于 3 的子数组为 [0,1,5]、[1,5,3]、[0,1,5,3] 。
在所有子数组中，最大元素都等于 k = 5 ，所以 nums 现在是美丽数组。
可以证明无法用少于 2 次递增运算使 nums 变为美丽数组。
因此，答案为 2 。

```

**示例 3：**

```

**输入：**nums = [1,1,2], k = 1
**输出：**0
**解释：**在这个示例中，只有一个长度大于或等于 3 的子数组 [1,1,2] 。
其最大元素 2 已经大于 k = 1 ，所以无需执行任何增量运算。
因此，答案为 0 。

```

**提示：**

* `3 <= n == nums.length <= 105`
* `0 <= nums[i] <= 109`
* `0 <= k <= 109`

请完成以下实现
```python
class Solution(object):
    def minIncrementOperations(self, nums, k):
        '''
        :type nums: List[int]
        :type k: int
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.minIncrementOperations(*[[2, 3, 0, 0, 2], 4]) == 3

assert my_solution.minIncrementOperations(*[[0, 1, 3, 3], 5]) == 2

assert my_solution.minIncrementOperations(*[[1, 1, 2], 1]) == 0

assert my_solution.minIncrementOperations(*[[0, 5, 5], 8]) == 3

assert my_solution.minIncrementOperations(*[[0, 18, 28], 93]) == 65

assert my_solution.minIncrementOperations(*[[0, 24, 14], 7]) == 0

assert my_solution.minIncrementOperations(*[[2, 3, 4], 3]) == 0

assert my_solution.minIncrementOperations(*[[3, 5, 9], 6]) == 0

assert my_solution.minIncrementOperations(*[[4, 3, 0], 2]) == 0

assert my_solution.minIncrementOperations(*[[5, 6, 5], 9]) == 3

assert my_solution.minIncrementOperations(*[[6, 9, 6], 3]) == 0

assert my_solution.minIncrementOperations(*[[7, 9, 0], 6]) == 0

assert my_solution.minIncrementOperations(*[[7, 47, 16], 39]) == 0

assert my_solution.minIncrementOperations(*[[9, 6, 1], 6]) == 0

assert my_solution.minIncrementOperations(*[[41, 44, 37], 55]) == 11

assert my_solution.minIncrementOperations(*[[48, 3, 13], 1]) == 0

assert my_solution.minIncrementOperations(*[[1, 2, 6, 9], 8]) == 2

assert my_solution.minIncrementOperations(*[[1, 3, 1, 6], 6]) == 3

assert my_solution.minIncrementOperations(*[[2, 35, 41, 20], 4]) == 0

assert my_solution.minIncrementOperations(*[[3, 9, 9, 7], 6]) == 0


class Solution(object):
    def beautifulSubstrings(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: int
        """
        exit(0)

给你一个字符串 `s` 和一个正整数 `k` 。

用 `vowels` 和 `consonants` 分别表示字符串中元音字母和辅音字母的数量。

如果某个字符串满足以下条件，则称其为 **美丽字符串** ：

* `vowels == consonants`，即元音字母和辅音字母的数量相等。
* `(vowels * consonants) % k == 0`，即元音字母和辅音字母的数量的乘积能被 `k` 整除。

返回字符串 `s` 中 **非空美丽子字符串** 的数量。

子字符串是字符串中的一个连续字符序列。

英语中的 **元音字母** 为 `'a'`、`'e'`、`'i'`、`'o'` 和 `'u'` 。

英语中的 **辅音字母** 为除了元音字母之外的所有字母。

**示例 1：**

```

**输入：**s = "baeyh", k = 2
**输出：**2
**解释：**字符串 s 中有 2 个美丽子字符串。
- 子字符串 "b***aeyh***"，vowels = 2（["a","e"]），consonants = 2（["y","h"]）。
可以看出字符串 "aeyh" 是美丽字符串，因为 vowels == consonants 且 vowels * consonants % k == 0 。
- 子字符串 "***baey***h"，vowels = 2（["a","e"]），consonants = 2（["b","y"]）。
可以看出字符串 "baey" 是美丽字符串，因为 vowels == consonants 且 vowels * consonants % k == 0 。
可以证明字符串 s 中只有 2 个美丽子字符串。

```

**示例 2：**

```

**输入：**s = "abba", k = 1
**输出：**3
**解释：**字符串 s 中有 3 个美丽子字符串。
- 子字符串 "***ab***ba"，vowels = 1（["a"]），consonants = 1（["b"]）。
- 子字符串 "ab***ba***"，vowels = 1（["a"]），consonants = 1（["b"]）。
- 子字符串 "***abba***"，vowels = 2（["a","a"]），consonants = 2（["b","b"]）。
可以证明字符串 s 中只有 3 个美丽子字符串。

```

**示例 3：**

```

**输入：**s = "bcdf", k = 1
**输出：**0
**解释：**字符串 s 中没有美丽子字符串。

```

**提示：**

* `1 <= s.length <= 5 * 104`
* `1 <= k <= 1000`
* `s` 仅由小写英文字母组成。

请完成以下实现
```python
class Solution(object):
    def beautifulSubstrings(self, s, k):
        '''
        :type s: str
        :type k: int
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.beautifulSubstrings(*['baeyh', 2]) == 2

assert my_solution.beautifulSubstrings(*['abba', 1]) == 3

assert my_solution.beautifulSubstrings(*['bcdf', 1]) == 0

assert my_solution.beautifulSubstrings(*['ihroyeeb', 5]) == 0

assert my_solution.beautifulSubstrings(*['uzuxpzou', 3]) == 1

assert my_solution.beautifulSubstrings(*['ouuoeqd', 2]) == 1

assert my_solution.beautifulSubstrings(*['eeebjoxxujuaeoqibd', 8]) == 4

assert my_solution.beautifulSubstrings(*['ilougekqlovegioemdvu', 4]) == 21

assert my_solution.beautifulSubstrings(*['tqaewreikaztwpfwnef', 8]) == 3

assert my_solution.beautifulSubstrings(*['oykiuhsafgfjumnzb', 7]) == 0

assert my_solution.beautifulSubstrings(*['ifvsa', 3]) == 0

assert my_solution.beautifulSubstrings(*['svzauyuevujektj', 5]) == 3

assert my_solution.beautifulSubstrings(*['urahjig', 2]) == 2

assert my_solution.beautifulSubstrings(*['ime', 2]) == 0

assert my_solution.beautifulSubstrings(*['oacghieut', 5]) == 0

assert my_solution.beautifulSubstrings(*['aoluu', 3]) == 0

assert my_solution.beautifulSubstrings(*['ioaoiciiuoziout', 1]) == 5

assert my_solution.beautifulSubstrings(*['ouafupsuhid', 6]) == 0

assert my_solution.beautifulSubstrings(*['ox', 2]) == 0

assert my_solution.beautifulSubstrings(*['tlaiwoauazutusiaaui', 10]) == 0


class Solution(object):
    def lexicographicallySmallestArray(self, nums, limit):
        """
        :type nums: List[int]
        :type limit: int
        :rtype: List[int]
        """
        exit(0)

给你一个下标从 **0** 开始的 **正整数** 数组 `nums` 和一个 **正整数** `limit` 。

在一次操作中，你可以选择任意两个下标 `i` 和 `j`，**如果** 满足 `|nums[i] - nums[j]| <= limit` ，则交换 `nums[i]` 和 `nums[j]` 。

返回执行任意次操作后能得到的 **字典序最小的数组**。

如果在数组 `a` 和数组 `b` 第一个不同的位置上，数组 `a` 中的对应元素比数组 `b` 中的对应元素的字典序更小，则认为数组 `a` 就比数组 `b` 字典序更小。例如，数组 `[2,10,3]` 比数组 `[10,2,3]` 字典序更小，下标 `0` 处是两个数组第一个不同的位置，且 `2 < 10` 。

**示例 1：**

```

**输入：**nums = [1,5,3,9,8], limit = 2
**输出：**[1,3,5,8,9]
**解释：**执行 2 次操作：
- 交换 nums[1] 和 nums[2] 。数组变为 [1,3,5,9,8] 。
- 交换 nums[3] 和 nums[4] 。数组变为 [1,3,5,8,9] 。
即便执行更多次操作，也无法得到字典序更小的数组。
注意，执行不同的操作也可能会得到相同的结果。

```

**示例 2：**

```

**输入：**nums = [1,7,6,18,2,1], limit = 3
**输出：**[1,6,7,18,1,2]
**解释：**执行 3 次操作：
- 交换 nums[1] 和 nums[2] 。数组变为 [1,6,7,18,2,1] 。
- 交换 nums[0] 和 nums[4] 。数组变为 [2,6,7,18,1,1] 。
- 交换 nums[0] 和 nums[5] 。数组变为 [1,6,7,18,1,2] 。
即便执行更多次操作，也无法得到字典序更小的数组。

```

**示例 3：**

```

**输入：**nums = [1,7,28,19,10], limit = 3
**输出：**[1,7,28,19,10]
**解释：**[1,7,28,19,10] 是字典序最小的数组，因为不管怎么选择下标都无法执行操作。

```

**提示：**

* `1 <= nums.length <= 105`
* `1 <= nums[i] <= 109`
* `1 <= limit <= 109`

请完成以下实现
```python
class Solution(object):
    def lexicographicallySmallestArray(self, nums, limit):
        '''
        :type nums: List[int]
        :type limit: int
        :rtype: List[int]
        '''
```


class Solution(object):
    def shortestBeautifulSubstring(self, s, k):
        """
        :type s: str
        :type k: int
        :rtype: str
        """
        exit(0)

给你一个二进制字符串 `s` 和一个正整数 `k` 。

如果 `s` 的某个子字符串中 `1` 的个数恰好等于 `k` ，则称这个子字符串是一个 **美丽子字符串** 。

令 `len` 等于 **最短** 美丽子字符串的长度。

返回长度等于 `len` 且字典序 **最小** 的美丽子字符串。如果 `s` 中不含美丽子字符串，则返回一个 **空** 字符串。

对于相同长度的两个字符串 `a` 和 `b` ，如果在 `a` 和 `b` 出现不同的第一个位置上，`a` 中该位置上的字符严格大于 `b` 中的对应字符，则认为字符串 `a` 字典序 **大于** 字符串 `b` 。

* 例如，`"abcd"` 的字典序大于 `"abcc"` ，因为两个字符串出现不同的第一个位置对应第四个字符，而 `d` 大于 `c` 。

**示例 1：**

```

**输入：**s = "100011001", k = 3
**输出：**"11001"
**解释：**示例中共有 7 个美丽子字符串：
1. 子字符串 "***100011***001" 。
2. 子字符串 "***1000110***01" 。
3. 子字符串 "***100011001***" 。
4. 子字符串 "1***00011001***" 。
5. 子字符串 "10***0011001***" 。
6. 子字符串 "100***011001***" 。
7. 子字符串 "1000***11001***" 。
最短美丽子字符串的长度是 5 。
长度为 5 且字典序最小的美丽子字符串是子字符串 "11001" 。

```

**示例 2：**

```

**输入：**s = "1011", k = 2
**输出：**"11"
**解释：**示例中共有 3 个美丽子字符串：
1. 子字符串 "***101***1" 。
2. 子字符串 "1***011***" 。
3. 子字符串 "10***11***" 。
最短美丽子字符串的长度是 2 。
长度为 2 且字典序最小的美丽子字符串是子字符串 "11" 。

```

**示例 3：**

```

**输入：**s = "000", k = 1
**输出：**""
**解释：**示例中不存在美丽子字符串。

```

**提示：**

* `1 <= s.length <= 100`
* `1 <= k <= s.length`

请完成以下实现
```python
class Solution(object):
    def shortestBeautifulSubstring(self, s, k):
        '''
        :type s: str
        :type k: int
        :rtype: str
        '''
```

#<INSERT>

my_solution = Solution()
assert my_solution.shortestBeautifulSubstring(*['100011001', 3]) == "11001"
assert my_solution.shortestBeautifulSubstring(*['', 1]) == "" # 没有满足条件的子串
assert my_solution.shortestBeautifulSubstring(*['0000000', 1]) == "" # 没有满足条件的子串
assert my_solution.shortestBeautifulSubstring(*['111111', 3]) == "111" # 选择最短的包含3个'1'的子串
assert my_solution.shortestBeautifulSubstring(*['1001', 5]) == "" # 没有足够的'1'
assert my_solution.shortestBeautifulSubstring(*['1000111100011', 3]) == "111"
assert my_solution.shortestBeautifulSubstring(*['0001000', 1]) == "1"
assert my_solution.shortestBeautifulSubstring(*['110', 4]) == "" # 字符串没有足够的'1'


class Solution(object):
    def constructProductMatrix(self, grid):
        """
        :type grid: List[List[int]]
        :rtype: List[List[int]]
        """
        exit(0)

给你一个下标从 **0** 开始、大小为 `n * m` 的二维整数矩阵 `grid` ，定义一个下标从 **0** 开始、大小为 `n * m` 的的二维矩阵 `p`。如果满足以下条件，则称 `p` 为 `grid` 的 **乘积矩阵** ：

* 对于每个元素 `p[i][j]` ，它的值等于除了 `grid[i][j]` 外所有元素的乘积。乘积对 `12345` 取余数。

返回 `grid` 的乘积矩阵。

**示例 1：**

```

**输入：**grid = [[1,2],[3,4]]
**输出：**[[24,12],[8,6]]
**解释：**p[0][0] = grid[0][1] * grid[1][0] * grid[1][1] = 2 * 3 * 4 = 24
p[0][1] = grid[0][0] * grid[1][0] * grid[1][1] = 1 * 3 * 4 = 12
p[1][0] = grid[0][0] * grid[0][1] * grid[1][1] = 1 * 2 * 4 = 8
p[1][1] = grid[0][0] * grid[0][1] * grid[1][0] = 1 * 2 * 3 = 6
所以答案是 [[24,12],[8,6]] 。
```

**示例 2：**

```

**输入：**grid = [[12345],[2],[1]]
**输出：**[[2],[0],[0]]
**解释：**p[0][0] = grid[0][1] * grid[0][2] = 2 * 1 = 2
p[0][1] = grid[0][0] * grid[0][2] = 12345 * 1 = 12345. 12345 % 12345 = 0 ，所以 p[0][1] = 0
p[0][2] = grid[0][0] * grid[0][1] = 12345 * 2 = 24690. 24690 % 12345 = 0 ，所以 p[0][2] = 0
所以答案是 [[2],[0],[0]] 。
```

**提示：**

* `1 <= n == grid.length <= 105`
* `1 <= m == grid[i].length <= 105`
* `2 <= n * m <= 105`
* `1 <= grid[i][j] <= 109`

请完成以下实现
```python
class Solution(object):
    def constructProductMatrix(self, grid):
        '''
        :type grid: List[List[int]]
        :rtype: List[List[int]]
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.constructProductMatrix(*[[[1, 2], [3, 4]]]) == [[24, 12], [8, 6]]

assert my_solution.constructProductMatrix(*[[[12345], [2], [1]]]) == [[2], [0], [0]]

assert my_solution.constructProductMatrix(*[[[1], [2]]]) == [[2], [1]]

assert my_solution.constructProductMatrix(*[[[1, 2]]]) == [[2, 1]]

assert my_solution.constructProductMatrix(*[[[12345, 12345]]]) == [[0, 0]]

assert my_solution.constructProductMatrix(*[[[1], [4]]]) == [[4], [1]]

assert my_solution.constructProductMatrix(*[[[3], [4]]]) == [[4], [3]]

assert my_solution.constructProductMatrix(*[[[4], [3]]]) == [[3], [4]]

assert my_solution.constructProductMatrix(*[[[1, 1, 1]]]) == [[1, 1, 1]]

assert my_solution.constructProductMatrix(*[[[2, 1, 1]]]) == [[1, 2, 2]]

assert my_solution.constructProductMatrix(*[[[3], [5], [2]]]) == [[10], [6], [15]]

assert my_solution.constructProductMatrix(*[[[1, 2], [1, 1], [6, 4]]]) == [[48, 24], [48, 48], [8, 12]]

assert my_solution.constructProductMatrix(*[[[1, 2, 2], [1, 4, 3]]]) == [[48, 24, 24], [48, 12, 16]]

assert my_solution.constructProductMatrix(*[[[2], [7], [2], [6]]]) == [[84], [24], [84], [28]]

assert my_solution.constructProductMatrix(*[[[3], [4], [7], [7]]]) == [[196], [147], [84], [84]]

assert my_solution.constructProductMatrix(*[[[3, 1, 1], [1, 3, 4]]]) == [[12, 36, 36], [36, 12, 9]]

assert my_solution.constructProductMatrix(*[[[4], [8], [3], [7]]]) == [[168], [84], [224], [96]]

assert my_solution.constructProductMatrix(*[[[5], [8], [8], [3]]]) == [[192], [120], [120], [320]]

assert my_solution.constructProductMatrix(*[[[6], [5], [8], [5]]]) == [[200], [240], [150], [240]]

assert my_solution.constructProductMatrix(*[[[8], [1], [3], [8]]]) == [[24], [192], [64], [24]]


class Solution(object):
    def maxBalancedSubsequenceSum(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        exit(0)

给你一个下标从 **0** 开始的整数数组 `nums` 。

`nums` 一个长度为 `k` 的 **子序列** 指的是选出 `k` 个 **下标** `i0 < i1 < ... < ik-1` ，如果这个子序列满足以下条件，我们说它是 **平衡的** ：

* 对于范围 `[1, k - 1]` 内的所有 `j` ，`nums[ij] - nums[ij-1] >= ij - ij-1` 都成立。

`nums` 长度为 `1` 的 **子序列** 是平衡的。

请你返回一个整数，表示 `nums` **平衡** 子序列里面的 **最大元素和** 。

一个数组的 **子序列** 指的是从原数组中删除一些元素（**也可能一个元素也不删除**）后，剩余元素保持相对顺序得到的 **非空** 新数组。

**示例 1：**

```

**输入：**nums = [3,3,5,6]
**输出：**14
**解释：**这个例子中，选择子序列 [3,5,6] ，下标为 0 ，2 和 3 的元素被选中。
nums[2] - nums[0] >= 2 - 0 。
nums[3] - nums[2] >= 3 - 2 。
所以，这是一个平衡子序列，且它的和是所有平衡子序列里最大的。
包含下标 1 ，2 和 3 的子序列也是一个平衡的子序列。
最大平衡子序列和为 14 。
```

**示例 2：**

```

**输入：**nums = [5,-1,-3,8]
**输出：**13
**解释：**这个例子中，选择子序列 [5,8] ，下标为 0 和 3 的元素被选中。
nums[3] - nums[0] >= 3 - 0 。
所以，这是一个平衡子序列，且它的和是所有平衡子序列里最大的。
最大平衡子序列和为 13 。

```

**示例 3：**

```

**输入：**nums = [-2,-1]
**输出：**-1
**解释：**这个例子中，选择子序列 [-1] 。
这是一个平衡子序列，而且它的和是 nums 所有平衡子序列里最大的。

```

**提示：**

* `1 <= nums.length <= 105`
* `-109 <= nums[i] <= 109`

请完成以下实现
```python
class Solution(object):
    def maxBalancedSubsequenceSum(self, nums):
        '''
        :type nums: List[int]
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.maxBalancedSubsequenceSum(*[[3, 3, 5, 6]]) == 14

assert my_solution.maxBalancedSubsequenceSum(*[[5, -1, -3, 8]]) == 13

assert my_solution.maxBalancedSubsequenceSum(*[[-2, -1]]) == -1

assert my_solution.maxBalancedSubsequenceSum(*[[0]]) == 0

assert my_solution.maxBalancedSubsequenceSum(*[[-47]]) == -47

assert my_solution.maxBalancedSubsequenceSum(*[[-8]]) == -8

assert my_solution.maxBalancedSubsequenceSum(*[[-7]]) == -7

assert my_solution.maxBalancedSubsequenceSum(*[[-6]]) == -6

assert my_solution.maxBalancedSubsequenceSum(*[[-5]]) == -5

assert my_solution.maxBalancedSubsequenceSum(*[[-3]]) == -3

assert my_solution.maxBalancedSubsequenceSum(*[[-2]]) == -2

assert my_solution.maxBalancedSubsequenceSum(*[[-1]]) == -1

assert my_solution.maxBalancedSubsequenceSum(*[[1]]) == 1

assert my_solution.maxBalancedSubsequenceSum(*[[3]]) == 3

assert my_solution.maxBalancedSubsequenceSum(*[[4]]) == 4

assert my_solution.maxBalancedSubsequenceSum(*[[5]]) == 5

assert my_solution.maxBalancedSubsequenceSum(*[[7]]) == 7

assert my_solution.maxBalancedSubsequenceSum(*[[8]]) == 8

assert my_solution.maxBalancedSubsequenceSum(*[[9]]) == 9

assert my_solution.maxBalancedSubsequenceSum(*[[45]]) == 45


class Solution(object):
    def minGroupsForValidAssignment(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        exit(0)

给你一个长度为 `n` 下标从 **0** 开始的整数数组 `nums` 。

我们想将下标进行分组，使得 `[0, n - 1]` 内所有下标 `i` 都 **恰好** 被分到其中一组。

如果以下条件成立，我们说这个分组方案是合法的：

* 对于每个组 `g` ，同一组内所有下标在 `nums` 中对应的数值都相等。
* 对于任意两个组 `g1` 和 `g2` ，两个组中 **下标数量** 的 **差值不超过**`1` 。

请你返回一个整数，表示得到一个合法分组方案的 **最少** 组数。

**示例 1：**

```

**输入：**nums = [3,2,3,2,3]
**输出：**2
**解释：**一个得到 2 个分组的方案如下，中括号内的数字都是下标：
组 1 -> [0,2,4]
组 2 -> [1,3]
所有下标都只属于一个组。
组 1 中，nums[0] == nums[2] == nums[4] ，所有下标对应的数值都相等。
组 2 中，nums[1] == nums[3] ，所有下标对应的数值都相等。
组 1 中下标数目为 3 ，组 2 中下标数目为 2 。
两者之差不超过 1 。
无法得到一个小于 2 组的答案，因为如果只有 1 组，组内所有下标对应的数值都要相等。
所以答案为 2 。
```

**示例 2：**

```

**输入：**nums = [10,10,10,3,1,1]
**输出：**4
**解释：**一个得到 2 个分组的方案如下，中括号内的数字都是下标：
组 1 -> [0]
组 2 -> [1,2]
组 3 -> [3]
组 4 -> [4,5]
分组方案满足题目要求的两个条件。
无法得到一个小于 4 组的答案。
所以答案为 4 。
```

**提示：**

* `1 <= nums.length <= 105`
* `1 <= nums[i] <= 109`

请完成以下实现
```python
class Solution(object):
    def minGroupsForValidAssignment(self, nums):
        '''
        :type nums: List[int]
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.minGroupsForValidAssignment(*[[3, 2, 3, 2, 3]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[10, 10, 10, 3, 1, 1]]) == 4

assert my_solution.minGroupsForValidAssignment(*[[1, 1]]) == 1

assert my_solution.minGroupsForValidAssignment(*[[1, 2]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[1, 3]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[2, 1]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[2, 2]]) == 1

assert my_solution.minGroupsForValidAssignment(*[[3, 1]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[3, 2]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[3, 3]]) == 1

assert my_solution.minGroupsForValidAssignment(*[[3, 4]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[10, 4]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[10, 10]]) == 1

assert my_solution.minGroupsForValidAssignment(*[[14, 15]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[1, 1, 1]]) == 1

assert my_solution.minGroupsForValidAssignment(*[[1, 2, 1]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[1, 7, 10]]) == 3

assert my_solution.minGroupsForValidAssignment(*[[2, 1, 1]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[2, 1, 2]]) == 2

assert my_solution.minGroupsForValidAssignment(*[[2, 2, 1]]) == 2


class Solution(object):
    def minimumSum(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        exit(0)

给你一个下标从 **0** 开始的整数数组 `nums` 。

如果下标三元组 `(i, j, k)` 满足下述全部条件，则认为它是一个 **山形三元组** ：

* `i < j < k`
* `nums[i] < nums[j]` 且 `nums[k] < nums[j]`

请你找出 `nums` 中 **元素和最小** 的山形三元组，并返回其 **元素和** 。如果不存在满足条件的三元组，返回 `-1` 。

**示例 1：**

```

**输入：**nums = [8,6,1,5,3]
**输出：**9
**解释：**三元组 (2, 3, 4) 是一个元素和等于 9 的山形三元组，因为：
- 2 < 3 < 4
- nums[2] < nums[3] 且 nums[4] < nums[3]
这个三元组的元素和等于 nums[2] + nums[3] + nums[4] = 9 。可以证明不存在元素和小于 9 的山形三元组。

```

**示例 2：**

```

**输入：**nums = [5,4,8,7,10,2]
**输出：**13
**解释：**三元组 (1, 3, 5) 是一个元素和等于 13 的山形三元组，因为：
- 1 < 3 < 5
- nums[1] < nums[3] 且 nums[5] < nums[3]
这个三元组的元素和等于 nums[1] + nums[3] + nums[5] = 13 。可以证明不存在元素和小于 13 的山形三元组。

```

**示例 3：**

```

**输入：**nums = [6,5,4,3,4,5]
**输出：**-1
**解释：**可以证明 nums 中不存在山形三元组。

```

**提示：**

* `3 <= nums.length <= 105`
* `1 <= nums[i] <= 108`

请完成以下实现
```python
class Solution(object):
    def minimumSum(self, nums):
        '''
        :type nums: List[int]
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.minimumSum(*[[8, 6, 1, 5, 3]]) == 9

assert my_solution.minimumSum(*[[5, 4, 8, 7, 10, 2]]) == 13

assert my_solution.minimumSum(*[[6, 5, 4, 3, 4, 5]]) == -1

assert my_solution.minimumSum(*[[50, 50, 50]]) == -1

assert my_solution.minimumSum(*[[49, 50, 48]]) == 147

assert my_solution.minimumSum(*[[48, 50, 49]]) == 147

assert my_solution.minimumSum(*[[99999999, 100000000, 99999999]]) == 299999998

assert my_solution.minimumSum(*[[1, 1, 1]]) == -1

assert my_solution.minimumSum(*[[1, 1, 2]]) == -1

assert my_solution.minimumSum(*[[1, 1, 3]]) == -1

assert my_solution.minimumSum(*[[1, 2, 1]]) == 4

assert my_solution.minimumSum(*[[1, 2, 2]]) == -1

assert my_solution.minimumSum(*[[1, 2, 3]]) == -1

assert my_solution.minimumSum(*[[1, 3, 1]]) == 5

assert my_solution.minimumSum(*[[1, 3, 2]]) == 6

assert my_solution.minimumSum(*[[1, 3, 3]]) == -1

assert my_solution.minimumSum(*[[2, 1, 1]]) == -1

assert my_solution.minimumSum(*[[2, 1, 2]]) == -1

assert my_solution.minimumSum(*[[2, 1, 3]]) == -1

assert my_solution.minimumSum(*[[2, 2, 1]]) == -1


给你一个下标从 **0** 开始的整数数组 `nums` 。

如果下标三元组 `(i, j, k)` 满足下述全部条件，则认为它是一个 **山形三元组** ：

* `i < j < k`
* `nums[i] < nums[j]` 且 `nums[k] < nums[j]`

请你找出 `nums` 中 **元素和最小** 的山形三元组，并返回其 **元素和** 。如果不存在满足条件的三元组，返回 `-1` 。

**示例 1：**

```

**输入：**nums = [8,6,1,5,3]
**输出：**9
**解释：**三元组 (2, 3, 4) 是一个元素和等于 9 的山形三元组，因为：
- 2 < 3 < 4
- nums[2] < nums[3] 且 nums[4] < nums[3]
这个三元组的元素和等于 nums[2] + nums[3] + nums[4] = 9 。可以证明不存在元素和小于 9 的山形三元组。

```

**示例 2：**

```

**输入：**nums = [5,4,8,7,10,2]
**输出：**13
**解释：**三元组 (1, 3, 5) 是一个元素和等于 13 的山形三元组，因为：
- 1 < 3 < 5
- nums[1] < nums[3] 且 nums[5] < nums[3]
这个三元组的元素和等于 nums[1] + nums[3] + nums[5] = 13 。可以证明不存在元素和小于 13 的山形三元组。

```

**示例 3：**

```

**输入：**nums = [6,5,4,3,4,5]
**输出：**-1
**解释：**可以证明 nums 中不存在山形三元组。

```

**提示：**

* `3 <= nums.length <= 50`
* `1 <= nums[i] <= 50`

请完成以下实现
```python
class Solution(object):
    def minimumSum(self, nums):
        '''
        :type nums: List[int]
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.minimumSum(*[[8, 6, 1, 5, 3]]) == 9

assert my_solution.minimumSum(*[[5, 4, 8, 7, 10, 2]]) == 13

assert my_solution.minimumSum(*[[6, 5, 4, 3, 4, 5]]) == -1

assert my_solution.minimumSum(*[[50, 50, 50]]) == -1

assert my_solution.minimumSum(*[[49, 50, 48]]) == 147

assert my_solution.minimumSum(*[[48, 50, 49]]) == 147

assert my_solution.minimumSum(*[[1, 1, 1]]) == -1

assert my_solution.minimumSum(*[[1, 1, 2]]) == -1

assert my_solution.minimumSum(*[[1, 1, 3]]) == -1

assert my_solution.minimumSum(*[[1, 2, 1]]) == 4

assert my_solution.minimumSum(*[[1, 2, 2]]) == -1

assert my_solution.minimumSum(*[[1, 2, 3]]) == -1

assert my_solution.minimumSum(*[[1, 3, 1]]) == 5

assert my_solution.minimumSum(*[[1, 3, 2]]) == 6

assert my_solution.minimumSum(*[[1, 3, 3]]) == -1

assert my_solution.minimumSum(*[[2, 1, 1]]) == -1

assert my_solution.minimumSum(*[[2, 1, 2]]) == -1

assert my_solution.minimumSum(*[[2, 1, 3]]) == -1

assert my_solution.minimumSum(*[[2, 2, 1]]) == -1

assert my_solution.minimumSum(*[[2, 2, 2]]) == -1


class Solution(object):
    def lengthOfLongestSubsequence(self, nums, target):
        """
        :type nums: List[int]
        :type target: int
        :rtype: int
        """
        exit(0)

给你一个下标从 **0** 开始的整数数组 `nums` 和一个整数 `target` 。

返回和为 `target` 的 `nums` 子序列中，子序列 **长度的最大值**。如果不存在和为 `target` 的子序列，返回 `-1` 。

**子序列** 指的是从原数组中删除一些或者不删除任何元素后，剩余元素保持原来的顺序构成的数组。

**示例 1：**

```

**输入：**nums = [1,2,3,4,5], target = 9
**输出：**3
**解释：**总共有 3 个子序列的和为 9 ：[4,5] ，[1,3,5] 和 [2,3,4] 。最长的子序列是 [1,3,5] 和 [2,3,4] 。所以答案为 3 。

```

**示例 2：**

```

**输入：**nums = [4,1,3,2,1,5], target = 7
**输出：**4
**解释：**总共有 5 个子序列的和为 7 ：[4,3] ，[4,1,2] ，[4,2,1] ，[1,1,5] 和 [1,3,2,1] 。最长子序列为 [1,3,2,1] 。所以答案为 4 。

```

**示例 3：**

```

**输入：**nums = [1,1,5,4,5], target = 3
**输出：**-1
**解释：**无法得到和为 3 的子序列。

```

**提示：**

* `1 <= nums.length <= 1000`
* `1 <= nums[i] <= 1000`
* `1 <= target <= 1000`

请完成以下实现
```python
class Solution(object):
    def lengthOfLongestSubsequence(self, nums, target):
        '''
        :type nums: List[int]
        :type target: int
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.lengthOfLongestSubsequence(*[[1, 2, 3, 4, 5], 9]) == 3

assert my_solution.lengthOfLongestSubsequence(*[[4, 1, 3, 2, 1, 5], 7]) == 4

assert my_solution.lengthOfLongestSubsequence(*[[1, 1, 5, 4, 5], 3]) == -1

assert my_solution.lengthOfLongestSubsequence(*[[1000], 12]) == -1

assert my_solution.lengthOfLongestSubsequence(*[[1000], 1000]) == 1

assert my_solution.lengthOfLongestSubsequence(*[[1, 2], 10]) == -1

assert my_solution.lengthOfLongestSubsequence(*[[1, 1000], 5]) == -1

assert my_solution.lengthOfLongestSubsequence(*[[2, 3], 3]) == 1

assert my_solution.lengthOfLongestSubsequence(*[[2, 3], 5]) == 2

assert my_solution.lengthOfLongestSubsequence(*[[2, 3, 5], 5]) == 2

assert my_solution.lengthOfLongestSubsequence(*[[1, 3, 3, 7], 1000]) == -1

assert my_solution.lengthOfLongestSubsequence(*[[1, 3, 3, 7], 2]) == -1

assert my_solution.lengthOfLongestSubsequence(*[[1, 3, 3, 8], 7]) == 3

assert my_solution.lengthOfLongestSubsequence(*[[1, 1, 2, 1], 2]) == 2

assert my_solution.lengthOfLongestSubsequence(*[[1, 1, 1, 1], 5]) == -1

assert my_solution.lengthOfLongestSubsequence(*[[1, 1, 1, 2], 3]) == 3

assert my_solution.lengthOfLongestSubsequence(*[[9, 12, 8, 4, 11, 13, 15, 7, 5], 84]) == 9

assert my_solution.lengthOfLongestSubsequence(*[[11, 5, 9, 11, 12, 13, 12, 5, 1, 8], 87]) == 10

assert my_solution.lengthOfLongestSubsequence(*[[9, 11, 11, 15, 4, 14, 3, 2, 13, 7], 89]) == 10

assert my_solution.lengthOfLongestSubsequence(*[[11, 13, 6, 13, 10], 53]) == 5


class Solution(object):
    def minimumCoins(self, prices):
        """
        :type prices: List[int]
        :rtype: int
        """
        exit(0)

你在一个水果超市里，货架上摆满了玲琅满目的奇珍异果。

给你一个下标从 **1** 开始的数组 `prices` ，其中 `prices[i]` 表示你购买第 `i` 个水果需要花费的金币数目。

水果超市有如下促销活动：

* 如果你花费 `price[i]` 购买了水果 `i` ，那么接下来的 `i` 个水果你都可以免费获得。

**注意** ，即使你 **可以** 免费获得水果 `j` ，你仍然可以花费 `prices[j]` 个金币去购买它以便能免费获得接下来的 `j` 个水果。

请你返回获得所有水果所需要的 **最少** 金币数。

**示例 1：**

```

**输入：**prices = [3,1,2]
**输出：**4
**解释****：**你可以按如下方法获得所有水果：
- 花 3 个金币购买水果 1 ，然后免费获得水果 2 。
- 花 1 个金币购买水果 2 ，然后免费获得水果 3 。
- 免费获得水果 3 。
注意，虽然你可以免费获得水果 2 ，但你还是花 1 个金币去购买它，因为这样的总花费最少。
购买所有水果需要最少花费 4 个金币。

```

**示例 2：**

```

**输入：**prices = [1,10,1,1]
**输出：**2
**解释：**你可以按如下方法获得所有水果：
- 花 1 个金币购买水果 1 ，然后免费获得水果 2 。
- 免费获得水果 2 。
- 花 1 个金币购买水果 3 ，然后免费获得水果 4 。
- 免费获得水果 4 。
购买所有水果需要最少花费 2 个金币。

```

**提示：**

* `1 <= prices.length <= 1000`
* `1 <= prices[i] <= 105`

请完成以下实现
```python
class Solution(object):
    def minimumCoins(self, prices):
        '''
        :type prices: List[int]
        :rtype: int
        '''
```


class Solution(object):
    def sumCounts(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        exit(0)

给你一个下标从 **0** 开始的整数数组 `nums` 。

定义 `nums` 一个子数组的 **不同计数** 值如下：

* 令 `nums[i..j]` 表示 `nums` 中所有下标在 `i` 到 `j` 范围内的元素构成的子数组（满足 `0 <= i <= j < nums.length` ），那么我们称子数组 `nums[i..j]` 中不同值的数目为 `nums[i..j]` 的不同计数。

请你返回 `nums` 中所有子数组的 **不同计数** 的 **平方** 和。

由于答案可能会很大，请你将它对 `109 + 7` **取余** 后返回。

子数组指的是一个数组里面一段连续 **非空** 的元素序列。

**示例 1：**

```

**输入：**nums = [1,2,1]
**输出：**15
**解释：**六个子数组分别为：
[1]: 1 个互不相同的元素。
[2]: 1 个互不相同的元素。
[1]: 1 个互不相同的元素。
[1,2]: 2 个互不相同的元素。
[2,1]: 2 个互不相同的元素。
[1,2,1]: 2 个互不相同的元素。
所有不同计数的平方和为 12 + 12 + 12 + 22 + 22 + 22 = 15 。

```

**示例 2：**

```

**输入：**nums = [2,2]
**输出：3**
**解释：**三个子数组分别为：
[2]: 1 个互不相同的元素。
[2]: 1 个互不相同的元素。
[2,2]: 1 个互不相同的元素。
所有不同计数的平方和为 12 + 12 + 12 = 3 。

```

**提示：**

* `1 <= nums.length <= 105`
* `1 <= nums[i] <= 105`

请完成以下实现
```python
class Solution(object):
    def sumCounts(self, nums):
        '''
        :type nums: List[int]
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.sumCounts(*[[1, 2, 1]]) == 15

assert my_solution.sumCounts(*[[2, 2]]) == 3

assert my_solution.sumCounts(*[[2, 2, 5, 5]]) == 22

assert my_solution.sumCounts(*[[5, 2, 4, 2, 1, 3, 2, 4, 3, 1]]) == 578

assert my_solution.sumCounts(*[[2, 3, 2, 1, 2, 5, 3, 4, 5, 2]]) == 629

assert my_solution.sumCounts(*[[5, 1, 5, 2, 3, 5, 1, 5, 1]]) == 385

assert my_solution.sumCounts(*[[4, 5, 4, 3, 4, 2]]) == 120

assert my_solution.sumCounts(*[[2]]) == 1

assert my_solution.sumCounts(*[[3, 4, 2, 5, 2, 4, 1, 2, 2, 5]]) == 535

assert my_solution.sumCounts(*[[4, 4, 2, 4, 1]]) == 57

assert my_solution.sumCounts(*[[2, 2, 5]]) == 12

assert my_solution.sumCounts(*[[4, 5, 1, 2, 2, 1, 3, 3]]) == 266

assert my_solution.sumCounts(*[[3, 1, 5, 5, 2, 3, 2, 2, 1]]) == 334

assert my_solution.sumCounts(*[[2, 5, 2, 5, 3, 2, 5, 2]]) == 205

assert my_solution.sumCounts(*[[5, 4, 1, 4, 5, 2, 4]]) == 203

assert my_solution.sumCounts(*[[1, 3, 3, 4, 3, 1, 2, 1]]) == 253

assert my_solution.sumCounts(*[[4]]) == 1

assert my_solution.sumCounts(*[[1, 4, 2, 1, 5, 4, 3, 1, 4]]) == 507

assert my_solution.sumCounts(*[[2, 4, 5, 3, 2, 5, 1, 5, 4, 4]]) == 626

assert my_solution.sumCounts(*[[3, 4, 1, 4, 5, 2, 2]]) == 220


给你一个下标从 **0** 开始的整数数组 `nums` 。

定义 `nums` 一个子数组的 **不同计数** 值如下：

* 令 `nums[i..j]` 表示 `nums` 中所有下标在 `i` 到 `j` 范围内的元素构成的子数组（满足 `0 <= i <= j < nums.length` ），那么我们称子数组 `nums[i..j]` 中不同值的数目为 `nums[i..j]` 的不同计数。

请你返回 `nums` 中所有子数组的 **不同计数** 的 **平方** 和。

由于答案可能会很大，请你将它对 `109 + 7` **取余** 后返回。

子数组指的是一个数组里面一段连续 **非空** 的元素序列。

**示例 1：**

```

**输入：**nums = [1,2,1]
**输出：**15
**解释：**六个子数组分别为：
[1]: 1 个互不相同的元素。
[2]: 1 个互不相同的元素。
[1]: 1 个互不相同的元素。
[1,2]: 2 个互不相同的元素。
[2,1]: 2 个互不相同的元素。
[1,2,1]: 2 个互不相同的元素。
所有不同计数的平方和为 12 + 12 + 12 + 22 + 22 + 22 = 15 。

```

**示例 2：**

```

**输入：**nums = [2,2]
**输出：3**
**解释：**三个子数组分别为：
[2]: 1 个互不相同的元素。
[2]: 1 个互不相同的元素。
[2,2]: 1 个互不相同的元素。
所有不同计数的平方和为 12 + 12 + 12 = 3 。

```

**提示：**

* `1 <= nums.length <= 100`
* `1 <= nums[i] <= 100`

请完成以下实现
```python
class Solution(object):
    def sumCounts(self, nums):
        '''
        :type nums: List[int]
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.sumCounts(*[[1, 2, 1]]) == 15

assert my_solution.sumCounts(*[[1, 1]]) == 3

assert my_solution.sumCounts(*[[2, 2, 5, 5]]) == 22

assert my_solution.sumCounts(*[[5, 2, 4, 2, 1, 3, 2, 4, 3, 1]]) == 578

assert my_solution.sumCounts(*[[2, 3, 2, 1, 2, 5, 3, 4, 5, 2]]) == 629

assert my_solution.sumCounts(*[[5, 1, 5, 2, 3, 5, 1, 5, 1]]) == 385

assert my_solution.sumCounts(*[[4, 5, 4, 3, 4, 2]]) == 120

assert my_solution.sumCounts(*[[2]]) == 1

assert my_solution.sumCounts(*[[3, 4, 2, 5, 2, 4, 1, 2, 2, 5]]) == 535

assert my_solution.sumCounts(*[[4, 4, 2, 4, 1]]) == 57

assert my_solution.sumCounts(*[[2, 2, 5]]) == 12

assert my_solution.sumCounts(*[[4, 5, 1, 2, 2, 1, 3, 3]]) == 266

assert my_solution.sumCounts(*[[3, 1, 5, 5, 2, 3, 2, 2, 1]]) == 334

assert my_solution.sumCounts(*[[2, 5, 2, 5, 3, 2, 5, 2]]) == 205

assert my_solution.sumCounts(*[[5, 4, 1, 4, 5, 2, 4]]) == 203

assert my_solution.sumCounts(*[[1, 3, 3, 4, 3, 1, 2, 1]]) == 253

assert my_solution.sumCounts(*[[4]]) == 1

assert my_solution.sumCounts(*[[1, 4, 2, 1, 5, 4, 3, 1, 4]]) == 507

assert my_solution.sumCounts(*[[2, 4, 5, 3, 2, 5, 1, 5, 4, 4]]) == 626

assert my_solution.sumCounts(*[[3, 4, 1, 4, 5, 2, 2]]) == 220


class Solution(object):
    def maximumTripletValue(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        exit(0)

给你一个下标从 **0** 开始的整数数组 `nums` 。

请你从所有满足 `i < j < k` 的下标三元组 `(i, j, k)` 中，找出并返回下标三元组的最大值。如果所有满足条件的三元组的值都是负数，则返回 `0` 。

**下标三元组** `(i, j, k)` 的值等于 `(nums[i] - nums[j]) * nums[k]` 。

**示例 1：**

```

**输入：**nums = [12,6,1,2,7]
**输出：**77
**解释：**下标三元组 (0, 2, 4) 的值是 (nums[0] - nums[2]) * nums[4] = 77 。
可以证明不存在值大于 77 的有序下标三元组。

```

**示例 2：**

```

**输入：**nums = [1,10,3,4,19]
**输出：**133
**解释：**下标三元组 (1, 2, 4) 的值是 (nums[1] - nums[2]) * nums[4] = 133 。
可以证明不存在值大于 133 的有序下标三元组。

```

**示例 3：**

```

**输入：**nums = [1,2,3]
**输出：**0
**解释：**唯一的下标三元组 (0, 1, 2) 的值是一个负数，(nums[0] - nums[1]) * nums[2] = -3 。因此，答案是 0 。

```

**提示：**

* `3 <= nums.length <= 105`
* `1 <= nums[i] <= 106`

请完成以下实现
```python
class Solution(object):
    def maximumTripletValue(self, nums):
        '''
        :type nums: List[int]
        :rtype: int
        '''
```


class Solution(object):
    def stringCount(self, n):
        """
        :type n: int
        :rtype: int
        """
        exit(0)

给你一个整数 `n` 。

如果一个字符串 `s` 只包含小写英文字母，**且** 将 `s` 的字符重新排列后，新字符串包含 **子字符串** `"leet"` ，那么我们称字符串 `s` 是一个 **好** 字符串。

比方说：

* 字符串 `"lteer"` 是好字符串，因为重新排列后可以得到 `"leetr"` 。
* `"letl"` 不是好字符串，因为无法重新排列并得到子字符串 `"leet"` 。

请你返回长度为 `n` 的好字符串 **总** 数目。

由于答案可能很大，将答案对`109 + 7` **取余** 后返回。

**子字符串** 是一个字符串中一段连续的字符序列。

**示例 1：**

```

**输入：**n = 4
**输出：**12
**解释：**总共有 12 个字符串重新排列后包含子字符串 "leet" ："eelt" ，"eetl" ，"elet" ，"elte" ，"etel" ，"etle" ，"leet" ，"lete" ，"ltee" ，"teel" ，"tele" 和 "tlee" 。

```

**示例 2：**

```

**输入：**n = 10
**输出：**83943898
**解释：**长度为 10 的字符串重新排列后包含子字符串 "leet" 的方案数为 526083947580 。所以答案为 526083947580 % (109 + 7) = 83943898 。

```

**提示：**

* `1 <= n <= 105`

请完成以下实现
```python
class Solution(object):
    def stringCount(self, n):
        '''
        :type n: int
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.stringCount(*[4]) == 12

assert my_solution.stringCount(*[10]) == 83943898

assert my_solution.stringCount(*[1]) == 0

assert my_solution.stringCount(*[2]) == 0

assert my_solution.stringCount(*[3]) == 0

assert my_solution.stringCount(*[5]) == 1460

assert my_solution.stringCount(*[6]) == 106620

assert my_solution.stringCount(*[7]) == 6058192

assert my_solution.stringCount(*[8]) == 295164156

assert my_solution.stringCount(*[9]) == 947613240

assert my_solution.stringCount(*[11]) == 795234177

assert my_solution.stringCount(*[12]) == 55396773

assert my_solution.stringCount(*[13]) == 968092561

assert my_solution.stringCount(*[14]) == 715599898

assert my_solution.stringCount(*[15]) == 430509685

assert my_solution.stringCount(*[16]) == 462719236

assert my_solution.stringCount(*[17]) == 155543310

assert my_solution.stringCount(*[18]) == 159683962

assert my_solution.stringCount(*[19]) == 808507313

assert my_solution.stringCount(*[20]) == 291395991


class Solution(object):
    def minimumSteps(self, s):
        """
        :type s: str
        :rtype: int
        """
        exit(0)

桌子上有 `n` 个球，每个球的颜色不是黑色，就是白色。

给你一个长度为 `n` 、下标从 **0** 开始的二进制字符串 `s`，其中 `1` 和 `0` 分别代表黑色和白色的球。

在每一步中，你可以选择两个相邻的球并交换它们。

返回「将所有黑色球都移到右侧，所有白色球都移到左侧所需的 **最小步数**」。

**示例 1：**

```

**输入：**s = "101"
**输出：**1
**解释：**我们可以按以下方式将所有黑色球移到右侧：
- 交换 s[0] 和 s[1]，s = "011"。
最开始，1 没有都在右侧，需要至少 1 步将其移到右侧。
```

**示例 2：**

```

**输入：**s = "100"
**输出：**2
**解释：**我们可以按以下方式将所有黑色球移到右侧：
- 交换 s[0] 和 s[1]，s = "010"。
- 交换 s[1] 和 s[2]，s = "001"。
可以证明所需的最小步数为 2 。

```

**示例 3：**

```

**输入：**s = "0111"
**输出：**0
**解释：**所有黑色球都已经在右侧。

```

**提示：**

* `1 <= n == s.length <= 105`
* `s[i]` 不是 `'0'`，就是 `'1'`。

请完成以下实现
```python
class Solution(object):
    def minimumSteps(self, s):
        '''
        :type s: str
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.minimumSteps(*['101']) == 1

assert my_solution.minimumSteps(*['100']) == 2

assert my_solution.minimumSteps(*['0111']) == 0

assert my_solution.minimumSteps(*['11000111']) == 6

assert my_solution.minimumSteps(*['01010001']) == 7

assert my_solution.minimumSteps(*['0100101']) == 4

assert my_solution.minimumSteps(*['111111111100100010']) == 65

assert my_solution.minimumSteps(*['10100000110010011010']) == 44

assert my_solution.minimumSteps(*['1101110000111011110']) == 42

assert my_solution.minimumSteps(*['01000010111010001']) == 29

assert my_solution.minimumSteps(*['11110']) == 4

assert my_solution.minimumSteps(*['010001001011010']) == 21

assert my_solution.minimumSteps(*['0011011']) == 2

assert my_solution.minimumSteps(*['001']) == 0

assert my_solution.minimumSteps(*['000100100']) == 6

assert my_solution.minimumSteps(*['00110']) == 2

assert my_solution.minimumSteps(*['001110001110001']) == 27

assert my_solution.minimumSteps(*['10000000001']) == 9

assert my_solution.minimumSteps(*['01']) == 0

assert my_solution.minimumSteps(*['0100011100001100100']) == 45


class Solution(object):
    def distributeCandies(self, n, limit):
        """
        :type n: int
        :type limit: int
        :rtype: int
        """
        exit(0)

给你两个正整数 `n` 和 `limit` 。

请你将 `n` 颗糖果分给 `3` 位小朋友，确保没有任何小朋友得到超过 `limit` 颗糖果，请你返回满足此条件下的 **总方案数** 。

**示例 1：**

```

**输入：**n = 5, limit = 2
**输出：**3
**解释：**总共有 3 种方法分配 5 颗糖果，且每位小朋友的糖果数不超过 2 ：(1, 2, 2) ，(2, 1, 2) 和 (2, 2, 1) 。

```

**示例 2：**

```

**输入：**n = 3, limit = 3
**输出：**10
**解释：**总共有 10 种方法分配 3 颗糖果，且每位小朋友的糖果数不超过 3 ：(0, 0, 3) ，(0, 1, 2) ，(0, 2, 1) ，(0, 3, 0) ，(1, 0, 2) ，(1, 1, 1) ，(1, 2, 0) ，(2, 0, 1) ，(2, 1, 0) 和 (3, 0, 0) 。

```

**提示：**

* `1 <= n <= 106`
* `1 <= limit <= 106`

请完成以下实现
```python
class Solution(object):
    def distributeCandies(self, n, limit):
        '''
        :type n: int
        :type limit: int
        :rtype: int
        '''
```

#<INSERT>

my_solution = Solution()

assert my_solution.distributeCandies(*[5, 2]) == 3

assert my_solution.distributeCandies(*[3, 3]) == 10

assert my_solution.distributeCandies(*[1, 1]) == 3

assert my_solution.distributeCandies(*[1, 2]) == 3

assert my_solution.distributeCandies(*[1, 3]) == 3

assert my_solution.distributeCandies(*[1, 4]) == 3

assert my_solution.distributeCandies(*[1, 5]) == 3

assert my_solution.distributeCandies(*[1, 6]) == 3

assert my_solution.distributeCandies(*[1, 7]) == 3

assert my_solution.distributeCandies(*[1, 8]) == 3

assert my_solution.distributeCandies(*[1, 9]) == 3

assert my_solution.distributeCandies(*[1, 10]) == 3

assert my_solution.distributeCandies(*[1, 11]) == 3

assert my_solution.distributeCandies(*[1, 12]) == 3

assert my_solution.distributeCandies(*[1, 13]) == 3

assert my_solution.distributeCandies(*[1, 14]) == 3

assert my_solution.distributeCandies(*[1, 15]) == 3

assert my_solution.distributeCandies(*[1, 16]) == 3

assert my_solution.distributeCandies(*[1, 17]) == 3

assert my_solution.distributeCandies(*[1, 18]) == 3


给你两个正整数 `n` 和 `limit` 。

请你将 `n` 颗糖果分给 `3` 位小朋友，确保没有任何小朋友得到超过 `limit` 颗糖果，请你返回满足此条件下的 **总方案数** 。

**示例 1：**

```

**输入：**n = 5, limit = 2
**输出：**3
**解释：**总共有 3 种方法分配 5 颗糖果，且每位小朋友的糖果数不超过 2 ：(1, 2, 2) ，(2, 1, 2) 和 (2, 2, 1) 。

```

**示例 2：**

```

**输入：**n = 3, limit = 3
**输出：**10
**解释：**总共有 10 种方法分配 3 颗糖果，且每位小朋友的糖果数不超过 3 ：(0, 0, 3) ，(0, 1, 2) ，(0, 2, 1) ，(0, 3, 0) ，(1, 0, 2) ，(1, 1, 1) ，(1, 2, 0) ，(2, 0, 1) ，(2, 1, 0) 和 (3, 0, 0) 。

```

**提示：**

* `1 <= n <= 50`
* `1 <= limit <= 50`

请完成以下实现
```python
class Solution(object):
    def distributeCandies(self, n, limit):
        '''
        :type n: int
        :type limit: int
        :rtype: int
        '''
```


from scipy.integrate import solve_ivp
import numpy as np

def solve(f, c, x_eval, t_eval):
    def diffusion(t, f, c):
        du_dt = -c * np.gradient(f)
        return du_dt

    x_min, x_max, n = x_eval
    t_min, t_max, m = t_eval

    x = np.linspace(x_min, x_max, n)
    t = np.linspace(t_min, t_max, m)

    sol = solve_ivp(diffusion, [t_min, t_max], f(x), t_eval=t, args=(c,))
    return sol.y

求解一维对流方程 $\frac{\partial u}{\partial t} + c \frac{\partial u}{\partial x} = 0$。
定义 Python 函数 solve(f, c, x_eval, t_eval) 解决这个问题:
- f 是一个关于x的函数，定义了t = 0初始条件 f(x) = u(x, t=0)
- c 是一个浮点数，代表速度
- x_eval 是一个三元组 (x_min, x_max, n)，表示求解区间 [x_min, x_max] 上均匀的n个点
- t_eval 是一个三元组 (t_min, t_max, m)，表示求解区间 [t_min, t_max] 上均匀的m个点

返回一个 numpy 数组 u，表示求解结果，形状为 (n, m)，u(i, j) 表示 x = (x_min, x_max)上第i个eval点，t = (t_min, t_max)上第j个eval点时的 u(x, t) 的值


import numpy as np
from scipy.optimize import milp, LinearConstraint

def solve():
    c = -np.array([3, 2, -5, -2, 3])
    A = np.array([
        [1, 1, 1, 2, 1],
        [7, 0, 3, -4, 3],
        [11, -6, 0, 3, -3],
        [1, 0, 0, 0, 0],
        [0, 1, 0, 0, 0],
        [0, 0, 1, 0, 0],
        [0, 0, 0, 1, 0],
        [0, 0, 0, 0, 1]
    ])
    b_u = np.array([4, 8, np.inf, 1, 1, 1, 1, 1])
    b_l = np.array([-np.inf, -np.inf, 3, 0, 0, 0, 0, 0])
    cons = LinearConstraint(A, b_l, b_u)
    integrality = np.ones_like(c)
    res = milp(c = c, constraints=cons, integrality=integrality)
    return -res.fun

求解整数规划问题

max z = 3x_1 + 2x_2 - 5x_3 - 2x_4 + 3x_5
s.t.
x_1 + x_2 + x_3 + 2x_4 + x_5 <= 4
7x_1 + 3x_3 - 4x_4 + 3x_5 <= 8
11x_1 - 6x_2 + 3x_4 - 3x_5 >= 3
x_i \in {0, 1}, i = 1, ..., 5

定义python函数solve()解决这个问题，返回最优的z


某医院昼夜24h各时段内需要的护士数量如下：
- 2:00~6:00 10人
- 6:00~10:00 15人
- 10:00~14:00 25人
- 14:00~18:00 20人
- 18:00~22:00 18人
- 22:00~2:00 12人。
护士分别于2:00, 6:00, 10:00, 14:00, 18:00, 22:00分6批上班，并连续工作8h。
试确定：该医院至少应设多少名护士，才能满足值班需要。

定义 Python 函数 solve() 解决这个问题，返回结果。


import numpy as np
from scipy.optimize import milp, LinearConstraint

def solve():
    c = -np.array([8, 2, -4, -7, -5])
    A = np.array([
        [3, 3, 1, 2, 3],
        [5, 3, -2, -1, 1],
        [1, 0, 0, 0, 0],
        [0, 1, 0, 0, 0],
        [0, 0, 1, 0, 0],
        [0, 0, 0, 1, 0],
        [0, 0, 0, 0, 1]
    ])
    b_u = np.array([4, 4, 1, 1, 1, 1, 1])
    b_l = np.array([-np.inf, -np.inf, 0, 0, 0, 0, 0])
    cons = LinearConstraint(A, b_l, b_u)
    integrality = np.ones_like(c)
    res = milp(c = c, constraints=cons, integrality=integrality)
    return -res.fun

求解整数规划问题

max z = 8x_1 + 2x_2 - 4x_3 - 7x_4 - 5x_5
s.t.
3x_1 + 3x_2 + x_3 + 2x_4 + 3x_5 <= 4
5x_1 + 3x_2 - 2x_3 - x_4 + x_5 <= 4
x_i \in {0, 1}, i = 1, ..., 5

定义python函数solve()解决这个问题，返回最优的z


import numpy as np
from scipy.optimize import minimize

def solve():
    fun = lambda x: x[0]**2 + x[1]**2 + x[2]**2
    bounds = [(1, None), (2, None), (0, None), (0, None), (0, None)]
    cons = [
        {'type': 'eq', 'fun': lambda x: 2 * x[0] + x[1] + x[3] - 5},
        {'type': 'eq', 'fun': lambda x: x[0] + x[2] + x[4] - 2}
    ]
    x0 = np.array([1, 2, 0, 1, 1], dtype=np.float32)
    res = minimize(fun, x0, bounds=bounds, constraints=cons)
    return res.fun

min f(x) = x_1^2 + x_2^2 + x_3^2
s.t.
5 - 2x_1 - x_2 >= 0
2 - x_1 - x_3 >= 0
x_1 - 1 >= 0
x_2 - 2 >= 0
x_3 >= 0

定义python函数 solve() 求解这个最优化问题，返回最大值


import numpy as np
from scipy.optimize import linprog

def solve(c1):
    c = np.array([-c1, -1], dtype=np.float32)
    A_ub = np.array([[1, 1], [1, 2]], dtype=np.float32)
    b_ub = np.array([6, 10], dtype=np.float32)
    bounds = [(0, None), (0, None)]
    res = linprog(c, A_ub=A_ub, b_ub=b_ub, bounds = bounds)
    return res.x

求解线性规划问题

max z = c_1 x_1 + x_2

s.t. x_1 + x_2 <= 6
x_1 + 2 x_2 <= 10
x_1, x_2 >= 0

定义 Python 函数 solve(c1) 解决这个问题，输入 c1 是 c_1 的值，返回一个长度为2的numpy数组，表示求解结果。

#<INSERT>

assert np.abs(solve(-10.5) - np.array([0., 5.])).mean() < 1e-3


import numpy as np
from scipy.optimize import minimize

def solve():
    fun = lambda x: (x[0] - 2)**4 + (x[0] - 2*x[1])**2
    bounds = [(None, None), (None, None)]
    cons = [
        {'type': 'eq', 'fun': lambda x: x[0]**2 - x[1]}
    ]
    x0 = np.array([1, 1], dtype=np.float32)
    res = minimize(fun, x0, bounds=bounds, constraints=cons)
    return res.fun

解非线性规划问题
min f(x) = (x_1 - 2)^4 + (x_1 - 2x_2)^2
s.t. x_1^2 - x_2 = 0

定义python函数solve解决这个问题，返回最小的f(x)