【华为OD机试 2024 Q1考试题 C卷】幼儿园篮球游戏【编程题目 |100分】

■ 题目描述

【幼儿园篮球游戏】

幼儿园里有一个放倒的圆桶，它是一个线性结构，允许在桶的右边将篮球放入，可以在桶的左边和右边将篮球取出。

每个篮球有单独的编号，老师可以连续放入一个或多个篮球，小朋友可以在桶左边或右边将篮球取出，当桶只有一个篮球的情况下，必须从左边取出。

如老师按顺序放入1、2、3、4、5共有5个编号的篮球，那么小朋友可以依次取出编号为1、2、3、4、5，或者3、1、2.4、5编号的篮球，无法取出5、1、3、2、4编号的篮球。

其中3、1、2、4、5的取出场景为：
->连续放入1、2、3号
->从右边取出3号
->从左边取出1号
->从左边取出2号
->放入4号
->从左边取出4号
->放入5号
->从左边取出5号
简答起见，我们以L表示左，R表示右，此时取出篮球的依次取出序列为“RLLLL”。

输入描述

每次输入包含一个测试用例
1.第一行的数字作为老师依次放入的篮球编号
2.第二行的数字作为要检查是否能够按照放入的顺序取出给定的篮球的编号，其中篮球的编号用逗号进行分隔。

输出描述

对干每个篮球的取出席列，如果确实可以获取，请打印出其按照左右方向的操作取出顺序，如果无法获取则打印”NO”

示例1 输入输出示例仅供调试，后台判题数据一般不包含示例

输入

2
0 3
3
0 0 2
1 3 4
6 6 4

输出

0 1 1 1

说明

无

示例2 输入输出示例仅供调试，后台判题数据一般不包含示例

输入

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

输出

error

说明

无

JAVA解答： 

import java.util.Scanner;
import java.util.*;
import java.util.stream.Stream;
import java.util.HashMap;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.stream.Collectors;
 
public class Main { 
    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        int[] nums = split(in.nextLine(), ",");
        int[] target_nums = split(in.nextLine(), ",");
     
        int[] arr = new int[300];
        for(int i=0;i<300;i++){
            arr[i] = Integer.MAX_VALUE;
        }
        int left = 0;
        int right = 0;
        int target_pos = 0;
     
        String result = "";
        int i=0;
        while(true){
            if(i>=nums.length){
                break;
            } else {
                arr[right] = nums[i];
                right+=1;
                while (true) {
                    if(right <= left){
                        break;
                    } else {
                        if (arr[left] == target_nums[target_pos]) {
                          result += "L";
                          left += 1;
                          target_pos += 1;
                          continue;
                        } else if (arr[right-1] == target_nums[target_pos]) {
                          result += "R";
                          right -= 1;
                          target_pos += 1;
                          continue;
                        } 
                        break;
                    }
                  }
            }
            i+=1;
        }
        if (left != right) {
          System.out.println("NO");
        } else {
          System.out.println(result);
        }
    }
    
    public static int[] split(String input_str,String chars){
        String[] tmp2 = input_str.split(chars);
        int[] counts = new int[tmp2.length];
        for (int i = 0; i < tmp2.length; i++) {  
            counts[i] = Integer.parseInt(tmp2[i]);
        }
        return counts;
    }
    
}

Python解答： 

import functools
import sys
import copy
import re
import math
import queue
 
directions = [[-1, 0],[0,-1] ,[0,1],[1,0]] 
result =""
 
def dfs(x, y, index,n,m,nums,matrix) :
    global result,directions
    result += str(x) +" "+ str(y) + " "
    if (index == n - 1) : 
        return True
    
    record = matrix[x][y]
    matrix[x][y] = float('inf')
    i=0
    while(True):
        if(i>=4):
            break
        else :
            new_x = x + directions[i][0]
            new_y = y + directions[i][1]
            if (new_x < 0 or new_x >= m or new_y < 0 or new_y >= m 
                or matrix[new_x][new_y] != nums[index + 1]) :
                    i+=1
                    continue
            
            if (dfs(new_x, new_y, index + 1,n,m,nums,matrix)) : 
                return True
        i+=1
    
    matrix[x][y] = record 
    result = result[:-4]
    return False 
    
        
n = int(input())
nums = [int(x) for x in input().split(" ")]
m = int(input())
matrix = []
for i in range(m):
    matrix.append([int(x) for x in input().split(" ")])
 
