Daily port checker / scanner tools – Email prompt [on hold]

Are there any recommendations on tools that can run light weight daily port checks on a windows server? I am hoping to check the state of ports daily. I recently discovered that port 1433 randomly closed after an update but nothing from MS mentions that an update could potentially disable the port.

Any suggestions would be great.

Why there is a strange numbers in my 5 queens checker?

i written a simple code to check your answer in 5 queens, i finished with horizontal positions but i have a problem in diagonal positions . when the code is executed i observe in some cases a strange numbers that was supposed to be not displayed, this an example (the strange nubers is with yellow. thanks for help.

l5=[] def Check(): for r in range(5):     for c in range(5):         if r*5+c in l:             while 0<=r<=4 and 0<=c<=4 :                  print(r,c)                 x=r*5+c                 l5.append(x)                 r+=1                 c+=1    print("l5:",l5) 

enter image description here

Frequency analysis based anagram checker

I uploaded code solutions for some problems of the book Cracking the Coding Interview, 6th Edition to GitHub, I would like to know your rating and potential improvement of the code I wrote.

Here is the first problem of chapter 1 (anagrams):

#include <stdio.h> #include <string.h>  /*check if one string is an anagram of another, it uses an int array  * called alphabet to store frequencies of chars in both strings, add  * 1 for s1 and subtract 1 for s2*/ int are_anagrams(const char *s1, const char *s2) {     int alphabet[26] = { 0 };     int index1, index2;     size_t l1 = strlen(s1), l2 = strlen(s2), i;      /*if the strings have different lengths are not anagrams */     if (l1 != l2) return 0;      /* count the frequencies of characters */     for (i = 0; i < l1; ++i) {         index1 = s1[i] - 'a';         index2 = s2[i] - 'a';         ++alphabet[index1];         --alphabet[index2];     }     /* all the alphabet letters should be 0, otherwise the strings are not      * anagrams */     for (i = 0; i < 26; ++i)         if (alphabet[i] != 0) return 0;      return 1; }  int main() {     char s1[] = "aaabbbccc";     char s2[] = "aabbaccbc";     printf("%d\n", are_anagrams(s1, s2));     return 0; } 

Any suggestion or advice is welcome, thanks for your time.

Pricing data checker script

I was recently given a task to implement a data-checker script which given an input file containing (date, last_price) values should check for 3 different kind of errors – missing values, stale values and outliers and returns list of errors. I wrote the code below and the feedback I got was that it was not “pythonic” enough. Can someone please let me know how I can make this more pythonic? What parts look good, what don’t? Will be extremely helpful as I write more python code in future.

#!/usr/bin/python3.6  import sys import csv import pprint import statistics from datetime import date  class DataChecker:     class DatePrice:         def __init__(self, input_date, price):             try:                 day, month, year = input_date.split("/")                 self._price_date = date(int(year), int(month), int(day))             except ValueError:                 # Don't tolerate invalid date                 raise              try:                 self._price = float(price)             except (TypeError, ValueError):                 self._price = 0          @property         def date(self):             return self._price_date.strftime("%d/%m/%Y")          @property         def date_obj(self):             return self._price_date          @property         def price(self):             return self._price          def __repr__(self):             return f"{self.date}, {self.price}"      def __init__(self, input_date_price_values):         self._date_price_values = []         for date, price in input_date_price_values:             try:                 self._date_price_values.append(self.DatePrice(date, price))             except ValueError:                 pass          self._date_price_values.sort(key=lambda x: x.date_obj)          self._stale_price_dict = {}          self._outlier_low, self._outlier_high = self._calculate_outlier_thresholds_using_iqr(             self._date_price_values         )      def check_for_errors(self):         """         returns -> List[tuple(date, float, error)]          errors = 'missing value', 'stale value' or 'outlier'          Uses 3 different error checkers to check for errors in data         1. Checks for missing values in data -> categorises missing values as any value == 0, or empty string or nulls         2. Checks for stale values in data -> categorises stale values as any value that remains unchanged              for 5 business days. For stale values it returns the last date on which it was repeated         3. Checks for outlier values in data -> Uses Interquartile range (IQR) and a low threshold of              first-quartile-value - 1.2 x IQR and high-threshold of third-quartile-value + 1.2 x IQR.              Any values outside this range are deemed as outliers         """         errors = []         for datePrice in self._date_price_values:             if self._is_value_missing(datePrice.price):                 self._add_to_errors(datePrice, "missing value", errors)             elif self._is_value_stale(datePrice.price):                 self._add_to_errors(datePrice, "stale value", errors)             elif self._is_value_outlier(datePrice.price):                 self._add_to_errors(datePrice, "outlier", errors)             else:                 continue          return errors      def _add_to_errors(self, datePrice, error_string, errors):         error_tuple = (datePrice.date, datePrice.price, error_string)         errors.append(error_tuple)      def _is_value_missing(self, price):         if price is None or price == 0:             return True         return False      def _is_value_stale(self, price):         if price in self._stale_price_dict:             self._stale_price_dict[price] += 1             if self._stale_price_dict[price] >= 5:  # 5 business days in week                 return True         else:             self._stale_price_dict.clear()             self._stale_price_dict[price] = 1         return False      def _is_value_outlier(self, price):         if price < self._outlier_low or price > self._outlier_high:             return True         return False      def _calculate_outlier_thresholds_using_iqr(self, data_price_values):         price_values = sorted([dataPrice.price for dataPrice in data_price_values])          median_index = len(price_values) // 2         first_quartile = statistics.median(price_values[:median_index])         third_quartile = statistics.median(price_values[median_index + 1 :])          iqr = third_quartile - first_quartile          low_iqr = first_quartile - 1.2 * iqr         high_iqr = third_quartile + 1.2 * iqr          return low_iqr, high_iqr      def _calculate_outlier_thresholds_using_mean_deviation(self, data_price_values):         price_values = sorted([dataPrice.price for dataPrice in data_price_values])          mean_value = statistics.mean(price_values)         std_dev = statistics.stdev(price_values)          low_iqr = mean_value - 2 * std_dev         high_iqr = mean_value + 2 * std_dev          return low_iqr, high_iqr   def check_file_data(file_path):     with open(file_path) as data_file:         raw_data = csv.DictReader(data_file)         input_data = []         for row in raw_data:             input_data.append((row["Date"], row["Last Price"]))          data_checker = DataChecker(input_data)         errors = data_checker.check_for_errors()          pp = pprint.PrettyPrinter(indent=4)         pp.pprint(errors)         print(f"Total Errors Found: {len(errors)}")          return errors   if __name__ == "__main__":     if len(sys.argv) < 2:         print("Please provide filepath")         sys.exit()      file_path = sys.argv[1]     check_file_data(file_path) 

To test put the above code in a file called “data_checker.py” and test code below in a file called “test_data_checker.py” in the same directory and run:

python3.6 -m pytest -v test_data_checker.py

import pytest  from data_checker import DataChecker  test_data = [     (         pytest.param(             [("01/02/2010", "10"), ("02/02/2010", "10.09"), ("03/02/2010", "10.12")],             [],             id="no-errors-in-data",         )     ),     (         pytest.param(             [("01/02/2010", "0.0"), ("02/02/2010", ""), ("03/02/2010", "10.12")],             [("01/02/2010", 0, "missing value"), ("02/02/2010", 0, "missing value")],             id="2-zero-values",         )     ),     (         pytest.param(             [                 ("01/02/2010", "2"),                 ("02/02/2010", "1.12"),                 ("03/02/2010", "1.12"),                 ("04/02/2010", "1.12"),                 ("05/02/2010", "1.12"),                 ("06/02/2010", "1.11"),             ],             [],             id="4-repeated-values-no-stale",         )     ),     (         pytest.param(             [                 ("01/02/2010", "1.10"),                 ("02/02/2010", "1.12"),                 ("03/02/2010", "1.12"),                 ("04/02/2010", "1.12"),                 ("05/02/2010", "1.12"),                 ("06/02/2010", "1.12"),                 ("07/02/2010", "1.11"),             ],             [("06/02/2010", 1.12, "stale value")],             id="1-stale-value",         )     ),     (         pytest.param(             [                 ("01/02/2010", "0"),                 ("02/02/2010", "1.12"),                 ("03/02/2010", "1.12"),                 ("04/02/2010", "1.12"),                 ("05/02/2010", "1.12"),                 ("06/02/2010", "1.12"),                 ("07/02/2010", "1.11"),             ],             [("01/02/2010", 0, "missing value"), ("06/02/2010", 1.12, "stale value")],             id="1-missing-1-stale-value",         )     ),     (         pytest.param(             [                 ("01/02/2010", "1.11"),                 ("02/02/2010", "5"),                 ("03/02/2010", "1.12"),                 ("04/02/2010", "1.11"),                 ("05/02/2010", "1.12"),                 ("06/02/2010", "1.12"),                 ("07/02/2010", "1.11"),             ],             [("02/02/2010", 5, "outlier")],             id="1-outlier-value",         )     ),     (         pytest.param(             [                 ("01/02/2010", "0"),                 ("02/02/2010", "5"),                 ("03/02/2010", "1.12"),                 ("04/02/2010", "1.11"),                 ("05/02/2010", "1.12"),                 ("06/02/2010", "1.12"),                 ("07/02/2010", "1.12"),                 ("08/02/2010", "1.12"),                 ("09/02/2010", "1.12"),             ],             [                 ("01/02/2010", 0, "missing value"),                 ("02/02/2010", 5, "outlier"),                 ("09/02/2010", 1.12, "stale value"),             ],             id="missing-stale-outlier-value",         )     ), ]   @pytest.mark.parametrize("input_data, expected_value", test_data) def test_check_for_error(input_data, expected_value):     data_checker = DataChecker(input_data)     errors = data_checker.check_for_errors()     assert errors == expected_value 

Explicit Song Checker

To stay in practice with my python I’ve decided to write an explicit song checker. It checks each word in the song against an array of explicit words contained in the file. I’ve decided not to include the words that are to be checked against, for I am not sure about the rule of having explicit words in a programs code. Feedback on efficiency and structure is what I’m going for mostly. Style and other critiques are invited as well.

explicit_song_checker.py

explicit_words = [     #explicit words not shown  ]  def isClean(song_path):     with open(song_path) as song:         for line in song:             words = line.split(" ")             for word in words:                 for explicit_word in explicit_words:                     if word == explicit_word:                         return False          return True  def main():     song = raw_input("Enter path to song: \n")     if isClean(song):         print("CLEAN")     else:         print("EXPLICIT")  if __name__ == '__main__':     main() 

Strong password checker in Python

This is a Leetcode problem –

A password is considered strong if below conditions are all met –

1. It has at least 6 characters and at most 20 characters.

2. It must contain at least one lowercase letter, at least one uppercase letter, and at least one digit.

3. It must NOT contain three repeating characters in a row (...aaa... is weak, but ...aa...a... is strong, assuming other conditions are met).

Write a function strong_password_checker(s), that takes a string s as input, and returns the MINIMUM change required to make s a strong password. If s is already strong, return 0.

Insertion, deletion or replacements of any one character are all considered as one change.

Here is my solution to this challenge –

def strong_password_checker(s: str) -> int:     def has_lower(s):         for c in s:             if c.islower(): return 1         return 0      def has_upper(s):         for c in s:             if c.isupper(): return 1         return 0      def has_digits(s):         for c in s:             if c.isnumeric(): return 1         return 0      def find_repeats(s):         i = 0         j = 0         repeats = []         while i < len(s) - 1:             if s[i+1] == s[i]:                 i += 1                 continue             if (i - j + 1) > 2: repeats.append(i - j + 1)             i += 1             j = i         if (i - j + 1) > 2: repeats.append(i - j + 1)         return repeats      def repeats_after_delete(reps, d):         if d >= sum([r - 2 for r in reps]):             return []         reps = sorted(reps, key=lambda d: d%3)         while d > 0:             for i in range(len(reps)):                 if reps[i] < 3:                     continue                 r = reps[i] % 3 + 1                 reps[i] -= min(r, d)                 d -= r                 if d <= 0:                     break         return [r for r in reps if r > 2]      def num_repeats_change(repeats):         return sum([r // 3 for r in repeats])      total_changes = 0     format_changes = (1 - has_lower(s)) + (1 - has_upper(s)) + (1 - has_digits(s))     repeats = find_repeats(s)     if len(s) < 6:         repeat_change = num_repeats_change(repeats)         total_changes = max([6 - len(s), format_changes, repeat_change])     elif len(s) > 20:         repeats = repeats_after_delete(repeats, len(s) - 20)         repeat_change = num_repeats_change(repeats)         total_changes = len(s) - 20 + max([repeat_change, format_changes])     else:          repeat_change = num_repeats_change(repeats)         total_changes = max([repeat_change, format_changes])     return total_changes 

Here are some example outputs –

#print(strongPasswordChecker("aaaaaaaaaaaaAsaxqwd1aaa"))  >>> 6  #Explanation - aa1aa1aa1aAsaxqwd1aa (just an example - delete three characters, add three digits to replace consecutive a's) 

#print(strongPasswordChecker("aaaaa"))  >>> 2  #Explanation - aaAaa1 (just an example - add a character (so the length is at least 6), add an uppercase letter to replace consecutive a's) 

#print(strongPasswordChecker("aAsaxqwd2aa"))  >>> 0  #Explanation - A strong password (all conditions are met) 

Here are the times taken for each output –

%timeit strongPasswordChecker("aaaaaaaaaaaaAsaxqwd1aaa") >>> 18.7 µs ± 1.75 µs per loop (mean ± std. dev. of 7 runs, 100000 loops each)  %timeit strongPasswordChecker("aaaaa") >>> 5.05 µs ± 594 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)  %timeit strongPasswordChecker("aAsaxqwd2aa") >>> 7.19 µs ± 469 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each) 

So, I would like to know whether I could make this program shorter and more efficient.

Any help would be highly appreciated.