Devuelve los enteros con sumas de dígitos cuadrados


31

Introducción y crédito

Todos conocemos y amamos nuestras increíbles reglas para probar si un número es divisible por 11 o 3, que es solo una suma inteligente sobre los dígitos del número. Ahora, este desafío lleva esto a un nuevo nivel, al exigirle que calcule la suma de los dígitos y luego verifique si el resultado es un cuadrado entero perfecto, ninguna de las cuales operaciones generalmente se pueden hacer muy cortas. Como esta propiedad también es muy difícil de ver cuando se mira un número, queremos que esto se haga para listas completas de números para que podamos ahorrar trabajo humano. ¡Así que este es tu desafío ahora!

Esta fue una tarea en el curso de programación funcional de mi universidad. Esta tarea ahora está cerrada y se ha discutido en clase y tengo el permiso de mi profesor para publicarla aquí (pregunté explícitamente).

Especificación

Entrada

Su entrada es una lista de enteros no negativos, en cualquier formato de E / S estándar.
Puede elegir el formato de lista según lo necesite su idioma

Salida

La salida es una lista de enteros, en cualquier formato de E / S estándar.

¿Qué hacer?

Filtre todos los enteros de la lista de entrada para los cuales la suma de los dígitos no es un cuadrado (de un entero).
El orden de los elementos no se puede cambiar, por ejemplo, si se obtiene [1,5,9]puede no volver[9,1]

Posibles casos de esquina

0 es un número entero no negativo y, por lo tanto, una entrada válida y 0 también es una raíz entera válida, por ejemplo, 0 cuenta como un cuadrado entero.
La lista vacía es una entrada y salida válida también.

¿Quién gana?

Este es el código de golf, por lo que gana la respuesta más corta en bytes.
Se aplican reglas estándar, por supuesto.

Casos de prueba

[1,4,9,16,25,1111] -> [1,4,9,1111]
[1431,2,0,22,999999999] -> [1431,0,22,999999999]
[22228,4,113125,22345] -> [22228,4,22345]
[] -> []
[421337,99,123456789,1133557799] -> []

Ejemplo paso a paso

Example input: [1337,4444]
Handling first number:
Sum of the digits of 1337: 1+3+3+7=14
14 is not an integer square, thus will be dropped!
Handling second number:
Sum of the digits of 4444: 4+4+4+4=16
16 is an integer square because 4*4=16, can get into the output list!
Example output: [4444]

11
¡Buen primer desafío y bienvenido al sitio!
DJMcMayhem

Para futuros desafíos, tenga en cuenta el sandbox . Es un lugar donde ponemos desafíos antes de ponerlos en el sitio principal para que puedan ser revisados ​​y consultados sobre su contenido para que (con suerte) sean mejor recibidos en main. No es que esta sea una mala pregunta (en realidad me gusta bastante)
Azul

@muddyfish, leí sobre esto y consideré publicar allí, pero decidí no hacerlo, porque estaba seguro de que no hay nada que pueda perder / hacer horriblemente mal aquí :) Por supuesto, si tengo alguna duda, podría haber algo Echo de menos que publique allí.
SEJPM

12
Si bien está totalmente bien evitar el sandbox, si hubiera publicado allí, le habría sugerido que haga el desafío solo sobre probar un número entero individual. La tarea interesante es la prueba, envolver esa tarea con un filtro no es particularmente interesante. Todo lo que parece hacer es hacer que el desafío sea mucho más difícil en lenguajes esotéricos que no tienen matrices como tipos. Eso puede sonar un poco duro, pero esta sigue siendo una excelente primera publicación. Solo digo que la caja de arena está allí porque no importa cuán seguro estés de que no te perdiste nada, te perdiste algo.
FryAmTheEggman

1
@FryAmTheEggman Puedo decir para Mathematica que hacer que esta función sea listable complica las cosas de una manera ligeramente no trivial, por lo que no es exactamente aburrido.
LLlAMnYP

Respuestas:



5

Mathematica, 39 36 bytes

Una función anónima:

