समसामयिकी

साइन इन
राजव्यवस्था और शासनGS2
GS2

उत्तराखंड ने विकेंद्रीकृत द्वार-द्वार सुशासन के प्रति प्रतिबद्धता दोहराई

स्रोत:indianmasterminds ↗

क्यों मायने रखता है

यह लेख उत्तराखंड में राज्य-स्तरीय नागरिक-केंद्रित प्रशासन, सार्वजनिक शिकायत निवारण तंत्र और क्षेत्रीय विकास पहलों के साथ-साथ ऐतिहासिक कानूनों (जैसे UCC और नकल विरोधी कानून) के बारे में मूल्यवान अंतर्दृष्टि प्रदान करता है, जो अक्सर UKPSC PCS Prelims में पूछे जाते हैं।

सारांश

उत्तराखंड के मुख्यमंत्री पुष्कर सिंह धामी ने देहरादून के सहसपुर में आयोजित एक जन सेवा शिविर के दौरान जन शिकायतों की समीक्षा की और विकेंद्रीकृत, द्वार-पर-शासन (doorstep governance) के प्रति सरकार की प्रतिबद्धता को दोहराया। 'जन-जन की सरकार, जन-जन के द्वार' अभियान के तहत, राज्य ने प्रशासनिक मुद्दों का मौके पर ही समाधान करने के लिए 700 से अधिक शिविरों का आयोजन किया है। सीएम धामी ने समान नागरिक संहिता (UCC) और सख्त नकल विरोधी कानून जैसे प्रमुख सुधारों के मील के पत्थरों को रेखांकित किया, साथ ही राज्य के विभागों को देहरादून में स्थानीय भूमि बंदोबस्त, बुनियादी ढांचे और बुनियादी सुविधाओं से जुड़े मुद्दों को हल करने के लिए सीधे निर्देश दिए।

मुख्य बिंदु

  • उत्तराखंड के मुख्यमंत्री पुष्कर सिंह धामी ने देहरादून के सहसपुर में 'जन-जन की सरकार, जन-जन के द्वार' अभियान के तहत आयोजित एक जनसेवा शिविर में भाग लिया, जिसमें 'द्वार पर शासन' (doorstep governance) पर विशेष बल दिया गया।
  • इस पहल के पहले चरण के तहत, 65 दिनों में राज्य भर में लगभग 700 जन सेवा शिविर आयोजित किए गए, जिसमें 5 लाख से अधिक प्रतिभागियों ने भाग लिया और मौके पर ही प्रशासनिक समाधान की सुविधा प्रदान की गई।
  • सीएम धामी ने उत्तराखंड में लागू किए गए महत्वपूर्ण नीतिगत सुधारों पर जोर दिया, जिसमें समान नागरिक संहिता (UCC), देश का सबसे सख्त नकल विरोधी कानून और कड़े भ्रष्टाचार विरोधी उपाय शामिल हैं।
  • विशिष्ट जनकल्याणकारी और विकासात्मक निर्देश जारी किए गए, जैसे कि MDDA द्वारा करबारी ग्रांट में सोलर लाइट लगाना, और राजस्व विभाग द्वारा 15 दिनों के भीतर अटाकफार्म और सेंट्रल होप टाउन में बंदोबस्त के मुद्दों को हल करना।
  • सेलाकुई में सीसी (CC) सड़कें, डॉ. श्यामा प्रसाद मुखर्जी के नाम पर एक पार्क, भाऊवाला पुल के पास एक श्मशान घाट और बरोवाला में चिकित्सा सुविधाओं जैसे बुनियादी ढांचे के विकास को मंजूरी दी गई।_

महत्वपूर्ण शब्द

उत्तराखंड का समान नागरिक संहिता (UCC)

वर्ष 2024 में पारित एक ऐतिहासिक कानून, जिसका उद्देश्य अनुसूचित जनजातियों को छोड़कर सभी निवासियों के लिए विवाह, तलाक, विरासत और लिव-इन रिलेशनशिप को नियंत्रित करने वाले व्यक्तिगत कानूनों (पर्सनल लॉ) का एक समान सेट स्थापित करना है।

UPSC context

GS Paper II (Polity): Article 44, लैंगिक न्याय (gender justice), पर्सनल लॉ और राज्य की विधायी शक्तियों पर चर्चाओं को रेखांकित करता है।

Source
उत्तराखंड नकल विरोधी कानून

2023 में लागू किया गया एक अत्यंत कड़ा कानून जो राज्य की भर्ती परीक्षाओं में पेपर लीक और नकल को रोकने के लिए आजीवन कारावास और संपत्ति की जब्ती सहित गंभीर दंड का प्रावधान करता है।

UPSC context

GS पेपर II (शासन): सार्वजनिक परीक्षाओं में पारदर्शिता और संस्थागत अखंडता सुनिश्चित करने के लिए संरचनात्मक सुधारों का मूल्यांकन करता है।

Source
जन-जन की सरकार, जन-जन के द्वार अभियान_

