Su tarea es bastante simple, calcule el enésimo elemento de A190810 .

Los elementos de A190810 se calculan de acuerdo con estas reglas:

1. El primer elemento es 1
2. La secuencia va en aumento
3. Si xocurre en la secuencia, entonces 2x+1y 3x-1también

Puede usar la indexación basada en 1 o en 0, pero si usa la indexación basada en 0, dígalo en la respuesta.

Casos de prueba

a(1) = 1
a(2) = 2
a(3) = 3
a(4) = 5
a(5) = 7
a(10) = 17
a(20) = 50
a(30) = 95
a(55) = 255

Como se trata de código de golf, ¡la respuesta más corta en bytes gana!

Jalea , 16 bytes

×3’;Ḥ‘$;
1Ç¡ṢQ³ị

Muy ineficiente Pruébalo en línea!

Cómo funciona

1Ç¡ṢQ³ị   Main link. Argument: n (integer)

1         Set the return value to 1.
 Ç¡       Execute the helper link n times.
   Ṣ      Sort the resulting array.
    Q     Unique; deduplicate the sorted array.
     ³ị   Retrieve its n-th element.


×3’;Ḥ‘$;  Helper link. Argument: A (array)

×3        Multiply all elements of A by 3.
  ’       Decrement the resulting products.
      $   Combine the two links to the left into a monadic chain.
    Ḥ     Unhalve; multiply all elements of A by 2.
     ‘    Increment the resulting products.
   ;      Concatenate 3A-1 and 2A+1.
       ;  Concatenate the result with A.

Python 2, 88 83 72 bytes

Es posible que desee leer los programas en esta respuesta en orden inverso ...

Más lento y más corto aún, gracias a Dennis:

L=1,;exec'L+=2*L[0]+1,3*L[0]-1;L=sorted(set(L))[1:];'*input()
print L[0]

Pruébalo en línea

Esto no se ejecuta tan rápido, pero es más corto ( 83 bytes ). Al ordenar y eliminar duplicados en cada iteración, así como al eliminar el primer elemento, elimino la necesidad de un índice en la lista. El resultado es simplemente el primer elemento después de las niteraciones.

Puede que haya superado a Dennis. :RE

L=[1]
n=input()
while n:L+=[2*L[0]+1,3*L[0]-1];n-=1;L=sorted(set(L))[1:]
print L[0]

Pruébalo en línea

Esta versión a continuación ( 88 bytes ) se ejecuta muy rápido, encontrando el elemento 500000 en aproximadamente dos segundos.

Es muy simple Calcule elementos de la lista hasta que haya tres veces más elementos que n, ya que cada elemento agregado puede agregar como máximo 2 elementos únicos más. Luego elimine los duplicados, ordene e imprima el nelemento th (indexado a cero).

L=[1]
i=0
n=input()
while len(L)<3*n:L+=[2*L[i]+1,3*L[i]-1];i+=1
print sorted(set(L))[n]

Pruébalo en línea

Python 2, 59 bytes

t={1}
exec'm=min(t);t=t-{m}|{2*m+1,3*m-1};'*input()
print m

Basado en la respuesta de Python de @ mbomb007 . Pruébalo en Ideone .

Haskell, 76 73 69 bytes

a#b=mod a b<1&&t(div a b)
t x=x<2||(x-1)#2||(x+1)#3
(filter t[1..]!!)

Utiliza un índice basado en 0. Ejemplo de uso: (filter t[1..]!!) 54-> 255.

En lugar de construir la lista insertando repetidamente 2x+1y 3x-1como se ve en la mayoría de las otras respuestas, reviso todos los enteros y compruebo si pueden reducirse 1aplicando repetidamente (x-1) / 2o (x+1) / 3si son divisibles.

Haskell 77 74 bytes

import Data.List
i=insert
f(x:y)=x:f(i(2*x+1)$i(3*x-1)y)
a=(!!)(nub$f[1])

Esto proporciona una función apara la enésima entrada. Es cero indexado. Alternativamente, a=nub$f[1]creará la lista completa (perezosamente).