Select[AtomQ@√Tr@IntegerDigits@#&]

LLlAMnYP guardó un byte. ¡Gracias!

Martin Ender salvó tres más al reemplazar IntegerQcon AtomQ. ¡Inteligente! (El resultado de será exacto, por lo que devuelve una expresión compuesta como Sqrt[5]si su argumento no fuera un cuadrado).


Un byte para ser guardado en ...Digits@#&lugar de...Digits[#]&
LLlAMnYP


4

Brachylog v2, 8 bytes

{ẹ+√ℤ&}ˢ

Pruébalo en línea!

Explicación

{ẹ+√ℤ&}ˢ
{     }ˢ  Map the following operation over {the input}, discarding elements that error:
 ẹ         Split into a list of digits
  +        Sum that list
   √       Take its square root
    ℤ      Assert that the result is an integer
     &     Return to the original value

Esto &significa que los elementos de salida son los mismos que los de la lista de entrada, pero se producirá un error si la entrada del bloque no es un número cuadrado, por lo que obtenemos la lista de entrada con elementos con sumas de dígitos no cuadrados descartados.

Tenga en cuenta que al principio puede parecer que hay un problema de inexactitud de coma flotante aquí (algunos enteros no cuadrados muy grandes tienen raíces cuadradas enteras debido al redondeo). Sin embargo, Brachylog admite aritmética bignum, y en realidad tiene este comportamiento factorizado en su implementación de : un número que es un cuadrado perfecto tendrá su raíz cuadrada informada como un entero, mientras que un número que no es un cuadrado perfecto (pero lo suficientemente cerca como para que sea raíz cuadrada es integral) tendrá su raíz cuadrada informada como flotante con un valor integral. Convenientemente, solo permite el primer tipo de valor de retorno, dando una falla de aserción para el segundo.


3

Pyth, 10 bytes

fsI@sjT;2Q

Banco de pruebas.

Explicación

fsI@sjT;2Q

f        Q  Filter for the following in Q(input):
     jT;        convert to base 10
    s           sum
   @    2       square-root
 sI             is integer (is invariant under flooring)

3

CJam, 14 bytes

¡Gracias a @FryAmTheEggman por guardar un byte!

{{Ab:+mq_i=},}

Pruébalo en línea!

Este es un bloque sin nombre que espera la lista de entrada en la pila y deja la lista filtrada en ella.

Explicación

{e # comienza un nuevo bloque
 Ab e # convertir a base 10 -> dividir número en dígitos
 : + e # suma th dígitos
 mq e # obtiene la raíz cuadrada
 _ e # duplica el resultado
 es decir, # convertir a entero
 = e # comprueba si la raíz cuadrada convertida y la original son iguales
} e # bloque final
, e # filtra la lista de entrada

3

Haskell - 70 60 59 bytes

f=filter(\x->elem(sum.map(read.pure).show$x)$map(^2)[0..x])

Uso:

> f [0..100]
[0,1,4,9,10,13,18,22,27,31,36,40,45,54,63,72,79,81,88,90,97,100]

Bastante sencillo; calcula la suma de dígitos y comprueba si floor (sqrt (y)) ^ 2 == y

Editar: Robó la idea de verificar la lista de cuadrados de C. Quilley


2
Enfoque interesante No estoy seguro de que f=se requiera para esta respuesta.
Michael Klein

3

05AB1E, 19 10 bytes

vySOtDï->—

Explicación

vy                     # for each int in list
  SO                   # digit sum
    tDï-               # difference between sqrt() and int(sqrt())
        >              # increase by 1 giving 1 (true) when equal
         —             # print current int in list if truthy

Pruébalo en línea

Editar: guardado 9 bytes gracias a @Adnan


Para obtener la suma de dígitos para cada uno, puede hacer vySOy verificar de inmediato si es cuadrado o no. Tengo esta a 5: tDï->. También hay una construcción especial que se imprime ycuando es igual a 1, que es ( ). Entonces, eso sería vySOtDï->—.
Adnan

@Adnan: No puedo creer que me olvidé de S. Ni siquiera miré, ya que la tarea decía que salía como una lista, pero veo que otras respuestas están haciendo lo mismo, así que supongo que está bien.
Emigna

Sí, creo que los elementos separados por líneas nuevas se aceptan por defecto, a menos que el desafío indique explícitamente que no.
Adnan

3

R , 57 55 bytes

Uso Filteren el vector. Asume enteros de 32 bits, por lo que 10 dígitos como máximo.

Casos de esquina: devuelve NULLpara el vector vacío y numeric(0)para un vector sin números válidos. Ambos tienen una longitud cero, por lo que deberían ser aceptables.

-2 gracias a @Giuseppe

Filter(function(n)!sum(n%/%10^(0:10)%%10)^.5%%1,scan())

Pruébalo en línea!


3

PowerShell , 64 54 bytes

$args|?{!([math]::Sqrt(([char[]]"$_"-join'+'|iex))%1)}

Pruébalo en línea!

-10 bytes gracias a mazzy

Toma datos como argumentos de línea de comandos (ver ejemplos a continuación), que se procesan en PowerShell en la matriz $args. Lo canalizamos a ?un alias para Where-Object(funciones similares a filter) para seleccionar nuestra salida. Nuestra selección se basa en la llamada .NET [math]::Sqrt()de la suma de dígitos del número con el que es un entero !(...%1). Los enteros resultarán en 0, que cuando noted se convierte Trueen raíces no enteras False.

Como se mencionó en otra parte "devolver" una matriz vacía no tiene sentido, ya que se convierte $nulltan pronto como deja el alcance, por lo que la salida para una entrada vacía no es nada.

Ejemplos

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 1 4 9 16 25 1111
1
4
9
1111

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 1431 2 0 22 999999999
1431
0
22
999999999

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 22228 4 113125 22345
22228
4
22345

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 

PS C:\Tools\Scripts\golfing> .\return-integers-with-square-digit-sums.ps1 1337 4444
4444

1
$n%1comprueba si solo int$args|?{!([math]::Sqrt(([char[]]"$_"-join'+'|iex))%1)}
mazzy

2

Python 2, 76 bytes

lambda l:filter(lambda n:eval(("sum(map(int,`n`))**.5==int("*2)[:-6]+")"),l)

Pruébalo aquí!

Algunos abusos de eval para verificar un número cuadrado, el resto es bastante espectacular.
La sentencia eval se evalúa como sum(map(int,n ))**.5==int(sum(map(int,n))**.5)


2

Oracle SQL 11.2, 213 bytes

WITH v AS(SELECT a,SQRT(XMLQUERY(REGEXP_REPLACE(a,'(\d)','+\1')RETURNING CONTENT).GETNUMBERVAL())s FROM(SELECT TRIM(COLUMN_VALUE)a FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))))SELECT a FROM v WHERE s=CEIL(s);

