code guessing, round #48 (completed)

pub fn entry(haystack: &str, needle: &str) -> Option<(usize,usize)>

{let solver: solverstd::structs::implemented::SolverBuilderBuilder  = solverstd::structs::implemented::SolverBuilderBuilder::new();
   let solver: solverstd::structs::implemented::SolveBuilder      = solverstd::structs::implemented::SolverBuilderBuilder::haystack(solver,haystack);
 // // / / / / ////  // // //// / YOUR mom is GAY /// // / / / / // / / // / // / / / // // / //// / // /   //  / /
      let solver: solverstd::structs::implemented::Solverer   = solverstd::structs::implemented::SolveBuilder::needle(solver,needle);
 return solverstd::structs::implemented::Solverer::solve(&solver);}

   mod solverstd { pub mod structs { pub mod implemented {
trait CharIter: Iterator<Item=(usize,char)> + Clone {}
impl<T: Iterator<Item=(usize,char)> + Clone> CharIter for T {}
  struct IncompleteWord<'a> { begin: usize, stride: usize,
    characters_to_go: usize, character: char, characters: std::str::Chars<'a> 

   }  impl<'a> Solverer<'a> {
            pub fn solve(&'a self) -> std::option::Option<(usize,usize)> {
                if self.Lemonade.is_ascii() {
                    #[cfg(feature="timetest")]println!("ascii!");
                    let chariter = |i,s|self.hackstack.as_bytes()[i..].iter().enumerate().step_by(s).map(move|(o,c)|(o+i,unsafe{char::from_u32_unchecked(*c as u32)}));
                    self.solve_for_real(chariter)
                } else {
                    #[cfg(feature="timetest")]println!("unicode...");
                    let charinds = str::char_indices(self.hackstack).collect::<Vec<_>>();
                    let chariter = |i,s|charinds[i..].iter().step_by(s).copied();
                    self.solve_for_real(chariter)
                }
            }
             fn solve_for_real<T:CharIter,F:FnMut(usize,usize)->T>(&'a self, mut chariterf: F) -> std::option::Option<(usize,usize)> {#[cfg(any(feature="meow",not(feature="meow")))]{
                let meow: std::vec::Vec<char> = str::chars(self.Lemonade).collect();
                 let mut characterifier = meow.iter().copied();
	         let first_character = characterifier.next()?;
                let characterifier = characterifier;
             let second_character = characterifier.clone().next();

	            let mut word_seeds: std::vec::Vec<WordSeed<'a>> = std::vec::Vec::new();
                let mut bad_seeds: std::vec::Vec<usize> = std::vec::Vec::new();
#[cfg(feature="timetest")]let mut beginned = std::time::Instant::now();
#[cfg(feature="timetest")]println!("begin...");
         	   for (i,index, character) in chariterf(0,1).enumerate().map(|(i,(cind,character))|(i,cind,character)) {
	                 if second_character.map(|value|value==character).unwrap_or(false){
                         for (word_index, word_seed) in <[WordSeed]>::iter(std::borrow::Borrow::borrow(&word_seeds)).enumerate() {
                         if index+(index-word_seed.begin)*(self.Lemonade.len()-1)>self.hackstack.len() {
                             bad_seeds.push(word_index);
                            } else {
                         let mut count = 1;
                         if chariterf(i,index-word_seed.begin).map(|(_,character)|character).zip(characterifier.clone()).all(|(a,b)|{count+=1;a==b}) && count==self.Lemonade.len() {
                             return Some((word_seed.begin,index-word_seed.begin-1));
                         }
                            }
               }}
		          for word_index in bad_seeds.drain(..).rev() {
                          word_seeds.swap_remove(word_index);
                    }
                         if character == first_character {
                            if self.Lemonade.len()<2 { return Some((index,usize::MAX)); }
	                      std::vec::Vec::push(&mut word_seeds, WordSeed {begin : index, meow: std::marker::PhantomData});
                   }
                         #[cfg(feature="timetest")]{let meow = std::time::Instant::now(); if (meow-beginned).as_millis()>500 { beginned=meow;
                         println!("{} {}",index as f64 / self.hackstack.len() as f64,word_seeds.len())}}
	      	     }
              None
          	}
             }}
  pub struct