Es una variante de la lista del Setcódigo de Reinhard Zumkeller .

Python 2, 88 84 bytes

g=lambda k:g(k%2*k/2)|g(k%3/2*-~k/3)if k>1else k
f=lambda n,k=1:n and-~f(n-g(k),k+1)

Pruébalo en Ideone .

Pyth, 20 19 bytes

hutS{+G,hyhGt*3hGQ0

Pruébalo en línea. Banco de pruebas.

Utiliza indexación basada en cero.

Brachylog , 45 bytes

:1-I,?:?*:1ydo:Im.
1.|:1-:1&I(:3*:1-.;I*:1+.)

Calcula N = 1000en aproximadamente 6 segundos en mi máquina.

Esto está indexado en 1, por ejemplo

run_from_file('code.brachylog',1000,Z).
Z = 13961 .

Explicación

• Predicado principal:

  :1-I,               I = Input - 1
       ?:?*           Square the Input
           :1y        Find the first Input*Input valid outputs of predicate 1
              do      Remove duplicates and order
                :Im.  Output is the Ith element
  

• Predicado 1:

  1.                  Input = Output = 1
  |                   Or
  :1-:1&I             I is the output of predicate 1 called with Input - 1 as input
         (            
           :3*:1-.      Output is 3*I-1
         ;            Or
           I*:1+.       Output is 2*I+1
         )
  

Puede notar que no pasamos ninguna entrada al predicado 1 cuando llamamos y - Yield. Debido a la propagación de restricciones, encontrará la entrada correcta una vez que llegue a la 1.cláusula que propagará los valores de entrada correctos.

MATL, 19, 18 17 bytes

1w:"tEQy3*qvSu]G)

Este es un algoritmo extremadamente ineficiente. El intérprete en línea se queda sin memoria para entradas mayores de 13.

¡Un byte guardado, gracias a Luis Mendo!

Pruébalo en línea!

Esta versión es más larga, pero más eficiente (21 bytes)

1`tEQy3*qvSutnG3*<]G)

Pruébalo en línea

Explicación:

La forma lógica de hacerlo es agregar elementos a la matriz hasta que sea lo suficientemente largo como para agarrar el i-ésimo elemento. Así es como funciona el eficiente. La forma golfosa (e ineficiente) de hacerlo es aumentar el tamaño de la matriz i veces.

Así que, primero, se define la matriz de inicio: 1. Luego intercambiamos los dos elementos superiores, de modo que la entrada esté en la parte superior. w. Ahora, recorremos la entrada con :". Entonces yo veces:

t             %Duplicate our starting (or current) array.
 EQ           %Double it and increment
   y          %Push our starting array again
    3*q       %Multiply by 3 and decrement
       v      %Concatenate these two arrays and the starting array
        Su    %Sort them and remove all duplicate elements.

Ahora, tenemos una matriz gigantesca de la secuencia. (Mucho más de lo que se necesita para calcular) Así que dejamos de hacer bucles ]y tomamos el i-ésimo número de esta matriz con G)(indexado 1)

JavaScript (ES6), 63 bytes

 f=(n,a=[1],i=0)=>a[i++]?--n?f(n,a,a[i*2]=a[i*3-2]=1):i:f(n,a,i)

Probablemente se rinde rápidamente debido a la recurrencia.

Retina, 57

^.+
$*¶¶1
¶¶(1(1*))
¶1$1$1¶$2$1$1
O`
}`(¶1+)\1\b
$1
G2`
1

Pruébalo en línea!

0 indexado. Sigue el algoritmo de uso frecuente: elimine el valor mínimo del conjunto actual, llámelo xy agregue 2x+1y 3x-1al conjunto un número de veces igual a la entrada, entonces el número inicial es el resultado. El "conjunto" en Retina es solo una lista que se ordena repetidamente y se hace para que contenga solo elementos únicos. Hay algunos bits furtivos agregados al algoritmo para el golf, que explicaré una vez que haya tenido más tiempo.