Sin golf

WITH v AS
(  
  SELECT a,SQRT(XMLQUERY( 
                   REGEXP_REPLACE(a,'(\d)','+\1')  -- Add a + in front of each digit 
                   RETURNING CONTENT
               ).GETNUMBERVAL())s                  -- Evaluate the expression generated by the added +
  FROM 
  (SELECT TRIM(COLUMN_VALUE)a FROM XMLTABLE(('"'||REPLACE(:1,',','","')||'"'))) -- Split string on ','
)
SELECT a FROM v WHERE s=CEIL(s) -- Is a square if square has no decimal part

2

Brachylog , 26 bytes

:1f.
e.(:ef+~^[X:2]h>0;.0)

Ejemplo:

?- run_from_file('code.brachylog',[1431:2:0:22:999999999],Z).
Z = [1431, 0, 22, 999999999]

Explicación

Esta es una situación en la que algo funciona demasiado bien ... la ~^[X:2]parte es cierta tanto para positivo como para negativo X, por lo que para evitar duplicados tengo que especificar eso X > 0.

La ;.0parte está aquí debido a un error (enumerar no funciona en el entero 0).

  • Predicado principal

    :1f.                Find all values of Input which satisfy predicate 1
    
  • Predicado 1

    e.                  Unify output with an element of the input
    (
      :ef               Find all elements of Output (i.e. all digits)
         +              Sum the digits
          ~^[X:2]       True if that sum is the result of X², whatever X is
                 h>0    Impose that X > 0
    ;                   OR
      .0                True if Output is 0
    )
    

2

Python 2, 53 bytes

lambda x:[n for n in x if sum(map(int,`n`))**.5%1==0]

Pruébalo en Ideone .


1
Para f([1111111111111111]), parece que repr(n)contiene un 'L'y int('L')arroja un ValueError. Siento que necesitas str(n)aquí?
Lynn