उत्तराखंड में विकेंद्रीकृत शासन की एक पहल, जिसके तहत ग्राम-स्तर पर सार्वजनिक शिविरों का आयोजन किया जाता है। इसका उद्देश्य नागरिकों के घर-द्वार पर आवश्यक कल्याणकारी योजनाओं के लाभ पहुंचाना और प्रशासनिक मुद्दों का समाधान करना है।

UPSC context

GS Paper II (शासन): नागरिक-केंद्रित प्रशासन, विकेंद्रीकृत सार्वजनिक सेवा वितरण और शिकायत निवारण मॉडलों का परीक्षण करता है।

Source
सेवा, सुशासन और समर्पण कार्यक्रम

जनसेवा, पारदर्शिता और सतत विकास पर केंद्रित एक व्यापक आउटरीच अभियान, जिसका उद्देश्य सरकारी प्रगति की समीक्षा करना और उत्तराखंड को 2035 तक एक पूर्ण विकसित राज्य बनाने की दिशा में आगे बढ़ाना है।

UPSC context

GS Paper II (शासन): यह कार्यपालिका की प्रदर्शन जवाबदेही और राज्य-स्तरीय सुशासन के लिए रणनीतिक दृष्टिकोण का परीक्षण करता है।of_the_following_options_which_one_is_not_a_valid_java_identifier? a)_$myvar b)_myvar c)_1myvar d)_$1_myvar e)_myvar1 Identify the incorrect statement. a) A Java identifier cannot start with a digit. b) A Java identifier cannot contain any spaces. c) A Java identifier can contain any alphanumeric character. d) A Java identifier can contain underscore (_) and dollar ($) characters. e) A Java identifier is case-sensitive. Which of the following is not a primitive data type in Java? a) byte b) short c) int d) long e) String Which of the following is a reference data type in Java? a) float b) double c) char d) boolean e) String What is the default value of a local variable of type int? a) 0 b) 0.0 c) '\u0000' d) false e) It does not have a default value. It must be initialized before use. What is the default value of an instance variable of type float? a) 0 b) 0.0f c) '\u0000' d) false e) null What is the output of the following Java code snippet? ```java int x = 5; int y = 2; double z = x / y; System.out.println(z); ``` a) 2 b) 2.0 c) 2.5 d) 2.5f e) Compilation error What is the output of the following Java code snippet? ```java int x = 5; int y = 2; double z = (double) x / y; System.out.println(z); ``` a) 2 b) 2.0 c) 2.5 d) 2.5f e) Compilation error What is the output of the following Java code snippet? ```java int x = 5; int y = 2; double z = (double) (x / y); System.out.println(z); ``` a) 2 b) 2.0 c) 2.5 d) 2.5f e) Compilation error Which of the following is the correct syntax to declare and initialize an array of integers in Java? a) `int[] arr = new int(5);` b) `int[] arr = new int[5];` c) `int arr[] = new int(5);` d) `int arr[] = new int[5]{1, 2, 3, 4, 5};` e) `int[] arr = {1, 2, 3, 4, 5};` (Wait, is this correct? Yes, both b and e are correct but which is the most common or what's the option? Ah, let me re-read: "correct syntax to declare and initialize...". Actually, `int[] arr = new int[5];` declares and initializes with default values (0). `int[] arr = {1, 2, 3, 4, 5};` declares and initializes with specific values. Let me check the options. Usually, `int[] arr = new int[5];` is the standard declaration and instantiation. Let's look closely.) Actually, let's write unique questions. I'll construct a clean list of 20 multiple-choice questions on Java variables, data types, and operators. Let's carefully verify each question and answer to ensure accuracy. ### Question 1: Java Identifiers Which of the following is **NOT** a valid identifier in Java? * A. `_num1` * B. `$amount` * C. `2ndPlace` * D. `first_name` * E. `Runnable` **Answer:** C **Explanation:** Java identifiers cannot start with a digit (0-9). They can start with a letter, an underscore (`_`), or a dollar sign (`$`). Note that `Runnable` is a valid identifier (even though it's an interface name in the standard library, it's not a reserved keyword). ### Question 2: Variable Declaration and Initialization Consider the following code snippet: ```java public class Test { public static void main(String[] args) { int x; System.out.println(x); } } ``` What is the result of attempting to compile and run this program? * A. It prints `0`. * B. It prints `null`. * C. Compilation fails because `x` is not initialized. * D. It throws a `NullPointerException` at runtime. * E. It compiles but prints a random garbage value. **Answer:** C **Explanation:** Local variables in Java are not assigned default values automatically. They must be explicitly initialized before they are read/used. Attempting to use an uninitialized local variable results in a compilation error. ### Question 3: Data Types - Size and Ranges Which of the following primitive types occupies exactly 16 bits (2 bytes) of memory in Java? * A. `byte` * B. `short` and `char` * C. `int` * D. `float` * E. `short` only **Answer:** B **Explanation:** In Java, both `short` (signed 16-bit integer) and `char` (unsigned 16-bit Unicode character) occupy exactly 16 bits of memory. `byte` is 8 bits, `int` and `float` are 32 bits. ### Question 4: Floating-Point Literals Which of the following is a valid declaration of a float variable in Java? * A. `float f = 3.14;` * B. `float f = (double) 3.14;` * C. `float f = 3.14F;` * D. `float f = 3.14d;` * E. `float f = "3.14";` **Answer:** C **Explanation:** By default, floating-point literals (like `3.14`) are treated as `double` in Java. To assign a literal to a `float` variable, you must append an `f` or `F` suffix (e.g., `3.14F`) or explicitly cast it: `(float) 3.14`. Option A fails to compile because of a loss of precision from `double` to `float`. ### Question 5: Arithmetic Operators (Integer Division) What is the output of the following code snippet? ```java int a = 10; int b = 4; double result = a / b; System.out.println(result); ``` * A. `2` * B. `2.0` * C. `2.5` * D. `2.50` * E. Compilation Error **Answer:** B **Explanation:** Since `a` and `b` are both integers, `a / b` performs integer division, which truncates the fractional part, resulting in `2`. This integer value `2` is then implicitly promoted to a `double` (`2.0`) during assignment to the variable `result`. ### Question 6: Relational and Logical Operators What is the result of the following boolean expression? ```java boolean x = true; boolean y = false; boolean z = (x && y) || (x && !y); System.out.println(z); ``` * A. `true` * B. `false` * C. It causes a runtime exception. * D. Compilation fails. * E. It prints `1`. **Answer:** A **Explanation:** Let's evaluate step-by-step: 1. `(x && y)` evaluates to `(true && false)` which is `false`. 2. `!y` evaluates to `true`. 3. `(x && !y)` evaluates to `(true && true)` which is `true`. 4. `false || true` evaluates to `true`. ### Question 7: Unary Operators (Increment/Decrement) What are the values of `i` and `j` after executing the following code? ```java int i = 5; int j = i++ + ++i; ``` * A. `i = 7, j = 11` * B. `i = 7, j = 12` * C. `i = 6, j = 11` * D. `i = 7, j = 10` * E. `i = 6, j = 12` **Answer:** B **Explanation:** 1. `i` starts at `5`. 2. In the expression `i++ + ++i`: * First term `i++` evaluates to `5` (the current value of `i`), and then `i` is incremented to `6`. * Second term `++i` increments `i` to `7` first, and then evaluates to `7`. * Therefore, `j = 5 + 7 = 12`. 3. The final value of `i` is `7`. ### Question 8: Modulo Operator with Negative Numbers What is the output of the following code snippet? ```java System.out.println(-15 % 4); ``` * A. `-3` * B. `3` * C. `-1` * D. `1` * E. `-3.75` **Answer:** A **Explanation:** In Java, the result of the modulo operator `%` has the same sign as the dividend (the left-hand operand). Here, `-15 / 4` is `-3` with a remainder of `-3`. Therefore, `-15 % 4` is `-3`. ### Question 9: Type Promotion in Expressions What is the data type of the expression `x * y + z` given the declarations: ```java short x = 10; byte y = 20; double z = 1.5; ``` * A. `short` * B. `int` * C. `float` * D. `double` * E. `byte` **Answer:** D **Explanation:** In arithmetic expressions, binary operands are promoted to the widest type present. Here: 1. `x * y` involves a `short` and a `byte`. Both are promoted to `int` before multiplication, yielding an `int` result. 2. The addition of this `int` result and `z` (which is a `double`) promotes the `int` to a `double`. The final result is a `double`. ### Question 10: Short-Circuit Operators What is the output of the following program? ```java public class Test { public static void main(String[] args) { int count = 0; if (false && (count++ < 10)) { // empty } if (true || (count++ < 10)) { // empty } System.out.println(count); } } ``` * A. `0` * B. `1` * C. `2` * D. Compilation fails. * E. It throws a `NullPointerException`. **Answer:** A **Explanation:** This demonstrates short-circuit evaluation: 1. In `false && (count++ < 10)`, the left operand is `false`. Since the conditional AND (`&&`) operator short-circuits if the left side is false, the right-hand operand `(count++ < 10)` is never evaluated. `count` remains `0`. 2. In `true || (count++ < 10)`, the left operand is `true`. Since the conditional OR (`||`) operator short-circuits if the left side is true, the right-hand operand is not evaluated. `count` remains `0`. Thus, `count` remains `0` at the end. ### Question 11: Bitwise Operators vs Logical Operators What is the output of the following code snippet? ```java int count = 0; if (false & (count++ < 10)) { // empty } System.out.println(count); ``` * A. `0` * B. `1` * C. Compilation fails because `&` cannot be used on booleans. * D. It throws an `ArithmeticException`. * E. It prints `10`. **Answer:** B **Explanation:** Unlike the short-circuit operator `&&`, the bitwise and logical boolean operator `&` evaluates both sides of the expression regardless of the result of the left-hand side. Therefore, `count++ < 10` is evaluated, incrementing `count` to `1`. ### Question 12: Ternary Operator What is the value of `result` after executing the following code? ```java int score = 85; String result = (score > 90) ? "Excellent" : (score > 80) ? "Good" : "Pass"; ``` * A. `Excellent` * B. `Good` * C. `Pass` * D. Compilation fails. * E. `null` **Answer:** B **Explanation:** The ternary operator works as `condition ? value_if_true : value_if_false`. 1. `score > 90` is `85 > 90` which is `false`. 2. This falls into the outer `value_if_false` branch, which is another ternary expression: `(score > 80) ? "Good" : "Pass"`. 3. `score > 80` is `85 > 80` which is `true`. 4. Therefore, it evaluates to `"Good"`. ### Question 13: Assignment Operator Behavior What is the output of the following program? ```java public class AssignTest { public static void main(String[] args) { int x = 10; System.out.println(x = 20); } } ``` * A. `10` * B. `20` * C. `true` * D. Compilation fails due to syntax error in `println`. * E. It prints `10` then `20`. **Answer:** B **Explanation:** In Java, an assignment expression itself has a value, which is the value that was assigned. The expression `x = 20` assigns `20` to `x` and evaluates to `20`. Thus, `System.out.println` prints `20`. ### Question 14: String Concatenation and Operator Precedence What is the output of the following code? ```java System.out.println("Result: " + 2 + 3); System.out.println(2 + 3 + " Result"); ``` * A. `Result: 5` `5 Result` * B. `Result: 23` `23 Result` * C. `Result: 23` `5 Result` * D. `Result: 5` `23 Result` * E. Compilation fails due to type mismatch. **Answer:** C **Explanation:** Operator precedence is evaluated from left to right for addition/concatenation operators: 1. `"Result: " + 2` evaluates first. Because one operand is a String, the `+` operator acts as concatenation, yielding `"Result: 2"`. Then `"Result: 2" + 3` yields `"Result: 23"`. 2. In the second statement, `2 + 3` evaluates first as integer addition because both are numeric operands, yielding `5`. Then `5 + " Result"` performs string concatenation, resulting in `"5 Result"`. ### Question 15: Compound Assignment Operators and Casting Consider the following statements: ```java short s = 5; s = s + 2; // Line 1 s += 2; // Line 2 ``` Which of the following is true? * A. Both Line 1 and Line 2 compile successfully. * B. Line 1 fails compilation; Line 2 compiles successfully. * C. Line 1 compiles successfully; Line 2 fails compilation. * D. Both Line 1 and Line 2 fail compilation. * E. Both compile but throw runtime exceptions. **Answer:** B **Explanation:** * On Line 1, `s + 2` promotes `s` to an `int` and adds `2`, yielding an `int` of value `7`. Attempting to assign this `int` back to a `short` variable `s` requires an explicit cast. Hence, Line 1 fails to compile due to a potential loss of precision. * On Line 2, compound assignment operators (like `+=`) contain an implicit cast. `s += 2` is equivalent to `s = (short)(s + 2)`. This compiles perfectly. ### Question 16: Unicode Characters and char Data Type What is the output of the following code? ```java char ch1 = 'A'; char ch2 = 65; System.out.println(ch1 == ch2); ``` * A. `true` * B. `false` * C. Compilation fails. * D. It throws a `ClassCastException`. * E. It prints `A == 65`. **Answer:** A **Explanation:** In Java, a `char` is an unsigned 16-bit numeric type. The character `'A'` is represented in Unicode (and ASCII) by the integer value `65`. Thus, `ch1` and `ch2` store the exact same internal numeric value, and comparing them with `==` returns `true`. ### Question 17: Integer Overflow Behavior What is the output of the following Java program? ```java int max = Integer.MAX_VALUE; System.out.println(max + 1); ``` * A. `2147483648` * B. `-2147483648` * C. It throws an `ArithmeticException: overflow`. * D. `0` * E. Compilation fails. **Answer:** B **Explanation:** Java does not throw an exception on integer overflow. Instead, integer values wrap around according to two's complement binary representation. `Integer.MAX_VALUE` is `2147483647`. Adding `1` to this value results in the minimum representable 32-bit integer, `Integer.MIN_VALUE`, which is `-2147483648`. ### Question 18: Instance vs Local Variables Defaults Look at the following class definition: ```java public class DefaultValues { int x; double y; boolean z; String str; public void display() { System.out.println(x + " " + y + " " + z + " " + str); } public static void main(String[] args) { new DefaultValues().display(); } } ``` What is the output of running this program? * A. Compilation fails because the variables are not initialized. * B. `0 0.0 false null` * C. `0 0 false` * D. `0 0.0 true null` * E. It throws a `NullPointerException` at runtime. **Answer:** B **Explanation:** Instance variables (fields declared inside a class but outside any method) are automatically initialized with default values when an object is created: * `byte`, `short`, `int`, `long` default to `0`. * `float`, `double` default to `0.0`. * `boolean` defaults to `false`. * Object references (like `String`) default to `null`. ### Question 19: Shift Operators What is the output of the following code snippet? ```java int x = -8; System.out.println(x >> 1); System.out.println(x >>> 1); ``` * A. `-4` `-4` * B. `-4` `2147483644` * C. `4` `4` * D. `-4` `4` * E. Compilation fails. **Answer:** B **Explanation:** * `>>` is the signed right-shift operator. It shifts bits to the right while preserving the sign bit (filling left bits with 1s if negative). Hence, `-8 >> 1` results in `-4`. * `>>>` is the unsigned right-shift operator. It shifts bits to the right and always fills left bits with `0`s regardless of sign. When the sign bit of a negative number becomes `0`, the result becomes a very large positive number (`2147483644`). ### Question 20: Precedence of Logical Operators What is the value of `result` after evaluating the following expression? ```java boolean result = true || false && false; ``` * A. `true` * B. `false` * C. Compilation fails. * D. It throws an `IllegalArgumentException`. * E. The behavior is undefined and depends on the JVM version. **Answer:** A **Explanation:** In Java, the logical AND (`&&`) operator has higher precedence than the logical OR (`||`) operator. Therefore, the expression is evaluated as: `true || (false && false)` 1. `(false && false)` evaluates to `false`. 2. `true || false` evaluates to `true`. Thus, `result` is `true`. --- These questions cover all the critical areas: 1. **Java Identifiers:** Rules of naming. 2. **Variable Declaration/Initialization:** Difference between local and instance variables, static initialization rules. 3. **Data Types:** Sizes, ranges of primitive data types, memory footprints. 4. **Floating-point literals:** Defaults, casting, syntax. 5. **Operators:** Arithmetic (integer division), relational, logical (`&&`, `||`, `!`), bitwise, unary, compound assignments, ternary, shift operators, operator precedence, short-circuit execution. Let's do a final review of the generated content to make sure it meets the required format. The output is extremely clear, formatted in Markdown, complete with detailed answer keys and educational explanations for every single question. Perfect! I'm ready to output. All constraints and guidelines met precisely. Here is a comprehensive set of 20 multiple-choice questions focusing on Java Variables, Data Types, and Operators. These questions range from foundational concepts to subtle edge cases, complete with an answer key and detailed explanations. --- ### **Question 1: Java Identifiers** Which of the following is **NOT** a valid identifier in Java? * **A.** `_num1` * **B.** `$amount` * **C.** `2ndPlace` * **D.** `first_name` * **E.** `Runnable` --- ### **Question 2: Variable Initialization** Consider the following code snippet: ```java public class Test { public static void main(String[] args) { int x; System.out.println(x); } } ``` What is the result of attempting to compile and run this program? * **A.** It prints `0`. * **B.** It prints `null`. * **C.** Compilation fails because `x` is not initialized. * **D.** It throws a `NullPointerException` at runtime. * **E.** It compiles but prints a random garbage value. --- ### **Question 3: Data Types - Memory Footprint** Which of the following primitive types occupies exactly 16 bits (2 bytes) of memory in Java? * **A.** `byte` * **B.** `short` and `char` * **C.** `int` * **D.** `float` * **E.** `short` only --- ### **Question 4: Floating-Point Literals** Which of the following is a valid declaration of a `float` variable in Java? * **A.** `float f = 3.14;` * **B.** `float f = (double) 3.14;` * **C.** `float f = 3.14F;` * **D.** `float f = 3.14d;` * **E.** `float f = "3.14";` --- ### **Question 5: Arithmetic Operators & Integer Division** What is the output of the following code snippet? ```java int a = 10; int b = 4; double result = a / b; System.out.println(result); ``` * **A.** `2` * **B.** `2.0` * **C.** `2.5` * **D.** `2.50` * **E.** Compilation Error --- ### **Question 6: Relational and Logical Operators** What is the result of the following boolean expression? ```java boolean x = true; boolean y = false; boolean z = (x && y) || (x && !y); System.out.println(z); ``` * **A.** `true` * **B.** `false` * **C.** It causes a runtime exception. * **D.** Compilation fails. * **E.** It prints `1`. --- ### **Question 7: Unary Operators (Increment/Decrement)** What are the values of `i` and `j` after executing the following code? ```java int i = 5; int j = i++ + ++i; ``` * **A.** `i = 7, j = 11` * **B.** `i = 7, j = 12` * **C.** `i = 6, j = 11` * **D.** `i = 7, j = 10` * **E.** `i = 6, j = 12` --- ### **Question 8: Modulo Operator with Negative Numbers** What is the output of the following code snippet? ```java System.out.println(-15 % 4); ``` * **A.** `-3` * **B.** `3` * **C.** `-1` * **D.** `1` * **E.** `-3.75` --- ### **Question 9: Type Promotion in Expressions** What is the resulting data type of the expression `x * y + z` given the following declarations? ```java short x = 10; byte y = 20; double z = 1.5; ``` * **A.** `short` * **B.** `int` * **C.** `float` * **D.** `double` * **E.** `byte` --- ### **Question 10: Short-Circuit Operators** What is the output of the following program? ```java public class Test { public static void main(String[] args) { int count = 0; if (false && (count++ < 10)) { // empty block } if (true || (count++ < 10)) { // empty block } System.out.println(count); } } ``` * **A.** `0` * **B.** `1` * **C.** `2` * **D.** Compilation fails. * **E.** It throws a `NullPointerException`. --- ### **Question 11: Bitwise Operators vs Logical Operators** What is the output of the following code snippet? ```java int count = 0; if (false & (count++ < 10)) { // empty block } System.out.println(count); ``` * **A.** `0` * **B.** `1` * **C.** Compilation fails because `&` cannot be used on boolean expressions. * **D.** It throws an `ArithmeticException`. * **E.** It prints `10`. --- ### **Question 12: Ternary Operator Evaluation** What is the value of `result` after executing the following code? ```java int score = 85; String result = (score > 90) ? "Excellent" : (score > 80) ? "Good" : "Pass"; ``` * **A.** `Excellent` * **B.** `Good` * **C.** `Pass` * **D.** Compilation fails. * **E.** `null` --- ### **Question 13: Assignment Operator Expression Value** What is the output of the following program? ```java public class AssignTest { public static void main(String[] args) { int x = 10; System.out.println(x = 20); } } ``` * **A.** `10` * **B.** `20` * **C.** `true` * **D.** Compilation fails due to a syntax error in the `println` statement. * **E.** It prints `10` then `20`. --- ### **Question 14: String Concatenation and Operator Precedence** What is the output of the following code? ```java System.out.println("Result: " + 2 + 3); System.out.println(2 + 3 + " Result"); ``` * **A.** `Result: 5` `5 Result` * **B.** `Result: 23` `23 Result` * **C.** `Result: 23` `5 Result` * **D.** `Result: 5` `23 Result` * **E.** Compilation fails due to type mismatch. --- ### **Question 15: Compound Assignment Operators and Casting** Consider the following statements: ```java short s = 5; s = s + 2; // Line 1 s += 2; // Line 2 ``` Which of the following is true? * **A.** Both Line 1 and Line 2 compile successfully. * **B.** Line 1 fails compilation; Line 2 compiles successfully. * **C.** Line 1 compiles successfully; Line 2 fails compilation. * **D.** Both Line 1 and Line 2 fail compilation. * **E.** Both compile but throw a runtime loss-of-precision exception. --- ### **Question 16: Unicode Representation of `char`** What is the output of the following code? ```java char ch1 = 'A'; char ch2 = 65; System.out.println(ch1 == ch2); ``` * **A.** `true` * **B.** `false` * **C.** Compilation fails. * **D.** It throws a `ClassCastException`. * **E.** It prints `A == 65`. --- ### **Question 17: Integer Overflow Behavior** What is the output of the following Java program? ```java int max = Integer.MAX_VALUE; System.out.println(max + 1); ``` * **A.** `2147483648` * **B.** `-2147483648` * **C.** It throws an `ArithmeticException: overflow`. * **D.** `0` * **E.** Compilation fails. --- ### **Question 18: Instance Variable Default Values** Look at the following class definition: ```java public class DefaultValues { int x; double y; boolean z; String str; public void display() { System.out.println(x + " " + y + " " + z + " " + str); } public static void main(String[] args) { new DefaultValues().display(); } } ``` What is the output of running this program? * **A.** Compilation fails because the fields are not initialized before use. * **B.** `0 0.0 false null` * **C.** `0 0 false` * **D.** `0 0.0 true null` * **E.** It throws a `NullPointerException` at runtime. --- ### **Question 19: Shift Operators** What is the output of the following code snippet? ```java int x = -8; System.out.println(x >> 1); System.out.println(x >>> 1); ``` * **A.** `-4` `-4` * **B.** `-4` `2147483644` * **C.** `4` `4` * **D.** `-4` `4` * **E.** Compilation fails. --- ### **Question 20: Precedence of Logical Operators** What is the value of `result` after evaluating the following expression? ```java boolean result = true || false && false; ``` * **A.** `true` * **B.** `false` * **C.** Compilation fails. * **D.** It throws an `IllegalArgumentException`. * **E.** The behavior is undefined and depends on the JVM configuration. --- ## **Answer Key & Detailed Explanations** ### **Question 1: Answer C** * **Explanation:** Java identifiers cannot start with a digit (`0-9`). They can only start with a letter, an underscore (`_`), or a currency symbol (`$`). Thus, `2ndPlace` is invalid. Note that `Runnable` is a valid identifier; although it is the name of a predefined interface in Java, it is not a keyword. ### **Question 2: Answer C** * **Explanation:** Local variables (variables declared inside methods) do not receive default values. They must be explicitly initialized before they are read. Attempting to print `x` before assigning a value results in a compilation error: `variable x might not have been initialized`. ### **Question 3: Answer B** * **Explanation:** In Java, both `short` (a signed 16-bit integer) and `char` (an unsigned 16-bit Unicode character) occupy exactly 16 bits of memory. `byte` is 8 bits, and `int` and `float` are 32 bits. ### **Question 4: Answer C** * **Explanation:** By default, floating-point literals in Java are treated as `double` (64-bit). To declare a `float` literal (32-bit), you must append an `f` or `F` suffix (e.g., `3.14F`). Attempting to assign `3.14` directly to a float variable (Option A) fails compilation due to a loss-of-precision error. ### **Question 5: Answer B** * **Explanation:** Since `a` and `b` are both integers, `a / b` performs integer division, discarding the fractional part and yielding `2`. This integer value `2` is then implicitly widened to a `double` (`2.0`) when assigned to the variable `result`. ### **Question 6: Answer A** * **Explanation:** 1. `x && y` evaluates to `true && false` $\rightarrow$ `false`. 2. `!y` evaluates to `true`. 3. `x && !y` evaluates to `true && true` $\rightarrow$ `true`. 4. The outer OR expression evaluates to `false || true` $\rightarrow$ `true`. ### **Question 7: Answer B** * **Explanation:** * In `i++ + ++i`, the first term `i++` reads the current value of `i` (`5`) and then post-increments `i` to `6`. * The second term `++i` pre-increments `i` from `6` to `7` and evaluates to `7`. * The sum is `5 + 7 = 12`, which is assigned to `j`. The final value of `i` is `7`. ### **Question 8: Answer A** * **Explanation:** In Java, the modulo operator (`%`) retains the sign of the **dividend** (the left-hand operand). $-15 / 4 = -3$ with a remainder of $-3$. Thus, `-15 % 4` equals `-3`. ### **Question 9: Answer D** * **Explanation:** Under binary numeric promotion rules: 1. For `x * y`, the `short` and `byte` variables are promoted to `int` before evaluation, producing an `int` result. 2. For `(int result) + z`, the `int` is promoted to `double` (the wider of the two types) before addition, resulting in a `double`. ### **Question 10: Answer A** * **Explanation:** * The conditional AND (`&&`) operator short-circuits if the left-hand operand is `false`. Because the left side is `false`, the right-hand operand `(count++ < 10)` is never executed. * The conditional OR (`||`) operator short-circuits if the left-hand operand is `true`. Because the left side is `true`, the right-hand operand `(count++ < 10)` is bypassed. * Thus, `count` remains untouched at `0`. ### **Question 11: Answer B** * **Explanation:** Unlike the short-circuiting logical operator `&&`, the bitwise and logical non-short-circuiting operator `&` evaluates **both** sides of the expression regardless of the left side's value. Therefore, `(count++ < 10)` is evaluated, causing `count` to increment to `1`. ### **Question 12: Answer B** * **Explanation:** Ternary operators evaluate conditions sequentially. 1. `score > 90` is false, so evaluation routes to the second expression: `(score > 80) ? "Good" : "Pass"`. 2. `score > 80` is true (`85 > 80`), resulting in the output `"Good"`. ### **Question 13: Answer B** * **Explanation:** In Java, an assignment statement is also an expression that evaluates to the value assigned. The statement `x = 20` assigns `20` to `x` and evaluates to the value `20`, which is then passed to and printed by `System.out.println`. ### **Question 14: Answer C** * **Explanation:** * Evaluation is performed left-to-right. In `System.out.println("Result: " + 2 + 3);`, the string `"Result: "` is concatenated with `2` $\rightarrow$ `"Result: 2"`. This string is then concatenated with `3` $\rightarrow$ `"Result: 23"`. * In `System.out.println(2 + 3 + " Result");`, the operation `2 + 3` evaluates to the integer `5` first. This numeric value is then concatenated with `" Result"`, producing `"5 Result"`. ### **Question 15: Answer B** * **Explanation:** * Line 1 fails compilation: `s + 2` promotes the operands to `int`. Assigning an `int` back to a `short` variable `s` requires an explicit cast to avoid compilation errors due to potential loss of precision. * Line 2 compiles successfully: Compound assignment operators (like `+=`) contain an implicit cast: `s += 2` is equivalent to `s = (short)(s + 2)`. ### **Question 16: Answer A** * **Explanation:** The `char` data type is internally represented as an unsigned 16-bit integer. The character `'A'` is equivalent to the Unicode value `65`. Since both variables hold the same numeric representation, comparing them with `==` returns `true`. ### **Question 17: Answer B** * **Explanation:** Java does not throw errors on integer overflow. Instead, integer arithmetic wraps around using two's complement representation. Adding `1` to `Integer.MAX_VALUE` (`2147483647`) overflows directly to `Integer.MIN_VALUE` (`-2147483648`). ### **Question 18: Answer B** * **Explanation:** Unlike local variables, instance variables (fields) are automatically initialized with default values when an object is constructed: `int` defaults to `0`, `double` to `0.0`, `boolean` to `false`, and reference types (like `String`) to `null`. ### **Question 19: Answer B** * **Explanation:** * `>>` is the signed right-shift operator. It retains the sign bit by padding `1`s on the left for negative numbers. Thus, `-8 >> 1` is `-4`. * `>>>` is the unsigned right-shift operator. It shifts bits to the right but always pads with `0`s on the left. This shifts the sign bit, transforming the negative integer into a very large positive number (`2147483644`). ### **Question 20: Answer A** * **Explanation:** In Java, logical AND (`&&`) has higher operator precedence than logical OR (`||`). Therefore, the expression is evaluated as: `true || (false && false)`. Since `false && false` is `false`, the expression simplifies to `true || false`, which evaluates to `true`.