flag = 0
for i in range(m):
    for j in range(m):
        result = ""
        if (matrix[i][j] == nums[0] and dfs(i, j, 0,n,m,nums,matrix)) : 
            flag = 1
            break
    if(flag == 1):
        break
 
if(flag == 1):
    print(result[:-1])
 
else :
    print("error")

JavaScript： 

let directions = [[-1, 0],[0,-1] ,[0,1],[1,0]]; 
let result="";
 
function dfs(x,y, index,n, m, nums,matrix) {
    result += x +" "+ y + " ";
    if (index == n - 1) { 
        return true;
    }
    let record = matrix[x][y];
    matrix[x][y] = Number.MAX_VALUE; 
    let i=0;
    while(true){
        if(i>=4){
            break;
        } else {
            let new_x = x + directions[i][0];
            let new_y = y + directions[i][1];
            if (new_x < 0 || new_x >= m || new_y < 0 || new_y >= m 
                || matrix[new_x][new_y] != nums[index + 1]) {
                    i+=1;
                continue;
            }
            if (dfs(new_x, new_y, index + 1,n,m,nums,matrix)) { 
                return true;
            }
        }
        i+=1;
    }
    matrix[x][y] = record; 
    result = result.substring(0, result.length-4);
    return false; 
}
 
function main(n,nums,m,matrix){ 
    
    let flag = 0;
    for (let i = 0; i < m; i++) {
        for (let j = 0; j < m; j++) {
            result = "";
            if (matrix[i][j] == nums[0] && dfs(i, j, 0,n,m,nums,matrix)) { 
                flag = 1;
                break;
            }
        }
        if(flag == 1){
            break;
        }
    }
 
    if(flag == 1){
        console.log(result.substring(0, result.length-1));
    } else {
        console.log("error");
    }
}
 
 
main(2,
[0, 3],
3,
[[0 ,0, 2],
[1 ,3, 4],
[6, 6 ,4]])

C：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdbool.h>
#include <math.h>
#include <limits.h>
#include <float.h>
#include <regex.h>
#include <ctype.h>
 
#define CEILING_POS(X) ((X-(int)(X)) > 0 ? (int)(X+1) : (int)(X))
#define CEILING_NEG(X) ((X-(int)(X)) < 0 ? (int)(X-1) : (int)(X))
#define CEILING(X) ( ((X) > 0) ? CEILING_POS(X) : CEILING_NEG(X) )
 
#define MIN(a, b) ((a) < (b)) ? (a) : (b)
#define MAX(a, b) ((a) > (b)) ? (a) : (b)
 
int cmpfunc_str (const void * a, const void * b) {
   return strcmp(a ,b);
}
 
int cmpfunc (const void * a, const void * b) {
   return ( *(int*)a - *(int*)b );
}
//qsort(dp, m+1, sizeof(int), cmpfunc);
 
/*
char input[200000];
    fgets(input, 200000, stdin);
 
    //逗号分隔
    char* token = strtok(input, ",");
    int v[1000];
    int score1 = 0;
    while (token != NULL) {
        v[score1++] = atoi(token);
        token = strtok(NULL, ",");
    }*/
 
int cmp(const void *a,const void *b)
{
    int *ap = (int *)a;       
    int *bp = (int *)b;
 
    //if(bp[0] == ap[0]){
    //    return ap[1]>bp[1];
    //} else {
    //    return ap[0]>bp[0];
    //}
     return ap[0]>bp[0];
} 
//qsort(a, n, sizeof(a[0]), cmp);
 
int directions[4][2] =  {{-1, 0},{0,-1} ,{0,1},{1,0}}; 
int result[10000];
int count = 0;
int nums[200];
int m=0;
int n=0;
int matrix[200][200];
bool dfs(int x, int y, int index) {
    result[count++] = x;
    result[count++] = y;
    if (index == n - 1) { 
        return true;
    }
    int record = matrix[x][y];
    matrix[x][y] = INT_MAX; 
    int i=0;
    while(true){
        if(i>=4){
            break;
        } else {
            int new_x = x + directions[i][0];
            int new_y = y + directions[i][1];
            if (new_x < 0 || new_x >= m || new_y < 0 || new_y >= m 
                || matrix[new_x][new_y] != nums[index + 1]) {
                    i+=1;
                continue;
            }
            if (dfs(new_x, new_y, index + 1)) { 
                return true;
            }
        }
        i+=1;
    }
    matrix[x][y] = record; 
    count-=2;
    return false; 
}
 
