Tag: finding

Finding original command result from MD5 hash

Basically I hashed the result of the “date” command with md5sum:

$ date | md5sum

The output is indeed in the likes of:

e4c94362cd4fd71ec6aca78c7411bdc3 -

My question was: is it possible to recover the result of the date command knowing the date pattern (except for maybe the minutes and seconds)?

I tried using john’s mask option as well as a custom wordlist, without result.

Do you guys have any idea how we could pull that off?

Finding a node in a binary tree by looking at the path between it and the root

There is a directed binary tree as shown in the picture (all edges are diercted from higher- to lower-level nodes). In that tree there is some specific unknown node $ s$ . All nodes in the $ (s, root)$ path are marked somehow (yellow nodes in the picture) so we can check using a $ check$ operation if a node belongs to the path. The total length of the path (number of the edges) is $ l$ and its value is unknown (in the picture $ l=2$ ). The task is to find the node $ s$ using a randomized algorithm such that it is expected to use $ check$ operation at most $ \frac{3}{2}l$ times.

enter image description here

Finding maximal cardinal independent set given oracle

The problem is given an oracle $ O(G, k)$ that would say if graph G contains IS of size k devise an algorithm for finding independent set of max cardinality that makes poly number of calls to the oracle. My attempt has been that first finding the maximal possible size and then try to find the set of that size by removing vertices one at a time. I understand for a given node it either has to be in or not in the set, then I noticed that that there are multiple overlaps between chain of removals and I could devise a DP algorithm of sorts. But I’m just really stuck after that and was wondering if any hint could be given.

Finding the closed form of this recurrence


We have the following recurrence $ T$ : $ $ T(n,k) = \left\{ \begin{array}{ll} \alpha n^2 + \beta n + \delta & \quad \text{if }\; n \le k \ T(\lceil n / 2 \rceil, k) + T(\lfloor n / 2 \rfloor, k) + \gamma n + \zeta & \quad \text{if }\; n > k \ \end{array} \right. $ $

for all positive integers $ n$ and $ k$

I want to find a closed-form of $ T$ .

I at least know that when $ n > k$ , then

  • If $ n$ is even, then $ T(n,k) \;=\; 2T(\frac{n}{2}) + \gamma n + \zeta$

  • If $ n$ is odd, then $ T(n,k) \;=\; T((n-1)/2) + T((n+1)/2) + \gamma n + \zeta$

Usually I would enter a range of inputs $ n$ to find a pattern. However, there are so many constants here, I cannot find a consistent pattern to get a closed-form.

Finding the smallest integer such that a given condition holds with “binary search”

Setup. Suppose we are given a function $ $ f:\mathbb N\to\{\text{False},\text{True}\}$ $ such that $ $ f(n)=\text{True}\implies f(n+1)=\text{True}$ $ and such that $ f(n)=\text{True}$ for some $ n$ large enough.

In natural language. The function $ f$ imposes a condition on the natural numbers which is fulfilled once $ n$ is large enough.

My question. How can I, for any given $ f$ , find the smallest $ n$ such that $ f(n)=\text{True}$ ?

A first idea would be to start with $ n=1$ and to increment $ n$ by one until $ f(n)$ is True. However, this is fairly slow. So I designed a sort of “binary search” for this task. How can I translate this to Mathematica?

Here is the Code in Python:

def bin_search(cond):     n = 1     while not cond(n):         n *= 2     lower_bound = n//2     upper_bound = n     middle = (lower_bound + upper_bound)//2     while upper_bound - lower_bound > 1:         if cond(middle):             upper_bound = middle         else:             lower_bound = middle         middle = (lower_bound + upper_bound)//2     return upper_bound

For example, one such condition would be $ $ f(n)=[H_n\geq 10],$ $

where $ $ H_n=\sum_{i=1}^n \frac 1i$ $ is the $ n$ th harmonic number.

Assignment Problem — finding the $k$ agents with the best assignment

I have a question that I have been thinking about. Suppose we have $ n$ agents, $ m$ tasks, and a cost matrix with $ M_{ij}$ being the cost of agent $ i$ performing task $ j$ . How can we find the $ k < n$ agents, who when each optimally allocated a unique task, result in a minimum total cost? Can this be related to the assignment problem? Thank you very much for any guidance or assistance.

Can humans of House Tharashk develop the Mark of Finding?

After reading through Eberron: Rising from the Last War, I have noticed a conflicting statement regarding the Mark of Finding. On page 32, Half-Orcs and Dragonmarks, it states:

The Mark of Finding appears among half-orcs of House Tharashk. Strangely, both orcs and humans associated with the house cannot develop this mark.

This directly conflicts with the information found on page 41 which goes into detail about the Mark of Finding:

Alone among the dragonmarks, the Mark of Finding is carried by two races: humans and half­ orcs.

[…]

If your half-orc or human character has the Mark of Finding, the following traits replace the character’s racial traits in the Player’s Handbook, aside from age, alignment, size, and speed.

Additionally, there is nothing under the House Tharashk subheading about humans being unable to develop the Mark of Finding. Further, on page 37 under Dragonmarks and their Houses, both humans and half-orcs are listed as being associated with House Tharashk and the Mark of Finding.

Is this some kind of editorial/printing error or is there some piece of lore which allows both of these claims to be true?

A heuristic for finding an edge cycle cover

I am working on a problem that considers the list of cycles that a certain vertex belongs to in a graph! After computing all simple cycles with Johnson algorithm, I realized that I don’t need them all but instead, for every vertex, a list of cycles covering the edges of its cycles would be enough! I made few searches and found out there is the Edge Cycle Cover and finding the minimum is NP-HARD problem. I’m not sure if it is exactly what I’m looking for. Also, I don’t want to process all the simple cycles returned cause it may increase the global algorithm complexity.

So, any help understanding this problem? Is there a heuristic to get only a subset of cycles for each vertex in the graph? it does not have to be minimal!