E. 2 канала

package main import "sync" func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { ch1 := make(chan int, 100) ch2 := make(chan int, 100) go readChannel(in1, ch1, n) go readChannel(in2, ch2, n) prev := make(chan interface{}, 2) prev = nil for ; 0 < n; n-- { next := make(chan interface{}, 2) go func(prev <-chan interface{}, next chan<- interface{}) { var r1, r2 int if prev != nil { <-prev } x, y := <-ch1, <-ch2 next <- struct{}{} wg := &sync.WaitGroup{} wg.Add(1) go func() { r1 = f(x) wg.Done() }() r2 = f(y) wg.Wait() res := r1 + r2 if prev != nil { <-prev } out <- res next <- struct{}{} }(prev, next) prev = next } } func readChannel(in <-chan int, out chan<- int, n int) { for ; n > 0; n-- { out <- <-in } }

package main func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { go func() { temp_chan1 := make(chan chan int, n) temp_chan2 := make(chan chan int, n) go func() { for i := 0; i < n; i++ { res_1 := <-<-temp_chan1 res_2 := <-<-temp_chan2 out <- res_1 + res_2 } }() input := func(in <-chan int, temp_chan chan chan int) { for i := 0; i < n; i++ { buffer := make(chan int) temp_chan <- buffer value := <-in go func(buffer chan int, value int) { buffer <- f(value) }(buffer, value) } } go input(in1, temp_chan1) go input(in2, temp_chan2) }() }

package main func calc(f func(int) int, x int, out chan<- int, prev <-chan struct{}, next chan<- struct{}) { y := f(x) <-prev out <- y close(next) } func calcChannel(f func(int) int, in <-chan int, out chan<- int, n int) { prev := make(chan struct{}) first := prev for i := 0; i < n; i++ { next := make(chan struct{}) x := <-in go calc(f, x, out, prev, next) prev = next } close(first) } func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { go func() { out1 := make(chan int) out2 := make(chan int) go calcChannel(f, in1, out1, n) go calcChannel(f, in2, out2, n) for i := 0; i < n; i++ { x1 := <-out1 x2 := <-out2 y := x1 + x2 out <- y } }() }

package main import "sync" func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { go func() { resultSum := make([]int, n) wg := &sync.WaitGroup{} wg.Add(n) for i := 0; i < n; i++ { x1 := <-in1 x2 := <-in2 go func(i int) { defer wg.Done() res1 := make(chan int) res2 := make(chan int) go wrapF(f,res1, x1) go wrapF(f,res2, x2) resultSum[i] = <-res1 + <-res2 }(i) } wg.Wait() for i := 0; i < n; i++ { out<- resultSum[i] } }() } func wrapF(f func(int) int, out chan<- int,num int){ out <- f(num) }

package main import ( "sync" ) func main() { } func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { go func() { resultSum := make([]int, n) wg := &sync.WaitGroup{} wg.Add(n) for i:=0; i < n; i++ { x1 := <- in1 x2 := <- in2 go func(i int) { defer wg.Done() f1 := make(chan int) f2 := make(chan int) go func(x int){ f1 <- f(x1) }(x2) go func(x int){ f2 <- f(x2) }(x2) resultSum[i] = <-f1 + <-f2 }(i) } wg.Wait() for i:=0; i<n; i++ { out <- resultSum[i] } }() }

package main import ( "runtime" "sync" ) type Result struct { R map[[2]int]int sync.Mutex } var result = Result{} type Order struct { NN [][2]int sync.Mutex } var order = Order{} type Carret struct { K int sync.Mutex } var K = Carret{} var mutex sync.Mutex var wg = &sync.WaitGroup{} func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { order.NN = make([][2]int, 0) result.R = make(map[[2]int]int) K.K = 0 process := func(n int, fch chan int) { fch <- f(n) } go func(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { wg.Add(n) i := 0 for i < n { mutex.Lock() n1 := <-in1 runtime.Gosched() n2 := <-in2 order.NN = append(order.NN, [2]int{n1, n2}) go func(n1 int, n2 int) { var f1 = make(chan int) var f2 = make(chan int) go process(n1, f1) go process(n2, f2) r := <-f1 + <-f2 result.Lock() result.R[[2]int{n1, n2}] = r wg.Done() result.Unlock() }(n1, n2) mutex.Unlock() i++ } wg.Wait() for K.K < len(result.R) { K.Lock() out <- result.R[order.NN[K.K]] K.K++ K.Unlock() } }(f, in1, in2, out, n) }

package main func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { go func() { fx := make([]chan int, n) for i := 0; i < n; i++ { fx[i] = make(chan int, 2) go func(ch chan int, x int) { ch <- f(x) }(fx[i], <-in1) go func(ch chan int, x int) { ch <- f(x) }(fx[i], <-in2) } for i := 0; i < n; i++ { out <- (<-fx[i] + <-fx[i]) } }() }

package main import( "sync" ) func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { go func(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { process := func(n int, fch chan int) { fch <- f(n) } var order = make([][2]int, 0, n) var results = make(map[[2]int]int) var wg = &sync.WaitGroup{} wg.Add(n) i := 0 for i < n { var f1 = make(chan int) var f2 = make(chan int) n1 := <-in1 go process(n1, f1) n2 := <-in2 go process(n2, f2) order = append(order, [2]int{n1, n2}) go func(n1 int, n2 int, f1 chan int, f2 chan int) { results[[2]int{n1, n2}] = (<-f1) + (<-f2) wg.Done() }(n1, n2, f1, f2) i++ } wg.Wait() for _, key := range order { out <- results[key] } }(f, in1, in2, out, n) }

package main func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int){ procIn := func(cin chan chan int, in <-chan int, n int) { defer close(cin) for i := 0; i < n; i++ { x, ok := <-in if !ok { return } c := make(chan int) cin <- c go func(c chan int) { c <- f(x) close(c) }(c) } } cin1 := make(chan chan int, n) cin2 := make(chan chan int, n) go procIn(cin1, in1, n) go procIn(cin2, in2, n) go func() { for i := range cin1 { out <- (<-i + <-<-cin2) } }() }

package main import ( "sync" ) func Merge2Channels(f func(int) int, in1 <-chan int, in2 <- chan int, out chan<- int, n int) { channel1, channel2 := make([]int, n), make([]int, n) var wg1, wg2 sync.WaitGroup go func() { for i := 0; i < n; i++ { wg1.Add(1) x := <-in1 go func(num int, idx int) { channel1[idx] = f(num) defer wg1.Done() }(x, i) } }() go func() { for i := 0; i < n; i++ { wg2.Add(1) x := <-in2 go func(num int, idx int) { channel2[idx] = f(num) defer wg2.Done() }(x, i) } }() go func() { wg1.Wait() wg2.Wait() for i := 0; i < n; i++ { out <- channel1[i] + channel2[i] } }() }