source : kodlogs.com

## Which of the following is a valid c++ array definition?

An array is an assortment of components of a similar sort set in contiguous memory areas that can be independently referenced by utilizing a list to a one of a kind identifier. Five estimations of type int can be pronounced as an array without announcing five unique factors (each with its own identifier).The correct answer is: int scores [10]; An array is an assortment of at least one estimations of a similar kind. Each worth is called a component of the array. The components of the array share a similar variable name, however, every component has its own extraordinary file number (otherwise called a subscript).

Tutorials – C++ Programming Quiz – Structures – Cprogramming.com – If you haven't already done so, be sure to read through Cprogramming.com's tutorial on Structures. Otherwise, best of luck with the quiz! 1. Which of the following accesses a variable in structure b?18. Which of the following is a valid function call (assuming the function exists)? 52. In what order do the two command line variables appear in the definition of main? A. Count then argument array B. Argument array then count C. They don't appear in the definition of main D. There is only one…B. numeric. C. float. D. All of the above. Answer: Option D. Which is the subset of SQL commands used to manipulate Oracle Database structures, including tables? A. Data Definition Language(DDL).

Question Bank – CPR | C (Programming Language) | Array Data… – 9) Which of the following statements is not valid C++ code? 34) Look at the following array definition. int numberArray[9][11]; Write a statement that assigns 145 to the first column of the first row of this array.Questions about arrays and classes in the java.lang package. 1. Which of the following statements are valid array declaration? 2. Consider the following code int number[] = new int[5]; After execution of this statement, which of the following are true?The following diagram illustrate the relationship between computers' memory address and content; and variable's name, type and value used by the Pointers must be declared before they can be used, just like a normal variable. The syntax of declaring a pointer is to place a * in front of the name.

Which of the following is a valid SQL type – By the name of the array followed by a dot and then the index value. C. Regression testing involves repeating previously run tests to ensure that known failures of prior versions do not appear in new versions of the software.Which of the following is a valid C++ array definition? The correct answer is: the row subscript of the element, the column subscript of the element. When writing functions that accept multi-dimensional arrays as arguments, _ must be explicitly stated in the parameter list.C – Arrays – Arrays a kind of data structure that can store a fixed-size sequential collection of To declare an array in C, a programmer specifies the type of the elements and the number of elements The arraySize must be an integer constant greater than zero and type can be any valid C data type.

**Evaluation of Prefix and Postfix expressions using stack** – In our previous lesson, we saw what

prefix and postfix expressions are but we did not discuss how we can

evaluate these expressions.

In this lesson we'll see how we can

evaluate prefix and postfix expressions. Algorithms to evaluate prefix and

postfix expressions are similar but I'm going to talk about postfix

evaluation first because its easier to understand and

implement and then I'll talk about evaluation of

prefix. Okay so let's get started. I have written an expression in infix form

here and I first want to convert this to postfix form. As we know in infix form operator is

written in between operands and we want to convert to postfix in

which operator is written after operands. We have already seen how we can do

this in our previous lesson. We need to go step by step just the way we would go in evaluation of infix. We need to go in

order of precedence and in each step we need to identify operands of an operator and we need to

bring the operator in front of the operands. What we can

actually do is we can first resolve operator precedence and put

parenthesis at appropriate places. In this expression

we will first do this multiplication this first

multiplication then we'll do this second multiplication then we will perform this addition and

finally the subtraction. Okay now we will go one

operator at a time, operands for this multiplication

operator are 'A' and 'B'. So this A*B will become AB*. Now next we would need to look at this

multiplication this will transform to cd* and now we can do the change for this addition the two operands are these two expressions in postfix, so I'm placing the plus

operator after these two expressions. Finally for this last operator the operands are this complex expression

and this variable 'e'. So this is how we will look like after the transformation. Finally when we

are done with all the operators we can get rid of all the paranthesis. They're not needed in postfix expression. This is how you can do the conversion

manualy. We will discuss efficient ways of doing this programitically in later lessons. We will discuss algorithms to convert infix to prefix or postfix in later lessons. In this lesson we're

