મેટ્રિક્સ લીટકોડ સોલ્યુશનમાં નસીબદાર નંબર્સ


મુશ્કેલી સ્તર સરળ
વારંવાર પૂછવામાં આવે છે ઓરેકલ
અરે

મેટ્રિક્સ લીટકોડ સોલ્યુશન સમસ્યામાં નસીબદાર નંબરોએ અમને આપેલા મેટ્રિક્સમાંથી નસીબદાર પૂર્ણાંકો શોધવા માટે કહ્યું. ભાગ્યશાળી પૂર્ણાંકો એક નંબર તરીકે વ્યાખ્યાયિત કરવામાં આવે છે જે તેની હરોળના અન્ય તમામ તત્વોમાં ન્યૂનતમ અને તેની કોલમની વચ્ચે મહત્તમ છે. તેથી આપેલ મેટ્રિક્સમાં એક કરતા વધુ નસીબદાર પૂર્ણાંકો હોઈ શકે છે. તેથી તેમાંના કોઈપણની સ્વતંત્રતા અમારી પાસે છે. જો મેટ્રિક્સમાં કોઈ ભાગ્યશાળી નંબર ન હોય તો, અમારે ખાલી વેક્ટર પરત કરવાની જરૂર છે. તેથી ઉકેલમાં dંડે ડાઇવ કરતા પહેલાં, ચાલો આપણે થોડા ઉદાહરણો જોઈએ.

મેટ્રિક્સ લીટકોડ સોલ્યુશનમાં નસીબદાર નંબર્સ

matrix = [[3,7,8],[9,11,13],[15,16,17]]
[15]

સમજૂતી: 15 તેની પંક્તિની ન્યૂનતમ સંખ્યા છે, અને તેની કોલમમાં મહત્તમ તત્વ પણ છે. આમ 15 આઉટપુટ તરીકે પરત કરવામાં આવી રહ્યું છે.

મેટ્રિક્સ લીટકોડ સોલ્યુશનમાં લકી નંબર્સનો અભિગમ

મેટ્રિક્સ લીટકોડ સોલ્યુશનમાં લકી નંબર્સની સમસ્યા એ પ્રમાણભૂત બાબતોમાંની એક છે. અને ઘણી વાર ઘણાં કોડિંગ રાઉન્ડમાં પૂછવામાં આવે છે. સમસ્યા સરળ છે કારણ કે આપણે ફક્ત તપાસવાની જરૂર છે કે ત્યાં કોઈ તત્વ છે જે તેની હરોળમાં ન્યૂનતમ છે. અને તે જ સમયે તે તેની કોલમમાં મહત્તમ હોવું જોઈએ. તેથી, અમે બે કામચલાઉ એરેનો ઉપયોગ કરીને આ સરળતાથી કરી શકીએ છીએ. આ એરે દરેક પંક્તિના ન્યૂનતમ તત્વ અને દરેક ક columnલમના મહત્તમ તત્વને સંગ્રહિત કરે છે.

તે પછી, આપણે તપાસવાની જરૂર છે કે ત્યાં કોઈ તત્વ છે કે જે આ બંને કામચલાઉ એરેમાં સામાન્ય છે. તેથી, આપણે વાપરી શકીએ છીએ હેશસેટ જ્યાં આપણે એક એરેના તત્વો દાખલ કરીશું. પછી આપણે બીજા એરેના તત્વોને ઓળંગીએ છીએ અને તપાસ કરીએ છીએ કે તે હેશસેટમાં હાજર છે કે નહીં. જો બંને એરેમાં કેટલાક તત્વ હાજર હોય તો આપણે તેને આઉટપુટ તરીકે આપીએ છીએ. પરંતુ જો ડબલ્યુ કોઈ મેચ ન મેળવે, તો અમે જવાબ તરીકે ખાલી વેક્ટર પરત કરીએ છીએ.

મેટ્રિક્સ લીટકોડ સોલ્યુશનમાં લકી નંબર્સ માટેનો કોડ

સી ++ કોડ

#include <bits/stdc++.h>
using namespace std;

vector<int> luckyNumbers (vector<vector<int>>& matrix) {
    int n = matrix.size();
    int m = matrix[0].size();
    vector<int> row(n, INT_MAX), col(m, INT_MIN);
    for(int i=0;i<n;i++){
        for(int j=0;j<m;j++)
            row[i] = min(row[i], matrix[i][j]);
    }
    unordered_set<int> s;
    for(int i=0;i<m;i++){
        for(int j=0;j<n;j++)
            col[i] = max(col[i], matrix[j][i]);
    }
    for(int i=0;i<n;i++)
        s.insert(row[i]);
    for(int i=0;i<m;i++)
        if(s.count(col[i]))
            return {col[i]};
    return {};
}

int main(){
    vector<vector<int>> v = {{3,7,8},{9,11,13},{15,16,17}};
    vector<int> output = luckyNumbers(v);
    for(auto x: output)
        cout<<x;
}
15

જાવા કોડ

import java.util.*;
import java.lang.*;
import java.io.*;

class Main
{
  public static List<Integer> luckyNumbers (int[][] matrix) {
      int n = matrix.length;
      int m = matrix[0].length;
      int[] row = new int[n];
      for(int i=0;i<n;i++)
          row[i] = Integer.MAX_VALUE;
      int[] col = new int[m];
      for(int i=0;i<m;i++)
          col[i] = Integer.MIN_VALUE;
      for(int i=0;i<n;i++){
          for(int j=0;j<m;j++)
              row[i] = Math.min(row[i], matrix[i][j]);
      }
      HashSet<Integer> s = new HashSet<Integer>();
      for(int i=0;i<m;i++){
          for(int j=0;j<n;j++)
              col[i] = Math.max(col[i], matrix[j][i]);
      }
      for(int i=0;i<n;i++)
          s.add(row[i]);
      for(int i=0;i<m;i++)
          if(s.contains(col[i]))
              return new ArrayList(Arrays.asList((col[i])));
      return new ArrayList();
  }

  public static void main (String[] args) throws java.lang.Exception
  {
    int[][] matrix = {{3,7,8},{9,11,13},{15,16,17}};
    List<Integer> output = luckyNumbers(matrix);
    if(output.size() > 0)
      System.out.print(output.get(0));
    
  }
}
15

જટિલતા વિશ્લેષણ

સમય જટિલતા

ઓ (એન * એમ), જ્યાં એન અને એમ એરેની પંક્તિઓ અને કumnsલમ્સમાં તત્વો છે.

અવકાશ જટિલતા

ઓ (એન + એમ), કારણ કે આપણે બે કામચલાઉ એરેનો ઉપયોગ કરીએ છીએ.