[Avance en el reclutamiento de otoño] Prueba escrita de reclutamiento de otoño de 2024-Preguntas de la prueba escrita de ByteDance-01-Soluciones de preguntas en tres idiomas (Java/Cpp/Python)

2024-07-12

🍭 大家好这里是Kiyotaka-senpai , un programador que ama los algoritmos

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

✨ Esta serie planea continuar actualizándose Preguntas del examen escrito de Qiuzhao
👏 感谢大家的订阅➕ 和喜欢💗

📧 清隆这边最近正在收集近一年半互联网笔试题汇总，有需要的小伙伴可以关注 Fin del artículo Consigue el crucero princesa ~

Directorio de artículos

escribe al final
- 🎧 秋招陪伴刷题打卡
- ✈️ Un resumen completo de las preguntas del examen escrito

Insertar descripción de la imagen aquí

🎀 01.A先生的环形花圃

Descripción de la pregunta

El señor A tiene un macizo de flores circular, que está dividido en $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ área del bloque. Inicialmente, el Sr. A seleccionó tres áreas del macizo de flores para plantar rosas.

Ahora, el Sr. A quiere utilizar operaciones móviles para hacer llegar el jardín de flores.Estado de equilibrio。

Estado de equilibrio: La distancia entre dos áreas plantadas con rosas no es menor que $a$ (La distancia entre áreas adyacentes es $1$ ）。

Operación de movimiento: intercambia el estado de las áreas adyacentes (el área rosa se convierte en un área vacía, el área vacía se convierte en un área rosa).

Al mismo tiempo, el Sr. A es una persona que presta gran atención a la eficiencia, por lo que espera que pueda utilizar la mínima cantidad de movimientos para que el macizo de flores alcance un estado de equilibrio.

Formato de entrada

Ingrese un número entero positivo en la primera línea $a$ , indicando el número de consultas.

Próximo $a$ líneas, cada línea contiene cinco números enteros positivos $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ 、 $a$ 、 $un_1$ 、 $un_2$ 、 $un_3$ , que representan respectivamente el número de áreas de macizos de flores, la distancia mínima requerida y la posición inicial de las tres áreas de rosas.

Formato de salida

producción $a$ líneas, cada una de las cuales genera un número entero que representa el número mínimo de intercambios necesarios para equilibrar el macizo de flores.Si no se puede alcanzar el equilibrio, la producción $- 1$ 。

Entrada de muestra

Salida de muestra

rango de datos

$10^4$
$10^9$
$a_1, a_2, a_3 leq n$

respuesta

Este problema se puede resolver analizando las condiciones de equilibrio.

Primero, si la distancia mínima requerida $a$ Se superó el número de zonas ajardinadas $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ un tercio de , entonces la condición no se puede cumplir pase lo que pase, y en este momento la salida $- 1$ 。

De lo contrario, primero podemos ordenar las posiciones de las tres áreas de rosas y luego calcular la distancia entre áreas de rosas adyacentes.A continuación, para cada distancia, si es menor que $a$ , entonces se requiere una operación de movimiento y el número de movimientos es $a$ La diferencia desde esta distancia.

Finalmente, cuando todas las distancias cumplen los requisitos, el macizo de flores alcanza un estado de equilibrio y se puede generar el número total de movimientos.

La complejidad del tiempo es $Ohhhhhhhhhh (a Lo gramoramoramoramo a)$ , la complejidad del espacio es $Ohhhhhhhhhh (1)$ 。

Código de referencia

Pitón

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

Java

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

#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.卢小姐的音游金币

Descripción del problema

Recientemente, la Sra. Lu se ha vuelto adicta a un juego de música que se centra en los sonidos del piano.En el juego, cada ficha de piano tiene un número, siendo el número mínimo $1$ . Si golpeas cinco fichas de piano con números crecientes seguidas, obtendrás una moneda de oro.

Por ejemplo, si la señorita Lu acierta el número 1, 2, 3, 4, 5, 6 de piezas para piano, luego para1, 2, 3, 4, 5 Por estos cinco bloques con números crecientes consecutivos, obtendrá una moneda de oro.

Cuando un nivel ha progresado durante mucho tiempo, el número se restablecerá. El número de reinicio cambiará de. $1$ comenzar. Entonces, para un nivel, es posible tocar varias fichas de piano con el mismo número pero diferentes.

Tenga en cuenta que sólo se requieren cinco fichas de piano con números en continuo aumento en el mismo nivel para obtener monedas de oro.

Debido a la fuerza superior de la señorita Lu, ha superado cuatro niveles.Miss Lu ahora tiene cuatro niveles de dificultad. $A$ 、 $B$ 、 $C$ y $D$ Número de golpes del mosaico del piano. ¿Cuántas monedas de oro puede obtener la Sra. Lu en total en estos cuatro niveles?

Formato de entrada

La primera línea contiene un número entero positivo. $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ （ $10^5$ ), que representa el número total de fichas de piano golpeadas por Miss Lu en los cuatro niveles.

