 Lingo

You are going to participate in the television show 'lingo'. You are very confident that you will make the finals of the show. This is not only because you are well prepared, but also because you managed to find a way to use your pda unnoticed during the contest, and you have already written a program to help you with the bonuswords.
In the finals of the show, you first solve as many lingo words as possible within the allowed time. This determines how many balls you may take afterwards. The more balls you may take, the higher your probability is of winning the finals. But it is not easy to see what this probability is. Write a program to help you with this.
For those who don't know the game of lingo, here follows a description of the last part of the finals, where you take the balls. You are given a square grid. Some squares in this grid are covered and the other squares contain numbers. A hopper in front of you contains numbered balls; there is exactly one ball for each numbered grid square. You take a ball at random (without replacement) from this hopper for each lingo word you solved in the first part of the finals. When you take a ball, the corresponding square in the grid becomes covered. You win the finals if an entire row, column or diagonal consist of only covered squares.
InputOn the first line an integer t (1 <= t <= 100): the number of test cases. Then for each test case:
One line with the integers n (1 <= n <= 8) and k (0 <= k), where n is the size of the lingo grid and k is the number of words you solved in the first part of the finals.
n lines, with on each line exactly n characters. Each character will be either '*' or '.', representing a covered square and a numbered square respectively.
There will be at least k numbered squares on the board, and there is no row, column or diagonal covered yet.
Output
For each test case:
One line with the percentage of getting lingo with either an absolute or a relative error of at most 106.
Sample Input
1
5 7
.*.*.
.**..
.*.*.
....
*..*Sample Output
82.703962704
Dice Password Security _course
20171203Problem Description NCIM Group sponsored problem. The NCIM Group does a lot of work on IT solutions in defense and security. Good security usually starts with picking a strong password. Generating a password at random is generally a good practice. For example, a password like "2R4eZ9Rqup" is a bit harder to guess than "god", "love", "sex" or "secret". The problem with passwords consisting of random letters and digits is that they are hard to remember. Instead of using letters and digits it is also possible to generate passwords by putting random words together. Words are easier to remember than letters and digits. Using a dictionary of 7776 (65) words, a 5randomword password is about as strong as a 11randomcharacter password. 77765 = 28430288029929701376 ≈ 3 * 1019 6211 = 52036560683837093888 ≈ 5 * 1019 Some applications hide the password you are typing on the screen by printing dots or asterisks. This allows someone watching your screen to count the number of characters in your password. The NCIM Group wants you to find out whether or not this compromises the strength of your password. You must write a program that calculates the number of possible passwords that can be generated given: the dictionary of words, the amount of words used to generate the password and the length of the password. Input On the first line an integer t (1 <= t <= 100): the number of test cases. Then for each test case: One line with three positive integers m (1 <= m <= 7776), n (1 <= n <= 5) and q (1 <= q <= 20): the number of words in the dictionary, the number of words to generate the password, and the number of queries, respectively. The dictionary: m lines each containing one word wi Each word consists only of lowercase letters. The length of each word will be between 3 and 10 inclusive. No word in the dictionary will be a substring of another word in the dictionary. q lines each containing a positive integer lj (1 <= lj <= 50), the length observed. Output For each test case: q lines with: the number of possible passwords with length lj . This number will be smaller than 263. Sample Input 1 4 2 2 aap noot mies piet 7 8 Sample Output 6 9
Generator _course
20170822Problem Description We can generate a random string by generating a sequence of random characters and concatenating them together. Each character is chosen independently from the first n letters in the English alphabet with equal probability. Only capital letters are used in this problem. The generation is stopped as soon as one of specific patterns occurs in the random string. Your task is to predict the expected length of the generated string. Input Standard input will contain multiple test cases. First line is the number of case x. Each test case consists of integer N (1<=N<=8) which is the number of letters used, and M (1<=M<=10) which is the number of patterns used. The following M lines contain the patterns which are nonempty strings consisting of letters chosen from the first N upper case English letters. The length of any pattern will not exceed 10. Output For each test case, print the expected length of the generated random string. All output numbers are rounded to the second digit after the decimal point. Sample Input 4 2 1 A 2 1 ABA 3 1 AAAAA 2 2 A AA Sample Output 2.00 10.00 363.00 2.00
Pi _course
20170507Professor Robert A. J. Matthews of the Applied Mathematics and Computer Science Department at the University of Aston in Birmingham, England has recently described how the positions of stars across the night sky may be used to deduce a surprisingly accurate value of Pi. This result followed from the application of certain theorems in number theory. Here, we don't have the night sky, but can use the same theoretical basis to form an estimate for Pi: Given any pair of whole numbers chosen from a large, random collection of numbers, the probability that the two numbers have no common factor other than one (1) is 6/Pi^2 For example, using the small collection of numbers: 2, 3, 4, 5, 6; there are 10 pairs that can be formed: (2,3), (2,4), etc. Six of the 10 pairs: (2,3), (2,5), (3,4), (3,5), (4,5) and (5,6) have no common factor other than one. Using the ratio of the counts as the probability we have: 6/Pi^2 = 6/10 Pi = 3.162 In this problem, you'll receive a series of data sets. Each data set contains a set of pseudorandom positive integers. For each data set, find the portion of the pairs which may be formed that have no common factor other than one (1), and use the method illustrated above to obtain an estimate for Pi. Report this estimate for each data set. Input The input consists of a series of data sets. The first line of each data set contains a positive integer value, N, greater than one (1) and less than 50. There is one positive integer per line for the next N lines that constitute the set for which the pairs are to be examined. These integers are each greater than 0 and less than 32768. Each integer of the input stream has its first digit as the first character on the input line. The set size designator, N, will be zero to indicate the end of data. Output A line with a single real value is to be emitted for each input data set encountered. This value is the estimate for Pi for the data set. An output format like the sample below should be used. Answers must be rounded to six digits after the decimal point. For some data sets, it may be impossible to estimate a value for Pi. This occurs when there are no pairs without common factors. In these cases, emit the singleline message: No estimate for this data set. exactly, starting with the first character, "N", as the first character on the line. Sample Input 5 2 3 4 5 6 2 13 39 0 Sample Output 3.162278 No estimate for this data set.
Rock, Scissors, Paper _course
20171103Description Bart's sister Lisa has created a new civilization on a twodimensional grid. At the outset each grid location may be occupied by one of three life forms: Rocks, Scissors, or Papers. Each day, differing life forms occupying horizontally or vertically adjacent grid locations wage war. In each war, Rocks always defeat Scissors, Scissors always defeat Papers, and Papers always defeat Rocks. At the end of the day, the victor expands its territory to include the loser's grid position. The loser vacates the position. Your job is to determine the territory occupied by each life form after n days. Input The first line of input contains t, the number of test cases. Each test case begins with three integers not greater than 100: r and c, the number of rows and columns in the grid, and n. The grid is represented by the r lines that follow, each with c characters. Each character in the grid is R, S, or P, indicating that it is occupied by Rocks, Scissors, or Papers respectively. Output For each test case, print the grid as it appears at the end of the nth day. Leave an empty line between the output for successive test cases. Sample Input 2 3 3 1 RRR RSR RRR 3 4 2 RSPR SPRS PRSP Sample Output RRR RRR RRR RRRS RRSP RSPR
Substitution Cipher _course
20170813Description Antique Comedians of Malidinesia would like to play a new discovered comedy of Aristofanes. Putting it on a stage should be a big surprise for the audience so all the preparations must be kept absolutely secret. The ACM director suspects one of his competitors of reading his correspondece. To prevent other companies from revealing his secret, he decided to use a substitution cipher in all the letters mentioning the new play. Substitution cipher is defined by a substitution table assigning each character of the substitution alphabet another character of the same alphabet. The assignment is a bijection (to each character exactly one character is assigned  not neccessary different). The director is afraid of disclosing the substitution table and therefore he changes it frequently. After each change he chooses a few words from a dictionary by random, encrypts them and sends them together with an encrypted message. The plain (i.e. nonencrypted) words are sent by a secure channel, not by mail. The recipient of the message can then compare plain and encrypted words and create a new substitution table. Unfortunately, one of the ACM cipher specialists have found that this system is sometimes insecure. Some messages can be decrypted by the rival company even without knowing the plain words. The reason is that when the director chooses the words from the dictionary and encrypts them, he never changes their order (the words in the dictionary are lexicographically sorted). String a1a2 ... ap is lexicografically smaller than b1b2 ... bq if there exists an integer i, i <= p, i <= q, such that aj=bj for each j, 1 <= j < i and ai < bi. The director is interested in which of his messages could be read by the rival company. You are to write a program to determine that. Input The input consists of N cases. The first line of the input contains only positive integer N. Then follow the cases. The first line of each case contains only two positive integers A, 1 <= A <= 26, and K, separated by space. A determines the size of the substitution alphabet (the substitution alphabet consists of the first A lowercase letters of the english alphabet (az) and K is the number of encrypted words. The plain words contain only the letters of the substitution alphabet. The plain message can contain any symbol, but only the letters of the substitution alphabet are encrypted. Then follow K lines, each containing exactly one encrypted word. At the next line is encrypted message. Output For each case, print exactly one line. If it is possible to decrypt the message uniquely, print the decrypted message. Otherwise, print the sentence 'Message cannot be decrypted.'. Sample Input 2 5 6 cebdbac cac ecd dca aba bac cedab 4 4 cca cad aac bca bdac Sample Output abcde Message cannot be decrypted.
Unix Robots _course
20170411Wyest is fond of the game Unix Robots. It is played on a twodimensional rectangular board. The objective of the game is to escape from a number of robots, which have been programmed with only a single objective: to kill you. The player character and the robots start at randomly selected grids in the board. Every time the player character moves a square in any direction (horizontally, vertically, or diagonally), so does each robot, in whichever direction is the shortest way. That is, if a robot has two optimal approaches, it will first make xrobot  xman and yrobot  yman both smaller (move diagonally). (In fact there're robots moving two squares in some sets of Unix Robots, but now we're not considering them.) If the player character collides with a robot, he dies and the game ends. However, the robots are also fatal to each other  when two robots collide, they both die, leaving behind a junkheap. These junkheaps are also fatal to robots. You can also transport into a grid in cases where moving is otherwise impossible. There're two kinds of transports, one is safe teleport, which has a limit of using, and the other is random. if you have no more safe ones, you'll have to be transported into a randomly selected location, maybe right into the path of a robot. Generally, the player will gain one safe teleport moving onto the next level, no doubt it's too few. So the Wait button is introduced to you. If you press it, you will no longer be able to move until either all of the robots (which still move towards you) are gone, or you are killed. If you survive finally, each robot will earn you one extra safe teleports to use in future. Now Wyest is playing the game again, and is asking you to do her a little favor. Given the situation on the board, you only need to tell her whether she can press the Wait button now. Input There're multiple test cases. In each test case, the first line contains two integers x and y, coordinates of the grid where the player character is. The second line of a case is an integer n, indicating the number of robots, and n lines follow, each contains two integers xi and yi, coordinates of the grid where roboti is. Then a single line containing an integer m, indicating the number of junkheaps of previous collisions on the board, and m lines follow, each contains two integers xj and yj, coordinates of the grid where junkheapj is. 0 < n <= 100, 0 <= m <= 100. All coordinates between 500000000 and 500000000, and you can safely assume that in each case, no two things are in the same grid initially. Output A single line for each case telling whether Wyest can Wait in the current situation, either "YES" or "NO". Sample Input 0 0 2 3 1 3 1 0 0 0 1 2 0 1 3 0 Sample Output YES NO
To and Fro _course
20170311Mo and Larry have devised a way of encrypting messages. They first decide secretly on the number of columns and write the message (letters only) down the columns, padding with extra random letters so as to make a rectangular array of letters. For example, if the message is ��There��s no place like home on a snowy night�� and there are five columns, Mo would write down t o i o y h p k n n e l e a i r a h s g e c o n h s e m o t n l e w x Note that Mo includes only letters and writes them all in lower case. In this example, Mo used the character ��x�� to pad the message out to make a rectangle, although he could have used any letter. Mo then sends the message to Larry by writing the letters in each row, alternating lefttoright and righttoleft. So, the above would be encrypted as toioynnkpheleaigshareconhtomesnlewx Your job is to recover for Larry the original message (along with any extra padding letters) from the encrypted one. Input There will be multiple input sets. Input for each set will consist of two lines. The first line will contain an integer in the range 2. . . 20 indicating the number of columns used. The next line is a string of up to 200 lower case letters. The last input set is followed by a line containing a single 0, indicating end of input. Output Each input set should generate one line of output, giving the original plaintext message, with no spaces. SampleInput 5 toioynnkpheleaigshareconhtomesnlewx 3 ttyohhieneesiaabss 0 SampleOutput theresnoplacelikehomeonasnowynightx thisistheeasyoneab
Euro Cup 2000 _course
20170504As you maybe know, the qualification for the European Soccer Championship 2000 is a tournament where in each group each team plays against each other team twice. Germany is in group 3 together with Turkey, Finland, Moldova and Northern Ireland. 14 games have been played and 6 are still to come. A quick look at the current standings might make you think that Northern Ireland is already out of the race. But that's wrong! Imagine Northern Ireland wins their three remaining games, Germany plays remis against Turkey and loses against Finland, and Moldova defeats Turkey. Then Northern Ireland is number one! For those who are not familiar with the scoring model: In each game a team gains 3 points for a victory, 1 point for a remis or 0 points for a loss. After all games have been played, teams are ranked according to points. In case of a tie, the additional tie breakers are: goal difference (i.e. goals scored  goals against), goals scored, and random choice, in that order. The question your program should answer is: Regarding all possibilities of how the remaining games could end, what is the highest and lowest possible rank of each team in the group after the tournament is over? Input The input will consist of one or more test cases. Each test case adheres to the following format: On the first line there will be one integer n (1 <= n <= 20), representing the number of teams in the group. On the next n lines, the names of the teams will follow. Names are always shorter than 30 characters and do not contain whitespace. On the next line, there will be an integer g, representing the number of completed games. Finally, g lines will follow, each one describing one completed game in the form team1 team2 goals1 goals2. You may further assume that at most 10 games will be remaining and each team has at least one remaining game to play. (This simplifies the problem a little.) Input will be terminated by a value of zero (0) for n. Output For each test case, first print a line saying "Group #x" where x is the number of the test case (counting from 1). Then, print one line per team in the order they appear in the input. On each line, print the team's name, a blank character, its best possible rank, a minus sign and its worst possible rank. Print a blank line after each test case, even after the last one. Sample Input 2 A B 1 A B 1 0 5 Ger Tur Fin Nor Mol 14 Fin Mol 3 2 Tur Nor 3 0 Tur Ger 1 0 Nor Fin 1 0 Mol Ger 1 3 Tur Fin 1 3 Nor Mol 2 2 Nor Ger 0 3 Tur Mol 2 0 Ger Fin 2 0 Mol Fin 0 0 Ger Mol 6 1 Fin Tur 2 4 Mol Nor 0 0 0 Sample Output Group #1 A 12 B 12 Group #2 Ger 13 Tur 13 Fin 14 Nor 15 Mol 45
Decoding Task _course
20170215Description In the near future any research and publications about cryptography are outlawed throughout the world on the grounds of national security concerns. The reasoning for this is clear and widely accepted by all governments  if cryptography literature is public like in the old times, then everybody (even criminals and terrorists) could easily use it to hide their malicious plans from the national and international security forces. Consequently, public cryptographic algorithms and systems have ceased to exist, and everybody who needs strong protection for their secrets is forced to invent proprietary algorithms. The ACM Corporation has lots of competitors who are eager to learn its trade secrets. Moreover, the job to protect their secrets is complicated by the fact, that they are forced to use intercontinental communication lines which are easy to eavesdrop on, unlike internal lines of the ACM Corporation which are well guarded. Therefore, the ACM Corporation have invented the Intercontinental Cryptographic Protection Code (ICPC) which they are very proud of, and which is considered unbreakable  nobody has even tried to break it yet, but that is about to change. The group of hackers was hired by the rival company, which does not disclose its name to them, to break ICPC. As the first step, they have bribed one of the programmers who implemented the software for ICPC and have learned how ICPC works. It turns out, the ICPC uses very long key which is a sequence of bytes generated by some sophisticated and random physical process. This key is changed weekly and is used to encrypt all messages that are sent over intercontinental communication lines during the week. This programmer has also proudly told them, that ICPC is the fastest code in the world, because (having the benefit of highly sophisticated code generation) they simply perform bitwise exclusive OR (XOR) operation between the bytes of the message and the key. That is, the ith byte of the encrypted message Ei = Ki XOR Ci, where Ki is the ith byte of the key and Ci is the ith byte of the original cleartext message. Having learned how ICPC works, they have started to look for the way to reliably obtain the key every week, which is the only thing that is still missing to listen for all intercontinental communications of the ACM Corporation (eavesdropping on the intercontinental lines themselves has indeed turned out to be an easy task). An attempt to bribe the security officers who guard and distribute the key has failed, because the security officers (having the profession with one the highest salaries of that time) have turned out to be too expensive to bribe. During the search for alternative solutions, they have stumbled upon a clerk, who sends weekly newsletters to various employees and departments. Fortunately, these newsletters are being sent just after the change of the key and the messages are usually long enough to recover sufficient portions of the key by studying original newsletters and their encoded forms. However, they could not covertly find anyone who will disclose the newsletter contents on a weekly basis, because all the employees were bound by a NonDisclosure Agreement (NDA) and the penalty for the disclosure of any corporate message according to this NDA is death. Yet they were able to convince this clerk (for a small reward) to do a seemingly innocent thing. That is, while sending the copies of newsletter throughout the corporation, he was instructed to insert an extra space character in the beginning of some messages but send other copies in their original form. Now the task to recover the key is straightforward and it is you, who shall create a program for this. The program is given two ICPCed messages where the first message is N bytes, and the second one is N+1 bytes and is the result of encoding the same cleartext messages as the first one, but with one extra space character (represented by the byte with the decimal value of 32) in the beginning. The program shall find the first N+1 bytes of the key that was used to encode the messages. Input The input consists of two lines. The first line consists of 2N characters and represents the encoded message N bytes long. The second line consists of 2N+2 characters and represents the encoded message N+1 bytes long. Here 1 ≤ N ≤ 10000. Each message is written on a single line in a hexadecimal form byte by byte without spaces. Each byte of the message is represented by two characters '0''9', 'A''F' that represent the hexadecimal value of the corresponding byte. Output Write to the output a single line that represents N+1 bytes of the recovered key in the same hexadecimal format as in the input. Sample Input 05262C5269143F314C2A69651A264B 610728413B63072C52222169720B425E Sample Output 41434D2049435043204E454552432732
In Defence of a Garden _course
20161225Description It's said that "Necessity is the mother of invention," but some people think that "Laziness" is a more likely parent. Hubert Greenthumb hated digging fence posts. But he knew that, without a fence around his garden, deer from the nearby woods would eat his vegetables before he could harvest them. Being something of a tinkerer, he retired to his workshop with a small garden tractor, some outofdate computer chips, and a couple of robot arms he had picked up at a bankruptcy auction from a failed ".com" hightech company. After two days of work, he emerged as the proud inventor of the Greenthumb Automatic Garden Fence Layer (pat. pending). To his skeptical wife (who observed that he could easily have built the fence in half the time it took to construct this machine), he explained that he needed only to program in the desired fence shape, and the machine would proceed to chug around the yard, laying down a fence in 1foot sections until the job had been completed. Hubert proceeded to key in instructions to enclose a square area, 25 feet on a side, of his 100' by 100' yard. He set the machine to operating and went inside for a celebratory drink. When he emerged, he discovered that the machine had laid down fence in an elaborate, possibly random walk about his lawn. Unwilling to actually admit that anything had gone wrong, he announced his intention to plant within the garden actually laid out by the machine, as if he had wanted it that way all along. Any section of the yard that was no longer accessible to the deer (enclosed by the fence) would be considered as garden space. "Fine," sighed his wife, "but we'll need to know just how many square feet of garden we have so that we can buy an appropriate amount of seeds." Hubert gamely began to trace out the fence laid down by the machine. "Let's see, it went North for 5 feet, then West for 3 feet, ..." Note: Hubert's yard can be divided into a grid of 100 × 100 feet, with each grid box being 1 foot by 1 foot. The robot moves along the edges of the boxes. As the robot moves, it builds a fence from vertex to vertex of the grid (intersections of the lines). Note: Because the robot moves along the edges of the grid, you can ignore the amount of space the fence occupies. For example, if the robot moves North one, East one, South one, andWest one, it has enclosed one square foot of garden space. Input The first line of the input will contain the number of data sets. The are no blank lines before or after each data set. The first line of each data set will contain three integers (X Y Z), indicating the X and Y position of the starting point on the grid, and the number of moves the robot makes. (X, Y , and Z are all nonnegative integers, X is the number of feet from the western edge, Y is the number of feet from the southern edge of the yard). (X and Y range from 0 to 100, inclusive.) The next Z lines will contain a character D and an integer F, separated by a space. The character will indicate the direction (N, S, E, W) and the integer will indicate how far in that direction the robot traveled. The path will never leave the 100' by 100' yard. The path may or may not be closed. It may cross itself or retrace its steps (walk along lines in the grid it previously laid fence). It automatically stops building fence until it moves onto an edge without fence on it. Output For each data set, output a single line of the form Data Set N: Q square feet. where N is the data set number (from 1) and Q is the number of square feet that are enclosed so they may be used for the garden. After the last line of output, print "End of Output" on a line by itself. Sample Input 1 0 0 8 N 25 E 25 N 25 E 25 S 25 W 25 S 25 W 25 Sample Output Data Set 1: 1250 square feet. End of Output
CARDS _course
20170808Description Alice and Bob have a set of N cards labelled with numbers 1 ... N (so that no two cards have the same label) and a shuffle machine. We assume that N is an odd integer. The shuffle machine accepts the set of cards arranged in an arbitrary order and performs the following operation of double shuffle : for all positions i, 1 <= i <= N, if the card at the position i is j and the card at the position j is k, then after the completion of the operation of double shuffle, position i will hold the card k. Alice and Bob play a game. Alice first writes down all the numbers from 1 to N in some random order: a1, a2, ..., aN. Then she arranges the cards so that the position ai holds the card numbered ai+1, for every 1 <= i <= N1, while the position aN holds the card numbered a1. This way, cards are put in some order x1, x2, ..., xN, where xi is the card at the ith position. Now she sequentially performs S double shuffles using the shuffle machine described above. After that, the cards are arranged in some final order p1, p2, ..., pN which Alice reveals to Bob, together with the number S. Bob's task is to guess the order x1, x2, ..., xN in which Alice originally put the cards just before giving them to the shuffle machine. Input The first line of the input contains two integers separated by a single blank character : the odd integer N, 1 <= N <= 1000, the number of cards, and the integer S, 1 <= S <= 1000, the number of double shuffle operations. The following N lines describe the final order of cards after all the double shuffles have been performed such that for each i, 1 <= i <= N, the (i+1)st line of the input file contains pi (the card at the position i after all double shuffles). Output The output should contain N lines which describe the order of cards just before they were given to the shuffle machine. For each i, 1 <= i <= N, the ith line of the output file should contain xi (the card at the position i before the double shuffles). Sample Input 7 4 6 3 1 2 4 7 5 Sample Output 4 7 5 6 1 2 3
Pachinko _course
20170316This problem is inspired by Pachinko, a popular game in Japan. A traditional Pachinko machine is a cross between a vertical pinball machine and a slot machine. The player launches small steel balls to the top of the machine using a plunger as in pinball. A ball drops through a maze of pins that deflect the ball, and eventually the ball either exits at a hole in the bottom and is lost, or lands in one of many gates scattered throughout the machine which reward the player with more balls in varying amounts. Players who collect enough balls can trade them in for prizes. For the purposes of this problem, a Pachinko machine is sequences of one or more of the following: holes ("."), floor tiles ("_"), walls (""), and mountains ("/\"). A wall or mountain will never be adjacent to another wall or mountain. To play the game, a ball is dropped at random over some character within a machine. A ball dropped into a hole falls through. A ball dropped onto a floor tile vertically stops immediately and a ball dropped onto a floor tite with horizontal speed continues to roll at the same direction. A ball dropped onto the left side of a mountain rolls to the left across any number of consecutive floor tiles until it falls into a hole, falls off the left end of the machine, or stops by hitting a wall or mountain. A ball dropped onto the right side of a mountain behaves similarly. A ball dropped onto a wall behaves as if it were dropped onto the left or right side of a mountain, with a 50% chance for each. If a ball is dropped at random over the machine, with all starting positions being equally likely, what is the probability that the ball will fall either through a hole or off an end? For example, consider the following machine, where the numbers just indicate character positions and are not part of the machine itself: 123456789 /\.__/\. The probabilities that a ball will fall through a hole or off the end of the machine are as follows, by position: 1=100%, 2=100%, 3=100%, 4=50%, 5=0%, 6=0%, 7=0%, 8=100%, 9=100%. The combined probability for the whole machine is just the average, which is approximately 61.111%. Input The input consists of one or more linear Pachinko machines, each of which contains m lines of n characters(1 <= n, m <= 1000). Two consecutive Pachinko machines are seperated by an empty line. Output For each machine, compute as accurately as possible the probability that a ball will fall through a hole or off the end when dropped at random, then output a single line containing that percentage round to 0.01. Sample Input /\.__/\. ___../\._ ____._/\ Sample Output 61.11 32.50
学透JavaScript
20200314JavaScript是前端程序员的必修课，也是目前流行的各前端框架的基础知识。本课程将全面剖析JavaScript的运行机制，掌握最核心的语法和编程思维、使用丰富的实例来帮助学员的理解JavaScript、jQurey。介绍笔试，面试环节中关于JS的常见问题，为将来的工作打下坚实基础。主讲老师有着丰富的前端开发经验和教学经验，在教学过程中不仅注重前端实践的动手能力，同时也注重培养同学们的编程思维模式和手写代码的核心能力。全课程不复制粘贴，除了特殊情况外，所有代码全部直播手写（直接敲代码），增加同学们的印象，相信通过这样的能力训练，同学们的动手能力会有飞越的提升。
高性能MySQL实战课
20200521限时福利1：原价 129 元，最后2天仅需 69 元！后天涨价至98元 限时福利2：购课进答疑群专享柳峰（刘运强）老师答疑服务 限时福利3：购课添加助教领取价值 800 元的编程大礼包 为什么需要掌握高性能的MySQL实战？ 由于互联网产品用户量大、高并发请求场景多，因此对MySQL的性能、可用性、扩展性都提出了很高的要求。使用MySQL解决大量数据以及高并发请求已经是程序员的必备技能，也是衡量一个程序员能力和薪资的标准之一。 为了让大家快速系统了解高性能MySQL核心知识全貌，我为你总结了「高性能 MySQL 知识框架图」,帮你梳理学习重点，建议收藏！ 【课程设计】 课程分为四大篇章，将为你建立完整的 MySQL 知识体系，同时将重点讲解 MySQL 底层运行原理、数据库的性能调优、高并发、海量业务处理、面试解析等。 一、性能优化篇： 主要包括经典 MySQL 问题剖析、索引底层原理和事务与锁机制。通过深入理解 MySQL 的索引结构 B+Tree ，学员能够从根本上弄懂为什么有些 SQL 走索引、有些不走索引，从而彻底掌握索引的使用和优化技巧，能够避开很多实战中遇到的“坑”。 二、MySQL 8.0新特性篇： 主要包括窗口函数和通用表表达式。企业中的许多报表统计需求，如果不采用窗口函数，用普通的 SQL 语句是很难实现的。 三、高性能架构篇： 主要包括主从复制和读写分离。在企业的生产环境中，很少采用单台MySQL节点的情况，因为一旦单个节点发生故障，整个系统都不可用，后果往往不堪设想，因此掌握高可用架构的实现是非常有必要的。 四、面试篇： 程序员获得工作的第一步，就是高效的准备面试，面试篇主要从知识点回顾总结的角度出发，结合程序员面试高频MySQL问题精讲精练，帮助程序员吊打面试官，获得心仪的工作机会。
 3.64MB
Xshell6完美破解版，亲测可用
20181226Xshell6破解版，亲测可用，分享给大家。直接解压即可使用
 43.19MB
智鼎(附答案).zip
20200422并不是完整题库，但是有智鼎在线2019年9、10、11三个月的试题，有十七套以上题目，普通的网申行测题足以对付，可以在做题时自己总结一些规律，都不是很难
 43KB
炉温系统的PID控制器设计——MATLAB程序
20180517本文主要研究的课题是：炉温系统的PID控制器设计研究 ，并且在MATLAB的大环境下进行模拟仿真。 (1)第一章 介绍课题的研究背景、意义以及发展现状。 (2)第二章 建立炉温系统数学模型 (3)第三
Python入门视频精讲
20180904Python入门视频培训课程以通俗易懂的方式讲解Python核心技术，Python基础，Python入门。适合初学者的教程，让你少走弯路！ 课程内容包括：1.Python简介和安装 、2.第一个Python程序、PyCharm的使用 、3.Python基础、4.函数、5.高级特性、6.面向对象、7.模块、8.异常处理和IO操作、9.访问数据库MySQL。教学全程采用笔记+代码案例的形式讲解，通俗易懂！！！
 121KB
移动认证互联网内容管理题库L2
20190426中国移动认证互联网内容管理学习题库L2
21天通关Python（仅视频课）
20190521本页面购买不发书！！！仅为视频课购买！！！ 请务必到https://edu.csdn.net/bundled/detail/49下单购买课+书。 本页面，仅为观看视频页面，如需一并购买图书，请务必到https://edu.csdn.net/bundled/detail/49下单购买课程+图书！！！ 疯狂Python精讲课程覆盖《疯狂Python讲义》全书的主体内容。 内容包括Python基本数据类型、Python列表、元组和字典、流程控制、函数式编程、面向对象编程、文件读写、异常控制、数据库编程、并发编程与网络编程、数据可视化分析、Python爬虫等。 全套课程从Python基础开始介绍，逐步步入当前就业热点。将会带着大家从Python基础语法开始学习，为每个知识点都提供对应的代码实操、代码练习，逐步过渡到文件IO、数据库编程、并发编程、网络编程、数据分 析和网络爬虫等内容，本课程会从小案例起，至爬虫、数据分析案例终、以Python知识体系作为内在逻辑，以Python案例作为学习方式，最终达到“知行合一”。
手把手搭建Java酒店管理系统【附源码】（毕设）
20200316本课程演示的是一套基于SSM框架实现的酒店管理系统，主要针对计算机相关专业的正在做毕设的学生与需要项目实战练习的Java学习者。 1. 包含：项目源码、项目文档、数据库脚本、软件工具等所有资料 2. 手把手的带你从零开始部署运行本套系统 3. 该项目附带的源码资料可作为毕设使用 4. 提供技术答疑和远程协助指导 技术实现： 1. 后台框架：Spring、SpringMVC、MyBatis 2. UI界面：BootStrap、JSP、jQuery 3. 数据库：MySQL 项目截图： 1）系统登陆界面 2）客房预订 3）住宿登记 4）旅客管理 更多Java毕设项目请关注【毕设系列课程】https://edu.csdn.net/lecturer/2104
 41.61MB
官方 DEV C++ 中文版
20131017官方的DEV C++ 规范好用的自学C语言工具
Python进阶Pandas数据分析库
20181218您观看课程学习后 免费入群领取【超全Python资料包+17本学习电子书】 Pandas是python中非常常用的数据分析库，在数据分析，机器学习，深度学习等领域经常被使用。本课程会讲解到pandas中最核心的一些知识点，包括Series以及DataFrame的构建，赋值，操作，选择数据，合并等等，以及使用pandas对文件进行读取和写入，使用pandas绘图等等。
 81.6MB
宠物医院管理系统(JAVA,SSM,JSP,MYSQL)【源码+数据库脚本+论文】
20200902本宠物医院管理系统以宠物交易、宠物收藏、加入购物车、在线支付、宠物寄养、在线挂号和网站留言为前台主要功能点来设计，总体上实现了一个B/S架构网站应具备的基本特点。
 下载 微信JSSDK上传图片
 学院 vue
 博客 强化学习组队学习task02——马尔可夫决策过程及表格型方法
 学院 Android开发  kotlin + jetpack + mvvm
 学院 Web全栈之成为编程小牛的十八般武艺秘籍
 下载 通信网络中的射频干扰成因与对策
 博客 12864为何个别汉字无法正常显示
 学院 2020千锋Linux云计算入门视频全套全开源（最新版）
 博客 CF504E Iron Man
 下载 遗传模糊算法在短期负荷预测中的应用
 博客 sql server 导进数据
 博客 P5502[JSOI2015]最大公约数【分治】
 下载 频率可自动调节的高线性度低通滤波器设计
 学院 NodeRED手把手从入门到实战
 下载 CSS javascript 结合实现悬浮固定菜单效果
 学院 多元线性回归模型的参数与统计量深度解读基于Python编程复现
 学院 轻松学习单片机
 博客 Dark CTF 2020Rev/c_mathswriteup
 学院 PHP微信小程序珠宝首饰商城 大学生毕业设计 教学视频
 博客 尼克勒的PTA之始
 博客 20201023
 学院 Java教程_2020最新版_JavaSE基础入门教程（小白版）
 学院 Java小白学习方法指南！避开思维惯性！让学习事半功倍
 学院 Vue3.0从入门到进阶实战
 下载 jQuery实现动态表单验证时文本框抖动效果完整实例
 博客 scan ip和vip的关系疑惑
 下载 JavaScript 常见安全漏洞和自动化检测技术
 下载 jQuery实现向下滑出的二级菜单效果实例
 下载 EFUCMSE16小说漫画系统源码
 学院 JavaWeb珠宝首饰购物商城毕业设计 大学生毕业设计教学视频