Pato Pato Josefo

49

Dado un conjunto entero:

  1. Comience desde el primer número
  2. Salta hacia adelante n posiciones donde n es el valor de la posición actual
  3. Elimine la posición actual, haciendo que la siguiente posición sea la posición actual.
  4. Ir al paso 2 hasta que quede un número
  5. Imprime ese número

Reglas

La matriz se ajusta (el siguiente número después del último número de la matriz es el primer número).

Un cero se elimina a sí mismo (obviamente).

Los números negativos no están permitidos como entrada.

Casos de prueba

[1] => 1
[1,2] => 1
[1,2,3] => 3
[1,2,2] => 1
[1,2,3,4] => 1
[6,2,3,4] => 4
[1,2,3,4,5] => 5
[0,1] => 1
[0,0,2,0,0] => 0

Ejemplo paso a paso

[1,4,2,3,5]
 ^          start from the first position
   ^        jump 1 position (value of the position)
[1,  2,3,5] remove number in that position
     ^      take next position of the removed number (the 'new' 'current' position)
         ^  jump 2 positions
[1,  2,3  ] remove number in that position
 ^          take next position (looping on the end of the array)
     ^      jump 1 position
[1,    3  ] remove number in that position
       ^    take next position (looping)
 ^          jump 3 positions (looping on the end of the array)
[      3  ] remove number in that position
print 3

Ejemplo # 2

[4,3,2,1,6,3]
 ^            start from the first position
         ^    jump 4 positions
[4,3,2,1,  3] remove number in that position    
           ^  take next position
     ^        jump 3 positions
[4,3,  1,  3] remove number in that position    
       ^      take next position
           ^  jump 1 positions
[4,3,  1    ] remove number in that position    
 ^            take next position
   ^          jump 4 positions
[4,    1    ] remove number in that position    
       ^      take next position
 ^            jump 1 position
[      1    ] remove number in that position
print 1

Este es el código de golf , ¡la respuesta más corta en bytes gana!

code-golf  array-manipulation 
— flujo de trabajo
fuente
14
¡Buen primer desafío!
— Luis Mendo
2
@LuisMendo Sí ... los desafíos de "saltar como un ..."
— J42161217
2
@ Jenny_mathy No pensé que hubiera una similar, pero como dijo Luis, la matriz envolvente constituye un desafío interesante para el golf. Creo: /
— workoverflow
3
@EriktheOutgolfer No soy realmente un tonto. Los elementos allí son indistinguibles y el tamaño del paso es fijo. Luis está mucho más cerca, pero creo que todavía es lo suficientemente diferente.
— Martin Ender
3
¿Necesita imprimir realmente el número final o puede devolverlo? ¿Es necesario que devuelva el número, o puede simplemente operar en la matriz en el lugar para que después de que se ejecute la función, la matriz contenga solo el número?
— iamnotmaynard

Respuestas:

9

Casco , 7 bytes

Esto devuelve el resultado como una lista singleton

ΩεSotṙ←

Pruébalo en línea!

Explicación

Ω               Until
 ε              the result is a singleton list
     ṙ          Rotate left by
  S   ←         the first element
   ot           Then remove the first element
— H.PWiz
fuente
7

Haskell , 54 50 48 bytes

f[x]=x
f(x:r)=f$snd<$>zip r(drop(x+1)$cycle$x:r)

Pruébalo en línea!

Explicación:

  • f[x]=x: Si la lista dada es una lista singleton, devuelve su elemento.
  • f(x:r)=f$ ...: De lo contrario, se aplica recursivamente fa la siguiente lista:
    • Los elementos de la lista actual se ciclan infinitamente ( cycle$x:r),
    • con los primeros x+1elementos eliminados ( drop(x+1)$),
    • y truncado a la longitud de r. ( snd<$>zip res una alternativa más corta a take(length r)).

Versión anterior de 54 bytes:

f=(%)=<<head
_%[x]=x
n%(x:r)|n<1=f r|s<-r++[x]=(n-1)%s

Pruébalo en línea!

— Laikoni
fuente
6

MATL , 21 bytes