¡Muchas gracias a Martin por jugar unos 20 bytes!

Clojure, 114 108 bytes

#(loop[a(sorted-set 1)n 1](let[x(first a)](if(= n %)x(recur(conj(disj a x)(+(* 2 x)1)(-(* 3 x)1))(inc n)))))

No me sorprendería si esto pudiera reducirse / reducirse en gran medida, pero setel hecho de que no sea compatible realmente daña mi tren de pensamiento.

Prueba el en línea

Versión con espacios:

#(loop [a (sorted-set 1)
        n 1]
  (let [x (first a)]
    (if (= n %)
      x
      (recur (conj (disj a x) (+ (* 2 x) 1) (- (* 3 x) 1)) (inc n))
      )))

05AB1E, 18 17 bytes

Utiliza la codificación CP-1252 .

$Fз>s3*<)˜Ù}ï{¹è

Explicación

$                  # initialize with 1
 F          }      # input number of times do
  Ð                # triplicate current list/number
   ·>              # double one copy and add 1
     s3*<          # multiply one copy by 3 and subtract 1
         )˜Ù       # combine the 3 lists to 1 list and remove duplicates
             ï{    # convert list to int and sort
               ¹è  # take the element from the list at index input

Pruébelo en línea para números pequeños

Muy lento.
Utiliza indexación basada en 0.

C ++, 102 bytes

[](int i){int t;map<int,int>k;for(k[1];i--;k.erase(t))t=k.begin()->first,k[t*2+1],k[t*3-1];return t;};

Esta función lambda requiere #include <map>y using std::map.

El mapaquí es solo una colección de llaves; Sus valores son ignorados. Utilizo mappara beneficiarme del código breve para la inserción:

k[1]; // inserts the key 1 into the map

Gracias al orden ordenado de map, el elemento más pequeño es extraído por k.begin()->first.

En realidad, 27 bytes

╗1#╜`;;2*1+)3*1@-#++╔S`n╜@E

Pruébalo en línea!

Este programa utiliza indexación basada en 0. El enfoque es de fuerza bruta, así que no esperes que funcione en el intérprete en línea para entradas más grandes.

Explicación:

╗1#╜`;;2*1+)3*1@-#++╔S`n╜@E
╗                            save input (n) in register 0
 1#                          push [1]
   ╜                         push n
    `;;2*1+)3*1@-#++╔S`n     do the following n times:
     ;;                        make two copies of the list
       2*1+                    apply 2x+1 to each element in one copy
           )3*1@-              and 3x-1 to each element in the other copy
                 #             workaround for a weird list bug
                  ++           append those two lists to the original list
                    ╔S         uniquify and sort
                        ╜@E  get the nth element (0-indexed)

CJam (25 bytes)

ri1a1${{_2*)1$3*(}%_&}*$=

Demo en línea . Tenga en cuenta que esto usa indexación basada en cero.

Esto utiliza un enfoque similar a la mayoría: aplica los ntiempos de transformación y luego ordena y extrae el nelemento th. Como un guiño a la eficiencia, la deduplicación se aplica dentro del ciclo y la clasificación se aplica fuera del ciclo.

Retina , 48 bytes

.+
$*
+1`^(((!*)!(!|\3)(?=\3!1))*!)1|\b
!$1
-2`.

Pruébalo en línea!

Inspirado por la respuesta de nimi, pensé en probar un enfoque diferente para Retina, haciendo uso de la marcha atrás del motor regex para averiguar si algún número (unario) dado está en la secuencia o no. Resulta que esto se puede determinar con una expresión regular de 27 bytes, pero usarlo cuesta unos pocos más, pero aún así es más corto que el enfoque generativo.

Aquí hay una solución alternativa de 48 bytes:

