我有去23
我将程序格式化为 gorod 模块。
但是，在我的一个程序中，我需要导入 github.com/lxn/walk 包。
这个包没有 go.mod 文件，因为它是在 golang 引入模块之前编写的。
这是一个常规的go get，go get -u他们下载了它，但他们不让我将其添加到我的项目中。
如何在我的项目中使用这个包？如何正确地破坏它？
当我尝试编译自述文件中的示例时，我得到
package github.com/udonetsm/test
imports github.com/lxn/walk: build constraints exclude all Go files in /home/active/go/pkg/mod/github.com/lxn/[email protected]
而第一张截图中的内容 /home/active/go/pkg/mod/github.com/lxn/[email protected]
我安装了 postgres office 映像并使用命令启动它
sudo docker run -it -p 5432:5432 --name database -e POSTGRES_PASSWORD=q postgres
我获得了大量数据，但是 postgresql 服务器在 docker 中启动。
2024-03-06 08:47:10.553 UTC [1] LOG: listening on IPv4 address "0.0.0.0", port 5432
接下来，我尝试使用以下命令从本地计算机连接到该数据库
psql -U postgres
我收到
psql: error: connection to server on socket "/var/run/postgresql/.s.PGSQL.5432" failed: No such file or directory
Is the server running locally and accepting connections on that socket?
同时，在本地机器上我禁用了postgresql服务，以免连接到本地postgresql服务器
如何在docker中连接postgres服务器，我还想找出该卷的路径，以便将其转发到本地目录，这样容器中去往postgres服务器的数据就保存在本地机器和容器中的服务器使用本地机器上的数据。
我想用按键连接音量
-v /var/lib/local/postgres/postgres-data:/var/lib/docker/postgres/postgresql-data
但我不知道要指定哪些路径，但据我了解，冒号之前是本地计算机上的数据库文件夹（我假设我可以指定任何方便的路径），后面是数据库文件夹在容器中（这是数据库等存储在我不知道的容器中的地方）。如果我理解正确，那么容器中的数据库服务器将访问本地文件夹（冒号之前的文件夹），而不是访问其内部文件夹，因此容器中最终的所有数据都将保存在本地。如果我误解了，请纠正我。
我们有：
路由上有一个中间件，用于检查 json 内接收到的数据是否有效。json 本身自然在 request.Body 中。为了检查json-e中的数据，需要对其进行解包，这是在中间件中完成的。但事实证明这是非常不愉快的行为，在从 Body 中解压 json 后，Body 变为空，当我这样做时next.ServeHTTP(w,r)，其余控制器收到一个空的 request.Body。
原则上，为什么会发生这种情况是可以理解的。但该怎么办并不完全清楚。
我需要：中间件在读取主体后根本不清除主体，或者在将控制权转移到另一个控制器（HadlerFunc）之前用 json 填充它，或者我需要一种根本不会解压 json 进行读取的方法（这里甚至什么也没有想到......这是一个API，在进入服务器的内部功能之前有必要检查数据的有效性）。将 json 解包到中间件中并在将其传递到另一个控制器之前将其打包回去，看起来不太好。重要的是对象必须继续通过引用传递。
一般来说，检查 json-e 中数据有效性的 IDIAMATIC 方法是什么？
这是在模型文件中（我没有包含所有内容，以免超载。还有接口和接口函数）
type Entries struct {
Number string `gorm:"number" json:"number"`
Object *Contact `gorm:"object" json:"object,omitempty"`
Error error `json:"error,omitempty" gorm:"-" `
}
type Contact struct {
Number string `json:"num,omitempty"`
Name string `json:"name,omitempty"`
NumberList []string `json:"nlist,omitempty"`
}
func (j *Entries) UnpackEntries(data []byte) {
err := json.Unmarshal(data, j)
if err != nil {
j.Error = err
return
}
}
这是在控制器中
func request(w http.ResponseWriter, r *http.Request) *models.Entries {
req, err := io.ReadAll(r.Body)
if err != nil {
w.WriteHeader(http.StatusInternalServerError)
w.Write([]byte("Something wrong. Try later"))
}
e := &models.Entries{}
//UnpackingEntries это как раз интерфейсная фунция которая
//вызывает метод func (j *Entries) UnpackEntries(data []byte)
//см выше сам метод
models.UnpackingEntries(e, req)
return e
}
//проблемная мидлварь
func MW(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
r.Header.Set("Accept", "application/json")
// Здесь r.Body содержит отправленный серверу json
e := request(w, r)
use.Match(e, use.ENUM)
if e.Error != nil {
fmt.Fprintln(w, e)
log.Println(e.Error, "for object", e.Object)
return
}
// здесь r.Body не содержит отправленныйв серверу json.
next.ServeHTTP(w, r)
}
}
中间件之后，其他控制器也使用request()函数，但已经报错Unexpected end of JSON
任务：实现MergeSort
我现在的阶段是：将数组划分为子数组并对这些子数组进行排序
不能：连接已排序的子数组。
条件（这是我的条件，而不是根据任务）：如果可能的话，仅使用已经存在的代码（因为我自己弄清楚了如何创建子数组并对它们进行排序，所以我想继续使用它）。
我已经写的代码：
package main
import (
"fmt"
"math/rand"
)
func main() {
// создаю массив под начальные числа и
// пустой массив под результат сортировки
var anonsorted, asorted []int
// заполняю начальный массив псевдорандомными числами.
for i := 0; i < 20; i++ {
anonsorted = append(anonsorted, rand.Intn(100))
}
asorted = divideAndSort(anonsorted, asorted)
fmt.Println(asorted)
}
// алгоритм создает группы(под-под-массивы) и сразу сортирует числа внутри этих под-под-массивов
// не могу додуматься как эти группы сотрированных под-под-массивов соеденить.
func divideAndSort(adivided, asorted []int) []int {
if len(adivided) == 1 {
return adivided
}
divide := len(adivided) / 2
left := 0
for i := range adivided {
if adivided[i] <= adivided[divide] {
adivided[i], adivided[left] = adivided[left], adivided[i]
left++
}
}
// отсортированный подмассив от нулевого индекса до его опорного
oneHalf := divideAndSort(adivided[:divide], asorted)
// отсортированный подмассив от его опорного индекса до конца массива.
twoHalf := divideAndSort(adivided[divide:], asorted)
asorted = merge(oneHalf, twoHalf, asorted)
return asorted
}
func merge(oneHalf, twoHalf, asorted []int) []int {
//...
//asorted = объединение oneHalf и twoHalf
return asorted
}
更新：
func merge(one, two, sorted []int) []int {
i, j := 0, 0
for i < len(one)-1 && j < len(two)-1 {
if one[i] <= two[j] {
sorted = append(sorted, one[i])
} else {
sorted = append(sorted, two[j])
}
i++
j++
}
if i < len(one) {
sorted = append(sorted, one...)
}
if j < len(two) {
sorted = append(sorted, two...)
}
return sorted
}
给出不正确的结果。
更新2：
我发现了所有的错误。
1. перенес инкременты из цикла и условия
2. при выходе из цикла в уловиях сделал заполнение `sorted`
от того индекса на котором завешился цикл а не от нулеого.
3. цикл сделал до len(array) а не до len(rray)-1
这是最终版本merge()。
func merge(one, two, sorted []int) []int {
i, j := 0, 0
for i < len(one) && j < len(two) {
if one[i] <= two[j] {
sorted = append(sorted, one[i])
i++
} else {
sorted = append(sorted, two[j])
j++
}
}
if i < len(one) {
//здесь была ошибка. Нужно было заполнять от того i
//на котором закончился цикл а не от нулевого.
sorted = append(sorted, one[i:]...)
}
if j < len(two) {
//здесь была ошибка. Нужно было заполнять от того j
//на котором закончился цикл а не от нулевого.
sorted = append(sorted, two[j:]...)
}
return sorted
}
再次使用递归。这次我想弄清楚如何确定递归深度
问题：给出一个自然数序列作为输入；您需要确定该序列的平均值。
条件：仅使用递归。
我的决定：
package main
import "fmt"
func main() {
fmt.Printf("%f", rec(0, 0))
}
func rec(sum, count float64) float64 {
x := 0.0
fmt.Scan(&x)
if x == 0 {
return sum / count
}
return rec(sum+x, count+1)
}
我想知道我的解决方案的递归深度是多少。我假设该函数的递归深度将等于变量count。在这种情况下，如果序列无限期地继续，我会发现潜在的堆栈溢出。如果我之前的假设是正确的，那么如何在每次调用后清理堆栈以使其不会膨胀？
我尝试这样做strace -k go run .，当我输入数字“1,2,3,4,5,6,7,8,9,8,7,6,5,4,3,2,1,0”时，我得到输出
> /usr/lib/go-1.21/bin/go() [0x70b63]
> /usr/lib/go-1.21/bin/go() [0xebe7]
> /usr/lib/go-1.21/bin/go() [0x4042c]
> /usr/lib/go-1.21/bin/go() [0x41d5c]
> /usr/lib/go-1.21/bin/go() [0x42b51]
> /usr/lib/go-1.21/bin/go() [0x43a66]
> /usr/lib/go-1.21/bin/go() [0x6cece]
+++ exited with 0 +++
但我不明白这意味着什么。理论上，-k它会在每次调用后打印堆栈。这个结论是否意味着堆栈根本不臃肿？
更新：
根据评论，我去阅读了尾递归，发现了一个尾递归不会被优化的例子。
基于这个例子，我稍微编辑了我的代码，如下所示：
package main
import "fmt"
func main() {
fmt.Printf("%f", rec(0, 0))
}
func rec(sum, count float64) float64 {
x := 0.0
fmt.Scan(&x)
if x == 0 {
return sum / count
}
return 1 * rec(sum+x, count+1)
}
这是否使递归无法优化？我如何知道我的递归在迭代之前是否正在优化？
UPPD
我开始阅读 sicp，他们也在那里写道（在我看来这是非常正确和合理的），树递归生成的递归调用甚至比线性递归多很多倍。树递归对什么样的数据有用？我不明白为什么需要它。
上面截图段落中讨论的树递归算法：
以及在树递归中生成调用的方案。显示被fib 1调用多达5次，其余情况fib x也好不到哪里去……
我还在研究递归
任务：判断N是否为素数。
条件：仅使用递归。
我的解决方案（在评论中解释我的逻辑）：
package main
func main() {
rec(890, 1, 0) //Output: NO
println()
}
// функция имеет допущение, что n>1(т.е рассчитывает на здравый смысл вызывающего)
// для n<=1 результат будет неправильным(YES).
func rec(n, d, c int) {
// если делитель дошел до делимого,
//то очевидно, что если они равны то делятся без остатка и
//делимость проверять не нужно. Просто выходим из функции.
//этот случай означает, что от d>1 до n делителей не найдено.
//значит n делится только на себя и на 1
if d > n {
print("YES")
return
}
//поиск делителя для n в диапазоне от 2 до n
if n%d == 0 && d > 1 {
//увеличиваем счетчик делителей
c++
//если d еще не дошел до n, а уже нашел делитель(c>0),
//то число точно составное, дальнейшие проверки не имеют смысла
//говорим что число составное и выходим из функции.
if c > 1 || (n%2 == 0 && n > 2) {
print("NO")
return
}
n=int(math.Sqrt(float64(n))) //так код продолжает работать, но делает это быстрее,
//хоть и нет гарантии что правильно рассчитывает. Но пока что ни разу не ошибся
}
//рекурсивно проверяем является ли d+1 делителем n
//рекурсивный вызов будет происходит до тех пор,
//пока c<1 || (d<n && n%d!=0 && (n>2 && n%2!=0))
rec(n, d+1, c)
}
问题1：是否可以不用那么多如果（据我能想到）？
Question2：如何计算这个算法的复杂度？如何使其非线性
问题3：如果数字太大，例如1284762193641112317堆栈溢出。问题是什么？我的猜测是递归调用太多了。但如何解决这个问题呢？
更新：
在代码中添加了一个片段
n = int(math.Sqrt(float64(n)))
并且代码继续有效。我在寻找一种减少递归调用次数的方法时想到了这个，并且通过这样的片段，在每次调用中 n 都减少到其根。
我正在努力掌握递归。任务：仅使用整数算术和递归，按直接顺序打印数字的所有数字，并用空格或其他分隔符分隔。不允许使用第三方软件包。我写并提出了这个解决方案：
package main
func main() {
rec(198, 0)
}
func rec(n, m int) (int, int) {
if n == 0 {
//убрать лишний ноль в конце перевернутого числа
m /= 10
//завершить выполнение когда все цифры числа будут выведены.
if m == 0 {
//функция перестает вызываться рекурсивно, когда все цифры выведены в прямом,
//по отношению к начальному числу, порядке.
return 0, 0
}
//вывести остаток от деления m на 10. Получаем последнюю цифру перевернутого числа
print(m%10, " ")
//убрать ту цифру которую уже вывели.
m /= 10
}
//рекурсивный переворот начального числа(делается в первую очередь)
//когда все разряды прибавлены к m и умножены на 10,
//получаем не цифры в обратном порядке, а именно перевернутое число.
//но в конце у него будет 0, его потом убираем внутри n==0 && m!=0
m += n % 10
//запускаем функцию с аргментом без последней цифры начального числа,
//которую уже включили в перевернутое число
//m умножаем на 10, как раз чтобы получить не просто цифры в обратном порядке а именно число.
//когда число будет переврнуто и функция провалится в условие n==0 && m!=0
//функция будет вызываться так же рекурсивно но с 0 в качестве обоих аргументов.
return rec(n/10, m*10)
}
但我怀疑，如果没有 n=0 && m!=0 的那部分条件，也可以做一些事情。但我还是不明白怎么做。如果你知道请告诉我。
更新：
package main
func main() {
rec(123456789098765432)
println()
}
func rec(n int) {
if n < 10 {
print(n)
} else {
rec(n / 10)
print(" ", n%10)
}
}
在这种方法中，递归调用的结果适用于堆栈原理还是什么？后进先出？首先，不会对其他所有实例执行打印，而是首先调用该函数的所有实例rec()，然后才发生输出，但输出以与调用相反的顺序发生，rec()但如果输出放在调用之前rec()，则输出顺序将与呼叫直接相关，但与起始号码相反。
我试图理解接口的用途。我写了这个例子：
package main
type Talker interface {
Talk()
}
type Person1 struct {
text string
}
type Person2 struct {
text string
}
func (n *Person1) Talk() {
println("person1 says", n.text)
}
func (n *Person2) Talk() {
println("person2 says", n.text)
}
func Converse(l Talker) {
l.Talk()
}
func main() {
Converse(&Person1{"hello"})
Converse(&Person2{"hi"})
}
写完后，我可以这样表述该接口的用途：
如果一个对象没有实现接口的所有方法，或者实现了至少一个与接口中指定的签名不同的方法，那么该对象将无法访问该接口的对象的通用功能（在我的示例中，是 Converse(l Talker) 函数）。
接口的目的真的只是以某种方式封装对象及其数据吗？看起来这似乎是对程序员的一种保护，因为他不明白自己在做什么，也不明白处理对象和数据需要什么方法和函数，而接口则向他澄清，“你确定这个对象应该正是处理这个函数吗？” 以前，我没有以这种方式考虑接口，因为它们总是作为通用化某些东西的手段而呈现，当我寻找这种通用化时我无法理解它们，因为我不观察通用化（谈论方法，无论如何，你需要为每个对象写不同的）
我将添加到答案：
package main
import (
"log"
"os"
)
type MoveSaveReader interface {
Copy()
Save()
Read()
}
type OBJ struct {
data, filename, newpath string
}
type NewObj struct {
data, path string
}
func (o *NewObj) Copy() {
}
func (o *NewObj) Save() {
err := os.WriteFile(o.path, []byte(o.data), 6060)
if err != nil {
log.Println(err)
return
}
log.Println("Saved")
}
func (o *NewObj) Read() {
d, err := os.ReadFile(o.path)
if err != nil {
log.Println(err)
return
}
o.data = string(d)
}
func (o *OBJ) Copy() {
o.Read()
o.filename = o.newpath
o.Save()
}
func (o *OBJ) Save() {
err := os.WriteFile(o.filename, []byte(o.data), 6060)
if err != nil {
log.Println(err)
return
}
log.Println("Saved")
}
func (o *OBJ) Read() {
d, err := os.ReadFile(o.filename)
if err != nil {
log.Println(err)
return
}
o.data = string(d)
}
func CopyFile(m MoveSaveReader) {
m.Copy()
}
func WriteNewFile(m MoveSaveReader) {
m.Save()
}
func ReadFile(m MoveSaveReader) {
m.Read()
}
func main() {
obj := &OBJ{"sometext", "path", "newpath"}
WriteNewFile(obj)
ReadFile(obj)
CopyFile(obj)
newObj := &NewObj{"newtext", "newSomePAth"}
WriteNewFile(newObj)
ReadFile(newObj)
}
不具有至少一种方法 的对象MoveSaveReader，即：Copy()、Save()，Read()或者有方法但至少有一个错误的签名，则这样的对象将受到保护，不会在函数CopyFile(m MoveSaveReader)、ReadFile(m MoveSaveReader)、中被错误放置WriteFile(m MoveSaveReader)。也就是说，借助接口我不再通用化数据处理，而是保护它？
我很难理解 goroutine 和通道。结果这个话题对我来说很难，有一瞬间困扰着我（因为我不明白）。我将提供完整的代码，因为我不确定问题是否出在 somework 函数中（尽管几乎肯定存在）。
这个问题完全是虚构的，要理解：
当其中一个嵌套 goroutine 正在执行长时间运行的操作时，如何继续执行所有 goroutine，包括 main...
我把我所有的想法写在代码的注释中，包括标记出对我提出问题的地方。因此，欢迎直接上代码。感谢您的关注和时间。
package main
import (
"fmt"
"io/ioutil"
"os"
"time"
)
func main() {
start := time.Now().UnixNano()
in, out, wait := make(chan int), make(chan int), make(chan bool)
go somework(in, out, wait, 12)
// записываем рандомные данные в канал который потом
// передадим в качестве аргумена в somework
in <- int(time.Now().Unix())
// выводим результат работы somework
fmt.Printf("somework вернула в канале значение: %v\n", <-out)
end := time.Now().UnixNano()
fmt.Printf("функция main завершилась через >>%v<< наносекунд после своего начала, выполнив все второстепенные горутины\n", end-start)
// ждем, пока somework просигнализирует об окончании своей работы.
<-wait
}
// некая функция, которая внутри себя должна отправить на выполнение длительную операцию.
// все горутины, включая main должны продолжать свое выполнение и когда завершится длительная
// операция вывести результат этой длительной операции независмо от того что в этот момент
// будет делать функция main
func somework(ch, out chan int, wait chan bool, i int) chan int {
start := time.Now().UnixNano()
go func() {
rsultOfrollingAction := make(chan int)
// далее запускаю длительную операцию чтения файла в отдельной горутине
go func(rsultOfrollingAction chan int) {
d := make(chan bool) //для сигнализации об окончании длительного действия
// начало длительной операции в отдельной горутине
// результат данной работы, при имеющемся коде, не выводится.
// ДАННЫЙ ВОПРОС ОТНОСТИИТСЯ КАК РАЗ К ЭТОЙ ПРОБЛЕМЕ
go func(d chan bool) {
time.Sleep(time.Second * 3)
text := readf("text.txt")
rsultOfrollingAction <- len(text)
// сигнализируем горутине которая должна вывести количество
// прочитанных строк, что длительная операция завершене
d <- true
}(d)
// когда d получает сигнал об окончании длительной операции
<-d
// выводим результат длительной операции.
fmt.Printf("вложенная в somework горутина завершила выполенение прочитав из файла %v символов\n", <-rsultOfrollingAction)
}(rsultOfrollingAction)
// читаем канал из входных аргументов somework
a := <-ch
// записываем в вызодной кнал
out <- a
// сигнализируем об окончании somesomework()
wait <- true
}()
fmt.Printf("прошло >>%v<< наносекунд с момента начала функции work и функция somework завершилась передав управление main\n", time.Now().UnixNano()-start)
// возвращаем канал с результататом работы somework
return out
}
// поростейшее чтение файла.
func readf(name string) []byte {
f, err := ioutil.ReadFile(name)
if err != nil {
fmt.Println(err)
os.Exit(123)
}
return f
}
我试图了解使用匿名函数调用函数的方法。而且我不明白为什么golang中需要匿名函数。例如，方法之间有什么区别
package main
import "fmt"
func main() {
var i, j int
fmt.Scan(&i, &j)
fmt.Println(sum(i, j))
}
func sum(i, j int) int {
return i + j
}
从方法
package main
import "fmt"
func main() {
var i, j int
fmt.Scan(&i, &j)
fmt.Println(do(i, j, sum))
}
func sum(i, j int) int {
return i + j
}
func do(i, j int, f func(int, int) int) int {
return f(i, j)
}
在第二个选项中，除了调用 sum() 函数的明显复杂性以及从中抽象之外，我还没有看到重点。什么是第二种方法可以做而第一种方法不能做的事情？当然，我很高兴我可以实现这两种方法，但如果第二种方法更复杂，为什么我需要第二种方法呢？
任务是确定字符串中的所有字符都是唯一的。例如在入口处
test string
在出口处
test string - false
在入口
abcde
在出口处
abcde - true
我这样做
package main
import (
"log"
"strings"
)
func CountLetters(str string) (bool, string) {
slcstr := strings.Split(str, "")
mpbool := make(map[string]bool, 0)
for _, item := range slcstr {
_, ok := mpbool[item]
if ok {
return false, str
}
mpbool[item] = true
}
return true, str
}
func main() {
log.Println(CountLetters("test"))
}
但也许还有其他一些方法，或者有一些经典的方法吗？而且我有点尴尬的是，缓慢的功能，我认为是因为字符串包。是否有没有它且没有类型转换的变体？
大家好。你可以创建一个集合，你可以像这样填充它
func main() {
m := make(map[int]bool, 0)
for i := 0; i < 20; i++ {
m[i] = true
}
log.Println(m)
}
是这样吗，如果是这样，如何为集合创建一个子集
需要这样的东西
множество[подмножество1{член1, член2, член3...}, подмножество2{член1, член2, член3 ...}...etc]
package main
import (
"math"
"sync"
)
type Set struct {
sync.Mutex
mp map[*SubSet]bool
}
type SubSet struct {
sync.Mutex
mp map[float64]bool
}
func NewSet() *Set {
return &Set{
mp: map[*SubSet]bool{},
}
}
func NewSubSet() *SubSet {
return &SubSet{
mp: map[float64]bool{},
}
}
func (s *SubSet) InsertInSubset(key float64) *SubSet {
s.Lock()
defer s.Unlock()
s.mp[key] = true
return s
}
func (s *Set) InsertInSet(key *SubSet, value bool) *Set {
s.Lock()
defer s.Unlock()
s.mp[key] = true
return s
}
func CelcionSet(celcions []float64) {
celcions = QS(celcions)
lencelcions := len(celcions)
set := NewSet()
for i := 0; i < lencelcions; i++ {
rng := math.Trunc(celcions[i]/10) * 10
sub := NewSubSet()
set.InsertInSet(sub.InsertInSubset(celcions[i]), true)//это конечно же не сработает, но не понимаю как заставить работать чтобы в множество вставлялось подмножество
}
}
func QS(nums []float64) []float64 {
// find len of arr
lennums := len(nums)
// if arr contains less then 2 items, nothing to sort
if lennums < 2 {
return nums
}
toehold := nums[0] //or nums[lennums/2]
// items which less than toehold
left := make([]float64, 0)
// items which more than toehold
right := make([]float64, 0)
for _, num := range nums[1:] {
// move to right if item more than toehold
if num > toehold {
right = append(right, num)
} else {
// move to left if item less than toehold
left = append(left, num)
}
}
// recoursive sorting left side
nums = append(QS(left), toehold)
// recoursive sorting right side
nums = append(nums, QS(right)...)
return nums
}
大家好
任务是将数字的第 i 位更改为 1 或 0。我这样做了，但让我感到困惑的是，有很多类型转换和代码，原则上，这样的任务很多。还能怎么做？
package main
import (
"fmt"
"log"
"strconv"
)
func IntToBits(num int) string {
return strconv.FormatInt(int64(num), 2)
}
func bitsToInt(s string) int64 {
newVal, err := strconv.ParseInt(s, 2, 64)
if err != nil {
log.Fatal(err)
}
return newVal
}
func changeOneBit(num, position, newBit int) int64 {
if position > 0 && num == 0 {
return int64(num)
}
if newBit > 1 || newBit < 0 {
log.Println("Новый бит может быть только 1 или 0")
return int64(num)
}
bits := []byte(IntToBits(num))
fmt.Printf("Было \t %s(%v)\n", string(bits), num)
if position >= len(bits) {
log.Printf("В числе %v нет %v разрядов. Разярядов в числе %v только %v\n", num, position, num, len(bits))
return int64(num)
}
newB := []byte(IntToBits(newBit))
bits[position] = newB[0]
newVal := bitsToInt(string(bits))
fmt.Printf("Стало \t %s(%v)\n", string(bits), newVal)
return newVal
}
func main(){
log.Println(changeOneBit(12, 3, 1)) //8
}
大家好。任务是开发一个在竞争环境中工作的计数器结构。我不确定我是否正确理解了“结构计数器”一词。也许有人知道计数器结构是什么意思？我是这么理解的
package main
import (
"sync"
"github.com/udonetsm/help/helper"
)
type Counter struct {
num int
sync.RWMutex
}
func (c *Counter) Count(wg *sync.WaitGroup, finish, start int) int {
defer helper.PanicCapture("Count")
wg.Add(finish - start)
for c.num < finish {
go func() {
c.Lock()
c.num += 1
c.Unlock()
wg.Done()
}()
}
return c.num
}
func New(start int) *Counter {
defer helper.PanicCapture("INIT")
return &Counter{
num: start,
}
}
func Counting(start, finish int) {
defer helper.PanicCapture("Counting")
c := New(start)
wg := sync.WaitGroup{}
c.Count(&wg, finish, start)
wg.Wait()
}
不断地给人一种恐慌
panic: sync: negative WaitGroup counter
package main
import (
"log"
"sync"
"time"
"github.com/udonetsm/help/helper"
)
type Counter struct {
num int
sync.RWMutex
}
func (c *Counter) Count(wg *sync.WaitGroup, finish, start int) int {
defer helper.PanicCapture("Count")
wg.Add(1)
go func() {
for i := start; i <= finish; i++ {
c.Lock()
c.num += 1
c.Unlock()
log.Println(c.num)
time.Sleep(time.Second)
}
wg.Done()
}()
wg.Wait()
return c.num
}
func New(start int) *Counter {
defer helper.PanicCapture("INIT")
return &Counter{
num: -1,
}
}
func Counting(start, finish int) {
defer helper.PanicCapture("Counting")
c := New(start)
wg := sync.WaitGroup{}
log.Println(c.Count(&wg, finish, start))
}
所以他并不恐慌，他没有正确使用 Wait 。但是不知道有没有看懂counter的结构
package main
import (
"log"
)
func BinarySearch(sorted, result []int, target int) int {
lendata := len(sorted) - 1
var mid int
first := 0
for first < lendata {
mid = (first + lendata) / 2
if target > sorted[mid] {
first += 1
}
if target < sorted[mid] {
lendata -= 1
}
if target == sorted[mid] {
//здесь нужно добавить искомый в массив и ПРОДОЛЖИТЬ выполнение функции пока текущий элемент не станет больше или меньше искомого
return mid
}
}
if sorted[first] != target && sorted[lendata] != target {
return 0
}
return mid
}
你好。输入是一个排序数组，数组的中心，期望的值。你真的需要找到你正在寻找的东西。原则上，我处理了搜索，但是在第一次出现所需的之后，它就结束了，我无法以任何方式用找到的所需数字的位置来固定结果数组的填充。这个怎么做？
升级版：
package main
import (
"log"
)
/* Находит первое вхождение искомого */
func BinarySearch(sorted, result []int, target int) []int {
// изначально границы поиска между нулевым и последний элементом
lendata := len(sorted)
first := 0
//чтобы сохранять сюда середину текущей области поиска и иметь к ней доступ вне цикла
var mid int
//Идем от начальной границы до конечной
for first < lendata {
//При первом вхождении искомого выходим из цикла
if target == sorted[mid] {
break
}
//если искомое больше чем значение в середине области поиска,
//началом области поиска становится то значение, которое было серединой области +1
//так как значение по середине тоже не искомое
if target > sorted[mid] {
log.Println(">", mid)
first = mid + 1
}
//если искомое меньше, чем значение посередине области поиска,
//то конечной границей области поиска становится середина-1
//так как значение посередине не подошло тоже
if target < sorted[mid] {
log.Println("<", mid)
lendata = mid - 1
}
//находим заново середину так как в условиях передвинули границы
mid = (first + lendata) / 2
}
//добавляем в массив вхождений первый индекс содержащий искомое
result = append(result, mid)
//вызов нахождения повторных вхождений искомого в массиве по первому индексу который содержит искомое
result = FindRepeated(target, mid, sorted, result)
return result
}
//Здесь ничего интересного. QuickSort тот, что я сделал в одном из заданий уровня, чтобы не писать заново
//использую его
//Сортировка нужна так как бинарный поиск работает только на отсортированном массиве(слайсе)
func make_for_Binary(target int) {
slc, result := make([]int, 0), make([]int, 0)
slc = append(slc, 32, 1, 1, 1, 2, 5, 12, 87, 87, 87, 87, 87, 87, 87, 45, 344, 344, 12, 3, 89, 90, 43)
slc = QuickSort(slc)
//здесь вывод чтобы можно было убедится что поиск выводит индексы корректно и ничего не сдвигается
log.Println(slc)
result = BinarySearch(slc, result, target)
//дополнительно сортирую все индексы с искомым для удобства восприятия
result = QuickSort(result)
log.Println(result)
}
//Принимает первое индекс с искомым и опираясь на него находит остальные вхождения искомого.
func FindRepeated(target, position int, sorted, result []int) []int {
//Буфер
p := position
//проверка всех индексов следующих за первым вхождением
for position <= len(sorted)-1 {
//не допускаем выход за пределы массива(слайса), так как иначе будет паника, так как индекс не может быть > длины массива
if position+1 >= len(sorted) {
break
}
//все повторные вхождения после первого индекса вносятся в результирующий слайс
if sorted[position+1] == target {
//и передвигаемся на следующий в порядке убывания элемент
position += 1
result = append(result, position)
} else {
break
}
}
position = p
for position >= 0 {
if position-1 <= 0 {
break
}
if sorted[position-1] == target {
position -= 1
result = append(result, position)
} else {
break
}
}
return result
}
大家好。培训课程中有几个任务需要，例如，在竞争地图中记录值，竞争性地平方值，还有一些还需要一些东西有竞争力地完成。我不明白你说的竞争是什么意思？谁能举一个完全竞争的操作的例子，但是这么简单的例子，就好像你会展示一个孩子一样。
如果它很重要，那么 go 语言，但我认为这些东西与语言无关
我就是这么理解的。问题e
Написать программу, которая конкурентно рассчитает значение квадратов чисел взятых из массива (2,4,6,8,10) и выведет их квадраты в stdout.
如果竞争意味着并行计算，这是我的解决方案。
package main
import "fmt"
func square(num int) {
fmt.Println(num * num)
// fmt.Fprintln(os.Stdout, num*num)
}
func do() {
nums := [...]int{2, 4, 6, 8, 10}
for _, num := range nums {
go square(num)//параллельные вызовы square
}
fmt.Scanln()
}
大家好。
我在一个项目中有几个中间件，当在运行最终的 handlefunk 之前请求特定的 url 时，它们会被一一触发
我遇到了原始请求中的数据在通过中间件时丢失的事实。比如表单数据。
现在，为了将初始请求数据带到最终的handfunk，我将请求数据保存在第一个中间件中，然后将其作为标头传递给下一个中间件。有没有更实用的方法来获取从初始请求到最终句柄的数据？谢谢。
大家好
我需要通过 go 的内置工具发送 https 请求。
我愿意
func Requester(url, method, token, login string) []byte {
defer tools.Panic_recover("requester")
url = strings.TrimSpace(fmt.Sprintf("\n%s\n", url))
req, err := http.NewRequest(method, url, nil)
req.Header.Add("Login", login)
req.Header.Add("Token", token)
tools.Errors("httpnewrequest(from requester)", err)
resp, err := http.DefaultClient.Do(req) //подозреваю что проблема с дефолтным клиентом http
tools.Errors("defclido(from requester", err) //здесь `certificate has expired or is not yet valid: current time 2022-04-26T18:04:55+03:00 is after 2014-12-19T10:21:01Z`
ans, err := ioutil.ReadAll(resp.Body)
tools.Errors("ioutilreadll from requester", err)
return ans
}
我在评论中发表了我的想法。我正在尝试修复它
func Clientt() *http.Client {
return &http.Client{
Transport: &http.Transport{
DialTLS: //здесь не знаю что писать чтобы подключить сюда сертификат,
},
}
}
结果是我想使用的函数而不是 defaultclient。我有一个域和子域的通配符证书。我从一个域到一个子域创建了一个请求者，证书结果是一样的。但 DefaultClienDo 写道certificate has expired or is not yet valid: current time 2022-04-26T18:04:55+03:00 is after 2014-12-19T10:21:01Z。我认为问题出在默认客户端的设置中。如何注册您的证书？
大家好你们好。我的表有 3 列，每一列都不是唯一的。我希望这些列保持非唯一，但通常不可能向表中添加与另一行完全匹配的行。
例如，如果已经有一个条目：
id username dob
1 John 01-01-1991
然后当你进入
insert into some_table (id, username, dob) values(1, 'John', '01-01-1991')
没有创建新记录，但理想情况下它给出了一个错误，然后可以在后端处理
但是，如果在相同条件下，值的参数中至少有一个值发生了变化，则输入
按 id 过滤不合适，因为 id 指的是另一个表，怎么办？