 Fermat vs. Pythagoras

Description
Computer generated and assisted proofs and verification occupy a small niche in the realm of Computer Science. The first proof of the fourcolor problem was completed with the assistance of a computer program and current efforts in verification have succeeded in verifying the translation of highlevel code down to the chip level.
This problem deals with computing quantities relating to part of Fermat's Last Theorem: that there are no integer solutions of a^n + b^n = c^n for n > 2.
Given a positive integer N, you are to write a program that computes two quantities regarding the solution of x^2 + y^2 = z^2, where x, y, and z are constrained to be positive integers less than or equal to N. You are to compute the number of triples (x,y,z) such that x < y < z, and they are relatively prime, i.e., have no common divisor larger than 1. You are also to compute the number of values 0 < p <= N such that p is not part of any triple (not just relatively prime triples).
InputThe input consists of a sequence of positive integers, one per line. Each integer in the input file will be less than or equal to 1,000,000. Input is terminated by endoffile
OutputFor each integer N in the input file print two integers separated by a space. The first integer is the number of relatively prime triples (such that each component of the triple is <=N). The second number is the number of positive integers <=N that are not part of any triple whose components are all <=N. There should be one output line for each input line.
Sample Input10
25
100
Sample Output1 4
4 9
16 27
Fermat vs. Pythagoras，这道题目用C语言的程序的编写的代码的形式如何进行正确回答的_course
20190602Description Computer generated and assisted proofs and verification occupy a small niche in the realm of Computer Science. The first proof of the fourcolor problem was completed with the assistance of a computer program and current efforts in verification have succeeded in verifying the translation of highlevel code down to the chip level. This problem deals with computing quantities relating to part of Fermat's Last Theorem: that there are no integer solutions of a^n + b^n = c^n for n > 2. Given a positive integer N, you are to write a program that computes two quantities regarding the solution of x^2 + y^2 = z^2, where x, y, and z are constrained to be positive integers less than or equal to N. You are to compute the number of triples (x,y,z) such that x < y < z, and they are relatively prime, i.e., have no common divisor larger than 1. You are also to compute the number of values 0 < p <= N such that p is not part of any triple (not just relatively prime triples). Input The input consists of a sequence of positive integers, one per line. Each integer in the input file will be less than or equal to 1,000,000. Input is terminated by endoffile Output For each integer N in the input file print two integers separated by a space. The first integer is the number of relatively prime triples (such that each component of the triple is <=N). The second number is the number of positive integers <=N that are not part of any triple whose components are all <=N. There should be one output line for each input line. Sample Input 10 25 100 Sample Output 1 4 4 9 16 27
less的使用,在使用标签导入时出错_course
20170714[165] ./src/styles/layout/Home.less 1.07 kB {0} [built] + 352 hidden modules ERROR in ./~/cssloader!./~/lessloader/dist!./src/styles/layout/Home.less Module build failed: alignitems: center; borderbottom: 1px solid @bordercolorbase; ^ Variable @bordercolorbase is undefined in /home/jkwu/WebstormProjects/electronDesktopTool/src/styles/layout/Home.less (line 20, column 27) @ ./src/styles/layout/Home.less 4:14128 @ ./src/components/layout/Home.js  上面时我在使用webpack打包的时候,出现的错误,其中 borderbottom: 1px solid @bordercolorbase;是什么意思??
Ponds _course
20171029Problem Description Betty owns a lot of ponds, some of them are connected with other ponds by pipes, and there will not be more than one pipe between two ponds. Each pond has a value v. Now Betty wants to remove some ponds because she does not have enough money. But each time when she removes a pond, she can only remove the ponds which are connected with less than two ponds, or the pond will explode. Note that Betty should keep removing ponds until no more ponds can be removed. After that, please help her calculate the sum of the value for each connected component consisting of a odd number of ponds Input The first line of input will contain a number T(1≤T≤30) which is the number of test cases. For each test case, the first line contains two number separated by a blank. One is the number p(1≤p≤104) which represents the number of ponds she owns, and the other is the number m(1≤m≤105) which represents the number of pipes. The next line contains p numbers v1,...,vp, where vi(1≤vi≤108) indicating the value of pond i. Each of the last m lines contain two numbers a and b, which indicates that pond a and pond b are connected by a pipe. Output For each test case, output the sum of the value of all connected components consisting of odd number of ponds after removing all the ponds connected with less than two pipes. Sample Input 1 7 7 1 2 3 4 5 6 7 1 4 1 5 4 5 2 3 2 6 3 6 2 7 Sample Output 21
Treasure Hunters _course
20170803Introduction You've been a treasure hunter for a long time. You're pretty good at disarming traps, sneaking past the natives, and generally getting the goods while leaving your skin intact. That stuff doesn't really worry you, but what really raises a sweat is after each expedition there are always very tense arguments about how to split up the loot. You've worked with all kinds of characters and nobody ever agrees on what each piece of treasure is actually worth. You need to come up with a way of splitting the booty as fairly as possible. Input Input to this problem will consist of a (nonempty) series of up to 100 data sets. Each data set will be formatted according to the following description, and there will be no blank lines separating data sets. A single data set has 5 components: Start line  A single line, "START" Number of Treasures  A single line with a single integer, t, where 1 <= t <= 8, indicating the number of treasures. Number of Hunters  A single line with a single integer, h, where 1 <= h <= 6, indicating the number of treasure hunters. Treasure Value List  A series of h lines, one for each hunter in sequence (line 1 for hunter 1, line 2 for hunter 2, etc.). Each line contains a spaceseparated list of estimated treasure values for that hunter. The first estimate on each line is for treasure 1, the second is for treasure 2, etc., and an estimate for each treasure will appear for every hunter. Each estimate will be a positive integer strictly less than 10000. End line  A single line, "END" Output For each input data set, there will be exactly one output set, and there will be exactly one blank line separating output sets. Each output set consists of multiple lines, where each line represents a hunter (listed in the same order as the corresponding input data set). Each line contains a list of the treasures given to that hunter followed by the total perceived cash value (by that hunter), of all the treasures they receive. Treasures will be listed in ascending order by treasure number, and all values on each line will be spaceseparated. Treasures will be divided among the hunters in the fairest way possible. The "fairest" way to divide the treasure is defined to be the distribution with the minimum difference between the highest perceived total value and the lowest perceived total value of treasures received by any hunter. In other words, find the distribution that minimizes the difference between the hunter that gets the "most" and the hunter that gets the "least." There will not be multiple "fair" distributions. Sample Input START 5 3 42 500 350 700 100 250 200 500 1000 75 150 400 800 800 150 END START 5 3 42 500 350 200 100 250 200 500 1000 75 150 400 800 800 150 END START 5 3 500 500 350 200 100 250 200 500 1000 75 150 400 800 800 150 END Sample Output 4 700 3 5 575 1 2 550 1 4 5 342 3 500 2 400 1 2 1000 4 1000 3 5 950
CssEmbed在bootstrap_less文件上生成异常_course
20131105<div class="posttext" itemprop="text"> <p>I'm currently following this tutorial: <a href="https://www.youtube.com/watch?v=5om81wXYIns" rel="nofollow">https://www.youtube.com/watch?v=5om81wXYIns</a></p> <p>It's about learning Symfony 2.3, and right now is demonstrating how to set up Twitter Bootstrap and also how to use assetic with cssembed, to compress all css and javascript code in to 1 file each.</p> <p>I'm working on Windows7, I can't get a linux machine or VM where I'm at.</p> <p>The config file can be found here: <a href="http://mossco.co.uk/symfony2/symfony2andbootstrap3asseticconfigandbasehtmltemplatefile/" rel="nofollow">http://mossco.co.uk/symfony2/symfony2andbootstrap3asseticconfigandbasehtmltemplatefile/</a></p> <p>I of course changed the java path to this:</p> <pre><code>java: 'C:\Program Files\Java\jre7\bin' </code></pre> <p>An exception is thrown on the file </p> <blockquote> <p>../web/assetic/bootstrap_less.less</p> </blockquote> <p>The exception being: </p> <blockquote> <p>Failed to assign arg @list: line: 50</p> </blockquote> <p>That also means the file is never generated, so I don't really know where to look for the error. And even then, I don't know how to fix it. I've got all this listed in the composer.json file and it has been updated:</p> <pre><code>"leafo/lessphp": "*", "twitter/bootstrap": "*", "components/jquery": "devmaster" </code></pre> <p>Does anyone have an incling of what might be going wrong here?</p> </div>
将html模板组件存储在数据库中_course
20120219<div class="posttext" itemprop="text"> <p>I am looking for a solution to a staright forward problem:</p> <p>There are some templates which are divided into parts of two types: <strong>1. image 2. text</strong></p> <p>I call these parts as <strong>components</strong> of the template whose values are entered by the user. The image component can have a link, alt text related to it. The text component can have plain text or some lines of html. The value of these components are used to render the final output of the template.</p> <p>There can be around 510 components for each template which may not be common for other templates, like:</p> <pre><code>pageTitle tagline firstParagraph buttonText headerImage  Image Component firstImage  Image Component </code></pre> <p>So the simple calculation says:</p> <ul> <li>1 page = 1 template</li> <li>1 user can have > 1 pages</li> <li>Each template can have 510 components</li> </ul> <p>So if i store it like:</p> <pre><code>COMPONENT TYPE VALUE LINK pageTitle text Hello world tagline text tagline here headerImage image image.jpg http://example.com </code></pre> <p>And it can be any number of users, so lets say 10000 pages will have > 10000*10 components in a db!!</p> <p>How can we have less number of entries and with the best performance? Better schema? Serialized? Json? File based system? or anything else... What can be done?</p> <p>Thanks in advance!</p> </div>
费尔马二平方素数_course
20060519题目： 除了2这个特别的素数外，所有的素数都可以分成两类：第一类是被4除余 1的素数，如5，13，17，29，37，41；第二类是被4除余3的素数，如3，7， 11，19，23，31。第一类素数都能表
Rectangles _course
20161120描述 : A specialist in VLSI design testing must decide if there are some components that cover each other for a given design. A component is represented as a rectangle. Assume that each rectangle is rectilinearly oriented (sides parallel to the x and y axis), so that the representation of a rectangle consists of its minimum and maximum x and y coordinates. Write a program that counts the rectangles that are entirely covered by another rectangle. 输入: The input contains the text description of several sets of rectangles. The specification of a set consists of the number of rectangles in the set and the list of rectangles given by the minimum and maximum x and y coordinates separated by white spaces, in the format: nr_rectangles xmin1 xmax1 ymin1 ymax1 xmin2 xmax2 ymin2 ymax2 … xminn xmaxn yminn ymaxn For each set,there will be less than 5000 rectangles. 输出: The output should be printed on the standard output. For each given input data set, print one integer number in a single line that gives the result (the number of rectangles that are covered). 样例输入: 3 100 101 100 101 0 3 0 101 20 40 10 400 4 10 20 10 20 10 20 10 20 10 20 10 20 10 20 10 20 样例输出: 0 4
连通图的数据结构上的一个算法的视线，怎么能采用C语言的程序的设计的思想去实现？_course
20190428Problem Description Betty owns a lot of ponds, some of them are connected with other ponds by pipes, and there will not be more than one pipe between two ponds. Each pond has a value v. Now Betty wants to remove some ponds because she does not have enough money. But each time when she removes a pond, she can only remove the ponds which are connected with less than two ponds, or the pond will explode. Note that Betty should keep removing ponds until no more ponds can be removed. After that, please help her calculate the sum of the value for each connected component consisting of a odd number of ponds Input The first line of input will contain a number T(1≤T≤30) which is the number of test cases. For each test case, the first line contains two number separated by a blank. One is the number p(1≤p≤104) which represents the number of ponds she owns, and the other is the number m(1≤m≤105) which represents the number of pipes. The next line contains p numbers v1,...,vp, where vi(1≤vi≤108) indicating the value of pond i. Each of the last m lines contain two numbers a and b, which indicates that pond a and pond b are connected by a pipe. Output For each test case, output the sum of the value of all connected components consisting of odd number of ponds after removing all the ponds connected with less than two pipes. Sample Input 1 7 7 1 2 3 4 5 6 7 1 4 1 5 4 5 2 3 2 6 3 6 2 7 Sample Output 21
数据结构C语言计算，要用数组的顺序表的插入删除_course
20190107Problem Description Betty owns a lot of ponds, some of them are connected with other ponds by pipes, and there will not be more than one pipe between two ponds. Each pond has a value v. Now Betty wants to remove some ponds because she does not have enough money. But each time when she removes a pond, she can only remove the ponds which are connected with less than two ponds, or the pond will explode. Note that Betty should keep removing ponds until no more ponds can be removed. After that, please help her calculate the sum of the value for each connected component consisting of a odd number of ponds Input The first line of input will contain a number T(1≤T≤30) which is the number of test cases. For each test case, the first line contains two number separated by a blank. One is the number p(1≤p≤104) which represents the number of ponds she owns, and the other is the number m(1≤m≤105) which represents the number of pipes. The next line contains p numbers v1,...,vp, where vi(1≤vi≤108) indicating the value of pond i. Each of the last m lines contain two numbers a and b, which indicates that pond a and pond b are connected by a pipe. Output For each test case, output the sum of the value of all connected components consisting of odd number of ponds after removing all the ponds connected with less than two pipes. Sample Input 1 7 7 1 2 3 4 5 6 7 1 4 1 5 4 5 2 3 2 6 3 6 2 7 Sample Output 21
这里的C语言排序的实现，采用什么思路可以实现，代码怎么写的？_course
20190109Problem Description Betty owns a lot of ponds, some of them are connected with other ponds by pipes, and there will not be more than one pipe between two ponds. Each pond has a value v. Now Betty wants to remove some ponds because she does not have enough money. But each time when she removes a pond, she can only remove the ponds which are connected with less than two ponds, or the pond will explode. Note that Betty should keep removing ponds until no more ponds can be removed. After that, please help her calculate the sum of the value for each connected component consisting of a odd number of ponds Input The first line of input will contain a number T(1≤T≤30) which is the number of test cases. For each test case, the first line contains two number separated by a blank. One is the number p(1≤p≤104) which represents the number of ponds she owns, and the other is the number m(1≤m≤105) which represents the number of pipes. The next line contains p numbers v1,...,vp, where vi(1≤vi≤108) indicating the value of pond i. Each of the last m lines contain two numbers a and b, which indicates that pond a and pond b are connected by a pipe. Output For each test case, output the sum of the value of all connected components consisting of odd number of ponds after removing all the ponds connected with less than two pipes. ``` Sample Input 1 7 7 1 2 3 4 5 6 7 1 4 1 5 4 5 2 3 2 6 3 6 2 7 ``` Sample Output 21
最大最小间隔的匹配，多行数据输入动态数组分配，怎么利用的C语言实现的_course
20190129Description You've been a treasure hunter for a long time. You're pretty good at disarming traps, sneaking past the natives, and generally getting the goods while leaving your skin intact. That stuff doesn't really worry you, but what really raises a sweat is after each expedition there are always very tense arguments about how to split up the loot. You've worked with all kinds of characters and nobody ever agrees on what each piece of treasure is actually worth. You need to come up with a way of splitting the booty as fairly as possible. Input Input to this problem will consist of a (nonempty) series of up to 100 data sets. Each data set will be formatted according to the following description, and there will be no blank lines separating data sets. A single data set has 5 components: Start line  A single line, "START" Number of Treasures  A single line with a single integer, t, where 1 <= t <= 8, indicating the number of treasures. Number of Hunters  A single line with a single integer, h, where 1 <= h <= 6, indicating the number of treasure hunters. Treasure Value List  A series of h lines, one for each hunter in sequence (line 1 for hunter 1, line 2 for hunter 2, etc.). Each line contains a spaceseparated list of estimated treasure values for that hunter. The first estimate on each line is for treasure 1, the second is for treasure 2, etc., and an estimate for each treasure will appear for every hunter. Each estimate will be a positive integer strictly less than 10000. End line  A single line, "END" Output For each input data set, there will be exactly one output set, and there will be exactly one blank line separating output sets. Each output set consists of multiple lines, where each line represents a hunter (listed in the same order as the corresponding input data set). Each line contains a list of the treasures given to that hunter followed by the total perceived cash value (by that hunter), of all the treasures they receive. Treasures will be listed in ascending order by treasure number, and all values on each line will be spaceseparated. Treasures will be divided among the hunters in the fairest way possible. The "fairest" way to divide the treasure is defined to be the distribution with the minimum difference between the highest perceived total value and the lowest perceived total value of treasures received by any hunter. In other words, find the distribution that minimizes the difference between the hunter that gets the "most" and the hunter that gets the "least." There will not be multiple "fair" distributions. Sample Input START 5 3 42 500 350 700 100 250 200 500 1000 75 150 400 800 800 150 END START 5 3 42 500 350 200 100 250 200 500 1000 75 150 400 800 800 150 END START 5 3 500 500 350 200 100 250 200 500 1000 75 150 400 800 800 150 END Sample Output 4 700 3 5 575 1 2 550 1 4 5 342 3 500 2 400 1 2 1000 4 1000 3 5 950
Fermat vs. Pythagoras 代码设计_course
20191003Description Computer generated and assisted proofs and verification occupy a small niche in the realm of Computer Science. The first proof of the fourcolor problem was completed with the assistance of a computer program and current efforts in verification have succeeded in verifying the translation of highlevel code down to the chip level. This problem deals with computing quantities relating to part of Fermat's Last Theorem: that there are no integer solutions of a^n + b^n = c^n for n > 2. Given a positive integer N, you are to write a program that computes two quantities regarding the solution of x^2 + y^2 = z^2, where x, y, and z are constrained to be positive integers less than or equal to N. You are to compute the number of triples (x,y,z) such that x < y < z, and they are relatively prime, i.e., have no common divisor larger than 1. You are also to compute the number of values 0 < p <= N such that p is not part of any triple (not just relatively prime triples). Input The input consists of a sequence of positive integers, one per line. Each integer in the input file will be less than or equal to 1,000,000. Input is terminated by endoffile Output For each integer N in the input file print two integers separated by a space. The first integer is the number of relatively prime triples (such that each component of the triple is <=N). The second number is the number of positive integers <=N that are not part of any triple whose components are all <=N. There should be one output line for each input line. Sample Input 10 25 100 Sample Output 1 4 4 9 16 27
Byte Me! _course
20170919Description You are a dealer at The One, the first allbinary casino in Las Vegas. What makes The One special is that its blackjack tables don't use cards; they use bytes (an 8bit sequence representing a number from 0 to 255) and nibbles (a 4bit sequence representing a number from 0 to 15). All day long, you play the house's hand against individual opponents. Of course, the casino owners know their statistics, and they have devised a strategy for you that gives gamblers just less than even odds. Here are the rules of binary blackjack: The goal of the game is to be the player closest to 510 points without going over. Each player is dealt two bytes, one face up and one face down. The players then have the opportunity to take more bytes (by saying, "Byte Me!") or more nibbles (by saying, "Nibble Me!") until he reaches his limit of 4 hits or has more than 510 points showing. All hits are played face up. If a player goes over 510, he immediately busts and loses the hand. The dealer hits last. The dealer wins any ties (this includes a tie where everyone busts). The rules for the dealer are (in order of precedence, where lower numbered rules override higher numbered ones): Never hit when it is certain that you've won by simply looking at your hand and what is showing of other people's hands. If your total is strictly less than 382 take a byte hit. If your total is less than or equal to 500 take a nibble hit. Take no hits Input Input to this problem will consist of a (nonempty) series of up to 100 data sets. Each data set will be formatted according to the following description, and there will be no blank lines separating data sets. A single data set has 6 components: Start line : A single line, "START N", where N is the number of players playing this hand (not including the dealer). There will never be more than 10 nondealer players, and the dealer never plays by himself. Dealer Line : A single line containing 2 binary strings of exactly eight digits separated by exactly one space. These two strings represent the two cards in the dealer's hand. Player Line : A single line containing N 8digit binary strings, each separated from the others by a single space. These represent the faceup cards of all of the nondealer players. Byte Line : A single line containing 4 8digit binary strings, each separated from the others by a single space. These represent the next 4 bytes in the byte deck, in the order they will be drawn. Nibble Line : A single line containing 4 4digit binary strings, each separated from the others by a single space. These represent the next 4 nibbles in the nibble deck, in the order they will be drawn. End line : A single line, "END". Following the final data set will be a single line, "ENDOFINPUT". Here are some other useful facts: Oddly enough, each nondealer player is always dealt a facedown card 11111111, value 255, but the dealer has no knowledge of this. Players other than the dealer never hit (they aren't too bright). Output Calculate the actions taken by the dealer and how the dealer fares with the resulting hand. For each data set, there will be exactly one output set, consisting of the following components: Hand Line : A single line, "HAND N", where N is the number of players playing this hand (not including the dealer). Dealer Hit List : A single line will be printed for each hit the dealer takes on his turn. For a byte hit, print a line "Byte me!", and for a nibble hit print, "Nibble me!" Outcome Line : A single line containing "Win!" if the dealer wins, "Bust!" if the dealer loses by busting, and "Lose!" if the dealer loses without busting. Sample Input START 1 11111111 11111111 00000001 10101010 01010101 11110000 00001111 1010 0101 1100 0011 END START 1 10111110 10111111 11111110 00010010 10101010 01010101 11110000 0001 1010 1100 0011 END START 8 11111111 00001000 00000000 00000001 00000010 00000011 00000100 00000101 00000110 00000111 00010010 10101010 01010101 11110000 0001 1010 1100 0011 END ENDOFINPUT Sample Output HAND 1 Win! HAND 1 Byte me! Nibble me! Nibble me! Nibble me! Lose! HAND 8 Win!
Byte Me! C语言的解法_course
20190927Description You are a dealer at The One, the first allbinary casino in Las Vegas. What makes The One special is that its blackjack tables don't use cards; they use bytes (an 8bit sequence representing a number from 0 to 255) and nibbles (a 4bit sequence representing a number from 0 to 15). All day long, you play the house's hand against individual opponents. Of course, the casino owners know their statistics, and they have devised a strategy for you that gives gamblers just less than even odds. Here are the rules of binary blackjack: The goal of the game is to be the player closest to 510 points without going over. Each player is dealt two bytes, one face up and one face down. The players then have the opportunity to take more bytes (by saying, "Byte Me!") or more nibbles (by saying, "Nibble Me!") until he reaches his limit of 4 hits or has more than 510 points showing. All hits are played face up. If a player goes over 510, he immediately busts and loses the hand. The dealer hits last. The dealer wins any ties (this includes a tie where everyone busts). The rules for the dealer are (in order of precedence, where lower numbered rules override higher numbered ones): Never hit when it is certain that you've won by simply looking at your hand and what is showing of other people's hands. If your total is strictly less than 382 take a byte hit. If your total is less than or equal to 500 take a nibble hit. Take no hits Input Input to this problem will consist of a (nonempty) series of up to 100 data sets. Each data set will be formatted according to the following description, and there will be no blank lines separating data sets. A single data set has 6 components: Start line : A single line, "START N", where N is the number of players playing this hand (not including the dealer). There will never be more than 10 nondealer players, and the dealer never plays by himself. Dealer Line : A single line containing 2 binary strings of exactly eight digits separated by exactly one space. These two strings represent the two cards in the dealer's hand. Player Line : A single line containing N 8digit binary strings, each separated from the others by a single space. These represent the faceup cards of all of the nondealer players. Byte Line : A single line containing 4 8digit binary strings, each separated from the others by a single space. These represent the next 4 bytes in the byte deck, in the order they will be drawn. Nibble Line : A single line containing 4 4digit binary strings, each separated from the others by a single space. These represent the next 4 nibbles in the nibble deck, in the order they will be drawn. End line : A single line, "END". Following the final data set will be a single line, "ENDOFINPUT". Here are some other useful facts: Oddly enough, each nondealer player is always dealt a facedown card 11111111, value 255, but the dealer has no knowledge of this. Players other than the dealer never hit (they aren't too bright). Output Calculate the actions taken by the dealer and how the dealer fares with the resulting hand. For each data set, there will be exactly one output set, consisting of the following components: Hand Line : A single line, "HAND N", where N is the number of players playing this hand (not including the dealer). Dealer Hit List : A single line will be printed for each hit the dealer takes on his turn. For a byte hit, print a line "Byte me!", and for a nibble hit print, "Nibble me!" Outcome Line : A single line containing "Win!" if the dealer wins, "Bust!" if the dealer loses by busting, and "Lose!" if the dealer loses without busting. Sample Input START 1 11111111 11111111 00000001 10101010 01010101 11110000 00001111 1010 0101 1100 0011 END START 1 10111110 10111111 11111110 00010010 10101010 01010101 11110000 0001 1010 1100 0011 END START 8 11111111 00001000 00000000 00000001 00000010 00000011 00000100 00000101 00000110 00000111 00010010 10101010 01010101 11110000 0001 1010 1100 0011 END ENDOFINPUT Sample Output HAND 1 Win! HAND 1 Byte me! Nibble me! Nibble me! Nibble me! Lose! HAND 8 Win!
Rout 66 _course
20170820Problem Description While the Romans may have had a fancy number system, the Visigoths (led by Alareiks, known now as Alaric I) managed to take Rome on August 24, 410. This was the first time that Rome had been taken by foreign troops in eight hundred years. You will simulate a considerably less bloody (and less realistic) rout of soldiers by a potentially overwhelming force. Consider a group of invaders of strength I, and an opposing force of strength J, with distance D between them and a defensive stronghold of strength S. The Routing Force F of the invaders can be calculated as their strength times the distance: F = ID and the Blocking Force B of the defenders can be calculated as their strength times the square of their defenses: B = JS2 If F is less than or equal to B, the invaders' rout fails, and they are driven off. If F is greater than B, the rout is successful, all defenders of the stronghold are driven off, and the invaders can continue. However, their strength is reduced by removing a fraction equal to the ratio of the defenders' Blocking Force to their Routing Force for that attack. The resulting number should be rounded up to the nearest integer, to ensure that a successful rout leaves at least one soldier: Inew = ?I(1  B/F)? If the invaders make it through a stronghold, its location is considered the starting point for calculations regarding the next group of defenders, and so on, until either the invading force makes it all the way through the defenders or is completely routed. Your goal is to determine whether or not a given invading force can make it through a particular gauntlet of defenders. For the purposes of simplification, all defending strongholds in this simulation are considered to be in a straight line from the starting position of the invaders, and must be encountered in order from nearest to furthest away. No strongholds will be in the same location in a given set of data. Input Input to this problem will begin with a line containing a single integer N (1 ≤ N ≤ 100) indicating the number of data sets. Each data set consists of the following components: A line containing a single integer E (1 ≤ E ≤ 20) indicating the number of defensive strongholds in the data set; A series of E lines, each with three integers D, J, S (1 ≤ D, J ≤ 10000; 1 ≤ S ≤ 50) separated by spaces representing the strongholds. D is the distance of the stronghold from the invaders' starting position; remember that all strongholds are considered to be in a straight line from the invaders' starting position, and must be encountered in order from nearest to furthest away. J and S represent the strength of the defenders and the stronghold, respectively, as in the above equation; and A line containing a single integer I (1 ≤ I ≤ 30000) representing the strength of the invading force. Output For each data set, print "ROUT!" if the invaders make it through all of the strongholds, or "RETREAT!" if the invaders cannot make it through all of the strongholds. Sample Input 2 1 10 10 5 100 2 75 100 5 10 10 5 50 Sample Output ROUT! RETREAT!
HoloLens2开发入门教程
20200501本课程为HoloLens2开发入门教程，讲解部署开发环境，安装VS2019，Unity版本，Windows SDK，创建Unity项目，讲解如何使用MRTK，编辑器模拟手势交互，打包VS工程并编译部署应用到HoloLens上等。
 13.17MB
