primera pregunta
1. El número
de briquetas Hay una pila de briquetas en forma de pirámide triangular. En concreto:
1 en la primera capa,
3 en la segunda capa (dispuestas en triángulo),
6 en la tercera capa (dispuestas en triángulo),
10 en la cuarta capa (dispuestas en triángulo),
....
Si hay son 100 capas en total, ¿cuántas briquetas hay?
Complete el número que representa el número total de briquetas.
Nota: Lo que envíe debe ser un número entero, no complete ningún contenido adicional o texto explicativo.
Respuesta: 171700
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char** argv) {
int sum = 0;
int add = 1;
int now = 0;
for(int i = 0; i < 100; i++){
now += add;
sum += now;
add++;
}
cout << sum ;
return 0;
}Segunda pregunta
Velas de cumpleaños Cierta
persona ha celebrado una fiesta de cumpleaños todos los años desde cierto año, y cada vez que apaga el mismo número de velas que su edad.
Contando ahora, apagó un total de 236 velas.
Disculpe, ¿a qué edad empezó su fiesta de cumpleaños?
Por favor, ingrese la edad cuando comenzó la fiesta de cumpleaños.
Nota: Lo que envíe debe ser un número entero, no complete ningún contenido adicional o texto explicativo.
Respuesta: 26
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char** argv) {
for(int x = 1; x < 100; x++){
for(int n = 0; n < 100; n++){
if(n * x + n*(n-1)/2 == 236){
cout << x;
}
}
}
return 0;
}Tercera pregunta
Fórmula de invento En
esta fórmula, AI representa números del 1 al 9, y letras diferentes representan números diferentes.
Por ejemplo:
6 + 8/3 + 952/714 es una solución,
5 + 3/1 + 972/486 es otra solución.
¿Cuántas soluciones hay en esta fórmula?
Nota: Su envío debe ser un número entero, no complete ningún contenido adicional o texto explicativo.
Respuesta: 29
#include <iostream>
using namespace std;
/* run this program using the console pauser or add your own getch, system("pause") or input loop */
int main(int argc, char** argv) {
int count = 0;
for(int a = 1; a < 10; a++){
for(int b = 1; b < 10; b++){
if(b != a){
for(int c = 1; c < 10; c++){
if( c != b && c != a){
for(int d = 1; d < 10; d++){
if(d != c && d != b && d != a){
for(int e = 1; e < 10; e++){
if(e != d && e != c && e != b && e != a ){
for(int f = 1; f < 10; f++){
if(f != e && f != d && f != c && f != b && f != a){
for(int g = 1; g < 10; g++){
if(g != f && g != e && g != d && g != c && g != b && g != a){
for(int h = 1; h < 10; h++){
if(h != g && h != f && h != e && h != d && h != c && h != b && h != a){
for(int i = 1; i < 10; i ++){
if(i != h && i != g && i != g && i != f && i !=e && i != d && i != c && i != b && i !=a){
int num1 = a * c * (g*100 + h*10 + i);
int num2 = b * (g*100 + h*10 + i);
int num3 = c * (d*100 + e*10 + f);
int num4 = 10 * c * (g*100 + h*10 + i);
if( num1 + num2 + num3 == num4){
count ++;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
cout << count;
return 0;
}Arreglo completo:
int main(){
int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int count = 0;
do{
int sum1, sum2, sum3, sum;
sum1 = a[1] * a[3] * (a[7]*100 + a[8]*10 + a[9]);
sum2 = a[2] * (a[7]*100 + a[8]*10 + a[9]);
sum3 = a[3] * (a[4]*100 + a[5]*10 + a[6]);
sum = 10 * a[3] * (a[7]*100 + a[8]*10 + a[9]);
if(sum1 + sum2 + sum3 == sum){
count ++;
}
}while(next_permutation(a+1, a+1+9));
cout << count;
}
Cuarta pregunta
Clasificación rápida La clasificación se utiliza a menudo en diversas situaciones.
La clasificación rápida es un algoritmo eficiente y de uso muy común.
La idea es: primero seleccione una "regla" y
utilícela para tamizar toda la cola
para asegurarse de que los elementos de la izquierda no sean más grandes que ella y los elementos de la derecha no sean más pequeños que ella.
De esta forma, el problema de clasificación se divide en dos subintervalos.
Luego, ordena los subintervalos por separado.
El siguiente código es una implementación. Analice y complete los códigos que faltan en la parte subrayada.
#include <stdio.h>
void swap(int a[], int i, int j)
{
int t = a[i];
a[i] = a[j];
a[j] = t;
}
int partition(int a[], int p, int r)
{
int i = p;
int j = r + 1;
int x = a[p];
while(1){
while(i<r && a[++i]<x);
while(a[--j]>x);
if(i>=j) break;
swap(a,i,j);
}
______________________;
return j;
}
void quicksort(int a[], int p, int r)
{
if(p<r){
int q = partition(a,p,r);
quicksort(a,p,q-1);
quicksort(a,q+1,r);
}
}
int main()
{
int i;
int a[] = {5,13,6,24,2,8,19,27,6,12,1,17};
int N = 12;
quicksort(a, 0, N-1);
for(i=0; i<N; i++) printf("%d ", a[i]);
printf("\n");
return 0;
}Respuesta: intercambio (a, p, j);
int i = first;
int j = end;
int x = r[first];
while(1){
while(i < end && r[i++] < x)
while(j > first && r[j--] > x);
if(i >= j){
break;
}
swap(r[i], r[j]);
}
swap(r[i], r[j]);Por cierto, revise la cola rápida:
#include <iostream>
using namespace std;
void swap(int *i, int *j){
int temp;
temp = *i;
*i = *j;
*j = temp;
}
int Partion(int r[], int first, int end){
int i = first, j = end;
while(i < j){
while(i < j && r[i] <= r[j]){
j--; //右侧扫描
}
if(i < j){
swap(&r[i], &r[j]);
i++; //右侧较小值交换到前面
}
while(i < j && r[i] <= r[j]){
swap(&r[i], &r[j]);
j--; //左侧较大值交换到后面
}
}
return i;
}
void QuickSort(int r[], int first, int end){
int pivot;
if(first < end){
pivot = Partion(r, first, end);
QuickSort(r, first, pivot-1);
QuickSort(r, pivot+1, end);
}
}
int main(int argc, char** argv) {
int a[] = {5,13,6,24,2,8,19,27,6,12,1,17};
int N = 12;
QuickSort(a, 0, N-1);
for(int i = 0; i < N; i++){
cout << i << " ";
}
return 0;
}Quinta pregunta
Para sortear el
Planeta X, se enviará un grupo de observación de 5 miembros a Star W.
Entre ellos: El
país A puede enviar hasta 4 personas.
El país B puede enviar hasta 2 personas.
El país C puede enviar hasta 2 personas.
… ¿
Cuántas combinaciones diferentes de países diferentes enviará la misión de observación a W Star al final?
El siguiente procedimiento resuelve este problema.
En la matriz, un [] es el mayor número de lugares que puede enviar cada país.
El resultado de la ejecución del programa es:
DEFFF
CEFFF
CDFFF
CDEFF
CCFFF
CCEFF
CCDFF
CCDEF
BEFFF
BDFFF
BDEFF
BCFFF
BCEFF
BCDFF
BCDEF
. ...
(Se omite a continuación, un total de 101 líneas)
#include <stdio.h>
#define N 6
#define M 5
#define BUF 1024
void f(int a[], int k, int m, char b[])
{
int i,j;
if(k==N){
b[M] = 0;
if(m==0) printf("%s\n",b);
return;
}
for(i=0; i<=a[k]; i++){
for(j=0; j<i; j++) b[M-m+j] = k+'A';
______________________; //填空位置
}
}
int main()
{
int a[N] = {4,2,2,1,1,3};
char b[BUF];
f(a,0,M,b);
return 0;
}Respuesta: f (a, k + 1, mi, b);
Comprender el análisis de código:
#include <stdio.h>
#define N 6 //六个国家
#define M 5 //5个人
#define BUF 1024
void f(int a[], int k, int m, char b[])
{
int i,j;
if(k==N){ //k是国家编号，当k==N时表示此时已经全部安排了
b[M] = 0;
if(m==0) printf("%s\n",b); //m表示剩余名额数量
return;
}
for(i=0; i<=a[k]; i++){
for(j=0; j<i; j++)
b[M-m+j] = k+'A'; //M-m+j 表示选取几个国家中的五个人去的几种方式
// ______________________; //填空位置，得出这里是个递归
f(a, k+1, m-i, b);
}
}
int main()
{
int a[N] = {4,2,2,1,1,3}; //六个国家, a[i] 分别表示每个国家可以去的人数
char b[BUF];
f(a,0,M,b);
return 0;
}Sexta pregunta
Completa el número de cuadrados Completa los números
del
0 al 9 en los siguientes 10 cuadrados . Requisito: dos números consecutivos no pueden ser adyacentes.
(Izquierda y derecha, arriba y abajo, y las diagonales son todas adyacentes)
¿Cuántos esquemas de llenado posibles hay?
Complete un número entero que represente el número de planes.
Nota: Lo que envíe debe ser un número entero, no complete ningún contenido adicional o texto explicativo.
Respuesta: 1580
Aquí, todos los gráficos transversales utilizados en DFS son de izquierda a derecha y luego comienzan una nueva línea, en lugar de girar de izquierda a derecha, este método puede ser relativamente simple y se puede verificar cada vez que se completa el número, solo cuatro aspectos deben ser revisados, a saber (izquierda, arriba a la izquierda, arriba, arriba a la derecha).
Luego, cada vez que verifique, la diferencia entre el número en diferentes direcciones y el número, el valor absoluto es 1, lo que significa que los extremos adyacentes devuelven directamente falso, hasta que se prueben todas las direcciones, puede devolver verdadero como un número adecuado.
#include <iostream>
#include<stdio.h>
#include<algorithm>
#include<string.h>
#include<math.h>
using namespace std;
int a[4][4];
int vis[11];
int cnt=0;
bool check(int x,int y,int v){
//转向
int dir[4][2]={
{0,-1},{-1,-1},{-1,0},{-1,1}};//左 左上 上 右上
for(int i=0;i<4;i++){
int xx=x+dir[i][0];
int yy=y+dir[i][1];
if(xx<3 && xx>=0 && yy<4 && yy>=0){
if(abs(a[xx][yy]-v)==1)
return false;
}
}
return true;
}
void DFS(int x,int y){
if(x==2 && y==3){
cnt++;
return;
} //遇到（2，3）说明结束
for(int i=0; i<=9; i++){
//要确保这个数没被选过并且放在这里符合题意
if(vis[i]==0 && check(x,y,i)){
vis[i]=1;
a[x][y]=i;
if(y+1 < 4)
DFS(x, y+1); //向右搜索
else
DFS(x+1, 0); //另起一行
vis[i]=0;
}
}
return ;
}
int main(){
for(int i=0; i<4; i++)//初始化一个较小的数
for(int j=0; j<4; j++)
a[i][j] = -20;
DFS(0,1); //从（0，1）开始
printf("%d\n",cnt);
return 0;
}
Séptima pregunta
Cortar los sellos
Como se muestra en la imagen, hay 12 sellos postales con 12 signos del zodíaco conectados entre sí.
Ahora debe recortar 5 hojas y los requisitos deben estar conectados. (Solo conectar una esquina no se considera conectado) Por
ejemplo, en la figura siguiente, la parte que se muestra en rosa es un corte calificado.
Calcule cuántos métodos de recorte diferentes existen.
Complete un número entero que represente el número de planes.
Nota: Lo que envíe debe ser un número entero, no complete ningún contenido adicional o texto explicativo.
Pregunta 8
Suma de
cuatro cuadrados Teorema de suma de cuatro cuadrados, también conocido como teorema de Lagrange:
cada número entero positivo se puede expresar como la suma de los cuadrados de como máximo 4 números enteros positivos.
Si se incluye 0, se puede expresar como la suma de los cuadrados de 4 números.
Por ejemplo:
5 = 0 ^ 2 + 0 ^ 2 + 1 ^ 2 + 2 ^ 2
7 = 1 ^ 2 + 1 ^ 2 + 1 ^ 2 + 2 ^ 2
(El signo ^ significa potencia)
para un dado Para enteros positivos , puede haber múltiples representaciones de la suma de cuadrados.
Debe ordenar los 4 números:
0 <= a <= b <= c <= dy
organizar todas las representaciones posibles en orden ascendente de acuerdo con a, b, c, d como clave primaria conjunta, y finalmente generar la primera
programa de representación La entrada es un número entero positivo N (N <5000000)
. Se requieren 4 números enteros no negativos, ordenados de pequeño a grande, separados por espacios.
Por ejemplo, entrada:
5
, el programa debe generar:
0 0 1 2
Para otro ejemplo, ingrese:
12
luego El programa debería generar:
0 2 2 2
Consumo máximo de memoria <256M
Consumo de CPU <3000ms
#include <iostream>
using namespace std;
int main(int argc, char** argv) {
int num;
cin >> num;
for(int a = 0; a <= 3000; a ++){
for(int b = a; b <= 3000; b++){
for(int c = b; c <= 3000; c++){
for(int d = c; d <= 3000; d++){
if(a*a + b*b + c*c+ d*d == num){
cout << a << " " << b << " " << c << " " << d ;
return 0;
}
}
}
}
}
return 0;
}Pregunta 9
Botellas de intercambio
Hay N botellas, numeradas 1 ~ N, colocadas en el estante.
Por ejemplo, hay 5 botellas:
2 1 3 5 4 Se
requiere tomar 2 botellas a la vez e intercambiar sus posiciones.
Después de varias veces, el número de serie de la botella es:
1 2 3 4 5
Para una situación tan simple, es obvio que se puede restablecer al menos 2 veces.
¿Y si hay más botellas? Puedes resolverlo programando.
El formato de entrada es de dos líneas: la
primera línea: un entero positivo N (N <10000), que indica el número de botellas, la
segunda línea: N números enteros positivos, separados por espacios, que indican la disposición actual de las botellas.
Los datos de salida son un número entero positivo en una línea, lo que significa cuántos intercambios se pueden realizar al menos para completar la clasificación.
Por ejemplo, entrada:
5
3 1 2 5 4 El
programa debe generar:
3
Otro ejemplo, entrada:
5
5 4 3 2 1 El
programa debe generar:
2
Consumo máximo de memoria <256M
Consumo de CPU <1000ms
Algo similar al tipo de selección
#include <iostream>
using namespace std;
int main(int argc, char** argv) {
int num;
cin >> num;
int data[10100];
for(int i = 1; i <= num; i++){
cin >> data[i];
}
int count = 0;
for(int i = 1; i <= num; i++){
if(data[i] != i){
int temp = data[i];
for(int j = 1; j <= num; j++){
if(data[j] == i){
data[i] = data[j];
data[j] = temp;
count ++;
}
}
}
}
cout << count;
return 0;
}Revise la clasificación de la selección, cada vez que la clasificación de la selección selecciona el valor más pequeño para clasificar en el orden sin clasificar
//复习选择排序
void swap(int *x, int *y){
int temp = *x;
*x = *y;
*y = temp;
}
int scanForMin(int A[], int i, int len){
int temp = i;
for(int j = i+1; j < len; j ++){
if(A[j] < A[temp]){
temp = j;
}
}
return temp;
}
void selectSort(int a[], int N){
int minPos;
for(int i = 0; i < N; i++){
minPos = scanForMin(a, i, N);
swap(&a[i], &a[minPos]);
}
}
int main(){
int A[6] = {2, 5, 9, 7, 1, 4};
selectSort(A, 6);
for (int i = 0; i < 6; i++)
{
cout << A[i] << " ";
}
cout << endl;
Décima pregunta
La proporción máxima de
un Grand Prix Planet X se establece como premio M-Class. La bonificación para cada nivel es un número entero positivo.
Y la relación entre dos niveles adyacentes es un valor fijo.
En otras palabras: los números de bonificación de todos los niveles constituyen una serie geométrica. Por ejemplo:
16,24,36,54
cuya proporción igual es: 3/2.
Ahora, investigamos aleatoriamente el número de premios de algunos ganadores.
Calcule la mayor equivalencia posible basándose en esto.
Formato de entrada: La
primera línea es un número N (0 <N <100), lo que significa que la siguiente línea contiene N números enteros positivos. La
segunda línea contiene N números enteros positivos Xi (Xi <10000000000000), separados por espacios . Cada número entero representa la cantidad de bonificación de alguien encuestado
Salida requerida:
Una puntuación en forma de A / B, que requiere que A y B sean relativamente primos. Representa el posible factor de escala máximo. Los
datos de prueba aseguran que el formato de entrada sea correcto y que exista la escala máxima.
Por ejemplo, entrada:
3 1250200
32 El
programa debería generar:
25/4
Para otro ejemplo, entrada:
4
3125 32 32200
Convención de recursos:
Consumo máximo de memoria <256M
Consumo de CPU <3000ms