प्रौद्योगिकी साझेदारी

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

🍭 大家好这里是कियोतका-सेनपाई , एकः प्रोग्रामरः यः एल्गोरिदम्स् प्रेम्णा पश्यति

💻 ACM银牌🥈| 多次AK大厂笔试 ｜ 编程一对一辅导

✨ अस्याः श्रृङ्खलायाः योजना अस्ति यत् निरन्तरं अद्यतनं करणीयम् Qiuzhao लिखित परीक्षा प्रश्न
👏 感谢大家的订阅➕ 和 喜欢💗

---

📧 清隆这边最近正在收集近一年半互联网笔试题汇总，有需要的小伙伴可以关注 लेखस्य समाप्ति राजकुमारी क्रूजं प्राप्नुत~

🎀 01.A先生的环形花圃

प्रश्नवर्णनम्

क महोदयस्य वृत्ताकारः पुष्पस्तरः अस्ति, यः विभक्तः अस्ति $न$ खण्ड क्षेत्र। प्रारम्भे ए महोदयः गुलाबस्य रोपणार्थं पुष्पशय्यायां त्रीणि क्षेत्राणि चयनं कृतवान् ।

अधुना ए महोदयः पुष्पोद्यानस्य व्याप्तिम् कर्तुं मोबाईल-सञ्चालनस्य उपयोगं कर्तुम् इच्छतिसंतुलित अवस्था。