狂神docker笔记（超详细）.rar
20200614狂神docker教学视频笔记，截图标注很全（本人增加了很多额外的标注），帮助更好理解，敲了很久，实在不易。上传来帮助大家学习，一方面攒点积分！
 9.75MB
simsun.ttf、simheittf.ttf 字体库文件
20181219Linux CentOS 7 安装 字体库文件（simsun.ttf、simheittf.ttf）
 29.82MB
改进SEIR模型的matlab代码.zip
20200512本资源包括，基于SEIR模型的新冠肺炎疫情分析matlab代码和最新的国内疫情数据集。代码已详细备注，具体模型详解见本人博客，大家可以下载交流，略有瑕疵，欢迎指正。
 536KB
移相法5倍细分电路
20180608可用于模拟正余弦信号的，使用运放对信号进行高倍细，已经搭建好仿真电路，可以直接运行仿真测试。
人脸识别项目实战特训营
20200706人脸识别的技术及业务已经广泛应用于各行各业，如住宅安全管理、电子身份证护照、公安、司法和刑侦、自助服务、信息安全等。本训练营连续4天的时间，通过Opencv来采集需要识别的人脸数据库，并建立相关的ID信息标签，利用开源数据集，通过MTCNN模型、FaceNet模型的学习，编写人脸识别程序，并实现整个项目。
 学院 Kubernetes云原生存储实战
 下载 小程序源码加后台.zip
 下载 BA8206 用于新型多功能电话的音调振铃器
 下载 axios.min.js
 博客 树遍历及其应用场景（前序，中序，后序）
 学院 Python专题精讲 从入门到实战
 博客 uniapp实现加载图片失败显示占位图
 下载 centos7重置密码.docx
 下载 Windows使用VSCode远程Linux（ConteOS）开发调试C++(超详细) .docx
 下载 DevExpress WPF PDF帮助文档
 学院 用户故事地图详解
 学院 2020年最新 Kubernetes最新版集群高可用安装
 博客 关于Maven构造多模块工程
 下载 轻松学会在Linux中添加和删除程序
 学院 深度学习语音识别实战
 博客 【Git】远程基础命令
 下载 实时变音处理芯片SD771D的原理与应用
 下载 基于ADS8364的数据采集系统设计
 博客 HDU——1856 More is better（并查集模板题）
 下载 基于DSP和CPLD技术的多路ADC系统的设计与实现
 下载 LauncherViewPager.zip
 下载 CISC和RISC微控制器
 博客 leetcode第三题无重复字符的最长子串
 下载 用SPMC75F2313A实现LIN结点
 下载 通信/信息工程大二课程设计——温度指示报警电路设计.rar
 博客 对比Java中的abstract与C++中的virtual
 博客 164Vue工程化2挂载路由导航守卫+退出清除token
 博客 初识消息队列和ActiveMQ简介
 下载 基于低压电力线载波技术的病房呼叫系统
 下载 Linux下常用SVN命令