package main
import "fmt"
func Stmt() {
fmt.Printf("%d",2)
switch lookahead {
case "expr":
match("expr")
match(";")
case "if":
match("if")
match("(")
match("expr")
match(")")
Stmt()
case "for":
match("for")
match("(")
optexpr()
match(";")
optexpr()
match(";")
optexpr()
match(")")
expr()
case "other":
match("other")
default:
report("syntax error")
}
}
func optexpr(){
if lookahead == expr{
match(expr)
}
func (t terminal)match(){
if lookahead == t {
lookahead=nextTerminal
}else{
report("syntax error")
}
}
func main() {
}
package main
import (
"sync"
"time"
"math/rand"
"fmt"
)
var wait sync.WaitGroup
var count int
//var mutex sync.Mutex
func increment(s string) {
start := time.Now()
// mutex.Lock()
for i :=0;i<10;i++ {
x := count
x++;
//rand.Seed(time.Now().UnixNano())
time.Sleep(time.Duration(rand.Intn(10))*time.Millisecond)
count = x;
fmt.Println(s, i,"Count: ",count,"time taken: ",time.Since(start))
}
// mutex.Unlock()
wait.Done()
}
func main(){
wait.Add(2)
go increment("foo: ")
go increment("bar: ")
wait.Wait()
fmt.Println("last count value " ,count)
}
/*import (
"crypto/rand"
"fmt"
)
func main() {
key := [256]byte{}
_, err := rand.Read(key[:])
if err != nil {
panic(err)
}
fmt.Println(key)
}*/
/*...........................................................
generating a random number and sequencse
https://flaviocopes.com/go-random/
.......................................................
.......................................................
.....................................................
.....................................................*/
// for concurrency waitgroup is to hold the
/* import (
"fmt"
"time"
"sync"
)
var wg = sync.WaitGroup{}
func main() {
wg.Add(2)
go fun1()
go fun2()
wg.Wait()
}
func fun1(){
for i:=0;i<10;i++{
fmt.Println("fun1, ->",i)
time.Sleep(time.Duration(5*time.Millisecond))
}
wg.Done()
}
func fun2(){
for i:=0;i<10;i++{
fmt.Println("fun2, ->",i)
time.Sleep(time.Duration(10*time.Millisecond))
}
wg.Done()
} */
/*error handling
......................................................................
import (
"fmt"
"errors"
//"math"
)
func sqr(value int) (int, error){
i:=10
if(value<=0){
return 0, errors.New("Math: negative number passed to Sqrt")
}
//else{
i=i/value
return i,nil
// }
}
func main(){
// i:=10
result,err:=sqr(3)
if err !=nil{
fmt.Println(err)
}else{
fmt.Println(result)
}
}*/
package main
import "fmt"
func main() {
c := make(chan int) // Allocate a channel.
// Start the sort in a goroutine; when it completes, signal on the channel.
go func() {
for x:=0 ; x<20 ;x++{
fmt.Println("x=",x)
}
c <- 1 // Send a signal; value does not matter.
}()
//<-c // Wait for sort to finish; discard sent value.
for y:=0 ; y<40 ; y++{
fmt.Println("y=",y)
}
}
package main
import "fmt"
func main() {
// a first program in go
fmt.Println("Hello, World")
}
/*package main
import "fmt"
func main() {
fmt.Printf("hello, world\n")
} */
/*package main
import "fmt"
func main() {
var i int
var f float64
var b bool
var s string
fmt.Printf("%T %T %T %T\n",i,f,b,s)
fmt.Printf("%v %v %v %q",i,f,b,s)
} */
/*package main
import "fmt"
func main() {
var i=10
if(i>9) {
fmt.Print("condition is true")
}
} */
/*package main
import "fmt"
func main() {
var i=5
if(i%2==0) {
fmt.Printf("%d is even",i)
} else {
fmt.Printf("%d is odd",i)
}
} */
/*package main
import "fmt"
func main() {
fmt.Print("Enter Number: ")
var i int
fmt.Scanln(&i)
fmt.Println(i)
if(i%2==0) {
fmt.Printf("%d is even",i)
} else {
fmt.Printf("%d is odd",i)
}
} */
/*package main
import "fmt"
func main() {
var i int
fmt.Print("Enter a number : ")
fmt.Scanln(&i)
fmt.Println(i)
if(i<0||i>100) {
fmt.Println("Enter number b/w 0 and 100")
} else if(i>=0&&i<50) {
fmt.Println("Fail")
} else if(i>=50&&i<60) {
fmt.Println("Grade D")
} else if(i>=60&&i<70) {
fmt.Println("Grade C")
} else if(i>=70&&i<80) {
fmt.Println("Grade B")
} else if(i>=80&&i<90) {
fmt.Println("Grade A")
} else if(i>=90&&i<=100) {
fmt.Println("Grade A+")
}
} */
/*package main
import "fmt"
func main() {
var i int
fmt.Print("enter number : ")
fmt.Scanln(&i)
fmt.Println(i)
switch(i) {
case 10:
fmt.Printf("%d is entered value",i)
case 20:
fmt.Printf("%d is entered value",i)
default:
fmt.Print("Input is not 10 or 20")
}
} */
/*package main
import "fmt"
func main() {
var i int
fmt.Print("enter number : ")
fmt.Scanln(&i)
fmt.Println(i)
switch(i) {
case 10:
fmt.Printf("%d is entered value\n",i)
fallthrough
case 20:
fmt.Printf("%d is entered value\n",i)
fallthrough
default:
fmt.Print("Input is not 10 or 20")
}
}*/
/*package main
import "fmt"
func main() {
var i=0
for i=0;i<=10;i++ {
fmt.Println(i)
}
} */
/*package main
import "fmt"
func main() {
for i:=0;i<=10;i++ {
fmt.Println(i)
}
} */
/*package main
import "fmt"
func main() {
for i:=1;i<=5;i++ {
for j:=1;j<=i;j++ {
fmt.Print("*")
}
fmt.Println()
}
} */
/*package main
import "fmt"
func main() {
var n int
fmt.Print("enter number : ")
fmt.Scanln(&n)
fmt.Println(n)
for i:=1;i<=n;i++ {
for j:=1;j<=i;j++ {
fmt.Print("*")
}
fmt.Println()
}
}*/
/*package main
import "fmt"
func main() {
for true {
fmt.Printf("This loop will run forever.\n");
}
} */
/*package main
import "fmt"
func main() {
var limit int
var i=1
var sum=0
fmt.Print("Enter Limit : ")
fmt.Scanln(&limit)
fmt.Print(limit)
for i<=limit {
sum+=i
i++
}
fmt.Printf("\nsum from 1 to %d is %d",limit,sum)
} */
/*package main
import "fmt"
func main() {
nums := []int{2, 3, 4}
sum := 0
for _, value := range nums {// "_ " is to ignore the index
sum += value
}
fmt.Println("sum:", sum)
for i, num := range nums {
if num == 3 {
fmt.Println("index:", i)
}
}
kvs := map[string]string{"1":"mango","2":"apple","3":"banana"}
for k, v := range kvs {
fmt.Printf("%s -> %s\n", k, v)
}
for k := range kvs {
fmt.Println("key:", k)
}
for i, c := range "Hi" {
fmt.Println(i, c)
}
} */
/*package main
import "fmt"
func main() {
var age int
loop:
fmt.Println("Not eligible for voting")
fmt.Print("Enter your age : ")
fmt.Scanln(&age)
if(age<18) {
goto loop
} else {
fmt.Println("Elgibile for voting")
}
}*/
/*package main
import "fmt"
func main() {
var i=1
for i<10 {
if(i==7) {
break
}
fmt.Println(i)
i++
}
}*/
/*package main
import "fmt"
func main() {
var a int = 1
for a < 10 {
if a == 5 {
a = a + 1;
continue;
}
fmt.Printf("value of a: %d\n", a);
a++;
}
} */
/*package main
import "fmt"
func main() {
const PI=3.14
var area=0.0
var rad float64=2.5
area=PI*rad*rad
fmt.Print("Area = ",area)
} */
/*package main
import ("fmt";"strconv")
func main() {
var i int=10
var f float64=3.14
var s1 string="101"
var s2 string="102.25"
fmt.Println(float64(i))
fmt.Println(int(f))
newInt, _ := strconv.ParseInt(s1, 0, 64)
fmt.Println(newInt)
newfloat, _ := strconv.ParseFloat(s2, 64)
fmt.Println(newfloat)
} */
/*package main
import "fmt"
func main() {
for i:=1;i<=10;i++ {
fmt.Println("2*",i,"=",2*i)
//fmt.Print("=")
//fmt.Print(2*i)
//fmt.Println()
}
} */
/* package main
import "fmt"
func fun() int {
return 123456789
}
func main() {
x:=fun()
fmt.Print(x)
} */
/* package main
import "fmt"
func main() {
fmt.Println(addAll(10,20,30,40,50))
}
func addAll(args...int)(int,int) {
addvalue:=0
subvalue:=0
for _,value:=range args {
addvalue+=value
subvalue-=value
}
return addvalue,subvalue
} */
/*package main
import "fmt"
func main() {
var num int
fmt.Print("enter a number : ")
fmt.Scanln(&num)
fmt.Printf("factorial=%d",fact(num))
}
func fact(num int)int {
if (num==0) {
return 1
}
return num*fact(num-1)
} */
/* package main
import "fmt"
func main() {
number:=10
sqnum:=func()(int) {
number*=number
return number
}
fmt.Println(sqnum())
fmt.Println(sqnum())
fmt.Println(sqnum())
fmt.Println(sqnum())
} */
/*package main
import "fmt"
func main() {
var a [10]int
var i int
for i=0;i<5;i++ {
a[i]=i*5
}
for i=0;i<;i++ {
fmt.Printf("Element[%d]=%d\n",i,a[i])
}
} */
/*package main
import "fmt"
func fact(n int)int {
fact:=1
if(n==0) {
return 1
} else {
for i:=1;i<=n;i++ {
fact=fact*i
}
return fact
}
}
func main() {
var res int
var n int
fmt.Print("Enter a number : ")
fmt.Scanln(&n)
fmt.Println(n)
res=fact(n)
fmt.Printf("Factorial of %d is %d",n,res)
} */
/* package main
import "fmt"
func fact(n int) {
fact:=1
if(n==0) {
fmt.Printf("Factorial of %d is %d",n,fact)
} else {
for i:=1;i<=n;i++ {
fact=fact*i
}
fmt.Printf("Factorial of %d is %d",n,fact)
}
}
func main() {
var n int
fmt.Print("Enter a number : ")
fmt.Scanln(&n)
fmt.Println(n)
fact(n)
} */
/*package main
import "fmt"
func muldiv(n1,n2 int)(int,int,int,int) {
return n1*n2,n2/n1,n1+n2,n1-n2
}
func main() {
var n1,n2,mul,div,add,sub int
fmt.Print("Enter two numbers : ")
fmt.Scanln(&n1,&n2)
mul,div,add,sub=muldiv(n1,n2)
fmt.Printf("%d*%d=%d\n",n1,n2,mul)
fmt.Printf("%d/%d=%d\n",n2,n1,div)
fmt.Printf("%d+%d=%d\n",n1,n2,add)
fmt.Printf("%d-%d=%d\n",n1,n2,sub)
} */
/*package main
import "fmt"
func main() {
num:=1
oneplus:=func() int {
num+=1
return num
}
fmt.Println(oneplus())
fmt.Println(oneplus())
fmt.Println(oneplus())
fmt.Println(oneplus())
} */
/* package main
import "fmt"
func main() {
num:=0
var n int
fmt.Scanln(&n)
oneplus:=func() int {
num+=1
return num
}
for i:=1;i<=n;i++ {
fmt.Println(oneplus())
}
} */
/*package main
import "fmt"
func main() {
var a[10]int
sum:=0
for i:=0;i<=9;i++ {
a[i]=i
sum+=a[i]
fmt.Println(sum)
}
fmt.Println()
for i:=0;i<=9;i++ {
fmt.Println(a[i])
}
fmt.Println(a)
fmt.Println(sum)
} */
/* package main
import "fmt"
func main() {
var a[3][3] int
for i:=0;i<3;i++ {
for j:=0;j<3;j++ {
a[i][j]=i+j
}
}
for i:=0;i<3;i++ {
for j:=0;j<3;j++ {
fmt.Printf("a[%d][%d]=%d\n",i,j,a[i][j])
}
fmt.Println()
}
fmt.Print(a)
} */
/*package main
import "fmt"
func main() {
var a = [3][3]int{ {1,2,3}, {4,5,6}, {7,8,9}}
var i, j int
for i = 0; i < 3; i++ {
for j = 0; j < 3; j++ {
fmt.Print(a[i][j] )
}
fmt.Println()
}
} */
/*package main
import "fmt"
func main() {
a:=[]string{"Blockchain","Solidity","Android","Python"}
fmt.Println(a)
var b=[4]string{"Blockchain","Solidity","Android","Python"}
fmt.Println(b)
var c[4]string
c[0]="Blockchain"
c[1]="Solidity"
c[2]="Android"
c[3]="Python"
fmt.Println(c)
fmt.Println(a,b,c)
} */
/* package main
import "fmt"
func main() {
a:=[]string{"Blockchain","Solidity","Android","Python"}
fmt.Print("a=",a,"\n")
fmt.Println("a[0:2]=",a[0:2])
b:=a[0:2]
fmt.Println("a[0:2]=b[0:2]=",b)
fmt.Println("b[0]=",b[0])
fmt.Println("b[1]=",b[1])
b[0]="Java"
b[1]=".Net"
fmt.Println("b=",b)
fmt.Print("a=",a)
} */
/* package main
import "fmt"
func main() {
a:=[]int{2,4,6,8,10,12}
fmt.Println(len(a))
fmt.Println(cap(a))
fmt.Println(a)
fmt.Println(a[:3])
fmt.Println(a[3:])
} */
/*package main
import "fmt"
func main() {
slice := make([]int, 10)
printSlice("slice", slice)
slice1 := make([]int, 2, 10)
printSlice("slice1", slice1)
slice2 := slice1[:5]
printSlice("slice2", slice2)
slice3 := slice2[2:5]
printSlice("slice3", slice3)
}
func printSlice(s string, x []int) {
fmt.Printf("%s length=%d capacity=%d %v\n",
s, len(x), cap(x), x)
} */
/*package main
import "fmt"
import "os"
func main() {
var s,arg string
for i:=1;i<len(os.Args);i++ {
s+=arg+os.Args[i]+""
}
fmt.Println(s)
} */
/* package main
import "fmt"
import "os"
func main() {
fmt.Println(os.Args)
var s string
for i:=0;i<len(os.Args);i++ {
s+=os.Args[i]+" "
}
fmt.Println(s)
} */
/*package main //not working
import "fmt"
func main() {
a:=[]int{1,2,3,4,5,6}
e:=[]int{}
o:=[]int{}
j:=0
k:=0
for i:=0;i<len(a);i++ {
if(a[i]%2==0) {
e[j]=a[i]
j++
} else {
o[k]=a[i]
k++
}
}
fmt.Print(o,e)
}*/
/*package main
import ("fmt"
"reflect"
)
func main() {
var s string="Hello Go"
fmt.Println(s)
fmt.Printf("%T\n",s)
fmt.Print(reflect.TypeOf(s))
} */
/*package main
import "fmt"
func main() {
s:="Hello Go Programming"
fmt.Print(len(s))
} */
/*package main
import "fmt"
func main() {
ch:="A"
fmt.Printf("ASCII value of A is %d\n",'A')
fmt.Println("Ascii value of A is ",ch[0])
} */
/* package main
import "fmt"
func main() {
var c string
fmt.Scanln(&c)
fmt.Printf("ASCII value of %s is %d",c,c[0])
} */
/* package main
import "fmt"
import "strings"
func main() {
s := "INDIA"
fmt.Println(strings.HasPrefix(s,"IN"))
} */
/*package main
import "fmt"
import "strings"
func main() {
s := "INDIA"
fmt.Println(strings.HasSuffix(s,"IA"))
} */
/*package main
import ("fmt"
"strings"
)
func main() {
var a=[]string{"1","2","3","4","5"}
fmt.Println(strings.Join(a,"*"))
}*/
/*package main
import ("fmt"
"strings"
)
func main() {
s:="GO "
fmt.Println(strings.Repeat(s,20))
} */
/*package main
import ( "fmt"
"strings"
)
func main() {
s:="Hello I am go program"
fmt.Println(strings.Contains(s,"go p"))
}*/
/*package main
import ("fmt"
"strings"
)
func main() {
var s string
fmt.Scanln(&s)
fmt.Println(strings.Split(s,""))
}*/
/*package main
import (
"fmt"
"strings"
)
func main() {
s:="Hello World"
fmt.Println(strings.Index(s,"rld"))
}*/
/*package main
import (
"fmt"
"strings"
)
func main() {
s:="Hello World"
fmt.Println(strings.Index(s,"rld"))
}*/
/*package main
import (
"fmt"
"strings"
)
func main() {
s:="Hello World"
fmt.Println(strings.Count(s,"l"))
} */
/* package main
import (
"fmt"
"strings"
)
func main() {
s:="Hello Java Programming"
fmt.Println(strings.Replace(s,"Java","GO",6))
}*/
/* package main
import ("fmt"
"strings"
)
func main() {
s:="Good,Evening,Everyone"
var a[] string=strings.Split(s,",")
for k,v:=range a {
fmt.Println(k,v)
}
}*/
/* package main
import "fmt"
func main() {
var size int
//var arr[] int
fmt.Print("Enter size of array : ")
fmt.Scanln(&size)
//var arr[size] int
a:=make([]int,size)
fmt.Println(len(a))
for i:=0;i<len(a);i++ {
fmt.Print("Enter values : ")
fmt.Scanln(&a[i])
}
for i:=0;i<len(a);i++ {
fmt.Println(a[i])
}
} */
/*package main
import (
"fmt"
"strings"
)
func main() {
fmt.Println(strings.Compare("a", "b"))
fmt.Println(strings.Compare("a", "a"))
fmt.Println(strings.Compare("b", "a"))
} */
/*package main
import "fmt"
type trainee struct {
firstName string
lastName string
age int
}
func main() {
a:=trainee{"Rob","Pike",48}
fmt.Println(a.firstName)
fmt.Println(a.lastName)
fmt.Println(a.age)
fmt.Println(a)
}*/
/*package main
import ( "fmt"
"regexp"
)
func main() {
re:=regexp.MustCompile(".com")
fmt.Println(re.FindString("google.com"))
fmt.Println(re.FindString("wikipedia.org"))
fmt.Println(re.FindString("tutorialspoint.com"))
} */
/*package main
import ("fmt"
"regexp"
)
func main() {
re:=regexp.MustCompile(".com")
fmt.Println(re.FindStringIndex("mobiloitte.com"))
fmt.Println(re.FindStringIndex(".in.com.org"))
} */
/* package main
import (
"fmt"
"regexp"
)
func main() {
re := regexp.MustCompile("f([a-z]+)ing")
fmt.Println(re.FindStringSubmatch("flying"))
fmt.Println(re.FindStringSubmatch("abcfloatingxyz"))
} */
/*package main
import "fmt"
type Emp struct {
fName string
lName string
empid int
}
func main() {
e1:=Emp{empid:402,fName:"Arjun",lName:"Singh"}
fmt.Println(e1)
fmt.Println(e1.empid)
} */
/* main
import (
"fmt"
)
type person struct {
fname string
lname string}
type employee struct {
person
empId int
}
func (p person) details() {
fmt.Println(p, " "+" I am a person")
}
func (e employee) details() {
fmt.Println(e, " "+"I am a employee")
}
func main() {
p1 := person{"Raj", "Kumar"}
p1.details()
e1 := employee{person:person{"John", "Ponting"}, empId: 11}
e1.details()
} */
/*package main
import ("fmt";"math");
type Shape interface {
area() float64
}
type Circle struct {
rad float64
}
type Square struct {
side float64
}
func(circle Circle) area() float64 {
return math.Pi*circle.rad*circle.rad
}
func(square Square) area() float64 {
return square.side*square.side
}
func getArea(shape Shape) float64 {
return shape.area()
}
func main() {
c1:=Circle{rad:5.0}
sq:=Square{side:6.0}
fmt.Println(getArea(c1))
fmt.Println(getArea(sq))
fmt.Println(math.Pi)
fmt.Println(math.Sqrt(4 ))
} */
/*package main
import "fmt"
func main() {
first:="Golang"
last:="Programming"
name:=first+last
fmt.Println(name)
fmt.Println(first+" "+last)
} */
/*package main
import (
"fmt"
)
func main() {
i := 55
j := 67.8
sum := i + j
dif:=i-j
mul:=i*j
div:=i/j
fmt.Println(sum)
} */
/*package main
func main() {
var defaultName = "Sam" //allowed
type myString string
var customName myString = "Sam" //allowed
customName = defaultName //not allowed
} */
/*package main
import (
"fmt"
)
func main() {
const a = 5
var intVar int = a
var int32Var int32 = a
var float64Var float64 = a
var complex64Var complex64 = a
fmt.Println("intVar",intVar, "\nint32Var", int32Var, "\nfloat64Var", float64Var, "\ncomplex64Var",complex64Var)
} */
/*package main
import "fmt"
func rect(len,wid float64)(float64,float64) {
return len*wid,2*(len+wid)
}
func main() {
var len,wid float64
fmt.Print("Enter length and width : ")
fmt.Scanln(&len,&wid)
area,peri:=rect(len,wid)
fmt.Printf("area=%f\nperi=%f",area,peri)
} */
/*package main
import (
"fmt"
)
func main() {
if num := 10; num % 2 == 0 { //checks if number is even
fmt.Println(num,"is even")
} else {
fmt.Println(num,"is odd")
}
} */
/*package main
import "fmt"
func main() {
for i:=1;i<=10;i++ {
fmt.Printf("i=%d\n",i)
}
} */
/*package main
import "fmt"
func main() {
var i int
for ;i<=10;i++ {
fmt.Println(i)
}
} */
/*package main
import "fmt"
func main() {
var i int
for i<=10 {
fmt.Println(i)
i++
}
} */
/*package main
import "fmt"
func main() {
for i,j:=10,1;i<=19 && j<=10;i,j=i+1,j+1 {
fmt.Println(i,"*",j,"=",i*j)
}
} */
/*package main
import "fmt"
func main() {
var option int
fmt.Scanln(&option)
switch option {
case 1:
fmt.Println("C")
case 2:
fmt.Println("C++")
case 3:
fmt.Println("C#")
case 4:
fmt.Println("Java")
case 5:
fmt.Println("Go")
default :
fmt.Println("invalid")
}
} */
/*package main
import (
"fmt"
)
func main() {
letter := "i"
switch letter {
case "a", "e", "i", "o", "u": //multiple expressions
fmt.Println("vowel")
default:
fmt.Println("not a vowel")
}
} */
/*package main
import "fmt"
func main() {
var a[3]int
fmt.Println(a)
a[0]=0
a[1]=1
a[2]=2
fmt.Println(a)
b:=[3]int{10,20,30}
fmt.Println(b)
c:=[]int{11,22,33}
fmt.Println(c)
} */
/*package main
func main() {
a := [3]int{5, 78, 8}
var b [5]int
b = a //not possible since [3]int and [5]int are distinct types
} */
/*package main
import "fmt"
func main() {
a := [3]int{5, 78, 8}
var b [5]int
b = a //not possible since [3]int and [5]int are distinct types
fmt.Println(b)
} */
/*package main
import "fmt"
func changeLocal(num [5]int) {
num[0] = 5
fmt.Println("inside function ", num)
}
func main() {
num := [...]int{4, 6, 7, 8, 8}
fmt.Println("before passing to function ", num)
changeLocal(num)
fmt.Println("after passing to function ", num)
} */
/*package main
import "fmt"
// without passing array size is like slice
func change(num []int) {
fmt.Println(&num)
num[0]=5
fmt.Println("Inside change function",num)
}
func main() {
num:=[]int{4,6,7,8,9}
fmt.Println(&num)
fmt.Println("num before function call",num)
change(num)
fmt.Println("num after function call",num)
} */
/*package main
import "fmt"
func main() {
a:=[...]float64{3.14,7.22,22.00,21}
for i:=0;i<len(a);i++ {
fmt.Printf("Element at %d index is %.2f\n",i,a[i])
}
} */
/*package main
import "fmt"
func main() {
a:=[...]float64{3.14,7.22,22.00,21}
sum:=float64(0)
fmt.Printf("%T\n",sum)
for i,v:=range a {
fmt.Printf("Element at %d index is %.2f\n",i,v)
sum+=v
}
fmt.Print("sum=",sum)
} */
/*package main
import (
"fmt"
)
func main() {
a := [5]int{76, 77, 78, 79, 80}
var b []int = a[1:4] //creates a slice from a[1] to a[3]
fmt.Println(b)
} */
/*package main
import (
"fmt"
)
func main() {
c := []int{6, 7, 8} //creates and array and returns a slice reference
fmt.Println(c)
} */
/*package main
import (
"fmt"
)
func main() {
darr := [...]int{57, 89, 90, 82, 100, 78, 67, 69, 59}
dslice := darr[2:5]
fmt.Println("array before",darr)
for i := range dslice {
dslice[i]++
}
fmt.Println("array after",darr)
} */
/*package main
import (
"fmt"
)
func main() {
fruitarray := [...]string{"apple", "orange", "grape", "mango", "water melon", "pine apple", "chikoo"}
fruitslice := fruitarray[1:3]
fmt.Printf("length of slice %d capacity %d", len(fruitslice), cap(fruitslice)) //length of is 2 and capacity is 6
} */
/*package main
import (
"fmt"
)
func main() {
i := make([]int, 5, 5)
fmt.Println(i)
} */
/*package main
import (
"fmt"
)
func main() {
cars := []string{"Ferrari", "Honda", "Ford"}
fmt.Println("cars:", cars, "has old length", len(cars), "and capacity", cap(cars)) //capacity of cars is 3
cars = append(cars, "Toyota")
fmt.Println("cars:", cars, "has new length", len(cars), "and capacity", cap(cars)) //capacity of cars is doubled to 6
} */
/*package main
import (
"fmt"
)
func main() {
var names []string //zero value of a slice is nil
if names == nil {
fmt.Println("slice is nil going to append")
names = append(names, "John", "Sebastian", "Vinay")
fmt.Println("names contents:",names)
}
} */
/*package main
import (
"fmt"
)
func main() {
veggies := []string{"potatoes","tomatoes","brinjal"}
fruits := []string{"oranges","apples"}
food := append(veggies, fruits...)
fmt.Println("food:",food)
} */
/*package main
import (
"fmt"
)
func subtactOne(numbers []int) {
for i := range numbers {
numbers[i] -= 2
}
}
func main() {
nos := []int{8, 7, 6}
fmt.Println("slice before function call", nos)
subtactOne(nos) //function modifies the slice
fmt.Println("slice after function call", nos) //modifications are visible outside
} */
/*package main
import (
"fmt"
)
func countries() []string {
countries := []string{"USA", "Singapore", "Germany", "India", "Australia"}
neededCountries := countries[:len(countries)-2]
countriesCpy := make([]string, len(neededCountries))
copy(countriesCpy, neededCountries) //copies neededCountries to countriesCpy
return countriesCpy
}
func main() {
countriesNeeded := countries()
fmt.Println(countriesNeeded)
} */
/*package main
import "fmt"
func find(num int,nums...int) {
fmt.Printf("Type of nums is %T\n",nums)
found:=false
for i,v:=range nums {
if v==num {
fmt.Printf("%d found at index %d in %d\n",num,i,nums)
found=true
}
}
if !found {
fmt.Println(num, "not found in ", nums)
}
fmt.Println()
}
func main() {
find(89, 89, 90, 95)
find(45, 56, 67, 45, 90, 109)
find(78, 38, 56, 98)
find(87)
} */
/*package main //will not work and give error
import (
"fmt"
)
func find(num int, nums ...int) {
fmt.Printf("type of nums is %T\n", nums)
found := false
for i, v := range nums {
if v == num {
fmt.Println(num, "found at index", i, "in", nums)
found = true
}
}
if !found {
fmt.Println(num, "not found in ", nums)
}
fmt.Printf("\n")
}
func main() {
nums := []int{89, 90, 95}
find(89, nums)
} */
/*package main
import (
"fmt"
)
func find(num int, nums ...int) {
fmt.Printf("type of nums is %T\n", nums)
found := false
for i, v := range nums {
if v == num {
fmt.Println(num, "found at index", i, "in", nums)
found = true
}
}
if !found {
fmt.Println(num, "not found in ", nums)
}
fmt.Printf("\n")
}
func main() {
nums := []int{89, 90, 95}
find(89, nums...)
} */
/*package main
import (
"fmt"
)
func change(s ...string) {
s[0] = "Go"
}
func main() {
welcome := []string{"hello", "world"}
change(welcome...)
fmt.Println(welcome)
} */
/*package main
import "fmt"
func main() {
welcome:=[]string{"Hello","World"}
for i:=0;i<len(welcome);i++ {
fmt.Println(welcome[i])
}
} */
/*package main
import (
"fmt"
)
func change(s ...string) {
s[0] = "Go"
s = append(s, "playground")
fmt.Println(s)
}
func main() {
welcome := []string{"hello", "world"}
change(welcome...)
fmt.Println(welcome)
} */
/*package main
import (
"fmt"
)
func main() {
var personSalary map[string]int
if personSalary == nil {
fmt.Println("map is nil. Going to make one.")
personSalary = make(map[string]int)
}
} */
/*package main
import "fmt"
func main() {
persal:=make(map[string]int)
persal["A"]=100
persal["B"]=200
persal["C"]=150
persal["D"]=300
fmt.Println(persal)
} */
/*package main
import "fmt"
func main() {
persal:=map[string]int {
"A":1,
"B":2,
}
fmt.Println(persal)
persal["C"]=3
fmt.Println(persal)
fmt.Println(persal["B"])
fmt.Println(persal["A"])
fmt.Println(persal["C"])
} */
/*package main
import "fmt"
func main() {
persal:=map[string]int {
"A":10,
"B":20,
"C":30,
}
persal["D"]=40
fmt.Println(persal)
check:="B"
value,flag:=persal[check]
if flag==true {
fmt.Println("Value of",check,"is",value)
} else {
fmt.Println(check,"is not found")
}
} */
/*package main
import "fmt"
func main() {
persal:=map[string]int {
"A":10,
"B":20,
"C":30,
}
persal["D"]=40
fmt.Println(persal)
for i,v:=range persal {
fmt.Println(i,v)
}
} */
/*package main
import "fmt"
func main() {
persal:=map[string]int {
"A":10,
"B":20,
"C":30,
}
persal["D"]=40
fmt.Println(persal)
for i,v:=range persal {
fmt.Println(i,v)
}
delete(persal,"B")
fmt.Println(persal)
for i,v:=range persal {
fmt.Println(i,v)
}
} */
/*package main
import "fmt"
func main() {
persal:=map[string]int {
"A":10,
"B":20,
"C":30,
}
persal["D"]=40
fmt.Println(persal)
fmt.Println(len(persal))
} */
/*package main
import "fmt"
func main() {
langseq:=map[int]string {
1:"C",
2:"C++",
3:"JAVA",
4:"Python",
5:"Solidity",
}
fmt.Println(langseq,"\n")
langseq1:=langseq
langseq1[3]="GO"
fmt.Println(langseq1,"\n")
fmt.Println(langseq)
} */
/*package main
import "fmt"
func main() {
str:="Hello GO"
for i:=0;i<len(str);i++ {
fmt.Printf("%c\n",str[i])
}
} */
/*package main
import (
"fmt"
)
func printBytes(s string) {
for i:= 0; i < len(s); i++ {
fmt.Printf("%x ", s[i])
}
}
func printChars(s string) {
for i:= 0; i < len(s); i++ {
fmt.Printf("%c ",s[i])
}
}
func main() {
name := "Hello World"
printBytes(name)
fmt.Printf("\n")
printChars(name)
fmt.Printf("\n")
name = "Señor"
printBytes(name)
fmt.Printf("\n")
printChars(name)
} */
/*package main
import "fmt"
func main() {
s:="Hello World"
printb(s)
printc(s)
printb1(s)
s="Señor"
printb(s)
printc(s)
printb1(s)
}
func printb(s string) {
for i:=0;i<len(s);i++ {
fmt.Printf("%x",s[i])
}
fmt.Println()
}
func printb1(s string) {
for i:=0;i<len(s);i++ {
fmt.Printf("%c",s[i])
}
fmt.Println()
}
func printc(s string) {
r:=[]rune(s)
for i:=0;i<len(r);i++ {
fmt.Printf("%c",r[i])
}
fmt.Println()
} */
/*package main
import "fmt"
func main() {
name:="Señor"
print(name)
}
func print(s string) {
for i,rune:= range s {
fmt.Printf("%d %c\n",i,rune)
}
} */
/*package main
import "fmt"
func main() {
name:=[]byte{0x52,0x61,0x6A,0x61,0x74}
s:=string(name)
fmt.Print(s)
} */
/*package main
import "fmt"
func main() {
name:=[]byte{82,97,106,97,116}
s:=string(name)
fmt.Print(s)
} */
/*package main
import (
"fmt"
)
func main() {
runeSlice := []rune{0x0053, 0x0065, 0x00f1, 0x006f, 0x0072}
str := string(runeSlice)
fmt.Println(str)
} */
/*package main
import (
"fmt"
)
func main() {
runeSlice := []rune{82,97,106,97,116}
str := string(runeSlice)
fmt.Println(str)
} */
/*package main
import (
"fmt"
"unicode/utf8"
)
func main() {
name:="Señor"
fmt.Printf("length of %s through len function is %d\n",name,len(name))
fmt.Printf("length of %s through rune function is %d\n",name,utf8.RuneCountInString(name))
} */
/*package main
import "fmt"
func main() {
s:="lava"
fmt.Println(change(s))
}
func change(s string)string {
r:=[]rune(s)
r[0]='j'
return string(r)
} */
/*package main
import "fmt"
func main() {
s:="lava"
r:=[]rune(s)
fmt.Print(change(r))
}
func change(r []rune) string {
r[0]='j'
return string(r)
} */
/*package main
import "fmt"
func main() {
var c *int
fmt.Println(c)
var a=100
fmt.Printf("%T\n",a)
fmt.Println(&a)
var b=&a
fmt.Printf("%T\n",b)
fmt.Println(b)
} */
/*package main
import (
"fmt"
)
func main() {
b := 255
a := &b
fmt.Println("address of b is", a)
fmt.Println("value of b is", *a)
} */
/*package main
import (
"fmt"
)
func main() {
b := 255
a := &b
fmt.Println("address of b is", a)
fmt.Println("value of b is", *a)
*a=256
fmt.Println("value of b is", b)
} */
/*package main
import "fmt"
func main() {
a:="Java"
b:=&a
fmt.Println("value of a before func call is",a)
change(b)
fmt.Println("value of a after func call is",a)
}
func change(b *string) {
*b="GO"
} */
/*package main
import "fmt"
func main() {
a:=[3]int{1,3,5}
fmt.Println("a=",a)
p:=&a
fmt.Printf("%T\n",p)
change(p)
fmt.Println("a=",a)
}
func change(p *[3]int) {
(*p)[0]=2 //p[0]=2
(*p)[1]=4 //p[1]=4
(*p)[2]=6 //p[2]=6
} */
/*package main
import "fmt"
func main() {
a:=[3]int{1,2,3}
fmt.Println("a=",a)
change(a[:])
fmt.Println("a=",a)
}
func change(s []int) {
s[0]=2
s[1]=4
s[2]=6
} */
/*package main
import "fmt"
type Emp struct { //named structure
first,last string
age,salary int
}
func main() {
e1:=Emp{"A","Z",50,2500}
e2:=Emp{
first:"B",
last:"Y",
age:51,
salary:2000,
}
fmt.Println(e1)
fmt.Println(e2)
} */
/*package main
import "fmt"
func main() {
e1:= struct {
first ,last string
age,salary int
} {
first:"A",
last:"B",
age:20,
salary:0,
}
fmt.Println(e1)
} */
/* package main
import "fmt"
func main() {
e1:= struct {
first ,last string
age,salary int
}{
"A",
"B",
20,
0,
}
fmt.Println(e1)
} */
/*package main
import (
"fmt"
)
type Employee struct {
firstName, lastName string
age, salary int
}
func main() {
emp6 := Employee{"Sam", "Anderson", 55, 6000}
fmt.Println("First Name:", emp6.firstName)
fmt.Println("Last Name:", emp6.lastName)
fmt.Println("Age:", emp6.age)
fmt.Printf("Salary: $%d", emp6.salary)
} */
/*package main
import "fmt"
type student struct {
first,last string
age,salary int
}
func main() {
var s1 student
s1.first="A"
s1.last="B"
s1.age=10
s1.salary=200
fmt.Println(s1)
} */
/*package main
import (
"fmt"
)
type Employee struct {
firstName, lastName string
age, salary int
}
func main() {
emp8 := &Employee{"Sam", "Anderson", 55, 6000}
fmt.Println("First Name:", (*emp8).firstName)
fmt.Println("Age:", (*emp8).age)
(*emp8).firstName="Ram" // or emp8.firstName="Ram"
fmt.Println(emp8)
} */
/*package main
import (
"fmt"
)
type name struct {
firstName string
lastName string
}
func main() {
name1 := name{"Steve", "Jobs"}
name2 := name{"Steve", "Jobs"}
if name1 == name2 {
fmt.Println("name1 and name2 are equal")
} else {
fmt.Println("name1 and name2 are not equal")
}
name3 := name{firstName:"Steve", lastName:"Jobs"}
name4 := name{}
name4.firstName = "Steve"
if name3 == name4 {
fmt.Println("name3 and name4 are equal")
} else {
fmt.Println("name3 and name4 are not equal")
}
} */
/*package main
import (
"fmt"
)
type image struct {
data map[int]int
}
func main() {
image1 := image{data: map[int]int{
0: 155,
}}
image2 := image{data: map[int]int{
0: 155,
}}
if image1 == image2 {
fmt.Println("image1 and image2 are equal")
}
} */
/*package main
import (
"fmt"
"math"
)
type Square struct {
side float64
}
type Circle struct {
radius float64
}
func (s Square) Area() float64{
return s.side*s.side
}
func (c Circle) Area() float64 {
return math.Pi*c.radius*c.radius
}
func main() {
s1:=Square{4}
fmt.Printf("Area of Square=%.2f\n",s1.Area())
c1:=Circle{2}
fmt.Printf("Area of circle=%.2f",c1.Area())
} */
/*package main
import "fmt"
type Person struct {
name string
age int
}
func(p Person) displayname(new string) {
p.name=new
}
func(p *Person) displayage(new int) {
p.age=new
}
func main() {
p1:=Person{
name:"Python",
age:27,
}
fmt.Printf("Name before change is %s\n",p1.name)
p1.displayname("Java")
fmt.Printf("Name after change is %s\n\n",p1.name)
fmt.Printf("Age before change is %d\n",p1.age)
(&p1).displayage(23)
fmt.Printf("Age after change is %d",p1.age)
} */
/*package main
import (
"fmt"
)
type address struct {
city string
state string
}
func (a address) fullAddress() {
fmt.Printf("Full address: %s, %s", a.city, a.state)
}
type person struct {
firstName string
lastName string
address
}
func main() {
p := person{
firstName: "Elon",
lastName: "Musk",
address: address {
city: "Los Angeles",
state: "California",
},
}
p.fullAddress() //accessing fullAddress method of address struct
} */
/*package main
import (
"fmt"
)
type rectangle struct {
length int
width int
}
func area(r rectangle) {
fmt.Printf("Area Function result: %d\n", (r.length * r.width))
}
func (r rectangle) area() {
fmt.Printf("Area Method result: %d\n", (r.length * r.width))
}
func main() {
r := rectangle{
length: 10,
width: 5,
}
area(r)
r.area()
p := &r
// compilation error, cannot use p (type *rectangle) as //type rectangle
//in argument to area
//area(p)
p.area()//calling value receiver with a pointer
} */
/*package main
import (
"fmt"
)
type rectangle struct {
length int
width int
}
func perimeter(r *rectangle) {
fmt.Println("perimeter function output:", 2*(r.length+r.width))
}
func (r *rectangle) perimeter() {
fmt.Println("perimeter method output:", 2*(r.length+r.width))
}
func main() {
r := rectangle{
length: 10,
width: 5,
}
p := &r //pointer to r
perimeter(p)
p.perimeter()
// cannot use r (type rectangle) as type *rectangle in //argument to perimeter
//perimeter(r)
r.perimeter()//calling pointer receiver with a value
} */
/*package main
import "fmt"
type myint int
func(a myint) mul(b myint) myint {
return a*b
}
func main() {
num1:=myint(2)
num2:=myint(5)
fmt.Println(num1.mul(num2))
} */
/*package main
import "fmt"
type VowelFinder interface {
FindVowel() []rune
}
type mystring string
func(s mystring) FindVowel() []rune {
var vowels []rune
for _,val:=range s {
if val=='a'||val=='e'||val=='i'||val=='o'||val=='u' {
vowels=append(vowels,val)
}
}
return vowels
}
func main() {
str:=mystring("Go Programming")
var face VowelFinder
face=str
fmt.Println(string(face.FindVowel()))
} */
/*package main
import "fmt"
type SalaryCalculator interface {
CalSal() int
}
type Permanent struct {
empid int
basic int
pf int
}
type Contract struct {
empid int
basic int
}
func(p Permanent) CalSal() int {
return p.basic+p.pf
}
func(c Contract) CalSal() int {
return c.basic
}
func total(s []SalaryCalculator) {
total:=0
for _,v:=range s {
total=total+v.CalSal()
}
fmt.Printf("Total Expense=₹%d",total)
}
func main() {
p1:=Permanent{101,10000,700}
p2:=Permanent{101,20000,1400}
c1:=Contract{103,15000}
employees:=[]SalaryCalculator{p1,p2,c1}
total(employees)
} */
/*package main
import "fmt"
type Tester interface {
Test()
}
type MyFloat float64
func(m MyFloat) Test() {
fmt.Println(m)
}
func describe(t Tester) {
fmt.Printf("%T, %v\n",t,t)
}
func main() {
m1:=MyFloat(3.14)
var t1 Tester
t1=m1
describe(t1)
t1.Test()
} */
/*package main
import (
"fmt"
)
func describe(i interface{}) {
fmt.Printf("Type = %T, value = %v\n", i, i)
}
func main() {
s := "Hello World"
describe(s)
i := 55
describe(i)
strt := struct {
name string
}{
name: "Naveen R",
}
describe(strt)
} */
/*package main
import "fmt"
func assert(i interface{}) {
s:=i.(float64)
fmt.Println(s)
}
func main() {
var s interface{}=50.05
assert(s)
} */
/*package main
import "fmt"
func assert(i interface{}) {
v,ok:=i.(float64)
fmt.Println(v,ok)
}
func main() {
var s interface{}="Hello Go"
assert(s)
} */
/*package main
import (
"fmt"
)
func findType(i interface{}) {
switch i.(type) {
case string:
fmt.Printf("I am a string and my value is %s\n", i.(string))
case int:
fmt.Printf("I am an int and my value is %d\n", i.(int))
default:
fmt.Printf("Unknown type\n")
}
}
func main() {
findType("Naveen")
findType(77)
findType(89.98)
} */
///GO Routines
/*package main
import "fmt"
func hello() {
fmt.Println("Hello")
}
func main() {
go hello()
fmt.Println("Main")
} */
/*package main
import (
"fmt"
"time"
)
func hello() {
fmt.Println("Hello Go Routine")
}
func main() {
go hello()
time.Sleep(5*time.Second)
fmt.Println("Main Go Routine")
} */
/*package main
import (
"fmt"
"time"
)
func nums() {
for i:=1;i<=5;i++ {
time.Sleep(250*time.Millisecond)
fmt.Printf("%d",i)
}
}
func alpha() {
for i:='a';i<='e';i++ {
time.Sleep(400*time.Millisecond)
fmt.Printf("%c",i)
}
}
func main() {
go nums()
go alpha()
time.Sleep(3000*time.Millisecond)
fmt.Println("\nMain End")
} */
/*package main
import "fmt"
func main() {
var c chan int
fmt.Println(c)
if c==nil {
fmt.Println("channel x is nil")
c=make(chan int)
fmt.Printf("%T\n",c)
fmt.Println(c)
}
} */
/*package main
import "fmt"
func hello(channel chan bool) {
fmt.Println("HELLO GO ROUTINE")
channel<-true
}
func main() {
channel:=make(chan bool)
go hello(channel)
<-channel
fmt.Println("MAIN GO ROUTINE")
} */
/*package main
import (
"fmt"
"time"
)
func hello(channel chan bool) {
fmt.Println("HELLO GO ROUTINE BEFORE SLEEP")
time.Sleep(4*time.Second)
fmt.Println("HELLO GO ROUTINE AFTER SLEEP")
channel<-true
}
func main() {
channel:=make(chan bool)
fmt.Println("MAIN BEFORE HELLO")
go hello(channel)
<-channel
fmt.Println("MAIN")
} */
/*package main
import "fmt"
func square(num int,chan1 chan int) {
sum:=0
for num!=0 {
digit:=num%10
sum+=digit*digit
num=num/10
}
chan1<-sum
}
func cube(num int,chan2 chan int) {
sum:=0
for num!=0 {
digit:=num%10
sum+=digit*digit*digit
num/=10
}
chan2<-sum
}
func main() {
num:=123
chan1:=make(chan int)
chan2:=make(chan int)
go square(num,chan1)
go cube(num,chan2)
sq,cu:=<-chan1,<-chan2
fmt.Printf("Output=%d",sq+cu)
} */
/*package main
func main() {
ch := make(chan int)
ch <- 5
} */
//if a Goroutine is waiting to receive data from a channel, then some other Goroutine is expected to write data on that channel
//If a Goroutine is sending data on a channel, then it is expected that some other Goroutine should be receiving the data.
//will give error as channel is send only not receive
/*package main
import "fmt"
func send(sendch chan<- int) {
sendch<-10
}
func main() {
sendch:=make(chan<- int)
go send(sendch)
fmt.Println(<-sendch)
} */
/*package main
import "fmt"
func send(sendch chan<- int) {
sendch<-10
}
func main() {
sendch:=make(chan int)
go send(sendch)
fmt.Println(<-sendch)
} */
/*package main
import "fmt"
func pro(channel chan int) {
for i:=1;i<=10;i++ {
channel<-i
}
close(channel)
}
func main() {
channel:=make(chan int)
go pro(channel)
for {
v,ok:= <-channel
if ok==false {
break
}
fmt.Println(v,ok)
}
} */
/*package main
import "fmt"
func pro(channel chan int) {
for i:=1;i<=10;i++ {
channel<-i
}
close(channel)
}
func main() {
channel:=make(chan int)
go pro(channel)
for v:=range channel {
fmt.Println(v)
}
} */
/*package main
import (
"fmt"
)
func digits(number int, dchnl chan int) {
for number != 0 {
digit := number % 10
dchnl <- digit
number /= 10
}
close(dchnl)
}
func calcSquares(number int, squareop chan int) {
sum := 0
dch := make(chan int)
go digits(number, dch)
for digit := range dch {
sum += digit * digit
}
squareop <- sum
}
func calcCubes(number int, cubeop chan int) {
sum := 0
dch := make(chan int)
go digits(number, dch)
for digit := range dch {
sum += digit * digit * digit
}
cubeop <- sum
}
func main() {
number := 589
sqrch := make(chan int)
cubech := make(chan int)
go calcSquares(number, sqrch)
go calcCubes(number, cubech)
squares, cubes := <-sqrch, <-cubech
fmt.Println("Final output", squares+cubes)
} */
/*package main
import "fmt"
func main() {
channel:=make(chan string,2)
channel<-"GO"
channel<-"JAVA"
fmt.Println(<-channel)
fmt.Println(<-channel)
} */
/*package main
import (
"fmt"
"time"
)
func write(ch chan int) {
for i:=1;i<=5;i++ {
ch<-i
fmt.Println("Wrote",i)
}
close(ch)
}
func main() {
ch:=make(chan int,2)
go write(ch)
time.Sleep(2*time.Second)
for v:=range ch {
fmt.Println("read value",v)
time.Sleep(2*time.Second)
}
} */
/*package main
import "fmt"
func main() {
ch:=make(chan string,3)
ch<-"ALGOL"
ch<-"BCPL"
fmt.Printf("length of channel=%d",len(ch))
fmt.Printf("\ncapacity of channel=%d\n",cap(ch))
fmt.Println(<-ch)
fmt.Printf("\nlength of channel=%d",len(ch))
fmt.Printf("\ncapacity of channel=%d",cap(ch))
} */
/*package main
import (
"fmt"
"sync"
"time"
)
func process(i int,wg *sync.WaitGroup) {
fmt.Println("Goroutine",i)
time.Sleep(2*time.Second)
fmt.Printf("\nGoroutine %d ended",i)
wg.Done()
}
func main() {
num:=3
var wg sync.WaitGroup
for i:=0;i<num;i++ {
wg.Add(1)
go process(i,&wg)
}
wg.Wait()
fmt.Println("\nAll go routine finished")
} */
/*package main
import (
"fmt"
"math/rand"
"sync"
"time"
)
type Job struct {
id int
randomno int
}
type Result struct {
job Job
sumofdigits int
}
var jobs = make(chan Job, 10)
var results = make(chan Result, 10)
func digits(number int) int {
sum := 0
no := number
for no != 0 {
digit := no % 10
sum += digit
no /= 10
}
time.Sleep(2 * time.Second)
return sum
}
func worker(wg *sync.WaitGroup) {
for job := range jobs {
output := Result{job, digits(job.randomno)}
results <- output
}
wg.Done()
}
func createWorkerPool(noOfWorkers int) {
var wg sync.WaitGroup
for i := 0; i < noOfWorkers; i++ {
wg.Add(1)
go worker(&wg)
}
wg.Wait()
close(results)
}
func allocate(noOfJobs int) {
for i := 0; i < noOfJobs; i++ {
randomno := rand.Intn(999)
job := Job{i, randomno}
jobs <- job
}
close(jobs)
}
func result(done chan bool) {
for result := range results {
fmt.Printf("Job id %d, input random no %d , sum of digits %d\n", result.job.id, result.job.randomno, result.sumofdigits)
}
done <- true
}
func main() {
startTime := time.Now()
noOfJobs := 100
go allocate(noOfJobs)
done := make(chan bool)
go result(done)
noOfWorkers := 10
createWorkerPool(noOfWorkers)
<-done
endTime := time.Now()
diff := endTime.Sub(startTime)
fmt.Println("total time taken ", diff.Seconds(), "seconds")
} */
/*package main
import (
"fmt"
"time"
)
func serv1(ch chan string) {
time.Sleep(6*time.Second)
ch<-"from serv1"
}
func serv2(ch chan string) {
time.Sleep(3*time.Second)
ch<-"from serv2"
}
func main() {
ch1:=make(chan string)
ch2:=make(chan string)
go serv1(ch1)
go serv2(ch2)
select {
case c1:=<-ch1:
fmt.Println(c1)
case c2:=<-ch2:
fmt.Println(c2)
}
} */
/*package main
import (
"fmt"
"time"
)
func process(ch chan string) {
time.Sleep(10500 * time.Millisecond)
ch <- "process successful"
}
func main() {
ch := make(chan string)
go process(ch)
for {
time.Sleep(1000 * time.Millisecond)
select {
case v := <-ch:
fmt.Println("received value: ", v)
return
default:
fmt.Println("no value received")
}
}
}*/
/*package main //Error
func main() {
ch := make(chan string)
select {
case <-ch:
}
} */
/*package main
import "fmt"
func main() {
channel:=make(chan string)
select {
case<-channel:
default:
fmt.Println("default case execution")
}
} */
/*package main
import "fmt"
func main() {
var channel chan string
select {
case<-channel:
default:
fmt.Println("default case execution")
}
} */
/*package main
import (
"fmt"
"time"
)
func serv1(ch chan string) {
ch<-"from serv1"
}
func serv2(ch chan string) {
ch<-"from serv2"
}
func main() {
ch1:=make(chan string)
ch2:=make(chan string)
go serv1(ch1)
go serv2(ch2)
time.Sleep(1*time.Second)
select {
case s1:=<-ch1:
fmt.Println(s1)
case s2:=<-ch2:
fmt.Println(s2)
default:
fmt.Println("Default case")
}
} */
/*package main
func main() {
select {}
} */
/*package main
import (
"fmt"
"sync"
)
var x = 0
func increment(wg *sync.WaitGroup) {
x = x + 1
wg.Done()
}
func main() {
var w sync.WaitGroup
for i := 0; i < 1000; i++ {
w.Add(1)
go increment(&w)
}
w.Wait()
fmt.Println("final value of x", x)
} */
/*package main
import (
"fmt"
"sync"
)
var x = 0
func increment(wg *sync.WaitGroup,m *sync.Mutex) {
m.Lock()
x = x + 1
m.Unlock()
wg.Done()
}
func main() {
var w sync.WaitGroup
var m sync.Mutex
for i := 0; i < 1000; i++ {
w.Add(1)
go increment(&w,&m)
}
w.Wait()
fmt.Println("final value of x", x)
} */
/*package main
import (
"fmt"
"sync"
)
var x=0
func increment(wg *sync.WaitGroup,ch chan bool) {
ch<-true
x=x+1
<-ch
wg.Done()
}
func main() {
var w sync.WaitGroup
ch:=make(chan bool,1)
for i:=0;i<1000;i++ {
w.Add(1)
go increment(&w,ch)
}
w.Wait()
fmt.Println("final value of x",x)
} */
/*package main
import "oop/employee"
func main() {
e1:=employee.Employee{
FirstName:"Ram",
LastName:"Singh",
TotalLeaves:10,
LeavesTaken:3,
}
e1.LeavesRemaining()
}
package employee
import "fmt"
type Employee struct {
FirstName string
LastName string
TotalLeaves int
LeavesTaken int
}
func(e Employee) LeavesRemaining() {
fmt.Printf("%s %s has %d leaves remaining\n",e.FirstName,e.LastName,(e.TotalLeaves-e.LeavesTaken))
} */
/*package emplyoee
import "fmt"
type emplyoee struct {
firstname string
lastname string
totalleaves int
leavestaken int
}
func New(firstname string,lastname string,totalleaves int,leavestaken int) emplyoee {
e:=emplyoee{firstname,lastname,totalleaves,leavestaken}
return e
}
func(e emplyoee) LeavesRemaining() {
fmt.Printf("%s %s has %d leaves remaining\n",e.firstname,e.lastname,e.totalleaves-e.leavestaken)
}
package main
import "oop/employee"
func main() {
e1:=emplyoee.New("Ram","Singh",10,3)
e1.LeavesRemaining()
} */
/*package main
import "fmt"
type author struct {
firstname string
lastname string
bio string
}
type post struct {
title string
content string
author
}
func(a author) fullname() string {
return fmt.Sprintf("%s %s",a.firstname,a.lastname)
}
func(p post) details() {
fmt.Printf("Title is %s\n",p.title)
fmt.Printf("content is %s\n",p.content)
fmt.Printf("author is %s\n",p.author.fullname()) // fmt.Printf("Author: %s\n", p.fullname())
fmt.Printf("Bio is %s",p.author.bio)
}
func main() {
a1:=author{"Arjun","Singh","Solidity Trainer"}
p1:=post{"Solidity","First line of solidity program",a1}
p1.details()
} */
/*package main
import "fmt"
type author struct {
firstname string
lastname string
bio string
}
type post struct {
title string
content string
author
}
func(a author) fullname() string {
return fmt.Sprintf("%s %s",a.firstname,a.lastname)
}
func(p post) details() {
fmt.Printf("Title is %s\n",p.title)
fmt.Printf("content is %s\n",p.content)
fmt.Printf("author is %s\n",p.author.fullname()) // fmt.Printf("Author: %s\n", p.fullname())
fmt.Printf("Bio is %s",p.author.bio)
}
type website struct {
posts []post
}
func (w website) contents() {
fmt.Println("Contents of Website\n")
for _, v := range w.posts {
v.details()
fmt.Println()
}
}
func main() {
a1:=author{"Arjun","Singh","Solidity Trainer"}
p1:=post{"Solidity","First line of solidity program",a1}
p1.details()
} */
/*package main
import (
"fmt"
)
type author struct {
firstName string
lastName string
bio string
}
func (a author) fullName() string {
return fmt.Sprintf("%s %s", a.firstName, a.lastName)
}
type post struct {
title string
content string
author
}
func (p post) details() {
fmt.Println("Title: ", p.title)
fmt.Println("Content: ", p.content)
fmt.Println("Author: ", p.fullName())
fmt.Println("Bio: ", p.bio)
}
type website struct {
posts []post
}
func (w website) contents() {
fmt.Println("Contents of Website\n")
for _, v := range w.posts {
v.details()
fmt.Println()
}
}
func main() {
author1 := author{
"Rajat",
"Mishra",
"Golang Enthusiast",
}
post1 := post{
"Inheritance in Go",
"Go supports composition instead of inheritance",
author1,
}
post2 := post{
"Struct instead of Classes in Go",
"Go does not support classes but methods can be added to structs",
author1,
}
post3 := post{
"Concurrency",
"Go is a concurrent language and not a parallel one",
author1,
}
w := website{
posts: []post{post1, post2, post3},
}
w.contents()
} */
/*package main
import "fmt"
type Income interface {
calculate() int
source() string
}
type FixedBilling struct {
projectName string
biddedAmount int
}
type TimeAndMaterial struct {
projectName string
hourlyRate int
noOfHours int
}
func(fb FixedBilling)calculate() int {
return fb.biddedAmount
}
func(fb FixedBilling) source() string {
return fb.projectName
}
func(tm TimeAndMaterial) calculate() int {
return tm.hourlyRate*tm.noOfHours
}
func(tm TimeAndMaterial) source() string {
return tm.projectName
}
func TotalIncome(in []Income) {
income:=0
for _,inc:=range in {
fmt.Printf("Income from %s=%d\n",inc.source(),inc.calculate())
income+=inc.calculate()
}
fmt.Printf("NetIncome=%d",income)
}
func main() {
fb1:=FixedBilling{projectName: "Project 1", biddedAmount: 5000}
fb2:=FixedBilling{projectName: "Project 2", biddedAmount: 15000}
tm1:=TimeAndMaterial{projectName: "Project 3", noOfHours: 160, hourlyRate: 25}
in:=[]Income{fb1,fb2,tm1}
TotalIncome(in)
} */
/*package main
import (
"fmt"
"runtime"
"time"
)
func main() {
os:=runtime.GOOS
fmt.Println(os)
fmt.Println(time.Now())
switch os{
case "windows":
fmt.Printf("OS=%s",os)
}
} */
/*package main
import "fmt"
func main() {
m := make(map[string]int)
m["Answer"] = 42
fmt.Println(m)
fmt.Println("The value:", m["Answer"])
m["Answer"] = 48
fmt.Println(m)
fmt.Println("The value:", m["Answer"])
delete(m, "Answer")
fmt.Println(m)
fmt.Println("The value:", m["Answer"])
v, ok := m["Answer"]
fmt.Println(m)
fmt.Println("The value:", v, "Present?", ok)
} */
/*package main
import (
"fmt"
"strings"
)
func main() {
str:="Hello I am Arjun. I am solidity trainer"
fmt.Println(str)
fmt.Println(strings.Fields(str))
fmt.Printf("%T\n",strings.Fields(str))
for i,v:=range strings.Fields(str) {
fmt.Println(i,v)
}
} */
/*package main
import (
"fmt"
"math"
)
func compute(fn func(float64, float64) float64) float64 {
return fn(3, 4)
}
func main() {
hypot := func(x, y float64) float64 {
return math.Sqrt(x*x + y*y)
}
fmt.Println(hypot(5, 12))
fmt.Println(compute(hypot))
fmt.Println(compute(math.Pow))
} */
/*package main
import "fmt"
func adder() func(int) int {
sum := 0
return func(x int) int {
sum += x
return sum
}
}
func main() {
pos, neg := adder(), adder()
for i := 0; i < 10; i++ {
fmt.Println(
pos(i),
neg(-2*i),
)
}
} */
/*package main
import(
"fmt"
)
func main() {
a:=func() {
fmt.Println("First Class Function")
}
a()
fmt.Printf("%T",a)
} */
/*package main
import (
"fmt"
)
func main() {
func() {
fmt.Println("hello world first class function")
} ()
} */
/*package main
import(
"fmt"
)
func main() {
func(str string) {
fmt.Println("Hello",str)
} ("GO")
} */
/*package main
import (
"fmt"
)
type add func(a,b int) int
func main() {
var a add=func(a,b int) int {
return a+b
}
s:=a(5,10)
fmt.Print("sum=",s)
} */
/*package main
import "fmt"
func Simple(a func(a,b int) int) {
fmt.Println(a(5,10))
}
func main() {
f:=func(a,b int) int {
return a+b
}
Simple(f)
} */
/*package main
import "fmt"
func Simple() func (a,b int) int {
f:=func (a,b int) int {
return a+b
}
return f
}
func main() {
s:=Simple()
fmt.Println(s(87,97))
} */
/*package main
import "fmt"
func main() {
a:=5
func() {
fmt.Print("a=",a)
} ()
} */
/*package main
import (
"fmt"
)
type student struct {
firstName string
lastName string
grade string
country string
}
func filter(s []student, f func(student) bool) []student {
var r []student
for _, v := range s {
if f(v) == true {
r = append(r, v)
}
}
return r
}
func main() {
s1 := student{
firstName: "Naveen",
lastName: "Ramanathan",
grade: "A",
country: "India",
}
s2 := student{
firstName: "Samuel",
lastName: "Johnson",
grade: "B",
country: "USA",
}
s := []student{s1, s2}
f := filter(s, func(s student) bool {
if s.grade == "B" {
return true
}
return false
})
fmt.Println(f)
} */
/*package main
import "fmt"
func iMap(s []int,f func(int)int) []int {
var r []int
for _,v:=range s {
r=append(r,f(v))
}
return r
}
func main() {
s:=[]int{1,3,5,7,9}
r:=iMap(s,func(n int) int {
return n*5
})
fmt.Println(r)
} */
/*package main
import "fmt"
type order struct {
ordId int
custId int
}
func createQuery(o order) string {
i:=fmt.Sprintf("insert into order values (%d,%d)",o.ordId,o.custId)
return i
}
func main() {
o:=order{
ordId:12,
custId:131,
}
fmt.Println(createQuery(o))
} */
package main
import (
"fmt"
"math"
)
func main() {
arr := []int{148, 651, 124, 638, 567, 435, 185, 413, 841, 35};
fmt.Println(quickSort(arr));
}
func quickSort(arr []int) []int {
var q func(int, int) []int;
q = func(head int, tail int) []int {
i := head;
j := tail;
pivot := arr[int(math.Floor(float64(head + tail) / 2))];
tmp := 0;
for{
for arr[i] < pivot {
i++;
}
for pivot < arr[j] {
j--;
}
if i >= j {
break;
}
tmp = arr[i];
arr[i] = arr[j];
arr[j] = tmp;
i++
j--;
}
if head < i-1 {
q(head, i-1);
}
if j+1 < tail {
q(j+1, tail);
}
return arr;
}
return q(0, len(arr)-1);
}
package main
import "fmt"
func factorial(i int)int {
if(i <= 1) {
return 1
}
return i * factorial(i - 1)
}
func main() {
var i int = 15
fmt.Printf("Factorial of %d is %d", i, factorial(i))
}
//First Program
package main
import "fmt"
func main() {
var age int=25;
var friut int=5
var flower int=6
var total int=friut+flower
fmt.Println("Hello, World!")
fmt.Println("srikanth")
fmt.Println("age ", age)
fmt.Println("total ",total)
}
package main
import (
"fmt"
"math"
)
/* define an interface */
type Shape interface {
area() float64
}
/* define a circle */
type Circle struct {
x,y,radius float64
}
/* define a rectangle */
type Rectangle struct {
width, height float64
}
/* define a method for circle (implementation of Shape.area())*/
func(circle Circle) area() float64 {
return math.Pi * circle.radius * circle.radius
}
/* define a method for rectangle (implementation of Shape.area())*/
func(rect Rectangle) area() float64 {
return rect.width * rect.height
}
/* define a method for shape */
func getArea(shape Shape) float64 {
return shape.area()
}
func main() {
circle := Circle{x:0,y:0,radius:5}
rectangle := Rectangle {width:10, height:5}
fmt.Printf("Circle area: %f\n",getArea(circle))
fmt.Printf("Rectangle area: %f\n",getArea(rectangle))
}
package main
import "fmt"
func main() {
var a = []int{1,2,3};
b:=make([]int,11);
//c:=make([]int,0,5)
//fmt.Println(a,b,c)
//fmt.Println(len(a),len(b),len(c),cap(a),cap(b),cap(c))
a=append(a,0,1,1,1)
sum:=0;
for j:=range b{
b[j]=1 << uint(j);
}
for _,val:=range b{
fmt.Println(val)
}
for i:=range a{
sum+=i
fmt.Println(sum,i)
}
fmt.Println(a,sum)
}
We use cookies to provide and improve our services. By using our site, you consent to our Cookies Policy. Accept Learn more