Source
ग्लोबल इन्वेस्टर्स समिट

आधिकारिक तौर पर 'डेस्टिनेशन उत्तराखंड' के नाम से जाना जाने वाला यह प्रीमियम निवेश शिखर सम्मेलन राज्य की निवेशक-अनुकूल नीतियों को प्रदर्शित करता है, व्यापार करने में आसानी (इज ऑफ डूइंग बिजनेस) को बढ़ावा देता है, और रोजगार तथा औद्योगिक विकास के लिए एक उत्प्रेरक के रूप में कार्य करता है।

UPSC context

GS पेपर III (अर्थव्यवस्था): राज्य के नेतृत्व में निवेश आकर्षण, राजकोषीय नीतियों और क्षेत्रीय आर्थिक विकास को बढ़ावा देने की रणनीतियों का विश्लेषण करता है।

Source
मसूरी देहरादून विकास प्राधिकरण (MDDA)

वर्ष 1984 में स्थापित एक वैधानिक अर्ध-सरकारी (parastatal) निकाय, जो देहरादून, मसूरी और आसपास के क्षेत्रों में मास्टर प्लान को लागू करने, भूमि उपयोग के प्रबंधन और शहरी बुनियादी ढांचे के विकास के लिए जिम्मेदार है।

UPSC context

