दिलचस्प पोस्ट
एंटीटी फ्रेमवर्क 6 में मल्टी-एसिंक? एनजी-क्लिक ng-repeat के अंदर काम नहीं करता है सरणी के तत्वों में शामिल हों? सीखना VB6 स्प्रिंग-बूट जर्सी: जर्सी को स्थिर सामग्री प्रदान करने की अनुमति दें जानकारी के लिए एक वेबसाइट (या पेज) को कैसे स्कैन करें, और इसे मेरे कार्यक्रम में लाएं? एंड्रॉइड त्रुटि – ओपन असफल ईनोन्ट वरीयता के पृष्ठभूमि का रंग बदलें हल करने के लिए "भूमिका का संग्रह शुरू करने के लिए आज़ादी में विफल" अपवाद PrintWriter और PrintStream कभी IOExceptions फेंक नहीं शून्य / नल को आरक्षित करें / रीसेट करें एंड्रॉइड: Async टास्क रद्द करें n कस्टम प्रकार के लिए मैपिंग हेइबरनेट करें Django में, मैं डेटाबेस से 100 यादृच्छिक रिकॉर्ड कैसे चुन सकता हूं? कैसे LINQ उत्पन्न एसक्यूएल बयान को देखने के लिए?

लीप वर्ष की गणना के लिए जावा कोड

मैं "जावा के कला और विज्ञान" पुस्तक का पालन कर रहा हूं और यह दिखाता है कि एक लीप वर्ष की गणना कैसे करें। पुस्तक एसीएम जावा टास्क फोर्स की लाइब्रेरी का उपयोग करती है

यहां किताबों का उपयोग करने वाला कोड है:

import acm.program.*; public class LeapYear extends ConsoleProgram { public void run() { println("This program calculates leap year."); int year = readInt("Enter the year: "); boolean isLeapYear = ((year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0)); if (isLeapYear) { println(year + " is a leap year."); } else println(year + " is not a leap year."); } } 

अब, इस तरह मैं लीप वर्ष की गणना करता हूं।

 import acm.program.*; public class LeapYear extends ConsoleProgram { public void run() { println("This program calculates leap year."); int year = readInt("Enter the year: "); if ((year % 4 == 0) && year % 100 != 0) { println(year + " is a leap year."); } else if ((year % 4 == 0) && (year % 100 == 0) && (year % 400 == 0)) { println(year + " is a leap year."); } else { println(year + " is not a leap year."); } } } 

क्या मेरे कोड में कोई गड़बड़ है या क्या मुझे किताब द्वारा उपलब्ध कराई गई किसी का उपयोग करना चाहिए?

संपादित करें: उपर्युक्त दोनों कोड ठीक काम करता है, मैं क्या पूछना चाहता हूं कि लीप वर्ष की गणना करने का सबसे अच्छा तरीका कौन सी कोड है।

Solutions Collecting From Web of "लीप वर्ष की गणना के लिए जावा कोड"

वे मेरे लिए वही देखते हैं, हालांकि ध्यान दें कि आपके कोड में यह पंक्ति कुछ अतिरेक है:

 else if ((year % 4 == 0) && (year % 100 == 0) && (year % 400 == 0)) 

द्वारा प्रतिस्थापित किया जा सकता है:

 else if (year % 400 == 0) 

अगर कोई संख्या 400 का एक बहुमूल्य है, तो यह स्वचालित रूप से 100 और 4 का एक भी है।

संपादित करें: (7 साल बाद!)

कृपया ध्यान दें कि उपरोक्त मूल प्रश्न से पूर्ववर्ती उपस्थिति की गिनती if ((year % 4 == 0) && year % 100 != 0) !

किसी भी मामले में, लाइब्रेरी कोड का उपयोग करना एक बेहतर समाधान है, क्लेक्टस का जवाब स्वीकार किया जाना चाहिए: https://stackoverflow.com/a/1021373/8331

सही कार्यान्वयन है:

 public static boolean isLeapYear(int year) { Calendar cal = Calendar.getInstance(); cal.set(Calendar.YEAR, year); return cal.getActualMaximum(Calendar.DAY_OF_YEAR) > 365; } 

लेकिन अगर आप इस पहिया को फिर से लगाने के लिए जा रहे हैं तो:

 public static boolean isLeapYear(int year) { if (year % 4 != 0) { return false; } else if (year % 400 == 0) { return true; } else if (year % 100 == 0) { return false; } else { return true; } } 

