Hacer un simple envoltorio de palabras


22

(Nota: esta es mi primera pregunta de código de golf, pero por lo que puedo decir, nadie más ha hecho exactamente esto, así que debería ser bueno).

Su tarea es hacer un programa o función que tome una cadena sy un número entero n, y devuelva o genere ese texto envuelto en varias líneas. Cada palabra debe estar totalmente en una línea; es decir, no hay palabras divididas en el medio. Cada línea puede tener una nlongitud máxima de caracteres y debe incluir tantas palabras como sea posible en cada línea.

Ejemplo:

s = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat." 
n = 50

output:
Lorem ipsum dolor sit amet, consectetur adipiscing
elit. Sed eget erat lectus. Morbi mi mi, fringilla
sed suscipit ullamcorper, tristique at mauris.
Morbi non commodo nibh. Pellentesque habitant
morbi tristique senectus et netus et malesuada
fames ac turpis egestas. Sed at iaculis mauris.
Praesent a sem augue. Nulla lectus sapien, auctor
nec pharetra eu, tincidunt ac diam. Sed ligula
arcu, aliquam quis velit aliquam, dictum varius
erat.

Su salida puede ser una matriz de cadenas o una sola cadena con saltos de línea. Además, puede asumir que las palabras no serán más largas que n, así que no se preocupe por tratar casos extraños.

Se aplican las reglas estándar de E / S y se prohíben las lagunas estándar. Se permiten espacios finales.

Como se trata de , gana la solución de shortes en bytes.

Aquí hay un programa de ejemplo en Python que funcionaría.



3
n es la longitud máxima de la línea? o la longitud que tenemos que alcanzar antes del salto de línea?
David

1
@david, o el número de líneas?
Peter Taylor

1
28 bytes Python es relevante?
David

3
nes la longitud máxima de la línea, lamento que eso no esté claro. Voy a aclarar Además, las reglas ahora se han actualizado, por lo que una división simple no funciona.
ATMunn

Respuestas:



5

PHP , 8 bytes

¡Es cierto que no es la solución más original, pero PHP tiene una función nativa que se adapta perfectamente a tus requisitos!

wordwrap:

string wordwrap ( string $str [, int $width = 75 [, string $break = "\n" [, bool $cut = FALSE ]]] )

Envuelve una cadena a un número dado de caracteres usando un carácter de salto de cadena.

Use así:

$str = "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.";
echo wordwrap($str, 50);

O Pruébelo en línea!


5

JavaScript (ES6),  75 73  72 bytes

Toma entrada como (string)(n).

s=>n=>s.split` `.map(w=>r=(u=r?r+' '+w:w)[n]?(o+=r+`
`,w):u,o=r='')&&o+r

Pruébalo en línea!

Variables

La salida formateada se almacena en (en verde a continuación).o

La línea actualizada se define como la concatenación de:tu

  • la línea actual (en negro debajo)r
  • un espacio si no está vacío, o nada más (en naranja debajo)r
  • la nueva palabra (en azul abajo)w

Hay que insertar un salto de línea cada vez que el carácter -ésimo de se establece (0 indexados, en rojo abajo).nortetu

Ejemplo

norte=dieciséis y = "LOREM ipsum dolor"s

Agregar "LOREM":

00010203040506070809101112131415dieciséisLORmiMETRO

Agregar "IPSUM":

00010203040506070809101112131415dieciséisLORmiMETROyoPAGSSUMETRO

Agregar "DOLOR":

00010203040506070809101112131415dieciséisLORmiMETROyoPAGSSUMETROreOLOR

00010203040506070809101112131415dieciséisLORmiMETROyoPAGSSUMETROreOLOR


Se permiten espacios finales. tal vez r+w+' '?
l4m2

5

Perl 6 , 46 29 bytes

{;*.comb(/.**{1..$_}[\s|$]/)}

Pruébalo en línea!

Solución basada en expresiones regulares que toma la entrada curry, como f(n)(s)y devuelve una lista de líneas. Cada línea, excepto la última, tiene un espacio en blanco al final

Explicación:

{;*                         }   # Anonymous code block that returns a Whatever lambda
   .comb(/                /)    # Split the string by
          .**{1..$_}            # Up to n characters
                    [\s|$]      # Terminated by a whitespace char or the end of the string

4

Vim, 15 bytes / pulsaciones de teclas

DJ:se tw=<C-r>"
gq_

¿Una pregunta de formato de texto? ¡Sé exactamente la herramienta para el trabajo! E incluso tiene mi nombre en las dos primeras pulsaciones: D

<C-r>significa ctrl-r.