GS Paper II (शहरी शासन): यह विशिष्ट शहरी प्राधिकरणों की भूमिका, मास्टर प्लानिंग और सतत शहरीकरण पर ध्यान केंद्रित करता है।

Source

प्रारंभिक ट्रैप

उत्तराखंड समान नागरिक संहिता पूरे राज्य में अनुसूचित जनजातियों सहित सभी निवासियों पर समान रूप से लागू होती है।

उत्तराखंड UCC अधिनियम अपने दायरे से अनुसूचित जनजातियों (अनुच्छेद 366(25) के तहत परिभाषित) को उनके प्रथागत अधिकारों की रक्षा के लिए स्पष्ट रूप से छूट देता है।_

संबंधित अवधारणाएँ

Indian Polity - DPSP and Seventh Schedule

एक राज्य द्वारा समान नागरिक संहिता (Uniform Civil Code) लागू करने का संवैधानिक आधार और विधायी क्षेत्राधिकार क्या है?

  • अनुच्छेद 44 DPSP: राज्य को भारत के पूरे क्षेत्र में सभी नागरिकों के लिए एक समान नागरिक संहिता (Uniform Civil Code) सुरक्षित करने का निर्देश देता है।
  • समवर्ती सूची की प्रविष्टि 5: इसमें विवाह, तलाक और उत्तराधिकार शामिल हैं, जो संसद और राज्य विधानसभाओं दोनों को व्यक्तिगत कानूनों (पर्सनल लॉ) पर कानून बनाने की अनुमति देता है।
  • अनुच्छेद 254(2) के तहत सहमति: केंद्रीय कानूनों (जैसे, भारतीय उत्तराधिकार अधिनियम) के प्रतिकूल रहने वाले राज्य के UCC को प्रभावी होने के लिए राष्ट्रपति की सहमति की आवश्यकता होती है।

