笔试题目合集

1.题目一描述 **

小招在玩一款游戏：在一个N层高的金字塔上，以金字塔顶为第一层，第i层有i个落点，每个落点有若干枚金币，在落点可以跳向左斜向下或向右斜向下的落点。若知道金字塔的层数N及每层的金币数量分布，请计算小招在本次游戏中可以获得的最多金币数量。
测试输入： 第一行输入为层数
5
8
3 8
8 1 0
4 7 5 4
3 5 2 6 5
测试输出：31

n=int(input())#5
a=[[0]*n for i in range(n)]
for i in range(1,n+1):
    a[i-1][:i]=list(map(int,input().split()))
    
a=[[8, 0, 0, 0, 0],
 [3, 8, 0, 0, 0],
 [8, 1, 0, 0, 0],
 [4, 7, 5, 4, 0],
 [3, 5, 2, 6, 5]]
for i in range(n-2,-1,-1):
    for j in range(i+1):
        a[i][j]=a[i][j]+max(a[i+1][j],a[i+1][j+1])
a

2.整数抽取

题目描述
输入一个整数，将其数位上的奇数和偶数分离出来分别组成新的整数，输出这两个整数的差的绝对值.
120395的 奇数：1395，偶数：20， 输出差的绝对值：1375120395的奇数：1395，偶数：20， 输出差的绝对值：1375.

def fun(s):
   even=0 #偶数
   odd=0 #奇数
   for i in s:
       if int(i)%2==0:
           even=even*10+int(i)
       else:
           odd=odd*10+int(i)
   return even-odd if even>odd else odd-even
fun('120395')

结果：

1375

3.读取未给出行列数的矩阵

时间限制： 3000MS
内存限制： 589824KB
题目描述：
【输入问题】在考试时，有些时候没有给出数据的行数n，对于矩阵，可能行数n和列数m都未给出，本题就是为了训练这类题目的输入。（做题前可以先阅读：https://labfiles.acmcoder.com/ojhtml/index.html#/?id=%e6%b2%a1%e6%9c%89%e7%bb%99%e5%87%ba%e7%9f%a9%e9%98%b5%e7%9a%84%e8%a1%8c%e5%88%97%e6%95%b0）

对于给定的一个二维矩阵，请转置后进行输出。

#!/usr/bin/env python  
# coding=utf-8
arr = []
while 1:
  s = input()

  if s != "":
    arr.append(list(map(int, s.split())))
  else:
    break
    
n=len(arr)
m=len(arr[0])
for j in range(m):
    for i in range(n):
        print(arr[i][j],end=' ')
    print('\n')

4.打字 *****

时间限制： 3000MS
内存限制： 589824KB
题目描述：
小明很喜欢打字，今天小红给了小明一个字符串。
这个字符串只包含大写和小写字母。
我们知道，按下CapsLock键，可以切换大小写模式。
我们在小写模式时候，同时按下shift+字母键，就能写出大写字母。
在大写模式的时候，按下shift+字母键，就能写出小写字母。
现在问题来了，给你一个字符串，问你最少使用多少个按键，就可以写出这个字符串呢？
注意，按shift和字母键，算两次按键。开始时均为小写状态。

样例输入
	3
	A
	AA
	AAAAAA
样例输出
	2
	3
	7

很奇怪，明明觉得自己思路都是对的，但为什么正确率只有9%啊？是哪里出了问题

def fun_3(s):
    flag=0 #表示此时属于小写状态
    cnt=0
    for i in range(len(s)):
        if s[i]>='A' and s[i]<='Z':
            if flag==0:
                if i+1<len(s):
                    if s[i+1]>='A' and s[i+1]<='Z':
                        cnt+=2
                        flag=1
                    else:
                        cnt+=2
                else:
                    cnt+=2
            else:
                cnt+=1
        elif s[i]>='a' and s[i]<='z':
            if flag==0:
                cnt+=1
            else:
                if i+1<len(s):
                    if s[i+1]>='a' and s[i+1]<='z':
                        cnt+=2
                        flag=0
                    else:
                        cnt+=2
                else:
                    cnt+=2
        else:
            cnt+=1

    return cnt

n=int(input())
for i in range(n):
    s=input()
    print(fun_3(s))

状态转移的写法

def fun(s):
    dp=[[0 for i in range(len(s))] for i in range(2)]
    for i in range(len(s)):
        if s[i]>='a' and s[i]<='z':
            if i==0:
                dp[0][i]=1
                dp[1][i]=2
            else:
                dp[0][i]=min(dp[0][i-1]+1,dp[1][i-1]+2)
                dp[1][i]=min(dp[0][i-1]+2,dp[1][i-1]+2)
        else:
            if i==0:
                dp[0][i]=2
                dp[1][i]=2
            else:
                dp[0][i]=min(dp[0][i-1]+2,dp[1][i-1]+2)
                dp[1][i]=min(dp[0][i-1]+2,dp[1][i-1]+1)
                
    for i in dp:print(i)
    return min(dp[0][-1],dp[1][-1])