सन्तुलितावस्था : गुलाबरोपितयोः कस्यापि क्षेत्रयोः मध्ये अन्तरं न्यूनं न भवति $k$(समीपस्थक्षेत्राणां मध्ये अन्तरं भवति $1$）。

चालन संचालनम् : समीपस्थक्षेत्राणां स्थितिं आदानप्रदानं कुर्वन्तु (गुलाबक्षेत्रं रिक्तक्षेत्रं भवति, रिक्तक्षेत्रं गुलाबक्षेत्रं भवति)।

तस्मिन् एव काले ए महोदयः एकः व्यक्तिः अस्ति यः कार्यक्षमतायाः विषये महत् ध्यानं ददाति, अतः सः आशास्ति यत् भवान् न्यूनतमं चालनानां उपयोगं कृत्वा पुष्पशय्यायाः सन्तुलितावस्थां प्राप्तुं शक्नोति।

इनपुट प्रारूप

प्रथमपङ्क्तौ सकारात्मकं पूर्णाङ्कं प्रविशन्तु $त$, जिज्ञासानां संख्यां सूचयन् ।

अग्रिम $त$ रेखाः, प्रत्येकं रेखायां पञ्च धनात्मकाः पूर्णाङ्काः सन्ति$न$、$k$、${एकः}_1$、${एकः}_2$、${एकः}_3$, क्रमशः पुष्पशय्याक्षेत्राणां संख्यां, आवश्यकं न्यूनतमं दूरं, त्रयाणां गुलाबक्षेत्राणां प्रारम्भिकस्थानं च प्रतिनिधियन्ति ।

आउटपुट प्रारूप

उत्पादनम् $त$ रेखाः, प्रत्येकं पूर्णाङ्कं निर्गच्छति यत् पुष्पशय्यायाः समतायां आनेतुं आवश्यकस्य न्यूनतमसङ्ख्यायाः आदानप्रदानस्य प्रतिनिधित्वं करोति ।यदि समता प्राप्तुं न शक्यते तर्हि उत्पादनम्$-1$。

नमूना निवेशः

3
5 1 1 2 3
5 2 1 2 3
6 2 2 3 6
1
2
3
4

नमूना उत्पादनम्

0
-1
1
1
2
3

दत्तांशपरिधिः

$1\le त\le 10^4$
$1\le न\le 10^9$
$1\le k,{एकः}_1,{एकः}_2,{एकः}_3\le न$

उत्तरम्‌

समतायाः स्थितिविश्लेषणेन एषा समस्या समाधानं कर्तुं शक्यते ।

प्रथमं यदि आवश्यकं न्यूनतमं दूरम् $k$ उद्यानक्षेत्राणां संख्यां अतिक्रान्तवान्$न$ one-third of , तर्हि स्थितिः किमपि न पूरयितुं न शक्यते, अस्मिन् समये च निर्गमः$-1$。

अन्यथा प्रथमं त्रयाणां गुलाबक्षेत्राणां स्थानानि क्रमयित्वा ततः समीपस्थगुलाबक्षेत्राणां मध्ये दूरं गणयितुं शक्नुमः ।तदनन्तरं प्रत्येकं दूरं कृते यदि न्यूनं भवति$k$, तदा गतिक्रिया आवश्यकी भवति, गतिसङ्ख्या च $k$ अस्मात् दूरात् भेदः।

अन्ते यदा सर्वे दूराः आवश्यकताः पूरयन्ति तदा पुष्पशय्या सन्तुलितावस्थां प्राप्नोति, ततः कुलचरणसङ्ख्या निर्गन्तुं शक्यते ।

कालजटिलता अस्ति ओ ( त् लॉग् ⁡ त् ) ओ(त लॉग त्) .ओ(तलोछत), अन्तरिक्षजटिलता अस्ति $ओ(1)$。

सन्दर्भ संहिता

• अजगर

t = int(input())

for _ in range(t):
    n, k, *a = map(int, input().split())
    a.sort()

    if k * 3 > n:
        print(-1)
        continue

    b = [a[1] - a[0], a[2] - a[1], n - a[2] + a[0]]
    ans = sum(max(0, k - d) for d in b)

    print(ans)
1
2
3
4
5
6
7
8
9
10
11
12
13
14

• जावा

import java.util.Arrays;
import java.util.Scanner;

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

        while (t-- > 0) {
            int n = sc.nextInt();
            int k = sc.nextInt();
            int[] a = new int[3];
            for (int i = 0; i < 3; i++) {
                a[i] = sc.nextInt();
            }

            Arrays.sort(a);

            if (k * 3 > n) {
                System.out.println(-1);
                continue;
            }

            int[] b = {a[1] - a[0], a[2] - a[1], n - a[2] + a[0]};
            int ans = 0;
            for (int d : b) {
                ans += Math.max(0, k - d);
            }

            System.out.println(ans);
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

• Cpp

#include <iostream>
#include <algorithm>

using namespace std;

int main() {
    int t;
    cin >> t;

    while (t--) {
        int n, k, a[3];
        cin >> n >> k >> a[0] >> a[1] >> a[2];

        sort(a, a + 3);

        if (k * 3 > n) {
            cout << -1 << endl;
            continue;
        }

        int b[] = {a[1] - a[0], a[2] - a[1], n - a[2] + a[0]};
        int ans = 0;
        for (int d : b) {
            ans += max(0, k - d);
        }

        cout << ans << endl;
    }

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

🪐 02.卢小姐的音游金币

समस्या वर्णनम्

लु सुश्री अधुना एव पियानोध्वनिषु केन्द्रितस्य सङ्गीतक्रीडायाः व्यसनं प्राप्तवती अस्ति ।क्रीडायां प्रत्येकस्य पियानो टाइल् इत्यस्य सङ्ख्या भवति, यत्र न्यूनतमा संख्या भवति$1$ . यदि भवन्तः पङ्क्तिबद्धरूपेण वर्धमानसङ्ख्याभिः सह पञ्च पियानो टाइल्स् मारयन्ति तर्हि भवन्तः सुवर्णमुद्रां प्राप्नुवन्ति ।

यथा, यदि मिस् लु संख्याकृतं प्रहरति 1, 2, 3, 4, 5, 6 पियानोखण्डानां, ततः कृते1, 2, 3, 4, 5 एतेषां पञ्चानां खण्डानां कृते क्रमशः वर्धमानसङ्ख्यायाः कृते सा सुवर्णमुद्रां प्राप्स्यति ।

यदा कश्चन स्तरः दीर्घकालं यावत् प्रगतिशीलः भवति तदा सङ्ख्या पुनः सेट् भविष्यति $1$ प्रारंभः। अतः एकस्य स्तरस्य कृते, समानसङ्ख्यायाः परन्तु भिन्नानां बहुविधपियानो टाइल्स् मारयितुं शक्यते ।

ध्यानं कुर्वन्तु यत् सुवर्णमुद्राः प्राप्तुं केवलं पञ्च पियानो टाइल्स् आवश्यकाः सन्ति येषां संख्या एकस्मिन् स्तरे निरन्तरं वर्धमानाः सन्ति ।

मिस् लु इत्यस्याः श्रेष्ठबलस्य कारणात् सा चत्वारि स्तराः उत्तीर्णा अस्ति ।इदानीं मिस् लु इत्यस्याः चत्वारि कठिनतास्तराः दत्ताः सन्ति$एकः$、$ख$、$ग$ तथा$घ$ पियानो टाइल् हिट् इत्यस्य संख्या एतेषु चतुर्षु स्तरेषु सुश्री लु कुलम् कति सुवर्णमुद्राः प्राप्तुं शक्नोति?

इनपुट प्रारूप

प्रथमपङ्क्तौ धनात्मकः पूर्णाङ्कः भवति $न$（$1\le न\le 10^5$), चतुर्षु स्तरेषु मिस् लु इत्यनेन प्रहारितपियानो टाइल्स् इत्यस्य कुलसङ्ख्यायाः प्रतिनिधित्वं करोति ।

अग्रिम $न$ रेखाः, प्रत्येकपङ्क्तौ त्रीणि मापदण्डानि प्रविशन्तु:${एकः}_{अहम्‌}$、${ख}_{अहम्‌}$（$1\le {एकः}_{अहम्‌},{ख}_{अहम्‌}\le 10^9$)तथा ${ग}_{अहम्‌}$（ ci ∈ { ′ A ′ , ′ B ′ , ′ C ′ , ′ D ′ } c_i in {'A', 'B', 'C', 'D'}गअहम्‌​∈{′एकः′,′ख′,′ग′,′घ′}), क्रमशः प्रत्येकस्य पियानो टाइलस्य संख्या, परिमाणं, स्तरं च प्रतिनिधियति ।