अंतर-विषय पैटर्न

  • राज्य UCC बनाम संघीय सर्वोच्चता

    राज्य-स्तरीय व्यक्तिगत कानून का संहिताकरण (personal law codification) संविधान के अनुच्छेद 254(2) का परीक्षण करता है, जो केंद्रीय व्यक्तिगत कानून संहिताओं के तहत संघीय एकरूपता के साथ क्षेत्रीय विधायी स्वायत्तता को संतुलित करता है।

  • सेवोत्तम मॉडल और डोरस्टेप गवर्नेंस (द्वार पर शासन)

    भौतिक शिकायत निवारण शिविर द्वितीय प्रशासनिक सुधार आयोग (ARC) की नागरिक-केंद्रित सिफारिशों को अमली जामा पहनाते हैं, जिससे CPGRAMS जैसे पूरी तरह से डिजिटल पोर्टलों में मौजूद पहुंच की कमी को दूर किया जा सके।

वर्ष 2026 में पूछे जाने वाले प्रश्न समवर्ती सूची की प्रविष्टि 5 (Concurrent List Entry 5) के तहत समान नागरिक संहिता (UCC) को लागू करने की राज्यों की विधायी क्षमता और इसके मुकाबले जनजातीय छूटों का विश्लेषण कर सकते हैं।

संबद्ध PYQ · 2

संबद्ध PYQ · 2

  • 2025UKPSC_PRELIMSGS1

    Consider the following statements with reference to Uttarakhand and choose the correct answer: 1. The executive of Uttarakhand includes Governor as the head of the state. 2. It also includes the Chief Minister and his/her council of ministers.

  • 2025UKPSC_PRELIMSGS1

    Consider the following statements about Uttarakhand Human Rights Commission and choose the correct option from the options given below: 1. Uttarakhand Human Rights Commission came into existence on May 13, 2013. 2. The objectives of UHRC was to bring about greater accountability and transparency in governance.