wesmota · September 15, 2021 12:15 · May 10, 2016 · May 10, 2016 · May 10, 2016 · May 10, 2016
diff --git a/codility_missing_elem b/codility_missing_elem
@@ -0,0 +1,22 @@
+func Solution(A []int) int {
+    // write your code in Go 1.4
+
+
+    var pom = make([]int, len(A)+1)
+    pom[0] = 0;
+    for _, v := range A {
+        if v > 0 && v <= len(A) {
+            pom[v-1] = 1
+        }
+    }
+
+    //fmt.Println(pom)
+
+    for i, v := range pom {
+        if v == 0 {
+            return i+1
+        }
+    }
+
+    return 1
+}
diff --git a/codility_permutation b/codility_permutation
@@ -0,0 +1,21 @@
+func Solution(A []int) int {
+    // write your code in Go 1.4
+
+    var pom = make([]int, len(A)+1)
+    var sum = 0
+    for _, v := range A {
+
+            if v < len(pom) && pom[v] == 0 {
+                pom[v] = 1
+                sum += 1
+            }
+
+       // fmt.Println(v, sum, X)
+
+    }
+
+    if(sum == len(A)) {
+            return 1
+        }
+    return 0
+}
diff --git a/codility_frog_leaves_27% → codility_frog_leaves b/codility_frog_leaves_27% → codility_frog_leaves
@@ -1,19 +1,19 @@
 func Solution(X int, A []int) int {
     // write your code in Go 1.4
 
-    var pom = make([]int, X)
+    var pom = make([]int, X+1)
     pom[0] = 1
-    var sum = 1
+
     for i, v := range A {
-        if v < X {
+
             if pom[v] == 0 {
                 pom[v] = 1
-                sum += 1
+                X--
             }
 
-        }
+
        // fmt.Println(v, sum, X)
-        if(v == X && sum == X) {
+        if(X == 0) {
             return i
         }
     }

diff --git a/codility_frog_leaves_27% b/codility_frog_leaves_27%
@@ -0,0 +1,22 @@
+func Solution(X int, A []int) int {
+    // write your code in Go 1.4
+
+    var pom = make([]int, X)
+    pom[0] = 1
+    var sum = 1
+    for i, v := range A {
+        if v < X {
+            if pom[v] == 0 {
+                pom[v] = 1
+                sum += 1
+            }
+
+        }
+       // fmt.Println(v, sum, X)
+        if(v == X && sum == X) {
+            return i
+        }
+    }
+
+    return -1
+}
diff --git a/codility_miss_element b/codility_miss_element
@@ -0,0 +1,19 @@
+func Solution(A []int) int {
+    // write your code in Go 1.4
+
+    var B []int = make([]int, len(A)+1)
+
+    for _, v := range A {
+        B[v-1] = 1
+    }
+
+   // fmt.Println(B)
+
+    for i, v := range B {
+        if(v == 0) {
+            return i + 1
+        }
+    }
+
+    return 0
+}
diff --git a/codility_arr_diff b/codility_arr_diff
@@ -0,0 +1,31 @@
+func Solution(A []int) int {
+    // write your code in Go 1.4
+
+    var sum int = 0;
+
+    for _, v := range A {
+        sum += v
+    }
+
+   // fmt.Println(sum)
+
+    res := make([]int, len(A)-1)
+    var prevSum int = 0
+    var diff float64 = 0
+    for i, v := range A {
+        if(i < len(A)-1) {
+            prevSum = v + prevSum
+            diff = math.Abs(float64(prevSum - (sum - prevSum)))
+            res[i] = int(diff)
+        }
+    }
+
+    var min float64 = math.Inf(1);
+    for _, v := range res {
+        if float64(v) < min {
+            min = float64(v)
+        }
+    }
+
+    return int(min)
+}
diff --git a/codility_frog b/codility_frog
@@ -0,0 +1,7 @@
+func Solution(X int, Y int, D int) int {
+    // write your code in Go 1.4
+    var j float64 = float64(Y - X) / float64(D)
+    var r float64 = math.Ceil(j)
+   // fmt.Println(r)
+    return int(r)
+}
diff --git a/codility_arr_even b/codility_arr_even
@@ -0,0 +1,31 @@
+package solution
+
+// you can also use imports, for example:
+ //import "fmt"
+ import "sort"
+
+// you can write to stdout for debugging purposes, e.g.
+// fmt.Println("this is a debug message")
+
+
+func Solution(A []int) int {
+    // write your code in Go 1.4
+    //var B []int = make([]int, 100)
+
+    sort.Ints(A)
+    //fmt.Println(A)
+    lth := len(A)
+    i := 0
+    for i < lth {
+        if i >= lth-1 {
+            return A[lth-1]
+        }
+        if A[i] != A[i+1] {
+            //fmt.Println(A[i])
+            return A[i]
+        }
+        i += 2
+    }
+
+    return 0
+}
diff --git a/codility_arr_rotation b/codility_arr_rotation
@@ -0,0 +1,29 @@
+package solution
+
+// you can also use imports, for example:
+ //import "fmt"
+// import "os"
+
+// you can write to stdout for debugging purposes, e.g.
+// fmt.Println("this is a debug message")
+
+func Solution(A []int, K int) []int {
+    // write your code in Go 1.4
+    lth := len(A)
+  //  idx := lth + K
+    var B []int = make([]int, lth)
+
+    for i, v := range A {
+        B[i] = v
+    }
+
+    for i, v := range B {
+
+            x := (i + K) % lth
+            //fmt.Println(x, v)
+            A[x] = v
+
+    }
+   // fmt.Println(A)
+    return A
+}
diff --git a/codility_binary_gap b/codility_binary_gap
@@ -0,0 +1,31 @@
+func Solution(N int) int {
+    // write your code in Go 1.4
+    gap := 0
+    max_gap := 0
+    //start_gap := false
+
+    for ;N > 0 && N % 2 == 0; {
+        N = N /  2
+    }
+
+
+    for N > 0 {
+        rest := N % 2
+
+        if rest == 0 {
+            gap += 1
+        } else {
+            if gap != 0 {
+                if gap > max_gap {
+                    max_gap = gap
+                }
+                gap = 0
+            }
+        }
+
+
+        N = N / 2
+    }
+
+    return max_gap
+}
diff --git a/taks2 b/taks2
@@ -0,0 +1,22 @@
+package main
+
+import (
+	"golang.org/x/tour/wc"
+	"strings"
+	//"fmt"
+)
+
+func WordCount(s string) map[string]int {
+	res := make(map[string]int)
+
+	for _, v := range strings.Fields(s) {
+		_, ok := res[v];
+		if ok == true {res[v] = res[v] + 1
+			} else {res[v] = 1}
+	}
+	return res
+}
+
+func main() {
+	wc.Test(WordCount)
+}
diff --git a/task3 b/task3
@@ -0,0 +1,21 @@
+package main
+
+import "fmt"
+
+// fibonacci is a function that returns
+// a function that returns an int.
+func fibonacci() func() int {
+	a, b := 1, 0 
+	return func() int {
+		a, b = b, a + b
+        return a
+	}
+}
+
+func main() {
+	f := fibonacci()
+	for i := 0; i < 10; i++ {
+		fmt.Println(f())
+	}
+}
+
diff --git a/task4 b/task4
@@ -0,0 +1,20 @@
+package main
+
+import "fmt"
+
+type IPAddr [4]byte
+
+// TODO: Add a "String() string" method to IPAddr.
+func (ip IPAddr) String() string {
+	return fmt.Sprintf("%v.%v.%v.%v", ip[0], ip[1], ip[2], ip[3])
+}
+
+func main() {
+	hosts := map[string]IPAddr{
+		"loopback":  {127, 0, 0, 1},
+		"googleDNS": {8, 8, 8, 8},
+	}
+	for name, ip := range hosts {
+		fmt.Printf("%v: %v\n", name, ip)
+	}
+}
diff --git a/task5 b/task5
@@ -0,0 +1,35 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+
+var p = 0.0
+
+type ErrNegativeSqrt float64
+
+func Sqrt(x float64) (float64, error) {
+	if x < 0 { return x, ErrNegativeSqrt(x) }
+	z := 1.0
+	for math.Abs(p - z) > 0.001 { 
+		z = newton(z, x)
+		p = newton(z, x)
+	}
+	return z, nil
+}
+
+func (e ErrNegativeSqrt) Error() string {
+	return fmt.Sprintf("cannot Sqrt negative number: %v",
+		float64(e))
+}
+
+func newton(z, x float64) float64 {
+	return z - ( ((z*z) - x) / (2*z) )
+}
+
+func main() {
+	fmt.Println(Sqrt(2))
+	fmt.Println(Sqrt(-2))
+}
diff --git a/task6 b/task6
@@ -0,0 +1,20 @@
+package main
+
+import ("golang.org/x/tour/reader"
+
+		)
+
+type MyReader struct{}
+
+// TODO: Add a Read([]byte) (int, error) method to MyReader.
+
+func (m MyReader) Read(b []byte) (i int, e error) {
+    for x := range b {
+        b[x] = 'A'
+    }
+    return len(b), nil
+}
+
+func main() {
+	reader.Validate(MyReader{})
+}
diff --git a/task7 b/task7
@@ -0,0 +1,31 @@
+package main
+
+import (
+	"io"
+	"os"
+	"strings"
+)
+
+type rot13Reader struct {
+	r io.Reader
+}
+
+func (r *rot13Reader) Read(p []byte) (n int, err error) {
+    n, err = r.r.Read(p)
+    for i, b := range p {
+        switch {
+        case 'A' <= b && b <= 'M', 'a' <= b && b <= 'm':
+            p[i] += 13
+        case 'N' <= b && b <= 'Z', 'n' <= b && b <= 'z':
+            p[i] -= 13
+        }
+    }
+    return
+}
+
+func main() {
+	s := strings.NewReader("Lbh penpxrq gur pbqr!")
+	r := rot13Reader{s}
+	io.Copy(os.Stdout, &r)
+}
+
diff --git a/task8 b/task8
@@ -0,0 +1,28 @@
+package main
+
+import ("golang.org/x/tour/pic"
+		"image"
+
+	"image/color"
+	   )
+
+type Image struct{
+Width, Height int
+	color uint8	
+}
+
+func (img Image) Bounds() image.Rectangle {
+    return image.Rect(0, 0, img.Height, img.Width)
+}
+func (img Image) ColorModel() color.Model {
+    return color.RGBAModel
+}
+
+func (img Image) At(x, y int) color.Color {
+    return color.RGBA{img.color+uint8(x), img.color+uint8(y), 255, 255}
+}
+
+func main() {
+	m := Image{100, 100, 148}
+	pic.ShowImage(m)
+}
diff --git a/task9 b/task9
@@ -0,0 +1,46 @@
+package main
+
+import ("golang.org/x/tour/tree"
+		"fmt"
+		)
+
+// Walk walks the tree t sending all values
+// from the tree to the channel ch.
+func Walk(t *tree.Tree, ch chan int) {
+	_walk(t, ch)
+	close(ch)
+}
+
+func _walk(t *tree.Tree, ch chan int) {
+	if t != nil {
+		_walk(t.Left, ch)
+		ch <- t.Value
+		_walk(t.Right, ch)
+	}
+}
+
+// Same determines whether the trees
+// t1 and t2 contain the same values.
+func Same(t1, t2 *tree.Tree) bool {
+	ch1 := make(chan int)
+	ch2 := make(chan int)
+	go Walk(t1, ch1)
+	go Walk(t2, ch2)
+	for i := range ch1 {
+		if i != <- ch2 {
+			return false
+		}
+	}
+	return true
+}
+
+func main() {
+	ch := make(chan int)
+	go Walk(tree.New(1), ch)
+	for v := range ch {
+		fmt.Print(v)
+	}
+	fmt.Println()
+	fmt.Println(Same(tree.New(1), tree.New(1)))
+	fmt.Println(Same(tree.New(1), tree.New(2)))
+}
diff --git a/task1 b/task1
@@ -0,0 +1,25 @@
+package main
+
+import (
+	"fmt"
+	"math"
+)
+
+var p = 0.0
+
+func Sqrt(x float64) float64 {
+	z := 1.0
+	for math.Abs(p - z) > 0.000000001 { 
+		z = newton(z, x)
+		p = newton(z, x)
+	}
+	return z
+}
+
+func newton(z, x float64) float64 {
+	return z - ( ((z*z) - x) / (2*z) )
+}
+
+func main() {
+	fmt.Println(Sqrt(2))
+}