Primes con recuentos de bits principales

23

Tarea

Encuentre todos los enteros no negativos hasta e incluyendo un entero positivo n distinto de cero n , que son primos y el recuento de 1'sy 0'sen su representación binaria (sin ceros a la izquierda) también son primos.

Aquí están los primeros cinco primos,

17, 19, 37, 41, 79

10001, 10011, 100101, 101001, 1001111

Aclaraciones y reglas.

  • Se aceptan métodos de E / S predeterminados .
  • La respuesta puede ser un programa o una función.
  • Si no hay tales primos, entonces genera basura o nada.
  • Lagunas estándar están prohibidas.
  • 2 3 5 7no llegó a la lista porque en su representación binaria el número de ocurrencias de 0'sy 1'sno son primos. Considere de 7quién es la representación binaria 111, aquí0 ocurre cero veces y cero no es primo.

  • Se permiten empotrados.

  • ¡El código más corto en bytes gana!

Casos de prueba

10
[]

100
[17, 19, 37, 41, 79]

150
[17, 19, 37, 41, 79, 103, 107, 109, 131, 137]

Mostrar fragmento de código

code-golf  primes  binary 
— Gurupad Mamadapur
fuente
1
Pide todos los números primos bajo una n dada, pero también dice inclusivo. ¿A qué te refieres?
— Riley
@Riley lo que quiero decir es ... all the numbers from 1....n. No sé cómo reformularlo de una manera simple.
— Gurupad Mamadapur
66
— mbomb007
3
@ mbomb007 Claramente, para cualquier ordenación total de secuencias de enteros, la secuencia de enteros sin interés más pequeña sería en sí misma interesante y, por lo tanto, digna de inclusión en OEIS. Ergo, OEIS contiene todas las secuencias de enteros, de cualquier interés real o imaginario :-)
— Iwillnotexist Idonotexist
99
Me pregunto si Mathematica contiene más componentes integrados que OEIS tiene secuencias ...
— Neil

Respuestas:

5

Jalea , 14 13 bytes

RBċþd`ÆPPTfÆR

Pruébalo en línea!

Cómo funciona

RBċþd`ÆPPTfÆR  Main link. Argument: n

R              Range; yield [1, ..., n].
 B             Binary; convert each integer to base 2.
    d`         Divmod self; yield [n : n, n % n], i.e., [1, 0].
  ċþ           Count table; count the occurrences of 1 and 0 in each binary
               representation, yielding a pair of lists of length n.
      ÆP       Test each count for primality.
        P      Product; multiply the corresponding Booleans.
         T     Truth; get all indices of 1, yielding the list of integers in
               [1, ..., n] that have a prime amount of 0's and 1's.
           ÆR  Prime range; yield all primes in [1, ..., n].
          f    Filter; intersect the lists.
— Dennis
fuente
2
Ese d`​truco es otra cosa ...
— ETHproductions
10

Python 2 , 106 102 100 bytes

k=m=1;p={0}
exec"p^={m%k*k,0};c=bin(k).count\nif{k,c('1'),c('0')-1}<p:print k\nm*=k*k;k+=1;"*input()

Pruébalo en línea!

Fondo

Para identificar números primos, usamos un corolario del teorema de Wilson :

corolario del teorema de Wilson

Cómo funciona

Comenzamos inicializando k y m como 1 y p como el conjunto {0} . Tenga en cuenta que m = 1 = 0! ² = (k - 1)! ² . Inmediatamente después, el siguiente código se ejecuta n veces, donde n es el entero leído desde la entrada estándar.

p^={m%k*k,0};c=bin(k).count
if{k,c('1'),c('0')-1}<p:print k
m*=k*k;k+=1

Según el corolario, m% k será 1 si k es primo y 0 en caso contrario. Por lo tanto, {m%k*k,0}devolverá el conjunto {k, 0} si k es primo y el conjunto {0} de lo contrario.

Si (y solo si) k es primo, ya que p no puede contener k en este punto, la diferencia simétrica in situ p^={m%k*k,0}agregará k al conjunto p . Además, p contendrá 0 después de la actualización si y solo si no contiene 0 antes, por lo que 0 ∊ p si y solo si k es par.