Próximo $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ líneas, ingrese tres parámetros en cada línea: $yo_yo$ 、 $b_i$ （ $a_i, b_i leq 10^9$ )y $c_i$ （ $c_i en {'A', 'B', 'C', 'D'}$ ), que representan respectivamente el número, la cantidad y el nivel de cada ficha de piano.

Formato de salida

Genere un número entero que represente la cantidad total de monedas de oro que la señorita Lu puede obtener.

Entrada de muestra

Salida de muestra

3
1

Descripción de la muestra

Para niveles $A$ ,primero 1, 2, 3, 4, 5 Puedes conseguir una moneda de oro y luego2, 3, 4, 5, 6 Puedes conseguir otra moneda de oro.

Para niveles $B$ ，7, 8, 9, 10, 11 Puedes conseguir una moneda de oro.

Por lo tanto, un total de $3$ monedas de oro.

Entrada de muestra 2

Salida de muestra 2

0
1

Descripción de la muestra 2

en el nivel $C$ En , no se pueden obtener cinco números crecientes consecutivos, por lo que la cantidad de monedas de oro es $0$ 。

rango de datos

$10^5$
$a_i, b_i leq 10^9$
$c_i en {'A', 'B', 'C', 'D'}$

respuesta

Este problema se puede resolver mediante tablas hash y clasificación. Las ideas específicas son las siguientes:

Usar tabla hash cnt Anota el número de veces que aparece cada número en cada nivel. La clave es la combinación del carácter del nivel y el número, y el valor es la cantidad de veces que aparece el número en el nivel.
Ordene los datos de entrada según los caracteres y números de nivel para garantizar que los números del mismo nivel sean consecutivos.
Recorra los datos ordenados y, para cada número, determine si sus cinco números consecutivos existen en el nivel actual. Si existe, tome el valor mínimo del número de apariciones entre estos cinco números, cuéntelo en la respuesta y reste el valor mínimo del número de apariciones de estos cinco números.
La respuesta final es la suma de todas las monedas de oro que cumplen las condiciones.

La complejidad del tiempo es $Ohhhhhhhhhh (norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte Lo gramoramoramoramo norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte)$ , la complejidad del espacio es $Ohhhhhhhhhh (norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte)$ 。

Código de referencia

Pitó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

Java

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

#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. El jardín único de Miss Lu

Descripción del problema

La señorita Lu tiene una longitud de $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ en un jardín plantado con $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ Planta diferentes flores.Cada flor tiene un valor de belleza. $yo_yo$ 。

La Sra. Lu cree que un hermoso jardín debe ser único, es decir, debe tener $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte - 1$ El valor de belleza de las flores plantadas es el mismo, sólo que $1$ El valor de belleza de las flores plantadas es diferente al de otras flores.

Para cada operación, la señorita Lu puede elegir una flor y aumentar su valor de belleza. $1$ o menos $1$ 。

Ahora, la Sra. Lu quiere saber cuántas operaciones se necesitan para que el jardín sea único.

Formato de entrada

La segunda línea contiene $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ entero positivo $a_1, a_2, ldots, a_n$ , indicando el valor de belleza de cada flor.

Formato de salida

Genera un número entero que representa el número mínimo de operaciones necesarias para que el jardín sea único.

Entrada de muestra

Salida de muestra

2
1

rango de datos

$10^5$
$a_i leq 10^9$

respuesta

La solución óptima es convertirse en la mediana y enumerar todos los costos de convertirse en la mediana.

Código de referencia

Pitó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

Java

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

#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的字符画

Descripción de la pregunta

LYA recientemente se ha obsesionado con la pintura de personajes. Ella cree que la belleza de una pintura de personajes es igual al número de símbolos idénticos consecutivos en la pintura de personajes.Por ejemplo, la estética del personaje que pinta "aabbccddef" es $6$ 。

La amiga de LYA le dio un $0$ y $1$ LYA, que se ha obsesionado con el dibujo de personajes, quiere saber todos los hilos que componen este hilo.subcadena¿Cuál es la suma de la estética?

Nota: Hay $C^{2}_{n+1}$ subcadena.