1`yy)+ynX\[]w(5Mynq]x

Pruébalo en línea! O verificar todos los casos de prueba .

Explicación

1        % Push 1: current position in the array
`        % Do...while
  yy     %   Duplicate top two elements in the stack. Takes input implicitly
         %   in the first iteration.
         %   STACK: array, position, array, position
  )      %   Get specified entry in the array
         %   STACK: array, position, selected entry
  +      %   Add
         %   STACK: array, position (updated)
  y      %   Duplicate from below
         %   STACK: array, position, array
  n      %   Number of elements of array
         %   STACK: array, position, number of elements or array
  X\     %   1-based modulus
         %   STACK: array, position (wrapped around)
  []     %   Push empty array
         %   STACK: array, position, []
  w      %   Swap
         %   STACK: array, [], position
  (      %   Write value into specified entry in array. Writing [] removes
         %   the entry
         %   STACK: array (with one entry removed)
  5M     %   Push latest used position. Because of the removal, this now
         %   points to the entry that was after the removed one
         %   STACK: array, position
  y      %   Duplicate from below
         %   STACK: array, position, array
  n      %   Number of elements of array
         %   STACK: array, position, number of elements of array
  q      %   Subtract 1
         %   STACK: array, position, number of elements of array minus 1
]        % End. If top of the stack is nonzero, proceed with next iteration
         % STACK: array (containing 1 entry), position
x        % Delete. Implicitly display
         % STACK: array (containing 1 entry)
— Luis Mendo
fuente
1
Nota: el uso de rotaciones de lista en lugar de mantener un puntero probablemente hará que esto sea mucho más corto.
— Erik the Outgolfer
1
@ Erik Gracias. Pero ahora que agregué la explicación, creo que lo dejaré así
— Luis Mendo
Bueno, siempre puedes eliminar la explicación, se mantendrá en el historial :)
— Erik the Outgolfer
6

Python 3 , 54 51 bytes

f=lambda x:x and f((x+x*x[0])[x[0]:][1:len(x)])or x

La salida es una lista singleton.

Pruébalo en línea!

— Dennis
fuente
Completamente no relacionado, pero me gusta tu sombrero de unicornio, Dennis. xD (¡Y buena respuesta, por supuesto, como siempre!)
— Kevin Cruijssen
5

CJam , 15 bytes

