您的任务非常简单，计算A190810的第n个元素。

A190810的元素是根据以下规则计算的：

1. 第一个元素是1
2. 顺序在增加
3. 如果x发生的顺序，然后2x+1和3x-1还做

您可以使用基于1的索引或基于0的索引，但是如果您使用基于0的索引，请在回答中说明。

测试用例

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

由于这是代码高尔夫球，因此以字节为单位的最短答案会获胜！

果冻，16 字节

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

非常低效的。在线尝试！

怎么运行的

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字节

您可能想以相反的顺序阅读此答案中的程序...

得益于丹尼斯，速度更慢，更短：

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

在线尝试

它的运行速度不是很快，而是更短（83个字节）。通过在每次迭代中排序和删除重复项，以及删除第一个元素，我无需在列表中使用索引。结果只是n迭代之后的第一个元素。

我可能打败了丹尼斯。：D

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]

在线尝试

下面的这个版本（88个字节）运行得非常快，大约在两秒钟内找到了500000个元素。

很简单 计算列表中的元素，直到元素比多三倍n，因为添加的每个元素最多可以添加2个以上的唯一元素。然后删除重复项，排序并打印nth元素（零索引）。

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]

在线尝试

Python 2，59个字节

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

基于@ mbomb007的Python答案。在Ideone上进行测试。

Haskell，76 73 69字节

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

使用基于0的索引。用法示例：(filter t[1..]!!) 54-> 255。

而不是通过反复将建立名单2x+1，并3x-1在大多数其他的答案看出，我经历的所有整数，并检查他们是否可以降低到1通过重复应用(x-1) / 2或(x+1) / 3如果整除。

哈斯克尔， 77 74字节

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

这a为第n个条目提供了功能。它的索引为零。或者，a=nub$f[1]将创建整个列表（延迟）。

这是Reinhard Zumkeller Set代码的列表变量。

Python 2，88 84字节

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)

在Ideone上进行测试。

Pyth，20个 19字节

hutS{+G,hyhGt*3hGQ0

在线尝试。 测试套件。

使用基于零的索引。

Brachylog，45个字节

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

N = 1000在我的计算机上大约需要6秒钟的时间进行计算。

这是1索引的，例如

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

说明

• 主要谓词：

  :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
  

• 谓词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
         )
  

您可能会注意到，调用时，我们不会将任何输入传递给谓词1 y - Yield。由于约束传播，一旦到达1.将传播正确输入值的子句，它将找到正确的输入。

MATL，19，18 17个字节

1w:"tEQy3*qvSu]G)

这是一个非常低效的算法。对于大于13的输入，在线解释器的内存不足。

感谢路易斯·门多（Luis Mendo），节省了一个字节！

在线尝试！

此版本更长，但效率更高（21字节）

1`tEQy3*qvSutnG3*<]G)

在线尝试

说明：

这样做的逻辑方法是将元素添加到数组中，直到足够长的时间来抓取第i个元素。这就是有效的方式。的golfy（和低效）的方式来做到这一点，是只是增加数组的大小我倍。

首先，我们定义start数组：1。然后，我们交换顶部的两个元素，从而使输入位于顶部。w。现在，我们使用遍历输入:"。所以我时代：

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.

现在，我们有了一个巨大的序列数组。（比计算所需的更多）所以我们停止循环]，并使用G)（1-indexed）从此数组中获取第i个数字

JavaScript（ES6），63个字节

 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)

由于递归，可能很快就放弃了。

视网膜，57

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

在线尝试！

0索引。遵循常用的算法：从当前集中删除最小值，将其称为x，然后将2x+1与3x-1该集合相加并等于输入的次数，然后得出前导数字。视网膜中的“集合”只是一个列表，该列表被反复排序并仅包含唯一元素。高尔夫算法中增加了一些偷偷摸摸的地方，一旦有更多时间，我将进行解释。

非常感谢Martin高尔夫球了大约20个字节！

Clojure，114108字节

#(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)))))

如果这可以打很多/减少很多，但我不感到惊讶，但是set不支持nth确实会伤害我的思路。

在线尝试

带空格的版本：

#(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字节

使用CP-1252编码。

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

说明

$                  # 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

在线尝试少量

非常慢。
使用基于0的索引。

C ++，102字节

[](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;};

此lambda函数需要#include <map>和using std::map。

这map只是键的集合；它们的值将被忽略。我使用map以便从简洁的插入代码中受益：

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

由于的排序顺序map，最小元素被提取k.begin()->first。

其实是27个位元组

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

在线尝试！

该程序使用基于0的索引。这种方法是蛮力的，所以不要指望它可以在在线解释器中用于更大的输入。

说明：

╗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字节）

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

在线演示。请注意，这使用基于零的索引。

这在大多数情况下使用类似的方法：应用转换n时间，然后对第一n项进行排序和提取。为了提高效率，重复数据删除应用于循环内部，而排序则应用于循环外部。

视网膜，48字节

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

在线尝试！

受到nimi答案的启发，我认为我将为Retina尝试另一种方法，利用正则表达式引擎的回溯来确定是否有给定的（一元）数字。事实证明，可以使用27字节的正则表达式确定它，但是使用它要花费更多，但最终仍比生成方法要短。

这是另一种48字节的解决方案：

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

使用一元I / O，我们可以处理42个字节，但是我试图避免这种情况，另一个Retina答案也使用了十进制：

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

Ruby，70个字节

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

说明

->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个字节

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

使用基于零的索引。内存效率非常低。

说明

{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

八度，68字节

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 -n = 133字节+1

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];

取消高尔夫：

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];

如果我想得更多，我可能会做得更好，但这是我几分钟后想到的。我第一次打高尔夫球，所以这很有趣！

感谢@Dada和@TùxCräftîñg（以及一些次要的字节优化），用于-40个字节

JavaScript（ES6），58

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

少打高尔夫球

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
}

测试

关于时间和内存：我的FireFox 64位Alpha使用的元素500000在约20秒内和300MB

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>