View difference between Paste ID: i0D54Lsq and Q4wFU0AS

 #!/bin/sh
 exec /Users/baldur/scala-2.11.7/bin/scala "$0" "$@"
 !#
 
 val inputRE = """\s*(add|remove)\s+(\d+)\.(\d+)\.(\d+)\.(\d+)/(\d+)\s*""".r
 def toIP(i1: Int, i2: Int, i3: Int, i4: Int) = (i1 << 24) | (i2 << 16) | (i3 << 8) | i4
 def ipToString(ip: Int): String = f"${(ip>>24)&255}.${(ip>>16)&255}.${(ip>>8)&255}.${ip&255}"
 case class Subnet(ip: Int, prefixLength: Int) {
   override def toString: String = f"${ipToString(ip)}/${prefixLength}"
 }
 def netmask(prefixLength: Int) = if (prefixLength==0) 0 else -1 << (32 - prefixLength)
 
 // a valid subnet is a subnet where (ip & netmask) == ip
 def makeValid(subnet: Subnet): Subnet =
   subnet.copy(ip = subnet.ip & netmask(subnet.prefixLength))
 
 // split a subnet into two each with prefixLength+1
 def split(subnet: Subnet): (Subnet,Subnet) = (
   Subnet(subnet.ip, subnet.prefixLength + 1),
   Subnet(subnet.ip + (1 << (31 - subnet.prefixLength)), subnet.prefixLength + 1))
 
 /*
   subnetList: current set of subnets that shall be expanded
   subnetToAdd: subnet that will be added to subnetList
   returns: set of subnets that includes everything from subnetList plus subnetToAdd
 
   requirements:
 
   subnetToAdd is valid
 
   subnetList is optimal
   subnetList does not contain overlapping subnets
   subnetList does not contain subnets that could be merged
   subnetList does not contain invalid subnets
 
   return value provides same guaranties
 */
 def add(subnetList: Set[Subnet], subnetToAdd: Subnet): Set[Subnet] = {
   // 1) remove all subnets covered by subnetToAdd
   val subnetList2 = subnetList.filterNot { subnet =>
     subnet.prefixLength >= subnetToAdd.prefixLength &&
       ((subnet.ip & netmask(subnetToAdd.prefixLength)) == subnetToAdd.ip)
   }
 
   // 2) add subnetToAdd
   val subnetList3 = subnetList2 + subnetToAdd
 
   // 3) possibly merge subnetToAdd with adjicent subnet
   // 4) recursively perform step 4 until no merge or 0.0.0.0/0
   def merge(subnetList: Set[Subnet], toBeMerged: Subnet): Set[Subnet] = {
     if (toBeMerged.prefixLength == 0) return subnetList
     val supernet = makeValid(Subnet(toBeMerged.ip,toBeMerged.prefixLength-1))
     val (subnet1,subnet2) = split(supernet)
     // either subnet1 or subnet2 will be equal to toBeMerged
     if (subnetList(subnet1) && subnetList(subnet2)) {
       // two subnets found, remove both and add supernet instead
       // then run merge recursively
       merge(subnetList - subnet1 - subnet2 + supernet, supernet)
     } else {
       // done, could not find two subnets to merge
       subnetList
     }
 
   }
 
   merge(subnetList3, subnetToAdd)
 }
 
 /*
   subnetList: current set of subnets that shall be reduced
   subnetToRemove: subnet that will be removed from subnetList
   returns: set of subnets that includes all address space covered by subnetList excluding subnetToRemove
 
   requirements:
 
   subnetList is optimal
   subnetList does not contain overlapping subnets
   subnetList does not contain subnets that could be merged
   subnetList does not contain invalid subnets
 
   return value provides same guaranties
 */
 def remove(subnetList: Set[Subnet], subnetToRemove: Subnet): Set[Subnet] = {
   // 1) remove all subnets covered by subnetToRemove
   val subnetList2 = subnetList.filterNot { subnet =>
     subnet.prefixLength >= subnetToRemove.prefixLength &&
       ((subnet.ip & netmask(subnetToRemove.prefixLength)) == subnetToRemove.ip)
   }
 
   // 2) find all subnets that covers subnetToRemove
   val subnetCoversList = subnetList2.filter { subnet =>
     (subnetToRemove.ip & netmask(subnet.prefixLength)) == subnet.ip
   }
 
   // 3) select bestMatch, that is the one of largest prefixLength
   val bestMatch = subnetCoversList.toVector.sortBy(-_.prefixLength).headOption.getOrElse {
     // subnetCoversList is empty so we are done
     return subnetList2
   }
 
   // 4) remove bestMatch
   val subnetList3 = subnetList2 - bestMatch
 
   // 5) possibly split bestMatch and add the half that does not cover subnetToRemove
   // 6) recursively perform step 4 until subnet to split is equal to subnetToRemove
   def splitStep(subnetList: Set[Subnet], toBeSplit: Subnet): Set[Subnet] = {
     if (toBeSplit == subnetToRemove) return subnetList
     val (subnet1,subnet2) = split(toBeSplit)
     if ((subnetToRemove.ip & netmask(subnet1.prefixLength)) == subnet1.ip) {
       // add subnet2 and split subnet1
       splitStep(subnetList + subnet2, subnet1)
     } else {
       // add subnet1 and split subnet2
       splitStep(subnetList + subnet1, subnet2)
     }
   }
 
   splitStep(subnetList3, bestMatch)
 }
 
 val input = io.Source.stdin.getLines.collect {
   case inputRE(command,i1,i2,i3,i4,l) =>
-    (command,Subnet(toIP(i1.toInt,i2.toInt,i3.toInt,i4.toInt),l.toInt))
+    (command,makeValid(Subnet(toIP(i1.toInt,i2.toInt,i3.toInt,i4.toInt),l.toInt)))
 }
 
 val result = input.foldLeft[Set[Subnet]](Set.empty){ case (acc,op) => op match {
   case ("add",subnet: Subnet) => add(acc,subnet)
   case ("remove",subnet: Subnet) => remove(acc,subnet)
 }}
 
 for(subnet <- result.toVector.sortBy(_.prefixLength).sortBy(_.ip.toLong & 0xffffffffL))
   println(subnet)