only going to look at algorithms to evaluate prefix and

postfix expressions. Okay so we have this postfix

expression here and we want to evaluate this expression,

let's say for these values of variables a,b,c,d and e. So we have this expression in

terms of values to evaluate. I'll first quickly tell you how you can

evaluate a postfix expression manually. What you need to do is you need to scan

the expression from left to right and find the first occurrence of an

operator like here, multiplication is the first operator.

In postfix expression operands of an operator will always

lie to its left. For the first operator, the preceding two

entities will always be operands. You need to look for the first

occurrence of this pattern operand, operand, operator in the expression

and now you can apply the operator on these two operands and reduced expression. So this is

what I'm getting after evaluating 23*. Now we need to repeat this

process till we are done with all the operators. Once again we need to

scan the expression from left to right and look for the first operator, if the

expression is correct it will be preceeded by two values. So basically we need to look for first

occurrence of this pattern operand, operand, operator. So now we can reduce this. we have 6 and then we have 5*4 20. We are using space as delimeter here, there should be some space in between two operands. Okay so this is

what I have now. Once again I'll look for the first

occurrence of operand, operand and operator. We will go on like this till we are done with all the operators. When I am saying we need to look for first

occurrence of this pattern operand, operand and operator, what I mean by operand here is a value and

not a complex expression itself. The first

operator will always be preceded by two values and if you will give this some thought you will

be able to understand why. If you can see in this expression we are

applying the operators in the same order in which we have them while

parsing from left to right. So first we're applying this leftmost

multiplication on 2 and 3 then we are applying the next

multiplication on 5 and 4 then we're performing the addition and then finally we are performing the

subtraction and whenever we are performing an operation, we're picking the last two operands proceeding the operator in the

expression. So if we have to do this programitically,

if we have to evaluate a postfix expression given to us in a string like this and let's say operands and operators are separated by space we can have some

other delimiter like comma also to separate operands

and operator. Now what we can do is we can parse the

string from left to right. In each step in this parsing, in each

step in the scanning process, we can get a token that will either be an

operator or an operand. What we can do is as we parse from left to right, we can keep track

of all the operands seen so far and I'll come back to how it

will help us. So I'm keeping all the operands so seen so

far in a list. The first entity that we have here is 2 which is an operand so it will go to the

list, next we have 3 which once again is operand so it will go into the list next we have this multiplication

operator. Now this multiplication should be applied to last two operands preceding it last

two operands to the left of it because we already have the elements stored in this list. All we need to do is we need to pick the

last two from this list and perform the operation. It should be 2*3 and with this multiplication we have reduced expression this 23* has now become 6 it has become an operand that can be used by an operator later. We are at this stage right now that I'm

showing in the right. I'll continue the scanning. Next we have an operand, will push this number 5 on to the

list. Next we have 4 which once again will

come to the list and now we have the multiplication operator and it should be applied to the last two

operands in the reduced expression and we should put the result back into the list. This is the stage

where we are right now. So this list actually is storing all the

operands in the reduced expression preceeding the position at which we are during passing. Now for this edition we should take out

the last two elements from the list and then we should put the result back,

next we have an operand we are at this stage right now. Next we have

an operator this subtraction. We will perform this

subtraction and put the result back. Finally when I'm done

scanning the whole expression I'll have only one element left in the list and this will be my final answer this

will be my final result. This is an efficient algorithm. We

are doing only one pass on the string representing the expression and we have our result. The list that we are using here if you could notice is being used in a

special way we are inserting operands one at a time

from one side and then to perform an operation we are

taking out operand from the same side. Whatever is coming in last is getting

out first. This whole thing that we're doing here

with the list can be done efficiently with a stack, which is nothing but a

special kind of list in which elements are inserted and removed from the same side in which

whatever gets in last comes out first. It's called Last In First

Out(LIFO) structure. Let's do this evaluation again. I have drawn

logical representation of stack here, and this time I'm going to use this stack.

