Calcular A190810


27

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!


2
Debe agregar casos de prueba más grandes.
mbomb007

77
¿Puedes explicar esto un poco más claramente? Soy un hablante nativo de inglés y no tengo idea de qué "... y si x está en a, entonces 2x + 1 y 3x-1 están en a". se supone que significa.
gato

1
@cat x ϵ A → (2*x) + 1 ϵ Ay x ϵ A → (3*x)-1 ϵ A, donde ϵsignifica "es miembro de" y puede entenderse como "implica".
Steven H.

3
Condición implícita: la secuencia no contiene números no requeridos por las otras reglas. (De lo contrario, $ a (i) = i $ sería una secuencia válida)
Stig Hemmer

1
Y obtienes respuestas gratuitas de Mathematica y Haskell para comenzar desde :)
Deja de dañar a Monica el

Respuestas:


9

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.

1
Puede tener 16 caracteres , pero no conozco ninguna codificación que represente eso en menos de 30 bytes .
rico remer

18
Jelly tiene su propia página de códigos que permite que estos caracteres sean de 1 byte cada uno.

15

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


8

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 .


"Uno no simplemente supera a Dennis" ... Ojalá hubiera pensado en usar literales establecidos. Parece tan obvio ahora. ¿Es esta respuesta aún más rápida que mi programa "rápido" si cambia de ejecutar una cadena a un código real?
mbomb007

No Es mas lento. Las operaciones de set son más caras.
mbomb007

Sí, mines O (n) mientras que la indexación de la lista es O (1) , por lo que esta solución es al menos O (n²) ...
Dennis

8

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.


Eso realmente no define una función o un fragmento de código válido, ¿verdad?
Zeta

@Zeta La última línea se evalúa como una función sin nombre.
Zgarb

@Zgarb, que es un error en un archivo Haskell, y ningún intérprete que conozco admite este tipo de función. Entonces, por favor, ilumíneme, ¿cómo se supone que un usuario debe usar esto sin modificar el código anterior de ninguna manera? ¿O podrías señalarme una meta publicación que permita este tipo de código?
Zeta

2
@Zgarb Creo que para la última línea, asígnelo a un enlace (como f=filter t[1..]!!), porque no creo que esto sea correcto.
TuxCrafting

1
@ TùxCräftîñg En esta publicación Meta , se determinó que las funciones auxiliares adicionales son aceptables por defecto en esta situación. Este es también el formato que generalmente veo para las respuestas de Haskell aquí. Por supuesto, usted como autor del desafío tiene la autoridad final.
Zgarb

7

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 .


¿Por qué no en ylugar de xsguardar dos bytes? Además, creo que puede reducir la última línea a algo como(!!)$nub.f[1]
Michael Klein

@MichaelKlein: Estoy demasiado acostumbrado (x:xs), lo olvidé por completo, gracias.
Zeta

6

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 .


13
Eres un profesional en convertir algo simple en algo ilegible.
mbomb007


5

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.


4

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)


@LuisMendo Gracias por el consejo! ¿Cómo reescribiría esto con un ciclo while en lugar del ciclo for? (Tal vez esa sería una mejor pregunta para la sala de chat de
MATL

Se podría hacer de esta manera: 1`tEQy3*qvuStnG<]G). La condición del bucle es tnG<(salir cuando la matriz ya tiene el tamaño requerido)
Luis Mendo

No estoy seguro de cuánto engaño es, pero en la forversión de bucle puede tomar la entrada en unario como una cadena y eliminar el:
Luis Mendo

4

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.


4

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!


4

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

4

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.


3

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.


1
Ligeramente más corto (97), utilizando sety inicializador listas: [](int i){int t;set<int>k{1};for(;i--;k.erase(t))t=*k.begin(),k.insert({t*2+1,t*3-1});return t;};.
nwn

3

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)

2

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.


2
22: 1ari{(_2*)\3*(@||$}*0=(También mucho más eficiente.)
Martin Ender

2

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

2

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

1
Ese *1truco es bueno
TuxCrafting

1

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

1

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

Puedes quitar la final;end
Luis Mendo

En la versión que uso, al menos (4.0.0) no puedes ...
dcsohl

1

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


1
Creo que puedes soltar los espacios después de mys, the returny the print(No puedo probar, no tengo perl)
TuxCrafting

1
@ TùxCräftîñg tiene razón sobre el return. El printpuede ser reemplazado por a say. La mayoría de los myno son necesarios (sólo se necesita la anterior $aen la función que pienso. No inicialice ni declarar @b. Es probable que pueda dejar caer la inicialización de $isi lo hace $i++en el inicio del tiempo en lugar de al final. popSe más corto que shift. Tenga en cuenta que hay mucho más para jugar al golf que simplemente eliminar espacios en blanco y líneas nuevas ...
Dada

0

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>

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.