int main() {
    scanf("%d", &n);
 
    for (int i = 0; i < n; i++) {
        scanf("%d", &nums[i]); 
    }
    
    scanf("%d", &m); 
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            scanf("%d", &matrix[i][j]); 
        }
    }
 
    int flag = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            count=0;
            if (matrix[i][j] == nums[0] && dfs(i, j, 0)) { 
                flag = 1;
                break;
            }
        }
        if(flag == 1){
            break;
        }
    }
 
    if(flag == 1){
        for (int i=0;i<count;i++){
            printf("%d ", result[i]);
        }
        
    } else {
        printf("error");
    }
    return 0;
}

C++: 

#include<iostream>
#include <utility>
#include<vector>
#include<stdlib.h>
#include<algorithm>
#include<string.h>
#include<exception> 
#include<map>
#include<cmath>
#include<numeric>
#include<set>
#include<climits>
#include<ctype.h>
#include<queue>
#include<stack>
#include<list>
#include<bitset>
using namespace std;
 
vector<int> split(string params_str, string split_char) {
    vector<int> p;
    while (params_str.find(split_char) != string::npos) {
        int found = params_str.find(split_char);
        p.push_back(stoi(params_str.substr(0, found)));
        params_str = params_str.substr(found + 1);
    }    
    p.push_back(stoi(params_str));
    return p;
}
 
vector<string> split_str(string params_str, string split_char) {
    vector<string> p;
    while (params_str.find(split_char) != string::npos) {
        int found = params_str.find(split_char);
        p.push_back(params_str.substr(0, found));
        params_str = params_str.substr(found + 1);
    }    
    p.push_back(params_str);
    return p;
}  
 
vector<vector<int>> directions = {{-1, 0},{0,-1} ,{0,1},{1,0}}; 
string result = "";
 
bool dfs(int x, int y, int index,int n,int m,vector<int> nums,vector<vector<int>> matrix) {
        result += to_string(x) +" "+  to_string(y) + " ";
        if (index == n - 1) { 
            return true;
        }
        int record = matrix[x][y];
        matrix[x][y] = INT_MAX; 
        int i=0;
        while(true){
            if(i>=4){
                break;
            } else {
                int new_x = x + directions[i][0];
                int new_y = y + directions[i][1];
                if (new_x < 0 || new_x >= m || new_y < 0 || new_y >= m 
                    || matrix[new_x][new_y] != nums[index + 1]) {
                        i+=1;
                    continue;
                }
                if (dfs(new_x, new_y, index + 1,n,m,nums,matrix)) { 
                    return true;
                }
            }
            i+=1;
        }
        matrix[x][y] = record; 
        result = result.substr(0, result.size()-4);
        return false; 
    }
int main()
{
    int n;
    cin >>n;
    vector<int> nums(n,0); 
    for (int i = 0; i < n; i++) {
        int a;
        cin >> a;
        nums[i] = a; 
    }
    
    int m;
    cin >> m;
    vector<vector<int>> matrix (m, vector<int>(m,0)); 
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            int a;
            cin >> a;
            matrix[i][j] = a; 
        }
    }
 
    int flag = 0;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            result = "";
            if (matrix[i][j] == nums[0] && dfs(i, j, 0,n,m,nums,matrix)) { 
                flag = 1;
                break;
            }
        }
        if(flag == 1){
            break;
        }
    }
 
    if(flag == 1){
        cout<<result.substr(0, result.size()-1);
    } else {
        cout<<"error";
    }
 
    return 0;
}

Golang

package main

import (
    "fmt"
    "sort"
)

type City struct {
    income   int
    decrease int
}

type ByIncome []City

func (a ByIncome) Len() int           { return len(a) }
func (a ByIncome) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
func (a ByIncome) Less(i, j int) bool { return a[i].income > a[j].income }

func main() {
    var T, N int
    fmt.Scan(&T, &N)

    costDays := 0
    for i := 0; i < N+1; i++ {
        var days int
        fmt.Scan(&days)
        costDays += days
    }

    restDays := T - costDays

    cities := make([]City, N)
    for i := 0; i < N; i++ {
        fmt.Scan(&cities[i].income, &cities[i].decrease)
    }

    income := 0
    for i := 0; i < restDays; i++ {
        sort.Sort(ByIncome(cities))
        if len(cities) > 0 && cities[0].income > 0 {
            income += cities[0].income
            cities[0].income -= cities[0].decrease
        }
    }

    fmt.Println(income)
}