I'll also write pseudo code for this algorithm. I'm going to write a function named evaluate postfix that will take a string

as argument. Let's name this string expression exp for expression. In my function here, i'll first create a stack. Now for the sake of simplicity, let's assume that each operand or operator

in the expression will be of only one character. So to get a token or operator,

We can simply run a loop from zero till length of expression -1. So exp[i] will be my operand or operator. If

expression 'i' is operand I should put, push it onto the stack

else if exp[i] is operator we should do two pop operations in the

stack store the value of the operands in some variable. I'm using variable names op1 and op2. Let's say this pop function will remove

an element from top of stack s and also return this element. Once we have the two operands we can perform the operation, I'm using this

variable to store the output. Let's say this function will perform the operation. Now the result should be pushed back onto the stack. If

I have to run through this expression with whatever code I have right now,

then first entity is 2 which is operand so it should be pushed onto the stack.

Next we have 3, once again this will go to the stack.

Next we have this multiplication operator. So we will come to this else if part of

the code. I'll make first pop and I'll store 3 in this variable op1. Well actually this is the second operand,

so I should say this one is op2 and next one will be op1. Once I have popped these two elements I can perform the

operation. As you can see I'm doing the same stuff that I was doing with the list, the only thing is that I'm showing

things vertically. Stack is being shown as a vertical list. I'm

inserting or taking out from the top. Now I'll push the result back onto the

stack. Now we will move to the next entity

which is operand it will go onto the stack. Next 4 will

also go onto the stack and now we have this multiplication, so we

will perform two pop operations. After this operation

is performed result will be pushed back. Next we have

addition. So we will go on like this. We have 26

pushed onto the stack now. Now it's 9 which will go in and

finally we have this subtraction 26-9, 17 will be pushed onto the stack. At this stage we will be done with the loop we are done with all the tokens, all the

operands and operators. The top of stack can be returned as

final result. At this stage we will have only one

element in the stack and this element will be my final result.

You will have to take care of some parsing logic in actual implementation.

Operand can be a number of multiple digits and then we will have delimiter like

space or comma so you'll have to take care of that.

Parsing operand or operator will be some task. If you want to see my implementation you

can check the description of this video for a link. Okay so this was postfix evaluation.

Let's now quickly see how we can do prefix evaluation. Once again I have written this expression in

infix form and I'll first convert it to prefix. We will go in order of precedence. I first

put this paranthesis this 2 * 3 will become *23, this 5 * 4 will become *54 and now we will pick this plus(+) operator whose operands are these two prefix expressions. Finally for the subtraction operator this is

the first operand and this is the second operand. In the last step we can get rid of all the

parenthesis. So this is what I have finally. Let's now

see how we can evaluate a prefix expression like this. We will do it just like postfix this time all we need to do is we need

to scan from right, so we will go from right to left. Once again we will people use a stack if it's an

operand we can push it onto the stack. So here for this example 9 will go onto the stack and now we will go to the next entity in the left, it's 4. Once again we have an operand. It will go onto the stack. Now we have 5. 5 will also be pushed onto the stack and

now we have this multiplication operator. At this stage we need to pop two elements from the stack. This time the first element popped will be the first operand. In postfix the first element popped was

the second operand. This time the second element popped will

be the second operand. For this multiplication, first operand is 5 and second operand is 4. This order is really important for multipication the order doesn't matter but for say division or subtraction this will matter. Result 20 will be pushed onto the stack and we

will keep moving left. Now we have 3 and 2 both will go onto the stack and now we have this multiplication operation. 3 and 2 will be popped and their product 6 will be pushed. Now we have this addition, the two

elements at top are 20 and 6 they will be popped and their sum 26 will be pushed. Finally we have to subtraction. 26 and 9 will be popped out and 17 will be

pushed and finally this is my answer. Prefix evaluation can be performed in couple of other ways also but this

is easiest and most straightforward. Okay so this was prefix

and postfix evaluation using Stack. In coming lessons, we will see efficient algorithms to convert infix to prefix or postfix. This is it

for this lesson. Thanks for Watching! .