5.Manager ****

时间限制： 3000MS
内存限制： 589824KB
题目描述：
小明是一个互联网公司的老板，需要招聘员工。现在有k个学校的学生前来应聘。

由于特殊原因，要求最后入职的员工学校的人数应该都不一样。

比如我们可以A大学录取5人，B大学录取4人。但是不允许A大学和B大学都录取5人。

请问最后最多录取多少人呢？
正确率67%，不知道为啥

n=int(input())
li=list(map(int,input().split()))
li.sort(reverse=True)
ans=li[0]
tmp=li[0]
for i in range(1,n):
    ans+=min(tmp-1,li[i])
    tmp=min(tmp-1,li[i])
    
print(ans)

6.异或归零 ****

对于二进制字符串s，异或上若干个长度相等起所有连续的二进制串（000111，1100，010，10等），使得所有位都为0，最少要进行多少次异或运算？
示例

1. 00011101 输出 2
2. 0 输出 0

分析：其实相当于数有几个连通块

def fun(n,s): #n 字符串s的长度    s 二进制字符串
    cnt=0
    if s[0]=='1':cnt+=1
    for i in range(1,n):
        if s[i]=='1' and s[i-1]=='0':
            cnt+=1
    return cnt

fun(8,'00011101') #结果 2

7.字符串的修改 ****

对于字符串’111222333’进行多少次修改，可以保证相邻字符不相等。

def fun(s):
	arr=list(s)
	cnt=0
	for i in range(1,len(s)):
		if arr[i]==arr[i-1]:
			arr[i]='+'
			cnt+=1
	return cnt

8.乘二除二 **** 不会

题目：给定一个大小为n的数组，选择k个元素，使得每个元素分别进行一次如下操作：

1. 该元素乘以2
2. 该元素除以2，向下取整
   经过k次操作之后，该数组的极差最小。
   示例：
   输入：
   3 2 #代表有3个数 选取2个数进行操作
   2 1 5
   输出：
   0 #1*2 且 5//2，使得这个数组=[2，2，2]
   不会

import heapq

n, k = map(int, input().split())
nums = list(map(int, input().split()))

nums.sort()
queueMin = []
queueMid = []
queueMax = []
minMin, midMin, maxMin = float('inf'), float('inf'), float('inf')

for i in range(k):
    minMin = min(minMin, 2 * nums[i])
    heapq.heappush(queueMin, -2 * nums[i])

for i in range(k, n):
    midMin = min(midMin, nums[i])
    heapq.heappush(queueMid, -nums[i])

9.字母拆分

一个字母==两个字母顺序表中前一个字母，即b=aa,c=bb。
问输入k，打印出最短的可以拆分出k个a的字符串。

def fun(k):
    i=0
    ans=[]
    while k:
        if k%2==1:ans.append(chr(ord('a')+i))
        i+=1
        k=k//2
    return ''.join(ans)
fun(5)

结果：
‘ac’

10.对树进行操作 ****

N个结点的树，根节点编号为1.
最开始，树上所有结点都为1。
操作：选择一个子树，让子树的所有结点的值+1.
问：需要多少次操作才可以让每个结点的值等于其编号。

11.好串 ***

对于一个字符串，当只有一个字符串的出现次数为奇数，其他字符出现次数为偶数。
输出一个字符所拥有子序列中是好串的个数，并且对1e9+7进行取模操作。

12.最长路径

输入：
n #表示树的结点个数
[1,2,3,4,5,3]. #n-1个整数，第i个整数pi表示结点i+1与pi之间有连接。
3 7 #表示有一条路经过3和7这条边
输出：
4 ，经过这条边的简单路径中，最长的那条。

分析：
计算分别以这两个端点能去达的最远距离。

G={} #生成字典地图
nums=[1,2,3,4,5,3]
for i in range(len(nums)):
    G[i+2]=[nums[i]] if not G.get(i+2) else G[i+2].append(nums[i])
    if G.get(nums[i])==None:
        G[nums[i]]=[i+2]
    else:
        G[nums[i]].append(i+2)

res=0
dist={i:0 for i in G.keys()}
def dfs(s,t):
    global res
    res=max(res,dist[s])
    for node in G[s]:
        if node==t:
            continue
        dist[node]=dist[s]+1
        dfs(node,s)

dfs(3,7) #查看细节
print(G)
print(res)
print(dist)
dfs(3,7)+1+dfs(7,3) #计算结果

13.游游的排列统计 **

困难处：

• 不知道如何剪枝

from math import sqrt
def issushu(num):
    if num<=2:
        return True
    for i in range(2,int(sqrt(num))+1):
        if num%i==0:
            return False
    return True

def ifvalide(array):
    for i in range(len(array)-1):
        if issushu(array[i]+array[i+1]):
            return False
    return True

