Iniciar sesión

AcAnchoa · 19-08-2015 21:34

(19-08-2015 20:27)Jase escribió:¿Qué os parece, shurprogramadores si pongo un ejercicio por semana de esta página https://www.aceptaelreto.com y retomamos el hilo?
En la página dice que se tiene que hacer en C, C++ o Java. Pero como veo que no implica orientación a objetos ni movidas chungas del este, pues lo podéis hacer en el lenguaje que queráis.

Presento el primer ejercicio, el de esta semana:

Intentad usar la función random de vuestro lenguaje, no me seáis ruines

Este es fácil.

==================================================
Suma número:┬á┬á┬á 1
El número en el que se aplica la suma es:┬á┬á┬á 24385
El resultado de la suma descendente es:┬á┬á┬á 29245
==================================================
Suma número:┬á┬á┬á 2
El número en el que se aplica la suma es:┬á┬á┬á 81062
El resultado de la suma descendente es:┬á┬á┬á 82250
==================================================
Suma número:┬á┬á┬á 3
El número en el que se aplica la suma es:┬á┬á┬á 64126
El resultado de la suma descendente es:┬á┬á┬á 68410
==================================================
Suma número:┬á┬á┬á 4
El número en el que se aplica la suma es:┬á┬á┬á 55514
El resultado de la suma descendente es:┬á┬á┬á 61560
==================================================
Suma número:┬á┬á┬á 5
El número en el que se aplica la suma es:┬á┬á┬á 75744
El resultado de la suma descendente es:┬á┬á┬á 82280
==================================================
Suma número:┬á┬á┬á 6
El número en el que se aplica la suma es:┬á┬á┬á 99121
El resultado de la suma descendente es:┬á┬á┬á 108385
==================================================
Suma número:┬á┬á┬á 7
El número en el que se aplica la suma es:┬á┬á┬á 15974
El resultado de la suma descendente es:┬á┬á┬á 23000
==================================================
Suma número:┬á┬á┬á 8
El número en el que se aplica la suma es:┬á┬á┬á 65481
El resultado de la suma descendente es:┬á┬á┬á 71525
==================================================
Suma número:┬á┬á┬á 9
El número en el que se aplica la suma es:┬á┬á┬á 37562
El resultado de la suma descendente es:┬á┬á┬á 45750
==================================================
Suma número:┬á┬á┬á 10
El número en el que se aplica la suma es:┬á┬á┬á 44096
El resultado de la suma descendente es:┬á┬á┬á 48390
==================================================

sisi1

19-08-2015 22:24

En Java no, pero en PHP sí me ha salido elrisas

Dejo el código en spoiler por si alguien no quiere que le chiven:

Spoiler :

xecollons · 20-08-2015 00:10

Fácil.

C#:

Spoiler :

Edito, que no he puesto la salida:
Suma 1
El número es 8942118
La suma es 9928616

Suma 2
El número es 7780590
La suma es 8643040

Suma 3
El número es 7938654
La suma es 8925328

Suma 4
El número es 2688956
La suma es 3476842

Suma 5
El número es 9620149
La suma es 10260803

Suma 6
El número es 5395632
La suma es 5893194

Suma 7
El número es 2018197
La suma es 2063089

Suma 8
El número es 9000923
La suma es 9004641

Suma 9
El número es 929110
La suma es 967450

Suma 10
El número es 9419997
La suma es 9871089

AcAnchoa · 20-08-2015 00:44

Yo creo que me he complicado un poco para descomponer el número qmeparto

:

Código:

public class sumdesc {

 ┬á ┬ápublic static void main(String[] args) {

 ┬á ┬á ┬á ┬á ┬á ┬áint sum = 0;

 ┬á ┬á ┬á ┬á ┬á ┬áint n = (int) Math.ceil(Math.random()*100000);

 ┬á ┬á ┬á ┬á ┬á ┬áint lon = (int) Math.log10(n) + 1;

 ┬á ┬á ┬á ┬á ┬á ┬áfor (int i = 0; i<lon; i++){

 ┬á ┬á ┬á ┬á ┬á ┬á ┬á ┬ádouble cut = (int) n/Math.pow(10, lon-i);

 ┬á ┬á ┬á ┬á ┬á ┬á ┬á ┬áint cut2 = (int) cut;

 ┬á ┬á ┬á ┬á ┬á ┬á ┬á ┬ásum += n-cut2*Math.pow(10, lon-i);

 ┬á ┬á ┬á ┬á ┬á ┬á}

 ┬á ┬á ┬á ┬á ┬á ┬áSystem.out.println("Número: " + n + " | Suma descendete: " + sum);

 ┬á ┬á}

}

