𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int T = scanner.nextInt();
        while (T-- > 0) {
            int N = scanner.nextInt(); 
            int M = scanner.nextInt(); 
            int K = scanner.nextInt(); 

            Map<String, Integer> rowCount = new HashMap<>();

            for (int i = 0; i < N; i++) {
                StringBuilder rowPattern = new StringBuilder();
                for (int j = 0; j < M; j++) {
                    int val = scanner.nextInt();
                    rowPattern.append(val);
                }
                String pattern = rowPattern.toString();
                rowCount.put(pattern, rowCount.getOrDefault(pattern, 0) + 1);
            }

            int maxEqualRows = 0;
            Set<String> processedPatterns = new HashSet<>();

            for (String pattern : rowCount.keySet()) {
                if (processedPatterns.contains(pattern)) {
                    continue; 
                }

                StringBuilder complementBuilder = new StringBuilder();
                for (int i = 0; i < pattern.length(); i++) {
                    complementBuilder.append(pattern.charAt(i) == '0' ? '1' : '0');
                }
                String complement = complementBuilder.toString();

                int countPattern = rowCount.get(pattern);
                int countComplement = rowCount.getOrDefault(complement, 0);

                int inversionsNeeded = Math.min(countPattern, countComplement);

                if (inversionsNeeded <= K) {
                    int totalRows = countPattern + countComplement;
                    maxEqualRows = Math.max(maxEqualRows, totalRows);
                }

                processedPatterns.add(pattern);
                processedPatterns.add(complement);
            }

            System.out.println(maxEqualRows);
        }

        scanner.close();
    }
}

Equal Rows ✅
Google

819 views10:55

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

import java.util.*; public class Main { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int T = scanner.nextInt(); while (T-- > 0) { int N = scanner.nextInt(); int M…

from collections import defaultdict
def solve(N, M, K, mat):
    rf, irf = defaultdict(int), defaultdict(int)
    for i in range(N):
        r = tuple(mat[i])
        ir = tuple(1 - x for x in mat[i])
        rf[r] += 1
        irf[ir] += 1
    res = 0
    for r, c in rf.items():
        res = max(res, c)
        if K > 0:
            res = max(res, c + min(K, irf[r]))
    return res

Equal Rows ✅
Google

895 views11:50

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

long long minimumHealth(vector<int>& damage, int armor) {
        long long s = 0;
        int mx = damage[0];
        for (int& v : damage) {
            s += v;
            mx = max(mx, v);
        }
        return s - min(mx, armor) + 1;
    }

Amazon ✅

1.0K views11:51

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

#include <vector>
#include <iostream>
using namespace std;
int longestDiagonalSegment(vector<vector<int>>& matrix) {
    int rows = matrix.size();
    int cols = matrix[0].size();
    int longest = 0;
    int dR[] = {-1, 1, -1, 1}; 
    int dC[] = {1, 1, -1, -1};  
    for (int r = 0; r < rows; ++r) {
    for (int c = 0; c < cols; ++c) {
    for (int dir = 0; dir < 4; ++dir) {
    int len = 0;
    int rPos = r, cPos = c;
    int pattern[] = {1, 2, 0, 2, 0, 2, 0};
    int pIdx = 0;
    while (rPos >= 0 && rPos < rows && cPos >= 0 && cPos < cols) {
    if (matrix[rPos][cPos] == pattern[pIdx]) {
        ++len;
        pIdx = (pIdx + 1) % 7; 
        } else {
        break;
        }
        rPos += dR[dir];
        cPos += dC[dir];
        }
                
        longest = max(longest, len);
            }
        }
    }

    return longest;
}

Visa ✅

1.1K views17:59

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

IBM✅

819 views18:00

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

def getRank(coffee, chocolate, query):
    n = len(coffee)
    drinks = [(coffee[i], chocolate[i], i+1) for i in range(n)]
    drinks.sort(key=lambda x: (-x[0], -x[1], x[2]))
    result = [drinks[q-1][2] for q in query]
    return result

DE Shaw ✅

867 views18:01

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

def canonical_form(s):
    mapping = {}
    form = []
    next_index = 0

    for char in s:
        if char not in mapping:
            mapping[char] = next_index
            next_index += 1
        form.append(mapping[char])

    return tuple(form)

def solve(N, Q, S, K):
    canonical_map = {}

    for string in S:
        form = canonical_form(string)
        if form not in canonical_map:
            canonical_map[form] = 0
        canonical_map[form] += 1

    result = []
    for query in K:
        query_form = canonical_form(query)
        result.append(canonical_map.get(query_form, 0))

    return result

Google ✅

796 views18:02

𝗖𝗦 𝗔𝗹𝗴𝗼 💻 🌐 『𝗖𝗼𝗺𝗽𝗲𝘁𝗶𝘁𝗶𝘃𝗲 𝗣𝗿𝗼𝗴𝗿𝗮𝗺𝗺𝗶𝗻𝗴』

#include <vector>
using namespace std;

vector<int> solution(vector<int> forest, int bird) {
    vector<int> pos;
    int total_length = 0;
    int direction = 1;
    int n = forest.size();
    while (total_length < 100) {
        if (direction == 1) {
            for (int i = bird + 1; i < n; i++) {
                if (forest[i] > 0) {
                    pos.push_back(i);
                    total_length += forest[i];
                    forest[i] = 0;
                    break;
                }
            }
        } else {
            for (int i = bird - 1; i >= 0; i--) {
                if (forest[i] > 0) {
                    pos.push_back(i);
                    total_length += forest[i];
                    forest[i] = 0;
                    break;
                }
            }
        }
        direction *= -1;
    }
    return pos;
}