आउटपुट प्रारूप

मिस् लु प्राप्तुं शक्नुवन्तः सुवर्णमुद्राणां कुलसङ्ख्यां प्रतिनिधियति पूर्णाङ्कं निर्गच्छतु ।

नमूना निवेशः

11
1 1 A
2 2 A
3 2 A
4 2 A
5 2 A
6 1 A
7 1 B
8 2 B
9 2 B
10 2 B
11 1 B
1
2
3
4
5
6
7
8
9
10
11
12

नमूना उत्पादनम्

3
1

नमूनावर्णनम्

स्तरानाम् कृते $एकः$,प्रथमः 1, 2, 3, 4, 5 भवन्तः सुवर्णमुद्रां प्राप्तुं शक्नुवन्ति, ततः2, 3, 4, 5, 6 भवन्तः अन्यं सुवर्णमुद्रां प्राप्तुं शक्नुवन्ति।

स्तरानाम् कृते $ख$，7, 8, 9, 10, 11 भवन्तः सुवर्णमुद्रां प्राप्तुं शक्नुवन्ति।

अतः कुलम् $3$ सुवर्णमुद्राः ।

नमूना निवेशः 2

5
1 1 C
2 2 C
3 2 C 
4 2 C
6 1 C
1
2
3
4
5
6

नमूनानिर्गमः २

0
1

नमूना वर्णन 2

स्तरे $ग$ In , पञ्च क्रमशः वर्धमानाः संख्याः प्राप्तुं न शक्यन्ते अतः सुवर्णमुद्राणां संख्या अस्ति$0$。

दत्तांशपरिधिः

• $1\le न\le 10^5$
• $1\le {एकः}_{अहम्‌},{ख}_{अहम्‌}\le 10^9$
• ci ∈ { ′ A ′ , ′ B ′ , ′ C ′ , ′ D ′ } c_i in {'A', 'B', 'C', 'D'}गअहम्‌​∈{′एकः′,′ख′,′ग′,′घ′}