20-08-2015 01:05

Actualizo el código de php para meter los 10 números y su salida:

Código:

<?php 

for ($n = 1; $n <= 10; $n++) {

┬á┬á ┬á$numero = (string) rand(1, 100000);

┬á┬á ┬á$resultado = 0;

┬á┬á ┬áfor ($i = 0; $i < strlen($numero); $i++) {

┬á┬á ┬á┬á┬á ┬á$suma = substr($numero, $i, strlen($numero));

┬á┬á ┬á┬á┬á ┬á$resultado = $resultado + (int) $suma;

┬á┬á ┬á}

┬á┬á ┬áecho "Suma".$n."<br>",

┬á┬á ┬á┬á┬á ┬á"El número es: ".$numero."<br>",

┬á┬á ┬á┬á┬á ┬á"La suma es: ".$resultado."<br><br>";

}

┬á?>

Salida:

Suma1
El número es: 40168
La suma es: 40580

Suma2
El número es: 75278
La suma es: 80920

Suma3
El número es: 88257
La suma es: 96835

Suma4
El número es: 70170
La suma es: 70580

Suma5
El número es: 22040
La suma es: 24160

Suma6
El número es: 30637
La suma es: 31955

Suma7
El número es: 28626
La suma es: 37910

Suma8
El número es: 51603
La suma es: 53815

Suma9
El número es: 54499
La suma es: 59605

Suma10
El número es: 99863
La suma es: 110655

Así a ojo juraría que es correcto.

En Java he hecho lo mismo:

Código:

public class SumaDescendente {

┬á┬á ┬ápublic static void main(String[] args) {

┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬ádouble random = 4567;

┬á┬á ┬á┬á┬á ┬áint random1 = (int) random;

┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬áString numero = String.valueOf(random1);

┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬áint resultado = 0;

┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬áfor (int i = 0; i < numero.length(); i++) {

┬á┬á ┬á┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬á┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬á┬á┬á ┬áString potencia = numero.substring(i, numero.length());

┬á┬á ┬á┬á┬á ┬á┬á┬á ┬áint sumar = Integer.parseInt(potencia);

┬á┬á ┬á┬á┬á ┬á┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬á┬á┬á ┬áresultado = resultado + sumar;

┬á┬á ┬á┬á┬á ┬á┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬á┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬á}

┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬áSystem.out.println(resultado);

┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á┬á┬á ┬á

┬á┬á ┬á}

┬á┬á ┬á┬á┬á ┬á

}

Sólo sé manejar strings, qué manco soy Facepalm

srlara · 20-08-2015 08:27

Buenas

mi solucion en codigo SAS

Código:

%macro Suma_Descendente(numero);

data _NULL_;

*LO CALCULAMOS COMO DIFERENCIA DE LONGITUDES; 

cnn=length(compress(upcase(&numero)));

valor_cnn = cnn;

do i = 1 to cnn;

    *ASIGNAMOS EL VALOR DE NUMERO ACTUAL, ESTO ES SOLO INFORMATIVO;

    valor_numero = INPUT(substr(&numero,i,valor_cnn),8.);        

    /*ASIGNAMOS LA LOGGITUD DE NUMERO PARA USARSE COMO CONTROL DEL SUBSTRING*/

    calculo = SUM(calculo,INPUT(substr(&numero,i,valor_cnn),8.));    

    valor_cnn = valor_cnn - 1;

    put valor_numero =;

    put calculo=;

end;

run;

%mend;

/*SE PASA LA VARIABLE COMO CARACTER PARA PODER CONTAR LA LONGITUD*/

%Suma_Descendente("123456");

cree el código tipo macro para que se pudiese meter la longitud que de números que se quisiera
[Imagen: 1zdx36c.jpg]

un saludo

20-08-2015 12:48

Pues aporto yo una en Python:

Código:

from random import randint

num = randint(1000, 1000000)

suma = sum([int(str(num)[x:]) for x in range(len(str(num)))])

print('La suma descendente de ' + str(num) + ' es: ' + str(suma) + '.')

La suma descendente de 756235 es: 818980.

20-08-2015 13:31

Me gusta que os vayáis animando mola

Si os parece esta noche pongo otro que vi en la misma web, pero me da que es un poco más complejo.

xecollons · 20-08-2015 18:33

(20-08-2015 00:44)AcAnchoa escribió:Yo creo que me he complicado un poco para descomponer el número :

Código:

