E. 2 канала

package main import "sync" func Merge2Channels(fn func(int) int, in1 <-chan int, in2 <- chan int, out chan<- int, n int) { wg := new(sync.WaitGroup) f1 := make([]int, n) f2 := make([]int, n) calculate := func(in <-chan int, f []int, i int, wg *sync.WaitGroup) { defer wg.Done() f[i] = fn(<-in) } for i := 0; i < n; i++ { wg.Add(2) go calculate(in1, f1, i, wg) go calculate(in2, f2, i, wg) } go func() { wg.Wait() for i := 0; i < n; i++ { out <- f1[i] + f2[i] } }() }

package main import "sync" type record struct { x [2]int } func (r *record) result() int { return r.x[0] + r.x[1] } type table struct { records []*record size int } func newTable(size int) *table { tbl := &table{ records: make([]*record, size), size: size, } for i := 0; i < size; i++ { tbl.records[i] = &record{} } return tbl } func (tbl *table) populate(ins []<-chan int) { var ok bool for _, rec := range tbl.records { for i := range ins { if rec.x[i], ok = <-ins[i]; !ok { return } } } } func (tbl *table) foreach(f func(int) int) { var wg sync.WaitGroup wg.Add(tbl.size << 1) defer wg.Wait() for i := range tbl.records { for j := 0; j < 2; j++ { go func(rec *record, idx int, wg *sync.WaitGroup) { defer wg.Done() rec.x[idx] = f(rec.x[idx]) }(tbl.records[i], j, &wg) } } } func (tbl *table) result(out chan<- int) { for _, rec := range tbl.records { out <- rec.result() } } // Merge2Channels ... 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) { // defer close(out) tbl := newTable(n) tbl.populate([]<-chan int{in1, in2}) tbl.foreach(f) tbl.result(out) }(f, in1, in2, out, n) }

package main import "time" type Result struct { done bool value int } func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { results := make([]Result, n) go func() { for i := 0; i < n; i++ { x1 := <-in1 x2 := <-in2 index := i go func() { x1res := make(chan int) x2res := make(chan int) go func() { x1res <- f(x1) }() go func() { x2res <- f(x2) }() results[index].value = (<-x1res) + (<-x2res) results[index].done = true }() } }() go func() { for i := 0; i < n; { time.Sleep(time.Millisecond) if results[i].done { out <- results[i].value i++ } } }() }

package main var lock = make(chan struct{}, 1) func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { go func() { //mutex.Lock() lock <- struct{}{} ww1 := make(chan chan int, n) ww2 := make(chan chan int, n) go func() { for i := 0; i < n; i++ { f1 := <-<-ww1 f2 := <-<-ww2 out <- f1 + f2 } //mutex.Unlock() <-lock }() input := func(in <-chan int, ww chan chan int) { for i := 0; i < n; i++ { w := make(chan int) ww <- w x := <-in go func(w chan int, x int) { w <- f(x) }(w, x) } } go input(in1, ww1) go input(in2, ww2) }() }

package main import "sync" var lock sync.Mutex func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { go func() { done := make(chan bool, n*2) r1 := make([]*int, n) // 1 r2 := make([]*int, n) go func() { nDone := 0 for <-done { for i := nDone; i < n; i++ { if r1[i] != nil && r2[i] != nil { out <- *r1[i] + *r2[i] if nDone++; nDone == n { lock.Unlock() return } } else { break } } } }() input := func(ch <-chan int, results []*int) { for i := 0; i < n; i++ { x := <-ch go func(i int, x int) { result := f(x) results[i] = &result done <- true }(i, x) } } lock.Lock() go input(in1, r1) go input(in2, r2) }() }

package main import "sync" // AAAaaa, Let me in!! func Merge2Channels(f func(int) int, in1 <-chan int, in2 <- chan int, out chan<- int, n int) { go func() { var wg sync.WaitGroup r := make([]int, n) for i := 0; i < n; i++ { x1 := <- in1 x2 := <- in2 wg.Add(1) go func(idx, x1, x2 int, wg *sync.WaitGroup) { defer wg.Done() r[idx] = f(x1) + f(x2) }(i, x1, x2, &wg) } wg.Wait() for _, result := range r { out <- result } }() }

package main var lim chan struct{} func init(){ lim= make(chan struct{},1) } func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int){ go func() { lim<-struct{}{} 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 cnt:=0; cnt<n;{ select { case x:=<-cin1: out<- <-x+<-<-cin2 cnt++ case x:=<-cin2: out<- <-x+<-<-cin1 cnt++ } } <-lim }() }() }

package main import ( "sync" ) var lock sync.Mutex 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) { done := make(chan bool, n*2) results := make([]*int, n*2) go func() { nDone := 0 for <-done { for i := nDone; i < n; i++ { if results[i] != nil && results[i+n] != nil { out <- (*results[i] + *results[i+n]) if nDone++; nDone == n { lock.Unlock() return } } else { break } } } }() input := func(ch <-chan int, results []*int) { for i := 0; i < n; i++ { x := <-ch go func(i int, x int) { result := f(x) results[i] = &result done <- true }(i, x) } } lock.Lock() go input(in1, results[:n]) go input(in2, results[n:]) }(f, in1, in2, out) }

package main func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { go func() { sendChans := make([]chan int, n) for i := range sendChans { sendChans[i] = make(chan int) } for i := 0; i < n; i++ { c1, c2 := <-in1, <-in2 go func(k int) { sendChans[k] <- (f(c1) + f(c2)) }(i) } for i := 0; i < n; i++ { out <- (<-sendChans[i]) } }() }

package main import "sync" func Merge2Channels(f func(int) int, in1 <-chan int, in2 <-chan int, out chan<- int, n int) { go func() { var results = make([]int, n) var wg sync.WaitGroup for i := 1; i <= n; i++ { wg.Add(1) x1 := <-in1 x2 := <-in2 go func(x1 int, x2 int, indx int) { if x1 == x2{ results[indx-1] = f(x1) * 2 } else { results[indx-1] = f(x1) + f(x2) } defer wg.Done() }(x1, x2, i) } wg.Wait() for _, res := range results { out <- res } }() }