**CAL étole solidaire – Présentation et choix des fils** – Hi and welcome to this new crochetalong ! It's summer in France now, no more sweaters …

I don't have tons of summer crochet patterns yet But I have 2: the Open Spaces top

and the Solidaire Stole Along with you in my FB group, we decided to crochet the stole in this CAL The Solidaire Stole is a long shawl, very airy you could also make it as a winter shawl It features several pretty lace stitches: a pretty "Marguerite" flowers motif A very airy yet super easy lace pattern (let's turn it around) with pine trees… and a final dangling edging of candle lights (this pattern was first designed to help a good cause, french "Echeveau Solidaire") This stole can easily be dressed up or down Make it in white for a wedding… Covers your shoulders just right for cooler summer nights or if you use wintery yarns (wool, alpaca..) it will make a perfect shawl for winter This time, the CAL will be quite relaxed with no date set for each part It's summer, I'll go away on vacation and so will many of you… I'll be showing you many yarn options to crochet your Solidaire Stole then go and purchase your own copy of the pattern in my pattern stores This time the crochetalong will be slightly different You'll see in the pattern I have already included tons of tutorials at the end I explained with tons of step by step pictures how to crochet the flowers and the candle lights edging You'll see that… So, both because it's already all explained in the pattern and the fact that there isn't so much I could show without revealing too much of the pattern… (it's not my intention to give away my pattern

for free in this video…) So. I'll show you all those yarn options, Then I'll make another video both to show off your stoles and WIPs, as this is one of the parts of the CAL I love best… and I'll also reply any questions you may have…

So ask away ! technical questions, on yarns..anything But for now, I'll show you several swatches I made with lots of yarn options Let's go ! As you can see, I made lots of swatches ! I made only 2 repeats of the motif for each swatch As this Solidaire Stole pattern is very easy to customize: Simply work as many repeats as desired (here I made 2) Of course the original stole has more repeats as you can see… To modify the width of the stole, simply work any repeat of repeats, as noted at the beginning of pattern Simply work as many repeats of 12 sts (+the selvedge sts) as desired This can allow you to use thinner or thicker yarns, OR to change the final size of the stole… Simply modify the number of repeats Those 2 are my reference swatches for size as this is the yarn I originally used for my silver stole This silver silk yarn is not really readily available anywhere (probably mill ends) All the yarns I'll show you for this stole are light fingering weight slightly thinner than sock yarn, often around 500/600 m per 100g but yardage can vary even further depening on fiber content and spinning process… This silver yarn is silk and a bit of nylon, 470m /100g Lots of drape, which is really what you want for this stole Also, make sure to use a larger hook than recommended on yarn label… as you can see, stitches are open and you can nearly see through the stole… I used crochet hooks anywhere between 4 and 5 mm for those swatches (I'm a tight crocheter) This navy blue is nearly the same yarn. I do have a few kits left with both those yarns… I do want to warn you tho, that it's quite fragile (esp.the silver one). No scratchy nails when crocheting with this yarn ! The navy blue silk is sturdier tho So those were the first 2 swatches… You saw earlier my turquoise stole This is actually a danish yarn by Holst Garn This one is the "Coast" yarn, more popular it seems than the purple "Supersoft 100% uld" The turquoise "Coast" yarn is 55% merino, 45%cotton, 350m / 50g It's also a very light and soft yarn As for the size of the sample, (the silver silk swatch will be my reference for size) Size is pretty spot on. Just keep in mind that size will also depend on size of crochet hook used 😉 (as I experienced with one of my swatches) This purple yarn is "Supersoft 100% uld" by Holst Garn 100% wool and 287m/50g (but not as soft as the name suggests IMO) I also contacted some of my french friends who have online yarn stores… Christine aka "trIScote" has a popular store in France She sells icelandic yarns such as Lopi,… and many other yarns too ! Last summer when I released this pattern she sent me a selection of 3 yarns to try… This is the one I liked best Barts & Francis "Silks & Wools", It's a very thin yarn with slubs of silk I found it weird at first when crocheting But after blocking, it looks gorgeous. It's a very lightweight and soft yarn, really close to my sample when it comes to size Makes a good substitute As shows this Solidaire Stole crocheted with this yarn This yarn is 60%silk, 35% wool, 5% merino,