En la misma línea, definimos una función c vía c=bin(k).count, que contará las ocurrencias de su argumento en la representación binaria de k .

La segunda línea produce la salida real. {k,c('1'),c('0')-1}devuelve el conjunto que consta de k , el número de bits establecidos en k y el número de bits no establecidos en k . Como la salida de bin(k)comienza con 0b , tenemos que disminuir c('0')para tener en cuenta el 0 inicial .

Si todos ellos son primos, todos pertenecerán a p , que ahora contiene todos los números primos hasta k (y potencialmente 0 ). Si k es un número de Mersenne (es decir, si solo ha establecido bits), c('0')-1producirá 0 . Puesto que los números de Mersenne son impares, p será no contiene 0 , por lo que la condición se producirá un error.

Después de (potencialmente) imprimir k , multiplicamos m por k² . Como m = (k-1)! ² antes de la actualización, m = k! ² después de ella. Después de incrementar k , la relación m = (k-1)! ² se mantiene nuevamente y estamos listos para la próxima iteración.

— Dennis
fuente
9

Mathematica, 80 68 54 bytes

Select[p=PrimeQ;Range@#,p@#&&And@@p/@#~DigitCount~2&]&

Explicación

Select[p=PrimeQ;Range@#,p@#&&And@@p/@#~DigitCount~2&]&

       p=PrimeQ                                        (* Store prime check func. in p *)
Select[                                             ]  (* Select *)
                Range@#                                (* from a list {1..n} *)
                        p@#                            (* numbers that are prime *)
                           &&                          (* And *)
                                     #~DigitCount~2    (* whose digit counts in binary *)
                             And@@p/@                  (* are prime as well *)
— JungHwan Min
fuente
8

JavaScript (ES6), 123 118 115 111 104 96 bytes

Guardado 4 bytes gracias a @Arnauld

G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
F=n=>F(n-1,G(n,a=[0,0,n])||alert(n))

Una combinación de tres funciones recursivas típicas. Alerta la secuencia en orden inverso y termina en un error de "demasiada recursividad".

Fragmento de prueba

(modificado para enviar a la página)

Mostrar fragmento de código

La función principal puede devolver una matriz de 104 bytes:

G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
F=n=>n?F(n-1).concat(G(n,a=[0,0,n])?[]:n):[]

También puede ser no recursivo a costa de otro byte:

G=n=>n?G(n>>1,++a[n%2]):a.some(n=>(P=x=>n%--x?P(x):x)(n)-1)
n=>[for(_ of Array(n))if(!G(--n,a=[0,0,n]))n]

Aquí está el que comencé con: (Guardado 6 bytes gracias a @Arnauld)

P=(n,x=n)=>n>1&--x<2||n%x&&P(n,x)
G=n=>n?G(n>>1,o+=n%2,t++):P(o)&P(t-o)
F=n=>n?F(n-1).concat(P(n)&G(n,o=t=0)?n:[]):[]

Intenté jugar más al golf y logré hacerlo en 104 bytes, luego me di cuenta de que ya había encontrado esa solución (está en la parte inferior de la respuesta). ¿No odias cuando eso sucede? :PAGS

Un intento no recursivo en la función principal (de nuevo, el mismo recuento de bytes):

n=>[for(i of Array(n))if(P(--n)&G(n,o=t=0))n]

Éste toma la ruta fácil de contar cuántos 0 y 1 hay en la representación binaria:

F=n=>n?F(n-1).concat([n,(G=x=>n.toString(2).split(x).length-1)(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]

Lo mismo con una comprensión de matriz:

n=>[for(_ of Array(n))if(![--n,(G=x=>n.toString(2).split(x).length-1)(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1))n]

Este toma una ruta un poco más difícil para hacer lo mismo:

F=n=>n?F(n-1).concat([n,(G=(x,w=n)=>w&&G(x,w>>1)+(w%2==x))(0),G(1)].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]

Y esta toma otra ruta relacionada que es tan corta como la original:

F=n=>n?F(n-1).concat([n,o=(G=x=>x&&x%2+G(n>>++t))(n,t=0),t-o].some(n=>(P=x=>n%--x?P(x):x)(n)-1)?[]:n):[]

Una vez más, puedes jugar 8 bytes haciendo que alerta la secuencia en orden inverso:

F=n=>F(n-1,[n,o=(G=x=>x&&x%2+G(n>>++t))(n,t=0),t-o].some(n=>(P=x=>n%--x?P(x):x)(n)-1)||alert(n))
— ETHproducciones
fuente
Realmente no necesitas pasar recursivamente a. Simplemente inicialícelo en la llamada inicial a G. (Eso debería ahorrar 4 bytes.)
— Arnauld
@Arnauld ¡Oh sí, gracias! Esto es divertido :-)
— ETHproductions
1
Wow, esto ha caído mucho. Buen trabajo
— George Reith
6

Jalea , 17 16 bytes

BĠL€µ;LÆPẠ
ÆRÇÐf

Pruébalo en línea!

¿Cómo?

BĠL€µ;LÆPẠ - Link 1, hasPrimeBits: n  e.g. 7         or 13
B          - convert to binary        e.g. [1,1,1]  or [1,1,0,1]
 Ġ         - group indices            e.g. [1,2,3]  or [3,[1,2,4]]
  L€       - length of €ach           e.g. 3          or [1,3]
    µ      - monadic chain separation
     ;L    - concatenate length       e.g. [3,1]      or [1,3,2]
           -     this caters for the edge case of Mersenne primes (like 7), which have
           -     no zero bits, the length will be 1, which is not prime.
       ÆP  - isPrime?                 e.g. [1,0]      or [0,1,1]
         Ạ - All?                     e.g. 0          or 0

ÆRÇÐf - Main link: N
ÆR    - prime range (primes up to and including N)
   Ðf - filter keep those satisfying
  Ç   - last link (1) as a monad
— Jonathan Allan
fuente
1
Ah, gracias, veo que cambiaste eso, eso ahorrará un byte.
— Jonathan Allan
1
Tienes el alfabeto en marcha, ahí. ẠBÇЀfĠ...
— mbomb007
2
@ mbomb007 Sí, el LƵ;Pbit siempre me confunde.
— Jonathan Allan
6

05AB1E , 14 bytes

ƒNpNbSD_‚OpP&–

Pruébalo en línea!

Explicación

ƒ               # for N in [0 ... input]
 Np             # push N is prime
   Nb           # push N converted to binary
     S          # split into individual digits
      D_        # push an inverted copy
        ‚       # pair the 2 binary lists
         O      # sum them
          p     # elementwise check for primality
           P    # product of list
            &   # and with the primality of N
             –  # if true, print N
— Emigna
fuente
Todavía no puedo encontrar un uso .¡, este desafío me pareció bien, pero es más largo:FNb{.¡€gpONp+3QiN}})
— Urna de pulpo mágico
@carusocomputing: también tuve una solución similar que consideré, pero también terminó un poco más que esta.
— Emigna
4

MATL , 16 15 bytes

:"@tB!t~hshZp?@

Pruébalo en línea!

:         % Input n (implicit). Push range [1 2 ... n]
"         % For each k in [1 2 ... n]
  @       %   Push k
  tB!     %   Duplicate. Binary expansion as an m×1 vector
  t~      %   Duplicate. Negate
  hs      %   Concatenate horizontally into an m×2 matrix. Sum of each column.
          %   This gives a 1×2 vector. However, for k==1 this gives the sum of
          %   the original 1×2 matrix (m==1). But fortunately it doesn't matter
          %   because 1 is not a prime anyway
  h       %   Concatenate horizontally into a 1×3 row vector
  Zp      %   Isprime function applied on each of those three numbers
  ?       %   If all gave true
    @     %     Push k
          %   End (implicit)
          % End (implicit)
          % Display (implicit)
— Luis Mendo
fuente
4

Perl, 101 bytes

99 bytes de código + -nlbanderas.

$r=q/^1?$|^(11+)\1+$/;for$@(2..$_){$_=sprintf"%b",$@;print$@if(1x$@)!~$r&y/01/1/dr!~$r&s/0//gr!~$r}

Para ejecutarlo:

perl -lne '$r=q/^1?$|^(11+)\1+$/;for$@(2..$_){$_=sprintf"%b",$@;print$@if(1x$@)!~$r&y/01/1/dr!~$r&s/0//gr!~$r}' <<< 150

Algunas explicaciones breves
$r contienen la clásica expresión regular de verificación regex ( q/^1?$|^(11+)\1+$/).
Para todos los números entre 2 y la entrada,
(1x$@)!~$rverifica si el número es primo,
y/01/1/dr!~$rverifica si el número 0en la representación binaria es primo,
s/0//gr!~$rverifica si el número 1en la representación binaria es primo.
(si se cumplen las 3 condiciones, lo print$@imprime).

— Dada
fuente
Gracias por la explicación. Bastante sorprendente lo que puedes hacer con lo que es básicamente expresiones regulares y algo de lógica :)
— Emigna
@ Emmigna Gracias! Las explicaciones no son muy detalladas (me cuesta mucho escribir explicaciones más largas), pero parece que fue suficiente para ti :) (Todavía creo que el código es un poco demasiado largo, pero no veo cómo obtenerlo es más corto, así que aquí está)
— Dada
1
Como alguien que no conoce a Perl, aprecio cada explicación que puedo obtener. No me ayudará a hacer un programa Perl, pero entiendo algunos de los razonamientos detrás del método empleado, que siempre es interesante.
— Emigna
3

Pitón, 129 125 123 bytes

Si solo cero fuera primo ...

p=lambda n:all(n%m for m in range(2,n))*n>1
lambda n:[i for i in range(n+1)if p(i)*all(p(bin(i)[2:].count(x))for x in'01')]

Pruébalo en línea

La función pes la función de verificación principal, que tiene>0 al final para que también funcione para cero, que de lo contrario volvería -1. La lambda anónima es la lambda que verifica todas las condiciones requeridas.

Aquí hay un método ligeramente diferente usando una comprensión establecida. El resultado será un conjunto. ( 124 bytes ):

p=lambda n:all(n%m for m in range(2,n))*n>1
lambda n:{i*p(i)*all(p(bin(i)[2:].count(x))for x in'01')for i in range(n+1)}-{0}
— mbomb007
fuente
3

Perl 6 , 65 bytes

{grep {all($^a,|map {+$a.base(2).comb(~$_)},0,1).is-prime},0..$_}

Intentalo

Expandido:

{           # bare block lambda with implicit parameter ｢$_｣

  grep      # find all of the values where

  {         # lambda with placeholder parameter ｢$a｣

    all(    # all junction ( treat multiple values as a single value )

      $^a,  # declare parameter to block

      |\    # slip the following list into the outer list

      # get the count of 0's and 1's in the binary representation
      map

      {             # bare block lambda with implicit parameter ｢$_｣

        +           # turn to numeric ( count the values in the list )
        $a          # the outer parameter
        .base(2)    # in base 2
        .comb(~$_)  # find the characters that are the same as
      },0,1         # 0 or 1

    # ask if $a, count of 0's, count of 1's are all prime
    ).is-prime

  },

  0 .. $_ # Range from 0 to the input inclusive

}
— Brad Gilbert b2gills
fuente
3

Octava, 73 bytes

@(n)(p=primes(n))(all(isprime([s=sum(dec2bin(p)'-48);fix(log2(p))+1-s])))

¡Pruébelo en línea!

@(n)
    (p=primes(n))                           generate prime numbers
        (all(                               from them select those that
            isprime(                        are prime both
                [s=sum(dec2bin(p)'-48);     sum of 1s
                fix(log2(p))+1-s])))        and sum of 0s
— rahnema1
fuente
2

CJam , 26 27 bytes

ri){mp},{2b_1-,mp\0-,mp&},p

Algoritmo directo, jugará más golf.

EDITAR: Olvidé n fue inclusivo.

Pruébalo en línea!

Por diversión, esto es muy similar y también de 27 bytes:

ri){_mp\2b_1-,mp\0-,mp&&},p

Explicación

ri                          e# Take an int as input
  ){mp},                    e# Take the range up and including to the input, 
                            e#   including only prime numbers
       {                    e# For each prime...
        2b_                 e# Convert it to binary and copy it
           1-,mp            e# Take the top binary number, remove 1's, check if the length 
                            e#   is prime
                \           e# Swap top elements
                 0-,mp      e# Do the same but remove 0's
                      &     e# And
                       },   e# Filter out primes for which the above block was false
                         p  e# Print nicely
— Gato de negocios
fuente
2

Jalea , 14 bytes

BċÆPðÐf
ÆRç0ç1

Pruébalo en línea!

Desafortunadamente, solo pude vincularme con @Dennis, pero el algoritmo parece ser algo diferente, así que estoy publicando esto de todos modos.

Explicación

Función auxiliar (elimina elementos de la lista que no tienen un número primo de ocurrencias de un bit dado):

BċÆPðÐf
     Ðf   Filter {the first argument}, looking for truthy returns from
    ð     the preceding code, which takes two arguments:
B         Convert {the element being checked} to binary
 ċ        Count the number of occurrences of {the second argument}
  ÆP      Return true if prime, false if not prime

Programa principal:

ÆRç0ç1
ÆR        Generate all primes from 2 to the input
  ç0      Call the subroutine to require a prime 0 count
    ç1    Call the subroutine to require a prime 1 count
2

Haxe, 169 171 bytes

function f(n,?p)return[for(j in(p=[for(i in 0...++n)i<2?0:i]))if(j>0){var x=j*2,y=0,z=0,k=j;while(k<n)p[k+=j]=0;while((x>>=1)>0)x&1>0?y++:z++;p[y]<1||p[z]<1?continue:j;}];

Nada loco Esencialmente, un tamiz modificado de Eratóstenes que evalúa la primalidad del recuento 0/1 en la misma iteración que tachando los no primos superiores. Con algo de espacio en blanco:

function f(n, ?p)
  return [ for (j in (p = [ for(i in 0...++n) i < 2 ? 0 : i ]))
    if (j > 0){
      var x = j * 2, y = 0, z = 0, k = j;
      while (k < n)
        p[k += j] = 0;
      while((x >>= 1) > 0)
        x & 1 > 0 ? y++ : z++;
      p[y] < 1 || p[z] < 1 ? continue : j;
    }
  ];

Pero hoy aprendí que podía poner continue un operador ternario y a Haxe ni siquiera le importa.

Editar: +2 porque nes un límite superior inclusivo!

— Aurel Bílý
fuente
Hola, el nes inclusivo.
— Gurupad Mamadapur
@GurupadMamadapur Tienes razón, ¡arreglado!
— Aurel Bílý
2

Bash utilidades + GNU, 129 126 123 114 111 109 bytes

seq '-fp()([ `factor|wc -w` = 2 ]);g()(dc -e2o${n}n|tr -cd $1|wc -c|p);n=%.f;p<<<$n&&g 0&&g 1&&echo $n' $1|sh

Pruébalo en línea!

Noté el comentario de que la salida no tiene que estar en orden creciente: redujo 3 bytes al contar hacia atrás en lugar de contar hacia arriba.

Se reemplazó grep con wc para guardar 3 bytes adicionales.

Se eliminó una variable (9 bytes más desactivados).

Se modificó la forma en que se usa el factor: 3 bytes más.

Lo hizo más golfista con seq (2 bytes).

— Mitchell Spector
fuente
2

Python, 172 170 168 159 154 133 130 bytes

p=lambda n:[i for i in range(1,n)if n%i==0]==[1]
lambda n:[i for i in range(n+1)if p(i)*all(p(bin(i)[2:].count(x))for x in'10')]

Uso: llamar a la función lambda anónima El
método pverifica si un número es primo

Guardado 2 + 2 + 9 = 13 bytes gracias a Gurupad Mamadapur
Guardado 5 bytes gracias a mbomb007

— ovs
fuente
1
Puedes ahorrar 2 más usando esto v-def v(n):a=bin(n)[2:];return p(n)and(p(a.count('1'))and p(a.count('0')))
— Gurupad Mamadapur
1
Una mucho más corta -v=lambda a:p(a)and all(p(bin(a)[2:].count(x))for x in['1','0'])
— Gurupad Mamadapur
2
Las cadenas son iterables. Entonces puedes usar for x in'01'.
— mbomb007
1

Pyke, 21 bytes

S#j_PI\0[jb2R/_P)I\1[

Pruébalo aquí!

S#j                   - for j in filter(range(1, input+1))
   _PI                -  if is_prime(j):
        [jb2R/_P)     -   function_[(a) = V
         jb2          -      base_2(j)
            R/        -     ^.count(a)
      \0         I    -   if function_[("0"):
                  \1[ -    function_[("1")
— Azul
fuente
1

Groovy, 120 bytes

p={x->(2..<x).every{x%it!=0}&x>1|x==2}
{x->(1..x).findAll({y->p(y)&'10'.every{p(Integer.toBinaryString(y).count(it))}})}

Este es un cierre sin nombre.

Pruébalo aquí!

— Gurupad Mamadapur
fuente
1

JavaScript (ES6), 110 bytes

B=n=>n?B(n>>1,v[n%2]++):v.every(n=>(P=i=>n%--i?P(i):1==i)(n))
F=(n,a=[])=>n?F(n-1,B(n,v=[0,0,n])?[n,...a]:a):a

Mostrar fragmento de código

— George Reith
fuente
Esa función de prueba de primalidad es ... simplemente increíble :-) ¿Lo creaste tú mismo?
— ETHproductions
@ETHproductions Lo has visto antes de codegolf.stackexchange.com/a/91309/11182 modificado desde aquí. También tomé prestado tu código de conteo 1 y 0 (pude decir cualquier cosa que se me ocurriera) pero lamentablemente no pude superar tu conteo de bytes.
— George Reith
@ETHproductions Buena captura gracias! Era un artefacto de una versión anterior
— George Reith
1

MATLAB, 50 bytes

@(n)all(isprime([n,sum(de2bi(n)),sum(~de2bi(n))]))
— MattWH
fuente
1

Haxe, 158147 bytes

function p(n,x=1)return n%++x<1||n<2?x==n:p(n,x);function f(n){var q=n,t=0,o=0;while(q>0){t++;o+=q%2;q>>=1;}p(n)&&p(o)&&p(t-o)?trace(n):0;f(n-1);};

Sale a STDOUT y termina en un error de "demasiada recursividad"; llamar con, por ejemplo f(1000);. Puede usar un whilebucle sin error para 156 bytes:

function p(n,x=1)return n%++x<1||n<2?x==n:p(n,x);function f(n){while(n>0){var q=n,t=0,o=0;while(q>0){t++;o+=q%2;q>>=1;}p(n)&&p(o)&&p(t-o)?trace(n):0;n--;}};

Usando un rango resultó tres bytes más largos:

function p(n,x=1)return n%++x<1||n<2?x==n:p(n,x);function f(n){for(i in 0...n+1){var q=i,t=0,o=0;while(q>0){t++;o+=q%2;q>>=1;}p(i)&&p(o)&&p(t-o)?trace(i):0;}};

¡Pruébalo en línea!

— ETHproducciones
fuente
1

Óxido, 147 bytes

fn f(x:u32){let p=|n|n>1&&(2..n).all(|x|n%x!=0);for n in 9..x+1{if p(n)&&p(n.count_ones())&&p(n.count_zeros()-n.leading_zeros()){print!("{} ",n)}}}

enlace de juegos

Las count_ones, count_zerosy leading_zeroslos métodos fueron muy útiles.

Versión formateada

fn f(x: u32) {
    // primality test closure using trial division
    let p = |n| n > 1 && (2..n).all(|x| n % x != 0);

    for n in 9..x + 1 {
        if p(n) && p(n.count_ones()) && p(n.count_zeros() - n.leading_zeros()) {
            print!("{} ", n)
        }
    }
}
— Buscador14491
fuente
1

Perl 6 , 50 bytes

{grep {($_&+.base(2).comb(~0&~1)).is-prime},0..$_}

Variación de la respuesta de b2gills , utilizando el operador de & unión con gran efecto.

Pruébalo en línea!

Cómo funciona

{                                                }  # Lambda
                                            0..$_   # Range from 0 to the lambda argument.
 grep {                                   },        # Filter values satisfying:
       ($_                      ).is-prime          #  a) The Number itself is prime.
       (   +.base(2).comb(~0   )).is-prime          #  b) The count of 0's is prime.
       (   +.base(2).comb(   ~1)).is-prime          #  c) The count of 1's is prime.
          &                 &                       # Junction magic! :)
— smls
fuente
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.