## What is the difference between \$SIZE(n^k)\$ and \$P/poly\$?

$$SIZE(n^k)$$ is defined as the class of problems solvable with Boolean circuits (of fan-in two) with $$O(n^k)$$ gates. While $$P/poly$$ is defined as those problems over {0,1}* which can be solved by an infinite family of polynomial-size circuits $${Cn}$$.

## Difference between DNS Spoofing and DNS Hijacking?

DNS Spoofing and DNS Hijacking, both of them basically are type of attacks where the request is redirected to some other malicious website or some other web page. But I did not find some concrete difference between them, Can someone please explain the primary difference between DNS Spoofing and DNS Hijacking..

## Difference between impersonation and masquerading attacks

According to a book that I am reading, an impersonation attack is a more active attack than masquerading but I thought they are the same thing. How is this so.

## What are the sales figures for Pathfinder 2e between launch year and second year to date?

Pathfinder 2nd edition officially hit gaming tables almost a full year ago. Since then, I’ve noticed quite a lack of questions on this site with the pathfinder-2e tag compared to other systems, and I doubt it’s because of a corresponding lack of rules ambiguity.

I know that 5th edition is Dungeons & Dragons’ most successful edition yet; has Paizo released any information about the financial reception of 2nd edition?

How is the company doing compared to last year at this time?

## What is the difference between python list and c++ vector?

I read about the similarities between the python list and c++ vector and it looks as if the only difference is python list is heterogeneous. Are there any other differences? How are they both implemented?

## How do I balance game interactions between a giant mecha that can level cities and its pilot?

I have had recurring trouble with a subject I like, and would like to implement into my games, but can’t find a good way to do so: mechas (big huge robots)

From a system point of view, it is usually quite easy: just a big suit of armor with specific weapons. The pilot has to be inside to be able to use it, and it is too big to use just anywhere. Most systems can allow it.

However, I can’t find a good game balance for it. The main problem is that the whole “normal person when outside the suit / super-destruction-machine when inside the suit” makes too much of a difference in-game. For example, any challenge when the pilot is outside the suit is a trifle when in the suit; while any challenge for the suit is impossible for the pilot. It ends up feeling like playing two games at the same time: the mechas’ game, and the pilots’ game.

I have tried reducing the difference between the pilot and suits (making the pilots stronger and/or the suits weaker), but then the suits have almost no use, and the players end up almost never using them.

I have tried mainly in BESM (since it is already implemented), D&D, and even tried to develop my own system (with Mecha/pilot classes and perks). I’m looking for a Gundam/Front Mission style, i.e. mechas are big and powerful, can potentially be destroyed by well-equipped and organized infantry, but are mainly in their own world (mecha vs mecha)

So the question is: how would you balance a game focused on mechas?

## How to find the size of gaps between entries in an array so that the first and last element of the array is filled and the gaps are all of equal size?

I have an array a of n entries. I need to place a token on the first and last position of that array, so `a[0] = 1` and `a[n-1] = 1`.

I now want to place additional tokens into that array with a distance inbetween each index i where `a[i] = 1` that is greater than 2 (so placing a token on every index is invalid as well as alternating using and not using an entry is invalid). Phrazed differently: I want that `sum(a) < n/2` . The gap inbetween each token should be the same, so say with an array of size 16,

`a[0] = 1, a[3] = 1, a[6] = 1, a[9] = 1, a[12] = 1, a[15] = 1`

would be a solution with a gap size of 2 (distance of 3).

How do I find all gap sizes that are possible to fill said array with the given constraints?

Imagine a street inbetween two crossroads where a lamppost should be placed on each crossroad and then additional lampposts should be placed equidistant to each other and for some reason only natural number distances are allowed.

(The actual problem I want to solve is where to place Sea Lanterns in my Minecraft Project so do not disregard this problem as an assignment question I want a solution for.)

## Performance comparison between AES256 GCM vs AES 256 SHA 256