Esto podría ser un poco más corto en V , pero prefiero responder en vainilla vim para obtener respuestas que realmente muestren cuán concisa puede ser vim para el desafío correcto. Y la diferencia es muy pequeña de todos modos.

Esto también podría ser lo siguiente para 15 bytes:

:se tw=<C-r><C-w>
ddgq_

Pruébalo en línea!


1
Explicación: DJ:Este programa ha sido realizado por DJ, nuestro gato favorito con un diamante alrededor del cuello. [...]
Erik the Outgolfer

4

R , 36 27 bytes

R tiene esto como un incorporado ( strwrap), devolvemos un vector de líneas divididas.

function(s,n)strwrap(s,n+1)

Pruébalo en línea!


1
Sí, eso debería estar permitido. Se permiten matrices de líneas, así que no veo por qué esto sería diferente.
ATMunn

4

Haskell , 70 bytes

s!n|length s<=n=[s]|(t,_:d)<-splitAt(until((<'!').(s!!))pred n)s=t:d!n


3

Java (JDK) , 46 44 bytes

Básicamente, una solución de expresiones regulares puras en Java, casi seguramente la más corta que he escrito.

¡Saludos a Kevin por ayudar a reducir aún más los bytes en la expresión regular!

n->s->s.replaceAll(".{1,"+n+"}( |$)","$0\n")

Pruébalo en línea!

Usando una lamdba al curry, crea una expresión regular para emparejar con avidez los ncaracteres seguidos de un espacio o un final de cadena. Luego reemplaza esos personajes con ellos mismos seguidos de una nueva línea.


@KevinCruijssen en [ $]realidad solo coincide con un espacio o $si no recuerdo mal, en lugar del final de la cadena. Sin embargo, parece funcionar, por lo que parece que se puede reducir a un solo espacio para incluso menos bytes.
Luke Stevens

Ah, de hecho, puede ser solo un espacio, ya que agrega nuevas líneas y no necesita agregar una nueva línea adicional al final.
Kevin Cruijssen

1
Puede jugar golf 2 bytes más eliminando el paréntesis en la expresión regular y usar en $0lugar de $1.
Kevin Cruijssen

@KevinCruijssen ¡Buena! ¡Es una pena que replaceAllsea ​​tan detallado!
Luke Stevens

2
Para mí está mal, aparece si modifico la frase latina del ejercicio en la forma en que termina con "... dictum varius abc erat". Hay una nueva línea innecesaria después de la letra c ...
RosLuP

2

Mathematica, 16 bytes

InsertLinebreaks

Función incorporada Toma una cadena y un entero como entrada y devuelve una cadena como salida.

InsertLinebreaks["string", n]
 inserta caracteres de nueva línea para que no haya más de n caracteres.


2

Powershell, 40 83 bytes

Caso de prueba con n=80agregado.

param($s,$n)$s-split' '|%{if(($o+$_|% le*)-lt$n){$o+=' '*!!$o+$_}else{$o;$o=$_}}
$o

Script de prueba:

$f = {

param($s,$n)$s-split' '|%{if(($o+$_|% le*)-lt$n){$o+=' '*!!$o+$_}else{$o;$o=$_}}
$o

}

@(
,(50, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.",
"Lorem ipsum dolor sit amet, consectetur adipiscing",
"elit. Sed eget erat lectus. Morbi mi mi, fringilla",
"sed suscipit ullamcorper, tristique at mauris.",
"Morbi non commodo nibh. Pellentesque habitant",
"morbi tristique senectus et netus et malesuada",
"fames ac turpis egestas. Sed at iaculis mauris.",
"Praesent a sem augue. Nulla lectus sapien, auctor",
"nec pharetra eu, tincidunt ac diam. Sed ligula",
"arcu, aliquam quis velit aliquam, dictum varius",
"erat.")
,(80, "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat.",
"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus.",
"Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non",
"commodo nibh. Pellentesque habitant morbi tristique senectus et netus et",
"malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue.",
"Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu,",
"aliquam quis velit aliquam, dictum varius erat.")
) | %{
    $n,$s,$expected = $_
    $result = &$f $s $n
    "$result"-eq"$expected"
    # $result   # uncomment this line to dispaly a result
}

Salida:

True
True


Gracias. El ternario falso es una expresión. Este script contiene un implícito returnen la elseparte y una declaración en la thenparte.
mazzy


2

Japt , 20 bytes

¸rÈ+Yi[X·ÌY]¸Ê>V?R:S

Pruébalo en línea!

Gracias a Bubbler y Shaggy por su ayuda.

Explicación:

