दिलचस्प पोस्ट
स्कीमा परिभाषित किए बिना आप मोंगोज़ोस का उपयोग कैसे करते हैं? सुरक्षाएक्सेप्शन: कॉलर यूआईडी XXXX प्रामाणिकेटर की यूआईडी से अलग है Ls में bash का उपयोग करने वाली निर्देशिकाओं को सूचीबद्ध करना: एक परीक्षा जावा में यादृच्छिक भारित चयन UIBarButtonItem कस्टम दृश्य के साथ IOS 7 पर ठीक से गठबंधन नहीं है जब बाएं या दायां नेविगेशन बार आइटम के रूप में उपयोग किया जाता है बॉट फ़्रेमवर्क को एम्बेडेड चैट कंट्रोल पेज के ServiceUrl मिलता है कैसे छवि संसाधन से base64encoded स्ट्रिंग बनाने के लिए क्या डीप्टर हर एक को सूचीबद्ध किए बिना कई चर पर संक्षेप कर सकता है? एक संपत्ति बनाना deserialize लेकिन json.net के साथ क्रमबद्ध नहीं है यूटीएफ -8 में 3 बाइट्स से अधिक ले जाने वाले यूनिकोड वर्णों को फ़िल्टर करने (या बदलने के लिए) कैसे करें? यादृच्छिक संख्या को समान रूप से पूरी रेंज पर जनरेट करें ट्रेविस-सीआई पर गुप्त एपीआई कुंजी का उपयोग करना मैं सी में एक बहुआयामी सरणी को सही तरीके से कैसे स्थापित, एक्सेस और मुक्त कर सकता हूं? WooCommerce शो कस्टम कॉलम टेम्पलेट का उपयोग करते समय मुझे "अनसुलझे बाहरी प्रतीक" त्रुटियां क्यों मिलती हैं?

एक इंट संख्या के अलग अंक कैसे प्राप्त करें?

मेरे पास 1100, 1002, 1022 आदि जैसी संख्याएं हैं। मैं व्यक्तिगत अंक चाहूंगा, उदाहरण के लिए, पहले नंबर 1100 में मुझे 1, 1, 0, 0 होना चाहिए।

मैं इसे जावा में कैसे प्राप्त कर सकता हूं?

Solutions Collecting From Web of "एक इंट संख्या के अलग अंक कैसे प्राप्त करें?"

ऐसा करने के लिए, आप % (mod) ऑपरेटर का उपयोग करेंगे

 int number; // = some int while (number > 0) { print( number % 10); number = number / 10; } 

मॉड ऑपरेटर आपको एक नंबर पर इंट डिवीजन करने का शेष दे देगा।

इसलिए,

 10012 % 10 = 2 

इसलिये:

 10012 / 10 = 1001, remainder 2 

नोट: जैसा पौलुस ने कहा, यह आपको रिवर्स ऑर्डर में नंबर देगा। आपको स्टैक पर उन्हें धक्का देना होगा और उन्हें रिवर्स ऑर्डर में पॉप अप करना होगा।

संख्याओं को सही क्रम में प्रिंट करने के लिए कोड:

 int number; // = and int LinkedList<Integer> stack = new LinkedList<Integer>(); while (number > 0) { stack.push( number % 10 ); number = number / 10; } while (!stack.isEmpty()) { print(stack.pop()); } 

इसे String कनवर्ट करें और String#toCharArray() या String#split()

 String number = String.valueOf(someInt); char[] digits1 = number.toCharArray(); // or: String[] digits2 = number.split("(?<=.)"); 

यदि आप पहले से ही जावा 8 पर हैं और आप उसके बाद कुछ समग्र आपरेशन करना चाहते हैं, तो String#chars() का उपयोग करने पर विचार करें।

 IntStream chars = number.chars(); 

इस बारे में कैसा है?

 public static void printDigits(int num) { if(num / 10 > 0) { printDigits(num / 10); } System.out.printf("%d ", num % 10); } 

