## What are the logical steps taken to perform ssh key authentication?

I understand the logical steps of asymmetric key cryptography as it relates to TLS, however, I’ve started using Git and in a bid to avoid having to use a password for authentication, I’ve set up ssh keys for passwordless authentication. I understand that these ssh keys are complements of each other but I do not understand how the actual authentication is taking place. I’ve copied the public key to Git and stored the private key locally. As such, I am able to do what I set out to do (passwordless authentication) but I do not know the underlying steps as to why the authentication is successful. I’ve tried searching the web but every answer I’ve found thus far has been too high level in that they did not specify the steps. For example, were I looking for the TLS steps, I’d expect something along the lines of: Check cert of https page (server) – Grab public key and encrypt secret with it – Securely send secret to server which should be the only entity with the corresponding private key to decrypt – Server and client now switch over to encrypted communications using the, now, shared secret.

## Steps to take to ensure Android security? [closed]

I am aware that I should keep android up to date and have an anti virus like MalwareBytes. I also use VPN for connections. What other steps should I take to secure my android phone?

In addition, how can I check which apps are transmitting data?

(I also scan apps using the Play Protect).

## Is $nHALT$ undecidable even if $M$ halts on input $w$ in finite steps

If we have the language

$$nHALT=\{;$$ $$M$$ halts on input $$w$$ in less than $$n$$ steps$$\}$$

Is this language also undecidable in the same way that $$HALT$$ is undecidable? And if so, $$nHALT\notin P$$, right?

## How to proof that Turing machine that can move right only a limit number of steps is not equal to normal Turing machine

I need to prove that a Turing machine that can move only k steps on the tape after the last latter of the input word is not equal to a normal Turning machine.

My idea is that given a finite input with a finite alphabet the limited machine can write only a finite number of “outputs” on the tape while a normal Turing machine has infinite tape so it can write infinite “outputs” but I have no idea how to make it a formal proof.

any help will be appreciated.

## Probabilistic Turing machine – Probability that the head has moved k steps to the right on the work tape

I have a PTM with following transition:

$$\delta(Z_0, \square , 0) = \delta(Z_0, \square , L, R)$$,

$$\delta(Z_0, \square , 1) = \delta(Z_0, \square , R, R)$$

Suppose that this PTM executes n steps. What is the probability that the head has moved k steps to the right on the work tape (in total, i.e., k is the difference between moves to the right and moves to the left) ?

## 4 Steps to Reach Your Goals Achieve Success FASTER Emotional Speech

4 Steps to Reach Your Goals Achieve Success FASTER Emotional Speech Set goals. Setting goals and putting them in a plan is important for achieving them, as there are some basics to follow when setting goals, including: Clearly define the goal, which is what needs to be achieved, and be measurable, in addition to its realism in order to challenge the person himself, while avoiding setting impossible goals to avoid frustration and failure, and a time limit must be set to achieve them. Setting…

4 Steps to Reach Your Goals Achieve Success FASTER Emotional Speech

## Minimum steps to sort array

Consider you have a permutation of $$1$$ to $$n$$ in an array $$array$$. Now select three distinct indices $$i$$,$$j$$,$$k$$, there is no need to be sorted. Let $$array_i$$, $$array_j$$ and $$array_k$$ be the values at those indices and now you make a right shift to it, that is $$new$$ $$array_i$$= $$old$$ $$array_j$$ and $$new$$ $$array_j$$= $$old$$ $$array_k$$ and $$new$$ $$array_k$$=$$old$$ $$array_i$$. Find the minimum number of operations required to sort the array or if is impossible how to determine it.

Example : Consider $$array= [3,1,2]$$; consider indices $$(1,3,2)$$ in the given order after applying one operation it is $$s =[1,3,2]$$.

## Number of m length walks from a vertice with steps in [1, s]

The problem is stated as the following:

We are given a grid graph $$G$$ of $$N \times N$$, represented by a series of strings that describe vertices s.t.

