 Hang Up the System

You're going to design a multitask operating system for an embedded system. Because the resources are limited on this mini computer, parallel running of some programs will probably give rise to the deadlock problem. According to experience, you have a list of programs that will hang up the system if all of them are running simultaneously. You are also given the priority of these programs. Now you're interested in the maximum value of the total priority of the programs that can run simultaneously in the system without hanging up.
Input
The input has several test cases, each starts with n (2 <= n <= 16), the number of programs. The following n lines contain the name of the program and its priority, with each program on a line. The name is a string of no more than 10 characters. The priority is an integer from 1 to 100. The next line contains a single integer m (0 <= m <= 1,024), which is the length of the list of the conflicting programs. The following m lines each contains several names of the programs which cannot run together.
The input is terminated with a case n = 0. This case should not be processed.
Output
Print the case number and the maximal total priority value you can get on a line. Adhere to the sample output format.
Sample Input
3
HARDDISK 20
FLOPPY 10
CDROM 15
1
CDROM HARDDISK
5
HARDDISK 20
FLOPPY 10
CDROM 15
SERIAL 25
MOUSE 20
3
CDROM HARDDISK FLOPPY
FLOPPY SERIAL
SERIAL MOUSE
0Sample Output
System 1: 30
System 2: 60
String Distance and Transform Process _course
20170308String Distance is a nonnegative integer that measures the distance between two strings. Here we give the definition. A transform list is a list of string, where each string, except for the last one, can be changed to the string followed by adding a character, deleting a character or replacing a character. The length of a transform list is the count of strings minus 1 (that is the count of operations to transform these two strings). The distance between two strings is the length of a transform list from one string to the other with the minimal length. You are to write a program to calculate the distance between two strings and give the corresponding transform list. Input Input consists a sequence of string pairs, each string pair consists two lines, each string occupies one line. The length of each string will be no more than 80. Output For each string pair, you should give an integer to indicate the distance between them at the first line, and give a sequence of command to transform string 1 to string 2. Each command is a line lead by command count, then the command. A command must be Insert pos,value Delete pos Replace pos,value where pos is the position of the string and pos should be between 1 and the current length of the string (in Insert command, pos can be 1 greater than the length), and value is a character. Actually many command lists can satisfy the request, but only one of them is required. Sample Input abcac bcd aaa aabaaaa Sample Output 3 1 Delete 1 2 Replace 3,d 3 Delete 4 4 1 Insert 1,a 2 Insert 2,a 3 Insert 3,b 4 Insert 7,a
Slurpys _course
20171015Description Recognizing strings based on a set of restrictions is a common computational problem. A Slurpy is a string of characters that has certain properties. Your program will read in strings of characters and output whether or not they are Slurpys. A Slump is a character string that has the following properties: 1. Its first character is either a 'D' or an 'E'. 2. The first character is followed by a string of one or more 'F's. 3. The string of one or more 'F's is followed by either a Slump or a 'G'. The Slump or 'G' that follows the F's ends the Slump. For example DFFEFFFG is a Slump since it has a 'D' for its first character, followed by a string of two F's, and ended by the Slump 'EFFFG'. 4. Nothing else is a Slump. A Slimp is a character string that has the following properties: 1. Its first character is an 'A'. 2. If it is a two character Slimp then its second and last character is an 'H'. 3. If it is not a two character Slimp then it is in one of these two forms: a) 'A' followed by 'B' followed by a Slimp followed by a 'C'. b) 'A' followed by a Slump (see above) followed by a 'C'. 4. Nothing else is a Slimp. A Slurpy is a character string that consists of a Slimp followed by a Slump. Examples Slumps: DFG, EFG, DFFFFFG, DFDFDFDFG, DFEFFFFFG Not Slumps: DFEFF, EFAHG, DEFG, DG, EFFFFDG Slimps: AH, ABAHC, ABABAHCC, ADFGC, ADFFFFGC, ABAEFGCC, ADFDFGC Not Slimps: ABC, ABAH, DFGC, ABABAHC, SLIMP, ADGC Slurpys: AHDFG, ADFGCDFFFFFG, ABAEFGCCDFEFFFFFG Not Slurpys: AHDFGA, DFGAH, ABABCC Input The first line contains an integer N between 1 and 10 describing how many strings of characters are represented. The next N lines each contain a string of 1 to 60 alpha characters. Output The first line of output should read SLURPYS OUTPUT. Each of the next N lines of output should consist of either YES or NO depending on whether or not the corresponding input line is a Slurpy. The last line of output should read END OF OUTPUT. Sample Input 2 AHDFG DFGAH Sample Output SLURPYS OUTPUT YES NO END OF OUTPUT
Zipper _course
20161212Description Given three strings, you are to determine whether the third string can be formed by combining the characters in the first two strings. The first two strings can be mixed arbitrarily, but each must stay in its original order. For example, consider forming "tcraete" from "cat" and "tree": String A: cat String B: tree String C: tcraete As you can see, we can form the third string by alternating characters from the two strings. As a second example, consider forming "catrtee" from "cat" and "tree": String A: cat String B: tree String C: catrtee Finally, notice that it is impossible to form "cttaree" from "cat" and "tree". Input The first line of input contains a single positive integer from 1 through 1000. It represents the number of data sets to follow. The processing for each data set is identical. The data sets appear on the following lines, one data set per line. For each data set, the line of input consists of three strings, separated by a single space. All strings are composed of upper and lower case letters only. The length of the third string is always the sum of the lengths of the first two strings. The first two strings will have lengths between 1 and 200 characters, inclusive. Output For each data set, print: Data set n: yes if the third string can be formed from the first two, or Data set n: no if it cannot. Of course n should be replaced by the data set number. See the sample output below for an example. Sample Input 3 cat tree tcraete cat tree catrtee cat tree cttaree Sample Output Data set 1: yes Data set 2: yes Data set 3: no
Period _course
20170206Problem Description For each prefix of a given string S with N characters (each character has an ASCII code between 97 and 126, inclusive), we want to know whether the prefix is a periodic string. That is, for each i (2 <= i <= N) we want to know the largest K > 1 (if there is one) such that the prefix of S with length i can be written as AK , that is A concatenated K times, for some string A. Of course, we also want to know the period K. Input The input file consists of several test cases. Each test case consists of two lines. The first one contains N (2 <= N <= 1 000 000) – the size of the string S. The second line contains the string S. The input file ends with a line, having the number zero on it. Output For each test case, output “Test case #” and the consecutive test case number on a single line; then, for each prefix with length i that has a period K > 1, output the prefix size i and the period K separated by a single space; the prefix sizes must be in increasing order. Print a blank line after each test case. Sample Input 3 aaa 12 aabaabaabaab 0 Sample Output Test case #1 2 2 3 3 Test case #2 2 2 6 2 9 3 12 4
Parencodings _course
20171013Description Let S = s1 s2...s2n be a wellformed string of parentheses. S can be encoded in two different ways: q By an integer sequence P = p1 p2...pn where pi is the number of left parentheses before the ith right parenthesis in S (Psequence). q By an integer sequence W = w1 w2...wn where for each right parenthesis, say a in S, we associate an integer which is the number of right parentheses counting from the matched left parenthesis of a up to a. (Wsequence). Following is an example of the above encodings: S (((()()()))) Psequence 4 5 6666 Wsequence 1 1 1456 Write a program to convert Psequence of a wellformed string to the Wsequence of the same string. Input The first line of the input contains a single integer t (1 <= t <= 10), the number of test cases, followed by the input data for each test case. The first line of each test case is an integer n (1 <= n <= 20), and the second line is the Psequence of a wellformed string. It contains n positive integers, separated with blanks, representing the Psequence. Output The output file consists of exactly t lines corresponding to test cases. For each test case, the output line should contain n integers describing the Wsequence of the string corresponding to its given Psequence. Sample Input 2 6 4 5 6 6 6 6 9 4 6 6 6 6 8 9 9 9 Sample Output 1 1 1 4 5 6 1 1 2 4 5 1 1 3 9
Bridged Marble Rings _course
20171024问题描述 : 26 marbles―half yellow and half gray―are distributed between two circles of 13 marbles each. The marbles in each circle can be freely rotated clockwise or counterclockwise. The upper and lower circles are bridged by a smaller circle, which rotates―in the plane of the board―180 degrees, effectively exchanging the three bottommost marbles of the upper circle with the three uppermost marbles of the lower one. The goal is to get all gray marbles to the upper circle and all yellow marbles to the lower one while minimizing the number of times the bridging circle is rotated. 输入: The input is a series of lines, where each line describes an initial board configuration. Each line is a permutation of 13 y’s and 13 g’s. The first half of the line describes the clockwise configuration of the upper circle, and the rest of the line describes the clockwise configuration of the lower one. Of course, each y corresponds to a yellow marble, and each g corresponds to a gray one. The input file will include multiple test cases. Each test case consists of a single line containing some permutation of the string y13g13. All lines (including the last one) are terminated with a newline. The newline immediately follows the last letter on the line. 输出: The input is a series of lines, where each line describes an initial board configuration. Each line is a permutation of 13 y’s and 13 g’s. The first half of the line describes the clockwise configuration of the upper circle, and the rest of the line describes the clockwise configuration of the lower one. Of course, each y corresponds to a yellow marble, and each g corresponds to a gray one. The input file will include multiple test cases. Each test case consists of a single line containing some permutation of the string y13g13. All lines (including the last one) are terminated with a newline. The newline immediately follows the last letter on the line. 样例输入: gggggggggggggyyyyyyyyyyyyy yyyyyggggggggyyyygggggyyyy gyyygyggyyygyyggyyggggyygg ygygygygygygygygygygygygyg 样例输出: 0 2 5 6
Find the Shortest Common Superstring_course
20170527Problem Description The shortest common superstring of 2 strings S1 and S2 is a string S with the minimum number of characters which contains both S1 and S2 as a sequence of consecutive characters. For instance, the shortest common superstring of “alba” and “bacau” is “albacau”. Given two strings composed of lowercase English characters, find the length of their shortest common superstring. Input The first line of input contains an integer number T, representing the number of test cases to follow. Each test case consists of 2 lines. The first of these lines contains the string S1 and the second line contains the string S2. Both of these strings contain at least 1 and at most 1.000.000 characters. Output For each of the T test cases, in the order given in the input, print one line containing the length of the shortest common superstring. Sample Input 2 alba bacau resita mures Sample Output 7 8
Forgetful _course
20171015Description Each Sunday Mrs. Mahtaj who is an old woman goes to David Church and after the Sunday pray she comes back home. The traffic center has a complicated rule for closing crossroads that Mrs. Mahtaj can't understand. She is a forgetful woman who can only memorize the path from her house to church. The streets of her city are vertical or horizontal, the same as a grid with the squares of the same size. So she memorizes a path by a string of F (Forward), B (Backward), L (Left) and R (Right). For example, if there is no closed crossroad and Mahtaj is in crossroad (1,0) and faces east, if the string is BRFRLFL she reaches the crossroad (0,4). His son, Khashayar, decides to help her finding a path that can be used both for going from their house to the church and for coming back from the church to their house and does not pass any closed crossroad. I.e. Mahtaj should be able to go from her house to the church and from the church to her house by just one string. Help Khashayar to find such a path. When Mrs. Mahtaj starts the path from her house, she faces east and when she starts from the church she faces west. Input The input consists of several test cases. Each test case begins with a line containing m and n, the number of vertical and horizontal lines (streets) in the grid, which are in range 1 to 100. The second line of a test case contains two pairs of integer, which are x and y coordinates of the source (Mrs. Mahtaj's house) and x and y coordinates of the destination (David church). The horizontal and vertical lines in the grid are indexed from left to right and bottom to up from 0, so coordinates can be expressed using the indices. The third line of a test case contains a single numbe r N, which is the number of closed crossroads. It follows by N lines that each line contains x and y coordinates of a closed crossroad. The test case with m=n=0 indicates the end of the input file. Output The output for each test case is "YES" if there is such path and otherwise "NO". Output for each test case must be written on a separate line and the test case with m=n=0 has no output. Sample Input 3 3 0 0 2 2 2 1 2 2 1 6 5 0 0 5 4 5 3 0 3 2 2 2 0 2 5 2 0 0 Sample Output NO YES
Substrings _course
20170920Description You are given a number of casesensitive strings of alphabetic characters, find the largest string X, such that either X, or its inverse can be found as a substring of any of the given strings. Input The first line of the input contains a single integer t (1 <= t <= 10), the number of test cases, followed by the input data for each test case. The first line of each test case contains a single integer n (1 <= n <= 100), the number of given strings, followed by n lines, each representing one string of minimum length 1 and maximum length 100. There is no extra white space before and after a string. Output There should be one line per test case containing the length of the largest string found. Sample Input 2 3 ABCD BCDFF BRCD 2 rose orchid Sample Output 2 2
Organize Your Train part II _course
20161108Description RJ Freight, a Japanese railroad company for freight operations has recently constructed exchange lines at Hazawa, Yokohama. The layout of the lines is shown in Figure 1. ![](http://poj.org/images/3007_1.gif) Figure 1: Layout of the exchange lines A freight train consists of 2 to 72 freight cars. There are 26 types of freight cars, which are denoted by 26 lowercase letters from "a" to "z". The cars of the same type are indistinguishable from each other, and each car's direction doesn't matter either. Thus, a string of lowercase letters of length 2 to 72 is sufficient to completely express the configuration of a train. Upon arrival at the exchange lines, a train is divided into two subtrains at an arbitrary position (prior to entering the storage lines). Each of the subtrains may have its direction reversed (using the reversal line). Finally, the two subtrains are connected in either order to form the final configuration. Note that the reversal operation is optional for each of the subtrains. For example, if the arrival configuration is "abcd", the train is split into two subtrains of either 3:1, 2:2 or 1:3 cars. For each of the splitting, possible final configurations are as follows ("+" indicates final concatenation position): [3:1] abc+d cba+d d+abc d+cba [2:2] ab+cd ab+dc ba+cd ba+dc cd+ab cd+ba dc+ab dc+ba [1:3] a+bcd a+dcb bcd+a dcb+a Excluding duplicates, 12 distinct configurations are possible. Given an arrival configuration, answer the number of distinct configurations which can be constructed using the exchange lines described above. Input The entire input looks like the following. the number of datasets = m 1st dataset 2nd dataset ... mth dataset Each dataset represents an arriving train, and is a string of 2 to 72 lowercase letters in an input line. Output For each dataset, output the number of possible train configurations in a line. No other characters should appear in the output. Sample Input 4 aa abba abcd abcde Sample Output 1 6 12 18
IBM Minus One _course
20170302You may have heard of the book '2001  A Space Odyssey' by Arthur C. Clarke, or the film of the same name by Stanley Kubrick. In it a spaceship is sent from Earth to Saturn. The crew is put into stasis for the long flight, only two men are awake, and the ship is controlled by the intelligent computer HAL. But during the flight HAL is acting more and more strangely, and even starts to kill the crew on board. We don't tell you how the story ends, in case you want to read the book for yourself :) After the movie was released and became very popular, there was some discussion as to what the name 'HAL' actually meant. Some thought that it might be an abbreviation for 'Heuristic ALgorithm'. But the most popular explanation is the following: if you replace every letter in the word HAL by its successor in the alphabet, you get ... IBM. Perhaps there are even more acronyms related in this strange way! You are to write a program that may help to find this out. Input The input starts with the integer n on a line by itself  this is the number of strings to follow. The following n lines each contain one string of at most 50 uppercase letters. Output For each string in the input, first output the number of the string, as shown in the sample output. The print the string start is derived from the input string by replacing every time by the following letter in the alphabet, and replacing 'Z' by 'A'. Print a blank line after each test case. Sample Input 2 HAL SWERC Sample Output String #1 IBM String #2 TXFSD
Alignment of Code _course
20170110Description You are working in a team that writes Incredibly Customizable Programming Codewriter (ICPC) which is basically a text editor with bells and whistles. You are working on a module that takes a piece of code containing some definitions or other tabular information and aligns each column on a fixed vertical position, while keeping the resulting code as short as possible, making sure that only whitespaces that are absolutely required stay in the code. So, that the first words on each line are printed at position p1 = 1; the second words on each line are printed at the minimal possible position p2, such that all first words end at or before position p2  2; the third words on each line are printed at the minimal possible position p3, such that all second words end at or before position p3  2, etc. For the purpose of this problem, the code consists of multiple lines. Each line consists of one or more words separated by spaces. Each word can contain uppercase and lowercase Latin letters, all ASCII punctuation marks, separators, and other nonwhitespace ASCII characters (ASCII codes 33 to 126 inclusive). Whitespace consists of space characters (ASCII code 32). Input The input file contains one or more lines of the code up to the end of file. All lines (including the last one) are terminated by a standard endofline sequence in the file. Each line contains at least one word, each word is 1 to 80 characters long (inclusive). Words are separated by one or more spaces. Lines of the code can have both leading and trailing spaces. Each line in the input file is at most 180 characters long. There are at most 1000 lines in the input file. Output Write to the output file the reformatted, aligned code that consists of the same number of lines, with the same words in the same order, without trailing and leading spaces, separated by one or more spaces such that ith word on each line starts at the same position pi. Sample Input start: integer; // begins here stop: integer; // ends here s: string; c: char; // temp Sample Output start: integer; // begins here stop: integer; // ends here s: string; c: char; // temp
MU Puzzle _course
20171029Problem Description Suppose there are the symbols M, I, and U which can be combined to produce strings of symbols called "words". We start with one word MI, and transform it to get a new word. In each step, we can use one of the following transformation rules: 1. Double any string after the M (that is, change Mx, to Mxx). For example: MIU to MIUIU. 2. Replace any III with a U. For example: MUIIIU to MUUU. 3. Remove any UU. For example: MUUU to MU. Using these three rules is it possible to change MI into a given string in a finite number of steps? Input First line, number of strings, n. Following n lines, each line contains a nonempty string which consists only of letters 'M', 'I' and 'U'. Total length of all strings <= 106. Output n lines, each line is 'Yes' or 'No'. Sample Input 2 MI MU Sample Output Yes No
Reincarnation _course
20170828Problem Description Now you are back,and have a task to do: Given you a string s consist of lowercase English letters only,denote f(s) as the number of distinct substring of s. And you have some query,each time you should calculate f(s[l...r]), s[l...r] means the substring of s start from l end at r. Input The first line contains integer T(1<=T<=5), denote the number of the test cases. For each test cases,the first line contains a string s(1 <= length of s <= 2000). Denote the length of s by n. The second line contains an integer Q(1 <= Q <= 10000),denote the number of queries. Then Q lines follows,each lines contains two integer l, r(1 <= l <= r <= n), denote a query. Output For each test cases,for each query,print the answer in one line. Sample Input 2 bbaba 5 3 4 2 2 2 5 2 4 1 4 baaba 5 3 3 3 4 1 4 3 5 5 5 Sample Output 3 1 7 5 8 1 3 8 5 1
Magic Number _course
20170215Problem Description There are many magic numbers whose lengths are less than 10. Given some queries, each contains a single number, if the Levenshtein distance (see below) between the number in the query and a magic number is no more than a threshold, we call the magic number is the lucky number for that query. Could you find out how many luck numbers are there for each query? Levenshtein distance (from Wikipedia http://en.wikipedia.org/wiki/Levenshtein_distance): In information theory and computer science, the Levenshtein distance is a string metric for measuring the amount of difference between two sequences. The term edit distance is often used to refer specifically to Levenshtein distance. The Levenshtein distance between two strings is defined as the minimum number of edits needed to transform one string into the other, with the allowable edit operations being insertion, deletion, or substitution of a single character. It is named after Vladimir Levenshtein, who considered this distance in 1965. For example, the Levenshtein distance between "kitten" and "sitting" is 3, since the following three edits change one into the other, and there is no way to do it with fewer than three edits: 1.kitten → sitten (substitution of 's' for 'k') 2.sitten → sittin (substitution of 'i' for 'e') 3.sittin → sitting (insertion of 'g' at the end). Input There are several test cases. The first line contains a single number T shows that there are T cases. For each test case, there are 2 numbers in the first line: n (n <= 1500) m (m <= 1000) where n is the number of magic numbers and m is the number of queries. In the next n lines, each line has a magic number. You can assume that each magic number is distinctive. In the next m lines, each line has a query and a threshold. The length of each query is no more than 10 and the threshold is no more than 3. Output For each test case, the first line is "Case #id:", where id is the case number. Then output m lines. For each line, there is a number shows the answer of the corresponding query. Sample Input 1 5 2 656 67 9313 1178 38 87 1 9509 1 Sample Output Case #1: 1 0
Win the Bonus _course
20170422There is a game with m bankers, each holding a string of integers of length 3 (note: an integer that has less than 3 digits has zeros filled to the left, e.g. 5 is considered as 005). Each banker assigns to his\her string some bonus or penalty points. As a player, you are supposed to select n digits from the set {0,1,2,3,4,5,6,7,8,9} to form your own integer string. If your string contains some of the bankers' strings, then you will gain or lose points accordingly. For example, if there are two bankers assigning 20 bonus points to 356 and 10 penalty points to 674 respectively, and your string is 035674, then since 356 and 674 both appear once in your string, the score you get will be 2010=10. The player getting the most points wins the game. If there are more than one player getting the most points, the one with the smallest string number wins. Now, suppose that Harry Potter gets to know all the bankers' secret strings and their assigned points by waving his magic wand, it is still not an easy task to win the game even with Hermione on his side. So he has come to you for help  given the string length n, you may write a program to find the winning string. Input The input consists of several test cases. The first line of each test case contains two integers m and n (1<=n<=10000), where m is the number of bankers and n is the required length of the player's string. The following m lines contain m pairs of integers which are the banker's string and the points assigned to it. You may assume that all the bankers' strings are distinct. Output For each test case you are supposed to output the winning string you find in a line. No extra spaces are allowed. Sample Input: 2 5 356 20 674 10 Sample Output: 00356
The Cubic End _course
20170101问题描述 : Given any string of decimal digits, ending in 1, 3, 7 or 9, there is always a decimal number, which when cubed has a decimal expansion ending in the original given digit string. The number need never have more digits than the given digit string. Write a program, which takes as input a string of decimal digits ending in 1, 3, 7 or 9 and finds a number of at most the same number of digits, which when cubed, ends in the given digit string. 输入: The input begins with a line containing only the count of problem instances, nProb, as a decimal integer, 1 ≤ nProb ≤ 1000. This is followed by nProb lines, each of which contains a string of between 1 and 10 decimal digits ending in 1, 3, 7 or 9. 输出: For each problem instance, there should be one line of output consisting of the number, which when cubed, ends in the given digit string. The number should be output as a decimal integer with no leading spaces and no leading zeroes. 样例输入: 4 123 1234567 435621 9876543213 样例输出: 947 2835223 786941 2916344917
Lsystem _course
20170919Description A D0L (Deterministic Lindenmayer system without interaction) system consists of a finite set SIGMA of symbols (the alphabet), a finite set P of productions and a starting string w. The productions in P are of the form x > u, where x in SIGMA and u in SIGMA+ (u is called the right side of the production), SIGMA+ is the set of all strings of symbols from SIGMA excluding the empty string. Such productions represent the transformation of the symbol x into the string u. For each symbol x in SIGMA , P contains exactly one production of the form x > u. Direct derivation from string u1 to u2 consists of replacing each occurrence of the symbol x in SIGMA in u1 by the string on the right side of the production for that symbol. The language of the D0L system consists of all strings which can be derived from the starting string w by a sequence of the direct derivations. Suppose that the alphabet consists of two symbols a and b. So the set of productions includes two productions of the form a > u, b > v, where u and v in {a,b}+, and the starting string w in {a,b}+. Can you answer whether there exists a string in the language of the D0L system of the form xzy for a given string z? (x and y are some strings from SIGMA*, SIGMA* is the set of all strings of symbols from SIGMA, including the empty string.). Certainly you can. Write the program which will solve this problem. Input The input of the program consists of several blocks of lines. Each block includes four lines. There are no empty lines between any successive two blocks. The first line of a block contains the right side of the production for the symbol a. The second one contains the right side of the production for the symbol b and the third one contains the starting string and the fourth line the given string z. The right sides of the productions, the given string z and the starting string are at most 15 characters long. Output For each block in the input there is one line in the output containing YES or NO according to the solution of the given problem. Sample Input aa bb ab aaabb a b ab ba Sample Output YES NO
The most binary substring _course
20171128Problem Description Everybody knows the number is saved with the binary string in the computer. Now, their have N (1 <= N <= 1000) binary strings I tell you, your task is tell me what is the most binary substring with K (1 <= K <= L) characters in the strings I give you. The length of each string is L (1 <= L <= 60). Output times of the most appearing binary substring. Input Each line will contain three numbers N, L, K. Following N lines, represent N binary strings. Output One answer one line. Sample Input 2 6 3 101011 110101 2 6 4 101011 110101 Sample Output 4 2
 5.30MB
滴滴萌猫跳一跳辅助(安卓))
20201020按提示开无障碍服务，给悬浮窗权限，然后打开跳一跳游戏，打开软件，切回游戏画面，拖动顶部栏往下让软件的半透明区域把猫覆盖完，可以点击右上角数字修改为1.6。使用方法:从猫的位置按住往第二个方块上滑动，松
软件测试2小时入门
20181010本课程内容系统、全面、简洁、通俗易懂，通过2个多小时的介绍，让大家对软件测试有个系统的理解和认识，具备基本的软件测试理论基础。 主要内容分为5个部分： 1 软件测试概述，了解测试是什么、测试的对象、原则、流程、方法、模型； 2.常用的黑盒测试用例设计方法及示例演示； 3 常用白盒测试用例设计方法及示例演示； 4.自动化测试优缺点、使用范围及示例‘； 5.测试经验谈。
C语言及程序设计初步
20150105课程针对没有任何程序设计基础的初学者，全面介绍C语言及利用C语言进行程序设计的方法。课程注重知识的传授，更关注学习者能够通过实践的方式，真正学会利用C语言解决问题，奠定程序设计的基础。为此，专门设计了实践方案，指导学习者在听讲的同时，有效完成实践。讲课中还适时穿插进行学习指导，帮助初学者尽快掌握程序设计的学习方法。
 9.61MB
UniBeast 7.1.zip
20190809用于制作mac os Sierra 10.12 启动u盘，在普通电脑上安装。
 2KB
中信银行计算机类笔试
20120412中信银行计算机类笔试题75道单项选择题，需要的同学何以参考一下，希望能帮到你
 博客 SpringBoot + maven 父子模块项目搭建
 下载 Js参数值中含有单引号或双引号问题的解决方法
 学院 基于SSM框架电影订票网站开发全程实录(附源码)
 下载 PHP中spl_autoload_register函数的用法总结
 下载 用js实现in_array的方法
 博客 Python初学者手册（14）
 学院 Spring Boot集成EasyPoi
 博客 Perl学习笔记（五）——关联数组
 下载 北航991数据结构与C语言程序设计历年真题集合
 学院 全新Vue3.0全家桶 零基础入门到项目实战
 下载 普传变频器在彩钢机械上的应用
 下载 php去除HTML标签实例
 下载 php根据分类合并数组的方法实例详解
 博客 【JVM系列】低延迟回收器 ZGC
 下载 js onclick事件传参讲解
 博客 常见面试SQL问题
 学院 多元线性回归模型的参数与统计量深度解读基于Python编程复现
 博客 linux汇编指令
 下载 基于单片机和CPLD实时数据采集显示系统设计
 学院 Git使用详解
 学院 PowerDesigner数据库设计与建模
 博客 20201026
 下载 基于单片机的16×64 LED 点阵显示屏的设计
 学院 全平台OpenGL游戏技术(OSX/Windows/Android/iOS)
 博客 GoFrame——数据校验库之结构体校验
 学院 Java微信小程序手机数码商城 大学生毕业设计教学视频
 学院 Web全栈之成为编程小牛的十八般武艺秘籍
 下载 php二维数组排序详解
 博客 《手写数字识别》神经网络 学习笔记
 下载 window10下编译的hadoop2.7.2