या कंसोल पर मुद्रण के बजाय, हम इसे पूर्णांक के सरणी में एकत्र कर सकते हैं और फिर सरणी मुद्रित कर सकते हैं:

 public static void main(String[] args) { Integer[] digits = getDigits(12345); System.out.println(Arrays.toString(digits)); } public static Integer[] getDigits(int num) { List<Integer> digits = new ArrayList<Integer>(); collectDigits(num, digits); return digits.toArray(new Integer[]{}); } private static void collectDigits(int num, List<Integer> digits) { if(num / 10 > 0) { collectDigits(num / 10, digits); } digits.add(num % 10); } 

मैंने किसी को इस विधि का उपयोग नहीं देखा है, लेकिन यह मेरे लिए काम किया है और यह छोटा और मीठा है:

 int num = 5542; String number = String.valueOf(num); for(int i = 0; i < number.length(); i++) { int j = Character.digit(number.charAt(i), 10); System.out.println("digit: " + j); } 

यह आउटपुट होगा:

 digit: 5 digit: 5 digit: 4 digit: 2 
 // could be any num this is a randomly generated one int num = (int) (Math.random() * 1000); // this will return each number to a int variable int num1 = num % 10; int num2 = num / 10 % 10; int num3 = num /100 % 10; // you could continue this pattern for 4,5,6 digit numbers // dont need to print you could then use the new int values man other ways System.out.print(num1); System.out.print("\n" + num2); System.out.print("\n" + num3); 

मुझे लगता है कि आसान तरीका संख्या को स्ट्रिंग में कनवर्ट करने के लिए और substring का उपयोग करने के लिए निकालें और फिर पूर्णांक में कनवर्ट करें।

कुछ इस तरह:

 int digits1 =Integer.parseInt( String.valueOf(201432014).substring(0,4)); System.out.println("digits are: "+digits1); 

ouput है 2014

मैंने एक प्रोग्राम लिखा है कि यह प्रदर्शित करता है कि कैसे एक पूर्णांक के अंक को एक और अधिक सरल और समझने योग्य दृष्टिकोण का उपयोग करके अलग करना है जिसमें एरेज़, पुनरीक्षण और सभी फैंसी विद्या शामिल नहीं हैं। यहां मेरा कोड है:

 int year = sc.nextInt(), temp = year, count = 0; while (temp>0) { count++; temp = temp / 10; } double num = Math.pow(10, count-1); int i = (int)num; for (;i>0;i/=10) { System.out.println(year/i%10); } 

मान लें कि आपका इनपुट पूर्णांक 123 , परिणामस्वरूप परिणाम निम्न होगा:

 1 2 3 

टिप्पणियों के साथ मेरा प्रस्ताव देखें

  int size=i.toString().length(); // the length of the integer (i) we need to split; ArrayList<Integer> li = new ArrayList<Integer>(); // an ArrayList in whcih to store the resulting digits Boolean b=true; // control variable for the loop in which we will reatrive step by step the digits String number="1"; // here we will add the leading zero depending on the size of i int temp; // the resulting digit will be kept by this temp variable for (int j=0; j<size; j++){ number=number.concat("0"); } Integer multi = Integer.valueOf(number); // the variable used for dividing step by step the number we received while(b){ multi=multi/10; temp=i/(multi); li.add(temp); i=i%(multi); if(i==0){ b=false; } } for(Integer in: li){ System.out.print(in.intValue()+ " "); } 

मेरा जवाब है, मैंने इसे अपने लिए किया है और मुझे आशा है कि उन लोगों के लिए यह काफी सरल है जो स्ट्रिंग दृष्टिकोण का उपयोग नहीं करना चाहते या अधिक गणित- y समाधान की आवश्यकता है:

 public static void reverseNumber2(int number) { int residual=0; residual=number%10; System.out.println(residual); while (residual!=number) { number=(number-residual)/10; residual=number%10; System.out.println(residual); } } 

तो मैं सिर्फ इकाइयां लेता हूं, उन्हें मुद्रित कर, संख्या से उन्हें अवतरित कर, फिर उस संख्या को 10 से विभाजित कर देता हूं – जो हमेशा किसी अस्थायी सामान के बिना होता है, क्योंकि इकाइयां चली जाती हैं, दोहराते हैं।

