উত্তর:
এটি করার জন্য, আপনি %(মোড) অপারেটরটি ব্যবহার করবেন ।
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()একটি সংখ্যাটিকে নয় আসকি মানগুলিতে ফলাফলটি ফিরিয়ে দেবে। যাতে "1234" নম্বরটি "1", "2", "3", "4" এর পরিবর্তে "49", "50", "51", "52" এ বিভক্ত হবে। এটি সঠিকভাবে করার জন্য এটি দেখতে হবে: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]) থেকে সর্বাধিক তাৎপর্যপূর্ণ (সূচক [এন]) পর্যন্ত সংখ্যার ক্রম বজায় রাখতে চান তবে নীচের আপডেট হওয়া গেটডিজিটস () আপনার যা প্রয়োজন তা হল:
/**
* 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: 2
0142323একটি অকট্যাল ধ্রুবক সমান 50387, শূন্য কারণে, ঠিক 0x100একটি হেক্সাডেসিমেল ধ্রুবক থেকে সমান 256নেতৃস্থানীয় কারণে 0x, এবং 0b1011একটি বাইনারি ধ্রুবক সমান 11নেতৃস্থানীয় কারণে 0b। পূর্ণসংখ্যার ধ্রুবকগুলিতে 0 এর শীর্ষস্থানীয় হতে সতর্ক থাকুন!
আমি লক্ষ্য করেছি যে আপনার সমস্যা সমাধানের জন্য জাভা 8 স্ট্রিম ব্যবহারের কয়েকটি উদাহরণ রয়েছে তবে আমি মনে করি এটিই সবচেয়ে সহজ:
int[] intTab = String.valueOf(number).chars().map(Character::getNumericValue).toArray();পরিষ্কার হওয়ার জন্য: আপনি String.valueOf(number)স্ট্রিং-এ chars()ইন্টার রূপান্তর করতে ব্যবহার করেন, তারপরে একটি ইন্টারস্ট্রিম পাওয়ার পদ্ধতি (আপনার স্ট্রিং থেকে প্রতিটি চর এখন একটি আসকি নম্বর), তারপরে আপনাকে এসকি নম্বরটির map()একটি সংখ্যাসূচক মান পেতে পদ্ধতি চালানো দরকার । শেষে আপনি toArray()আপনার স্ট্রিমটিকে ইনট [] অ্যারেতে পরিবর্তন করার জন্য পদ্ধতিটি ব্যবহার করেন ।
আমি দেখতে পেয়েছি যে সমস্ত উত্তর কুৎসিত এবং খুব পরিষ্কার নয়।
আমি আপনাকে পরামর্শ দিচ্ছি যে আপনার সমস্যাটি সমাধান করতে আপনি কিছুটা পুনরাবৃত্তি ব্যবহার করুন। এই পোস্টটি খুব পুরানো, তবে এটি ভবিষ্যতের কোডারদের জন্য সহায়ক হতে পারে।
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);আউটপুট 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[] digits = intAsString.chars().map(i -> i - '0').toArray();i -> i - '0'ম্যাপিং অন্তর্ভুক্ত করার জন্য আমার উত্তর আপডেট করেছি যাতে ফলাফলটি ঠিক ওপি যা চেয়েছিল তা হ'ল।
i - '0'মতো আরও পদ্ধতি রয়েছে Character.toDigit।
"0123456789".chars().map(i -> Character.digit(i, 10)).toArray() ক্যারেক্টার # অঙ্ক (সেখানে int- এ codePoints জন্য গৃহস্থালির কাজ জন্য এক এবং এক)
জাভা 9 একটি নতুন Stream.iterateপদ্ধতি প্রবর্তন করেছে যা একটি স্ট্রিম তৈরি করতে এবং একটি নির্দিষ্ট শর্তে থামাতে ব্যবহার করা যেতে পারে। এটি মডুলো পদ্ধতির ব্যবহার করে সংখ্যার সমস্ত অঙ্ক পেতে ব্যবহার করা যেতে পারে।
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" কে প্রাথমিক অঙ্ক হিসাবে ব্যবহার করছেন না।
এটি ব্যবহারকারীর ইনপুট নিতে সংশোধিত হয়। এই অ্যারেটি মূলত পিছনের দিকে inোকানো হয়েছে, তাই আমাকে 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(ScannerObjectName.nextInt());
int[] digits = new int[number.length()];
for (int i = 0 ; i < number.length() ; i++)
int[i] = Integer.parseInt(digits.substring(i,i+1))এখন সমস্ত অঙ্কগুলি "অঙ্কগুলি" অ্যারেতে অন্তর্ভুক্ত রয়েছে।
আপনি কেন করবেন না:
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()mis " অমিল টাইপ করুন: সংগ্রাহক থেকে রূপান্তর করতে পারবেন না <অবজেক্ট, ক্যাপচার # 3-এর ?, তালিকা <অবজেক্ট>> কে সরবরাহকারী <আর> ", collect→ " পদ্ধতিটি সংগ্রহ করে (সরবরাহকারী <আর>, ওবিআইএনটি কনসুমার <আর >, ইনটস্ট্রিম প্রকারে বাইকনসুমার <আর, আর>) আর্গুমেন্টের জন্য প্রযোজ্য নয় (সংগ্রাহক <অবজেক্ট,?, তালিকা <অবজেক্ট>>) "
আমি মনে করি এটি সংখ্যা পাওয়ার সবচেয়ে কার্যকর উপায় হবে:
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] );
}লক্ষ্য করুন শেষ পদ্ধতিটি কলটি ডিজিটস অফ পদ্ধতিতে খুব বেশি সময় নেয়। সুতরাং এটি ধীর হবে। আপনার কোনও int অ্যারে তৈরি করা উচিত এবং তারপরে দ্বিতীয় কোড ব্লকের মতো একবার getD DigitsOf পদ্ধতিতে কল করা উচিত।
নিম্নলিখিত কোডে, আপনি প্রক্রিয়াতে বিপরীত করতে পারেন। এই কোডটি সমস্ত অঙ্কগুলি একসাথে সংখ্যা তৈরি করে:
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;
}দুটি পদ্ধতিই আমি providedণাত্মক সংখ্যার জন্য কাজ সরবরাহ করেছি।
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।