Comparing 2 files [Steganography] [closed]

I am sure that something malicious is going on with the 1st file (bigger file size) Please compare the two files and test if something malicious is found

1st file(malicious) — Google-drive

2nd file(clean) — Google-drive

also I have uploaded both these files

problem- whenever i right click the malicious file my laptop hangs up for 10 sec, also while editing it in notepad++ the system hanged

—————————- [update]——————————–

when comparing with WinMerge

lines after 8418 (1st file) and 342(2nd file) are same So, it is proven that something is hidden in the 1st file

Comparing shortest path distance and relation between two modes present in FIFO queue at the same time during breadth first traversal

I came across following problem:

Consider two vertices $ a$ and $ b$ that are simultaneously on the FIFO queue at same point during the execution of breadth first search from $ s$ in an undirected graph. Then which of the following is true:

  1. The number of edges on the shortest path between $ s$ and $ a$ is at most one more than the number of edges on the shortest path between $ s$ and $ b$ .
  2. The number of edges on the shortest path between $ s$ and $ a$ is at least one less than the number of edges on the shortest path between $ s$ and $ b$ .
  3. There is a path between $ a$ and $ b$ .
  4. $ a$ may lie on shortest path from $ s$ to $ b$ .

The solution just said first three may hold separately. But that really left me confused. Especially it did not say anything about point 4.

Here is what I guess is correct:

  1. The shortest path distance of two nodes simultaneously present in FIFO queue can differ at max by 1. That is one node may be closer to source by at max just 1 edge than the other or it may be present at the same distance from source as other node. So either point 1 is correct or point 2, but not both. Am I right with this?

  2. Also what is significance of “at most” and “at least” in point 1 and point 2? I feel the difference between shortest path distance if two nodes can be “at most” 1. I guess “at most one more” aligns with this, but “at least one less” does not. That is shortest path distance of node $ a$ cannot be lesser than that of node $ b$ by 2 or more.

  3. I feel point 3 will always be true as there will always be path from $ a$ to $ b$ going through $ s$

  4. I feel point 4 is always false, because we dequeue the node $ a$ and then enqueue all its neighbours, one of which is $ b$ . So such $ a$ and $ b$ cannot be in the queue at the same time.

Am I correct with these?

Comparing classical tree-search algorithms (BFS,DFS,A*,IDS) – when to use one or the other?

I have a question about classical tree-search algorithms as I will have an exam soon and this is the type of questions they might be asking. Although I know how to compare the complexities, optimality, and completeness, I would like to go a bit further than that and compare the sparseness of the tree, the branching factor, solution depth, etc. I would like to compare the algorithms (A*, BFS, DFS, IDS tree-search algorithms (i.e. without keeping a list of visited nodes)) pairwise and ask the question what would be the situation where one or the other would be preferred.

So far I have written down everything I can think of and I would like to know:

  • Is what I have written down correct?
  • Is there something I have missed for specific comparisons?
  • Is there something I missed for all of them? I.e. some specific quality I did not think of?
  • Something I struggled with was which algorithm to prefer if the tree is sparse/dense – I took an educated guess for most of them but I am uncertain of my answers. If anyone has any guidance in that part, it would be terrific.

I have also added some questions here and there. I realise this is a lot but I greatly appreciate any help – any hints are welcome as well.

1 DFS vs IDS

When to prefer DFS?

  • If the solutions are frequent deeper in the tree

When to prefer IDS?

  • If you need at least one of them: optimality, completeness
  • If the tree is infinite (as DFS might get stuck)
  • If the solution is located in the upper part of the tree
  • If the solution is located deep in the tree and they are infrequent

Is there anything that can be said about sparseness/denseness for IDS here?

2 DFS vs BFS

When to prefer DFS?

  • If the tree has a large branching factor (BFS gets slow with wide trees)
  • If solutions and frequent and located deep in the tree
  • If there is a limit to how much memory can be used

When to prefer BFS?

  • If at least one of the two is required: optimality, completeness
  • If the tree is infinite
  • If the maximum depth is much larger than the branching factor
  • If you know that the solution is now far from the root of the tree
  • If solutions are rare and located deep in the tree
  • When the tree is sparse (unsure why)

3 DFS vs A*

When to prefer DFS?

  • If the heuristic of A* is poor
  • If the goal is optimality and the A* heuristic is not admissible
  • If solutions are frequent and located deep in the tree

When to prefer A*?

  • If the tree is infinite
  • If the tree is dense (unsure why)
  • In general blind search is slower than heuristic search, therefore for a good enough heuristic, A* should be prefered

Is there anything that can be said about the branching factor here?

4 BFS vs A*

When to prefer A*?

  • If memory space is limited
  • If the tree has a high branching factor
  • If the tree is dense
  • Although the complexity of queue is slightly better than that of priority queue, A*’s time complexity is usually better than BFS’s time complexity with a good enough heuristic

When to prefer BFS?

  • If the tree has a low branching factor
  • If the tree is dense
  • If the heuristic is poor
  • If the heuristic is not admissible and optimality is required

Is there anything that can be said about frequent/infrequent solutions here?

5 BFS vs IDS

When to prefer IDS?

  • When a lower space complexity is required and somewhat lower time complexity is acceptable

When to prefer BFS?

  • If the solution is in the upper part of the tree as it is less costly to generate the nodes once

I am a bit lost here – is there anything else that can be said about finiteness, denseness, frequency of solutions of the graph?

6 A* vs IDS

When to prefer IDS?

  • When the A* algorithm has a poor heuristic
  • When optimality is required and the A* heuristic is not admissible
  • If there are limitations to the amount of memory available

When to prefer A*?

  • In general blind search is slower than heuristic search, therefore for a good enough heuristic, A* should be prefered