public class sumdesc { ┬á ┬ápublic static void main(String[] args) { ┬á ┬á ┬á ┬á ┬á ┬áint sum = 0; ┬á ┬á ┬á ┬á ┬á ┬áint n = (int) Math.ceil(Math.random()*100000); ┬á ┬á ┬á ┬á ┬á ┬áint lon = (int) Math.log10(n) + 1; ┬á ┬á ┬á ┬á ┬á ┬áfor (int i = 0; i<lon; i++){ ┬á ┬á ┬á ┬á ┬á ┬á ┬á ┬ádouble cut = (int) n/Math.pow(10, lon-i); ┬á ┬á ┬á ┬á ┬á ┬á ┬á ┬áint cut2 = (int) cut; ┬á ┬á ┬á ┬á ┬á ┬á ┬á ┬ásum += n-cut2*Math.pow(10, lon-i); ┬á ┬á ┬á ┬á ┬á ┬á} ┬á ┬á ┬á ┬á ┬á ┬áSystem.out.println("Número: " + n + " | Suma descendete: " + sum); ┬á ┬á} }

Un poco sí┬á lol

Estos físicos que tienen que complicarlo todo... (¿eras físico o me lo he inventado? xD)

Por lo demás, hoy he dado mis primeros pinitos en programación de clases dinámicas en tiempo de ejecución y era algo que no había tocado y tiene muy muy buena pinta. Básicamente, y muy a grandes rasgos, es inyectar código en tiempo real en el "lenguaje ensamblador" al que resulta el compilado de .Net(CIL), y así se pueden crear clases y métodos┬áa la carta mientras el programa está en ejecución. Está muy chulo.

AcAnchoa · 20-08-2015 19:23

(20-08-2015 18:33)xecollons escribió:Un poco sí┬á

Estos físicos que tienen que complicarlo todo... (¿eras físico o me lo he inventado? xD)

Te lo inventas, soy ingeniero técnico aeronáutico lol

. Yo la verdad de programación poquito y con Java menos, hice un pong con cuatro palas en un curso en la escuela y ahí se quedó. Ahora con esto lo he vuelto a tocar y me las ingenio como puedo con lo que recuerdo y saco de mi gran amigo Google. También di Fortran en la escuela, cuya utilidad tiende peligrosamente a cero.

Lo último que he tocado es Matlab y Python, en el que lo más destacable que hice fue un analizador de crecimiento de cultivos para Minecraft (

) y luego Jase y no recuerdo quien más me picaron para hacer un hundir la flota.

La verdad es que tengo interés en esto de programar, pero me pongo y digo "vale, ¿qué hago?" y como no se me ocurre nada lo dejo Facepalm

.

20-08-2015 19:28

(20-08-2015 18:33)xecollons escribió:Un poco sí┬á

Estos físicos que tienen que complicarlo todo... (¿eras físico o me lo he inventado? xD)

Por lo demás, hoy he dado mis primeros pinitos en programación de clases dinámicas en tiempo de ejecución y era algo que no había tocado y tiene muy muy buena pinta. Básicamente, y muy a grandes rasgos, es inyectar código en tiempo real en el "lenguaje ensamblador" al que resulta el compilado de .Net(CIL), y así se pueden crear clases y métodos┬áa la carta mientras el programa está en ejecución. Está muy chulo.

Di que sí, que es un cerebrito de las mates y la física. Mírale ahí jugándole al Kerbal sisi

Lo de negrita me da miedo leerlo roto2

xecollons · 20-08-2015 19:48

(20-08-2015 19:23)AcAnchoa escribió:Te lo inventas, soy ingeniero técnico aeronáutico . Yo la verdad de programación poquito y con Java menos, hice un pong con cuatro palas en un curso en la escuela y ahí se quedó. Ahora con esto lo he vuelto a tocar y me las ingenio como puedo con lo que recuerdo y saco de mi gran amigo Google. También di Fortran en la escuela, cuya utilidad tiende peligrosamente a cero.

Lo último que he tocado es Matlab y Python, en el que lo más destacable que hice fue un analizador de crecimiento de cultivos para Minecraft ( ) y luego Jase y no recuerdo quien más me picaron para hacer un hundir la flota.

La verdad es que tengo interés en esto de programar, pero me pongo y digo "vale, ¿qué hago?" y como no se me ocurre nada lo dejo .

Sabía que algo había lol

Y si alguien quiere programar y no sabe qué hacer, lo mejor es este tipo de ejercicios. Estimulan la mente y la creatividad, y aunque no sea una idea revolucionaria, ayudan a mantener en forma tu cerebro. Para mí este tipo de ejercicios son como los puzzles del Portal┬á roto2

(20-08-2015 19:28)Jase escribió:Di que sí, que es un cerebrito de las mates y la física. Mírale ahí jugándole al Kerbal