Java 8 समाधान को पूर्णांक के रूप में अंक प्राप्त करने के लिए [] एक स्ट्रिंग के रूप में आपके पास एक पूर्णांक है:

 int[] digits = intAsString.chars().map(i -> i - '0').toArray(); 

Integer.toString (1100) आपको स्ट्रिंग के रूप में पूर्णांक देता है। पूर्णांक के लिए स्ट्रेटिंग (1100) .getBytes () व्यक्तिगत अंकों के बाइट्स को प्राप्त करने के लिए।

संपादित करें:

आप चरित्र अंकों को संख्यात्मक अंकों में परिवर्तित कर सकते हैं, इस प्रकार:

  String string = Integer.toString(1234); int[] digits = new int[string.length()]; for(int i = 0; i<string.length(); ++i){ digits[i] = Integer.parseInt(string.substring(i, i+1)); } System.out.println("digits:" + Arrays.toString(digits)); 

यह 0 से बड़े संख्या में प्रत्येक अंक को निकालने के लिए मॉड्यूल 10 विधि का उपयोग करता है, फिर यह सरणी के क्रम को उलट देगा। ऐसा लगता है कि आप "0" को शुरुआती अंक के रूप में नहीं उपयोग कर रहे हैं

इसे उपयोगकर्ता इनपुट में लेने के लिए संशोधित किया गया है। यह सरणी मूल रूप से पीछे की तरफ डाली गई है, इसलिए मुझे इसे Collections.reverse() उपयोग के लिए उपयोगकर्ता के आदेश में वापस लाने के लिए Collections.reverse()

  Scanner scanNumber = new Scanner(System.in); int userNum = scanNumber.nextInt(); // user's number // divides each digit into its own element within an array List<Integer> checkUserNum = new ArrayList<Integer>(); while(userNum > 0) { checkUserNum.add(userNum % 10); userNum /= 10; } Collections.reverse(checkUserNum); // reverses the order of the array System.out.print(checkUserNum); 

बस इस विषय पर निर्माण करने के लिए, यह पुष्टि करने के लिए है कि यह संख्या जावा में एक पालंड्रोमिक पूर्णांक है:

 public static boolean isPalindrome(int input) { List<Integer> intArr = new ArrayList(); int procInt = input; int i = 0; while(procInt > 0) { intArr.add(procInt%10); procInt = procInt/10; i++; } int y = 0; int tmp = 0; int count = 0; for(int j:intArr) { if(j == 0 && count == 0) { break; } tmp = j + (tmp*10); count++; } if(input != tmp) return false; return true; } 

मुझे यकीन है कि मैं इस अलगो को और आसान कर सकता हूं। फिर भी, यह वह जगह है जहां मैं हूं। और यह मेरे सभी परीक्षण मामलों के तहत काम किया है।

मुझे उम्मीद है इससे किसी को सहायता मिलेगी।

 int number = 12344444; // or it Could be any valid number int temp = 0; int divider = 1; for(int i =1; i< String.valueOf(number).length();i++) { divider = divider * 10; } while (divider >0) { temp = number / divider; number = number % divider; System.out.print(temp +" "); divider = divider/10; } 

इसे इस्तेमाल करे:

 int num= 4321 int first = num % 10; int second = ( num - first ) % 100 / 10; int third = ( num - first - second ) % 1000 / 100; int fourth = ( num - first - second - third ) % 10000 / 1000; 

आपको पहले मिलेगा = 1, दूसरा = 2, तीसरा = 3 और चौथा = 4 ….

 public int[] getDigitsOfANumber(int number) { String numStr = String.valueOf(number); int retArr[] = new int[numStr.length()]; for (int i = 0; i < numStr.length(); i++) { char c = numStr.charAt(i); int digit = c; int zero = (char) '0'; retArr[i] = digit - zero; } return retArr; } 

