#Buildlist

[rabbykhan04-blog]

Super method to build your email list for free Enter your email adress and follow the instruction

[tigerkirby215]

Build list should be fully updated

I have finally listed all my builds (minus Lux potentially, depending on when this is posted relative to my personal schedule) on https://tigerkirby215.tumblr.com/buildlist

Please search there (CTRL + F) for any builds to see if I’ve made them! If any builds that I have made aren’t on that list I apologize in advance for the error.

[adscheiffele]

The Year is Still Young Start a Home Business

The Year is Still Young Start a Home Business

The Year is Still Young Start a Home Business Have you been thinking about a home biz but think its too much of a risk It costs too much It will take too much of my time It would be too much overhead It would take space for storage It would cost too much to ship Well all the items I listed above are all NO for this home business

            CLICK HERE

via Blogger https://ift.tt/2XKe2Jh

[root]

implement a playlist shuffle algorithm

# Enter your code here. Read input from STDIN. Print output to STDOUT # given a positive integer n, and a positive seed k, returned a list data structure (can be any type) made up of 1..n and shuffled using the k seed ''' original n=5: 1 2 3 4 5 seed k=3 shuffled : 3 1 5 2 4 inputs: int n, int k output: "list" ''' # original n=5: /1, /2, /3, /4, /5 # seed k=2: 2, 4, 1, 5, 3 def shufflePlaylist(n, k): head = Node(1) # tail = Node(n) myCircularLL = CircularLL() result = [] # stop when there is none left in the list, head = tail current = myCircularLL.head counter = 0 nodesRemoved = 0 while nodesRemoved <= n: counter += 1 # 1, 2 if counter % k == 0: # result.append(current.value) current.prev.next = current.next current.next.prev = current.prev current = current.next nodesRemoved += 1 #if using singly linked list we would also need to keep track of the previous node (current) current = current.next # result.append(myCircularLL.head) return result class Node: def __init__(self, data, prev, next): self.data = data self.prev = prev self.next = next class CircularLL: head = None tail = None def append(self, data): new_node = Node(data, None, None) if self.head is None: self.head = self.tail = new_node else: new_node.prev = self.tail new_node.next = None self.tail.next = new_node self.tail = new_node def buildList(self, n): # specific method for constructing this particular list l = 1 while l <= n: l += 1 self.append(l)

Time complexity: O(n*k)

[kotlintutorial]

📚 readln, buildList, typeOf, x.seconds & y.rotateLeft – those are just some of the new functions you can use in Kotlin 1.6+! Join @sebi_io in our latest video to find out more about them, and how you can benefit from using them in your own projects! 👀 https://t.co/4yRVIAZqtr

[tomssharepointdiscoveries]

Great explanation of the term ‘First Class Functions’ and closures

function sayHello(name) {  var text = 'Hello ' + name;  var say = function() { console.log(text); }  say(); } sayHello('Joe');

This means the language supports passing functions as arguments to other functions, returning them as the values from other functions, and assigning them to variables or storing them in data structures.

Closures:

A closure is one way of supporting first-class functions; it is an expression that can reference variables within its scope (when it was first declared), be assigned to a variable, be passed as an argument to a function, or be returned as a function result.