l~_,({_0=m<1>}*

Pruébalo en línea!

Explicación

En lugar de hacer un seguimiento de un puntero, simplemente cambio la matriz cíclicamente para que el elemento actual esté siempre al frente.

l~     e# Read and evaluate input.
_,(    e# Get its length L and decrement to L-1.
{      e# Run this block L-1 times...
  _0=  e#   Get the first element X.
  m<   e#   Rotate the array left by X positions.
  1>   e#   Discard the first element.
}*
       e# The final element remains on the stack and gets printed implicitly.

Una alternativa divertida que desafortunadamente no guarda ningún byte:

l~_{;m<1>_0=}*;
— Martin Ender
fuente
5

Brain-Flak , 88 bytes

([[]]()){({}<(({})){({}<({}<([]){({}{}<>)<>([])}{}>)<>{({}[<>[]])<>}<>>[()])}{}{}>())}{}

Pruébalo en línea!

Explicación

([[]]())                      Push negative N: the stack height - 1
{({}< … >())}{}               Do N times
     (({}))                     Duplicate M: the top of the stack
     {({}< … >[()])}{}          Do M times 
                                  Rotate the stack by 1:
          ({}< … >)               Pop the top of the stack and put it back down after
          ([]){({}{}<>)<>([])}{}  Pushing the rest of the stack on to the other one, in reverse, with the stack height added to each element (to ensure that all are positive)
          <>{({}[<>[]])<>}<>      Push the rest of the stack back, unreversing, and subtracting the stack height from each element
                      {}        Pop the top of stack
— H.PWiz
fuente
1
Un golf muy extraño pero aquí está en 88 bytes .
— Wheat Wizard
1
@WheatWizard Nice, sorprendentemente intenté algo así antes.
— H.PWiz
¡Nunca puedo saber cómo la gente puede codificar así! ¿hay un traductor de pseudocódigo o algo así?
— workoverflow
1
@workoverflow no, honestamente es más fácil de lo que parece. Fue muy desalentador antes de comenzar, pero cuando los comandos son tan simples, es fácil de aprender.
— H.PWiz
5

Python 2 , 55 bytes

def f(a):
 while a[1:]:l=a[0]%len(a);a[:]=a[-~l:]+a[:l]

Pruébalo en línea!

Salidas como una lista singleton, según lo permitido por defecto . Ahorré algunos bytes gracias a Dennis , recordándome que está permitido modificar el argumento de la función.

Cómo funciona

  • def f(a)- Define una función con un parámetro a.

  • while a[1:]:- Si bien ael primer elemento eliminado es verdadero, ejecuta el bloque de código que sigue. Una lista con un elemento o más es verdadera, y las listas vacías son falsas en Python, por lo tanto, esto se detendrá una vez que aalcance una longitud de 1.

  • l=a[0]%len(a)- Tome el primer elemento y obtenga el resto de su división por la longitud de a. Asignar el resultado a l.

  • a[:]=a[-~l:]+a[:l]- Gire aa la izquierda por lelementos y elimine el primero, mientras asigna esto a su alugar.

Python 2 , 63 bytes

f=lambda a,i=0:a[1:]and f(a,a.pop(((a*-~i)[i]+i)%len(a))+1)or a

Pruébalo en línea!

Aunque más largo, esto parece mucho más elegante. También gracias a ovs por ayudar en el chat.

— Sr. Xcoder
fuente
1
¿No podrías hacer algo como a,*b=input()(python3) y guardar algunos bytes? Sin embargo, no estoy seguro de cómo afectaría eso ly el corte
— Rod
1
@ Rod No lo creo, también necesitaría evaluar la entrada en Python 3
— Sr. Xcoder
4

Jalea , 9 bytes

ṙḷ/ḊµL’$¡

Pruébalo en línea!

-2 bytes gracias al usuario202729

Explicación

ṙḷ/ḊµL’$¡  Main Link
     L’$¡  Repeat <length - 1> times
ṙ          Rotate left by
 ḷ/        The first element (from JHT; thanks to user202729)
   Ḋ       Take all but the first element
— Hiperneutrino
fuente
3

Mathematica, 36 bytes

usa el algoritmo de Martin 

#//.l:{x_,__}:>Rest@RotateLeft[l,x]&

-5 bytes de Misha Lavrov && Martin Ender

Pruébalo en línea!

— J42161217
fuente
1
Puede guardar dos bytes utilizando el patrón para seleccionar el primer elemento #//.{x_,y__}:>Rest@RotateLeft[{x,y},x]&. (Esto se detiene cuando solo hay un elemento porque {a}ya no coincide con el patrón {x_,y__}).
— Misha Lavrov
1
@MishaLavrov no puede probar en este momento, pero probablemente pueda acortarlo aún más al soltar y, llamar a la lista completa ly luego usar en llugar de {x,y}.
— Martin Ender
1
@MartinEnder ¿Quieres decir así #//.l:{x_,__}:>Rest@RotateLeft[l,x]&?
— Misha Lavrov
1
@MishaLavrov sí.
— Martin Ender
3

J , 21 17 bytes

-4 bytes gracias a FrownyFrog

((1<#)}.{.|.])^:_

Pruébalo en línea!

Original:

([:}.{.|.])^:(1<#)^:_

Cómo funciona:

^:_ repita hasta que el resultado deje de cambiar

^:(1<#) si la longitud de la lista es mayor que 1

{.|.] rotar la lista a la izquierda su primer elemento veces

[:}. suelte el primer elemento y tape el tenedor

Pruébalo en línea!

— Galen Ivanov
fuente
@ FrownyFrog Gracias, no probé esto, ¡es mucho mejor!
— Galen Ivanov
3

JavaScript (ES6), 54 60 bytes

Guardado 1 byte gracias a la versión fija @Shaggy
(+6 bytes)

Modifica la matriz de entrada , que se reduce a un singleton.

f=(a,p=0)=>1/a||f(a,p=(p+a[p%(l=a.length)])%l,a.splice(p,1))

Casos de prueba

Mostrar fragmento de código

¿Cómo?

Aplicamos recursivamente el algoritmo descrito en el desafío. Solo la condición de parada 1/apuede parecer un poco extraña. Al aplicar un operador aritmético:

  • Las matrices de más de un elemento están obligadas NaNy 1/NaNtambién son NaNfalsas.
  • Las matrices de exactamente un entero se coaccionan a ese entero, lo que lleva a cualquiera 1/0 = +Infinityo 1/N = positive floatpara N> 0 (ambos verdaderos).
f = (a, p = 0) =>                 // a = input array, p = pointer into this array
  1 / a ||                        // if a is not yet a singleton:
    f(                            //   do a recursive call with:
      a,                          //     a
      p = (                       //     the updated pointer
        p + a[p % (l = a.length)] //
      ) % l,                      //
      a.splice(p, 1)              //     the element at the new position removed
    )                             //   end of recursive call
— Arnauld
fuente
Al ver que splicemodifica la matriz original, podría hacerlo f=(a,p=0)=>1/a||f(a,p=p+a[p]%a.length,a.splice(p,1))por 52 bytes
— Shaggy
parece que no da el resultado correcto para el segundo ejemplo paso a paso, f=(a,p=0)=>1/a?a:f(a,p=(p%a.length+a[p%a.length])%a.length,a.splice(p,1))está bien, pero puede optimizarse
— Nahuel Fouilleul
@NahuelFouilleul Vaya. En algún momento pensé que los paréntesis p+a[p]podrían eliminarse. Lo cual, por supuesto, no es el caso. ¡Gracias por informar esto!
— Arnauld
Vea este consenso , que @Neil me llamó la atención aquí .
— Shaggy
@ Shaggy Oh, ya veo. ¡Gracias! (Perdí tu enlace TIO la primera vez ...)
— Arnauld
3

Java 8, 79 bytes

Esta lambda acepta a Stack<Integer>y devuelve un into Integer.

l->{for(int i=0,s=l.size();s>1;)l.remove(i=(i+l.get(i%s))%s--);return l.pop();}

Pruébalo en línea

Sin golf

l -> {
    for (
        int i = 0, s = l.size()
        ; s > 1
        ;
    )
        l.remove(
            i = (i + l.get(i % s)) % s--
        );
    return l.pop();
}

Expresiones de gratitud

  • -2 bytes gracias a Nahuel Fouilleul
— Jakob
fuente
1
i%=spuede ser eliminado si es l.get(i)cambiado porl.get(i%s)
— Nahuel Fouilleul
2

Pyth , 9 bytes

.WtHt.<Zh

Pruébalo aquí!

Esto genera el resultado como una lista singleton, según lo permitido por defecto .

Cómo funciona

.WtHt.<Zh ~ Full program.

.W        ~ Functional while. It takes three arguments, two functions: A and B
            and a starting value, which in this case is automatically assigned
            to the input. While A(value) is truthy, value is set to B(value).
            Returns the ending value. A's argument is H and B's is Z.
  tH      ~ A (argument H): Remove the first element of H. A singleton list
            turns into [], which is falsy and thus breaks the loop. Otherwise,
            it is truthy and the loops goes on until the list reaches length 1.
     .<Zh ~ B (argument Z): Cyclically rotate Z by Z[0] places, whereas Z[0]
            represents the first element of Z.
    t     ~ And remove the first element.

Nota: Si no desea ver esos corchetes, simplemente agregue ho edelante del código completo.

— Sr. Xcoder
fuente
2

Rápido , 87 bytes

func f(a:inout[Int]){var i=0,c=0;while(c=a.count,c>1).1{i=(i+a[i%c])%c;a.remove(at:i)}}

Regresa como una lista unitaria mediante la modificación de la entrada . Pruébalo en línea!

Explicación

func f(a:inout[Int]){
  var i=0,c=0;            // Set the index i to 0
  while(c=a.count,c>1).1{ // While the length of the list > 0:
    i=(i+a[i%c])%c;       //  Add a[i] to i and loop back using modulo
    a.remove(at:i)        //  Remove a[i]
  }
}
— Herman L
fuente
2

Perl 6 , 46 45 bytes

(-1 byte gracias a Brad Gilbert)

{($_,{(|$_ xx*)[.[0]+(1..^$_)]}...1)[*-1][0]}

Pruébalo en línea!

($_, { ... } ... 1)genera una secuencia de listas, comenzando con la lista de entrada $_, cada elemento sucesivo generado por la expresión de llaves, y terminando cuando la lista coincide de forma inteligente 1--es decir, tiene una longitud de 1. El seguimiento [* - 1]obtiene el elemento final, y el final [0]saca el único elemento de esa lista singleton.

(|$_ xx *)genera una copia plana, infinitamente replicada del elemento actual. Esta lista está indexada con el rango .[0] + (1 ..^ $_)para extraer la siguiente lista finita de la serie.

— Sean
fuente
1
mente soplado oO
— Adrian
[*-1][0]se puede combinar para [*-1;0]guardar un byte. También 1..$_-1está mejor escrito como 1..^$_guardar de nuevo un byte.
— Brad Gilbert b2gills
@ BradGilbertb2gills Lo intenté [*-1;0], pero parece no ser equivalente de alguna manera. La función luego devuelve una lista en lugar de un número.
— Sean
Eso no detiene la 1..^$_optimización
— Brad Gilbert b2gills
1

Perl 5 , 47 43 41 + 2 ( -ap) = 43 bytes

$\=splice@F,($_+=$F[$_%@F])%@F,1while@F}{

Pruébalo en línea!

Toma datos como números separados por espacios.

— Xcali
fuente
parece que no es exactamente lo mismo que el ejemplo paso a paso que sigue, pero es más largo$x%=@F,splice@F,$x=($x+$F[$x])%@F,1while$#F;$_="@F"
— Nahuel Fouilleul
1
wow oO Necesito mejorar mi juego.
— Adrian
1

Java 8 , 325 bytes

Golfizado:

static void n(Integer[]j){Integer[]h;int a=0;h=j;for(int i=0;i<j.length-1;i++){if(h.length==a){a=0;}a=(a+h[a])%h.length;h[a]=null;h=m(h);}System.out.print(h[0]);}static Integer[] m(Integer[]array){Integer[]x=new Integer[array.length-1];int z=0;for(int i=0;i<array.length;i++){if(array[i]!=null){x[z]=array[i];z++;}}return x;}

Sin golf:

 interface ArrayLeapFrog {
static void main(String[] z) throws Exception {
    Integer[] j = {6, 2, 3, 4};
    n(j);
}

static void n(Integer[] j) {
    Integer[] h;
    int a = 0;
    h = j;
    for (int i = 0; i < j.length - 1; i++) {
        if (h.length == a) {
            a = 0;
        }
        a = (a + h[a]) % h.length;
        h[a] = null;
        h = m(h);
    }
    System.out.print(h[0]);
}

static Integer[] m(Integer[] array) {
    Integer[] x = new Integer[array.length - 1];
    int z = 0;
    for (int i = 0; i < array.length; i++) {
        if (array[i] != null) {
            x[z] = array[i];
            z++;
        }
    }
    return x;
  }
}
— Desarrollador en desarrollo
fuente
44
¡Bienvenidos! Un par de consejos: no es necesario contar las staticpalabras clave aquí. Por lo general, las soluciones de métodos múltiples se implementan como miembros no estáticos de una clase y maincrean una instancia para la prueba. Además, si lo hace de esa manera, admite Java 7 y puede enviarlo simplemente como una solución "Java". Para referencia futura, el formato de entrada tiende a ser bastante flexible aquí, por lo que, por ejemplo, puede optar por tomar la entrada como a List(lo cual es bastante útil para este problema).
— Jakob
1

APL + WIN, 36 bytes

¯1↑⍎¨(1⌈¯1+⍴v←,⎕)⍴⊂'v←(1<⍴v)↓v[1]⌽v'

Explicación:

Solicita entrada de pantalla. 

'v←(1<⍴v)↓v[1]⌽v' Loop logic as a string

 (1<⍴v)↓ only drop the first when number of elements n>1

 (1⌈¯1+⍴v←,⎕)⍴⊂ create a nested vector of logic of length 1 max n-1

 ⍎¨ execute each element of the nested vector in turn

¯1↑ take answer from executing final element
— Graham
fuente
1

Python 2, 61 bytes

def f(x):
 while x[1:]:y=x[0]%len(x);x=x[y+1:]+x[:y]
 print x
— Rɪᴋᴇʀ
fuente
1
Sé que existen muchas respuestas de Python, pero pensé que podría agregar las mías.
— Rɪᴋᴇʀ
1

JavaScript, 58 56 59 bytes

let f =

a=>{for(i=0,k=a.length;k>1;)i+=a[i%=k],a.splice(i%=k--,1)}
<h2>Test</h2>
Enter or paste a valid array literal within square brackets and click Run.
<blockquote>
   <input id = "array" type="text" length="20">
   <button type="button" onclick="run()">Run</button>
</blockquote>
Result: <pre id="o"></pre>

<script>
    function run() {
       let a = JSON.parse(array.value);
       f(a);
       o.textContent = a;
    }
</script>
Expandir fragmento

Devuelve el resultado como el único elemento que queda en la matriz de entrada que se actualiza en su lugar.

¡Dos bytes guardados usando una declaración separada por comas en lugar de una declaración de bloque en el cuerpo del bucle for! Tres bytes perdidos para saltar de un elemento eliminado al final de la matriz (:

Menos golfizado:

a => {
    for(i=0,k=a.length;k>1;) // once less than array length
        i+=a[i%=k],          // the new index
        a.splice(            // delete an element
           i%=k--,           // ensuring index is within array,
                             // and post decrement loop count
           1
        )
}
— traktor53
fuente
Esto parece dar la respuesta incorrecta para [3, 5, 7, 9].
— Neil
Mal por [3,5,7,9]. Valor esperado 5
— edc65
La función no devuelve el valor, no estoy seguro de si el recuento de bytes es adecuado teniendo esto en cuenta, ya que no puede funcionar por sí solo ...
— Brian H.
@ edc65 y Neil, gracias: el índice de un elemento eliminado al final de la matriz no se estaba ajustando al inicio de la matriz acortada.
— traktor53
@BrianH. la función modifica su parámetro, hay consenso sobre ese codegolf.meta.stackexchange.com/a/4942/21348
— edc65
1

Brain-Flak , 104 bytes

H.PWiz tiene una respuesta más corta aquí que ayudé a hacer, deberías verificarla.

([[]]()){({}()<(({})){({}[()]<({}<(([])<{{}({}<>)<>([])}{}<>>)<>>)<>{({}[()]<({}<>)<>>)}{}<>>)}{}{}>)}{}

Pruébalo en línea!

Explicación

([[]]())   #Push 1 minus stackheight
{({}()<    #N times
 (({}))    #Get a copy of the top
 {({}[()]< #N times
  ({}<(([])<{{}({}<>)<>([])}{}<>>)<>>)<>{({}[()]<({}<>)<>>)}{}<>
           #Roll the top to the bottom (From the wiki)
 >)}{}     #End loop
 {}        #Remove one value
>)}{}      #End loop
— Asistente de trigo
fuente
Pensé que competiría . Entonces me di cuenta de que el mío era casi exactamente el mismo que el tuyo , aparte de un "top roll" diferente
— H.PWiz
Vi eso ;). Usar el hecho de que todo no es negativo es bastante inteligente.
— Wheat Wizard
1

R , 111 117 126 bytes

Gracias a @Giuseppe por jugar 11 bytes al cambiar a un ciclo while, obtuve otros 4 al eliminar la función y leer la entrada del usuario directamente.

No me siento bien con lo que se necesitó para llegar allí; estoy seguro de que existe una solución más elegante.

i=scan();m=1;while((l=sum(i|1))-1){j=i[m];p=`if`(j+m>l,j%%l+!m-1,j+m);p=`if`(!p,m,p);i=i[-p];m=`if`(p-l,p,1)};i

Pruébalo en línea!

Código sin golf

i=scan()
m=1
while((l=sum(i|1))-1){
  j=i[m]
  p=`if`(j+m>l,j%%l+!m-1,j+m)
  p=`if`(!p,m,p)
  i=i[-p]
  m=`if`(p-l,p,1)
}
i
— marca
fuente
117 bytes - tenga en cuenta que, dado que esta es una función recursiva, el nombre f=debe incluirse
— Giuseppe
1
Encontré este desafío bastante difícil con un lenguaje de índice basado en 1 sin rotaciones de matriz; Esto es potencialmente 1-3 bytes más corto con un whilebucle, creo.
— Giuseppe
— Giuseppe
mi anterior byter 115 no era válido ya que ambos olvidamos la f=parte de la función recursiva. :(
— Giuseppe
Actualicé el puntaje anterior y el nuevo puntaje para reflejar la recursividad :) Con el ciclo 'while', obtuve otros 4 bytes usando el escaneo.
— Mark
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.