¸                       #Split into words
 r                      #For each word, add them to the output in this way:
     i                  # Choose a character using this process:
       X·Ì              #  Get the last line of the output
          Y             #  And the current word
      [    ]¸           #  Join them with a space
             Ê>V?       #  If the resulting line is greater than the allowed length:
                ?R      #   Choose "/n" (newline)
                  :S    #  Otherwise choose " " (space)
     i                  # Add the chosen character to the output
  È+Y                   # Add the current word to the output

24 bytes con [X,Y].join(...).
Bubbler


1

Retina 0.8.2 , 37 bytes

.+$
$*
!`(?=\S.*¶(1)+)(?<-1>.)+(?=\s)

Pruébalo en línea! Toma sy nen líneas separadas. Explicación:

.+$
$*

Convierte na unario.

(?=\S.*¶(1)+)(?<-1>.)+(?=\s)

Haga coincidir espacios que no sean espacios en blanco, luego mire hacia adelante ny cuente como $#1. Luego regrese y use un grupo de equilibrio para hacer coincidir los ncaracteres seguidos de espacios en blanco.

!`

Salida de las coincidencias como una lista de líneas.


¿Hay alguna forma en Retina de poner la primera entrada en una expresión regular que usamos con la segunda entrada? Entonces, algo como esto: .{1,50} y$0¶ , pero ¿dónde 50se recibe como entrada en su lugar?
Kevin Cruijssen

@KevinCruijssen En Retina 1 probablemente puedas usar una etapa Eval para dar un resultado similar, pero eso es aburrido, así que no me molesté.
Neil

1

Carbón de leña , 19 bytes

Nθ←F⪪S «¿‹⁺LιⅈθM→⸿ι

Pruébalo en línea! El enlace es a la versión detallada del código. Toma entrada de ny sen líneas separadas. Explicación:

Nθ

Entrada n.

Mueva el cursor un cuadrado hacia la izquierda para equilibrar el movimiento derecho desde la primera iteración del bucle.

F⪪S «

Divida la cadena en espacios y repita sobre las palabras.

¿‹⁺Lιⅈθ

Calcule si la siguiente palabra llegará al borde derecho.

M→

Si no lo hace, mueva un cuadrado a la derecha.

⸿

Si entonces comenzará una nueva línea.

ι

Salida de la palabra.



1

05AB1E , 18 bytes

õs#vDy«g²›i,}yðJ}?

Pruébalo en línea.

Explicación:

õ                   # Push an empty string "" to the stack
 s                  # Swap to take the (implicit) string input
  #                 # Split it by spaces
   v            }   # For-each `y` over the words:
    D               #  Duplicate the top of the stack
                    #  (which is the empty string in the very first iteration)
     y«             #  Append the current word `y`
       g            #  Get its length
        ²›i }       #  If its lengthy is larger than the second input:
           ,        #   Pop and output the current duplicated value with trailing newline
             yð     #  Push the word `y` and a space " "
               J    #  Join the entire stack together
                 ?  # After the loop, output the last part as well (without newline)

1

Java 8, 135 bytes

n->s->{String r="",S[]=s.split(" "),t=r;for(int i=0;i<S.length;)if((t+S[i]).length()>n){r+=t+"\n";t="";}else t+=S[i++]+" ";return r+t;}

Pruébalo en línea.

Explicación:

n->s->{                      // Method with integer & String parameters and String return
  String r="",               //  Result-String, starting empty
         S[]=s.split(" "),   //  Input-String split by spaces
         t=r;                //  Temp-String, starting empty as well
  for(int i=0;i<S.length;)   //  Loop `i` in the range [0, amount_of_words):
    if((t+S[i]).length()>n){ //   If `t` and the word are larger than the integer input:
      r+=t+"\n";             //    Add `t` and a newline to the result
      t="";}                 //    And reset `t` to an empty String
     else                    //   Else:
       t+=S[i++]+" ";        //    Append the word and a space to `t`
                             //    (and then increase `i` by 1 with `i++` for the next word
                             //     of the next iteration)
  return r+t;}               //  Return the result-String appended with `t` as result


1

APL (Dyalog Unicode) , SBCS de 14 bytes

Función de infijo; argumento izquierdo es n, argumento derecho es n.

CY'dfns'wrap

Pruébalo en línea!

⎕CYc op y en la biblioteca dfns

 luego

wrap[c]  usar la envoltura [n] función

[c]  código de esa función
[n]  notas para esa función


Versión de golf de SBCS dewrap 59 bytes