function sayHello2(name) {  var text = 'Hello ' + name; // Local variable  var say = function() { console.log(text); }  return say; } var say2 = sayHello2('Bob'); say2(); // logs "Hello Bob"

Most JavaScript programmers will understand how a reference to a function is returned to a variable (say2) in the above code. If you don't, then you need to look at that before you can learn closures. A programmer using C would think of the function as returning a pointer to a function, and that the variables say and say2 were each a pointer to a function.

There is a critical difference between a C pointer to a function and a JavaScript reference to a function. In JavaScript, you can think of a function reference variable as having both a pointer to a function as well as a hidden pointer to a closure.

The above code has a closure because the anonymous function function() { console.log(text); } is declared inside another function, sayHello2() in this example. In JavaScript, if you use the function keyword inside another function, you are creating a closure.

In C and most other common languages, after a function returns, all the local variables are no longer accessible because the stack-frame is destroyed.

In JavaScript, if you declare a function within another function, then the local variables of the outer function can remain accessible after returning from it. This is demonstrated above, because we call the function say2() after we have returned from sayHello2(). Notice that the code that we call references the variable text, which was a local variable of the function sayHello2().

Looking at the output of say2.toString(), We can see that the code refers to the variable text. The anonymous function can reference text which holds the value 'Hello Bob' because the local variables of sayHello2() have been secretly kept alive in a closure.

The genius is that in JavaScript a function reference also has a secret reference to the closure it was created in — similar to how delegates are a method pointer plus a secret reference to an object.

EXAMPLE 3

This example shows that the local variables are not copied — they are kept by reference. It is as though the stack-frame stays alive in memory even after the outer function exists!

function say667() {  // Local variable that ends up within closure  var num = 42;  var say = function() { console.log(num); }  num++;  return say; } var sayNumber = say667(); sayNumber(); // logs 43

Example 4

All three global functions have a common reference to the same closure because they are all declared within a single call to setupSomeGlobals().

var gLogNumber, gIncreaseNumber, gSetNumber; function setupSomeGlobals() {  // Local variable that ends up within closure  var num = 42;  // Store some references to functions as global variables  gLogNumber = function() { console.log(num); }  gIncreaseNumber = function() { num++; }  gSetNumber = function(x) { num = x; } } setupSomeGlobals(); gIncreaseNumber(); gLogNumber(); // 43 gSetNumber(5); gLogNumber(); // 5 var oldLog = gLogNumber; setupSomeGlobals(); gLogNumber(); // 42 oldLog() // 5

The three functions have shared access to the same closure — the local variables of setupSomeGlobals() when the three functions were defined.

Note that in the above example, if you call setupSomeGlobals() again, then a new closure (stack-frame!) is created. The old gLogNumber, gIncreaseNumber, gSetNumber variables are overwritten with new functions that have the new closure. (In JavaScript, whenever you declare a function inside another function, the inside function(s) is/are recreated again each time the outside function is called.)

Example 5

This example shows that the closure contains any local variables that were declared inside the outer function before it exited. Note that the variable alice is actually declared after the anonymous function. The anonymous function is declared first, and when that function is called it can access the alice variable because alice is in the same scope (JavaScript does variable hoisting). Also sayAlice()() just directly calls the function reference returned from sayAlice() — it is exactly the same as what was done previously but without the temporary variable.

function sayAlice() {    var say = function() { console.log(alice); }    // Local variable that ends up within closure    var alice = 'Hello Alice';    return say; } sayAlice()();// logs "Hello Alice"

Tricky: also note that the say variable is also inside the closure, and could be accessed by any other function that might be declared within sayAlice(), or it could be accessed recursively within the inside function.

Example 6

This one is a real gotcha for many people, so you need to understand it. Be very careful if you are defining a function within a loop: the local variables from the closure may not act as you might first think.

You need to understand the "variable hoisting" feature in Javascript in order to understand this example.

function buildList(list) {    var result = [];    for (var i = 0; i < list.length; i++) {        var item = 'item' + i;        result.push( function() {console.log(item + ' ' + list[i])} );    }    return result; } function testList() {    var fnlist = buildList([1,2,3]);    // Using j only to help prevent confusion -- could use i.    for (var j = 0; j < fnlist.length; j++) {        fnlist[j]();    } } testList() //logs "item2 undefined" 3 times

The line result.push( function() {console.log(item + ' ' + list[i])} adds a reference to an anonymous function three times to the result array. If you are not so familiar with anonymous functions think of it like:

pointer = function() {console.log(item + ' ' + list[i])}; result.push(pointer);

Note that when you run the example, "item2 undefined" is logged three times! This is because just like previous examples, there is only one closure for the local variables for buildList (which are result, i and item). When the anonymous functions are called on the line fnlist[j](); they all use the same single closure, and they use the current value for i and item within that one closure (where i has a value of 3 because the loop had completed, and item has a value of 'item2'). Note we are indexing from 0 hence item has a value of item2. And the i++ will increment i to the value 3.

It may be helpful to see what happens when a block-level declaration of the variable item is used (via the let keyword) instead of a function-scoped variable declaration via the var keyword. If that change is made, then each anonymous function in the array result has its own closure; when the example is run the output is as follows:

item0 undefined item1 undefined item2 undefined

If the variable i is also defined using let instead of var, then the output is:

item0 1 item1 2 item2 3

Example 7

In this final example, each call to the main function creates a separate closure.

function newClosure(someNum, someRef) {    // Local variables that end up within closure    var num = someNum;    var anArray = [1,2,3];    var ref = someRef;    return function(x) {        num += x;        anArray.push(num);        console.log('num: ' + num +            '; anArray: ' + anArray.toString() +            '; ref.someVar: ' + ref.someVar + ';');      } } obj = {someVar: 4}; fn1 = newClosure(4, obj); fn2 = newClosure(5, obj); fn1(1); // num: 5; anArray: 1,2,3,5; ref.someVar: 4; fn2(1); // num: 6; anArray: 1,2,3,6; ref.someVar: 4; obj.someVar++; fn1(2); // num: 7; anArray: 1,2,3,5,7; ref.someVar: 5; fn2(2); // num: 8; anArray: 1,2,3,6,8; ref.someVar: 5;

Final points:

Whenever you use function inside another function, a closure is used.

Whenever you use eval() inside a function, a closure is used. The text you eval can reference local variables of the function, and within eval you can even create new local variables by using eval('var foo = …')

When you use new Function(…) (the Function constructor) inside a function, it does not create a closure. (The new function cannot reference the local variables of the outer function.)

A closure in JavaScript is like keeping a copy of all the local variables, just as they were when a function exited.

It is probably best to think that a closure is always created just an entry to a function, and the local variables are added to that closure.

A new set of local variables is kept every time a function with a closure is called (given that the function contains a function declaration inside it, and a reference to that inside function is either returned or an external reference is kept for it in some way).

Two functions might look like they have the same source text, but have completely different behavior because of their 'hidden' closure. I don't think JavaScript code can actually find out if a function reference has a closure or not.

If you are trying to do any dynamic source code modifications (for example: myFunction = Function(myFunction.toString().replace(/Hello/,'Hola'));), it won't work if myFunction is a closure (of course, you would never even think of doing source code string substitution at runtime, but...).

It is possible to get function declarations within function declarations within functions &mdash, and you can get closures at more than one level.

I think normally a closure is a term for both the function along with the variables that are captured. Note that I do not use that definition in this article!

I suspect that closures in JavaScript differ from those normally found in functional languages.

[mbaljeetsingh]

Understanding Closures

Advertise here with BSA

If you already know the main concept, the closures are not hard to understand. But it is difficult to understand by reading only theoretical explanations. Our article is for programmers with any experience. For easier understanding, the examples are in javascript.

Closures Explanation

When a function (foo) declares other functions (bar and baz), the family of local variables created in foo is not destroyed when the function exits. The variables merely become invisible to the outside world. foo can therefore cunningly return the unctions bar and baz, and they can continue to read, write and communicate with each other through this closed-off family of variables (“the closure”) that nobody else can meddle with, not even someone who calls foo again in future.

A closure is one way of supporting first-class functions; it is an expression that can reference variables within its scope (when it was first declared), be assigned to a variable, be passed as an argument to a function, or be returned as a function result.

Closure example 1

The following code returns a reference to a function:

function sayHelloWorld(name) { var text = 'Hello World ' + name; // Local variable var sayClosure = function() { console.log(text); } return sayClosure; } var sayMyClosure = sayHelloWorld('one'); sayMyClosure(); // writes "Hello World one"

Most javascript developers understand how a reference to a function is returned to a variable (sayMyClosure) in the above code. If you don’t understand, then you need to look at that before you can learn closures. A programmer using C would think of the function as returning a pointer to a function, and that the variables sayClosure and sayMyClosure were each a pointer to a function.

There is a critical difference between a C pointer to a function and a JavaScript reference to a function. In JavaScript, you can think of a function reference variable as having both a pointer to a function as well as a hidden pointer to a closure.

The above code has a closure because the anonymous function function() { console.log(text); } is declared inside another function, sayHelloWorld() in this example. In JavaScript, if you use the function keyword inside another function, you are creating a closure.

In C and most other common languages, after a function returns, all the local variables are no longer accessible because the stack-frame is destroyed.

In JavaScript, if you declare a function within another function, then the local variables of the outer function can remain accessible after returning from it. This is demonstrated above, because we call the function sayMyClosure() after we have returned from sayHelloWorld(). Notice that the code that we call references the variable text, which was a local variable of the function sayHelloWorld().

function() { console.log(text); } // Output of say2.toString();

Looking at the output of sayMyClosure.toString(), we can see that the code refers to the variable text. The anonymous function can reference text which holds the value 'Hello World one' because the local variables of sayHelloWorld() have been secretly kept alive in a closure.

The genius is that in JavaScript a function reference also has a secret reference to the closure it was created in – similar to how delegates are a method pointer plus a secret reference to an object.

More examples

Maybe closures seem hard to understand when you read about them, but when you see some examples it becomes clear how they work. Usually I recommend working through the examples carefully until you understand how they work. If you start using closures without fully understanding how they work, you would soon create some very weird bugs!

Example 2

This example shows that the local variables are not copied – they are kept by reference. It is as though the stack-frame stays alive in memory even after the outer function exits!

function someFunction() { // Local variable that ends up within closure var value = 100; var callbackFunction = function() { console.log(value); } value++; return callbackFunction(); } someFunction(); // logs 101

Example 3

All three global functions have a common reference to the same closure because they are all declared within a single call to setupSomeGlobals().

var gLogNumber, gIncreaseNumber, gSetNumber; function setupSomeGlobals() { // Local variable that ends up within closure var _num = 50; // Store some references to functions as global variables gLogNumber = function() { console.log(_num); }; gIncreaseNumber = function() { _num++; }; gSetNumber = function(x) { _num = x; }; } setupSomeGlobals(); gIncreaseNumber(); gLogNumber(); // 51 gSetNumber(10); gLogNumber(); // 10 var oldLog = gLogNumber; setupSomeGlobals(); gLogNumber(); // 50 oldLog() // 10

The three functions have shared access to the same closure – the local variables of setupSomeGlobals() when the three functions were defined.

Note that in the above example, if you call setupSomeGlobals() again, then a new closure (stack-frame!) is created. The old gLogNumber, gIncreaseNumber, gSetNumber variables are overwritten with new functions that have the new closure. (In JavaScript, whenever you declare a function inside another function, the inside function(s) is/are recreated again each time the outside function is called.)

Example 4

This example shows that the closure contains any local variables that were declared inside the outer function before it exited. Note that the variable alice is actually declared after the anonymous function. The anonymous function is declared first and when that function is called it can access the alice variable because alice is in the same scope (JavaScript does variable hoisting). Also sayAlice()() just directly calls the function reference returned from sayAlice() — it is exactly the same as what was done previously but without the temporary variable.

function closureTest4() { var closure = function() { console.log(_variable); }; // Local variable that ends up within closure var _variable = 'Initial Value'; return closure; } closureTest4()();// logs "Initial Value"

Tricky: note the closure variable is also inside the closure and could be accessed by any other function that might be declared within closureTest4(), or it could be accessed recursively within the inside function.

Example 5

This one is a real gotcha for many people, so you need to understand it. Be very careful if you are defining a function within a loop: the local variables from the closure may not act as you might first think.

You need to understand the “variable hoisting” feature in Javascript in order to understand this example.

function buildList(list) { var result = []; for (var i = 0; i < list.length; i++) { var item = 'item' + i; result.push( function() { console.log(item + ' ' + list[i]); } ); } return result; } function testList() { var fnlist = buildList([1,2,3,4]); // Using j only to help prevent confusion -- could use i. for (var j = 0; j < fnlist.length; j++) { fnlist[j](); } } testList(); //logs "item3 undefined" 4 times

The line result.push( function() {console.log(item + ' ' + list[i])} adds a reference to an anonymous function four times to the result array. If you are not so familiar with anonymous functions think of it like:

pointer = function() {console.log(item + ' ' + list[i])}; result.push(pointer);

Note that when you run the example, "item3 undefined" is logged four times! This is because just like previous examples, there is only one closure for the local variables for buildList (which are result, i, list and item). When the anonymous functions are called on the line fnlist[j](); they all use the same single closure, and they use the current value for i and item within that one closure (where i has a value of 4 because the loop had completed, and item has a value of 'item3'). Note we are indexing from 0 hence item has a value of item3. And the i++ will increment i to the value 4.

It may be helpful to see what happens when a block-level declaration of the variable item is used (via the let keyword) instead of a function-scoped variable declaration via the var keyword. If that change is made, then each anonymous function in the array result has its own closure; when the example is run the output is as follows:

item0 undefined item1 undefined item2 undefined item3 undefined

If the variable i is also defined using let instead of var, then the output is:

item0 1 item1 2 item2 3 item3 4

Example 6

In this final example, each call to the main function creates a separate closure.

function newClosure(someNum, someRef) { // Local variables that end up within closure var num = someNum; var anArray = [1,2,3]; var ref = someRef; return function(x) { num += x; anArray.push(num); console.log('num: ' + num + '; anArray: ' + anArray.toString() + '; ref.someVar: ' + ref.someVar + ';'); } } obj = {someVar: 4}; fn1 = newClosure(4, obj); fn2 = newClosure(5, obj); fn1(1); // num: 5; anArray: 1,2,3,5; ref.someVar: 4; fn2(1); // num: 6; anArray: 1,2,3,6; ref.someVar: 4; obj.someVar++; fn1(2); // num: 7; anArray: 1,2,3,5,7; ref.someVar: 5; fn2(2); // num: 8; anArray: 1,2,3,6,8; ref.someVar: 5;

Summary

If everything seems completely unclear, then the best thing to do is to play with the examples. Reading an explanation is much harder than understanding examples. My explanations of closures and stack-frames, etc. are not technically correct – they are gross simplifications intended to help to understand. Once the basic idea is grokked, you can pick up the details later.

Final points:

Whenever you use function inside another function, a closure is used.

Whenever you use eval() inside a function, a closure is used. The text you eval can reference local variables of the function, and within eval you can even create new local variables by using eval('var foo = …')

When you use new Function(…) (the Function constructor) inside a function, it does not create a closure. (The new function cannot reference the local variables of the outer function.)

A closure in JavaScript is like keeping a copy of all the local variables, just as they were when a function exited.

It is probably best to think that a closure is always created just an entry to a function, and the local variables are added to that closure.

A new set of local variables is kept every time a function with a closure is called (given that the function contains a function declaration inside it, and a reference to that inside function is either returned or an external reference is kept for it in some way).

Two functions might look like they have the same source text, but have completely different behavior because of their ‘hidden’ closure. I don’t think JavaScript code can actually find out if a function reference has a closure or not.

If you are trying to do any dynamic source code modifications (for example: myFunction = Function(myFunction.toString().replace(/Hello/,'Hola'));), it won’t work if myFunction is a closure (of course, you would never even think of doing source code string substitution at runtime, but…).

It is possible to get function declarations within function declarations within functions… and you can get closures at more than one level.

I think normally a closure is a term for both the function along with the variables that are captured. Note that I do not use that definition in this article!

I suspect that closures in JavaScript differ from those normally found in functional languages.

via https://ift.tt/2PBYCFk

[extramoney]

Build Your Business and Your List the Old Fasion Way..

Are you tired of your emails not  getting opened or worse, being accused of spamming?  You spend your hard earned money to get leads to try to build your business only to end up with your emails not being opened or ending up in a junk email account they set up to download your free offer.

Now you can bypass the email black hole  by building you list the old fashioned way using postcards. You'll also enjoy the Power of Residual Income flowing from your 100% turnkey direct mail campaign via their 3 tier affiliate program. 

Get more info at  betterway4u.com

[rabbykhan04-blog]

Super method to build your email list for free Enter your email adress and follow the instruction

[adscheiffele]

The Year is Still Young Start a Home Business

The Year is Still Young Start a Home Business

The Year is Still Young Start a Home Business Have you been thinking about a home biz but think its too much of a risk It costs too much It will take too much of my time It would be too much overhead It would take space for storage It would cost too much to ship Well all the items I listed above are all NO for this home business

            CLICK HERE

via Blogger https://ift.tt/2XKe2Jh

[rabbykhan04-blog]

Super method to build your email list for free Enter your email adress and follow the instruction

[rabbykhan04-blog]

Super method to build your email list for free Enter your email adress and follow the instruction

[rabbykhan04-blog]

Super method to build your email list for free Enter your email adress and follow the instruction

[rabbykhan04-blog]

Super method to build your email list for free Enter your email adress and follow the instruction

[rabbykhan04-blog]

Super method to build your email list for free Enter your email adress and follow the instruction