SolverBuilderBuilder { murder	//1 481 9991 003 884 4 2342342342 8jg LMK!fc gcc clang llvm
                	           	//rusted tragedy demonic recruitment
     :()
}
  pub struct SolveBuilder<'a> {
       haystack: &'a str,
  }

struct WordSeed<'a> {
	begin: usize,
    meow: std::marker::PhantomData<&'a str>,
 //  characters: std::str::Chars<'a>,
}

	pub struct Solverer<'a> {
		hackstack : &'a str,
		Lemonade : &'a str
	}

	impl SolverBuilderBuilder {
		pub fn new() -> Self {
			Self{murder:()}
		}

		pub fn haystack<'a>(self, hellostrat: &'a str) -> SolveBuilder<'a> {
			SolveBuilder {haystack: hellostrat}
		}
	}

   impl<'a> SolveBuilder<'a> {
     	pub fn needle(self, needLemon: &'a str) -> Solverer {
       Solverer {hackstack: self.haystack,
         Lemonade: needLemon}
          }
	}
}}}


#[cfg(test)]
mod tests {
    use super::*;

      fn strangle(stack: &str, index: Option<(usize,usize)>, len: usize) -> String {
        let mut buffer = String::new();
      let index = match index {
           None => {return buffer}
            Some(index) => {index}
            };
       for i in 0..len {
          buffer.push(stack.chars().nth(index.0 + i*(index.1)+i).unwrap());
      }
           return buffer;
   }

   #[test]
  fn it_works() {
         let result = entry("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY", "S");
       assert!(match result {Some((n,_))=>n==3,None=>false}, "S test failed: {}", strangle("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY",result,1));

         let result = entry("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY", "SA");
          assert_eq!(Some((3, 15)), result, "SA test failed: {}", strangle("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY",result,2));

     let result = entry("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY", "SAD");
    assert_eq!(Some((10, 8)), result, "SAD test failed: {}", strangle("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY",result,3));

          let result = entry("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY", "SCAM");
	  assert_eq!(Some((9, 4)), result, "SCAM test failed: {}", strangle("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY",result,4));

      	let result = entry("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY", "GAY");
        assert_eq!(Some((39, 0)), result, "GAY test failed: {}", strangle("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY",result,3));

      let result = entry("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY", "SICK");
     	assert_eq!(None, result, "SICK test failed: {}", strangle("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY",result,4));
    }

   //#[test]
      //fn it_does_not_works() {
    //      unsafe{
      //    *std::mem::transmute::<_,*mut u64>(std::ptr::null::<u8>()) = 42;
  //     };
      //}
}

#include <stdbool.h>
#include <stddef.h>

bool entry_impl(
	// strings don't need to be \0 terminated because fuck that
	const char *haystack, const size_t s_haystack,
	const char *needle,   const size_t s_needle,
	// output
	size_t *start, size_t *gap // thigh gap uwu
)
{
	// search for first char
	for (*start = 0; *start <= s_haystack-s_needle; haystack++, (*start)++) {
		// skip over chars that dont match
		if (*haystack != *needle)
			continue;

		// reset char gap
		*gap = 0;

		// if there's only one char in needle, quit early
		if (s_needle == 1)
			return true;

		// max pos for second char so the entire needle still fits
		const char *h_max = haystack + (s_haystack - *start - 1) / (s_needle - 1);

		const char *h = haystack+1;
		const char *n = needle+1;

		// search for second char
		for (; *n != *h; h++, (*gap)++) {
			// skip if no matching second char found
			if (h > h_max)
				goto skip;
		}

		// match remaining chars
		for (size_t i = 2; i < s_needle; i++) {
			// skip if mismatch
			if (*++n != *(h += *gap + 1))
				goto skip;
		}

		return true;
		skip: continue;
	}

	return false;
}

// fuck your language limitations
// just require an ABI or a I/O interface instead of being cringe