{⍺≥≢⍵:⍵⋄(t↑⍵),2↓⎕TC,⍺∇⍵↓⍨t+b⊃⍨t←⊃⌽⍺,g/⍨⍺≥g←⍸(⍺+1)↑b' '=⍵}

Pruébalo en línea!

{... } dfn; es argumento izquierdo (ancho), es argumento derecho (cadena)

≢⍵ cuenta (número de caracteres) de cadena

⍺≥... : si el ancho es mayor o igual que eso, entonces:

   devolver la cadena

 de otra manera:

  ' '=⍵ Máscara booleana donde los espacios en blanco son iguales a la cadena

  b← almacenar en b(para b lanks)

  (... )↑ tome el siguiente número de elementos de eso:

   ⍺+1 uno más que el ancho

  y dónde es verdad

  g← almacenar en g(para g aps)

  ⍺≥ Máscara booleana donde el ancho es mayor o igual que

  g/⍨ filtrar los índices de brecha por eso

  ⍺, añadir eso al ancho

  ⊃⌽ elige el último elemento de eso (iluminado, elige el primero de los invertidos)

  t← tienda en t(para t ake)

  b⊃⍨úsalo  para elegir un elemento de la máscara de b lanks

  t+ agregue eso a t

  ⍵↓⍨ soltar tantos caracteres de la cadena

  ⍺∇ recurse a eso con el mismo argumento izquierdo izquierdo

  ⎕TC, append que a la lista de t ERMINAL c ontrol caracteres (8: HT, 10: NL, 13: CR)

  2↓ suelte los dos primeros caracteres de eso (dejando solo un 13: CR principal)

  (), Agregue eso a lo siguiente:

   t↑⍵ los primeros tcaracteres de la cadena



0

JavaScript + HTML + CSS, 117 64 bytes

-53 bytes cortesía de @Neil

n=50
s="Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat."
f=(n,s)=>document.body.innerHTML+=`<tt><p style=width:${n}ch>${s}`
f(n,s)


1
Al menos en mi navegador puedes reducir esto a (n,s)=>document.body.innerHTML+=`<p style=width:${n}ch><tt>${s}</tt></p>` 74 bytes. Si está dispuesto a desenterrar versiones antiguas de Firefox, puede guardar otros 8 bytes con (n,s)=>document.body.innerHTML+=`<pre wrap width=${n}>${s}</pre>` .
Neil

@Neil Buen uso de chunidades. Firefox 65 calcula 50chcomo 500px; Chromium 70 se computa 50chcomo400px
guest271314

Esta respuesta es incorrecta. elit. Sed eget erat lectus. Morbi mi mi, fringilla sed(Segunda línea) tiene más de 50 caracteres. Estoy usando el Chrome más nuevo.
mbomb007

Pude modificar mi sugerencia original para trabajar en Chrome colocando el <p>interior del <tt>.
Neil



0

C # (.NET Core) , 162 bytes

string[]t(string n,int a){var g="";for(int i=0;i++<Math.Floor((double)n.Length/a);)g+=$"^.{{{i*a-1}}}|";return Regex.Split(n,$@"(?n)(?<=({g.Trim('|')})\S*)\s");}}

Esta función utiliza una expresión regular que coincide con el espacio en blanco más cercano que está cerca del enésimo o múltiple del enésimo carácter y divide la cadena en función de él.

Pruébalo en línea!

El enlace TIO es un programa completo, y la función tiene una palabra clave estática, por lo que se puede llamar a la función desde main.

Test Regex


Esto no da el resultado correcto para el caso de prueba: algunas líneas tienen más de 50 caracteres. Desea "antes", no "cerca", y también la división en un punto debe depender de dónde se dividió anteriormente.
Ørjan Johansen

0

C # (compilador interactivo de Visual C #) , 78 bytes

s=>n=>System.Text.RegularExpressions.Regex.Replace(s,".{1,"+n+"}( |$)","$0\n")

Pruébalo en línea!

