classical webcast

smallest element For (j = i + 1; j if (A[j] Nminindex = j; Swap (A[i], a[nminindex]); //Put this element at the beginning of the unordered area } } Here, we would like to draw special attention to the implementation of the Swap (), it is recommended to use:[CPP]View Plaincopy inline void Swap (int a, int b) { int c = A; A = b; b = C; } Test interview without intermediate data exchange two numbers, a lot of people gave[CPP]View Plaincopy

First, Quicksort1 intPartitionintS[],intLintR)2 {3 inti = l, j =R;4 intx =S[l];5 while(I j)6 {7 while(S[j] >= Xi j)8j--;9 if(I j)Ten { OneS[i] =S[j]; Ai++; - } - while(S[i] j) thei++; - if(I j) - { -S[J] =S[i]; +j--; - } + } AS[i] =x; at returni; - } - voidQuicksortintS[],intLintR) - { - if(L R) - { in intpos =partition (S, L, R); -Quicksort (S, L, pos-1); toQuicksort (s, POS +1, R); +

Title: An odd number of 0-7 can be composed.Algorithm idea:This problem is actually a permutation of the problem, set the number of SUN=A1A2A3A4A5A6A7A8,A1-A8 to represent this number of a bit of the value,When the last digit of a number is odd, it must be an odd number, no matter what number is in front of it. If the last digit is an even number,The number must be even.A1-a8 can take 0-7 of this eight number, the first number is not 0.From this number to one count to the number of 8 digits to s

The Fibonacci sequence is a common-sense knowledge, it refers to such a sequence, its first item is 1, the second item is 1, each of the following is its front two items, such as: 1,1,2,3,5,8,13,21,34,55,89,144,233 ...Note: Due to the low efficiency through recursion, the system overhead, high space complexity, it is not considered.1 /*Fibonacci sequence: The first and second items are 1, and the following items are the sum of the preceding two items*/2 /*Write a function, enter an integer n to

satisfy the condition with the position of the specified sort Algorithm analysis Each trip selects the largest or smallest element in the data element to be sorted, placing it in the final order until all the data elements to be sorted are finished. The total average time complexity of the bubble sort O (n), so the speed is relatively fast! Specific implementation the invert Sort " Basic ideas Reversal sorting is the reordering of the contents of the

First question: recursion1. Give a dict or JSON value greater than 53 and convert the value to str for int　　Mydict1 = {"A": {"a": []}, "B": {"B": 1}}def Foo (mydict): for _,v in Mydict.items (): if Isinstance (V, dict): Foo (v) elif isinstance (v,int) and Ord (v) >: v = str (v) elif isinstance (v,list): for I In V: foo (i) elif isinstance (v,tuple): For i in V: foo (i)　　Second questi

/************************************************************************//* after eight questions *//************************************************************************/#include Classical backtracking algorithm--eight problems

prefixed with [A, AB, ABC, ABCD, abcda], suffix [Bcdab, Cdab, DAB, AB, B], the total element is "AB", the length is 2; -"ABCDABD" is prefixed with [A, AB, ABC, ABCD, ABCDA, Abcdab], suffix [bcdabd, cdabd, Dabd, ABD, BD, D], with a total element length of 0. From the above theory we can get the following prefix to the next array to solve the algorithm.void Setprefix (const char *pattern, int prefix[]){int Len=charlen (pattern);//pattern string length.prefix[0]=0;for (int i=1; i{int k=pr

-problems have such a nature. If we combine the optimality of sub-problems with the greedy choice we make, we can get an optimal solution of the original problem.The greedy choice nature and the optimal substructure property are the key features of the greedy algorithm.Greedy Choice property: A global optimal solution can be achieved by local optimal (greedy) selection. This is where the greedy algorithm differs from the dynamic programming. In dynamic planning, each step has to make a choice, b

The tutorial introduces a very classical method of making frame. The entire tutorial has many textual explanations, but there are more steps to be done, plus a reference chart without each step. It's a little difficult to make. However, as long as the reference effect chart, and then clarify the author's thinking, production is very simple. Final effect 1, the background part of the production: a new 600* 500-pixel file, select the Gradi

will be:(2) Virtual function tableFirst to analyze the object of the derive class in our main function, obj, to see its memory layout, because there is no data member, its size is 4 bytes, only one vfptr, so the address of obj is vfptr address.For a C + + class, if it is to render polymorphic (the generic compiler will use this class and whether the virtual keyword exists in its base class to be polymorphic), then the class will have a virtual function table, Each instance (object) will have a

element.The following solution comments in detail, can well understand the fast selection algorithm, this can be used as a template to write down. Can AC be not wrong at an interview? It's not that easy, actually. The key to remembering is a deep understanding.classSolution {/*** Solution 0. Heap O (KLOGN) * Solution 1. Quick selection: O (n)*/ Public intFindkthlargest (int[] Nums,intk) {if(Nums.length = = 0 | | nums = =NULL)return0; intleft = 0, right = nums.length-1; while(true) {

System;Namespace Shellsorter{public class Shellsorter{public void Sort (int [] list){INT Inc;For (inc=1;incfor (; inc>0;inc/=3){for (int i=inc+1;i{int t=list[i-1];int j=i;while ((J>inc) (list[j-inc-1]>t)){LIST[J-1]=LIST[J-INC-1];J-=inc;}list[j-1]=t;}}}}public class MainClass{public static void Main (){Int[] Iarrary=new int[]{1,5,13,6,10,55,99,2,87,12,34,75,33,47};Shellsorter sh=new Shellsorter ();Sh. Sort (iarrary);for (int m=0;mConsole.Write ("{0}", Iarrary[m]);Console.WriteLine ();}}}

, plus the N/2-down adjustment of the previous build heap, and the complexity of each adjustment is O (logn). Two operation times added or O (N * logn). Therefore, the time complexity of heap sequencing is O (N * logn). STL also implements the related functions of the heap, and can refer to thefour heap heap of STL series. Note 1 As a data structure, it is best to use classes to encapsulate their data and methods so that they are easy to operate and understandable. In addition, in addition to he

used to evaluate the data itself with the correct category information using the ARI Ari indicator is similar to the method of calculating accuracy in the classification problem, while also taking into account the problem that the cluster cannot match the classification mark one by one② if the data being used for evaluation does not have a category, then we are accustomed to using contour coefficients to measure the quality of the clustering results. The contour factor also takes into account t

classes more equal. but .....Recall, though,that better data often beats better algorithms, and designing good features goes a long. And if you had a huge dataset, your choice of classification algorithm might not really matter so much in terms of Classi Fication performance (so choose your algorithm based on speed or ease of use instead).And if you really-accuracy, you should definitely try a bunch of different classifiers and select the best one by Cross-validation. Or, to take a lesson from

(): Image_size= 224Images=TF. Variable (Tf.random_normal ([Batch_size, Image_size, Image_size,3], Dtype=Tf.float32, StdDev=1e-1)) Keep_prob=Tf.placeholder (tf.float32) predictions, Softmax, FC8, p=inference_op (images, keep_prob) init=tf.global_variables_initializer () config=TF. Configproto () Config.gpu_options.allocator_type='BFC'Sess= TF. Session (config=config) sess.run (init) time_tensorflow_run (sess, predictions, {keep_prob:1.0},"Forward") O

}----------------------------------------Fifth cycle:Compare 1 and 2,1 for the first timeSecond comparison 2 and 4,2Third comparison 4 and 5,4Comparison of 5 and 6,5 for the fourth timeComparison of 6 and 7,6 for the fifth timeThird Loop completion result: {1,2,4,5,6,7}Believe that after reading the above demonstration process, you have a full understanding of the bubbling sequencing process and principles, but careful friends should be found in fact in the fourth cycle has been the final result

The algorithm of this shuffle way:1: Initialize an array of length 54, and 54 cards.2: Starting from I=1 to 54, each time from the remaining pile of cards randomly draw a card placed in the array of I subscript.So we can do it with an array or two arrays.Sort of like a classic choice.#include The implementation of the classical shuffling algorithm C language

Bayesian MODEL,NBC). naive Bayesian model originates from classical mathematics theory, has a solid mathematical foundation, and stable classification efficiency. At the same time, the NBC model required a very small number of expected parameters, less sensitive to missing data, and simpler algorithms. In theory, the NBC model has the smallest error rate compared to other classification methods. But this is not always the case, because if the NBC mo