num=10 #--int(input())
nums=[i for i in range(1,num+1)]
label=[1 for _ in range(num)]
ans=[0]
tmp=[]
def fun(nums):
    if len(tmp)==num:
        if ifvalide(tmp):
            ans[0]+=1
#             ans.append(tmp[::])

        return
    for i in range(num):
        if label[i]==1:
            tmp.append(nums[i])
            label[i]=0
            if not ifvalide(tmp):
                pass
            fun(nums)
            tmp.pop()
            label[i]=1
fun(nums)
print(ans)

14.游游的you矩阵 ***

15.fintech1 *****

from collections import defaultdict
N,K=6,5
li=[1,4,2,5,3,4]
g=[list('10100'),list('00010'),list('01100'),list('01000'),list('11111')]
mp=defaultdict(list)
for ind,val in enumerate(li):
    mp[val].append(ind+1)
mpp=defaultdict(list)
def fun(x,y):
    for i in mp[x]:
        for j in mp[y]:
            if i!=j:
                mpp[i].append(j)
            
for i in range(K):
    for j in range(K):
        if g[i][j]=='1':
            fun(i+1,j+1)
            
visted=[0]*(N+1)
path,ans=[1],[]
def dfs(u):
    visted[u]=1
    if u==6:
        tmp=0
        for i in range(1,len(path)):
            tmp+=abs(path[i]-path[i-1])
        ans.append(tmp)
        return
#     visted=[0]*(N+1)
    for v in mpp[u]:
        if visted[v]==0:
            visted[v]=1
            path.append(v)
            dfs(v)
            path.pop()
            visted[v]=1
dfs(1)
print(min(ans))

16.fintech2 *****

def fun(li):
    path=[]
    for j in range(len(li)-1,1,-1):
        for i in range(j-1,-1,-1):
            path.append(li[j]-li[i])
    path.extend(li[:-1])
    path=sorted(path)
    print(path)

    def isvalid(li,nums):
        ans=set()
        ans.add(li[0]+li[-1])
        for i in range(3):
            ans.add(li[i])
            for j in range(i+1,3):
                ans.add(sum(li[i:j+1]))
        for i in nums:
            if i not in ans:
                return False
        return True 

    tmp,ans=[],set()
    def dfs(path,startindex):
        if len(tmp)==3:
            print(tmp)
            if isvalid(tmp,li):
                ans.add(tuple(tmp[:]))
            return
        for i in range(startindex,len(path)):
            tmp.append(path[i])
            dfs(path,i+1)
            tmp.pop()
            
    dfs(path,0)
    print(ans)
    return len(ans)

package main

import (
    "fmt"
)

const MAXN = 101

var indegree [MAXN]int
var help [MAXN]int
var zeroQueue [MAXN]int
var need [MAXN]int
var n int

func maxValue(arr []int, convert [][]int) int {
    n = len(arr)
    graph := make([][]int, n)
    for i := range graph {
        graph[i] = make([]int, 0)
    }
    t := make([]int, n)
    copy(indegree[:], t)
    for _, relation := range convert {
        for i := 1; i < len(relation); i++ {
            graph[relation[0]] = append(graph[relation[0]], relation[i])
            indegree[relation[i]]++
        }
    }
    l := arr[n-1] + 1
    r := 0
    for _, num := range arr {
        r += num
    }
    m := 0
    ans := arr[n-1]
    for l <= r {
        m = (l + r) / 2
        if ok(arr, graph, m) {
            ans = m
            l = m + 1
        } else {
            r = m - 1
        }
    }
    return ans
}

func ok(arr []int, graph [][]int, aim int) bool {
    l := 0
    r := 0
    for i := 0; i < n; i++ {
        help[i] = indegree[i]
        if help[i] == 0 {
            zeroQueue[r] = i
            r++
        }
    }
    t := make([]int, n)
    copy(need[:], t)
    need[n-1] = aim
    for l < r {
        cur := zeroQueue[l]
        supplement := max(need[cur]-arr[cur], 0)
        if len(graph[cur]) == 0 && supplement > 0 {
            return false
        }
        for _, next := range graph[cur] {
            need[next] += supplement
            help[next]--
            if help[next] == 0 {
                zeroQueue[r] = next
                r++
            }
        }
        l++
    }
    return true
}

func max(a, b int) int {
    if a > b {
        return a
    }
    return b
}

func main() {
    arr1 := []int{2, 0, 0, 1, 0}
    convert1 := [][]int{{4, 2, 3}, {1, 0}, {2, 1}}
    fmt.Println(maxValue(arr1, convert1))

    arr2 := []int{100, 5, 5, 0}
    convert2 := [][]int{{1, 0}, {2, 0, 1}, {3, 0, 1, 2}}
    fmt.Println(maxValue(arr2, convert2))
}

17.fintech3 ****

18.魔幻森林救公主 ****