El crédito va a @LukeStevens por proponer la versión de Java ... Aparentemente .NET te hace importar el RegularExpressionsespacio de nombres para reemplazarlo :(

Aquí está mi versión original que se divide en el carácter espacial y usa LINQ para unirlos nuevamente:

C # (compilador interactivo de Visual C #) , 91 bytes

s=>n=>s.Split(' ').Aggregate((a,w)=>a+(a.Length-a.LastIndexOf('\n')+w.Length>n?'\n':' ')+w)

Pruébalo en línea!



0

APL (NARS), 48 caracteres, 96 bytes

{⊃⍵{⍺≥≢⍵:⊂⍵⋄k←1+⍺-' '⍳⍨⌽r←⍺↑⍵⋄(⊂k↑r),⍺∇k↓⍵}⍨⍺+1}

prueba:

  f←{⊃⍵{⍺≥≢⍵:⊂⍵⋄k←1+⍺-' '⍳⍨⌽r←⍺↑⍵⋄(⊂k↑r),⍺∇k↓⍵}⍨⍺+1}
  s←"Lorem ipsum dolor sit amet, consectetur adipiscing elit. Sed eget erat lectus. Morbi mi mi, fringilla sed suscipit ullamcorper, tristique at mauris. Morbi non commodo nibh. Pellentesque habitant morbi tristique senectus et netus et malesuada fames ac turpis egestas. Sed at iaculis mauris. Praesent a sem augue. Nulla lectus sapien, auctor nec pharetra eu, tincidunt ac diam. Sed ligula arcu, aliquam quis velit aliquam, dictum varius erat."
  50 f s
Lorem ipsum dolor sit amet, consectetur adipiscing 
elit. Sed eget erat lectus. Morbi mi mi, fringilla 
sed suscipit ullamcorper, tristique at mauris.     
Morbi non commodo nibh. Pellentesque habitant      
morbi tristique senectus et netus et malesuada     
fames ac turpis egestas. Sed at iaculis mauris.    
Praesent a sem augue. Nulla lectus sapien, auctor  
nec pharetra eu, tincidunt ac diam. Sed ligula     
arcu, aliquam quis velit aliquam, dictum varius    
erat.                                              

No sé en "{⊃⍵ {⍺≥≢⍵: ⊂⍵⋄ ..." Si es correcto ≥ o está allí> ...
RosLuP

0

C, 63 bytes

b(a,n)char*a;{while(strlen(a)>n){for(a+=n;*a-32;--a);*a++=10;}}

La función de este ejercicio b (a, n) rompería la línea "a" como se dijo en el ejercicio, en la forma en que no cambia su longitud (si vemos el resultado como una cadena) porque cambia algunos espacios en \ n o una nueva línea en lugar. La cadena de entrada "a" no debería tener ningún carácter \ n para la función b () (podría tener \ n en la cadena de entrada para bs ())

La función b (a, n) estaría bien solo porque la restricción de este ejercicio, que impone cada palabra de la cadena "a" tiene una longitud <n si esto no es cierto, esa función puede ir
a un bucle infinito ... (muy mal en mi forma de ver, así que copié también la función más buena porque en ese caso devolvería -1 y no iría a un bucle infinito; es bs (a, n) a continuación) No excluyo que ambas funciones tengan errores ... .

#define R(x,y) if(x)return y
#define U unsigned
U bs(char*a,U n)
{U c,q,r=1,i,j;
 R(!a||n<1||n++>0xFFFF,-1);
 for(j=c=i=0;;++i,++c)
    {R(i==-1,-1);q=a[i];
     if(q==10)goto l;
     if(c>=n){R(i-j>n,-1);a[i=j]=10;l:c=-1;++r;}
     R(!q,r);
     if(q==32)j=i;
    }
}

resultado de b () pasado en una función que agrega longitud de línea a cada línea

Lorem ipsum dolor sit amet, consectetur adipiscing [50]
elit. Sed eget erat lectus. Morbi mi mi, fringilla [50]
sed suscipit ullamcorper, tristique at mauris. [46]
Morbi non commodo nibh. Pellentesque habitant [45]
morbi tristique senectus et netus et malesuada [46]
fames ac turpis egestas. Sed at iaculis mauris. [47]
Praesent a sem augue. Nulla lectus sapien, auctor [49]
nec pharetra eu, tincidunt ac diam. Sed ligula [46]
arcu, aliquam quis velit aliquam, dictum varius [47]
erat. [5]

@ceilingcat ok, el código anterior también consideraría el \ n ... un error que encontré con el código fue que la última línea no se imprimió correctamente ... ¿por qué no escribe su respuesta C como otra? Ganaría en el mío porque es más corto ... por decir lo cierto, uso la primera línea (o la declaración ";") para la verificación de la entrada solo porque para mí la entrada tiene que verificarse incluso si eso es un poco más largo; Intento sin éxito escribir la función en APL ...
RosLuP

@ceilingcat en la última respuesta, visto esa pregunta no decir si la cadena de entrada tiene o no tiene que tener '\ n' char y visto que el ejemplo no tiene '\ n' Supongo que la cadena de entrada no tiene un nuevo carácter de línea ...
RosLuP

Solo 83 ... Sí, tengo que ver si
gano

Solo 81 .... .... ....
RosLuP

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.