मैं सुझाव देता हूं कि आप इस कोड को एक विधि में डालते हैं और एक इकाई परीक्षण बनाते हैं।

 public static boolean isLeapYear(int year) { assert year >= 1583; // not valid before this date. return ((year % 4 == 0) && (year % 100 != 0)) || (year % 400 == 0); } 

यूनिट टेस्ट में

 assertTrue(isLeapYear(2000)); assertTrue(isLeapYear(1904)); assertFalse(isLeapYear(1900)); assertFalse(isLeapYear(1901)); 

java.time.Year::isLeap

मैं इस Year वर्ग के साथ ऐसा करने के नए java.time तरीके को जोड़ना चाहता हूं और isLeap विधि:

 java.time.Year.of(year).isLeap() 
 new GregorianCalendar().isLeapYear(year); 

विकिपीडिया से छद्म कोड सबसे कॉम्पैक्ट जावा में अनुवादित है

 (year % 400 == 0) || ((year % 4 == 0) && (year % 100 != 0)) 

जावा के ग्रेगोरियन कैलेंडर स्रोत कोड से:

 /** * Returns true if {@code year} is a leap year. */ public boolean isLeapYear(int year) { if (year > changeYear) { return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0); } return year % 4 == 0; } 

जहां परिवर्तन वर्ष साल है जूलियन कैलेंडर ग्रेगोरीयन कैलेंडर (1582) बन जाता है

जूलियन कैलेंडर हर चार वर्षों में छलांग वर्ष निर्दिष्ट करता है, जबकि ग्रेगोरियन कैलेंडर सदी के वर्षों को छोड़ देता है जो कि 400 से विभाजित नहीं हैं।

ग्रेगोरियन कैलेंडर दस्तावेज़ में आप इसके बारे में अधिक जानकारी पा सकते हैं।

सबसे कुशल लीप वर्ष टेस्ट:

 if ((year & 3) == 0 && ((year % 25) != 0 || (year & 15) == 0)) { /* leap year */ } 

यह मेरे विस्तृत उत्तर से https://stackoverflow.com/a/11595914/733805 पर एक अंश है

सॉफ़्टवेयर में पुनरावृत्ति करने के लिए लगभग हमेशा गलत होता है किसी भी इंजीनियरिंग अनुशासन में, फार्म का पालन करना चाहिए, और आपके पास तीन शाखाएं हैं जिनके पास दो संभावित मार्ग हैं – यह एक लीप वर्ष है या नहीं।

तंत्र जिस पर एक पंक्ति पर परीक्षण होता है, उसमें कोई समस्या नहीं होती है, लेकिन आम तौर पर यह परीक्षण को एक समारोह में अलग करना बेहतर होता है जो एक वर्ष का प्रतिनिधित्व करता है और एक बूलियन देता है कि यह वर्ष एक लीप वर्ष है या नहीं। । इस तरह आप इसके साथ कुछ कर सकते हैं जो कि कंसोल पर मानक आउटपुट पर प्रिंट करता है, और इसे आसानी से जांच सकता है।

कोड जो अपने प्रदर्शन बजट को पार करने के लिए जाना जाता है, परीक्षणों की व्यवस्था करने के लिए सामान्य है ताकि वे बेमानी न हो जाएं और एक आदेश में परीक्षण कर सकें, जो कि शुरुआती लाभ देता है विकिपीडिया का उदाहरण ऐसा करता है – अधिकांश वर्षों के लिए आपको मॉड्यूलो 400,100 और 4 का आकलन करना पड़ता है, लेकिन कुछ के लिए आपको केवल 400 रुपये या 400 और 100 रुपये की आवश्यकता है। यह प्रदर्शन के संदर्भ में एक छोटा अनुकूलन है (सर्वोत्तम पर, केवल एक सौ में इनपुट प्रभावित होते हैं), लेकिन इसका यह भी मतलब है कि कोड में पुनरावृत्ति कम है, और प्रोग्रामर के टाइपिंग में कम है।

यदि आप java8 का प्रयोग कर रहे हैं:

 java.time.Year.of(year).isLeap() 

उपरोक्त विधि के जावा कार्यान्वयन:

 public static boolean isLeap(long year) { return ((year & 3) == 0) && ((year % 100) != 0 || (year % 400) == 0); } 

आप इस के लिए ग्रेगोरियन कैलेंण्डर वर्ग से पूछ सकते हैं:

 boolean isLeapyear = new GregorianCalendar().isLeapYear(year); 