2
Bien, no funcionará por largos períodos. Sin embargo, no creo que sea diferente de una solución en un lenguaje con enteros de ancho fijo.
Dennis

2

J, 33 27 bytes

6 bytes gracias a @miles .

#~[:(=<.)@%:+/"1@(10&#.inv)

En intérpretes en línea, invno está guardado. Cambia eso a su ^:_1lugar.

Uso

>> f =: #~[:(=<.)@%:+/"1@(10&#.inv)
>> f 1 4 9 16 25 1111 0
<< 1 4 9 1111 0

¿Dónde >>está STDIN y<<es STDOUT.

Ligeramente no golfista

to_base_10 =: 10&#.^:_1
sum        =: +/"1
sqrt       =: %:
floor      =: <.
itself     =: ]
equals     =: =
of         =: @
is_integer =: equals floor
test       =: is_integer of sqrt
copies_of  =: #
f =: copies_of~ [: test (sum of to_base_10)

Versión anterior de 33 bytes

(]=*:@<.@%:)@(+/"1@(10#.^:_1]))#]

Uso

>> f =: (]=*:@<.@%:)@(+/"1@(10#.^:_1]))#]
>> f 1 4 9 16 25 1111 0
<< 1 4 9 1111 0

Donde >>es STDIN y <<es STDOUT.

Ligeramente no golfista

to_base_10 =: 10#.^:_1]
sum        =: +/"1
sqrt       =: %:
floor      =: <.
square     =: *:
itself     =: ]
equals     =: =
of         =: @
test       =: itself equals square of floor of sqrt
copies_of  =: #
f =: (test of (sum of to_base_10)) copies_of itself

1
Puede usar f&.gpara aplicar g, luego f, y luego el inverso de gacortar *:@<.@%:para <.&.%:guardar 2 bytes. Puede reorganizarlo y usar solo el piso para obtener #~[:(=<.)@%:+/"1@(10&#.inv)27 bytes donde investá ^:_1y ya está definido.
millas

2

Javascript 66 bytes

a=>a.filter(b=>(e=Math.sqrt((b+"").split``.reduce((c,d)=>c-+-d)))==(e|0))

Gracias por SergioFC por guardar 7 bytes


¿No puedes usar en c+dlugar de c-+-d? Además, puede usar n%1==0para probar si el resultado es un int, por lo que tal vez pueda guardar algunos bytes usando b=>!(Math.sqrt((b+"").split``.reduce((c,d)=>c-+-d))%1)para filtrar
sergioFC

@sergioFC No puedo cambiar - + - a +, porque son cadenas
Bálint

2

Perl 5, 42 bytes

41, más 1 para -pe lugar de-e

my$s;map$s+=$_,/./g;$_ x=sqrt$s==~~sqrt$s

Explicación:

  • -p obtiene cada entero de entrada en una nueva línea y asigna $_ a esa cadena.
  • my$s inicializa la variable $s a nada, de nuevo para cada entero de entrada.
  • map$s+=$_,/./g toma cada carácter numérico y lo agrega numéricamente a $s . (La nueva línea se convierte en 0 cuando se numera).
  • sqrt$s==~~sqrt$sprueba si $stiene una raíz cuadrada no integral, y$_ x= convierte $_en sí mismo o en la cadena vacía dependiendo de esa prueba.
  • -p huellas dactilares $_

Gracias a Brad Gilbert b2gills por guardar tres bytes.

También 41 más 1:

my$s;s/./$s+=$&/ger;$_ x=sqrt$s==~~sqrt$s
  • s/./$s+=$&/geragrega cada carácter numérico a $s(y la nueva línea es 0 como arriba)

2

JavaScript (Node.js) , 48 bytes

a=>a.filter(b=>eval([...b+""].join`+`)**.5%1==0)

Pruébalo en línea!

Explicación

a =>                                  // lambda function taking one argument
    a.filter(                         // filter the list
        eval(                         // begin eval
            [...b+""]                 // convert number to array of digits 
                .join`+`              // join them with + sign
            )                         // close eval. we achieved sum of all digits of number
        **.5                          // square root of number
        %1==0                         // check for perfect square
    )                                 // end filter and return value

1

MATL, 16 14 13 bytes

"@tV!UsX^1\?x

Pruébalo en línea!

Explicación

        % Implicitly grab input