Formato de entrada

Ingrese un número entero positivo en la primera línea $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ , indicando la longitud de la cadena.

La longitud de la segunda línea es $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ de $01$ Cadena.

Formato de salida

Genere un número entero que represente la suma de la estética de todas las subcadenas.

Entrada de muestra

Salida de muestra

14
1

rango de datos

$10^5$

respuesta

Este problema se puede resolver mediante la idea de suma de prefijo.

Primero, podemos calcular el número total de subcadenas de la cadena, es decir $n ( n + 1 ) 2 frac{n(n+1)}{2}$ 。

Luego, iteramos sobre la cadena y usamos las variables. $yo$ Registre la posición inicial de los símbolos idénticos consecutivos actuales, variable $a$ Registre la ubicación actual.cuando $s [a] \neq = s [a - 1]$ Cuando , significa que aparece un nuevo símbolo, y podemos calcular $[yo, a)$ El número de subcadenas en el intervalo, es decir $( r − l ) ( r − l + 1 ) 2 frac{(rl)(r-l+1)}{2}$ , réstelo del número total de subcadenas.

Finalmente, lo que queda es el número de todas las hermosas subcadenas que se pueden generar.

complejidad del tiempo $Ohhhhhhhhhh (norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte)$ , complejidad espacial $Ohhhhhhhhhh (1)$ 。

Código de referencia

Pitón

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

Java

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

#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.卢小姐的数组删除计划

Nombre de la pregunta

Descripción del problema

La señorita Lu tiene un gran plan: ¡quiere eliminar todas las matrices del mundo! Pero su habilidad es limitada solo puede seleccionar dos elementos idénticos en la matriz cada vez y eliminar todos los elementos entre ellos (incluidos los dos elementos mismos).

Ahora, frente a la señorita Lu, hay un largo de $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ gama de $a$ , quiere saber cuántos elementos de esta matriz puede eliminar como máximo.

Formato de entrada

La segunda línea contiene $norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte$ enteros positivos separados por espacios $a_1, a_2, ldots, a_n$ , representa una matriz $a$ Elementos.

Formato de salida

Genere un número entero, que indica la cantidad máxima de elementos que Miss Lu puede eliminar.

Entrada de muestra

Salida de muestra

1
1

rango de datos

$10^5$
$a_i leq 10^9$

respuesta

Este problema se puede resolver utilizando las ideas de clasificación y punteros dobles.

Primero, podemos convertir la matriz. $a$ Los elementos se ordenan por valor y se registra la posición original de cada elemento en la matriz. El propósito de esto es facilitarnos encontrar el rango de posición de un mismo elemento.

A continuación, podemos iterar a través de la matriz ordenada y, para cada elemento, encontrar el rango de posición de todos los elementos que tienen el mismo valor. $[yo, R]$ . Los elementos de este rango se pueden eliminar porque están ubicados entre dos elementos idénticos en la matriz original.Podemos calcular el rango $[yo, R]$ El número de elementos en $R - yo - 1$ , compárelo con el número máximo actual de elementos eliminados y actualice el valor máximo.

Finalmente, genere el número máximo de elementos eliminados.

La complejidad del tiempo es $Ohhhhhhhhhh (norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte Lo gramoramoramoramo norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte)$ , principalmente la complejidad temporal de la clasificación.La complejidad del espacio es $Ohhhhhhhhhh (norteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorteorte)$ , utilizado para almacenar la posición original del elemento.

Código de referencia

Pitó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

Java

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

#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

escribe al final

Aquí me gustaría recomendarle la cabina de registro de acompañantes de reclutamiento de otoño para personas mayores. Le llevará paso a paso a resolver preguntas comunes de exámenes escritos de Internet en 31 días.

🎧 秋招陪伴刷题打卡

Lectura de prueba:

[Registro de reclutamiento de otoño] Día 01-Clasificación personalizada-Blog CSDN

[Registro de reclutamiento de otoño] Día 02: la serie de dos secciones más sólida: búsqueda binaria-Blog de CSDN

[Registro de reclutamiento de otoño] Día 03: La serie de dos puntos más sólida: Respuesta de dos puntos: Blog de CSDN

Proporcionamos reseñas en línea de preguntas reales de los principales fabricantes anteriores. Los amigos interesados pueden enviar un mensaje privado a Qinglong para obtener más información.

Insertar descripción de la imagen aquí

¡Y más! ¡Y más! ¡además!

✈️ Un resumen completo de las preguntas del examen escrito

Insertar descripción de la imagen aquí

Compartir tecnología