मैंने ये ढूंढ निकाला। यह देखने के लिए एक जोड़ा कार्य है कि क्या इंट उस तारीख से पहले है, जिस पर अपवाद लागू किए गए थे (सालाना 100, वर्ष% 400)। 1582 से पहले उन अपवाद लगभग नहीं थे।

 import java.util.Scanner; public class lecture{ public static void main(String[] args) { boolean loop=true; Scanner console = new Scanner( System.in ); while (loop){ System.out.print( "Enter the year: " ); int year= console.nextInt(); System.out.println( "The year is a leap year: "+ leapYear(year) ); System.out.print( "again?: " ); int again = console.nextInt(); if (again == 1){ loop=false; }//if } } public static boolean leapYear ( int year){ boolean leaped = false; if (year%4==0){ leaped = true; if(year>1582){ if (year%100==0&&year%400!=0){ leaped=false; } } }//1st if return leaped; } } 
 public static void main(String[] args) { String strDate="Feb 2013"; String[] strArray=strDate.split("\\s+"); Calendar cal = Calendar.getInstance(); cal.setTime(new SimpleDateFormat("MMM").parse(strArray[0].toString())); int monthInt = cal.get(Calendar.MONTH); monthInt++; cal.set(Calendar.YEAR, Integer.parseInt(strArray[1])); strDate=strArray[1].toString()+"-"+monthInt+"-"+cal.getActualMaximum(Calendar.DAY_OF_MONTH); System.out.println(strDate); } 
  import java.util.Scanner; public class LeapYear { public static void main(String[] args) { // TODO Auto-generated method stub Scanner input = new Scanner(System.in); System.out.print("Enter the year then press Enter : "); int year = input.nextInt(); if ((year < 1580) && (year % 4 == 0)) { System.out.println("Leap year: " + year); } else { if ((year % 4 == 0) && (year % 100 != 0) || (year % 400 == 0)) { System.out.println("Leap year: " + year); } else { System.out.println(year + " not a leap year!"); } } } } 

जैसा कि विकिपीडिया राज्य एल्गोरिदम लीप वर्ष के लिए होना चाहिए

 (((year%4 == 0) && (year%100 !=0)) || (year%400==0)) 

यहाँ एक नमूना कार्यक्रम है जिसे लीप वर्ष की जांच करना है ।

आपका कोड, जैसा कि एक अतिरिक्त वर्ग के बिना, सार्वभौमिक जावा के लिए काम नहीं करता है। यहां एक सरलीकृत संस्करण है जो कहीं भी काम करता है, आपके कोड के प्रति अधिक झुकाव।

 import java.util.*; public class LeapYear { public static void main(String[] args) { int year; { Scanner scan = new Scanner(System.in); System.out.println("Enter year: "); year = scan.nextInt(); if ((year % 4 == 0) && year % 100 != 0) { System.out.println(year + " is a leap year."); } else if ((year % 4 == 0) && (year % 100 == 0) && (year % 400 == 0)) { System.out.println(year + " is a leap year."); } else { System.out.println(year + " is not a leap year."); } } } } 

आपका कोड, संदर्भ में, ठीक ही काम करता है, लेकिन ध्यान रखें कि पुस्तक कोड हमेशा काम करता है , और पूरी तरह से परीक्षण किया जाता है। नहीं कहना तुम्हारा नहीं है 🙂

जावा लीप वर्ष बनाने के लिए आसान तरीका है और enter code here को समझने के लिए अधिक स्पष्ट enter code here

 import java.util.Scanner; 

कक्षा क्यू 1 9

 public static void main(String[] args) { Scanner input=new Scanner(System.in); double a; System.out.println("enter the year here "); a=input.nextDouble(); if ((a % 4 ==0 ) && (a%100!=0) || (a%400==0)) { System.out.println("leep year"); } else { System.out.println("not a leap year"); } } 

}

 import javax.swing.*; public class LeapYear { public static void main(String[] args) { int year; String yearStr = JOptionPane.showInputDialog(null, "Enter radius: " ); year = Integer.parseInt( yearStr ); boolean isLeapYear; isLeapYear = (year % 4 == 0 && year % 100 != 0) || (year % 400 == 0); if(isLeapYear){ JOptionPane.showMessageDialog(null, "Leap Year!"); } else{ JOptionPane.showMessageDialog(null, "Not a Leap Year!"); } } } 
 boolean leapYear = ( ( year % 4 ) == 0 );