उत्तरम्‌

एतस्याः समस्यायाः समाधानं hash tables तथा sorting इत्यस्य उपयोगेन कर्तुं शक्यते । विशिष्टविचाराः यथा - १.

1. hash table इत्यस्य उपयोगं कुर्वन्तु cnt प्रत्येकस्मिन् स्तरे प्रत्येकं संख्या कियत्वारं दृश्यते इति अभिलेखयन्तु। कीलः स्तरवर्णस्य संख्यायाः च संयोजनं भवति, मूल्यं च स्तरस्य संख्यायाः कियत्वारं दृश्यते ।

2. स्तरवर्णानां संख्यानां च अनुसारं निवेशदत्तांशं क्रमबद्धं कुर्वन्तु येन समानस्तरस्य सङ्ख्याः क्रमिकाः सन्ति इति सुनिश्चितं भवति ।

3. क्रमबद्धदत्तांशं भ्रमन्तु, प्रत्येकसङ्ख्यायाः कृते च निर्धारयन्तु यत् तस्य पञ्च क्रमिकसङ्ख्याः सर्वे वर्तमानस्तरस्य सन्ति वा इति । यदि अस्ति तर्हि एतेषां पञ्चानां संख्यानां मध्ये आवृत्तिसङ्ख्यायाः न्यूनतमं मूल्यं गृहीत्वा उत्तरे गणयित्वा एतेषां पञ्चानां संख्यानां आवृत्तिसङ्ख्यायाः न्यूनतमं मूल्यं हृतव्यम्

4. अन्तिमम् उत्तरं सर्वेषां सुवर्णमुद्राणां योगः भवति ये शर्ताः पूरयन्ति ।

कालजटिलता अस्ति ओ ( n log ⁡ n ) O(n log n) .ओ(नलोछन), अन्तरिक्षजटिलता अस्ति $ओ(न)$。

सन्दर्भ संहिता

• अजगर

from collections import defaultdict
import sys

def solve():
    n = int(input())
    cnt = defaultdict(int)
    vec = []

    for _ in range(n):
        a, b, c = input().split()
        a, b = int(a), int(b)
        cnt[c + str(a)] += b
        vec.append((c, a))

    vec.sort()

    ans = 0
    for v in vec:
        arr = [v[0] + str(v[1] + i) for i in range(5)]
        t = min(cnt[a] for a in arr)
        ans += t
        for a in arr:
            cnt[a] -= t

    print(ans)

if __name__ == '__main__':
    solve()
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

• जावा

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

public class Main {
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(br.readLine());

        Map<String, Integer> cnt = new HashMap<>();
        List<int[]> vec = new ArrayList<>();

        for (int i = 0; i < n; i++) {
            String[] input = br.readLine().split(" ");
            int a = Integer.parseInt(input[0]);
            int b = Integer.parseInt(input[1]);
            String c = input[2];
            String key = c + a;
            cnt.put(key, cnt.getOrDefault(key, 0) + b);
            vec.add(new int[]{c.charAt(0), a});
        }

        vec.sort((x, y) -> {
            if (x[0] != y[0]) {
                return x[0] - y[0];
            }
            return x[1] - y[1];
        });

        long ans = 0;
        for (int[] v : vec) {
            String[] arr = new String[5];
            for (int i = 0; i < 5; i++) {
                arr[i] = (char) v[0] + String.valueOf(v[1] + i);
            }
            int t = Integer.MAX_VALUE;
            for (String a : arr) {
                t = Math.min(t, cnt.getOrDefault(a, 0));
            }
            ans += t;
            for (String a : arr) {
                cnt.put(a, cnt.get(a) - t);
            }
        }