#[link(name = "impl")]
extern "C" {
    pub fn entry_impl(
        haystack: *const u8,
        s_haystack: usize,
        needle: *const u8,
        s_needle: usize,
        start: *mut usize,
        gap: *mut usize,
    ) -> bool;
}

pub fn entry(haystack: &str, needle: &str) -> Option<(usize, usize)> {
    let mut start = 0;
    let mut gap = 0;

    let succ = unsafe {
        entry_impl(
            haystack.as_ptr(),
            haystack.len(),
            needle.as_ptr(),
            needle.len(),
            &mut start as *mut usize,
            &mut gap as *mut usize,
        )
    };

    if succ {
        Some((start, gap))
    } else {
        None
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn sad_succeeds() {
        assert_eq!(
            entry("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY", "SAD"),
            Some((10, 8))
        );
    }

    #[test]
    fn scam_succeeds() {
        assert_eq!(
            entry("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY", "SCAM"),
            Some((9, 4))
        );
    }

    #[test]
    fn gay_succeeds() {
        assert_eq!(
            entry("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY", "GAY"),
            Some((39, 0))
        );
    }

    #[test]
    fn sick_fails() {
        assert_eq!(
            entry("THISBOOKISSOFUCKINGAWESOMEANDIAMTOTALLYGAY", "SICK"),
            None
        );
    }
}

struct IterNatPair {
	next: (usize, usize),
}
impl IterNatPair {
	pub fn new() -> Self {
		Self { next: (0, 0) }
	}
}
impl Iterator for IterNatPair {
	type Item = (usize, usize);
	fn next(&mut self) -> Option<Self::Item> {
		let next = self.next;
		self.next = match self.next.0 {
			0 => (self.next.1 + 1, 0),
			_ => (self.next.0 - 1, self.next.1 + 1),
		};
		Some(next)
	}
}

// TODO: If needle isn't in haystack, return None. Currently, we get stuck.
//       I think this is hard to do without breaking infinite haystacks.

// I'd be interested what time complexity this is, and how you worked it out.

pub fn divine_intellect<T: PartialEq, I: Iterator<Item = T> + Clone>(
	haystack: I,
	needle: I,
) -> impl Iterator<Item = (usize, usize)> {
	IterNatPair::new()
		.filter(|(_, step)| *step != 0)
		.filter(move |(start, step)| {
			haystack
				.clone()
				.skip(*start)
				.step_by(*step)
				.take(needle.clone().count())
				.eq(needle.clone())
		})
}

pub fn entry(haystack: &str, needle: &str) -> Option<(usize, usize)> {
	divine_intellect(haystack.chars(), needle.chars()).next()
}

#[cfg(test)]
mod tests {
	use super::*;

	#[test]
	fn iternatpair() {
		assert_eq!(
			IterNatPair::new().take(6).collect::<Vec<_>>(),
			[(0, 0), (1, 0), (0, 1), (2, 0), (1, 1), (0, 2)],
		);
	}

	#[test]
	fn short() {
		assert_eq!(entry("hello", "hello"), Some((0, 1)));
		assert_eq!(entry(" hello", "hello"), Some((1, 1)));
		assert_eq!(entry("h e l l o", "hello"), Some((0, 2)));
		assert_eq!(entry(" h e l l o", "hello"), Some((1, 2)));
		assert!(match entry("abc", "b") {
			Some((start, _)) => start == 1,
			None => false,
		});
		assert!(match entry("abc", "") {
			Some((start, _)) => start <= 3,
			None => false,
		});
		matches!(entry("", ""), Some((0, _)));
	}

	#[test]
	fn wrong_path() {
		assert_eq!(entry("ehello", "hello"), Some((1, 1)));
		assert_eq!(entry("hhello", "hello"), Some((1, 1)));
		assert_eq!(entry("he hello", "hello"), Some((3, 1)));
	}

	#[test]
	fn failure() {
		assert_eq!(entry("hello", "hi"), None);
	}

	#[test]
	fn long() {
		assert_eq!(
			entry("abhegggggggggaachjkhfasd h e l l o a", "hello"),
			Some((25, 2)),
		);
	}
}