चूंकि मुझे इस प्रश्न पर कोई तरीका नहीं दिखाई देता है जो जावा 8 का उपयोग करता है, मैं इसे अंदर फेंक दूँगा। मान लें कि आप String शुरुआत कर रहे हैं और List<Integer> प्राप्त करना चाहते हैं, तो आप तत्वों को इसी तरह स्ट्रीम कर सकते हैं ।

 List<Integer> digits = digitsInString.chars().map(Character::getNumericValue) .collect(Collectors.toList()); 

यह String में एक IntStream रूप में IntStream , उन IntStream पूर्णांक के रूप में चिह्नित करता है, और फिर उन्हें एक सूची में एकत्रित करता है।

ऐसा कुछ कुछ char[] वापस करेगा:

 public static char[] getTheDigits(int value){ String str = ""; int number = value; int digit = 0; while(number>0){ digit = number%10; str = str + digit; System.out.println("Digit:" + digit); number = number/10; } return str.toCharArray(); } 
 import java.util.Scanner; class Test { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int num=sc.nextInt(); System.out.println("Enter a number (-1 to end):"+num); int result=0; int i=0; while(true) { int n=num%10; if(n==-1){ break; } i++; System.out.println("Digit"+i+" = "+n); result=result*10+n; num=num/10; if(num==0) { break; } } } } 

मुझे लगता है कि यह अंक प्राप्त करने का सबसे उपयोगी तरीका होगा:

 public int[] getDigitsOf(int num) { int digitCount = Integer.toString(num).length(); if (num < 0) digitCount--; int[] result = new int[digitCount]; while (digitCount-- >0) { result[digitCount] = num % 10; num /= 10; } return result; } 

फिर आप एक साधारण तरीके से अंक प्राप्त कर सकते हैं:

 int number = 12345; int[] digits = getDigitsOf(number); for (int i = 0; i < digits.length; i++) { System.out.println(digits[i]); } 

या अधिक आसानी से:

 int number = 12345; for (int i = 0; i < getDigitsOf(number).length; i++) { System.out.println( getDigitsOf(number)[i] ); } 

ध्यान दें कि पिछले विधि को कॉल करें getDigitsOf पद्धति बहुत अधिक समय है। तो यह धीमा हो जाएगा। आपको एक पूर्णांक सरणी बनाना चाहिए और फिर एक बार getDigitsOf विधि को कॉल करना चाहिए, जैसे कि दूसरे कोड ब्लॉक में।

निम्न कोड में, आप प्रक्रिया को रिवर्स कर सकते हैं। यह कोड संख्या को बनाने के लिए सभी अंक जोड़ता है:

 public int digitsToInt(int[] digits) { int digitCount = digits.length; int result = 0; for (int i = 0; i < digitCount; i++) { result = result * 10; result += digits[i]; } return result; } 

मैंने दोनों तरीके नकारात्मक संख्याओं के लिए काम भी प्रदान किए हैं I

 import java.util.Scanner; public class SeparatingDigits { public static void main( String[] args ) { System.out.print( "Enter the digit to print separately :- "); Scanner scan = new Scanner( System.in ); int element1 = scan.nextInt(); int divider; if( ( element1 > 9999 ) && ( element1 <= 99999 ) ) { divider = 10000; } else if( ( element1 > 999 ) && ( element1 <= 9999 ) ) { divider = 1000; } else if ( ( element1 > 99) && ( element1 <= 999 ) ) { divider = 100; } else if( ( element1 > 9 ) && ( element1 <= 99 ) ) { divider = 10; } else { divider = 1; } quotientFinder( element1, divider ); } public static void quotientFinder( int elementValue, int dividerValue ) { for( int count = 1; dividerValue != 0; count++) { int quotientValue = elementValue / dividerValue ; elementValue = elementValue % dividerValue ; System.out.printf( "%d ", quotientValue ); dividerValue /= 10; } } } 

सरणियों और तारों का उपयोग किए बिना (अंक 1- 99 99 9)

आउटपुट:

अलग-अलग मुद्रित करने के लिए अंक दर्ज करें: – 12345

1 2 3 4 5