/* Scrivere un programma Go che legge un intero n e, a seconda del valore di n, stampa uno dei messaggi n è pari oppure n è dispari */ package main import "fmt" func main() { var numero int fmt.Print("Inserire un numero intero: ") fmt.Scan(&numero) if numero%2==0 { fmt.Println("Il numero inserito è pari.") } else if numero%2==1 { fmt.Println("Il numero inserito è dispari.") } }
/* Scrivere un programma Go che legga sei interi (coordinate dei punti A e B diagonali di un rettangolo e coordinate di un punto P) e che calcola se il punto P è fuori o dentro il rettangolo AB Esempio: A (1,1) B (2,2) P (5,5) è fuori etc. */ /* package main import "fmt" func main() { var ax, ay, bx, by, px, py int fmt.Println("inserisci prima i punti x e y del punto in basso a sinistra, i punti x e y del punto in alto a destra e i punti del punto scelto") fmt.Scan(&ax, &ay, &bx, &by, &px, &py) if ax < bx && ay < by { if (px <= bx && px >= ax) && (py <= by && py >= ay) { fmt.Println("il punto è contenuto") } else { fmt.Println("il punto non è contenuto") } } } */ package main import "fmt" func main() { var ascissaA, ordinataA, ascissaB, ordinataB, ascissaP, ordinataP int fmt.Print("Inserire le coordinate del punto A. ") fmt.Scan(&ascissaA, &ordinataA) fmt.Print("Inserire le coordinate del punto B. ") fmt.Scan(&ascissaB, &ordinataB) fmt.Print("Inserire le coordinate del punto P. ") fmt.Scan(&ascissaP, &ordinataP) if (ascissaP<ascissaA || ascissaP>ascissaB || ordinataP<ordinataA || ordinataP>ordinataB) { fmt.Println("Il punto non appartiene al rettangolo.") } else { fmt.Println("Il punto appartiene al rettangolo.") } } /* package main import "fmt" func main() { var xA, yA, xB, yB, xP, yP int fmt.Println("inserire coordinate (x,y) di A\n") fmt.Scan(&xA, &yA) fmt.Println("inserire coordinate (x,y) di B\n") fmt.Scan(&xB, &yB) fmt.Println("inserire coordinate (x,y) di P\n") fmt.Scan(&xP, &yP) if ((xP>=xA && xP<=xB)||(xP>=xB && xP<=xA)) && ((yP>=yA && yP<=yB)||(yP>=yB && yP<=yA)){ fmt.Printf("il punto di coordinate (%d,%d) e' all'interno del quadrato\n",xP,yP) }else{ fmt.Printf("il punto di coordinate (%d,%d) non e' all'interno del quadrato\n",xP,yP) } } */
/* Scrivere un programma Go che legga 5 interi (coordinate dei punti C del centro di un cerchio, raggio e coordinate di un punto P) e che calcola se il punto P è fuori o dentro il cerchio */ /* non corretto, considera quadrato che circoscrive package main import "fmt" func main() { var xc, yc, r, xp, yp float64 fmt.Print("inserisci le coordinate del cerchio ") fmt.Scan(&xc, &yc) fmt.Print("inserisci il raggio ") fmt.Scan(&r) fmt.Print("inserisci le coordinate del punto ") fmt.Scan(&xp, &yp) if (xc-r <= xp) && (yc-r <= yp) && (xc+r >= xp) && (yc+r >= yp) { fmt.Print("Il punto è contenuto") } else { fmt.Print("Il punto non è contenuto") } } */ package main import "fmt" import "math" func main() { var ascissaC, ordinataC, raggio, ascissaP, ordinataP, distanza float64 fmt.Println("Inserire le coordinate del centro del cerchio, il suo raggio, e le coordinate di P.") fmt.Scan(&ascissaC, &ordinataC, &raggio, &ascissaP, &ordinataP) distanza=math.Sqrt((ascissaC-ascissaP)*(ascissaC-ascissaP)+(ordinataC-ordinataP)*(ordinataC-ordinataP)) if distanza<=raggio { fmt.Println("Il punto appartiene al cerchio.") } else { fmt.Println("Il punto non appartiene al cerchio.") } } /* package main import "fmt" import "math" func main() { var cx, cy, r, px, py, dist float64 fmt.Print("inserisci le coorinate del centro ") / fmt.Scan(&cx, &cy) fmt.Print("Inserisci la lunghezza del raggio ") fmt.Scan(&r) fmt.Print("Inserisci le coordinate del punto da controllare ") fmt.Scan(&px, &py) dist = math.Sqrt(math.Pow(cx-px, 2) + math.Pow(cy-py, 2)) if dist < r { fmt.Print("Il punto è dentro il cerchio ") } else { fmt.Println("Il punto è fuori dal centro") } } */ /* package main import "fmt" func main () { var cx, cy, r, px, py int fmt. Print("Coordinate centro cerchio: ") fmt. Scan(& cx, & cy) fmt. Print("Lunghezza raggio: ") fmt. Scan(& r) fmt. Print("Coordinate P: ") fmt. Scan(& px, & py) if px>cx+r && py>cy+r || px<cx-r && px<cx-r{ fmt. Println("P è fuori") }else{ fmt. Println("P è dentro") } } */ /* package main import "fmt" func main(){ var cx,cy,r,px,py int fmt.Println("Inserire la lunghezza del raggio") fmt.Scan(&r) fmt.Println("Inserire le coordinate del centro") fmt.Scan(&cx,&cy) fmt.Println("Inserire le coordinate del punto") fmt.Scan(&px,&py) if (px-cx)*(px-cx)+(py-cy)*(py-cy)>r*r { fmt.Println("il punto non appartiene al cerchio") } else { fmt.Println("il punto appartiene al cerchio") } } */
/* Scrivere un programma Go che legga 6 float (coordinate dei punti A,B,E) e che calcola se il punto E è equidistante da A e B */ package main import ("fmt" "math") func main () { var ax,ay,bx,by,px,py,da,db float64 fmt.Println("Questo programma calcola se un punto P è equidistante da due punti A e B") fmt.Println("Fornisci le coordinate del punto A, separate da una virgola: ") fmt.Scanf("%f,%f\n", &ax, &ay) fmt.Println("Fornisci le coordinate del punto B, separate da una virgola: ") fmt.Scanf("%f,%f\n", &bx, &by) fmt.Println("Fornisci le coordinate del punto P, separate da una virgola: ") fmt.Scanf("%f,%f\n", &px, &py) da= math.Sqrt((ax-px)*(ax-px)+(ay-py)*(ay-py)) db= math.Sqrt((bx-px)*(bx-px)+(by-py)*(by-py)) diff=db-da // e vedere se è più piccolo di un epsilon preso a piacere if (da==db) { // funziona sempre??? fmt.Println("Il punto P è equidistante da A e B.") } else { fmt.Println("Il punto P non è equidistante da A e B.") } } /* package main import "fmt" import "math" func main() { var ascissaA, ordinataA, ascissaB, ordinataB, ascissaE, ordinataE, distanzaAE, distanzaBE float64 l fmt.Print("Inserire le coordinate dei punti A, B ed E. " fmt.Scan(&ascissaA, &ordinataA, &ascissaB, &ordinataB, &ascissaE, &ordinataE) distanzaAE=math.Sqrt((ascissaA-ascissaE)*(ascissaA-ascissaE)+(ordinataA-ordinataE)*(ordinataA-ordinataE)) distanzaBE=math.Sqrt((ascissaB-ascissaE)*(ascissaB-ascissaE)+(ordinataB-ordinataE)*(ordinataB-ordinataE)) if distanzaAE==distanzaBE { //math.Abs(distanzaAE-distanzaBE)<"epsilon" fmt.Println("E è equidistante da A e B.") } else { fmt.Println("E non è equidistante da A e B.") } } */ /* package main import "fmt" func main(){ var ax, bx, ay, by, cx, cy int fmt.Println("Digitare cordinate punto A") fmt.Scan(&ax,&ay) fmt.Println("Digitare cordinate punto B") fmt.Scan(&bx,&by) fmt.Println("Digitare cordinate punto C da verificare se è equidistante da A e B") fmt.Scan(&cx,&cy) if (cx-ax)*(cx-ax)+(cy-ay)*(cy-ay)==(cx-bx)*(cx-bx)+(cy-by)*(cy-by){ fmt.Println("C è equidistante da A e B") } else { fmt.Println("C non è equidistante da A e B") } } */ /* package main import "fmt" import "math" func main() { var ax, ay, bx, by, ex, ey, distA, distB float64 fmt.Print("inserisci le coorinate del primo punto ") fmt.Scan(&ax, &ay) fmt.Print("Inserisci la lunghezza del secondo punto ") fmt.Scan(&bx, &by) fmt.Print("Inserisci le coordinate del punto da controllare ") fmt.Scan(&ex, &ey) distA = math.Sqrt(math.Pow(ax-ex, 2) + math.Pow(ay-ey, 2)) distB = math.Sqrt(math.Pow(bx-ex, 2) + math.Pow(by-ey, 2)) if math.Abs(distA-distB) <= 0.001 { fmt.Println("Il punto è equidistante ") } else { fmt.Println("Il punto non è equidistante") } } */ func main() { var Ax, Ay, Ex, Ey, Bx, By float64 fmt.Print("Inserisci le coordinate di A: ") fmt.Scan(&Ax, &Ay) fmt.Print("Inserisci le coorsinate di B: ") fmt.Scan(&Bx, &By) fmt.Print("Inserisci le coordinate di E: ") fmt.Scan(&Ex, & Ey) if ((Ax-Ex)*(Ax-Ex)+(Ay-Ey)*(Ay-Ey))-((Bx-Ex)*(Bx-Ex)+(By-Ey)*(By-Ey)) < 0.0001 { fmt.Print("Equidistante\n") }else { fmt.Print("Non equidistante\n") } fmt.Scan(&Ax) //usato come pausa di sistema } /* package main import "fmt" import "math" func main () { var ax, ay, bx, by, ex, ey float64 fmt. Print("punto A: ") fmt. Scan(& ax, & ay) fmt. Print("punto B: ") fmt. Scan(& bx, & by) fmt. Print("punto E: ") fmt. Scan(& ex, & ey) if math. Abs(ex-ax)==math. Abs(ex-bx) && math. Abs(ey-ay)==math. Abs(ey-by){ // mi convince poco, provare con alcuni casi con i punti in diagonale fmt. Println("E è equidistante") }else{ fmt. Println("E non è equidistante") } } */
/* Scrivere un programma Go che legga 4 float (parametri della retta m e q, coordinate di un punto P) e che calcola se il punto P appartiene alla retta */ package main import "fmt" func main () { var m,q,px,py float64 fmt.Println("Questo programma calcola se un punto P appartiene a una retta nella forma y=mx+q") fmt.Println("Fornisci le coordinate del punto P, separate da una virgola: ") fmt.Scanf("%f,%f\n", &px, &py) fmt.Println("Fornisci la pendenza m della retta: ") fmt.Scan(&m) fmt.Println("Fornisci il parametro q: ") fmt.Scan(&q) if py==m*px+q { // qui problema? fmt.Println("Il punto P appartiene alla retta.") } else { fmt.Println("Il punto P non appartiene alla retta.") } } /* package main import "fmt" func main() { var m, q, ascissaP, ordinataP float64 fmt.Println("Inserire i parametri m e q della retta e le coordinate del punto P.") fmt.Scan(&m, &q, &ascissaP, &ordinataP) if m*ascissaP+q==ordinataP { fmt.Println("Il punto appartiene alla retta.") } else { fmt.Println("Il punto non appartiene alla retta.") } } */
/* Scrivere un programma Go che legga 5 float (parametri della retta m e q, coordinate di un punto P e un valore float per la distanza D) e che calcola se il punto P è a meno di una distanza D dalla retta */ package main import ("fmt" "math") func main () { var m,q,d,px,py float64 fmt.Println("Questo programma calcola se un punto P si trova a meno di una distanza D da una retta nella forma y=mx+q") fmt.Println("Fornisci le coordinate del punto P, separate da una virgola: ") fmt.Scanf("%f,%f\n", &px, &py) fmt.Println("Fornisci la distanza d dalla retta: ") fmt.Scan(&d) fmt.Println("Fornisci la pendenza m della retta: ") fmt.Scan(&m) fmt.Println("Fornisci il parametro q: ") fmt.Scan(&q) // provato con 5,5 dist=3, retta y=4, NON funziona if math.Abs(py-m*px+q)<=d { fmt.Println("Il punto P rientra nella distanza D.") } else { fmt.Println("Il punto P non rientra nella distanza D.") } } /* package main import ( "fmt" "math" ) func main() { var m, q, ascissaP, ordinataP, distanzaP float64 fmt.Println("Inserire i parametri m e q della retta, le coordinate del punto P e la distanza presunta.") fmt.Scan(&m, &q, &ascissaP, &ordinataP, &distanzaP) if distanzaP>math.Abs(ordinataP-(m*ascissaP+q))/math.Sqrt(1+math.Pow(m, 2)) { fmt.Println("La distanza inserita è maggiore della reale.") } else if distanzaP==math.Abs(ordinataP-(m*ascissaP+q))/math.Sqrt(1+math.Pow(m, 2)) { fmt.Println("La distanza inserita è uguale alla reale.") } else { fmt.Println("La distanza inserita è minore della reale.") } } */ /* package main import "fmt" import "math" func main() { var ax, ay, bx, by, m1, q1, m2, q2, d, dist float64 fmt.Print("Inserisci le coordinate del punto ") fmt.Scan(&ax,&ay) fmt.Print("Inserisci l'm della retta poi il q della retta ") fmt.Scan(&m1,&q1) fmt.Print("Inserisci la distanza ") fmt.Scan(&d) m2 = -1 / m1 q2 = -m2*ax + ay bx = (q2 - q1) / (m1 - m2) by = bx*m2 + q2 dist = math.Sqrt(math.Pow(bx-ax, 2) + math.Pow(by-ay, 2)) if dist < d { fmt.Println("il punto è a distanza minore di ", d) } else { fmt.Println("il punto è a distanza maggiore di ", d) } } */ /* package main import "fmt" import "math" func main () { var m, q, xp, yp, D float64 fmt.Println("Inserisci le coordinate del punto P: ") fmt.Scan(&xp) fmt.Scan(&yp) fmt.Println("Inserisci la distanza dalla retta: ") fmt.Scan(&D) fmt.Println("Inserisci la pendenza m della retta(y=mx+q): ") fmt.Scan(&m) fmt.Println("Inserisci il parametro q della retta(y=mx+q): ") fmt.Scan(&q) if (math.Abs(yp-(m*xp+q)))/math.Sqrt(1+m*m)<= D{ fmt.Println("Il punto P è dentro la distanza fornita.") } else { fmt.Println("Il punto P non è dentro la distanza fornita.") } } */
/* Scrivere un programma Go che prenda in ingresso un float64 e determini se esso sia anche un int. (Esempio: 5.0 è anche un intero, mentre 5.31 no) (Opzionale: se la risposta è no arrotondarlo all'intero più vicino, senza usare il package math) */ //Sbagliato: qualsiasi numero che abbia 0 come primo decimale viene considerato Int... /* package main import "fmt" func main() { var numero, numero2 float64 fmt.Print("Inserire il numero. ") fmt.Scan(&numero) numero2=numero*10 //Provato: non funziona con 3.01 if int(numero2)%10==0 { fmt.Println("Il numero è sia Int sia Float.") } else { fmt.Println("Il numero non è sia Int sia Float.") } } */ /* //Versione corretta? package main import "fmt" func main() { var numero float64 fmt.Print("Inserire il numero. ") fmt.Scan(&numero) if float64(int(numero))==numero { fmt.Println("Il numero è sia Int sia Float.") } else { fmt.Println("Il numero non è sia Int sia Float.") } } */ package main import "fmt" func main() { var aFloat float64 var aInt int fmt.Print("Inserisci il valore da controllare ") fmt.Scan(&aFloat) aInt = int(aFloat) if aFloat-float64(aInt) == 0 { fmt.Println("Il numero è anche un intero") } else { fmt.Print("il numero non è un intero ") if aFloat-float64(aInt) < 0.5 { fmt.Println("e si arrotonda a", aInt) } else { fmt.Println("e si arrotonda a ", aInt+1) } } } /* package main import "fmt" func main() { var numero float64 fmt.Println("Inserisci numero da controllare:") fmt.Scan(&numero) var intero int = int(numero) var floatintero float64 = float64(intero) if numero -floatintero != 0 { fmt.Println("Questo numero non è un int") } if numero - floatintero >= 0.5 { fmt.Println("Il numero approssimato è:", floatintero+1) } else { fmt.Println("Il numero è:", floatintero) } } */
/* Scrivere un programma in Go che, ricevuti in input 8 float rappresentanti le coordinate di 4 punti nel piano (ogni coppia di punti identifica i vertici opposti di un rettangolo), restituisca in output l'area della sovrapposizione tra i due rettangoli. */ package main import ( "fmt" ) func main() { /* D-----C D1-----C1 | | | | A-----B A1-----B1 */ var ax, ay, cx, cy float64 var a1x, a1y, c1x, c1y float64 var area float64 fmt.Scan(&ax, &ay, &cx, &cy, &a1x, &a1y, &c1x, &c1y) //Se i due rettangoli non si sovrappongono l'area è 0 if cx <= a1x || ax >= c1x || cy <= a1y || ay >= c1y { area = 0 } else { //Esiste almeno una sovrapposizione e tale sovrapposizione corrisponde ai due valori centrali var x1, x2, y1, y2 float64 x1 = ax x2 = cx if a1x > ax { x1 = a1x } if c1x < cx { x2 = c1x } y1 = ay y2 = cy if a1y > ay { y1 = a1y } if c1y< cy { y2 = c1y } area = (x2 - x1) * (y2 - y1) } fmt.Println("La sovrapposizione è", area) }