350m / 50g So this is one option I would recommend… And Christine does offer Kits with this yarn on her website (link in description of video) I also tried more yarns from her store… they are a bit thicker though, if you can see… This one is "Harvest fingering" by Urth yarns 100% merino, 398m / 100g This yarn is very slightly thicker, with a very pretty drape and hand but it's pure merino wool, so maybe not the best choice if you are making a summer stole But I was really pleasantly surprised by this yarn, I would recommend it for a winter version I didn't think much of it before blocking, but blocking was a revelation for this yarn ! I really like it very much, with this excellent stitch definition We also tried an alpaga yarn from her store: "Indiecita" by Filcolana It's also very pretty.. Alpaca is heavier it's 100% alpaca, with 160m /50g It is a slightly thicker yarn, which you can see when you compare the sizes of the swatches… This would make a wider stole AND totally screams "warm winter stole" ! 🙂 But I'm sure it would make a beautiful winter stole and can't wait to see if anyone tries it with that yarn… ( I only asked them for remnants of yarns and didn't have enough to make the full swatch for this one..) Then, I happened to have one ball of "Einband" yarn from Lopi so I quickly made a swatch yesterday… this is a fun yarn, very thin and not plied it's icelandic wool though, so NOT for skin-sensitive people 😉 But I like the stitch definition.. of course I used a larger hook than recommended to open up the lace I think I used a 4 mm or 4.5 mm.. Size is much wider than my initial swatch. Just another option…as my goal with this video is to show you a wide array of possibilities So those were the yarns from the trIScote store… I also asked Annette Petavy which yarns she could recommend from her online yarn store Annette is a very famous crochet designer, most of you probably already know her… She lives not so far away from my place, so we do meet every so often 🙂 She sent me 2 yarns from her store to try out: This one is a thin alpaca yarn, 100% alpaca from Bolivia it's called "alpaga plume" from her own brand Unfortunately you can't touch it, but it's oh-so-soft !! It is alpaca, yet it seems very light it's very thin, with a slightly flecked effect not sure if you can see, but this is seriously thin yarn !! especially for me, as I crochet mostly with worsted weight yarns 😉 yardage is 275m / 50g Size is perfect So that's another very good yarn option, on Annette Petavy's online store Then she also treated me with yak down !! I had never crocheted with yak fiber so far, so I'm pretty impressed… as it's really an exotic and rare fiber… This one is also buttery soft also quite thin, althouth it seems not as thin as the alpaca..(or is it just the color ?) Super soft… it's called "Genghis kan 2 – duvet de yak", by Fonty 100% down of yak,

150m / 25g as for size, it's slightly larger than my swatch It is an option that's much more suited for a winter stole though the alpaca yarn would totally work for a spring/fall version, as it feels nice and light but the yak would work for a winter version this one is sold in small balls of 25g, as it's a rare/exotic fiber I guess… So that's all the options I wanted to show you… I can't wait to see which yarns you'll choose for your Solidaire stoles… Please share photos of your yarn, and of your stoles … Ask your questions, so that I can answer them in the next video… Voilà ! Now it's time to go and purchase your copy of the pattern…. at least for those of you who haven't done so already Choose your yarn then come and share your photos on my Facebook group make sure to use the #solidairestolecal hashtag and as for my previous Crochetalongs, make sure to upload your projects on Ravelry: at the end of the crochetalong, all the projects with finished pictures, linked to my pattern and hashtag of the cal will receive a 3€ voucher valid in my pattern store Till then… Enjoy the summer !! It's getting really hot here, even the stole is too much altough I live in altitude Happy crochet. Enjoy the summer and holidays if you're lucky to go on vacation… Bye and see you soon ! .

**C Practical and Assignment Programs-Pattern Printing 8** – .