Datasets:

---

code-rag-bench

/

online-tutorials

like 1

Follow

CodeRAG-Bench 15

[ { "code": null, "e": 54, "s": 26, "text": "\n13 Apr, 2018" }, { "code": null, "e": 112, "s": 54, "text": "Following questions have been asked in GATE 2008 CS exam." }, { "code": null, "e": 302, "s": 112, "text": "1) The data blocks of a very large file in the Unix file system are allocated using(A) contiguous allocation(B) linked allocation(C) indexed allocation(D) an extension of indexed allocation" }, { "code": null, "e": 532, "s": 302, "text": "Answer (D)The Unix file system uses an extension of indexed allocation. It uses direct blocks, single indirect blocks, double indirect blocks and triple indirect blocks. Following diagram shows implementation of Unix file system." }, { "code": null, "e": 639, "s": 532, "text": "2) The P and V operations on counting semaphores, where s is a counting semaphore, are defined as follows:" }, { "code": null, "e": 752, "s": 639, "text": "P(s) : s = s - 1;\n if (s < 0) then wait;\nV(s) : s = s + 1;\n if (s <= 0) then wakeup a process waiting on s;\n" }, { "code": null, "e": 945, "s": 752, "text": "Assume that Pb and Vb the wait and signal operations on binary semaphores are provided. Two binary semaphores Xb and Yb are used to implement the semaphore operations P(s) and V(s) as follows:" }, { "code": null, "e": 1098, "s": 945, "text": "P(s) : Pb(Xb);\n s = s - 1;\n if (s < 0) {\n Vb(Xb) ;\n Pb(Yb) ;\n }\n else Vb(Xb); \n\n\nV(s) : Pb(Xb) ;\n s = s + 1;\n if (s <= 0) Vb(Yb) ;\n Vb(Xb) ;\n" }, { "code": null, "e": 1191, "s": 1098, "text": "The initial values of Xb and Yb are respectively(A) 0 and 0(B) 0 and 1(C) 1 and 0(D) 1 and 1" }, { "code": null, "e": 1549, "s": 1191, "text": "Answer (C)Both P(s) and V(s) operations are perform Pb(xb) as first step. If Xb is 0, then all processes executing these operations will be blocked. Therefore, Xb must be 1.If Yb is 1, it may become possible that two processes can execute P(s) one after other (implying 2 processes in critical section). Consider the case when s = 1, y = 1. So Yb must be 0." }, { "code": null, "e": 2152, "s": 1549, "text": "3) Which of the following statements about synchronous and asynchronous I/O is NOT true?(A) An ISR is invoked on completion of I/O in synchronous I/O but not in asynchronous I/O(B) In both synchronous and asynchronous I/O, an ISR (Interrupt Service Routine) is invoked after completion of the I/O(C) A process making a synchronous I/O call waits until I/O is complete, but a process making an asynchronous I/O call does not wait for completion of the I/O(D) In the case of synchronous I/O, the process waiting for the completion of I/O is woken up by the ISR that is invoked after the completion of I/O" }, { "code": null, "e": 2430, "s": 2152, "text": "Answer (B)An interrupt service routine will be invoked after the completion of I/O operation and it will place process from block state to ready state, because process performing I/O operation was placed in blocked state till the I/O operation was completed in Synchronous I/O." }, { "code": null, "e": 2765, "s": 2430, "text": "However, process performing I/O will not be placed in the block state and process continues to execute the remaining instructions in Asynchronous I/O, because handler function will be registered while performing the I/O operation, when the I/O operation completed signal mechanism is used to notify the process that data is available." }, { "code": null, "e": 2790, "s": 2765, "text": "So, option (B) is false." }, { "code": null, "e": 2904, "s": 2790, "text": "Please see GATE Corner for all previous year paper/solutions/explanations, syllabus, important dates, notes, etc." }, { "code": null, "e": 3053, "s": 2904, "text": "Please write comments if you find any of the answers/explanations incorrect, or you want to share more information about the topics discussed above." }, { "code": null, "e": 3066, "s": 3053, "text": "GATE-CS-2008" }, { "code": null, "e": 3074, "s": 3066, "text": "GATE CS" }, { "code": null, "e": 3078, "s": 3074, "text": "MCQ" }, { "code": null, "e": 3096, "s": 3078, "text": "Operating Systems" }, { "code": null, "e": 3114, "s": 3096, "text": "Operating Systems" } ]

[ { "code": null, "e": 54, "s": 26, "text": "\n29 Nov, 2020" }, { "code": null, "e": 227, "s": 54, "text": "The PageView widget allows the user to transition between different screens in their flutter application. All you need to set it up are a PageViewController and a PageView." }, { "code": null, "e": 492, "s": 227, "text": "Syntax:\nPageView({Key key, \nAxis scrollDirection, \nbool reverse, \nPageController controller, \nScrollPhysics physics, \nbool pageSnapping, \nvoid Function(int) onPageChanged, \nList<Widget> children, \nDragStartBehavior dragStartBehavior, \nbool allowImplicitScrolling})" }, { "code": null, "e": 565, "s": 492, "text": "scrollDirection: It sets the axis of scrolling (Vertical or horizontal)." }, { "code": null, "e": 642, "s": 565, "text": "reverse: It defines the scrolling direction. By default, it is set to false." }, { "code": null, "e": 687, "s": 642, "text": "controller: It is used to control the pages." }, { "code": null, "e": 750, "s": 687, "text": "physics: It sets the animation of page after stopped dragging." }, { "code": null, "e": 805, "s": 750, "text": "onPageChanged: This is called when page change occurs." }, { "code": null, "e": 848, "s": 805, "text": "children: It displays the list of widgets." }, { "code": null, "e": 999, "s": 848, "text": "allowImplicitScrolling: This property takes in a boolean value as the object. It controls whether to allocate implicit scrolling to the widget’s page." }, { "code": null, "e": 1127, "s": 999, "text": "childDelegate: SliverChildDelegate class is the object given to this property. It provides children widgets to PageView widget." }, { "code": null, "e": 1273, "s": 1127, "text": "clipBehaviour: This property takes in Clip enum as the object. It controls whether the content inside the PageView widget will be clipped or not." }, { "code": null, "e": 1436, "s": 1273, "text": "dragStartBehaviour: This property holds DragStartBehavior enum (final) as the object. It controls the way in which the drag behaviour will start to be registered." }, { "code": null, "e": 1552, "s": 1436, "text": "pageSnapping: It takes a boolean value to determine whether the page snapping will be on or of for PageView widget." }, { "code": null, "e": 1679, "s": 1552, "text": "restoralionID: The restorationID takes in a string as the object. It is used to save the scroll position and later restore it." }, { "code": null, "e": 1826, "s": 1679, "text": "scrollDirection: This property holds Axis enum as the object to decide the scroll axis of the PageView which can be either vertical or horizontal." }, { "code": null, "e": 1836, "s": 1826, "text": "Example: " }, { "code": null, "e": 1856, "s": 1836, "text": "The main.dart file." }, { "code": null, "e": 1861, "s": 1856, "text": "Dart" }, { "code": "import 'package:flutter/material.dart'; void main() { runApp(MyApp());} class MyApp extends StatelessWidget { // This widget is the root // of your application. @override Widget build(BuildContext context) { return MaterialApp( title: 'PageView', theme: ThemeData( primarySwatch: Colors.blue, ), debugShowCheckedModeBanner: false, home: MyHomePage(), ); }} class MyHomePage extends StatefulWidget { @override _MyHomePageState createState() => _MyHomePageState();} class _MyHomePageState extends State<MyHomePage> { PageController controller=PageController(); List<Widget> _list=<Widget>[ new Center(child:new Pages(text: \"Page 1\",)), new Center(child:new Pages(text: \"Page 2\",)), new Center(child:new Pages(text: \"Page 3\",)), new Center(child:new Pages(text: \"Page 4\",)) ]; int _curr=0; @override Widget build(BuildContext context) { return Scaffold( backgroundColor: Colors.grey, appBar:AppBar( title: Text(\"GeeksforGeeks\"), backgroundColor: Colors.green, actions: <Widget>[ Padding( padding: const EdgeInsets.all(3.0), child: Text( \"Page: \"+( _curr+1).toString()+\"/\"+_list.length.toString(),textScaleFactor: 2,), ) ],), body: PageView( children: _list, scrollDirection: Axis.horizontal, // reverse: true, // physics: BouncingScrollPhysics(), controller: controller, onPageChanged: (num){ setState(() { _curr=num; }); }, ), floatingActionButton:Row( mainAxisAlignment: MainAxisAlignment.spaceEvenly, children:<Widget>[ FloatingActionButton( onPressed: () { setState(() { _list.add( new Center(child: new Text( \"New page\", style: new TextStyle(fontSize: 35.0))), ); }); if(_curr!=_list.length-1) controller.jumpToPage(_curr+1); else controller.jumpToPage(0); }, child:Icon(Icons.add)), FloatingActionButton( onPressed: (){ _list.removeAt(_curr); setState(() { controller.jumpToPage(_curr-1); }); }, child:Icon(Icons.delete)), ] ) ); }} class Pages extends StatelessWidget { final text; Pages({this.text}); @override Widget build(BuildContext context) { return Center( child: Column( mainAxisAlignment: MainAxisAlignment.center, children:<Widget>[ Text(text,textAlign: TextAlign.center,style: TextStyle( fontSize: 30,fontWeight:FontWeight.bold),), ] ), ); }}", "e": 4663, "s": 1861, "text": null }, { "code": null, "e": 4722, "s": 4663, "text": "We have set the following parameters in the above example:" }, { "code": null, "e": 4780, "s": 4722, "text": "scrollDirection: Axis.horizontal,\ncontroller: controller," }, { "code": null, "e": 4788, "s": 4780, "text": "Output:" }, { "code": null, "e": 4849, "s": 4788, "text": "If the properties are changed as below in the above example:" }, { "code": null, "e": 4956, "s": 4849, "text": "scrollDirection: Axis.horizontal,\nreverse: true,\nphysics: BouncingScrollPhysics(),\ncontroller: controller," }, { "code": null, "e": 4989, "s": 4956, "text": "It will result in the following:" }, { "code": null, "e": 5050, "s": 4989, "text": "If the properties are changed as below in the above example:" }, { "code": null, "e": 5140, "s": 5050, "text": "scrollDirection: Axis.vertical,\nphysics: BouncingScrollPhysics(),\ncontroller: controller," }, { "code": null, "e": 5173, "s": 5140, "text": "It will result in the following:" }, { "code": null, "e": 5269, "s": 5173, "text": "For the complete code, you can refer to https://github.com/singhteekam/Flutter-PageView-Example" }, { "code": null, "e": 5282, "s": 5269, "text": "ankit_kumar_" }, { "code": null, "e": 5290, "s": 5282, "text": "Flutter" }, { "code": null, "e": 5295, "s": 5290, "text": "Dart" }, { "code": null, "e": 5393, "s": 5295, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 5432, "s": 5393, "text": "Flutter - Custom Bottom Navigation Bar" }, { "code": null, "e": 5458, "s": 5432, "text": "Flutter - Checkbox Widget" }, { "code": null, "e": 5481, "s": 5458, "text": "Flutter - Stack Widget" }, { "code": null, "e": 5495, "s": 5481, "text": "Dart Tutorial" }, { "code": null, "e": 5516, "s": 5495, "text": "Flutter - Search Bar" }, { "code": null, "e": 5534, "s": 5516, "text": "Operators in Dart" }, { "code": null, "e": 5565, "s": 5534, "text": "Flutter - FutureBuilder Widget" }, { "code": null, "e": 5591, "s": 5565, "text": "Flutter - Flexible Widget" }, { "code": null, "e": 5609, "s": 5591, "text": "Flutter - Dialogs" } ]

[ { "code": null, "e": 53, "s": 25, "text": "\n20 Oct, 2021" }, { "code": null, "e": 741, "s": 53, "text": "Swift is a general-purpose, multi-paradigm, object-oriented, functional, imperative and block-structured language. Swift is the result of the latest research on programming languages and is built using a modern approach to safety, software design patterns by Apple Inc. for iOS applications, macOS applications, watchOS applications, tvOS applications. Swift is easy to learn, easy to implement, safe, fast and expressive. Developing Swift in the open has its exciting aspects as it is now free to be ported across a wide range of platforms, devices, and use cases.The features of Swift are designed to work together to create a powerful language. Additional features of Swift include: " }, { "code": null, "e": 781, "s": 741, "text": "Closures unified with function pointers" }, { "code": null, "e": 815, "s": 781, "text": "Tuples and multiple return values" }, { "code": null, "e": 824, "s": 815, "text": "Generics" }, { "code": null, "e": 878, "s": 824, "text": "Concise and fast iteration over a range or collection" }, { "code": null, "e": 934, "s": 878, "text": "Structs that support methods, extensions, and protocols" }, { "code": null, "e": 988, "s": 934, "text": "Functional programming patterns, e.g., map and filter" }, { "code": null, "e": 1021, "s": 988, "text": "Powerful error handling built-in" }, { "code": null, "e": 1086, "s": 1021, "text": "Advanced control flow with do, guard, defer, and repeat keywords" }, { "code": null, "e": 1440, "s": 1086, "text": "Memory Management – Swift uses Automatic Reference Counting (ARC) to manage memory. Earlier, Apple used to require manual memory management in Objective-C, but after introducing ARC in 2011 memory allocation and de-allocation became easier.Swift is managed as a collection of projects, each with its repositories. The current list of projects include: " }, { "code": null, "e": 1477, "s": 1440, "text": "The Swift compiler command-line tool" }, { "code": null, "e": 1530, "s": 1477, "text": "The standard library bundled as part of the language" }, { "code": null, "e": 1585, "s": 1530, "text": "Core libraries that provide higher-level functionality" }, { "code": null, "e": 1623, "s": 1585, "text": "The Swift REPL included LLDB debugger" }, { "code": null, "e": 1680, "s": 1623, "text": "Xcode playground support to enable playgrounds in Xcode." }, { "code": null, "e": 1754, "s": 1680, "text": "The Swift package manager for distributing and building Swift source code" }, { "code": null, "e": 1765, "s": 1754, "text": "Example: " }, { "code": null, "e": 1771, "s": 1765, "text": "Swift" }, { "code": null, "e": 1846, "s": 1771, "text": "var str1 = \"Hello geeks!\"var str2 = \"How are you?\"print (str1)print (str2)" }, { "code": null, "e": 1856, "s": 1846, "text": "Output: " }, { "code": null, "e": 1882, "s": 1856, "text": "Hello geeks!\nHow are you?" }, { "code": null, "e": 2224, "s": 1882, "text": "Run: Code can be tested on Online IDE for Swift Note: Import statement is used to import any objective-C framework or library directly into Swift program. var keyword is used for variable and let keyword is used for constant. There is no need for”;” for termination, in case the programmer uses it compiler won’t show an error. Advantages – " }, { "code": null, "e": 2265, "s": 2224, "text": "Swift is open-sourced and easy to learn." }, { "code": null, "e": 2301, "s": 2265, "text": "Swift is fast, safe and expressive." }, { "code": null, "e": 2412, "s": 2301, "text": "Swift is approachable and familiar (C and C++ code can be added by Swift programmers into Swift applications.)" }, { "code": null, "e": 2454, "s": 2412, "text": "Swift is the future of Apple development." }, { "code": null, "e": 2481, "s": 2454, "text": "Swift is enterprise-ready." }, { "code": null, "e": 2497, "s": 2481, "text": "Disadvantages –" }, { "code": null, "e": 2563, "s": 2497, "text": "The language is still quite young and the talent pool is limited." }, { "code": null, "e": 2669, "s": 2563, "text": "Swift is considered a “moving target” as it is a new language and the number of swift programmers is few." }, { "code": null, "e": 2723, "s": 2669, "text": "Poor interoperability with third-party tools and IDEs" }, { "code": null, "e": 2765, "s": 2723, "text": "Lack of support for earlier iOS versions." }, { "code": null, "e": 2778, "s": 2767, "text": "iamabhijha" }, { "code": null, "e": 2783, "s": 2778, "text": "Misc" }, { "code": null, "e": 2804, "s": 2783, "text": "Programming Language" }, { "code": null, "e": 2809, "s": 2804, "text": "Misc" }, { "code": null, "e": 2814, "s": 2809, "text": "Misc" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n22 Apr, 2019" }, { "code": null, "e": 155, "s": 28, "text": "The rotate() function in p5.js is used to rotate a shape or the object using p5.js to a specified axis over a specified angle." }, { "code": null, "e": 163, "s": 155, "text": "Syntax:" }, { "code": null, "e": 186, "s": 163, "text": "rotate(angle, [axis])\n" }, { "code": null, "e": 276, "s": 186, "text": "Parameters: The function accepts single parameter as mentioned above and described below:" }, { "code": null, "e": 344, "s": 276, "text": "angle: The angle of rotation which specified in radians or degrees." }, { "code": null, "e": 376, "s": 344, "text": "axis: the axis to rotate around" }, { "code": null, "e": 444, "s": 376, "text": "Below program illustrates the rotate() function in p5.js:Example-1:" }, { "code": "function setup() { // Create Canvas of given size createCanvas(380, 170);} function draw() { // Set the background color background(220); strokeWeight(12); //set strokeJoin function strokeJoin(ROUND); // rotation function rotate(PI / 10.0); line(20, 30, 200, 30); line(200, 30, 200, 100); line(200, 100, 20, 30);}", "e": 815, "s": 444, "text": null }, { "code": null, "e": 823, "s": 815, "text": "Output:" }, { "code": null, "e": 834, "s": 823, "text": "Example-2:" }, { "code": "function setup() { // Create Canvas of given size createCanvas(380, 170);} function draw() { // Set the background color background(220); strokeWeight(12); // rotation function rotate(PI / 7.0); textSize(30); text(\"GeeksForGeeks\", 50, 50);}", "e": 1119, "s": 834, "text": null }, { "code": null, "e": 1127, "s": 1119, "text": "Output:" }, { "code": null, "e": 1177, "s": 1127, "text": "Reference: https://p5js.org/reference/#/p5/rotate" }, { "code": null, "e": 1194, "s": 1177, "text": "JavaScript-p5.js" }, { "code": null, "e": 1205, "s": 1194, "text": "JavaScript" }, { "code": null, "e": 1222, "s": 1205, "text": "Web Technologies" }, { "code": null, "e": 1320, "s": 1222, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 1381, "s": 1320, "text": "Difference between var, let and const keywords in JavaScript" }, { "code": null, "e": 1453, "s": 1381, "text": "Differences between Functional Components and Class Components in React" }, { "code": null, "e": 1493, "s": 1453, "text": "Remove elements from a JavaScript Array" }, { "code": null, "e": 1546, "s": 1493, "text": "Hide or show elements in HTML using display property" }, { "code": null, "e": 1587, "s": 1546, "text": "Difference Between PUT and PATCH Request" }, { "code": null, "e": 1620, "s": 1587, "text": "Installation of Node.js on Linux" }, { "code": null, "e": 1682, "s": 1620, "text": "Top 10 Projects For Beginners To Practice HTML and CSS Skills" }, { "code": null, "e": 1743, "s": 1682, "text": "Difference between var, let and const keywords in JavaScript" }, { "code": null, "e": 1793, "s": 1743, "text": "How to insert spaces/tabs in text using HTML/CSS?" } ]

[ { "code": null, "e": 53, "s": 25, "text": "\n02 Jan, 2019" }, { "code": null, "e": 142, "s": 53, "text": "This method is used to associate the specified value with the specified key in this map." }, { "code": null, "e": 150, "s": 142, "text": "Syntax:" }, { "code": null, "e": 176, "s": 150, "text": "V put(K key,\n V value)" }, { "code": null, "e": 324, "s": 176, "text": "Parameters: This method has two arguments, key and value where key is the left argument and value is the corresponding value of the key in the map." }, { "code": null, "e": 428, "s": 324, "text": "Returns: This method returns returns previous value associated with the key if present, else return -1." }, { "code": null, "e": 488, "s": 428, "text": "Below programs show the implementation of int put() method." }, { "code": null, "e": 499, "s": 488, "text": "Program 1:" }, { "code": "// Java code to show the implementation of// put method in Map interfaceimport java.util.*;public class GfG { // Driver code public static void main(String[] args) { // Initializing a Map of type HashMap Map<Integer, String> map = new HashMap<>(); map.put(1, \"One\"); map.put(3, \"Three\"); map.put(5, \"Five\"); map.put(7, \"Seven\"); map.put(9, \"Ninde\"); System.out.println(map); }}", "e": 949, "s": 499, "text": null }, { "code": null, "e": 993, "s": 949, "text": "{1=One, 3=Three, 5=Five, 7=Seven, 9=Ninde}\n" }, { "code": null, "e": 1055, "s": 993, "text": "Program 2: Below is the code to show implementation of put()." }, { "code": "// Java code to show the implementation of// put method in Map interfaceimport java.util.*;public class GfG { // Driver code public static void main(String[] args) { // Initializing a Map of type HashMap Map<String, String> map = new HashMap<>(); map.put(\"1\", \"One\"); map.put(\"3\", \"Three\"); map.put(\"5\", \"Five\"); map.put(\"7\", \"Seven\"); map.put(\"9\", \"Ninde\"); System.out.println(map); }}", "e": 1514, "s": 1055, "text": null }, { "code": null, "e": 1558, "s": 1514, "text": "{1=One, 3=Three, 5=Five, 7=Seven, 9=Ninde}\n" }, { "code": null, "e": 1580, "s": 1558, "text": "Reference:Oracle Docs" }, { "code": null, "e": 1600, "s": 1580, "text": "Java - util package" }, { "code": null, "e": 1617, "s": 1600, "text": "Java-Collections" }, { "code": null, "e": 1632, "s": 1617, "text": "Java-Functions" }, { "code": null, "e": 1641, "s": 1632, "text": "java-map" }, { "code": null, "e": 1646, "s": 1641, "text": "Java" }, { "code": null, "e": 1651, "s": 1646, "text": "Java" }, { "code": null, "e": 1668, "s": 1651, "text": "Java-Collections" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n28 Jun, 2021" }, { "code": null, "e": 192, "s": 28, "text": "In a B+ tree, if the search-key value is 8 bytes long, the block size is 512 bytes and the block pointer is 2 bytes, then the maximum order of the B+ tree is ____." }, { "code": null, "e": 294, "s": 192, "text": "Note: This question appeared as Numerical Answer Type.(A) 51(B) 52(C) 53(D) 54Answer: (B)Explanation:" }, { "code": null, "e": 600, "s": 294, "text": "Order of a B+ tree node is maximum number of children \nin an internal node\n\nLet the order be x. Number of keys in a node is equal to\nnumber children minus 1.\nSo a full node has (x-1) keys and x children.\n\n(x-1)*(search key) + x * block ptr <= block size\n==> (x-1)*8 + x*2 <= 512\n==> 10x <= 520\n==> x <= 52" }, { "code": null, "e": 622, "s": 600, "text": "Quiz of this Question" }, { "code": null, "e": 643, "s": 622, "text": "GATE-CS-2017 (Set 2)" }, { "code": null, "e": 669, "s": 643, "text": "GATE-GATE-CS-2017 (Set 2)" }, { "code": null, "e": 674, "s": 669, "text": "GATE" }, { "code": null, "e": 772, "s": 674, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 814, "s": 772, "text": "GATE | GATE-CS-2014-(Set-2) | Question 65" }, { "code": null, "e": 876, "s": 814, "text": "GATE | Sudo GATE 2020 Mock I (27 December 2019) | Question 33" }, { "code": null, "e": 918, "s": 876, "text": "GATE | GATE-CS-2015 (Set 3) | Question 65" }, { "code": null, "e": 952, "s": 918, "text": "GATE | GATE CS 2008 | Question 46" }, { "code": null, "e": 994, "s": 952, "text": "GATE | GATE-CS-2014-(Set-3) | Question 65" }, { "code": null, "e": 1028, "s": 994, "text": "GATE | GATE CS 1996 | Question 63" }, { "code": null, "e": 1062, "s": 1028, "text": "GATE | GATE CS 2008 | Question 40" }, { "code": null, "e": 1104, "s": 1062, "text": "GATE | GATE-CS-2014-(Set-1) | Question 51" }, { "code": null, "e": 1138, "s": 1104, "text": "GATE | GATE-CS-2001 | Question 50" } ]

[ { "code": null, "e": 1412, "s": 1187, "text": "BCNF (Boyce Codd Normal Form) is the advanced version of 3NF. A table is in BCNF if every functional dependency X->Y, X is the super key of the table. For BCNF, the table should be in 3NF, and for every FD. LHS is super key." }, { "code": null, "e": 1479, "s": 1412, "text": "Consider a relation R with attributes (student, subject, teacher)." }, { "code": null, "e": 1564, "s": 1479, "text": "F: { (student, Teacher) -> subject\n(student, subject) -> Teacher\nTeacher -> subject}" }, { "code": null, "e": 1626, "s": 1564, "text": "Candidate keys are (student, teacher) and (student, subject)." }, { "code": null, "e": 1773, "s": 1626, "text": "The above relation is in 3NF [since there is no transitive dependency]. A relation R is in BCNF if for every non-trivial FD X->Y, X must be a key." }, { "code": null, "e": 1907, "s": 1773, "text": "The above relation is not in BCNF, because in the FD (teacher->subject), teacher is not a key. This relation suffers with anomalies −" }, { "code": null, "e": 2108, "s": 1907, "text": "For example, if we try to delete the student Subbu, we will lose the information that R. Prasad teaches C. These difficulties are caused by the fact the teacher is determinant but not a candidate key." }, { "code": null, "e": 2180, "s": 2108, "text": "Teacher-> subject violates BCNF [since teacher is not a candidate key]." }, { "code": null, "e": 2243, "s": 2180, "text": "If X->Y violates BCNF then divide R into R1(X, Y) and R2(R-Y)." }, { "code": null, "e": 2325, "s": 2243, "text": "So R is divided into two relations R1(Teacher, subject) and R2(student, Teacher)." }, { "code": null, "e": 2328, "s": 2325, "text": "R1" }, { "code": null, "e": 2331, "s": 2328, "text": "R2" }, { "code": null, "e": 2414, "s": 2331, "text": "All the anomalies which were present in R, now removed in the above two relations." }, { "code": null, "e": 2674, "s": 2414, "text": "BCNF decomposition does not always satisfy dependency preserving property. After BCNF decomposition if dependency is not preserved then we have to decide whether we want to remain in BCNF or rollback to 3NF. This process of rollback is called denormalization." } ]

[ { "code": null, "e": 2135, "s": 1914, "text": "JSON or JavaScript Object Notation is a lightweight text-based open standard designed for human-readable data interchange. Conventions used by JSON are known to programmers, which include C, C++, Java, Python, Perl, etc." }, { "code": null, "e": 2179, "s": 2135, "text": "JSON stands for JavaScript Object Notation." }, { "code": null, "e": 2223, "s": 2179, "text": "JSON stands for JavaScript Object Notation." }, { "code": null, "e": 2270, "s": 2223, "text": "The format was specified by Douglas Crockford." }, { "code": null, "e": 2317, "s": 2270, "text": "The format was specified by Douglas Crockford." }, { "code": null, "e": 2370, "s": 2317, "text": "It was designed for human-readable data interchange." }, { "code": null, "e": 2423, "s": 2370, "text": "It was designed for human-readable data interchange." }, { "code": null, "e": 2484, "s": 2423, "text": "It has been extended from the JavaScript scripting language." }, { "code": null, "e": 2545, "s": 2484, "text": "It has been extended from the JavaScript scripting language." }, { "code": null, "e": 2578, "s": 2545, "text": "The filename extension is .json." }, { "code": null, "e": 2611, "s": 2578, "text": "The filename extension is .json." }, { "code": null, "e": 2657, "s": 2611, "text": "JSON Internet Media type is application/json." }, { "code": null, "e": 2703, "s": 2657, "text": "JSON Internet Media type is application/json." }, { "code": null, "e": 2747, "s": 2703, "text": "The Uniform Type Identifier is public.json." }, { "code": null, "e": 2791, "s": 2747, "text": "The Uniform Type Identifier is public.json." }, { "code": null, "e": 2893, "s": 2791, "text": "It is used while writing JavaScript based applications that includes browser extensions and websites." }, { "code": null, "e": 2995, "s": 2893, "text": "It is used while writing JavaScript based applications that includes browser extensions and websites." }, { "code": null, "e": 3089, "s": 2995, "text": "JSON format is used for serializing and transmitting structured data over network connection." }, { "code": null, "e": 3183, "s": 3089, "text": "JSON format is used for serializing and transmitting structured data over network connection." }, { "code": null, "e": 3260, "s": 3183, "text": "It is primarily used to transmit data between a server and web applications." }, { "code": null, "e": 3337, "s": 3260, "text": "It is primarily used to transmit data between a server and web applications." }, { "code": null, "e": 3399, "s": 3337, "text": "Web services and APIs use JSON format to provide public data." }, { "code": null, "e": 3461, "s": 3399, "text": "Web services and APIs use JSON format to provide public data." }, { "code": null, "e": 3511, "s": 3461, "text": "It can be used with modern programming languages." }, { "code": null, "e": 3561, "s": 3511, "text": "It can be used with modern programming languages." }, { "code": null, "e": 3593, "s": 3561, "text": "JSON is easy to read and write." }, { "code": null, "e": 3644, "s": 3593, "text": "It is a lightweight text-based interchange format." }, { "code": null, "e": 3674, "s": 3644, "text": "JSON is language independent." }, { "code": null, "e": 3790, "s": 3674, "text": "The following example shows how to use JSON to store information related to books based on their topic and edition." }, { "code": null, "e": 4078, "s": 3790, "text": "{\n \"book\": [\n\t\n {\n \"id\":\"01\",\n \"language\": \"Java\",\n \"edition\": \"third\",\n \"author\": \"Herbert Schildt\"\n },\n\t\n {\n \"id\":\"07\",\n \"language\": \"C++\",\n \"edition\": \"second\",\n \"author\": \"E.Balagurusamy\"\n }\n ]\n}" }, { "code": null, "e": 4186, "s": 4078, "text": "After understanding the above program, we will try another example. Let's save the below code as json.htm −" }, { "code": null, "e": 5113, "s": 4186, "text": "<html>\n <head>\n <title>JSON example</title>\n <script language = \"javascript\" >\n var object1 = { \"language\" : \"Java\", \"author\" : \"herbert schildt\" };\n document.write(\"<h1>JSON with JavaScript example</h1>\");\n document.write(\"<br>\");\n document.write(\"<h3>Language = \" + object1.language+\"</h3>\"); \n document.write(\"<h3>Author = \" + object1.author+\"</h3>\"); \n\n var object2 = { \"language\" : \"C++\", \"author\" : \"E-Balagurusamy\" };\n document.write(\"<br>\");\n document.write(\"<h3>Language = \" + object2.language+\"</h3>\"); \n document.write(\"<h3>Author = \" + object2.author+\"</h3>\"); \n \n document.write(\"<hr />\");\n document.write(object2.language + \" programming language can be studied \" + \"from book written by \" + object2.author);\n document.write(\"<hr />\");\n </script>\n </head>\n \n <body>\n </body>\n</html>" }, { "code": null, "e": 5230, "s": 5113, "text": "Now let's try to open json.htm using IE or any other javascript enabled browser that produces the following result −" }, { "code": null, "e": 5306, "s": 5230, "text": "You can refer to JSON Objects chapter for more information on JSON objects." }, { "code": null, "e": 5457, "s": 5306, "text": "Let's have a quick look at the basic syntax of JSON. JSON syntax is basically considered as a subset of JavaScript syntax; it includes the following −" }, { "code": null, "e": 5498, "s": 5457, "text": "Data is represented in name/value pairs." }, { "code": null, "e": 5539, "s": 5498, "text": "Data is represented in name/value pairs." }, { "code": null, "e": 5655, "s": 5539, "text": "Curly braces hold objects and each name is followed by ':'(colon), the name/value pairs are separated by , (comma)." }, { "code": null, "e": 5771, "s": 5655, "text": "Curly braces hold objects and each name is followed by ':'(colon), the name/value pairs are separated by , (comma)." }, { "code": null, "e": 5837, "s": 5771, "text": "Square brackets hold arrays and values are separated by ,(comma)." }, { "code": null, "e": 5903, "s": 5837, "text": "Square brackets hold arrays and values are separated by ,(comma)." }, { "code": null, "e": 5931, "s": 5903, "text": "Below is a simple example −" }, { "code": null, "e": 6220, "s": 5931, "text": "{\n \"book\": [\n\n {\n \"id\": \"01\",\n \"language\": \"Java\",\n \"edition\": \"third\",\n \"author\": \"Herbert Schildt\"\n },\n\n {\n \"id\": \"07\",\n \"language\": \"C++\",\n \"edition\": \"second\",\n \"author\": \"E.Balagurusamy\"\n }\n\n ]\n}" }, { "code": null, "e": 6270, "s": 6220, "text": "JSON supports the following two data structures −" }, { "code": null, "e": 6372, "s": 6270, "text": "Collection of name/value pairs − This Data Structure is supported by different programming languages." }, { "code": null, "e": 6474, "s": 6372, "text": "Collection of name/value pairs − This Data Structure is supported by different programming languages." }, { "code": null, "e": 6548, "s": 6474, "text": "Ordered list of values − It includes array, list, vector or sequence etc." }, { "code": null, "e": 6622, "s": 6548, "text": "Ordered list of values − It includes array, list, vector or sequence etc." }, { "code": null, "e": 6670, "s": 6622, "text": "JSON format supports the following data types −" }, { "code": null, "e": 6677, "s": 6670, "text": "Number" }, { "code": null, "e": 6731, "s": 6677, "text": "double- precision floating-point format in JavaScript" }, { "code": null, "e": 6738, "s": 6731, "text": "String" }, { "code": null, "e": 6784, "s": 6738, "text": "double-quoted Unicode with backslash escaping" }, { "code": null, "e": 6792, "s": 6784, "text": "Boolean" }, { "code": null, "e": 6806, "s": 6792, "text": "true or false" }, { "code": null, "e": 6812, "s": 6806, "text": "Array" }, { "code": null, "e": 6842, "s": 6812, "text": "an ordered sequence of values" }, { "code": null, "e": 6848, "s": 6842, "text": "Value" }, { "code": null, "e": 6902, "s": 6848, "text": "it can be a string, a number, true or false, null etc" }, { "code": null, "e": 6909, "s": 6902, "text": "Object" }, { "code": null, "e": 6952, "s": 6909, "text": "an unordered collection of key:value pairs" }, { "code": null, "e": 6963, "s": 6952, "text": "Whitespace" }, { "code": null, "e": 7002, "s": 6963, "text": "can be used between any pair of tokens" }, { "code": null, "e": 7007, "s": 7002, "text": "null" }, { "code": null, "e": 7013, "s": 7007, "text": "empty" }, { "code": null, "e": 7108, "s": 7013, "text": "It is a double precision floating-point format in JavaScript and it depends on implementation." }, { "code": null, "e": 7203, "s": 7108, "text": "It is a double precision floating-point format in JavaScript and it depends on implementation." }, { "code": null, "e": 7247, "s": 7203, "text": "Octal and hexadecimal formats are not used." }, { "code": null, "e": 7291, "s": 7247, "text": "Octal and hexadecimal formats are not used." }, { "code": null, "e": 7329, "s": 7291, "text": "No NaN or Infinity is used in Number." }, { "code": null, "e": 7367, "s": 7329, "text": "No NaN or Infinity is used in Number." }, { "code": null, "e": 7412, "s": 7367, "text": "The following table shows the number types −" }, { "code": null, "e": 7420, "s": 7412, "text": "Integer" }, { "code": null, "e": 7459, "s": 7420, "text": "Digits 1-9, 0 and positive or negative" }, { "code": null, "e": 7468, "s": 7459, "text": "Fraction" }, { "code": null, "e": 7490, "s": 7468, "text": "Fractions like .3, .9" }, { "code": null, "e": 7499, "s": 7490, "text": "Exponent" }, { "code": null, "e": 7534, "s": 7499, "text": "Exponent like e, e+, e-, E, E+, E-" }, { "code": null, "e": 7592, "s": 7534, "text": "var json-object-name = { string : number_value, .......}\n" }, { "code": null, "e": 7654, "s": 7592, "text": "Example showing Number Datatype, value should not be quoted −" }, { "code": null, "e": 7676, "s": 7654, "text": "var obj = {marks: 97}" }, { "code": null, "e": 7767, "s": 7676, "text": "It is a sequence of zero or more double quoted Unicode characters with backslash escaping." }, { "code": null, "e": 7858, "s": 7767, "text": "It is a sequence of zero or more double quoted Unicode characters with backslash escaping." }, { "code": null, "e": 7926, "s": 7858, "text": "Character is a single character string i.e. a string with length 1." }, { "code": null, "e": 7994, "s": 7926, "text": "Character is a single character string i.e. a string with length 1." }, { "code": null, "e": 8086, "s": 7994, "text": "The table shows various special characters that you can use in strings of a JSON document −" }, { "code": null, "e": 8088, "s": 8086, "text": "\"" }, { "code": null, "e": 8105, "s": 8088, "text": "double quotation" }, { "code": null, "e": 8107, "s": 8105, "text": "\\" }, { "code": null, "e": 8117, "s": 8107, "text": "backslash" }, { "code": null, "e": 8119, "s": 8117, "text": "/" }, { "code": null, "e": 8133, "s": 8119, "text": "forward slash" }, { "code": null, "e": 8135, "s": 8133, "text": "b" }, { "code": null, "e": 8145, "s": 8135, "text": "backspace" }, { "code": null, "e": 8147, "s": 8145, "text": "f" }, { "code": null, "e": 8157, "s": 8147, "text": "form feed" }, { "code": null, "e": 8159, "s": 8157, "text": "n" }, { "code": null, "e": 8168, "s": 8159, "text": "new line" }, { "code": null, "e": 8170, "s": 8168, "text": "r" }, { "code": null, "e": 8186, "s": 8170, "text": "carriage return" }, { "code": null, "e": 8188, "s": 8186, "text": "t" }, { "code": null, "e": 8203, "s": 8188, "text": "horizontal tab" }, { "code": null, "e": 8205, "s": 8203, "text": "u" }, { "code": null, "e": 8229, "s": 8205, "text": "four hexadecimal digits" }, { "code": null, "e": 8289, "s": 8229, "text": "var json-object-name = { string : \"string value\", .......}\n" }, { "code": null, "e": 8323, "s": 8289, "text": "Example showing String Datatype −" }, { "code": null, "e": 8348, "s": 8323, "text": "var obj = {name: 'Amit'}" }, { "code": null, "e": 8382, "s": 8348, "text": "It includes true or false values." }, { "code": null, "e": 8438, "s": 8382, "text": "var json-object-name = { string : true/false, .......}\n" }, { "code": null, "e": 8493, "s": 8438, "text": "var obj = {name: 'Amit', marks: 97, distinction: true}" }, { "code": null, "e": 8532, "s": 8493, "text": "It is an ordered collection of values." }, { "code": null, "e": 8571, "s": 8532, "text": "It is an ordered collection of values." }, { "code": null, "e": 8667, "s": 8571, "text": "These are enclosed in square brackets which means that array begins with .[. and ends with .].." }, { "code": null, "e": 8763, "s": 8667, "text": "These are enclosed in square brackets which means that array begins with .[. and ends with .].." }, { "code": null, "e": 8802, "s": 8763, "text": "The values are separated by , (comma)." }, { "code": null, "e": 8841, "s": 8802, "text": "The values are separated by , (comma)." }, { "code": null, "e": 8882, "s": 8841, "text": "Array indexing can be started at 0 or 1." }, { "code": null, "e": 8923, "s": 8882, "text": "Array indexing can be started at 0 or 1." }, { "code": null, "e": 8989, "s": 8923, "text": "Arrays should be used when the key names are sequential integers." }, { "code": null, "e": 9055, "s": 8989, "text": "Arrays should be used when the key names are sequential integers." }, { "code": null, "e": 9074, "s": 9055, "text": "[ value, .......]\n" }, { "code": null, "e": 9126, "s": 9074, "text": "Example showing array containing multiple objects −" }, { "code": null, "e": 9294, "s": 9126, "text": "{\n \"books\": [\n { \"language\":\"Java\" , \"edition\":\"second\" },\n { \"language\":\"C++\" , \"lastName\":\"fifth\" },\n { \"language\":\"C\" , \"lastName\":\"third\" }\n ]\n}" }, { "code": null, "e": 9338, "s": 9294, "text": "It is an unordered set of name/value pairs." }, { "code": null, "e": 9382, "s": 9338, "text": "It is an unordered set of name/value pairs." }, { "code": null, "e": 9466, "s": 9382, "text": "Objects are enclosed in curly braces that is, it starts with '{' and ends with '}'." }, { "code": null, "e": 9550, "s": 9466, "text": "Objects are enclosed in curly braces that is, it starts with '{' and ends with '}'." }, { "code": null, "e": 9638, "s": 9550, "text": "Each name is followed by ':'(colon) and the key/value pairs are separated by , (comma)." }, { "code": null, "e": 9726, "s": 9638, "text": "Each name is followed by ':'(colon) and the key/value pairs are separated by , (comma)." }, { "code": null, "e": 9792, "s": 9726, "text": "The keys must be strings and should be different from each other." }, { "code": null, "e": 9858, "s": 9792, "text": "The keys must be strings and should be different from each other." }, { "code": null, "e": 9923, "s": 9858, "text": "Objects should be used when the key names are arbitrary strings." }, { "code": null, "e": 9988, "s": 9923, "text": "Objects should be used when the key names are arbitrary strings." }, { "code": null, "e": 10016, "s": 9988, "text": "{ string : value, .......}\n" }, { "code": null, "e": 10041, "s": 10016, "text": "Example showing Object −" }, { "code": null, "e": 10102, "s": 10041, "text": "{\n \"id\": \"011A\",\n \"language\": \"JAVA\",\n \"price\": 500,\n}" }, { "code": null, "e": 10251, "s": 10102, "text": "It can be inserted between any pair of tokens. It can be added to make a code more readable. Example shows declaration with and without whitespace −" }, { "code": null, "e": 10270, "s": 10251, "text": "{string:\" \",....}\n" }, { "code": null, "e": 10347, "s": 10270, "text": "var obj1 = {\"name\": \"Sachin Tendulkar\"}\nvar obj2 = {\"name\": \"SauravGanguly\"}" }, { "code": null, "e": 10368, "s": 10347, "text": "It means empty type." }, { "code": null, "e": 10374, "s": 10368, "text": "null\n" }, { "code": null, "e": 10500, "s": 10374, "text": "var i = null;\n\nif(i == 1) {\n document.write(\"<h1>value is 1</h1>\");\n} else {\n document.write(\"<h1>value is null</h1>\");\n}" }, { "code": null, "e": 10514, "s": 10500, "text": "It includes −" }, { "code": null, "e": 10549, "s": 10514, "text": "number (integer or floating point)" }, { "code": null, "e": 10556, "s": 10549, "text": "string" }, { "code": null, "e": 10564, "s": 10556, "text": "boolean" }, { "code": null, "e": 10570, "s": 10564, "text": "array" }, { "code": null, "e": 10577, "s": 10570, "text": "object" }, { "code": null, "e": 10582, "s": 10577, "text": "null" }, { "code": null, "e": 10638, "s": 10582, "text": "String | Number | Object | Array | TRUE | FALSE | NULL\n" }, { "code": null, "e": 10681, "s": 10638, "text": "var i = 1;\nvar j = \"sachin\";\nvar k = null;" }, { "code": null, "e": 10798, "s": 10681, "text": "JSON objects can be created with JavaScript. Let us see the various ways of creating JSON objects using JavaScript −" }, { "code": null, "e": 10828, "s": 10798, "text": "Creation of an empty Object −" }, { "code": null, "e": 10847, "s": 10828, "text": "var JSONObj = {};\n" }, { "code": null, "e": 10874, "s": 10847, "text": "Creation of a new Object −" }, { "code": null, "e": 10903, "s": 10874, "text": "var JSONObj = new Object();\n" }, { "code": null, "e": 11053, "s": 10903, "text": "Creation of an object with attribute bookname with value in string, attribute price with numeric value. Attribute is accessed by using '.' Operator −" }, { "code": null, "e": 11203, "s": 11053, "text": "Creation of an object with attribute bookname with value in string, attribute price with numeric value. Attribute is accessed by using '.' Operator −" }, { "code": null, "e": 11264, "s": 11203, "text": "var JSONObj = { \"bookname \":\"VB BLACK BOOK\", \"price\":500 };\n" }, { "code": null, "e": 11383, "s": 11264, "text": "This is an example that shows creation of an object in javascript using JSON, save the below code as json_object.htm −" }, { "code": null, "e": 11869, "s": 11383, "text": "<html>\n <head>\n <title>Creating Object JSON with JavaScript</title>\n <script language = \"javascript\" >\n var JSONObj = { \"name\" : \"tutorialspoint.com\", \"year\" : 2005 };\n\t\t\n document.write(\"<h1>JSON with JavaScript example</h1>\");\n document.write(\"<br>\");\n document.write(\"<h3>Website Name = \"+JSONObj.name+\"</h3>\"); \n document.write(\"<h3>Year = \"+JSONObj.year+\"</h3>\"); \n </script>\n </head>\n \n <body>\n </body>\t\n</html>" }, { "code": null, "e": 11988, "s": 11869, "text": "Now let's try to open Json Object using IE or any other javaScript enabled browser. It produces the following result −" }, { "code": null, "e": 12117, "s": 11988, "text": "The following example shows creation of an array object in javascript using JSON, save the below code as json_array_object.htm −" }, { "code": null, "e": 13766, "s": 12117, "text": "<html>\n <head>\n <title>Creation of array object in javascript using JSON</title>\n <script language = \"javascript\" >\n document.writeln(\"<h2>JSON array object</h2>\");\n var books = { \"Pascal\" : [ \n { \"Name\" : \"Pascal Made Simple\", \"price\" : 700 },\n { \"Name\" : \"Guide to Pascal\", \"price\" : 400 }], \n\t\t\t\t\n \"Scala\" : [\n { \"Name\" : \"Scala for the Impatient\", \"price\" : 1000 }, \n { \"Name\" : \"Scala in Depth\", \"price\" : 1300 }] \n } \n var i = 0\n document.writeln(\"<table border = '2'><tr>\");\n\t\t\t\n for(i = 0;i<books.Pascal.length;i++) {\t\n document.writeln(\"<td>\");\n document.writeln(\"<table border = '1' width = 100 >\");\n document.writeln(\"<tr><td><b>Name</b></td><td width = 50>\" + books.Pascal[i].Name+\"</td></tr>\");\n document.writeln(\"<tr><td><b>Price</b></td><td width = 50>\" + books.Pascal[i].price +\"</td></tr>\");\n document.writeln(\"</table>\");\n document.writeln(\"</td>\");\n }\n\n for(i = 0;i<books.Scala.length;i++) {\n document.writeln(\"<td>\");\n document.writeln(\"<table border = '1' width = 100 >\");\n document.writeln(\"<tr><td><b>Name</b></td><td width = 50>\" + books.Scala[i].Name+\"</td></tr>\");\n document.writeln(\"<tr><td><b>Price</b></td><td width = 50>\" + books.Scala[i].price+\"</td></tr>\");\n document.writeln(\"</table>\");\n document.writeln(\"</td>\");\n }\n\t\t\t\n document.writeln(\"</tr></table>\");\n </script>\n </head>\n \n <body>\n </body>\n</html>" }, { "code": null, "e": 13891, "s": 13766, "text": "Now let's try to open Json Array Object using IE or any other javaScript enabled browser. It produces the following result −" }, { "code": null, "e": 14054, "s": 13891, "text": "JSON Schema is a specification for JSON based format for defining the structure of JSON data. It was written under IETF draft which expired in 2011. JSON Schema −" }, { "code": null, "e": 14091, "s": 14054, "text": "Describes your existing data format." }, { "code": null, "e": 14141, "s": 14091, "text": "Clear, human- and machine-readable documentation." }, { "code": null, "e": 14203, "s": 14141, "text": "Complete structural validation, useful for automated testing." }, { "code": null, "e": 14269, "s": 14203, "text": "Complete structural validation, validating client-submitted data." }, { "code": null, "e": 14437, "s": 14269, "text": "There are several validators currently available for different programming languages. Currently the most complete and compliant JSON Schema validator available is JSV." }, { "code": null, "e": 14528, "s": 14437, "text": "Given below is a basic JSON schema, which covers a classical product catalog description −" }, { "code": null, "e": 15080, "s": 14528, "text": "{\n \"$schema\": \"http://json-schema.org/draft-04/schema#\",\n \"title\": \"Product\",\n \"description\": \"A product from Acme's catalog\",\n \"type\": \"object\",\n\t\n \"properties\": {\n\t\n \"id\": {\n \"description\": \"The unique identifier for a product\",\n \"type\": \"integer\"\n },\n\t\t\n \"name\": {\n \"description\": \"Name of the product\",\n \"type\": \"string\"\n },\n\t\t\n \"price\": {\n \"type\": \"number\",\n \"minimum\": 0,\n \"exclusiveMinimum\": true\n }\n },\n\t\n \"required\": [\"id\", \"name\", \"price\"]\n}" }, { "code": null, "e": 15157, "s": 15080, "text": "Let's the check various important keywords that can be used in this schema −" }, { "code": null, "e": 15165, "s": 15157, "text": "$schema" }, { "code": null, "e": 15261, "s": 15165, "text": "The $schema keyword states that this schema is written according to the draft v4 specification." }, { "code": null, "e": 15267, "s": 15261, "text": "title" }, { "code": null, "e": 15317, "s": 15267, "text": "You will use this to give a title to your schema." }, { "code": null, "e": 15329, "s": 15317, "text": "description" }, { "code": null, "e": 15365, "s": 15329, "text": "A little description of the schema." }, { "code": null, "e": 15370, "s": 15365, "text": "type" }, { "code": null, "e": 15462, "s": 15370, "text": "The type keyword defines the first constraint on our JSON data: it has to be a JSON Object." }, { "code": null, "e": 15473, "s": 15462, "text": "properties" }, { "code": null, "e": 15569, "s": 15473, "text": "Defines various keys and their value types, minimum and maximum values to be used in JSON file." }, { "code": null, "e": 15578, "s": 15569, "text": "required" }, { "code": null, "e": 15620, "s": 15578, "text": "This keeps a list of required properties." }, { "code": null, "e": 15628, "s": 15620, "text": "minimum" }, { "code": null, "e": 15715, "s": 15628, "text": "This is the constraint to be put on the value and represents minimum acceptable value." }, { "code": null, "e": 15732, "s": 15715, "text": "exclusiveMinimum" }, { "code": null, "e": 15870, "s": 15732, "text": "If \"exclusiveMinimum\" is present and has boolean value true, the instance is valid if it is strictly greater than the value of \"minimum\"." }, { "code": null, "e": 15878, "s": 15870, "text": "maximum" }, { "code": null, "e": 15965, "s": 15878, "text": "This is the constraint to be put on the value and represents maximum acceptable value." }, { "code": null, "e": 15982, "s": 15965, "text": "exclusiveMaximum" }, { "code": null, "e": 16118, "s": 15982, "text": "If \"exclusiveMaximum\" is present and has boolean value true, the instance is valid if it is strictly lower than the value of \"maximum\"." }, { "code": null, "e": 16129, "s": 16118, "text": "multipleOf" }, { "code": null, "e": 16263, "s": 16129, "text": "A numeric instance is valid against \"multipleOf\" if the result of the division of the instance by this keyword's value is an integer." }, { "code": null, "e": 16273, "s": 16263, "text": "maxLength" }, { "code": null, "e": 16357, "s": 16273, "text": "The length of a string instance is defined as the maximum number of its characters." }, { "code": null, "e": 16367, "s": 16357, "text": "minLength" }, { "code": null, "e": 16451, "s": 16367, "text": "The length of a string instance is defined as the minimum number of its characters." }, { "code": null, "e": 16459, "s": 16451, "text": "pattern" }, { "code": null, "e": 16558, "s": 16459, "text": "A string instance is considered valid if the regular expression matches the instance successfully." }, { "code": null, "e": 16754, "s": 16558, "text": "You can check a http://json-schema.org for the complete list of keywords that can be used in defining a JSON schema. The above schema can be used to test the validity of the following JSON code −" }, { "code": null, "e": 16919, "s": 16754, "text": "[\n {\n \"id\": 2,\n \"name\": \"An ice sculpture\",\n \"price\": 12.50,\n },\n\t\n {\n \"id\": 3,\n \"name\": \"A blue mouse\",\n \"price\": 25.50,\n }\n]" }, { "code": null, "e": 17136, "s": 16919, "text": "JSON and XML are human readable formats and are language independent. They both have support for creation, reading and decoding in real world situations. We can compare JSON with XML, based on the following factors −" }, { "code": null, "e": 17214, "s": 17136, "text": "XML is more verbose than JSON, so it is faster to write JSON for programmers." }, { "code": null, "e": 17317, "s": 17214, "text": "XML is used to describe the structured data, which doesn't include arrays whereas JSON include arrays." }, { "code": null, "e": 17412, "s": 17317, "text": "JavaScript's eval method parses JSON. When applied to JSON, eval returns the described object." }, { "code": null, "e": 17450, "s": 17412, "text": "Individual examples of XML and JSON −" }, { "code": null, "e": 17519, "s": 17450, "text": "{\n \"company\": Volkswagen,\n \"name\": \"Vento\",\n \"price\": 800000\n}" }, { "code": null, "e": 17612, "s": 17519, "text": "<car>\n <company>Volkswagen</company>\n <name>Vento</name>\n <price>800000</price>\n</car>" }, { "code": null, "e": 17789, "s": 17612, "text": "This chapter covers how to encode and decode JSON objects using PHP programming language. Let's start with preparing the environment to start our programming with PHP for JSON." }, { "code": null, "e": 17870, "s": 17789, "text": "As of PHP 5.2.0, the JSON extension is bundled and compiled into PHP by default." }, { "code": null, "e": 18020, "s": 17870, "text": "PHP json_encode() function is used for encoding JSON in PHP. This function returns the JSON representation of a value on success or FALSE on failure." }, { "code": null, "e": 18069, "s": 18020, "text": "string json_encode ( $value [, $options = 0 ] )\n" }, { "code": null, "e": 18152, "s": 18069, "text": "value − The value being encoded. This function only works with UTF-8 encoded data." }, { "code": null, "e": 18235, "s": 18152, "text": "value − The value being encoded. This function only works with UTF-8 encoded data." }, { "code": null, "e": 18432, "s": 18235, "text": "options − This optional value is a bitmask consisting of JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT." }, { "code": null, "e": 18629, "s": 18432, "text": "options − This optional value is a bitmask consisting of JSON_HEX_QUOT, JSON_HEX_TAG, JSON_HEX_AMP, JSON_HEX_APOS, JSON_NUMERIC_CHECK, JSON_PRETTY_PRINT, JSON_UNESCAPED_SLASHES, JSON_FORCE_OBJECT." }, { "code": null, "e": 18702, "s": 18629, "text": "The following example shows how to convert an array into JSON with PHP −" }, { "code": null, "e": 18805, "s": 18702, "text": "<?php\n $arr = array('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5);\n echo json_encode($arr);\n?>" }, { "code": null, "e": 18863, "s": 18805, "text": "While executing, this will produce the following result −" }, { "code": null, "e": 18896, "s": 18863, "text": "{\"a\":1,\"b\":2,\"c\":3,\"d\":4,\"e\":5}\n" }, { "code": null, "e": 18973, "s": 18896, "text": "The following example shows how the PHP objects can be converted into JSON −" }, { "code": null, "e": 19324, "s": 18973, "text": "<?php\n class Emp {\n public $name = \"\";\n public $hobbies = \"\";\n public $birthdate = \"\";\n }\n\t\n $e = new Emp();\n $e->name = \"sachin\";\n $e->hobbies = \"sports\";\n $e->birthdate = date('m/d/Y h:i:s a', \"8/5/1974 12:20:03 p\");\n $e->birthdate = date('m/d/Y h:i:s a', strtotime(\"8/5/1974 12:20:03\"));\n\n echo json_encode($e);\n?>" }, { "code": null, "e": 19382, "s": 19324, "text": "While executing, this will produce the following result −" }, { "code": null, "e": 19459, "s": 19382, "text": "{\"name\":\"sachin\",\"hobbies\":\"sports\",\"birthdate\":\"08\\/05\\/1974 12:20:03 pm\"}\n" }, { "code": null, "e": 19595, "s": 19459, "text": "PHP json_decode() function is used for decoding JSON in PHP. This function returns the value decoded from json to appropriate PHP type." }, { "code": null, "e": 19675, "s": 19595, "text": "mixed json_decode ($json [,$assoc = false [, $depth = 512 [, $options = 0 ]]])\n" }, { "code": null, "e": 19747, "s": 19675, "text": "json_string − It is an encoded string which must be UTF-8 encoded data." }, { "code": null, "e": 19819, "s": 19747, "text": "json_string − It is an encoded string which must be UTF-8 encoded data." }, { "code": null, "e": 19937, "s": 19819, "text": "assoc − It is a boolean type parameter, when set to TRUE, returned objects will be converted into associative arrays." }, { "code": null, "e": 20055, "s": 19937, "text": "assoc − It is a boolean type parameter, when set to TRUE, returned objects will be converted into associative arrays." }, { "code": null, "e": 20127, "s": 20055, "text": "depth − It is an integer type parameter which specifies recursion depth" }, { "code": null, "e": 20199, "s": 20127, "text": "depth − It is an integer type parameter which specifies recursion depth" }, { "code": null, "e": 20291, "s": 20199, "text": "options − It is an integer type bitmask of JSON decode, JSON_BIGINT_AS_STRING is supported." }, { "code": null, "e": 20383, "s": 20291, "text": "options − It is an integer type bitmask of JSON decode, JSON_BIGINT_AS_STRING is supported." }, { "code": null, "e": 20456, "s": 20383, "text": "The following example shows how PHP can be used to decode JSON objects −" }, { "code": null, "e": 20584, "s": 20456, "text": "<?php\n $json = '{\"a\":1,\"b\":2,\"c\":3,\"d\":4,\"e\":5}';\n\n var_dump(json_decode($json));\n var_dump(json_decode($json, true));\n?>" }, { "code": null, "e": 20640, "s": 20584, "text": "While executing, it will produce the following result −" }, { "code": null, "e": 20872, "s": 20640, "text": "object(stdClass)#1 (5) {\n [\"a\"] => int(1)\n [\"b\"] => int(2)\n [\"c\"] => int(3)\n [\"d\"] => int(4)\n [\"e\"] => int(5)\n}\n\narray(5) {\n [\"a\"] => int(1)\n [\"b\"] => int(2)\n [\"c\"] => int(3)\n [\"d\"] => int(4)\n [\"e\"] => int(5)\n}\n" }, { "code": null, "e": 21051, "s": 20872, "text": "This chapter covers how to encode and decode JSON objects using Perl programming language. Let's start with preparing the environment to start our programming with Perl for JSON." }, { "code": null, "e": 21274, "s": 21051, "text": "Before you start encoding and decoding JSON using Perl, you need to install JSON module, which can be obtained from CPAN. Once you downloaded JSON-2.53.tar.gz or any other latest version, follow the steps mentioned below −" }, { "code": null, "e": 21354, "s": 21274, "text": "$tar xvfz JSON-2.53.tar.gz\n$cd JSON-2.53\n$perl Makefile.PL\n$make\n$make install\n" }, { "code": null, "e": 21456, "s": 21354, "text": "Perl encode_json() function converts the given Perl data structure to a UTF-8 encoded, binary string." }, { "code": null, "e": 21554, "s": 21456, "text": "$json_text = encode_json ($perl_scalar );\nor\n$json_text = JSON->new->utf8->encode($perl_scalar);\n" }, { "code": null, "e": 21612, "s": 21554, "text": "The following example shows arrays under JSON with Perl −" }, { "code": null, "e": 21758, "s": 21612, "text": "#!/usr/bin/perl\nuse JSON;\n\nmy %rec_hash = ('a' => 1, 'b' => 2, 'c' => 3, 'd' => 4, 'e' => 5);\nmy $json = encode_json \\%rec_hash;\nprint \"$json\\n\";" }, { "code": null, "e": 21816, "s": 21758, "text": "While executing, this will produce the following result −" }, { "code": null, "e": 21849, "s": 21816, "text": "{\"e\":5,\"c\":3,\"a\":1,\"b\":2,\"d\":4}\n" }, { "code": null, "e": 21923, "s": 21849, "text": "The following example shows how Perl objects can be converted into JSON −" }, { "code": null, "e": 22354, "s": 21923, "text": "#!/usr/bin/perl\n\npackage Emp;\nsub new {\n my $class = shift;\n\t\n my $self = {\n name => shift,\n hobbies => shift,\n birthdate => shift,\n };\n\t\n bless $self, $class;\n return $self;\n}\n\nsub TO_JSON { return { %{ shift() } }; }\n\npackage main;\nuse JSON;\n\nmy $JSON = JSON->new->utf8;\n$JSON->convert_blessed(1);\n\n$e = new Emp( \"sachin\", \"sports\", \"8/5/1974 12:20:03 pm\");\n$json = $JSON->encode($e);\nprint \"$json\\n\";" }, { "code": null, "e": 22407, "s": 22354, "text": "On executing, it will produce the following result −" }, { "code": null, "e": 22480, "s": 22407, "text": "{\"birthdate\":\"8/5/1974 12:20:03 pm\",\"name\":\"sachin\",\"hobbies\":\"sports\"}\n" }, { "code": null, "e": 22622, "s": 22480, "text": "Perl decode_json() function is used for decoding JSON in Perl. This function returns the value decoded from json to an appropriate Perl type." }, { "code": null, "e": 22715, "s": 22622, "text": "$perl_scalar = decode_json $json_text\nor\n$perl_scalar = JSON->new->utf8->decode($json_text)\n" }, { "code": null, "e": 22885, "s": 22715, "text": "The following example shows how Perl can be used to decode JSON objects. Here you will need to install Data::Dumper module if you already do not have it on your machine." }, { "code": null, "e": 23024, "s": 22885, "text": "#!/usr/bin/perl\nuse JSON;\nuse Data::Dumper;\n\n$json = '{\"a\":1,\"b\":2,\"c\":3,\"d\":4,\"e\":5}';\n\n$text = decode_json($json);\nprint Dumper($text);" }, { "code": null, "e": 23073, "s": 23024, "text": "On executing, it will produce following result −" }, { "code": null, "e": 23151, "s": 23073, "text": "$VAR1 = {\n 'e' => 5,\n 'c' => 3,\n 'a' => 1,\n 'b' => 2,\n 'd' => 4\n};\n" }, { "code": null, "e": 23334, "s": 23151, "text": "This chapter covers how to encode and decode JSON objects using Python programming language. Let's start with preparing the environment to start our programming with Python for JSON." }, { "code": null, "e": 23524, "s": 23334, "text": "Before you start with encoding and decoding JSON using Python, you need to install any of the JSON modules available. For this tutorial we have downloaded and installed Demjson as follows −" }, { "code": null, "e": 23595, "s": 23524, "text": "$tar xvfz demjson-1.6.tar.gz\n$cd demjson-1.6\n$python setup.py install\n" }, { "code": null, "e": 23681, "s": 23595, "text": "Python encode() function encodes the Python object into a JSON string representation." }, { "code": null, "e": 23722, "s": 23681, "text": "demjson.encode(self, obj, nest_level=0)\n" }, { "code": null, "e": 23781, "s": 23722, "text": "The following example shows arrays under JSON with Python." }, { "code": null, "e": 23914, "s": 23781, "text": "#!/usr/bin/python\nimport demjson\n\ndata = [ { 'a' : 1, 'b' : 2, 'c' : 3, 'd' : 4, 'e' : 5 } ]\n\njson = demjson.encode(data)\nprint json" }, { "code": null, "e": 23972, "s": 23914, "text": "While executing, this will produce the following result −" }, { "code": null, "e": 24007, "s": 23972, "text": "[{\"a\":1,\"b\":2,\"c\":3,\"d\":4,\"e\":5}]\n" }, { "code": null, "e": 24148, "s": 24007, "text": "Python can use demjson.decode() function for decoding JSON. This function returns the value decoded from json to an appropriate Python type." }, { "code": null, "e": 24175, "s": 24148, "text": "demjson.decode(self, txt)\n" }, { "code": null, "e": 24250, "s": 24175, "text": "The following example shows how Python can be used to decode JSON objects." }, { "code": null, "e": 24367, "s": 24250, "text": "#!/usr/bin/python\nimport demjson\n\njson = '{\"a\":1,\"b\":2,\"c\":3,\"d\":4,\"e\":5}';\n\ntext = demjson.decode(json)\nprint text" }, { "code": null, "e": 24420, "s": 24367, "text": "On executing, it will produce the following result −" }, { "code": null, "e": 24467, "s": 24420, "text": "{u'a': 1, u'c': 3, u'b': 2, u'e': 5, u'd': 4}\n" }, { "code": null, "e": 24646, "s": 24467, "text": "This chapter covers how to encode and decode JSON objects using Ruby programming language. Let's start with preparing the environment to start our programming with Ruby for JSON." }, { "code": null, "e": 25000, "s": 24646, "text": "Before you start with encoding and decoding JSON using Ruby, you need to install any of the JSON modules available for Ruby. You may need to install Ruby gem, but if you are running latest version of Ruby then you must have gem already installed on your machine, otherwise let's follow the following single step assuming you already have gem installed −" }, { "code": null, "e": 25019, "s": 25000, "text": "$gem install json\n" }, { "code": null, "e": 25194, "s": 25019, "text": "The following example shows that the first 2 keys hold string values and the last 3 keys hold arrays of strings. Let's keep the following content in a file called input.json." }, { "code": null, "e": 25547, "s": 25194, "text": "{\n \"President\": \"Alan Isaac\",\n \"CEO\": \"David Richardson\",\n \n \"India\": [\n \"Sachin Tendulkar\",\n \"Virender Sehwag\",\n \"Gautam Gambhir\"\n ],\n\n \"Srilanka\": [\n \"Lasith Malinga\",\n \"Angelo Mathews\",\n \"Kumar Sangakkara\"\n ],\n\n \"England\": [\n \"Alastair Cook\",\n \"Jonathan Trott\",\n \"Kevin Pietersen\"\n ]\n\t\n}" }, { "code": null, "e": 25640, "s": 25547, "text": "Given below is a Ruby program that will be used to parse the above mentioned JSON document −" }, { "code": null, "e": 25766, "s": 25640, "text": "#!/usr/bin/ruby\nrequire 'rubygems'\nrequire 'json'\nrequire 'pp'\n\njson = File.read('input.json')\nobj = JSON.parse(json)\n\npp obj" }, { "code": null, "e": 25819, "s": 25766, "text": "On executing, it will produce the following result −" }, { "code": null, "e": 26113, "s": 25819, "text": "{\n \"President\"=>\"Alan Isaac\",\n \"CEO\"=>\"David Richardson\",\n\n \"India\"=>\n [\"Sachin Tendulkar\", \"Virender Sehwag\", \"Gautam Gambhir\"],\n\n \"Srilanka\"=>\n [\"Lasith Malinga \", \"Angelo Mathews\", \"Kumar Sangakkara\"],\n\n \"England\"=>\n [\"Alastair Cook\", \"Jonathan Trott\", \"Kevin Pietersen\"]\n}\n" }, { "code": null, "e": 26292, "s": 26113, "text": "This chapter covers how to encode and decode JSON objects using Java programming language. Let's start with preparing the environment to start our programming with Java for JSON." }, { "code": null, "e": 26568, "s": 26292, "text": "Before you start with encoding and decoding JSON using Java, you need to install any of the JSON modules available. For this tutorial we have downloaded and installed JSON.simple and have added the location of json-simple-1.1.1.jar file to the environment variable CLASSPATH." }, { "code": null, "e": 26719, "s": 26568, "text": "JSON.simple maps entities from the left side to the right side while decoding or parsing, and maps entities from the right to the left while encoding." }, { "code": null, "e": 26885, "s": 26719, "text": "On decoding, the default concrete class of java.util.List is org.json.simple.JSONArray and the default concrete class of java.util.Map is org.json.simple.JSONObject." }, { "code": null, "e": 27180, "s": 26885, "text": "Following is a simple example to encode a JSON object using Java JSONObject which is a subclass of java.util.HashMap. No ordering is provided. If you need the strict ordering of elements, use JSONValue.toJSONString ( map ) method with ordered map implementation such as java.util.LinkedHashMap." }, { "code": null, "e": 27524, "s": 27180, "text": "import org.json.simple.JSONObject;\n\nclass JsonEncodeDemo {\n\n public static void main(String[] args) {\n JSONObject obj = new JSONObject();\n\n obj.put(\"name\", \"foo\");\n obj.put(\"num\", new Integer(100));\n obj.put(\"balance\", new Double(1000.21));\n obj.put(\"is_vip\", new Boolean(true));\n\n System.out.print(obj);\n }\n}" }, { "code": null, "e": 27610, "s": 27524, "text": "On compiling and executing the above program the following result will be generated −" }, { "code": null, "e": 27672, "s": 27610, "text": "{\"balance\": 1000.21, \"num\":100, \"is_vip\":true, \"name\":\"foo\"}\n" }, { "code": null, "e": 27760, "s": 27672, "text": "Following is another example that shows a JSON object streaming using Java JSONObject −" }, { "code": null, "e": 28231, "s": 27760, "text": "import org.json.simple.JSONObject;\n\nclass JsonEncodeDemo {\n\n public static void main(String[] args) {\n\t\n JSONObject obj = new JSONObject();\n\n obj.put(\"name\",\"foo\");\n obj.put(\"num\",new Integer(100));\n obj.put(\"balance\",new Double(1000.21));\n obj.put(\"is_vip\",new Boolean(true));\n\n StringWriter out = new StringWriter();\n obj.writeJSONString(out);\n \n String jsonText = out.toString();\n System.out.print(jsonText);\n }\n}" }, { "code": null, "e": 28313, "s": 28231, "text": "On compiling and executing the above program, the following result is generated −" }, { "code": null, "e": 28375, "s": 28313, "text": "{\"balance\": 1000.21, \"num\":100, \"is_vip\":true, \"name\":\"foo\"}\n" }, { "code": null, "e": 28570, "s": 28375, "text": "The following example makes use of JSONObject and JSONArray where JSONObject is a java.util.Map and JSONArray is a java.util.List, so you can access them with standard operations of Map or List." }, { "code": null, "e": 29700, "s": 28570, "text": "import org.json.simple.JSONObject;\nimport org.json.simple.JSONArray;\nimport org.json.simple.parser.ParseException;\nimport org.json.simple.parser.JSONParser;\n\nclass JsonDecodeDemo {\n\n public static void main(String[] args) {\n\t\n JSONParser parser = new JSONParser();\n String s = \"[0,{\\\"1\\\":{\\\"2\\\":{\\\"3\\\":{\\\"4\\\":[5,{\\\"6\\\":7}]}}}}]\";\n\t\t\n try{\n Object obj = parser.parse(s);\n JSONArray array = (JSONArray)obj;\n\t\t\t\n System.out.println(\"The 2nd element of array\");\n System.out.println(array.get(1));\n System.out.println();\n\n JSONObject obj2 = (JSONObject)array.get(1);\n System.out.println(\"Field \\\"1\\\"\");\n System.out.println(obj2.get(\"1\")); \n\n s = \"{}\";\n obj = parser.parse(s);\n System.out.println(obj);\n\n s = \"[5,]\";\n obj = parser.parse(s);\n System.out.println(obj);\n\n s = \"[5,,2]\";\n obj = parser.parse(s);\n System.out.println(obj);\n }catch(ParseException pe) {\n\t\t\n System.out.println(\"position: \" + pe.getPosition());\n System.out.println(pe);\n }\n }\n}" }, { "code": null, "e": 29787, "s": 29700, "text": "On compiling and executing the above program, the following result will be generated −" }, { "code": null, "e": 29903, "s": 29787, "text": "The 2nd element of array\n{\"1\":{\"2\":{\"3\":{\"4\":[5,{\"6\":7}]}}}}\n\nField \"1\"\n{\"2\":{\"3\":{\"4\":[5,{\"6\":7}]}}}\n{}\n[5]\n[5,2]\n" }, { "code": null, "e": 30260, "s": 29903, "text": "AJAX is Asynchronous JavaScript and XML, which is used on the client side as a group of interrelated web development techniques, in order to create asynchronous web applications. According to the AJAX model, web applications can send and retrieve data from a server asynchronously without interfering with the display and the behavior of the existing page." }, { "code": null, "e": 30627, "s": 30260, "text": "Many developers use JSON to pass AJAX updates between the client and the server. Websites updating live sports scores can be considered as an example of AJAX. If these scores have to be updated on the website, then they must be stored on the server so that the webpage can retrieve the score when it is required. This is where we can make use of JSON formatted data." }, { "code": null, "e": 30854, "s": 30627, "text": "Any data that is updated using AJAX can be stored using the JSON format on the web server. AJAX is used so that javascript can retrieve these JSON files when necessary, parse them, and perform one of the following operations −" }, { "code": null, "e": 30957, "s": 30854, "text": "Store the parsed values in the variables for further processing before displaying them on the webpage." }, { "code": null, "e": 31060, "s": 30957, "text": "Store the parsed values in the variables for further processing before displaying them on the webpage." }, { "code": null, "e": 31168, "s": 31060, "text": "It directly assigns the data to the DOM elements in the webpage, so that they are displayed on the website." }, { "code": null, "e": 31276, "s": 31168, "text": "It directly assigns the data to the DOM elements in the webpage, so that they are displayed on the website." }, { "code": null, "e": 31424, "s": 31276, "text": "The following code shows JSON with AJAX. Save it as ajax.htm file. Here the loading function loadJSON() is used asynchronously to upload JSON data." }, { "code": null, "e": 33552, "s": 31424, "text": "<html>\n <head>\n <meta content = \"text/html; charset = ISO-8859-1\" http-equiv = \"content-type\">\n\t\t\n <script type = \"application/javascript\">\n function loadJSON() {\n var data_file = \"http://www.tutorialspoint.com/json/data.json\";\n var http_request = new XMLHttpRequest();\n try{\n // Opera 8.0+, Firefox, Chrome, Safari\n http_request = new XMLHttpRequest();\n }catch (e) {\n // Internet Explorer Browsers\n try{\n http_request = new ActiveXObject(\"Msxml2.XMLHTTP\");\n\t\t\t\t\t\n }catch (e) {\n\t\t\t\t\n try{\n http_request = new ActiveXObject(\"Microsoft.XMLHTTP\");\n }catch (e) {\n // Something went wrong\n alert(\"Your browser broke!\");\n return false;\n }\n\t\t\t\t\t\n }\n }\n\t\t\t\n http_request.onreadystatechange = function() {\n\t\t\t\n if (http_request.readyState == 4 ) {\n // Javascript function JSON.parse to parse JSON data\n var jsonObj = JSON.parse(http_request.responseText);\n\n // jsonObj variable now contains the data structure and can\n // be accessed as jsonObj.name and jsonObj.country.\n document.getElementById(\"Name\").innerHTML = jsonObj.name;\n document.getElementById(\"Country\").innerHTML = jsonObj.country;\n }\n }\n\t\t\t\n http_request.open(\"GET\", data_file, true);\n http_request.send();\n }\n\t\t\n </script>\n\t\n <title>tutorialspoint.com JSON</title>\n </head>\n\t\n <body>\n <h1>Cricketer Details</h1>\n\t\t\n <table class = \"src\">\n <tr><th>Name</th><th>Country</th></tr>\n <tr><td><div id = \"Name\">Sachin</div></td>\n <td><div id = \"Country\">India</div></td></tr>\n </table>\n\n <div class = \"central\">\n <button type = \"button\" onclick = \"loadJSON()\">Update Details </button>\n </div>\n\t\t\n </body>\n\t\t\n</html>" }, { "code": null, "e": 33761, "s": 33552, "text": "Given below is the input file data.json, having data in JSON format which will be uploaded asynchronously when we click the Update Detail button. This file is being kept in http://www.tutorialspoint.com/json/" }, { "code": null, "e": 33804, "s": 33761, "text": "{\"name\": \"Brett\", \"country\": \"Australia\"}\n" }, { "code": null, "e": 33897, "s": 33804, "text": "The above HTML code will generate the following screen, where you can check AJAX in action −" } ]

[ { "code": null, "e": 53, "s": 25, "text": "\n19 Feb, 2019" }, { "code": null, "e": 496, "s": 53, "text": "Cookies are small data that are stored on a client side and sent to the client along with server requests. Cookies have various functionality, they can be used for maintaining sessions and adding user-specific features in your web app. For this, we will use cookie-parser module of npm which provides middleware for parsing of cookies.First set your directory of the command prompt to root folder of the project and run the following command:" }, { "code": null, "e": 506, "s": 496, "text": "npm init\n" }, { "code": null, "e": 707, "s": 506, "text": "This will ask you details about your app and finally will create a package.json file.After that run the following command and it will install the required module and add them in your package.json file" }, { "code": null, "e": 749, "s": 707, "text": "npm install express cookie-parser --save\n" }, { "code": null, "e": 785, "s": 749, "text": "package.json file looks like this :" }, { "code": null, "e": 893, "s": 785, "text": "After that we will setup basic express app by writing following code in our app.js file in root directory ." }, { "code": "let express = require('express');//setup express applet app = express() //basic route for homepageapp.get('/', (req, res)=>{res.send('welcome to express app');}); //server listens to port 3000app.listen(3000, (err)=>{if(err)throw err;console.log('listening on port 3000');});", "e": 1173, "s": 893, "text": null }, { "code": null, "e": 1206, "s": 1173, "text": "After that if we run the command" }, { "code": null, "e": 1219, "s": 1206, "text": "node app.js\n" }, { "code": null, "e": 1336, "s": 1219, "text": "It will start our server on port 3000 and if go to the url: localhost:3000, we will get a page showing the message :" }, { "code": null, "e": 1360, "s": 1336, "text": "welcome to express app\n" }, { "code": null, "e": 1430, "s": 1360, "text": "Here is screenshot of localhost:3000 page after starting the server :" }, { "code": null, "e": 1517, "s": 1430, "text": "So until now we have successfully set up our express app now let’s start with cookies." }, { "code": null, "e": 1619, "s": 1517, "text": "For cookies first, we need to import the module in our app.js file and use it like other middlewares." }, { "code": null, "e": 1692, "s": 1619, "text": "\nvar cookieParser = require('cookie-parser');\napp.use(cookieParser());\n\n" }, { "code": null, "e": 1840, "s": 1692, "text": "Let’s say we have a user and we want to add that user data in the cookie then we have to add that cookie to the response using the following code :" }, { "code": null, "e": 1886, "s": 1840, "text": "res.cookie(name_of_cookie, value_of_cookie);\n" }, { "code": null, "e": 1935, "s": 1886, "text": "This can be explained by the following example :" }, { "code": "let express = require('express');let cookieParser = require('cookie-parser');//setup express applet app = express() app.use(cookieParser()); //basic route for homepageapp.get('/', (req, res)=>{res.send('welcome to express app');}); //JSON object to be added to cookielet users = {name : \"Ritik\",Age : \"18\"} //Route for adding cookieapp.get('/setuser', (req, res)=>{res.cookie(\"userData\", users);res.send('user data added to cookie');}); //Iterate users data from cookieapp.get('/getuser', (req, res)=>{//shows all the cookiesres.send(req.cookies);}); //server listens to port 3000app.listen(3000, (err)=>{if(err)throw err;console.log('listening on port 3000');});", "e": 2607, "s": 1935, "text": null }, { "code": null, "e": 2741, "s": 2607, "text": "So if we restart our server and make a get request to the route: localhost:3000/getuser before setting the cookies it is as follows :" }, { "code": null, "e": 2852, "s": 2741, "text": "After making a request to localhost:3000/setuser it will add user data to cookie and gives output as follows :" }, { "code": null, "e": 3119, "s": 2852, "text": "Now if we again make a request to localhost:3000/getuser as this route is iterating user data from cookies using req.cookies so output will be as follows :If we have multiple objects pushed in cookies then we can access specific cookie using req.cookie.cookie_name ." }, { "code": null, "e": 3402, "s": 3119, "text": "Adding Cookie with expiration TimeWe can add a cookie with some expiration time i.e. after that time cookies will be destroyed automatically. For this, we need to pass an extra property to the res.cookie object while setting the cookies.It can be done by using any of the two ways :" }, { "code": null, "e": 3521, "s": 3402, "text": "\n//Expires after 400000 ms from the time it is set.\nres.cookie(cookie_name, 'value', {expire: 400000 + Date.now()});\n\n" }, { "code": null, "e": 3635, "s": 3521, "text": "\n//It also expires after 400000 ms from the time it is set.\nres.cookie(cookie_name, 'value', {maxAge: 360000});\n\n" }, { "code": null, "e": 3702, "s": 3635, "text": "Destroy the cookies :We can destroy cookies using following code :" }, { "code": null, "e": 3732, "s": 3702, "text": "res.clearCookie(cookieName);\n" }, { "code": null, "e": 3837, "s": 3732, "text": "Now let us make a logout route which will destroy user data from the cookie. Now our app.js looks like :" }, { "code": "let express = require('express');let cookieParser = require('cookie-parser');//setup express applet app = express() app.use(cookieParser()); //basic route for homepageapp.get('/', (req, res)=>{res.send('welcome to express app');}); //JSON object to be added to cookielet users = {name : \"Ritik\",Age : \"18\"} //Route for adding cookieapp.get('/setuser', (req, res)=>{res.cookie(\"userData\", users);res.send('user data added to cookie');}); //Iterate users data from cookieapp.get('/getuser', (req, res)=>{//shows all the cookiesres.send(req.cookies);}); //Route for destroying cookieapp.get('/logout', (req, res)=>{//it will clear the userData cookieres.clearCookie('userData');res.send('user logout successfully');}); //server listens to port 3000app.listen(3000, (err)=>{if(err)throw err;console.log('listening on port 3000');});", "e": 4677, "s": 3837, "text": null }, { "code": null, "e": 4765, "s": 4677, "text": "For destroying the cookie make get request to following link: user logged out[/caption]" }, { "code": null, "e": 4901, "s": 4765, "text": "To check whether cookies are destroyed or not make a get request to localhost:3000/getuserand you will get an empty user cookie object." }, { "code": null, "e": 5141, "s": 4901, "text": "This is about basic use of HTTP cookies using cookie-parser middleware. Cookies can be used in many ways like maintaining sessions and providing each user a different view of the website based on their previous transactions on the website." }, { "code": null, "e": 5157, "s": 5141, "text": "JavaScript-Misc" }, { "code": null, "e": 5165, "s": 5157, "text": "Node.js" }, { "code": null, "e": 5176, "s": 5165, "text": "JavaScript" }, { "code": null, "e": 5193, "s": 5176, "text": "Web Technologies" }, { "code": null, "e": 5291, "s": 5193, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 5352, "s": 5291, "text": "Difference between var, let and const keywords in JavaScript" }, { "code": null, "e": 5424, "s": 5352, "text": "Differences between Functional Components and Class Components in React" }, { "code": null, "e": 5464, "s": 5424, "text": "Remove elements from a JavaScript Array" }, { "code": null, "e": 5516, "s": 5464, "text": "How to append HTML code to a div using JavaScript ?" }, { "code": null, "e": 5557, "s": 5516, "text": "Difference Between PUT and PATCH Request" }, { "code": null, "e": 5619, "s": 5557, "text": "Top 10 Projects For Beginners To Practice HTML and CSS Skills" }, { "code": null, "e": 5652, "s": 5619, "text": "Installation of Node.js on Linux" }, { "code": null, "e": 5713, "s": 5652, "text": "Difference between var, let and const keywords in JavaScript" }, { "code": null, "e": 5763, "s": 5713, "text": "How to insert spaces/tabs in text using HTML/CSS?" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n26 Apr, 2021" }, { "code": null, "e": 197, "s": 28, "text": "To know what a composite key is we need to have the knowledge of what a primary key is, a primary key is a column that has a unique and not null value in an SQL table. " }, { "code": null, "e": 366, "s": 197, "text": "Now a composite key is also a primary key, but the difference is that it is made by the combination of more than one column to identify the particular row in the table." }, { "code": null, "e": 381, "s": 366, "text": "Composite Key:" }, { "code": null, "e": 791, "s": 381, "text": "A composite key is made by the combination of two or more columns in a table that can be used to uniquely identify each row in the table when the columns are combined uniqueness of a row is guaranteed, but when it is taken individually it does not guarantee uniqueness, or it can also be understood as a primary key made by the combination of two or more attributes to uniquely identify every row in a table. " }, { "code": null, "e": 798, "s": 791, "text": "Note: " }, { "code": null, "e": 883, "s": 798, "text": " A composite key can also be made by the combination of more than one candidate key." }, { "code": null, "e": 915, "s": 883, "text": "A composite key cannot be null." }, { "code": null, "e": 924, "s": 915, "text": "Example:" }, { "code": null, "e": 945, "s": 924, "text": "Creating a database:" }, { "code": null, "e": 960, "s": 945, "text": "CREATE School;" }, { "code": null, "e": 976, "s": 960, "text": "Using database:" }, { "code": null, "e": 988, "s": 976, "text": "USE School;" }, { "code": null, "e": 1025, "s": 988, "text": "Creating table with a composite key:" }, { "code": null, "e": 1179, "s": 1025, "text": "CREATE TABLE student\n(rollNumber INT, \nname VARCHAR(30), \nclass VARCHAR(30), \nsection VARCHAR(1), \nmobile VARCHAR(10),\nPRIMARY KEY (rollNumber, mobile));" }, { "code": null, "e": 1380, "s": 1179, "text": "In this example, we have made the composite key as the combination of two columns i.e. rollNumber and mobile because all the rows of the table student can be uniquely identified by this composite key." }, { "code": null, "e": 1412, "s": 1380, "text": "Inserting records in the table:" }, { "code": null, "e": 1861, "s": 1412, "text": "INSERT INTO student (rollNumber, name, class, section, mobile) \nVALUES (1, \"AMAN\",\"FOURTH\", \"B\", \"9988774455\");\nINSERT INTO student (rollNumber, name, class, section, mobile) \nVALUES (2, \"JOHN\",\"FIRST\", \"A\", \"9988112233\");\nINSERT INTO student (rollNumber, name, class, section, mobile) \nVALUES (3, \"TOM\",\"FOURTH\", \"B\", \"9988777755\");\nINSERT INTO student (rollNumber, name, class, section, mobile) \nVALUES (4, \"RICHARD\",\"SECOND\", \"C\", \"9955663322\");" }, { "code": null, "e": 1883, "s": 1861, "text": "Querying the records:" }, { "code": null, "e": 1906, "s": 1883, "text": "SELECT * FROM student;" }, { "code": null, "e": 1915, "s": 1906, "text": "OUTPUT: " }, { "code": null, "e": 1924, "s": 1915, "text": "DBMS-SQL" }, { "code": null, "e": 1931, "s": 1924, "text": "Picked" }, { "code": null, "e": 1936, "s": 1931, "text": "DBMS" }, { "code": null, "e": 1940, "s": 1936, "text": "SQL" }, { "code": null, "e": 1945, "s": 1940, "text": "DBMS" }, { "code": null, "e": 1949, "s": 1945, "text": "SQL" }, { "code": null, "e": 2047, "s": 1949, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 2058, "s": 2047, "text": "CTE in SQL" }, { "code": null, "e": 2111, "s": 2058, "text": "Difference between Clustered and Non-clustered index" }, { "code": null, "e": 2169, "s": 2111, "text": "Introduction of DBMS (Database Management System) | Set 1" }, { "code": null, "e": 2192, "s": 2169, "text": "Introduction of B-Tree" }, { "code": null, "e": 2204, "s": 2192, "text": "SQL | Views" }, { "code": null, "e": 2248, "s": 2204, "text": "How to find Nth highest salary from a table" }, { "code": null, "e": 2269, "s": 2248, "text": "SQL | ALTER (RENAME)" }, { "code": null, "e": 2280, "s": 2269, "text": "CTE in SQL" }, { "code": null, "e": 2346, "s": 2280, "text": "How to Update Multiple Columns in Single Update Statement in SQL?" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n18 May, 2022" }, { "code": null, "e": 635, "s": 52, "text": "To create a search bar in the navigation bar is easy, just like creating another option in the navbar that will search the database. You need to be careful about the timing of placing the search bar. Make sure separately placed in the navbar. To create a navbar containing a search bar you will need HTML and CSS. The below explanation will guide you stepwise on how to create a search bar. This article contains 2 sections in the first section we will attach the CDN link for icon and will make a basic structure. The second section will design the navbar and the search bar in it." }, { "code": null, "e": 829, "s": 635, "text": "Creating Structure: In this section, we will just create the basic site structure and also attach the CDN link of the Font-Awesome for the icons which will be used as a search icon in the bar. " }, { "code": null, "e": 878, "s": 829, "text": "CDN links for the Icons from the Font Awesome: " }, { "code": null, "e": 992, "s": 878, "text": "<link rel=”stylesheet” href=”https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css”>" }, { "code": null, "e": 1207, "s": 992, "text": "HTML code: The HTML code is used to create a structure of navigation bar containing search bar. Since it does not contain CSS so it is just a simple structure. We will use some CSS property to make it attractive. " }, { "code": null, "e": 1212, "s": 1207, "text": "html" }, { "code": "<!DOCTYPE html><html> <head> <title> Create a Search Bar using HTML and CSS </title> <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"></head> <body> <!-- Navbar items --> <div id=\"navlist\"> <a href=\"#\">Home</a> <a href=\"#\">Our Products</a> <a href=\"#\">Careers</a> <a href=\"#\">About Us</a> <a href=\"#\">Contact Us</a> <!-- search bar right align --> <div class=\"search\"> <form action=\"#\"> <input type=\"text\" placeholder=\" Search Courses\" name=\"search\"> <button> <i class=\"fa fa-search\" style=\"font-size: 18px;\"> </i> </button> </form> </div> </div> <!-- logo with tag --> <div class=\"content\"> <h1 style=\"color:green; padding-top:40px;\"> GeeksforGeeks </h1> <b> A Computer Science Portal for Geeks </b> <p> How many times were you frustrated while looking out for a good collection of programming/algorithm/interview questions? What did you expect and what did you get? This portal has been created to provide well written, well thought and well explained solutions for selected questions. </p> </div></body> </html> ", "e": 2716, "s": 1212, "text": null }, { "code": null, "e": 2954, "s": 2716, "text": "Designing Structure: In the previous section, we created the structure of the basic site where we are going to use the Navigation bar with the search bar with the icon. We will design the structure and attach the icons for each navbar. " }, { "code": null, "e": 3100, "s": 2954, "text": "CSS code: CSS code is used to make the attractive website. This CSS property is used to make the style on navigation bar containing search bar . " }, { "code": null, "e": 3105, "s": 3100, "text": "html" }, { "code": "<style> /* styling navlist */ #navlist { background-color: #0074D9; position: absolute; width: 100%; } /* styling navlist anchor element */ #navlist a { float:left; display: block; color: #f2f2f2; text-align: center; padding: 12px; text-decoration: none; font-size: 15px; } .navlist-right{ float:right; } /* hover effect of navlist anchor element */ #navlist a:hover { background-color: #ddd; color: black; } /* styling search bar */ .search input[type=text]{ width:300px; height:25px; border-radius:25px; border: none; } .search{ float:right; margin:7px; } .search button{ background-color: #0074D9; color: #f2f2f2; float: right; padding: 5px 10px; margin-right: 16px; font-size: 12px; border: none; cursor: pointer; }</style>", "e": 4127, "s": 3105, "text": null }, { "code": null, "e": 4296, "s": 4127, "text": "Combining HTML and CSS Code: This is the final code that is the combination of the above two sections. It will be displaying the navigation bar containing search bar. " }, { "code": null, "e": 4301, "s": 4296, "text": "html" }, { "code": "<!DOCTYPE html><html> <head> <title> Create a Search Bar using HTML and CSS </title> <meta name=\"viewport\" content=\"width=device-width, initial-scale=1\"> <link rel=\"stylesheet\" href=\"https://cdnjs.cloudflare.com/ajax/libs/font-awesome/4.7.0/css/font-awesome.min.css\"> <style> /* styling navlist */ #navlist { background-color: #0074D9; position: absolute; width: 100%; } /* styling navlist anchor element */ #navlist a { float:left; display: block; color: #f2f2f2; text-align: center; padding: 12px; text-decoration: none; font-size: 15px; } .navlist-right{ float:right; } /* hover effect of navlist anchor element */ #navlist a:hover { background-color: #ddd; color: black; } /* styling search bar */ .search input[type=text]{ width:300px; height:25px; border-radius:25px; border: none; } .search{ float:right; margin:7px; } .search button{ background-color: #0074D9; color: #f2f2f2; float: right; padding: 5px 10px; margin-right: 16px; font-size: 12px; border: none; cursor: pointer; } </style></head> <body> <!-- Navbar items --> <div id=\"navlist\"> <a href=\"#\">Home</a> <a href=\"#\">Our Products</a> <a href=\"#\">Careers</a> <a href=\"#\">About Us</a> <a href=\"#\">Contact Us</a> <!-- search bar right align --> <div class=\"search\"> <form action=\"#\"> <input type=\"text\" placeholder=\" Search Courses\" name=\"search\"> <button> <i class=\"fa fa-search\" style=\"font-size: 18px;\"> </i> </button> </form> </div> </div> <!-- logo with tag --> <div class=\"content\"> <h1 style=\"color:green; padding-top:40px;\"> GeeksforGeeks </h1> <b> A Computer Science Portal for Geeks </b> <p> How many times were you frustrated while looking out for a good collection of programming/algorithm/interview questions? What did you expect and what did you get? This portal has been created to provide well written, well thought and well explained solutions for selected questions. </p> </div></body> </html> ", "e": 7154, "s": 4301, "text": null }, { "code": null, "e": 7163, "s": 7154, "text": "Output: " }, { "code": null, "e": 7393, "s": 7163, "text": "HTML and CSS both are foundation of webpages. HTML is used for webpage development by structuring websites, web apps and CSS used for styling websites and webapps. You can learn more about HTML and CSS from the links given below:" }, { "code": null, "e": 7425, "s": 7393, "text": "HTML Tutorial and HTML Examples" }, { "code": null, "e": 7455, "s": 7425, "text": "CSS Tutorial and CSS Examples" }, { "code": null, "e": 7472, "s": 7455, "text": "arorakashish0911" }, { "code": null, "e": 7489, "s": 7472, "text": "hardikkoriintern" }, { "code": null, "e": 7498, "s": 7489, "text": "CSS-Misc" }, { "code": null, "e": 7508, "s": 7498, "text": "HTML-Misc" }, { "code": null, "e": 7512, "s": 7508, "text": "CSS" }, { "code": null, "e": 7517, "s": 7512, "text": "HTML" }, { "code": null, "e": 7534, "s": 7517, "text": "Web Technologies" }, { "code": null, "e": 7561, "s": 7534, "text": "Web technologies Questions" }, { "code": null, "e": 7566, "s": 7561, "text": "HTML" }, { "code": null, "e": 7664, "s": 7566, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 7712, "s": 7664, "text": "How to update Node.js and NPM to next version ?" }, { "code": null, "e": 7774, "s": 7712, "text": "Top 10 Projects For Beginners To Practice HTML and CSS Skills" }, { "code": null, "e": 7824, "s": 7774, "text": "How to insert spaces/tabs in text using HTML/CSS?" }, { "code": null, "e": 7882, "s": 7824, "text": "How to create footer to stay at the bottom of a Web page?" }, { "code": null, "e": 7932, "s": 7882, "text": "CSS to put icon inside an input element in a form" }, { "code": null, "e": 7980, "s": 7932, "text": "How to update Node.js and NPM to next version ?" }, { "code": null, "e": 8042, "s": 7980, "text": "Top 10 Projects For Beginners To Practice HTML and CSS Skills" }, { "code": null, "e": 8092, "s": 8042, "text": "How to insert spaces/tabs in text using HTML/CSS?" }, { "code": null, "e": 8116, "s": 8092, "text": "REST API (Introduction)" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n24 Jul, 2017" }, { "code": null, "e": 456, "s": 52, "text": "Competitive programming often involves computation of Least Common Multiple (LCM) of two numbers. One way of doing that is using boost::math::lcm(), which we discussed in the post – Inbuilt function for calculating LCM in C++ .But, recently, C++ in its latest version C++17 has also included another in-built function for computation of LCM, std::lcm(). This function is defined inside the header file ." }, { "code": null, "e": 464, "s": 456, "text": "Syntax:" }, { "code": null, "e": 583, "s": 464, "text": "std::lcm (m, n)\nArguments: m, n\nReturns: 0, if either of m or n are 0\n else, returns lcm of mod(m) and mod(n)\n" }, { "code": null, "e": 734, "s": 583, "text": "Remember, since this feature has been defined in latest version of C++, so using this function in compilers not supporting C++17, will throw an error." }, { "code": "// CPP program to illustrate// std::lcm function of C++#include <iostream>#include <numeric> using namespace std; int main(){ cout << \"LCM(10, 20) = \" << std::lcm(10, 20) << endl; return 0;}", "e": 941, "s": 734, "text": null }, { "code": null, "e": 949, "s": 941, "text": "Output:" }, { "code": null, "e": 953, "s": 949, "text": "20\n" }, { "code": null, "e": 971, "s": 953, "text": "Important Points:" }, { "code": null, "e": 1260, "s": 971, "text": "This function works on positive numbers, and if any argument is negative, it is firstly converted to its modulus, and then calculates the LCM.Also, it works only on integer data type , and if any other data type like char, double, is provided in its argument, then it will throw an error." }, { "code": null, "e": 1403, "s": 1260, "text": "This function works on positive numbers, and if any argument is negative, it is firstly converted to its modulus, and then calculates the LCM." }, { "code": null, "e": 1550, "s": 1403, "text": "Also, it works only on integer data type , and if any other data type like char, double, is provided in its argument, then it will throw an error." }, { "code": null, "e": 1561, "s": 1550, "text": "Reference:" }, { "code": null, "e": 1612, "s": 1561, "text": "C++ Weekly – Ep 67 – C++17’s std::gcd and std::lcm" }, { "code": null, "e": 1663, "s": 1612, "text": "C++ Weekly – Ep 67 – C++17’s std::gcd and std::lcm" }, { "code": null, "e": 1966, "s": 1663, "text": "This article is contributed by Mrigendra Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to [email protected]. See your article appearing on the GeeksforGeeks main page and help other Geeks." }, { "code": null, "e": 2091, "s": 1966, "text": "Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above." }, { "code": null, "e": 2112, "s": 2091, "text": "cpp-numerics-library" }, { "code": null, "e": 2116, "s": 2112, "text": "LCM" }, { "code": null, "e": 2120, "s": 2116, "text": "STL" }, { "code": null, "e": 2124, "s": 2120, "text": "C++" }, { "code": null, "e": 2128, "s": 2124, "text": "STL" }, { "code": null, "e": 2132, "s": 2128, "text": "CPP" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n24 Jul, 2020" }, { "code": null, "e": 132, "s": 28, "text": "Basic Example of ReferenceError – Invalid assignment left-hand side, run the code and check the console" }, { "code": null, "e": 141, "s": 132, "text": "Example:" }, { "code": null, "e": 152, "s": 141, "text": "Javascript" }, { "code": "<script> if (Math.PI = 10 || Math.PI = 5) { document.write(\"Inside Loop\"); }</script>", "e": 252, "s": 152, "text": null }, { "code": null, "e": 260, "s": 252, "text": "Output:" }, { "code": null, "e": 313, "s": 260, "text": "ReferenceError: Invalid left-hand side in assignment" }, { "code": null, "e": 499, "s": 313, "text": "This JavaScript exception invalid assignment left-hand side occurs if there is a wrong assignment somewhere in code. A single “=” sign instead of “==” or “===” is an Invalid assignment." }, { "code": null, "e": 508, "s": 499, "text": "Message:" }, { "code": null, "e": 559, "s": 508, "text": "ReferenceError: invalid assignment left-hand side\n" }, { "code": null, "e": 571, "s": 559, "text": "Error Type:" }, { "code": null, "e": 587, "s": 571, "text": "ReferenceError\n" }, { "code": null, "e": 698, "s": 587, "text": "Cause of the error: There may be a misunderstanding between the assignment operator and a comparison operator." }, { "code": null, "e": 782, "s": 698, "text": "Example 1: In this example, “=” operator is misused as “==”, So the error occurred." }, { "code": null, "e": 787, "s": 782, "text": "HTML" }, { "code": "<!DOCTYPE html><html> <head> </head> <body style=\"text-align: center;\"> <h1 style=\"color: green;\"> GeeksforGeeks </h1> <p> JavaScript ReferenceError - Invalid assignment left-hand side </p> <button onclick=\"Geeks();\"> click here </button> <p id=\"GFG_DOWN\"></p> <script> var el_down = document.getElementById(\"GFG_DOWN\"); function Geeks() { try { if ((Math.PI = 10 || Math.PI = 5)) { document.write(\"Inside Loop\"); } el_down.innerHTML = \"'Invalid assignment left-hand side'\" + \" error has not occurred\"; } catch (e) { el_down.innerHTML = \"'Invalid assignment left-hand side'\" + \"error has occurred\"; } } </script> </body></html>", "e": 1801, "s": 787, "text": null }, { "code": null, "e": 1809, "s": 1801, "text": "Output:" }, { "code": null, "e": 1913, "s": 1809, "text": "Example 2: In this example, the + operator is used with the declaration, So the error has not occurred." }, { "code": null, "e": 1918, "s": 1913, "text": "HTML" }, { "code": "<!DOCTYPE HTML><html> <head> </head> <body style=\"text-align:center;\"> <h1 style=\"color:green;\"> GeeksforGeeks </h1> <p> JavaScript ReferenceError - Invalid assignment left-hand side </p> <button onclick = \"Geeks();\"> click here </button> <p id=\"GFG_DOWN\"> </p> <script> var el_down = document.getElementById(\"GFG_DOWN\"); function Geeks() { try { var str = 'Hello, ' + 'Geeks'; // Error Here el_down.innerHTML = \"'Invalid assignment left-hand side'\"+ \"error has not occurred\"; } catch(e) { el_down.innerHTML = \"'Invalid assignment left-hand side'\"+ \"error has occurred\"; } } </script> </body> </html>", "e": 2786, "s": 1918, "text": null }, { "code": null, "e": 2795, "s": 2786, "text": "Output: " }, { "code": null, "e": 2813, "s": 2795, "text": "JavaScript-Errors" }, { "code": null, "e": 2824, "s": 2813, "text": "JavaScript" }, { "code": null, "e": 2841, "s": 2824, "text": "Web Technologies" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n15 Feb, 2022" }, { "code": null, "e": 300, "s": 52, "text": "SDL is Simple DirectMedia Layer.It is a cross-platform development library designed to provide low level access to audio, keyboard, mouse, joystick, and graphics hardware via OpenGL and Direct3D.It can be used to make animations and video games. " }, { "code": null, "e": 422, "s": 300, "text": "It basically provides a set of APIs to interact with various devices like graphics hardware, audio, keyboard, mouse, etc." }, { "code": null, "e": 529, "s": 422, "text": "It is written in C programming language and works with C++ and various other languages like c# and python." }, { "code": null, "e": 611, "s": 529, "text": "Installation on Linux ( For OS which uses the apt package manager eg : Ubuntu ): " }, { "code": null, "e": 958, "s": 611, "text": "Run command sudo apt-get update on your terminal.Run command sudo apt-get install clang on your terminal.Run command sudo apt-get install libsdl2-2.0-0 libsdl2-dbg libsdl2-dev libsdl2-image-2.0-0 libsdl2-image-dbg libsdl2-image-dev on your terminal.We need to make a Makefile.So open a text editor of your choice and start writing the code below." }, { "code": null, "e": 1008, "s": 958, "text": "Run command sudo apt-get update on your terminal." }, { "code": null, "e": 1065, "s": 1008, "text": "Run command sudo apt-get install clang on your terminal." }, { "code": null, "e": 1210, "s": 1065, "text": "Run command sudo apt-get install libsdl2-2.0-0 libsdl2-dbg libsdl2-dev libsdl2-image-2.0-0 libsdl2-image-dbg libsdl2-image-dev on your terminal." }, { "code": null, "e": 1308, "s": 1210, "text": "We need to make a Makefile.So open a text editor of your choice and start writing the code below." }, { "code": null, "e": 2174, "s": 1308, "text": "# A simple Makefile for compiling small SDL projects\n\n# set the compiler\nCC := clang\n\n# set the compiler flags\nCFLAGS := `sdl2-config --libs --cflags` -ggdb3 -O0 --std=c99 -Wall -lSDL2_image -lm\n# add header files here\nHDRS :=\n\n# add source files here\nSRCS := #file-name.c\n\n# generate names of object files\nOBJS := $(SRCS:.c=.o)\n\n# name of executable\nEXEC := #name your executable file\n\n# default recipe\nall: $(EXEC)\n \nshowfont: showfont.c Makefile\n $(CC) -o $@ [email protected] $(CFLAGS) $(LIBS)\n\nglfont: glfont.c Makefile\n $(CC) -o $@ [email protected] $(CFLAGS) $(LIBS)\n\n# recipe for building the final executable\n$(EXEC): $(OBJS) $(HDRS) Makefile\n $(CC) -o $@ $(OBJS) $(CFLAGS)\n\n# recipe for building object files\n#$(OBJS): $(@:.o=.c) $(HDRS) Makefile\n# $(CC) -o $@ $(@:.o=.c) -c $(CFLAGS)\n\n# recipe to clean the workspace\nclean:\n rm -f $(EXEC) $(OBJS)\n\n.PHONY: all clean" }, { "code": null, "e": 2190, "s": 2174, "text": "Header Files: " }, { "code": null, "e": 2194, "s": 2190, "text": "C++" }, { "code": "// for initializing and shutdown functions#include <SDL2/SDL.h> // for rendering images and graphics on screen#include <SDL2/SDL_image.h> // for using SDL_Delay() functions#include <SDL2/SDL_timer.h>", "e": 2394, "s": 2194, "text": null }, { "code": null, "e": 2411, "s": 2394, "text": "Initialization: " }, { "code": null, "e": 2415, "s": 2411, "text": "C++" }, { "code": "#include <SDL2/SDL.h>#include <SDL2/SDL_image.h>#include <SDL2/SDL_timer.h> int main(int argc, char *argv[]){ // returns zero on success else non-zero if (SDL_Init(SDL_INIT_EVERYTHING) != 0) { printf(\"error initializing SDL: %s\\n\", SDL_GetError()); } SDL_Window* win = SDL_CreateWindow(\"GAME\", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1000, 1000, 0); while (1) ; return 0;}", "e": 2944, "s": 2415, "text": null }, { "code": null, "e": 3002, "s": 2944, "text": "That will create a empty window on your screen. Output: " }, { "code": null, "e": 3073, "s": 3002, "text": "We will write a simple program to explain rendering and I/O handling: " }, { "code": null, "e": 3077, "s": 3073, "text": "C++" }, { "code": "#include <SDL2/SDL.h>#include <SDL2/SDL_image.h>#include <SDL2/SDL_timer.h> int main(int argc, char *argv[]){ // returns zero on success else non-zero if (SDL_Init(SDL_INIT_EVERYTHING) != 0) { printf(\"error initializing SDL: %s\\n\", SDL_GetError()); } SDL_Window* win = SDL_CreateWindow(\"GAME\", // creates a window SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 1000, 1000, 0); // triggers the program that controls // your graphics hardware and sets flags Uint32 render_flags = SDL_RENDERER_ACCELERATED; // creates a renderer to render our images SDL_Renderer* rend = SDL_CreateRenderer(win, -1, render_flags); // creates a surface to load an image into the main memory SDL_Surface* surface; // please provide a path for your image surface = IMG_Load(\"path\"); // loads image to our graphics hardware memory. SDL_Texture* tex = SDL_CreateTextureFromSurface(rend, surface); // clears main-memory SDL_FreeSurface(surface); // let us control our image position // so that we can move it with our keyboard. SDL_Rect dest; // connects our texture with dest to control position SDL_QueryTexture(tex, NULL, NULL, &dest.w, &dest.h); // adjust height and width of our image box. dest.w /= 6; dest.h /= 6; // sets initial x-position of object dest.x = (1000 - dest.w) / 2; // sets initial y-position of object dest.y = (1000 - dest.h) / 2; // controls animation loop int close = 0; // speed of box int speed = 300; // animation loop while (!close) { SDL_Event event; // Events management while (SDL_PollEvent(&event)) { switch (event.type) { case SDL_QUIT: // handling of close button close = 1; break; case SDL_KEYDOWN: // keyboard API for key pressed switch (event.key.keysym.scancode) { case SDL_SCANCODE_W: case SDL_SCANCODE_UP: dest.y -= speed / 30; break; case SDL_SCANCODE_A: case SDL_SCANCODE_LEFT: dest.x -= speed / 30; break; case SDL_SCANCODE_S: case SDL_SCANCODE_DOWN: dest.y += speed / 30; break; case SDL_SCANCODE_D: case SDL_SCANCODE_RIGHT: dest.x += speed / 30; break; default: break; } } } // right boundary if (dest.x + dest.w > 1000) dest.x = 1000 - dest.w; // left boundary if (dest.x < 0) dest.x = 0; // bottom boundary if (dest.y + dest.h > 1000) dest.y = 1000 - dest.h; // upper boundary if (dest.y < 0) dest.y = 0; // clears the screen SDL_RenderClear(rend); SDL_RenderCopy(rend, tex, NULL, &dest); // triggers the double buffers // for multiple rendering SDL_RenderPresent(rend); // calculates to 60 fps SDL_Delay(1000 / 60); } // destroy texture SDL_DestroyTexture(tex); // destroy renderer SDL_DestroyRenderer(rend); // destroy window SDL_DestroyWindow(win); // close SDL SDL_Quit(); return 0;}", "e": 6603, "s": 3077, "text": null }, { "code": null, "e": 6717, "s": 6603, "text": "That will render a image on the window which can be controlled via your keyboard up, down, left, right. Output: " }, { "code": null, "e": 6796, "s": 6717, "text": "References: https://www.libsdl.org/, https://github.com/vivek9236/rocket_game " }, { "code": null, "e": 6808, "s": 6796, "text": "roshanr2001" }, { "code": null, "e": 6820, "s": 6808, "text": "bensonmuite" }, { "code": null, "e": 6830, "s": 6820, "text": "kalrap615" }, { "code": null, "e": 6845, "s": 6830, "text": "varshagumber28" }, { "code": null, "e": 6859, "s": 6845, "text": "sumitgumber28" }, { "code": null, "e": 6868, "s": 6859, "text": "rkbhola5" }, { "code": null, "e": 6875, "s": 6868, "text": "OpenGL" }, { "code": null, "e": 6886, "s": 6875, "text": "C Language" }, { "code": null, "e": 6890, "s": 6886, "text": "C++" }, { "code": null, "e": 6898, "s": 6890, "text": "Project" }, { "code": null, "e": 6902, "s": 6898, "text": "CPP" } ]

[ { "code": null, "e": 54, "s": 26, "text": "\n04 Nov, 2019" }, { "code": null, "e": 181, "s": 54, "text": "To convert a color image to Grayscale image using OpenCV, we read the image into BufferedImage and convert it into Mat Object." }, { "code": null, "e": 288, "s": 181, "text": "Syntax:\nFile input = new File(\"digital_image_processing.jpg\");\nBufferedImage image = ImageIO.read(input);\n" }, { "code": null, "e": 389, "s": 288, "text": "To transform the image from RGB to Grayscale format by using method cvtColor() in the Imgproc class." }, { "code": null, "e": 620, "s": 389, "text": "Syntax:Imgproc.cvtColor(source mat, destination mat1, Imgproc.COLOR_RGB2GRAY);Parameters: The method cvtColor() takes three parameters which are the source image matrix, the destination image matrix, and the color conversion type." }, { "code": "// Java program to convert a color image to gray scaleimport org.opencv.core.Core;import org.opencv.core.Mat;import org.opencv.imgcodecs.Imgcodecs;import org.opencv.imgproc.Imgproc; public class GeeksforGeeks { public static void main(String args[]) throws Exception { // To load OpenCV core library System.loadLibrary(Core.NATIVE_LIBRARY_NAME); String input = \"C:/opencv/GeeksforGeeks.jpg\"; // To Read the image Mat source = Imgcodecs.imread(input); // Creating the empty destination matrix Mat destination = new Mat(); // Converting the image to gray scale and // saving it in the dst matrix Imgproc.cvtColor(source, destination, Imgproc.COLOR_RGB2GRAY); // Writing the image Imgcodecs.imwrite(\"C:/opencv/GeeksforGeeks.jpg\", destination); System.out.println(\"The image is successfully to Grayscale\"); }}", "e": 1539, "s": 620, "text": null }, { "code": null, "e": 1562, "s": 1539, "text": "Input : \n\n\nOutput :\n\n\n" }, { "code": null, "e": 1573, "s": 1562, "text": "nidhi_biet" }, { "code": null, "e": 1590, "s": 1573, "text": "Image-Processing" }, { "code": null, "e": 1595, "s": 1590, "text": "Java" }, { "code": null, "e": 1600, "s": 1595, "text": "Java" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n26 Nov, 2020" }, { "code": null, "e": 648, "s": 28, "text": "We might sometimes need a tidy/long-form of data for data analysis. So, in python’s library Pandas there are a few ways to reshape a dataframe which is in wide form into a dataframe in long/tidy form. Here, we will discuss converting data from a wide form into a long-form using the pandas function stack(). stack() mainly stacks the specified index from column to index form. And it returns a reshaped DataFrame or even a series having a multi-level index with one or more new inner-most levels compared to the current DataFrame, these levels are created by pivoting the columns of the current dataframe and outputs a:" }, { "code": null, "e": 691, "s": 648, "text": "Series: if the columns have a single level" }, { "code": null, "e": 811, "s": 691, "text": "DataFrame: if the columns have multiple levels, then the new index level(s) is (are) taken from the specified level(s)." }, { "code": null, "e": 859, "s": 811, "text": "Syntax: DataFrame.stack(level=- 1, dropna=True)" }, { "code": null, "e": 872, "s": 859, "text": "Parameters –" }, { "code": null, "e": 1023, "s": 872, "text": "level : It levels to stack from the column axis to the index axis. It either takes an int, string or list as input value. And by default is set to -1." }, { "code": null, "e": 1187, "s": 1023, "text": "dropna : It asks whether to drop the rows into the resulting dataFrame or series in case they don’t have any values. It is of bool type and by default set to True." }, { "code": null, "e": 1226, "s": 1187, "text": "Returns a stacked DataFrame or series." }, { "code": null, "e": 1251, "s": 1226, "text": "Now, let’s start coding!" }, { "code": null, "e": 1260, "s": 1251, "text": "Case 1#:" }, { "code": null, "e": 1340, "s": 1260, "text": "Firstly, let’s start with a simple single-level column and a wide form of data." }, { "code": null, "e": 1348, "s": 1340, "text": "Python3" }, { "code": "import pandas as pd # Single level columnsdf_single_level_cols = pd.DataFrame([[74, 80], [72, 85]], index=['Deepa', 'Balram'], columns=['Maths', 'Computer'])print(df_single_level_cols)", "e": 1604, "s": 1348, "text": null }, { "code": null, "e": 1611, "s": 1604, "text": "Output" }, { "code": null, "e": 1731, "s": 1611, "text": "Now, after we apply the stack() function Then we will get a dataframe with a single level column axis returns a Series:" }, { "code": null, "e": 1739, "s": 1731, "text": "Python3" }, { "code": "# Single level with stack()df_single_level_cols.stack()", "e": 1795, "s": 1739, "text": null }, { "code": null, "e": 1803, "s": 1795, "text": "Output:" }, { "code": null, "e": 1812, "s": 1803, "text": "Case 2#:" }, { "code": null, "e": 1856, "s": 1812, "text": "Let’s now try out with multi-level columns." }, { "code": null, "e": 1864, "s": 1856, "text": "Python3" }, { "code": "# Simple Multi-level columnsmulticol1 = pd.MultiIndex.from_tuples([('Science', 'Physics'), ('Science', 'Chemistry')]) df_multi_level_cols1 = pd.DataFrame([[80, 64], [76, 70]], index=['Deepa', 'Balram'], columns=multicol1) print(df_multi_level_cols1)", "e": 2224, "s": 1864, "text": null }, { "code": null, "e": 2232, "s": 2224, "text": "Output:" }, { "code": null, "e": 2293, "s": 2232, "text": "After stacking the dataframe with a multi-level column axis:" }, { "code": null, "e": 2301, "s": 2293, "text": "Python3" }, { "code": "# Multi-level stacking with stackdf_multi_level_cols1.stack()", "e": 2363, "s": 2301, "text": null }, { "code": null, "e": 2371, "s": 2363, "text": "Output:" }, { "code": null, "e": 2380, "s": 2371, "text": "Case 3#:" }, { "code": null, "e": 2529, "s": 2380, "text": "Now, let’s try with some missing values In the regular wide form, we will get the values as it is, since it has lesser value than the stacked forms:" }, { "code": null, "e": 2537, "s": 2529, "text": "Python3" }, { "code": "# Multi-level with missing valuesmulticol2 = pd.MultiIndex.from_tuples([('English', 'Literature'), ('Hindi', 'Language')]) df_multi_level_cols2 = pd.DataFrame([[80, 75], [80, 85]], index=['Deepa', 'Balram'], columns=multicol2)df_multi_level_cols2", "e": 2893, "s": 2537, "text": null }, { "code": null, "e": 2901, "s": 2893, "text": "Output:" }, { "code": null, "e": 2923, "s": 2901, "text": "But when we stack it," }, { "code": null, "e": 3217, "s": 2923, "text": "We can have missing values when stacking a dataframe with multi-level columns, as the stacked dataframe typically has more values than the original dataframe. Missing values are filled with NaNs, like here in this example, the value for the English Language is not known so is filled with NaN." }, { "code": null, "e": 3225, "s": 3217, "text": "Python3" }, { "code": "# Multi-level missing values as NaNdf_multi_level_cols2.stack()", "e": 3289, "s": 3225, "text": null }, { "code": null, "e": 3297, "s": 3289, "text": "Output:" }, { "code": null, "e": 3306, "s": 3297, "text": "Case 4#:" }, { "code": null, "e": 3518, "s": 3306, "text": "Apart from that, we can also contain the stacked values as per our preferences, hence by prescribing the stack the value to be kept. The first parameter actually controls which level or levels are stacked. Like," }, { "code": null, "e": 3526, "s": 3518, "text": "Python3" }, { "code": "# Prescribing the level(s) to be stackeddf_multi_level_cols2.stack(0) # The first parameter controls which level # or levels are stackeddf_multi_level_cols2.stack([0, 1])", "e": 3698, "s": 3526, "text": null }, { "code": null, "e": 3706, "s": 3698, "text": "Output:" }, { "code": null, "e": 3715, "s": 3706, "text": "Case 5#:" }, { "code": null, "e": 3930, "s": 3715, "text": "Now, finally let’s check what is the purpose of the dropna in stack(). For this, we will drop the rows which have completely NaN values. Let’s check the code for the regular result when the NaN values are included." }, { "code": null, "e": 3938, "s": 3930, "text": "Python3" }, { "code": "# Dropping missing valuesdf_multi_level_cols3 = pd.DataFrame([[None, 80], [77, 82]], index=['Deepa', 'Balram'], columns=multicol2)print(df_multi_level_cols3) # contains the row with all NaN values since,# dropna=Falsedf_multi_level_cols3.stack(dropna=False)print(df_multi_level_cols3)", "e": 4294, "s": 3938, "text": null }, { "code": null, "e": 4302, "s": 4294, "text": "Output:" }, { "code": null, "e": 4453, "s": 4302, "text": "Here, we can see in the Deepa index, the value for Literature is NaN when we are operating with dropna = False (it is including the NaN value as well)" }, { "code": null, "e": 4532, "s": 4453, "text": "Let’s check when we make the dropna = True( omits the complete NaN values row)" }, { "code": null, "e": 4540, "s": 4532, "text": "Python3" }, { "code": "# Drops the row with completely NaN valuesdf_multi_level_cols3.stack(dropna=True)print(df_multi_level_cols3)", "e": 4649, "s": 4540, "text": null }, { "code": null, "e": 4657, "s": 4649, "text": "Output:" }, { "code": null, "e": 4753, "s": 4657, "text": "So, here making dropna = False omits the Literature row as a whole since it was NaN completely." }, { "code": null, "e": 4777, "s": 4753, "text": "Python pandas-dataFrame" }, { "code": null, "e": 4791, "s": 4777, "text": "Python-pandas" }, { "code": null, "e": 4798, "s": 4791, "text": "Python" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n17 Dec, 2019" }, { "code": null, "e": 382, "s": 28, "text": "Sometimes, while working with dictionaries, we can have a use-case in which we require to decrement a particular key’s value by K in dictionary. It may seem a quite straight forward problem, but catch comes when the existence of a key is not known, hence becomes a 2 step process at times. Let’s discuss certain ways in which this task can be performed." }, { "code": null, "e": 570, "s": 382, "text": "Method #1 : Using get()The get function can be used to initialize a non-existing key with 0 and then the decrement is possible. By this way the problem of non-existing key can be avoided." }, { "code": "# Python3 code to demonstrate working of# Decrement Dictionary value by K# Using get() # Initialize dictionarytest_dict = {'gfg' : 1, 'is' : 2, 'for' : 4, 'CS' : 5} # printing original dictionaryprint(\"The original dictionary : \" + str(test_dict)) # Initialize K K = 5 # Using get()# Decrement Dictionary value by Ktest_dict['best'] = test_dict.get('best', 0) - K # printing result print(\"Dictionary after the decrement of key : \" + str(test_dict))", "e": 1028, "s": 570, "text": null }, { "code": null, "e": 1183, "s": 1028, "text": "The original dictionary : {‘for’: 4, ‘CS’: 5, ‘is’: 2, ‘gfg’: 1}Dictionary after the decrement of key : {‘best’: -5, ‘for’: 4, ‘CS’: 5, ‘is’: 2, ‘gfg’: 1}" }, { "code": null, "e": 1381, "s": 1185, "text": "Method #2 : Using defaultdict()This problem can also be solved by using a defaultdict method, which initializes the potential keys and doesn’t throw an exception in case of non-existence of keys." }, { "code": "# Python3 code to demonstrate working of# Decrement Dictionary value by K# Using defaultdict()from collections import defaultdict # Initialize dictionarytest_dict = defaultdict(int) # printing original dictionaryprint(\"The original dictionary : \" + str(dict(test_dict))) # Initialize K K = 5 # Using defaultdict()# Decrement Dictionary value by Ktest_dict['best'] -= K # printing result print(\"Dictionary after the decrement of key : \" + str(dict(test_dict)))", "e": 1850, "s": 1381, "text": null }, { "code": null, "e": 1931, "s": 1850, "text": "The original dictionary : {}Dictionary after the decrement of key : {‘best’: -5}" }, { "code": null, "e": 1958, "s": 1931, "text": "Python dictionary-programs" }, { "code": null, "e": 1965, "s": 1958, "text": "Python" }, { "code": null, "e": 1981, "s": 1965, "text": "Python Programs" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n06 Jul, 2022" }, { "code": null, "e": 240, "s": 52, "text": "Vectors are same as dynamic arrays with the ability to resize itself automatically when an element is inserted or deleted, with their storage being handled automatically by the container." }, { "code": null, "e": 443, "s": 240, "text": "push_back() function is used to push elements into a vector from the back. The new value is inserted into the vector at the end, after the current last element and the container size is increased by 1. " }, { "code": null, "e": 453, "s": 443, "text": "Syntax : " }, { "code": null, "e": 654, "s": 453, "text": "vectorname.push_back(value)\nParameters :\nThe value to be added in the back is \npassed as the parameter\nResult :\nAdds the value mentioned as the parameter \nto the back of the vector named as vectorname" }, { "code": null, "e": 666, "s": 654, "text": "Examples: " }, { "code": null, "e": 851, "s": 666, "text": "Input : myvector = {1, 2, 3, 4, 5};\n myvector.push_back(6);\nOutput :1, 2, 3, 4, 5, 6\n\nInput : myvector = {5, 4, 3, 2, 1};\n myvector.push_back(0);\nOutput :5, 4, 3, 2, 1, 0" }, { "code": null, "e": 1066, "s": 851, "text": "Errors and Exceptions1. Strong exception guarantee – if an exception is thrown, there are no changes in the container. 2. If the value passed as argument is not supported by the vector, it shows undefined behavior." }, { "code": null, "e": 1070, "s": 1066, "text": "C++" }, { "code": "// CPP program to illustrate// push_back() function#include <iostream>#include <vector>using namespace std; int main(){ vector<int> myvector{ 1, 2, 3, 4, 5 }; myvector.push_back(6); // Vector becomes 1, 2, 3, 4, 5, 6 for (auto it = myvector.begin(); it != myvector.end(); ++it) cout << ' ' << *it;}", "e": 1393, "s": 1070, "text": null }, { "code": null, "e": 1402, "s": 1393, "text": "Output: " }, { "code": null, "e": 1414, "s": 1402, "text": "1 2 3 4 5 6" }, { "code": null, "e": 1591, "s": 1414, "text": "pop_back() function is used to pop or remove elements from a vector from the back. The value is removed from the vector from the end, and the container size is decreased by 1. " }, { "code": null, "e": 1602, "s": 1591, "text": "Syntax : " }, { "code": null, "e": 1757, "s": 1602, "text": "vectorname.pop_back()\nParameters :\nNo parameters are passed\nResult :\nRemoves the value present at the end or back \nof the given vector named as vectorname" }, { "code": null, "e": 1768, "s": 1757, "text": "Examples: " }, { "code": null, "e": 1937, "s": 1768, "text": "Input : myvector = {1, 2, 3, 4, 5};\n myvector.pop_back();\nOutput :1, 2, 3, 4\n\nInput : myvector = {5, 4, 3, 2, 1};\n myvector.pop_back();\nOutput :5, 4, 3, 2" }, { "code": null, "e": 2107, "s": 1937, "text": "Errors and Exceptions1. No-Throw-Guarantee – If the container is not empty, the function never throws exceptions. 2. If the vector is empty, it shows undefined behavior." }, { "code": null, "e": 2111, "s": 2107, "text": "C++" }, { "code": "// CPP program to illustrate// pop_back() function#include <iostream>#include <vector>using namespace std; int main(){ vector<int> myvector{ 1, 2, 3, 4, 5 }; myvector.pop_back(); // Vector becomes 1, 2, 3, 4 for (auto it = myvector.begin(); it != myvector.end(); ++it) cout << ' ' << *it;}", "e": 2425, "s": 2111, "text": null }, { "code": null, "e": 2434, "s": 2425, "text": "Output: " }, { "code": null, "e": 2442, "s": 2434, "text": "1 2 3 4" }, { "code": null, "e": 2495, "s": 2442, "text": "Does pop_back() removes values along with elements ?" }, { "code": null, "e": 2929, "s": 2495, "text": "When pop_back() function is called, element at the last is removed, values and elements are one of the same thing in this case. The destructor of the stored object is called, and length of the vector is removed by 1. If the container’s capacity is not reduced, then you can still access the previous memory location but in this case, there is no use of accessing an already popped element, as it will result in an undefined behavior." }, { "code": null, "e": 3065, "s": 2929, "text": "Application push_back() and pop_back() Given an empty vector, add integers to it using push_back function and then calculate its size. " }, { "code": null, "e": 3102, "s": 3065, "text": "Input : 1, 2, 3, 4, 5, 6\nOutput : 6" }, { "code": null, "e": 3395, "s": 3102, "text": "Algorithm 1. Add elements to the vector using push_back function 2. Check if the size of the vector is 0, if not, increment the counter variable initialized as 0, and pop the back element. 3. Repeat this step until the size of the vector becomes 0. 4. Print the final value of the variable. " }, { "code": null, "e": 3399, "s": 3395, "text": "C++" }, { "code": "// CPP program to illustrate// Application of push_back and pop_back function#include <iostream>#include <vector>using namespace std; int main(){ int count = 0; vector<int> myvector; myvector.push_back(1); myvector.push_back(2); myvector.push_back(3); myvector.push_back(4); myvector.push_back(5); myvector.push_back(6); while (!myvector.empty()) { count++; myvector.pop_back(); } cout << count; return 0;}", "e": 3857, "s": 3399, "text": null }, { "code": null, "e": 3866, "s": 3857, "text": "Output: " }, { "code": null, "e": 3868, "s": 3866, "text": "6" }, { "code": null, "e": 3917, "s": 3868, "text": " Let us see the differences in a tabular form -:" }, { "code": null, "e": 3934, "s": 3917, "text": "Its syntax is -:" }, { "code": null, "e": 3952, "s": 3934, "text": "push_back(value);" }, { "code": null, "e": 3969, "s": 3952, "text": "Its syntax is -:" }, { "code": null, "e": 3981, "s": 3969, "text": "pop_back();" }, { "code": null, "e": 3997, "s": 3981, "text": "pranamikapandey" }, { "code": null, "e": 4011, "s": 3997, "text": "chhabradhanvi" }, { "code": null, "e": 4025, "s": 4011, "text": "mayank007rawa" }, { "code": null, "e": 4037, "s": 4025, "text": "CPP-Library" }, { "code": null, "e": 4048, "s": 4037, "text": "cpp-vector" }, { "code": null, "e": 4052, "s": 4048, "text": "STL" }, { "code": null, "e": 4056, "s": 4052, "text": "C++" }, { "code": null, "e": 4061, "s": 4056, "text": "Misc" }, { "code": null, "e": 4066, "s": 4061, "text": "Misc" }, { "code": null, "e": 4071, "s": 4066, "text": "Misc" }, { "code": null, "e": 4075, "s": 4071, "text": "STL" }, { "code": null, "e": 4079, "s": 4075, "text": "CPP" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n04 Jan, 2021" }, { "code": null, "e": 230, "s": 28, "text": "Given a Hashtable, the task is to sort this Hashtable. Hashtable is a data structure that stores data in key-value format. The stored data is neither in sorted order nor preserves the insertion order. " }, { "code": null, "e": 238, "s": 230, "text": "Example" }, { "code": null, "e": 243, "s": 238, "text": "Java" }, { "code": "import java.io.*;import java.util.*; public class SortHashtable { public static void main(String[] args) { // create a hashtable Hashtable<Integer, String> ht = new Hashtable<Integer, String>(); // insert data into hashtable ht.put(2, \"mango\"); ht.put(3, \"orange\"); ht.put(1, \"apple\"); Set<Integer> keys = ht.keySet(); Iterator<Integer> itr = keys.iterator(); // traverse the TreeMap using iterator while (itr.hasNext()) { Integer i = itr.next(); System.out.println(i + \" \" + ht.get(i)); } }}", "e": 864, "s": 243, "text": null }, { "code": null, "e": 890, "s": 864, "text": "3 orange\n2 mango\n1 apple\n" }, { "code": null, "e": 958, "s": 890, "text": "The Hashtable mappings can be sorted using the following two ways: " }, { "code": null, "e": 991, "s": 958, "text": "Using TreeMapUsing LinkedHashMap" }, { "code": null, "e": 1005, "s": 991, "text": "Using TreeMap" }, { "code": null, "e": 1025, "s": 1005, "text": "Using LinkedHashMap" }, { "code": null, "e": 1035, "s": 1025, "text": "Examples:" }, { "code": null, "e": 1091, "s": 1035, "text": "Input: Hashtable: {2: “mango”, 1: “apple”, 3: “orange”}" }, { "code": null, "e": 1107, "s": 1091, "text": "Output: 1 apple" }, { "code": null, "e": 1131, "s": 1107, "text": " 2 mango" }, { "code": null, "e": 1155, "s": 1131, "text": " 3 orange" }, { "code": null, "e": 1210, "s": 1155, "text": "Input: Hashtable: {3: “three”, 2: “second”, 1:”first”}" }, { "code": null, "e": 1226, "s": 1210, "text": "Output: 1 first" }, { "code": null, "e": 1251, "s": 1226, "text": " 2 second" }, { "code": null, "e": 1275, "s": 1251, "text": " 3 third" }, { "code": null, "e": 1287, "s": 1275, "text": "Approach 1:" }, { "code": null, "e": 1472, "s": 1287, "text": "TreeMap stores the data in sorted order. We can use the TreeMap constructor and convert the Hashtable object into a TreeMap object. Now the resultant TreeMap object is in sorted order." }, { "code": null, "e": 1480, "s": 1472, "text": "Syntax:" }, { "code": null, "e": 1525, "s": 1480, "text": "TreeMap<K, V> tm = new TreeMap<K, V>(Map m);" }, { "code": null, "e": 1572, "s": 1525, "text": "Parameters: m is the Hashtable in our program." }, { "code": null, "e": 1580, "s": 1572, "text": "Example" }, { "code": null, "e": 1585, "s": 1580, "text": "Java" }, { "code": "import java.io.*;import java.util.*; public class SortHashtable { public static void main(String[] args) { // create a hashtable Hashtable<Integer, String> ht = new Hashtable<Integer, String>(); // insert data into hashtable ht.put(2, \"mango\"); ht.put(3, \"orange\"); ht.put(1, \"apple\"); // create a TreeMap TreeMap<Integer, String> tm = new TreeMap<Integer, String>(ht); // create a keyset Set<Integer> keys = tm.keySet(); Iterator<Integer> itr = keys.iterator(); // traverse the TreeMap using iterator while (itr.hasNext()) { Integer i = itr.next(); System.out.println(i + \" \" + tm.get(i)); } }}", "e": 2343, "s": 1585, "text": null }, { "code": null, "e": 2369, "s": 2343, "text": "1 apple\n2 mango\n3 orange\n" }, { "code": null, "e": 2381, "s": 2369, "text": "Approach 2:" }, { "code": null, "e": 2555, "s": 2381, "text": "LinkedHashMap stores the data in the order in which it is inserted. As when the data comes insert it into LinkedHashMap which has a property to preserve the insertion order." }, { "code": null, "e": 2563, "s": 2555, "text": "Syntax:" }, { "code": null, "e": 2616, "s": 2563, "text": "LinkedHashMap<K, V> lhm = new LinkedHashMap<K, V>();" }, { "code": null, "e": 2624, "s": 2616, "text": "Example" }, { "code": null, "e": 2629, "s": 2624, "text": "Java" }, { "code": "import java.io.*;import java.util.*; public class SortHashTable { public static void main(String[] args) { // create a LinkedHashMap LinkedHashMap<Integer, String> lhm = new LinkedHashMap<Integer, String>(); // insert data into LinkeHashMap lhm.put(2, \"mango\"); lhm.put(3, \"orange\"); lhm.put(1, \"apple\"); // prepare a keyset Set<Integer> keys = lhm.keySet(); Iterator<Integer> itr = keys.iterator(); // traverse the LinkedHashMap using iterator while (itr.hasNext()) { Integer i = itr.next(); System.out.println(i + \" \" + lhm.get(i)); } }}", "e": 3304, "s": 2629, "text": null }, { "code": null, "e": 3330, "s": 3304, "text": "2 mango\n3 orange\n1 apple\n" }, { "code": null, "e": 3345, "s": 3330, "text": "Java-HashTable" }, { "code": null, "e": 3352, "s": 3345, "text": "Picked" }, { "code": null, "e": 3357, "s": 3352, "text": "Java" }, { "code": null, "e": 3371, "s": 3357, "text": "Java Programs" }, { "code": null, "e": 3376, "s": 3371, "text": "Java" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n07 Feb, 2019" }, { "code": null, "e": 285, "s": 28, "text": "Pandas series is a One-dimensional ndarray with axis labels. The labels need not be unique but must be a hashable type. The object supports both integer- and label-based indexing and provides a host of methods for performing operations involving the index." }, { "code": null, "e": 539, "s": 285, "text": "Pandas Series.select() function return data corresponding to axis labels matching criteria. We pass the name of the function as an argument to this function which is applied on all the index labels. The index labels satisfying the criteria are selected." }, { "code": null, "e": 575, "s": 539, "text": "Syntax: Series.select(crit, axis=0)" }, { "code": null, "e": 667, "s": 575, "text": "Parameter :crit : called on each index (label). Should return True or Falseaxis : int value" }, { "code": null, "e": 709, "s": 667, "text": "Returns : selection : same type as caller" }, { "code": null, "e": 864, "s": 709, "text": "Example #1: Use Series.select() function to select the names of all those cities from the given Series object for which it’s index labels has even ending." }, { "code": "# importing pandas as pdimport pandas as pd # Creating the Seriessr = pd.Series(['New York', 'Chicago', 'Toronto', 'Lisbon', 'Rio', 'Moscow']) # Create the Datetime Indexindex_ = ['City 1', 'City 2', 'City 3', 'City 4', 'City 5', 'City 6'] # set the indexsr.index = index_ # Print the seriesprint(sr)", "e": 1169, "s": 864, "text": null }, { "code": null, "e": 1178, "s": 1169, "text": "Output :" }, { "code": null, "e": 1308, "s": 1178, "text": "Now we will use Series.select() function to select the names of all those cities, whose index label ends with even integer value." }, { "code": "# Define a function to Select those cities whose index# label's last character is an even integerdef city_even(city): # if last character is even if int(city[-1]) % 2 == 0: return True else: return False # Call the function and select the valuesselected_cities = sr.select(city_even, axis = 0) # Print the returned Series objectprint(selected_cities)", "e": 1685, "s": 1308, "text": null }, { "code": null, "e": 1694, "s": 1685, "text": "Output :" }, { "code": null, "e": 1831, "s": 1694, "text": "As we can see in the output, the Series.select() function has successfully returned all those cities which satisfies the given criteria." }, { "code": null, "e": 1954, "s": 1831, "text": "Example #2: Use Series.select() function to select the sales of the ‘Coca Cola’ and ‘Sprite’ from the given Series object." }, { "code": "# importing pandas as pdimport pandas as pd # Creating the Seriessr = pd.Series([100, 25, 32, 118, 24, 65]) # Create the Indexindex_ = ['Coca Cola', 'Sprite', 'Coke', 'Fanta', 'Dew', 'ThumbsUp'] # set the indexsr.index = index_ # Print the seriesprint(sr)", "e": 2214, "s": 1954, "text": null }, { "code": null, "e": 2223, "s": 2214, "text": "Output :" }, { "code": null, "e": 2338, "s": 2223, "text": "Now we will use Series.select() function to select the sales of the listed beverages from the given Series object." }, { "code": "# Function to select the sales of # Coca Cola and Spritedef show_sales(x): if x == 'Sprite' or x == 'Coca Cola': return True else: return False # Call the function and select the valuesselected_cities = sr.select(show_sales, axis = 0) # Print the returned Series objectprint(selected_cities)", "e": 2652, "s": 2338, "text": null }, { "code": null, "e": 2661, "s": 2652, "text": "Output :" }, { "code": null, "e": 2815, "s": 2661, "text": "As we can see in the output, the Series.select() function has successfully returned the sales data of the desired beverages from the given Series object." }, { "code": null, "e": 2836, "s": 2815, "text": "Python pandas-series" }, { "code": null, "e": 2865, "s": 2836, "text": "Python pandas-series-methods" }, { "code": null, "e": 2879, "s": 2865, "text": "Python-pandas" }, { "code": null, "e": 2886, "s": 2879, "text": "Python" } ]

[ { "code": null, "e": 1211, "s": 1062, "text": "You can treat multiple characters as a single unit by capturing them as groups. You just need to place these characters inside a set of parentheses." }, { "code": null, "e": 1410, "s": 1211, "text": "You can count the number of groups in the current match using the groupCount() method of the Matcher class. This method calculates the number of capturing groups in the current match and returns it." }, { "code": null, "e": 1421, "s": 1410, "text": " Live Demo" }, { "code": null, "e": 2255, "s": 1421, "text": "import java.util.regex.Matcher;\nimport java.util.regex.Pattern;\npublic class Test {\n public static void main(String[] args) {\n String str1 = \"<p>This <b>is</b> an <b>example</b> HTML <b>script</b> where <b>ever</b> alternative <b>word</b> is <b>bold</b></p>.\";\n //Regular expression to match contents of the bold tags\n String regex = \"(t(\\\\S+)t)(\\\\s)\";\n String str = \"the words tit tat tweet tostff tact that tilt text. start and end with the letter t \";\n //Creating a pattern object\n Pattern pattern = Pattern.compile(regex);\n //Matching the compiled pattern in the String\n Matcher matcher = pattern.matcher(str);\n while (matcher.find()) {\n System.out.println(matcher.group(0));\n }\n System.out.println(\"Total capturing groups: \"+matcher.groupCount());\n }\n}" }, { "code": null, "e": 2320, "s": 2255, "text": "tit\ntat\ntweet\ntact\nthat\ntilt\ntext\ntart\nTotal capturing groups: 3" } ]

[ { "code": null, "e": 1196, "s": 1062, "text": "Sets in C# is a HashSet. HashSet in C# eliminates duplicate strings or elements in an array. In C#, it is an optimized set collection" }, { "code": null, "e": 1217, "s": 1196, "text": "To declare HashSet −" }, { "code": null, "e": 1252, "s": 1217, "text": "var h = new HashSet<string>(arr1);" }, { "code": null, "e": 1319, "s": 1252, "text": "Above, we have set the already declared array arr1 in the HashSet." }, { "code": null, "e": 1375, "s": 1319, "text": "Now set it on the array to remove the duplicate words −" }, { "code": null, "e": 1404, "s": 1375, "text": "string[] arr2 = h.ToArray();" }, { "code": null, "e": 1472, "s": 1404, "text": "Let us see an example to remove duplicate strings using C# HashSet." }, { "code": null, "e": 1507, "s": 1472, "text": "Here, we have duplicate elements −" }, { "code": null, "e": 1913, "s": 1507, "text": "using System;\nusing System.Collections.Generic;\nusing System.Linq;\n\nclass Program {\n static void Main() {\n string[] arr1 = {\"Table\",\"Chair\",\"Pen\",\"Clip\",\"Table\"};\n Console.WriteLine(string.Join(\",\", arr1));\n\n // HashSet\n var h = new HashSet<string>(arr1);\n\n // eliminates duplicate words\n string[] arr2 = h.ToArray();\n Console.WriteLine(string.Join(\",\", arr2));\n }\n}" } ]

[ { "code": null, "e": 1152, "s": 1062, "text": "In this tutorial, we will be discussing a program to understand default arguments in C++." }, { "code": null, "e": 1284, "s": 1152, "text": "Default arguments are those which are provided to the called function in case the caller statement does provide any value for them." }, { "code": null, "e": 1295, "s": 1284, "text": " Live Demo" }, { "code": null, "e": 1582, "s": 1295, "text": "#include<iostream>\nusing namespace std;\n//function defined with default arguments\nint sum(int x, int y, int z=0, int w=0){\n return (x + y + z + w);\n}\nint main(){\n cout << sum(10, 15) << endl;\n cout << sum(10, 15, 25) << endl;\n cout << sum(10, 15, 25, 30) << endl;\n return 0;\n}" }, { "code": null, "e": 1591, "s": 1582, "text": "25\n50\n80" } ]

[ { "code": null, "e": 285, "s": 172, "text": "When travelling in a car as a kid, did you ever play a game where you counted the number of cars that passed by?" }, { "code": null, "e": 329, "s": 285, "text": "That used to be my favourite game as a kid." }, { "code": null, "e": 441, "s": 329, "text": "In this post, I will teach you how to build your own car counter program in just 10 lines of code using Python." }, { "code": null, "e": 529, "s": 441, "text": "You will need to install the following python libraries if it is not already installed:" }, { "code": null, "e": 573, "s": 529, "text": "opencv-pythoncvlibmatplotlibtensorflowkeras" }, { "code": null, "e": 826, "s": 573, "text": "Here is the code to import the required python libraries, read an image from storage, perform object detection on the image, display the image with a bounding box and label about the detected objects, count the number of cars in the image and print it." }, { "code": null, "e": 1154, "s": 826, "text": "import cv2import matplotlib.pyplot as pltimport cvlib as cvfrom cvlib.object_detection import draw_bboxim = cv2.imread('cars_4.jpeg')bbox, label, conf = cv.detect_common_objects(im)output_image = draw_bbox(im, bbox, label, conf)plt.imshow(output_image)plt.show()print('Number of cars in the image is '+ str(label.count('car')))" }, { "code": null, "e": 1177, "s": 1154, "text": "Output for this image:" }, { "code": null, "e": 1211, "s": 1177, "text": "Number of cars in the image is 29" }, { "code": null, "e": 1234, "s": 1211, "text": "Output for this image:" }, { "code": null, "e": 1268, "s": 1234, "text": "Number of cars in the image is 22" }, { "code": null, "e": 1291, "s": 1268, "text": "Output for this image:" }, { "code": null, "e": 1325, "s": 1291, "text": "Number of cars in the image is 25" }, { "code": null, "e": 1469, "s": 1325, "text": "Your car counter program is now ready. You can use it for fun experiments such as counting the number of cars that pass your driveway each day." }, { "code": null, "e": 1522, "s": 1469, "text": "Python version 3.6.9 was used for running this code." }, { "code": null, "e": 1617, "s": 1522, "text": "Versions of the most important packages that were installed when this code was run as follows:" }, { "code": null, "e": 1700, "s": 1617, "text": "cvlib: 0.2.2opencv-python: 4.1.1.26tensorflow: 1.14.0matplotlib: 3.1.1Keras: 2.2.5" }, { "code": null, "e": 1765, "s": 1700, "text": "Here is a GitHub link for the Jupyter Notebook for this program:" }, { "code": null, "e": 1776, "s": 1765, "text": "github.com" }, { "code": null, "e": 1840, "s": 1776, "text": "Found this post helpful? Leave your thoughts as comments below." }, { "code": null, "e": 1967, "s": 1840, "text": "Looking to implement face detection. Check out my post on how to implement face detection in less than 3 minutes using python." }, { "code": null, "e": 2083, "s": 1967, "text": "Looking to implement object detection. Check out my post on object detection using just 10 lines of code in python." }, { "code": null, "e": 2141, "s": 2083, "text": "Click here to read my other posts on AI/Machine Learning." } ]

[ { "code": null, "e": 1251, "s": 1062, "text": "The java.math.BigInteger.modInverse(BigInteger m) returns a BigInteger whose value is (this-1 mod m). Using this method you can calculate Modular multiplicative inverse for a given number." }, { "code": null, "e": 1261, "s": 1251, "text": "Live Demo" }, { "code": null, "e": 1828, "s": 1261, "text": "import java.math.*;\npublic class BigIntegerDemo {\n public static void main(String[] args) {\n // create 3 BigInteger objects\n BigInteger bi1, bi2, bi3;\n \n // create a BigInteger exponent\n BigInteger exponent = new BigInteger(\"2\");\n bi1 = new BigInteger(\"7\");\n bi2 = new BigInteger(\"20\");\n \n // perform modPow operation on bi1 using bi2 and exp\n bi3 = bi1.modPow(exponent, bi2);\n String str = bi1 + \"^\" +exponent+ \" mod \" + bi2 + \" is \" +bi3;\n \n // print bi3 value\n System.out.println( str );\n }\n}" }, { "code": null, "e": 1844, "s": 1828, "text": "7^2 mod 20 is 9" } ]

[ { "code": null, "e": 158, "s": 123, "text": "PROGRAMMINGJava ExamplesC Examples" }, { "code": null, "e": 172, "s": 158, "text": "Java Examples" }, { "code": null, "e": 183, "s": 172, "text": "C Examples" }, { "code": null, "e": 195, "s": 183, "text": "C Tutorials" }, { "code": null, "e": 199, "s": 195, "text": "aws" }, { "code": null, "e": 234, "s": 199, "text": "JAVAEXCEPTIONSCOLLECTIONSSWINGJDBC" }, { "code": null, "e": 245, "s": 234, "text": "EXCEPTIONS" }, { "code": null, "e": 257, "s": 245, "text": "COLLECTIONS" }, { "code": null, "e": 263, "s": 257, "text": "SWING" }, { "code": null, "e": 268, "s": 263, "text": "JDBC" }, { "code": null, "e": 275, "s": 268, "text": "JAVA 8" }, { "code": null, "e": 282, "s": 275, "text": "SPRING" }, { "code": null, "e": 294, "s": 282, "text": "SPRING BOOT" }, { "code": null, "e": 304, "s": 294, "text": "HIBERNATE" }, { "code": null, "e": 311, "s": 304, "text": "PYTHON" }, { "code": null, "e": 315, "s": 311, "text": "PHP" }, { "code": null, "e": 322, "s": 315, "text": "JQUERY" }, { "code": null, "e": 357, "s": 322, "text": "PROGRAMMINGJava ExamplesC Examples" }, { "code": null, "e": 371, "s": 357, "text": "Java Examples" }, { "code": null, "e": 382, "s": 371, "text": "C Examples" }, { "code": null, "e": 394, "s": 382, "text": "C Tutorials" }, { "code": null, "e": 398, "s": 394, "text": "aws" }, { "code": null, "e": 487, "s": 398, "text": "In this tutorials, I am going to show you how to work with Spring MVC With Apache Tiles." }, { "code": null, "e": 668, "s": 487, "text": "Spring MVC Tiles are mostly used combination. Apache Tiles is a templating framework helpful to minimize the development effort of web application (Spring, Struts) user interfaces." }, { "code": null, "e": 689, "s": 668, "text": "Spring 4.3.4.RELEASE" }, { "code": null, "e": 708, "s": 689, "text": "Apache Tiles 3.0.7" }, { "code": null, "e": 726, "s": 708, "text": "Servlet API 3.1.0" }, { "code": null, "e": 738, "s": 726, "text": "Maven 3.6.0" }, { "code": null, "e": 751, "s": 738, "text": "Java 1.7 and" }, { "code": null, "e": 769, "s": 751, "text": "STS 3.6.4.RELEASE" }, { "code": null, "e": 777, "s": 769, "text": "pom.xml" }, { "code": null, "e": 3033, "s": 777, "text": "<properties>\n <springframework.version>4.3.4.RELEASE</springframework.version>\n <apache-tiles.version>3.0.7</apache-tiles.version>\n <javax.servlet-api.version>3.1.0</javax.servlet-api.version>\n <javax.servlet.jsp-api.version>2.3.1</javax.servlet.jsp-api.version>\n <jstl.version>1.2</jstl.version>\n <java.version>1.7</java.version>\n\n <maven-compiler-plugin.version>3.6.0</maven-compiler-plugin.version>\n <maven-war-plugin.version>2.6</maven-war-plugin.version>\n\n </properties>\n\n <dependencies>\n\n <dependency>\n <groupId>org.springframework</groupId>\n <artifactId>spring-core</artifactId>\n <version>${springframework.version}</version>\n <exclusions>\n <exclusion>\n <artifactId>commons-logging</artifactId>\n <groupId>commons-logging</groupId>\n </exclusion>\n </exclusions>\n </dependency>\n <dependency>\n <groupId>org.springframework</groupId>\n <artifactId>spring-web</artifactId>\n <version>${springframework.version}</version>\n </dependency>\n <dependency>\n <groupId>org.springframework</groupId>\n <artifactId>spring-webmvc</artifactId>\n <version>${springframework.version}</version>\n </dependency>\n <!-- Apache Tiles -->\n <dependency>\n <groupId>org.apache.tiles</groupId>\n <artifactId>tiles-jsp</artifactId>\n <version>${apache-tiles.version}</version>\n </dependency>\n <!-- Servlet+JSP+JSTL -->\n <dependency>\n <groupId>javax.servlet</groupId>\n <artifactId>javax.servlet-api</artifactId>\n <version>${javax.servlet-api.version}</version>\n </dependency>\n <dependency>\n <groupId>javax.servlet.jsp</groupId>\n <artifactId>javax.servlet.jsp-api</artifactId>\n <version>${javax.servlet.jsp-api.version}</version>\n </dependency>\n <dependency>\n <groupId>javax.servlet</groupId>\n <artifactId>jstl</artifactId>\n <version>${jstl.version}</version>\n </dependency>\n </dependencies>" }, { "code": null, "e": 3175, "s": 3033, "text": "Create ApplicationConfiguration file, since we are using Servlet 3.x version, there is no web.xml. The below class replaces the web.xml role." }, { "code": null, "e": 3198, "s": 3175, "text": "ApplicationConfig.java" }, { "code": null, "e": 4717, "s": 3198, "text": "package com.onlinetutorialspoint.tiles.config;\n\nimport org.springframework.context.annotation.Bean;\nimport org.springframework.context.annotation.ComponentScan;\nimport org.springframework.context.annotation.Configuration;\nimport org.springframework.web.servlet.config.annotation.EnableWebMvc;\nimport org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;\nimport org.springframework.web.servlet.config.annotation.ViewResolverRegistry;\nimport org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter;\nimport org.springframework.web.servlet.view.tiles3.TilesConfigurer;\nimport org.springframework.web.servlet.view.tiles3.TilesViewResolver;\n\n@Configuration\n@EnableWebMvc\n@ComponentScan(basePackages = \"com.onlinetutorialspoint.tiles\")\npublic class ApplicationConfig extends WebMvcConfigurerAdapter {\n\n @Bean\n public TilesConfigurer tilesConfigurer() {\n TilesConfigurer tilesConfigurer = new TilesConfigurer();\n tilesConfigurer.setDefinitions(new String[] { \"/WEB-INF/views/**/tiles.xml\" });\n tilesConfigurer.setCheckRefresh(true);\n return tilesConfigurer;\n }\n\n @Override\n public void configureViewResolvers(ViewResolverRegistry registry) {\n TilesViewResolver viewResolver = new TilesViewResolver();\n registry.viewResolver(viewResolver);\n }\n\n @Override\n public void addResourceHandlers(ResourceHandlerRegistry registry) {\n registry.addResourceHandler(\"/resources/**\").addResourceLocations(\"/resources/\");\n }\n\n}" }, { "code": null, "e": 4776, "s": 4717, "text": "Create ApplicationInitializer to start up the application." }, { "code": null, "e": 4804, "s": 4776, "text": "ApplicationInitializer.java" }, { "code": null, "e": 5440, "s": 4804, "text": "package com.onlinetutorialspoint.tiles;\n\nimport org.springframework.web.servlet.support.AbstractAnnotationConfigDispatcherServletInitializer;\n\nimport com.onlinetutorialspoint.tiles.config.ApplicationConfig;\n\npublic class ApplicationInitializer extends AbstractAnnotationConfigDispatcherServletInitializer {\n\n @Override\n protected Class<?>[] getRootConfigClasses() {\n return new Class[] { ApplicationConfig.class };\n }\n\n @Override\n protected Class<?>[] getServletConfigClasses() {\n return null;\n }\n\n @Override\n protected String[] getServletMappings() {\n return new String[] { \"/\" };\n }\n\n}" }, { "code": null, "e": 5461, "s": 5440, "text": "Create a Controller." }, { "code": null, "e": 5481, "s": 5461, "text": "HomeController.java" }, { "code": null, "e": 6251, "s": 5481, "text": "package com.onlinetutorialspoint.tiles.controller;\n\nimport org.springframework.stereotype.Controller;\nimport org.springframework.ui.ModelMap;\nimport org.springframework.web.bind.annotation.RequestMapping;\nimport org.springframework.web.bind.annotation.RequestMethod;\n@Controller\n@RequestMapping(\"/\")\npublic class HomeController {\n @RequestMapping(value = { \"/\" }, method = RequestMethod.GET)\n public String homePage(ModelMap model) {\n return \"home\";\n }\n\n @RequestMapping(value = { \"/admin\" }, method = RequestMethod.GET)\n public String productsPage(ModelMap model) {\n return \"admin\";\n }\n\n @RequestMapping(value = { \"/user\" }, method = RequestMethod.GET)\n public String contactUsPage(ModelMap model) {\n return \"user\";\n }\n}" }, { "code": null, "e": 6275, "s": 6251, "text": "Create necessary views:" }, { "code": null, "e": 6284, "s": 6275, "text": "home.jsp" }, { "code": null, "e": 6698, "s": 6284, "text": "<%@ page language=\"java\" contentType=\"text/html; charset=ISO-8859-1\"\n pageEncoding=\"ISO-8859-1\"%>\n<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<head>\n<meta http-equiv=\"Content-Type\" content=\"text/html; charset=ISO-8859-1\">\n<title>Home</title>\n</head>\n<body>\n <h2>Welcome to OnlineTutorialsPoint Spring MVC Tiles Tutorials</h2>\n</body>\n</html>" }, { "code": null, "e": 6707, "s": 6698, "text": "user.jsp" }, { "code": null, "e": 7084, "s": 6707, "text": "<%@ page language=\"java\" contentType=\"text/html; charset=ISO-8859-1\"\n pageEncoding=\"ISO-8859-1\"%>\n<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<head>\n<meta http-equiv=\"Content-Type\" content=\"text/html; charset=ISO-8859-1\">\n<title>Spring MVC</title>\n</head>\n<body>\n <h2>Welcome User :)</h2>\n</body>\n</html>" }, { "code": null, "e": 7094, "s": 7084, "text": "admin.jsp" }, { "code": null, "e": 7474, "s": 7094, "text": "<%@ page language=\"java\" contentType=\"text/html; charset=ISO-8859-1\"\n pageEncoding=\"ISO-8859-1\"%>\n<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">\n<html>\n<head>\n<meta http-equiv=\"Content-Type\" content=\"text/html; charset=ISO-8859-1\">\n<title>Apache Tiles</title>\n</head>\n<body>\n <h2>Welcome Admin :)</h2>\n</body>\n</html>" }, { "code": null, "e": 7512, "s": 7474, "text": "Configure the Apache tiles:\ntiles.xml" }, { "code": null, "e": 8972, "s": 7512, "text": "<?xml version=\"1.0\" encoding=\"UTF-8\" ?>\n<!DOCTYPE tiles-definitions PUBLIC \"-//Apache Software Foundation//DTD Tiles Configuration 3.0//EN\" \"http://tiles.apache.org/dtds/tiles-config_3_0.dtd\"> \n \n<tiles-definitions> \n \n <!-- Template Definition -->\n <definition name=\"template-def\"\n template=\"/WEB-INF/views/tiles/layouts/defaultLayout.jsp\"> \n <put-attribute name=\"title\" value=\"\" /> \n <put-attribute name=\"header\" value=\"/WEB-INF/views/tiles/templates/header.jsp\" /> \n <put-attribute name=\"menu\" value=\"/WEB-INF/views/tiles/templates/menu.jsp\" /> \n <put-attribute name=\"body\" value=\"\" /> \n <put-attribute name=\"footer\" value=\"/WEB-INF/views/tiles/templates/footer.jsp\" /> \n </definition> \n \n <!-- Main Page -->\n <definition name=\"home\" extends=\"template-def\"> \n <put-attribute name=\"title\" value=\"Welcome\" /> \n <put-attribute name=\"body\" value=\"/WEB-INF/views/pages/home.jsp\" /> \n </definition> \n \n <!-- User Page -->\n <definition name=\"user\" extends=\"template-def\"> \n <put-attribute name=\"title\" value=\"User\" /> \n <put-attribute name=\"body\" value=\"/WEB-INF/views/pages/user.jsp\" /> \n </definition> \n \n <!-- Admin Page -->\n <definition name=\"admin\" extends=\"template-def\"> \n <put-attribute name=\"title\" value=\"Admin\" /> \n <put-attribute name=\"body\" value=\"/WEB-INF/views/pages/admin.jsp\" /> \n </definition> \n \n</tiles-definitions>" }, { "code": null, "e": 8983, "s": 8972, "text": "header.jsp" }, { "code": null, "e": 9058, "s": 8983, "text": "<header>\n <h1>Welcome To OnlineTutorialsPoint MVC Ttorials</h1>\n</header>" }, { "code": null, "e": 9069, "s": 9058, "text": "footer.jsp" }, { "code": null, "e": 9119, "s": 9069, "text": "<footer>copyright © OnlineTutorialsPoint</footer>" }, { "code": null, "e": 9128, "s": 9119, "text": "menu.jsp" }, { "code": null, "e": 9460, "s": 9128, "text": "<nav class=\"nav\">\n <a href=\"${pageContext.request.contextPath}/\"></a>\n <ul id=\"menu\">\n <li><a href=\"${pageContext.request.contextPath}/\">Home</a></li>\n <li><a href=\"${pageContext.request.contextPath}/user\">User</a></li>\n <li><a href=\"${pageContext.request.contextPath}/admin\">Admin</a></li>\n </ul>\n</nav>" }, { "code": null, "e": 9500, "s": 9460, "text": "http://localhost:8080/spring-mvc-tiles/" }, { "code": null, "e": 9517, "s": 9500, "text": "Happy Learning 🙂" }, { "code": null, "e": 10107, "s": 9517, "text": "\nSpring MVC Form Validation Example\nSpring Hibernate Example\nSpring MVC HelloWorld\nSpring Boot How to change the Tomcat to Jetty Server\nHow to Get All Spring Beans Details Loaded in ICO\nSpring Boot MVC Example Tutorials\nSpring Boot Validation Login Form Example\nSimple Spring Boot Example\nHow to Create own Spring Boot Error Page\nSpring Boot In Memory Basic Authentication Security\nTypes of Spring Bean Scopes Example\nDependency Injection (IoC) in spring with Example\nSpring Web MVC Framework Flow\nSpring Boot Apache ActiveMq In Memory Example\nExternal Apache ActiveMQ Spring Boot Example\n" }, { "code": null, "e": 10142, "s": 10107, "text": "Spring MVC Form Validation Example" }, { "code": null, "e": 10167, "s": 10142, "text": "Spring Hibernate Example" }, { "code": null, "e": 10189, "s": 10167, "text": "Spring MVC HelloWorld" }, { "code": null, "e": 10242, "s": 10189, "text": "Spring Boot How to change the Tomcat to Jetty Server" }, { "code": null, "e": 10292, "s": 10242, "text": "How to Get All Spring Beans Details Loaded in ICO" }, { "code": null, "e": 10326, "s": 10292, "text": "Spring Boot MVC Example Tutorials" }, { "code": null, "e": 10368, "s": 10326, "text": "Spring Boot Validation Login Form Example" }, { "code": null, "e": 10395, "s": 10368, "text": "Simple Spring Boot Example" }, { "code": null, "e": 10436, "s": 10395, "text": "How to Create own Spring Boot Error Page" }, { "code": null, "e": 10488, "s": 10436, "text": "Spring Boot In Memory Basic Authentication Security" }, { "code": null, "e": 10524, "s": 10488, "text": "Types of Spring Bean Scopes Example" }, { "code": null, "e": 10574, "s": 10524, "text": "Dependency Injection (IoC) in spring with Example" }, { "code": null, "e": 10604, "s": 10574, "text": "Spring Web MVC Framework Flow" }, { "code": null, "e": 10650, "s": 10604, "text": "Spring Boot Apache ActiveMq In Memory Example" }, { "code": null, "e": 10695, "s": 10650, "text": "External Apache ActiveMQ Spring Boot Example" }, { "code": null, "e": 10983, "s": 10695, "text": "\n\n\n\n\n\nNikit Kumar\nJanuary 25, 2018 at 3:19 pm - Reply \n\nmail me this project : [email protected]\n\n\n\n\n\n\n\n\n\nKoushik Ghosh\nOctober 12, 2019 at 7:44 pm - Reply \n\nYou have not provided defaultLayout.jsp. It would kind of you if you provide the same to my mail.\nThanks,\nKoushik Ghosh\n\n\n\n\n" }, { "code": null, "e": 11088, "s": 10983, "text": "\n\n\n\n\nNikit Kumar\nJanuary 25, 2018 at 3:19 pm - Reply \n\nmail me this project : [email protected]\n\n\n\n" }, { "code": null, "e": 11134, "s": 11088, "text": "mail me this project : [email protected]" }, { "code": null, "e": 11315, "s": 11134, "text": "\n\n\n\n\nKoushik Ghosh\nOctober 12, 2019 at 7:44 pm - Reply \n\nYou have not provided defaultLayout.jsp. It would kind of you if you provide the same to my mail.\nThanks,\nKoushik Ghosh\n\n\n\n" } ]

[ { "code": null, "e": 24238, "s": 24210, "text": "\n12 Jul, 2021" }, { "code": null, "e": 24658, "s": 24238, "text": "Apart from the generic looping techniques, such as “for, while and do-while”, C++ in its language also allows us to use another functionality which solves the same purpose termed “for-each” loops. This loop accepts a function which executes over each of the container elements. This loop is defined in the header file “algorithm”: #include<algorithm>, and hence has to be included for successful operation of this loop." }, { "code": null, "e": 24710, "s": 24658, "text": "It is versatile, i.e. Can work with any container." }, { "code": null, "e": 24777, "s": 24710, "text": "It reduces chances of errors one can commit using generic for loop" }, { "code": null, "e": 24805, "s": 24777, "text": "It makes code more readable" }, { "code": null, "e": 24856, "s": 24805, "text": "for_each loops improve overall performance of code" }, { "code": null, "e": 24868, "s": 24858, "text": "Syntax: " }, { "code": null, "e": 25224, "s": 24868, "text": "for_each (InputIterator start_iter, InputIterator last_iter, Function fnc)\n\nstart_iter : The beginning position \nfrom where function operations has to be executed.\nlast_iter : The ending position \ntill where function has to be executed.\nfnc/obj_fnc : The 3rd argument is a function or \nan object function which operation would be applied to each element. " }, { "code": null, "e": 25228, "s": 25224, "text": "CPP" }, { "code": "// C++ code to demonstrate the// working of for_each loop #include<iostream>#include<vector>#include<algorithm>using namespace std; // helper function 1void printx2(int a){ cout << a * 2 << \" \";} // helper function 2// object type functionstruct Class2{ void operator() (int a) { cout << a * 3 << \" \"; }} ob1; int main(){ // initializing array int arr[5] = { 1, 5, 2, 4, 3 }; cout << \"Using Arrays:\" << endl; // printing array using for_each // using function cout << \"Multiple of 2 of elements are : \"; for_each(arr, arr + 5, printx2); cout << endl; // printing array using for_each // using object function cout << \"Multiple of 3 of elements are : \"; for_each(arr, arr + 5, ob1); cout << endl; // initializing vector vector<int> arr1 = { 4, 5, 8, 3, 1 }; cout << \"Using Vectors:\" << endl; // printing array using for_each // using function cout << \"Multiple of 2 of elements are : \"; for_each(arr1.begin(), arr1.end(), printx2); cout << endl; // printing array using for_each // using object function cout << \"Multiple of 3 of elements are : \"; for_each(arr1.begin(), arr1.end(), ob1); cout << endl; }", "e": 26499, "s": 25228, "text": null }, { "code": null, "e": 26708, "s": 26499, "text": "Using Arrays:\nMultiple of 2 of elements are : 2 10 4 8 6 \nMultiple of 3 of elements are : 3 15 6 12 9 \nUsing Vectors:\nMultiple of 2 of elements are : 8 10 16 6 2 \nMultiple of 3 of elements are : 12 15 24 9 3 " }, { "code": null, "e": 26733, "s": 26708, "text": "Exceptions and for_each:" }, { "code": null, "e": 26933, "s": 26733, "text": "In the cases of exceptions, if the function throws an exception or if any of the operations on iterators throws an exception, for_each loop will also throw an exception and break/terminate the loop. " }, { "code": null, "e": 26940, "s": 26933, "text": "Note: " }, { "code": null, "e": 26991, "s": 26940, "text": "Invalid arguments may leads to Undefined behavior." }, { "code": null, "e": 27158, "s": 26991, "text": "For_each can not work with pointers of an array (An array pointer do not know its size, for_each loops will not work with arrays without knowing the size of an array)" }, { "code": null, "e": 27162, "s": 27158, "text": "CPP" }, { "code": "// C++ code to demonstrate the working// of for_each with Exception #include<iostream>#include<vector>#include<algorithm>using namespace std; // Helper function 1void printx2(int a){ cout << a * 2 << \" \"; if ( a % 2 == 0) { throw a; } } // Helper function 2// object type functionstruct Class2{ void operator() (int a) { cout << a * 3 << \" \"; if ( a % 2 == 0) { throw a; } }} ob1; int main(){ // Initializing array int arr[5] = { 1, 5, 2, 4, 3 }; cout << \"Using Array\" << endl; // Printing Exception using for_each // using function try { for_each(arr, arr + 5, printx2); } catch(int i) { cout << \"\\nThe Exception element is : \" << i ; } cout << endl; // Printing Exception using for_each // using object function try { for_each(arr, arr + 5, ob1); } catch(int i) { cout << \"\\nThe Exception element is : \" << i ; } // Initializing vector vector<int> arr1 = { 1, 3, 6, 5, 1 }; cout << \"\\nUsing Vector\" << endl; // Printing Exception using for_each // using function try { for_each(arr1.begin(), arr1.end(), printx2); } catch(int i) { cout << \"\\nThe Exception element is : \" << i ; } cout << endl; // printing Exception using for_each // using object function try { for_each(arr1.begin(), arr1.end(), ob1); } catch(int i) { cout << \"\\nThe Exception element is : \" << i ; }}", "e": 28735, "s": 27162, "text": null }, { "code": null, "e": 28908, "s": 28735, "text": "Using Array\n2 10 4 \nThe Exception element is : 2\n3 15 6 \nThe Exception element is : 2\nUsing Vector\n2 6 12 \nThe Exception element is : 6\n3 9 18 \nThe Exception element is : 6" }, { "code": null, "e": 28923, "s": 28908, "text": "Using Lambdas:" }, { "code": null, "e": 29107, "s": 28923, "text": "With the introduction of lambda functions, this can be easily used to make the whole thing inline which is very compact and useful for people looking for using functional programming." }, { "code": null, "e": 29111, "s": 29107, "text": "C++" }, { "code": "#include <bits/stdc++.h>#include <iostream>using namespace std; int main(){ vector<int> vec{ 1, 2, 3, 4, 5 }; // this increases all the values in the vector by 1; for_each(vec.begin(), vec.end(), [](int& a) { a++; }); // this prints all the values in the vector; for_each(vec.begin(), vec.end(), [](int a) { cout << a << \" \" << endl; }); return 0;}", "e": 29494, "s": 29111, "text": null }, { "code": null, "e": 29509, "s": 29494, "text": "2 \n3 \n4 \n5 \n6 " }, { "code": null, "e": 29930, "s": 29509, "text": "This article is contributed by Astha Tyagi. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to [email protected]. See your article appearing on the GeeksforGeeks main page and help other Geeks. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. " }, { "code": null, "e": 29946, "s": 29930, "text": "sriramvuppuluri" }, { "code": null, "e": 29966, "s": 29946, "text": "harshitmaheshwari20" }, { "code": null, "e": 29982, "s": 29966, "text": "satyakantsahu18" }, { "code": null, "e": 30004, "s": 29982, "text": "cpp-algorithm-library" }, { "code": null, "e": 30030, "s": 30004, "text": "Loops & Control Structure" }, { "code": null, "e": 30034, "s": 30030, "text": "STL" }, { "code": null, "e": 30038, "s": 30034, "text": "C++" }, { "code": null, "e": 30042, "s": 30038, "text": "STL" }, { "code": null, "e": 30046, "s": 30042, "text": "CPP" }, { "code": null, "e": 30144, "s": 30046, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 30163, "s": 30144, "text": "Inheritance in C++" }, { "code": null, "e": 30206, "s": 30163, "text": "Map in C++ Standard Template Library (STL)" }, { "code": null, "e": 30230, "s": 30206, "text": "C++ Classes and Objects" }, { "code": null, "e": 30257, "s": 30230, "text": "Bitwise Operators in C/C++" }, { "code": null, "e": 30285, "s": 30257, "text": "Operator Overloading in C++" }, { "code": null, "e": 30313, "s": 30285, "text": "Socket Programming in C/C++" }, { "code": null, "e": 30333, "s": 30313, "text": "Constructors in C++" }, { "code": null, "e": 30357, "s": 30333, "text": "Virtual Function in C++" }, { "code": null, "e": 30392, "s": 30357, "text": "Multidimensional Arrays in C / C++" } ]

[ { "code": null, "e": 528, "s": 172, "text": "Many a time, I have seen beginners in data science skip exploratory data analysis (EDA) and jump straight into building a hypothesis function or model. In my opinion, this should not be the case. We should first perform an EDA as it will connect us with the dataset at an emotional level and yes, of course, will help in building good hypothesis function." }, { "code": null, "e": 783, "s": 528, "text": "EDA is a very crucial step. It gives us a glimpse of what our data set is all about, its uniqueness, its anomalies and finally it summarizes the main characteristics of the dataset for us. In this post, I will share a very basic guide for performing EDA." }, { "code": null, "e": 846, "s": 783, "text": "Step 1: Import your data set and have a good look at the data." }, { "code": null, "e": 918, "s": 846, "text": "In order to perform EDA, we will require the following python packages." }, { "code": null, "e": 938, "s": 918, "text": "Packages to import:" }, { "code": null, "e": 1101, "s": 938, "text": "Once we have imported the packages successfully, we will move on to importing our dataset. You must be aware of read_csv() tool from pandas for reading csv files." }, { "code": null, "e": 1121, "s": 1101, "text": "Import the dataset:" }, { "code": null, "e": 1259, "s": 1121, "text": "For the purpose of this tutorial, I have used Loan Prediction dataset from Analytics Vidhya. If you wish to code along, here is the link." }, { "code": null, "e": 1343, "s": 1259, "text": "The dataset has been successfully imported. Let’s have a look at the Train dataset." }, { "code": null, "e": 1356, "s": 1343, "text": "Train.head()" }, { "code": null, "e": 1779, "s": 1356, "text": "head() gives us a glimpse of the dataset. It can be considered similar to select * from database_table limit 5 in SQL. Let’s go ahead and explore a little bit more about the different fields in the Train dataset. info() gives uses all the relevant information on the dataset. If your dataset has more numerical variables, consider using describe() too to summarize data along mean, median, standard variance, variance etc." }, { "code": null, "e": 1792, "s": 1779, "text": "Train.info()" }, { "code": null, "e": 2188, "s": 1792, "text": "We observe that there are 614 records and 13 columns in the dataset. Train dataset has Loan_ID, Gender, Married, Dependents, Education, Self_Employed, Property_Area and Loan_status as object types. Object type in pandas is similar to strings. ApplicantIncome field is of integer type. The other three fields namely CoapplicantIncome, Loan_Amount_Term and Credit_History are floating point types." }, { "code": null, "e": 2285, "s": 2188, "text": "Step 2: Now let’s try to classify these columns as Categorical, Ordinal or Numerical/Continuous." }, { "code": null, "e": 2562, "s": 2285, "text": "Categorical Variables: Categorical variables are those data fields that can be divided into definite groups. In this case, Gender(Male OR Female), Married(Yes Or No), Education(Graduate Or Not Graduate), Self_Employed(Yes Or No), Loan_Status(Y Or N) are categorical variables." }, { "code": null, "e": 2930, "s": 2562, "text": "Ordinal Variables: Ordinal variables are the ones that can be divided into groups, but these groups have some kind of order. Like, high, medium, low. Dependents field can be considered ordinal since the data can be clearly divided into 4 categories : 0, 1, 2, 3+ and there is a definite ordering also. Same is the case with Property_Area (Urban, Semi-urban Or Rural)." }, { "code": null, "e": 3254, "s": 2930, "text": "Numerical or Continuous Variables: Numerical variables are those that can take up any value within a given range. For example, applicantIncome, CoapplicantIncome, Loan_Term, Loan_Amount, Credit_History.(I assumed that credit history can be anything between 0 and 1, but for this, it seems more like a categorical variable.)" }, { "code": null, "e": 3442, "s": 3254, "text": "Good Job! You may pat yourself for this, as you now know to identify different types of variables. Going ahead, we will perform univariate, bivariate and multivariate analysis one by one." }, { "code": null, "e": 3501, "s": 3442, "text": "Step 3: Now we are all set to perform Univariate Analysis." }, { "code": null, "e": 3862, "s": 3501, "text": "Univariate analysis involves analysis of one variable at a time. Let’s say “Gender” then we will analyze only the “Gender” field in the dataset. The analysis is usually summarized in the form of count. For visualization, we have many options such as frequency tables, bar graphs, pie charts, histograms etc. Since we are beginners, we will stick to bar charts." }, { "code": null, "e": 3909, "s": 3862, "text": "Here is the basic syntax for plot() in pandas." }, { "code": null, "e": 4079, "s": 3909, "text": "pandas.DataFrame.plot(kind='{bar,barh,pie,box,line,...}',figsize=(x,y), use_index={True,False},title= Name_of_plot, fontsize={integer},colormap={colors_from_matplotlib})" }, { "code": null, "e": 4125, "s": 4079, "text": "Let’s start with categorical variables first." }, { "code": null, "e": 4167, "s": 4125, "text": "Train.Gender.value_counts(normalize=True)" }, { "code": null, "e": 4338, "s": 4167, "text": "This piece of code will take gender field from the Train dataset and perform groupwise count on it. Values have been normalized as it will help in visualizing percentage." }, { "code": null, "e": 4376, "s": 4338, "text": ".plot(kind = 'bar', title = \"Gender\")" }, { "code": null, "e": 4706, "s": 4376, "text": "plot() tool from pandas will help in plotting a chart of a specific kind. The arguments such as kind = ‘bar’, means we want a bar chart. Feel free to choose pie, hist,line, etc. based on your requirement. title = ‘Gender’, this is quite evident, it's the name of the plot. There are other arguments too such as figsize=(x,y) etc." }, { "code": null, "e": 4836, "s": 4706, "text": "We can plot all the categorical variables together using plt.subplot() and give some space between them using plt.tight_layout()." }, { "code": null, "e": 4847, "s": 4836, "text": "Insights :" }, { "code": null, "e": 4904, "s": 4847, "text": "80% of loan applicants are male in the training dataset." }, { "code": null, "e": 4927, "s": 4904, "text": "Nearly 70% are married" }, { "code": null, "e": 4970, "s": 4927, "text": "About 75% of loan applicants are graduates" }, { "code": null, "e": 5018, "s": 4970, "text": "Nearly 85–90% loan applicants are self-employed" }, { "code": null, "e": 5078, "s": 5018, "text": "The loan has been approved for more than 65% of applicants." }, { "code": null, "e": 5115, "s": 5078, "text": "Now let’s move to ordinal variables." }, { "code": null, "e": 5126, "s": 5115, "text": "Insights :" }, { "code": null, "e": 5175, "s": 5126, "text": "Almost 58% of the applicants have no dependents." }, { "code": null, "e": 5256, "s": 5175, "text": "Highest number of applicants are from Semi Urban areas, followed by urban areas." }, { "code": null, "e": 5522, "s": 5256, "text": "Visualization for numerical variables will be a bit different from the ordinal and categorical variables. You may create bar plots by first creating bins, but a better plot will be a distribution, dotted line or box plot, as it will help us in identifying outliers." }, { "code": null, "e": 5532, "s": 5522, "text": "Insights:" }, { "code": null, "e": 5577, "s": 5532, "text": "85% of applicants have a credit history of 1" }, { "code": null, "e": 5621, "s": 5577, "text": "Nearly 85% of loans are taken for 360 days." }, { "code": null, "e": 5691, "s": 5621, "text": "The applicantIncome is mostly between 10000–40000 with some outliers." }, { "code": null, "e": 5796, "s": 5691, "text": "CoapplicantIncome is lesser than applicantIncome and is within the 5000–15000, again with some outliers." }, { "code": null, "e": 5848, "s": 5796, "text": "Loan Amount is mostly concentrated between 250–500." }, { "code": null, "e": 5976, "s": 5848, "text": "We might have to remove outliers from applicantIncome and CoapplicantIncome. But that forms part of the data preparation stage." }, { "code": null, "e": 5996, "s": 5976, "text": "Well Done So far !!" }, { "code": null, "e": 6205, "s": 5996, "text": "Step 4: Now let’s find some relationship between two variables, particularly between the target variable “Loan_Status” and a predictor variable from the dataset. Formally, this is known as bivariate analysis." }, { "code": null, "e": 6357, "s": 6205, "text": "Bivariate Analysis: Bivariate analysis is finding some kind of empirical relationship between two variables. Let’s say ApplicantIncome and Loan_Status." }, { "code": null, "e": 6496, "s": 6357, "text": "Before performing any kind of analysis, let’s create an hypothesis.This hypothesis will act as a guiding light, where to look and analyse." }, { "code": null, "e": 6649, "s": 6496, "text": "I have come up with the following hypothesis after looking at the results of univariate analysis. You may have your own completely different hypothesis." }, { "code": null, "e": 6736, "s": 6649, "text": "Applicants with higher income might have more chances of getting their loans approved." }, { "code": null, "e": 6854, "s": 6736, "text": "Applicants with less number of dependents higher coapplicantIncome might have more chances of getting loan approvals." }, { "code": null, "e": 6945, "s": 6854, "text": "Applicants who are graduates, tend to earn more and hence have higher loan approval rates." }, { "code": null, "e": 7037, "s": 6945, "text": "Applicants who are married, might seem more responsible hence higher loan approval chances." }, { "code": null, "e": 7208, "s": 7037, "text": "Applicants who are not self-employed, might have a higher chances of loan approval as they tend to have constant source of income. There is less uncertainty, I would say." }, { "code": null, "e": 7336, "s": 7208, "text": "Candidates with property in urban areas might have higher chances of loan approval, since the cost of collateral would be high." }, { "code": null, "e": 7404, "s": 7336, "text": "Good credit history should definitely correlate with loan approval." }, { "code": null, "e": 7554, "s": 7404, "text": "For Gender, I don’t have any specific thing in my mind but let’s say women tend to be more responsible and hence high approval rates. (P.S. No Hate)." }, { "code": null, "e": 7627, "s": 7554, "text": "Now, let’s check if this hypothesis, is correct or not for this dataset." }, { "code": null, "e": 7757, "s": 7627, "text": "For visualization, we will be using seaborn.countplot(). It can be considered similar to the histogram for categorical variables." }, { "code": null, "e": 7810, "s": 7757, "text": "The basic syntax for sns.countplot() is as follows :" }, { "code": null, "e": 7937, "s": 7810, "text": "seaborn.countplot(x = 'x_axis_values', y_axis = 'y_axis_values',hue='data_field_on_which_colour_of_bars_depend', data=dataset)" }, { "code": null, "e": 8049, "s": 7937, "text": "Here, I have used the minimum possible arguments, you may use color, saturation etc. for amplifying your plots." }, { "code": null, "e": 8092, "s": 8049, "text": "sns.set(rc={'figure.figsize':(11.7,8.27)})" }, { "code": null, "e": 8149, "s": 8092, "text": "sns.set() is used for setting the size of output figure." }, { "code": null, "e": 8206, "s": 8149, "text": "sns.countplot(x=\"Gender\", hue='Loan_Status', data=Train)" }, { "code": null, "e": 8300, "s": 8206, "text": "sns.countplot() will plot gender field counts, with bars colored based on loan_status values." }, { "code": null, "e": 8311, "s": 8300, "text": "Insights :" }, { "code": null, "e": 8389, "s": 8311, "text": "There is not a substantial difference between male and female approval rates." }, { "code": null, "e": 8457, "s": 8389, "text": "Married applicants have a slightly higher chances of loan approval." }, { "code": null, "e": 8530, "s": 8457, "text": "Graduates have higher chance of loan approval compared to non-graduates." }, { "code": null, "e": 8632, "s": 8530, "text": "There is no substantial difference in the loan approval rates for self_employed vs not self_employed." }, { "code": null, "e": 8745, "s": 8632, "text": "Applicants with no dependents or 2 dependents have higher chances of approval. But this does not correlate well." }, { "code": null, "e": 8825, "s": 8745, "text": "Applicants with properties in semi-urban areas have higher loan approval rates." }, { "code": null, "e": 9035, "s": 8825, "text": "Step 5 : Let’s move on to analyzing more than two variables now. Yay !! You guessed it right, we call it “Multivariate analysis”. You should first create an hypothesis like in step 3 and act in that direction." }, { "code": null, "e": 9099, "s": 9035, "text": "Here is an analysis of Gender, applicantIncome and Loan_Status." }, { "code": null, "e": 9261, "s": 9099, "text": "Since applicantIncome is a continuous field, I have first created 12 bins using np.linspace() function with intervals in the range of min to max ApplicantIncome." }, { "code": null, "e": 9341, "s": 9261, "text": "bins = np.linspace(Train.ApplicantIncome.min(), Train.ApplicantIncome.max(),12)" }, { "code": null, "e": 9519, "s": 9341, "text": "FacetGrid() is used to for plotting conditional relationships between multiple variables. Here, we have Gender group on x-axis and value counts on y-axis and Loan_Status as hue." }, { "code": null, "e": 9609, "s": 9519, "text": "graph = sns.FacetGrid(Train, col=\"Gender\", hue=\"Loan_Status\", palette=\"Set2\", col_wrap=2)" }, { "code": null, "e": 9678, "s": 9609, "text": "Next, we have mapped FacetGrid() plot with bins for ApplicantIncome." }, { "code": null, "e": 9736, "s": 9678, "text": "graph.map(plt.hist, 'ApplicantIncome', bins=bins, ec=\"k\")" }, { "code": null, "e": 9761, "s": 9736, "text": "Now everything together." }, { "code": null, "e": 9823, "s": 9761, "text": "Let’s go ahead and do it for all other possible combinations." }, { "code": null, "e": 9834, "s": 9823, "text": "Insights :" }, { "code": null, "e": 9907, "s": 9834, "text": "Females with income higher than 7000 has higher chances of loan approval" }, { "code": null, "e": 9951, "s": 9907, "text": "Females seem to loan lesser amount than men" }, { "code": null, "e": 10077, "s": 9951, "text": "The coapplicant income for female candidates is less compared to males. However, it does not reflect much on the loan_status." }, { "code": null, "e": 10246, "s": 10077, "text": "This is quite intuitive. You understand the concept right. Now feel free to try more such plots with other predictors such as married, self_employed, property_area etc." }, { "code": null, "e": 10312, "s": 10246, "text": "Finding a correlation between numerical variables in the dataset." }, { "code": null, "e": 10343, "s": 10312, "text": "correlation_mat = Train.corr()" }, { "code": null, "e": 10413, "s": 10343, "text": "Let’s visualize the data in this correlation matrix using a heat map." }, { "code": null, "e": 10541, "s": 10413, "text": "We don’t need the entire heat map. Why not delete the upper half, since its repetitive. A mask can be used to perform the task." }, { "code": null, "e": 10552, "s": 10541, "text": "Insights :" }, { "code": null, "e": 10658, "s": 10552, "text": "There is a positive correlation between ApplicantIncome and LoanAmount, CoapplicantIncome and LoanAmount." }, { "code": null, "e": 10675, "s": 10658, "text": "In a nutshell..." } ]

[ { "code": null, "e": 418, "s": 172, "text": "Often, in real world problems the dataset used to train our models take up much more memory than we have in RAM. The problem is that we cannot load the entire dataset into memory and use the standard keras fit method in order to train our model." }, { "code": null, "e": 663, "s": 418, "text": "One approach to tackle this problem involves loading into memory only one batch of data and then feed it to the net. Repeating this process until we have trained the network with all the dataset. Then we shuffle all the dataset and start again." }, { "code": null, "e": 809, "s": 663, "text": "In order to make a custom generator, keras provide us with a Sequence class. This class is abstract and we can make classes that inherit from it." }, { "code": null, "e": 919, "s": 809, "text": "We are going to code a custom data generator which will be used to yield batches of samples of MNIST Dataset." }, { "code": null, "e": 973, "s": 919, "text": "Firstly, we are going to import the python libraries:" }, { "code": null, "e": 1228, "s": 973, "text": "import tensorflow as tfimport osimport tensorflow.keras as kerasfrom tensorflow.keras.models import Sequentialfrom tensorflow.keras.layers import Dense, Dropout, Flattenfrom tensorflow.keras.layers import Conv2D, MaxPooling2Dimport numpy as npimport math" }, { "code": null, "e": 1289, "s": 1228, "text": "Then we are going to load the MNIST dataset into RAM memory:" }, { "code": null, "e": 1377, "s": 1289, "text": "mnist = tf.keras.datasets.mnist(x_train, y_train), (x_test, y_test) = mnist.load_data()" }, { "code": null, "e": 1476, "s": 1377, "text": "The MNIST Dataset consist of 60000 training images of handwritten digits and 10000 testing images." }, { "code": null, "e": 1673, "s": 1476, "text": "Each image have dimensions of 28 x 28 pixels. You should take into account that in order to train the model we have to convert uint8 data to float32. Each pixel in float32 needs 4 bytes of memory." }, { "code": null, "e": 1709, "s": 1673, "text": "Therefore the whole dataset needs :" }, { "code": null, "e": 1793, "s": 1709, "text": "4 bytes per pixel * (28 * 28 ) pixels per image * 70000 images + (70000*10) labels." }, { "code": null, "e": 1913, "s": 1793, "text": "In total 220 Mb of memory that can perfectly fit in RAM memory but in real world problems we may need much more memory." }, { "code": null, "e": 2047, "s": 1913, "text": "Our generator simulated generator is going to load the images from RAM but in a real problem they would be loaded from the hard disk." }, { "code": null, "e": 4199, "s": 2047, "text": "class DataGenerator(tf.compat.v2.keras.utils.Sequence): def __init__(self, X_data , y_data, batch_size, dim, n_classes, to_fit, shuffle = True): self.batch_size = batch_size self.X_data = X_data self.labels = y_data self.y_data = y_data self.to_fit = to_fit self.n_classes = n_classes self.dim = dim self.shuffle = shuffle self.n = 0 self.list_IDs = np.arange(len(self.X_data)) self.on_epoch_end() def __next__(self): # Get one batch of data data = self.__getitem__(self.n) # Batch index self.n += 1 # If we have processed the entire dataset then if self.n >= self.__len__(): self.on_epoch_end self.n = 0 return data def __len__(self): # Return the number of batches of the dataset return math.ceil(len(self.indexes)/self.batch_size) def __getitem__(self, index): # Generate indexes of the batch indexes = self.indexes[index*self.batch_size: (index+1)*self.batch_size] # Find list of IDs list_IDs_temp = [self.list_IDs[k] for k in indexes] X = self._generate_x(list_IDs_temp) if self.to_fit: y = self._generate_y(list_IDs_temp) return X, y else: return X def on_epoch_end(self): self.indexes = np.arange(len(self.X_data)) if self.shuffle: np.random.shuffle(self.indexes) def _generate_x(self, list_IDs_temp): X = np.empty((self.batch_size, *self.dim)) for i, ID in enumerate(list_IDs_temp): X[i,] = self.X_data[ID] # Normalize data X = (X/255).astype('float32') return X[:,:,:, np.newaxis] def _generate_y(self, list_IDs_temp): y = np.empty(self.batch_size) for i, ID in enumerate(list_IDs_temp): y[i] = self.y_data[ID] return keras.utils.to_categorical( y,num_classes=self.n_classes)" }, { "code": null, "e": 4250, "s": 4199, "text": "Then we are going to build the classification net:" }, { "code": null, "e": 4814, "s": 4250, "text": "n_classes = 10input_shape = (28, 28)model = Sequential()model.add(Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28 , 1)))model.add(Conv2D(64, (3, 3), activation='relu'))model.add(MaxPooling2D(pool_size=(2, 2)))model.add(Dropout(0.25))model.add(Flatten())model.add(Dense(128, activation='relu'))model.add(Dropout(0.5))model.add(Dense(n_classes, activation='softmax'))model.compile(loss=keras.losses.categorical_crossentropy, optimizer=keras.optimizers.Adadelta(), metrics=['accuracy'])" }, { "code": null, "e": 4870, "s": 4814, "text": "The next step is to make an instance of our generators:" }, { "code": null, "e": 5313, "s": 4870, "text": "train_generator = DataGenerator(x_train, y_train, batch_size = 64, dim = input_shape, n_classes=10, to_fit=True, shuffle=True)val_generator = DataGenerator(x_test, y_test, batch_size=64, dim = input_shape, n_classes= n_classes, to_fit=True, shuffle=True)" }, { "code": null, "e": 5551, "s": 5313, "text": "If we want to check if the generator is working correctly, we can call to the next() method that yields a batch of samples and labels. Then check if the datatype of images and labels are correct, check the dimensions of the batch, etc..." }, { "code": null, "e": 5628, "s": 5551, "text": "images, labels = next(train_generator)print(images.shape)print(labels.shape)" }, { "code": null, "e": 5700, "s": 5628, "text": "If we want that in one epoch the whole dataset is fed into the network:" }, { "code": null, "e": 5776, "s": 5700, "text": "steps_per_epoch = len(train_generator)validation_steps = len(val_generator)" }, { "code": null, "e": 5860, "s": 5776, "text": "Finally we are going to train the network with the keras function fit_generator() ." }, { "code": null, "e": 6043, "s": 5860, "text": "model.fit_generator( train_generator, steps_per_epoch=steps_per_epoch, epochs=10, validation_data=val_generator, validation_steps=validation_steps)" } ]

[ { "code": null, "e": 1262, "s": 1062, "text": "We can get the user Agent information with Selenium webdriver. This is done with the help of the JavaScript Executor. Selenium executes JavaScript commands with the help of the execute_script method." }, { "code": null, "e": 1455, "s": 1262, "text": "To obtain the user Agent information, we have to pass the return navigator.userAgent parameter to the execute_script method. Selenium does have a direct method the to get or modify user Agent." }, { "code": null, "e": 1519, "s": 1455, "text": "a= driver.execute_script(\"return navigator.userAgent\")\nprint(a)" }, { "code": null, "e": 2030, "s": 1519, "text": "from selenium import webdriver\nfrom selenium.webdriver.chrome.options import Options\n#object of Options class\nop = webdriver.ChromeOptions()\n#set chromedriver.exe path\ndriver = webdriver.Chrome(executable_path=\"C:\\\\chromedriver.exe\",\noptions=op)\n#maximize browser\ndriver.maximize_window()\n#launch URL\ndriver.get(\"https://www.seleniumhq.org/download/\");\n#get user Agent with execute_script\na= driver.execute_script(\"return navigator.userAgent\")\nprint(\"User agent:\")\nprint(a)\n#close browser session\ndriver.quit()" } ]

[ { "code": null, "e": 503, "s": 171, "text": "This post is all about teaching AI how to play a simple game which I built using pygame library. The game is, the ball should keep on rolling through the gap between the pipes, if the ball hits any of the pipe then we lose. As and when a ball successfully passes through the gap between the pipes, the score will be increased by 1." }, { "code": null, "e": 694, "s": 503, "text": "The Gif image above shows the training process of how neural network improves generation after generation and the progress status can be seen the in game window using the below three values." }, { "code": null, "e": 763, "s": 694, "text": "Score: Number of points scored/number of pipes successfully crossed." }, { "code": null, "e": 835, "s": 763, "text": "Gens: Number of generations/mutations the algorithm is taking to learn." }, { "code": null, "e": 905, "s": 835, "text": "Balls: Indicates the number of balls alive in the current generation." }, { "code": null, "e": 993, "s": 905, "text": "The complete code to build the game interface and the related files are in my Git repo." }, { "code": null, "e": 1479, "s": 993, "text": "Now lets come to the training part using NEAT (NeuroEvolution of Augmenting Topologies). NEAT is an evolutionary algorithm that creates artificial neural networks, a detailed description of the algorithm is here. The basic idea here is instead of relying on a fixed structure for the network, NEAT allows it to evolve through a genetic algorithm. So it builds a most optimal network by itself by adding nodes, connections and layers as and when required to accomplish the task in hand." }, { "code": null, "e": 1672, "s": 1479, "text": "Once we have a game ready, we feed the below inputs/parameters to the NEAT algorithm to create a best neural network which accomplishes the task, in our case rolling the ball through the gaps." }, { "code": null, "e": 1731, "s": 1672, "text": "We pass all these parameters through a Configuration file." }, { "code": null, "e": 1842, "s": 1731, "text": "Inputs for the Network: Telling the NEAT algorithm what inputs the network can expect and what output we need." }, { "code": null, "e": 1966, "s": 1842, "text": "Num_Hidden: I have set the number of hidden layers to 0 as it is a simple game, we can try with another number if required." }, { "code": null, "e": 2143, "s": 1966, "text": "Num_Inputs: I am passing 3 inputs for the network. Position of the Ball on Y axis, Distance between the ball and the top pipe and distance between the ball and the bottom pipe." }, { "code": null, "e": 2271, "s": 2143, "text": "Num_Outputs: It is set to 1, i.e single node in the output. Based on the value of the output node we decide to Jump or No Jump." }, { "code": null, "e": 2391, "s": 2271, "text": "# we used tanh activation function so result will be between -1 & 1. if over 0.5 jumpif output[0] > 0.5: ball.jump()" }, { "code": null, "e": 2412, "s": 2391, "text": "Activation Function:" }, { "code": null, "e": 2584, "s": 2412, "text": "Activation default: Which activation function to use to determine the output value, in this case, I used Tanh. We can use other activation functions like sigmoid/relu etc." }, { "code": null, "e": 2679, "s": 2584, "text": "Activation_mutate_rate: Probability of picking the other activation functions during mutation." }, { "code": null, "e": 2772, "s": 2679, "text": "Activation options: Other Activation functions to use randomly during the mutation/breeding." }, { "code": null, "e": 2852, "s": 2772, "text": "Fitness Parameters: Way to evaluate how good the network/ball is like distance." }, { "code": null, "e": 3020, "s": 2852, "text": "Fitness_criterion: It can have the values of min/max/mean. Which tells the NEAT how to pick the best network/ball. The ball with the maximum fitness score is the best." }, { "code": null, "e": 3104, "s": 3020, "text": "Fitness_threshold: Max fitness score to reach before stopping the training process." }, { "code": null, "e": 3365, "s": 3104, "text": "Pop_size: Arbitrary value and we can play around. It indicates how many balls in each generation. Start the Generation Zero with 20 members/balls, test them, select the best, breed/mutate them to create the next generation of 20 balls and continue the process." }, { "code": null, "e": 3532, "s": 3365, "text": "Reset on extinction: If this evaluates to True, when all species(balls) in a simultaneously become extinct due to stagnation, a new random population will be created." }, { "code": null, "e": 4116, "s": 3532, "text": "In NEAT we call the population members as genomes/species and once the properties of genomes are set as above, neat starts building a network by creating a population of balls which we set it to 20. Each ball is associated with a completely random neural network that controls it & each network has its own random weights and biases. So we test each of the neural networks and see how well they do by evaluating their fitness. Fitness depends on what task/game we play, in this case how far the ball progresses. Every pipe it crosses we are adding 1 to its fitness score in the game." }, { "code": null, "e": 4498, "s": 4116, "text": "At the end of the first generation when all the balls are exhausted, neat sees which among them performed the best. It then picks those best of the last generation of balls/networks (two or three with the highest score), mutate and breed them to create a new set of population. A detailed explanation of how neat actually breeds and mutates these neural networks are in this paper." }, { "code": null, "e": 5007, "s": 4498, "text": "Now we will have the off-springs of the best species/balls from the last generation. So we hope that these next generation of species/balls perform better compare to the previous generation. What neat actually does is, it updates the weights, randomly adds/removes the nodes and connections until it finds an architecture that works best for the problem we are solving. It starts with a simple network and gets complex if required. We need to continue the process until we are satisfied with the performance." }, { "code": null, "e": 5330, "s": 5007, "text": "After a few generations of slowly learning and getting better, it finally pick up a pattern of moving ahead without hitting the pipes. In this case with the current set of parameters, in the 4th generation itself, AI starts performing better and reached a point where it never fails as we could see in the above gif image." }, { "code": null, "e": 5597, "s": 5330, "text": "Once the score reaches the fitness threshold we set, then we can exit the training by saving the neural network associated with that ball using pickle. Then create a game with one ball and the best Network we saved. Now it plays seamlessly by never hitting the pipe." } ]

[ { "code": null, "e": 24513, "s": 24485, "text": "\n01 Jun, 2020" }, { "code": null, "e": 24981, "s": 24513, "text": "List is a type of an object in R programming. Lists can contain heterogeneous elements like strings, numeric, matrices, or even lists. A list is a generic vector containing other objects. Two-dimensional list can be created in R programming by creating more lists in a list or simply, we can say nested lists. The list() function in R programming is used to create a list. In this article, we’ll learn to create plot graph using Two Dimensional List in R programming." }, { "code": null, "e": 25052, "s": 24981, "text": "A Two Dimensional list can be created with the use of list() function." }, { "code": null, "e": 25068, "s": 25052, "text": "Syntax: list(x)" }, { "code": null, "e": 25123, "s": 25068, "text": "Parameter:x: represents objects to be inserted in list" }, { "code": null, "e": 25132, "s": 25123, "text": "Example:" }, { "code": "# Defining objectsx <- c(1, 2, 3, 4) y <- LETTERS[1:4] # Adding lists into a listls <- list( list(x), list(y)) # Print listprint(ls)", "e": 25271, "s": 25132, "text": null }, { "code": null, "e": 25279, "s": 25271, "text": "Output:" }, { "code": null, "e": 25349, "s": 25279, "text": "[[1]]\n[[1]][[1]]\n[1] 1 2 3 4\n\n\n[[2]]\n[[2]][[1]]\n[1] \"A\" \"B\" \"C\" \"D\"\n\n" }, { "code": null, "e": 25523, "s": 25349, "text": "To create plot graphs, lists have to be passed as vectors to the plot() function as coordinate values. The unlist() function converts the list into an atomic type of vector." }, { "code": null, "e": 25532, "s": 25523, "text": "Example:" }, { "code": "# Creating nested lists with random valuesls <- list( list(rnorm(20, mean = 10, sd = 2)), list(rnorm(20, mean = 100, sd = 10))) # Output to be present as PNG filepng(file = \"2DListGraph.png\") # Plotting listplot(unlist(ls[[1]]), unlist(ls[[2]])) # Saving the filedev.off()", "e": 25810, "s": 25532, "text": null }, { "code": null, "e": 25818, "s": 25810, "text": "Output:" }, { "code": null, "e": 25825, "s": 25818, "text": "Picked" }, { "code": null, "e": 25832, "s": 25825, "text": "R-List" }, { "code": null, "e": 25840, "s": 25832, "text": "R-plots" }, { "code": null, "e": 25851, "s": 25840, "text": "R Language" }, { "code": null, "e": 25949, "s": 25851, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 25958, "s": 25949, "text": "Comments" }, { "code": null, "e": 25971, "s": 25958, "text": "Old Comments" }, { "code": null, "e": 26029, "s": 25971, "text": "How to Replace specific values in column in R DataFrame ?" }, { "code": null, "e": 26073, "s": 26029, "text": "How to change Row Names of DataFrame in R ?" }, { "code": null, "e": 26125, "s": 26073, "text": "Filter data by multiple conditions in R using Dplyr" }, { "code": null, "e": 26177, "s": 26125, "text": "Change Color of Bars in Barchart using ggplot2 in R" }, { "code": null, "e": 26209, "s": 26177, "text": "Loops in R (for, while, repeat)" }, { "code": null, "e": 26241, "s": 26209, "text": "Printing Output of an R Program" }, { "code": null, "e": 26279, "s": 26241, "text": "How to Change Axis Scales in R Plots?" }, { "code": null, "e": 26314, "s": 26279, "text": "Group by function in R using Dplyr" }, { "code": null, "e": 26372, "s": 26314, "text": "How to Split Column Into Multiple Columns in R DataFrame?" } ]

[ { "code": null, "e": 3049, "s": 2825, "text": "The PostgreSQL extension is enabled by default in the latest releases of PHP 5.3.x. It is possible to disable it by using --without-pgsql at compile time. Still you can use yum command to install PHP -PostgreSQL interface −" }, { "code": null, "e": 3071, "s": 3049, "text": "yum install php-pgsql" }, { "code": null, "e": 3221, "s": 3071, "text": "Before you start using the PHP PostgreSQL interface, find the pg_hba.conf file in your PostgreSQL installation directory and add the following line −" }, { "code": null, "e": 3305, "s": 3221, "text": "# IPv4 local connections:\nhost all all 127.0.0.1/32 md5" }, { "code": null, "e": 3405, "s": 3305, "text": "You can start/restart the postgres server, in case it is not running, using the following command −" }, { "code": null, "e": 3581, "s": 3405, "text": "[root@host]# service postgresql restart\nStopping postgresql service: [ OK ]\nStarting postgresql service: [ OK ]" }, { "code": null, "e": 3737, "s": 3581, "text": "Windows users must enable php_pgsql.dll in order to use this extension. This DLL is included with Windows distributions in the latest releases of PHP 5.3.x" }, { "code": null, "e": 3833, "s": 3737, "text": "For detailed installation instructions, kindly check our PHP tutorial and its official website." }, { "code": null, "e": 4078, "s": 3833, "text": "The following are important PHP routines, which can suffice your requirement to work with PostgreSQL database from your PHP program. If you are looking for a more sophisticated application, then you can look into the PHP official documentation." }, { "code": null, "e": 4151, "s": 4078, "text": "resource pg_connect ( string $connection_string [, int $connect_type ] )" }, { "code": null, "e": 4236, "s": 4151, "text": "This opens a connection to a PostgreSQL database specified by the connection_string." }, { "code": null, "e": 4435, "s": 4236, "text": "If PGSQL_CONNECT_FORCE_NEW is passed as connect_type, then a new connection is created in case of a second call to pg_connect(), even if the connection_string is identical to an existing connection." }, { "code": null, "e": 4485, "s": 4435, "text": "bool pg_connection_reset ( resource $connection )" }, { "code": null, "e": 4599, "s": 4485, "text": "This routine resets the connection. It is useful for error recovery. Returns TRUE on success or FALSE on failure." }, { "code": null, "e": 4649, "s": 4599, "text": "int pg_connection_status ( resource $connection )" }, { "code": null, "e": 4763, "s": 4649, "text": "This routine returns the status of the specified connection. Returns PGSQL_CONNECTION_OK or PGSQL_CONNECTION_BAD." }, { "code": null, "e": 4808, "s": 4763, "text": "string pg_dbname ([ resource $connection ] )" }, { "code": null, "e": 4901, "s": 4808, "text": "This routine returns the name of the database that the given PostgreSQL connection resource." }, { "code": null, "e": 4982, "s": 4901, "text": "resource pg_prepare ([ resource $connection ], string $stmtname, string $query )" }, { "code": null, "e": 5088, "s": 4982, "text": "This submits a request to create a prepared statement with the given parameters and waits for completion." }, { "code": null, "e": 5169, "s": 5088, "text": "resource pg_execute ([ resource $connection ], string $stmtname, array $params )" }, { "code": null, "e": 5278, "s": 5169, "text": "This routine sends a request to execute a prepared statement with given parameters and waits for the result." }, { "code": null, "e": 5339, "s": 5278, "text": "resource pg_query ([ resource $connection ], string $query )" }, { "code": null, "e": 5409, "s": 5339, "text": "This routine executes the query on the specified database connection." }, { "code": null, "e": 5463, "s": 5409, "text": "array pg_fetch_row ( resource $result [, int $row ] )" }, { "code": null, "e": 5563, "s": 5463, "text": "This routine fetches one row of data from the result associated with the specified result resource." }, { "code": null, "e": 5603, "s": 5563, "text": "array pg_fetch_all ( resource $result )" }, { "code": null, "e": 5690, "s": 5603, "text": "This routine returns an array that contains all rows (records) in the result resource." }, { "code": null, "e": 5732, "s": 5690, "text": "int pg_affected_rows ( resource $result )" }, { "code": null, "e": 5820, "s": 5732, "text": "This routine returns the number of rows affected by INSERT, UPDATE, and DELETE queries." }, { "code": null, "e": 5857, "s": 5820, "text": "int pg_num_rows ( resource $result )" }, { "code": null, "e": 5986, "s": 5857, "text": "This routine returns the number of rows in a PostgreSQL result resource for example number of rows returned by SELECT statement." }, { "code": null, "e": 6028, "s": 5986, "text": "bool pg_close ([ resource $connection ] )" }, { "code": null, "e": 6150, "s": 6028, "text": "This routine closes the non-persistent connection to a PostgreSQL database associated with the given connection resource." }, { "code": null, "e": 6199, "s": 6150, "text": "string pg_last_error ([ resource $connection ] )" }, { "code": null, "e": 6268, "s": 6199, "text": "This routine returns the last error message for a given connection." }, { "code": null, "e": 6335, "s": 6268, "text": "string pg_escape_literal ([ resource $connection ], string $data )" }, { "code": null, "e": 6399, "s": 6335, "text": "This routine escapes a literal for insertion into a text field." }, { "code": null, "e": 6465, "s": 6399, "text": "string pg_escape_string ([ resource $connection ], string $data )" }, { "code": null, "e": 6522, "s": 6465, "text": "This routine escapes a string for querying the database." }, { "code": null, "e": 6668, "s": 6522, "text": "The following PHP code shows how to connect to an existing database on a local machine and finally a database connection object will be returned." }, { "code": null, "e": 7024, "s": 6668, "text": "<?php\n $host = \"host = 127.0.0.1\";\n $port = \"port = 5432\";\n $dbname = \"dbname = testdb\";\n $credentials = \"user = postgres password=pass123\";\n\n $db = pg_connect( \"$host $port $dbname $credentials\" );\n if(!$db) {\n echo \"Error : Unable to open database\\n\";\n } else {\n echo \"Opened database successfully\\n\";\n }\n?>" }, { "code": null, "e": 7175, "s": 7024, "text": "Now, let us run the above given program to open our database testdb: if the database is successfully opened, then it will give the following message −" }, { "code": null, "e": 7205, "s": 7175, "text": "Opened database successfully\n" }, { "code": null, "e": 7297, "s": 7205, "text": "The following PHP program will be used to create a table in a previously created database −" }, { "code": null, "e": 8038, "s": 7297, "text": "<?php\n $host = \"host = 127.0.0.1\";\n $port = \"port = 5432\";\n $dbname = \"dbname = testdb\";\n $credentials = \"user = postgres password=pass123\";\n\n $db = pg_connect( \"$host $port $dbname $credentials\" );\n if(!$db) {\n echo \"Error : Unable to open database\\n\";\n } else {\n echo \"Opened database successfully\\n\";\n }\n \n $sql =<<<EOF\n CREATE TABLE COMPANY\n (ID INT PRIMARY KEY NOT NULL,\n NAME TEXT NOT NULL,\n AGE INT NOT NULL,\n ADDRESS CHAR(50),\n SALARY REAL);\nEOF;\n\n $ret = pg_query($db, $sql);\n if(!$ret) {\n echo pg_last_error($db);\n } else {\n echo \"Table created successfully\\n\";\n }\n pg_close($db);\n?>" }, { "code": null, "e": 8169, "s": 8038, "text": "When the above given program is executed, it will create COMPANY table in your testdb and it will display the following messages −" }, { "code": null, "e": 8226, "s": 8169, "text": "Opened database successfully\nTable created successfully\n" }, { "code": null, "e": 8332, "s": 8226, "text": "The following PHP program shows how we can create records in our COMPANY table created in above example −" }, { "code": null, "e": 9300, "s": 8332, "text": "<?php\n $host = \"host=127.0.0.1\";\n $port = \"port=5432\";\n $dbname = \"dbname = testdb\";\n $credentials = \"user = postgres password=pass123\";\n\n $db = pg_connect( \"$host $port $dbname $credentials\" );\n if(!$db) {\n echo \"Error : Unable to open database\\n\";\n } else {\n echo \"Opened database successfully\\n\";\n }\n\n $sql =<<<EOF\n INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)\n VALUES (1, 'Paul', 32, 'California', 20000.00 );\n\n INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)\n VALUES (2, 'Allen', 25, 'Texas', 15000.00 );\n\n INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)\n VALUES (3, 'Teddy', 23, 'Norway', 20000.00 );\n\n INSERT INTO COMPANY (ID,NAME,AGE,ADDRESS,SALARY)\n VALUES (4, 'Mark', 25, 'Rich-Mond ', 65000.00 );\nEOF;\n\n $ret = pg_query($db, $sql);\n if(!$ret) {\n echo pg_last_error($db);\n } else {\n echo \"Records created successfully\\n\";\n }\n pg_close($db);\n?>" }, { "code": null, "e": 9435, "s": 9300, "text": "When the above given program is executed, it will create the given records in COMPANY table and will display the following two lines −" }, { "code": null, "e": 9494, "s": 9435, "text": "Opened database successfully\nRecords created successfully\n" }, { "code": null, "e": 9613, "s": 9494, "text": "The following PHP program shows how we can fetch and display records from our COMPANY table created in above example −" }, { "code": null, "e": 10372, "s": 9613, "text": "<?php\n $host = \"host = 127.0.0.1\";\n $port = \"port = 5432\";\n $dbname = \"dbname = testdb\";\n $credentials = \"user = postgres password=pass123\";\n\n $db = pg_connect( \"$host $port $dbname $credentials\" );\n if(!$db) {\n echo \"Error : Unable to open database\\n\";\n } else {\n echo \"Opened database successfully\\n\";\n }\n\n $sql =<<<EOF\n SELECT * from COMPANY;\nEOF;\n\n $ret = pg_query($db, $sql);\n if(!$ret) {\n echo pg_last_error($db);\n exit;\n } \n while($row = pg_fetch_row($ret)) {\n echo \"ID = \". $row[0] . \"\\n\";\n echo \"NAME = \". $row[1] .\"\\n\";\n echo \"ADDRESS = \". $row[2] .\"\\n\";\n echo \"SALARY = \".$row[4] .\"\\n\\n\";\n }\n echo \"Operation done successfully\\n\";\n pg_close($db);\n?>" }, { "code": null, "e": 10542, "s": 10372, "text": "When the above given program is executed, it will produce the following result. Keep a note that fields are returned in the sequence they were used while creating table." }, { "code": null, "e": 10820, "s": 10542, "text": "Opened database successfully\nID = 1\nNAME = Paul\nADDRESS = California\nSALARY = 20000\n\nID = 2\nNAME = Allen\nADDRESS = Texas\nSALARY = 15000\n\nID = 3\nNAME = Teddy\nADDRESS = Norway\nSALARY = 20000\n\nID = 4\nNAME = Mark\nADDRESS = Rich-Mond\nSALARY = 65000\n\nOperation done successfully\n" }, { "code": null, "e": 10974, "s": 10820, "text": "The following PHP code shows how we can use the UPDATE statement to update any record and then fetch and display updated records from our COMPANY table −" }, { "code": null, "e": 11958, "s": 10974, "text": "<?php\n $host = \"host=127.0.0.1\";\n $port = \"port=5432\";\n $dbname = \"dbname = testdb\";\n $credentials = \"user = postgres password=pass123\";\n\n $db = pg_connect( \"$host $port $dbname $credentials\" );\n if(!$db) {\n echo \"Error : Unable to open database\\n\";\n } else {\n echo \"Opened database successfully\\n\";\n }\n $sql =<<<EOF\n UPDATE COMPANY set SALARY = 25000.00 where ID=1;\nEOF;\n $ret = pg_query($db, $sql);\n if(!$ret) {\n echo pg_last_error($db);\n exit;\n } else {\n echo \"Record updated successfully\\n\";\n }\n \n $sql =<<<EOF\n SELECT * from COMPANY;\nEOF;\n\n $ret = pg_query($db, $sql);\n if(!$ret) {\n echo pg_last_error($db);\n exit;\n } \n while($row = pg_fetch_row($ret)) {\n echo \"ID = \". $row[0] . \"\\n\";\n echo \"NAME = \". $row[1] .\"\\n\";\n echo \"ADDRESS = \". $row[2] .\"\\n\";\n echo \"SALARY = \".$row[4] .\"\\n\\n\";\n }\n echo \"Operation done successfully\\n\";\n pg_close($db);\n?>" }, { "code": null, "e": 12039, "s": 11958, "text": "When the above given program is executed, it will produce the following result −" }, { "code": null, "e": 12323, "s": 12039, "text": "Opened database successfully\nRecord updated successfully\nID = 2\nNAME = Allen\nADDRESS = 25\nSALARY = 15000\n\nID = 3\nNAME = Teddy\nADDRESS = 23\nSALARY = 20000\n\nID = 4\nNAME = Mark\nADDRESS = 25\nSALARY = 65000\n\nID = 1\nNAME = Paul\nADDRESS = 32\nSALARY = 25000\n\nOperation done successfully\n" }, { "code": null, "e": 12483, "s": 12323, "text": "The following PHP code shows how we can use the DELETE statement to delete any record and then fetch and display the remaining records from our COMPANY table −" }, { "code": null, "e": 13454, "s": 12483, "text": "<?php\n $host = \"host = 127.0.0.1\";\n $port = \"port = 5432\";\n $dbname = \"dbname = testdb\";\n $credentials = \"user = postgres password=pass123\";\n\n $db = pg_connect( \"$host $port $dbname $credentials\" );\n if(!$db) {\n echo \"Error : Unable to open database\\n\";\n } else {\n echo \"Opened database successfully\\n\";\n }\n $sql =<<<EOF\n DELETE from COMPANY where ID=2;\nEOF;\n $ret = pg_query($db, $sql);\n if(!$ret) {\n echo pg_last_error($db);\n exit;\n } else {\n echo \"Record deleted successfully\\n\";\n }\n \n $sql =<<<EOF\n SELECT * from COMPANY;\nEOF;\n\n $ret = pg_query($db, $sql);\n if(!$ret) {\n echo pg_last_error($db);\n exit;\n } \n while($row = pg_fetch_row($ret)) {\n echo \"ID = \". $row[0] . \"\\n\";\n echo \"NAME = \". $row[1] .\"\\n\";\n echo \"ADDRESS = \". $row[2] .\"\\n\";\n echo \"SALARY = \".$row[4] .\"\\n\\n\";\n }\n echo \"Operation done successfully\\n\";\n pg_close($db);\n?>" }, { "code": null, "e": 13535, "s": 13454, "text": "When the above given program is executed, it will produce the following result −" }, { "code": null, "e": 13769, "s": 13535, "text": "Opened database successfully\nRecord deleted successfully\nID = 3\nNAME = Teddy\nADDRESS = 23\nSALARY = 20000\n\nID = 4\nNAME = Mark\nADDRESS = 25\nSALARY = 65000\n\nID = 1\nNAME = Paul\nADDRESS = 32\nSALARY = 25000\n\nOperation done successfully\n" }, { "code": null, "e": 13804, "s": 13769, "text": "\n 23 Lectures \n 1.5 hours \n" }, { "code": null, "e": 13816, "s": 13804, "text": " John Elder" }, { "code": null, "e": 13851, "s": 13816, "text": "\n 49 Lectures \n 3.5 hours \n" }, { "code": null, "e": 13867, "s": 13851, "text": " Niyazi Erdogan" }, { "code": null, "e": 13904, "s": 13867, "text": "\n 126 Lectures \n 10.5 hours \n" }, { "code": null, "e": 13926, "s": 13904, "text": " Abhishek And Pukhraj" }, { "code": null, "e": 13959, "s": 13926, "text": "\n 35 Lectures \n 5 hours \n" }, { "code": null, "e": 13973, "s": 13959, "text": " Karthikeya T" }, { "code": null, "e": 14004, "s": 13973, "text": "\n 5 Lectures \n 51 mins\n" }, { "code": null, "e": 14017, "s": 14004, "text": " Vinay Kumar" }, { "code": null, "e": 14048, "s": 14017, "text": "\n 5 Lectures \n 52 mins\n" }, { "code": null, "e": 14061, "s": 14048, "text": " Vinay Kumar" }, { "code": null, "e": 14068, "s": 14061, "text": " Print" }, { "code": null, "e": 14079, "s": 14068, "text": " Add Notes" } ]

[ { "code": null, "e": 366, "s": 172, "text": "Update: April 29, 2019. Updated some of the code to not use ggplot but instead use seaborn and matplotlib. I also added an example for a 3d-plot. I also changed the syntax to work with Python3." }, { "code": null, "e": 594, "s": 366, "text": "The first step around any data related challenge is to start by exploring the data itself. This could be by looking at, for example, the distributions of certain variables or looking at potential correlations between variables." }, { "code": null, "e": 1205, "s": 594, "text": "The problem nowadays is that most datasets have a large number of variables. In other words, they have a high number of dimensions along which the data is distributed. Visually exploring the data can then become challenging and most of the time even practically impossible to do manually. However, such visual exploration is incredibly important in any data-related problem. Therefore it is key to understand how to visualise high-dimensional datasets. This can be achieved using techniques known as dimensionality reduction. This post will focus on two techniques that will allow us to do this: PCA and t-SNE." }, { "code": null, "e": 1286, "s": 1205, "text": "More about that later. Lets first get some (high-dimensional) data to work with." }, { "code": null, "e": 1430, "s": 1286, "text": "We will use the MNIST-dataset in this write-up. There is no need to download the dataset manually as we can grab it through using Scikit Learn." }, { "code": null, "e": 1470, "s": 1430, "text": "First let’s get all libraries in place." }, { "code": null, "e": 1776, "s": 1470, "text": "from __future__ import print_functionimport timeimport numpy as npimport pandas as pdfrom sklearn.datasets import fetch_mldatafrom sklearn.decomposition import PCAfrom sklearn.manifold import TSNE%matplotlib inlineimport matplotlib.pyplot as pltfrom mpl_toolkits.mplot3d import Axes3Dimport seaborn as sns" }, { "code": null, "e": 1820, "s": 1776, "text": "and let’s then start by loading in the data" }, { "code": null, "e": 1947, "s": 1820, "text": "mnist = fetch_mldata(\"MNIST original\")X = mnist.data / 255.0y = mnist.targetprint(X.shape, y.shape)[out] (70000, 784) (70000,)" }, { "code": null, "e": 2117, "s": 1947, "text": "We are going to convert the matrix and vector to a Pandas DataFrame. This is very similar to the DataFrames used in R and will make it easier for us to plot it later on." }, { "code": null, "e": 2378, "s": 2117, "text": "feat_cols = [ 'pixel'+str(i) for i in range(X.shape[1]) ]df = pd.DataFrame(X,columns=feat_cols)df['y'] = ydf['label'] = df['y'].apply(lambda i: str(i))X, y = None, Noneprint('Size of the dataframe: {}'.format(df.shape))[out] Size of the dataframe: (70000, 785)" }, { "code": null, "e": 2801, "s": 2378, "text": "Because we dont want to be using 70,000 digits in some calculations we’ll take a random subset of the digits. The randomisation is important as the dataset is sorted by its label (i.e., the first seven thousand or so are zeros, etc.). To ensure randomisation we’ll create a random permutation of the number 0 to 69,999 which allows us later to select the first five or ten thousand for our calculations and visualisations." }, { "code": null, "e": 2900, "s": 2801, "text": "# For reproducability of the resultsnp.random.seed(42)rndperm = np.random.permutation(df.shape[0])" }, { "code": null, "e": 3076, "s": 2900, "text": "We now have our dataframe and our randomisation vector. Lets first check what these numbers actually look like. To do this we’ll generate 30 plots of randomly selected images." }, { "code": null, "e": 3327, "s": 3076, "text": "plt.gray()fig = plt.figure( figsize=(16,7) )for i in range(0,15): ax = fig.add_subplot(3,5,i+1, title=\"Digit: {}\".format(str(df.loc[rndperm[i],'label'])) ) ax.matshow(df.loc[rndperm[i],feat_cols].values.reshape((28,28)).astype(float))plt.show()" }, { "code": null, "e": 3809, "s": 3327, "text": "Now we can start thinking about how we can actually distinguish the zeros from the ones and two’s and so on. If you were, for example, a post office such an algorithm could help you read and sort the handwritten envelopes using a machine instead of having humans do that. Obviously nowadays we have very advanced methods to do this, but this dataset still provides a very good testing ground for seeing how specific methods for dimensionality reduction work and how well they work." }, { "code": null, "e": 3956, "s": 3809, "text": "The images are all essentially 28-by-28 pixel images and therefore have a total of 784 ‘dimensions’, each holding the value of one specific pixel." }, { "code": null, "e": 4226, "s": 3956, "text": "What we can do is reduce the number of dimensions drastically whilst trying to retain as much of the ‘variation’ in the information as possible. This is where we get to dimensionality reduction. Lets first take a look at something known as Principal Component Analysis." }, { "code": null, "e": 4874, "s": 4226, "text": "PCA is a technique for reducing the number of dimensions in a dataset whilst retaining most information. It is using the correlation between some dimensions and tries to provide a minimum number of variables that keeps the maximum amount of variation or information about how the original data is distributed. It does not do this using guesswork but using hard mathematics and it uses something known as the eigenvalues and eigenvectors of the data-matrix. These eigenvectors of the covariance matrix have the property that they point along the major directions of variation in the data. These are the directions of maximum variation in a dataset." }, { "code": null, "e": 5089, "s": 4874, "text": "I am not going to get into the actual derivation and calculation of the principal components — if you want to get into the mathematics see this great page — instead we’ll use the Scikit-Learn implementation of PCA." }, { "code": null, "e": 5350, "s": 5089, "text": "Since we as humans like our two- and three-dimensional plots lets start with that and generate, from the original 784 dimensions, the first three principal components. And we’ll also see how much of the variation in the total dataset they actually account for." }, { "code": null, "e": 5697, "s": 5350, "text": "pca = PCA(n_components=3)pca_result = pca.fit_transform(df[feat_cols].values)df['pca-one'] = pca_result[:,0]df['pca-two'] = pca_result[:,1] df['pca-three'] = pca_result[:,2]print('Explained variation per principal component: {}'.format(pca.explained_variance_ratio_))Explained variation per principal component: [0.09746116 0.07155445 0.06149531]" }, { "code": null, "e": 6245, "s": 5697, "text": "Now, given that the first two components account for about 25% of the variation in the entire dataset lets see if that is enough to visually set the different digits apart. What we can do is create a scatterplot of the first and second principal component and color each of the different types of digits with a different color. If we are lucky the same type of digits will be positioned (i.e., clustered) together in groups, which would mean that the first two principal components actually tell us a great deal about the specific types of digits." }, { "code": null, "e": 6430, "s": 6245, "text": "plt.figure(figsize=(16,10))sns.scatterplot( x=\"pca-one\", y=\"pca-two\", hue=\"y\", palette=sns.color_palette(\"hls\", 10), data=df.loc[rndperm,:], legend=\"full\", alpha=0.3)" }, { "code": null, "e": 6964, "s": 6430, "text": "From the graph we can see the two components definitely hold some information, especially for specific digits, but clearly not enough to set all of them apart. Luckily there is another technique that we can use to reduce the number of dimensions that may prove more helpful. In the next few paragraphs we are going to take a look at that technique and explore if it gives us a better way of reducing the dimensions for visualisation. The method we will be exploring is known as t-SNE (t-Distributed Stochastic Neighbouring Entities)." }, { "code": null, "e": 6998, "s": 6964, "text": "For a 3d-version of the same plot" }, { "code": null, "e": 7307, "s": 6998, "text": "ax = plt.figure(figsize=(16,10)).gca(projection='3d')ax.scatter( xs=df.loc[rndperm,:][\"pca-one\"], ys=df.loc[rndperm,:][\"pca-two\"], zs=df.loc[rndperm,:][\"pca-three\"], c=df.loc[rndperm,:][\"y\"], cmap='tab10')ax.set_xlabel('pca-one')ax.set_ylabel('pca-two')ax.set_zlabel('pca-three')plt.show()" }, { "code": null, "e": 7622, "s": 7307, "text": "t-Distributed Stochastic Neighbor Embedding (t-SNE) is another technique for dimensionality reduction and is particularly well suited for the visualization of high-dimensional datasets. Contrary to PCA it is not a mathematical technique but a probablistic one. The original paper describes the working of t-SNE as:" }, { "code": null, "e": 7917, "s": 7622, "text": "“t-Distributed stochastic neighbor embedding (t-SNE) minimizes the divergence between two distributions: a distribution that measures pairwise similarities of the input objects and a distribution that measures pairwise similarities of the corresponding low-dimensional points in the embedding”." }, { "code": null, "e": 8422, "s": 7917, "text": "Essentially what this means is that it looks at the original data that is entered into the algorithm and looks at how to best represent this data using less dimensions by matching both distributions. The way it does this is computationally quite heavy and therefore there are some (serious) limitations to the use of this technique. For example one of the recommendations is that, in case of very high dimensional data, you may need to apply another dimensionality reduction technique before using t-SNE:" }, { "code": null, "e": 8669, "s": 8422, "text": "| It is highly recommended to use another dimensionality reduction| method (e.g. PCA for dense data or TruncatedSVD for sparse data)| to reduce the number of dimensions to a reasonable amount (e.g. 50)| if the number of features is very high." }, { "code": null, "e": 8704, "s": 8669, "text": "The other key drawback is that it:" }, { "code": null, "e": 8952, "s": 8704, "text": "“Since t-SNE scales quadratically in the number of objects N, its applicability is limited to data sets with only a few thousand input objects; beyond that, learning becomes too slow to be practical (and the memory requirements become too large)”." }, { "code": null, "e": 9047, "s": 8952, "text": "We will use the Scikit-Learn Implementation of the algorithm in the remainder of this writeup." }, { "code": null, "e": 9392, "s": 9047, "text": "Contrary to the recommendation above we will first try to run the algorithm on the actual dimensions of the data (784) and see how it does. To make sure we don’t burden our machine in terms of memory and power/time we will only use the first 10,000 samples to run the algorithm on. To compare later on I’ll also run the PCA again on the subset." }, { "code": null, "e": 9847, "s": 9392, "text": "N = 10000df_subset = df.loc[rndperm[:N],:].copy()data_subset = df_subset[feat_cols].valuespca = PCA(n_components=3)pca_result = pca.fit_transform(data_subset)df_subset['pca-one'] = pca_result[:,0]df_subset['pca-two'] = pca_result[:,1] df_subset['pca-three'] = pca_result[:,2]print('Explained variation per principal component: {}'.format(pca.explained_variance_ratio_))[out] Explained variation per principal component: [0.09730166 0.07135901 0.06183721]" }, { "code": null, "e": 9849, "s": 9847, "text": "x" }, { "code": null, "e": 11079, "s": 9849, "text": "time_start = time.time()tsne = TSNE(n_components=2, verbose=1, perplexity=40, n_iter=300)tsne_results = tsne.fit_transform(data_subset)print('t-SNE done! Time elapsed: {} seconds'.format(time.time()-time_start))[out] [t-SNE] Computing 121 nearest neighbors...[t-SNE] Indexed 10000 samples in 0.564s...[t-SNE] Computed neighbors for 10000 samples in 121.191s...[t-SNE] Computed conditional probabilities for sample 1000 / 10000[t-SNE] Computed conditional probabilities for sample 2000 / 10000[t-SNE] Computed conditional probabilities for sample 3000 / 10000[t-SNE] Computed conditional probabilities for sample 4000 / 10000[t-SNE] Computed conditional probabilities for sample 5000 / 10000[t-SNE] Computed conditional probabilities for sample 6000 / 10000[t-SNE] Computed conditional probabilities for sample 7000 / 10000[t-SNE] Computed conditional probabilities for sample 8000 / 10000[t-SNE] Computed conditional probabilities for sample 9000 / 10000[t-SNE] Computed conditional probabilities for sample 10000 / 10000[t-SNE] Mean sigma: 2.129023[t-SNE] KL divergence after 250 iterations with early exaggeration: 85.957787[t-SNE] KL divergence after 300 iterations: 2.823509t-SNE done! Time elapsed: 157.3975932598114 seconds" }, { "code": null, "e": 11252, "s": 11079, "text": "Now that we have the two resulting dimensions we can again visualise them by creating a scatter plot of the two dimensions and coloring each sample by its respective label." }, { "code": null, "e": 11525, "s": 11252, "text": "df_subset['tsne-2d-one'] = tsne_results[:,0]df_subset['tsne-2d-two'] = tsne_results[:,1]plt.figure(figsize=(16,10))sns.scatterplot( x=\"tsne-2d-one\", y=\"tsne-2d-two\", hue=\"y\", palette=sns.color_palette(\"hls\", 10), data=df_subset, legend=\"full\", alpha=0.3)" }, { "code": null, "e": 11861, "s": 11525, "text": "This is already a significant improvement over the PCA visualisation we used earlier. We can see that the digits are very clearly clustered in their own sub groups. If we would now use a clustering algorithm to pick out the seperate clusters we could probably quite accurately assign new points to a label. Just to compare PCA & T-SNE:" }, { "code": null, "e": 12268, "s": 11861, "text": "plt.figure(figsize=(16,7))ax1 = plt.subplot(1, 2, 1)sns.scatterplot( x=\"pca-one\", y=\"pca-two\", hue=\"y\", palette=sns.color_palette(\"hls\", 10), data=df_subset, legend=\"full\", alpha=0.3, ax=ax1)ax2 = plt.subplot(1, 2, 2)sns.scatterplot( x=\"tsne-2d-one\", y=\"tsne-2d-two\", hue=\"y\", palette=sns.color_palette(\"hls\", 10), data=df_subset, legend=\"full\", alpha=0.3, ax=ax2)" }, { "code": null, "e": 12599, "s": 12268, "text": "We’ll now take the recommendations to heart and actually reduce the number of dimensions before feeding the data into the t-SNE algorithm. For this we’ll use PCA again. We will first create a new dataset containing the fifty dimensions generated by the PCA reduction algorithm. We can then use this dataset to perform the t-SNE on" }, { "code": null, "e": 12882, "s": 12599, "text": "pca_50 = PCA(n_components=50)pca_result_50 = pca_50.fit_transform(data_subset)print('Cumulative explained variation for 50 principal components: {}'.format(np.sum(pca_50.explained_variance_ratio_)))[out] Cumulative explained variation for 50 principal components: 0.8267618822147329" }, { "code": null, "e": 12977, "s": 12882, "text": "Amazingly, the first 50 components roughly hold around 85% of the total variation in the data." }, { "code": null, "e": 13346, "s": 12977, "text": "Now lets try and feed this data into the t-SNE algorithm. This time we’ll use 10,000 samples out of the 70,000 to make sure the algorithm does not take up too much memory and CPU. Since the code used for this is very similar to the previous t-SNE code I have moved it to the Appendix: Code section at the bottom of this post. The plot it produced is the following one:" }, { "code": null, "e": 13694, "s": 13346, "text": "From this plot we can clearly see how all the samples are nicely spaced apart and grouped together with their respective digits. This could be an amazing starting point to then use a clustering algorithm and try to identify the clusters or to actually use these two dimensions as input to another algorithm (e.g., something like a Neural Network)." }, { "code": null, "e": 13965, "s": 13694, "text": "So we have explored using various dimensionality reduction techniques to visualise high-dimensional data using a two-dimensional scatter plot. We have not gone into the actual mathematics involved but instead relied on the Scikit-Learn implementations of all algorithms." }, { "code": null, "e": 14005, "s": 13965, "text": "Before closing off with the appendix..." }, { "code": null, "e": 14193, "s": 14005, "text": "Together with some likeminded friends we are sending out weekly newsletters with some links and notes that we want to share amongst ourselves (why not allow others to read them as well?)." }, { "code": null, "e": 14225, "s": 14193, "text": "Code: t-SNE on PCA-reduced data" }, { "code": null, "e": 14500, "s": 14225, "text": "time_start = time.time()tsne = TSNE(n_components=2, verbose=0, perplexity=40, n_iter=300)tsne_pca_results = tsne.fit_transform(pca_result_50)print('t-SNE done! Time elapsed: {} seconds'.format(time.time()-time_start))[out] t-SNE done! Time elapsed: 42.01495909690857 seconds" }, { "code": null, "e": 14526, "s": 14500, "text": "And for the visualisation" } ]

[ { "code": null, "e": 1273, "s": 1062, "text": "A Vector can be converted into an Array using the java.util.Vector.toArray() method. This method requires no parameters and it returns an Array that contains all the elements of the Vector in the correct order." }, { "code": null, "e": 1328, "s": 1273, "text": "A program that demonstrates this is given as follows −" }, { "code": null, "e": 1339, "s": 1328, "text": " Live Demo" }, { "code": null, "e": 1738, "s": 1339, "text": "import java.util.Vector;\npublic class Demo {\n public static void main(String args[]) {\n Vector vec = new Vector();\n vec.add(7);\n vec.add(3);\n vec.add(5);\n vec.add(2);\n vec.add(8);\n Object[] arr = vec.toArray();\n System.out.println(\"The Array elements are: \");\n for (int i = 0; i < arr.length; i++) {\n System.out.println(arr[i]);\n }\n }\n}" }, { "code": null, "e": 1786, "s": 1738, "text": "The output of the above program is as follows −" }, { "code": null, "e": 1820, "s": 1786, "text": "The Array elements are:\n7\n3\n5\n2\n8" }, { "code": null, "e": 1861, "s": 1820, "text": "Now let us understand the above program." }, { "code": null, "e": 2129, "s": 1861, "text": "The Vector is created. Then Vector.add() is used to add the elements to the Vector. The method Vector.toArray() is used to convert the Vector into an Array. Then the Array elements are displayed using a for loop. A code snippet which demonstrates this is as follows −" }, { "code": null, "e": 2366, "s": 2129, "text": "Vector vec = new Vector();\nvec.add(7);\nvec.add(3);\nvec.add(5);\nvec.add(2);\nvec.add(8);\nObject[] arr = vec.toArray();\nSystem.out.println(\"The Array elements are: \");\nfor (int i = 0; i < arr.length; i++) {\n System.out.println(arr[i]);\n}" } ]

[ { "code": null, "e": 538, "s": 238, "text": "Given a Linked List Representation of Complete Binary Tree. The task is to construct the Binary tree.\nNote : The complete binary tree is represented as a linked list in a way where if root node is stored at position i, its left, and right children are stored at position 2*i+1, 2*i+2 respectively.\n " }, { "code": null, "e": 551, "s": 538, "text": "\n\nExample 1:" }, { "code": null, "e": 743, "s": 551, "text": "Input:\nN = 5\nK = 1->2->3->4->5\nOutput: 1 2 3 4 5\nExplanation: The tree would look like\n 1\n / \\\n 2 3\n / \\\n4 5\nNow, the level order traversal of\nthe above tree is 1 2 3 4 5.\n" }, { "code": null, "e": 754, "s": 743, "text": "Example 2:" }, { "code": null, "e": 940, "s": 754, "text": "Input:\nN = 5\nK = 5->4->3->2->1\nOutput: 5 4 3 2 1\nExplanation: The tree would look like\n 5\n / \\\n 4 3\n / \\\n2 1\nNow, the level order traversal of\nthe above tree is 5 4 3 2 1." }, { "code": null, "e": 1109, "s": 940, "text": "Your Task:\nThe task is to complete the function convert() which takes head of linked list and root of the tree as the reference. The driver code prints the level order." }, { "code": null, "e": 1262, "s": 1109, "text": "Expected Time Complexity: O(N).\nExpected Auxiliary Space: O(N).\nNote: H is the height of the tree and this space is used implicitly for recursion stack." }, { "code": null, "e": 1304, "s": 1262, "text": "Constraints:\n1 <= N <= 105\n1 <= Ki <= 105" }, { "code": null, "e": 1306, "s": 1304, "text": "0" }, { "code": null, "e": 1324, "s": 1306, "text": "codepk3 weeks ago" }, { "code": null, "e": 1356, "s": 1324, "text": "plz anybody optimize this......" }, { "code": null, "e": 1784, "s": 1362, "text": "TreeNode * llToBt(vector<int> v,int sizeofll,int index){ if(index>=sizeofll) { return NULL;} TreeNode* root =new TreeNode(v[index]); root->left=llToBt(v,sizeofll,index*2+1); root->right=llToBt(v,sizeofll,index*2+2); return root;}void convert(Node *head, TreeNode *&root) { if(head==NULL) return; vector<int> v; while(head) {v.push_back(head->data);head=head->next; } int index=0; root=llToBt(v,v.size(),index);}" }, { "code": null, "e": 1786, "s": 1784, "text": "0" }, { "code": null, "e": 1810, "s": 1786, "text": "abrajput15063 weeks ago" }, { "code": null, "e": 2385, "s": 1810, "text": "void convert(Node *head, TreeNode *&root) {\n // Your code here\n queue<TreeNode*> q;\n root = new TreeNode(head->data);\n q.push(root);\n \n Node* ptr = head->next;\n while(!q.empty() && ptr){\n TreeNode* temp = q.front();\n q.pop();\n \n if(ptr){\n temp->left = new TreeNode(ptr->data);\n q.push(temp->left);\n ptr = ptr->next;\n }\n \n if(ptr){\n temp->right = new TreeNode(ptr->data);\n q.push(temp->right);\n ptr = ptr->next;\n }\n \n }\n}\n" }, { "code": null, "e": 2387, "s": 2385, "text": "0" }, { "code": null, "e": 2406, "s": 2387, "text": "crawler1 month ago" }, { "code": null, "e": 3162, "s": 2406, "text": "void huihui(TreeNode *&root, int i, vector<int> &values){\n if(root){\n int left = 2*i + 1;\n int right = 2*i + 2;\n if(left < values.size()){\n root->left = new TreeNode(values[left]);\n }\n if(right < values.size()){\n root->right = new TreeNode(values[right]);\n }\n huihui(root->left, 2*i+1, values);\n huihui(root->right, 2*i+2, values);\n }\n}\nvoid convert(Node *head, TreeNode *&root) {\n vector<int> values;\n Node *iter = head;\n while(iter){\n values.push_back(iter->data);\n iter = iter->next;\n }\n if(!values.size())\n root = nullptr;\n else{\n root = new TreeNode(values[0]);\n int i = 0;\n huihui(root,i, values);\n }\n}" }, { "code": null, "e": 3164, "s": 3162, "text": "0" }, { "code": null, "e": 3186, "s": 3164, "text": "dvirbarel2 months ago" }, { "code": null, "e": 3189, "s": 3186, "text": "C#" }, { "code": null, "e": 3821, "s": 3191, "text": " if(head == null) { return null; } var q = new Queue<Node>(); var root = new Node(head.val); q.Enqueue(root); while(head.next != null){ head = head.next; var parent = q.Dequeue(); parent.left = new Node(head.val); if(head.next != null){ head = head.next; parent.right = new Node(head.val); } q.Enqueue(parent.left); q.Enqueue(parent.right); } return root;" }, { "code": null, "e": 3825, "s": 3823, "text": "0" }, { "code": null, "e": 3854, "s": 3825, "text": "mridulbhaskarabc2 months ago" }, { "code": null, "e": 3887, "s": 3854, "text": "# Contributed By: Mridul Bhaskar" }, { "code": null, "e": 4329, "s": 3887, "text": "def convert(head):\n root = None\n temp = None\n \n # code here\n if(head is None):\n return None\n root = Tree(head.data)\n temp = root\n while(head.next):\n \n \n head = head.next\n root.left = Tree(head.data)\n \n \n if(head.next):\n \n head = head.next\n root.right = Tree(head.data)\n root = root.left\n \n return temp" }, { "code": null, "e": 4334, "s": 4331, "text": "+1" }, { "code": null, "e": 4357, "s": 4334, "text": "shivank9112 months ago" }, { "code": null, "e": 4388, "s": 4357, "text": "JAVA SOLUTION -O(N) COMPLEXITY" }, { "code": null, "e": 5163, "s": 4388, "text": "public static Tree convert(Node head, Tree node) { // add code here.} ArrayDeque<Tree> que=new ArrayDeque<>(); Tree root=new Tree(head.data); que.add(root); while(que.size()>0){ int size=que.size(); while(size-->0){ Tree temp=que.remove(); if(head.next!=null){ head=head.next; Tree left=new Tree(head.data); temp.left=left; que.add(left); } if(head.next!=null){ head=head.next; Tree right=new Tree(head.data); temp.right=right; que.add(right); } } } return root; }" }, { "code": null, "e": 5165, "s": 5163, "text": "0" }, { "code": null, "e": 5193, "s": 5165, "text": "hamidnourashraf2 months ago" }, { "code": null, "e": 5670, "s": 5193, "text": "def convert(head):\n root = Tree(head.data)\n stack = [root]\n while head:\n curr_node = stack.pop(0)\n head = head.next\n if head:\n curr_node.left = Tree(head.data)\n stack.append(curr_node.left)\n head = head.next\n if head:\n curr_node.right = Tree(head.data)\n stack.append(curr_node.right)\n else:\n break\n else:\n break\n\n return root" }, { "code": null, "e": 5672, "s": 5670, "text": "0" }, { "code": null, "e": 5694, "s": 5672, "text": "abhhishek2 months ago" }, { "code": null, "e": 6653, "s": 5694, "text": "class GfG \n{\n //Function to make binary tree from linked list.\n public static Tree convert(Node head, Tree node) {\n if (head == null)\n {\n node = null;\n return null;\n }\n Tree res = new Tree(head.data);\n head = head.next;\n Queue<Tree> queue = new LinkedList<>();\n queue.offer(res);\n while(!queue.isEmpty()){\n int n=queue.size();\n \n while(n-- > 0){\n Tree temp = queue.peek();\n if(head!=null){\n temp.left = new Tree(head.data);\n queue.offer(temp.left);\n head = head.next;\n }\n if(head!=null){\n temp.right = new Tree(head.data);\n queue.offer(temp.right);\n head = head.next;\n }\n queue.poll();\n }\n }\n return res;\n }\n}" }, { "code": null, "e": 6656, "s": 6653, "text": "+4" }, { "code": null, "e": 6685, "s": 6656, "text": "mohankumarit20012 months ago" }, { "code": null, "e": 6708, "s": 6685, "text": "Found a loop hole lol!" }, { "code": null, "e": 6848, "s": 6708, "text": "void convert(Node *head, TreeNode *&root) {\n if(!head)return;\n root = new TreeNode(head->data);\n convert(head->next,root->left);\n}" }, { "code": null, "e": 6850, "s": 6848, "text": "0" }, { "code": null, "e": 6881, "s": 6850, "text": "rogueninjaofkonoha3 months ago" }, { "code": null, "e": 6918, "s": 6881, "text": "Without Recursion:2 queues approach " }, { "code": null, "e": 8273, "s": 6920, "text": "public static Tree convert(Node head, Tree node) {\n // add code here.}\n \n Queue<Tree> q1 = new LinkedList<Tree>();\n Queue<Tree> q2 = new LinkedList<Tree>();\n \n Tree sm = new Tree(head.data);\n \n q1.add(sm);\n head = head.next;\n \n while(!q1.isEmpty() || !q2.isEmpty()) {\n while(!q1.isEmpty()) {\n Tree temp = q1.poll();\n if(head!=null) {\n temp.left = new Tree(head.data);\n head = head.next;\n q1.add(temp.left);\n }\n if(head!=null) {\n temp.right = new Tree(head.data);\n head = head.next;\n q1.add(temp.right);\n \n }\n }\n while(!q2.isEmpty()) {\n Tree temp = q2.poll();\n if(head!=null) {\n temp.left = new Tree(head.data);\n head = head.next;\n q1.add(temp.left);\n }\n if(head!=null) {\n temp.right = new Tree(head.data);\n head = head.next;\n q1.add(temp.right);\n \n }\n }\n }\n node = sm;\n return node;\n \n }" }, { "code": null, "e": 8419, "s": 8273, "text": "We strongly recommend solving this problem on your own before viewing its editorial. Do you still\n want to view the editorial?" }, { "code": null, "e": 8455, "s": 8419, "text": " Login to access your submissions. " }, { "code": null, "e": 8465, "s": 8455, "text": "\nProblem\n" }, { "code": null, "e": 8475, "s": 8465, "text": "\nContest\n" }, { "code": null, "e": 8538, "s": 8475, "text": "Reset the IDE using the second button on the top right corner." }, { "code": null, "e": 8686, "s": 8538, "text": "Avoid using static/global variables in your code as your code is tested against multiple test cases and these tend to retain their previous values." }, { "code": null, "e": 8894, "s": 8686, "text": "Passing the Sample/Custom Test cases does not guarantee the correctness of code. On submission, your code is tested against multiple test cases consisting of all possible corner cases and stress constraints." }, { "code": null, "e": 9000, "s": 8894, "text": "You can access the hints to get an idea about what is expected of you as well as the final solution code." } ]

[ { "code": null, "e": 557, "s": 171, "text": "To the learners out there, who need large amount of fake data to experiment different algorithm. Mammoth data is generated online each second in various domains but for learning and experimenting purpose, the original data can’t be used due to security and many other constraints. So here I am talking about huge amount of fake data generation using a library called Faker with Python." }, { "code": null, "e": 609, "s": 557, "text": "Faker is a Python package that generates fake data." }, { "code": null, "e": 645, "s": 609, "text": "Installing Faker library using pip:" }, { "code": null, "e": 663, "s": 645, "text": "pip install Faker" }, { "code": null, "e": 1091, "s": 663, "text": "faker.Faker() initializes a fake generator which can generate data for different properties based on different data types. Different properties of faker generator are packaged in “providers”. The list of different faker providers can be found here. It also has internet providers for ipv4 and other community providers like web, cloud and wifi. Custom Providers can be created and added using fake.add_provider(CustomProvider)." }, { "code": null, "e": 1235, "s": 1091, "text": "Some of the fake generators for different data types are illustrated below. More detailed use of different providers is given in this notebook." }, { "code": null, "e": 1671, "s": 1235, "text": "from faker import Fakerfrom faker.providers import internetfake = Faker()fake.pybool() # Randomly returns True/Falseprint(fake.pyfloat(left_digits=3, right_digits=3, positive=False, min_value=None, max_value=None)) # Float dataprint(fake.pystr(min_chars=None, max_chars=10)) # String dataprint(fake.pylist(nb_elements=5, variable_nb_elements=True)) # Listfake.add_provider(internet)print(fake.ipv4_private()) # Fake ipv4 address" }, { "code": null, "e": 1704, "s": 1671, "text": "The data output looks like this:" }, { "code": null, "e": 1910, "s": 1704, "text": "faker.Faker() can take a locale as an argument, to return localized data. Default locale is en_US. It has support for languages like Hindi, French, Spanish, Chinese, Japanese, Arabic, German and many more." }, { "code": null, "e": 2002, "s": 1910, "text": "from faker import Fakerfake_H = Faker('hi_IN') # To generate Hindi Fake datafake_H.name()" }, { "code": null, "e": 2066, "s": 2002, "text": "Faker can also be invoked from command-line after installation." }, { "code": null, "e": 2732, "s": 2066, "text": "faker [-h] [--version] [-o output] [-l {bg_BG,cs_CZ,...,zh_CN,zh_TW}] [-r REPEAT] [-s SEP] [-i {package.containing.custom_provider otherpkg.containing.custom_provider}] [fake] [fake argument [fake argument ...]]where;-h, --help : shows a help message--version : shows the program version-o : output file[-l {bg_BG,cs_CZ,...,zh_CN,zh_TW}] : allows using localized provider[-r REPEAT] : To generate specified number of outputs[-s SEP] : Separator to separate generated outputs[-i {package.containing.custom_provider otherpkg.containing.custom_provider}] : to add custom providers[fake] : name of fake to generate an output for (e.g. name, address)" }, { "code": null, "e": 2920, "s": 2732, "text": "Large CSV files with fake data can be generated very easily with any number of records. All you need to do is just pass headers of CSV and specify data property for each column in header." }, { "code": null, "e": 3125, "s": 2920, "text": "Faker facilitates the data generation of types such as name, email, url, address, phone number, zip code, city, state, country, date, time and many more. The code to generate fake CSV data is given below." } ]

[ { "code": null, "e": 356, "s": 172, "text": "We will use the wine dataset available on Kaggle. This dataset has 12 columns where the first 11 are the features and the last column is the target column. The data set has 1599 rows." }, { "code": null, "e": 429, "s": 356, "text": "We’re using tqdm to enable progress bars for training and testing loops." }, { "code": null, "e": 849, "s": 429, "text": "import numpy as npimport pandas as pdimport seaborn as snsfrom tqdm.notebook import tqdmimport matplotlib.pyplot as pltimport torchimport torch.nn as nnimport torch.optim as optimfrom torch.utils.data import Dataset, DataLoader, WeightedRandomSamplerfrom sklearn.preprocessing import MinMaxScaler from sklearn.model_selection import train_test_splitfrom sklearn.metrics import confusion_matrix, classification_report" }, { "code": null, "e": 926, "s": 849, "text": "df = pd.read_csv(\"data/tabular/classification/winequality-red.csv\")df.head()" }, { "code": null, "e": 1006, "s": 926, "text": "To make the data fit for a neural net, we need to make a few adjustments to it." }, { "code": null, "e": 1164, "s": 1006, "text": "First off, we plot the output rows to observe the class distribution. There’s a lot of imbalance here. Classes 3, 4, and 8 have a very few number of samples." }, { "code": null, "e": 1202, "s": 1164, "text": "sns.countplot(x = 'quality', data=df)" }, { "code": null, "e": 1386, "s": 1202, "text": "Next, we see that the output labels are from 3 to 8. That needs to change because PyTorch supports labels starting from 0. That is [0, n]. We need to remap our labels to start from 0." }, { "code": null, "e": 1617, "s": 1386, "text": "To do that, let’s create a dictionary called class2idx and use the .replace() method from the Pandas library to change it. Let’s also create a reverse mapping called idx2class which converts the IDs back to their original classes." }, { "code": null, "e": 1723, "s": 1617, "text": "To create the reverse mapping, we create a dictionary comprehension and simply reverse the key and value." }, { "code": null, "e": 1879, "s": 1723, "text": "class2idx = { 3:0, 4:1, 5:2, 6:3, 7:4, 8:5}idx2class = {v: k for k, v in class2idx.items()}df['quality'].replace(class2idx, inplace=True)" }, { "code": null, "e": 2029, "s": 1879, "text": "In order to split our data into train, validation, and test sets using train_test_split from Sklearn, we need to separate out our inputs and outputs." }, { "code": null, "e": 2094, "s": 2029, "text": "Input X is all but the last column. Output y is the last column." }, { "code": null, "e": 2133, "s": 2094, "text": "X = df.iloc[:, 0:-1]y = df.iloc[:, -1]" }, { "code": null, "e": 2212, "s": 2133, "text": "To create the train-val-test split, we’ll use train_test_split() from Sklearn." }, { "code": null, "e": 2347, "s": 2212, "text": "First we’ll split our data into train+val and test sets. Then, we’ll further split our train+val set to create our train and val sets." }, { "code": null, "e": 2551, "s": 2347, "text": "Because there’s a class imbalance, we want to have equal distribution of all output classes in our train, validation, and test sets. To do that, we use the stratify option in function train_test_split()." }, { "code": null, "e": 2844, "s": 2551, "text": "# Split into train+val and testX_trainval, X_test, y_trainval, y_test = train_test_split(X, y, test_size=0.2, stratify=y, random_state=69)# Split train into train-valX_train, X_val, y_train, y_val = train_test_split(X_trainval, y_trainval, test_size=0.1, stratify=y_trainval, random_state=21)" }, { "code": null, "e": 2976, "s": 2844, "text": "Neural networks need data that lies between the range of (0,1). There’s a ton of material available online on why we need to do it." }, { "code": null, "e": 3146, "s": 2976, "text": "To scale our values, we’ll use the MinMaxScaler() from Sklearn. The MinMaxScaler transforms features by scaling each feature to a given range which is (0,1) in our case." }, { "code": null, "e": 3186, "s": 3146, "text": "x_scaled = (x-min(x)) / (max(x)–min(x))" }, { "code": null, "e": 3280, "s": 3186, "text": "Notice that we use .fit_transform() on X_train while we use .transform() on X_val and X_test." }, { "code": null, "e": 3527, "s": 3280, "text": "We do this because we want to scale the validation and test set with the same parameters as that of the train set to avoid data leakage. fit_transform calculates scaling values and applies them while .transform only applies the calculated values." }, { "code": null, "e": 3807, "s": 3527, "text": "scaler = MinMaxScaler()X_train = scaler.fit_transform(X_train)X_val = scaler.transform(X_val)X_test = scaler.transform(X_test)X_train, y_train = np.array(X_train), np.array(y_train)X_val, y_val = np.array(X_val), np.array(y_val)X_test, y_test = np.array(X_test), np.array(y_test)" }, { "code": null, "e": 3944, "s": 3807, "text": "Once we’ve split our data into train, validation, and test sets, let’s make sure the distribution of classes is equal in all three sets." }, { "code": null, "e": 4240, "s": 3944, "text": "To do that, let’s create a function called get_class_distribution() . This function takes as input the obj y , ie. y_train, y_val, or y_test. Inside the function, we initialize a dictionary which contains the output classes as keys and their count as values. The counts are all initialized to 0." }, { "code": null, "e": 4301, "s": 4240, "text": "We then loop through our y object and update our dictionary." }, { "code": null, "e": 4965, "s": 4301, "text": "def get_class_distribution(obj): count_dict = { \"rating_3\": 0, \"rating_4\": 0, \"rating_5\": 0, \"rating_6\": 0, \"rating_7\": 0, \"rating_8\": 0, } for i in obj: if i == 0: count_dict['rating_3'] += 1 elif i == 1: count_dict['rating_4'] += 1 elif i == 2: count_dict['rating_5'] += 1 elif i == 3: count_dict['rating_6'] += 1 elif i == 4: count_dict['rating_7'] += 1 elif i == 5: count_dict['rating_8'] += 1 else: print(\"Check classes.\") return count_dict" }, { "code": null, "e": 5301, "s": 4965, "text": "Once we have the dictionary count, we use Seaborn library to plot the bar charts. The make the plot, we first convert our dictionary to a dataframe using pd.DataFrame.from_dict([get_class_distribution(y_train)]) . Subsequently, we .melt() our convert our dataframe into the long format and finally use sns.barplot() to build the plots." }, { "code": null, "e": 5934, "s": 5301, "text": "fig, axes = plt.subplots(nrows=1, ncols=3, figsize=(25,7))# Trainsns.barplot(data = pd.DataFrame.from_dict([get_class_distribution(y_train)]).melt(), x = \"variable\", y=\"value\", hue=\"variable\", ax=axes[0]).set_title('Class Distribution in Train Set')# Validationsns.barplot(data = pd.DataFrame.from_dict([get_class_distribution(y_val)]).melt(), x = \"variable\", y=\"value\", hue=\"variable\", ax=axes[1]).set_title('Class Distribution in Val Set')# Testsns.barplot(data = pd.DataFrame.from_dict([get_class_distribution(y_test)]).melt(), x = \"variable\", y=\"value\", hue=\"variable\", ax=axes[2]).set_title('Class Distribution in Test Set')" }, { "code": null, "e": 5986, "s": 5934, "text": "We’ve now reached what we all had been waiting for!" }, { "code": null, "e": 6104, "s": 5986, "text": "First up, let’s define a custom dataset. This dataset will be used by the dataloader to pass our data into our model." }, { "code": null, "e": 6200, "s": 6104, "text": "We initialize our dataset by passing X and y as inputs. Make sure X is a float while y is long." }, { "code": null, "e": 6786, "s": 6200, "text": "class ClassifierDataset(Dataset): def __init__(self, X_data, y_data): self.X_data = X_data self.y_data = y_data def __getitem__(self, index): return self.X_data[index], self.y_data[index] def __len__ (self): return len(self.X_data)train_dataset = ClassifierDataset(torch.from_numpy(X_train).float(), torch.from_numpy(y_train).long())val_dataset = ClassifierDataset(torch.from_numpy(X_val).float(), torch.from_numpy(y_val).long())test_dataset = ClassifierDataset(torch.from_numpy(X_test).float(), torch.from_numpy(y_test).long())" }, { "code": null, "e": 6893, "s": 6786, "text": "Because there’s a class imbalance, we use stratified split to create our train, validation, and test sets." }, { "code": null, "e": 7100, "s": 6893, "text": "While it helps, it still does not ensure that each mini-batch of our model see’s all our classes. We need to over-sample the classes with less number of values. To do that, we use the WeightedRandomSampler." }, { "code": null, "e": 7216, "s": 7100, "text": "First, we obtain a list called target_list which contains all our outputs. This list is then converted to a tensor." }, { "code": null, "e": 7327, "s": 7216, "text": "target_list = []for _, t in train_dataset: target_list.append(t) target_list = torch.tensor(target_list)" }, { "code": null, "e": 7518, "s": 7327, "text": "Then, we obtain the count of all classes in our training set. We use the reciprocal of each count to obtain it’s weight. Now that we’ve calculated the weights for each class, we can proceed." }, { "code": null, "e": 7778, "s": 7518, "text": "class_count = [i for i in get_class_distribution(y_train).values()]class_weights = 1./torch.tensor(class_count, dtype=torch.float) print(class_weights)###################### OUTPUT ######################tensor([0.1429, 0.0263, 0.0020, 0.0022, 0.0070, 0.0714])" }, { "code": null, "e": 7863, "s": 7778, "text": "WeightedRandomSampler expects a weight for each sample. We do that using as follows." }, { "code": null, "e": 7910, "s": 7863, "text": "class_weights_all = class_weights[target_list]" }, { "code": null, "e": 8004, "s": 7910, "text": "Finally, let’s initialize our WeightedRandomSampler. We’ll call this in our dataloader below." }, { "code": null, "e": 8136, "s": 8004, "text": "weighted_sampler = WeightedRandomSampler( weights=class_weights_all, num_samples=len(class_weights_all), replacement=True)" }, { "code": null, "e": 8227, "s": 8136, "text": "Before we proceed any further, let’s define a few parameters that we’ll use down the line." }, { "code": null, "e": 8321, "s": 8227, "text": "EPOCHS = 300BATCH_SIZE = 16LEARNING_RATE = 0.0007NUM_FEATURES = len(X.columns)NUM_CLASSES = 6" }, { "code": null, "e": 8359, "s": 8321, "text": "Let’s now initialize our dataloaders." }, { "code": null, "e": 8570, "s": 8359, "text": "For train_dataloader we’ll use batch_size = 64 and pass our sampler to it. Note that we’re not using shuffle=True in our train_dataloader because we’re already using a sampler. These two are mutually exclusive." }, { "code": null, "e": 8636, "s": 8570, "text": "For test_dataloader and val_dataloader we’ll use batch_size = 1 ." }, { "code": null, "e": 8902, "s": 8636, "text": "train_loader = DataLoader(dataset=train_dataset, batch_size=BATCH_SIZE, sampler=weighted_sampler)val_loader = DataLoader(dataset=val_dataset, batch_size=1)test_loader = DataLoader(dataset=test_dataset, batch_size=1)" }, { "code": null, "e": 8982, "s": 8902, "text": "Let’s define a simple 3-layer feed-forward network with dropout and batch-norm." }, { "code": null, "e": 9937, "s": 8982, "text": "class MulticlassClassification(nn.Module): def __init__(self, num_feature, num_class): super(MulticlassClassification, self).__init__() self.layer_1 = nn.Linear(num_feature, 512) self.layer_2 = nn.Linear(512, 128) self.layer_3 = nn.Linear(128, 64) self.layer_out = nn.Linear(64, num_class) self.relu = nn.ReLU() self.dropout = nn.Dropout(p=0.2) self.batchnorm1 = nn.BatchNorm1d(512) self.batchnorm2 = nn.BatchNorm1d(128) self.batchnorm3 = nn.BatchNorm1d(64) def forward(self, x): x = self.layer_1(x) x = self.batchnorm1(x) x = self.relu(x) x = self.layer_2(x) x = self.batchnorm2(x) x = self.relu(x) x = self.dropout(x) x = self.layer_3(x) x = self.batchnorm3(x) x = self.relu(x) x = self.dropout(x) x = self.layer_out(x) return x" }, { "code": null, "e": 9961, "s": 9937, "text": "Check if GPU is active." }, { "code": null, "e": 10104, "s": 9961, "text": "device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")print(device)###################### OUTPUT ######################cuda:0" }, { "code": null, "e": 10462, "s": 10104, "text": "Initialize the model, optimizer, and loss function. Transfer the model to GPU. We’re using the nn.CrossEntropyLoss because this is a multiclass classification problem. We don’t have to manually apply a log_softmax layer after our final layer because nn.CrossEntropyLoss does that for us. However, we need to apply log_softmax for our validation and testing." }, { "code": null, "e": 11378, "s": 10462, "text": "model = MulticlassClassification(num_feature = NUM_FEATURES, num_class=NUM_CLASSES)model.to(device)criterion = nn.CrossEntropyLoss(weight=class_weights.to(device))optimizer = optim.Adam(model.parameters(), lr=LEARNING_RATE)print(model)###################### OUTPUT ######################MulticlassClassification( (layer_1): Linear(in_features=11, out_features=512, bias=True) (layer_2): Linear(in_features=512, out_features=128, bias=True) (layer_3): Linear(in_features=128, out_features=64, bias=True) (layer_out): Linear(in_features=64, out_features=6, bias=True) (relu): ReLU() (dropout): Dropout(p=0.2, inplace=False) (batchnorm1): BatchNorm1d(512, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (batchnorm2): BatchNorm1d(128, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True) (batchnorm3): BatchNorm1d(64, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True))" }, { "code": null, "e": 11465, "s": 11378, "text": "Before we start our training, let’s define a function to calculate accuracy per epoch." }, { "code": null, "e": 11613, "s": 11465, "text": "This function takes y_pred and y_test as input arguments. We then apply log_softmax to y_pred and extract the class which has a higher probability." }, { "code": null, "e": 11712, "s": 11613, "text": "After that, we compare the the predicted classes and the actual classes to calculate the accuracy." }, { "code": null, "e": 12013, "s": 11712, "text": "def multi_acc(y_pred, y_test): y_pred_softmax = torch.log_softmax(y_pred, dim = 1) _, y_pred_tags = torch.max(y_pred_softmax, dim = 1) correct_pred = (y_pred_tags == y_test).float() acc = correct_pred.sum() / len(correct_pred) acc = torch.round(acc * 100) return acc" }, { "code": null, "e": 12133, "s": 12013, "text": "We’ll also define 2 dictionaries which will store the accuracy/epoch and loss/epoch for both train and validation sets." }, { "code": null, "e": 12226, "s": 12133, "text": "accuracy_stats = { 'train': [], \"val\": []}loss_stats = { 'train': [], \"val\": []}" }, { "code": null, "e": 12253, "s": 12226, "text": "Let’s TRAAAAAIN our model!" }, { "code": null, "e": 14492, "s": 12253, "text": "print(\"Begin training.\")for e in tqdm(range(1, EPOCHS+1)): # TRAINING train_epoch_loss = 0 train_epoch_acc = 0model.train() for X_train_batch, y_train_batch in train_loader: X_train_batch, y_train_batch = X_train_batch.to(device), y_train_batch.to(device) optimizer.zero_grad() y_train_pred = model(X_train_batch) train_loss = criterion(y_train_pred, y_train_batch) train_acc = multi_acc(y_train_pred, y_train_batch) train_loss.backward() optimizer.step() train_epoch_loss += train_loss.item() train_epoch_acc += train_acc.item() # VALIDATION with torch.no_grad(): val_epoch_loss = 0 val_epoch_acc = 0 model.eval() for X_val_batch, y_val_batch in val_loader: X_val_batch, y_val_batch = X_val_batch.to(device), y_val_batch.to(device) y_val_pred = model(X_val_batch) val_loss = criterion(y_val_pred, y_val_batch) val_acc = multi_acc(y_val_pred, y_val_batch) val_epoch_loss += val_loss.item() val_epoch_acc += val_acc.item()loss_stats['train'].append(train_epoch_loss/len(train_loader)) loss_stats['val'].append(val_epoch_loss/len(val_loader)) accuracy_stats['train'].append(train_epoch_acc/len(train_loader)) accuracy_stats['val'].append(val_epoch_acc/len(val_loader)) print(f'Epoch {e+0:03}: | Train Loss: {train_epoch_loss/len(train_loader):.5f} | Val Loss: {val_epoch_loss/len(val_loader):.5f} | Train Acc: {train_epoch_acc/len(train_loader):.3f}| Val Acc: {val_epoch_acc/len(val_loader):.3f}')###################### OUTPUT ######################Epoch 001: | Train Loss: 1.38551 | Val Loss: 1.42033 | Train Acc: 38.889| Val Acc: 43.750Epoch 002: | Train Loss: 1.19558 | Val Loss: 1.36613 | Train Acc: 59.722| Val Acc: 45.312Epoch 003: | Train Loss: 1.12264 | Val Loss: 1.44156 | Train Acc: 79.167| Val Acc: 35.938...Epoch 299: | Train Loss: 0.29774 | Val Loss: 1.42116 | Train Acc: 100.000| Val Acc: 57.812Epoch 300: | Train Loss: 0.33134 | Val Loss: 1.38818 | Train Acc: 100.000| Val Acc: 57.812" }, { "code": null, "e": 14612, "s": 14492, "text": "You can see we’ve put a model.train() at the before the loop. model.train() tells PyTorch that you’re in training mode." }, { "code": null, "e": 14848, "s": 14612, "text": "Well, why do we need to do that? If you’re using layers such as Dropout or BatchNorm which behave differently during training and evaluation (for example; not use dropout during evaluation), you need to tell PyTorch to act accordingly." }, { "code": null, "e": 14929, "s": 14848, "text": "Similarly, we’ll call model.eval() when we test our model. We’ll see that below." }, { "code": null, "e": 15126, "s": 14929, "text": "Back to training; we start a for-loop. At the top of this for-loop, we initialize our loss and accuracy per epoch to 0. After every epoch, we’ll print out the loss/accuracy and reset it back to 0." }, { "code": null, "e": 15229, "s": 15126, "text": "Then we have another for-loop. This for-loop is used to get our data in batches from the train_loader." }, { "code": null, "e": 15390, "s": 15229, "text": "We do optimizer.zero_grad() before we make any predictions. Since the backward() function accumulates gradients, we need to set it to 0 manually per mini-batch." }, { "code": null, "e": 15561, "s": 15390, "text": "From our defined model, we then obtain a prediction, get the loss(and accuracy) for that mini-batch, perform back-propagation using loss.backward() and optimizer.step() ." }, { "code": null, "e": 15860, "s": 15561, "text": "Finally, we add all the mini-batch losses (and accuracies) to obtain the average loss (and accuracy) for that epoch. We add up all the losses/accuracies for each mini-batch and finally divide it by the number of mini-batches ie. length of train_loader to obtain the average loss/accuracy per epoch." }, { "code": null, "e": 16157, "s": 15860, "text": "The procedure we follow for training is the exact same for validation except for the fact that we wrap it up in torch.no_grad and not perform any back-propagation. torch.no_grad() tells PyTorch that we do not want to perform back-propagation, which reduces memory usage and speeds up computation." }, { "code": null, "e": 16280, "s": 16157, "text": "To plot the loss and accuracy line plots, we again create a dataframe from the accuracy_stats and loss_stats dictionaries." }, { "code": null, "e": 16886, "s": 16280, "text": "# Create dataframestrain_val_acc_df = pd.DataFrame.from_dict(accuracy_stats).reset_index().melt(id_vars=['index']).rename(columns={\"index\":\"epochs\"})train_val_loss_df = pd.DataFrame.from_dict(loss_stats).reset_index().melt(id_vars=['index']).rename(columns={\"index\":\"epochs\"})# Plot the dataframesfig, axes = plt.subplots(nrows=1, ncols=2, figsize=(20,7))sns.lineplot(data=train_val_acc_df, x = \"epochs\", y=\"value\", hue=\"variable\", ax=axes[0]).set_title('Train-Val Accuracy/Epoch')sns.lineplot(data=train_val_loss_df, x = \"epochs\", y=\"value\", hue=\"variable\", ax=axes[1]).set_title('Train-Val Loss/Epoch')" }, { "code": null, "e": 17170, "s": 16886, "text": "After training is done, we need to test how our model fared. Note that we’ve used model.eval() before we run our testing code. To tell PyTorch that we do not want to perform back-propagation during inference, we use torch.no_grad(), just like we did it for the validation loop above." }, { "code": null, "e": 17303, "s": 17170, "text": "We start by defining a list that will hold our predictions. Then we loop through our batches using the test_loader. For each batch —" }, { "code": null, "e": 17340, "s": 17303, "text": "We move our input mini-batch to GPU." }, { "code": null, "e": 17389, "s": 17340, "text": "We make the predictions using our trained model." }, { "code": null, "e": 17480, "s": 17389, "text": "Apply log_softmax activation to the predictions and pick the index of highest probability." }, { "code": null, "e": 17520, "s": 17480, "text": "Move the batch to the GPU from the CPU." }, { "code": null, "e": 17584, "s": 17520, "text": "Convert the tensor to a numpy object and append it to our list." }, { "code": null, "e": 17686, "s": 17584, "text": "Flatten out the list so that we can use it as an input to confusion_matrix and classification_report." }, { "code": null, "e": 18012, "s": 17686, "text": "y_pred_list = []with torch.no_grad(): model.eval() for X_batch, _ in test_loader: X_batch = X_batch.to(device) y_test_pred = model(X_batch) _, y_pred_tags = torch.max(y_test_pred, dim = 1) y_pred_list.append(y_pred_tags.cpu().numpy())y_pred_list = [a.squeeze().tolist() for a in y_pred_list]" }, { "code": null, "e": 18112, "s": 18012, "text": "We create a dataframe from the confusion matrix and plot it as a heatmap using the seaborn library." }, { "code": null, "e": 18273, "s": 18112, "text": "confusion_matrix_df = pd.DataFrame(confusion_matrix(y_test, y_pred_list)).rename(columns=idx2class, index=idx2class)sns.heatmap(confusion_matrix_df, annot=True)" }, { "code": null, "e": 18377, "s": 18273, "text": "Finally, we print out the classification report which contains the precision, recall, and the F1 score." }, { "code": null, "e": 18995, "s": 18377, "text": "print(classification_report(y_test, y_pred_list))###################### OUTPUT ######################precision recall f1-score support 0 0.00 0.00 0.00 2 1 0.14 0.27 0.19 11 2 0.70 0.65 0.67 136 3 0.63 0.57 0.60 128 4 0.49 0.60 0.54 40 5 0.00 0.00 0.00 3 accuracy 0.59 320 macro avg 0.33 0.35 0.33 320weighted avg 0.62 0.59 0.60 320" }, { "code": null, "e": 19073, "s": 18995, "text": "Thank you for reading. Suggestions and constructive criticism are welcome. :)" }, { "code": null, "e": 19175, "s": 19073, "text": "This blogpost is a part of the series — ” How to train you Neural Net”. You can find the series here." } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n14 Jul, 2022" }, { "code": null, "e": 228, "s": 52, "text": "To append characters, you can use operator +=, append(), and push_back(). All of them helps to append character but with a little difference in implementation and application." }, { "code": null, "e": 297, "s": 228, "text": "Operator += : appends single-argument values. Time complexity : O(n)" }, { "code": null, "e": 395, "s": 297, "text": "append() : lets you specify the appended value by using multiple arguments. Time complexity: O(n)" }, { "code": null, "e": 478, "s": 395, "text": "push_back() : lets you to append single character at a time. Time complexity: O(1)" }, { "code": null, "e": 547, "s": 478, "text": "Here are few standards we can have for comparison among these three:" }, { "code": null, "e": 564, "s": 547, "text": "1) Full String: " }, { "code": null, "e": 605, "s": 564, "text": "+= : We can append full string using +=." }, { "code": null, "e": 663, "s": 605, "text": "append() : We can also append full string using append()." }, { "code": null, "e": 715, "s": 663, "text": "push_back : doesn’t allow appending of full string." }, { "code": null, "e": 731, "s": 715, "text": "Implementation:" }, { "code": null, "e": 735, "s": 731, "text": "CPP" }, { "code": "// CPP code for comparison on the// basis of appending Full String#include <iostream>#include <string>using namespace std; // Function to demonstrate comparison among// +=, append(), push_back()void appendDemo(string str1, string str2){ string str = str1; // Appending using += str1 += str2; cout << \"Using += : \"; cout << str1 << endl; // Appending using append() str.append(str2); cout << \"Using append() : \"; cout << str << endl;} // Driver codeint main(){ string str1(\"Hello World! \"); string str2(\"GeeksforGeeks\"); cout << \"Original String : \" << str1 << endl; appendDemo(str1, str2); return 0;}", "e": 1382, "s": 735, "text": null }, { "code": null, "e": 1496, "s": 1382, "text": "Original String : Hello World! \nUsing += : Hello World! GeeksforGeeks\nUsing append() : Hello World! GeeksforGeeks" }, { "code": null, "e": 1526, "s": 1496, "text": "2) Appending part of String: " }, { "code": null, "e": 1571, "s": 1526, "text": "+= : Doesn’t allow appending part of string." }, { "code": null, "e": 1615, "s": 1571, "text": "append() : Allows appending part of string." }, { "code": null, "e": 1675, "s": 1615, "text": "push_back : We can’t append part of string using push_back." }, { "code": null, "e": 1691, "s": 1675, "text": "Implementation:" }, { "code": null, "e": 1695, "s": 1691, "text": "CPP" }, { "code": "// CPP code for comparison on the basis of// Appending part of string #include <iostream>#include <string>using namespace std; // Function to demonstrate comparison among// +=, append(), push_back()void appendDemo(string str1, string str2){ // Appends 5 characters from 0th index of // str2 to str1 str1.append(str2, 0, 5); cout << \"Using append() : \"; cout << str1;} // Driver codeint main(){ string str1(\"GeeksforGeeks \"); string str2(\"Hello World! \"); cout << \"Original String : \" << str1 << endl; appendDemo(str1, str2); return 0;}", "e": 2263, "s": 1695, "text": null }, { "code": null, "e": 2333, "s": 2263, "text": "Original String : GeeksforGeeks \nUsing append() : GeeksforGeeks Hello" }, { "code": null, "e": 2365, "s": 2333, "text": "3) Appending C-string (char*): " }, { "code": null, "e": 2396, "s": 2365, "text": "+= : Allows appending C-string" }, { "code": null, "e": 2441, "s": 2396, "text": "append() : It also allows appending C-string" }, { "code": null, "e": 2498, "s": 2441, "text": "push_back : We cannot append C-string using push_back()." }, { "code": null, "e": 2514, "s": 2498, "text": "Implementation:" }, { "code": null, "e": 2518, "s": 2514, "text": "CPP" }, { "code": "// CPP code for comparison on the basis of// Appending C-string #include <iostream>#include <string>using namespace std; // Function to demonstrate comparison among// +=, append(), push_back()void appendDemo(string str){ string str1 = str; // Appending using += str += \"GeeksforGeeks\"; cout << \"Using += : \"; cout << str << endl; // Appending using append() str1.append(\"GeeksforGeeks\"); cout << \"Using append() : \"; cout << str1 << endl;} // Driver codeint main(){ string str(\"World of \"); cout << \"Original String : \" << str << endl; appendDemo(str); return 0;}", "e": 3125, "s": 2518, "text": null }, { "code": null, "e": 3227, "s": 3125, "text": "Original String : World of \nUsing += : World of GeeksforGeeks\nUsing append() : World of GeeksforGeeks" }, { "code": null, "e": 3258, "s": 3227, "text": "4) Appending character array: " }, { "code": null, "e": 3299, "s": 3258, "text": "+= : Allows appending of character array" }, { "code": null, "e": 3347, "s": 3299, "text": "append() : Allows appending of character array." }, { "code": null, "e": 3396, "s": 3347, "text": "push_back : Does not allow char array appending." }, { "code": null, "e": 3412, "s": 3396, "text": "Implementation:" }, { "code": null, "e": 3416, "s": 3412, "text": "CPP" }, { "code": "// CPP code for comparison on the basis of// Appending character array #include <iostream>#include <string>using namespace std; // Function to demonstrate comparison among// +=, append(), push_back()void appendDemo(string str){ char ch[6] = { 'G', 'e', 'e', 'k', 's', '\\0' }; string str1 = str; // Appending using += str += ch; cout << \"Using += : \" << str << endl; // Appending using append() str1.append(ch); cout << \"Using append() : \"; cout << str1 << endl;} // Driver codeint main(){ string str(\"World of \"); cout << \"Original String : \" << str << endl; appendDemo(str); return 0;}", "e": 4046, "s": 3416, "text": null }, { "code": null, "e": 4132, "s": 4046, "text": "Original String : World of \nUsing += : World of Geeks\nUsing append() : World of Geeks" }, { "code": null, "e": 4164, "s": 4132, "text": "5) Appending single character: " }, { "code": null, "e": 4219, "s": 4164, "text": "+= : We can append single character using += operator." }, { "code": null, "e": 4265, "s": 4219, "text": "append() : Allows appending single character." }, { "code": null, "e": 4312, "s": 4265, "text": "push_back : Allows appending single character." }, { "code": null, "e": 4316, "s": 4312, "text": "CPP" }, { "code": "// CPP code for comparison on the basis of// Appending single character #include <iostream>#include <string>using namespace std; // Function to demonstrate comparison among// +=, append(), push_back()void appendDemo(string str){ string str1 = str; string str2 = str; // Appending using += str += 'C'; cout << \"Using += : \" << str << endl; // Appending using append() str2.append(\"C\"); cout << \"Using append() : \"; cout << str2 << endl; // Appending using push_back() str1.push_back('C'); cout << \"Using push_back : \"; cout << str1;} // Driver codeint main(){ string str(\"AB\"); cout << \"Original String : \" << str << endl; appendDemo(str); return 0;}", "e": 5021, "s": 4316, "text": null }, { "code": null, "e": 5100, "s": 5021, "text": "Original String : AB\nUsing += : ABC\nUsing append() : ABC\nUsing push_back : ABC" }, { "code": null, "e": 5120, "s": 5100, "text": "6) Iterator range: " }, { "code": null, "e": 5157, "s": 5120, "text": "+= : Doesn’t provide iterator range." }, { "code": null, "e": 5193, "s": 5157, "text": "append() : Provides iterator range." }, { "code": null, "e": 5237, "s": 5193, "text": "push_back : Doesn’t provide iterator range." }, { "code": null, "e": 5253, "s": 5237, "text": "Implementation:" }, { "code": null, "e": 5257, "s": 5253, "text": "CPP" }, { "code": "// CPP code for comparison on the basis of// Appending using iterator range #include <iostream>#include <string>using namespace std; // Function to demonstrate comparison among// +=, append(), push_back()void appendDemo(string str1, string str2){ // Appends all characters from // str2.begin()+5, str2.end() to str1 str1.append(str2.begin() + 5, str2.end()); cout << \"Using append : \"; cout << str1;}// Driver codeint main(){ string str1(\"Hello World! \"); string str2(\"GeeksforGeeks\"); cout << \"Original String : \" << str1 << endl; appendDemo(str1, str2); return 0;}", "e": 5857, "s": 5257, "text": null }, { "code": null, "e": 5926, "s": 5857, "text": "Original String : Hello World! \nUsing append : Hello World! forGeeks" }, { "code": null, "e": 5944, "s": 5926, "text": "7) Return Value: " }, { "code": null, "e": 5963, "s": 5944, "text": "+= : Return *this." }, { "code": null, "e": 5988, "s": 5963, "text": "append() : Returns *this" }, { "code": null, "e": 6025, "s": 5988, "text": "push_back : Doesn’t return anything." }, { "code": null, "e": 6041, "s": 6025, "text": "Implementation:" }, { "code": null, "e": 6045, "s": 6041, "text": "CPP" }, { "code": "// CPP code for comparison on the basis of// Return value #include <iostream>#include <string>using namespace std; // Function to demonstrate comparison among// +=, append(), push_back()string appendDemo(string str1, string str2){ // Appends str2 in str1 str1.append(str2); // Similarly with str1 += str2 cout << \"Using append : \"; // Returns *this return str1;} // Driver codeint main(){ string str1(\"Hello World! \"); string str2(\"GeeksforGeeks\"); string str; cout << \"Original String : \" << str1 << endl; str = appendDemo(str1, str2); cout << str; return 0;}", "e": 6643, "s": 6045, "text": null }, { "code": null, "e": 6717, "s": 6643, "text": "Original String : Hello World! \nUsing append : Hello World! GeeksforGeeks" }, { "code": null, "e": 7031, "s": 6717, "text": "This article is contributed by Sakshi Tiwari. If you like GeeksforGeeks(We know you do!) and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to [email protected]. See your article appearing on the GeeksforGeeks main page and help other Geeks." }, { "code": null, "e": 7044, "s": 7031, "text": "mokshgrover2" }, { "code": null, "e": 7055, "s": 7044, "text": "rit7011503" }, { "code": null, "e": 7071, "s": 7055, "text": "surbhikumaridav" }, { "code": null, "e": 7091, "s": 7071, "text": "cpp-strings-library" }, { "code": null, "e": 7095, "s": 7091, "text": "STL" }, { "code": null, "e": 7099, "s": 7095, "text": "C++" }, { "code": null, "e": 7118, "s": 7099, "text": "Difference Between" }, { "code": null, "e": 7126, "s": 7118, "text": "Strings" }, { "code": null, "e": 7134, "s": 7126, "text": "Strings" }, { "code": null, "e": 7138, "s": 7134, "text": "STL" }, { "code": null, "e": 7142, "s": 7138, "text": "CPP" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n29 Dec, 2021" }, { "code": null, "e": 374, "s": 52, "text": "In this article, we will discuss on how to get Geolocation when you enter any location name and its gives all the useful information such as postal code, city, state, country etc. with the latitudes and the longitudes (the specific coordinates) and vice-versa in which we provide the coordinates to get the location name." }, { "code": null, "e": 507, "s": 374, "text": "This can be done using the GeoPy library in python. This library isn’t built into python and hence needs to be installed explicitly." }, { "code": null, "e": 555, "s": 507, "text": "In your terminal, simply run the given command:" }, { "code": null, "e": 573, "s": 555, "text": "pip install geopy" }, { "code": null, "e": 762, "s": 573, "text": "With provided location, it is possible using geopy to extract the coordinates meaning its latitude and longitude. Therefore, it can be used to express the location in terms of coordinates." }, { "code": null, "e": 771, "s": 762, "text": "Approach" }, { "code": null, "e": 785, "s": 771, "text": "Import module" }, { "code": null, "e": 975, "s": 785, "text": "Import Nominatim from geopy- Nominatim is a free service or tool or can be called an API with no keys that provide you with the data after providing it with name and address and vice versa." }, { "code": null, "e": 1152, "s": 975, "text": "On calling the Nomination tool which accepts an argument of user_agent you can give any name as it considers it to be the name of the app to which it is providing its services." }, { "code": null, "e": 1370, "s": 1152, "text": "The geocode() function accepts the location name and returns a geodataframe that has all the details and since it’s a dataframe we can get the address, latitude and longitude by simply calling it with the given syntax" }, { "code": null, "e": 1378, "s": 1370, "text": "Syntax:" }, { "code": null, "e": 1400, "s": 1378, "text": "variablename.address " }, { "code": null, "e": 1423, "s": 1400, "text": "variablename.latitude " }, { "code": null, "e": 1447, "s": 1423, "text": "variablename.longitude." }, { "code": null, "e": 1456, "s": 1447, "text": "Example:" }, { "code": null, "e": 1464, "s": 1456, "text": "Python3" }, { "code": "# importing geopy libraryfrom geopy.geocoders import Nominatim # calling the Nominatim toolloc = Nominatim(user_agent=\"GetLoc\") # entering the location namegetLoc = loc.geocode(\"Gosainganj Lucknow\") # printing addressprint(getLoc.address) # printing latitude and longitudeprint(\"Latitude = \", getLoc.latitude, \"\\n\")print(\"Longitude = \", getLoc.longitude)", "e": 1819, "s": 1464, "text": null }, { "code": null, "e": 1827, "s": 1819, "text": "Output:" }, { "code": null, "e": 2121, "s": 1827, "text": "In this method all the things are same as the above, the only difference is instead of using the geocode function we will now use the reverse() method which accepts the coordinates (latitude and longitude) as the argument, this method gives the address after providing it with the coordinates." }, { "code": null, "e": 2129, "s": 2121, "text": "Syntax:" }, { "code": null, "e": 2157, "s": 2129, "text": "reverse(latitude,longitude)" }, { "code": null, "e": 2166, "s": 2157, "text": "Approach" }, { "code": null, "e": 2180, "s": 2166, "text": "Import module" }, { "code": null, "e": 2200, "s": 2180, "text": "Call nominatim tool" }, { "code": null, "e": 2241, "s": 2200, "text": "Pass latitude and longitude to reverse()" }, { "code": null, "e": 2261, "s": 2241, "text": "Print location name" }, { "code": null, "e": 2270, "s": 2261, "text": "Example:" }, { "code": null, "e": 2278, "s": 2270, "text": "Python3" }, { "code": "# importing modulesfrom geopy.geocoders import Nominatim # calling the nominatim toolgeoLoc = Nominatim(user_agent=\"GetLoc\") # passing the coordinateslocname = geoLoc.reverse(\"26.7674446, 81.109758\") # printing the address/location nameprint(locname.address)", "e": 2537, "s": 2278, "text": null }, { "code": null, "e": 2545, "s": 2537, "text": "Output:" }, { "code": null, "e": 2557, "s": 2545, "text": "agmalayeb19" }, { "code": null, "e": 2564, "s": 2557, "text": "Picked" }, { "code": null, "e": 2579, "s": 2564, "text": "python-modules" }, { "code": null, "e": 2594, "s": 2579, "text": "python-utility" }, { "code": null, "e": 2618, "s": 2594, "text": "Technical Scripter 2020" }, { "code": null, "e": 2625, "s": 2618, "text": "Python" }, { "code": null, "e": 2644, "s": 2625, "text": "Technical Scripter" }, { "code": null, "e": 2742, "s": 2644, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 2774, "s": 2742, "text": "How to Install PIP on Windows ?" }, { "code": null, "e": 2801, "s": 2774, "text": "Python Classes and Objects" }, { "code": null, "e": 2832, "s": 2801, "text": "Python | os.path.join() method" }, { "code": null, "e": 2855, "s": 2832, "text": "Introduction To PYTHON" }, { "code": null, "e": 2876, "s": 2855, "text": "Python OOPs Concepts" }, { "code": null, "e": 2932, "s": 2876, "text": "How to drop one or multiple columns in Pandas Dataframe" }, { "code": null, "e": 2974, "s": 2932, "text": "How To Convert Python Dictionary To JSON?" }, { "code": null, "e": 3016, "s": 2974, "text": "Check if element exists in list in Python" }, { "code": null, "e": 3055, "s": 3016, "text": "Python | Get unique values from a list" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n16 Jul, 2019" }, { "code": null, "e": 84, "s": 52, "text": "Prerequisite : Switch Case in C" }, { "code": null, "e": 227, "s": 84, "text": "Problem Statement:Write a menu-driven program using Switch case to calculate the following:1. Area of circle2. Area of square3. Area of sphere" }, { "code": null, "e": 307, "s": 227, "text": "Also use functions input() and output() to input and display respective values." }, { "code": "// C program to illustrate// Menu-Driven program// using Switch-case #include <stdio.h>int input();void output(float);int main(){ float result; int choice, num; printf(\"Press 1 to calculate area of circle\\n\"); printf(\"Press 2 to calculate area of square\\n\"); printf(\"Press 3 to calculate area of sphere\\n\"); printf(\"Enter your choice:\\n\"); choice = input(); switch (choice) { case 1: { printf(\"Enter radius:\\n\"); num = input(); result = 3.14 * num * num; printf(\"Area of sphere=\"); output(result); break; } case 2: { printf(\"Enter side of square:\\n\"); num = input(); result = num * num; printf(\"Area of square=\"); output(result); break; } case 3: { printf(\"Enter radius:\\n\"); num = input(); result = 4 * (3.14 * num * num); printf(\"Area of sphere=\"); output(result); break; } default: printf(\"wrong Input\\n\"); } return 0;}int input(){ int number; scanf(\"%d\", &number); return (number);} void output(float number){ printf(\"%f\", number);}", "e": 1448, "s": 307, "text": null }, { "code": null, "e": 1456, "s": 1448, "text": "Output:" }, { "code": null, "e": 1622, "s": 1456, "text": "Press 1 to calculate area of circle\nPress 2 to calculate area of square\nPress 3 to calculate area of sphere\nEnter your choice:\n1\nEnter radius:\n5\nArea of circle=78.5\n" }, { "code": null, "e": 1640, "s": 1622, "text": "Related Articles:" }, { "code": null, "e": 1686, "s": 1640, "text": "Interesting facts about switch statement in C" }, { "code": null, "e": 1730, "s": 1686, "text": "Output of C programs | Set 30 (Switch Case)" }, { "code": null, "e": 1766, "s": 1730, "text": "Using range in switch case in C/C++" }, { "code": null, "e": 1777, "s": 1766, "text": "cpp-switch" }, { "code": null, "e": 1798, "s": 1777, "text": "Menu driven programs" }, { "code": null, "e": 1809, "s": 1798, "text": "C Programs" }, { "code": null, "e": 1822, "s": 1809, "text": "C++ Programs" }, { "code": null, "e": 1841, "s": 1822, "text": "School Programming" }, { "code": null, "e": 1860, "s": 1841, "text": "Technical Scripter" }, { "code": null, "e": 1958, "s": 1860, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 1993, "s": 1958, "text": "Header files in C/C++ and its uses" }, { "code": null, "e": 2034, "s": 1993, "text": "C Program to read contents of Whole File" }, { "code": null, "e": 2093, "s": 2034, "text": "How to return multiple values from a function in C or C++?" }, { "code": null, "e": 2127, "s": 2093, "text": "C++ Program to check Prime Number" }, { "code": null, "e": 2158, "s": 2127, "text": "Producer Consumer Problem in C" }, { "code": null, "e": 2193, "s": 2158, "text": "Header files in C/C++ and its uses" }, { "code": null, "e": 2227, "s": 2193, "text": "Sorting a Map by value in C++ STL" }, { "code": null, "e": 2286, "s": 2227, "text": "How to return multiple values from a function in C or C++?" }, { "code": null, "e": 2324, "s": 2286, "text": "C++ program for hashing with chaining" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n02 Jun, 2020" }, { "code": null, "e": 652, "s": 28, "text": "Blob is a fundamental data type in JavaScript. Blob stands for Binary Large Object and it is a representation of bytes of data. Web browsers support the Blob data type for holding data. Blob is the underlying data structure for the File object and the FileReader API. Blob has a specific size and file type just like ordinary files and it can be stored and retrieved from the system memory. Blob can also be converted and read as Buffers. Buffers are very handy to store binary data such as the binary data of an image or a file. We will be using the FileReader API to convert Blob to a Base64 Encoded String in JavaScript." }, { "code": null, "e": 1279, "s": 652, "text": "We cannot transfer Binary data over a Network in its raw format. This is because the raw bytes may be interpreted incorrectly due to the different protocols involved in the Network. There is also a higher chance of it being corrupted while being transferred over the Network. Hence this binary data is encoded into characters using Base64 encoding before being transferred over the network such as in email attachments, HTML form data, etc. Base64 encoding is a way of converting arbitrary Binary data into ASCII characters. Base64 encoding is used so that we do not have to rely on external files and scripts in web browsers." }, { "code": null, "e": 1777, "s": 1279, "text": "Example: Convert Blob to Base64 Encoded String using FileReader API. The FileReader.readAsDataURL() reads the contents of the specified Blob data type and will return a Base64 Encoded String with data: attribute. The FileReader.onloadend Event is fired when the reading of the data has been completed successfully or when an error is encountered. We have created a sample Blob using the Blob() constructor. The constructor takes in values in a String[] and an Object consisting of the String type." }, { "code": null, "e": 1786, "s": 1777, "text": "Program:" }, { "code": null, "e": 2573, "s": 1786, "text": "<!DOCTYPE html><html lang=\"en\"> <head> <meta charset=\"UTF-8\"> <title>Convert Blob to Base64 String</title></head> <body><div>Hello GeeksForGeeks</div><script type=\"text/javascript\"> let blob = new Blob([\"GeeksForGeeks\"], { type: \"text/plain\" }); // The full Blob Object can be seen // in the Console of the Browser console.log('Blob - ', blob); var reader = new FileReader(); reader.readAsDataURL(blob); reader.onloadend = function () { var base64String = reader.result; console.log('Base64 String - ', base64String); // Simply Print the Base64 Encoded String, // without additional data: Attributes. console.log('Base64 String without Tags- ', base64String.substr(base64String.indexOf(', ') + 1)); } </script></body></html>" }, { "code": "<!DOCTYPE html><html lang=\"en\"> <head> <meta charset=\"UTF-8\"> <title>Convert Blob to Base64 String</title></head> <body><div>Hello GeeksForGeeks</div><script type=\"text/javascript\"> let blob = new Blob([\"GeeksForGeeks\"], { type: \"text/plain\" }); // The full Blob Object can be seen // in the Console of the Browser console.log('Blob - ', blob); var reader = new FileReader(); reader.readAsDataURL(blob); reader.onloadend = function () { var base64String = reader.result; console.log('Base64 String - ', base64String); // Simply Print the Base64 Encoded String, // without additional data: Attributes. console.log('Base64 String without Tags- ', base64String.substr(base64String.indexOf(', ') + 1)); } </script></body></html>", "e": 3360, "s": 2573, "text": null }, { "code": null, "e": 3368, "s": 3360, "text": "Output:" }, { "code": null, "e": 3384, "s": 3368, "text": "JavaScript-Misc" }, { "code": null, "e": 3391, "s": 3384, "text": "Picked" }, { "code": null, "e": 3402, "s": 3391, "text": "JavaScript" }, { "code": null, "e": 3419, "s": 3402, "text": "Web Technologies" }, { "code": null, "e": 3446, "s": 3419, "text": "Web technologies Questions" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n06 Jul, 2022" }, { "code": null, "e": 336, "s": 52, "text": "The map::find() is a built-in function in C++ STL which returns an iterator or a constant iterator that refers to the position where the key is present in the map. If the key is not present in the map container, it returns an iterator or a constant iterator which refers to map.end()" }, { "code": null, "e": 347, "s": 336, "text": ". Syntax: " }, { "code": null, "e": 424, "s": 347, "text": "iterator=map_name.find(key)\n or \nconstant iterator=map_name.find(key)" }, { "code": null, "e": 548, "s": 424, "text": "Parameters: The function accepts one mandatory parameter key, which specifies the key to be searched in the map container. " }, { "code": null, "e": 806, "s": 548, "text": "Return Value: The function returns an iterator or a constant iterator which refers to the position where the key is present in the map. If the key is not present in the map container, it returns an iterator or a constant iterator which refers to map.end(). " }, { "code": null, "e": 1114, "s": 806, "text": "Time Complexity for Searching element : The time complexity for searching elements in std::map is O(log n). Even in the worst case, it will be O(log n) because elements are stored internally as Balanced Binary Search tree (BST) whereas, in std::unordered_map best case time complexity for searching is O(1)." }, { "code": null, "e": 1164, "s": 1114, "text": "Below is the illustration of the above function: " }, { "code": null, "e": 1168, "s": 1164, "text": "CPP" }, { "code": "// C++ program for illustration// of map::find() function#include <bits/stdc++.h>using namespace std; int main(){ // Initialize container map<int, int> mp; // Insert elements in random order mp.insert({ 2, 30 }); mp.insert({ 1, 40 }); mp.insert({ 3, 20 }); mp.insert({ 4, 50 }); cout << \"Elements from position of 3 in the map are : \\n\"; cout << \"KEY\\tELEMENT\\n\"; // find() function finds the position // at which 3 is present for (auto itr = mp.find(3); itr != mp.end(); itr++) { cout << itr->first << '\\t' << itr->second << '\\n'; } return 0;}", "e": 1781, "s": 1168, "text": null }, { "code": null, "e": 1855, "s": 1781, "text": "The elements from position 3 in map are : \nKEY ELEMENT\n3 20\n4 50" }, { "code": null, "e": 1902, "s": 1855, "text": "Time Complexity: O(log n)Auxiliary Space: O(n)" }, { "code": null, "e": 1909, "s": 1902, "text": "cheesy" }, { "code": null, "e": 1923, "s": 1909, "text": "privatehandle" }, { "code": null, "e": 1944, "s": 1923, "text": "abhijitgeeksforgeeks" }, { "code": null, "e": 1956, "s": 1944, "text": "jayanth_mkv" }, { "code": null, "e": 1970, "s": 1956, "text": "CPP-Functions" }, { "code": null, "e": 1978, "s": 1970, "text": "cpp-map" }, { "code": null, "e": 1982, "s": 1978, "text": "STL" }, { "code": null, "e": 1986, "s": 1982, "text": "C++" }, { "code": null, "e": 1990, "s": 1986, "text": "STL" }, { "code": null, "e": 1994, "s": 1990, "text": "CPP" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n14 May, 2020" }, { "code": null, "e": 260, "s": 28, "text": "A Dictionary in Python works similar to the Dictionary in the real world. Keys of a Dictionary must be unique and of immutable data types such as Strings, Integers, and tuples, but the key-values can be repeated and be of any type." }, { "code": null, "e": 323, "s": 260, "text": "Refer to the below article to get the idea about dictionaries:" }, { "code": null, "e": 341, "s": 323, "text": "Python Dictionary" }, { "code": null, "e": 444, "s": 341, "text": "Nested Dictionary: The nested dictionaries in Python are nothing but dictionaries within a dictionary." }, { "code": null, "e": 489, "s": 444, "text": "Consider an employee record as given below :" }, { "code": null, "e": 615, "s": 489, "text": "Employees\nemp1:\n name:Lisa\n age:29\n designation:Programmer\nemp2:\n name:Steve\n age:45\n designation:HR\n" }, { "code": null, "e": 788, "s": 615, "text": "Here, the employees is the outer dictionary. emp1, emp2 are keys that have another dictionary as their value. The dictionary structure of the above information appears as :" }, { "code": null, "e": 969, "s": 788, "text": "employees:\n{\n emp1:\n {\n 'name':'Lisa',\n 'age':29,\n 'designation':'Programmer'\n },\nemp2:\n {\n 'name':'Steve',\n 'age':45,\n 'designation':'HR'\n }\n}\n" }, { "code": null, "e": 1297, "s": 969, "text": "Consider a simple dictionary like d={'a':1, 'b':2, 'c':3}. If you want to update the value of ‘b’ to 7, you can write as d['b']=7. However the same method cannot be applied to nested ones. That will create a new key as the keys in outer dictionary will only be searched while you try to update. For example, see the code below:" }, { "code": "# an employee recordEmployee = { 'emp1': { 'name': 'Lisa', 'age': '29', 'Designation':'Programmer' }, 'emp2': { 'name': 'Steve', 'age': '45', 'Designation':'HR' }} # updating in the way similar to# simple dictionaryEmployee['name']='Kate' print(Employee)", "e": 1644, "s": 1297, "text": null }, { "code": null, "e": 1790, "s": 1644, "text": "{‘name’: ‘Kate’, ’emp1′: {‘Designation’: ‘Programmer’, ‘name’: ‘Lisa’, ‘age’: ’29’}, ’emp2′: {‘Designation’: ‘HR’, ‘name’: ‘Steve’, ‘age’: ’45’}}" }, { "code": null, "e": 2118, "s": 1790, "text": "In the output look that ‘name’:’Kate’ is added as a new key-value pair which is not our desired output. Let us consider that we need to update first employee’s name as ‘Kate’. Let us look at our dictionary as a 2D-array. This will help us update the information easily. The 2D-array view of the above dictionary is given below:" }, { "code": null, "e": 2249, "s": 2118, "text": "Employee name age Designation\nemp1 Lisa 29 Programmer\nemp2 Steve 45 HR\n" }, { "code": null, "e": 2389, "s": 2249, "text": "Now we have to update the first employee’s name as ‘Kate’. So we have to update Employee[’emp1′][‘name’]. The modified code is given below:" }, { "code": "# an employee recordEmployee = { 'emp1': { 'name': 'Lisa', 'age': '29', 'Designation':'Programmer' }, 'emp2': { 'name': 'Steve', 'age': '25', 'Designation':'HR' } } # updating in the way similar to simple dictionaryEmployee['emp1']['name']='Kate' print(Employee)", "e": 2765, "s": 2389, "text": null }, { "code": null, "e": 2895, "s": 2765, "text": "{’emp2′: {‘Designation’: ‘HR’, ‘age’: ’25’, ‘name’: ‘Steve’}, ’emp1′: {‘Designation’: ‘Programmer’, ‘age’: ’29’, ‘name’: ‘Kate’}}" }, { "code": null, "e": 3142, "s": 2895, "text": "The above method updates the value for the mentioned key if it is present in the dictionary. Otherwise, it creates a new entry. For example if you want to add a new attribute ‘salary’ for the first employee, then you can write the above code as :" }, { "code": "# an employee recordEmployee = { 'emp1': { 'name': 'Lisa', 'age': '29', 'Designation':'Programmer' }, 'emp2': { 'name': 'Steve', 'age': '25', 'Designation':'HR' } } # updating in the way similar to # simple dictionaryEmployee['emp1']['name']='Kate' # adding new key-value pair to first # employee recordEmployee['emp1']['salary']= 56000 print(Employee)", "e": 3609, "s": 3142, "text": null }, { "code": null, "e": 3756, "s": 3609, "text": "{’emp1′: {‘Designation’: ‘Programmer’, ‘salary’: 56000, ‘name’: ‘Kate’, ‘age’: ’29’}, ’emp2′: {‘Designation’: ‘HR’, ‘name’: ‘Steve’, ‘age’: ’25’}}" }, { "code": null, "e": 3876, "s": 3756, "text": "The above methods are static. Now to make it interactive with the user, we can slightly modify the code as given below:" }, { "code": "# an employee recordEmployee = { 'emp1': { 'name': 'Lisa', 'age': '29', 'Designation':'Programmer' }, 'emp2': { 'name': 'Steve', 'age': '25', 'Designation':'HR' } } # to make the updation dynamic # Get input from the user for which # employee he needs to updateempid = input(\"Employee id :\") # which attribute / key to updateattribute = input(\"Attribute to be updated :\") # what value to updatenew_value = input(\"New value :\") # updation of the dictionaryEmployee[empid][attribute]= new_value print(Employee)", "e": 4504, "s": 3876, "text": null }, { "code": null, "e": 4569, "s": 4504, "text": "Employee id :emp1\nAttribute to be updated :name\nNew value :Kate\n" }, { "code": null, "e": 4699, "s": 4569, "text": "{’emp1′: {‘age’: ’29’, ‘Designation’: ‘Programmer’, ‘name’: ‘Kate’}, ’emp2′: {‘age’: ’25’, ‘Designation’: ‘HR’, ‘name’: ‘Steve’}}" }, { "code": null, "e": 4742, "s": 4699, "text": "Let us try to be a bit more professional!!" }, { "code": null, "e": 4766, "s": 4742, "text": "An alternative approach" }, { "code": null, "e": 4929, "s": 4766, "text": "The idea is to flatten the nested dictionary first, then update it and unflatten it again. To make it more clear, consider the following dictionary as an example:" }, { "code": null, "e": 5058, "s": 4929, "text": "dict1={\n 'a':{\n 'b':1\n },\n 'c':{\n 'd':2,\n 'e':5\n }\n }\n" }, { "code": null, "e": 5401, "s": 5058, "text": "Flattening a nested dictionary is nothing but appending the parent key with the real key using appropriate separators. The separator can be any symbol. It can be a comma(, ), or a hyphen(-), or an underscore(_), or a period(.), or even just a space( ). Here, after flattening with underscore as the separator, this dictionary will look like :" }, { "code": null, "e": 5436, "s": 5401, "text": "dict1={'a_b':1, 'c_d':2, 'c_e':5}\n" }, { "code": null, "e": 5678, "s": 5436, "text": "The flattening can be easily done with the in-built methods provided by the package flatten-dict in Python. It provides methods for flattening dictionary like objects and unflattening them. Install the package using the pip command as below:" }, { "code": null, "e": 5703, "s": 5678, "text": "pip install flatten-dict" }, { "code": null, "e": 5721, "s": 5703, "text": "flatten() method:" }, { "code": null, "e": 5871, "s": 5721, "text": "The flatten method has various arguments to format it in a desirable, readable and understandable way. The two most important arguments among all is:" }, { "code": null, "e": 6439, "s": 5871, "text": "dict : The flattened dictionary which has to be convertedreducer : It specifies how the parent key is joined with the child. The values possible are tuple, path, underscore or a user defined function name.tuple: creates a tuple of parent and child keys as the key and assigns the value to it.path : Appends ‘/’ between the parent and child key.underscore: Appends ‘_’ between the parent and child key.User defined function: The parent and child key should be passed to the function as arguments. The function should return them as a string separated by desired symbol" }, { "code": null, "e": 6497, "s": 6439, "text": "dict : The flattened dictionary which has to be converted" }, { "code": null, "e": 6646, "s": 6497, "text": "reducer : It specifies how the parent key is joined with the child. The values possible are tuple, path, underscore or a user defined function name." }, { "code": null, "e": 6734, "s": 6646, "text": "tuple: creates a tuple of parent and child keys as the key and assigns the value to it." }, { "code": null, "e": 6787, "s": 6734, "text": "path : Appends ‘/’ between the parent and child key." }, { "code": null, "e": 6845, "s": 6787, "text": "underscore: Appends ‘_’ between the parent and child key." }, { "code": null, "e": 7012, "s": 6845, "text": "User defined function: The parent and child key should be passed to the function as arguments. The function should return them as a string separated by desired symbol" }, { "code": null, "e": 7075, "s": 7012, "text": "Other arguments enumerate_types, keep_empty_types are optional" }, { "code": null, "e": 7095, "s": 7075, "text": "unflatten() method:" }, { "code": null, "e": 7208, "s": 7095, "text": "This method unflattens the flattened dictionary and converts it into a nested one. It can take three arguments :" }, { "code": null, "e": 7541, "s": 7208, "text": "dict : The flattened dictionary which has to be revertedsplitter : The symbol on which the flattened dictionary has to be split. Like flatten method, this also takes up the value tuple, path, underscore or a user defined function.inverse : Takes a boolean value indicating whether key and value has to be inverted. This is optional." }, { "code": null, "e": 7598, "s": 7541, "text": "dict : The flattened dictionary which has to be reverted" }, { "code": null, "e": 7773, "s": 7598, "text": "splitter : The symbol on which the flattened dictionary has to be split. Like flatten method, this also takes up the value tuple, path, underscore or a user defined function." }, { "code": null, "e": 7876, "s": 7773, "text": "inverse : Takes a boolean value indicating whether key and value has to be inverted. This is optional." }, { "code": null, "e": 7959, "s": 7876, "text": "Let us consider the same Employee example we tried above. The code is given below:" }, { "code": "from flatten_dict import flattenfrom flatten_dict import unflatten # an employee recordEmployee = { 'emp1': { 'name': 'Lisa', 'age': '29', 'Designation':'Programmer' }, 'emp2': { 'name': 'Steve', 'age': '25', 'Designation':'HR' } } # flattening the dictionary, default # reducer is 'tuple'dict3 = flatten(Employee) print(\"Flattened dictionary :\", dict3) # adding new key-value pair to second # employee's recorddict3[('emp2', 'salary')]= 34000 print(dict3) # unflattening the dictionary, default # splitter is 'tuple'Employee = unflatten(dict3) print(\"\\nUnflattened and updated dictionary :\", Employee)", "e": 8680, "s": 7959, "text": null }, { "code": null, "e": 8688, "s": 8680, "text": "Output:" }, { "code": null, "e": 9077, "s": 8688, "text": "Flattened dictionary : {(’emp1′, ‘name’): ‘Lisa’, (’emp1′, ‘age’): ’29’, (’emp1′, ‘Designation’): ‘Programmer’, (’emp2′, ‘name’): ‘Steve’, (’emp2′, ‘age’): ’25’, (’emp2′, ‘Designation’): ‘HR’}{(’emp1′, ‘name’): ‘Lisa’, (’emp1′, ‘age’): ’29’, (’emp1′, ‘Designation’): ‘Programmer’, (’emp2′, ‘name’): ‘Steve’, (’emp2′, ‘age’): ’25’, (’emp2′, ‘Designation’): ‘HR’, (’emp2′, ‘salary’): 34000}" }, { "code": null, "e": 9261, "s": 9077, "text": "Unflattened and updated dictionary : {’emp1′: {‘name’: ‘Lisa’, ‘age’: ’29’, ‘Designation’: ‘Programmer’}, ’emp2′: {‘name’: ‘Steve’, ‘age’: ’25’, ‘Designation’: ‘HR’, ‘salary’: 34000}}" }, { "code": null, "e": 9273, "s": 9261, "text": "python-dict" }, { "code": null, "e": 9298, "s": 9273, "text": "Python-nested-dictionary" }, { "code": null, "e": 9305, "s": 9298, "text": "Python" }, { "code": null, "e": 9324, "s": 9305, "text": "Technical Scripter" }, { "code": null, "e": 9336, "s": 9324, "text": "python-dict" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n10 Jan, 2022" }, { "code": null, "e": 114, "s": 28, "text": "Problem Statement: Given a set of strings, find the longest common prefix.Examples: " }, { "code": null, "e": 227, "s": 114, "text": "Input: {\"geeksforgeeks\", \"geeks\", \"geek\", \"geezer\"}\nOutput: \"gee\"\n\nInput: {\"apple\", \"ape\", \"april\"}\nOutput: \"ap\"" }, { "code": null, "e": 589, "s": 229, "text": "The longest common prefix for an array of strings is the common prefix between 2 most dissimilar strings. For example, in the given array {“apple”, “ape”, “zebra”}, there is no common prefix because the 2 most dissimilar strings of the array “ape” and “zebra” do not share any starting characters. We have discussed five different approaches in below posts. " }, { "code": null, "e": 685, "s": 589, "text": "Word by Word MatchingCharacter by Character MatchingDivide and ConquerBinary Search.Using Trie)" }, { "code": null, "e": 707, "s": 685, "text": "Word by Word Matching" }, { "code": null, "e": 739, "s": 707, "text": "Character by Character Matching" }, { "code": null, "e": 758, "s": 739, "text": "Divide and Conquer" }, { "code": null, "e": 773, "s": 758, "text": "Binary Search." }, { "code": null, "e": 785, "s": 773, "text": "Using Trie)" }, { "code": null, "e": 963, "s": 787, "text": "In this post a new method based on sorting is discussed. The idea is to sort the array of strings and find the common prefix of the first and last string of the sorted array. " }, { "code": null, "e": 972, "s": 963, "text": "Python 3" }, { "code": "# Python 3 program to find longest # common prefix of given array of words.def longestCommonPrefix( a): size = len(a) # if size is 0, return empty string if (size == 0): return \"\" if (size == 1): return a[0] # sort the array of strings a.sort() # find the minimum length from # first and last string end = min(len(a[0]), len(a[size - 1])) # find the common prefix between # the first and last string i = 0 while (i < end and a[0][i] == a[size - 1][i]): i += 1 pre = a[0][0: i] return pre # Driver Codeif __name__ == \"__main__\": input = [\"geeksforgeeks\", \"geeks\", \"geek\", \"geezer\"] print(\"The longest Common Prefix is :\" , longestCommonPrefix(input)) # This code is contributed by ita_c", "e": 1810, "s": 972, "text": null }, { "code": null, "e": 1820, "s": 1810, "text": "Output: " }, { "code": null, "e": 1855, "s": 1820, "text": "The longest common prefix is : gee" }, { "code": null, "e": 2220, "s": 1855, "text": "Time Complexity: O(MAX * n * log n ) where n is the number of strings in the array and MAX is maximum number of characters in any string. Please note that comparison of two strings would take at most O(MAX) time and for sorting n strings, we would need O(MAX * n * log n ) time.Please refer complete article on Longest Common Prefix using Sorting for more details!" }, { "code": null, "e": 2242, "s": 2220, "text": "Longest Common Prefix" }, { "code": null, "e": 2258, "s": 2242, "text": "Python Programs" }, { "code": null, "e": 2266, "s": 2258, "text": "Sorting" }, { "code": null, "e": 2274, "s": 2266, "text": "Strings" }, { "code": null, "e": 2282, "s": 2274, "text": "Strings" }, { "code": null, "e": 2290, "s": 2282, "text": "Sorting" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n15 Jun, 2022" }, { "code": null, "e": 724, "s": 28, "text": "NodeJS is the runtime environment, which can execute the javascript code on any platform. It is widely used to create and run web application servers because of its salient features. During production, several times we need to send the resources or some type of information as a response, and javascript object notation (JSON) syntax is widely used to send data also it is used for communication between any two applications. In this article, we are going to see how we can send information to the user as JSON through a node.js server. NodeJS contains an inbuilt HTTP module, it is used to transfer data over the HTTP protocol and supports many features that are useful for any web application." }, { "code": null, "e": 767, "s": 724, "text": "Let’s see the step-by-step implementation." }, { "code": null, "e": 803, "s": 767, "text": "Step 1: Create a NodeJS application" }, { "code": null, "e": 1069, "s": 803, "text": "Write this command in your terminal and it will create a node application. This command will also ask for few configurations for this application which is quite simple to provide. As another option, you can use the -y flag after npm init for default configurations." }, { "code": null, "e": 1078, "s": 1069, "text": "npm init" }, { "code": null, "e": 1223, "s": 1078, "text": "Step 2: Create a Javascript file and we are going to name it app.js you can name whatever you want. In this file, we will write our entire code." }, { "code": null, "e": 1300, "s": 1223, "text": "Project structure: Now our directory structure will look like the following." }, { "code": null, "e": 1542, "s": 1300, "text": "Step 3: Now we are going to create a backend server, more clearly creating a server is nothing but writing few lines of code and calling the inbuilt functions of nodejs. It just creates a runtime that executes javascript code on the machine." }, { "code": null, "e": 1552, "s": 1542, "text": "Approach:" }, { "code": null, "e": 2046, "s": 1552, "text": "Import the HTTP module with require keyword at the top of the app.js file, and store that returned result in a const variable.Now call the createServer() function, it will provide you a web server in return. Later this server object will be used to listen the connection on a specified host and portNow call the function listen() by providing the port number, hostname, and callback function.The callback function will get executed either on the successful start of the server or on a failure." }, { "code": null, "e": 2173, "s": 2046, "text": "Import the HTTP module with require keyword at the top of the app.js file, and store that returned result in a const variable." }, { "code": null, "e": 2347, "s": 2173, "text": "Now call the createServer() function, it will provide you a web server in return. Later this server object will be used to listen the connection on a specified host and port" }, { "code": null, "e": 2441, "s": 2347, "text": "Now call the function listen() by providing the port number, hostname, and callback function." }, { "code": null, "e": 2543, "s": 2441, "text": "The callback function will get executed either on the successful start of the server or on a failure." }, { "code": null, "e": 2550, "s": 2543, "text": "app.js" }, { "code": "const http = require('http'); const server = http.createServer(); server.listen(3000,'localhost', function(error){ if(!error) console.log(\"Server is Listening at Port 3000!\"); else console.log(\"Error Occurred\");});", "e": 2785, "s": 2550, "text": null }, { "code": null, "e": 2929, "s": 2785, "text": "Output: Use the node app.js command in your terminal to run the server. Something like this will be shown in your terminal on successful start." }, { "code": null, "e": 3271, "s": 2929, "text": "Step 4: Create a Request Listener. Till step 3 we have successfully created a server but currently, the server will neither interact with us nor respond to our request. The reason is we have not created the request listeners yet. In this step we are going to create a request listener, this gets called every time someone hits on the server." }, { "code": null, "e": 3281, "s": 3271, "text": "Approach:" }, { "code": null, "e": 3675, "s": 3281, "text": "Create a simple function as we do in javascript, and this function will receive the request and response object as a parameter, and we can perform any server-related functionalities inside this.The first console.log() statement is just to indicate that our server is working and the request listener is being called on any request.Next, we are preparing some random data to send as a response." }, { "code": null, "e": 3870, "s": 3675, "text": "Create a simple function as we do in javascript, and this function will receive the request and response object as a parameter, and we can perform any server-related functionalities inside this." }, { "code": null, "e": 4008, "s": 3870, "text": "The first console.log() statement is just to indicate that our server is working and the request listener is being called on any request." }, { "code": null, "e": 4071, "s": 4008, "text": "Next, we are preparing some random data to send as a response." }, { "code": null, "e": 4078, "s": 4071, "text": "app.js" }, { "code": "const requestListener = (req, res)=>{ console.log(\"Request is Incoming\"); const responseData = { message:\"Hello, GFG Learner\", articleData:{ articleName: \"How to send JSON response from NodeJS\", category:\"NodeJS\", status: \"published\" }, endingMessage:\"Visit Geeksforgeeks.org for more\" }};", "e": 4409, "s": 4078, "text": null }, { "code": null, "e": 4515, "s": 4409, "text": "Step 5: Now we will send the response. The data will be sent along with the response object to the user. " }, { "code": null, "e": 4525, "s": 4515, "text": "Approach:" }, { "code": null, "e": 5383, "s": 4525, "text": "Inside the requestListener before sending a response, we are creating a jsonContent from a javascript object because the end() function which will be used to send data, receives either a buffer or string as data.The JSON.stringify() is the inbuilt method in nodejs it accepts a javascript object and returns the stringified object.The call to end() function indicates to the server that all processes have been finished so that it can send the response to the user.The end function can receive data to be sent along with the response, callback function which gets called when the response stream finishes successfully, and character encoding.In our case, we are only interested in sending the data.Finally, we have passed the request listener inside createServer(), so that each request to the server can call this functionality inside the request listener." }, { "code": null, "e": 5596, "s": 5383, "text": "Inside the requestListener before sending a response, we are creating a jsonContent from a javascript object because the end() function which will be used to send data, receives either a buffer or string as data." }, { "code": null, "e": 5716, "s": 5596, "text": "The JSON.stringify() is the inbuilt method in nodejs it accepts a javascript object and returns the stringified object." }, { "code": null, "e": 6084, "s": 5716, "text": "The call to end() function indicates to the server that all processes have been finished so that it can send the response to the user.The end function can receive data to be sent along with the response, callback function which gets called when the response stream finishes successfully, and character encoding.In our case, we are only interested in sending the data." }, { "code": null, "e": 6244, "s": 6084, "text": "Finally, we have passed the request listener inside createServer(), so that each request to the server can call this functionality inside the request listener." }, { "code": null, "e": 6251, "s": 6244, "text": "app.js" }, { "code": "const http = require('http'); const requestListener = (req, res)=>{ console.log(\"Request is Incoming\"); const responseData = { message:\"Hello, GFG Learner\", articleData:{ articleName: \"How to send JSON response from NodeJS\", category:\"NodeJS\", status: \"published\" }, endingMessage:\"Visit Geeksforgeeks.org for more\" } const jsonContent = JSON.stringify(responseData); res.end(jsonContent);}; const server = http.createServer(requestListener); server.listen(3000,'localhost', function(){ console.log(\"Server is Listening at Port 3000!\");});", "e": 6842, "s": 6251, "text": null }, { "code": null, "e": 6921, "s": 6842, "text": "Step to run the application: Open the terminal and type the following command." }, { "code": null, "e": 6933, "s": 6921, "text": "node app.js" }, { "code": null, "e": 7104, "s": 6933, "text": "Output: This is the JSON response of the request. If we open the network section of the chrome developers tool we will be able to see the actual response from the server." }, { "code": null, "e": 7177, "s": 7104, "text": "So that was all about sending responses as JSON from the NodeJS server. " }, { "code": null, "e": 7190, "s": 7177, "text": "nikhatkhan11" }, { "code": null, "e": 7195, "s": 7190, "text": "JSON" }, { "code": null, "e": 7212, "s": 7195, "text": "NodeJS-Questions" }, { "code": null, "e": 7219, "s": 7212, "text": "Picked" }, { "code": null, "e": 7227, "s": 7219, "text": "Node.js" }, { "code": null, "e": 7244, "s": 7227, "text": "Web Technologies" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n09 Dec, 2021" }, { "code": null, "e": 265, "s": 28, "text": "Triadic Closure for a Graph is the tendency for nodes who has a common neighbour to have an edge between them. In case more edges are added in the Graph, these are the edges that tend to get formed. For example in the following Graph : " }, { "code": null, "e": 399, "s": 265, "text": "The edges that are most likely to be formed next are (B, F), (C, D), (F, H), and (D, H) because these pairs share a common neighbour." }, { "code": null, "e": 615, "s": 399, "text": "Local Clustering Coefficient of a node in a Graph is the fraction of pairs of the node’s neighbours that are adjacent to each other. For example the node C of the above graph has four adjacent nodes, A, B, E and F. " }, { "code": null, "e": 865, "s": 615, "text": "Number of possible pairs that can be formed using these 4 nodes are 4*(4-1)/2 = 6. Number of actual pairs that are adjacent to each other = 2. These are (A, B) and (E, F). Thus Local Clustering Coefficient for node C in the given Graph = 2/6 = 0.667" }, { "code": null, "e": 918, "s": 865, "text": "Networkx helps us get the clustering values easily. " }, { "code": null, "e": 926, "s": 918, "text": "Python3" }, { "code": "import networkx as nx G = nx.Graph() G.add_edges_from([('A', 'B'), ('A', 'K'), ('B', 'K'), ('A', 'C'), ('B', 'C'), ('C', 'F'), ('F', 'G'), ('C', 'E'), ('E', 'F'), ('E', 'D'), ('E', 'H'), ('I', 'J')]) # returns a Dictionary with clustering value of each nodeprint(nx.clustering(G)) # This returns clustering value of specified nodeprint(nx.clustering(G, 'C'))", "e": 1319, "s": 926, "text": null }, { "code": null, "e": 1533, "s": 1319, "text": "Output:\n{'A': 0.6666666666666666,\n 'B': 0.6666666666666666,\n 'C': 0.3333333333333333,\n 'D': 0,\n 'E': 0.16666666666666666,\n 'F': 0.3333333333333333,\n 'G': 0,\n 'H': 0,\n 'I': 0,\n 'J': 0,\n 'K': 1.0}\n0.3333333333333333" }, { "code": null, "e": 1584, "s": 1533, "text": "There are two separate ways for finding that out :" }, { "code": null, "e": 1887, "s": 1584, "text": "1. We can average over all the Local Clustering Coefficient of individual nodes, that is sum of local clustering coefficient of all nodes divided by total number of nodes. nx.average_clustering(G) is the code for finding that out. In the Graph given above, this returns a value of 0.28787878787878785. " }, { "code": null, "e": 1933, "s": 1887, "text": "2. We can measure Transitivity of the Graph. " }, { "code": null, "e": 2037, "s": 1933, "text": "Transitivity of a Graph = 3 * Number of triangles in a Graph / Number of connected triads in the Graph." }, { "code": null, "e": 2129, "s": 2037, "text": "In other words, it is thrice the ratio of number of closed triads to number of open triads." }, { "code": null, "e": 2152, "s": 2129, "text": "This is a Closed Triad" }, { "code": null, "e": 2304, "s": 2152, "text": "This is an Open Triad.nx.transitivity(G) is the code for getting the Transitivity. In the Graph given above, it returns a value of 0.4090909090909091. " }, { "code": null, "e": 2522, "s": 2304, "text": "Now, we know that the graph given above is not connected. Networkx provides a number of in-built functions to check on the various Connectivity features of a Graph. They are better illustrated in the following code: " }, { "code": null, "e": 2530, "s": 2522, "text": "Python3" }, { "code": "import networkx as nx G = nx.Graph() G.add_edges_from([('A', 'B'), ('A', 'K'), ('B', 'K'), ('A', 'C'), ('B', 'C'), ('C', 'F'), ('F', 'G'), ('C', 'E'), ('E', 'F'), ('E', 'D'), ('E', 'H'), ('I', 'J')]) nx.draw_networkx(G, with_labels = True, node_color ='green') # returns True or False whether Graph is connectedprint(nx.is_connected(G)) # returns number of different connected componentsprint(nx.number_connected_components(G)) # returns list of nodes in different connected componentsprint(list(nx.connected_components(G))) # returns list of nodes of component containing given nodeprint(nx.node_connected_component(G, 'I')) # returns number of nodes to be removed# so that Graph becomes disconnectedprint(nx.node_connectivity(G)) # returns number of edges to be removed# so that Graph becomes disconnectedprint(nx.edge_connectivity(G))", "e": 3402, "s": 2530, "text": null }, { "code": null, "e": 3411, "s": 3402, "text": "Output: " }, { "code": null, "e": 3495, "s": 3411, "text": "False\n2\n[{'B', 'H', 'C', 'A', 'K', 'E', 'F', 'D', 'G'}, {'J', 'I'}]\n{'J', 'I'}\n0\n0 " }, { "code": null, "e": 3801, "s": 3495, "text": "A directed graph is strongly connected if for every pair of nodes u and v, there is a directed path from u to v and v to u. It is weakly connected if replacing all the edges of the directed graph with undirected edges will produce an Undirected Connected Graph. They can be checked by the following code: " }, { "code": null, "e": 3855, "s": 3801, "text": "nx.is_strongly_connected(G)\nnx.is_weakly_connected(G)" }, { "code": null, "e": 3925, "s": 3855, "text": "The given Directed Graph is weakly connected, not strongly connected." }, { "code": null, "e": 4036, "s": 3925, "text": "Networkx allows us to find paths between nodes easily in a Graph. Let us closely examine the following Graph: " }, { "code": null, "e": 4044, "s": 4036, "text": "Python3" }, { "code": "import networkx as nximport matplotlib.pyplot as plt G = nx.Graph()G.add_edges_from([('A', 'B'), ('A', 'K'), ('B', 'K'), ('A', 'C'), ('B', 'C'), ('C', 'F'), ('F', 'G'), ('C', 'E'), ('E', 'F'), ('E', 'D'), ('E', 'H'), ('H', 'I'), ('I', 'J')]) plt.figure(figsize =(9, 9))nx.draw_networkx(G, with_labels = True, node_color ='green') print(nx.shortest_path(G, 'A'))# returns dictionary of shortest paths from A to all other nodes print(int(nx.shortest_path_length(G, 'A')))# returns dictionary of shortest path length from A to all other nodes print(nx.shortest_path(G, 'A', 'G'))# returns a shortest path from node A to G print(nx.shortest_path_length(G, 'A', 'G'))# returns length of shortest path from node A to G print(list(nx.all_simple_paths(G, 'A', 'J')))# returns list of all paths from node A to J print(nx.average_shortest_path_length(G))# returns average of shortest paths between all possible pairs of nodes", "e": 4994, "s": 4044, "text": null }, { "code": null, "e": 5003, "s": 4994, "text": "Output: " }, { "code": null, "e": 5633, "s": 5003, "text": "{‘A’: [‘A’], ‘B’: [‘A’, ‘B’], ‘C’: [‘A’, ‘C’], ‘D’: [‘A’, ‘C’, ‘E’, ‘D’], ‘E’: [‘A’, ‘C’, ‘E’], ‘F’: [‘A’, ‘C’, ‘F’], ‘G’: [‘A’, ‘C’, ‘F’, ‘G’], ‘H’: [‘A’, ‘C’, ‘E’, ‘H’], ‘I’: [‘A’, ‘C’, ‘E’, ‘H’, ‘I’], ‘J’: [‘A’, ‘C’, ‘E’, ‘H’, ‘I’, ‘J’], ‘K’: [‘A’, ‘K’]} {‘A’: 0, ‘B’: 1, ‘C’: 1, ‘D’: 3, ‘E’: 2, ‘F’: 2, ‘G’: 3, ‘H’: 3, ‘I’: 4, ‘J’: 5, ‘K’: 1} [‘A’, ‘C’, ‘F’, ‘G’] 3 [[‘A’, ‘C’, ‘F’, ‘E’, ‘H’, ‘I’, ‘J’], [‘A’, ‘C’, ‘E’, ‘H’, ‘I’, ‘J’], [‘A’, ‘K’, ‘B’, ‘C’, ‘F’, ‘E’, ‘H’, ‘I’, ‘J’], [‘A’, ‘K’, ‘B’, ‘C’, ‘E’, ‘H’, ‘I’, ‘J’], [‘A’, ‘B’, ‘C’, ‘F’, ‘E’, ‘H’, ‘I’, ‘J’], [‘A’, ‘B’, ‘C’, ‘E’, ‘H’, ‘I’, ‘J’]] 2.6363636363636362 " }, { "code": null, "e": 5772, "s": 5633, "text": "Eccentricity: For a node n in graph G, the eccentricity of n is the largest possible shortest path distance between n and all other nodes." }, { "code": null, "e": 5924, "s": 5772, "text": "Diameter : The maximum shortest distance between a pair of nodes in a graph G is its Diameter. It is the largest possible eccentricity value of a node." }, { "code": null, "e": 5981, "s": 5924, "text": "Radius : It is the minimum eccentricity value of a node." }, { "code": null, "e": 6070, "s": 5981, "text": "Periphery : It is the set of nodes that have their eccentricity equal to their Diameter." }, { "code": null, "e": 6173, "s": 6070, "text": "Center : Center of a Graph is the set of nodes whose eccentricity is equal to the radius of the Graph." }, { "code": null, "e": 6245, "s": 6173, "text": "Networkx offers built-in function for computing all these properties. " }, { "code": null, "e": 6253, "s": 6245, "text": "Python3" }, { "code": "import networkx as nximport matplotlib.pyplot as plt G = nx.Graph()G.add_edges_from([('A', 'B'), ('A', 'K'), ('B', 'K'), ('A', 'C'), ('B', 'C'), ('C', 'F'), ('F', 'G'), ('C', 'E'), ('E', 'F'), ('E', 'D'), ('E', 'H'), ('H', 'I'), ('I', 'J')]) plt.figure(figsize =(9, 9))nx.draw_networkx(G, with_labels = True, node_color ='green') print(\"Eccentricity: \", nx.eccentricity(G))print(\"Diameter: \", nx.diameter(G))print(\"Radius: \", nx.radius(G))print(\"Preiphery: \", list(nx.periphery(G)))print(\"Center: \", list(nx.center(G)))", "e": 6807, "s": 6253, "text": null }, { "code": null, "e": 6817, "s": 6807, "text": "Output: " }, { "code": null, "e": 6980, "s": 6817, "text": "Eccentricity: {‘A’: 5, ‘K’: 6, ‘B’: 5, ‘H’: 4, ‘J’: 6, ‘E’: 3, ‘C’: 4, ‘I’: 5, ‘F’: 4, ‘D’: 4, ‘G’: 5} Diameter: 6 Radius: 3 Periphery: [‘K’, ‘J’] Center: [‘E’] " }, { "code": null, "e": 7034, "s": 6980, "text": "Reference: https://networkx.github.io/documentation. " }, { "code": null, "e": 7053, "s": 7034, "text": "surindertarika1234" }, { "code": null, "e": 7068, "s": 7053, "text": "python-modules" }, { "code": null, "e": 7075, "s": 7068, "text": "Python" } ]

[ { "code": null, "e": 53, "s": 25, "text": "\n07 Jun, 2022" }, { "code": null, "e": 252, "s": 53, "text": "Data Types define the type of data a variable can store. PHP allows eight different types of data types. All of them are discussed below. There are pre-defined, user-defined, and special data types." }, { "code": null, "e": 283, "s": 252, "text": "The predefined data types are:" }, { "code": null, "e": 291, "s": 283, "text": "Boolean" }, { "code": null, "e": 299, "s": 291, "text": "Integer" }, { "code": null, "e": 306, "s": 299, "text": "Double" }, { "code": null, "e": 313, "s": 306, "text": "String" }, { "code": null, "e": 357, "s": 313, "text": "The user-defined (compound) data types are:" }, { "code": null, "e": 363, "s": 357, "text": "Array" }, { "code": null, "e": 371, "s": 363, "text": "Objects" }, { "code": null, "e": 399, "s": 371, "text": "The special data types are:" }, { "code": null, "e": 404, "s": 399, "text": "NULL" }, { "code": null, "e": 413, "s": 404, "text": "resource" }, { "code": null, "e": 503, "s": 413, "text": "The first five are called simple data types and the last three are compound data types: " }, { "code": null, "e": 915, "s": 503, "text": "1. Integer: Integers hold only whole numbers including positive and negative numbers, i.e., numbers without fractional part or decimal point. They can be decimal (base 10), octal (base 8), or hexadecimal (base 16). The default base is decimal (base 10). The octal integers can be declared with leading 0 and the hexadecimal can be declared with leading 0x. The range of integers must lie between -2^31 to 2^31. " }, { "code": null, "e": 925, "s": 915, "text": "Example: " }, { "code": null, "e": 929, "s": 925, "text": "PHP" }, { "code": "<?php // decimal base integers$deci1 = 50;$deci2 = 654; // octal base integers$octal1 = 07; // hexadecimal base integers$octal = 0x45; $sum = $deci1 + $deci2;echo $sum;echo \"\\n\\n\"; //returns data type and valuevar_dump($sum) ?>", "e": 1159, "s": 929, "text": null }, { "code": null, "e": 1173, "s": 1159, "text": "704\n\nint(704)" }, { "code": null, "e": 1466, "s": 1173, "text": "2. Double: Can hold numbers containing fractional or decimal parts including positive and negative numbers or a number in exponential form. By default, the variables add a minimum number of decimal places. The Double data type is the same as a float as floating-point numbers or real numbers." }, { "code": null, "e": 1476, "s": 1466, "text": "Example: " }, { "code": null, "e": 1480, "s": 1476, "text": "PHP" }, { "code": "<?php $val1 = 50.85;$val2 = 654.26; $sum = $val1 + $val2; echo $sum;echo \"\\n\\n\"; //returns data type and valuevar_dump($sum) ?>", "e": 1610, "s": 1480, "text": null }, { "code": null, "e": 1632, "s": 1610, "text": "705.11\n\nfloat(705.11)" }, { "code": null, "e": 1922, "s": 1632, "text": "3. String: Hold letters or any alphabets, even numbers are included. These are written within double quotes during declaration. The strings can also be written within single quotes, but they will be treated differently while printing variables. To clarify this look at the example below. " }, { "code": null, "e": 1932, "s": 1922, "text": "Example: " }, { "code": null, "e": 1936, "s": 1932, "text": "PHP" }, { "code": "<?php $name = \"Krishna\";echo \"The name of the Geek is $name \\n\";echo 'The name of the geek is $name ';echo \"\\n\\n\"; //returns data type, size and valuevar_dump($name) ?>", "e": 2107, "s": 1936, "text": null }, { "code": null, "e": 2192, "s": 2107, "text": "The name of the Geek is Krishna \nThe name of the geek is $name \n\nstring(7) \"Krishna\"" }, { "code": null, "e": 2567, "s": 2192, "text": "4. Boolean: Boolean data types are used in conditional testing. Hold only two values, either TRUE(1) or FALSE(0). Successful events will return true and unsuccessful events return false. NULL type values are also treated as false in Boolean. Apart from NULL, 0 is also considered false in boolean. If a string is empty then it is also considered false in boolean data type. " }, { "code": null, "e": 2579, "s": 2567, "text": "Example: " }, { "code": null, "e": 2583, "s": 2579, "text": "PHP" }, { "code": "<?php if(TRUE) echo \"This condition is TRUE\";if(FALSE) echo \"This condition is not TRUE\"; ?>", "e": 2682, "s": 2583, "text": null }, { "code": null, "e": 2705, "s": 2682, "text": "This condition is TRUE" }, { "code": null, "e": 2902, "s": 2705, "text": "5. Array: Array is a compound data type that can store multiple values of the same data type. Below is an example of an array of integers. It combines a series of data that are related together. " }, { "code": null, "e": 2906, "s": 2902, "text": "PHP" }, { "code": "<?php $intArray = array( 10, 20 , 30); echo \"First Element: $intArray[0]\\n\";echo \"Second Element: $intArray[1]\\n\";echo \"Third Element: $intArray[2]\\n\\n\"; //returns data type and valuevar_dump($intArray); ?>", "e": 3113, "s": 2906, "text": null }, { "code": null, "e": 3236, "s": 3113, "text": "First Element: 10\nSecond Element: 20\nThird Element: 30\n\narray(3) {\n [0]=>\n int(10)\n [1]=>\n int(20)\n [2]=>\n int(30)\n}" }, { "code": null, "e": 3292, "s": 3236, "text": "We will discuss arrays in detail in further articles. " }, { "code": null, "e": 3680, "s": 3292, "text": "6. Objects: Objects are defined as instances of user-defined classes that can hold both values and functions and information for data processing specific to the class. This is an advanced topic and will be discussed in detail in further articles. When the objects are created, they inherit all the properties and behaviours from the class, having different values for all the properties." }, { "code": null, "e": 3756, "s": 3680, "text": " Objects are explicitly declared and created from the new keyword." }, { "code": null, "e": 3760, "s": 3756, "text": "PHP" }, { "code": "<?php class gfg { var $message; function gfg($message) { $this->message = $message; } function msg() { return \"This is an example of \" . $this->message . \"!\"; }} // instantiating a object$newObj = new gfg(\"Object Data Type\");echo $newObj -> msg(); ?>", "e": 4028, "s": 3760, "text": null }, { "code": null, "e": 4068, "s": 4028, "text": "This is an example of Object Data Type!" }, { "code": null, "e": 4370, "s": 4068, "text": "7. NULL: These are special types of variables that can hold only one value i.e., NULL. We follow the convention of writing it in capital form, but it’s case-sensitive. If a variable is created without a value or no value, it is automatically assigned a value of NULL. It is written in capital letters." }, { "code": null, "e": 4380, "s": 4370, "text": "Example: " }, { "code": null, "e": 4384, "s": 4380, "text": "PHP" }, { "code": "<?php $nm = NULL;echo $nm; // this will return no output // return data typevar_dump($nm); ?>", "e": 4481, "s": 4384, "text": null }, { "code": null, "e": 4486, "s": 4481, "text": "NULL" }, { "code": null, "e": 4843, "s": 4486, "text": "8. Resources: Resources in PHP are not an exact data type. These are basically used to store references to some function call or to external PHP resources. For example, consider a database call. This is an external resource. Resource variables hold special handles for files and database connections.We will discuss resources in detail in further articles." }, { "code": null, "e": 4850, "s": 4843, "text": "Note: " }, { "code": null, "e": 4967, "s": 4850, "text": "To check the type and value of an expression, use the var_dump() function which dumps information about a variable. " }, { "code": null, "e": 5015, "s": 4967, "text": "PHP allows the developer to cast the data type." }, { "code": null, "e": 5440, "s": 5015, "text": "This article is contributed by Chinmoy Lenka. If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to [email protected]. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or if you want to share more information about the topic discussed above. " }, { "code": null, "e": 5450, "s": 5440, "text": "VishalPal" }, { "code": null, "e": 5463, "s": 5450, "text": "geetanjali16" }, { "code": null, "e": 5477, "s": 5463, "text": "sanjyotpanure" }, { "code": null, "e": 5488, "s": 5477, "text": "PHP-basics" }, { "code": null, "e": 5492, "s": 5488, "text": "PHP" }, { "code": null, "e": 5509, "s": 5492, "text": "Web Technologies" }, { "code": null, "e": 5513, "s": 5509, "text": "PHP" }, { "code": null, "e": 5611, "s": 5513, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 5656, "s": 5611, "text": "How to execute PHP code using command line ?" }, { "code": null, "e": 5680, "s": 5656, "text": "PHP in_array() Function" }, { "code": null, "e": 5732, "s": 5680, "text": "How to delete an array element based on key in PHP?" }, { "code": null, "e": 5782, "s": 5732, "text": "How to Insert Form Data into Database using PHP ?" }, { "code": null, "e": 5843, "s": 5782, "text": "How to Upload Image into Database and Display it using PHP ?" }, { "code": null, "e": 5876, "s": 5843, "text": "Installation of Node.js on Linux" }, { "code": null, "e": 5938, "s": 5876, "text": "Top 10 Projects For Beginners To Practice HTML and CSS Skills" }, { "code": null, "e": 5999, "s": 5938, "text": "Difference between var, let and const keywords in JavaScript" }, { "code": null, "e": 6042, "s": 5999, "text": "How to fetch data from an API in ReactJS ?" } ]

[ { "code": null, "e": 54, "s": 26, "text": "\n02 Sep, 2020" }, { "code": null, "e": 191, "s": 54, "text": "First round: It was on Hackerrank. We were given 2 coding questions which were random for all. The questions that I got are as follows: " }, { "code": null, "e": 486, "s": 191, "text": "Purchasing Supplies: This question was similar to the chocolate wrapper problem. You can refer it here. Triplets: Given an array of n distinct integers, d=[d[0],d[1], ...,d[n-1]], and an integer threshold t, how many (a,b,c) index triplets exist that satisfy both of the following conditions? " }, { "code": null, "e": 591, "s": 486, "text": "Purchasing Supplies: This question was similar to the chocolate wrapper problem. You can refer it here. " }, { "code": null, "e": 782, "s": 591, "text": "Triplets: Given an array of n distinct integers, d=[d[0],d[1], ...,d[n-1]], and an integer threshold t, how many (a,b,c) index triplets exist that satisfy both of the following conditions? " }, { "code": null, "e": 811, "s": 782, "text": "d[a]<d[b]<d \nd[a]+d[b]+d<=t " }, { "code": null, "e": 916, "s": 811, "text": "I could solve only 1 question. After this round, 24 students across CSE, ECE, IT have been shortlisted. " }, { "code": null, "e": 1105, "s": 916, "text": "Second round: It was on Hackerrank Codepair. This is the first interview conducted by FactSet. It lasted for 1hr 50min for me. The interviewer gave 3 coding questions to solve one by one. " }, { "code": null, "e": 1252, "s": 1105, "text": "Function to check if a singly linked list is palindromeCount of subarrays having exactly K perfect square numbersConnect n ropes with minimum cost" }, { "code": null, "e": 1308, "s": 1252, "text": "Function to check if a singly linked list is palindrome" }, { "code": null, "e": 1367, "s": 1308, "text": "Count of subarrays having exactly K perfect square numbers" }, { "code": null, "e": 1401, "s": 1367, "text": "Connect n ropes with minimum cost" }, { "code": null, "e": 1564, "s": 1401, "text": "I initially explained each approach and solved all three questions given. Later, he asked me some concepts regarding databases. Then, he asked about my projects. " }, { "code": null, "e": 1636, "s": 1564, "text": "After this round, 10 students have been shortlisted to the next round. " }, { "code": null, "e": 1817, "s": 1636, "text": "Third round: It was on Hackerrank Codepair. This was the difficult round. They increased the complexity. It lasted for 1hr 45min. I was asked 2 coding questions in this interview. " }, { "code": null, "e": 2929, "s": 1817, "text": "Burn the binary tree starting from the target node. Initially, I explained the approach to the interviewer and later, started coding that. But somehow couldn’t complete. As time passed, he gave another question. There are N dominoes in a line, and we place each domino vertically upright. In the beginning, we simultaneously push some of the dominoes either to the left or to the right. After each second, each domino that is falling to the left pushes the adjacent domino on the left. Similarly, the dominoes falling to the right push their adjacent dominoes standing on the right. When a vertical domino has dominoes falling on it from both sides, it stays still due to the balance of the forces. For the purposes of this question, we will consider that a falling domino expends no additional force to a falling or already fallen domino. Given a string “S” representing the initial state. S[i] = ‘L’, if the i-th domino has been pushed to the left; S[i] = ‘R’, if the i-th domino has been pushed to the right; S[i] = ‘.’, if the i-th domino has not been pushed. Return a string representing the final state. " }, { "code": null, "e": 3143, "s": 2929, "text": "Burn the binary tree starting from the target node. Initially, I explained the approach to the interviewer and later, started coding that. But somehow couldn’t complete. As time passed, he gave another question. " }, { "code": null, "e": 4042, "s": 3143, "text": "There are N dominoes in a line, and we place each domino vertically upright. In the beginning, we simultaneously push some of the dominoes either to the left or to the right. After each second, each domino that is falling to the left pushes the adjacent domino on the left. Similarly, the dominoes falling to the right push their adjacent dominoes standing on the right. When a vertical domino has dominoes falling on it from both sides, it stays still due to the balance of the forces. For the purposes of this question, we will consider that a falling domino expends no additional force to a falling or already fallen domino. Given a string “S” representing the initial state. S[i] = ‘L’, if the i-th domino has been pushed to the left; S[i] = ‘R’, if the i-th domino has been pushed to the right; S[i] = ‘.’, if the i-th domino has not been pushed. Return a string representing the final state. " }, { "code": null, "e": 4313, "s": 4042, "text": "Given a string “S” representing the initial state. S[i] = ‘L’, if the i-th domino has been pushed to the left; S[i] = ‘R’, if the i-th domino has been pushed to the right; S[i] = ‘.’, if the i-th domino has not been pushed. Return a string representing the final state. " }, { "code": null, "e": 4359, "s": 4313, "text": "https://leetcode.com/problems/push-dominoes/ " }, { "code": null, "e": 4534, "s": 4359, "text": "I wrote the code for this, but it couldn’t work for some corner cases which my interviewer pointed out. After this round, 4 students have been shortlisted for the HR Round. " }, { "code": null, "e": 4750, "s": 4534, "text": "HR round: It was on Microsoft Teams. It lasted for around 20-25 min. It was a casual talk between us. She inquired about my details and asked whether I had any questions. I asked a few questions to the interviewer. " }, { "code": null, "e": 4810, "s": 4750, "text": "After this round, the results were shared with the campus. " }, { "code": null, "e": 4884, "s": 4810, "text": "All 4 including me were selected for the Software Engineer role finally. " }, { "code": null, "e": 4892, "s": 4884, "text": "FactSet" }, { "code": null, "e": 4902, "s": 4892, "text": "Marketing" }, { "code": null, "e": 4924, "s": 4902, "text": "Interview Experiences" }, { "code": null, "e": 4932, "s": 4924, "text": "FactSet" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n30 Jun, 2021" }, { "code": null, "e": 284, "s": 28, "text": "One of the most important tasks for someone working on datasets with countries, cities, etc. is to understand the relationships between their data’s physical location and their geographical context. And one such way to visualize the data is using Folium." }, { "code": null, "e": 585, "s": 284, "text": "Folium is a powerful data visualization library in Python that was built primarily to help people visualize geospatial data. With Folium, one can create a map of any location in the world. Folium is actually a python wrapper for leaflet.js which is a javascript library for plotting interactive maps." }, { "code": null, "e": 719, "s": 585, "text": "We shall now see a simple way to plot and visualize geospatial data. We will use a dataset consisting of unemployment rates in the US" }, { "code": null, "e": 816, "s": 719, "text": "If folium is not installed, one can simply install it using any one of the following commands: " }, { "code": null, "e": 880, "s": 816, "text": "$ pip install folium\n\nOR\n\n$ conda install -c conda-forge folium" }, { "code": null, "e": 1024, "s": 880, "text": "Using folium.Map(), we will create a base map and store it in an object. This function takes location coordinates and zoom values as arguments." }, { "code": null, "e": 1089, "s": 1024, "text": "Syntax: folium.Map(location,tiles= “OpenStreetMap” zoom_start=4)" }, { "code": null, "e": 1101, "s": 1089, "text": "Parameters:" }, { "code": null, "e": 1140, "s": 1101, "text": "location: list of location coordinates" }, { "code": null, "e": 1236, "s": 1140, "text": "tiles: default is OpenStreetMap. Other options: tamen Terrain, Stamen Toner, Mapbox Bright etc." }, { "code": null, "e": 1252, "s": 1236, "text": "zoom_start: int" }, { "code": null, "e": 1258, "s": 1252, "text": "Code:" }, { "code": null, "e": 1266, "s": 1258, "text": "Python3" }, { "code": "# import the folium, pandas librariesimport foliumimport pandas as pd # initialize the map and store it in a m objectm = folium.Map(location = [40, -95], zoom_start = 4) # show the mapm.save('my_map.html')", "e": 1488, "s": 1266, "text": null }, { "code": null, "e": 1496, "s": 1488, "text": "Output:" }, { "code": null, "e": 1557, "s": 1496, "text": "Now, we shall import the data sets using the Pandas library." }, { "code": null, "e": 1565, "s": 1557, "text": "Python3" }, { "code": "# getting the dataurl = ( \"https://raw.githubusercontent.com/python-visualization/folium/master/examples/data\")state_geo = f\"{url}/us-states.json\"state_unemployment = f\"{url}/US_Unemployment_Oct2012.csv\"state_data = pd.read_csv(state_unemployment)", "e": 1816, "s": 1565, "text": null }, { "code": null, "e": 2111, "s": 1816, "text": "Once we have all the data we have, we will visualize this data using choropleth maps. Chloropleth maps represent divided areas in various colors based on the statistical variable presented to them. Here, we use the unemployment rate in the US as a means to divide regions into different colors." }, { "code": null, "e": 2470, "s": 2111, "text": "Using folium.Choropleth(), we can plot the final map. The details of each attribute are given in the code itself. The ‘key on’ parameter refers to the label in the JSON object (state_geo) which has the state detail as the feature ID attached to each country’s border information. Our states in the data frame should match the feature ID in the json object." }, { "code": null, "e": 2583, "s": 2470, "text": "Syntax: folium.Choropleth(geo_data,name,data,columns,fill_color, fill_opacity, line_opacity, key_on,legend_name)" }, { "code": null, "e": 2595, "s": 2583, "text": "Parameters:" }, { "code": null, "e": 2664, "s": 2595, "text": "geo_data: a set of geographic regions and their boundary coordinates" }, { "code": null, "e": 2695, "s": 2664, "text": "name: String (name of our map)" }, { "code": null, "e": 2753, "s": 2695, "text": "data: a numeric value for each region, used for the color" }, { "code": null, "e": 2796, "s": 2753, "text": "columns: list (columns we need to work on)" }, { "code": null, "e": 2835, "s": 2796, "text": "fill_color: Color of the map, eg: YlGn" }, { "code": null, "e": 2878, "s": 2835, "text": "fill_opacity: opacity of the colors filled" }, { "code": null, "e": 2920, "s": 2878, "text": "line_opacity: opacity of the border lines" }, { "code": null, "e": 2940, "s": 2920, "text": "legend_name: String" }, { "code": null, "e": 2986, "s": 2940, "text": "Finally, we can save our map as an HTML file." }, { "code": null, "e": 2994, "s": 2986, "text": "Python3" }, { "code": "folium.Choropleth( # geographical locations geo_data = state_geo, name = \"choropleth\", # the data set we are using data = state_data, columns = [\"State\", \"Unemployment\"], # YlGn refers to yellow and green fill_color = \"YlGn\", fill_opacity = 0.7, line_opacity = .1, key_on = \"feature.id\", legend_name = \"Unemployment Rate (%)\",).add_to(m) m.save('final_map.html')", "e": 3519, "s": 2994, "text": null }, { "code": null, "e": 3527, "s": 3519, "text": "Output:" }, { "code": null, "e": 3534, "s": 3527, "text": "Picked" }, { "code": null, "e": 3549, "s": 3534, "text": "python-modules" }, { "code": null, "e": 3556, "s": 3549, "text": "Python" } ]

[ { "code": null, "e": 19, "s": 0, "text": "\n❮ String Methods\n" }, { "code": null, "e": 75, "s": 19, "text": "Find out if a string contains a sequence of characters:" }, { "code": null, "e": 278, "s": 75, "text": "String myStr = \"Hello\";\nSystem.out.println(myStr.contentEquals(\"Hello\")); // true\nSystem.out.println(myStr.contentEquals(\"e\")); // false\nSystem.out.println(myStr.contentEquals(\"Hi\")); // false" }, { "code": null, "e": 298, "s": 278, "text": "\nTry it Yourself »\n" }, { "code": null, "e": 449, "s": 298, "text": "The contentEquals() method searches a string to find out if it contains the exact same sequence of characters in the specified string or StringBuffer." }, { "code": null, "e": 504, "s": 449, "text": "Returns true if the characters exist and false if not." }, { "code": null, "e": 541, "s": 504, "text": "There are 2 contentEquals() methods:" }, { "code": null, "e": 640, "s": 541, "text": "public boolean contentEquals(StringBuffer chars)\npublic boolean contentEquals(CharSequence chars)\n" }, { "code": null, "e": 738, "s": 640, "text": "The StringBuffer class is like a String, only it can be modified, found in the java.lang package." }, { "code": null, "e": 836, "s": 738, "text": "The CharSequence interface is a readable sequence of char values, found in the java.lang package." }, { "code": null, "e": 873, "s": 836, "text": "true - sequence of characters exists" }, { "code": null, "e": 917, "s": 873, "text": "false - sequence of characters do not exist" }, { "code": null, "e": 950, "s": 917, "text": "We just launchedW3Schools videos" }, { "code": null, "e": 992, "s": 950, "text": "Get certifiedby completinga course today!" }, { "code": null, "e": 1099, "s": 992, "text": "If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:" }, { "code": null, "e": 1118, "s": 1099, "text": "[email protected]" } ]

[ { "code": null, "e": 890, "s": 172, "text": "Forecasting future demand is a fundamental business problem and any solution that is successful in tackling this will find valuable commercial applications in diverse business segments. In the retail context, Demand Forecasting methods are implemented to make decisions regarding buying, provisioning, replenishment, and financial planning. Some of the common time-series methods applied for Demand Forecasting and provisioning include Moving Average, Exponential Smoothing, and ARIMA. The most popular models in Kaggle competitions for time-series forecasting have been Gradient Boosting models that convert time-series data into tabular data, with lag terms in the time-series as ‘features’ or columns in the table." }, { "code": null, "e": 1378, "s": 890, "text": "The Facebook Prophet model is a type of GAM (Generalized Additive Model) that specializes in solving business/econometric — time-series problems. My objective in this project was to apply and investigate the performance of the Facebook Prophet model for Demand Forecasting problems and to this end, I used the Kaggle M5- Demand Forecasting Competition Dataset and participated in the competition. The competition aimed to generate point forecasts 28 days ahead at a product- store level." }, { "code": null, "e": 1733, "s": 1378, "text": "The dataset involves unit sales of 3049 products and is classified into 3 product categories (Hobbies, Foods, and Household) and 7 departments. The products are sold in 10 stores located across 3 states (CA, TX, and WI). The diagram gives an overview of the levels of aggregations of the products. The competition data has been made available by Walmart." }, { "code": null, "e": 1782, "s": 1733, "text": "Source:- https://mofc.unic.ac.cy/m5-competition/" }, { "code": null, "e": 1973, "s": 1782, "text": "The data range for Sales Data is from 2011–01–29 to 2016–06–19. Thus products have a maximum of 1941 days or 5.4 years worth of available data. (The Test dataset of 28 days is not included)." }, { "code": null, "e": 2050, "s": 1973, "text": "The datasets are divided into Calendar Data, Price Data, and Sales Data [3]." }, { "code": null, "e": 2399, "s": 2050, "text": "Calendar Data — contains columns, like date, weekday, month, year, and Snap-Days for the states TX, CA, and WI. Additionally, the table contains information on holidays and special events (like Superbowl) through its columns event_type1 and event_type2. The holidays/ special events are divided into cultural, national, religious, and sporting [3]." }, { "code": null, "e": 2574, "s": 2399, "text": "Price Data- The table consists of the columns — store, item, week, and price. It provides information on the price of an item at a particular store, in a particular week [3]." }, { "code": null, "e": 2868, "s": 2574, "text": "Sales Data — consists of validation and evaluation files. The evaluation file consists of sales for 28 extra days which can be used for model evaluation. The table provides information on the quantity sold for a particular item in a particular department, in a particular state, and store [3]." }, { "code": null, "e": 2958, "s": 2868, "text": "The data can be found in the link — https://www.kaggle.com/c/m5-forecasting-accuracy/data" }, { "code": null, "e": 3320, "s": 2958, "text": "As can be seen from the charts above, for every category, the highest number of sales occur in CA, followed by TX and WI. CA contributes to around 50% of Hobby sales. The sales distribution across categories in the three states is symmetric and the highest-selling categories ordered by descending order of sales in each state are Foods, Household, and Hobbies." }, { "code": null, "e": 3482, "s": 3320, "text": "The charts above show that percentage_price_change is highly right-skewed. Log transformation is performed on sell_price to make its distribution more symmetric." }, { "code": null, "e": 3565, "s": 3482, "text": "The chart above shows that higher sales are observed on Snap-Days in all 3 states." }, { "code": null, "e": 3954, "s": 3565, "text": "A seasonal decomposition is performed of the time-series using the statsmodels.tsa.seasonal_decompose function. The charts above show a linear growth in sales over time (across categories and states) along with seasonal effects. Linearity is particularly evident in the latter half of the time-series starting from the year 2014. A yearly seasonality is seen in all states and categories." }, { "code": null, "e": 4084, "s": 3954, "text": "The chart above shows a weekly seasonality across all 3 categories. Sales on the weekends and Monday are higher than on weekdays." }, { "code": null, "e": 4285, "s": 4084, "text": "The above chart shows the monthly seasonality across categories. The pattern seen is that sales are high at the beginning of the month, then decline steadily and pick up again closer to the month-end." }, { "code": null, "e": 4666, "s": 4285, "text": "The charts above show yearly seasonality across categories from 2011–2016. The sales behavior is symmetric within each category — i.e, Household sales 2011, is similar to Household sales 2012, and so on. This, historical data will prove useful in forecasting yearly sales in a category — for example, data on 2011 Household sales will be useful in predicting 2012 Household sales." }, { "code": null, "e": 5114, "s": 4666, "text": "The Prophet model is trained and predictions are made at a product-store level. Thus, 30490 different prophet models are trained for the 30490 different time-series at the product-store level. Two years of training data and 28 days of prediction/evaluation data is used for model training & evaluation on each series. The final 28 days of test data is hidden by Kaggle. This split of training, evaluation and test data is shown in the table below-" }, { "code": null, "e": 5160, "s": 5114, "text": "Two Models are tried across all time-series —" }, { "code": null, "e": 5168, "s": 5160, "text": "Model 1" }, { "code": null, "e": 5544, "s": 5168, "text": "def run_prophet(id1,data): holidays = get_holidays(id1) model = Prophet(uncertainty_samples=False, holidays=holidays, weekly_seasonality = True, yearly_seasonality= True, changepoint_prior_scale = 0.5 ) model.add_seasonality(name='monthly', period=30.5, fourier_order=2)" }, { "code": null, "e": 5552, "s": 5544, "text": "Model 2" }, { "code": null, "e": 5967, "s": 5552, "text": "def run_prophet(id1,data): holidays = get_holidays(id1) model = Prophet(uncertainty_samples=False, holidays=holidays, weekly_seasonality = True, yearly_seasonality= True, changepoint_prior_scale = 0.5 ) model.add_seasonality(name='monthly', period=30.5, fourier_order=2) model.add_regressor('log_sell_price')" }, { "code": null, "e": 6079, "s": 5967, "text": "Model 1 consists of the components — holidays, weekly_seasonality, yearly_seasonality, and monthly seasonality." }, { "code": null, "e": 6406, "s": 6079, "text": "Model 2 consists of the components — holidays, weekly_seasonality, yearly_seasonality, monthly seasonality, and additionally, the regressor log_sell_price = log(sales_price). The latest sales_price in each product-store series is assumed invariant over the 28 days forecasting horizon and is used for forecasting future sales." }, { "code": null, "e": 6620, "s": 6406, "text": "The Facebook Prophet model is similar to a GAM (Generalized Additive Model ) and uses a decomposable timeseries model with three components — trend, seasonality and holidays — y(t) = g(t) + s(t) + h(t) + e(t) [4]." }, { "code": null, "e": 6742, "s": 6620, "text": "Growth g(t): By default Prophet allows you to use a linear growth model for forecasts. This model is being used here [4]." }, { "code": null, "e": 7250, "s": 6742, "text": "Holidays h(t): — Prophet considers holiday effects. Holidays modeled here are religious holidays, cultural holidays, national holidays, and Snap-Days. Prophet allows the user to add a “upper_window” and “lower_window” which extends the effect of the holiday around the holiday date. In the current model, an upper and lower window of 0 days is applied on Snap-Days and an upper and lower window of 1 day is applied on other holidays. Prophet assumes each of the holidays- D_i to be mutually independent [4]." }, { "code": null, "e": 7514, "s": 7250, "text": "Seasonality s(t): — A Fourier Series is used to model seasonal effects. In the formula given below, P is the regular period (weekly — 7 days, yearly — 365.25 days). Fitting the seasonal parameters, requires fitting 2 N parameters — beta = (a1, b1,... an, bn) [4]." }, { "code": null, "e": 7594, "s": 7514, "text": "For example for yearly data and N = 10, the seasonal component S(t) = X(t)*beta" }, { "code": null, "e": 7784, "s": 7594, "text": "A smoothing prior — beta ~ Normal(0, sigma2) is imposed on beta. Increasing the number of terms N of the Fourier series increases model complexity and increases the risk of overfitting [4]." }, { "code": null, "e": 8047, "s": 7784, "text": "Modeling Changepoints: — The parameter for several changepoints can be adjusted using the hyperparameter — “changepoint_prior_scale”. This imposes a sparse prior to the changepoint parameters in Prophet. Increasing this parameter increases model flexibility [4]." }, { "code": null, "e": 8301, "s": 8047, "text": "from joblib import Parallel, delayedsubmission = Parallel(n_jobs=4, backend=\"multiprocessing\")(delayed(run_prophet)(comb_lst[i][0],comb_lst[i][1]) for i in range(30490))model.make_future_dataframe(periods=28, include_history=False)" }, { "code": null, "e": 8990, "s": 8301, "text": "Model training and prediction in FB Prophet takes longer than an ARIMA model or an Exponential smoothing model. Since we are fitting the model 30490 times at a product-store level, it is necessary to reduce the runtime on an individual series and parallelize the training & prediction of the 30490 series. The former is accomplished by 1) setting “uncertainty_samples = False” in the Prophet() function used in Model 1 & Model 2. This prevents the creation of an uncertainty interval for prediction and 2) setting “include_history=False” in the make_future_dataframe() function for model prediction (shown above), which prevents Prophet from displaying model fit for the training dataset." }, { "code": null, "e": 9142, "s": 8990, "text": "The joblib.Parallel() function is used to implement multiprocessing on fitting and prediction for the 30490 series, as shown in the code snippet above." }, { "code": null, "e": 9312, "s": 9142, "text": "Accuracy of the point forecasts is evaluated using three metrics — RMSE, RMSSE, WRMSSE. The metric WRMSSE is the metric for evaluation used by Kaggle in the competition." }, { "code": null, "e": 9640, "s": 9312, "text": "wi is the weight on each of the 42,840 (includes various levels of aggregation as shown in Fig 1) time series in the dataset. The weights are calculated based on the cumulative dollar sales of the series at a period. Additional details on the weights are given in the competition guide — https://mofc.unic.ac.cy/m5-competition/" }, { "code": null, "e": 9987, "s": 9640, "text": "The performance of Model 1 and Model 2 is given below. The Average RMSE and Average RMSSE is calculated by computing the mean RMSE or RMSSE across all 30490 product-store time-series. As can be seen, the inclusion of log_price in Model 2 improves performance across all metrics. The performance on the hidden Test dataset is calculated by Kaggle." }, { "code": null, "e": 10333, "s": 9987, "text": "The graphs above show the RMSE distribution of the 30490 product-store time-series. As can be seen, the distribution is heavily right-skewed. The performance of both models is similar across all RMSE levels. For more details on the code and implementation kindly refer the GitHub repository -https://github.com/Ritvik29/Walmart-Demand-Prediction" }, { "code": null, "e": 10635, "s": 10333, "text": "In conclusion, Components in FB- Prophet like seasonality, changepoints, growth, and holidays make it especially suitable for tackling business time-series problems like Demand Forecasting. I would recommend analysts to at-least consider Prophet as a first stop for building Demand Forecasting models." }, { "code": null, "e": 10733, "s": 10635, "text": "[1] Kaggle M5 Forecasting — Accuracy competition https://www.kaggle.com/c/m5-forecasting-accuracy" }, { "code": null, "e": 10824, "s": 10733, "text": "[2] Kaggle M5 Forecasting — Accuracy Documentation https://mofc.unic.ac.cy/m5-competition/" }, { "code": null, "e": 10932, "s": 10824, "text": "[3] Kaggle M5 — Accuracy Forecasting Competition Data https://www.kaggle.com/c/m5-forecasting-accuracy/data" }, { "code": null, "e": 11016, "s": 10932, "text": "[4] Taylor, Letham (2017), “Forecasting at Scale” https://peerj.com/preprints/3190/" } ]

[ { "code": null, "e": 448, "s": 238, "text": "Given a Binary Tree, you need to find the maximum value which you can get by subtracting the value of node B from the value of node A, where A and B are two nodes of the binary tree and A is an ancestor of B. " }, { "code": null, "e": 459, "s": 448, "text": "Example 1:" }, { "code": null, "e": 577, "s": 459, "text": "Input:\n 5\n / \\\n2 1\nOutput: 4\nExplanation:The maximum difference we can\nget is 4, which is bewteen 5 and 1." }, { "code": null, "e": 588, "s": 577, "text": "Example 2:" }, { "code": null, "e": 743, "s": 588, "text": "Input:\n 1\n / \\\n 2 3\n \\\n 7\nOutput: -1\nExplanation:The maximum difference we can\nget is -1, which is between 1 and 2." }, { "code": null, "e": 871, "s": 743, "text": "Your Task:\nThe task is to complete the function maxDiff() which finds the maximum difference between the node and its ancestor." }, { "code": null, "e": 970, "s": 871, "text": "Expected Time Complexity: O(N).\nExpected Auxiliary Space: O(H).\nNote: H is the height of the tree." }, { "code": null, "e": 1038, "s": 970, "text": "Constraints:\n2 <= Number of edges <= 104\n0 <= Data of a node <= 105" }, { "code": null, "e": 1358, "s": 1038, "text": "Note: The Input/Output format and Examples given are used for the system's internal purpose, and should be used by a user for Expected Output only. As it is a function problem, hence a user should not read any input from the stdin/console. The task is to complete the function specified, and not to write the full code." }, { "code": null, "e": 1360, "s": 1358, "text": "0" }, { "code": null, "e": 1384, "s": 1360, "text": "abrajput15064 weeks ago" }, { "code": null, "e": 1919, "s": 1384, "text": "int min3(int a,int b,int c){\n return a<b?(a<c?a:c):(b<c?b:c);\n}\nint helper(Node* root,int &mx,int mn){\n if(!root)\n return INT_MAX;\n if(!root->left && !root->right)\n return root->data;\n \n int left = helper(root->left,mx,mn);\n int right = helper(root->right,mx,mn);\n mn = min3(root->data,left,right);\n mx = max(root->data - min(left,right),mx);\n return mn;\n}\nint maxDiff(Node* root)\n{\n // Your code here\n int mn = INT_MAX;\n int mx = INT_MIN;\n helper(root,mx,mn);\n return mx;\n}" }, { "code": null, "e": 1921, "s": 1919, "text": "0" }, { "code": null, "e": 1943, "s": 1921, "text": "ibrahimidn1 month ago" }, { "code": null, "e": 2522, "s": 1943, "text": "class Tree\n{\n int maxSoFar=Integer.MIN_VALUE;\n int maxDiff(Node root)\n {\n if(root==null) return 0;\n findMaxDiff(root.left,root.data);\n findMaxDiff(root.right,root.data);\n return maxSoFar;\n }\n \n void findMaxDiff(Node node,int maxPathValue){\n if(node==null) return;\n int diff=maxPathValue-node.data;\n if(node.data>maxPathValue)\n maxPathValue=node.data;\n maxSoFar=Math.max(maxSoFar,diff);\n findMaxDiff(node.left,maxPathValue);\n findMaxDiff(node.right,maxPathValue);\n \n }\n}" }, { "code": null, "e": 2525, "s": 2522, "text": "+1" }, { "code": null, "e": 2549, "s": 2525, "text": "ashvinkict201 month ago" }, { "code": null, "e": 2878, "s": 2549, "text": "int func(Node* root, int &ans){ if(!root)return INT_MAX; int left = func(root->left,ans); int right = func(root->right,ans); ans = max(ans,max(root->data-left,root->data-right)); return min(left,min(root->data,right));}int maxDiff(Node* root){ // Your code here int ans = INT_MIN; func(root,ans); return ans;}" }, { "code": null, "e": 2880, "s": 2878, "text": "0" }, { "code": null, "e": 2906, "s": 2880, "text": "nestoffice37311 month ago" }, { "code": null, "e": 2919, "s": 2906, "text": "4 line java " }, { "code": null, "e": 3145, "s": 2919, "text": "int ans; void solve(Node root,int max){ if(root == null) return; solve(root.left,Math.max(max,root.data)); solve(root.right,Math.max(max,root.data)); ans = Math.max(ans,max-root.data); } " }, { "code": null, "e": 3147, "s": 3145, "text": "0" }, { "code": null, "e": 3167, "s": 3147, "text": "jai20222 months ago" }, { "code": null, "e": 3511, "s": 3167, "text": "EASY C++ SOLUTION step by stepint diff(Node* root,int &di){ if(root==NULL) return INT_MAX; if(root->left==NULL && root->right==NULL) return root->data; int l=diff(root->left,di); int r=diff(root->right,di); if(l<r){ di=max(di,root->data-l); } else{ di=max(di,root->data-r); } return min(min(l,r),root->data); }" }, { "code": null, "e": 3633, "s": 3511, "text": "int maxDiff(Node* root){ // Your code here if(root==NULL) return 0; int di=INT_MIN; diff(root,di); return di;}" }, { "code": null, "e": 3636, "s": 3633, "text": "+2" }, { "code": null, "e": 3664, "s": 3636, "text": "singhanshul28072 months ago" }, { "code": null, "e": 4631, "s": 3664, "text": "class Tree\n{\n //Function to return the maximum difference between any \n //node and its ancestor.\n static class Type{\n int max,min,ans;\n public Type(int max,int min,int ans){\n this.max=max;\n this.min=min;\n this.ans=ans;\n }\n }\n public Type solve(Node root){\n if(root==null)return new Type(Integer.MIN_VALUE,Integer.MAX_VALUE,Integer.MIN_VALUE);\n Type left=solve(root.left);\n Type right=solve(root.right);\n \n int child_max=Math.max(left.max,right.max);\n int child_min=Math.min(left.min,right.min);\n int child_ans=Math.max(left.ans,right.ans);\n int curr_max=Math.max(root.data,child_max);\n int curr_min=Math.min(root.data,child_min);\n int ans1=Math.max(root.data-child_max,root.data-child_min);\n int ans=Math.max(ans1,child_ans);\n return new Type(curr_max,curr_min,ans);\n }\n int maxDiff(Node root){\n return solve(root).ans;\n }\n}" }, { "code": null, "e": 4634, "s": 4631, "text": "+1" }, { "code": null, "e": 4670, "s": 4634, "text": "gurjotsingh21003Premium2 months ago" }, { "code": null, "e": 4683, "s": 4670, "text": "C++ Solution" }, { "code": null, "e": 5194, "s": 4683, "text": "int minm(Node* root,int& ans)\n{\n if(root==NULL)return INT_MAX;\n \n int lmin=minm(root->left,ans);\n int rmin=minm(root->right,ans);\n \n int val=root->data;\n int temp;\n if(lmin==INT_MAX && rmin==INT_MAX)\n {\n \n }\n else \n {\n temp=max(val-lmin,val-rmin);\n ans=max(ans,temp);\n }\n return min(val,min(lmin,rmin));\n}\nint maxDiff(Node* root)\n{\n // Your code here \n if(root==NULL) return 0;\n \n int ans=INT_MIN;\n minm(root,ans);\n return ans;\n}" }, { "code": null, "e": 5196, "s": 5194, "text": "0" }, { "code": null, "e": 5224, "s": 5196, "text": "hamidnourashraf3 months ago" }, { "code": null, "e": 5680, "s": 5224, "text": "_MAX = -math.inf\ndef traverse(root, largest_parent):\n global _MAX\n if root is None:\n return \n if largest_parent is not None:\n _MAX = max(largest_parent-root.data, _MAX)\n if largest_parent is None:\n largest_parent = root.data\n traverse(root.left, max(largest_parent, root.data))\n traverse(root.right, max(largest_parent, root.data))\ndef maxDiff(root):\n global _MAX\n _MAX = -math.inf\n traverse(root, None)\n return(_MAX)" }, { "code": null, "e": 5683, "s": 5680, "text": "+4" }, { "code": null, "e": 5704, "s": 5683, "text": "17vineet3 months ago" }, { "code": null, "e": 6159, "s": 5704, "text": "int maxDUtil(Node* root, int& max_diff)\n{\n if(!root)\n return INT_MAX ;\n if(!root->left && !root->right)\n return root->data ;\n int left = maxDUtil(root->left,max_diff) ;\n int right = maxDUtil(root->right,max_diff) ;\n max_diff = max(max_diff,root->data-min(left,right)) ;\n return min(min(left,right),root->data) ;\n}\nint maxDiff(Node* root)\n{\n int max_diff = INT_MIN ;\n maxDUtil(root,max_diff) ;\n return max_diff ;\n}" }, { "code": null, "e": 6161, "s": 6159, "text": "0" }, { "code": null, "e": 6192, "s": 6161, "text": "laxmijha20202020203 months ago" }, { "code": null, "e": 6228, "s": 6192, "text": "0(1) space , using morris traversal" }, { "code": null, "e": 7283, "s": 6228, "text": "Node*getrightmostnode(Node*leftnode,Node*curr){ while(leftnode->right!=NULL&&leftnode->right!=curr) leftnode=leftnode->right; return leftnode;}int maxDiff(Node* root){ int ans=INT_MIN; int maximum=root->data; Node*curr=root; while(curr!=NULL) { Node*leftnode=curr->left; if(leftnode==NULL) { if(curr!=root) { ans=max(ans,maximum-curr->data); maximum=max(maximum,curr->data); curr->data=maximum; } curr=curr->right; } else{ Node*rightmostnode=getrightmostnode(leftnode,curr); if(rightmostnode->right==NULL) { rightmostnode->right=curr; if(curr!=root) { ans=max(ans,maximum-curr->data); maximum=max(maximum,curr->data); } curr->data=maximum; curr=curr->left; } else{ rightmostnode->right=NULL; maximum=curr->data; curr=curr->right; } } } return ans;}" }, { "code": null, "e": 7429, "s": 7283, "text": "We strongly recommend solving this problem on your own before viewing its editorial. Do you still\n want to view the editorial?" }, { "code": null, "e": 7465, "s": 7429, "text": " Login to access your submissions. " }, { "code": null, "e": 7475, "s": 7465, "text": "\nProblem\n" }, { "code": null, "e": 7485, "s": 7475, "text": "\nContest\n" }, { "code": null, "e": 7548, "s": 7485, "text": "Reset the IDE using the second button on the top right corner." }, { "code": null, "e": 7696, "s": 7548, "text": "Avoid using static/global variables in your code as your code is tested against multiple test cases and these tend to retain their previous values." }, { "code": null, "e": 7904, "s": 7696, "text": "Passing the Sample/Custom Test cases does not guarantee the correctness of code. On submission, your code is tested against multiple test cases consisting of all possible corner cases and stress constraints." }, { "code": null, "e": 8010, "s": 7904, "text": "You can access the hints to get an idea about what is expected of you as well as the final solution code." } ]

[ { "code": null, "e": 92, "s": 0, "text": "Conditional statements are used to perform different actions based on different conditions." }, { "code": null, "e": 249, "s": 92, "text": "Very often when you write code, you want to perform different actions for \ndifferent conditions. You can use conditional statements in your code to do this." }, { "code": null, "e": 302, "s": 249, "text": "In PHP we have the following conditional statements:" }, { "code": null, "e": 361, "s": 302, "text": "if statement - executes some code if one condition is true" }, { "code": null, "e": 469, "s": 361, "text": "if...else statement - executes some code if a condition is true and another code if that condition is false" }, { "code": null, "e": 555, "s": 469, "text": "if...elseif...else statement - executes different codes for more than two conditions" }, { "code": null, "e": 624, "s": 555, "text": "switch statement - selects one of many blocks of code to be executed" }, { "code": null, "e": 686, "s": 624, "text": "The if statement executes some code if one condition is true." }, { "code": null, "e": 756, "s": 686, "text": "Output \"Have a good day!\" if the current time (HOUR) is less than 20:" }, { "code": null, "e": 868, "s": 756, "text": "The if...else statement executes some code if a condition is true and \nanother code if that condition is false." }, { "code": null, "e": 970, "s": 868, "text": "Output \"Have a good day!\" if the current time is less than 20, and \"Have a \n good night!\" otherwise:" }, { "code": null, "e": 1059, "s": 970, "text": "The if...elseif...else statement executes different codes for more than two \nconditions." }, { "code": null, "e": 1239, "s": 1059, "text": "Output \"Have a good morning!\" if the current time is less than 10, and \n \"Have a good day!\" if the current time is less than 20. Otherwise it will \n output \"Have a good night!\":" }, { "code": null, "e": 1299, "s": 1239, "text": "The switch statement will be explained in the next chapter." }, { "code": null, "e": 1346, "s": 1299, "text": "Output \"Hello World\" if $a is greater than $b." }, { "code": null, "e": 1396, "s": 1346, "text": "$a = 50;\n$b = 10;\n > {\n echo \"Hello World\";\n}\n" }, { "code": null, "e": 1429, "s": 1396, "text": "We just launchedW3Schools videos" }, { "code": null, "e": 1471, "s": 1429, "text": "Get certifiedby completinga course today!" }, { "code": null, "e": 1578, "s": 1471, "text": "If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:" }, { "code": null, "e": 1597, "s": 1578, "text": "[email protected]" } ]

[ { "code": null, "e": 2567, "s": 2333, "text": "After establishing connection with MySQL, to manipulate data in it you need to connect to a database. You can connect to an existing database or, create your own. You can create any database using the MySQL CREATE DATABASE statement." }, { "code": null, "e": 2643, "s": 2567, "text": "The SHOW DATABASES Statement of MySQL lists out all the existing databases." }, { "code": null, "e": 2697, "s": 2643, "text": "Following is the syntax of the Show DATABASES table −" }, { "code": null, "e": 2758, "s": 2697, "text": "SHOW {DATABASES | SCHEMAS}\n [LIKE 'pattern' | WHERE expr]\n" }, { "code": null, "e": 2816, "s": 2758, "text": "Following query creates a database with name myDatabase −" }, { "code": null, "e": 2851, "s": 2816, "text": "mysql> CREATE DATABASE myDatabase;" }, { "code": null, "e": 3003, "s": 2851, "text": "Make sure you have the admin privilege before creating any database. Once a database is created, you can check it in the list of databases as follows −" }, { "code": null, "e": 3235, "s": 3003, "text": "mysql> show databases;\n+--------------------+\n| Database |\n+--------------------+\n| information_schema |\n| mydatabase |\n| performance_schema |\n| world |\n+--------------------+\n4 rows in set (0.00 sec)" }, { "code": null, "e": 3335, "s": 3235, "text": "Assume we have created four databases in MYSQL using the CREATE DATABASE statement as shown below −" }, { "code": null, "e": 3610, "s": 3335, "text": "mysql> CREATE DATABASE testDB1;\nQuery OK, 1 row affected (0.34 sec)\n\nmysql> CREATE DATABASE testDB2;\nQuery OK, 1 row affected (0.19 sec)\n\nmysql> CREATE DATABASE testDB3;\nQuery OK, 1 row affected (0.21 sec)\n\nmysql> CREATE DATABASE testDB4;\nQuery OK, 1 row affected (0.25 sec)" }, { "code": null, "e": 3697, "s": 3610, "text": "Following query lists out the databases, you can observe the created ones in the list." }, { "code": null, "e": 4021, "s": 3697, "text": "mysql> show databases;\n+--------------------+\n| Database |\n+--------------------+\n| information_schema |\n| mydatabase |\n| performance_schema |\n| testdb1 |\n| testdb2 |\n| testdb3 |\n| testdb4 |\n| world |\n+--------------------+\n8 rows in set (0.00 sec)" }, { "code": null, "e": 4071, "s": 4021, "text": "Now, let us delete three databases create above −" }, { "code": null, "e": 4272, "s": 4071, "text": "mysql> DROP DATABASE testDB1;\nQuery OK, 0 rows affected (0.15 sec)\nmysql> DROP DATABASE testDB2;\nQuery OK, 0 rows affected (0.34 sec)\nmysql> DROP DATABASE testDB3;\nQuery OK, 0 rows affected (0.21 sec)" }, { "code": null, "e": 4378, "s": 4272, "text": "if you verify the list of the tables again, you can observe that the deleted database names are missing −" }, { "code": null, "e": 4633, "s": 4378, "text": "mysql> show databases;\n+--------------------+\n| Database |\n+--------------------+\n| information_schema |\n| mydatabase |\n| performance_schema |\n| testdb4 |\n| world |\n+--------------------+\n5 rows in set (0.00 sec)" }, { "code": null, "e": 4666, "s": 4633, "text": "\n 31 Lectures \n 6 hours \n" }, { "code": null, "e": 4694, "s": 4666, "text": " Eduonix Learning Solutions" }, { "code": null, "e": 4729, "s": 4694, "text": "\n 84 Lectures \n 5.5 hours \n" }, { "code": null, "e": 4746, "s": 4729, "text": " Frahaan Hussain" }, { "code": null, "e": 4780, "s": 4746, "text": "\n 6 Lectures \n 3.5 hours \n" }, { "code": null, "e": 4815, "s": 4780, "text": " DATAhill Solutions Srinivas Reddy" }, { "code": null, "e": 4849, "s": 4815, "text": "\n 60 Lectures \n 10 hours \n" }, { "code": null, "e": 4877, "s": 4849, "text": " Vijay Kumar Parvatha Reddy" }, { "code": null, "e": 4910, "s": 4877, "text": "\n 10 Lectures \n 1 hours \n" }, { "code": null, "e": 4930, "s": 4910, "text": " Harshit Srivastava" }, { "code": null, "e": 4963, "s": 4930, "text": "\n 25 Lectures \n 4 hours \n" }, { "code": null, "e": 4981, "s": 4963, "text": " Trevoir Williams" }, { "code": null, "e": 4988, "s": 4981, "text": " Print" }, { "code": null, "e": 4999, "s": 4988, "text": " Add Notes" } ]

[ { "code": null, "e": 24312, "s": 24284, "text": "\n17 Feb, 2022" }, { "code": null, "e": 24322, "s": 24312, "text": "Question:" }, { "code": null, "e": 24415, "s": 24322, "text": "Given two strings s1 and s2, check if both the strings are anagrams of each other.Examples: " }, { "code": null, "e": 24572, "s": 24415, "text": "Input : s1 = \"listen\"\n s2 = \"silent\"\nOutput : The strings are anagrams.\n\n\nInput : s1 = \"dad\"\n s2 = \"bad\"\nOutput : The strings aren't anagrams." }, { "code": null, "e": 24744, "s": 24572, "text": "Python provides a inbuilt function sorted() which does not modify the original string, but returns sorted string.Below is the Python implementation of the above approach: " }, { "code": null, "e": 24751, "s": 24744, "text": "Python" }, { "code": "# function to check if two strings are# anagram or notdef check(s1, s2): # the sorted strings are checked if(sorted(s1)== sorted(s2)): print(\"The strings are anagrams.\") else: print(\"The strings aren't anagrams.\") # driver code s1 =\"listen\"s2 =\"silent\"check(s1, s2)", "e": 25061, "s": 24751, "text": null }, { "code": null, "e": 25087, "s": 25061, "text": "The strings are anagrams." }, { "code": null, "e": 25153, "s": 25087, "text": "Count all the frequencies of 1st string and 2 and using counter()" }, { "code": null, "e": 25190, "s": 25153, "text": "If they are equal then print anagram" }, { "code": null, "e": 25198, "s": 25190, "text": "Python3" }, { "code": "# Python3 program for the above approachfrom collections import Counter # function to check if two strings are# anagram or notdef check(s1, s2): # implementing counter function if(Counter(s1) == Counter(s2)): print(\"The strings are anagrams.\") else: print(\"The strings aren't anagrams.\") # driver codes1 = \"listen\"s2 = \"silent\"check(s1, s2)", "e": 25566, "s": 25198, "text": null }, { "code": null, "e": 25592, "s": 25566, "text": "The strings are anagrams." }, { "code": null, "e": 25603, "s": 25592, "text": "vikkycirus" }, { "code": null, "e": 25612, "s": 25603, "text": "adnanjsr" }, { "code": null, "e": 25627, "s": 25612, "text": "kapoorsagar226" }, { "code": null, "e": 25639, "s": 25627, "text": "mattjschaub" }, { "code": null, "e": 25647, "s": 25639, "text": "anagram" }, { "code": null, "e": 25661, "s": 25647, "text": "Python-Sorted" }, { "code": null, "e": 25668, "s": 25661, "text": "Python" }, { "code": null, "e": 25676, "s": 25668, "text": "Strings" }, { "code": null, "e": 25684, "s": 25676, "text": "Strings" }, { "code": null, "e": 25692, "s": 25684, "text": "anagram" }, { "code": null, "e": 25790, "s": 25692, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 25799, "s": 25790, "text": "Comments" }, { "code": null, "e": 25812, "s": 25799, "text": "Old Comments" }, { "code": null, "e": 25830, "s": 25812, "text": "Python Dictionary" }, { "code": null, "e": 25865, "s": 25830, "text": "Read a file line by line in Python" }, { "code": null, "e": 25887, "s": 25865, "text": "Enumerate() in Python" }, { "code": null, "e": 25919, "s": 25887, "text": "How to Install PIP on Windows ?" }, { "code": null, "e": 25949, "s": 25919, "text": "Iterate over a list in Python" }, { "code": null, "e": 25974, "s": 25949, "text": "Reverse a string in Java" }, { "code": null, "e": 26020, "s": 25974, "text": "Write a program to reverse an array or string" }, { "code": null, "e": 26054, "s": 26020, "text": "Longest Common Subsequence | DP-4" }, { "code": null, "e": 26114, "s": 26054, "text": "Write a program to print all permutations of a given string" } ]

[ { "code": null, "e": 24852, "s": 24824, "text": "\n07 Apr, 2022" }, { "code": null, "e": 25257, "s": 24852, "text": "What is Determinant of a Matrix? Determinant of a Matrix is a special number that is defined only for square matrices (matrices which have same number of rows and columns). Determinant is used at many places in calculus and other matrix related algebra, it actually represents the matrix in term of a real number which can be used in solving system of linear equation and finding the inverse of a matrix." }, { "code": null, "e": 25642, "s": 25257, "text": "How to calculate? The value of determinant of a matrix can be calculated by following procedure – For each element of first row or first column get cofactor of those elements and then multiply the element with the determinant of the corresponding cofactor, and finally add them with alternate signs. As a base case the value of determinant of a 1*1 matrix is the single value itself. " }, { "code": null, "e": 25756, "s": 25642, "text": "Cofactor of an element, is a matrix which we can get by removing row and column of that element from that matrix." }, { "code": null, "e": 25785, "s": 25756, "text": "Determinant of 2 x 2 Matrix:" }, { "code": null, "e": 25818, "s": 25787, "text": "Determinant of 3 x 3 Matrix: " }, { "code": null, "e": 25822, "s": 25818, "text": "C++" }, { "code": null, "e": 25824, "s": 25822, "text": "C" }, { "code": null, "e": 25829, "s": 25824, "text": "Java" }, { "code": null, "e": 25837, "s": 25829, "text": "Python3" }, { "code": null, "e": 25840, "s": 25837, "text": "C#" }, { "code": null, "e": 25851, "s": 25840, "text": "Javascript" }, { "code": "// C++ program to find Determinant of a matrix#include <iostream>using namespace std; // Dimension of input square matrix#define N 4 // Function to get cofactor of mat[p][q] in temp[][]. n is// current dimension of mat[][]void getCofactor(int mat[N][N], int temp[N][N], int p, int q, int n){ int i = 0, j = 0; // Looping for each element of the matrix for (int row = 0; row < n; row++) { for (int col = 0; col < n; col++) { // Copying into temporary matrix only those // element which are not in given row and // column if (row != p && col != q) { temp[i][j++] = mat[row][col]; // Row is filled, so increase row index and // reset col index if (j == n - 1) { j = 0; i++; } } } }} /* Recursive function for finding determinant of matrix. n is current dimension of mat[][]. */int determinantOfMatrix(int mat[N][N], int n){ int D = 0; // Initialize result // Base case : if matrix contains single element if (n == 1) return mat[0][0]; int temp[N][N]; // To store cofactors int sign = 1; // To store sign multiplier // Iterate for each element of first row for (int f = 0; f < n; f++) { // Getting Cofactor of mat[0][f] getCofactor(mat, temp, 0, f, n); D += sign * mat[0][f] * determinantOfMatrix(temp, n - 1); // terms are to be added with alternate sign sign = -sign; } return D;} /* function for displaying the matrix */void display(int mat[N][N], int row, int col){ for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) cout <<\" \" << mat[i][j]; cout <<\"n\"; }} // Driver program to test above functionsint main(){ /* int mat[N][N] = {{6, 1, 1}, {4, -2, 5}, {2, 8, 7}}; */ int mat[N][N] = { { 1, 0, 2, -1 }, { 3, 0, 0, 5 }, { 2, 1, 4, -3 }, { 1, 0, 5, 0 } }; // Function call cout <<\"Determinant of the matrix is : \" << determinantOfMatrix(mat, N); return 0;} // this code is contributed by shivanisinghss2110", "e": 28167, "s": 25851, "text": null }, { "code": "// C program to find Determinant of a matrix#include <stdio.h> // Dimension of input square matrix#define N 4 // Function to get cofactor of mat[p][q] in temp[][]. n is// current dimension of mat[][]void getCofactor(int mat[N][N], int temp[N][N], int p, int q, int n){ int i = 0, j = 0; // Looping for each element of the matrix for (int row = 0; row < n; row++) { for (int col = 0; col < n; col++) { // Copying into temporary matrix only those // element which are not in given row and // column if (row != p && col != q) { temp[i][j++] = mat[row][col]; // Row is filled, so increase row index and // reset col index if (j == n - 1) { j = 0; i++; } } } }} /* Recursive function for finding determinant of matrix. n is current dimension of mat[][]. */int determinantOfMatrix(int mat[N][N], int n){ int D = 0; // Initialize result // Base case : if matrix contains single element if (n == 1) return mat[0][0]; int temp[N][N]; // To store cofactors int sign = 1; // To store sign multiplier // Iterate for each element of first row for (int f = 0; f < n; f++) { // Getting Cofactor of mat[0][f] getCofactor(mat, temp, 0, f, n); D += sign * mat[0][f] * determinantOfMatrix(temp, n - 1); // terms are to be added with alternate sign sign = -sign; } return D;} /* function for displaying the matrix */void display(int mat[N][N], int row, int col){ for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) printf(\" %d\", mat[i][j]); printf(\"n\"); }} // Driver program to test above functionsint main(){ /* int mat[N][N] = {{6, 1, 1}, {4, -2, 5}, {2, 8, 7}}; */ int mat[N][N] = { { 1, 0, 2, -1 }, { 3, 0, 0, 5 }, { 2, 1, 4, -3 }, { 1, 0, 5, 0 } }; // Function call printf(\"Determinant of the matrix is : %d\", determinantOfMatrix(mat, N)); return 0;}", "e": 30422, "s": 28167, "text": null }, { "code": "// Java program to find Determinant of// a matrixclass GFG { // Dimension of input square matrix static final int N = 4; // Function to get cofactor of // mat[p][q] in temp[][]. n is // current dimension of mat[][] static void getCofactor(int mat[][], int temp[][], int p, int q, int n) { int i = 0, j = 0; // Looping for each element of // the matrix for (int row = 0; row < n; row++) { for (int col = 0; col < n; col++) { // Copying into temporary matrix // only those element which are // not in given row and column if (row != p && col != q) { temp[i][j++] = mat[row][col]; // Row is filled, so increase // row index and reset col // index if (j == n - 1) { j = 0; i++; } } } } } /* Recursive function for finding determinant of matrix. n is current dimension of mat[][]. */ static int determinantOfMatrix(int mat[][], int n) { int D = 0; // Initialize result // Base case : if matrix contains single // element if (n == 1) return mat[0][0]; // To store cofactors int temp[][] = new int[N][N]; // To store sign multiplier int sign = 1; // Iterate for each element of first row for (int f = 0; f < n; f++) { // Getting Cofactor of mat[0][f] getCofactor(mat, temp, 0, f, n); D += sign * mat[0][f] * determinantOfMatrix(temp, n - 1); // terms are to be added with // alternate sign sign = -sign; } return D; } /* function for displaying the matrix */ static void display(int mat[][], int row, int col) { for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) System.out.print(mat[i][j]); System.out.print(\"\\n\"); } } // Driver code public static void main(String[] args) { int mat[][] = { { 1, 0, 2, -1 }, { 3, 0, 0, 5 }, { 2, 1, 4, -3 }, { 1, 0, 5, 0 } }; System.out.print(\"Determinant \" + \"of the matrix is : \" + determinantOfMatrix(mat, N)); }} // This code is contributed by Anant Agarwal.", "e": 33045, "s": 30422, "text": null }, { "code": "# python program to find# determinant of matrix. # defining a function to get the# minor matrix after excluding# i-th row and j-th column. def getcofactor(m, i, j): return [row[: j] + row[j+1:] for row in (m[: i] + m[i+1:])] # defining the function to# calculate determinant value# of given matrix a. def determinantOfMatrix(mat): # if given matrix is of order # 2*2 then simply return det # value by cross multiplying # elements of matrix. if(len(mat) == 2): value = mat[0][0] * mat[1][1] - mat[1][0] * mat[0][1] return value # initialize Sum to zero Sum = 0 # loop to traverse each column # of matrix a. for current_column in range(len(mat)): # calculating the sign corresponding # to co-factor of that sub matrix. sign = (-1) ** (current_column) # calling the function recursily to # get determinant value of # sub matrix obtained. sub_det = determinantOfMatrix(getcofactor(mat, 0, current_column)) # adding the calculated determinant # value of particular column # matrix to total Sum. Sum += (sign * mat[0][current_column] * sub_det) # returning the final Sum return Sum # Driver codeif __name__ == '__main__': # declaring the matrix. mat = [[1, 0, 2, -1], [3, 0, 0, 5], [2, 1, 4, -3], [1, 0, 5, 0]] # printing determinant value # by function call print('Determinant of the matrix is :', determinantOfMatrix(mat)) # This code is contributed by Amit Mangal.", "e": 34594, "s": 33045, "text": null }, { "code": "// C# program to find Determinant of// a matrixusing System;class GFG { // Dimension of input square matrix static int N = 4; // Function to get cofactor of // mat[p][q] in temp[][]. n is // current dimension of mat[][] static void getCofactor(int[, ] mat, int[, ] temp, int p, int q, int n) { int i = 0, j = 0; // Looping for each element of // the matrix for (int row = 0; row < n; row++) { for (int col = 0; col < n; col++) { // Copying into temporary matrix // only those element which are // not in given row and column if (row != p && col != q) { temp[i, j++] = mat[row, col]; // Row is filled, so increase // row index and reset col // index if (j == n - 1) { j = 0; i++; } } } } } /* Recursive function for finding determinant of matrix. n is current dimension of mat[][]. */ static int determinantOfMatrix(int[, ] mat, int n) { int D = 0; // Initialize result // Base case : if matrix // contains single // element if (n == 1) return mat[0, 0]; // To store cofactors int[, ] temp = new int[N, N]; // To store sign multiplier int sign = 1; // Iterate for each element // of first row for (int f = 0; f < n; f++) { // Getting Cofactor of mat[0][f] getCofactor(mat, temp, 0, f, n); D += sign * mat[0, f] * determinantOfMatrix(temp, n - 1); // terms are to be added with // alternate sign sign = -sign; } return D; } /* function for displaying the matrix */ static void display(int[, ] mat, int row, int col) { for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) Console.Write(mat[i, j]); Console.Write(\"\\n\"); } } // Driver code public static void Main() { int[, ] mat = { { 1, 0, 2, -1 }, { 3, 0, 0, 5 }, { 2, 1, 4, -3 }, { 1, 0, 5, 0 } }; Console.Write(\"Determinant \" + \"of the matrix is : \" + determinantOfMatrix(mat, N)); }} // This code is contributed by nitin mittal.", "e": 37202, "s": 34594, "text": null }, { "code": "<script> // JavaScript program to find Determinant of// a matrix // Dimension of input square matrixlet N = 4; // Function to get cofactor of // mat[p][q] in temp[][]. n is // current dimension of mat[][]function getCofactor(mat,temp,p,q,n){ let i = 0, j = 0; // Looping for each element of // the matrix for (let row = 0; row < n; row++) { for (let col = 0; col < n; col++) { // Copying into temporary matrix // only those element which are // not in given row and column if (row != p && col != q) { temp[i][j++] = mat[row][col]; // Row is filled, so increase // row index and reset col // index if (j == n - 1) { j = 0; i++; } } } }} /* Recursive function for finding determinant of matrix. n is current dimension of mat[][]. */function determinantOfMatrix(mat,n){ let D = 0; // Initialize result // Base case : if matrix contains single // element if (n == 1) return mat[0][0]; // To store cofactors let temp = new Array(N); for(let i=0;i<N;i++) { temp[i]=new Array(N); } // To store sign multiplier let sign = 1; // Iterate for each element of first row for (let f = 0; f < n; f++) { // Getting Cofactor of mat[0][f] getCofactor(mat, temp, 0, f, n); D += sign * mat[0][f] * determinantOfMatrix(temp, n - 1); // terms are to be added with // alternate sign sign = -sign; } return D;} /* function for displaying the matrix */function display(mat,row,col){ for (let i = 0; i < row; i++) { for (let j = 0; j < col; j++) document.write(mat[i][j]); document.write(\"<br>\"); }} // Driver codelet mat=[[ 1, 0, 2, -1 ], [ 3, 0, 0, 5 ], [ 2, 1, 4, -3 ], [ 1, 0, 5, 0 ]]; document.write(\"Determinant \" + \"of the matrix is : \" + determinantOfMatrix(mat, N)); // This code is contributed by rag2127 </script>", "e": 39615, "s": 37202, "text": null }, { "code": null, "e": 39649, "s": 39615, "text": "Determinant of the matrix is : 30" }, { "code": null, "e": 39966, "s": 39649, "text": "Adjoint and Inverse of a Matrix There are various properties of the Determinant which can be helpful for solving problems related with matrices, This article is contributed by Utkarsh Trivedi. Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above" }, { "code": null, "e": 40453, "s": 39966, "text": "In Above Method Recursive Approach is discussed. When the size of matrix is large it consumes more stack size In this Method We are using the properties of Determinant. In this approach we are converting the given matrix into upper triangular matrix using determinant properties The determinant of upper triangular matrix is the product of all diagonal elements For properties on determinant go through this website https://cran.r-project.org/web/packages/matlib/vignettes/det-ex1.html " }, { "code": null, "e": 40595, "s": 40453, "text": "In this approach, we are iterating every diagonal element and making all the elements down the diagonal as zero using determinant properties " }, { "code": null, "e": 40689, "s": 40595, "text": "If the diagonal element is zero then we will search next non zero element in the same column " }, { "code": null, "e": 41121, "s": 40689, "text": "There exist two cases Case 1: If there is no non-zero element. In this case the determinant of matrix is zero Case 2: If there exists non-zero element there exist two cases Case a: if index is with respective diagonal row element. Using the determinant properties we make all the column elements down to it as zero Case b: Here we need to swap the row with respective to diagonal element column and continue the case ‘a; operation " }, { "code": null, "e": 41172, "s": 41121, "text": "Below is the implementation of the above approach:" }, { "code": null, "e": 41176, "s": 41172, "text": "C++" }, { "code": null, "e": 41181, "s": 41176, "text": "Java" }, { "code": null, "e": 41189, "s": 41181, "text": "Python3" }, { "code": null, "e": 41192, "s": 41189, "text": "C#" }, { "code": null, "e": 41203, "s": 41192, "text": "Javascript" }, { "code": "// C++ program to find Determinant of a matrix#include <bits/stdc++.h>using namespace std; // Dimension of input square matrix#define N 4// Function to get determinant of matrixint determinantOfMatrix(int mat[N][N], int n){ int num1, num2, det = 1, index, total = 1; // Initialize result // temporary array for storing row int temp[n + 1]; // loop for traversing the diagonal elements for (int i = 0; i < n; i++) { index = i; // initialize the index // finding the index which has non zero value while (mat[index][i] == 0 && index < n) { index++; } if (index == n) // if there is non zero element { // the determinant of matrix as zero continue; } if (index != i) { // loop for swapping the diagonal element row and // index row for (int j = 0; j < n; j++) { swap(mat[index][j], mat[i][j]); } // determinant sign changes when we shift rows // go through determinant properties det = det * pow(-1, index - i); } // storing the values of diagonal row elements for (int j = 0; j < n; j++) { temp[j] = mat[i][j]; } // traversing every row below the diagonal element for (int j = i + 1; j < n; j++) { num1 = temp[i]; // value of diagonal element num2 = mat[j][i]; // value of next row element // traversing every column of row // and multiplying to every row for (int k = 0; k < n; k++) { // multiplying to make the diagonal // element and next row element equal mat[j][k] = (num1 * mat[j][k]) - (num2 * temp[k]); } total = total * num1; // Det(kA)=kDet(A); } } // multiplying the diagonal elements to get determinant for (int i = 0; i < n; i++) { det = det * mat[i][i]; } return (det / total); // Det(kA)/k=Det(A);} // Driver codeint main(){ /*int mat[N][N] = {{6, 1, 1}, {4, -2, 5}, {2, 8, 7}}; */ int mat[N][N] = { { 1, 0, 2, -1 }, { 3, 0, 0, 5 }, { 2, 1, 4, -3 }, { 1, 0, 5, 0 } }; // Function call printf(\"Determinant of the matrix is : %d\", determinantOfMatrix(mat, N)); return 0;}", "e": 43722, "s": 41203, "text": null }, { "code": "// Java program to find Determinant of a matrixclass GFG{ // Dimension of input square matrix static final int N = 4; // Function to get determinant of matrix static int determinantOfMatrix(int mat[][], int n) { int num1, num2, det = 1, index, total = 1; // Initialize result // temporary array for storing row int[] temp = new int[n + 1]; // loop for traversing the diagonal elements for (int i = 0; i < n; i++) { index = i; // initialize the index // finding the index which has non zero value while (mat[index][i] == 0 && index < n) { index++; } if (index == n) // if there is non zero element { // the determinant of matrix as zero continue; } if (index != i) { // loop for swapping the diagonal element row // and index row for (int j = 0; j < n; j++) { swap(mat, index, j, i, j); } // determinant sign changes when we shift // rows go through determinant properties det = (int)(det * Math.pow(-1, index - i)); } // storing the values of diagonal row elements for (int j = 0; j < n; j++) { temp[j] = mat[i][j]; } // traversing every row below the diagonal // element for (int j = i + 1; j < n; j++) { num1 = temp[i]; // value of diagonal element num2 = mat[j] [i]; // value of next row element // traversing every column of row // and multiplying to every row for (int k = 0; k < n; k++) { // multiplying to make the diagonal // element and next row element equal mat[j][k] = (num1 * mat[j][k]) - (num2 * temp[k]); } total = total * num1; // Det(kA)=kDet(A); } } // multiplying the diagonal elements to get // determinant for (int i = 0; i < n; i++) { det = det * mat[i][i]; } return (det / total); // Det(kA)/k=Det(A); } static int[][] swap(int[][] arr, int i1, int j1, int i2, int j2) { int temp = arr[i1][j1]; arr[i1][j1] = arr[i2][j2]; arr[i2][j2] = temp; return arr; } // Driver code public static void main(String[] args) { /*int mat[N][N] = {{6, 1, 1}, {4, -2, 5}, {2, 8, 7}}; */ int mat[][] = { { 1, 0, 2, -1 }, { 3, 0, 0, 5 }, { 2, 1, 4, -3 }, { 1, 0, 5, 0 } }; // Function call System.out.printf( \"Determinant of the matrix is : %d\", determinantOfMatrix(mat, N)); }} // This code is contributed by Rajput-Ji", "e": 46890, "s": 43722, "text": null }, { "code": "# Python program to find Determinant of a matrix def determinantOfMatrix(mat, n): temp = [0]*n # temporary array for storing row total = 1 det = 1 # initialize result # loop for traversing the diagonal elements for i in range(0, n): index = i # initialize the index # finding the index which has non zero value while(mat[index][i] == 0 and index < n): index += 1 if(index == n): # if there is non zero element # the determinant of matrix as zero continue if(index != i): # loop for swapping the diagonal element row and index row for j in range(0, n): mat[index][j], mat[i][j] = mat[i][j], mat[index][j] # determinant sign changes when we shift rows # go through determinant properties det = det*int(pow(-1, index-i)) # storing the values of diagonal row elements for j in range(0, n): temp[j] = mat[i][j] # traversing every row below the diagonal element for j in range(i+1, n): num1 = temp[i] # value of diagonal element num2 = mat[j][i] # value of next row element # traversing every column of row # and multiplying to every row for k in range(0, n): # multiplying to make the diagonal # element and next row element equal mat[j][k] = (num1*mat[j][k]) - (num2*temp[k]) total = total * num1 # Det(kA)=kDet(A); # multiplying the diagonal elements to get determinant for i in range(0, n): det = det*mat[i][i] return int(det/total) # Det(kA)/k=Det(A); # Drivers codeif __name__ == \"__main__\": # mat=[[6 1 1][4 -2 5][2 8 7]] mat = [[1, 0, 2, -1], [3, 0, 0, 5], [2, 1, 4, -3], [1, 0, 5, 0]] N = len(mat) # Function call print(\"Determinant of the matrix is : \", determinantOfMatrix(mat, N))", "e": 48844, "s": 46890, "text": null }, { "code": "// C# program to find Determinant of a matrixusing System; class GFG { // Dimension of input square matrix static readonly int N = 4; // Function to get determinant of matrix static int determinantOfMatrix(int[, ] mat, int n) { int num1, num2, det = 1, index, total = 1; // Initialize result // temporary array for storing row int[] temp = new int[n + 1]; // loop for traversing the diagonal elements for (int i = 0; i < n; i++) { index = i; // initialize the index // finding the index which has non zero value while (mat[index, i] == 0 && index < n) { index++; } if (index == n) // if there is non zero element { // the determinant of matrix as zero continue; } if (index != i) { // loop for swapping the diagonal element row // and index row for (int j = 0; j < n; j++) { swap(mat, index, j, i, j); } // determinant sign changes when we shift // rows go through determinant properties det = (int)(det * Math.Pow(-1, index - i)); } // storing the values of diagonal row elements for (int j = 0; j < n; j++) { temp[j] = mat[i, j]; } // traversing every row below the diagonal // element for (int j = i + 1; j < n; j++) { num1 = temp[i]; // value of diagonal element num2 = mat[j, i]; // value of next row element // traversing every column of row // and multiplying to every row for (int k = 0; k < n; k++) { // multiplying to make the diagonal // element and next row element equal mat[j, k] = (num1 * mat[j, k]) - (num2 * temp[k]); } total = total * num1; // Det(kA)=kDet(A); } } // multiplying the diagonal elements to get // determinant for (int i = 0; i < n; i++) { det = det * mat[i, i]; } return (det / total); // Det(kA)/k=Det(A); } static int[, ] swap(int[, ] arr, int i1, int j1, int i2, int j2) { int temp = arr[i1, j1]; arr[i1, j1] = arr[i2, j2]; arr[i2, j2] = temp; return arr; } // Driver code public static void Main(String[] args) { /*int mat[N,N] = {{6, 1, 1}, {4, -2, 5}, {2, 8, 7}}; */ int[, ] mat = { { 1, 0, 2, -1 }, { 3, 0, 0, 5 }, { 2, 1, 4, -3 }, { 1, 0, 5, 0 } }; // Function call Console.Write(\"Determinant of the matrix is : {0}\", determinantOfMatrix(mat, N)); }} // This code is contributed by 29AjayKumar", "e": 52025, "s": 48844, "text": null }, { "code": "Javascript<script>// javascript program to find Determinant of a matrix // Dimension of input square matrix var N = 4; // Function to get determinant of matrix function determinantOfMatrix(mat , n) { var num1, num2, det = 1, index, total = 1; // Initialize result // temporary array for storing row var temp = Array(n + 1).fill(0); // loop for traversing the diagonal elements for (i = 0; i < n; i++) { index = i; // initialize the index // finding the index which has non zero value while (mat[index][i] == 0 && index < n) { index++; } if (index == n) // if there is non zero element { // the determinant of matrix as zero continue; } if (index != i) { // loop for swapping the diagonal element row // and index row for (j = 0; j < n; j++) { swap(mat, index, j, i, j); } // determinant sign changes when we shift // rows go through determinant properties det = parseInt((det * Math.pow(-1, index - i))); } // storing the values of diagonal row elements for (j = 0; j < n; j++) { temp[j] = mat[i][j]; } // traversing every row below the diagonal // element for (j = i + 1; j < n; j++) { num1 = temp[i]; // value of diagonal element num2 = mat[j] [i]; // value of next row element // traversing every column of row // and multiplying to every row for (k = 0; k < n; k++) { // multiplying to make the diagonal // element and next row element equal mat[j][k] = (num1 * mat[j][k]) - (num2 * temp[k]); } total = total * num1; // Det(kA)=kDet(A); } } // multiplying the diagonal elements to get // determinant for (i = 0; i < n; i++) { det = det * mat[i][i]; } return (det / total); // Det(kA)/k=Det(A); } function swap(arr , i1 , j1 , i2, j2) { var temp = arr[i1][j1]; arr[i1][j1] = arr[i2][j2]; arr[i2][j2] = temp; return arr; } // Driver code /*var mat[N][N] = [{6, 1, 1], {4, -2, 5], {2, 8, 7}]; */ var mat = [ [ 1, 0, 2, -1 ], [ 3, 0, 0, 5 ], [ 2, 1, 4, -3 ], [ 1, 0, 5, 0 ] ]; // Function call document.write( \"Determinant of the matrix is : \", determinantOfMatrix(mat, N)); // This code contributed by gauravrajput1</script>", "e": 55098, "s": 52025, "text": null }, { "code": null, "e": 55132, "s": 55098, "text": "Determinant of the matrix is : 30" }, { "code": null, "e": 55179, "s": 55132, "text": "Time complexity: O(n3) Auxiliary Space: O(n) " }, { "code": null, "e": 55219, "s": 55179, "text": "Method 3: Using numpy package in python" }, { "code": null, "e": 55419, "s": 55219, "text": "There is a built-in function or method in linalg module of numpy package in python. It can be called as numpy.linalg.det(mat) which returns the determinant value of matrix mat passed in the argument." }, { "code": null, "e": 55427, "s": 55419, "text": "Python3" }, { "code": "# importing the numpy package# as npimport numpy as np def determinant(mat): # calling the det() method det = np.linalg.det(mat) return round(det) # Driver Code# declaring the matrixmat = [[1, 0, 2, -1], [3, 0, 0, 5], [2, 1, 4, -3], [1, 0, 5, 0]] # Function callprint('Determinant of the matrix is:', determinant(mat)) # This code is contributed by Amit Mangal.", "e": 55826, "s": 55427, "text": null }, { "code": null, "e": 55834, "s": 55826, "text": "Output:" }, { "code": null, "e": 55869, "s": 55834, "text": "Determinant of the matrix is: 30.0" }, { "code": null, "e": 55882, "s": 55869, "text": "nitin mittal" }, { "code": null, "e": 55897, "s": 55882, "text": "Sairahul Jella" }, { "code": null, "e": 55910, "s": 55897, "text": "Akanksha_Rai" }, { "code": null, "e": 55920, "s": 55910, "text": "Rajput-Ji" }, { "code": null, "e": 55932, "s": 55920, "text": "29AjayKumar" }, { "code": null, "e": 55945, "s": 55932, "text": "amit_mangal_" }, { "code": null, "e": 55959, "s": 55945, "text": "GauravRajput1" }, { "code": null, "e": 55975, "s": 55959, "text": "simranarora5sos" }, { "code": null, "e": 55983, "s": 55975, "text": "rag2127" }, { "code": null, "e": 56002, "s": 55983, "text": "surindertarika1234" }, { "code": null, "e": 56021, "s": 56002, "text": "shivanisinghss2110" }, { "code": null, "e": 56038, "s": 56021, "text": "surinderdawra388" }, { "code": null, "e": 56051, "s": 56038, "text": "simmytarika5" }, { "code": null, "e": 56064, "s": 56051, "text": "Mathematical" }, { "code": null, "e": 56071, "s": 56064, "text": "Matrix" }, { "code": null, "e": 56084, "s": 56071, "text": "Mathematical" }, { "code": null, "e": 56091, "s": 56084, "text": "Matrix" }, { "code": null, "e": 56189, "s": 56091, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 56198, "s": 56189, "text": "Comments" }, { "code": null, "e": 56211, "s": 56198, "text": "Old Comments" }, { "code": null, "e": 56253, "s": 56211, "text": "Program to find GCD or HCF of two numbers" }, { "code": null, "e": 56267, "s": 56253, "text": "Prime Numbers" }, { "code": null, "e": 56291, "s": 56267, "text": "Merge two sorted arrays" }, { "code": null, "e": 56334, "s": 56291, "text": "Modulo Operator (%) in C/C++ with Examples" }, { "code": null, "e": 56355, "s": 56334, "text": "Operators in C / C++" }, { "code": null, "e": 56390, "s": 56355, "text": "Matrix Chain Multiplication | DP-8" }, { "code": null, "e": 56434, "s": 56390, "text": "Program to find largest element in an array" }, { "code": null, "e": 56458, "s": 56434, "text": "Sudoku | Backtracking-7" }, { "code": null, "e": 56489, "s": 56458, "text": "Rat in a Maze | Backtracking-2" } ]

[ { "code": null, "e": 343, "s": 290, "text": "Print numbers from 1 to N without the help of loops." }, { "code": null, "e": 354, "s": 343, "text": "Example 1:" }, { "code": null, "e": 398, "s": 354, "text": "Input:\nN = 10\nOutput: 1 2 3 4 5 6 7 8 9 10\n" }, { "code": null, "e": 410, "s": 398, "text": "\nExample 2:" }, { "code": null, "e": 441, "s": 410, "text": "Input:\nN = 5\nOutput: 1 2 3 4 5" }, { "code": null, "e": 659, "s": 443, "text": "Your Task:\nThis is a function problem. You only need to complete the function printNos() that takes N as parameter and prints number from 1 to N recursively. Don't print newline, it will be added by the driver code." }, { "code": null, "e": 736, "s": 659, "text": "\nExpected Time Complexity: O(N).\nExpected Auxiliary Space: O(N) (Recursive)." }, { "code": null, "e": 764, "s": 736, "text": "\nConstraints:\n1 <= N <= 105" }, { "code": null, "e": 766, "s": 764, "text": "0" }, { "code": null, "e": 790, "s": 766, "text": "yasugupta20014 days ago" }, { "code": null, "e": 1048, "s": 790, "text": "class Solution{ void print(int N) { if(N == 0) { return; } else { print(N-1); System.out.print(N + \" \"); } } public void printNos(int N) { //Your code here print(N); }} " }, { "code": null, "e": 1050, "s": 1048, "text": "0" }, { "code": null, "e": 1077, "s": 1050, "text": "kumarrohit5120004 days ago" }, { "code": null, "e": 1125, "s": 1077, "text": "// { Driver Code Starts//Initial Template for C" }, { "code": null, "e": 1144, "s": 1125, "text": "#include <stdio.h>" }, { "code": null, "e": 1196, "s": 1144, "text": "// } Driver Code Ends//User function Template for C" }, { "code": null, "e": 1683, "s": 1196, "text": "void printNos(int N){ if(N>0) { printNos(N-1); printf(\"%d\",N); }//Your code here return;}int main(){ printNos(10); getchar(); return 0;}// { Driver Code Starts./* Driver program to test printNos */int main(){ int T; //taking testcases scanf(\"%d\", &T); while(T--) { int N; //input N scanf(\"%d\", &N); //calling printNos() function printNos(N); printf(\"\\n\"); } return 0;} // } Driver Code Ends" }, { "code": null, "e": 1685, "s": 1683, "text": "0" }, { "code": null, "e": 1712, "s": 1685, "text": "kumarrohit5120004 days ago" }, { "code": null, "e": 1732, "s": 1714, "text": "#include<stdio.h>" }, { "code": null, "e": 1753, "s": 1732, "text": "void printNos(int N)" }, { "code": null, "e": 1755, "s": 1753, "text": "{" }, { "code": null, "e": 1763, "s": 1755, "text": "if(N>0)" }, { "code": null, "e": 1765, "s": 1763, "text": "{" }, { "code": null, "e": 1780, "s": 1765, "text": "printNos(N-1);" }, { "code": null, "e": 1796, "s": 1780, "text": "printf(\"%d\",N);" }, { "code": null, "e": 1798, "s": 1796, "text": "}" }, { "code": null, "e": 1806, "s": 1798, "text": "return;" }, { "code": null, "e": 1808, "s": 1806, "text": "}" }, { "code": null, "e": 1819, "s": 1808, "text": "int main()" }, { "code": null, "e": 1821, "s": 1819, "text": "{" }, { "code": null, "e": 1835, "s": 1821, "text": "printNos(10);" }, { "code": null, "e": 1846, "s": 1835, "text": "getchar();" }, { "code": null, "e": 1856, "s": 1846, "text": "return 0;" }, { "code": null, "e": 1858, "s": 1856, "text": "}" }, { "code": null, "e": 1862, "s": 1860, "text": "0" }, { "code": null, "e": 1887, "s": 1862, "text": "niharbastia2975 days ago" }, { "code": null, "e": 2032, "s": 1887, "text": " void printNos(int N) { //Your code here if(N == 0) return; printNos(N-1); cout<< N <<\" \"; }" }, { "code": null, "e": 2034, "s": 2032, "text": "0" }, { "code": null, "e": 2064, "s": 2034, "text": "dipanshusharma93132 weeks ago" }, { "code": null, "e": 2081, "s": 2064, "text": "// java solution" }, { "code": null, "e": 2342, "s": 2081, "text": "class Solution{ public void print(int N){ if(N == 1){ return; } N = N-1; print(N); System.out.print(N+\" \"); } public void printNos(int N) { //Your code here print(N); System.out.print(N+\" \"); }}" }, { "code": null, "e": 2344, "s": 2342, "text": "0" }, { "code": null, "e": 2363, "s": 2344, "text": "dipanshusharma9313" }, { "code": null, "e": 2389, "s": 2363, "text": "This comment was deleted." }, { "code": null, "e": 2391, "s": 2389, "text": "0" }, { "code": null, "e": 2414, "s": 2391, "text": "bhushanrane2 weeks ago" }, { "code": null, "e": 2428, "s": 2414, "text": "cout<<N<<\" \";" }, { "code": null, "e": 2430, "s": 2428, "text": "0" }, { "code": null, "e": 2458, "s": 2430, "text": "shivjeetpaswan862 weeks ago" }, { "code": null, "e": 2474, "s": 2458, "text": "in cpp language" }, { "code": null, "e": 2501, "s": 2474, "text": "void print_n_number(int n)" }, { "code": null, "e": 2503, "s": 2501, "text": "{" }, { "code": null, "e": 2515, "s": 2503, "text": "if (n == 0)" }, { "code": null, "e": 2517, "s": 2515, "text": "{" }, { "code": null, "e": 2525, "s": 2517, "text": "return;" }, { "code": null, "e": 2527, "s": 2525, "text": "}" }, { "code": null, "e": 2550, "s": 2527, "text": "print_n_number(n - 1);" }, { "code": null, "e": 2568, "s": 2550, "text": "cout << n << \" \";" }, { "code": null, "e": 2570, "s": 2568, "text": "}" }, { "code": null, "e": 2574, "s": 2572, "text": "0" }, { "code": null, "e": 2598, "s": 2574, "text": "sumit20445553 weeks ago" }, { "code": null, "e": 2669, "s": 2598, "text": " if(N <= 0): return self.printNos(N - 1) print(N, end = \" \")" }, { "code": null, "e": 2671, "s": 2669, "text": "0" }, { "code": null, "e": 2695, "s": 2671, "text": "sumit20445553 weeks ago" }, { "code": null, "e": 2789, "s": 2695, "text": "/Your code here if(N==0) return; printNos(N-1); cout<<N<<\" \"; }" }, { "code": null, "e": 2935, "s": 2789, "text": "We strongly recommend solving this problem on your own before viewing its editorial. Do you still\n want to view the editorial?" }, { "code": null, "e": 2971, "s": 2935, "text": " Login to access your submissions. " }, { "code": null, "e": 2981, "s": 2971, "text": "\nProblem\n" }, { "code": null, "e": 2991, "s": 2981, "text": "\nContest\n" }, { "code": null, "e": 3054, "s": 2991, "text": "Reset the IDE using the second button on the top right corner." }, { "code": null, "e": 3202, "s": 3054, "text": "Avoid using static/global variables in your code as your code is tested against multiple test cases and these tend to retain their previous values." }, { "code": null, "e": 3410, "s": 3202, "text": "Passing the Sample/Custom Test cases does not guarantee the correctness of code. On submission, your code is tested against multiple test cases consisting of all possible corner cases and stress constraints." }, { "code": null, "e": 3516, "s": 3410, "text": "You can access the hints to get an idea about what is expected of you as well as the final solution code." } ]

[ { "code": null, "e": 662, "s": 171, "text": "Although on the surface Python might appear to be a language of simplicity that anyone can learn, and it is, many might be surprised to know just how much mastery one can obtain in the language. Python is one of those things that is rather easy learn, but can be difficult to master. In Python, there are often multiple ways of doing things, but it can be easy to do the wrong thing, or reinvent the standard library and waste time simply because you were not aware of a module’s existence." }, { "code": null, "e": 1006, "s": 662, "text": "Unfortunately, the Python standard library is quite a vast beast, and furthermore, its ecosystem is absolutely terrifyingly enormous. Although there are probably two-million gigabytes of Python modules, there are some useful tips that you can learn with the standard library and packages usually associated with scientific computing in Python." }, { "code": null, "e": 1260, "s": 1006, "text": "Though it might seem rather basic, reversing a string with char looping can be rather tedious and annoying. Fortunately, Python includes an easy built-in operation to perform exactly this task. To do this, we simply access the indice ::-1 on our string." }, { "code": null, "e": 1297, "s": 1260, "text": "a = \"!dlrow olleH\"backward = a[::-1]" }, { "code": null, "e": 1465, "s": 1297, "text": "In most languages, in order to get an array into a set of variables we would need to either loop through the values iteratively or access the dims by position like so:" }, { "code": null, "e": 1485, "s": 1465, "text": "firstdim = array[1]" }, { "code": null, "e": 1691, "s": 1485, "text": "In Python, however, there is a way cooler and quicker way to do so. In order to change a list of values into variables we can simply set variable names equal to the array with the same length of the array:" }, { "code": null, "e": 1745, "s": 1691, "text": "array = [5, 10, 15, 20]five, ten, fift, twent = array" }, { "code": null, "e": 2150, "s": 1745, "text": "If you’re going to spend any time whatsoever in Python, you will definitely want to get familiar with itertools. Itertools is a module within the standard library that will allow you to get around iteration constantly. Not only does it make it far easier to code complex loops, it also makes your code both faster and more concise. Here is just one example of a use for Itertools, but there are hundreds:" }, { "code": null, "e": 2294, "s": 2150, "text": "c = [[1, 2], [3, 4], [5, 6]]# Let's convert this matrix to a 1 dimensional list.import itertools as itnewlist = list(it.chain.from_iterable(c))" }, { "code": null, "e": 2558, "s": 2294, "text": "Unpacking values iteratively can be rather intensive and time consuming. Fortunately, Python has several cool ways in which we can unpack lists! One example of this is the *, which will fill in unassigned values and add them to a new list under our variable name." }, { "code": null, "e": 2585, "s": 2558, "text": "a, *b, c = [1, 2, 3, 4, 5]" }, { "code": null, "e": 2822, "s": 2585, "text": "If you’re not aware of enumerate, you probably should get familiar with it. Enumerate will allow you to get indexes of certain values in a list. This is especially useful in data science when working with arrays rather than data-frames." }, { "code": null, "e": 2865, "s": 2822, "text": "for i,w in enumerate(array): print(i,w)" }, { "code": null, "e": 3112, "s": 2865, "text": "Slicing apart lists in Python is incredibly easy! There are all sorts of great tools that can be used for this, but one that certainly is valuable is the ability to name slices of your list. This is especially useful for linear algebra in Python." }, { "code": null, "e": 3202, "s": 3112, "text": "a = [0, 1, 2, 3, 4, 5]LASTTHREE = slice(-3, None)slice(-3, None, None)print(a[LASTTHREE])" }, { "code": null, "e": 3488, "s": 3202, "text": "Grouping adjacent loops could certainly be done rather easily in a for loop, especially by using zip(), but this is certainly not the best way of doing things. To make things a bit easier and faster, we can write a lambda expression with zip that will group our adjacent lists like so:" }, { "code": null, "e": 3675, "s": 3488, "text": "a = [1, 2, 3, 4, 5, 6] group_adjacent = lambda a, k: zip(*([iter(a)] * k)) group_adjacent(a, 3) [(1, 2, 3), (4, 5, 6)] group_adjacent(a, 2) [(1, 2), (3, 4), (5, 6)] group_adjacent(a, 1)" }, { "code": null, "e": 3833, "s": 3675, "text": "In most normal scenarios in programming, we can access an indice and get our position number by using a counter, which will just be a value that is added to:" }, { "code": null, "e": 4084, "s": 3833, "text": "array1 = [5, 10, 15, 20]array2 = (x ** 2 for x in range(10))counter = 0for i in array1:# This code wouldn't work because 'i' is not in array2. # i = array2[i] i = array2[counter]# ^^^ This code would because we are accessing the position of i" }, { "code": null, "e": 4251, "s": 4084, "text": "Instead of this, however, we can use next(). Next takes an iterator that will store our current position in memory and will iterate across our list in the background." }, { "code": null, "e": 4311, "s": 4251, "text": "g = (x ** 2 for x in range(10))print(next(g))print(next(g))" }, { "code": null, "e": 4674, "s": 4311, "text": "Another great module from the standard library is collections, and what I would like to introduce to you today is Counter from collections. Using Counter, we can easily get counts of a list. This is useful for getting the total number of values in our data, getting a null count of our data, and seeing the unique values of our data. I know what you’re thinking," }, { "code": null, "e": 4702, "s": 4674, "text": "“ Why not just use Pandas?”" }, { "code": null, "e": 5095, "s": 4702, "text": "And this is certainly a valid point. However, using Pandas for this is certainly going to be a lot harder to automate, and is just another dependency you are going to need to add to your virtual environment whenever you deploy your algorithm. Additionally, a counter type in Python has a lot of features that Pandas Series don’t have, which can make it far more useful for certain situations." }, { "code": null, "e": 5279, "s": 5095, "text": "A = collections.Counter([1, 1, 2, 2, 3, 3, 3, 3, 4, 5, 6, 7]) A Counter({3: 4, 1: 2, 2: 2, 4: 1, 5: 1, 6: 1, 7: 1}) A.most_common(1) [(3, 4)] A.most_common(3) [(3, 4), (1, 2), (2, 2)]" }, { "code": null, "e": 5404, "s": 5279, "text": "Another great thing coming out of the collections module is dequeue. Check out all the neat things we can do with this type!" }, { "code": null, "e": 5563, "s": 5404, "text": "import collectionsQ = collections.deque() Q.append(1) Q.appendleft(2) Q.extend([3, 4]) Q.extendleft([5, 6]) Q.pop()Q.popleft()Q.rotate(3) Q.rotate(-3)print(Q)" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n06 May, 2019" }, { "code": null, "e": 117, "s": 28, "text": "Problem: Write a YACC program which accept strings that starts and ends with Zero or One" }, { "code": null, "e": 407, "s": 117, "text": "Explanation:YACC (Yet another Compiler-Compiler) is the standard parser generator for the Unix operating system. An open source program, yacc generates code for the parser in the C programming language. The acronym is usually rendered in lowercase but is occasionally seen as YACC or Yacc." }, { "code": null, "e": 417, "s": 407, "text": "Examples:" }, { "code": null, "e": 583, "s": 417, "text": "Input: 001100\nOutput: Sequence Accepted\n\nInput: 1001001\nOutput: Sequence Accepted\n\nInput: 0011101\nOutput: Sequence Rejected\n\nInput: 100110\nOutput: Sequence Rejected " }, { "code": null, "e": 614, "s": 583, "text": "Lexical Analyzer Source Code :" }, { "code": "%{ /* Definition section */ extern int yylval;%} /* Rule Section */%% 0 {yylval = 0; return ZERO;} 1 {yylval = 1; return ONE;} .|\\n {yylval = 2; return 0;} %%", "e": 780, "s": 614, "text": null }, { "code": null, "e": 801, "s": 780, "text": "Parser Source Code :" }, { "code": "%{ /* Definition section */ #include<stdio.h> #include <stdlib.h> void yyerror(const char *str) { printf(\"\\nSequence Rejected\\n\"); } %} %token ZERO ONE /* Rule Section */%% r : s {printf(\"\\nSequence Accepted\\n\\n\");}; s : n| ZERO a| ONE b; a : n a| ZERO; b : n b| ONE; n : ZERO| ONE; %% #include\"lex.yy.c\"//driver codeint main() { printf(\"\\nEnter Sequence of Zeros and Ones : \"); yyparse(); printf(\"\\n\"); return 0; }", "e": 1257, "s": 801, "text": null }, { "code": null, "e": 1265, "s": 1257, "text": "Output:" }, { "code": null, "e": 1277, "s": 1265, "text": "Lex program" }, { "code": null, "e": 1293, "s": 1277, "text": "Compiler Design" }, { "code": null, "e": 1391, "s": 1293, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 1449, "s": 1391, "text": "Directed Acyclic graph in Compiler Design (with examples)" }, { "code": null, "e": 1482, "s": 1449, "text": "Type Checking in Compiler Design" }, { "code": null, "e": 1513, "s": 1482, "text": "Data flow analysis in Compiler" }, { "code": null, "e": 1583, "s": 1513, "text": "S - attributed and L - attributed SDTs in Syntax directed translation" }, { "code": null, "e": 1623, "s": 1583, "text": "Runtime Environments in Compiler Design" }, { "code": null, "e": 1651, "s": 1623, "text": "Compiler construction tools" }, { "code": null, "e": 1683, "s": 1651, "text": "Basic Blocks in Compiler Design" }, { "code": null, "e": 1711, "s": 1683, "text": "Token, Patterns, and Lexems" }, { "code": null, "e": 1753, "s": 1711, "text": "Compiler Design - Variants of Syntax Tree" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n01 Oct, 2020" }, { "code": null, "e": 97, "s": 28, "text": "Prerequisite- Introduction to Social Networks, Barabasi Albert Graph" }, { "code": null, "e": 401, "s": 97, "text": "In social networks, there is a phenomenon called Rich getting Richer also known as Preferential Attachment. In Preferential Attachment, a person who is already rich gets more and more and a person who is having less gets less. This is called the Rich getting Richer phenomena or Preferential Attachment." }, { "code": null, "e": 943, "s": 401, "text": "For example, assume there are some students in a class and every student is friends with some students which is called its degree i.e a degree of a student Is the number of friends it has. Now the student with a higher degree is rich and the student with a low degree is poor. Now suppose there comes a new student in the class and he/she has to make m friends, so he/she will select students with a higher degree and become friends with them which increases the degree of rich. This is called Rich getting Richer or Preferential Attachment." }, { "code": null, "e": 1016, "s": 943, "text": "Barabasi Albert Model is the implementation of Preferential Attachment. " }, { "code": null, "e": 1078, "s": 1016, "text": "Logic – Below are the logic behind the Barabasi Albert Model:" }, { "code": null, "e": 1434, "s": 1078, "text": "Take a random graph with n0 nodes and connect them randomly with a condition that each has at least 1 link.At each time we add a new node n which is less or equal to n0 links that will connect the new node to n nodes already in the network.Now the probability that a node connects to a particular node will depend on its degree. (Preferential Attachment)." }, { "code": null, "e": 1542, "s": 1434, "text": "Take a random graph with n0 nodes and connect them randomly with a condition that each has at least 1 link." }, { "code": null, "e": 1676, "s": 1542, "text": "At each time we add a new node n which is less or equal to n0 links that will connect the new node to n nodes already in the network." }, { "code": null, "e": 1792, "s": 1676, "text": "Now the probability that a node connects to a particular node will depend on its degree. (Preferential Attachment)." }, { "code": null, "e": 1867, "s": 1792, "text": "Approach – Below are the steps for implementing the Barabasi Albert Model:" }, { "code": null, "e": 2113, "s": 1867, "text": "Take a graph with n nodes.Take m from the user i.e number of edges to be connected to the new node.Take m0 i.e initial number of nodes such that m<=m0.Now add the n-m0 nodes.Now add edges to these n-m0 nodes according to Preferential Attachment." }, { "code": null, "e": 2140, "s": 2113, "text": "Take a graph with n nodes." }, { "code": null, "e": 2214, "s": 2140, "text": "Take m from the user i.e number of edges to be connected to the new node." }, { "code": null, "e": 2267, "s": 2214, "text": "Take m0 i.e initial number of nodes such that m<=m0." }, { "code": null, "e": 2291, "s": 2267, "text": "Now add the n-m0 nodes." }, { "code": null, "e": 2363, "s": 2291, "text": "Now add edges to these n-m0 nodes according to Preferential Attachment." }, { "code": null, "e": 2421, "s": 2363, "text": "Below is the implementation of the Barabasi Albert model." }, { "code": null, "e": 2429, "s": 2421, "text": "Python3" }, { "code": "import networkx as nximport randomimport matplotlib.pyplot as plt def display(g, i, ne): pos = nx.circular_layout(g) if i == '' and ne == '': new_node = [] rest_nodes = g.nodes() new_edges = [] rest_edges = g.edges() else: new_node = [i] rest_nodes = list(set(g.nodes()) - set(new_node)) new_edges = ne rest_edges = list(set(g.edges()) - set(new_edges) - set([(b, a) for (a, b) in new_edges])) nx.draw_networkx_nodes(g, pos, nodelist=new_node, node_color='g') nx.draw_networkx_nodes(g, pos, nodelist=rest_nodes, node_color='r') nx.draw_networkx_edges(g, pos, edgelist=new_edges, style='dashdot') nx.draw_networkx_edges(g, pos, edgelist=rest_edges,) plt.show() def barabasi_add_nodes(g, n, m0): m = m0 - 1 for i in range(m0 + 1, n + 1): g.add_node(i) degrees = nx.degree(g) node_prob = {} s = 0 for j in degrees: s += j[1] print(g.nodes()) for each in g.nodes(): node_prob[each] = (float)(degrees[each]) / s node_probabilities_cum = [] prev = 0 for n, p in node_prob.items(): temp = [n, prev + p] node_probabilities_cum.append(temp) prev += p new_edges = [] num_edges_added = 0 target_nodes = [] while (num_edges_added < m): prev_cum = 0 r = random.random() k = 0 while (not (r > prev_cum and r <= node_probabilities_cum[k][1])): prev_cum = node_probabilities_cum[k][1] k = k + 1 target_node = node_probabilities_cum[k][0] if target_node in target_nodes: continue else: target_nodes.append(target_node) g.add_edge(i, target_node) num_edges_added += 1 new_edges.append((i, target_node)) print(num_edges_added, ' edges added') display(g, i, new_edges) return g def plot_deg_dist(g): all_degrees = [] for i in nx.degree(g): all_degrees.append(i[1]) unique_degrees = list(set(all_degrees)) unique_degrees.sort() count_of_degrees = [] for i in unique_degrees: c = all_degrees.count(i) count_of_degrees.append(c) print(unique_degrees) print(count_of_degrees) plt.plot(unique_degrees, count_of_degrees, 'ro-') plt.xlabel('Degrees') plt.ylabel('Number of Nodes') plt.title('Degree Distribution') plt.show() N = 10m0 = random.randint(2, N / 5)g = nx.path_graph(m0)display(g, '', '') g = barabasi_add_nodes(g, N, m0)plot_deg_dist(g)", "e": 5140, "s": 2429, "text": null }, { "code": null, "e": 5148, "s": 5140, "text": "Output:" }, { "code": null, "e": 5487, "s": 5148, "text": "Enter the value of n: 10\n3\n[0, 1, 3]\n1 edges added\n[0, 1, 3, 4]\n1 edges added\n[0, 1, 3, 4, 5]\n1 edges added\n[0, 1, 3, 4, 5, 6]\n1 edges added\n[0, 1, 3, 4, 5, 6, 7]\n1 edges added\n[0, 1, 3, 4, 5, 6, 7, 8]\n1 edges added\n[0, 1, 3, 4, 5, 6, 7, 8, 9]\n1 edges added\n[0, 1, 3, 4, 5, 6, 7, 8, 9, 10]\n1 edges added\n[1, 2, 3, 6]\n[7, 1, 1, 1]\n" }, { "code": null, "e": 5515, "s": 5487, "text": "Initial Graph with m0 nodes" }, { "code": null, "e": 5546, "s": 5515, "text": "Final Node with new node added" }, { "code": null, "e": 5565, "s": 5546, "text": "Distribution Graph" }, { "code": null, "e": 5589, "s": 5565, "text": "Advanced Data Structure" }, { "code": null, "e": 5595, "s": 5589, "text": "Graph" }, { "code": null, "e": 5602, "s": 5595, "text": "Python" }, { "code": null, "e": 5608, "s": 5602, "text": "Graph" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n12 Jul, 2019" }, { "code": null, "e": 127, "s": 28, "text": "The color.opacity in D3.js is used to fade the color. The opacity value is in the range of [0, 1]." }, { "code": null, "e": 135, "s": 127, "text": "Syntax:" }, { "code": null, "e": 149, "s": 135, "text": "color.opacity" }, { "code": null, "e": 207, "s": 149, "text": "Parameters: This function does not accept any parameters." }, { "code": null, "e": 285, "s": 207, "text": "Return Value: This function returns the opacity value of the specified color." }, { "code": null, "e": 347, "s": 285, "text": "Below program illustrate the color.opacity function in D3.js:" }, { "code": null, "e": 356, "s": 347, "text": "Example:" }, { "code": "<!DOCTYPE html><html> <head> <title>color.rgb() function</title> <script src='https://d3js.org/d3.v4.min.js'> </script></head> <body> <script> // Calling the d3.color() function // with some parameters var color1 = d3.color(\"red\"); var color2 = d3.color(\"green\"); var color3 = d3.color(\"blue\"); // Calling the color.opacity var A = color1.opacity; var B = color2.opacity; var C = color3.opacity; // Getting the opacity value console.log(A); console.log(B); console.log(C); </script></body> </html>", "e": 967, "s": 356, "text": null }, { "code": null, "e": 975, "s": 967, "text": "Output:" }, { "code": null, "e": 982, "s": 975, "text": "1\n1\n1\n" }, { "code": null, "e": 1034, "s": 982, "text": "Ref: https://devdocs.io/d3~5/d3-color#color_opacity" }, { "code": null, "e": 1040, "s": 1034, "text": "D3.js" }, { "code": null, "e": 1051, "s": 1040, "text": "JavaScript" }, { "code": null, "e": 1068, "s": 1051, "text": "Web Technologies" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n05 Jul, 2022" }, { "code": null, "e": 110, "s": 28, "text": "Let us know what an IP address is first, if you already know, skip this section. " }, { "code": null, "e": 428, "s": 110, "text": "IP (Internet Protocol): It is one of the fundamental protocols inorder to have communications on the Internet. IP describes how the information is addressed, routed by networking devices. An IP address is a number identifying of a computer or another device on the Internet. A simple example could be mailing address." }, { "code": null, "e": 548, "s": 428, "text": "There are 2 types of IP\n1. IPv4 : 32 bit long, Ex: 35.244.11.196\n2. IPv6 : 128 bit long, it is so much longer than IPv4" }, { "code": null, "e": 567, "s": 548, "text": "Example for IPv4 :" }, { "code": null, "e": 595, "s": 567, "text": "1. Dotted Decimal Notation " }, { "code": null, "e": 632, "s": 595, "text": "IPv4: 32 bit long ( Dotted Decimal )" }, { "code": null, "e": 656, "s": 632, "text": "2. Hexadecimal Notation" }, { "code": null, "e": 690, "s": 656, "text": "IPv4: 32 bit long ( Hexadecimal )" }, { "code": null, "e": 709, "s": 690, "text": "CLASS ADDRESSING :" }, { "code": null, "e": 798, "s": 709, "text": "So, In IPv4 addressing, there are 5 classes to range IP Values : Class A, B, C, D and E." }, { "code": null, "e": 872, "s": 798, "text": "The order of bits in the first octet determine the classes of IP address." }, { "code": null, "e": 936, "s": 872, "text": "IPv4 address is divided into two parts:1. Network ID 2. Host ID" }, { "code": null, "e": 1002, "s": 936, "text": "The class can determine the bits used for network ID and host ID." }, { "code": null, "e": 1094, "s": 1002, "text": "The number of total networks and hosts possible in that particular class can be calculated." }, { "code": null, "e": 1223, "s": 1094, "text": "Only class A, B and C are commonly used. classes D and E are reserved classes, D for multicast groups and E for future purposes." }, { "code": null, "e": 1233, "s": 1223, "text": "CLASS A :" }, { "code": null, "e": 1392, "s": 1233, "text": "IP address belonging to class A are assigned to the networks that contain a large number of hosts. Here, class A can support 16 million hosts on 127 networks." }, { "code": null, "e": 1461, "s": 1392, "text": "Here, the network ID is 8 bits long and the host ID is 24 bits long." }, { "code": null, "e": 1527, "s": 1461, "text": "IP addresses belonging to class A ranges from 1.x.x.x – 126.x.x.x" }, { "code": null, "e": 1558, "s": 1527, "text": "Default Subnet Mask: 255.x.x.x" }, { "code": null, "e": 1753, "s": 1558, "text": "Number Of Hosts and Networks:\n\nNumber of Hosts: (2^24)-2= 16,777,214 i.e 16 million hosts\nNumber of Networks: (2^7)-2=126 \nNote: Reducing 2 because, 0.0.0.0 and 127.a.b.c are different addresses" }, { "code": null, "e": 1807, "s": 1753, "text": ">> The range of class A is 1.0.0.1 to 126.255.255.254" }, { "code": null, "e": 1821, "s": 1807, "text": "Other classes" }, { "code": null, "e": 1970, "s": 1821, "text": "Class B: 128.1.0.1 to 191.255.255.254Class C: 192.0.1.1 to 223.255.254.254Class D: 244.0.0.0 to 239.255.255.255Class E: 240.0.0.0 to 254.255.255.254" }, { "code": null, "e": 1981, "s": 1970, "text": "emailten9r" }, { "code": null, "e": 1992, "s": 1981, "text": "vinayedula" }, { "code": null, "e": 1999, "s": 1992, "text": "Picked" }, { "code": null, "e": 2017, "s": 1999, "text": "Computer Networks" }, { "code": null, "e": 2025, "s": 2017, "text": "GATE CS" }, { "code": null, "e": 2043, "s": 2025, "text": "Computer Networks" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n22 Mar, 2022" }, { "code": null, "e": 303, "s": 28, "text": "UltraSPARC Architecture belongs to the SPARC (Scalable Processor Architecture) family of processors. This architecture is suitable for wide range of microcomputers and supercomputers. UltraSPARC is example of RISC (Reduced Instruction Set Computer). UltraSPARC architecture:" }, { "code": null, "e": 1611, "s": 303, "text": "Memory: Memory consists of 8 bit-bytes. Two consecutive bytes form a halfword, four bytes form a word, eight bytes form a doubleword. UltraSPARC programs operates on Virtual Address Space (264 bytes). Virtual Address Space is divided into pages and these pages are stored in the physical memory or on disk.Registers: UltraSPARC architecture include a large file of registers that have more than 100 general purpose registers. Any procedure can access only 32 registers only. The SPARC hardware uses window into registers file to manage all the operations of different procedures. Beside these register files, UltraSPARC also uses Program Counter, code register, and other control registers.Data Formats:Integers are stored as 8-, 16-, 32-, or 64-bit Binary numbers.Characters are represented using 8-bit ASCII codes.Floating points are represented using three different formats namely single-precision format, double-precision format, quad-precision format.Instruction Formats: SPARC architecture use three basic instruction formats. All the instructions are of 32-bit long and first two bits are used to identify which format is being used. Format 1- Used for Call instruction. Format 2- Used for branch instructions. Format 3- Used by all the remaining instructions like register load and store. Where," }, { "code": null, "e": 1918, "s": 1611, "text": "Memory: Memory consists of 8 bit-bytes. Two consecutive bytes form a halfword, four bytes form a word, eight bytes form a doubleword. UltraSPARC programs operates on Virtual Address Space (264 bytes). Virtual Address Space is divided into pages and these pages are stored in the physical memory or on disk." }, { "code": null, "e": 2303, "s": 1918, "text": "Registers: UltraSPARC architecture include a large file of registers that have more than 100 general purpose registers. Any procedure can access only 32 registers only. The SPARC hardware uses window into registers file to manage all the operations of different procedures. Beside these register files, UltraSPARC also uses Program Counter, code register, and other control registers." }, { "code": null, "e": 2571, "s": 2303, "text": "Data Formats:Integers are stored as 8-, 16-, 32-, or 64-bit Binary numbers.Characters are represented using 8-bit ASCII codes.Floating points are represented using three different formats namely single-precision format, double-precision format, quad-precision format." }, { "code": null, "e": 2634, "s": 2571, "text": "Integers are stored as 8-, 16-, 32-, or 64-bit Binary numbers." }, { "code": null, "e": 2686, "s": 2634, "text": "Characters are represented using 8-bit ASCII codes." }, { "code": null, "e": 2828, "s": 2686, "text": "Floating points are represented using three different formats namely single-precision format, double-precision format, quad-precision format." }, { "code": null, "e": 3179, "s": 2828, "text": "Instruction Formats: SPARC architecture use three basic instruction formats. All the instructions are of 32-bit long and first two bits are used to identify which format is being used. Format 1- Used for Call instruction. Format 2- Used for branch instructions. Format 3- Used by all the remaining instructions like register load and store. Where," }, { "code": null, "e": 3310, "s": 3179, "text": "n=Indirect mode, \ni=Immediate addressing, \nx=Index addressing, \nb=Base addressing, \np= Program counter, \ne=Exponential addressing " }, { "code": null, "e": 3401, "s": 3310, "text": "Addressing Modes: Operands in memory are addressed using one of the following three modes:" }, { "code": null, "e": 3492, "s": 3401, "text": "Addressing Modes: Operands in memory are addressed using one of the following three modes:" }, { "code": null, "e": 3738, "s": 3492, "text": "Mode Target address(TA) calculation\nPC-relative TA=(PC) + displacement\n\nRegister indirect TA=(register) + displacement\nwith displacement\n\nRegister indirect TA=(register-1) + (register-2)\nindexed" }, { "code": null, "e": 4379, "s": 3738, "text": "PC-relative is used only for branch instructions.Instruction Set: This architecture have less number of instructions as compared to CISC machines. The only instructions that access memory are load and stores. All other instructions operates on register only. Instruction execution on a SPARC system is pipelined which means while one instruction is executed next one is being fetched from memory and decoded.Input and Output: Communication between I/O devices and SPARC operation are accomplished through memory. Input and Output can be performed with the regular instruction set of the computer, and no special I/O instructions are needed." }, { "code": null, "e": 4429, "s": 4379, "text": "PC-relative is used only for branch instructions." }, { "code": null, "e": 4789, "s": 4429, "text": "Instruction Set: This architecture have less number of instructions as compared to CISC machines. The only instructions that access memory are load and stores. All other instructions operates on register only. Instruction execution on a SPARC system is pipelined which means while one instruction is executed next one is being fetched from memory and decoded." }, { "code": null, "e": 5022, "s": 4789, "text": "Input and Output: Communication between I/O devices and SPARC operation are accomplished through memory. Input and Output can be performed with the regular instruction set of the computer, and no special I/O instructions are needed." }, { "code": null, "e": 5040, "s": 5022, "text": "gulshankumarar231" }, { "code": null, "e": 5053, "s": 5040, "text": "simmytarika5" }, { "code": null, "e": 5068, "s": 5053, "text": "microprocessor" }, { "code": null, "e": 5105, "s": 5068, "text": "Computer Organization & Architecture" }, { "code": null, "e": 5120, "s": 5105, "text": "microprocessor" }, { "code": null, "e": 5218, "s": 5120, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 5267, "s": 5218, "text": "Logical and Physical Address in Operating System" }, { "code": null, "e": 5329, "s": 5267, "text": "Direct Access Media (DMA) Controller in Computer Architecture" }, { "code": null, "e": 5367, "s": 5329, "text": "Computer Organization | RISC and CISC" }, { "code": null, "e": 5462, "s": 5367, "text": "Computer Organization and Architecture | Pipelining | Set 1 (Execution, Stages and Throughput)" }, { "code": null, "e": 5510, "s": 5462, "text": "Memory Hierarchy Design and its Characteristics" }, { "code": null, "e": 5529, "s": 5510, "text": "Control Characters" }, { "code": null, "e": 5540, "s": 5529, "text": "Interrupts" }, { "code": null, "e": 5576, "s": 5540, "text": "Architecture of 8085 microprocessor" }, { "code": null, "e": 5615, "s": 5576, "text": "Programmable peripheral interface 8255" } ]

[ { "code": null, "e": 54, "s": 26, "text": "\n05 Jan, 2022" }, { "code": null, "e": 410, "s": 54, "text": "Prerequisite – Process Synchronization, Inter Process Communication To obtain such a mutual exclusion, bounded waiting, and progress there have been several algorithms implemented, one of which is Dekker’s Algorithm. To understand the algorithm let’s understand the solution to the critical section problem first. A process is generally represented as : " }, { "code": null, "e": 521, "s": 410, "text": "do {\n //entry section\n critical section\n //exit section\n remainder section\n} while (TRUE);" }, { "code": null, "e": 612, "s": 521, "text": "The solution to the critical section problem must ensure the following three conditions: " }, { "code": null, "e": 652, "s": 612, "text": "Mutual ExclusionProgressBounded Waiting" }, { "code": null, "e": 669, "s": 652, "text": "Mutual Exclusion" }, { "code": null, "e": 678, "s": 669, "text": "Progress" }, { "code": null, "e": 694, "s": 678, "text": "Bounded Waiting" }, { "code": null, "e": 1588, "s": 694, "text": "One of the solutions for ensuring above all factors is Peterson’s solution.Another one is Dekker’s Solution. Dekker’s algorithm was the first probably-correct solution to the critical section problem. It allows two threads to share a single-use resource without conflict, using only shared memory for communication. It avoids the strict alternation of a naïve turn-taking algorithm, and was one of the first mutual exclusion algorithms to be invented.Although there are many versions of Dekker’s Solution, the final or 5th version is the one that satisfies all of the above conditions and is the most efficient of them all. Note – Dekker’s Solution, mentioned here, ensures mutual exclusion between two processes only, it could be extended to more than two processes with the proper use of arrays and variables.Algorithm – It requires both an array of Boolean values and an integer variable: " }, { "code": null, "e": 2030, "s": 1588, "text": "var flag: array [0..1] of boolean;\nturn: 0..1;\nrepeat\n\n flag[i] := true;\n while flag[j] do\n if turn = j then\n begin\n flag[i] := false;\n while turn = j do no-op;\n flag[i] := true;\n end;\n\n critical section\n\n turn := j;\n flag[i] := false;\n\n remainder section\n\nuntil false;" }, { "code": null, "e": 2263, "s": 2030, "text": "First Version of Dekker’s Solution – The idea is to use a common or shared thread number between processes and stop the other process from entering its critical section if the shared thread indicates the former one already running. " }, { "code": null, "e": 2267, "s": 2263, "text": "CPP" }, { "code": null, "e": 2275, "s": 2267, "text": "Python3" }, { "code": "Main(){ int thread_number = 1; startThreads();} Thread1(){ do { // entry section // wait until threadnumber is 1 while (threadnumber == 2) ; // critical section // exit section // give access to the other thread threadnumber = 2; // remainder section } while (completed == false)} Thread2(){ do { // entry section // wait until threadnumber is 2 while (threadnumber == 1) ; // critical section // exit section // give access to the other thread threadnumber = 1; // remainder section } while (completed == false)}", "e": 2953, "s": 2275, "text": null }, { "code": "def Thread1(): doWhile=False while not completed or not doWhile: doWhile=True # entry section # wait until threadnumber is 1 while (threadnumber == 2): pass # critical section # exit section # give access to the other thread threadnumber = 2 # remainder section def Thread2(): doWhile=False while not completed or not doWhile: doWhile=True # entry section # wait until threadnumber is 2 while (threadnumber == 1): pass # critical section # exit section # give access to the other thread threadnumber = 1 # remainder section if __name__ == '__main__': thread_number = 1 startThreads()", "e": 3710, "s": 2953, "text": null }, { "code": null, "e": 4313, "s": 3710, "text": "The problem arising in the above implementation is lockstep synchronization, i.e each thread depends on the other for its execution. If one of the processes completes, then the second process runs, gives access to the completed one, and waits for its turn, however, the former process is already completed and would never run to return the access back to the latter one. Hence, the second process waits infinitely then.Second Version of Dekker’s Solution – To remove lockstep synchronization, it uses two flags to indicate its current status and updates them accordingly at the entry and exit section. " }, { "code": null, "e": 4317, "s": 4313, "text": "CPP" }, { "code": null, "e": 4325, "s": 4317, "text": "Python3" }, { "code": "Main(){ // flags to indicate if each thread is in // its critical section or not. boolean thread1 = false; boolean thread2 = false; startThreads();} Thread1(){ do { // entry section // wait until thread2 is in its critical section while (thread2 == true) ; // indicate thread1 entering its critical section thread1 = true; // critical section // exit section // indicate thread1 exiting its critical section thread1 = false; // remainder section } while (completed == false)} Thread2(){ do { // entry section // wait until thread1 is in its critical section while (thread1 == true) ; // indicate thread2 entering its critical section thread2 = true; // critical section // exit section // indicate thread2 exiting its critical section thread2 = false; // remainder section } while (completed == false)}", "e": 5333, "s": 4325, "text": null }, { "code": "def Thread1(): doWhile=False while not completed or not doWhile: doWhile=True # entry section # wait until thread2 is in its critical section while (thread2): pass # indicate thread1 entering its critical section thread1 = True # critical section # exit section # indicate thread1 exiting its critical section thread1 = False # remainder section def Thread2(): doWhile=False while not completed or not doWhile: doWhile=True # entry section # wait until thread1 is in its critical section while (thread1): pass # indicate thread1 entering its critical section thread2 = True # critical section # exit section # indicate thread2 exiting its critical section thread2 = False # remainder section if __name__ == '__main__': # flags to indicate if each thread is in # its critical section or not. thread1 = False thread2 = False startThreads()", "e": 6392, "s": 5333, "text": null }, { "code": null, "e": 6847, "s": 6392, "text": "The problem arising in the above version is mutual exclusion itself. If threads are preempted (stopped) during flag updation ( i.e during current_thread = true ) then, both the threads enter their critical section once the preempted thread is restarted, also the same can be observed at the start itself, when both the flags are false.Third Version of Dekker’s Solution – To re-ensure mutual exclusion, it sets the flags before the entry section itself. " }, { "code": null, "e": 6851, "s": 6847, "text": "C++" }, { "code": null, "e": 6859, "s": 6851, "text": "Python3" }, { "code": "Main(){ // flags to indicate if each thread is in // queue to enter its critical section boolean thread1wantstoenter = false; boolean thread2wantstoenter = false; startThreads();} Thread1(){ do { thread1wantstoenter = true; // entry section // wait until thread2 wants to enter // its critical section while (thread2wantstoenter == true) ; // critical section // exit section // indicate thread1 has completed // its critical section thread1wantstoenter = false; // remainder section } while (completed == false)} Thread2(){ do { thread2wantstoenter = true; // entry section // wait until thread1 wants to enter // its critical section while (thread1wantstoenter == true) ; // critical section // exit section // indicate thread2 has completed // its critical section thread2wantstoenter = false; // remainder section } while (completed == false)}", "e": 7926, "s": 6859, "text": null }, { "code": "if __name__=='__main__': # flags to indicate if each thread is in # queue to enter its critical section thread1wantstoenter = False thread2wantstoenter = False startThreads() def Thread1(): doWhile=False while (completed == False or not doWhile): doWhile=True thread1wantstoenter = True # entry section # wait until thread2 wants to enter # its critical section while (thread2wantstoenter == True): pass # critical section # exit section # indicate thread1 has completed # its critical section thread1wantstoenter = False # remainder section def Thread2(): doWhile=False while (completed == False or not doWhile) : doWhile=True thread2wantstoenter = True # entry section # wait until thread1 wants to enter # its critical section while (thread1wantstoenter == True): pass # critical section # exit section # indicate thread2 has completed # its critical section thread2wantstoenter = False # remainder section", "e": 9090, "s": 7926, "text": null }, { "code": null, "e": 9392, "s": 9090, "text": "The problem with this version is a deadlock possibility. Both threads could set their flag as true simultaneously and both will wait infinitely later on.Fourth Version of Dekker’s Solution – Uses small time interval to recheck the condition, eliminates deadlock, and ensures mutual exclusion as well. " }, { "code": null, "e": 9396, "s": 9392, "text": "CPP" }, { "code": null, "e": 9404, "s": 9396, "text": "Python3" }, { "code": "Main(){ // flags to indicate if each thread is in // queue to enter its critical section boolean thread1wantstoenter = false; boolean thread2wantstoenter = false; startThreads();} Thread1(){ do { thread1wantstoenter = true; while (thread2wantstoenter == true) { // gives access to other thread // wait for random amount of time thread1wantstoenter = false; thread1wantstoenter = true; } // entry section // wait until thread2 wants to enter // its critical section // critical section // exit section // indicate thread1 has completed // its critical section thread1wantstoenter = false; // remainder section } while (completed == false)} Thread2(){ do { thread2wantstoenter = true; while (thread1wantstoenter == true) { // gives access to other thread // wait for random amount of time thread2wantstoenter = false; thread2wantstoenter = true; } // entry section // wait until thread1 wants to enter // its critical section // critical section // exit section // indicate thread2 has completed // its critical section thread2wantstoenter = false; // remainder section } while (completed == false)}", "e": 10807, "s": 9404, "text": null }, { "code": "if __name__ == '__main__': # flags to indicate if each thread is in # queue to enter its critical section thread1wantstoenter = False thread2wantstoenter = False startThreads() def Thread1(): doWhile=False while (completed == False or not doWhile): doWhile=True thread1wantstoenter = True while (thread2wantstoenter == True) : # gives access to other thread # wait for random amount of time thread1wantstoenter = False thread1wantstoenter = True # entry section # wait until thread2 wants to enter # its critical section # critical section # exit section # indicate thread1 has completed # its critical section thread1wantstoenter = False # remainder section def Thread2(): doWhile=False while (completed == False or not doWhile): doWhile=True thread2wantstoenter = True while (thread1wantstoenter == True) : # gives access to other thread # wait for random amount of time thread2wantstoenter = False thread2wantstoenter = True # entry section # wait until thread1 wants to enter # its critical section # critical section # exit section # indicate thread2 has completed # its critical section thread2wantstoenter = False # remainder section", "e": 12273, "s": 10807, "text": null }, { "code": null, "e": 12797, "s": 12273, "text": "The problem with this version is the indefinite postponement. Also, a random amount of time is erratic depending upon the situation in which the algorithm is being implemented, hence not an acceptable solution in business critical systems.Dekker’s Algorithm: Final and completed Solution – -Idea is to use favoured thread notion to determine entry to the critical section. Favoured thread alternates between the thread providing mutual exclusion and avoiding deadlock, indefinite postponement, or lockstep synchronization. " }, { "code": null, "e": 12801, "s": 12797, "text": "CPP" }, { "code": null, "e": 12809, "s": 12801, "text": "Python3" }, { "code": "Main(){ // to denote which thread will enter next int favouredthread = 1; // flags to indicate if each thread is in // queue to enter its critical section boolean thread1wantstoenter = false; boolean thread2wantstoenter = false; startThreads();} Thread1(){ do { thread1wantstoenter = true; // entry section // wait until thread2 wants to enter // its critical section while (thread2wantstoenter == true) { // if 2nd thread is more favored if (favaouredthread == 2) { // gives access to other thread thread1wantstoenter = false; // wait until this thread is favored while (favouredthread == 2) ; thread1wantstoenter = true; } } // critical section // favor the 2nd thread favouredthread = 2; // exit section // indicate thread1 has completed // its critical section thread1wantstoenter = false; // remainder section } while (completed == false)} Thread2(){ do { thread2wantstoenter = true; // entry section // wait until thread1 wants to enter // its critical section while (thread1wantstoenter == true) { // if 1st thread is more favored if (favaouredthread == 1) { // gives access to other thread thread2wantstoenter = false; // wait until this thread is favored while (favouredthread == 1) ; thread2wantstoenter = true; } } // critical section // favour the 1st thread favouredthread = 1; // exit section // indicate thread2 has completed // its critical section thread2wantstoenter = false; // remainder section } while (completed == false)}", "e": 14763, "s": 12809, "text": null }, { "code": "if __name__ == '__main__': # to denote which thread will enter next favouredthread = 1 # flags to indicate if each thread is in # queue to enter its critical section thread1wantstoenter = False thread2wantstoenter = False startThreads() def Thread1(): doWhile=False while (completed == False or not doWhile) : doWhile=True thread1wantstoenter = True # entry section # wait until thread2 wants to enter # its critical section while (thread2wantstoenter == True) : # if 2nd thread is more favored if (favaouredthread == 2) : # gives access to other thread thread1wantstoenter = False # wait until this thread is favored while (favouredthread == 2): pass thread1wantstoenter = True # critical section # favor the 2nd thread favouredthread = 2 # exit section # indicate thread1 has completed # its critical section thread1wantstoenter = False # remainder section def Thread2(): doWhile=False while (completed == False or not doWhile) : doWhile=True thread2wantstoenter = True # entry section # wait until thread1 wants to enter # its critical section while (thread1wantstoenter == True) : # if 1st thread is more favored if (favaouredthread == 1) : # gives access to other thread thread2wantstoenter = False # wait until this thread is favored while (favouredthread == 1): pass thread2wantstoenter = True # critical section # favour the 1st thread favouredthread = 1 # exit section # indicate thread2 has completed # its critical section thread2wantstoenter = False # remainder section ", "e": 16828, "s": 14763, "text": null }, { "code": null, "e": 16984, "s": 16828, "text": "This version guarantees a complete solution to the critical solution problem.References – Dekker’s Algorithm -csisdmz.ul.ie Dekker’s algorithm – Wikipedia " }, { "code": null, "e": 17003, "s": 16984, "text": "surindertarika1234" }, { "code": null, "e": 17019, "s": 17003, "text": "amartyaghoshgfg" }, { "code": null, "e": 17027, "s": 17019, "text": "sarimh9" }, { "code": null, "e": 17038, "s": 17027, "text": "Algorithms" }, { "code": null, "e": 17046, "s": 17038, "text": "GATE CS" }, { "code": null, "e": 17064, "s": 17046, "text": "Operating Systems" }, { "code": null, "e": 17082, "s": 17064, "text": "Operating Systems" }, { "code": null, "e": 17093, "s": 17082, "text": "Algorithms" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n10 Jul, 2022" }, { "code": null, "e": 223, "s": 52, "text": "Given a string and a substring, write a Python program to find the nth occurrence of the string. Let’s discuss a few methods to solve the given task. Method #1: Using re " }, { "code": null, "e": 231, "s": 223, "text": "Python3" }, { "code": "# Python code to demonstrate# to find nth occurrence of substring import re # Initialising valuesini_str = \"abababababab\"substr = \"ab\"occurrence = 4 # Finding nth occurrence of substringinilist = [m.start() for m in re.finditer(r\"ab\", ini_str)]if len(inilist)>= 4: # Printing result print (\"Nth occurrence of substring at\", inilist[occurrence-1])else: print (\"No {} occurrence of substring lies in given string\".format(occurrence))", "e": 670, "s": 231, "text": null }, { "code": null, "e": 704, "s": 670, "text": " Method #2: Using find() method " }, { "code": null, "e": 712, "s": 704, "text": "Python3" }, { "code": "# Python code to demonstrate# to find nth occurrence of substring # Initialising valuesini_str = \"abababababab\"sub_str = \"ab\"occurrence = 4 # Finding nth occurrence of substringval = -1for i in range(0, occurrence): val = ini_str.find(sub_str, val + 1) # Printing nth occurrenceprint (\"Nth occurrence is at\", val)", "e": 1030, "s": 712, "text": null }, { "code": null, "e": 1086, "s": 1030, "text": " Method #3: Using startswith() and list comprehension " }, { "code": null, "e": 1094, "s": 1086, "text": "Python3" }, { "code": "# Python code to demonstrate# to find nth occurrence of substring # Initialising valuesini_str = \"abababababab\"substr = \"ab\"occurrence = 4 # Finding nth occurrence of substringinilist = [i for i in range(0, len(ini_str)) if ini_str[i:].startswith(substr)] if len(inilist)>= 4: # Printing result print (\"Nth occurrence of substring at\", inilist[occurrence-1])else: print (\"No {} occurrence of substring lies in given string\".format(occurrence)) ", "e": 1554, "s": 1094, "text": null }, { "code": null, "e": 1617, "s": 1554, "text": "The Time and Space Complexity is the same for all the methods:" }, { "code": null, "e": 1639, "s": 1617, "text": "Time Complexity: O(n)" }, { "code": null, "e": 1685, "s": 1639, "text": "Space Complexity: O(n) (length of the string)" }, { "code": null, "e": 1696, "s": 1685, "text": "nidhi_biet" }, { "code": null, "e": 1713, "s": 1696, "text": "harshmaster07705" }, { "code": null, "e": 1736, "s": 1713, "text": "Python string-programs" }, { "code": null, "e": 1743, "s": 1736, "text": "Python" }, { "code": null, "e": 1759, "s": 1743, "text": "Python Programs" } ]

[ { "code": null, "e": 1233, "s": 1187, "text": "To convert a date format, use STR_TO_DATE() −" }, { "code": null, "e": 1332, "s": 1233, "text": "mysql> create table DemoTable2010\n(\n DueDate varchar(20)\n);\nQuery OK, 0 rows affected (0.68 sec)" }, { "code": null, "e": 1388, "s": 1332, "text": "Insert some records in the table using insert command −" }, { "code": null, "e": 1688, "s": 1388, "text": "mysql> insert into DemoTable2010 values('12/10/2019 12:34:00');\nQuery OK, 1 row affected (0.13 sec)\nmysql> insert into DemoTable2010 values('12/12/2011 11:00:20');\nQuery OK, 1 row affected (0.21 sec)\nmysql> insert into DemoTable2010 values('31/01/2017 11:00:20');\nQuery OK, 1 row affected (0.23 sec)" }, { "code": null, "e": 1748, "s": 1688, "text": "Display all records from the table using select statement −" }, { "code": null, "e": 1784, "s": 1748, "text": "mysql> select * from DemoTable2010;" }, { "code": null, "e": 1825, "s": 1784, "text": "This will produce the following output −" }, { "code": null, "e": 2018, "s": 1825, "text": "+---------------------+\n| DueDate |\n+---------------------+\n| 12/10/2019 12:34:00 |\n| 12/12/2011 11:00:20 |\n| 31/01/2017 11:00:20 |\n+---------------------+\n3 rows in set (0.00 sec)" }, { "code": null, "e": 2061, "s": 2018, "text": "Here is the query to convert date format −" }, { "code": null, "e": 2133, "s": 2061, "text": "mysql> select str_to_date(DueDate,'%d/%m/%Y %k:%i') from DemoTable2010;" }, { "code": null, "e": 2174, "s": 2133, "text": "This will produce the following output −" }, { "code": null, "e": 2505, "s": 2174, "text": "+---------------------------------------+\n| str_to_date(DueDate,'%d/%m/%Y %k:%i') |\n+---------------------------------------+\n| 2019-10-12 12:34:00 |\n| 2011-12-12 11:00:00 |\n| 2017-01-31 11:00:00 |\n+---------------------------------------+\n3 rows in set, 3 warnings (0.00 sec)" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n08 Nov, 2019" }, { "code": null, "e": 157, "s": 28, "text": "yes command in linux is used to print a continuous output stream of given STRING. If STRING is not mentioned then it prints ‘y’;" }, { "code": null, "e": 165, "s": 157, "text": "Syntax:" }, { "code": null, "e": 178, "s": 165, "text": "yes [STRING]" }, { "code": null, "e": 224, "s": 178, "text": "Note: To stop printing please press Ctrl + C." }, { "code": null, "e": 253, "s": 224, "text": "Question: Where it is used ?" }, { "code": null, "e": 466, "s": 253, "text": "Ans: Lets say that we want to delete all the .txt file present in the current directory. Instead of writing rm -i *.txt and then typing y at the end for every file, what we can do is we can use yes | rm -i *.txt." }, { "code": null, "e": 475, "s": 466, "text": "Options:" }, { "code": null, "e": 517, "s": 475, "text": "yes –help : It displays help information." }, { "code": null, "e": 565, "s": 517, "text": "yes –version : It displays version information." }, { "code": null, "e": 576, "s": 565, "text": "nidhi_biet" }, { "code": null, "e": 590, "s": 576, "text": "shubham_singh" }, { "code": null, "e": 604, "s": 590, "text": "linux-command" }, { "code": null, "e": 635, "s": 604, "text": "Linux-text-processing-commands" }, { "code": null, "e": 646, "s": 635, "text": "Linux-Unix" }, { "code": null, "e": 665, "s": 646, "text": "Technical Scripter" }, { "code": null, "e": 763, "s": 665, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 800, "s": 763, "text": "nohup Command in Linux with Examples" }, { "code": null, "e": 822, "s": 800, "text": "'dd' command in Linux" }, { "code": null, "e": 875, "s": 822, "text": "Start/Stop/Restart Services Using Systemctl in Linux" }, { "code": null, "e": 911, "s": 875, "text": "How to Find Out File Types in Linux" }, { "code": null, "e": 947, "s": 911, "text": "uniq Command in LINUX with examples" }, { "code": null, "e": 981, "s": 947, "text": "mv command in Linux with examples" }, { "code": null, "e": 1017, "s": 981, "text": "Tree command in Linux with examples" }, { "code": null, "e": 1035, "s": 1017, "text": "vi Editor in UNIX" }, { "code": null, "e": 1073, "s": 1035, "text": "source command in Linux with Examples" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n08 Sep, 2021" }, { "code": null, "e": 426, "s": 28, "text": "Angular PrimeNG is an open-source framework with a rich set of native Angular UI components that are used for great styling and this framework is used to make responsive websites with very much ease. In this article, we will know how to use the ProgressSpinner component in Angular PrimeNG. We will also learn about the properties, styling along with their syntaxes that will be used in the code. " }, { "code": null, "e": 521, "s": 426, "text": "ProgressSpinner: This component is used to make a spinner that illustrates the process status." }, { "code": null, "e": 533, "s": 521, "text": "Properties:" }, { "code": null, "e": 656, "s": 533, "text": "strokeWidth: It specifies the width of the circle stroke. It accepts a string data type as input & the default Value is 2." }, { "code": null, "e": 773, "s": 656, "text": "fill: It specifies the color for the background of the circle. It is of string data type, the default value is null." }, { "code": null, "e": 895, "s": 773, "text": "animationDuration: It specifies the duration of the rotate animation. It is of string data type, the default value is 2s." }, { "code": null, "e": 904, "s": 895, "text": "Styling:" }, { "code": null, "e": 953, "s": 904, "text": "p-progress-spinner: it is the container element." }, { "code": null, "e": 1003, "s": 953, "text": "p-progress-circle: it is the SVG styling element." }, { "code": null, "e": 1054, "s": 1003, "text": "p-progress-path: It is the circle styling element." }, { "code": null, "e": 1109, "s": 1056, "text": "Creating Angular application & module installation:" }, { "code": null, "e": 1176, "s": 1109, "text": "Step 1: Create an Angular application using the following command." }, { "code": null, "e": 1191, "s": 1176, "text": "ng new appname" }, { "code": null, "e": 1289, "s": 1191, "text": "Step 2: After creating your project folder i.e. app name, move to it using the following command." }, { "code": null, "e": 1300, "s": 1289, "text": "cd appname" }, { "code": null, "e": 1349, "s": 1300, "text": "Step 3: Install PrimeNG in your given directory." }, { "code": null, "e": 1406, "s": 1349, "text": "npm install primeng --save\nnpm install primeicons --save" }, { "code": null, "e": 1487, "s": 1406, "text": "Project Structure: After complete installation, it will look like the following:" }, { "code": null, "e": 1579, "s": 1489, "text": "Example 1: This is the basic example that shows how to use the ProgressSpinner component." }, { "code": null, "e": 1598, "s": 1579, "text": "app.component.html" }, { "code": "<h2>GeeksforGeeks</h2><h5>PrimeNg ProgressSpinner Component</h5><p-progressSpinner></p-progressSpinner>", "e": 1702, "s": 1598, "text": null }, { "code": null, "e": 1716, "s": 1702, "text": "app.module.ts" }, { "code": "import { NgModule } from '@angular/core';import { BrowserModule } from '@angular/platform-browser';import { FormsModule } from '@angular/forms';import { BrowserAnimationsModule } from '@angular/platform-browser/animations'; import { AppComponent } from './app.component';import { ProgressSpinnerModule } from 'primeng/progressspinner'; @NgModule({ imports: [ BrowserModule, BrowserAnimationsModule, ProgressSpinnerModule, FormsModule ], declarations: [AppComponent], bootstrap: [AppComponent]})export class AppModule {}", "e": 2262, "s": 1716, "text": null }, { "code": null, "e": 2279, "s": 2262, "text": "app.component.ts" }, { "code": "import { Component } from '@angular/core'; @Component({ selector: 'my-app', templateUrl: './app.component.html'})export class AppComponent {}", "e": 2424, "s": 2279, "text": null }, { "code": null, "e": 2432, "s": 2424, "text": "Output:" }, { "code": null, "e": 2557, "s": 2432, "text": "Example 2: In this example, we will use strokeWidth, fill and animationduration properties in the progressSpinner Component." }, { "code": null, "e": 2576, "s": 2557, "text": "app.component.html" }, { "code": "<h2>GeeksforGeeks</h2><h5>PrimeNG ProgressSpinner Component</h5><p-progressSpinner strokeWidth=\"5\" fill=\"#03fc24\" animationDuration=\"1s\"></p-progressSpinner>", "e": 2753, "s": 2576, "text": null }, { "code": null, "e": 2767, "s": 2753, "text": "app.module.ts" }, { "code": "import { NgModule } from '@angular/core';import { BrowserModule } from '@angular/platform-browser';import { FormsModule } from '@angular/forms';import { BrowserAnimationsModule } from '@angular/platform-browser/animations'; import { AppComponent } from './app.component';import { ProgressSpinnerModule } from 'primeng/progressspinner'; @NgModule({ imports: [ BrowserModule, BrowserAnimationsModule, ProgressSpinnerModule, FormsModule ], declarations: [AppComponent], bootstrap: [AppComponent]})export class AppModule {}", "e": 3309, "s": 2767, "text": null }, { "code": null, "e": 3326, "s": 3309, "text": "app.component.ts" }, { "code": "import { Component } from '@angular/core'; @Component({ selector: 'my-app', templateUrl: './app.component.html'})export class AppComponent {}", "e": 3471, "s": 3326, "text": null }, { "code": null, "e": 3480, "s": 3471, "text": "Output: " }, { "code": null, "e": 3549, "s": 3480, "text": "Reference: https://primefaces.org/primeng/showcase/#/progressspinner" }, { "code": null, "e": 3565, "s": 3549, "text": "Angular-PrimeNG" }, { "code": null, "e": 3575, "s": 3565, "text": "AngularJS" }, { "code": null, "e": 3592, "s": 3575, "text": "Web Technologies" }, { "code": null, "e": 3690, "s": 3592, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 3714, "s": 3690, "text": "Routing in Angular 9/10" }, { "code": null, "e": 3749, "s": 3714, "text": "Angular PrimeNG Dropdown Component" }, { "code": null, "e": 3773, "s": 3749, "text": "Angular 10 (blur) Event" }, { "code": null, "e": 3826, "s": 3773, "text": "How to make a Bootstrap Modal Popup in Angular 9/8 ?" }, { "code": null, "e": 3875, "s": 3826, "text": "How to create module with Routing in Angular 9 ?" }, { "code": null, "e": 3908, "s": 3875, "text": "Installation of Node.js on Linux" }, { "code": null, "e": 3970, "s": 3908, "text": "Top 10 Projects For Beginners To Practice HTML and CSS Skills" }, { "code": null, "e": 4031, "s": 3970, "text": "Difference between var, let and const keywords in JavaScript" }, { "code": null, "e": 4081, "s": 4031, "text": "How to insert spaces/tabs in text using HTML/CSS?" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n12 Sep, 2018" }, { "code": null, "e": 230, "s": 52, "text": "In C, variables are always statically (or lexically) scoped i.e., binding of a variable can be determined by program text and is independent of the run-time function call stack." }, { "code": null, "e": 400, "s": 230, "text": "For example, output for the below program is 0, i.e., the value returned by f() is not dependent on who is calling it. f() always returns the value of global variable x." }, { "code": "# include <stdio.h> int x = 0;int f(){ return x;}int g(){ int x = 1; return f();}int main(){ printf(\"%d\", g()); printf(\"\\n\"); getchar();}", "e": 548, "s": 400, "text": null }, { "code": null, "e": 612, "s": 548, "text": "References:http://en.wikipedia.org/wiki/Scope_%28programming%29" }, { "code": null, "e": 625, "s": 612, "text": "InathiSirayi" }, { "code": null, "e": 658, "s": 625, "text": "C-Variable Declaration and Scope" }, { "code": null, "e": 669, "s": 658, "text": "C Language" }, { "code": null, "e": 676, "s": 669, "text": "GFacts" }, { "code": null, "e": 774, "s": 676, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 791, "s": 774, "text": "Substring in C++" }, { "code": null, "e": 813, "s": 791, "text": "Function Pointer in C" }, { "code": null, "e": 858, "s": 813, "text": "Different Methods to Reverse a String in C++" }, { "code": null, "e": 883, "s": 858, "text": "std::string class in C++" }, { "code": null, "e": 931, "s": 883, "text": "Unordered Sets in C++ Standard Template Library" }, { "code": null, "e": 978, "s": 931, "text": "Return values of printf() and scanf() in C/C++" }, { "code": null, "e": 1046, "s": 978, "text": "What are the Operators that Can be and Cannot be Overloaded in C++?" }, { "code": null, "e": 1103, "s": 1046, "text": "G-Fact 19 (Logical and Bitwise Not Operators on Boolean)" }, { "code": null, "e": 1135, "s": 1103, "text": "Difference between YOLO and SSD" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n25 Nov, 2021" }, { "code": null, "e": 254, "s": 28, "text": "The Window innerHeight property is used for returning the height of a window’s content area. It is a read-only property and returns a number which represents the height of the browser window’s content area in pixels.Syntax: " }, { "code": null, "e": 273, "s": 254, "text": "window.innerHeight" }, { "code": null, "e": 371, "s": 273, "text": "Return Value: It returns a number that represents browser window’s content area height in pixels." }, { "code": null, "e": 468, "s": 371, "text": "Below program illustrates the Window innerheight Property:Returning the current frame’s height. " }, { "code": null, "e": 473, "s": 468, "text": "html" }, { "code": "<!DOCTYPE html><html><head> <title> Window innerHeight Property in HTML </title> <style> h1 { color: green; } h2 { font-family: Impact; } body { text-align: center; } </style></head> <body> <h1>GeeksforGeeks</h1> <h2>Window innerHeight Property</h2> <p>For returning the current frame's height, double click the \"Check Height\" button: </p> <button ondblclick=\"height()\">Check Height</button> <p id=\"measure\"></p> <script> function height() { var h = window.innerHeight; document.getElementById(\"measure\").innerHTML = \"Frame's Height: \" + h; } </script> </body> </html> ", "e": 1261, "s": 473, "text": null }, { "code": null, "e": 1271, "s": 1261, "text": "Output: " }, { "code": null, "e": 1299, "s": 1271, "text": "After clicking the button " }, { "code": null, "e": 1392, "s": 1299, "text": "Supported Browsers: The browser supported by Window innerHeight Property are listed below: " }, { "code": null, "e": 1406, "s": 1392, "text": "Google Chrome" }, { "code": null, "e": 1424, "s": 1406, "text": "Internet Explorer" }, { "code": null, "e": 1432, "s": 1424, "text": "Firefox" }, { "code": null, "e": 1438, "s": 1432, "text": "Opera" }, { "code": null, "e": 1445, "s": 1438, "text": "Safari" }, { "code": null, "e": 1461, "s": 1447, "text": "ManasChhabra2" }, { "code": null, "e": 1475, "s": 1461, "text": "HTML-Property" }, { "code": null, "e": 1480, "s": 1475, "text": "HTML" }, { "code": null, "e": 1497, "s": 1480, "text": "Web Technologies" }, { "code": null, "e": 1502, "s": 1497, "text": "HTML" }, { "code": null, "e": 1600, "s": 1502, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 1648, "s": 1600, "text": "How to update Node.js and NPM to next version ?" }, { "code": null, "e": 1672, "s": 1648, "text": "REST API (Introduction)" }, { "code": null, "e": 1722, "s": 1672, "text": "CSS to put icon inside an input element in a form" }, { "code": null, "e": 1759, "s": 1722, "text": "Types of CSS (Cascading Style Sheet)" }, { "code": null, "e": 1787, "s": 1759, "text": "HTTP headers | Content-Type" }, { "code": null, "e": 1820, "s": 1787, "text": "Installation of Node.js on Linux" }, { "code": null, "e": 1881, "s": 1820, "text": "Difference between var, let and const keywords in JavaScript" }, { "code": null, "e": 1924, "s": 1881, "text": "How to fetch data from an API in ReactJS ?" }, { "code": null, "e": 1996, "s": 1924, "text": "Differences between Functional Components and Class Components in React" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n26 Apr, 2021" }, { "code": null, "e": 260, "s": 52, "text": "I was contacted by a recruiter through Linkedin. At that time I had just started in an XYZ firm as a software engineer. I had forwarded my resume, after 2 months I got a call from HR to have an online round." }, { "code": null, "e": 436, "s": 260, "text": "Coding Round: 2 coding questions on HackerRank to be solved in 2 hours. Both the questions are very easy, and I was able to solve both of them completely in a very short time." }, { "code": null, "e": 503, "s": 436, "text": "Run Length EncodingMinimum Initial Energy Required To Cross Street" }, { "code": null, "e": 523, "s": 503, "text": "Run Length Encoding" }, { "code": null, "e": 571, "s": 523, "text": "Minimum Initial Energy Required To Cross Street" }, { "code": null, "e": 635, "s": 571, "text": "After a week, I got a call from HR to schedule a Coderpad round" }, { "code": null, "e": 1020, "s": 635, "text": "CoderPad Round (1 hour): In this round, the interviewer will be on a call with you and you have to write the code in the coderpad(an online code editor) which is visible to the interviewer as well. The interviewer will type the question on coderpad and you have to write the code and it will be tested on multiple cases. Two questions were asked, and I was able to solve both of them." }, { "code": null, "e": 1172, "s": 1020, "text": "Given an array scores [][] = {“jerry”,”65”},{“bob”,”91”}, {“jerry”,”23”}, {“Eric”,”83”}} Find the student with highest average scoreTrapping Rain Water" }, { "code": null, "e": 1305, "s": 1172, "text": "Given an array scores [][] = {“jerry”,”65”},{“bob”,”91”}, {“jerry”,”23”}, {“Eric”,”83”}} Find the student with highest average score" }, { "code": null, "e": 1325, "s": 1305, "text": "Trapping Rain Water" }, { "code": null, "e": 1408, "s": 1325, "text": "Round 1 (Zoom Interview-1 hour): There were 3 questions asked by two interviewers." }, { "code": null, "e": 2382, "s": 1408, "text": "This was an adhoc type of problem. They only ask about my thought approach, no code is required. Given a stream of packets, in one second you can process only 10 packets. But more than 10 packets may arrive in a second. Suggest a proper DS/Algorithm to manage this scenario. Well, I was not sure of the solution, I suggested a queue and two pointer-based approaches. but he didn’t seem quite satisfied. He seems to be more concerned about some other approach. Then he jumped to the next question.Smallest subarray with sum greater than a given value. I was able to solve this problem. This is a famous question that is often asked in their interviews. I gave both brute-force and optimized approach and wrote the code.https://leetcode.com/problems/bus-routes/Initially, I suggested a connected component approach that was wrong, Then I suggested a DFS based approach once he told me an example test case. He didn’t ask to code as it was almost the time and seem satisfied." }, { "code": null, "e": 2879, "s": 2382, "text": "This was an adhoc type of problem. They only ask about my thought approach, no code is required. Given a stream of packets, in one second you can process only 10 packets. But more than 10 packets may arrive in a second. Suggest a proper DS/Algorithm to manage this scenario. Well, I was not sure of the solution, I suggested a queue and two pointer-based approaches. but he didn’t seem quite satisfied. He seems to be more concerned about some other approach. Then he jumped to the next question." }, { "code": null, "e": 3102, "s": 2879, "text": "Smallest subarray with sum greater than a given value. I was able to solve this problem. This is a famous question that is often asked in their interviews. I gave both brute-force and optimized approach and wrote the code." }, { "code": null, "e": 3358, "s": 3102, "text": "https://leetcode.com/problems/bus-routes/Initially, I suggested a connected component approach that was wrong, Then I suggested a DFS based approach once he told me an example test case. He didn’t ask to code as it was almost the time and seem satisfied." }, { "code": null, "e": 3464, "s": 3358, "text": "Round 2 (Zoom Interview-1 hour): There were 3 questions asked by two interviewers. Again on the same day." }, { "code": null, "e": 3601, "s": 3464, "text": "Implement rand3() using rand2(). Honestly, I have never seen this type of problem. My question is little different. Given 3 functions. " }, { "code": null, "e": 3738, "s": 3601, "text": "Implement rand3() using rand2(). Honestly, I have never seen this type of problem. My question is little different. Given 3 functions. " }, { "code": null, "e": 3969, "s": 3740, "text": "def rand2(){\n return 1 with 0.5 probability\n otherwise return 0\n}\ndef rand3(){\n return 1 with 0.33 probability\n otherwise return 0\n}\ndef rand4(){\n return 1 with 0.25 probability\n otherwise return 0\n}" }, { "code": null, "e": 5027, "s": 3969, "text": "You need to convert rand2() to rand3() and rand2() to rand4(). I think this is some bit manipulation question and told the answer using bitwise and to convert rand2() to rand4(). He said okay then says use a similar method to convert rand2() to rand3(). I was not able to pick it up for a few minutes, then he jumped to the next question.Find the minimum path from the given source and destination and also find all such paths. We are allowed to move in all 8 directions and the cost from moving one cell to its adjacent other is one. I told a BFS based approach to get the minimum path and again applying BFS to get all such paths. He didn’t ask code and seemed satisfied.https://leetcode.com/problems/last-stone-weight-ii/Well, I know the easy version of it but didn’t know about the medium version of this question. I solved using the priority queue approach, but he made a test case where this logic fails. I was thinking about some other approaches but can’t figure out that this is a DP problem. After seeing me struggling he concluded the interview." }, { "code": null, "e": 5367, "s": 5027, "text": "You need to convert rand2() to rand3() and rand2() to rand4(). I think this is some bit manipulation question and told the answer using bitwise and to convert rand2() to rand4(). He said okay then says use a similar method to convert rand2() to rand3(). I was not able to pick it up for a few minutes, then he jumped to the next question." }, { "code": null, "e": 5703, "s": 5367, "text": "Find the minimum path from the given source and destination and also find all such paths. We are allowed to move in all 8 directions and the cost from moving one cell to its adjacent other is one. I told a BFS based approach to get the minimum path and again applying BFS to get all such paths. He didn’t ask code and seemed satisfied." }, { "code": null, "e": 6087, "s": 5703, "text": "https://leetcode.com/problems/last-stone-weight-ii/Well, I know the easy version of it but didn’t know about the medium version of this question. I solved using the priority queue approach, but he made a test case where this logic fails. I was thinking about some other approaches but can’t figure out that this is a DP problem. After seeing me struggling he concluded the interview." }, { "code": null, "e": 6489, "s": 6087, "text": "I guess this is it me. Few things which I notice during the interview. First, they ask a lot of previously asked questions, so be ready for that. Second, they didn’t ask a very tough question, GFG and Leetcode are enough. Third, Have a good grasp of probability and puzzles. Fourth, try to be very interactive, even if you don’t think of an approach, communicate whatever you think to the interviewer." }, { "code": null, "e": 6522, "s": 6489, "text": "Hope this helps, All the best..." }, { "code": null, "e": 6536, "s": 6522, "text": "Goldman Sachs" }, { "code": null, "e": 6546, "s": 6536, "text": "Marketing" }, { "code": null, "e": 6557, "s": 6546, "text": "Off-Campus" }, { "code": null, "e": 6579, "s": 6557, "text": "Interview Experiences" }, { "code": null, "e": 6593, "s": 6579, "text": "Goldman Sachs" } ]

[ { "code": null, "e": 2419, "s": 2260, "text": "Using Mapstruct we can pass a computed value using defaultExpression in case source property is null using defaultExpression attribute of @Mapping annotation." }, { "code": null, "e": 2526, "s": 2419, "text": "@Mapping(target = \"target-property\", source=\"source-property\" defaultExpression = \"default-value-method\")\n" }, { "code": null, "e": 2531, "s": 2526, "text": "Here" }, { "code": null, "e": 2649, "s": 2531, "text": "default-value-method − target-property will be set as result of default-value-method in case source-property is null." }, { "code": null, "e": 2767, "s": 2649, "text": "default-value-method − target-property will be set as result of default-value-method in case source-property is null." }, { "code": null, "e": 2808, "s": 2767, "text": "Following example demonstrates the same." }, { "code": null, "e": 2890, "s": 2808, "text": "Open project mapping as updated in Mapping Using defaultValue chapter in Eclipse." }, { "code": null, "e": 2934, "s": 2890, "text": "Update CarEntity.java with following code −" }, { "code": null, "e": 2949, "s": 2934, "text": "CarEntity.java" }, { "code": null, "e": 3732, "s": 2949, "text": "package com.tutorialspoint.entity;\nimport java.util.GregorianCalendar;\n\npublic class CarEntity {\n private int id;\n private double price;\n private GregorianCalendar manufacturingDate;\n private String name;\n public int getId() {\n return id;\n }\n public void setId(int id) {\n this.id = id;\n }\n public double getPrice() {\n return price;\n }\n public void setPrice(double price) {\n this.price = price;\n }\n public GregorianCalendar getManufacturingDate() {\n return manufacturingDate;\n }\n public void setManufacturingDate(GregorianCalendar manufacturingDate) {\n this.manufacturingDate = manufacturingDate;\n }\n public String getName() {\n return name;\n }\n public void setName(String name) {\n this.name = name;\n }\n}" }, { "code": null, "e": 3770, "s": 3732, "text": "Update Car.java with following code −" }, { "code": null, "e": 3779, "s": 3770, "text": "Car.java" }, { "code": null, "e": 4636, "s": 3779, "text": "package com.tutorialspoint.model;\npublic class Car {\n private int id;\n private String price;\n private String manufacturingDate;\n private String brand;\n private String name;\n public int getId() {\n return id;\n }\n public void setId(int id) {\n this.id = id;\n }\n public String getPrice() {\n return price;\n }\n public void setPrice(String price) {\n this.price = price;\n }\n public String getManufacturingDate() {\n return manufacturingDate;\n }\n public void setManufacturingDate(String manufacturingDate) {\n this.manufacturingDate = manufacturingDate;\n }\n public String getBrand() {\n return brand;\n }\n public void setBrand(String brand) {\n this.brand = brand;\n }\n public String getName() {\n return name;\n }\n public void setName(String name) {\n this.name = name;\n }\n}" }, { "code": null, "e": 4680, "s": 4636, "text": "Update CarMapper.java with following code −" }, { "code": null, "e": 4695, "s": 4680, "text": "CarMapper.java" }, { "code": null, "e": 5329, "s": 4695, "text": "package com.tutorialspoint.mapper;\n\nimport org.mapstruct.Mapper;\nimport org.mapstruct.Mapping;\nimport com.tutorialspoint.entity.CarEntity;\nimport com.tutorialspoint.model.Car;\nimport java.util.UUID;\n\n@Mapper( imports = UUID.class )\npublic interface CarMapper {\n @Mapping(source = \"name\", target = \"name\", defaultExpression = \"java(UUID.randomUUID().toString())\")\n @Mapping(target = \"brand\", constant = \"BMW\")\n @Mapping(source = \"price\", target = \"price\", numberFormat = \"$#.00\")\n @Mapping(source = \"manufacturingDate\", target = \"manufacturingDate\", dateFormat = \"dd.MM.yyyy\")\n Car getModelFromEntity(CarEntity carEntity);\n}" }, { "code": null, "e": 5377, "s": 5329, "text": "Update CarMapperTest.java with following code −" }, { "code": null, "e": 5396, "s": 5377, "text": "CarMapperTest.java" }, { "code": null, "e": 6413, "s": 5396, "text": "package com.tutorialspoint.mapping;\n\nimport static org.junit.jupiter.api.Assertions.assertEquals;\nimport static org.junit.jupiter.api.Assertions.assertNotNull;\nimport java.util.GregorianCalendar;\nimport org.junit.jupiter.api.Test;\nimport org.mapstruct.factory.Mappers;\nimport com.tutorialspoint.entity.CarEntity;\nimport com.tutorialspoint.mapper.CarMapper;\nimport com.tutorialspoint.model.Car;\n\npublic class CarMapperTest {\n private CarMapper carMapper=Mappers.getMapper(CarMapper.class);\n\n @Test\n public void testEntityToModel() {\n CarEntity entity = new CarEntity();\n entity.setPrice(345000);\n entity.setId(1);\n entity.setManufacturingDate(new GregorianCalendar(2015, 3, 5));\n Car model = carMapper.getModelFromEntity(entity);\n assertEquals(model.getPrice(), \"$345000.00\");\n assertEquals(entity.getId(), model.getId());\n assertEquals(\"05.04.2015\", model.getManufacturingDate());\n assertNotNull(model.getName());\n assertEquals(\"BMW\", model.getBrand());\n }\n}" }, { "code": null, "e": 6461, "s": 6413, "text": "Run the following command to test the mappings." }, { "code": null, "e": 6477, "s": 6461, "text": "mvn clean test\n" }, { "code": null, "e": 6524, "s": 6477, "text": "Once command is successful. Verify the output." }, { "code": null, "e": 7291, "s": 6524, "text": "mvn clean test\n[INFO] Scanning for projects...\n...\n[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ mapping ---\n[INFO] Surefire report directory: \\mvn\\mapping\\target\\surefire-reports\n\n-------------------------------------------------------\n T E S T S\n-------------------------------------------------------\nRunning com.tutorialspoint.mapping.CarMapperTest\nTests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.035 sec\nRunning com.tutorialspoint.mapping.DeliveryAddressMapperTest\nTests run: 1, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0 sec\nRunning com.tutorialspoint.mapping.StudentMapperTest\nTests run: 2, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.001 sec\n\nResults :\n\nTests run: 4, Failures: 0, Errors: 0, Skipped: 0\n...\n" }, { "code": null, "e": 7298, "s": 7291, "text": " Print" }, { "code": null, "e": 7309, "s": 7298, "text": " Add Notes" } ]

[ { "code": null, "e": 1192, "s": 1062, "text": "MongoDB supports the BSON format data, so there is no max length of field name. Let us first create a collection with documents −" }, { "code": null, "e": 2388, "s": 1192, "text": ">db.maxLengthDemo.insertOne({\"maxLengthhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\":\"This is demo\"});\n{\n \"acknowledged\" : true,\n \"insertedId\" : ObjectId(\"5ce97ac978f00858fb12e926\")\n}" }, { "code": null, "e": 2487, "s": 2388, "text": "Following is the query to display all documents from a collection with the help of find() method −" }, { "code": null, "e": 2514, "s": 2487, "text": "> db.maxLengthDemo.find();" }, { "code": null, "e": 2554, "s": 2514, "text": "This will produce the following output." }, { "code": null, "e": 3684, "s": 2554, "text": "{ \"_id\" : ObjectId(\"5ce97ac978f00858fb12e926\"), \"maxLengthhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\nhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhhh\" : \"This is demo\" }" } ]

[ { "code": null, "e": 24075, "s": 24047, "text": "\n09 Oct, 2017" }, { "code": null, "e": 24124, "s": 24075, "text": "RAID configurations of disks are used to provide" }, { "code": null, "e": 24309, "s": 24124, "text": "(A) Fault-tolerance(B) High speed(C) High data density(D) None of the aboveAnswer: (A)Explanation:Quiz of this QuestionPlease comment below if you find anything wrong in the above post" }, { "code": null, "e": 24322, "s": 24309, "text": "GATE CS 1999" }, { "code": null, "e": 24340, "s": 24322, "text": "GATE-GATE CS 1999" }, { "code": null, "e": 24345, "s": 24340, "text": "GATE" }, { "code": null, "e": 24443, "s": 24345, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 24452, "s": 24443, "text": "Comments" }, { "code": null, "e": 24465, "s": 24452, "text": "Old Comments" }, { "code": null, "e": 24507, "s": 24465, "text": "GATE | GATE-CS-2014-(Set-1) | Question 30" }, { "code": null, "e": 24549, "s": 24507, "text": "GATE | GATE-CS-2015 (Set 1) | Question 65" }, { "code": null, "e": 24583, "s": 24549, "text": "GATE | GATE CS 2010 | Question 45" }, { "code": null, "e": 24625, "s": 24583, "text": "GATE | GATE-CS-2015 (Set 3) | Question 65" }, { "code": null, "e": 24679, "s": 24625, "text": "C++ Program to count Vowels in a string using Pointer" }, { "code": null, "e": 24712, "s": 24679, "text": "GATE | GATE-CS-2004 | Question 3" }, { "code": null, "e": 24754, "s": 24712, "text": "GATE | GATE-CS-2015 (Set 1) | Question 42" }, { "code": null, "e": 24796, "s": 24754, "text": "GATE | GATE-CS-2014-(Set-3) | Question 65" }, { "code": null, "e": 24830, "s": 24796, "text": "GATE | GATE CS 2011 | Question 65" } ]

[ { "code": null, "e": 471, "s": 171, "text": "Note from Towards Data Science’s editors: While we allow independent authors to publish articles in accordance with our rules and guidelines, we do not endorse each author’s contribution. You should not rely on an author’s works without seeking professional advice. See our Reader Terms for details." }, { "code": null, "e": 811, "s": 471, "text": "Support and resistance are some of the most talked-about concepts when it comes to technical analysis. Support and resistance are used as price barriers, in which the price “bounces” off of. In this article, I will use the K-means clustering algorithm to find these different support and resistance channels, and trade with these insights." }, { "code": null, "e": 922, "s": 811, "text": "To understand how best to implement something, we should first understand the thing that we want to implement." }, { "code": null, "e": 1040, "s": 922, "text": "Support and Resistance, are two lines that are drawn on a graph, to form a channel, in which the price exists within." }, { "code": null, "e": 1318, "s": 1040, "text": "Support and resistance are resultant of a security not being able to decrease or increase anymore, due to pressure from sellers or buyers. A good rule of thumb is that the more times a price is deflected against a support or resistance line, the less likely it will work again." }, { "code": null, "e": 1511, "s": 1318, "text": "Support and resistance give good insight into entry points and selling points, as the support and resistance lines are theoretically the lowest and highest points for that limited time period." }, { "code": null, "e": 1679, "s": 1511, "text": "Downsides of the support and resistance strategy is that it works for an unknown period of time, and the lines are subjective and are therefore subject to human error." }, { "code": null, "e": 1959, "s": 1679, "text": "The K-means clustering algorithm, finds different sections of the time series data, and groups them into a defined number of groups. This number (K) can be optimized. The highest and lowest value of each group is then defined as the support and resistance values for the cluster." }, { "code": null, "e": 2041, "s": 1959, "text": "Now that we know how the program is intended, let’s try to recreate it in Python!" }, { "code": null, "e": 2134, "s": 2041, "text": "import yfinancedf = yfinance.download('AAPL','2013-1-1','2020-1-1')X = np.array(df['Close'])" }, { "code": null, "e": 2283, "s": 2134, "text": "This script is to access data for the Apple stock price. For this example, we are implementing the support and resistance only on the closing price." }, { "code": null, "e": 2689, "s": 2283, "text": "from sklearn.cluster import KMeansimport numpy as npfrom kneed import DataGenerator, KneeLocator sum_of_squared_distances = []K = range(1,15)for k in K: km = KMeans(n_clusters=k) km = km.fit(X.reshape(-1,1)) sum_of_squared_distances.append(km.inertia_)kn = KneeLocator(K, sum_of_squared_distances,S=1.0, curve=\"convex\", direction=\"decreasing\")kn.plot_knee()# plt.plot(sum_of_squared_distances)" }, { "code": null, "e": 2762, "s": 2689, "text": "This script is to test the different values of K to find the best value:" }, { "code": null, "e": 2860, "s": 2762, "text": "The K-value of 2 creates support and resistance lines that will never be reached for a long time." }, { "code": null, "e": 2973, "s": 2860, "text": "A K-value of 9 creates support and resistance that are far too common and make it difficult to make predictions." }, { "code": null, "e": 3163, "s": 2973, "text": "Therefore, we have to find the best value of K, calculated by the elbow point when comparing variance between K values. The elbow point is the biggest improvement, given a certain movement." }, { "code": null, "e": 3258, "s": 3163, "text": "Based on the kneed library, the elbow point is at 4. This means that the optimum K value is 4." }, { "code": null, "e": 3594, "s": 3258, "text": "kmeans = KMeans(n_clusters= kn.knee).fit(X.reshape(-1,1))c = kmeans.predict(X.reshape(-1,1))minmax = []for i in range(kn.knee): minmax.append([-np.inf,np.inf])for i in range(len(X)): cluster = c[i] if X[i] > minmax[cluster][0]: minmax[cluster][0] = X[i] if X[i] < minmax[cluster][1]: minmax[cluster][1] = X[i]" }, { "code": null, "e": 3748, "s": 3594, "text": "This script finds the minimum and maximum value for the points that reside in each cluster. These, when plotted, become the support and resistance lines." }, { "code": null, "e": 4115, "s": 3748, "text": "from matplotlib import pyplot as pltfor i in range(len(X)): colors = ['b','g','r','c','m','y','k','w'] c = kmeans.predict(X[i].reshape(-1,1))[0] color = colors[c] plt.scatter(i,X[i],c = color,s = 1)for i in range(len(minmax)): plt.hlines(minmax[i][0],xmin = 0,xmax = len(X),colors = 'g') plt.hlines(minmax[i][1],xmin = 0,xmax = len(X),colors = 'r')" }, { "code": null, "e": 4378, "s": 4115, "text": "This script plots the support and resistance, along with the actual graph of the prices, which are color coded based on the cluster. Unfortunately, I think that the colors are limited, meaning that there is a limited K value in which the data can be color coded." }, { "code": null, "e": 4691, "s": 4378, "text": "This is the result of the program, a set of support and resistance lines. Keep in mind that the lines are most accurate, when the values fall back into the channel. Additionally, the final resistance line would be the least accurate ,as it takes the last value into account, without considering any other values." } ]

[ { "code": null, "e": 54, "s": 0, "text": "CSS is the language we use to style an HTML document." }, { "code": null, "e": 107, "s": 54, "text": "CSS describes how HTML elements should be displayed." }, { "code": null, "e": 164, "s": 107, "text": "This tutorial will teach you CSS from basic to advanced." }, { "code": null, "e": 217, "s": 164, "text": "This CSS tutorial contains hundreds of CSS examples." }, { "code": null, "e": 305, "s": 217, "text": "With our online editor, you can edit the CSS, and click on a button to view the result." }, { "code": null, "e": 364, "s": 305, "text": "Click on the \"Try it Yourself\" button to see how it works." }, { "code": null, "e": 475, "s": 364, "text": "Learn from over 300 examples! With our editor, you can edit the CSS, and click on a\nbutton to view the result." }, { "code": null, "e": 495, "s": 475, "text": "Go to CSS Examples!" }, { "code": null, "e": 567, "s": 495, "text": "We recommend reading this tutorial, in the sequence listed in the menu." }, { "code": null, "e": 640, "s": 567, "text": "If you have a large screen, the menu will always be present on the left." }, { "code": null, "e": 715, "s": 640, "text": "If you have a small screen, open the menu by clicking the top menu sign ☰." }, { "code": null, "e": 780, "s": 715, "text": "We have created some responsive W3.CSS templates for you to use." }, { "code": null, "e": 852, "s": 780, "text": "You are free to modify, save, share, and use them in all your projects." }, { "code": null, "e": 872, "s": 852, "text": "Free CSS Templates!" }, { "code": null, "e": 914, "s": 872, "text": "Set the color of all <p> elements to red." }, { "code": null, "e": 945, "s": 914, "text": "<style>\n {\n red;\n}\n</style>\n" }, { "code": null, "e": 964, "s": 945, "text": "Start the Exercise" }, { "code": null, "e": 998, "s": 964, "text": "Test your CSS skills with a quiz." }, { "code": null, "e": 1014, "s": 998, "text": "Start CSS Quiz!" }, { "code": null, "e": 1147, "s": 1014, "text": "At W3Schools you will find complete CSS references of all properties and selectors with syntax, examples, browser support, and more." }, { "code": null, "e": 1190, "s": 1147, "text": "Get certified by completing the CSS course" }, { "code": null, "e": 1223, "s": 1190, "text": "We just launchedW3Schools videos" }, { "code": null, "e": 1265, "s": 1223, "text": "Get certifiedby completinga course today!" }, { "code": null, "e": 1372, "s": 1265, "text": "If you want to report an error, or if you want to make a suggestion, do not hesitate to send us an e-mail:" }, { "code": null, "e": 1391, "s": 1372, "text": "[email protected]" } ]

[ { "code": null, "e": 240, "s": 172, "text": "Data cleaning is one of the most important aspects of data science." }, { "code": null, "e": 323, "s": 240, "text": "As a data scientist, you can expect to spend up to 80% of your time cleaning data." }, { "code": null, "e": 428, "s": 323, "text": "In a previous post I walked through a number of data cleaning tasks using Python and the Pandas library." }, { "code": null, "e": 508, "s": 428, "text": "That post got so much attention, I wanted to follow it up with an example in R." }, { "code": null, "e": 618, "s": 508, "text": "In this post you’ll learn how to detect missing values using the tidyr and dplyr packages from the Tidyverse." }, { "code": null, "e": 726, "s": 618, "text": "The Tidyverse is the best collection of R packages for data science, so you should become familiar with it." }, { "code": null, "e": 802, "s": 726, "text": "A good way to start any data science project is to get a feel for the data." }, { "code": null, "e": 937, "s": 802, "text": "This is just a quick look to see the variable names and expected variable types. Looking at the dimensions of the data is also useful." }, { "code": null, "e": 1072, "s": 937, "text": "Exploratory data analysis (EDA) is extremely important, so it deserves its own blog post. We won’t go over a full EDA in this article." }, { "code": null, "e": 1236, "s": 1072, "text": "Before we get started, head on over to our github page to grab a copy of the data. Make sure to put a copy in the same working directory where your R code will be." }, { "code": null, "e": 1269, "s": 1236, "text": "Here’s a quick look at our data:" }, { "code": null, "e": 1309, "s": 1269, "text": "This is a small customer churn dataset." }, { "code": null, "e": 1404, "s": 1309, "text": "For purposes of learning, this dataset shows some great real-world examples of missing values." }, { "code": null, "e": 1466, "s": 1404, "text": "To start, load the tidverse library and read in the csv file." }, { "code": null, "e": 1638, "s": 1466, "text": "library(tidyverse)# set working directorypath_loc <- \"C:/Users/Jonathan/Desktop/data cleaning with R post\"setwd(path_loc)# reading in the datadf <- read_csv(\"telecom.csv\")" }, { "code": null, "e": 1723, "s": 1638, "text": "Usually the data is read in to a dataframe, but the tidyverse actually uses tibbles." }, { "code": null, "e": 1862, "s": 1723, "text": "These are similar to dataframes, but also slightly different. To learn more about tibbles, check out this chapter from R for Data Science." }, { "code": null, "e": 1938, "s": 1862, "text": "I like to use the glimpse function to look at the variable names and types." }, { "code": null, "e": 2352, "s": 1938, "text": "# taking a quick lookglimpse(df)> glimpse(df)Observations: 10Variables: 5$ customerID chr \"7590-VHVEG\", \"5575-GNVDE\", \"3668-QPYBK\", \"7...$ MonthlyCharges dbl 29.85, 56.95, NA, 42.30, 70.70, NaN, 89.10, ...$ TotalCharges chr \"109.9\", \"na\", \"108.15\", \"1840.75\", NA, \"820...$ PaymentMethod chr \"Electronic check\", \"Mailed check\", \"--\", \"B...$ Churn chr \"yes\", \"yes\", \"yes\", \"no\", \"no\", \"yes\", \"no\"..." }, { "code": null, "e": 2389, "s": 2352, "text": "We can see that there’s 5 variables." }, { "code": null, "e": 2400, "s": 2389, "text": "customerID" }, { "code": null, "e": 2415, "s": 2400, "text": "MonthlyCharges" }, { "code": null, "e": 2428, "s": 2415, "text": "TotalCharges" }, { "code": null, "e": 2442, "s": 2428, "text": "PaymentMethod" }, { "code": null, "e": 2448, "s": 2442, "text": "Churn" }, { "code": null, "e": 2506, "s": 2448, "text": "There’s also a description of the type for each variable:" }, { "code": null, "e": 2576, "s": 2506, "text": "customerID: chr which stands for character, another name for a string" }, { "code": null, "e": 2645, "s": 2576, "text": "MonthlyCharges: dbl which stands for double, which is a numeric type" }, { "code": null, "e": 2673, "s": 2645, "text": "TotalCharges: chr character" }, { "code": null, "e": 2701, "s": 2673, "text": "PaymentMethod: chrcharacter" }, { "code": null, "e": 2721, "s": 2701, "text": "Churn: chrcharacter" }, { "code": null, "e": 2783, "s": 2721, "text": "There’s 10 observations, which means there’s 10 rows of data." }, { "code": null, "e": 2895, "s": 2783, "text": "Now that we’ve taken a quick look to become familiar with the data, let’s go over some basic data manipulation." }, { "code": null, "e": 2971, "s": 2895, "text": "Before we get started with missing values, let’s go over the dplyr library." }, { "code": null, "e": 3129, "s": 2971, "text": "This is just a quick introduction, so be sure to check out the official dplyr documentation as well as Chapter 5 Data Transformation from R for Data Science." }, { "code": null, "e": 3283, "s": 3129, "text": "This library uses a “grammar of data manipulation” which basically means that there’s a set of functions with logical verb names for what you want to do." }, { "code": null, "e": 3407, "s": 3283, "text": "For example, maybe you want to only look at customers that churned. You can filter the data on Churn values equal to “yes”." }, { "code": null, "e": 3468, "s": 3407, "text": "We can quickly do that using the filter function from dplyr." }, { "code": null, "e": 3977, "s": 3468, "text": "# filter on customers that churneddf %>% filter(Churn==\"yes\")# A tibble: 5 x 5 customerID MonthlyCharges TotalCharges PaymentMethod Churn chr dbl chr chr chr1 7590-VHVEG 29.8 109.9 Electronic check yes2 5575-GNVDE 57.0 na Mailed check yes3 3668-QPYBK NA 108.15 -- yes4 9305-CDSKC NaN 820.5 -- yes5 6713-OKOMC NA N/A NA yes" }, { "code": null, "e": 4081, "s": 3977, "text": "Taking a look we can see that R returned an organized tibble that only includes customers that churned." }, { "code": null, "e": 4193, "s": 4081, "text": "If you’re not familiar with the %>% operator, also known as the “pipe operator” check out this great blog post." }, { "code": null, "e": 4373, "s": 4193, "text": "The pipe is a useful operator that comes from the magrittr package. It allows us to organize our code by eliminating nested parentheses so that we can make our code more readable." }, { "code": null, "e": 4430, "s": 4373, "text": "For example, let’s say we had the following calculation:" }, { "code": null, "e": 4497, "s": 4430, "text": "# nested functionslog(sin(exp(2)))> log(sin(exp(2)))[1] -0.1122118" }, { "code": null, "e": 4587, "s": 4497, "text": "With all of the parentheses, this isn’t very readable. Now let’s look at a piped example." }, { "code": null, "e": 4638, "s": 4587, "text": "# piped functions2 %>% exp() %>% sin() %>% log()" }, { "code": null, "e": 4701, "s": 4638, "text": "It’s easy to see that the piped example is much more readable." }, { "code": null, "e": 4722, "s": 4701, "text": "Okay, back to dplyr." }, { "code": null, "e": 4817, "s": 4722, "text": "We just used the filter function to quickly filter out rows with a Churn value equal to “yes”." }, { "code": null, "e": 4949, "s": 4817, "text": "Maybe we also want to just select the customerID and TotalChargescolumns. We can quickly do that as well using the select function." }, { "code": null, "e": 5239, "s": 4949, "text": "# filter on customers that churned,# select customerID and TotalCharges columnsdf %>% filter(Churn==\"yes\") %>% select(customerID, TotalCharges)# A tibble: 5 x 2 customerID TotalCharges chr chr1 7590-VHVEG 109.92 5575-GNVDE na3 3668-QPYBK 108.154 9305-CDSKC 820.55 6713-OKOMC N/A" }, { "code": null, "e": 5322, "s": 5239, "text": "We can see just how easy it is to manipulate our data using these dplyr functions." }, { "code": null, "e": 5396, "s": 5322, "text": "Chaining functions together vertically makes our code extremely readable." }, { "code": null, "e": 5514, "s": 5396, "text": "This way of coding might seem a little strange at first, but after a little practice it will become extremely useful." }, { "code": null, "e": 5639, "s": 5514, "text": "Now that we’re a little bit more familiar with the pipe operator and dplyr, let’s dive right in to detecting missing values." }, { "code": null, "e": 5708, "s": 5639, "text": "We’ll start by looking at standard missing values that R recognizes." }, { "code": null, "e": 5763, "s": 5708, "text": "Go ahead and take a look at the MonthlyCharges column." }, { "code": null, "e": 5809, "s": 5763, "text": "We can see that there’s three missing values." }, { "code": null, "e": 5890, "s": 5809, "text": "There’s two empty cells, and one with “Nan”. These are obviously missing values." }, { "code": null, "e": 5950, "s": 5890, "text": "We can see how R recognizes these using the is.na function." }, { "code": null, "e": 6006, "s": 5950, "text": "First let’s print out that column and then apply is.na." }, { "code": null, "e": 6262, "s": 6006, "text": "# looking at MonthlyChargesdf$MonthlyChargesis.na(df$MonthlyCharges)> df$MonthlyCharges [1] 29.85 56.95 NA 42.30 70.70 NaN 89.10 NA 104.80[10] 54.10> is.na(df$MonthlyCharges) [1] FALSE FALSE TRUE FALSE FALSE TRUE FALSE TRUE FALSE FALSE" }, { "code": null, "e": 6391, "s": 6262, "text": "We can see that the two missing cells were recognized as “NA” and the other missing value with Nan was identified by R as “NaN”." }, { "code": null, "e": 6553, "s": 6391, "text": "When we run the is.na function, R recognizes both types of missing values. We can see this because there’s three TRUE values that are returned when we run is.na." }, { "code": null, "e": 6682, "s": 6553, "text": "It’s important to note the difference between “NA” and “NaN”. We can use the help function to take a closer look at both values." }, { "code": null, "e": 6734, "s": 6682, "text": "# using the help function to learn about NAhelp(NA)" }, { "code": null, "e": 6843, "s": 6734, "text": "Taking a look at the bottom right window we can see that “NA” or “Not Available” is used for missing values." }, { "code": null, "e": 6987, "s": 6843, "text": "“NaN” or “Not a Number” is used for numeric calculations. If a value is undefined, such as 0/0, “NaN” is the appropriate way to represent this." }, { "code": null, "e": 7136, "s": 6987, "text": "There is also a is.nan function. Try running this with both “NA” and “NaN”. You’ll see that it returns a value of TRUE for “NaN” but FALSE for “NA”." }, { "code": null, "e": 7238, "s": 7136, "text": "The is.na function on the other hand is more generic, so it will detect both types of missing values." }, { "code": null, "e": 7303, "s": 7238, "text": "Let’s go ahead and use dplyr to summarize our data a little bit." }, { "code": null, "e": 7410, "s": 7303, "text": "We can use the distinct function to look at the distinct values that show up in the MonthlyCharges column." }, { "code": null, "e": 7663, "s": 7410, "text": "# looking at the distinct valuesdf %>% distinct(MonthlyCharges)# A tibble: 9 x 1 MonthlyCharges dbl1 29.82 57.03 NA4 42.35 70.76 NaN7 89.18 105.9 54.1" }, { "code": null, "e": 7781, "s": 7663, "text": "We can see there’s 9 distinct values. There’s 10 rows of data, but “NA” shows up twice, so there’s 9 distinct values." }, { "code": null, "e": 7870, "s": 7781, "text": "If we want to get a quick count of the distinct values we can use the summarisefunction." }, { "code": null, "e": 7983, "s": 7870, "text": "# counting unique valuesdf %>% summarise(n = n_distinct(MonthlyCharges))# A tibble: 1 x 1 n int1 9" }, { "code": null, "e": 8107, "s": 7983, "text": "This returns a simple tibble with a column that we named “n” for the count of distinct values in the MonthlyCharges column." }, { "code": null, "e": 8243, "s": 8107, "text": "What we’re really after is the count of missing values. We can use the summarise function along with is.na to count the missing values." }, { "code": null, "e": 8361, "s": 8243, "text": "# counting missing valuesdf %>% summarise(count = sum(is.na(MonthlyCharges)))# A tibble: 1 x 1 count int1 3" }, { "code": null, "e": 8413, "s": 8361, "text": "As we saw above, the number of missing values is 3." }, { "code": null, "e": 8581, "s": 8413, "text": "Maybe we want to do multiple things at once. Let’s say we want to get a count of unique values, as well as missing values, and also the median value of MonthlyCharges." }, { "code": null, "e": 8624, "s": 8581, "text": "Here’s how we can do that using summarise:" }, { "code": null, "e": 8901, "s": 8624, "text": "# counting unique, missing, and median valuesdf %>% summarise(n = n_distinct(MonthlyCharges), na = sum(is.na(MonthlyCharges)), med = median(MonthlyCharges, na.rm = TRUE))# A tibble: 1 x 3 n na med int int dbl1 9 3 57.0" }, { "code": null, "e": 8963, "s": 8901, "text": "This produces an organized little tibble of our summary data." }, { "code": null, "e": 9124, "s": 8963, "text": "Now that we’ve identified the missing values, let’s replace them with the median value of MonthlyCharges. To do that, we can use the mutate function from dplyr." }, { "code": null, "e": 10068, "s": 9124, "text": "# mutate missing valuesdf %>% mutate(MonthlyCharges = replace(MonthlyCharges, is.na(MonthlyCharges), median(MonthlyCharges, na.rm = TRUE)))# A tibble: 10 x 5 customerID MonthlyCharges TotalCharges PaymentMethod Churn chr dbl chr chr chr 1 7590-VHVEG 29.8 109.9 Electronic check yes 2 5575-GNVDE 57.0 na Mailed check yes 3 3668-QPYBK 57.0 108.15 -- yes 4 7795-CFOCW 42.3 1840.75 Bank transfer no 5 9237-HQITU 70.7 NA Electronic check no 6 9305-CDSKC 57.0 820.5 -- yes 7 1452-KIOVK 89.1 1949.4 Credit card no 8 6713-OKOMC 57.0 N/A NA yes 9 7892-POOKP 105. 3046.05 Electronic check no10 8451-AJOMK 54.1 354.95 Electronic check no" }, { "code": null, "e": 10168, "s": 10068, "text": "We can see that the missing values were replaced with the median value 57 in three different spots." }, { "code": null, "e": 10246, "s": 10168, "text": "Just to double check that this worked, lets print out the whole tibble again." }, { "code": null, "e": 11009, "s": 10246, "text": "df# A tibble: 10 x 5 customerID MonthlyCharges TotalCharges PaymentMethod Churn chr dbl chr chr chr 1 7590-VHVEG 29.8 109.9 Electronic check yes 2 5575-GNVDE 57.0 na Mailed check yes 3 3668-QPYBK NA 108.15 -- yes 4 7795-CFOCW 42.3 1840.75 Bank transfer no 5 9237-HQITU 70.7 NA Electronic check no 6 9305-CDSKC NaN 820.5 -- yes 7 1452-KIOVK 89.1 1949.4 Credit card no 8 6713-OKOMC NA N/A NA yes 9 7892-POOKP 105. 3046.05 Electronic check no10 8451-AJOMK 54.1 354.95 Electronic check no" }, { "code": null, "e": 11074, "s": 11009, "text": "It looks like all the missing values are back. So what happened?" }, { "code": null, "e": 11159, "s": 11074, "text": "This brings up an important point. The dplyr package won’t modify the data in place." }, { "code": null, "e": 11335, "s": 11159, "text": "Basically this means if we apply a mutate to some of the data with just a pipe operator, it will show us a modified view of the data, but it won’t be a permanent modification." }, { "code": null, "e": 11451, "s": 11335, "text": "To permanently modify the data, we need to assign the mutate to the original data using the assignment operator <-." }, { "code": null, "e": 11480, "s": 11451, "text": "Here’s how we would do that:" }, { "code": null, "e": 11719, "s": 11480, "text": "# mutate missing values, and modify the dataframedf <- df %>% mutate(MonthlyCharges = replace(MonthlyCharges, is.na(MonthlyCharges), median(MonthlyCharges, na.rm = TRUE)))" }, { "code": null, "e": 11783, "s": 11719, "text": "Now if we take another look at the data, it should be modified." }, { "code": null, "e": 12545, "s": 11783, "text": "df# A tibble: 10 x 5 customerID MonthlyCharges TotalCharges PaymentMethod Churn chr dbl chr chr chr 1 7590-VHVEG 29.8 109.9 Electronic check yes 2 5575-GNVDE 57.0 na Mailed check yes 3 3668-QPYBK 57.0 108.15 -- yes 4 7795-CFOCW 42.3 1840.75 Bank transfer no 5 9237-HQITU 70.7 NA Electronic check no 6 9305-CDSKC 57.0 820.5 -- yes 7 1452-KIOVK 89.1 1949.4 Credit card no 8 6713-OKOMC 57.0 N/A NA yes 9 7892-POOKP 105. 3046.05 Electronic check no10 8451-AJOMK 54.1 354.95 Electronic check no" }, { "code": null, "e": 12735, "s": 12545, "text": "This time the MonthlyCharges column was modified permanently. Keep in mind that when you want to permanently mutate your data with dplyr, you need to assign the mutate to the original data." }, { "code": null, "e": 12851, "s": 12735, "text": "A lot of times you won’t be lucky enough to have all standard missing value types that R will recognize right away." }, { "code": null, "e": 12929, "s": 12851, "text": "Let’s take a quick look at the next column, TotalCharges, to see what I mean." }, { "code": null, "e": 13003, "s": 12929, "text": "We can see there’s three different missing values, “na”, “NA”, and “N/A”." }, { "code": null, "e": 13108, "s": 13003, "text": "In the previous example we saw that R recognized “NA” as a missing value, but what about “na” and “N/A”?" }, { "code": null, "e": 13210, "s": 13108, "text": "Let’s take a look at this column and use is.na to see if R recognizes all of these as missing values." }, { "code": null, "e": 13363, "s": 13210, "text": "# looking at missing valuesdf$TotalChargesis.na(df$TotalCharges)> is.na(df$TotalCharges) [1] FALSE FALSE FALSE FALSE TRUE FALSE FALSE FALSE FALSE FALSE" }, { "code": null, "e": 13445, "s": 13363, "text": "Looking at the results we can see that R only identified “NA” as a missing value." }, { "code": null, "e": 13518, "s": 13445, "text": "Let’s use the summarise function to see how many missing values R found." }, { "code": null, "e": 13634, "s": 13518, "text": "# counting missing valuesdf %>% summarise(count = sum(is.na(TotalCharges)))# A tibble: 1 x 1 count int1 1" }, { "code": null, "e": 13691, "s": 13634, "text": "The result confirms that R only found one missing value." }, { "code": null, "e": 13806, "s": 13691, "text": "We’ll need to replace both “na” and “N/A” with “NA” to make sure that R recognizes all of these as missing values." }, { "code": null, "e": 13988, "s": 13806, "text": "Let’s use the mutate function to replace these with the correct missing value types. Keep in mind that we need to use the assignment operator to make sure the changes are permanent." }, { "code": null, "e": 14198, "s": 13988, "text": "# replacing with standard missing value type, NAdf <- df %>% mutate(TotalCharges = replace(TotalCharges, TotalCharges == \"na\", NA)) %>% mutate(TotalCharges = replace(TotalCharges, TotalCharges == \"N/A\", NA))" }, { "code": null, "e": 14321, "s": 14198, "text": "If we take a look at this column again, we can see that now all of the missing values have been correctly identified by R." }, { "code": null, "e": 14590, "s": 14321, "text": "# taking another lookdf$TotalChargesis.na(df$TotalCharges)> df$TotalCharges [1] \"109.9\" NA \"108.15\" \"1840.75\" NA \"820.5\" [7] \"1949.4\" NA \"3046.05\" \"354.95\"> is.na(df$TotalCharges) [1] FALSE TRUE FALSE FALSE TRUE FALSE FALSE TRUE FALSE FALSE" }, { "code": null, "e": 14648, "s": 14590, "text": "Now we can see that R picked up all three missing values." }, { "code": null, "e": 14717, "s": 14648, "text": "Before we replace the missing values, there’s still another problem." }, { "code": null, "e": 14812, "s": 14717, "text": "R thinks that the column values are characters. We can confirm this with the glimpse function." }, { "code": null, "e": 14907, "s": 14812, "text": "> glimpse(df$TotalCharges) chr [1:10] \"109.9\" NA \"108.15\" \"1840.75\" NA \"820.5\" \"1949.4\" NA ..." }, { "code": null, "e": 14944, "s": 14907, "text": "Let’s change these to numeric types." }, { "code": null, "e": 15150, "s": 14944, "text": "# changing to numeric typedf$TotalCharges <- as.numeric(df$TotalCharges)glimpse(df$TotalCharges)> df$TotalCharges <- as.numeric(df$TotalCharges) > glimpse(df$TotalCharges) num [1:10] 110 NA 108 1841 NA ..." }, { "code": null, "e": 15224, "s": 15150, "text": "Finally, let’s finish up by replacing the missing values with the median." }, { "code": null, "e": 15555, "s": 15224, "text": "# replace missing values with mediandf <- df %>% mutate(TotalCharges = replace(TotalCharges, is.na(TotalCharges), median(TotalCharges, na.rm = T)))df$TotalCharges> df$TotalCharges [1] 109.90 820.50 108.15 1840.75 820.50 820.50 1949.40 820.50 [9] 3046.05 354.95" }, { "code": null, "e": 15674, "s": 15555, "text": "An even simpler way to change all of the missing values is to change the column to numeric before doing anything else." }, { "code": null, "e": 15744, "s": 15674, "text": "Let’s import the data again so that we have the missing values again." }, { "code": null, "e": 15937, "s": 15744, "text": "# importing the data againdf <- read_csv(\"telecom.csv\")df$TotalCharges> df$TotalCharges [1] \"109.9\" \"na\" \"108.15\" \"1840.75\" NA \"820.5\" [7] \"1949.4\" \"N/A\" \"3046.05\" \"354.95\"" }, { "code": null, "e": 15983, "s": 15937, "text": "Now let’s try changing the column to numbers." }, { "code": null, "e": 16278, "s": 15983, "text": "# change TotalCharges to numeric typedf$TotalCharges <- as.numeric(df$TotalCharges)df$TotalCharges> df$TotalCharges <- as.numeric(df$TotalCharges)Warning message:NAs introduced by coercion > df$TotalCharges [1] 109.90 NA 108.15 1840.75 NA 820.50 1949.40 NA [9] 3046.05 354.95" }, { "code": null, "e": 16357, "s": 16278, "text": "This time all of the different missing value types were changed automatically." }, { "code": null, "e": 16433, "s": 16357, "text": "Although this is a little bit shorter, I don’t always prefer this solution." }, { "code": null, "e": 16568, "s": 16433, "text": "This worked for our specific example, but if you’re trying to detect anomalies or other dirty data, this might not be a good solution." }, { "code": null, "e": 16668, "s": 16568, "text": "Always make sure to read the R console for warnings like this. It can provide valuable information." }, { "code": null, "e": 16771, "s": 16668, "text": "So far we’ve looked at standard missing values like “NA” and non-standard values like “n/a” and “N/A”." }, { "code": null, "e": 16826, "s": 16771, "text": "There’s numerous other ways to represent missing data." }, { "code": null, "e": 16907, "s": 16826, "text": "Maybe I was manually entering in data and chose to use “ — ” for missing values." }, { "code": null, "e": 16973, "s": 16907, "text": "On the other hand, maybe you prefer to just leave the cell blank." }, { "code": null, "e": 17053, "s": 16973, "text": "Let’s learn about detecting some of these more unusual types of missing values." }, { "code": null, "e": 17094, "s": 17053, "text": "Take a look at the PaymentMethod column:" }, { "code": null, "e": 17140, "s": 17094, "text": "We can see that there’s three missing values." }, { "code": null, "e": 17202, "s": 17140, "text": "Two are represented with “ — ” and one is just an empty cell." }, { "code": null, "e": 17239, "s": 17202, "text": "Let’s see what R thinks about these:" }, { "code": null, "e": 17394, "s": 17239, "text": "# looking at PaymentMethoddf$PaymentMethodis.na(df$PaymentMethod)> is.na(df$PaymentMethod) [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE TRUE FALSE FALSE" }, { "code": null, "e": 17460, "s": 17394, "text": "R was only to identify one of the missing values, the empty cell." }, { "code": null, "e": 17513, "s": 17460, "text": "Let’s go ahead and use mutate to change “ — “ to NA." }, { "code": null, "e": 17857, "s": 17513, "text": "# replacing \"--\" with NAdf <- df %>% mutate(PaymentMethod = replace(PaymentMethod, PaymentMethod == \"--\", NA))is.na(df$PaymentMethod)df$PaymentMethod> df$PaymentMethod [1] \"Electronic check\" \"Mailed check\" NA [4] \"Bank transfer\" \"Electronic check\" NA [7] \"Credit card\" NA \"Electronic check\"[10] \"Electronic check\"" }, { "code": null, "e": 17915, "s": 17857, "text": "Now we can see that all three missing values now show up." }, { "code": null, "e": 17994, "s": 17915, "text": "So far we’ve either left missing values alone, or replaced them with a median." }, { "code": null, "e": 18065, "s": 17994, "text": "What about dealing with missing values in a column of character types?" }, { "code": null, "e": 18156, "s": 18065, "text": "Since all of the entries in the PaymentMethod column are strings, there’s no median value." }, { "code": null, "e": 18264, "s": 18156, "text": "Rather than just exclude the missing values, let’s convert the NAs to a new category, called “unavailable”." }, { "code": null, "e": 18633, "s": 18264, "text": "# replace NA with \"unavailable\"df <- df %>% mutate(PaymentMethod = replace(PaymentMethod, is.na(PaymentMethod), \"unavailable\"))df$PaymentMethod> df$PaymentMethod [1] \"Electronic check\" \"Mailed check\" \"unavailable\" [4] \"Bank transfer\" \"Electronic check\" \"unavailable\" [7] \"Credit card\" \"unavailable\" \"Electronic check\"[10] \"Electronic check\"" }, { "code": null, "e": 18737, "s": 18633, "text": "Now we can see that our three missing values, NA, have been converted to a new category, “unavailable”." }, { "code": null, "e": 18895, "s": 18737, "text": "Sometimes there’s a reason why values are missing, so it’s good to keep that information to see how it influences the results in our machine learning models." }, { "code": null, "e": 19025, "s": 18895, "text": "We won’t get in to those details in this post, but keep in mind that throwing out missing values might not always be a good idea." }, { "code": null, "e": 19120, "s": 19025, "text": "In this post we learned about data cleaning, one of the most important skills in data science." }, { "code": null, "e": 19192, "s": 19120, "text": "Specifically, we looked at detecting different types of missing values." }, { "code": null, "e": 19272, "s": 19192, "text": "We also learned about replacing both numeric and character type missing values." }, { "code": null, "e": 19371, "s": 19272, "text": "You can expect to spend up to 80% of your time cleaning data, so this is a valuable skill to have." } ]

[ { "code": null, "e": 1388, "s": 1062, "text": "We have 2 arrays in JavaScript and we want to compare one with the other to see if the\nelements of master array exists in keys array, and then make one new array of the same length\nthat of the master array but containing only true and false (being true for the values that exists in\nkeys array and false the ones that don't)." }, { "code": null, "e": 1423, "s": 1388, "text": "Let’s say, if the two arrays are −" }, { "code": null, "e": 1475, "s": 1423, "text": "const master = [3,9,11,2,20];\nconst keys = [1,2,3];" }, { "code": null, "e": 1508, "s": 1475, "text": "Then the final array should be −" }, { "code": null, "e": 1562, "s": 1508, "text": "const finalArray = [true, false, false, true, false];" }, { "code": null, "e": 1617, "s": 1562, "text": "Therefore, let’s write the function for this problem −" }, { "code": null, "e": 1858, "s": 1617, "text": "const master = [3,9,11,2,20];\nconst keys = [1,2,3];\nconst prepareBooleans = (master, keys) => {\n const booleans = master.map(el => {\n return keys.includes(el);\n });\n return booleans;\n};\nconsole.log(prepareBooleans(master, keys));" }, { "code": null, "e": 1894, "s": 1858, "text": "The output in the console will be −" }, { "code": null, "e": 1930, "s": 1894, "text": "[ true, false, false, true, false ]" } ]

[ { "code": null, "e": 2456, "s": 2318, "text": "Before we understand the concept of array of pointers, let us consider the following example, which makes use of an array of 3 integers −" }, { "code": null, "e": 2710, "s": 2456, "text": "#include <iostream>\n \nusing namespace std;\nconst int MAX = 3;\n \nint main () {\n int var[MAX] = {10, 100, 200};\n \n for (int i = 0; i < MAX; i++) {\n \n cout << \"Value of var[\" << i << \"] = \";\n cout << var[i] << endl;\n }\n \n return 0;\n}" }, { "code": null, "e": 2791, "s": 2710, "text": "When the above code is compiled and executed, it produces the following result −" }, { "code": null, "e": 2857, "s": 2791, "text": "Value of var[0] = 10\nValue of var[1] = 100\nValue of var[2] = 200\n" }, { "code": null, "e": 3064, "s": 2857, "text": "There may be a situation, when we want to maintain an array, which can store pointers to an int or char or any other data type available. Following is the declaration of an array of pointers to an integer −" }, { "code": null, "e": 3080, "s": 3064, "text": "int *ptr[MAX];\n" }, { "code": null, "e": 3303, "s": 3080, "text": "This declares ptr as an array of MAX integer pointers. Thus, each element in ptr, now holds a pointer to an int value. Following example makes use of three integers which will be stored in an array of pointers as follows −" }, { "code": null, "e": 3674, "s": 3303, "text": "#include <iostream>\n \nusing namespace std;\nconst int MAX = 3;\n \nint main () {\n int var[MAX] = {10, 100, 200};\n int *ptr[MAX];\n \n for (int i = 0; i < MAX; i++) {\n ptr[i] = &var[i]; // assign the address of integer.\n }\n \n for (int i = 0; i < MAX; i++) {\n cout << \"Value of var[\" << i << \"] = \";\n cout << *ptr[i] << endl;\n }\n \n return 0;\n}" }, { "code": null, "e": 3755, "s": 3674, "text": "When the above code is compiled and executed, it produces the following result −" }, { "code": null, "e": 3821, "s": 3755, "text": "Value of var[0] = 10\nValue of var[1] = 100\nValue of var[2] = 200\n" }, { "code": null, "e": 3912, "s": 3821, "text": "You can also use an array of pointers to character to store a list of strings as follows −" }, { "code": null, "e": 4210, "s": 3912, "text": "#include <iostream>\n \nusing namespace std;\nconst int MAX = 4;\n \nint main () {\nconst char *names[MAX] = { \"Zara Ali\", \"Hina Ali\", \"Nuha Ali\", \"Sara Ali\" };\n\n for (int i = 0; i < MAX; i++) {\n cout << \"Value of names[\" << i << \"] = \";\n cout << (names + i) << endl;\n }\n \n return 0;\n}" }, { "code": null, "e": 4291, "s": 4210, "text": "When the above code is compiled and executed, it produces the following result −" }, { "code": null, "e": 4432, "s": 4291, "text": "Value of names[0] = 0x7ffd256683c0\nValue of names[1] = 0x7ffd256683c8\nValue of names[2] = 0x7ffd256683d0\nValue of names[3] = 0x7ffd256683d8\n" }, { "code": null, "e": 4469, "s": 4432, "text": "\n 154 Lectures \n 11.5 hours \n" }, { "code": null, "e": 4488, "s": 4469, "text": " Arnab Chakraborty" }, { "code": null, "e": 4520, "s": 4488, "text": "\n 14 Lectures \n 57 mins\n" }, { "code": null, "e": 4543, "s": 4520, "text": " Kaushik Roy Chowdhury" }, { "code": null, "e": 4579, "s": 4543, "text": "\n 30 Lectures \n 12.5 hours \n" }, { "code": null, "e": 4596, "s": 4579, "text": " Frahaan Hussain" }, { "code": null, "e": 4631, "s": 4596, "text": "\n 54 Lectures \n 3.5 hours \n" }, { "code": null, "e": 4648, "s": 4631, "text": " Frahaan Hussain" }, { "code": null, "e": 4683, "s": 4648, "text": "\n 77 Lectures \n 5.5 hours \n" }, { "code": null, "e": 4700, "s": 4683, "text": " Frahaan Hussain" }, { "code": null, "e": 4735, "s": 4700, "text": "\n 12 Lectures \n 3.5 hours \n" }, { "code": null, "e": 4752, "s": 4735, "text": " Frahaan Hussain" }, { "code": null, "e": 4759, "s": 4752, "text": " Print" }, { "code": null, "e": 4770, "s": 4759, "text": " Add Notes" } ]

[ { "code": null, "e": 2818, "s": 2603, "text": "It is a logic error exception and this class defines the type of objects thrown as exceptions to report errors in the internal logical of the program, such as violation of logical preconditions or class invariants." }, { "code": null, "e": 2869, "s": 2818, "text": "Following is the declaration for std::logic_error." }, { "code": null, "e": 2888, "s": 2869, "text": "class logic_error;" }, { "code": null, "e": 2907, "s": 2888, "text": "class logic_error;" }, { "code": null, "e": 2912, "s": 2907, "text": "none" }, { "code": null, "e": 2917, "s": 2912, "text": "none" }, { "code": null, "e": 3025, "s": 2917, "text": "constructor − Here the string passed as what_arg has the same content as the value returned by member what." }, { "code": null, "e": 3032, "s": 3025, "text": " Print" }, { "code": null, "e": 3043, "s": 3032, "text": " Add Notes" } ]

[ { "code": null, "e": 2619, "s": 2377, "text": "WeakHashMap is an implementation of the Map interface that stores only weak references to its keys. Storing only weak references allows a key-value pair to be garbage-collected when its key is no longer referenced outside of the WeakHashMap." }, { "code": null, "e": 2849, "s": 2619, "text": "This class provides the easiest way to harness the power of weak references. It is useful for implementing \"registry-like\" data structures, where the utility of an entry vanishes when its key is no longer reachable by any thread." }, { "code": null, "e": 3074, "s": 2849, "text": "The WeakHashMap functions identically to the HashMap with one very important exception: if the Java memory manager no longer has a strong reference to the object specified as a key, then the entry in the map will be removed." }, { "code": null, "e": 3343, "s": 3074, "text": "Weak Reference − If the only references to an object are weak references, the garbage collector can reclaim the object's memory at any time.it doesn't have to wait until the system runs out of memory. Usually, it will be freed the next time the garbage collector runs." }, { "code": null, "e": 3417, "s": 3343, "text": "Following is the list of constructors supported by the WeakHashMap class." }, { "code": null, "e": 3431, "s": 3417, "text": "WeakHashMap()" }, { "code": null, "e": 3559, "s": 3431, "text": "This constructor constructs a new, empty WeakHashMap with the default initial capacity (16) and the default load factor (0.75)." }, { "code": null, "e": 3592, "s": 3559, "text": "WeakHashMap(int initialCapacity)" }, { "code": null, "e": 3721, "s": 3592, "text": "This constructor constructs a new, empty WeakHashMap with the given initial capacity and the default load factor, which is 0.75." }, { "code": null, "e": 3773, "s": 3721, "text": "WeakHashMap(int initialCapacity, float loadFactor)\n" }, { "code": null, "e": 3885, "s": 3773, "text": "This constructor constructs a new, empty WeakHashMap with the given initial capacity and the given load factor." }, { "code": null, "e": 3904, "s": 3885, "text": "WeakHashMap(Map t)" }, { "code": null, "e": 3995, "s": 3904, "text": "This constructor constructs a new WeakHashMap with the same mappings as the specified Map." }, { "code": null, "e": 4093, "s": 3995, "text": "Apart from the methods inherited from its parent classes, TreeMap defines the following methods −" }, { "code": null, "e": 4106, "s": 4093, "text": "void clear()" }, { "code": null, "e": 4142, "s": 4106, "text": "Removes all mappings from this map." }, { "code": null, "e": 4174, "s": 4142, "text": "boolean containsKey(Object key)" }, { "code": null, "e": 4241, "s": 4174, "text": "Returns true if this map contains a mapping for the specified key." }, { "code": null, "e": 4277, "s": 4241, "text": "boolean containsValue(Object value)" }, { "code": null, "e": 4348, "s": 4277, "text": "Returns true if this map maps one or more keys to the specified value." }, { "code": null, "e": 4363, "s": 4348, "text": "Set entrySet()" }, { "code": null, "e": 4428, "s": 4363, "text": "Returns a collection view of the mappings contained in this map." }, { "code": null, "e": 4451, "s": 4428, "text": "Object get(Object key)" }, { "code": null, "e": 4582, "s": 4451, "text": "Returns the value to which the specified key is mapped in this weak hash map, or null if the map contains no mapping for this key." }, { "code": null, "e": 4600, "s": 4582, "text": "boolean isEmpty()" }, { "code": null, "e": 4657, "s": 4600, "text": "Returns true if this map contains no key-value mappings." }, { "code": null, "e": 4670, "s": 4657, "text": "Set keySet()" }, { "code": null, "e": 4724, "s": 4670, "text": "Returns a set view of the keys contained in this map." }, { "code": null, "e": 4761, "s": 4724, "text": "Object put(Object key, Object value)" }, { "code": null, "e": 4828, "s": 4761, "text": "Associates the specified value with the specified key in this map." }, { "code": null, "e": 4847, "s": 4828, "text": "void putAll(Map m)" }, { "code": null, "e": 5021, "s": 4847, "text": "Copies all of the mappings from the specified map to this map. These mappings will replace any mappings that this map had for any of the keys currently in the specified map." }, { "code": null, "e": 5047, "s": 5021, "text": "Object remove(Object key)" }, { "code": null, "e": 5106, "s": 5047, "text": "Removes the mapping for this key from this map if present." }, { "code": null, "e": 5117, "s": 5106, "text": "int size()" }, { "code": null, "e": 5171, "s": 5117, "text": "Returns the number of key-value mappings in this map." }, { "code": null, "e": 5191, "s": 5171, "text": "Collection values()" }, { "code": null, "e": 5254, "s": 5191, "text": "Returns a collection view of the values contained in this map." }, { "code": null, "e": 5342, "s": 5254, "text": "The following program illustrates several of the methods supported by this collection −" }, { "code": null, "e": 6104, "s": 5342, "text": "import java.util.*;\npublic class WeakHashMap_Demo {\n\n private static Map map;\n public static void main (String args[]) {\n map = new WeakHashMap();\n map.put(new String(\"Maine\"), \"Augusta\");\n \n Runnable runner = new Runnable() {\n public void run() {\n while (map.containsKey(\"Maine\")) {\n try {\n Thread.sleep(500);\n } catch (InterruptedException ignored) {\n }\n System.out.println(\"Thread waiting\");\n System.gc();\n }\n }\n };\n Thread t = new Thread(runner);\n t.start();\n System.out.println(\"Main waiting\");\n try {\n t.join();\n } catch (InterruptedException ignored) {\n }\n }\n}" }, { "code": null, "e": 6145, "s": 6104, "text": "This will produce the following result −" }, { "code": null, "e": 6174, "s": 6145, "text": "Main waiting\nThread waiting\n" }, { "code": null, "e": 6369, "s": 6174, "text": "If you do not include the call to System.gc(), the system may never run the garbage collector as not much memory is used by the program. For a more active program, the call would be unnecessary." }, { "code": null, "e": 6402, "s": 6369, "text": "\n 16 Lectures \n 2 hours \n" }, { "code": null, "e": 6418, "s": 6402, "text": " Malhar Lathkar" }, { "code": null, "e": 6451, "s": 6418, "text": "\n 19 Lectures \n 5 hours \n" }, { "code": null, "e": 6467, "s": 6451, "text": " Malhar Lathkar" }, { "code": null, "e": 6502, "s": 6467, "text": "\n 25 Lectures \n 2.5 hours \n" }, { "code": null, "e": 6516, "s": 6502, "text": " Anadi Sharma" }, { "code": null, "e": 6550, "s": 6516, "text": "\n 126 Lectures \n 7 hours \n" }, { "code": null, "e": 6564, "s": 6550, "text": " Tushar Kale" }, { "code": null, "e": 6601, "s": 6564, "text": "\n 119 Lectures \n 17.5 hours \n" }, { "code": null, "e": 6616, "s": 6601, "text": " Monica Mittal" }, { "code": null, "e": 6649, "s": 6616, "text": "\n 76 Lectures \n 7 hours \n" }, { "code": null, "e": 6668, "s": 6649, "text": " Arnab Chakraborty" }, { "code": null, "e": 6675, "s": 6668, "text": " Print" }, { "code": null, "e": 6686, "s": 6675, "text": " Add Notes" } ]

[ { "code": null, "e": 1218, "s": 1062, "text": "To add a line break in array values for every occurrence of ~, first split the array. After splitting, add a line break i.e. <br> for each occurrence of ~." }, { "code": null, "e": 1231, "s": 1218, "text": "For example," }, { "code": null, "e": 1295, "s": 1231, "text": "This is demo text 1!~This is demo text 2!~~This is demo text 3!" }, { "code": null, "e": 1358, "s": 1295, "text": "This will add line breaks like the following for ~ occurrence:" }, { "code": null, "e": 1421, "s": 1358, "text": "This is demo text 1!\nThis is demo text 2!\nThis is demo text 3!" }, { "code": null, "e": 1431, "s": 1421, "text": "Live Demo" }, { "code": null, "e": 1910, "s": 1431, "text": "<!DOCTYPE html>\n<html>\n <body>\n <h2>Adding line break</h2>\n <script>\n var myArray = 'This is demo text 1!~This is demo text 2!~~This is demo text 3!~This is demo text 4!~~This is demo text 5!';\n document.write(\"Original Array: \"+myArray);\n var brk = myArray.split('~');\n var res = brk.join(\" <br> \");\n document.write(\"<br><br>\"+res);\n </script>\n <p>Each occurence of ~ adds a line break above.</p>\n </body>\n</html>" } ]

[ { "code": null, "e": 24302, "s": 24274, "text": "\n10 Dec, 2019" }, { "code": null, "e": 24492, "s": 24302, "text": "Type.GetMembers() Method is used to get the members (properties, methods, fields, events, and so on) of the current Type. There are 2 methods in the overload list of this method as follows:" }, { "code": null, "e": 24512, "s": 24492, "text": "GetMembers() Method" }, { "code": null, "e": 24544, "s": 24512, "text": "GetMembers(BindingFlags) Method" }, { "code": null, "e": 24618, "s": 24544, "text": "This method is used to return all the public members of the current Type." }, { "code": null, "e": 24679, "s": 24618, "text": "Syntax: public System.Reflection.MemberInfo[] GetMembers ();" }, { "code": null, "e": 24887, "s": 24679, "text": "Return Value: This method returns an array of MemberInfo objects representing all the public members of the current Type Or an empty array of type MemberInfo if the current Type does not have public members." }, { "code": null, "e": 24950, "s": 24887, "text": "Below programs illustrate the use of Type.GetMembers() Method:" }, { "code": null, "e": 24961, "s": 24950, "text": "Example 1:" }, { "code": "// C# program to demonstrate the// Type.GetMember() Methodusing System;using System.Globalization;using System.Reflection; // Defining Empty classpublic class Empty { } class GFG { // Main Method public static void Main() { // Declaring and initializing object of Type Type objType = typeof(Empty); // try-catch block for handling Exception try { // Getting array of MemberInfos by // using GetMembers() Method MemberInfo[] info = objType.GetMembers(); // Display the Result Console.WriteLine(\"Fields of current type is as Follow: \"); for (int i = 0; i < info.Length; i++) Console.WriteLine(\" {0}\", info[i]); } // catch ArgumentNullException here catch (ArgumentNullException e) { Console.Write(\"name is null.\"); Console.Write(\"Exception Thrown: \"); Console.Write(\"{0}\", e.GetType(), e.Message); } }}", "e": 25966, "s": 24961, "text": null }, { "code": null, "e": 26120, "s": 25966, "text": "Fields of current type is as Follow: \n Boolean Equals(System.Object)\n Int32 GetHashCode()\n System.Type GetType()\n System.String ToString()\n Void .ctor()\n" }, { "code": null, "e": 26131, "s": 26120, "text": "Example 2:" }, { "code": "// C# program to demonstrate the// Type.GetMember() Methodusing System;using System.Globalization;using System.Reflection; class GFG { // Main Method public static void Main() { // Declaring and initializing object of Type Type objType = typeof(int); // try-catch block for handling Exception try { // Getting array of MemberInfos by // using GetMembers() Method MemberInfo[] info = objType.GetMembers(); // Display the Result Console.WriteLine(\"Fields of current type is as Follow: \"); for (int i = 0; i < 6; i++) Console.WriteLine(\" {0}\", info[i]); } // catch ArgumentNullException here catch (ArgumentNullException e) { Console.Write(\"name is null.\"); Console.Write(\"Exception Thrown: \"); Console.Write(\"{0}\", e.GetType(), e.Message); } }}", "e": 27067, "s": 26131, "text": null }, { "code": null, "e": 27263, "s": 27067, "text": "Fields of current type is as Follow: \n Int32 CompareTo(System.Object)\n Int32 CompareTo(Int32)\n Boolean Equals(System.Object)\n Boolean Equals(Int32)\n Int32 GetHashCode()\n System.String ToString()\n" }, { "code": null, "e": 27415, "s": 27263, "text": "This method is used to search for the members defined for the current Type, using the specified binding constraints when overridden in a derived class." }, { "code": null, "e": 27675, "s": 27415, "text": "Syntax: public abstract System.Reflection.MemberInfo[] GetMembers (System.Reflection.BindingFlags bindingAttr);Here, it takes a bitmask comprised of one or more BindingFlags that specify how the search is conducted or,Zero (Default), to return an empty array." }, { "code": null, "e": 27990, "s": 27675, "text": "Return Value: This method returns an array of MemberInfo objects representing all members defined for the current Type that match the specified binding constraints Or an empty array of type MemberInfo, if no members are defined for the current Type, or if none of the defined members match the binding constraints." }, { "code": null, "e": 28055, "s": 27990, "text": "Below programs illustrate the use of the above-discussed method:" }, { "code": null, "e": 28066, "s": 28055, "text": "Example 1:" }, { "code": "// C# program to demonstrate the// Type.GetMembers(BindingFlags)// Methodusing System;using System.Globalization;using System.Reflection; // Defining class Emptypublic class Empty { } class GFG { // Main Method public static void Main() { // Declaring and initializing object of Type Type objType = typeof(Empty); // try-catch block for handling Exception try { // Getting array of Fields by // using GetField() Method MemberInfo[] info = objType.GetMembers(BindingFlags.Public | BindingFlags.Instance); // Display the Result Console.WriteLine(\"Fields of current type is as Follow: \"); for (int i = 0; i < info.Length; i++) Console.WriteLine(\" {0}\", info[i]); } // catch ArgumentNullException here catch (ArgumentNullException e) { Console.WriteLine(\"name is null.\"); Console.Write(\"Exception Thrown: \"); Console.Write(\"{0}\", e.GetType(), e.Message); } }}", "e": 29166, "s": 28066, "text": null }, { "code": null, "e": 29320, "s": 29166, "text": "Fields of current type is as Follow: \n Boolean Equals(System.Object)\n Int32 GetHashCode()\n System.Type GetType()\n System.String ToString()\n Void .ctor()\n" }, { "code": null, "e": 29331, "s": 29320, "text": "Example 2:" }, { "code": "// C# program to demonstrate the// Type.GetMembers(BindingFlags)// Methodusing System;using System.Globalization;using System.Reflection; // Defining class Emptypublic class Empty { } class GFG { // Main Method public static void Main() { // Declaring and initializing object of Type Type objType = typeof(int); // try-catch block for handling Exception try { // Getting array of Fields by // using GetField() Method MemberInfo[] info = objType.GetMembers(BindingFlags.Public | BindingFlags.Static); // Display the Result Console.WriteLine(\"Fields of current type is as Follow: \"); for (int i = 0; i < info.Length; i++) Console.WriteLine(\" {0}\", info[i]); } // catch ArgumentNullException here catch (ArgumentNullException e) { Console.WriteLine(\"name is null.\"); Console.Write(\"Exception Thrown: \"); Console.Write(\"{0}\", e.GetType(), e.Message); } }}", "e": 30435, "s": 29331, "text": null }, { "code": null, "e": 30901, "s": 30435, "text": "Fields of current type is as Follow: \n Int32 Parse(System.String)\n Int32 Parse(System.String, System.Globalization.NumberStyles)\n Int32 Parse(System.String, System.IFormatProvider)\n Int32 Parse(System.String, System.Globalization.NumberStyles, System.IFormatProvider)\n Boolean TryParse(System.String, Int32 ByRef)\n Boolean TryParse(System.String, System.Globalization.NumberStyles, System.IFormatProvider, Int32 ByRef)\n System.Int32 MaxValue\n System.Int32 MinValue\n" }, { "code": null, "e": 30912, "s": 30901, "text": "Reference:" }, { "code": null, "e": 31001, "s": 30912, "text": "https://docs.microsoft.com/en-us/dotnet/api/system.type.getmembers?view=netframework-4.8" }, { "code": null, "e": 31015, "s": 31001, "text": "shubham_singh" }, { "code": null, "e": 31029, "s": 31015, "text": "CSharp-method" }, { "code": null, "e": 31047, "s": 31029, "text": "CSharp-Type-Class" }, { "code": null, "e": 31050, "s": 31047, "text": "C#" }, { "code": null, "e": 31148, "s": 31050, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 31166, "s": 31148, "text": "Destructors in C#" }, { "code": null, "e": 31189, "s": 31166, "text": "Extension Method in C#" }, { "code": null, "e": 31217, "s": 31189, "text": "HashSet in C# with Examples" }, { "code": null, "e": 31257, "s": 31217, "text": "Top 50 C# Interview Questions & Answers" }, { "code": null, "e": 31300, "s": 31257, "text": "C# | How to insert an element in an Array?" }, { "code": null, "e": 31322, "s": 31300, "text": "Partial Classes in C#" }, { "code": null, "e": 31339, "s": 31322, "text": "C# | Inheritance" }, { "code": null, "e": 31355, "s": 31339, "text": "C# | List Class" }, { "code": null, "e": 31405, "s": 31355, "text": "Difference between Hashtable and Dictionary in C#" } ]

[ { "code": null, "e": 258, "s": 172, "text": "Also published at https://afagarap.works/2020/07/26/installing-tf-gpu-ubuntu2004.html" }, { "code": null, "e": 741, "s": 258, "text": "When Ubuntu publishes a long-term support (LTS) release, I usually wait for a while before upgrading, mainly because I’m waiting for CUDA and cuDNN support for the new release. This time, it only took me three months to migrate from Ubuntu 18.04 to Ubuntu 20.04 — well, technically an Ubuntu-based distro, i.e. Regolith Linux. My decision to do so was simply because I upgraded my SSD from 120GB to 1TB, and so I migrated to a different OS as well— albeit just an Ubuntu derivative." }, { "code": null, "e": 1059, "s": 741, "text": "As I expected, it took me a while to work things out in my new system. Fortunately, I saw some helpful answers online, and now I’m expanding on their answers by adding a bit more explanations. So, this post is actually based on the answers given by meetnick and singrium in this related question posted in Ask Ubuntu." }, { "code": null, "e": 1153, "s": 1059, "text": "The installation of TensorFlow GPU in Ubuntu 20.04 can be summarized in the following points," }, { "code": null, "e": 1206, "s": 1153, "text": "Install CUDA 10.1 by installing nvidia-cuda-toolkit." }, { "code": null, "e": 1259, "s": 1206, "text": "Install the cuDNN version compatible with CUDA 10.1." }, { "code": null, "e": 1294, "s": 1259, "text": "Export CUDA environment variables." }, { "code": null, "e": 1335, "s": 1294, "text": "Install TensorFlow 2.0 with GPU support." }, { "code": null, "e": 1648, "s": 1335, "text": "First, ensure that you are using the NVIDIA proprietary driver by going to “Additional Drivers”, and then choosing the appropriate driver, i.e. for CUDA 10.1, the required driver version is ≥ 418.39. We use the proprietary version over the open source one since CUDA can only operate with the proprietary driver." }, { "code": null, "e": 1734, "s": 1648, "text": "We are installing CUDA 10.1 because it is the compatible version with TensorFlow GPU." }, { "code": null, "e": 1931, "s": 1734, "text": "At the time of this writing, there is no available CUDA 10.1 for Ubuntu 20.04, but as meetnick points out in the referenced Ask Ubuntu post, installing nvidia-cuda-toolkit also installs CUDA 10.1." }, { "code": null, "e": 2057, "s": 1931, "text": "For the sake of being verbose, do not try to use 18.10 or 18.04 CUDA 10.1 for Ubuntu 20.04. I learned that the hard way, lol!" }, { "code": null, "e": 2115, "s": 2057, "text": "So, you can install CUDA 10.1 in Ubuntu 20.04 by running," }, { "code": null, "e": 2154, "s": 2115, "text": "$ sudo apt install nvidia-cuda-toolkit" }, { "code": null, "e": 2296, "s": 2154, "text": "After installing CUDA 10.1, run nvcc -V. Then you will get an output similar to the following to verify if you had a successful installation," }, { "code": null, "e": 2460, "s": 2296, "text": "nvcc: NVIDIA (R) Cuda compiler driverCopyright (c) 2005-2019 NVIDIA CorporationBuilt on Sun_Jul_28_19:07:16_PDT_2019Cuda compilation tools, release 10.1, V10.1.243" }, { "code": null, "e": 2605, "s": 2460, "text": "Unlike in Ubuntu 18.04 (where I was from), CUDA is installed in a different path in 20.04, i.e. /usr/lib/cuda — which you can verify by running," }, { "code": null, "e": 2659, "s": 2605, "text": "$ whereis cudacuda: /usr/lib/cuda /usr/include/cuda.h" }, { "code": null, "e": 2760, "s": 2659, "text": "In Ubuntu 18.04, as you might know, CUDA is installed in /usr/local/cuda or in /usr/local/cuda-10.1." }, { "code": null, "e": 3070, "s": 2760, "text": "After installing CUDA 10.1, you can now install cuDNN 7.6.5 by downloading it from this link. Then, choose “Download cuDNN”, and you’ll be asked to login or create an NVIDIA account. After logging in and accepting the terms of cuDNN software license agreement, you will see a list of available cuDNN software." }, { "code": null, "e": 3268, "s": 3070, "text": "Click “Download cuDNN v7.6.5 (November 5th, 2019) for CUDA 10.1”, then choose “cuDNN Library for Linux” to download cuDNN 7.6.5 for CUDA 10.1. After downloading cuDNN, extract the files by running," }, { "code": null, "e": 3315, "s": 3268, "text": "$ tar -xvzf cudnn-10.1-linux-x64-v7.6.5.32.tgz" }, { "code": null, "e": 3379, "s": 3315, "text": "Next, copy the extracted files to the CUDA installation folder," }, { "code": null, "e": 3484, "s": 3379, "text": "$ sudo cp cuda/include/cudnn.h /usr/lib/cuda/include/$ sudo cp cuda/lib64/libcudnn* /usr/lib/cuda/lib64/" }, { "code": null, "e": 3519, "s": 3484, "text": "Set the file permissions of cuDNN," }, { "code": null, "e": 3596, "s": 3519, "text": "$ sudo chmod a+r /usr/lib/cuda/include/cudnn.h /usr/lib/cuda/lib64/libcudnn*" }, { "code": null, "e": 3735, "s": 3596, "text": "The CUDA environment variables are needed by TensorFlow for GPU support. To set them, we need to append them to ~/.bashrc file by running," }, { "code": null, "e": 3900, "s": 3735, "text": "$ echo 'export LD_LIBRARY_PATH=/usr/lib/cuda/lib64:$LD_LIBRARY_PATH' >> ~/.bashrc$ echo 'export LD_LIBRARY_PATH=/usr/lib/cuda/include:$LD_LIBRARY_PATH' >> ~/.bashrc" }, { "code": null, "e": 3952, "s": 3900, "text": "Load the exported environment variables by running," }, { "code": null, "e": 3971, "s": 3952, "text": "$ source ~/.bashrc" }, { "code": null, "e": 4055, "s": 3971, "text": "After installing the prerequisite packages, you can finally install TensorFlow 2.0," }, { "code": null, "e": 4087, "s": 4055, "text": "$ pip install tensorflow==2.2.0" }, { "code": null, "e": 4226, "s": 4087, "text": "The tensorflow package now includes GPU support by default as opposed to the old days that we need to install tensorflow-gpu specifically." }, { "code": null, "e": 4281, "s": 4226, "text": "Verify that TensorFlow can detect your GPU by running," }, { "code": null, "e": 4417, "s": 4281, "text": ">>> import tensorflow as tf>>> tf.config.list_physical_devices(\"GPU\")[PhysicalDevice(name='/physical_device:GPU:0', device_type='GPU')]" }, { "code": null, "e": 4476, "s": 4417, "text": "If things went smoothly, you should have a similar output." }, { "code": null, "e": 4552, "s": 4476, "text": "You can now enjoy using TensorFlow for your deep learning projects! Hooray!" }, { "code": null, "e": 4695, "s": 4552, "text": "If you are looking for a TensorFlow project to work on, perhaps you will find my blog on Implementing Autoencoder in TensorFlow 2.0 enjoyable!" } ]

[ { "code": null, "e": 2050, "s": 2001, "text": "Converts a text string to all uppercase letters." }, { "code": null, "e": 2067, "s": 2050, "text": "UPPER (<text>) \n" }, { "code": null, "e": 2072, "s": 2067, "text": "text" }, { "code": null, "e": 2167, "s": 2072, "text": "The text that you want to convert to uppercase, or a reference to a column that contains text." }, { "code": null, "e": 2199, "s": 2167, "text": "Same text string in upper case." }, { "code": null, "e": 2256, "s": 2199, "text": "The characters other than alphabets will not be changed." }, { "code": null, "e": 2314, "s": 2256, "text": "= UPPER(\"ab\") returns AB. \n= UPPER(\"12ab\") returns 12AB. " }, { "code": null, "e": 2349, "s": 2314, "text": "\n 53 Lectures \n 5.5 hours \n" }, { "code": null, "e": 2363, "s": 2349, "text": " Abhay Gadiya" }, { "code": null, "e": 2396, "s": 2363, "text": "\n 24 Lectures \n 2 hours \n" }, { "code": null, "e": 2410, "s": 2396, "text": " Randy Minder" }, { "code": null, "e": 2445, "s": 2410, "text": "\n 26 Lectures \n 4.5 hours \n" }, { "code": null, "e": 2459, "s": 2445, "text": " Randy Minder" }, { "code": null, "e": 2466, "s": 2459, "text": " Print" }, { "code": null, "e": 2477, "s": 2466, "text": " Add Notes" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n27 Sep, 2021" }, { "code": null, "e": 188, "s": 28, "text": "In this article, we will learn how to create a two-column layout using flexbox. To create the two-column layout, we use display and flex-direction properties. " }, { "code": null, "e": 560, "s": 188, "text": "Approach: To create a two-column layout, first we create a <div> element with property display: flex, it makes that a div flexbox and then add flex-direction: row, to make the layout column-wise. Then add the required div inside the above div with require width and they all will come as columns. In the case of a two-column layout, we add two divs inside the parent div." }, { "code": null, "e": 568, "s": 560, "text": "Syntax:" }, { "code": null, "e": 627, "s": 568, "text": "<div style=\" display: flex; flex-direction: row; \" ></div>" }, { "code": null, "e": 696, "s": 627, "text": "Example 1: A two-column layout with both columns having equal width." }, { "code": null, "e": 701, "s": 696, "text": "HTML" }, { "code": "<!DOCTYPE html><html> <head> <title>Two Column Layout</title> <style> .body { padding: 0; margin: 0; } .Parent { display: flex; flex-direction: row; } .child1 { width: 50%; height: 100vh; background-color: green; text-align: right; color: white; } .child2 { width: 50%; color: green; height: 100vh; } </style></head> <body> <div class=\"Parent\"> <div class=\"child1\"> <h1>Geeksfo</h1> <center> <h1>Left</h1> </center> </div> <div class=\"child2\"> <h1>rgeeks</h1> <center> <h1>RIGHT</h1> </center> </div> </div></body> </html>", "e": 1562, "s": 701, "text": null }, { "code": null, "e": 1570, "s": 1562, "text": "Output:" }, { "code": null, "e": 1577, "s": 1570, "text": "Output" }, { "code": null, "e": 1651, "s": 1577, "text": "Example 2: A two-column layout with both columns having different widths." }, { "code": null, "e": 1656, "s": 1651, "text": "HTML" }, { "code": "<!DOCTYPE html><html> <head> <title>Two Column Layout</title> <style> .body { padding: 0; margin: 0; } .Parent { display: flex; flex-direction: row; } .child1 { width: 70%; height: 100vh; background-color: green; text-align: center; color: white; } .child2 { width: 30%; padding: 30px; height: 100vh; border: green solid 5px; margin: 50px; } </style></head> <body> <div class=\"Parent\"> <div class=\"child1\"> <h1>Geeksforgeeks</h1> </div> <div class=\"child2\"> <h2> We provide a variety of services for you to learn, thrive and also have fun! Free Tutorials, Millions of Articles, Live, Online and Classroom Courses ,Frequent Coding Competitions, Webinars by Industry Experts, Internship opportunities and Job Opportunities. </h2> </div> </div></body> </html>", "e": 2837, "s": 1656, "text": null }, { "code": null, "e": 2845, "s": 2837, "text": "Output:" }, { "code": null, "e": 2852, "s": 2845, "text": "Output" }, { "code": null, "e": 2867, "s": 2852, "text": "CSS-Properties" }, { "code": null, "e": 2881, "s": 2867, "text": "CSS-Questions" }, { "code": null, "e": 2896, "s": 2881, "text": "HTML-Questions" }, { "code": null, "e": 2903, "s": 2896, "text": "Picked" }, { "code": null, "e": 2907, "s": 2903, "text": "CSS" }, { "code": null, "e": 2912, "s": 2907, "text": "HTML" }, { "code": null, "e": 2929, "s": 2912, "text": "Web Technologies" }, { "code": null, "e": 2934, "s": 2929, "text": "HTML" }, { "code": null, "e": 3032, "s": 2934, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 3071, "s": 3032, "text": "How to set space between the flexbox ?" }, { "code": null, "e": 3110, "s": 3071, "text": "Design a Tribute Page using HTML & CSS" }, { "code": null, "e": 3139, "s": 3110, "text": "Form validation using jQuery" }, { "code": null, "e": 3191, "s": 3139, "text": "How to Change the Position of Scrollbar using CSS ?" }, { "code": null, "e": 3238, "s": 3191, "text": "What is the difference between SCSS and SASS ?" }, { "code": null, "e": 3262, "s": 3238, "text": "REST API (Introduction)" }, { "code": null, "e": 3315, "s": 3262, "text": "Hide or show elements in HTML using display property" }, { "code": null, "e": 3375, "s": 3315, "text": "How to set the default value for an HTML <select> element ?" }, { "code": null, "e": 3436, "s": 3375, "text": "How to set input type date in dd-mm-yyyy format using HTML ?" } ]

[ { "code": null, "e": 1308, "s": 1187, "text": "Let us suppose that we have to create an application such that we can show as well as hide the widgets whenever we need." }, { "code": null, "e": 1364, "s": 1308, "text": "The widgets can be hidden through pack_forget() method." }, { "code": null, "e": 1420, "s": 1364, "text": "The widgets can be hidden through pack_forget() method." }, { "code": null, "e": 1478, "s": 1420, "text": "To show the hidden widgets, we can use the pack() method." }, { "code": null, "e": 1536, "s": 1478, "text": "To show the hidden widgets, we can use the pack() method." }, { "code": null, "e": 1604, "s": 1536, "text": "Both methods can be invoked using the lambda or anonymous function." }, { "code": null, "e": 2289, "s": 1604, "text": "#Import the required library\nfrom tkinter import *\n\n#Create an instance of tkinter frame\nwin= Tk()\n\n#Define the geometry of the window\nwin.geometry(\"650x450\")\n\n#Define function to hide the widget\ndef hide_widget(widget):\n widget.pack_forget()\n\n#Define a function to show the widget\ndef show_widget(widget):\n widget.pack()\n\n#Create an Label Widget\nlabel= Label(win, text= \"Showing the Message\", font= ('Helvetica bold', 14))\nlabel.pack(pady=20)\n\n#Create a button Widget\nbutton_hide= Button(win, text= \"Hide\", command= lambda:hide_widget(label))\nbutton_hide.pack(pady=20)\n\nbutton_show= Button(win, text= \"Show\", command= lambda:show_widget(label))\nbutton_show.pack()\n\nwin.mainloop()" }, { "code": null, "e": 2417, "s": 2289, "text": "Running the above code will display a window with two buttons “Show” and “Hide” which can be used to show and hide the widgets." }, { "code": null, "e": 2502, "s": 2417, "text": "Now click on “Hide” button to hide the Label Text and “Show” to show the Label Text." } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n30 Apr, 2020" }, { "code": null, "e": 132, "s": 28, "text": "This map() Method in jQuery is used to translate all items in an array or object to new array of items." }, { "code": null, "e": 140, "s": 132, "text": "Syntax:" }, { "code": null, "e": 177, "s": 140, "text": "jQuery.map( array/object, callback )" }, { "code": null, "e": 269, "s": 177, "text": "Parameters: This method accept two parameters which is mentioned above and described below:" }, { "code": null, "e": 338, "s": 269, "text": "array/object: This parameter holds the Array or object to translate." }, { "code": null, "e": 412, "s": 338, "text": "callback: This parameter holds the function to process each item against." }, { "code": null, "e": 448, "s": 412, "text": "Return Value: It returns the array." }, { "code": null, "e": 509, "s": 448, "text": "Below examples illustrate the use of map() method in jQuery:" }, { "code": null, "e": 597, "s": 509, "text": "Example 1: This example use jQuery.map() method and return the square of array element." }, { "code": "<!DOCTYPE html><html> <head> <meta charset=\"utf-8\"> <title>JQuery | map() method</title> <script src=\"https://code.jquery.com/jquery-3.4.1.js\"> </script> </head> <body style=\"text-align:center;\"> <h1 style=\"color: green\"> GeeksforGeeks </h1> <h3>JQuery | map() method</h3> <b>Array = [2, 5, 6, 3, 8, 9]</b> <br> <br> <button onclick=\"geek()\">Click</button> <br> <br> <b id=\"root\"></b> <script> function geek() { var el = document.getElementById('root'); var arr = [2, 5, 6, 3, 8, 9]; var newArr = jQuery.map(arr, function(val, index) { return { number: val, square: val * val }; }) el.innerHTML = JSON.stringify(newArr); } </script></body> </html>", "e": 1451, "s": 597, "text": null }, { "code": null, "e": 1459, "s": 1451, "text": "Output:" }, { "code": null, "e": 1559, "s": 1459, "text": "Example 2: This example use map() method to concatenate character ‘A’ with every character of name." }, { "code": "<!DOCTYPE html><html> <head> <meta charset=\"utf-8\"> <title>JQuery | map() method</title> <script src=\"https://code.jquery.com/jquery-3.4.1.js\"> </script> </head> <body style=\"text-align:center;\"> <h1 style=\"color: green\"> GeeksforGeeks </h1> <h3>JQuery | map() method</h3> <b>String = \"Shubham\"</b> <br> <br> <button onclick=\"geek()\">Click</button> <br> <br> <b id=\"root\"></b> <script> function geek() { var el = document.getElementById('root'); var name = \"Shubham\"; name = name.split(\"\"); // New array of character and names // concatenated with 'A' var newName = jQuery.map(name, function(item) { return item + 'A<br>'; }) el.innerHTML = newName; } </script></body> </html> ", "e": 2447, "s": 1559, "text": null }, { "code": null, "e": 2455, "s": 2447, "text": "Output:" }, { "code": null, "e": 2470, "s": 2455, "text": "jQuery-Methods" }, { "code": null, "e": 2477, "s": 2470, "text": "JQuery" }, { "code": null, "e": 2494, "s": 2477, "text": "Web Technologies" } ]

[ { "code": null, "e": 54, "s": 26, "text": "\n23 Jul, 2021" }, { "code": null, "e": 276, "s": 54, "text": "Relative Position: Setting the top, right, bottom, and left properties of an element with position: relative; property will cause it to adjust from its normal position. The other objects or elements will not fill the gap." }, { "code": null, "e": 284, "s": 276, "text": "Syntax:" }, { "code": null, "e": 304, "s": 284, "text": "position: relative;" }, { "code": null, "e": 491, "s": 304, "text": "Absolute Position: An element with position: absolute; will cause it to adjust its position with respect to its parent. If no parent is present, then it uses the document body as parent." }, { "code": null, "e": 511, "s": 491, "text": "position: absolute;" }, { "code": null, "e": 527, "s": 511, "text": "Fixed Position:" }, { "code": null, "e": 720, "s": 527, "text": "Position: fixed; property applied to an element will cause it to always stay in the same place even if the page is scrolled. To position the element we use top, right, bottom, left properties." }, { "code": null, "e": 728, "s": 720, "text": "Syntax:" }, { "code": null, "e": 745, "s": 728, "text": "position: fixed;" }, { "code": null, "e": 836, "s": 745, "text": "Below example illustrates the differences between Relative Position and Absolute Position." }, { "code": null, "e": 855, "s": 836, "text": "Relative Position:" }, { "code": null, "e": 860, "s": 855, "text": "HTML" }, { "code": "<!DOCTYPE html><html> <head> <style> div.relative { position: relative; left: 50px; border: 3px solid #73AD21; } </style></head> <body> <h1>position: relative;</h1> <div class=\"relative\"> This element has position:relative; </div></body> </html>", "e": 1176, "s": 860, "text": null }, { "code": null, "e": 1184, "s": 1176, "text": "Output:" }, { "code": null, "e": 1203, "s": 1184, "text": "Absolute Position:" }, { "code": null, "e": 1208, "s": 1203, "text": "HTML" }, { "code": "<!DOCTYPE html><html> <head> <style> div.relative { position: relative; width: 400px; height: 200px; border: 3px solid #73AD21; } div.absolute { position: absolute; top: 80px; right: 80px; width: 200px; height: 100px; border: 3px solid #73AD21; } </style></head> <body> <h1>position: absolute;</h1> <div class=\"relative\"> This element has position: relative; <div class=\"absolute\"> This element has position: absolute; </div> </div></body> </html>", "e": 1851, "s": 1208, "text": null }, { "code": null, "e": 1859, "s": 1851, "text": "Output:" }, { "code": null, "e": 1875, "s": 1859, "text": "Fixed Position:" }, { "code": null, "e": 1880, "s": 1875, "text": "HTML" }, { "code": "<!DOCTYPE html><html> <head> <style> div.fixed { position: fixed; bottom: 0; right: 0; width: 300px; border: 3px solid #73AD21;} div.absolute { position: absolute; top: 150px; right: 80; width: 200px; height: 100px; border: 3px solid #73AD21; } </style></head> <body> <h1>position: absolute;</h1> <h2>position: fixed;</h2> <div class=\"absolute\">This element has position: absolute;</div> </div> </body> </html>", "e": 2347, "s": 1880, "text": null }, { "code": null, "e": 2355, "s": 2347, "text": "Output:" }, { "code": null, "e": 2368, "s": 2355, "text": "aktmishra143" }, { "code": null, "e": 2381, "s": 2368, "text": "geekyquentin" }, { "code": null, "e": 2390, "s": 2381, "text": "CSS-Misc" }, { "code": null, "e": 2400, "s": 2390, "text": "HTML-Misc" }, { "code": null, "e": 2404, "s": 2400, "text": "CSS" }, { "code": null, "e": 2423, "s": 2404, "text": "Difference Between" }, { "code": null, "e": 2428, "s": 2423, "text": "HTML" }, { "code": null, "e": 2439, "s": 2428, "text": "JavaScript" }, { "code": null, "e": 2456, "s": 2439, "text": "Web Technologies" }, { "code": null, "e": 2461, "s": 2456, "text": "HTML" }, { "code": null, "e": 2559, "s": 2461, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 2598, "s": 2559, "text": "Design a Tribute Page using HTML & CSS" }, { "code": null, "e": 2637, "s": 2598, "text": "How to set space between the flexbox ?" }, { "code": null, "e": 2676, "s": 2637, "text": "Build a Survey Form using HTML and CSS" }, { "code": null, "e": 2713, "s": 2676, "text": "Design a web page using HTML and CSS" }, { "code": null, "e": 2742, "s": 2713, "text": "Form validation using jQuery" }, { "code": null, "e": 2782, "s": 2742, "text": "Class method vs Static method in Python" }, { "code": null, "e": 2813, "s": 2782, "text": "Difference between BFS and DFS" }, { "code": null, "e": 2874, "s": 2813, "text": "Difference between var, let and const keywords in JavaScript" }, { "code": null, "e": 2942, "s": 2874, "text": "Difference Between Method Overloading and Method Overriding in Java" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n18 Jul, 2021" }, { "code": null, "e": 143, "s": 52, "text": "Prerequisites: Matrix Diagonalization, Eigenvector Computation and Low-Rank Approximations" }, { "code": null, "e": 297, "s": 143, "text": "Before getting in depth into the SVD, let us first briefly understand what Matrix Diagonalization technique is and when it fails to perform efficiently. " }, { "code": null, "e": 320, "s": 297, "text": "Matrix Diagonalization" }, { "code": null, "e": 633, "s": 320, "text": "Matrix diagonalization is the process of taking a square matrix and converting it into a special type of matrix known as the diagonal matrix. This matrix shares the same fundamental properties of the underlying matrix. Mathematically, any input matrix A can be reduced into any diagonal matrix D if it satisfies:" }, { "code": null, "e": 832, "s": 633, "text": "where,\nP -> Modal Matrix: It is a (n x n) matrix that consists of eigen-vectors. \n It is generally used in the process of diagonalization \n and similarity transformation." }, { "code": null, "e": 1088, "s": 832, "text": "However, the matrix diagonalization technique fails for matrices of the form (m x n) where m ≠ n. (i.e. when the matrix is not a square matrix. This is where ‘Singular Value Decomposition’ comes into picture and provides a good solution to this problem. " }, { "code": null, "e": 1108, "s": 1088, "text": "Singular Values (σ)" }, { "code": null, "e": 1385, "s": 1108, "text": "Let A be any m x n matrix with rank r. On multiply it with its transpose (i.e. ATA), a n x n matrix is created which is symmetric as well as positive semi-definite in nature. In simpler terms, all the Eigen values (λi...r) of ATA matrix are non-negative (i.e. greater than 0)." }, { "code": null, "e": 1475, "s": 1385, "text": "The singular values are defined as the square root of the obtained Eigen values. That is:" }, { "code": null, "e": 1510, "s": 1475, "text": "Singular Value Decomposition (SVD)" }, { "code": null, "e": 1729, "s": 1510, "text": "Let A be any m x n matrix. Then the SVD divides this matrix into 2 unitary matrices that are orthogonal in nature and a rectangular diagonal matrix containing singular values till r. Mathematically, it is expressed as:" }, { "code": null, "e": 1909, "s": 1729, "text": "where, \nΣ -> (m x n) orthogonal matrix\nU -> (m x m) orthogonal matrix \nV -> (n x n) diagonal matrix with first r rows having only singular values.\n (Rest of the values are 0) " }, { "code": null, "e": 1984, "s": 1909, "text": "Now, It is important to understand how to calculate the matrices U, V & Σ." }, { "code": null, "e": 2016, "s": 1984, "text": "Calculating orthogonal matrix V" }, { "code": null, "e": 2216, "s": 2016, "text": "First, we calculate the Eigen vectors xi associated with input matrix A. Then, we find the normalized vectors vi corresponding to xi by dividing each value in vector xi by its magnitude. For example:" }, { "code": null, "e": 2318, "s": 2216, "text": "Let x = [1,2,4]\n=> mag(x) or |x| = √(12 + 22 + 42) = √21.\n\nTherefore, v = [(1/√21), (2/√21), (4/√21)]" }, { "code": null, "e": 2475, "s": 2318, "text": "We know, A is a m x n matrix. Therefore, ATA is a n x n symmetric matrix with all Eigen values > 0. So, we can obtain Eigen vectors v1...n of ATA such that:" }, { "code": null, "e": 2605, "s": 2475, "text": "where,\nxi -> eigen vector\nvi -> normalized eigen vector.\nand\nσi -> corresponding singular value.\nλi -> corresponding eigen value." }, { "code": null, "e": 2666, "s": 2605, "text": "Upon calculating the Eigen vectors of AAT, matrix V will be:" }, { "code": null, "e": 2728, "s": 2666, "text": "where, v1, v2, ... vi are arranged column-wise into matrix V." }, { "code": null, "e": 2760, "s": 2728, "text": "Calculating orthogonal matrix U" }, { "code": null, "e": 2913, "s": 2760, "text": "Similarly, for any A (m x n) matrix, AAT is a m x m symmetric matrix with all eigen values > 0. So, we can obtain eigen vectors x1...n of AAT such that:" }, { "code": null, "e": 3013, "s": 2913, "text": "where,\nxi -> eigen vector.\nand\nσi -> corresponding singular value.\nλi -> corresponding eigen value." }, { "code": null, "e": 3069, "s": 3013, "text": "Now, we use the following equation to compute matrix U:" }, { "code": null, "e": 3105, "s": 3069, "text": "Upon calculating, matrix U will be:" }, { "code": null, "e": 3167, "s": 3105, "text": "where, u1, u2, ... ui are arranged column-wise into matrix U." }, { "code": null, "e": 3197, "s": 3167, "text": "Calculating diagonal matrix Σ" }, { "code": null, "e": 3249, "s": 3197, "text": "Here, matrix A has rank(A) = r where r ≤ min (m,n)." }, { "code": null, "e": 3337, "s": 3249, "text": "Case 1: If m ≤ n, say m = 2 & n = 4, then assuming all (σi > 0), Σ can be expressed as:" }, { "code": null, "e": 3425, "s": 3337, "text": "Case 2: If m ≥ n, say m = 5 & n = 3, then assuming all (σi > 0), Σ can be expressed as:" }, { "code": null, "e": 3527, "s": 3425, "text": "Special Case: When rank of matrix is specified, say r = 3, m = 6 & n = 4. Then Σ can be expressed as:" }, { "code": null, "e": 3571, "s": 3527, "text": "This implies that σ4 ≤ 0, hence discarded. " }, { "code": null, "e": 3659, "s": 3571, "text": "NOTE: The number of singular values where σi > 0 can determine the rank of the matrix. " }, { "code": null, "e": 3675, "s": 3659, "text": "Example Problem" }, { "code": null, "e": 3757, "s": 3675, "text": "Consider the following problem. Find the SVD of a (2 x 3) matrix A having values:" }, { "code": null, "e": 3766, "s": 3757, "text": "Solution" }, { "code": null, "e": 3831, "s": 3766, "text": "Let us understand each step required for solving such problems. " }, { "code": null, "e": 3870, "s": 3831, "text": "Step 1 - Find AT and then compute ATA." }, { "code": null, "e": 3996, "s": 3870, "text": "Step 2 - Find the eigen values associated with matrix ATA. \n (Discussed in the prerequisite articles mentioned above)" }, { "code": null, "e": 4044, "s": 3996, "text": "Eigen values associated with ATA: λ = 0, 1 & 3." }, { "code": null, "e": 4146, "s": 4044, "text": "Step 3 - Find the singular values corresponding to the obtained \n eigen values using formula:" }, { "code": null, "e": 4197, "s": 4146, "text": "Singular values associated with ATA: λ = 3, 1 & 0." }, { "code": null, "e": 4250, "s": 4197, "text": "λ1 = 3 -> σ1 = √3\nλ2 = 1 -> σ2 = 1 \nλ3 = 0 -> σ3 = 0" }, { "code": null, "e": 4359, "s": 4250, "text": "Step 4 - Compute diagonal matrix Σ using the values of σ keeping\n the above discussed cases in mind." }, { "code": null, "e": 4414, "s": 4359, "text": "As (m = 2 < n = 3), Case 1 is applied and matrix Σ is:" }, { "code": null, "e": 4590, "s": 4414, "text": "Step 5 - Find the eigen vectors & corresponding normalized eigen vectors\n associated with matrix ATA.\n (Discussed in the prerequisite articles mentioned above)" }, { "code": null, "e": 4684, "s": 4590, "text": "NOTE: It is important to understand that normalized eigen vectors of ATA define the matrix V." }, { "code": null, "e": 4719, "s": 4684, "text": "Eigen vectors associated with ATA:" }, { "code": null, "e": 4864, "s": 4719, "text": "For λ1 = 3 -> x1 = [1, 2, 1]\nFor λ2 = 1 -> x2 = [-1, 0, 1]\nFor λ3 = 0 -> x3 = [1, -1, 1]\n \nwhere x1, x2 and x3 are eigen vectors of matrix ATA. " }, { "code": null, "e": 4910, "s": 4864, "text": "Normalized eigen vectors associated with ATA:" }, { "code": null, "e": 5121, "s": 4910, "text": "For x1 = [1, 2, 1] => v1 = [(1/√6), (2/√6), (1/√6)]\nFor x2 = [-1, 0, 1] => v2 = [(-1/√2), 0, (1/√2)]\nFor x3 = [1, -1, 1] => v3 = [(1/√3), (-1/√3), (1/√3)]\n \nwhere v1, v2 and v3 are eigen vectors of matrix ATA. " }, { "code": null, "e": 5178, "s": 5121, "text": "Step 6 - Use eigen vectors obtained to compute matrix V." }, { "code": null, "e": 5253, "s": 5178, "text": "Step 7 - Use the above given equation to compute the orthogonal matrix U. " }, { "code": null, "e": 5288, "s": 5253, "text": "Therefore, orthogonal matrix U is:" }, { "code": null, "e": 5381, "s": 5288, "text": "Step 8 - Compute the SVD of A using the equation given below: \n (As discussed above)" }, { "code": null, "e": 5426, "s": 5381, "text": "Therefore, using SVD, A can be expressed as:" }, { "code": null, "e": 5443, "s": 5426, "text": "Machine Learning" }, { "code": null, "e": 5450, "s": 5443, "text": "Python" }, { "code": null, "e": 5467, "s": 5450, "text": "Machine Learning" }, { "code": null, "e": 5565, "s": 5467, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 5589, "s": 5565, "text": "Search Algorithms in AI" }, { "code": null, "e": 5627, "s": 5589, "text": "Getting started with Machine Learning" }, { "code": null, "e": 5668, "s": 5627, "text": "Introduction to Recurrent Neural Network" }, { "code": null, "e": 5701, "s": 5668, "text": "Support Vector Machine Algorithm" }, { "code": null, "e": 5737, "s": 5701, "text": "ML | Monte Carlo Tree Search (MCTS)" }, { "code": null, "e": 5765, "s": 5737, "text": "Read JSON file using Python" }, { "code": null, "e": 5815, "s": 5765, "text": "Adding new column to existing DataFrame in Pandas" }, { "code": null, "e": 5837, "s": 5815, "text": "Python map() function" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n15 Oct, 2018" }, { "code": null, "e": 238, "s": 28, "text": "OpenCV (Open Source Computer Vision) is a computer vision library that contains various functions to perform operations on Images or videos. OpenCV library can be used to perform multiple operations on videos." }, { "code": null, "e": 287, "s": 238, "text": "Let’s see how to detect the corner in the image." }, { "code": null, "e": 676, "s": 287, "text": "cv2.goodFeaturesToTrack() method finds N strongest corners in the image by Shi-Tomasi method. Note that the image should be a grayscale image. Specify the number of corners you want to find and the quality level (which is a value between 0-1). It denotes the minimum quality of corner below which everyone is rejected. Then provide the minimum Euclidean distance between corners detected." }, { "code": null, "e": 813, "s": 676, "text": "Syntax : cv2.goodFeaturesToTrack(image, maxCorners, qualityLevel, minDistance[, corners[, mask[, blockSize[, useHarrisDetector[, k]]]]])" }, { "code": null, "e": 844, "s": 813, "text": "Image before corner detection:" }, { "code": "# import the required libraryimport numpy as npimport cv2from matplotlib import pyplot as plt # read the imageimg = cv2.imread('corner1.png') # convert image to gray scale imagegray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) # detect corners with the goodFeaturesToTrack function.corners = cv2.goodFeaturesToTrack(gray, 27, 0.01, 10)corners = np.int0(corners) # we iterate through each corner, # making a circle at each point that we think is a corner.for i in corners: x, y = i.ravel() cv2.circle(img, (x, y), 3, 255, -1) plt.imshow(img), plt.show()", "e": 1405, "s": 844, "text": null }, { "code": null, "e": 1436, "s": 1405, "text": "Image after corner detection –" }, { "code": null, "e": 1453, "s": 1436, "text": "Image-Processing" }, { "code": null, "e": 1460, "s": 1453, "text": "OpenCV" }, { "code": null, "e": 1467, "s": 1460, "text": "Python" }, { "code": null, "e": 1565, "s": 1467, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 1583, "s": 1565, "text": "Python Dictionary" }, { "code": null, "e": 1625, "s": 1583, "text": "Different ways to create Pandas Dataframe" }, { "code": null, "e": 1647, "s": 1625, "text": "Enumerate() in Python" }, { "code": null, "e": 1682, "s": 1647, "text": "Read a file line by line in Python" }, { "code": null, "e": 1708, "s": 1682, "text": "Python String | replace()" }, { "code": null, "e": 1740, "s": 1708, "text": "How to Install PIP on Windows ?" }, { "code": null, "e": 1769, "s": 1740, "text": "*args and **kwargs in Python" }, { "code": null, "e": 1799, "s": 1769, "text": "Iterate over a list in Python" }, { "code": null, "e": 1826, "s": 1799, "text": "Python Classes and Objects" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n19 Aug, 2021" }, { "code": null, "e": 253, "s": 28, "text": "The Navigator userAgent property is used for returning the user-agent header’s value sent to the server by the browser. It returns a string representing values such as the name, version, and platform of the browser.Syntax: " }, { "code": null, "e": 273, "s": 253, "text": "navigator.userAgent" }, { "code": null, "e": 356, "s": 273, "text": "Return Value: A String, representing the user agent string for the current browser" }, { "code": null, "e": 418, "s": 356, "text": "Below program illustrates the Navigator userAgent Property: " }, { "code": null, "e": 423, "s": 418, "text": "html" }, { "code": "<!DOCTYPE html><html> <head> <title> Navigator userAgent Property in HTML </title> <style> h1 { color: green; } h2 { font-family: Impact; } body { text-align: center; } </style></head> <body> <h1>GeeksforGeeks</h1> <h2>Navigator userAgent Property</h2> <p> For checking the browser's User-agent header name, double click the \"Check User Agent\" button: </p> <button ondblclick=\"checkua()\"> Check User Agent </button> <p id=\"header\"></p> <script> function checkua() { var u = \"User-agent header sent by the browser : \" + navigator.userAgent; document.getElementById(\"header\").innerHTML = u; } </script> </body> </html> ", "e": 1289, "s": 423, "text": null }, { "code": null, "e": 1299, "s": 1289, "text": "Output: " }, { "code": null, "e": 1327, "s": 1299, "text": "After clicking the button " }, { "code": null, "e": 1412, "s": 1327, "text": "Supported Browsers: The browser supported by Navigator userAgent are listed below: " }, { "code": null, "e": 1426, "s": 1412, "text": "Google Chrome" }, { "code": null, "e": 1444, "s": 1426, "text": "Internet Explorer" }, { "code": null, "e": 1452, "s": 1444, "text": "Firefox" }, { "code": null, "e": 1458, "s": 1452, "text": "Opera" }, { "code": null, "e": 1465, "s": 1458, "text": "Safari" }, { "code": null, "e": 1481, "s": 1467, "text": "ManasChhabra2" }, { "code": null, "e": 1495, "s": 1481, "text": "HTML-Property" }, { "code": null, "e": 1500, "s": 1495, "text": "HTML" }, { "code": null, "e": 1517, "s": 1500, "text": "Web Technologies" }, { "code": null, "e": 1522, "s": 1517, "text": "HTML" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n15 Feb, 2022" }, { "code": null, "e": 148, "s": 52, "text": "Given a number n, count minimum steps to minimize it to 1 according to the following criteria: " }, { "code": null, "e": 200, "s": 148, "text": "If n is divisible by 2 then we may reduce n to n/2." }, { "code": null, "e": 253, "s": 200, "text": "If n is divisible by 3 then you may reduce n to n/3." }, { "code": null, "e": 271, "s": 253, "text": "Decrement n by 1." }, { "code": null, "e": 282, "s": 271, "text": "Examples: " }, { "code": null, "e": 330, "s": 282, "text": "Input : n = 10\nOutput : 3\n\nInput : 6\nOutput : 2" }, { "code": null, "e": 371, "s": 330, "text": "Greedy Approach (Doesn’t work always) : " }, { "code": null, "e": 492, "s": 371, "text": "As per greedy approach we may choose the step that makes n as low as possible and continue the same, till it reaches 1. " }, { "code": null, "e": 627, "s": 492, "text": "while ( n > 1)\n{\n if (n % 3 == 0)\n n /= 3; \n else if (n % 2 == 0)\n n /= 2;\n else\n n--;\n steps++;\n}" }, { "code": null, "e": 889, "s": 627, "text": "If we observe carefully, the greedy strategy doesn’t work here. Eg: Given n = 10 , Greedy –> 10 /2 = 5 -1 = 4 /2 = 2 /2 = 1 ( 4 steps ). But the optimal way is –> 10 -1 = 9 /3 = 3 /3 = 1 ( 3 steps ). So, we must think of a dynamic approach for optimal solution." }, { "code": null, "e": 982, "s": 889, "text": "Dynamic Approach: For finding minimum steps we have three possibilities for n and they are: " }, { "code": null, "e": 1088, "s": 982, "text": "f(n) = 1 + f(n-1)\nf(n) = 1 + f(n/2) // if n is divisible by 2\nf(n) = 1 + f(n/3) // if n is divisible by 3" }, { "code": null, "e": 1158, "s": 1088, "text": "Below is memoization based implementation of above recursive formula." }, { "code": null, "e": 1162, "s": 1158, "text": "C++" }, { "code": null, "e": 1167, "s": 1162, "text": "Java" }, { "code": null, "e": 1175, "s": 1167, "text": "Python3" }, { "code": null, "e": 1178, "s": 1175, "text": "C#" }, { "code": null, "e": 1182, "s": 1178, "text": "PHP" }, { "code": null, "e": 1193, "s": 1182, "text": "Javascript" }, { "code": "// CPP program to minimize n to 1 by given// rule in minimum steps#include <bits/stdc++.h>using namespace std; // function to calculate min stepsint getMinSteps(int n, int *memo){ // base case if (n == 1) return 0; if (memo[n] != -1) return memo[n]; // store temp value for n as min( f(n-1), // f(n/2), f(n/3)) +1 int res = getMinSteps(n-1, memo); if (n%2 == 0) res = min(res, getMinSteps(n/2, memo)); if (n%3 == 0) res = min(res, getMinSteps(n/3, memo)); // store memo[n] and return memo[n] = 1 + res; return memo[n];} // This function mainly initializes memo[] and// calls getMinSteps(n, memo)int getMinSteps(int n){ int memo[n+1]; // initialize memoized array for (int i=0; i<=n; i++) memo[i] = -1; return getMinSteps(n, memo);} // driver programint main(){ int n = 10; cout << getMinSteps(n); return 0;}", "e": 2094, "s": 1193, "text": null }, { "code": "// Java program to minimize n to 1// by given rule in minimum stepsimport java.io.*;class GFG { // function to calculate min stepsstatic int getMinSteps(int n, int memo[]){ // base case if (n == 1) return 0; if (memo[n] != -1) return memo[n]; // store temp value for // n as min( f(n-1), // f(n/2), f(n/3)) +1 int res = getMinSteps(n - 1, memo); if (n % 2 == 0) res = Math.min(res, getMinSteps(n / 2, memo)); if (n % 3 == 0) res = Math.min(res, getMinSteps(n / 3, memo)); // store memo[n] and return memo[n] = 1 + res; return memo[n];} // This function mainly// initializes memo[] and// calls getMinSteps(n, memo)static int getMinSteps(int n){ int memo[] = new int[n + 1]; // initialize memoized array for (int i = 0; i <= n; i++) memo[i] = -1; return getMinSteps(n, memo);} // Driver Code public static void main (String[] args) { int n = 10; System.out.println(getMinSteps(n)); }} // This code is contributed by anuj_67.", "e": 3151, "s": 2094, "text": null }, { "code": "# Python program to minimize# n to 1 by given# rule in minimum steps # function to calculate min stepsdef getMinSteps(n, memo): # base case if (n == 1): return 0 if (memo[n] != -1): return memo[n] # store temp value for n as min(f(n-1), # f(n//2), f(n//3)) + 1 res = getMinSteps(n-1, memo) if (n%2 == 0): res = min(res, getMinSteps(n//2, memo)) if (n%3 == 0): res = min(res, getMinSteps(n//3, memo)) # store memo[n] and return memo[n] = 1 + res return memo[n] # This function mainly# initializes memo[] and# calls getMinSteps(n, memo)def getsMinSteps(n): memo = [0 for i in range(n+1)] # initialize memoized array for i in range(n+1): memo[i] = -1 return getMinSteps(n, memo) # driver programn = 10print(getsMinSteps(n)) # This code is contributed by Soumen Ghosh. ", "e": 4005, "s": 3151, "text": null }, { "code": "// C# program to minimize n to 1// by given rule in minimum stepsusing System; class GFG { // function to calculate min steps static int getMinSteps(int n, int []memo) { // base case if (n == 1) return 0; if (memo[n] != -1) return memo[n]; // store temp value for // n as min( f(n-1), // f(n/2), f(n/3)) +1 int res = getMinSteps(n - 1, memo); if (n % 2 == 0) res = Math.Min(res, getMinSteps(n / 2, memo)); if (n % 3 == 0) res = Math.Min(res, getMinSteps(n / 3, memo)); // store memo[n] and return memo[n] = 1 + res; return memo[n]; } // This function mainly // initializes memo[] and // calls getMinSteps(n, memo) static int getMinSteps(int n) { int []memo = new int[n + 1]; // initialize memoized array for (int i = 0; i <= n; i++) memo[i] = -1; return getMinSteps(n, memo); } // Driver Code public static void Main () { int n = 10; Console.WriteLine(getMinSteps(n)); }} // This code is contributed by anuj_67.", "e": 5211, "s": 4005, "text": null }, { "code": "<?php// PHP program to minimize n to 1 by// given rule in minimum steps // function to calculate min stepsfunction getMinSteps( $n, $memo){ // base case if ($n == 1) return 0; if ($memo[$n] != -1) return $memo[$n]; // store temp value for n // as min( f(n-1), // f(n/2), f(n/3)) +1 $res = getMinSteps($n - 1, $memo); if ($n % 2 == 0) $res = min($res, getMinSteps($n / 2, $memo)); if ($n % 3 == 0) $res = min($res, getMinSteps($n / 3, $memo)); // store memo[n] and return $memo[$n] = 1 + $res; return $memo[$n];} // This function mainly initializes// memo[] and calls getMinSteps(n, memo)function g_etMinSteps( $n){ $memo= array(); // initialize memoized array for($i = 0; $i <= $n; $i++) $memo[$i] = -1; return getMinSteps($n, $memo);} // Driver Code $n = 10; echo g_etMinSteps($n); // This code is contributed by anuj_67.?>", "e": 6148, "s": 5211, "text": null }, { "code": "<script>// javascript program to minimize n to 1// by given rule in minimum steps // function to calculate min steps function getMinSteps(n , memo) { // base case if (n == 1) return 0; if (memo[n] != -1) return memo[n]; // store temp value for // n as min( f(n-1), // f(n/2), f(n/3)) +1 var res = getMinSteps(n - 1, memo); if (n % 2 == 0) res = Math.min(res, getMinSteps(n / 2, memo)); if (n % 3 == 0) res = Math.min(res, getMinSteps(n / 3, memo)); // store memo[n] and return memo[n] = 1 + res; return memo[n]; } // This function mainly // initializes memo and // calls getMinSteps(n, memo) function getMinStep(n) { var memo = Array(n + 1).fill(0); // initialize memoized array for (var i = 0; i <= n; i++) memo[i] = -1; return getMinSteps(n, memo); } // Driver Code var n = 10; document.write(getMinStep(n)); // This code is contributed by Rajput-Ji</script>", "e": 7241, "s": 6148, "text": null }, { "code": null, "e": 7243, "s": 7241, "text": "3" }, { "code": null, "e": 7300, "s": 7243, "text": "Time Complexity: O(n), as there will be n unique calls. " }, { "code": null, "e": 7323, "s": 7300, "text": "Space Complexity: O(n)" }, { "code": null, "e": 7364, "s": 7323, "text": "Below is a tabulation based solution : " }, { "code": null, "e": 7368, "s": 7364, "text": "C++" }, { "code": null, "e": 7373, "s": 7368, "text": "Java" }, { "code": null, "e": 7381, "s": 7373, "text": "Python3" }, { "code": null, "e": 7384, "s": 7381, "text": "C#" }, { "code": null, "e": 7388, "s": 7384, "text": "PHP" }, { "code": null, "e": 7399, "s": 7388, "text": "Javascript" }, { "code": "#include <bits/stdc++.h>using namespace std; int getMinSteps(int n){ int table[n+1]; table[1]=0; for (int i=2; i<=n; i++) { if (!(i%2) && (i%3)) table[i] = 1+min(table[i-1], table[i/2]); else if (!(i%3) && (i%2)) table[i] = 1+min(table[i-1], table[i/3]); else if(!(i%2) && !(i%3)) table[i] = 1+min(table[i-1],min(table[i/2],table[i/3])); else table[i] =1+table[i-1]; } return table[n];} // driver programint main(){ int n = 14; cout << getMinSteps(n); return 0;}", "e": 7929, "s": 7399, "text": null }, { "code": "// A tabulation based// solution in Javaimport java.io.*; class GFG { static int getMinSteps(int n) { int[] dp = new int[n + 1]; dp[1] = 0; for (int i = 2; i <= n; i++) { int min = dp[i - 1]; if (i % 2 == 0) { min = Math.min(min, dp[i / 2]); } if (i % 3 == 0) { min = Math.min(min, dp[i / 3]); } dp[i] = min + 1; } return dp[n]; } // Driver Code public static void main(String[] args) { int n = 14; System.out.print(getMinSteps(n)); }} // This code is contributed// by anmol_sharma.", "e": 8583, "s": 7929, "text": null }, { "code": "# A tabulation based solution in Python3 def getMinSteps(n) : table = [0] * (n + 1) for i in range(n + 1) : table[i] = n-i for i in range(n, 0, -1) : if (not(i%2)) : table[i//2] = min(table[i]+1, table[i//2]) if (not(i%3)) : table[i//3] = min(table[i]+1, table[i//3]) return table[1] # driver programif __name__ == \"__main__\" : n = 14 print(getMinSteps(n)) # This code is contributed by Ryuga", "e": 9097, "s": 8583, "text": null }, { "code": "// A tabulation based// solution in C#using System; class GFG{static int getMinSteps(int n){ int []table = new int[n + 1]; for (int i = 0; i <= n; i++) table[i] = n - i; for (int i = n; i >= 1; i--) { if (!(i % 2 > 0)) table[i / 2] = Math.Min(table[i] + 1, table[i / 2]); if (!(i % 3 > 0)) table[i / 3] = Math.Min(table[i] + 1, table[i / 3]); } return table[1];} // Driver Codepublic static void Main (){ int n = 10; Console.WriteLine(getMinSteps(n));}} // This code is contributed// by anuj_67.", "e": 9706, "s": 9097, "text": null }, { "code": "<?php// A tabulation based solution in PHP function getMinSteps( $n){ $table = array(); for ($i = 0; $i <= $n; $i++) $table[$i] = $n - $i; for ($i = $n; $i >= 1; $i--) { if (!($i % 2)) $table[$i / 2] = min($table[$i] + 1, $table[$i / 2]); if (!($i % 3)) $table[$i / 3] = min($table[$i] + 1, $table[$i / 3]); } return $table[1];} // Driver Code $n = 10; echo getMinSteps($n); // This code is contributed by anuj_67.?>", "e": 10244, "s": 9706, "text": null }, { "code": "<script> // A tabulation based solution in Javascript function getMinSteps(n) { let table = new Array(n+1); table.fill(0); table[1]=0; for (let i=2; i<=n; i++) { if (!(i%2) && (i%3)) table[i] = 1+Math.min(table[i-1], table[i/2]); else if (!(i%3) && (i%2)) table[i] = 1+Math.min(table[i-1], table[i/3]); else if(!(i%2) && !(i%3)) table[i] = 1+Math.min(table[i-1], Math.min(table[i/2],table[i/3])); else table[i] =1+table[i-1]; } return table[n] + 1; } let n = 10; document.write(getMinSteps(n)); </script>", "e": 10932, "s": 10244, "text": null }, { "code": null, "e": 10934, "s": 10932, "text": "4" }, { "code": null, "e": 10990, "s": 10934, "text": "Time Complexity: O(n), as there will be n unique calls." }, { "code": null, "e": 11013, "s": 10990, "text": "Space Complexity: O(n)" }, { "code": null, "e": 11030, "s": 11013, "text": "Using recursion:" }, { "code": null, "e": 11034, "s": 11030, "text": "C++" }, { "code": null, "e": 11039, "s": 11034, "text": "Java" }, { "code": null, "e": 11047, "s": 11039, "text": "Python3" }, { "code": null, "e": 11050, "s": 11047, "text": "C#" }, { "code": null, "e": 11061, "s": 11050, "text": "Javascript" }, { "code": "// C++ program for the above approach#include <bits/stdc++.h>using namespace std;int getMinSteps(int n){ // If n is equal to 1 if (n == 1) return 0; int sub = INT_MAX; int div2 = INT_MAX; int div3 = INT_MAX; sub = getMinSteps(n - 1); if (n % 2 == 0) div2 = getMinSteps(n / 2); if (n % 3 == 0) div3 = getMinSteps(n / 3); return 1 + min(sub, min(div2, div3));} // Driver codeint main(){ int n = 10; // Function Call cout << (getMinSteps(n)); } // This code is contributed by Potta Lokesh", "e": 11611, "s": 11061, "text": null }, { "code": "// Java program for the above programimport java.io.*; class GFG { public static int getMinSteps(int n) { // If n is equal to 1 if (n == 1) return 0; int sub = Integer.MAX_VALUE; int div2 = Integer.MAX_VALUE; int div3 = Integer.MAX_VALUE; sub = getMinSteps(n - 1); if (n % 2 == 0) div2 = getMinSteps(n / 2); if (n % 3 == 0) div3 = getMinSteps(n / 3); return 1 + Math.min(sub, Math.min(div2, div3)); } // Driver Code public static void main(String[] args) { int n = 10; // Function Call System.out.print(getMinSteps(n)); }}", "e": 12310, "s": 11611, "text": null }, { "code": "# Python program for the above programimport sysdef getMinSteps(n): # If n is equal to 1 if (n == 1): return 0; sub = sys.maxsize; div2 = sys.maxsize; div3 = sys.maxsize; sub = getMinSteps(n - 1); if (n % 2 == 0): div2 = getMinSteps(n // 2); if (n % 3 == 0): div3 = getMinSteps(n // 3); return 1 + min(sub, min(div2, div3)); # Driver Codeif __name__ == '__main__': n = 10; # Function Call print(getMinSteps(n)); # This code is contributed by Rajput-Ji", "e": 12828, "s": 12310, "text": null }, { "code": "// C# program for the above programusing System; class GFG{ public static int getMinSteps(int n) { // If n is equal to 1 if (n == 1) return 0; int sub = Int32.MaxValue; int div2 = Int32.MaxValue; int div3 = Int32.MaxValue; sub = getMinSteps(n - 1); if (n % 2 == 0) div2 = getMinSteps(n / 2); if (n % 3 == 0) div3 = getMinSteps(n / 3); return 1 + Math.Min(sub, Math.Min(div2, div3)); } // Driver Code public static void Main(String[] args) { int n = 10; // Function Call Console.Write(getMinSteps(n)); }} //This code is contributed by shivansinghss2110", "e": 13563, "s": 12828, "text": null }, { "code": "<script> function getMinSteps(n) { // If n is equal to 1 if (n == 1) return 0; let sub = Number.MAX_VALUE; let div2 = Number.MAX_VALUE; let div3 = Number.MAX_VALUE; sub = getMinSteps(n - 1); if (n % 2 == 0) div2 = getMinSteps(n / 2); if (n % 3 == 0) div3 = getMinSteps(n / 3); return 1 + Math.min(sub, Math.min(div2, div3)); } let n = 10; // Function Call document.write(getMinSteps(n)); </script>", "e": 14129, "s": 13563, "text": null }, { "code": null, "e": 14131, "s": 14129, "text": "3" }, { "code": null, "e": 14169, "s": 14131, "text": "Time Complexity: Exponential(O(2^n)) " }, { "code": null, "e": 14603, "s": 14169, "text": "This article is contributed by Shivam Pradhan (anuj_charm). If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to [email protected]. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above." }, { "code": null, "e": 14608, "s": 14603, "text": "vt_m" }, { "code": null, "e": 14616, "s": 14608, "text": "ankthon" }, { "code": null, "e": 14620, "s": 14616, "text": "le0" }, { "code": null, "e": 14632, "s": 14620, "text": "tr_abhishek" }, { "code": null, "e": 14645, "s": 14632, "text": "ANMOL_SHARMA" }, { "code": null, "e": 14663, "s": 14645, "text": "divyeshrabadiya07" }, { "code": null, "e": 14672, "s": 14663, "text": "suresh07" }, { "code": null, "e": 14691, "s": 14672, "text": "shivanisinghss2110" }, { "code": null, "e": 14705, "s": 14691, "text": "lokeshpotta20" }, { "code": null, "e": 14714, "s": 14705, "text": "pbpcodes" }, { "code": null, "e": 14724, "s": 14714, "text": "Rajput-Ji" }, { "code": null, "e": 14744, "s": 14724, "text": "Dynamic Programming" }, { "code": null, "e": 14764, "s": 14744, "text": "Dynamic Programming" } ]

[ { "code": null, "e": 54, "s": 26, "text": "\n16 Jun, 2022" }, { "code": null, "e": 209, "s": 54, "text": "Given a 2D vector of NxM integers. The task is to sort the elements of the vectors diagonally from top-left to bottom-right in decreasing order.Examples: " }, { "code": null, "e": 413, "s": 209, "text": "Input: arr[][] = { { 10, 2, 3 }, { 4, 5, 6 }, {7, 8, 9 } } Output: 10 6 3 8 9 2 7 4 5Input: arr[][] = { { 10, 2, 43 }, { 40, 5, 16 }, { 71, 8, 29 }, {1, 100, 5} } Output: 29 16 43 40 10 2 100 8 5 1 71 5 " }, { "code": null, "e": 439, "s": 413, "text": "Approach: Observations: " }, { "code": null, "e": 678, "s": 439, "text": "The above images show the difference between the column index and row index at each cell. The cells having the same difference from top-left to bottom-down cell forms a diagonal. Below are the steps to sort diagonal in decreasing order: " }, { "code": null, "e": 1367, "s": 678, "text": "Store the diagonal element with a positive difference in one Array of Vectors(say Pos[]) such that elements at the cell having difference(say a) is stored at index an of Pos[] array.Store the diagonal element with the negative difference in another Array of Vectors(say Neg[]) such that elements at the cell having difference(say -b) is stored at index abs(-b) = b of Neg[] array.Sort both the Array of Vectors increasing order.Traverse the given 2D vector and updated the value at the current cell with the value stored in Pos[] and Neg[] array. If the difference between column and row index(say d) is positive, then updated the value from Pos[d] array and remove the last element as: " }, { "code": null, "e": 1550, "s": 1367, "text": "Store the diagonal element with a positive difference in one Array of Vectors(say Pos[]) such that elements at the cell having difference(say a) is stored at index an of Pos[] array." }, { "code": null, "e": 1749, "s": 1550, "text": "Store the diagonal element with the negative difference in another Array of Vectors(say Neg[]) such that elements at the cell having difference(say -b) is stored at index abs(-b) = b of Neg[] array." }, { "code": null, "e": 1798, "s": 1749, "text": "Sort both the Array of Vectors increasing order." }, { "code": null, "e": 2059, "s": 1798, "text": "Traverse the given 2D vector and updated the value at the current cell with the value stored in Pos[] and Neg[] array. If the difference between column and row index(say d) is positive, then updated the value from Pos[d] array and remove the last element as: " }, { "code": null, "e": 2201, "s": 2059, "text": "If the difference between column and row index(say d) is positive, then updated the value from Pos[d] array and remove the last element as: " }, { "code": null, "e": 2262, "s": 2201, "text": "d = i - j\narr[i][j] = Pos[d][Pos.size()-1]\nPos[d].pop_back()" }, { "code": null, "e": 2402, "s": 2262, "text": "If the difference between column and row index(say d) is negative, then updated the value from Neg[d] array and remove the last element as:" }, { "code": null, "e": 2463, "s": 2402, "text": "d = j - i\narr[i][j] = Neg[d][Neg.size()-1]\nNeg[d].pop_back()" }, { "code": null, "e": 2515, "s": 2463, "text": "Below is the implementation of the above approach: " }, { "code": null, "e": 2519, "s": 2515, "text": "CPP" }, { "code": null, "e": 2524, "s": 2519, "text": "Java" }, { "code": null, "e": 2532, "s": 2524, "text": "Python3" }, { "code": "// C++ program to sort the 2D vector// diagonally in decreasing order#include \"bits/stdc++.h\"using namespace std; // Function that sort the elements// of 2D vectorvoid diagonalSort(vector<vector<int> >& mat){ // Calculate the rows and column int row = mat.size(); int col = mat[0].size(); // Array of vectors to store the // diagonal elements vector<int> Neg[row]; vector<int> Pos[col]; // Traverse the 2D vector and put // element in Array of vectors at // index difference between indexes for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { // If diff is negative, then // push element to Neg[] if (j < i) { Neg[i - j].push_back(mat[i][j]); } // If diff is positive, then // push element to Pos[] else if (j > i) { Pos[j - i].push_back(mat[i][j]); } // If diff is 0, then push // element to Pos[0] else { Pos[0].push_back(mat[i][j]); } } } // Sort the Array of vectors for (int i = 0; i < row; i++) { sort(Neg[i].begin(), Neg[i].end()); } for (int i = 0; i < col; i++) { sort(Pos[i].begin(), Pos[i].end()); } // Update the value to arr[][] // from the sorted Array of vectors for (int i = 0; i < row; i++) { for (int j = 0; j < col; j++) { // If diff is positive if (j < i) { int d = i - j; int l = Neg[d].size(); mat[i][j] = Neg[d][l - 1]; Neg[d].pop_back(); } // If diff is negative else if (j > i) { int d = j - i; int l = Pos[d].size(); mat[i][j] = Pos[d][l - 1]; Pos[d].pop_back(); } // If diff is 0 else { int l = Pos[0].size(); mat[i][j] = Pos[0][l - 1]; Pos[0].pop_back(); } } }} // Function to print elementvoid printElement(vector<vector<int> >& arr){ // Traverse the 2D vector for (int i = 0; i < arr.size(); i++) { for (int j = 0; j < arr[0].size(); j++) { cout << arr[i][j] << ' '; } cout << endl; }} // Driver Codeint main(){ vector<vector<int> > arr = { { 10, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; diagonalSort(arr); // Function call to print elements printElement(arr);}", "e": 5050, "s": 2532, "text": null }, { "code": "// Java program to sort the 2D matrix// diagonally in decreasing orderimport java.io.*;import java.util.*; class GFG { public static void diagonalSort(ArrayList<ArrayList<Integer> > mat) { // Calculate the rows and column int row = mat.size(); int col = mat.get(0).size(); // Arraylist of Arraylist to store the // diagonal elements ArrayList<ArrayList<Integer> > Neg = new ArrayList<ArrayList<Integer> >(); ArrayList<ArrayList<Integer> > Pos = new ArrayList<ArrayList<Integer> >(); int i, j; for (i = 0; i < row; i++) { ArrayList<Integer> temp = new ArrayList<Integer>(); Neg.add(temp); } for (j = 0; j < col; j++) { ArrayList<Integer> temp = new ArrayList<Integer>(); Pos.add(temp); } // Traverse the 2D matrix and put // element in Arraylist of Arraylist at // index difference between indexes for (i = 0; i < row; i++) { for (j = 0; j < col; j++) { // If diff is negative, then // push element to Neg[] if (j < i) { Neg.get(i - j).add(mat.get(i).get(j)); } // If diff is positive, then // push element to Pos[] else if (i < j) { Pos.get(j - i).add(mat.get(i).get(j)); } // If diff is 0, then push // element to Pos[0] else { Pos.get(0).add(mat.get(i).get(j)); } } } // Sort the Array of vectors for (i = 0; i < row; i++) { Collections.sort(Neg.get(i)); ; } for (i = 0; i < col; i++) { Collections.sort(Pos.get(i)); ; } // Update the value to mat // from the sorted Arraylist of Arraylist for (i = 0; i < row; i++) { for (j = 0; j < col; j++) { // If diff is positive if (j < i) { int d = i - j; int l = Neg.get(d).size(); mat.get(i).set(j, Neg.get(d).get(l - 1)); Neg.get(d).remove(l - 1); } // If diff is negative else if (i < j) { int d = j - i; int l = Pos.get(d).size(); mat.get(i).set(j, Pos.get(d).get(l - 1)); Pos.get(d).remove(l - 1); } // If diff is 0 else { int l = Pos.get(0).size(); mat.get(i).set(j, Pos.get(0).get(l - 1)); Pos.get(0).remove(l - 1); } } } // Print diagonally sorted matrix for (i = 0; i < row; i++) { for (j = 0; j < col; j++) { System.out.print(mat.get(i).get(j) + \" \"); } System.out.println(); } } // Driver Code public static void main(String[] args) { ArrayList<ArrayList<Integer> > arr = new ArrayList<ArrayList<Integer> >(); ArrayList<Integer> row1 = new ArrayList<Integer>(); row1.add(10); row1.add(2); row1.add(3); arr.add(row1); ArrayList<Integer> row2 = new ArrayList<Integer>(); row2.add(4); row2.add(5); row2.add(6); arr.add(row2); ArrayList<Integer> row3 = new ArrayList<Integer>(); row3.add(7); row3.add(8); row3.add(9); arr.add(row3); diagonalSort(arr); }} // This code is contributed by Snigdha Patil", "e": 8906, "s": 5050, "text": null }, { "code": "# Python program for the above approachfrom collections import defaultdict def diagonalSort(matrix, n, m): # make a dict of list, where we # will store the diagonal elements to = defaultdict(list) # store the diagonal elements with # respect to their row-col value # remember every row-col value for # each diagonal will be different for row in range(n): for col in range(m): to[row-col].append(matrix[row][col]) # sort the elements of each # diagonal as required for i in to: to[i].sort(reverse=True) # store the new diagonal elements to # their respective position in the matrix for row in range(n): for col in range(m): matrix[row][col] = to[row-col].pop(0) return matrix # Driver Codeif __name__ == \"__main__\": matrix = [[10, 2, 3], [4, 5, 6], [7, 8, 9]] n = len(matrix) m = len(matrix[0]) matrix = diagonalSort(matrix, n, m) for row in range(n): for col in range(m): print(matrix[row][col], end=' ') print() # This code is contributed by ajaymakvana.", "e": 10033, "s": 8906, "text": null }, { "code": null, "e": 10055, "s": 10033, "text": "10 6 3 \n8 9 2 \n7 4 5 " }, { "code": null, "e": 10093, "s": 10055, "text": "Time Complexity: O(N*M*log(min(N,M)))" }, { "code": null, "e": 10118, "s": 10093, "text": "Space Complexity: O(N*M)" }, { "code": null, "e": 10129, "s": 10118, "text": "Method 2 :" }, { "code": null, "e": 10421, "s": 10129, "text": "here in this method, we will do space optimization in the above method. here we traverse matrix diagonal and store their values in the extra 1D array so for every diagonal we will need to store the maximum min(n,m) element in our 1D array so this is space optimization in the above solution " }, { "code": null, "e": 10425, "s": 10421, "text": "C++" }, { "code": null, "e": 10430, "s": 10425, "text": "Java" }, { "code": null, "e": 10438, "s": 10430, "text": "Python3" }, { "code": "// C++ program to sort the 2D vector// diagonally in decreasing order#include <bits/stdc++.h>using namespace std; // Function that sort 2D matrix Diagonally In Descending ordervoid diagonalSort(vector<vector<int> >& mat){ // Calculate the rows and column int n = mat.size(); int m = mat[0].size(); // 1D array for extra space vector<int> v; // start traversing from first row to nth row // where first row to nth row is first member of diagonal for (int row = 0; row < n; row++) { // take all diagonal element where first element is // mat[row][0] means left column of matrix for (int j = 0, i = row; i < n && j < m; i++, j++) { v.push_back(mat[i][j]); } // sort element in reverse order because we need // decreasing order in diagonal sort(v.rbegin(), v.rend()); int t = 0; // putting this all values to matrix in descending sorted order for (int j = 0, i = row; i < n && j < m; i++, j++) { mat[i][j] = v[t++]; } v.clear(); } // start traversing from second column to mth column // where second column to mth column is first member of diagonal // note that here we can't start from first column // because it is already sorted by first row processing for (int col = 1; col < m; col++) { // take all diagonal element where first element is // mat[0][col] means first row of matrix for (int j = col, i = 0; i < n && j < m; i++, j++) { v.push_back(mat[i][j]); } // sort element in reverse order because we need // decreasing order in diagonal sort(v.rbegin(), v.rend()); int t = 0; // putting this all values to matrix in descending sorted order for (int j = col, i = 0; i < n && j < m; i++, j++) { mat[i][j] = v[t++]; } v.clear(); }} // Function to print elementvoid printElement(vector<vector<int> >& arr){ // Traverse the 2D vector for (int i = 0; i < arr.size(); i++) { for (int j = 0; j < arr[0].size(); j++) { cout << arr[i][j] << ' '; } cout << endl; }} // Driver Codeint main(){ vector<vector<int> > arr = {{ 10, 2, 3 }, { 4, 5, 6 }, { 7, 8, 9 } }; diagonalSort(arr); // Function call to print elements printElement(arr);}", "e": 12842, "s": 10438, "text": null }, { "code": "// Java program to sort the 2D matrix// diagonally in decreasing orderimport java.io.*;import java.util.*; class GFG{ // Function that sort 2D matrix Diagonally In Descending // order public static void diagonalSort(ArrayList<ArrayList<Integer> > mat) { // Calculate the rows and column int n = mat.size(); int m = mat.get(0).size(); // 1D array for extra space ArrayList<Integer> v = new ArrayList<Integer>(); // start traversing from first row to nth row // where first row to nth row is first member of // diagonal for (int row = 0; row < n; row++) { // take all diagonal element where first element // is mat[row][0] means left column of matrix for (int j = 0, i = row; j < m && i < n; i++, j++) { v.add(mat.get(i).get(j)); } // sort element in reverse order because we need // decreasing order in diagonal Collections.sort(v, Collections.reverseOrder()); int t = 0; for (int j = 0, i = row; j < m && i < n; i++, j++) { mat.get(i).set(j, v.get(t++)); } v.clear(); } // start traversing from second column to mth column // where second column to mth column is first member // of diagonal note that here we can't start from // first column because it is already sorted by // first row processing for (int col = 1; col < m; col++) { // take all diagonal element where first element // is mat[0][col] means first row of matrix for (int j = col, i = 0; i < n && j < m; i++, j++) { v.add(mat.get(i).get(j)); } // sort element in reverse order because we need // decreasing order in diagonal Collections.sort(v, Collections.reverseOrder()); int t = 0; // putting this all values to matrix in // descending sorted order for (int j = col, i = 0; i < n && j < m; i++, j++) { mat.get(i).set(j, v.get(t++)); } v.clear(); } // Print diagonally sorted matrix for (int i = 0; i < n; i++) { for (int j = 0; j < m; j++) { System.out.print(mat.get(i).get(j) + \" \"); } System.out.println(); } } // Driver Code public static void main(String[] args) { ArrayList<ArrayList<Integer> > arr = new ArrayList<ArrayList<Integer> >(); ArrayList<Integer> row1 = new ArrayList<Integer>(); row1.add(10); row1.add(2); row1.add(3); arr.add(row1); ArrayList<Integer> row2 = new ArrayList<Integer>(); row2.add(4); row2.add(5); row2.add(6); arr.add(row2); ArrayList<Integer> row3 = new ArrayList<Integer>(); row3.add(7); row3.add(8); row3.add(9); arr.add(row3); diagonalSort(arr); }} // This code is contributed by Snigdha Patil", "e": 15627, "s": 12842, "text": null }, { "code": "# Python program to sort the 2D vector diagonally in decreasing order # Function that sort 2D matrix Diagonally In Descending orderdef DiagonalSort(mat): # Calculate the rows and column n = len(mat) m = len(mat[0]) # 1D array for extra space v = [] # start traversing from first row to nth row # where first row to nth row is first member of diagonal for row in range(0, n): j = 0 i = row # take all diagonal element where first element is # mat[row][0] means left column of matrix while(i < n and j < m): v.append(mat[i][j]) i += 1 j += 1 # sort element in reverse order because we need # decreasing order in diagonal v.sort(reverse=True) v[::-1] t = 0 j = 0 i = row # putting this all values to matrix in descending sorted order while(i < n and j < m): mat[i][j] = v[t] t += 1 i += 1 j += 1 v = [] # start traversing from second column to mth column # where second column to mth column is first member of diagonal # note that here we can't start from first column # because it is already sorted by first row processing for col in range(0, m): j = col i = 0 # take all diagonal element where first element is # mat[0][col] means first row of matrix while(i < n and j < m): v.append(mat[i][j]) i += 1 j += 1 # sort element in reverse order because we need # decreasing order in diagonal v.sort(reverse=True) v[::-1] t = 0 j = col i = 0 # putting this all values to matrix in descending sorted order while(i < n and j < m): mat[i][j] = v[t] t += 1 i += 1 j += 1 v = [] return mat # Function to print elementdef printElement(arr): n = len(arr) m = len(arr[0]) # Traverse the 2D array for i in range(0, n): for j in range(0, m): print(arr[i][j], end=\" \") print() # Driver Codearr = [[10, 2, 3], [4, 5, 6], [7, 8, 9]]DiagonalSort(arr)printElement(arr)", "e": 17823, "s": 15627, "text": null }, { "code": null, "e": 17845, "s": 17823, "text": "10 6 3 \n8 9 2 \n7 4 5 " }, { "code": null, "e": 17911, "s": 17845, "text": "Time Complexity: O(N*M*log(min(N,M)))Auxiliary Space: O(min(N,M))" }, { "code": null, "e": 17921, "s": 17913, "text": "jaidev2" }, { "code": null, "e": 17927, "s": 17921, "text": "tk315" }, { "code": null, "e": 17942, "s": 17927, "text": "varshagumber28" }, { "code": null, "e": 17962, "s": 17942, "text": "Pankaj Kumar Gautam" }, { "code": null, "e": 17974, "s": 17962, "text": "ajaymakvana" }, { "code": null, "e": 17989, "s": 17974, "text": "sagar0719kumar" }, { "code": null, "e": 18006, "s": 17989, "text": "akshaysingh98088" }, { "code": null, "e": 18015, "s": 18006, "text": "gabaa406" }, { "code": null, "e": 18029, "s": 18015, "text": "sumitgumber28" }, { "code": null, "e": 18036, "s": 18029, "text": "sniggy" }, { "code": null, "e": 18043, "s": 18036, "text": "Matrix" }, { "code": null, "e": 18051, "s": 18043, "text": "Sorting" }, { "code": null, "e": 18059, "s": 18051, "text": "Sorting" }, { "code": null, "e": 18066, "s": 18059, "text": "Matrix" }, { "code": null, "e": 18164, "s": 18066, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 18202, "s": 18164, "text": "Unique paths in a Grid with Obstacles" }, { "code": null, "e": 18240, "s": 18202, "text": "Find median in row wise sorted matrix" }, { "code": null, "e": 18280, "s": 18240, "text": "Traverse a given Matrix using Recursion" }, { "code": null, "e": 18321, "s": 18280, "text": "Zigzag (or diagonal) traversal of Matrix" }, { "code": null, "e": 18347, "s": 18321, "text": "A Boolean Matrix Question" }, { "code": null, "e": 18358, "s": 18347, "text": "Merge Sort" }, { "code": null, "e": 18380, "s": 18358, "text": "Bubble Sort Algorithm" }, { "code": null, "e": 18390, "s": 18380, "text": "QuickSort" }, { "code": null, "e": 18405, "s": 18390, "text": "Insertion Sort" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n08 Apr, 2022" }, { "code": null, "e": 207, "s": 28, "text": "For a given 2D square matrix of size N*N, the task is to find the sum of elements in the Principle and Secondary diagonals. For example, analyze the following 4 × 4 input matrix." }, { "code": null, "e": 268, "s": 207, "text": "a00 a01 a02 a03a10 a11 a12 a13a20 a21 a22 a23a30 a31 a32 a33" }, { "code": null, "e": 277, "s": 268, "text": "Example:" }, { "code": null, "e": 433, "s": 277, "text": "Input 1 : 6 7 3 4 8 9 2 1 1 2 9 6 6 5 7 2Output 1 : Principal Diagonal: 26 Secondary Diagonal: 14 " }, { "code": null, "e": 558, "s": 433, "text": "Input 2 : 2 2 2 1 1 1 3 3 3Output 2 : Principal Diagonal: 6 Secondary Diagonal: 6" }, { "code": null, "e": 569, "s": 558, "text": "Intuition:" }, { "code": null, "e": 719, "s": 569, "text": "1. The principal diagonal is constituted by the elements a00, a11, a22, a33, and the row-column condition for the principal diagonal is: row = column" }, { "code": null, "e": 886, "s": 719, "text": "2. However, the secondary diagonal is constituted by the elements a03, a12, a21, a30, and the row-column condition for the Secondary diagonal is: row + column = N – 1" }, { "code": null, "e": 1028, "s": 886, "text": "Naive approach: Use two nested loop to iterate over 2D matrix and check for the above condition for principal diagonal and seconday diagonal." }, { "code": null, "e": 1079, "s": 1028, "text": "Below is the implementation of the above approach." }, { "code": null, "e": 1084, "s": 1079, "text": "Java" }, { "code": "// Java Program to Find the Sum of Diagonals of a Matrix // Importing input output classesimport java.io.*; // Main Classpublic class GFG { // To calculate Sum of Diagonals static void Sum_of_Diagonals1(int[][] matrix, int N) { // Declaring and initializing two variables to zero // initially for primary and secondary diagonal // count int Pd = 0, Sd = 0; // Two Nested for loops for iteration over a matrix // Outer loop for rows for (int k = 0; k < N; k++) { // Inner loop for columns for (int l = 0; l < N; l++) { // Condition for the principal // diagonal if (k == l) Pd += matrix[k][l]; // Condition for the secondary diagonal if ((k + l) == (N - 1)) Sd += matrix[k][l]; } } // Print and display the sum of primary diagonal System.out.println(\"Sum of Principal Diagonal:\" + Pd); // Print and display the sum of secondary diagonal System.out.println(\"Sum of Secondary Diagonal:\" + Sd); } // Main driver method static public void main(String[] args) { // Input integer array // Custom entries in an array int[][] b = { { 8, 2, 13, 4 }, { 9, 16, 17, 8 }, { 1, 22, 3, 14 }, { 15, 6, 17, 8 } }; // Passing the array as an argument to the // function defined above Sum_of_Diagonals1(b, 4); }}", "e": 2719, "s": 1084, "text": null }, { "code": null, "e": 2778, "s": 2719, "text": "Sum of Principal Diagonal:35\nSum of Secondary Diagonal:58\n" }, { "code": null, "e": 2822, "s": 2778, "text": "Time complexity: O(N2)Auxiliary space: O(1)" }, { "code": null, "e": 3114, "s": 2822, "text": "Efficient approach: The idea to find the sum of values of principal diagonal is to iterate to N and use the value of matrix[row][row] for the summation of princliple diagonal and to find the sum of values of secondary diagonal is to use the value of matrix[row][N – (row + 1)] for summation." }, { "code": null, "e": 3165, "s": 3114, "text": "Below is the implementation of the above approach." }, { "code": null, "e": 3170, "s": 3165, "text": "Java" }, { "code": "// Java Program to Find the Sum of Diagonals of a Matrix // Importing input output classesimport java.io.*; // Main Classpublic class GFG { // To calculate Sum of Diagonals static void Sum_of_Diagonals(int[][] matrix, int N) { // Declaring and initializing two variables to zero // initially for primary and secondary diagonal // count int Pd = 0, Sd = 0; for(int i=0; i<N; i++) { // Since for primary diagonal sum the value of // row and column are equal Pd += matrix[i][i]; // For secondry diagonal sum values of i'th index // and j'th index sum is equal to n-1 at each // stage of matrix Sd += matrix[i][N-(i+1)]; } // Print and display the sum of primary diagonal System.out.println(\"Sum of Principal Diagonal:\" + Pd); // Print and display the sum of secondary diagonal System.out.println(\"Sum of Secondary Diagonal:\" + Sd); } // Main driver method static public void main(String[] args) { // Input integer array // Custom entries in an array int[][] b = { { 8, 2, 13, 4 }, { 9, 16, 17, 8 }, { 1, 22, 3, 14 }, { 15, 6, 17, 8 } }; // Passing the array as an argument to the // function defined above Sum_of_Diagonals(b, 4); }}", "e": 4677, "s": 3170, "text": null }, { "code": null, "e": 4736, "s": 4677, "text": "Sum of Principal Diagonal:35\nSum of Secondary Diagonal:58\n" }, { "code": null, "e": 4779, "s": 4736, "text": "Time complexity: O(N)Auxiliary space: O(1)" }, { "code": null, "e": 4792, "s": 4779, "text": "apsthakur951" }, { "code": null, "e": 4797, "s": 4792, "text": "Java" }, { "code": null, "e": 4811, "s": 4797, "text": "Java Programs" }, { "code": null, "e": 4816, "s": 4811, "text": "Java" } ]

[ { "code": null, "e": 52, "s": 24, "text": "\n06 Aug, 2017" }, { "code": null, "e": 248, "s": 52, "text": "std::sort is used for sorting the elements present within a container. One of the variants of this is std::partial_sort, which is used for sorting not the entire range, but only a sub-part of it." }, { "code": null, "e": 451, "s": 248, "text": "It rearranges the elements in the range [first, last), in such a way that the elements before middle are sorted in ascending order, whereas the elements after middle are left without any specific order." }, { "code": null, "e": 494, "s": 451, "text": "It can be used in two ways as shown below:" }, { "code": null, "e": 3012, "s": 494, "text": "Comparing elements using <:Syntax:Template \nvoid partial_sort (RandomAccessIterator first, RandomAccessIterator middle,\n RandomAccessIterator last);\n\nfirst: Random-Access iterator to the first element in the container.\nlast: Random-Access iterator to the last element in the container.\nmiddle: Random-Access iterator pointing to the element in the \nrange [first, last), that is used as the upper boundary for the elements \nto be sorted.\n\nReturn Value: It has a void return type, so it does not return any value.\n// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <vector>#include <algorithm>using namespace std;int main(){ vector<int> v = { 1, 3, 1, 10, 3, 3, 7, 7, 8 }, i; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 3, v.end()); // Displaying the vector after applying // std::partial_sort for (ip = v.begin(); ip != v.end(); ++ip) { cout << *ip << \" \"; } return 0;}Output:1 1 3 10 3 3 7 7 8 \nHere, only first three elements are sorted from first to middle, and here first is v.begin() and middle is v.begin() + 3, and rest are without any order.By comparing using a pre-defined function:Syntax:Template\n void partial_sort (RandomAccessIterator first, RandomAccessIterator middle,\n RandomAccessIterator last, Compare comp);\n\nHere, first, middle and last are the same as previous case.\n\ncomp: Binary function that accepts two elements in the range \nas arguments, and returns a value convertible to bool. The value \nreturned indicates whether the element passed as first \nargument is considered to go before the second in the specific\nstrict weak ordering it defines.\nThe function shall not modify any of its arguments.\nThis can either be a function pointer or a function object.\n\nReturn Value: It has a void return type, so it does not return any value.\n// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <algorithm>#include <vector>using namespace std; // Defining the BinaryFunctionbool comp(int a, int b){ return (a < b);} int main(){ vector<int> v = { 1, 3, 1, 10, 3, 3, 7, 7, 8 }, i; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 3, v.end(), comp); // Displaying the vector after applying // std::partial_sort for (ip = v.begin(); ip != v.end(); ++ip) { cout << *ip << \" \"; } return 0;}Output:1 1 3 10 3 3 7 7 8 \n" }, { "code": null, "e": 4208, "s": 3012, "text": "Comparing elements using <:Syntax:Template \nvoid partial_sort (RandomAccessIterator first, RandomAccessIterator middle,\n RandomAccessIterator last);\n\nfirst: Random-Access iterator to the first element in the container.\nlast: Random-Access iterator to the last element in the container.\nmiddle: Random-Access iterator pointing to the element in the \nrange [first, last), that is used as the upper boundary for the elements \nto be sorted.\n\nReturn Value: It has a void return type, so it does not return any value.\n// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <vector>#include <algorithm>using namespace std;int main(){ vector<int> v = { 1, 3, 1, 10, 3, 3, 7, 7, 8 }, i; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 3, v.end()); // Displaying the vector after applying // std::partial_sort for (ip = v.begin(); ip != v.end(); ++ip) { cout << *ip << \" \"; } return 0;}Output:1 1 3 10 3 3 7 7 8 \nHere, only first three elements are sorted from first to middle, and here first is v.begin() and middle is v.begin() + 3, and rest are without any order." }, { "code": null, "e": 4216, "s": 4208, "text": "Syntax:" }, { "code": null, "e": 4713, "s": 4216, "text": "Template \nvoid partial_sort (RandomAccessIterator first, RandomAccessIterator middle,\n RandomAccessIterator last);\n\nfirst: Random-Access iterator to the first element in the container.\nlast: Random-Access iterator to the last element in the container.\nmiddle: Random-Access iterator pointing to the element in the \nrange [first, last), that is used as the upper boundary for the elements \nto be sorted.\n\nReturn Value: It has a void return type, so it does not return any value.\n" }, { "code": "// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <vector>#include <algorithm>using namespace std;int main(){ vector<int> v = { 1, 3, 1, 10, 3, 3, 7, 7, 8 }, i; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 3, v.end()); // Displaying the vector after applying // std::partial_sort for (ip = v.begin(); ip != v.end(); ++ip) { cout << *ip << \" \"; } return 0;}", "e": 5199, "s": 4713, "text": null }, { "code": null, "e": 5207, "s": 5199, "text": "Output:" }, { "code": null, "e": 5228, "s": 5207, "text": "1 1 3 10 3 3 7 7 8 \n" }, { "code": null, "e": 5382, "s": 5228, "text": "Here, only first three elements are sorted from first to middle, and here first is v.begin() and middle is v.begin() + 3, and rest are without any order." }, { "code": null, "e": 6705, "s": 5382, "text": "By comparing using a pre-defined function:Syntax:Template\n void partial_sort (RandomAccessIterator first, RandomAccessIterator middle,\n RandomAccessIterator last, Compare comp);\n\nHere, first, middle and last are the same as previous case.\n\ncomp: Binary function that accepts two elements in the range \nas arguments, and returns a value convertible to bool. The value \nreturned indicates whether the element passed as first \nargument is considered to go before the second in the specific\nstrict weak ordering it defines.\nThe function shall not modify any of its arguments.\nThis can either be a function pointer or a function object.\n\nReturn Value: It has a void return type, so it does not return any value.\n// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <algorithm>#include <vector>using namespace std; // Defining the BinaryFunctionbool comp(int a, int b){ return (a < b);} int main(){ vector<int> v = { 1, 3, 1, 10, 3, 3, 7, 7, 8 }, i; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 3, v.end(), comp); // Displaying the vector after applying // std::partial_sort for (ip = v.begin(); ip != v.end(); ++ip) { cout << *ip << \" \"; } return 0;}Output:1 1 3 10 3 3 7 7 8 \n" }, { "code": null, "e": 6713, "s": 6705, "text": "Syntax:" }, { "code": null, "e": 7391, "s": 6713, "text": "Template\n void partial_sort (RandomAccessIterator first, RandomAccessIterator middle,\n RandomAccessIterator last, Compare comp);\n\nHere, first, middle and last are the same as previous case.\n\ncomp: Binary function that accepts two elements in the range \nas arguments, and returns a value convertible to bool. The value \nreturned indicates whether the element passed as first \nargument is considered to go before the second in the specific\nstrict weak ordering it defines.\nThe function shall not modify any of its arguments.\nThis can either be a function pointer or a function object.\n\nReturn Value: It has a void return type, so it does not return any value.\n" }, { "code": "// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <algorithm>#include <vector>using namespace std; // Defining the BinaryFunctionbool comp(int a, int b){ return (a < b);} int main(){ vector<int> v = { 1, 3, 1, 10, 3, 3, 7, 7, 8 }, i; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 3, v.end(), comp); // Displaying the vector after applying // std::partial_sort for (ip = v.begin(); ip != v.end(); ++ip) { cout << *ip << \" \"; } return 0;}", "e": 7961, "s": 7391, "text": null }, { "code": null, "e": 7969, "s": 7961, "text": "Output:" }, { "code": null, "e": 7990, "s": 7969, "text": "1 1 3 10 3 3 7 7 8 \n" }, { "code": null, "e": 8013, "s": 7990, "text": "Where can it be used ?" }, { "code": null, "e": 9513, "s": 8013, "text": "Finding the largest element: Since, with std::partial_sort, we can partially sort the container till whichever position we would like to. So, if we just sort the first position and use a function object , we can find the largest element, without having to sort the entire container.// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <algorithm>#include <vector>using namespace std;int main(){ vector<int> v = { 10, 45, 60, 78, 23, 21, 30 }; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 1, v.end(), greater<int>()); // Displaying the largest element after applying // std::partial_sort ip = v.begin(); cout << \"The largest element is = \" << *ip; return 0;}Output:The largest element is = 78\nFinding the smallest element: Similar to finding the largest element, we can also find the smallest element in the container in the previous example.// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <algorithm>#include <vector>using namespace std;int main(){ vector<int> v = { 10, 45, 60, 78, 23, 21, 3 }; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 1, v.end()); // Displaying the smallest element after applying // std::partial_sort ip = v.begin(); cout << \"The smallest element is = \" << *ip; return 0;}Output:The smallest element is = 3\n" }, { "code": null, "e": 10348, "s": 9513, "text": "Finding the largest element: Since, with std::partial_sort, we can partially sort the container till whichever position we would like to. So, if we just sort the first position and use a function object , we can find the largest element, without having to sort the entire container.// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <algorithm>#include <vector>using namespace std;int main(){ vector<int> v = { 10, 45, 60, 78, 23, 21, 30 }; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 1, v.end(), greater<int>()); // Displaying the largest element after applying // std::partial_sort ip = v.begin(); cout << \"The largest element is = \" << *ip; return 0;}Output:The largest element is = 78\n" }, { "code": "// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <algorithm>#include <vector>using namespace std;int main(){ vector<int> v = { 10, 45, 60, 78, 23, 21, 30 }; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 1, v.end(), greater<int>()); // Displaying the largest element after applying // std::partial_sort ip = v.begin(); cout << \"The largest element is = \" << *ip; return 0;}", "e": 10866, "s": 10348, "text": null }, { "code": null, "e": 10874, "s": 10866, "text": "Output:" }, { "code": null, "e": 10903, "s": 10874, "text": "The largest element is = 78\n" }, { "code": null, "e": 11569, "s": 10903, "text": "Finding the smallest element: Similar to finding the largest element, we can also find the smallest element in the container in the previous example.// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <algorithm>#include <vector>using namespace std;int main(){ vector<int> v = { 10, 45, 60, 78, 23, 21, 3 }; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 1, v.end()); // Displaying the smallest element after applying // std::partial_sort ip = v.begin(); cout << \"The smallest element is = \" << *ip; return 0;}Output:The smallest element is = 3\n" }, { "code": "// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <algorithm>#include <vector>using namespace std;int main(){ vector<int> v = { 10, 45, 60, 78, 23, 21, 3 }; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 1, v.end()); // Displaying the smallest element after applying // std::partial_sort ip = v.begin(); cout << \"The smallest element is = \" << *ip; return 0;}", "e": 12051, "s": 11569, "text": null }, { "code": null, "e": 12059, "s": 12051, "text": "Output:" }, { "code": null, "e": 12088, "s": 12059, "text": "The smallest element is = 3\n" }, { "code": null, "e": 12107, "s": 12088, "text": "Point to remember:" }, { "code": null, "e": 13467, "s": 12107, "text": "std::sort() vs std::partial_sort(): Some of you might think that why are we using std::partial_sort, in place we can use std::sort() for the limited range, but remember, if we use std::sort with a partial range, then only elements within that range will be considered for sorting, while all other elements outside the range will not be considered for this purpose, whereas with std::partial_sort(), all the elements will be considered for sorting.// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <algorithm>#include <vector>using namespace std;int main(){ vector<int> v = { 10, 45, 60, 78, 23, 21, 3 }, v1; int i; v1 = v; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 2, v.end()); // Using std::sort() std::sort(v1.begin(), v1.begin() + 2); cout << \"v = \"; for (i = 0; i < 2; ++i) { cout << v[i] << \" \"; } cout << \"\\nv1 = \"; for (i = 0; i < 2; ++i) { cout << v1[i] << \" \"; } return 0;}Output:v = 3 10\nv1 = 10 45\nExplanation: Here, we applied std::partial_sort on v and std::sort on v1, upto second position. Now, you can understand that std::sort sorted only the element within the given range, whereas partial_sort took into consideration the whole container, but sorted only the first two positions." }, { "code": "// C++ program to demonstrate the use of// std::partial_sort#include <iostream>#include <algorithm>#include <vector>using namespace std;int main(){ vector<int> v = { 10, 45, 60, 78, 23, 21, 3 }, v1; int i; v1 = v; vector<int>::iterator ip; // Using std::partial_sort std::partial_sort(v.begin(), v.begin() + 2, v.end()); // Using std::sort() std::sort(v1.begin(), v1.begin() + 2); cout << \"v = \"; for (i = 0; i < 2; ++i) { cout << v[i] << \" \"; } cout << \"\\nv1 = \"; for (i = 0; i < 2; ++i) { cout << v1[i] << \" \"; } return 0;}", "e": 14064, "s": 13467, "text": null }, { "code": null, "e": 14072, "s": 14064, "text": "Output:" }, { "code": null, "e": 14093, "s": 14072, "text": "v = 3 10\nv1 = 10 45\n" }, { "code": null, "e": 14383, "s": 14093, "text": "Explanation: Here, we applied std::partial_sort on v and std::sort on v1, upto second position. Now, you can understand that std::sort sorted only the element within the given range, whereas partial_sort took into consideration the whole container, but sorted only the first two positions." }, { "code": null, "e": 14686, "s": 14383, "text": "This article is contributed by Mrigendra Singh. If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to [email protected]. See your article appearing on the GeeksforGeeks main page and help other Geeks." }, { "code": null, "e": 14811, "s": 14686, "text": "Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above." }, { "code": null, "e": 14833, "s": 14811, "text": "cpp-algorithm-library" }, { "code": null, "e": 14837, "s": 14833, "text": "STL" }, { "code": null, "e": 14841, "s": 14837, "text": "C++" }, { "code": null, "e": 14845, "s": 14841, "text": "STL" }, { "code": null, "e": 14849, "s": 14845, "text": "CPP" }, { "code": null, "e": 14947, "s": 14849, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 14995, "s": 14947, "text": "Writing First C++ Program - Hello World Example" }, { "code": null, "e": 15023, "s": 14995, "text": "Basic Input / Output in C++" }, { "code": null, "e": 15066, "s": 15023, "text": "Functions that cannot be overloaded in C++" }, { "code": null, "e": 15092, "s": 15066, "text": "Switch Statement in C/C++" }, { "code": null, "e": 15112, "s": 15092, "text": "Polymorphism in C++" }, { "code": null, "e": 15157, "s": 15112, "text": "Queue in C++ Standard Template Library (STL)" }, { "code": null, "e": 15182, "s": 15157, "text": "std::string class in C++" }, { "code": null, "e": 15206, "s": 15182, "text": "Sorting a vector in C++" }, { "code": null, "e": 15239, "s": 15206, "text": "Friend class and function in C++" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n22 Jun, 2022" }, { "code": null, "e": 124, "s": 28, "text": "In this article, we will see how to convert an SQLAlchemy ORM to Pandas DataFrame using Python." }, { "code": null, "e": 223, "s": 124, "text": "We need to have the sqlalchemy as well as the pandas library installed in the python environment –" }, { "code": null, "e": 269, "s": 223, "text": "$ pip install sqlalchemy\n$ pip install pandas" }, { "code": null, "e": 539, "s": 269, "text": "For our example, we will make use of the MySQL database where we have already created a table named students. You are free to use any database but you need to accordingly create its connection string. The raw SQL script for reference for this example is provided below:" }, { "code": null, "e": 1210, "s": 539, "text": "CREATE DATABASE Geeks4Geeks;\nUSE Geeks4Geeks;\n\nCREATE TABLE students (\n first_name VARCHAR(50),\n last_name VARCHAR(50),\n course VARCHAR(50),\n score FLOAT\n);\n\nINSERT INTO students VALUES\n('Ashish', 'Mysterio', 'Statistics', 96),\n('Rahul', 'Kumar', 'Statistics', 83),\n('Irfan', 'Malik', 'Statistics', 66),\n('Irfan', 'Ahmed', 'Statistics', 81),\n('John', 'Wick', 'Statistics', 77),\n('Mayon', 'Irani', 'Statistics', 55),\n('Ashish', 'Mysterio', 'Sociology', 85),\n('Rahul', 'Kumar', 'Sociology', 78),\n('Irfan', 'Malik', 'Biology', 92),\n('Irfan', 'Ahmed', 'Chemistry', 45),\n('John', 'Wick', 'Biology', 78),\n('Mayon', 'Irani', 'Physics', 78);\n\nSELECT * FROM students;" }, { "code": null, "e": 1340, "s": 1210, "text": "The syntax for converting the SQLAlchemy ORM to a pandas dataframe is the same as you would do for a raw SQL query, given below –" }, { "code": null, "e": 1384, "s": 1340, "text": "Syntax: pandas.read_sql(sql, con, **kwargs)" }, { "code": null, "e": 1391, "s": 1384, "text": "Where:" }, { "code": null, "e": 1436, "s": 1391, "text": "sql: The SELECT SQL statement to be executed" }, { "code": null, "e": 1508, "s": 1436, "text": "con: SQLAlchemy engine object to establish a connection to the database" }, { "code": null, "e": 1595, "s": 1508, "text": "Please note that you can also use pandas.read_sql_query() instead of pandas.read_sql()" }, { "code": null, "e": 1606, "s": 1595, "text": "Example 1:" }, { "code": null, "e": 2062, "s": 1606, "text": "In the above example, we can see that the sql parameter of the pandas.read_sql() method takes in the SQLAlchemy ORM query as we may have defined it without the pandas dataframe conversion. The db.select() will get converted to raw SQL query when read by the read_sql() method. In the output, we have also printed the type of the response object. The output is a pandas DataFrame object where we have fetched all the records present in the student’s table." }, { "code": null, "e": 2070, "s": 2062, "text": "Python3" }, { "code": "import pandasimport sqlalchemy as dbfrom sqlalchemy.ext.declarative import declarative_base Base = declarative_base() # DEFINE THE ENGINE (CONNECTION OBJECT)engine = db.create_engine(\"mysql+pymysql:\\//root:password@localhost/Geeks4Geeks\") # CREATE THE TABLE MODEL TO USE IT FOR QUERYINGclass Students(Base): __tablename__ = 'students' first_name = db.Column(db.String(50), primary_key=True) last_name = db.Column(db.String(50), primary_key=True) course = db.Column(db.String(50)) score = db.Column(db.Float) # SQLAlCHEMY ORM QUERY TO FETCH ALL RECORDSdf = pandas.read_sql_query( sql = db.select([Students.first_name, Students.last_name, Students.course, Students.score]), con = engine) print(\"Type:\", type(df))print()print(df)", "e": 2942, "s": 2070, "text": null }, { "code": null, "e": 2950, "s": 2942, "text": "Output:" }, { "code": null, "e": 2961, "s": 2950, "text": "Example 2:" }, { "code": null, "e": 3775, "s": 2961, "text": "In this example, we have used the session object to bind the connection engine. We have also applied a filter() method which is equivalent to the WHERE clause in SQL. It consists of the condition that the picked records should contain the first name and the last name of those students who have a score of greater than 80. One thing worth noting here is that, for the queries build using the session object, we need to use the statement attribute to explicitly convert into a raw SQL query. This is required because without the statement attribute, it will be a sqlalchemy.orm.query.Query object which cannot be executed by the pandas.read_sql() method and you will get a sqlalchemy.exc.ObjectNotExecutableError error. The above output shows the type of object which is a pandas DataFrame along with the response." }, { "code": null, "e": 3783, "s": 3775, "text": "Python3" }, { "code": "import pandasimport sqlalchemy as dbfrom sqlalchemy.ext.declarative import declarative_base Base = declarative_base() # DEFINE THE ENGINE (CONNECTION OBJECT)engine = db.create_engine(\"mysql+pymysql:\\//root:password@localhost/Geeks4Geeks\") # CREATE THE TABLE MODEL TO USE IT FOR QUERYINGclass Students(Base): __tablename__ = 'students' first_name = db.Column(db.String(50), primary_key=True) last_name = db.Column(db.String(50), primary_key=True) course = db.Column(db.String(50)) score = db.Column(db.Float) # CREATE A SESSION OBJECT TO INITIATE QUERY IN DATABASEfrom sqlalchemy.orm import sessionmakerSession = sessionmaker(bind = engine)session = Session() # SQLAlCHEMY ORM QUERY TO FETCH ALL RECORDSdf = pandas.read_sql_query( sql = session.query(Students.first_name, Students.last_name).filter( Students.score > 80).statement, con = engine) print(\"Type:\", type(df))print()print(df)", "e": 4782, "s": 3783, "text": null }, { "code": null, "e": 4790, "s": 4782, "text": "Output:" }, { "code": null, "e": 4803, "s": 4790, "text": "nikhatkhan11" }, { "code": null, "e": 4810, "s": 4803, "text": "Picked" }, { "code": null, "e": 4817, "s": 4810, "text": "Python" } ]

[ { "code": null, "e": 28, "s": 0, "text": "\n03 Dec, 2021" }, { "code": null, "e": 436, "s": 28, "text": "TimeZone class is used to represents a time zone offset, and also figures out daylight savings.What is a Time Zone and Time Offset?“Time Zone” is used to describe the current time for different areas of the world. It refers to one of the specific regions out of the 24 total regions in the world that are divided up by longitude. Within each one of those regions, a standard version of time is maintained. " }, { "code": null, "e": 542, "s": 436, "text": "The different time zones are calculated based on their relation to the coordinated universal time or UTC." }, { "code": null, "e": 716, "s": 542, "text": "A time offset is an amount of time subtracted from or added to Universal Time) time to get the current civil time, whether it is standard time or daylight-saving time (DST)." }, { "code": null, "e": 980, "s": 716, "text": "We divide the whole earth east to west into 24 different regions based on longitude so each region is 15 degrees wider. So, there are 24 different Time zones available on earth. Each time zone is 15 degrees wide and there’s a one-hour difference between each one." }, { "code": null, "e": 1143, "s": 980, "text": "Depending on the distance east or west from the Greenwich Meridian you must either add or subtract the appropriate time for every 15-degree interval in Longitude." }, { "code": null, "e": 1484, "s": 1143, "text": "For Example : To find the time zone in hours of a particular location, you can take the longitude in degrees and divide it by 15. So, for example, 105° E would be 105/15 which equals 7. That translates to the time zone being 7 hours ahead of UTC or GMT time, which can also be labelled as UTC+7. Where 7 is a time offset for that location. " }, { "code": null, "e": 1507, "s": 1484, "text": "TimeZone Class in Java" }, { "code": null, "e": 1526, "s": 1507, "text": "Class declaration " }, { "code": null, "e": 1608, "s": 1526, "text": "public abstract class TimeZone extends \nObject implements Serializable, Cloneable" }, { "code": null, "e": 1637, "s": 1608, "text": "Methods of TimeZone Class : " }, { "code": null, "e": 1721, "s": 1637, "text": "getAvailableIDs() – Using this method you can get all the available Time Zone IDs. " }, { "code": null, "e": 1771, "s": 1721, "text": "Syntax : public static String[] getAvailableIDs()" }, { "code": null, "e": 1931, "s": 1771, "text": "getAvailableIDs (int rawOffset) – Using this method you can get an array of IDs, where the time zone for that ID has the specified GMT offset in milliseconds. " }, { "code": null, "e": 2066, "s": 1931, "text": "Syntax : public static String[] getAvailableIDs(int rawOffset)\nParameters: rawOffset - the given time zone GMT offset in milliseconds." }, { "code": null, "e": 2071, "s": 2066, "text": "Java" }, { "code": "// Java program for Demonstration of// getAvailableIDs() and// getAvailableIDs(int rawOffset ) methodsimport java.util.TimeZone; public class TimeZoneDemo { public static void main(String[] args) { // get all the timezones ids defined by TimeZone class String[] availableTimezones = TimeZone.getAvailableIDs(); // Print Total no of TimeZones System.out.println(\"Total No of Time Zone Available\"); System.out.println(availableTimezones.length); // get all the timezones whose offset is // 7200000 milliseconds means 2 hour String[] timezones = TimeZone.getAvailableIDs(7200000); // Print Total no of TimeZones System.out.println(\"No of Time Zone having time offset 2 hour\"); System.out.println(timezones.length); // print all timezones names System.out.println(\"Timezone names having time offset 2 hour\"); for (int i = 0; i < timezones.length; i++) System.out.println(timezones[i]); }}", "e": 3086, "s": 2071, "text": null }, { "code": null, "e": 3291, "s": 3086, "text": "Output: \nTotal No of Time Zone Available\n628\nNo of Time Zone having a time offset 2 hour\n43\nTimezone names having a time offset 2 hour\nART\nAfrica/Blantyre\nAfrica/Bujumbura\nAfrica/Cairo......\n............" }, { "code": null, "e": 3385, "s": 3291, "text": "getDefault() – Using this method you can get the TimeZone of place where Program is Running. " }, { "code": null, "e": 3430, "s": 3385, "text": "Syntax : public static TimeZone getDefault()" }, { "code": null, "e": 3515, "s": 3430, "text": "getDisplayName() – Method returns a long standard time name of initialize TimeZone. " }, { "code": null, "e": 3562, "s": 3515, "text": "Syntax : public final String getDisplayName() " }, { "code": null, "e": 3567, "s": 3562, "text": "Java" }, { "code": "// Java program for Demonstration of// getDefault() and getDisplayName() methodsimport java.util.TimeZone; public class TimeZoneDemo { public static void main(String[] args) { // Get your Local Time Zone Where this Program is Running. TimeZone timezone = TimeZone.getDefault(); // Get the Name of Time Zone String LocalTimeZoneDisplayName = timezone.getDisplayName(); // Print the Name of Time Zone System.out.println(LocalTimeZoneDisplayName); }}", "e": 4070, "s": 3567, "text": null }, { "code": null, "e": 4107, "s": 4070, "text": "Output: \nCoordinated Universal Time" }, { "code": null, "e": 4191, "s": 4107, "text": "getTimeZone(String ID) – This method is used to get the TimeZone for the given ID. " }, { "code": null, "e": 4285, "s": 4191, "text": "Syntax :public static TimeZone getTimeZone(String ID)\nParameters: ID - the ID for a TimeZone." }, { "code": null, "e": 4403, "s": 4285, "text": "getDSTSavings() – Method returns the amount of time to be added to local standard time to get local wall clock time. " }, { "code": null, "e": 4439, "s": 4403, "text": "Syntax : public int getDSTSavings()" }, { "code": null, "e": 4503, "s": 4439, "text": "getID() – This method is Used to Get the ID of this time zone. " }, { "code": null, "e": 4534, "s": 4503, "text": "Syntax : public String getID()" }, { "code": null, "e": 4539, "s": 4534, "text": "Java" }, { "code": "// Java program for Demonstration of// getTimeZone(String ID),// getDSTSavings() and getID() methodsimport java.sql.Time;import java.util.TimeZone; public class TimeZoneDemo { public static void main(String[] args) { // creating Timezone object whose id is Europe/Berlin TimeZone timezone = TimeZone.getTimeZone(\"Europe/Berlin\"); // printing the Display Name of this timezone object System.out.println(\"Display Name\"); System.out.println(timezone.getDisplayName()); // getting DST in milliseconds int timeInMilliseconds = timezone.getDSTSavings(); System.out.println(\"\\nDST of Europe/Berlin is\"); System.out.println(timezone.getDSTSavings()); // get Id of your Default Time Zone TimeZone defaultTimezone = TimeZone.getDefault(); System.out.println(\"\\nThe id of default Time zone is\"); System.out.println(timezone.getID()); }}", "e": 5474, "s": 4539, "text": null }, { "code": null, "e": 5597, "s": 5474, "text": "Output: \nDisplay Name\nCentral European Time\n\nDST of Europe/Berlin is\n3600000\n\nThe id of default Time zone is\nEurope/Berlin" }, { "code": null, "e": 5718, "s": 5597, "text": "getOffset(long date) – The method is used to return the offset of this time zone from UTC at the passed date in method. " }, { "code": null, "e": 5917, "s": 5718, "text": "Syntax : the method is used to return the offset of this time zone\n from UTC at the passed date in method.\nParameters: date - the date represented in milliseconds\n since January 1, 1970 00:00:00 GMT" }, { "code": null, "e": 6046, "s": 5917, "text": "inDaylightTime(Date date) – This method returns true if the given date is in Daylight Saving Time in this time zone else false. " }, { "code": null, "e": 6147, "s": 6046, "text": "Syntax :Syntax : public abstract boolean inDaylightTime(Date date)\nParameters:date - the given Date." }, { "code": null, "e": 6342, "s": 6147, "text": "observesDaylightTime() – This method returns true if this TimeZone is currently in Daylight Saving Time, or if a transition from Standard Time to Daylight Saving Time occurs at any future time. " }, { "code": null, "e": 6388, "s": 6342, "text": "Syntax :public boolean observesDaylightTime()" }, { "code": null, "e": 6393, "s": 6388, "text": "Java" }, { "code": "// Java program for// Demonstration of getOffset(long date),// inDaylightTime(Date date) and// observesDaylightTime() methodsimport java.sql.Time;import java.util.*; public class TimeZoneDemo { public static void main(String[] args) { // creating Timezone object whose id is Europe/Berlin TimeZone timezone = TimeZone.getTimeZone(\"Europe/Berlin\"); // printing offset value System.out.println(\"Offset value of Europe/Berlin:\"); System.out.println(timezone.getOffset(Calendar.ZONE_OFFSET)); // create Date Object Date date = new Date(2017, 04, 16); // checking the date is in day light time of that Time Zone or not System.out.println(\"\\nDate 16/04/2017 is in Day Light Time of\"); System.out.println(\"Timezone: timezone.getDisplayName()\"); System.out.println(timezone.inDaylightTime(date)); // check this Time Zone observes Day Light Time or Not System.out.println(\"\\nTimeZone name \" + timezone.getDisplayName()); System.out.println(\"Observes Day Light Time\"); System.out.println(timezone.observesDaylightTime()); }}", "e": 7532, "s": 6393, "text": null }, { "code": null, "e": 7727, "s": 7532, "text": "Output:\nOffset value of Europe/Berlin:\n3600000\n\nDate 16/04/2017 is in Day Light Time of\nTimezone: timezone.getDisplayName()\ntrue\n\nTimeZone name Central European Time\nObserves Day Light Time\ntrue" }, { "code": null, "e": 7830, "s": 7727, "text": "setDefault(TimeZone zone) – It is used to set the TimeZone that is returned by the getDefault method. " }, { "code": null, "e": 7929, "s": 7830, "text": "Syntax : public static void setDefault(TimeZone zone)\nParameters: zone - the new default time zone" }, { "code": null, "e": 7985, "s": 7929, "text": "setID(String ID) – It is used to set the time zone ID. " }, { "code": null, "e": 8061, "s": 7985, "text": "Syntax :public void setID(String ID)\nParameters: ID - the new time zone ID." }, { "code": null, "e": 8121, "s": 8061, "text": "clone() – This method used to create copy of this TimeZone " }, { "code": null, "e": 8152, "s": 8121, "text": "Syntax : public Object clone()" }, { "code": null, "e": 8157, "s": 8152, "text": "Java" }, { "code": "// Java program for Demonstration of// setDefault(TimeZone zone),// setID(String ID) and clone() methodsimport java.util.*; public class TimeZoneDemo { public static void main(String[] args) { // My previous Default Time Zone is TimeZone DefaultTimeZone = TimeZone.getDefault(); System.out.println(\"Current Default TimeZone:\"); System.out.println(DefaultTimeZone.getDisplayName()); // Setting Europe/Berlin as your Default Time Zone TimeZone timezone = TimeZone.getTimeZone(\"Europe/Berlin\"); timezone.setDefault(timezone); TimeZone NewDefaultTimeZone = TimeZone.getDefault(); System.out.println(\"\\nNew Default TimeZone:\"); System.out.println(NewDefaultTimeZone.getDisplayName()); // change Id Europe/Berlin to Eur/Ber timezone.setID(\"Eur/Ber\"); System.out.println(\"\\nNew Id of Europe/Berlin is\"); System.out.println(timezone.getID()); // create copy of a time zone System.out.println(\"\\nOriginal TimeZone ID:\"); System.out.println(timezone.getID()); TimeZone clonedTimezone = (TimeZone)timezone.clone(); System.out.println(\"Cloned TimeZone ID:\"); System.out.println(clonedTimezone.getID()); }}", "e": 9411, "s": 8157, "text": null }, { "code": null, "e": 9605, "s": 9411, "text": "Output:\nCurrent Default TimeZone:\nIndia Standard Time\n\nNew Default TimeZone:\nCentral European Time\n\nNew Id of Europe/Berlin is\nEur/Ber\n\nOriginal TimeZone ID:\nEur/Ber\nCloned TimeZone ID:\nEur/Ber" }, { "code": null, "e": 9696, "s": 9605, "text": "Example : Print the Date and Time for Any Given Input Time Zone Where Program is Running. " }, { "code": null, "e": 9701, "s": 9696, "text": "Java" }, { "code": "// Java program to illustrate// java.util.timezone classimport java.text.*;import java.util.*; public class TimeZoneDemo { public static void main(String[] args) { // Get your Local Time Zone Where this Program is Running. TimeZone timezone = TimeZone.getDefault(); // Get the Name of Time Zone String LocalTimeZoneName = timezone.getDisplayName(); // Initialize your Date Object and Date Format to represent your Date Date date = new Date(); DateFormat dformat = new SimpleDateFormat(\"yyyy-MM-dd HH:mm:ss\"); // set your local time Zone to your Date Format time Zone dformat.setTimeZone(timezone); // Print Date and Time for your Time Zone System.out.println(\"Date and time of your Local Time Zone:\"); System.out.println(LocalTimeZoneName + \", \" + dformat.format(date)); }}", "e": 10573, "s": 9701, "text": null }, { "code": null, "e": 10671, "s": 10573, "text": " Output: \nDate and time of your Local Time Zone:\nCoordinated Universal Time, 2018-04-17 07:36:19" }, { "code": null, "e": 10704, "s": 10671, "text": "Reference – Oracle Documentation" }, { "code": null, "e": 10717, "s": 10704, "text": "simmytarika5" }, { "code": null, "e": 10726, "s": 10717, "text": "sooda367" }, { "code": null, "e": 10746, "s": 10726, "text": "Java - util package" }, { "code": null, "e": 10751, "s": 10746, "text": "Java" }, { "code": null, "e": 10756, "s": 10751, "text": "Java" }, { "code": null, "e": 10854, "s": 10756, "text": "Writing code in comment?\nPlease use ide.geeksforgeeks.org,\ngenerate link and share the link here." }, { "code": null, "e": 10905, "s": 10854, "text": "Object Oriented Programming (OOPs) Concept in Java" }, { "code": null, "e": 10936, "s": 10905, "text": "How to iterate any Map in Java" }, { "code": null, "e": 10955, "s": 10936, "text": "Interfaces in Java" }, { "code": null, "e": 10985, "s": 10955, "text": "HashMap in Java with Examples" }, { "code": null, "e": 11003, "s": 10985, "text": "ArrayList in Java" }, { "code": null, "e": 11023, "s": 11003, "text": "Collections in Java" }, { "code": null, "e": 11038, "s": 11023, "text": "Stream In Java" }, { "code": null, "e": 11070, "s": 11038, "text": "Multidimensional Arrays in Java" }, { "code": null, "e": 11090, "s": 11070, "text": "Stack Class in Java" } ]

[ { "code": null, "e": 1333, "s": 1187, "text": "Sometimes you will want to pass some information on a program when you run it. This is accomplished by passing command-line arguments to main( )." }, { "code": null, "e": 1597, "s": 1333, "text": "A command-line argument is an information that directly follows the program's name on the command line when it is executed. To access the command-line arguments inside a Java program is quite easy. They are stored as strings in the String array passed to main( )." }, { "code": null, "e": 1687, "s": 1597, "text": "The following program displays all of the command-line arguments that it is called with -" }, { "code": null, "e": 1876, "s": 1687, "text": "public class CommandLine {\n public static void main(String args[]) {\n for(int i = 0; i<args.length; i++) {\n System.out.println(\"args[\" + i + \"]: \" + args[i]);\n }\n }\n}" }, { "code": null, "e": 1919, "s": 1876, "text": "Try executing this program as shown here -" }, { "code": null, "e": 1969, "s": 1919, "text": "$java CommandLine this is a command line 200 -100" }, { "code": null, "e": 2010, "s": 1969, "text": "This will produce the following result -" }, { "code": null, "e": 2105, "s": 2010, "text": "args[0]: this\nargs[1]: is\nargs[2]: a\nargs[3]: command\nargs[4]: line\nargs[5]: 200\nargs[6]: -100" } ]