        System.out.println(ans);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

• Cpp

#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
#include <climits>
using namespace std;

using ll = long long;

int main() {
    int n;
    cin >> n;
    map<string, ll> cnt;
    vector<pair<string, int>> vec;

    for (int i = 1; i <= n; i++) {
        int a, b;
        string c;
        cin >> a >> b >> c;
        cnt[c + to_string(a)] += b;
        vec.push_back({c, a});
    }

    sort(vec.begin(), vec.end());

    ll ans = 0;
    for (auto& v : vec) {
        vector<string> arr;
        for (int i = 0; i < 5; i++) {
            arr.push_back(v.first + to_string(v.second + i));
        }
        ll t = LLONG_MAX;
        for (auto& a : arr) {
            t = min(t, cnt[a]);
        }
        ans += t;
        for (auto& a : arr) {
            cnt[a] -= t;
        }
    }

    cout << ans << endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45

✨ 03. मिस् लु इत्यस्याः अद्वितीयं उद्यानम्

समस्या वर्णनम्

मिस् लु इत्यस्य दीर्घता अस्ति $न$ सह रोपिते उद्याने$न$ विभिन्नानि पुष्पाणि रोपयन्तु।प्रत्येकस्य पुष्पस्य सौन्दर्यमूल्यं भवति${एकः}_{अहम्‌}$。

लुमहोदया मन्यते यत् सुन्दरं उद्यानं अद्वितीयं भवितुमर्हति अर्थात् अस्ति $न-1$ रोपितपुष्पाणां सौन्दर्यमूल्यं समानं, केवलं$1$ रोपितपुष्पाणां सौन्दर्यमूल्यं अन्यपुष्पेभ्यः भिन्नं भवति ।

प्रत्येकं शल्यक्रियायाः कृते मिस् लु एकं पुष्पं चित्वा तस्य सौन्दर्यमूल्यं वर्धयितुं शक्नोति । $1$ न्यूनीकृतं वा$1$。

अधुना लुमहोदया ज्ञातुम् इच्छति यत् उद्यानं अद्वितीयं कर्तुं कति कार्याणि आवश्यकानि सन्ति।

इनपुट प्रारूप

प्रथमपङ्क्तौ धनात्मकः पूर्णाङ्कः भवति $न$, उद्यानस्य दीर्घतां सूचयति ।

द्वितीया पङ्क्तिः अस्ति $न$ सकारात्मक पूर्णाङ्क${एकः}_1,{एकः}_2,\dots ,{एकः}_{न}$, प्रत्येकस्य पुष्पस्य सौन्दर्यमूल्यं सूचयति ।

आउटपुट प्रारूप

उद्यानं अद्वितीयं कर्तुं आवश्यकानां न्यूनतमसङ्ख्यायाः कार्याणां प्रतिनिधित्वं कृत्वा पूर्णाङ्कं निर्गच्छति ।

नमूना निवेशः

4
1 2 3 4
1
2

नमूना उत्पादनम्

2
1

दत्तांशपरिधिः

• $1\le न\le 10^5$
• $1\le {एकः}_{अहम्‌}\le 10^9$

उत्तरम्‌

इष्टतमं समाधानं मध्यमं भवितुं मध्यमत्वस्य सर्वान् व्ययान् गणयितुं च।

कालजटिलता अस्ति ओ ( n log ⁡ n ) O(n log n) .ओ(नलोछन), अन्तरिक्षजटिलता अस्ति $ओ(न)$。

सन्दर्भ संहिता

• अजगर

def main():
    n = int(input())
    w = list(map(int, input().split()))
    w.sort()
    if w[0] == w[n - 1]:
        print("1")
        return
    s1, s2 = 0, 0
    m1, m2 = w[(n - 1) // 2], w[(n + 1) // 2]
    for i in range(n - 1):
        s1 += abs(m1 - w[i])
    for i in range(1, n):
        s2 += abs(m2 - w[i])
    print(min(s1, s2))

if __name__ == "__main__":
    main()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• जावा

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[] w = new int[n];
        for (int i = 0; i < n; i++)
            w[i] = scanner.nextInt();
        Arrays.sort(w);
        if (w[0] == w[n - 1]) {
            System.out.println("1");
            return;
        }
        long s1 = 0, s2 = 0;
        int m1 = w[(n - 1) / 2], m2 = w[(n + 1) / 2];
        for (int i = 0; i < n - 1; i++)
            s1 += Math.abs(m1 - w[i]);
        for (int i = 1; i < n; i++)
            s2 += Math.abs(m2 - w[i]);
        System.out.println(Math.min(s1, s2));
    }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• Cpp

#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long ll;
const int N = 100010;

int main() {
    int n, w[N];
    cin >> n;
    for (int i = 0; i < n; i++)
        cin >> w[i];
    sort(w, w + n);
    if (w[0] == w[n - 1]) {
        cout << "1" << endl;
        return 0;
    }
    ll s1 = 0, s2 = 0;
    int m1 = w[(n - 1) / 2], m2 = w[(n + 1) / 2];
    for (int i = 0; i < n - 1; i++)
        s1 += abs(m1 - w[i]);
    for (int i = 1; i < n; i++)
        s2 += abs(m2 - w[i]);
    cout << min(s1, s2) << endl;
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

🥝 04.LYA的字符画

प्रश्नवर्णनम्

अधुना एव एल.वाई.ए.यथा "आबब्च्च्द्देफ" इति वर्णचित्रस्य शृङ्गारः$6$。

LYA इत्यस्य मित्रं तस्याः क $0$ तथा$1$ वर्णचित्रणस्य आकृष्टः LYA अस्य तारस्य सर्वाणि ताराः ज्ञातुम् इच्छति ।उपतारम्शृङ्गारस्य योगः किम् ?

नोटः- सन्ति ${ग}_{न+1}^2$ उपतारम् ।

इनपुट प्रारूप

प्रथमपङ्क्तौ सकारात्मकं पूर्णाङ्कं प्रविशन्तु $न$, तारस्य दीर्घतां सूचयति ।

द्वितीयपङ्क्तिदीर्घता अस्ति $न$ इत्यस्य$01$ सूत्र।

आउटपुट प्रारूप

सर्वेषां उपतारानाम् सौन्दर्यशास्त्रस्य योगं प्रतिनिधियति पूर्णाङ्कं निर्गच्छतु ।

नमूना निवेशः

4
0011
1
2

नमूना उत्पादनम्

14
1

दत्तांशपरिधिः

$1\le न\le 2\times 10^5$

उत्तरम्‌

उपसर्गयोगस्य विचारेण एषा समस्या समाधानं कर्तुं शक्यते ।

प्रथमं वयं स्ट्रिंग् इत्यस्य उपस्ट्रिंग् इत्यस्य कुलसङ्ख्यां गणयितुं शक्नुमः अर्थात् $\frac{न(न+1)}{2}$。

ततः, वयं स्ट्रिंग् इत्यस्य उपरि पुनरावृत्तिं कुर्मः तथा च चरानाम् उपयोगं कुर्मः $ल$ वर्तमान क्रमिक समानचिह्नानां आरम्भस्थानं अभिलेखयन्तु, चरः$र$ वर्तमानस्थानं अभिलेखयन्तु।कदा$स[र]\ne स[र-1]$ यदा , तस्य अर्थः अस्ति यत् नूतनं चिह्नं दृश्यते, वयं च गणनां कर्तुं शक्नुमः$[ल,र)$ अन्तरालस्य उपतारसङ्ख्या इत्यर्थः$\frac{(र-ल)(र-ल+1)}{2}$, उपतारानाम् कुलसंख्यातः घटयन्तु ।

अन्ते यत् अवशिष्टं तत् सर्वेषां सुन्दराणां उपतारानाम् संख्या, या निर्गन्तुं शक्यते ।

कालजटिलता $ओ(न)$, अन्तरिक्षजटिलता $ओ(1)$。

सन्दर्भ संहिता

• अजगर

def cal(length):
    return length * (length + 1) // 2

n = int(input())
s = input() + '#'

ans = 0
total = cal(n)
l = 0
for r in range(1, n + 1):
    if s[r] != s[r - 1]:
        ans += total - cal(l) - cal(n - r)
        l = r

print(ans)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

• जावा

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        String s = sc.next() + "#";
        
        long ans = 0;
        long total = cal(n);
        int l = 0;
        for (int r = 1; r <= n; r++) {
            if (s.charAt(r) != s.charAt(r - 1)) {
                ans += total - cal(l) - cal(n - r);
                l = r;
            }
        }
        System.out.println(ans);
    }
    
    private static long cal(int len) {
        return (long) len * (len + 1) / 2;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

• Cpp

#include <iostream>
#include <string>

using namespace std;

using ll = long long;

ll cal(int len) {
    return (ll) len * (len + 1) / 2;
}

int main() {
    int n;
    cin >> n;
    string s;
    cin >> s;
    s += "#";
    
    ll ans = 0;
    ll total = cal(n);
    int l = 0;
    for (int r = 1; r <= n; r++) {
        if (s[r] != s[r - 1]) {
            ans += total - cal(l) - cal(n - r);
            l = r;
        }
    }
    cout << ans << endl;
    
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31

🌸 05.卢小姐的数组删除计划

प्रश्ननाम

समस्या वर्णनम्

मिस् लु इत्यस्य अतीव भव्ययोजना अस्ति, सा विश्वस्य सर्वाणि सरणीनि विलोपयितुम् इच्छति! परन्तु तस्याः क्षमता सीमितं भवति ।

अधुना मिस् लु इत्यस्याः पुरतः एकस्य दीर्घता अस्ति $न$ array of$एकः$, सा ज्ञातुम् इच्छति यत् अस्मिन् सरणीयां सा अधिकतया कति तत्त्वानि विलोपयितुं शक्नोति ।

इनपुट प्रारूप

प्रथमपङ्क्तौ धनात्मकः पूर्णाङ्कः भवति $न$, एकं सरणीं प्रतिनिधियति $एकः$ दैर्घ्यम्‌।

द्वितीया पङ्क्तिः अस्ति $न$ अन्तरिक्ष-विभक्त धनात्मक पूर्णांक${एकः}_1,{एकः}_2,\dots ,{एकः}_{न}$, एकं सरणीं प्रतिनिधियति $एकः$ तत्त्वानि ।

आउटपुट प्रारूप

एकं पूर्णाङ्कं निर्गच्छतु, यत् अधिकतमं तत्त्वानां संख्यां सूचयति यत् Miss Lu विलोपयितुं शक्नोति ।

नमूना निवेशः

4
1 2 1 2
1
2

नमूना उत्पादनम्

1
1

दत्तांशपरिधिः

• $1\le न\le 2\times 10^5$
• $1\le {एकः}_{अहम्‌}\le 10^9$

उत्तरम्‌

क्रमाङ्कनस्य, द्विगुणसूचकानां च विचाराणां उपयोगेन एषा समस्या समाधानं कर्तुं शक्यते ।

प्रथमं वयं array परिवर्तयितुं शक्नुमः $एकः$ in इत्यस्य तत्त्वानि मूल्येन क्रमबद्धानि भवन्ति, तथा च सरणीयां प्रत्येकस्य तत्त्वस्य मूलस्थानं अभिलेखितं भवति । अस्य उद्देश्यं अस्माकं कृते तस्यैव तत्त्वस्य स्थितिपरिधिं अन्वेष्टुं सुविधा भवति ।

तदनन्तरं वयं क्रमबद्धसरण्याः माध्यमेन पुनरावृत्तिं कर्तुं शक्नुमः तथा च प्रत्येकस्य तत्त्वस्य कृते सर्वेषां तत्त्वानां स्थितिपरिधिं ज्ञातुं शक्नुमः येषां मूल्यं तस्य समानम् अस्ति $[ल,आर]$ . अस्मिन् परिधिस्थानि तत्त्वानि मूलसरणौ समानतत्त्वद्वयस्य मध्ये स्थितानि इति कारणेन विलोपयितुं शक्यन्ते ।वयं श्रेणीं गणयितुं शक्नुमः$[ल,आर]$ इत्यस्मिन् तत्त्वानां संख्या$आर-ल-1$, वर्तमानस्य अधिकतमसङ्ख्यायाः विलोपिततत्त्वानां सह तुलनां कुर्वन्तु, अधिकतमं मूल्यं च अद्यतनं कुर्वन्तु ।

अन्ते विलोपितानां तत्त्वानां अधिकतमं संख्यां आउटपुट् कुर्वन्तु ।

कालजटिलता अस्ति ओ ( n log ⁡ n ) O(n log n) .ओ(नलोछन) , मुख्यतया क्रमणस्य समयजटिलता ।अन्तरिक्षजटिलता अस्ति$ओ(न)$, तत्त्वस्य मूलस्थानं संग्रहीतुं प्रयुक्तम् ।

सन्दर्भ संहिता

• अजगर

n = int(input())
a = list(map(int, input().split()))

idx = sorted(range(n), key=lambda x: a[x])

ans = 0
i = 0
while i < n:
    j = i
    L, R = n, -1
    while j < n and a[idx[j]] == a[idx[i]]:
        L = min(L, idx[j])
        R = max(R, idx[j])
        j += 1
    ans = max(ans, R - L - 1)
    i = j

print(ans)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• जावा

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int[] a = new int[n];
        Integer[] idx = new Integer[n];

        for (int i = 0; i < n; i++) {
            a[i] = sc.nextInt();
            idx[i] = i;
        }

        Arrays.sort(idx, Comparator.comparingInt(i -> a[i]));

        int ans = 0;
        for (int i = 0; i < n;) {
            int j = i;
            int L = n, R = -1;
            while (j < n && a[idx[j]] == a[idx[i]]) {
                L = Math.min(L, idx[j]);
                R = Math.max(R, idx[j]);
                j++;
            }
            ans = Math.max(ans, R - L - 1);
            i = j;
        }

        System.out.println(ans);
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

• Cpp

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    int n;
    cin >> n;
    vector<int> a(n);
    vector<int> idx(n);

    for (int i = 0; i < n; i++) {
        cin >> a[i];
        idx[i] = i;
    }

    sort(idx.begin(), idx.end(), [&](int i, int j) {
        return a[i] < a[j];
    });

    int ans = 0;
    for (int i = 0; i < n;) {
        int j = i;
        int L = n, R = -1;
        while (j < n && a[idx[j]] == a[idx[i]]) {
            L = min(L, idx[j]);
            R = max(R, idx[j]);
            j++;
        }
        ans = max(ans, R - L - 1);
        i = j;
    }

    cout << ans << endl;

    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

अन्ते लिखन्तु

अत्र अहं भवद्भ्यः वरिष्ठस्य शरद-नियुक्ति-सहचरस्य चेक-इन-केबिनस्य अनुशंसा कर्तुम् इच्छामि यत् 31 दिवसेषु सामान्य-अन्तर्जाल-लिखित-परीक्षा-प्रश्नानां समाधानार्थं भवन्तं पदे पदे नेष्यति |.

🎧 秋招陪伴刷题打卡

• परीक्षणपठनम् : १.

[शरद भर्ती चेक-इन] Day01-अनुकूलित क्रमबद्धता-CSDN ब्लॉग

[शरदऋतु भर्ती चेक-इन] Day02-The Strongest Two-Section Series-Binary Search-CSDN Blog

[शरद ऋतु भर्ती चेक-इन] Day03-The Strongest द्वि-बिन्दु-श्रृङ्खला-द्वि-बिन्दु-उत्तर-CSDN Blog

वयं पूर्वप्रमुखनिर्मातृणां वास्तविकप्रश्नानां ऑनलाइनसमीक्षां प्रदामः इच्छुकाः मित्राणि अधिकं ज्ञातुं Qinglong प्रति निजीसन्देशं प्रेषयितुं शक्नुवन्ति।

अपि च अधिकं! अधि!

✈️ लिखित परीक्षा प्रश्नों का व्यापक सारांश