• $$L$$ is the vertice we’re interested in
• $$P$$ are vertices that are unavailable
• $$.$$ are vertices that are available

e.g.:

....  ...L  ..P.  P... 

Would mean a graph that looks like this

   0    1    2    3  +-------------------+ 0|    |    |    |    |  |    |    |    |    |  +-------------------+ 1|    |    |    |    |  |    |    |    |    |  +-------------------+ 2|    |    |XXXX|    |  |    |    |XXXX|    |  +-------------------+ 3|XXXX|    |    |    |  |XXXX|    |    |    |  +-------------------+ 

Where $$v_{2,3}$$ and $$v_{0,3}$$ are unavailable and we’re interested in $$v_{3,1}$$.

From each vertice we’re only allowed to move on the axis (we can’t move on the diagonal) and a move is valid from $$v_{x,y}$$ to $$v_{q,p}$$ if

• $$|x-q| + |y-p| \leq s$$ and $$v_{q,p}$$ is available.
• Staying in the same spot is also a valid move

Given $$m$$ – maximal number of moves and $$s$$ what is the number of ways we can make $$m$$ moves from vertice designated by $$L$$.

My attempt was to

• First compute the neighbors reachable from each node. Create a look s.t. $$\forall v N[v]$$ is the list of reachable nodes from $$v$$
• Then build a starting record $$M_0$$ s.t. if node is reachable $$M[i][j] = 1$$ and $$0$$ otherwise.
• Then for each step calculate for $$\forall i,j \in N$$ (all the grid) $$M_{i}[i][j] = \sum_{v\in N[v]} M_{i-1}[v_i][v_j]$$ (where $$v_i, v_j$$ are the coordinates of $$v$$ on the grid) and store in a matrix $$M_i$$

We iterate until $$i==m$$.

1. for each $$v_{i,j}$$: 1. for each neighbor $$n$$ of $$v_{i,j}$$: 1. $$M[i][j] += M'[n_i][n_j]$$

Unfortunately this doesn’t work (tried to do it with a pen and paper as well to make sure) and I get fewer results then the expected answer, apparently there should be 385 ways but I only get to 187.

Here are the intermediate states for the above mentioned board:

----------------------------    5   6   5   5     5   7   6   6     4   6   0   5     0   5   4   5   ----------------------------   25  34  27  27    27  41  33  34    20  33   0  27     0  27  20  25   ----------------------------  133 187 146 149   146 229 182 187   105 182   0 146     0 146 105 133   ---------------------------- 

This did work for e.g. m=2 and s=1 for the following board:

   0   1   2  +---+---+---+ 0|   |   |   |  |   |   |   |  +-----------+ 1|   |   |   |  |   |   |   |  +-----------+ 2|   |   |   |  |   |   |   |  +---+---+---+ 

Here’s my reference code (findWalks is the main function)

