style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">

Operaciones entre bases

Hola a todos, bueno quisiera saber si alguien podria explicarme como tomar cada valor de un numero por ejemplo tenemos el 10110 que instruccion puedo usar para que haga esto 1+0+1+1+0

Gracias de antemano, soy nueva en esto. Apenas empeze la carrera

Opciones de visualización de comentarios

Seleccione la forma que prefiera para mostrar los comentarios y haga clic en «Guardar las opciones» para activar los cambios.
Imagen de Sr. Negativo

Re:Operaciones entre bases

Una pequeña ayuda:

public class Inicio{

   public static void main(String[] args){
   String numero="10110";//1+0+1+1+0=3
         int suma=0;
         for(int i=0;i<numero.length();i++){
             char c=numero.charAt(i);
                 int n=Integer.parseInt(String.valueOf(c));
                 suma+=n;
         }
         System.out.printf("suma: %d\n",suma);
}

}

suma: 3

Espero no hacerte algún daño haciendote la tarea ...

No hay una "sola" instrucción

No hay una "sola" instrucción para hacer esto, para ello tienes que escribir un programa.

Una forma de empezar a resolver problemas como estos es pensar como lo harías tú a mano, o con papel y lápiz y luego buscar como hacer cada paso con el programa.

Si tienes "10110" lo que haces es:

1. Tomar un elemento de la cadena
2. Sumarlo con el anterior,
3. Repetir hasta terminar

Luego verás que al intentar programar estos pasos te vas a ir preguntando "Y como hago esto? Y como hago esto otro?" y llegarás a una solución como la de Sr-

Otra implementación que sigue estos tres mismos pasos es aprovechar el hecho de que los números en UTF-16 ( el codificado que usa Java para las cadenas ) tienen un valor entero único, y que la resta de dos char's te da un int. Por ejemplo para el 0 es el 30, así que si restas '0' - '0' te da 0 ( porque 30 - 30 es 0 )

class Sum {
    public static void main( String ... args ) {

        int result = 0;
        for ( char c : "10110".toCharArray() ) { //1. Tomar cada elemento de la cadena:
            result += c - '0';                   //2. Sumarlo con el anterior,
        }                                        //3. Repetir hasta terminar

        System.out.println(result);
    }
}

Y sigue los mismos tres pasos que vienen en la solución de Mr- y que escribí al inicio.

Imagen de rodrigo salado anaya

Con groovy

Con groovy queda algo como esto:

3 == 10110.toString()*.toInteger().sum()

Saludos.

Imagen de alcides

En Kawa sería como

En Kawa sería como sigue:

