99 lines
2.8 KiB
Rust
99 lines
2.8 KiB
Rust
use std::io::{self, Write, BufRead, BufWriter};
|
|
|
|
#[derive(Debug)]
|
|
struct Measure{
|
|
x:i32,
|
|
y:i32,
|
|
r:i32,
|
|
}
|
|
|
|
impl Measure{
|
|
fn init(x:i32, y:i32, r:i32) -> Measure{
|
|
Measure{
|
|
x,
|
|
y,
|
|
r,
|
|
}
|
|
}
|
|
|
|
fn equal(&self, other: &Measure) -> bool{
|
|
if self.x == other.x && self.y == other.y && self.r == other.r{
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
fn distance(&self, other: &Measure) -> f64{
|
|
(((self.x - other.x).pow(2) + (self.y - other.y).pow(2)) as f64).sqrt()
|
|
}
|
|
|
|
fn rdiff(&self, other: &Measure) -> (f64, f64){
|
|
if self.r > other.r{
|
|
return ((self.r - other.r) as f64, (self.r + other.r) as f64);
|
|
}
|
|
return ((other.r - self.r) as f64, (self.r + other.r) as f64);
|
|
}
|
|
|
|
|
|
fn num_intersect(&self, other: &Measure) -> u8{
|
|
let dist = self.distance(&other);
|
|
let (rdiff, rsum) = self.rdiff(&other);
|
|
|
|
if dist == rdiff || dist == rsum{
|
|
return 1;
|
|
}
|
|
else if rdiff < dist && dist < rsum{
|
|
return 2;
|
|
}
|
|
else{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
fn main(){
|
|
let stdin = io::stdin();
|
|
let mut n = String::new();
|
|
stdin.read_line(&mut n).expect("Failed to read line\n");
|
|
let n = n.trim().parse::<u32>().expect("Not an integer\n");
|
|
|
|
let mut lock_in = stdin.lock();
|
|
|
|
let stdout = io::stdout();
|
|
let lock_out = stdout.lock();
|
|
let mut buff = BufWriter::new(lock_out);
|
|
|
|
for _i in 0..n{
|
|
let mut datas = String::new();
|
|
lock_in.read_line(&mut datas)
|
|
.expect("Failed to read line");
|
|
let mut datas = datas.trim().split(" ");
|
|
|
|
// first measurement
|
|
let x1 = datas.next().expect("Not enough input\n")
|
|
.parse::<i32>().expect("Not an integer\n");
|
|
let y1 = datas.next().expect("Not enough input\n")
|
|
.parse::<i32>().expect("Not an integer\n");
|
|
let r1 = datas.next().expect("Not enough input\n")
|
|
.parse::<i32>().expect("Not an integer\n");
|
|
let m1 = Measure::init(x1, y1, r1);
|
|
|
|
// second measurement
|
|
let x2 = datas.next().expect("Not enough input\n")
|
|
.parse::<i32>().expect("Not an integer\n");
|
|
let y2 = datas.next().expect("Not enough input\n")
|
|
.parse::<i32>().expect("Not an integer\n");
|
|
let r2 = datas.next().expect("Not enough input\n")
|
|
.parse::<i32>().expect("Not an integer\n");
|
|
let m2 = Measure::init(x2, y2, r2);
|
|
|
|
if m1.equal(&m2){ // check equivalence
|
|
buff.write(b"-1\n").expect("Failed to write\n");
|
|
}
|
|
else{ // check number of intersection
|
|
buff.write_fmt(format_args!("{}\n", m1.num_intersect(&m2))).expect("Failed to write\n");
|
|
}
|
|
}
|
|
}
|