Alert on file deletion activities – what are the specifics?

From the Microsoft Docs

Unusual activities (by user) These detections identify users who perform:

Unusual multiple file download activities Unusual file share activities Unusual file deletion activities Unusual impersonated activities Unusual administrative activities 

These policies look for activities within a single session with respect to the baseline learned, which could indicate on a breach attempt. These detections leverage a machine learning algorithm that profiles the users log on pattern and reduces false positives. These detections are part of the heuristic anomaly detection engine that profiles your environment and triggers alerts with respect to a baseline that was learned on your organization’s activity.

Can someone please advise if this alert is editable in order to set your own preference or it is as described?

Is there a way to set up an alert at tenancy level to be alerted whenever a file is deleted or a site is deleted?

External Content Type Connection : illegal operation attempted on a registry key marked for deletion

when I add a connection to a sql server database in an external content type from Sharepoint Designer 2013 I get this error:

Retrieving the COM class factory for component with CLSID {BDEADDF26....} failed due to the following error: 800703fa illegal operation attempted on a registry key that has been marked for deletion 

I see that CLSID corresponds to

C:\Program Files\Common Files\Microsoft Shared\Web Server Extensions\ISAPI\OWSSVR.DLL

What’s wrong?

Non-recursive version of Trie deletion

So,I was looking for the non-recursive version of Trie data structures deletion in the internet. I couldn’t find one. The best I could manage to find was a recursive implementation of trie in this website. Looking at the code for sometime, I thought that I could make the recursive version of the deletion to non-recursive one. Here is my take on it. Remember, I am worried whether I have done effective memory cleanup. Any insight on the overall code structure will also be helpful. Thanks.

#include<iostream> using namespace std; struct node{     bool isWord=false;     node* previous;     node* children[27]; };  void insert(node*& root, string key){     node *temp = root;     temp->previous = NULL;     int keyLen = key.length();     for(int i=0; i<keyLen; ++i){         int index = key[i]-'a';         //If i is the last element         if(i==keyLen-1){             //then take notice of it             //and change isWord to true             temp->isWord=true;             temp->children[index] = NULL;         }         //If there is no node at a given index         if(!temp->children[index]){             //Form a new node             temp->children[index] = new node;             //Take notice of the node that it is coming from             (temp->children[index])->previous = temp;         }         //Traverse along the children node         temp = temp->children[index];     } }   bool search(node*&root, string key){     node*temp = root;     int keyLen = key.length();     for(int i=0; i<keyLen; ++i){         int index = key[i] -'a';         //If i is at string length         //and the end the end it finds         //itself to be true         if(i==keyLen-1 && temp->isWord==true)         {             return true;         }          //If a character does not exist         //in the traversal          if(!temp->children[index]){             return false;         }         temp = temp->children[index];     }     //If the string is longer then expected     return false; } bool hasNoChildren(node* root){     for(int i=0; i<27; ++i){         //If the root has at least one child         //then return false         if(root->children[i])return false;     }     //else return true     return true; } void remove(node*& root, string key){     if(!search(root,key)) return ;     node*temp = root;     int keyLen = key.length();     for(int i=0; i<keyLen; ++i){         int index = key[i]-'a';         /*If i reaches the length of the string         temp is turned to false is turned to false         Which means if day word 'foo' is part of longer         word 'football', 'foo' does not exist as a         seperate word.         And if only 'foo' exist in the dictionary,         it also signals for it get removed in the next         for loop.*/         if(i==keyLen-1){             temp->isWord = false;         }         temp = temp->children[index];     }      /*The pointer temp in the above for loop     manages to reach to the end of the string     Since, the previous pointer is being tracked     it is easy to retract , if it is so required.*/     for(int i=keyLen-1; i>=0; --i){          /*If the temp isWord variable is false          and it happens to have not children         then it is being removed. Not this removal         happens in the bottom up fashion, which         allows effective memory deletion.*/         if(temp->isWord == false && hasNoChildren(temp)){             node*p = temp;             temp = temp->previous;             delete p;             }             else temp= temp->previous;         } }   int main(){     node* a = new node;     string keys[] = { "the", "a", "there",                       "answer", "any", "by",                       "bye", "their", "hero", "heroplane" };     for (int i = 0; i < 10; i++)         insert(a, keys[i]);     search(a, "the") ? cout << "Yes\n" : cout << "No\n";     search(a, "these") ? cout << "Yes\n" : cout << "No\n";     remove(a,"heroplane");     search(a, "hero") ? cout << "Yes\n" : cout << "No\n";     return 0; } 

Functional data structure fast to add and unorded deletion

I am looking for a functional data structure that would work in this role.

Adding items to the struct happens often. Removing items from the struct happens as often as adding them but I have no way of knowing what order the deletion happens in. Over the long term addions will equal removal Rarely I need all items currently in the struct

I thought of using a queue but out of order removal from a queue is expensive.

Red-black tree trinode restructuring after insertion and deletion

When performing an insertion/deletion on a red-black tree, how can be argued or proved that it requires at most one/two trinode restructuring(s) respectively? My thoughts so far were: after inserting a node and two consecutive red nodes exist along a path from root to a leaf a restructuring is done followed by recoloring, resulting in a red-black tree. Does this mean that after inserting a node there can only exist at most one double red problem in the tree which requires one restructuring to fix it?

Proofs for red-black tree insertion and deletion

I need to proof that the insertion into a red-black tree takes up to O(logn) recolorings and maximum 1 trinode reconstructions.

Additionally I need to show that deletion in a red black tree takes up to O(logn) recolorings and up to two reconstructions.


It seems logic that for the insertion and deletion takes up to log(n) recoloring because the tree has always a height of log(n). And also 1 reconstruction seem plausible, becuase the tree is already balanced before we insert a new element. However I’m am not sure how to show that mathematically and proof the 2 theorems. Can you help me with a sketch of the proofs?