I understand GCM Crypto uses ESP Encryption only for ESP and Authentication algorithm. whereas AES 256 SHA256 uses AES for ESP Encrypt and SHA256 for Auth algorithm.

Could someone help clarify the reason of getting a better performance with AES256GCM as compared to ASE256SHA256.

## What is the difference between these two Edit Distance Algorithm

Edit Distance is very well known problem in computer science. Came up with following algorithm after reading through CLRS but it doesn’t work. Check the working algorithm below, I couldn’t find why first algorithm doesn’t work while second one does.

``  public int find (String word1, String word2, int i, int j, int count) {     if (i >= word1.length()) return  count + word2.length() - j;     if (j >= word2.length()) return  count + word1.length() - i;      if (dp[i][j] != -1) return dp[i][j];      if (word1.charAt(i) == word2.charAt(j)) {         dp[i][j] = find(word1, word2, i+1, j+1, count);     } else {         int replace = find(word1, word2, i+1, j+1, count + 1);         int delete = find(word1, word2, i+1, j, count + 1);         int insert = find(word1, word2, i, j+1, count + 1);                  dp[i][j] = Math.min(replace, Math.min(delete, insert));     }      return dp[i][j]; } ``

Notice, how I’m passing the cost of edit in method argument. Now, the algorithm which works. Here I’m not passing the edit distance in the method parameter instead of I’m adding 1 to recursive method.

``  public int find (String word1, String word2, int i, int j) {     if (i >= word1.length()) return  word2.length() - j;     if (j >= word2.length()) return  word1.length() - i;      if (dp[i][j] != -1) return dp[i][j];      if (word1.charAt(i) == word2.charAt(j)) {         dp[i][j]  = find(word1, word2, i+1, j+1, count);     } else {         int replace = find(word1, word2, i+1, j+1, count + 1);         int delete = find(word1, word2, i+1, j, count + 1);         int insert = find(word1, word2, i, j+1, count + 1);                  dp[i][j] = 1 + Math.min(replace, Math.min(delete, insert));     }      return dp[i][j]; } ``

I’m not able to think why first algorithm fails. Appreciate, if you can point my error in understanding.

## Consistency between “yes and” with “no, because I’m the DM”

Context: I enjoy running softer systems, with Numenera being my latest favorite. I discard rules left and right in favor of what feels right during the play. I love the "rule of cool" too, and I use it liberally.

One of my players is rather creative and often vividly imagines the outcome of their plans. How do I help them manage their expectations when these plans can not come to fruition for DM reasons?

It’s easier to explain this with examples. Here’s an example of me letting the player have fun with their creative solution:

• DM: The bad guy is monologuing safely behind a force field.
• Player: I use my cypher of bypassing force field and my superhuman speed pill I swallowed 3 hours ago (and they indeed have) to tackle the bad guy.
• DM: Give me a roll.
• Player: 20.
• DM: You succeed.

The rest of the players jump in to restrain the baddie, everyone celebrates and players have fun. I’ll survive not having a bigger showdown here.

And here’s example of me not letting the player to go forward with their plan (all the rolls are 20s in this example to double down on the problem — I gave the player opportunity to roll, they critically succeeded, but I don’t want them to):

• Player: I "accidentally" tap the bad guy on the back to make sure they’re not a hologram.
• DM: They’re not.
• Player: I’m walking last, and I put on my invisibility cloak.
• DM: Give a roll.
• Player: 20.
• DM: You succeed.
• Player: I sneak behind him and slice his throat while he talks (this seems like a murder-hobo response, but the character had a solid motivation behind this)
• DM: Give me a roll.
• Player: 20.
• DM (trying to save a recurring villain for a larger ark): You attempt to do so, but in the last moment the bad guy wiggles out and yells for guards. A fight ensues.

Villain activates a mysterious device and teleports away during a fight. Also, since this is a Numenera game, I give out my players some experience for the GM intrusion and out of some guilt.

How do I manage players expectations without discouraging them from finding creative solutions to problems presented during the game?