Datasets:
Elfsong
/
Venus_CCG

Dataset card Data Studio Files
xet
 Community
1
id
int64
1
3.58k
problem_description
stringlengths
516
21.8k
instruction
int64
0
3
solution_c
dict
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n int rows=grid.size();\n int cols=grid[0].size();\n\n vector<vector<int>> ans;\n\n vector<int> rowsum1;\n vector<int> rowsum0;\n vector<int> colsum1;\n vector<int> colsum0;\n\n for(int i=0;i<rows;i++)\n {\n int row1=0,row0=0;\n for(int j=0;j<cols;j++)\n {\n if(grid[i][j]==0)\n row0++;\n else\n row1++;\n }\n rowsum1.push_back(row1);\n rowsum0.push_back(row0);\n }\n\n for(int i=0;i<cols;i++)\n {\n int col1=0,col0=0;\n for(int j=0;j<rows;j++)\n {\n if(grid[j][i]==0)\n col0++;\n else\n col1++;\n }\n colsum1.push_back(col1);\n colsum0.push_back(col0);\n }\n\n\n for(int i=0;i<rows;i++)\n {\n ans.push_back({});\n for(int j=0;j<cols;j++)\n {\n int val=rowsum1[i]+colsum1[j]-rowsum0[i]-colsum0[j];\n ans[i].push_back(val);\n }\n }\n\n return ans;\n }\n};", "memory": "137765" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n int n=grid.size();\n int m=grid[0].size();\n vector<vector<pair<int,int>>>sum(n,vector<pair<int,int>>(m));\n for(int i=0;i<n;i++){\n int s=0;\n for(int j=0;j<m;j++){\n s+=grid[i][j];\n }\n for(int j=0;j<m;j++){\n sum[i][j].first=s;\n }\n }\n for(int i=0;i<m;i++){\n int s=0;\n for(int j=0;j<n;j++){\n s+=grid[j][i];\n }\n for(int j=0;j<n;j++){\n sum[j][i].second=s;\n }\n }\n vector<vector<int>>diff(n,vector<int>(m));\n for(int i=0;i<n;i++){\n for(int j=0;j<m;j++){\n diff[i][j]=sum[i][j].first+sum[i][j].second-(n+m-(sum[i][j].first+sum[i][j].second));\n // cout<<sum[i][j].first<<\" \"<<sum[i][j].second<<\" : \";\n }\n // cout<<endl;\n }\n return diff;\n \n }\n};", "memory": "138346" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) \n {\n int row = grid.size();\n int cols = grid[0].size();\n \n vector<int> onesRow(row , 0);\n vector<int> onesCol(cols , 0);\n vector<vector<int>> ans;\n \n for(int i = 0 ; i < row ; i++)\n {\n for(int j = 0 ; j < cols ; j++)\n {\n if(grid[i][j] == 1)\n {\n onesRow[i]++;\n onesCol[j]++;\n }\n }\n }\n \n for(int i = 0 ; i < row ; i++)\n {\n vector<int> temp;\n for(int j = 0 ; j < cols ; j++)\n {\n int zerosRow = row - onesRow[i];\n int zerosCol = cols - onesCol[j];\n int val = onesRow[i] + onesCol[j] - zerosRow - zerosCol;\n temp.push_back(val);\n }\n ans.push_back(temp);\n }\n \n return ans;\n }\n};", "memory": "141834" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n vector<int> rz(grid.size(),0);\n vector<int> cz(grid[0].size(),0);\n vector<int> r1(grid.size(),0);\n vector<int> c1(grid[0].size(),0);\n for(int i=0;i<grid.size();i++)\n {\n for(int j=0;j<grid[i].size();j++)\n {\n if(grid[i][j]==0)\n {\n rz[i]++;\n cz[j]++;\n }\n else if(grid[i][j]==1)\n {\n r1[i]++;\n c1[j]++;\n }\n }\n }\n vector<vector<int>> dp;\n for(int i=0;i<grid.size();i++)\n {\n vector<int> temp;\n for(int j=0;j<grid[i].size();j++)\n temp.push_back(r1[i]+c1[j]-rz[i]-cz[j]);\n dp.push_back(temp);\n }\n return dp;\n }\n};", "memory": "142415" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n vector<vector<int>> diff;\n vector<int>diff1;\n vector<int> diff2;\n int onesRow,onesCol,zerosRow,zerosCol;\n onesRow=onesCol=zerosRow=zerosCol=0;\n for(int r=0;r<grid.size();++r){\n for(int c1=0;c1<grid[0].size();++c1){\n if(grid[r][c1]==0){\n ++zerosRow;\n }\n else{\n ++onesRow;\n }\n }\n diff1.push_back(onesRow-zerosRow);\n onesRow=zerosRow=0;\n }\n for(int c=0;c<grid[0].size();++c){\n for(int r1=0;r1<grid.size();++r1){\n if(grid[r1][c]==0){\n ++zerosCol;\n }\n else{\n ++onesCol;\n }\n }\n diff2.push_back(onesCol-zerosCol);\n onesCol=zerosCol=0;\n }\n for(int r=0;r<grid.size();++r){\n vector<int> diffi;\n for(int c=0;c<grid[0].size();++c){\n diffi.push_back(diff1[r]+diff2[c]);\n }\n diff.push_back(diffi);\n }\n return diff;\n }\n};", "memory": "142996" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n vector<vector<int>> arr;\n vector<int> row;\n vector<int> col;\n\n for(int i=0;i<grid.size();i++){\n int oner=0,zeror=0;\n // int zeror=0,zeroc=0;\n for(int j=0;j<grid[i].size();j++){\n if(grid[i][j]==1)\n oner++;\n else if(grid[i][j]==0)\n zeror++;\n // if(grid[j][i]==0)\n // zeroc++;\n // else if(grid[j][i]==1)\n // onec++;\n }\n oner=oner-zeror;\n row.push_back(oner);\n // onec=onec-zeroc;\n // col.push_back(onec);\n }\n for(int i=0;i<grid[0].size();i++){\n int onec=0,zeroc=0;\n for(int j=0;j<grid.size();j++){\n if(grid[j][i]==0)\n zeroc++;\n else if(grid[j][i]==1)\n onec++;\n }\n onec=onec-zeroc;\n col.push_back(onec);\n }\n for(int i=0;i<grid.size();i++){\n vector<int> ans;\n for(int j=0;j<grid[0].size();j++){\n ans.push_back(row[i]+col[j]);\n }\n arr.push_back(ans);\n }\n return arr;\n }\n};", "memory": "143578" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n vector<vector<int>> arr;\n vector<int> row;\n vector<int> col;\n\n for(int i=0;i<grid.size();i++){\n int oner=0,zeror=0;\n // int zeror=0,zeroc=0;\n for(int j=0;j<grid[i].size();j++){\n if(grid[i][j]==1)\n oner++;\n else if(grid[i][j]==0)\n zeror++;\n }\n oner=oner-zeror;\n row.push_back(oner);\n }\n for(int i=0;i<grid[0].size();i++){\n int onec=0,zeroc=0;\n for(int j=0;j<grid.size();j++){\n if(grid[j][i]==0)\n zeroc++;\n else if(grid[j][i]==1)\n onec++;\n }\n onec=onec-zeroc;\n col.push_back(onec);\n }\n for(int i=0;i<grid.size();i++){\n vector<int> ans;\n for(int j=0;j<grid[0].size();j++)\n ans.push_back(row[i]+col[j]);\n arr.push_back(ans);\n }\n return arr;\n }\n};", "memory": "143578" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) \n {\n vector<vector<int>> ans;\n vector<int> r,c;\n for(int i=0;i<grid.size();i++)\n {\n int s=0;\n for(int j=0;j<grid[0].size();j++)\n {\n s+=grid[i][j];\n if(grid[i][j]==0)\n s--;\n }\n r.push_back(s);\n }\n for(int i=0;i<grid[0].size();i++)\n {\n int s=0;\n for(int j=0;j<grid.size();j++)\n {\n s+=grid[j][i];\n if(grid[j][i]==0)\n s--;\n }\n c.push_back(s);\n }\n for(int i=0;i<grid.size();i++)\n {\n vector<int> g;\n for(int j=0;j<grid[0].size();j++)\n {\n g.push_back(r[i]+c[j]);\n }\n ans.push_back(g);\n }\n return ans;\n }\n};", "memory": "144159" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n\n int row_cnt = grid.size();\n int col_cnt = grid[0].size();\n\n // Initialize num_ones_zeros_at_row and num_ones_zeros_at_col with [0, 0]\n vector<vector<int>> num_ones_zeros_at_row(row_cnt, vector<int>(2, 0));\n vector<vector<int>> num_ones_zeros_at_col(col_cnt, vector<int>(2, 0));\n\n // First loop: calculate number of ones and zeros per row and column\n for (int r = 0; r < row_cnt; ++r) {\n for (int c = 0; c < col_cnt; ++c) {\n if (grid[r][c] == 0) {\n num_ones_zeros_at_row[r][0] += 1;\n num_ones_zeros_at_col[c][0] += 1;\n } else {\n num_ones_zeros_at_row[r][1] += 1;\n num_ones_zeros_at_col[c][1] += 1;\n }\n }\n }\n\n // Second loop: update the grid based on the calculated sums\n for (int r = 0; r < row_cnt; ++r) {\n for (int c = 0; c < col_cnt; ++c) {\n int ones_sum = num_ones_zeros_at_row[r][1] + num_ones_zeros_at_col[c][1];\n int zeros_sum = num_ones_zeros_at_row[r][0] + num_ones_zeros_at_col[c][0];\n grid[r][c] = ones_sum - zeros_sum;\n }\n }\n\n return grid;\n }\n};", "memory": "144740" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n int n = grid.size();\n int m = grid[0].size();\n vector<vector<int>> row(n, vector<int>(2, 0));\n vector<vector<int>> col(m, vector<int>(2, 0));\n vector<vector<int>> res(n, vector<int>(m));\n\n for(int i = 0; i < n; i++){\n for(int j = 0; j < m; j++){\n if(grid[i][j] == 0){\n row[i][0]++;\n col[j][0]++;\n }else{\n row[i][1]++;\n col[j][1]++;\n }\n }\n }\n\n for(int i = 0; i < n; i++){\n for(int j = 0; j < m; j++){\n res[i][j] = row[i][1] + col[j][1] - row[i][0] - col[j][0];\n }\n }\n\n return res;\n }\n};", "memory": "145321" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n int n = grid.size();\n int m = grid[0].size();\n vector<vector<int>> row(n, vector<int>(2, 0));\n vector<vector<int>> col(m, vector<int>(2, 0));\n vector<vector<int>> res(n, vector<int>(m));\n\n for(int i = 0; i < n; i++){\n for(int j = 0; j < m; j++){\n if(grid[i][j] == 0){\n row[i][0]++;\n col[j][0]++;\n }else{\n row[i][1]++;\n col[j][1]++;\n }\n }\n }\n\n for(int i = 0; i < n; i++){\n for(int j = 0; j < m; j++){\n res[i][j] = row[i][1] + col[j][1] - row[i][0] - col[j][0];\n }\n }\n\n return res;\n }\n};", "memory": "145321" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n int n = grid.size();\n int m = grid[0].size();\n vector<vector<int>> row(n, vector<int>(2, 0));\n vector<vector<int>> col(m, vector<int>(2, 0));\n vector<vector<int>> res(n, vector<int>(m));\n\n for(int i = 0; i < n; i++){\n for(int j = 0; j < m; j++){\n if(grid[i][j] == 0){\n row[i][0]++;\n col[j][0]++;\n }else{\n row[i][1]++;\n col[j][1]++;\n }\n }\n }\n\n for(int i = 0; i < n; i++){\n for(int j = 0; j < m; j++){\n res[i][j] = row[i][1] + col[j][1] - row[i][0] - col[j][0];\n }\n }\n\n return res;\n }\n};", "memory": "145903" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n unordered_map<int,int> countOneRows;\n unordered_map<int,int> countOneCol; \nvoid countOnesRow(vector<vector<int>>& grid,int i,int m){\n int count=0;\n for(int j=0;j<m;j++){\n if(grid[i][j]==1){\n count++;\n }\n }\n countOneRows[i]=count;\n \n\n}\nvoid countOnesCol(vector<vector<int>>& grid,int i,int n){\n int count=0;\n for(int j=0;j<n;j++){\n if(grid[j][i]==1){\n count++;\n }\n }\n countOneCol[i]=count;\n \n\n}\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n /// here we take two map one for column and one for row \n \n /// now traverse each rows \n int n=grid.size();\n int m=grid[0].size();\n for(int i=0;i<n;i++){\n \n countOnesRow(grid,i,m);\n \n }\n // count ones in Rows \n for(int i=0;i<m;i++){\n \n countOnesCol(grid,i,n);\n \n }\n /// now we traverse to get an answer\n //vector<vector<int>> result(n,vector<int>(m,0));\n for(int i=0;i<n;i++){\n \n for(int j=0;j<m;j++){\n\n grid[i][j]=((countOneRows[i]+countOneCol[j])-((m-countOneRows[i])+(n-countOneCol[j])));\n\n }\n }\n return grid;\n \n }\n};", "memory": "146484" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n int n = grid.size();\n int m = grid[0].size();\n unordered_map<int,int> row_ones;\n unordered_map<int,int> col_ones;\n for(int i=0;i<n;i++){\n int count = 0;\n for(int j=0;j<m;j++){\n if(grid[i][j] == 1) count++;\n }\n row_ones[i] = count;\n }\n for(int j=0;j<m;j++){\n int count = 0;\n for(int i=0;i<n;i++){\n if(grid[i][j] == 1) count++;\n }\n col_ones[j] = count;\n }\n for(int i=0;i<n;i++){\n for(int j=0;j<m;j++){\n grid[i][j] = 2*row_ones[i] + 2*col_ones[j] - (n+m);\n }\n }\n return grid;\n }\n};", "memory": "147065" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n int n=grid.size(),m=grid[0].size();\n unordered_map<int,int>r;\n unordered_map<int,int>c;\n for(int i=0;i<n;i++){\n for(int j=0;j<m;j++){\n if(grid[i][j]==1){\n r[i]++;\n c[j]++;\n }\n }\n }\n for(int i=0;i<n;i++){\n for(int j=0;j<m;j++){\n grid[i][j]=r[i]+c[j]-(n-r[i])-(m-c[j]);\n }\n }\n return grid;\n }\n};", "memory": "147646" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n vector<pair<int,int>>row;\n vector<pair<int,int>>col;\n int r=grid.size();\n int c=grid[0].size();\n for(int i=0;i<r;i++){\n int row_one=0;\n int row_zero=0;\n for(int j=0;j<c;j++){\n if(grid[i][j]==0){\n row_zero++;\n }\n else{\n row_one++;\n }\n }\n row.push_back({row_one,row_zero});\n\n }\n\n for(int i=0;i<c;i++){\n int col_one=0;\n int col_zero=0;\n for(int j=0;j<r;j++){\n if(grid[j][i]==0){\n col_zero++;\n }\n else{\n col_one++;\n }\n }\n col.push_back({col_one,col_zero});\n }\n\n vector<vector<int>>diff;\n for(int i=0;i<row.size();i++){\n vector<int>temp;\n for(int j=0;j<col.size();j++){\n int tt=(row[i].first+col[j].first)-(row[i].second+col[j].second);\n temp.push_back(tt);\n }\n diff.push_back(temp);\n }\n\n return diff;\n }\n};", "memory": "148228" }
2,606
<p>You are given a <strong>0-indexed</strong> <code>m x n</code> binary matrix <code>grid</code>.</p> <p>A <strong>0-indexed</strong> <code>m x n</code> difference matrix <code>diff</code> is created with the following procedure:</p> <ul> <li>Let the number of ones in the <code>i<sup>th</sup></code> row be <code>onesRow<sub>i</sub></code>.</li> <li>Let the number of ones in the <code>j<sup>th</sup></code> column be <code>onesCol<sub>j</sub></code>.</li> <li>Let the number of zeros in the <code>i<sup>th</sup></code> row be <code>zerosRow<sub>i</sub></code>.</li> <li>Let the number of zeros in the <code>j<sup>th</sup></code> column be <code>zerosCol<sub>j</sub></code>.</li> <li><code>diff[i][j] = onesRow<sub>i</sub> + onesCol<sub>j</sub> - zerosRow<sub>i</sub> - zerosCol<sub>j</sub></code></li> </ul> <p>Return <em>the difference matrix </em><code>diff</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171729-5.png" style="width: 400px; height: 208px;" /> <pre> <strong>Input:</strong> grid = [[0,1,1],[1,0,1],[0,0,1]] <strong>Output:</strong> [[0,0,4],[0,0,4],[-2,-2,2]] <strong>Explanation:</strong> - diff[0][0] = <code>onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][1] = <code>onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[0][2] = <code>onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[1][0] = <code>onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][1] = <code>onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub></code> = 2 + 1 - 1 - 2 = 0 - diff[1][2] = <code>onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub></code> = 2 + 3 - 1 - 0 = 4 - diff[2][0] = <code>onesRow<sub>2</sub> + onesCol<sub>0</sub> - zerosRow<sub>2</sub> - zerosCol<sub>0</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][1] = <code>onesRow<sub>2</sub> + onesCol<sub>1</sub> - zerosRow<sub>2</sub> - zerosCol<sub>1</sub></code> = 1 + 1 - 2 - 2 = -2 - diff[2][2] = <code>onesRow<sub>2</sub> + onesCol<sub>2</sub> - zerosRow<sub>2</sub> - zerosCol<sub>2</sub></code> = 1 + 3 - 2 - 0 = 2 </pre> <p><strong class="example">Example 2:</strong></p> <img src="https://assets.leetcode.com/uploads/2022/11/06/image-20221106171747-6.png" style="width: 358px; height: 150px;" /> <pre> <strong>Input:</strong> grid = [[1,1,1],[1,1,1]] <strong>Output:</strong> [[5,5,5],[5,5,5]] <strong>Explanation:</strong> - diff[0][0] = onesRow<sub>0</sub> + onesCol<sub>0</sub> - zerosRow<sub>0</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][1] = onesRow<sub>0</sub> + onesCol<sub>1</sub> - zerosRow<sub>0</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[0][2] = onesRow<sub>0</sub> + onesCol<sub>2</sub> - zerosRow<sub>0</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][0] = onesRow<sub>1</sub> + onesCol<sub>0</sub> - zerosRow<sub>1</sub> - zerosCol<sub>0</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][1] = onesRow<sub>1</sub> + onesCol<sub>1</sub> - zerosRow<sub>1</sub> - zerosCol<sub>1</sub> = 3 + 2 - 0 - 0 = 5 - diff[1][2] = onesRow<sub>1</sub> + onesCol<sub>2</sub> - zerosRow<sub>1</sub> - zerosCol<sub>2</sub> = 3 + 2 - 0 - 0 = 5 </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>m == grid.length</code></li> <li><code>n == grid[i].length</code></li> <li><code>1 &lt;= m, n &lt;= 10<sup>5</sup></code></li> <li><code>1 &lt;= m * n &lt;= 10<sup>5</sup></code></li> <li><code>grid[i][j]</code> is either <code>0</code> or <code>1</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n vector<vector<int>> onesMinusZeros(vector<vector<int>>& grid) {\n int row = grid.size();\n int col = grid[0].size();\n unordered_map<int, int> ans;\n unordered_map<int,int>column;\n for (int i = 0; i < row; i++) {\n int sum = 0;\n for (int j = 0 ; j < col ; j++) {\n sum += grid[i][j];\n column[j] += grid[i][j];\n }\n ans[i] = sum;\n }\n vector<vector<int>> res(row, vector<int>(col));\n for (int i = 0; i < row; i++) {\n for (int j = 0; j < col; j++) {\n res[i][j] =\n ans[i] + column[j] - (row - ans[i]) - (col - column[j]);\n }\n }\n return res;\n }\n};", "memory": "148809" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string& str) {\n int co = 0;\n for(int i=0;i<str.size();++i)\n co+=str[i]=='Y';\n\n int mn = INT_MAX, cur = 0, ind = -1;\n for(int i=0;i<=str.size();++i)\n {\n if(mn>co+cur)\n mn = co+cur, ind=i;\n\n if(i==str.size())\n return ind;\n \n cur += str[i]=='N';\n co -= str[i]=='Y';\n }\n return -1;\n }\n};", "memory": "11000" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(const string &c) {\n cin.tie(0); ios::sync_with_stdio(0);\n\n int penalty = 0;\n int minPenalty = penalty;\n int j = 0;\n\n for (int i=1; i<=c.size(); ++i)\n {\n if (c[i-1] == 'Y')\n penalty--;\n else\n penalty++;\n\n if (penalty < minPenalty)\n {\n minPenalty = penalty;\n j = i;\n }\n }\n return j;\n }\n};\n// class Solution {\n// public:\n// int bestClosingTime(string customers) {\n// cin.tie(0); ios::sync_with_stdio(0);\n// int n=customers.size();\n// int pre[n+1],suff[n+1];\n// pre[0]=0;\n// suff[n]=0;\n// for(int i=1; i<=n; i++){\n// pre[i]=pre[i-1]+((customers[i-1]=='Y')?0:1);\n \n// suff[n-i]=suff[n-i+1]+((customers[n-i]=='N')?0:1);}\n\n// int ni=n;\n// int idx=0;\n// for(int i=0; i<=n; i++)\n// {\n// pre[i]+=suff[i];\n// if(ni>pre[i]){\n// idx=i;\n// ni=pre[i];\n// }\n\n// }\n \n// return idx;\n// }\n// };", "memory": "11100" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(const string &c) {\n cin.tie(0); ios::sync_with_stdio(0);\n\n int penalty = 0;\n int minPenalty = penalty;\n int j = 0;\n\n for (int i=1; i<=c.size(); ++i)\n {\n if (c[i-1] == 'Y')\n penalty--;\n else\n penalty++;\n\n if (penalty < minPenalty)\n {\n minPenalty = penalty;\n j = i;\n }\n }\n return j;\n }\n};", "memory": "11200" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int Ncount=0;\n int Ncount2=0;\n int Ycount=0;\n for(int i=0;i<customers.size();i++){\n if(customers[i]=='Y') Ycount++;\n }\n int minpen=Ycount;\n int index=0;\n for(int i=0;i<customers.size();i++){\n if(customers[i]=='Y') Ycount--;\n else Ncount2++;\n if(Ycount+Ncount<minpen) {\n minpen= Ycount+Ncount;\n index=i+1;\n }\n Ncount=Ncount2;\n }\n return index;\n }\n};", "memory": "11800" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n\n // if close at j, penalty would be\n // 1) number of Y after j +\n // 2) number of N before j\n\n int numN = 0;\n /*\n for (int i=0;i<customers.size();i++) {\n if (customers[i] == 'N') numN++;\n }\n */\n int numY = 0; // N = customers.size() - numY;\n int minP = 0;\n int ans = customers.size();\n for (int i=customers.size() - 1;i >= 0;i--) {\n if (customers[i] == 'Y') {\n numY++;\n } else {\n numN--;\n }\n // cout << numY << \" \" << numN << endl;\n if (minP >= numN + numY) {\n minP = numN + numY;\n ans = i;\n }\n }\n return ans;\n }\n};", "memory": "11900" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int total = 0;\n // first calculate total penalty if shop closes at 0th hour\n for(int i=0; i<customers.length(); i++){\n if(customers[i] == 'Y')\n total++;\n }\n int res = total, ans = 0;\n // Then for each hour, check if customers come or not\n // If we close the shop at that hour and check if penalty is minimum\n for(int i=0; i<customers.length(); i++){\n if(customers[i] == 'Y')\n total -= 1;\n else\n total += 1;\n if(res > total){\n ans = i+1;\n res = total;\n }\n }\n return ans;\n }\n};", "memory": "12000" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n auto penalty = 0;\n for(const auto &c : customers)\n if(c == 'Y')\n ++ penalty;\n \n auto minPenalty = penalty;\n auto earliest = 0;\n for(auto i = 0; i < customers.size(); ++ i)\n {\n if(customers[i] == 'Y')\n -- penalty;\n else\n ++ penalty;\n\n if(penalty < minPenalty)\n {\n minPenalty = penalty;\n earliest = i + 1;\n }\n }\n\n return earliest;\n }\n};", "memory": "12100" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n=customers.size();\n\n int penalty=count(begin(customers),end(customers),'Y');\n int minpenalty=penalty;\n int minhour=0;\n\n for(int i=0;i<n;i++){\n if(customers[i]=='Y'){\n penalty--;\n }else{\n penalty++;\n }\n\n if(penalty<minpenalty){\n minpenalty=penalty;\n minhour=i+1;\n }\n }\n\n return minhour; \n }\n};", "memory": "12200" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.size();\n int ans = n, sum = 0, ma = 0;\n\n for(int i = n-1; i>=0; i--){\n sum += customers[i] == 'N'? 1:-1;\n if(sum>=ma){\n ma = sum;\n ans = i;\n }\n \n }\n\n return ans;\n \n }\n};", "memory": "12300" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n=customers.size();\n int pre[n+1];\n int c=0;\n for(int i=0;i<n;i++){\n if(customers[i]=='N') c++;\n }\n pre[n]=c;\n for(int i=n-1;i>=0;i--){\n if(customers[i]=='N') pre[i]=pre[i+1]-1;\n if(customers[i]=='Y') pre[i]=pre[i+1]+1;\n }\n int min=pre[0];\n for(int i=1;i<=n;i++){\n if(min>pre[i]) min=pre[i];\n }\n for(int i=0;i<=n;i++){\n if(pre[i]==min) return i;\n }\n return -1;\n }\n};", "memory": "12400" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n=customers.size();\n int pre[n+1];\n int c=0;\n for(int i=0;i<n;i++){\n if(customers[i]=='N') c++;\n }\n pre[n]=c;\n for(int i=n-1;i>=0;i--){\n if(customers[i]=='N') pre[i]=pre[i+1]-1;\n if(customers[i]=='Y') pre[i]=pre[i+1]+1;\n }\n int min=pre[0];\n for(int i=1;i<=n;i++){\n if(min>pre[i]) min=pre[i];\n }\n for(int i=0;i<=n;i++){\n if(pre[i]==min) return i;\n }\n return -1;\n }\n};", "memory": "12500" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int count=0;\n int n=customers.size();\n for(int i=0;i<n;i++) if(customers[i]=='Y') count++;\n int arr[n+1];\n arr[0]=count;\n for(int i=0;i<n;i++){\n if(customers[i]=='Y'){\n count--;\n arr[i+1]=count;\n }\n else{\n count++;\n arr[i+1]=count;\n }\n }\n int Min=INT_MAX;\n int idx=-1;\n for(int i=0;i<n+1;i++){\n if(arr[i]<Min){\n idx=i;\n Min=arr[i];\n }\n }\n return idx;\n }\n};", "memory": "12600" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n=customers.size();\n int pre[n+1];\n int c=0;\n for(int i=0;i<n;i++){\n if(customers[i]=='N') c++;\n }\n pre[n]=c;\n for(int i=n-1;i>=0;i--){\n if(customers[i]=='N') pre[i]=pre[i+1]-1;\n if(customers[i]=='Y') pre[i]=pre[i+1]+1;\n }\n int min=pre[0];\n for(int i=1;i<=n;i++){\n if(min>pre[i]) min=pre[i];\n }\n for(int i=0;i<=n;i++){\n if(pre[i]==min) return i;\n }\n return -1;\n }\n};", "memory": "12700" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.size();\n int pre[n+1];\n int suf[n+1];\n pre[0]= 0;\n for(int i=0;i<n;i++){\n int count =0;\n // if(customers[i]=='N')count++;\n pre[i+1]= pre[i] + ((customers[i]=='N') ? 1:0);\n }\n suf[n]=0;\n for(int i=n-1;i>=0;i--){\n suf[i]= suf[i+1] + ((customers[i]=='Y') ? 1:0);\n }\n int minp = n;\n\n for(int i=0;i<=n;i++){\n pre[i]+=suf[i];\n int penalty = pre[i];\n minp=min(minp,penalty);\n }\n for(int i=0;i<=n;i++){\n int p = pre[i];\n if(p==minp) return i;\n }\n return minp;\n }\n};", "memory": "12800" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n // at any j, no of ys from end(inclusive) + no of ns from start\n\n int n = customers.size();\n\n int suf[n+1], pre[n+1];\n\n for(int i = n-1; i>=0; i--){\n if(customers.at(i)=='Y') suf[i] = suf[i+1] + 1;\n else suf[i] = suf[i+1];\n }\n\n if(customers.at(0)=='N') pre[0] = 1;\n else pre[0] = 0;\n\n for(int i = 1; i<=n; i++){\n if(i==n) pre[i] = pre[i-1];\n else if(customers.at(i-1)=='N') pre[i] = pre[i-1] + 1;\n else pre[i] = pre[i-1];\n }\n\n int sum = INT_MAX, index = 0;\n\n for(int i = 0; i<=n; i++){\n if((pre[i]+suf[i])<sum){\n sum = pre[i] + suf[i];\n index = i;\n }\n }\n\n return index;\n\n\n }\n};", "memory": "12900" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.size();\n int pre[n+1]; // number of 'N' (no customers) before or at the kth hour\n int suf[n+1]; // number of 'Y' (customers) after and including the kth hour\n pre[0] = 0;\n \n // Calculate pre[]: the number of 'N' up to the ith hour\n for(int i=0; i<n; i++){\n pre[i+1] = pre[i] + ((customers[i]=='N') ? 1 : 0);\n }\n \n suf[n] = 0;\n // Calculate suf[]: the number of 'Y' after the ith hour\n for(int i=n-1; i>=0; i--){\n suf[i] = suf[i+1] + ((customers[i]=='Y') ? 1 : 0);\n }\n\n int minPen = n; // minimum penalty\n int bestHour = 0; // to store the best closing hour\n\n // Iterate over all hours to find the minimum penalty\n for(int i=0; i<=n; i++){\n int pen = pre[i] + suf[i]; // calculate penalty for closing at hour i\n if(pen < minPen) {\n minPen = pen;\n bestHour = i; // update the best hour when a lower penalty is found\n }\n }\n \n return bestHour; // return the earliest hour with minimum penalty\n }\n};\n\n\n// (customers[i]=='N') ? 1 : 0; this means if the condition is true the 1 add \n// kardo nhi to 0 add kardo", "memory": "13000" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.size();\n int pre[n+1]; // no of N before kth hour\n int suf[n+1]; // no of Y after and including kth hour\n pre[0] = 0;\n for(int i=0; i<n; i++){\n pre[i+1] = pre[i] + ((customers[i]=='N') ? 1 : 0);\n }\n suf[n] = 0;\n for(int i=n-1; i>=0; i--){\n suf[i] = suf[i+1] + ((customers[i]=='Y') ? 1 : 0);\n }\n int minPen = n; // minimum penalty\n for(int i=0; i<=n; i++){\n pre[i] += suf[i];\n int pen = pre[i];\n minPen = min(minPen,pen);\n }\n for(int i=0; i<=n; i++){\n int pen = pre[i];\n if(pen == minPen) return i;\n }\n return n;\n }\n};\n\n// (customers[i]=='N') ? 1 : 0; this means if the condition is true the 1 add \n// kardo nhi to 0 add kardo", "memory": "13000" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.length();\n int pre[n+1];// no. of \"N\" before kth hour\n int suf[n+1];// no. of \"Y\" after and including kth hour\n pre[0]=0;\n for(int i=0;i<n;i++){\n pre[i+1]=pre[i]+((customers[i]=='N') ? 1:0);\n }\n suf[n]=0;\n for(int i=n-1;i>=0;i--){\n suf[i]=suf[i+1]+((customers[i]=='Y') ? 1:0);\n }\n int minpen = n;\n for(int i=0;i<=n;i++){\n pre[i]+=suf[i];\n int pen = pre[i];\n minpen = min(minpen,pen);\n }\n for(int i=0;i<=n;i++){\n int pen = pre[i];\n if(pen==minpen) return i;\n }\n return n;\n }\n};", "memory": "13100" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.size();\n //arrays ka ek size extra due to closing time\n int pre[n+1]; //no of N before kth hour\n int suf[n+1]; //no of Y after kth hour and including kth hour\n pre[0] = 0; //1st element ke side me koi Y,N nahi hai...\n for(int i=0;i<n;i++){\n pre[i+1] = pre[i] + ((customers[i]=='N') ? 1 : 0) ;\n }\n suf[n] = 0; //suf ka size n hai chek kro\n for(int i=n-1;i>=0;i--){\n suf[i] = suf[i+1] + ((customers[i]=='Y') ? 1 : 0) ;\n }\n int minpen = n;// maximum penalty set krde\n //for summing up both the arrays having size of n+1\n for(int i=0;i<=n;i++){\n pre[i]+= suf[i]; //pre me hi update krde\n }\n for(int i=0;i<=n;i++){\n int pen = pre[i];\n minpen = min(minpen,pen);\n }\n for(int i=0;i<=n;i++){\n int pen =pre[i];\n if(pen==minpen) return i;\n }\n return n;\n }\n};", "memory": "13100" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int curRevenue= 0;\n int maxRevenue = curRevenue;\n int closingTime = 0;\n\n for(int i=0; i<customers.size(); i++){\n string customer = customers.substr(i, 1);\n curRevenue += customer==\"Y\" ? 1 : -1;\n if(curRevenue > maxRevenue){\n maxRevenue = curRevenue;\n closingTime = i+1;\n }\n }\n \n return closingTime;\n }\n};", "memory": "13200" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int curRevenue= 0;\n int maxRevenue = curRevenue;\n int closingTime = 0;\n\n for(int i=0; i<customers.size(); i++){\n string customer = customers.substr(i, 1);\n curRevenue += customer==\"Y\" ? 1 : -1;\n if(curRevenue > maxRevenue){\n maxRevenue = curRevenue;\n closingTime = i+1;\n }\n }\n \n return closingTime;\n }\n};", "memory": "13200" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int curPenalty = 0;\n for(int i=0; i<customers.size(); i++){\n string customer = customers.substr(i, 1);\n if(customer==\"Y\") curPenalty++;\n }\n\n int minPenalty = curPenalty;\n int closingTime = 0;\n\n for(int i=0; i<customers.size(); i++){\n string customer = customers.substr(i, 1);\n curPenalty += customer==\"Y\" ? -1 : 1;\n if(curPenalty < minPenalty){\n minPenalty = curPenalty;\n closingTime = i+1;\n }\n }\n \n return closingTime;\n }\n};", "memory": "13300" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int curPenalty = 0;\n for(int i=0; i<customers.size(); i++){\n string customer = customers.substr(i, 1);\n if(customer==\"Y\") curPenalty++;\n }\n\n int minPenalty = curPenalty;\n int closingTime = 0;\n\n for(int i=0; i<customers.size(); i++){\n string customer = customers.substr(i, 1);\n curPenalty += customer==\"Y\" ? -1 : 1;\n if(curPenalty < minPenalty){\n minPenalty = curPenalty;\n closingTime = i+1;\n }\n }\n \n return closingTime;\n }\n};", "memory": "13300" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int curRevenue= 0;\n int maxRevenue = curRevenue;\n int closingTime = 0;\n\n for(int i=0; i<customers.size(); i++){\n string customer = customers.substr(i, 1);\n curRevenue += customer==\"Y\" ? 1 : -1;\n if(curRevenue > maxRevenue){\n maxRevenue = curRevenue;\n closingTime = i+1;\n }\n }\n \n return closingTime;\n }\n};", "memory": "13400" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int curRevenue= 0;\n int maxRevenue = curRevenue;\n int closingTime = 0;\n\n for(int i=0; i<customers.size(); i++){\n string customer = customers.substr(i, 1);\n curRevenue += customer==\"Y\" ? 1 : -1;\n if(curRevenue > maxRevenue){\n maxRevenue = curRevenue;\n closingTime = i+1;\n }\n }\n \n return closingTime;\n }\n};", "memory": "13400" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.length();\n int pre[n+1];\n pre[0] = 0;\n int suf[n+1];\n suf[n] = 0;\n int final[n+1];\n for(int i = 1;i<=n;i++){\n if(customers[i-1] == 'N'){\n pre[i] = pre[i-1] + 1;\n }\n if(customers[i-1] == 'Y'){\n pre[i] = pre[i-1];\n }\n if(customers[n-i] == 'Y'){\n suf[n-i] = suf[n-i + 1] + 1; \n }\n if(customers[n-i] == 'N'){\n suf[n-i] = suf[n-i + 1]; \n }\n }\n for(int i = 0;i<n+1;i++){\n final[i] = pre[i] + suf[i];\n }\n int min = INT_MAX;\n int ans = 60;\n for(int i = 0;i<n+1;i++){\n if(final[i]<min){\n min = final[i];\n ans = i;\n }\n }\n return ans; \n }\n};", "memory": "13500" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.length();\n int pre[n+1];\n int suf[n+1];\n int final[n+1];\n pre[0]=0;\n for(int i =0;i<n;i++){\n if(customers[i]=='N'){\n pre[i+1]=pre[i]+1;\n }\n else pre[i+1] =pre[i]+ 0;\n }\n suf[n]=0;\n for(int i =n-1;i>=0;i--){\n \n if(customers[i]=='Y'){\n suf[i]=suf[i+1]+1;\n }\n else suf[i]= suf[i+1]+0;\n }\n int p=n;\n for(int i =0;i<=n;i++){\n final[i]=pre[i]+suf[i];\n if(final[i]<p) p = final[i];\n }\n for(int i =0;i<=n;i++){\n if(final[i]==p){\n return i;\n }\n }\n return n;\n }\n};", "memory": "13600" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string s) {\n int n=s.size();\n int cnty=0;\n int cntn=0;\n for(auto it:s){\n if(it=='Y') cnty++;\n else cntn++;\n }\n if(cnty==n) return n;\n if(cntn==n) return 0;\n int ln=0;\n int ly=0;\n int ry=0;\n int rn=0;\n for(int i=0;i<n;i++){\n if(s[i]=='Y') ry++;\n else rn++;\n }\n vector<int>dp(n+1);\n for(int i=0;i<=n;i++){\n if(s[i]=='Y'){\n //current is Y\n dp[i]= 1+ry+ln;\n ly+=1; \n }\n else{\n //current is N\n dp[i]= ry+ln;\n ln+=1;\n }\n if(i+1<=n){\n if(s[i+1]=='Y') ry-=1;\n else rn-=1;\n }\n }\n int mini=1e9;\n int hr=-1;\n for(int i=0;i<=n;i++){\n if(dp[i]<mini){\n mini=dp[i];\n hr=i;\n }\n }\n cout<<mini<<endl;\n \n return hr;\n }\n};", "memory": "15300" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.length();\n vector<int>pref(n+2,0);\n int tot = 0;\n for(int i=1;i<=n;i++){\n pref[i]=pref[i-1]+(customers[i-1]=='Y');\n tot += (customers[i-1]=='Y');\n }\n int ans = INT_MAX;\n int ind = -1;\n for(int i=0;i<=n;i++){\n int temp = 0;\n temp = (i-pref[i]) + (tot-pref[i]);\n if(temp < ans){\n ind = i;\n ans = temp;\n }\n }\n return ind;\n }\n};", "memory": "16100" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n=customers.size();\n vector<int> noprefix(n+1,0);\n\n for(int i=1;i<n;i++){\n if(customers[i-1]=='N')\n noprefix[i]=noprefix[i-1]+1;\n else\n noprefix[i]=noprefix[i-1];\n }\n if(customers[n-1]=='N')\n noprefix[n]=noprefix[n-1]+1;\n else\n noprefix[n]=noprefix[n-1];\n\n int mini=noprefix[n];\n\n int ans_index=n;\n int prev=0;\n for(int i=n-1;i>=0 ;i--){\n if(customers[i]=='Y')\n prev++;\n int sump=prev+noprefix[i];\n if(sump<=mini){\n mini=sump;\n ans_index=i;\n }\n }\n return ans_index;\n\n\n }\n};", "memory": "16200" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.size();\n vector<int> suff(n+1);\n suff[n] = 0;\n\n for(int i = n-1;i>=0;i--){\n suff[i] = customers[i] == 'Y' ? suff[i+1]+1 : suff[i+1];\n }\n\n int penalty = 0;\n int ans = INT_MAX;\n int ind = -1;\n for(int i = 0;i<=n;i++){\n \n int curr = penalty+suff[i];\n if(curr < ans){\n ans = curr;\n ind = i;\n }\n penalty = i < n ? penalty+(customers[i] == 'N') : penalty;\n }\n return ind;\n }\n};", "memory": "16200" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string c) {\n int n = c.size();\n vector<int> tmp(n+1);\n for(int i=n-1;i>=0;i--) tmp[i] = tmp[i+1] + (c[i] == 'Y');\n int res = -1, mn = INT_MAX, cur = 0;\n for(int i=0;i<=n;i++) {\n if(mn > cur + tmp[i]) {\n mn = cur + tmp[i];\n res = i;\n }\n if(i < n && c[i] == 'N') ++cur;\n }\n return res;\n }\n};", "memory": "16300" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
1
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.size();\n vector<int> pen(n+1,0);\n int pre = 0, post = 0;\n for(int i=0; i<=n; i++){\n pen[i] += pre;\n if(customers[i] == 'N')\n pre++;\n if(customers[n-i] == 'Y')\n post++; \n pen[n-i] += post;\n }\n return min_element(begin(pen), end(pen))-begin(pen);\n }\n};", "memory": "16300" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
2
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n vector<int> penaltyBack(customers.length() + 1, 0);\n for (int i = customers.length() - 1; i >= 0; i--) {\n penaltyBack[i] = customers[i] == 'Y' ? 1 : 0;\n penaltyBack[i] += penaltyBack[i + 1];\n }\n\n int bestPoz = 0, best = penaltyBack[0];\n\n int pen = 1 - penaltyBack[0] + penaltyBack[1];\n\n if (pen + penaltyBack[1] < best) {\n bestPoz = 1;\n best = pen + penaltyBack[1];\n }\n for (int i = 1; i < customers.length(); i++) {\n pen += (customers[i] == 'Y' ? 0 : 1);\n int currPen = pen + penaltyBack[i + 1];\n if (currPen < best) {\n best = currPen;\n bestPoz = i + 1;\n }\n }\n\n return bestPoz;\n }\n};", "memory": "16400" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
2
{ "code": "class Solution {\npublic:\n int bestClosingTime(string c) {\n int n=c.size();\n int preN[n+1];\n preN[0]=0;\n int suffY[n+1];\n for(int i=1;i<=n;i++){\n if(c[i-1]=='N')preN[i]=1;\n else preN[i]=0;\n preN[i]+=preN[i-1];\n }\n suffY[n]=0;\n for(int i=n-1;i>=0;i--){\n if(c[i]=='Y')suffY[i]=1;\n else suffY[i]=0;\n suffY[i]+=suffY[i+1];\n }\n for(auto x : preN)cout<<x<<\" \";\n cout<<endl;\n for(auto x : suffY)cout<<x<<\" \";\n cout<<endl;\n vector<int> penalty(n+1);\n int hour=n;\n int minPenalty=INT_MAX;\n for(int i=0;i<=n;i++){\n penalty[i]=preN[i]+suffY[i];\n if(penalty[i]<minPenalty){\n minPenalty=penalty[i];\n hour=i;\n }\n }\n if(hour==n-1 and c[n-1]=='Y')hour++;\n return hour;\n }\n};", "memory": "17100" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
2
{ "code": "class Solution {\npublic:\n int bestClosingTime(string& c) {\n int n = c.size();\n vector<int>pre(n+1,0);\n for(int i=1;i<=n;i++){\n if(c[i-1] == 'Y') pre[i] = pre[i-1] ;\n else pre[i] = pre[i-1] + 1;\n }\n vector<int>suf(n+1,0);\n for(int i=n-1;i>=0;i--){\n if(c[i] == 'Y') suf[i] = suf[i+1] +1 ;\n else suf[i] = suf[i+1];\n }\n int min = INT_MAX;\n int midx = -1;\n for(int i=0;i<=n;i++){\n if(pre[i] + suf[i] < min){\n midx = i;\n min = pre[i] + suf[i];\n } \n }\n return midx;\n }\n};", "memory": "19200" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
2
{ "code": "class Solution {\npublic:\n int bestClosingTime(const string& c) \n {\n vector<pair<int, int>> cnt(c.size());\n for (int i = 0; i < c.size(); ++i)\n {\n cnt[i] = i? cnt[i - 1] : make_pair(0, 0);\n ++(c[i] == 'Y'? cnt[i].first : cnt[i].second);\n }\n\n int minHour = c.size();\n int minPenalty{ cnt.back().second };\n for (int i = 0; i < c.size(); ++i)\n {\n int penalty{ cnt[i].second + (cnt.back().first - cnt[i].first) };\n penalty += (c[i] == 'Y')? 1 : -1;\n\n if (penalty < minPenalty || (penalty == minPenalty && i < minHour))\n {\n minPenalty = penalty;\n minHour = i;\n }\n }\n\n return minHour;\n }\n};", "memory": "19300" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
2
{ "code": "class Solution {\npublic:\n int bestClosingTime(string c) {\n int n = c.size();\n vector<int>v(n+1,0);\n int cnt = 0;\n for(int i=0;i<n;i++){\n if(c[i]=='Y'){\n v[i+1] = 1;\n cnt++;\n }\n else{\n v[i+1]=0;\n }\n }\n if(cnt==0)return 0;\n vector<int>ans(n+1,0);\n ans[0] = cnt;\n for(int i=1;i<n+1;i++){\n if(v[i]==1){\n ans[i] = ans[i-1]-1;\n }\n else if(v[i]==0){\n ans[i] = ans[i-1]+1;\n }\n }\n int ans1 = *min_element(ans.begin(),ans.end());\n for(int i=0;i<n+1;i++){\n if(ans[i]==ans1){\n return i;\n }\n }\n return 0;\n }\n};", "memory": "19700" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
2
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.length();\n vector<int> pre(n+1);\n pre[0] = 0;\n int count = 0;\n for(int i=1; i<n+1; i++) {\n if(customers[i-1]=='N') {\n count++;\n }\n pre[i] = count;\n }\n if(count == n) return 0;\n\n vector<int> suf(n+1);\n suf[n] = 0;\n count = 0;\n for(int i=n-1; i>=0; i--) {\n if(customers[i]=='Y') {\n count++;\n suf[i] = count;\n }\n suf[i] = count;\n }\n if(count==n) return n;\n\n for(int i=0; i<n+1; i++) {\n pre[i] += suf[i];\n }\n \n int mindx = -1;\n int min = INT_MAX;\n for(int i=0; i<n+1; i++) {\n if(pre[i] < min) {\n min = pre[i];\n mindx = i;\n }\n }\n return mindx;\n }\n};", "memory": "19800" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
2
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.length();\n vector<int> pre(n+1);\n pre[0] = 0;\n int count = 0;\n for(int i=1; i<n+1; i++) {\n if(customers[i-1]=='N') {\n count++;\n }\n pre[i] = count;\n }\n if(count == n) return 0;\n\n vector<int> suf(n+1);\n suf[n] = 0;\n count = 0;\n for(int i=n-1; i>=0; i--) {\n if(customers[i]=='Y') count++;\n \n // suf[i] = count;\n \n suf[i] = count;\n }\n if(count==n) return n;\n\n for(int i=0; i<n+1; i++) {\n pre[i] += suf[i];\n }\n \n int mindx = -1;\n int min = INT_MAX;\n for(int i=0; i<n+1; i++) {\n if(pre[i] < min) {\n min = pre[i];\n mindx = i;\n }\n }\n return mindx;\n }\n};", "memory": "19900" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
2
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.length();\n vector<int> pre(n+1);\n pre[0] = 0;\n int count = 0;\n for(int i=1; i<n+1; i++) {\n if(customers[i-1]=='N') count++;\n pre[i] = count;\n }\n if(count == n) return 0;\n\n vector<int> suf(n+1);\n suf[n] = 0;\n count = 0;\n for(int i=n-1; i>=0; i--) {\n if(customers[i]=='Y') count++;\n suf[i] = count;\n }\n if(count==n) return n;\n\n for(int i=0; i<n+1; i++) {\n pre[i] += suf[i];\n }\n \n int mindx = -1;\n int min = INT_MAX;\n for(int i=0; i<n+1; i++) {\n if(pre[i] < min) {\n min = pre[i];\n mindx = i;\n }\n }\n return mindx;\n }\n};", "memory": "19900" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
2
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.size();\n vector<int> right(n+1,0);\n vector<int> left(n+1,0);\n left[0] = 0;\n\n for(int i = 1;i<n+1;i++){\n if(customers[i-1] == 'N'){\n left[i] = left[i-1] +1;\n }\n else left[i] = left[i-1];\n }\n\n right[n] = 0;\n for(int i = n-1;i>=0;i--){\n if(customers[i] == 'Y'){\n right[i] = right[i+1] +1;\n }\n else right[i] = right[i+1];\n }\n \n int index = 0;\n int min1 = INT_MAX;\n for(int i = 0;i<n+1;i++){\n if (right[i]+left[i] < min1){\n min1 = right[i]+left[i];\n index = i;\n }\n }\n return index;\n }\n};", "memory": "20000" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
2
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.size();\n\n vector<int> pre(n+1);\n vector<int> suf(n+1);\n\n pre[0] =0;\n for(int i = 0; i < n; i++){\n int count = 0;\n if(customers[i] == 'N') count++;\n pre[i+1] = pre[i] + count;\n }\n\n suf[n] = 0;\n for(int i = n-1; i >= 0; i--){\n int count = 0;\n if(customers[i] == 'Y') count = 1;\n suf[i] = suf[i+1] + count;\n }\n\n int minPen;\n for(int i = 0; i <= n ; i++){\n pre[i] += suf[i];\n int pen = pre[i];\n minPen = min(pen , minPen);\n }\n for(int i = 0; i <=n ; i++){\n int pen = pre[i];\n if(pen == minPen) return i;\n }\n return n;\n }\n};", "memory": "20100" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
2
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n=customers.size();\n vector<int>Ncount(n+1,0), Ycount(n+1,0);\n \n int count=0;\n for(int i=1;i<=n;i++) {\n if(customers[i-1]=='N') {\n count++;\n }\n Ncount[i]=count;\n }\n\n count = 0;\n for(int i=n-1; i>=0;i--) {\n if(customers[i] == 'Y') {\n count++;\n }\n Ycount[i]=count;\n }\n\n int minHour = INT_MAX;\n int minPenalty = INT_MAX;\n for(int i=0;i<=n;i++) {\n int penalty = Ncount[i]+Ycount[i];\n if(penalty < minPenalty) {\n minPenalty = penalty;\n minHour = i;\n }\n }\n\n return minHour;\n }\n};\n/*\n close at xth hr\n [0...x-1] N's count\n [x...n-1] Y's count\n\n N = [0 0 0 1 1]\n Y = [3 2 1 1 0]\n*/", "memory": "20200" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n customers.push_back('#');\n int n = customers.size();\n vector<int> postfixYes(n, 0);\n vector<int> prefixNo(n, 0);\n for (int i = 0; i < n; i++) {\n prefixNo[i] = customers[i] == 'N';\n if (i-1>=0) prefixNo[i] += prefixNo[i-1];\n }\n for (int i = n-1; i >= 0; i--) {\n postfixYes[i] = customers[i] == 'Y';\n if (i+1 < n) postfixYes[i] += postfixYes[i+1];\n }\n\n int minSeen = INT_MAX;\n int minIdx = -1;\n for (int i = 0; i < n; i++) {\n int curr = postfixYes[i];\n if (i-1 >= 0) curr += prefixNo[i-1];\n if (curr < minSeen) {\n minSeen = curr;\n minIdx = i;\n }\n }\n\n return minIdx;\n }\n};", "memory": "21600" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n int bestClosingTime(string c) {\n int l=0, m=0;vector<int>v;\n v.push_back(0);int idx=0;\n for(int i=0;i<c.size();i++){\n if(c[i]=='Y'){\n m+=1;\n v.push_back(m);}\n\n else{ \n m-=1;\n v.push_back(m);}\n }\n for(int i=0;i<v.size();i++){\n if(v[i]>l){\n l=v[i];\n idx=i;}}\n\n \n return idx;\n }\n};", "memory": "21900" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n // compute the penalty if we close at i-th hour\n vector<int> penalty;\n int cur = 0;\n for (char c : customers) {\n penalty.push_back(cur);\n cur += (c=='N');\n }\n penalty.push_back(cur);\n cur = 0;\n for (int i=customers.size()-1; i>=0; --i) {\n cur += (customers[i]=='Y');\n penalty[i] += cur;\n }\n\n int min_penalty = customers.size();\n int min_i = -1;\n for (int i=0; i<penalty.size(); ++i) {\n if (penalty[i]<min_penalty) {\n min_i = i;\n min_penalty = penalty[i];\n }\n }\n return min_i;\n\n }\n};", "memory": "22000" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n int bestClosingTime(string s) {\n int n_before=0;\n int n_after=0;\n int y_after=0;\n int y_before=0;\n for(int i=0;i<s.length();i++){\n if(s[i] == 'Y'){\n y_after++;\n }\n else{\n n_after++;\n }\n }\n int penalty=0;\n vector<int> temp;\n for(int i=0;i<s.length();i++){\n penalty=n_before+y_after;\n if(s[i] == 'Y'){\n y_after--;\n y_before++;\n }\n else{\n n_after--;\n n_before++;\n }\n temp.push_back(penalty);\n }\n penalty=n_before+y_after;\n temp.push_back(penalty);\n\n int val=INT_MAX;\n int ans=0;\n for(int i=0;i<temp.size();i++){\n if(temp[i] < val){\n ans=i;\n val=temp[i];\n }\n }\n\n return ans;\n\n }\n};", "memory": "22100" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n // penalty\n vector <int> close_shop;\n vector <int> open_shop;\n for(int i =0; i<customers.size(); i++)\n {\n if(customers[i] == 'Y')\n close_shop.push_back(i); // y data\n\n else\n open_shop.push_back(i); // N data \n }\n\n if(close_shop.size() == 0) return 0;\n\n if(close_shop.size() == customers.size()) return customers.size(); \n \n int penalty = INT_MAX; int indx = -1;\n\nint close = 0, open =0; int open_shop_size = open_shop.size();\nfor(int i=0; i<customers.size(); i++)\n{\nif(close_shop.size() > 0 and i > close_shop[0]) close_shop.erase(close_shop.begin());\nclose = close_shop.size(); \n\nif(open_shop.size() > 0 and i > open_shop[0])\n{\nopen +=1;\nopen_shop.erase(open_shop.begin());\n} \n\n\nif(close + open <penalty)\n{\npenalty = close + open;\nindx = i;\n}\n\n}\n\n\n\nif(open_shop_size < penalty)\nreturn customers.size();\n\nreturn indx;\n\n }\n};", "memory": "22300" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\nvector <int> close_shop;\nvector <int> open_shop;\n\n\n\n// int open_shop(string customers , int i)\n// {\n// if(i<0) return 0;\n// int count =0;\n// while(i>=0)\n// {\n// if( customers[i] == 'N')\n// count +=1;\n\n// i-=1;\n// }\n\n// return count;\n\n\n// }\n\n// int close_shop(string customers , int i)\n// {\n// int n = customers.size();\n// int count =0;\n// if(i ==n) return 0;\n// while(i<n)\n// {\n// if( customers[i] == 'Y')\n// count +=1;\n\n// i+=1;\n// }\n// return count;\n// }\n \n \n int bestClosingTime(string customers) {\n \n \n // memory limit exceeded\n \n int n = customers.size();\n int check = INT_MAX , indx = -1;\n// for(int i=0; i<=n; i++)\n// {\n// int close = close_shop(customers , i);\n// int open = open_shop(customers , i-1);\n\n// if( (close + open) < check)\n// {\n// check = close+open;\n// indx = i;\n// }\n\n// }\n\n// return indx;\n\n\nfor(int i=0; i<n; i++)\n{\n if(customers[i] == 'Y')\n close_shop.push_back(i);\n\n else\n open_shop.push_back(i); // not come\n}\n\n\nif(close_shop.size()==0) return 0; // NNNN\n\nif(close_shop.size() ==n) return n; // yyyy\n\nint not_come = open_shop.size();\n\n int open_count = 0;\n\nfor(int i =0; i< n; i++)\n{ \n\nint close_count = 0; \nif( close_shop.size() > 0 )\n{\nif(i > close_shop[0] )\nclose_shop.erase(close_shop.begin());\n\nclose_count = close_shop.size();\n\n}\n\n if(i >0 and open_shop.size() >0)\n{\n\nif(i-1 == open_shop[0]) {\nopen_count +=1;\n\nopen_shop.erase(open_shop.begin());\n\n}\n}\n\n if((open_count+close_count ) < check)\n {\n check = open_count+close_count;\n indx = i;\n }\n\n\ncout<<check<<\" \";\n}\n\n\n// last when shop close at i ==n\n\n// no of customer not come , when shop open\n\n//cout<<check<<\" \"<<not_come;\n\nif(not_come <check )\n{\n return n;\n}\n\n return indx; \n\n}\n};", "memory": "22400" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n \n// int close_shop(string customers , int i)\n// {\n// int n = customers.size();\n// if(i ==n) return 0; int count = 0; \n// while(i<n)\n// {\n// if(customers[i] == 'Y')\n// count +=1;\n \n// i++;\n// }\n\n\n// return count;\n\n\n// }\n \n// int open_shop(string customers , int i)\n// {\n// if(i<0) return 0;\n// int count = 0;\n// while(i>=0)\n// {\n// if( customers[i] == 'N')\n// count +=1;\n\n// i -= 1;\n\n// }\n// return count;\n\n// }\n \n \n \n \n int bestClosingTime(string customers) {\n \n \n\n// ************************************************* Memory limit exceeded ****************************************************\n\n\n\n int check = INT_MAX , indx =-1; \nint n = customers.size();\n// for(int i =0; i<=n; i++)\n// {\n// int close = close_shop(customers , i);\n\n// int open = open_shop(customers , i-1);\n\n\n// if((close +open) < check)\n// {\n// check = close +open;\n// indx = i;\n// }\n\n// }\n \n \n// return indx;\n\n\n\n\nvector <int> close_shop;\nvector <int> open_shop;\n\nfor(int i=0; i<n; i++)\n{\nif(customers[i] == 'Y')\nclose_shop.push_back(i);\n\nelse\nopen_shop.push_back(i);\n\n}\n\nint count_openshop =0;\n\nint not_come = open_shop.size();\n\nfor(int i =0; i<n; i++)\n{\nint count_closeshop = 0;\nif(close_shop.size() >0)\n{\nif(i> close_shop[0])\nclose_shop.erase(close_shop.begin());\n\ncount_closeshop = close_shop.size();\n\n\n}\n\nif(i>0 and open_shop.size()>0)\n{\nif(i-1 == open_shop[0]) {\ncount_openshop +=1;\n\n\nopen_shop.erase(open_shop.begin());\n}\n\n}\n\nif((count_openshop + count_closeshop) < check)\n{\n check = count_openshop + count_closeshop;\n indx = i;\n}\n\n\n}\n\n\n // when shop close at n hour \n \n if(not_come < check)\n return n;\n\n\n\n\n return indx; \n \n \n \n \n \n \n \n \n \n \n \n \n }\n};", "memory": "22400" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\n int n;\n vector<int> open, close;\n \n void prePopulate(string& customers) {\n \n for(int i=0;i<n;++i) {\n char ch = customers[i];\n if(i == 0) {\n open[i] = 0;\n } else if(ch == 'N') {\n open[i] = open[i-1] + 1;\n } else {\n open[i] = open[i-1];\n }\n }\n\n for(int i=n-1;i>=0;--i) {\n char ch = customers[i];\n if(i == n-1) {\n close[i] = 0;\n } else if(ch == 'Y') {\n close[i] = close[i+1] + 1;\n } else {\n close[i] = close[i+1];\n }\n }\n }\n\npublic:\n int bestClosingTime(string customers) {\n customers = \"#\" + customers + \"#\";\n n = customers.size();\n open.resize(n);\n close.resize(n);\n prePopulate(customers);\n int mn = INT_MAX;\n int ans = 0;\n for(int i=0;i<n-1;++i) {\n if(mn > open[i] + close[i+1]) {\n mn = open[i] + close[i+1];\n ans = i;\n }\n \n }\n return ans;\n }\n};", "memory": "22600" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.length();\n vector<int> pre(n+1);\n pre[0] = 0;\n int count = 0;\n for(int i=1; i<n+1; i++) {\n if(customers[i-1]=='N') {\n count++;\n }\n pre[i] = count;\n }\n if(count == n) return 0;\n\n vector<int> suf(n+1);\n suf[n] = 0;\n count = 0;\n for(int i=n-1; i>=0; i--) {\n if(customers[i]=='Y') {\n count++;\n suf[i] = count;\n }\n suf[i] = count;\n }\n if(count==n) return n;\n\n vector<int> tPenalty(n+1);\n for(int i=0; i<n+1; i++) {\n tPenalty[i] = pre[i] + suf[i];\n }\n \n int mindx = -1;\n int min = INT_MAX;\n for(int i=0; i<n+1; i++) {\n if(tPenalty[i] < min) {\n min = tPenalty[i];\n mindx = i;\n }\n }\n return mindx;\n }\n};", "memory": "22800" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n int bestClosingTime(string customers) {\n int n = customers.size();\n vector<int>left(n,0), right(n,0),res(n,1e9);\n int l = 0, r = 0;\n for(int i=0;i<n;i++){\n left[i] = l;\n right[n-1-i] = r;\n l += customers[i] == 'Y';\n r += customers[n-1-i] == 'Y';\n // cout<<left[i] <<\" \"<<right[n-1-i]<<endl;\n }\n int ans = 1e9, ansi = -1;\n for(int i = 0;i<n;i++){\n int leftPenalty = i-left[i];\n int rightPenalty = right[i];\n \n int currentPenalty = customers[i] == 'Y';\n res[i] = min(res[i], leftPenalty + rightPenalty + currentPenalty);\n // cout<<leftPenalty <<\" \"<<rightPenalty<<\" \" <<res[i]<<endl;\n if(res[i] < ans){\n ans = min(ans, res[i]);\n ansi = i;\n }\n }\n //account for 1 extra hour at end\n if(n - left[n-1] - (customers[n-1]=='Y') < ans){\n ansi = n;\n }\n \n return ansi;\n }\n};", "memory": "24200" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n int bestClosingTime(string s) {\n vector<int>open(s.length());\n vector<int>closed(s.length());\n int oi=0;\n for(int i=0;i<s.length();i++){\n if(s[i]=='Y'){\n open[i]=oi;\n }\n else{\n open[i]=oi;\n oi++;\n }\n }\n oi=0;\n for(int i=s.length()-1;i>=0;i--){\n if(s[i]=='Y'){\n oi++;\n closed[i]=oi;\n }\n else{\n closed[i]=oi;\n }\n }\n int ncount=0;\n for(int i=0;i<s.length();i++){\n if(s[i]=='N'){\n ncount++;\n }\n }\n vector<int>ans(s.length()+1);\n for(int i=0;i<s.length();i++){\n ans[i]=open[i]+closed[i];\n }\n int min=INT_MAX;\n int index=ans.size()+1;\n ans[s.length()]=ncount;\n for(auto it:ans){\n cout<<it<<\" \";\n }\n for(int i=0;i<ans.size();i++){\n if(ans[i]<min){\n min=ans[i];\n index=i;\n }\n }\n return index;\n }\n};", "memory": "24300" }
2,576
<p>You are given the customer visit log of a shop represented by a <strong>0-indexed</strong> string <code>customers</code> consisting only of characters <code>&#39;N&#39;</code> and <code>&#39;Y&#39;</code>:</p> <ul> <li>if the <code>i<sup>th</sup></code> character is <code>&#39;Y&#39;</code>, it means that customers come at the <code>i<sup>th</sup></code> hour</li> <li>whereas <code>&#39;N&#39;</code> indicates that no customers come at the <code>i<sup>th</sup></code> hour.</li> </ul> <p>If the shop closes at the <code>j<sup>th</sup></code> hour (<code>0 &lt;= j &lt;= n</code>), the <strong>penalty</strong> is calculated as follows:</p> <ul> <li>For every hour when the shop is open and no customers come, the penalty increases by <code>1</code>.</li> <li>For every hour when the shop is closed and customers come, the penalty increases by <code>1</code>.</li> </ul> <p>Return<em> the <strong>earliest</strong> hour at which the shop must be closed to incur a <strong>minimum</strong> penalty.</em></p> <p><strong>Note</strong> that if a shop closes at the <code>j<sup>th</sup></code> hour, it means the shop is closed at the hour <code>j</code>.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYNY&quot; <strong>Output:</strong> 2 <strong>Explanation:</strong> - Closing the shop at the 0<sup>th</sup> hour incurs in 1+1+0+1 = 3 penalty. - Closing the shop at the 1<sup>st</sup> hour incurs in 0+1+0+1 = 2 penalty. - Closing the shop at the 2<sup>nd</sup> hour incurs in 0+0+0+1 = 1 penalty. - Closing the shop at the 3<sup>rd</sup> hour incurs in 0+0+1+1 = 2 penalty. - Closing the shop at the 4<sup>th</sup> hour incurs in 0+0+1+0 = 1 penalty. Closing the shop at 2<sup>nd</sup> or 4<sup>th</sup> hour gives a minimum penalty. Since 2 is earlier, the optimal closing time is 2. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> customers = &quot;NNNNN&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> It is best to close the shop at the 0<sup>th</sup> hour as no customers arrive.</pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> customers = &quot;YYYY&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> It is best to close the shop at the 4<sup>th</sup> hour as customers arrive at each hour. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= customers.length &lt;= 10<sup>5</sup></code></li> <li><code>customers</code> consists only of characters <code>&#39;Y&#39;</code> and <code>&#39;N&#39;</code>.</li> </ul>
3
{ "code": "class Solution {\npublic:\n int bestClosingTime(string s) {\n vector<int>open(s.length());\n vector<int>closed(s.length());\n int oi=0;\n for(int i=0;i<s.length();i++){\n if(s[i]=='Y'){\n open[i]=oi;\n }\n else{\n open[i]=oi;\n oi++;\n }\n }\n oi=0;\n for(int i=s.length()-1;i>=0;i--){\n if(s[i]=='Y'){\n oi++;\n closed[i]=oi;\n }\n else{\n closed[i]=oi;\n }\n }\n int ncount=0;\n for(int i=0;i<s.length();i++){\n if(s[i]=='N'){\n ncount++;\n }\n }\n vector<int>ans(s.length()+1);\n for(int i=0;i<s.length();i++){\n ans[i]=open[i]+closed[i];\n }\n int min=INT_MAX;\n int index=ans.size()+1;\n ans[s.length()]=ncount;\n for(auto it:ans){\n cout<<it<<\" \";\n }\n for(int i=0;i<ans.size();i++){\n if(ans[i]<min){\n min=ans[i];\n index=i;\n }\n }\n return index;\n }\n};", "memory": "24300" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
1
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) { \n\n int left = 0;\n int summ = 0;\n for (int i = 0; i <= n; ++i) {\n summ += i;\n }\n \n int right = summ - 1;\n \n for (int pivot = 1; pivot <= n; ++pivot) {\n if (left > right) return -1;\n if (left == right) { \n return pivot;\n }\n left += pivot;\n right -= pivot+1;\n }\n\n\n return -1;\n}\n};", "memory": "7800" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
1
{ "code": "class Solution {\npublic:\n int p(int n) { return n * (n + 1) / 2; }\n int pivotInteger(int n) {\n // 1 3 6 10 15 21 28 36\n int k = p(n);\n int l = 1, r = n;\n while (l <= r) {\n int m = (l + r) / 2;\n int f = p(m);\n int s = k + m - f;\n if (f == s) {\n return m;\n } else if (f > s) {\n r = m - 1;\n } else {\n l = m + 1;\n }\n }\n return -1;\n }\n};", "memory": "7800" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int getSum(int x) {\n return x * (x + 1) / 2;\n }\n\n int pivotInteger(int n) {\n int sum = getSum(n);\n\n int l = 1;\n int r = n;\n while (l <= r) {\n int m = (l + r) / 2;\n int firstPart = getSum(m);\n int secondPart = sum - firstPart + m; \n \n if (firstPart == secondPart)\n return m;\n else if (firstPart > secondPart)\n r = m - 1;\n else\n l = m + 1;\n }\n\n return -1;\n }\n};", "memory": "7900" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n int left=(n*(n+1))/2;\n int right=n;\n if(n==1)return n;\n for(int i=n-1;i>0;i--){\n left-=i+1;\n right+=i;\n if(left==right)\n return i;\n }\n return -1;\n \n }\n};", "memory": "7900" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n int mid = n/2;\n for (int i = mid; i <= n; i++) {\n cout << i << endl;\n double prefix = i/2.0 * (i + 1);\n double suffix = (n-i+1)/2.0 * ((2*i)+((n-i+1) - 1));\n cout << prefix << endl;\n cout << suffix << endl << endl;\n if (prefix == suffix) return i;\n }\n return -1;\n }\n};", "memory": "8000" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n auto it=pivots.find(n);\n if(it!=pivots.end())\n return it->second;\n else return -1;\n }\n Solution(){\n \n for(int i=1;i<1001;i++){\n float p=sqrt(float(i*i+i)/2.f);\n if(floor(p)==p)\n pivots.emplace(i,p);\n \n\n }\n }\n std::unordered_map<int,int> pivots;\n};", "memory": "8400" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n int arr[1001][2];\n int ans;\n int s = 0, e = 0;\n for (int i = 1; i <= n; i++) {\n s += i;\n e += n - i + 1;\n arr[i][0] = s;\n arr[n - i + 1][1] = e;\n }\n s = 1, e = n;\n int mid;\n while (s<=e) {\n mid = (s + e) / 2;\n if (arr[mid][0] == arr[mid][1]) {\n return mid;\n } else if (arr[mid][0] > arr[mid][1]) {\n e = mid - 1;\n } else {\n s = mid + 1;\n }\n }\n return -1;\n }\n};", "memory": "8500" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n int arr[1001][2];\n int ans;\n int s = 0, e = 0;\n for (int i = 1; i <= n; i++) {\n s += i;\n e += n - i + 1;\n arr[i][0] = s;\n arr[n - i + 1][1] = e;\n }\n s = 1, e = n;\n int mid;\n while (s<=e) {\n mid = (s + e) / 2;\n if (arr[mid][0] == arr[mid][1]) {\n return mid;\n } else if (arr[mid][0] > arr[mid][1]) {\n e = mid - 1;\n } else {\n s = mid + 1;\n }\n }\n return -1;\n }\n};", "memory": "8600" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n int arr[1001][2];\n int ans;\n int s = 0, e = 0;\n for (int i = 1; i <= n; i++) {\n s += i;\n e += n - i + 1;\n arr[i][0] = s;\n arr[n - i + 1][1] = e;\n }\n s = 1, e = n;\n int mid;\n while (s<=e) {\n mid = (s + e) / 2;\n if (arr[mid][0] == arr[mid][1]) {\n return mid;\n } else if (arr[mid][0] > arr[mid][1]) {\n e = mid - 1;\n } else {\n s = mid + 1;\n }\n }\n return -1;\n }\n};", "memory": "8700" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n int arr[1001][2];\n int ans;\n int s = 0, e = 0;\n for (int i = 1; i <= n; i++) {\n s += i;\n e += n - i + 1;\n arr[i][0] = s;\n arr[n - i + 1][1] = e;\n }\n s = 1, e = n;\n int mid;\n while (s<=e) {\n mid = (s + e) / 2;\n if (arr[mid][0] == arr[mid][1]) {\n return mid;\n } else if (arr[mid][0] > arr[mid][1]) {\n e = mid - 1;\n } else {\n s = mid + 1;\n }\n }\n return -1;\n }\n};", "memory": "8700" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n int a[1001];\n a[0]=0;\n for(int i=1;i<1001;i++){\n a[i]=i+a[i-1];\n }\n for(int i=1;i<=n;i++){\n if(a[i-1]==a[n]-a[i]){\n return i;\n }\n }\n return -1;\n }\n};", "memory": "8900" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n \n vector<int> prefixSum(n+1, 0);\n prefixSum[0] = 0;\n for (int i = 1; i <= n; ++i){\n prefixSum[i] = prefixSum[i - 1] + i;\n }\n for (int x = 1; x <= n; ++x) {\n int suffixSum = prefixSum[n] - prefixSum[x - 1];\n if (prefixSum[x] == suffixSum){\n return x;\n }\n }\n return -1;\n }\n};", "memory": "9000" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n vector<int> dp(n);\n iota(dp.begin(),dp.end(),1);\n if(n==1) return 1;\n int sum = 0;\n long long s = accumulate(dp.begin(),dp.end(),0LL);\n for(auto x : dp) cout<<x<<' ';\n for(int i = 0;i<n;i++){\n sum+=dp[i];\n if(sum==accumulate(dp.begin()+i,dp.end(),0)){\n return i+1;\n }\n \n \n }\n return -1;\n }\n};", "memory": "9100" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\nint pivotInteger(int n) {\n\tif (n == 1) {\n\t\treturn 1;\n\t}\n\tvector<int> ale(n);\n\tale[0] = 1;\n\tfor (int i = 1; i < ale.size(); i++) {\n\t\tale[i] = ale[i - 1] + i+1;\n\t}\n\tint maxsum = ale[ale.size() - 1];\n\tfor (int i = 0; i < ale.size(); i++) {\n\t\t//cout << ale[i]+i+2 << \" \" << maxsum - ale[i]<<endl;\n\t\tif (ale[i]+i+2 == maxsum - ale[i]) {\n\t\t\treturn i+2;\n\t\t}\n\t}\n\treturn -1;\n}\n};", "memory": "9200" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n vector<int> number(n);\n for(int i=1;i<=n;i++){\n number[i-1]=i;\n }\n int total_sum=0;\n int curr_sum=0;\n int right_sum=0;\n\n for(int i=0;i<number.size();i++){\n total_sum+=number[i];\n }\n\n for(int i=0;i<number.size();i++){\n right_sum=total_sum-curr_sum;\n curr_sum+=number[i];\n if(right_sum==curr_sum)return number[i];\n }\n return -1;\n }\n};", "memory": "9300" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n vector<int> left(n);\n vector<int> right(n);\n left[0] = 0;\n right[n-1] = 0;\n for(int i=1;i<n;i++){\n left[i] = left[i-1] + i;\n }\n for(int i=n-2;i>=0;i--){\n right[i] = right[i+1] + (i+2); \n }\n for(int i=0;i<left.size();i++){\n if(left[i] == right[i]){\n return i+1;\n }\n }\n return -1;\n }\n};", "memory": "9900" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n vector<int>leftsum(n);\n vector<int>rightsum(n);\n leftsum[0]=1;\n rightsum[n-1]=n;\n int i=1;\n while(i<n){\n leftsum[i]=leftsum[i-1]+i+1;\n rightsum[n-i-1]=rightsum[n-i]+n-i;\n i++;\n }\n i=0;\n while(i<n){\n if(leftsum[i]==rightsum[i])\n return i+1;\n i++;\n }\n return -1;\n }\n};", "memory": "10000" }
2,571
<p>Given a positive integer <code>n</code>, find the <strong>pivot integer</strong> <code>x</code> such that:</p> <ul> <li>The sum of all elements between <code>1</code> and <code>x</code> inclusively equals the sum of all elements between <code>x</code> and <code>n</code> inclusively.</li> </ul> <p>Return <em>the pivot integer </em><code>x</code>. If no such integer exists, return <code>-1</code>. It is guaranteed that there will be at most one pivot index for the given input.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> n = 8 <strong>Output:</strong> 6 <strong>Explanation:</strong> 6 is the pivot integer since: 1 + 2 + 3 + 4 + 5 + 6 = 6 + 7 + 8 = 21. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> n = 1 <strong>Output:</strong> 1 <strong>Explanation:</strong> 1 is the pivot integer since: 1 = 1. </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> n = 4 <strong>Output:</strong> -1 <strong>Explanation:</strong> It can be proved that no such integer exist. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= n &lt;= 1000</code></li> </ul>
3
{ "code": "class Solution {\npublic:\n int pivotInteger(int n) {\n vector<int> left(n, 0);\n vector<int> right(n, 0);\n left[0] = 1;\n right[n-1] = n;\n for(int i = 1; i < n; i++){\n left[i] = left[i-1] + i + 1;\n }\n for(int i = n-2; i >= 0; i--){\n right[i] = right[i+1] + i + 1;\n }\n for(int i = 0; i < n; i++){\n if(left[i] == right[i]) return i + 1;\n }\n return -1;\n }\n};", "memory": "10100" }
2,572
<p>You are given two strings <code>s</code> and <code>t</code> consisting of only lowercase English letters.</p> <p>Return <em>the minimum number of characters that need to be appended to the end of </em><code>s</code><em> so that </em><code>t</code><em> becomes a <strong>subsequence</strong> of </em><code>s</code>.</p> <p>A <strong>subsequence</strong> is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> s = &quot;coaching&quot;, t = &quot;coding&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> Append the characters &quot;ding&quot; to the end of s so that s = &quot;coachingding&quot;. Now, t is a subsequence of s (&quot;<u><strong>co</strong></u>aching<u><strong>ding</strong></u>&quot;). It can be shown that appending any 3 characters to the end of s will never make t a subsequence. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> s = &quot;abcde&quot;, t = &quot;a&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> t is already a subsequence of s (&quot;<u><strong>a</strong></u>bcde&quot;). </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> s = &quot;z&quot;, t = &quot;abcde&quot; <strong>Output:</strong> 5 <strong>Explanation:</strong> Append the characters &quot;abcde&quot; to the end of s so that s = &quot;zabcde&quot;. Now, t is a subsequence of s (&quot;z<u><strong>abcde</strong></u>&quot;). It can be shown that appending any 4 characters to the end of s will never make t a subsequence. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li> <li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li> </ul>
0
{ "code": "class Solution {\npublic:\n static int appendCharacters(string& s, string& t) {\n const int ns=s.size(), nt=t.size(); \n int i=0, j=0;\n for(i=0; i<ns && j<nt; i++){\n if(s[i]==t[j]) j++;\n }\n return nt-j;\n }\n};\n\nauto init = []() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n cout.tie(nullptr);\n return 'c';\n}();", "memory": "11000" }
2,572
<p>You are given two strings <code>s</code> and <code>t</code> consisting of only lowercase English letters.</p> <p>Return <em>the minimum number of characters that need to be appended to the end of </em><code>s</code><em> so that </em><code>t</code><em> becomes a <strong>subsequence</strong> of </em><code>s</code>.</p> <p>A <strong>subsequence</strong> is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> s = &quot;coaching&quot;, t = &quot;coding&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> Append the characters &quot;ding&quot; to the end of s so that s = &quot;coachingding&quot;. Now, t is a subsequence of s (&quot;<u><strong>co</strong></u>aching<u><strong>ding</strong></u>&quot;). It can be shown that appending any 3 characters to the end of s will never make t a subsequence. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> s = &quot;abcde&quot;, t = &quot;a&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> t is already a subsequence of s (&quot;<u><strong>a</strong></u>bcde&quot;). </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> s = &quot;z&quot;, t = &quot;abcde&quot; <strong>Output:</strong> 5 <strong>Explanation:</strong> Append the characters &quot;abcde&quot; to the end of s so that s = &quot;zabcde&quot;. Now, t is a subsequence of s (&quot;z<u><strong>abcde</strong></u>&quot;). It can be shown that appending any 4 characters to the end of s will never make t a subsequence. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li> <li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li> </ul>
0
{ "code": "class Solution {\npublic:\n static int appendCharacters(string& s, string& t) {\n const int ns=s.size(), nt=t.size(); \n int i=0, j=0;\n for(i=0; i<ns && j<nt; i++){\n if(s[i]==t[j]) j++;\n }\n return nt-j;\n }\n};\n\nauto init = []() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n cout.tie(nullptr);\n return 'c';\n}();", "memory": "11100" }
2,572
<p>You are given two strings <code>s</code> and <code>t</code> consisting of only lowercase English letters.</p> <p>Return <em>the minimum number of characters that need to be appended to the end of </em><code>s</code><em> so that </em><code>t</code><em> becomes a <strong>subsequence</strong> of </em><code>s</code>.</p> <p>A <strong>subsequence</strong> is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> s = &quot;coaching&quot;, t = &quot;coding&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> Append the characters &quot;ding&quot; to the end of s so that s = &quot;coachingding&quot;. Now, t is a subsequence of s (&quot;<u><strong>co</strong></u>aching<u><strong>ding</strong></u>&quot;). It can be shown that appending any 3 characters to the end of s will never make t a subsequence. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> s = &quot;abcde&quot;, t = &quot;a&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> t is already a subsequence of s (&quot;<u><strong>a</strong></u>bcde&quot;). </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> s = &quot;z&quot;, t = &quot;abcde&quot; <strong>Output:</strong> 5 <strong>Explanation:</strong> Append the characters &quot;abcde&quot; to the end of s so that s = &quot;zabcde&quot;. Now, t is a subsequence of s (&quot;z<u><strong>abcde</strong></u>&quot;). It can be shown that appending any 4 characters to the end of s will never make t a subsequence. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li> <li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li> </ul>
0
{ "code": "class Solution {\npublic:\n static int appendCharacters(string& s, string& t) {\n const int ns=s.size(), nt=t.size(); \n int i=0, j=0;\n for(i=0; i<ns && j<nt; i++){\n if(s[i]==t[j]) j++;\n }\n return nt-j;\n }\n};\n\nauto init = []() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n cout.tie(nullptr);\n return 'c';\n}();", "memory": "11200" }
2,572
<p>You are given two strings <code>s</code> and <code>t</code> consisting of only lowercase English letters.</p> <p>Return <em>the minimum number of characters that need to be appended to the end of </em><code>s</code><em> so that </em><code>t</code><em> becomes a <strong>subsequence</strong> of </em><code>s</code>.</p> <p>A <strong>subsequence</strong> is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> s = &quot;coaching&quot;, t = &quot;coding&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> Append the characters &quot;ding&quot; to the end of s so that s = &quot;coachingding&quot;. Now, t is a subsequence of s (&quot;<u><strong>co</strong></u>aching<u><strong>ding</strong></u>&quot;). It can be shown that appending any 3 characters to the end of s will never make t a subsequence. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> s = &quot;abcde&quot;, t = &quot;a&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> t is already a subsequence of s (&quot;<u><strong>a</strong></u>bcde&quot;). </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> s = &quot;z&quot;, t = &quot;abcde&quot; <strong>Output:</strong> 5 <strong>Explanation:</strong> Append the characters &quot;abcde&quot; to the end of s so that s = &quot;zabcde&quot;. Now, t is a subsequence of s (&quot;z<u><strong>abcde</strong></u>&quot;). It can be shown that appending any 4 characters to the end of s will never make t a subsequence. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li> <li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li> </ul>
0
{ "code": "class Solution {\npublic:\n static int appendCharacters(string& s, string& t) {\n const int ns=s.size(), nt=t.size(); \n int i=0, j=0;\n for(i=0; i<ns && j<nt; i++){\n if(s[i]==t[j]) j++;\n }\n return nt-j;\n }\n};\n\nauto init = []() {\n ios::sync_with_stdio(false);\n cin.tie(nullptr);\n cout.tie(nullptr);\n return 'c';\n}();", "memory": "11300" }
2,572
<p>You are given two strings <code>s</code> and <code>t</code> consisting of only lowercase English letters.</p> <p>Return <em>the minimum number of characters that need to be appended to the end of </em><code>s</code><em> so that </em><code>t</code><em> becomes a <strong>subsequence</strong> of </em><code>s</code>.</p> <p>A <strong>subsequence</strong> is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> s = &quot;coaching&quot;, t = &quot;coding&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> Append the characters &quot;ding&quot; to the end of s so that s = &quot;coachingding&quot;. Now, t is a subsequence of s (&quot;<u><strong>co</strong></u>aching<u><strong>ding</strong></u>&quot;). It can be shown that appending any 3 characters to the end of s will never make t a subsequence. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> s = &quot;abcde&quot;, t = &quot;a&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> t is already a subsequence of s (&quot;<u><strong>a</strong></u>bcde&quot;). </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> s = &quot;z&quot;, t = &quot;abcde&quot; <strong>Output:</strong> 5 <strong>Explanation:</strong> Append the characters &quot;abcde&quot; to the end of s so that s = &quot;zabcde&quot;. Now, t is a subsequence of s (&quot;z<u><strong>abcde</strong></u>&quot;). It can be shown that appending any 4 characters to the end of s will never make t a subsequence. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li> <li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int appendCharacters(string s, string t) {\n int m = s.length();\n int n = t.length();\n int i =0;\n int j = 0;\n\n while( i<m && j< n){\n\n if(s[i] == t[j]){\n i++;\n j++;\n }\n else{\n i++;\n }\n \n }\n \n return n - j;\n }\n};", "memory": "11900" }
2,572
<p>You are given two strings <code>s</code> and <code>t</code> consisting of only lowercase English letters.</p> <p>Return <em>the minimum number of characters that need to be appended to the end of </em><code>s</code><em> so that </em><code>t</code><em> becomes a <strong>subsequence</strong> of </em><code>s</code>.</p> <p>A <strong>subsequence</strong> is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> s = &quot;coaching&quot;, t = &quot;coding&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> Append the characters &quot;ding&quot; to the end of s so that s = &quot;coachingding&quot;. Now, t is a subsequence of s (&quot;<u><strong>co</strong></u>aching<u><strong>ding</strong></u>&quot;). It can be shown that appending any 3 characters to the end of s will never make t a subsequence. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> s = &quot;abcde&quot;, t = &quot;a&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> t is already a subsequence of s (&quot;<u><strong>a</strong></u>bcde&quot;). </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> s = &quot;z&quot;, t = &quot;abcde&quot; <strong>Output:</strong> 5 <strong>Explanation:</strong> Append the characters &quot;abcde&quot; to the end of s so that s = &quot;zabcde&quot;. Now, t is a subsequence of s (&quot;z<u><strong>abcde</strong></u>&quot;). It can be shown that appending any 4 characters to the end of s will never make t a subsequence. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li> <li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int appendCharacters(string s, string t) {\n int ssz = s.size();\n int tsz = t.size();\n int sidx = 0;\n int tidx = 0;\n while(sidx<ssz && tidx<tsz){\n if (s[sidx]==t[tidx]){\n tidx++;\n }\n sidx++;\n }\n return tsz-tidx;\n }\n};", "memory": "12000" }
2,572
<p>You are given two strings <code>s</code> and <code>t</code> consisting of only lowercase English letters.</p> <p>Return <em>the minimum number of characters that need to be appended to the end of </em><code>s</code><em> so that </em><code>t</code><em> becomes a <strong>subsequence</strong> of </em><code>s</code>.</p> <p>A <strong>subsequence</strong> is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> s = &quot;coaching&quot;, t = &quot;coding&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> Append the characters &quot;ding&quot; to the end of s so that s = &quot;coachingding&quot;. Now, t is a subsequence of s (&quot;<u><strong>co</strong></u>aching<u><strong>ding</strong></u>&quot;). It can be shown that appending any 3 characters to the end of s will never make t a subsequence. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> s = &quot;abcde&quot;, t = &quot;a&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> t is already a subsequence of s (&quot;<u><strong>a</strong></u>bcde&quot;). </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> s = &quot;z&quot;, t = &quot;abcde&quot; <strong>Output:</strong> 5 <strong>Explanation:</strong> Append the characters &quot;abcde&quot; to the end of s so that s = &quot;zabcde&quot;. Now, t is a subsequence of s (&quot;z<u><strong>abcde</strong></u>&quot;). It can be shown that appending any 4 characters to the end of s will never make t a subsequence. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li> <li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int appendCharacters(string s, string t) {\n int p1 = 0, p2 = 0;\n while(p1 != s.size()) {\n if(s[p1] == t[p2]) {\n p1++;\n p2++;\n }\n else {\n p1++;\n }\n }\n return t.size() - p2;\n }\n};", "memory": "12100" }
2,572
<p>You are given two strings <code>s</code> and <code>t</code> consisting of only lowercase English letters.</p> <p>Return <em>the minimum number of characters that need to be appended to the end of </em><code>s</code><em> so that </em><code>t</code><em> becomes a <strong>subsequence</strong> of </em><code>s</code>.</p> <p>A <strong>subsequence</strong> is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> s = &quot;coaching&quot;, t = &quot;coding&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> Append the characters &quot;ding&quot; to the end of s so that s = &quot;coachingding&quot;. Now, t is a subsequence of s (&quot;<u><strong>co</strong></u>aching<u><strong>ding</strong></u>&quot;). It can be shown that appending any 3 characters to the end of s will never make t a subsequence. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> s = &quot;abcde&quot;, t = &quot;a&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> t is already a subsequence of s (&quot;<u><strong>a</strong></u>bcde&quot;). </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> s = &quot;z&quot;, t = &quot;abcde&quot; <strong>Output:</strong> 5 <strong>Explanation:</strong> Append the characters &quot;abcde&quot; to the end of s so that s = &quot;zabcde&quot;. Now, t is a subsequence of s (&quot;z<u><strong>abcde</strong></u>&quot;). It can be shown that appending any 4 characters to the end of s will never make t a subsequence. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li> <li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int appendCharacters(string s, string t) {\n\n int i = 0;\n int j = 0;\n\n int m = s.length();\n int n = t.length();\n\n while(i<m && j<n){\n if(s[i] == t[j]){\n i++;\n j++;\n }\n else i++;\n }\n\n return n-j;\n }\n};", "memory": "12100" }
2,572
<p>You are given two strings <code>s</code> and <code>t</code> consisting of only lowercase English letters.</p> <p>Return <em>the minimum number of characters that need to be appended to the end of </em><code>s</code><em> so that </em><code>t</code><em> becomes a <strong>subsequence</strong> of </em><code>s</code>.</p> <p>A <strong>subsequence</strong> is a string that can be derived from another string by deleting some or no characters without changing the order of the remaining characters.</p> <p>&nbsp;</p> <p><strong class="example">Example 1:</strong></p> <pre> <strong>Input:</strong> s = &quot;coaching&quot;, t = &quot;coding&quot; <strong>Output:</strong> 4 <strong>Explanation:</strong> Append the characters &quot;ding&quot; to the end of s so that s = &quot;coachingding&quot;. Now, t is a subsequence of s (&quot;<u><strong>co</strong></u>aching<u><strong>ding</strong></u>&quot;). It can be shown that appending any 3 characters to the end of s will never make t a subsequence. </pre> <p><strong class="example">Example 2:</strong></p> <pre> <strong>Input:</strong> s = &quot;abcde&quot;, t = &quot;a&quot; <strong>Output:</strong> 0 <strong>Explanation:</strong> t is already a subsequence of s (&quot;<u><strong>a</strong></u>bcde&quot;). </pre> <p><strong class="example">Example 3:</strong></p> <pre> <strong>Input:</strong> s = &quot;z&quot;, t = &quot;abcde&quot; <strong>Output:</strong> 5 <strong>Explanation:</strong> Append the characters &quot;abcde&quot; to the end of s so that s = &quot;zabcde&quot;. Now, t is a subsequence of s (&quot;z<u><strong>abcde</strong></u>&quot;). It can be shown that appending any 4 characters to the end of s will never make t a subsequence. </pre> <p>&nbsp;</p> <p><strong>Constraints:</strong></p> <ul> <li><code>1 &lt;= s.length, t.length &lt;= 10<sup>5</sup></code></li> <li><code>s</code> and <code>t</code> consist only of lowercase English letters.</li> </ul>
0
{ "code": "class Solution {\npublic:\n int appendCharacters(string s, string t) {\n int n=s.size(),m=t.size();\n int i=0,j=0,cnt=0;\n while(i<n&&j<m){\n if(s[i]==t[j]){\n cnt++;\n i++;\n j++;\n }\n else{\n i++;\n }\n }\n return m-cnt;\n }\n};", "memory": "12200" }