22 ottobre 2018

/*
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)
}
pub/labprog/20181022.txt · Last modified: 2018/10/24 13:02 by lucafavalli
CC Attribution-Share Alike 4.0 International
Driven by DokuWiki Recent changes RSS feed Valid CSS Valid XHTML 1.0