जवाबों:
ऐसा करने के लिए, आप %(मॉड) ऑपरेटर का उपयोग करेंगे ।
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।
IntStream chars = number.chars();split(""), सरणी में पहला आइटम है ""। अन्य रेगेक्स का उपयोग करें, जैसे split("(?<=.)")।
number.chars()एक Ascii मान में परिणाम लौटाएगा एक संख्यात्मक नहीं। ताकि "1234" संख्या "49", "50", "51", "52" के बजाय "1", "2", "3", "4" में विभाजित हो जाएगी। इसे सही करने के लिए यह दिखना चाहिए:IntStream chars = number.chars().map(Character::getNumericValue);
इस बारे में कैसा है?
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);
}यदि आप अंकों के क्रम को कम से कम महत्वपूर्ण (इंडेक्स [0]) से सबसे महत्वपूर्ण (इंडेक्स [n]) तक बनाए रखना चाहते हैं, तो निम्न अपडेटेड गेटगिट्स () जो आपको चाहिए:
/**
* split an integer into its individual digits
* NOTE: digits order is maintained - i.e. Least significant digit is at index[0]
* @param num positive integer
* @return array of digits
*/
public static Integer[] getDigits(int num) {
if (num < 0) { return new Integer[0]; }
List<Integer> digits = new ArrayList<Integer>();
collectDigits(num, digits);
Collections.reverse(digits);
return digits.toArray(new Integer[]{});
}+1
+1
if (number < 0) { return new Integer[0]; } निम्नलिखित इनपुट के साथ परीक्षण किया गया:Integer[] samples = {11111, 123457, 0, -13334, 93846, 87892, 9876543, -1234, 012455};
मैंने किसी को इस पद्धति का उपयोग करते नहीं देखा है, लेकिन यह मेरे लिए काम करता है और छोटा और मीठा है:
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: 20142323एक अष्टाधारी निरंतर के बराबर है 50387, आगे शून्य की वजह से है, जैसे 0x100एक हेक्साडेसिमल स्थिर है के बराबर 256प्रमुख की वजह से, 0xऔर 0b1011एक द्विआधारी निरंतर के बराबर है 11प्रमुख के कारण 0b। पूर्णांक स्थिरांक पर 0 से सावधान रहें!
मैंने देखा कि आपकी समस्या को हल करने के लिए जावा 8 स्ट्रीम का उपयोग करने के कुछ उदाहरण हैं लेकिन मुझे लगता है कि यह सबसे सरल है:
int[] intTab = String.valueOf(number).chars().map(Character::getNumericValue).toArray();स्पष्ट होने के लिए: आप String.valueOf(number)स्ट्रिंग को int में कनवर्ट करने के लिए उपयोग करते हैं, फिर chars()एक IntStream प्राप्त करने के लिए विधि (आपके स्ट्रिंग में से प्रत्येक अब एक Ascii नंबर है), तो आपको map()Ascii संख्या के संख्यात्मक मान प्राप्त करने के लिए विधि को चलाने की आवश्यकता है । अंत में आप toArray()अपनी धारा को एक int [] सरणी में बदलने के लिए विधि का उपयोग करते हैं।
मुझे लगता है कि सभी जवाब बदसूरत हैं और बहुत साफ नहीं हैं।
मेरा सुझाव है कि आप अपनी समस्या को हल करने के लिए थोड़ा सा पुनरावर्तन का उपयोग करें। यह पोस्ट बहुत पुरानी है, लेकिन भविष्य के कोडर्स के लिए सहायक हो सकती है।
public static void recursion(int number) {
if(number > 0) {
recursion(number/10);
System.out.printf("%d ", (number%10));
}
}आउटपुट:
Input: 12345
Output: 1 2 3 4 5 // 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यहाँ मेरा जवाब है, मैंने इसे अपने लिए किया है और मुझे आशा है कि यह उन लोगों के लिए काफी सरल है जो स्ट्रिंग दृष्टिकोण का उपयोग नहीं करना चाहते हैं या अधिक गणित-वाई समाधान की आवश्यकता है:
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 से विभाजित करता हूं - जो हमेशा किसी भी अस्थायी सामान के बिना होता है, क्योंकि इकाइयां चली जाती हैं, दोहराती हैं।
सरल समाधान
public static void main(String[] args) {
int v = 12345;
while (v > 0){
System.out.println(v % 10);
v /= 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 मिलेगा ...।
%। यह बहुत कम मूल्य जोड़ता है।
जावा 8 समाधान पूर्णांक के रूप में अंक पाने के लिए int [] जो आपके पास एक स्ट्रिंग के रूप में है:
int[] digits = intAsString.chars().map(i -> i - '0').toArray();i -> i - '0'मैपिंग को शामिल करने के लिए अपने जवाब को अपडेट किया ताकि परिणाम वही हो जो ओपी ने पूछा था।
i - '0'तरह के तरीके भी हैं Character.toDigitकि आईएमओ का उपयोग करना बेहतर है।
"0123456789".chars().map(i -> Character.digit(i, 10)).toArray() चरित्र # अंक (चार कोड के लिए एक है और इंट कोड पॉइंट्स के लिए एक है)
जावा 9 ने एक नई Stream.iterateविधि पेश की जिसका उपयोग एक निश्चित स्थिति में एक धारा उत्पन्न करने और रोकने के लिए किया जा सकता है। यह modulo दृष्टिकोण का उपयोग करके संख्या में सभी अंक प्राप्त करने के लिए इस्तेमाल किया जा सकता है।
int[] a = IntStream.iterate(123400, i -> i > 0, i -> i / 10).map(i -> i % 10).toArray();ध्यान दें कि इससे अंकों को उल्टे क्रम में प्राप्त किया जा सकता है, लेकिन इसे या तो सरणी में पीछे की ओर लूप करके हल किया जा सकता है (किसी सरणी को उल्टा करना इतना आसान नहीं है ), या दूसरी स्ट्रीम बनाकर:
int[] b = IntStream.iterate(a.length - 1, i -> i >= 0, i -> i - 1).map(i -> a[i]).toArray();या
int[] b = IntStream.rangeClosed(1, a.length).map(i -> a[a.length - i]).toArray();एक उदाहरण के रूप में, यह कोड:
int[] a = IntStream.iterate(123400, i -> i > 0, i -> i / 10).map(i -> i % 10).toArray();
int[] b = IntStream.iterate(a.length - 1, i -> i >= 0, i -> i - 1).map(i -> a[i]).toArray();
System.out.println(Arrays.toString(a));
System.out.println(Arrays.toString(b));प्रिंट होगा:
[0, 0, 4, 3, 2, 1]
[1, 2, 3, 4, 0, 0]Integer.toString (1100) आपको एक स्ट्रिंग के रूप में पूर्णांक देता है। Integer.toString (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));'1'- चार बाइट्स का प्रतिनिधित्व करेगा जो चार या चार का प्रतिनिधित्व करते हैं '0'। बाइट मान अभ्यस्त 1, या 0।
यह प्रत्येक अंक को 0 से अधिक संख्या में निकालने के लिए मोडुलो 10 विधि का उपयोग करता है, फिर यह सरणी के क्रम को उलट देगा। यह मान रहा है कि आप "0" को एक शुरुआती अंक के रूप में उपयोग नहीं कर रहे हैं।
इसे उपयोगकर्ता इनपुट में लेने के लिए संशोधित किया गया है। यह सरणी मूल रूप से पीछे की ओर डाली गई है, इसलिए मुझे 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;
}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;
}टिप्पणियों के साथ मेरा प्रस्ताव देखें
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()+ " ");
}कुछ इस तरह लौटेगा 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();
}आप ऐसा क्यों नहीं करते:
String number = String.valueOf(input);
char[] digits = number.toCharArray();चूँकि मैं इस प्रश्न पर एक विधि नहीं देखता, जो जावा 8 का उपयोग करता है, इसलिए मैं इसे फेंक दूंगा। मान लें कि आप एक के साथ शुरू कर रहे Stringहैं और प्राप्त करना चाहते हैं List<Integer>, तो आप तत्वों को स्ट्रीम कर सकते हैं।
List<Integer> digits = digitsInString.chars()
.map(Character::getNumericValue)
.boxed()
.collect(Collectors.toList());यह वर्णों Stringको एक के रूप में प्राप्त करता है IntStream, वर्णों के पूर्णांक निरूपण को एक संख्यात्मक मान पर मैप करता है, उन्हें बॉक्स करता है, और फिर उन्हें एक सूची में एकत्रित करता है।
Collectors.toList()→ " टाइप मिसमैच: कलेक्टर <ऑब्जेक्ट से परिवर्तित नहीं हो सकता है, # 3-पर कब्जा करें; सूची <ऑब्जेक्ट >> से सप्लायर <आर> ", collect→ " विधि एकत्र करें (सप्लायर <आर>, ओब्जाइन्कॉनसुमेर / आर) >, BiConsumer <R, R> प्रकार में IntStream तर्कों (कलेक्टर <ऑब्जेक्ट
मुझे लगता है कि अंक पाने के लिए यह सबसे उपयोगी तरीका होगा:
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 विधि बहुत अधिक समय नोटिस। तो यह धीमा होगा। आपको एक int array बनानी चाहिए और फिर दूसरी बार ब्लॉक कोड की तरह 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;
}मेरे द्वारा दिए गए दोनों तरीके नकारात्मक संख्याओं के लिए भी काम करते हैं।
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 static void main(String[] args) {
System.out.println("Digits Array:: "+Arrays.toString(getNumberArr(1100)));
}
private static Integer[] getNumberArr(int number) {
//will get the total number of digits in the number
int temp = number;
int counter = 0;
while (temp > 0) {
temp /= 10;
counter++;
}
//reset the temp
temp = number;
// make an array
int modulo; //modulo is equivalent to single digit of the number.
Integer[] numberArr = new Integer[counter];
for (int i = counter - 1; i >= 0; i--) {
modulo = temp % 10;
numberArr[i] = modulo;
temp /= 10;
}
return numberArr;
}आउटपुट:
Digits Array:: [1, 1, 0, 0]अगर अंक का मतलब ए है Character
String numstr = Integer.toString( 123 );
Pattern.compile( "" ).splitAsStream( numstr ).map(
s -> s.charAt( 0 ) ).toArray( Character[]::new ); // [1, 2, 3]Pattern.compile? वह बहुत ज्यादा ओवरकिल है।
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-99999)
आउटपुट:
अलग से प्रिंट करने के लिए अंक दर्ज करें: - 12345
1 2 3 4 5
divider।