.+
$*
{`1\b
1!
}T`1``1((!*)!(!|\2)(?=!\2$))*!$
!

Y usando E / S unarias podemos hacer 42 bytes, pero estoy tratando de evitar eso y la otra respuesta Retina usa decimal también:

1\b
1!
}T`1``1((!*)!(!|\2)(?=!\2$))*!$
!
1

Ruby, 70 bytes

->n{a=*1
n.times{a<<a.map{|i|([2*i+1,3*i-1]-a).min||1.0/0}.min}
a[-2]}

Explicación

->n{
    # Magical, golfy way of initializing an array. Equivalent to a = [1].
    a=*1
    n.times{
        # Generate the next element in the sequence, by...
        a<<
            # ... finding the minimal term that will appear at some point.
            a.map{|i|
                ([2*i+1,3*i-1]-a).min||1.0/0
            }.min
    }
    # We generated n+1 elements, so we'll take the *second* to last one.
    a[-2]
}

J, 31 bytes

{1(]]/:~@~.@,3&*,&:<:2*>:)^:[~]

Utiliza indexación basada en cero. Muy ineficiente de memoria.

Explicación

{1(]]/:~@~.@,3&*,&:<:2*>:)^:[~]  Input: n
                              ]  Identity function, gets n
 1                               The constant 1
  (                      )^:[~   Repeat n times with an initial array a = [1]
                       >:          Increment each in a
                     2*            Multiply by 2 to get 2a+2
             3&*                   Multiply each in a by 3 to get 3a
                 &:<:              Decrement both x and y to get 2a+1 and 3a-1
                ,                  Join them
    ]                              Identity function, gets a
            ,                      Join a with 2a+1 and 3a-1
         ~.@                       Take the distinct values
     /:~@                          Sort up
   ]                               Return the sorted list
{                                Select the value from the list at index n and return it

Octava, 68 bytes

function r=a(n)s=1;for(i=1:n)r=s(i);s=union(s,[r*2+1 r*3-1]);end;end

Perl, 173 132 bytes +1 para -n = 133

sub c{my$a=pop;return($a==1||($a%2&&c(($a-1)/2))?1:$a%3!=2?0:$a%3==2?c(($a+1)/3):1)}while($#b<$_){$i++;@b=(@b,$i)if c$i}say$b[$_-1];

Sin golf:

my @array = ();
my $n = <>;
sub chk {
    my $a = shift;
    return 1 if ($a == 1);
    if ($a % 2 == 0) {
        if ($a % 3 != 2) {
            return 0;
        } else {
            return chk(($a + 1) / 3);
        }
    } else {
        if (chk(($a - 1) / 2) == 0) {
            if ($a % 3 != 2) {
                return 0;
            } else {
                return chk(($a + 1) / 3);
            }
        } else {
            return 1
        }
    }
}
my $i = 1;
while ($#array < $n-1) {
    push(@array,$i) if (chk($i) == 1);
    $i++;
}
print $array[$n];

Probablemente pueda hacerlo mejor si lo pensara más, pero esto es lo que se me ocurrió después de unos minutos. Mi primera vez jugando al golf, ¡fue muy divertido!

Gracias a @Dada y @ TùxCräftîñg (y un montón de optimizaciones de bytes menores) por -40 bytes

JavaScript (ES6), 58

n=>(a=>{for(;n;)a[++i]?a[i-~i]=a[3*i-1]=--n:0})([i=0,1])|i

Menos golf

n=>{
  a=[];
  a[1] = 1;
  for(i = 0; n;)
  {
    ++i
    if (a[i])
    {
      a[2*i+1] = 1;
      a[3*i-1] = 1;
      --n;
    }
  }
  return i
}

Prueba

Acerca del tiempo y la memoria: elemento 500000 en ~ 20 segundos y 300 MB utilizados por mi FireFox de 64 bits alfa

F=
n=>(a=>{for(;n;)a[++i]?a[i-~i]=a[3*i-1]=--n:0})([i=0,1])|i

function test() {
  var n=+I.value, t0=+new Date
  O.textContent = F(n)
  console.log((+new Date-t0)/1000,'sec')
}  

test()

#I { width:5em}

<input id=I type=number value=10 oninput="test()"> 
<span id=O></span>