using namespace std; using Cord = std::pair<size_t, size_t>;  auto hash_pair = [](const Cord& c) {     return std::hash<size_t>{}(c.first) ^ (std::hash<size_t>{}(c.second) << 1); };  using NeighborsMap = unordered_map<Cord, vector<Cord>, decltype(hash_pair)>;   inline vector<vector<int>> initBoard(size_t n) {     return vector<vector<int>>(n, vector<int>(n, 0)); }   Cord findPOI(vector<string>& board) {     for (size_t i=0; i < board.size(); i++) {         for (size_t j=0; j < board.size(); j++) {             if (board[i][j] == 'L')             {                 return make_pair(i, j);             }         }     }     return make_pair(-1, -1); }   NeighborsMap BuildNeighbors(const vector<string>& board, size_t s) {     NeighborsMap neighbors(board.size() * board.size(), hash_pair);      for (size_t i = 0; i < board.size(); i++)     {         for (size_t j = 0; j < board.size(); j++)         {             size_t min_i = i > s ? i - s : 0;             size_t max_i = i + s > board.size() - 1 ? board.size() - 1 : i + s;             size_t min_j = j > s ? j - s : 0;             size_t max_j = j + s > board.size() - 1 ? board.size() - 1 : j + s;              auto key = make_pair(i, j);               if (board[i][j] != 'P')             {                 for (size_t x = min_i; x <= max_i; x++)                 {                     if (board[x][j] != 'P' && x != i)                     {                         neighbors[key].push_back(make_pair(x, j));                     }                 }                  for (size_t y = min_j; y <= max_j; y++)                 {                     if (board[i][y] != 'P' && y != j)                     {                         neighbors[key].push_back(make_pair(i, y));                     }                 }                 neighbors[key].push_back(key);             }             else             {                 neighbors[key].clear();             }         }     }      return neighbors; }  int GetNeighboursWalks(const Cord& cord, NeighborsMap& neighbors, const vector<vector<int>>& prevBoard) {     int sum{ 0 };     const auto& currentNeighbors = neighbors[cord];     for (const auto& neighbor : currentNeighbors)     {         sum += prevBoard[neighbor.first][neighbor.second];     }     return sum; }   int findWalks(int m, int s, vector<string> board) {     vector<vector<int>> currentBoard = initBoard(board.size());     vector<vector<int>> prevBoard = initBoard(board.size());     std::unordered_map<int, std::vector<Cord>> progress;      auto poi = findPOI(board);     NeighborsMap neighbors = BuildNeighbors(board, s);     for (const auto& item : neighbors)     {         const auto& key = item.first;         const auto& value = item.second;         prevBoard[key.first][key.second] = value.size();     }      for (size_t k = 1; k <= static_cast<size_t>(m); k++)     {         for (size_t i = 0; i < board.size(); i++)         {             for (size_t j = 0; j < board.size(); j++)             {                 auto currentKey = make_pair(i, j);                 currentBoard[i][j] = board[i][j] != 'P' ? GetNeighboursWalks(currentKey, neighbors, prevBoard) : 0;             }         }          std::swap(currentBoard, prevBoard);     }     return prevBoard[poi.first][poi.second]; } 

## CFG to CNF, but stuck on the last few steps

I recently learned about the conversion, but I seem to be stuck.

I need to convert the following CFG to CNF:

$$S → XY$$

$$X → abb|aXb|e$$

$$Y → c|cY$$

1. There is no S on the right side, so I did not need to add another
2. I removed the null productions $$X → e$$

$$S→XY|Y$$

$$X→abb|aXb|ab|$$

$$Y→c|cY|$$

1. I removed unit production $$S→Y$$ $$Y→c$$ with $$S→c$$

2. There are no production rules which have more than 2 variables

3. Here, I struggle. I am not allowed to have a terminal symbol and a variable together, but I am not sure how to get rid of these.

New grammar after step 4:

$$S→XY|c$$

$$X→abb|aXb|ab$$

$$Y→ZY$$

$$Z→c$$

I managed to replace the symbol c with Z, and added the new rule, so that seems fixed. However, I am unsure what do do with $$aXb$$.

Is this okay so far? if yes, what step should i take next?

## Setting different steps for Y-Axes of ListPlot

I am trying to set the scaling interval of my Y-Axes different than Mathematica automatically does. So in steps of 1000 instead of 2000 (see picture)

At the moment I determined following PlotRange:

PlotRange -> {{1, 10}, {0, 8000}} 

Is there a simple option?

To get an overview over the command:

ListPlot [   MapThread[    If[Or[#1[[1]] === 3., #1[[1]] === 8.],       Callout[Tooltip[#1, #2], #2], Tooltip[#1, #2]] &, Annotated2],    FrameLabel -> {"Happiness Score",      "Education Expenditure (per capita)"}, Frame -> True,    GridLines -> Automatic, LabelStyle -> {GrayLevel[0]},    PlotRange -> {{1, 10}, {0, 8000}}] // Framed