Is there a discrepancy between the strength of aura when detect magic is cast comparing a ring of protection to a weapon with an enhancement bonus?

In the SRD it states:

Protection This ring offers continual magical protection in the form of a deflection bonus of +1 to +5 to AC. Faint abjuration; CL 5th; Forge Ring, shield of faith, caster must be of a level at least three times greater than the bonus of the ring; Price 2,000 gp (ring +1); 8,000 gp (ring +2); 18,000 gp (ring +3); 32,000 gp (ring +4); 50,000 gp (ring +5).

Compare that to:

Caster Level for Weapons The caster level of a weapon with a special ability is given in the item description. For an item with only an enhancement bonus and no other abilities, the caster level is three times the enhancement bonus. If an item has both an enhancement bonus and a special ability, the higher of the two caster level requirements must be met.

So according to a strict reading when detect magic is cast a ring of protection always radiates faint abjuration (CL 5th) and the creator as a perquisite for the crafting simply needs to be of a caster level at least three times greater than the bonus of the ring created. Regardless of the actual deflection bonus of the ring, a detect magic will always radiate faint abjuration.
Whereas conversely a weapon with a magical enhancement bonus to hit and damage always has a caster level (and perquisite) three times the enhancement bonus and will ‘register’ as such when a detect magic determines the strength of the aura.

This would seem to be a slight but significant difference in the way these magical items are handled in respect to detect magic. Is that anybody else’s understanding of this nuanced point or does anybody have a different interpretation?

Comparing design for a touch-screen (or an in-flight seatback) vs. design for responsive web/mobile

I am looking for a resource, reference, and or thoughts, that speak on the fundamental differences between designing for a fixed, touch screen app and a responsive-web, browser-based app.

Our web design team was asked to mimic the look-and-feel and functionality of an existing touch screen device (an in-flight seatback screen). These are to co-exist.

I’ve so far argued that although we will strive to unify the look-and-feel of the touch-screen app, we need to design based on standard responsive web design conventions: the use case for someone using a screen a foot or two away from them is different for someone using a phone or a tablet. Additionally, HTML5, CSS, JS is different from native apps or the like.

I’m looking to the UX community to weigh in on this and possibly give me a talking point, a source, or a reference that says that a touch screen app design does not necessarily translate to a responsive web-mobile design.

Comparing Data between two tables

We have a fairly large collection of DBs that has over 50 table (a few tables have few million rows) on SQL Server 2008 R2. The nightly batch runs independently between the DB’s (its a regulatory customer’s requirement), and throughout the day, there are subtle changes that goes in. At the end of the nightly processing, we compare all the tables (code base same as one would check replication – using sp_table_validation stored proc). We generate the number of rows, as well as checksums, as some update operations also happen. The biggest challenge that we face is – sp_table_validation process takes a very long time (over 1.5 hours) and is growing. We’ve looked into I/O performance, filegroups, multiple files, and the generic traceflags. Everything in that end is up to standard. I am looking for other ways where data can be compared between the tables (a bit quicker).

After a lot of experimentation, the direction I wanted to take is – enable cdc on the tables for which checksum is required. I’ve looked into things such as tablediff tools, among other things. Wanted to validate if I could get some inputs from the community who may had experience with this type of situation.

Specs: SQL Server 2008 R2 Enterprise Each DB has Primary and Secondary Filegroups Tables are partitioned mostly by quarter Data modification is only made to the first and last partition (unfortunately sp_table_validation does not have partition as parameter) All other best practices (multiple tempdb, TFs)

Thanks in advance.

Information Theory: Comparing surprisal of words with varying count frequency

This is a very broad question, I’m not sure if cstheory is the better place.

How can I compare the conditional surprisal of words that vary in frequency?

$ S(w|context)=−log(p(w|context))=−log(\frac{count(w,context)}{count(context)})$

The $ count(w,context)$ depends on the frequency of the word w because this can be further broken down to $ p(w|context)count(w)$ . This means a word that is more frequent will have a lower surprisal.

Is there a way to compare the surprisal of words with varying count/frequency, i.e control for frequency? Do I just divide $ count(w,context)$ by $ count(w)$ to normalize by count?

Comparing wait-signal alternatives for synchronizing two piece of programs

I came across following problem:

A certain computation generates two arrays a and b such that a[i]=f(i) for 0 ≤ i < n and b[i]=g(a[i]) for 0 ≤ i < n. Suppose this computation is decomposed into two concurrent processes X and Y such that X computes the array a and Y computes the array b. The processes employ two binary semaphores R and S, both initialized to zero. The array a is shared by the two processes. The structures of the processes are shown below.

+-------------------------+-------------------------+ | Process X:              | Process Y:              | | private i;              | private i;              | | for (i=0; i < n; i++) { | for (i=0; i < n; i++) { | |    a[i] = f(i);         |    EntryY(R, S);        | |    ExitX(R, S);         |    b[i]=g(a[i]);        | | }                       | }                       | +-------------------------+-------------------------+ 

How to correctly implement ExitX() and EntryY()?

The given solution was:

+---------------+----------------+ | ExitX(R, S) { | EntryY(R, S) { | |   P(S);       |   V(S);        | |   V(R);       |   P(R);        | | }             | }              | +---------------+----------------+ 

where P() is a wait operation and V() is a signal operation.

My doubt is will it make difference if we swap these operations, some like below?

+---------------+----------------+ | ExitX(R, S) { | EntryY(R, S) { | |   V(R);       |   P(R);        | |   P(S);       |   V(S);        | | }             | }              | +---------------+----------------+ 

I believe there is no difference in the behavior and overall outcome of the code when either of above two solutions is used. Am I right?