Pętle, początkujący

Question

Witam jestem początkujący w Javie i miał pytanie dotyczące pętli

pytanie w książce prosi o sumę wszystkich cyfr nieparzystych n. (Na przykład, jeśli n wynosi 32677, suma będzie wynosić 3 + 7 + 7 = 17.

Nie mogę się dowiedzieć, jak to zakodować, szukam kogoś, kto mi pomoże. jest to kod, a pierwszym krokiem, ale nie wiem, jak go wypełnić, czy mam to dobrze, czy źle.

Każda pomoc będzie mile widziane,

public class sumOfOddsInNumber 
{ 
    public static void main(String[] args) 
    { 

     int n = 0; 
     String value = String.valueOf(number); 
     int length = value.length(); 

     while (n < length) 
     { 
      ... //Idk if this the right first step, how do I start it? where do i go? 

Answer 1

nie będę aby dać ci pełne rozwiązanie, ale oto rzeczy, które musisz znać, aby zrobić to poprawnie, a jeśli je zrozumiesz, problem staje się prosty:

Jeśli masz całkowitą k, można przekonwertować go na ciąg z:

String s = String.valueOf(k); 

To pozwoli Ci prościej pętli nad poszczególnymi znakami napisu, które reprezentują cyfry numeru. Następnie można iteracyjne ciągu znaków jeden po drugim z

char c = s.charAt(0); 

gdzie 0 może być zmienna indeksu pętli, które mogą pętla od pierwszego znaku (indeks 0) do ostatniego (indeks s.length - 1 dla String s)

Następnie staje się kwestią konwersji z powrotem do liczby całkowitej, co jest proste, a następnie sprawdzenie, czy są równe lub nieparzyste. Standardowy sposób to zrobić z modułem.

int k = 7; 
if (k % 2 == 0) //k is even 
else //k is odd 

Działa to, ponieważ dowolny numer mod 2 zwróci 0 tylko wtedy, gdy jest liczbą parzystą. W przeciwnym razie nastąpi powrót 1.

Answer 2

public static int sumOfOddsInNumber(int n) 
{ 
    String valueString = String.valueOf(n); 
    int sum = 0; 

    for (int i = 0; i < valueString.length(); i++) 
    { 
     int value = Integer.parseInt(valueString.substring(i, i + 1)); 
     if (value % 2 != 0) 
      sum += value; 
    } 

    return sum; 
} 

Answer 3

Ten kod może wystarczyły bez użycia wyrażenie:

int sum= 0; 
int digit=0; 
int number= your_value; 
while (number > 0) 
{ 
    digit=number % 10; // we look at the "last" digit 
    if (digit %2 == 1) // odd digiti 
    { 
     sum+=digit; 
    } 
    number/=10; 
} 

Answer 4

napisałem komentarzy dla lepszego zrozumienia, spróbuj rozwiązać logikę sam będzie bardziej pomocny :)

public class SumOddMain { 

    public static void main(String args[]) { 
     String s = "1234"; 

     //Find the length of String 
     int len = s.length(); 

     //Convert data type String into int 
     int num = Integer.parseInt(s); 

     int mod; //Modulus 
     int od = 0, even = 0; 

     for(int i = 0; i < len ; i++) { 
      //Separates each digit from given number 
      mod = num % 10; 
      num = num/10; 

      if(mod % 2 == 0) { //Determines if the number is odd or even 
       even = even + mod; //Addition of even numbers 
      } else { 
       od = od + mod; //Addition of odd numbers 
      } 
     } 
     System.out.println("Sum of even numbers is "+even); 
     System.out.println("Sum of odd numbers is " + od); 
    } 
} 

Answer 5

to właśnie wymyśliłem:

package sum; 

import java.util.Scanner; 
public class Sum { 


    public static void main(String[] args) { 
    Scanner input=new Scanner(System.in); 

    String number=""; 
    int a=0, total=0; 
    boolean even=false; 

    System.out.println("Enter a number"); number=input.nextLine(); 

    for (int counter=0; counter<number.length(); counter++){ 
    a=Integer.parseInt(number.substring(counter,counter+1)); 
    if (a%2!=0||a==1){ 
     even=false; 
     total+=a; 
    } 
    }System.out.println("The sum is "+total); 




} 
} 

Najpierw otrzymujesz numer od użytkownika, następnie program przechodzi przez każdy numer w ciągu znaków (liczba) i oddziela je. Jest to reprezentowane przez zmienną "a". Teraz możesz przetestować a, czy liczba jest równa, czy nie, używając podziału modułów (jeśli% 2 nie jest równe 0, a nie jest równy). Na końcu dodajesz liczby parzyste razem z całkowitą zmienną, a wyświetli się odpowiedź!

Answer 6

public int SumOfDigits(int num) 
{ 
    if (num < 10) return num; 
    return num % 10 + SumOfDigits(num/10); 
} 

to nie używaj sznurka i to jest rekurencyjna (to jest C#, ale myślę, że będzie to również pracować na Java, ponieważ są one dość dużo podobny)

Aktualizacja:

 public int SumOfOddDigits(int num) 
     { 
      int rem = num % 10; 
      if (num < 10) 
      { 
       if (rem % 2 != 0) 
        return num; 
       return 0; 
      } 
      if (rem % 2 != 0) 
       return rem + SumOfOddDigits(num/10); 
      return SumOfOddDigits(num/10); 
     } 

Answer 7

Lekko wydajną metodą może być użycie operatora bitowego zamiast%, aby sprawdzić, czy liczba jest nieparzysta.

int sum(int n) { 
    int sum=0, rem; 
    while(n>0) { 
     rem = n%10; 
     if (rem&1 == 1) 
      sum+=rem; 
     n/=10; 
    } 
    return sum; 
} 

Uwaga jednak, że ta metoda będzie działać tylko w przypadku wejścia n jest liczbą dodatnią.

Answer 8

Myślę, że najlepszym podejściem jest użycie rozwiązania numerycznego opublikowanego przez julien.

Jeśli chcesz pozostać ze sznurkiem, tutaj jest inne podejście:

String numString = String.valueOf(number); 
int tmp=0; 
int sum=0; 
for(int i; i< numString.length; i++) { 
    tmp = Character.getNumericValue(element.charAt(i)); 
    if (tmp %2 != 0) 
     sum+= tmp; 
}