(apply + (map (lambda(c)(- (char->integer c) #x30)) (string->list "10110")))

Y en Clojure algo muy similar:

(apply + (map (fn[c](new Integer (.toString c))) (seq "10110")))

Debo reconocer que me agradó la solución anterior de Rodrigo en Groovy y quedó bastante mas compacta y concisa (el operador * de Groovy es muy útil en estos casos).

Me gustaría mucho ver la solución de EZamudio en Ceylon :-)

Saludos.

Imagen de Sr. Negativo

Otra en Groovy

String numero="11001"
int suma=0
numero.each{
        suma+=Integer.parseInt(it)
}
println "Suma: $suma"
Imagen de rodrigo salado anaya

Muy bien Sr. Negativo

También puedes probar con esto que es muy similar a lo que hiciste:

'11001'.inject(0) { sum, num ->
    sum + num.toInteger()
}
Imagen de Sr. Negativo

En Python y Ruby

numero="101100"
suma=0

for n in numero:
        suma+=int(n)

print "suma: %d"%(suma)

numero="101100"
suma=0

for n in 0..numero.length
  suma+=numero[n].to_i
end

puts "Suma: #{suma}\n"

Imagen de ezamudio

En Ceylon

Dado que Ceylon también tiene las operaciones típicas sobre colecciones: map, fold, find, etc, simplemente así:

value x = "101010".map((Character c) => c.integer-48).fold(0, (Integer a, Integer b) => a+b);
print(x);

Formateado más bonito, para evitar esos eternos one-liners:

value x = "101010".map((Character c) => c.integer-48)
    .reduce((Integer a, Integer b) => a+b);
print(x);

El método reduce es como fold pero en vez de requerir un valor inicial, simplemente usa el primer elemento de la colección y empieza a aplicar la función acumuladora con ese y el siguiente, igual que fold.

Imagen de echan

en Java 8

es concatenar?

 Arrays.stream(String.valueOf(10110).split("(?!^)")).collect(Collectors.joining("+"));

o sumar?

 Arrays.stream(String.valueOf(10110).split("(?!^)"))
       .map(n -> Integer.valueOf(n))
       .reduce((v1, v2) -> v1 + v2).get();
Imagen de alcides

Me pareció didáctico el

Me pareció didáctico el ejemplo/explicación de EZamudio de fold y reduce.

Aprovechando el hecho mencionado por Oscar de que se pueden comparar caracteres numéricamente (método compareTo de la clase java.lang.Character) se puede reducir un poco más el código en Kawa:

(apply + (map (lambda(c)(c:compareTo #\0)) (string->list "10110")))

Y en Clojure algo mas:

(apply + (map (fn[c](.compareTo c \0)) (seq "10110")))
Imagen de echan

aa que buen truco la resta de chars

Aqui una version en Scala

  "10110".map( _ - '0').reduce((e1, e2) =>  {e1 + e2})

o la version ultra compacta

  "10110".map( _ - '0').reduce(_+_)
Imagen de alcides

Efectivamente, utilizando

Efectivamente, utilizando aplicación parcial de funciones (lo cual se usa en el ejemplo anterior de echan en Scala) las expresiones lambda se pueden sustituír lo cual reduce todavía mas el tamaño del código.

En Kawa:

(apply + (map (cut *:compareTo <> #\0) (string->list "10110")))

En Clojure:

(apply + (map #(.compareTo % \0) (seq "10110")))
Imagen de ezamudio

echan

Alcides, según yo el ejemplo de echan es Java, no Scala... lo que pasa es que ya está usando las lambdas y streams de Java 8. Por eso me muero de ganas ya de pasar a Java 8, ya es otro pedo teniendo esas dos cosas.

Escribió otro después con

@Ezamudio: echan Escribió otro después con Scala que es aún más simple.

Otra versión con Java, aprovechando la sección de incremento en el for y sin crear un nuevo arreglo ( toCharArray)= ). Creo que esto es lo más simple que se puede obtener ( omiti el println )

int s = 0;
for( int i = 0; i < "10110".length() ; s += "10110".charAt(i++)-'0' );

Aunque entiendo los ejemplos que usan map/reduce aún me parece que son más pesados ( sé que no lo son o al menos no substancialmente pues son lazy ) pero supongo que será cuestión de acostumbrarse.

Re: suma

 

Si fue suma, también con Java 8:

int sum = Arrays.stream("10110".split("(?!^)")).mapToInt(Integer::parseInt).sum();

~~~

Imagen de julgo

otra suma

otra forma en java 8

 
 String p= "10110";
  int suma= p.chars().sum()-(48*p.length());

Re: otra suma

 

O incluso esta otra:

int sum = "10110".chars().map(c -> c - '0').sum();

:-)

Imagen de julgo

re:re:otra suma

o de una manera mas matemática , si es que no quisiéramos tratar la variable como String , aquí hize una versión :)

,
 int num= 10110;
       int sum=0;
   int c=(int)Math.log10(num)+1;// <---la cantidad de cifras
   
      for (int i = 0; i < c; i++) {
          sum=sum+num%10;
          num=num/10;
        }
      out.println(sum);

style="display:inline-block;width:728px;height:90px"
data-ad-client="ca-pub-5164839828746352"
data-ad-slot="7563230308">