Lo de negrita me da miedo leerlo

Mira el método que hice ayer┬ádel cálculo de la suma descendente, que tiene menos de 10 líneas contando las asignaciones e imagínate que la versión compilada es esto:

Spoiler :

Código:

    .method private hidebysig 

        instance string CalcularSumaDescendente (

            int32 numero

        ) cil managed 

    {

        // Method begins at RVA 0x20d0

        // Code size 157 (0x9d)

        .maxstack 3

        .locals init (

            [0] string str,

            [1] int32 suma,

            [2] int32 numeroActual,

            [3] int32 iteracion,

            [4] string CS$1$0000,

            [5] bool CS$4$0001,

            [6] object CS$0$0002,

            [7] object[] CS$0$0003

        )

        IL_0000: nop

        IL_0001: ldstr ""

        IL_0006: stloc.0

        IL_0007: ldc.i4.0

        IL_0008: stloc.1

        IL_0009: ldc.i4.0

        IL_000a: stloc.2

        IL_000b: ldc.i4.1

        IL_000c: stloc.3

        IL_000d: br.s IL_001e

        // loop start (head: IL_001e)

            IL_000f: nop

            IL_0010: ldloc.3

            IL_0011: ldc.i4.s 10

            IL_0013: mul

            IL_0014: stloc.3

            IL_0015: ldarg.1

            IL_0016: ldloc.3

            IL_0017: rem

            IL_0018: stloc.2

            IL_0019: ldloc.1

            IL_001a: ldloc.2

            IL_001b: add

            IL_001c: stloc.1

            IL_001d: nop

            IL_001e: ldloc.2

            IL_001f: ldarg.1

            IL_0020: ceq

            IL_0022: ldc.i4.0

            IL_0023: ceq

            IL_0025: stloc.s CS$4$0001

            IL_0027: ldloc.s CS$4$0001

            IL_0029: brtrue.s IL_000f

        // end loop

        IL_002b: ldloc.0

        IL_002c: stloc.s CS$0$0002

        IL_002e: ldc.i4.4

        IL_002f: newarr [mscorlib]System.Object

        IL_0034: stloc.s CS$0$0003

        IL_0036: ldloc.s CS$0$0003

        IL_0038: ldc.i4.0

        IL_0039: ldloc.s CS$0$0002

        IL_003b: stelem.ref

        IL_003c: ldloc.s CS$0$0003

        IL_003e: ldc.i4.1

        IL_003f: ldstr "El número es "

        IL_0044: stelem.ref

        IL_0045: ldloc.s CS$0$0003

        IL_0047: ldc.i4.2

        IL_0048: ldarg.1

        IL_0049: box [mscorlib]System.Int32

        IL_004e: stelem.ref

        IL_004f: ldloc.s CS$0$0003

        IL_0051: ldc.i4.3

        IL_0052: ldstr "\n"

        IL_0057: stelem.ref

        IL_0058: ldloc.s CS$0$0003

        IL_005a: call string [mscorlib]System.String::Concat(object[])

        IL_005f: stloc.0

        IL_0060: ldloc.0

        IL_0061: stloc.s CS$0$0002

        IL_0063: ldc.i4.4

        IL_0064: newarr [mscorlib]System.Object

        IL_0069: stloc.s CS$0$0003

        IL_006b: ldloc.s CS$0$0003

        IL_006d: ldc.i4.0

        IL_006e: ldloc.s CS$0$0002

        IL_0070: stelem.ref

        IL_0071: ldloc.s CS$0$0003

        IL_0073: ldc.i4.1

        IL_0074: ldstr "La suma es "

        IL_0079: stelem.ref

        IL_007a: ldloc.s CS$0$0003

        IL_007c: ldc.i4.2

        IL_007d: ldloc.1

        IL_007e: box [mscorlib]System.Int32

        IL_0083: stelem.ref

        IL_0084: ldloc.s CS$0$0003

        IL_0086: ldc.i4.3

        IL_0087: ldstr "\n\n\n"

        IL_008c: stelem.ref

        IL_008d: ldloc.s CS$0$0003

        IL_008f: call string [mscorlib]System.String::Concat(object[])

        IL_0094: stloc.0

        IL_0095: ldloc.0

        IL_0096: stloc.s CS$1$0000

        IL_0098: br.s IL_009a

        IL_009a: ldloc.s CS$1$0000

        IL_009c: ret

    } // end of method Form1::CalcularSumaDescendente

Y ahora piensa que lo que comentaba consiste en programarlo tú directamente así lol

Iniciar sesión
Nombre de usuario:
Contraseña:	¿Perdiste tu contraseña?
	Recordarme