"       % For each number in the input
  @t    % Get this element and duplicate
  V     % Convert to it's string representation
  !     % Transpose the string so each digit is on it's own row
  U     % Convert each row to a number (separates the digits)
  s     % Compute the sum of the digits
  X^    % Compute the square root
  1\    % mod with 1 to determine if the square root is an integer
  ?x    % If there is a remainder, then remove this element from the stack
        % Implicitly display the stack contents

1

Julia - 38 bytes

!X=filter(i->√sum(digits(i))%1==0,X)

Es bastante fácil ver qué hace esto. digitsconvierte un número en una lista de sus dígitos, sumasí calcula la suma de dígitos, luego producirá un número entero si el número es un cuadrado, de lo contrario habrá una parte fraccionaria. %1devolverá solo la parte fraccionaria, y si es cero ( ==0),filter mantendrá en la lista, de lo contrario se filtrará.

Usado como ![22228,4,113125,22345]


1

Jolf, 8 bytes

Pruébalo aquí!

ψxd!iUuH

Explicación

ψxd!iUuH
ψxd       filter the input according to the input
      uH  digit sum of H (element)
     U    sqrt of
   !i     is an integer?

1

MATLAB, 52 43 42 bytes

@(x)x(~mod(sum(dec2base(x,10)'-48).^.5,1))

Crea una función anónima llamada ans que se puede llamar con una serie como entrada: ans([22228,4,113125,22345]).

Demo en línea . La demostración en línea está en Octave, que no funciona para la entrada vacía, pero MATLAB sí.

Explicación

Convertimos cada elemento en la matriz de entrada a base 10, lo que producirá una matriz de caracteres 2D donde cada fila contiene los dígitos de un número en la matriz. Para convertir estos caracteres en números, restamos 48 (ASCII para '0'). Luego sumamos a través de las filas, sacamos la raíz cuadrada y determinamos si cada valor es un cuadrado perfecto ~mod 1. Luego usamos este booleano para filtrar la matriz de entrada.


1

Clojure, 110 bytes

(fn[t](filter(fn[x](let[a(reduce +(*(count(str x))-48)(map int(str x)))](some #(=(* % %)a)(range(inc a)))))t))

Calcula la suma de dígitos numéricos y luego filtra aquellos para los cuales no existe un número que al cuadrado sea igual a la suma.

Puede ver el resultado aquí: https://ideone.com/ciKOje


1

Perl 6 ,  38   35 bytes

{.grep: {($/=sqrt [+] .comb)==$/.Int}}
{.grep: {($/=.comb.sum.sqrt)==$/.Int}}
{.grep: {($/=sqrt [+] .comb)==^$/}}
{.grep: {($/=.comb.sum.sqrt)==^$/}}

Prueba:

#! /usr/bin/env perl6

use v6.c;
use Test;

my @tests = (
  [1,4,9,16,25,1111] => [1,4,9,1111],
  [1431,2,0,22,999999999] => [1431,0,22,999999999],
  [22228,4,113125,22345] => [22228,4,22345],
  [] => [],
  [421337,99,123456789,1133557799] => [],
);

plan +@tests;

my &sq-digit-sum = {.grep: {($/=sqrt [+] .comb)==^$/}}

for @tests -> $_ ( :key($input), :value($expected) ) {
  is sq-digit-sum($input), $expected, .gist
}
1..5
ok 1 - [1 4 9 16 25 1111] => [1 4 9 1111]
ok 2 - [1431 2 0 22 999999999] => [1431 0 22 999999999]
ok 3 - [22228 4 113125 22345] => [22228 4 22345]
ok 4 - [] => []
ok 5 - [421337 99 123456789 1133557799] => []

1

C, 143 141 bytes

  • guardado 2 bytes, @ user6188402
i;q(char*n){double m=0;while(*n)m+=*n++-48;m=sqrt(m)-(int)sqrt(m);return !m;}s(n,s)char**n;{i=-1;while(++i<s)if(q(n[i]))printf("%s\n",n[i]);}

Intente sin golf en línea

int q(char*n)
{
    double m=0;

    while(*n) // sum digits
        m+=*n++-48;

    // get the decimal part of its square root
    m=sqrt(m)-(int)sqrt(m);

    // true if decimal part is zero
    return !m;
}

// input is text, can be a file
void s(char**n, int s)
{
    int i=-1;

    while(++i<s) // for each number in input
        if(q(n[i])) // if is square
            printf("%s\n",n[i]); // output is terminal
}

1

Retina , 69

Porque prueba de cuadrados perfectos en la retina. Esto puede ser modificar para el cálculo generalizado de raíz cuadrada entera .

. +
$ & a $ &
+ `\ b \ d
$ * b 


\cama y desayuno
PS
+ `(\ bb +) :( bb \ 1)
$ 1 $ 2:
G` (: a | 0 $)
.*una

La entrada es una lista separada por una nueva línea.

Pruébalo en línea.

  • Etapa 1: repita el número en cada línea y sepárelo con a
  • Etapa 2: convierta cada dígito antes del aunario expresado como bs, separado con espacios
  • Etapa 3 - eliminar espacios - cada unario ahora representa la suma de dígitos
  • Etapa 4 y 5 - Usa el hecho de que los cuadrados perfectos pueden expresarse 1 + 3 + 5 + 7 + .... Dividir cada unario en consecuencia
  • Etapa 6: filtro grep solo los que se dividen exactamente en la forma anterior
  • Etapa 7: descarta todo menos el número original

Tenía algunas ideas sobre cómo mejorar esto, pero terminé reescribiendo la mayor parte. Sin embargo, esta sigue siendo exactamente su idea: duplicar la entrada, expandir dígitos en la primera mitad, filtrar cuadrados en forma de sumas de números impares, descartar la primera mitad de las líneas restantes. La forma en que jugué los pasos es a través de la %configuración \Gy las referencias directas . Siéntase libre de tomarlo: retina.tryitonline.net/… :)
Martin Ender

1

Python, 50 bytes

filter(lambda x:sum(map(int,str(x)))**0.5%1==0,in)

Si n es la lista de entrada de números


1
Hola y bienvenidos al sitio! Dado que esta es una competencia de código de golf , por ejemplo, quién puede escribir el código más corto, requerimos que todas las presentaciones sean al menos un tanto golfizadas . Tenemos una lista de consejos de golf de python aquí . Justo en la parte superior de mi cabeza, una mejora obvia que podrías hacer es eliminar todos los espacios en blanco adicionales y cambiar el nombre de tus variables a una letra cada una. También puede tomar la entrada como argumentos de función o STDIN en lugar de argumentos de línea de comando.
DJMcMayhem

También debe especificar el idioma y el recuento de bytes, que podrían contarse, por ejemplo, allí .
nicael

1
Bienvenido a PPCG! Además de lo que dijeron los demás, tenga en cuenta que todas las soluciones deben ser programas completos o funciones invocables . Hasta ahora, todas sus respuestas han sido fragmentos que suponen que la entrada se almacena en alguna variable y solo evalúan el resultado, lo que desafortunadamente los invalida. Para métodos de E / S aceptables, vea esta meta publicación .
Martin Ender


1

K (oK) , 19 17 13 bytes

Solución:

(~1!%+/.:'$)#

Pruébalo en línea!

Explicación:

(~1!%+/.:'$)# / the solution
(          )# / apply function to list
          $   / convert to string
       .:'    / value (.:) each (')
     +/       / sum
    %         / square-root
  1!          / modulo 1
 ~            / not

Notas:

  • -2 bytes con una forma más inteligente de identificar cuadrados
  • -4 bytes gracias a ngn

1
sabes sobre filter ( func#list) ?
ngn

No lo hice, muy bien!
Callejero

1

MathGolf , 5 4 bytes

gÅΣ°

Pruébalo en línea!

Explicación:

gÅ    Filter by the next two instructions
  Σ   The digit sum
   °  Is a perfect square?

MathGolf todavía está en desarrollo, por lo que supongo que pronto llegará una entrada implícita para eliminar ese primer byte. ¡Hurra!


¡Felicitaciones por la primera respuesta de MathGolf no hecha por mí! He discutido los aportes implícitos con Emigna, y él me dio algunas ideas geniales. Viene, con suerte pronto.
maxb
Al usar nuestro sitio, usted reconoce que ha leído y comprende nuestra Política de Cookies y Política de Privacidad.
Licensed under cc by-sa 3.0 with attribution required.