Un OEIS tras otro

94

A partir del 13/03/2018 16:45 UTC, el ganador es la respuesta # 345 , de Scrooble . Esto significa que el concurso ha terminado oficialmente, pero siéntase libre de seguir publicando respuestas, siempre y cuando sigan las reglas.

Además, solo un rápido saludo a los tres principales respondedores en términos de números de respuestas:

1. NieDzejkob - 41 respuestas

2. KSmarts - 30 respuestas

3. Hyper Neutrino - 26 respuestas


Esta es una pregunta de encadenamiento de respuestas que utiliza secuencias de OEIS y la duración de la presentación anterior.

Esta pregunta de encadenamiento de respuestas funcionará de la siguiente manera:

  • Publicaré la primera respuesta. Todas las demás soluciones deben provenir de eso.
  • El siguiente usuario (llamémosles usuario A) encontrará la secuencia OEIS en la que su número de índice (ver más abajo) es el mismo que la longitud de mi código.
  • Usando la secuencia, deben codificar, en un lenguaje no utilizado , un programa que toma un número entero como entrada, n, y genera el enésimo número en esa secuencia.
  • Luego, publican su solución después de la mía, y un nuevo usuario (usuarioB) debe repetir lo mismo.

El ntérmino th de una secuencia es el término n veces después del primero, trabajando con el primer valor como el primer valor dado en su página OEIS. En esta pregunta, utilizaremos la indexación 0 para estas secuencias. Por ejemplo, con A000242 y n = 3, el resultado correcto sería 25 .

¡Sin embargo!

Este no es un , por lo que el código más corto no importa. Pero la longitud de su código todavía tiene un impacto. Para evitar la duplicación de secuencias, su bytecount debe ser único . Esto significa que ningún otro programa enviado aquí puede tener la misma longitud en bytes que el suyo.

Si no hay una secuencia para la duración de la última publicación, entonces la secuencia de su publicación es la secuencia más baja no utilizada. Esto significa que las secuencias utilizadas también tienen que ser únicas, y que la secuencia no puede ser la misma que su bytecount.

Después de que se haya publicado una respuesta y no se hayan publicado nuevas respuestas durante más de una semana, la respuesta anterior a la última publicada (la que no rompió la cadena) ganará.

Entrada y salida

Se aplican reglas genéricas de entrada y salida. La entrada debe ser un entero o una representación de cadena de un entero y la salida debe ser el valor correcto en la secuencia.

Formateo

Como con la mayoría de las respuestas, formatee su respuesta de esta manera

# N. language, length, [sequence](link)

`code`

[next sequence](link)

*anything else*

Reglas

  • Debe esperar al menos 1 hora antes de publicar una respuesta, después de haber publicado.
  • No puede publicar dos veces (o más) seguidas.
  • El número índice de una secuencia es el número después de la Aparte, y con los ceros iniciales eliminados (por ejemplo, para A000040el número índice es 40)
  • Puede suponer que ni la entrada ni la salida requerida estarán fuera del rango numérico de sus idiomas, pero no abuse de esto eligiendo un idioma que solo pueda usar el número 1, por ejemplo.
  • Si la longitud de su envío es superior a 65536 caracteres, proporcione un enlace a una forma de acceder al código (por ejemplo, pastebin).
  • n nunca será mayor que 1000, o estará fuera de los límites de la secuencia, simplemente para evitar que las discrepancias de precisión impidan que un idioma compita.
  • Cada 150 respuestas (válidas), aumenta el número de veces que se puede usar un idioma. Entonces, después de haber publicado 150 soluciones, cada idioma se puede usar dos veces (con todas las respuestas anteriores contando para esto). Por ejemplo, cuando se han publicado 150 respuestas, Python 3 se puede usar dos veces, pero debido al hecho de que ya se ha usado una vez, esto significa que solo se puede usar una vez más hasta que se hayan publicado 300 respuestas.
  • Sea útil y publique un enlace a la siguiente secuencia que se utilizará. Esto no es obligatorio, pero es una recomendación.
  • Las diferentes versiones de lenguajes, por ejemplo, Python 2 y Python 3 son idiomas diferentes . Como regla general, si las diferentes versiones están disponibles en Try It Online, son diferentes idiomas, pero tenga en cuenta que esta es una regla general y no una respuesta rígida.
  • No está prohibido, pero intente no copiar el código de la página OEIS e intente resolverlo.
  • La codificación dura solo se permite si la secuencia es finita. Tenga en cuenta que la respuesta que provocó esto ( # 40 ) es la excepción a la regla. Algunas respuestas al principio del código rígido de la cadena, pero se pueden ignorar, ya que no es bueno eliminar la cadena hasta, digamos, # 100.

Fragmento de cadena de respuesta

caird coinheringaahing
fuente
Los comentarios no son para discusión extendida; Esta conversación se ha movido al chat .
Dennis
¿Está bien si un programa necesitaría una mejor precisión de punto flotante para el tipo incorporado float/ doublea fin de producir valores para mayor n?
NieDzejkob
1
@Giuseppe No, ya que estás generando los números haciendo los cálculos, en lugar de solo colocarlos en una matriz / cadena
caird coinheringaahing
2
@cairdcoinheringaahing En mi opinión, eso es difícil de codificar la constante gamma. No funciona "en teoría" para números más grandes.
user202729
66
Sala de chat
usuario202729

Respuestas:

4

345. brainfuck , 162 bytes, A000301

+<<,[>>[>]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[>+>+<<-]>>[<<+>>-]<[<]<-]>>[>]+<[-]++<[>[>>+>+<<<-]>>>[<<<+>>>-]<<[>[>+>+<<-]>>[<<+>>-]<<<-]>[-]>[<<+>>-]<<<<-]>>too golfy.

Pruébalo en línea!

Siguiente secuencia!

Esto toma como entrada el carácter con el punto de código n(según las especificaciones de BF) y sale de la misma manera. Para ver los números, sugiero usar @ Timwi EsotericIDE .

Explicación:

+<<,                                  Initialize the tape with the first two Fibonacci numbers. Take loop counter from input.
[                                     n times:
  >>[>]                                 Move to the end of the tape. 
  <<[>>+>+<<<-]>>>[<<<+>>>-]            Add fib(n-2)...
  <<[>+>+<<-]>>[<<+>>-]                 and fib(n-1). Store on the end of the tape.
  <[<]<-                                Move back to start of tape. Update loop counter.
]                                     End loop.
>>[>]+<[-]++<                         Delete the extra Fibonacci number and prepare for exponentiation. 
[                                     fib(n) times:
  >[>>+>+<<<-]>>>[<<<+>>>-]<<           Copy the base (2) to preserve it.
  [>[>+>+<<-]>>[<<+>>-]<<<-]            Multiply what started as a 1 by the base.
  >[-]>[<<+>>-]<<<<-                    Clean up and update loop counter.
]                                     End loop.
>>too golfy.                          Add some bytes, for all sequences <162 had been used. Print result. 

Dado que esto almacena todos los números de Fibonacci hasta el importante, fallará para una entrada REALMENTE grande en una cinta acotada.

Esto podría acortarse significativamente al codificar la base (2), pero el golf no es un problema en absoluto.

Khuldraeseth na'Barya
fuente
Como la siguiente respuesta (# 346) rompió la cadena, ¡su respuesta es la ganadora!
caird coinheringaahing
1
@cairdcoinheringaahing Gracias por este increíble desafío. Me entristece que deba terminar ahora, pero como hacen todas las cosas buenas del mundo, terminó. Ahora para jugar al golf esta pobre excusa para el código, ya que ahora es la primera respuesta que cualquiera verá, y debe ser impresionantemente corta ...
Khuldraeseth na'Barya
@Scrooble realmente no puedes cambiar la longitud ...
NieDzejkob
@NieDzejkob Sí, pero puedo jugar al golf y agregar más relleno, para mantener la misma longitud.
Khuldraeseth na'Barya
@cairdcoinheringaahing "rompió la cadena"? Qué significa eso?
Urna mágica del pulpo
40

22. FiM ++ , 982 bytes, A000024

Nota : si está leyendo esto, es posible que desee ordenar por "más antiguo".

Dear PPCG: I solved A000024!

I learned how to party to get a number using the number x and the number y.
Did you know that the number beers was x?
For every number chug from 1 to y,
  beers became beers times x!
That's what I did.
Then you get beers!
That's all about how to party.

Today I learned how to do math to get a number using the number n.
Did you know that the number answer was 0?
For every number x from 1 to n,
  For every number y from 1 to n,
    Did you know that the number tmp1 was how to party using x and 2?
    Did you know that the number tmp2 was how to party using y and 2?
    Did you know that the number max was how to party using 2 and n?
    tmp2 became tmp2 times 10!
    tmp1 became tmp1 plus tmp2!
    If tmp1 is more than max then: answer got one more.
  That's what I did.
That's what I did.
Then you get answer!
That's all about how to do math.

Your faithful student, BlackCap.

PS:  This is the best answer
PPS: This really is the best answer

Siguiente secuencia

Alondra
fuente
10
Jajaja, se rió tanto de todo el asunto. +1 para elegir el idioma :-)
ETHproductions
Increíble, toma mi
voto a favor
22

1. Triangular , 10 bytes, A000217

$\:_%i/2*<

Pruébalo en línea!

Secuencia siguiente

Cómo funciona

El código se formatea en este triángulo

   $
  \ :
 _ % i
/ 2 * <

con la IP comenzando en $y moviéndose hacia el sudeste (SE, heh), funciona así:

$            Take a numerical input (n);     STACK = [n]
 :           Duplicate it;                   STACK = [n, n]
  i          Increment the ToS;              STACK = [n, n+1]
   <         Set IP to W;                    STACK = [n, n+1]
    *        Multiply ToS and 2ndTos;        STACK = [n(n+1)]
     2       Push 2;                         STACK = [n(n+1), 2]
      /      Set IP to NE;                   STACK = [n(n+1), 2]
       _     Divide ToS by 2ndToS;           STACK = [n(n+1)/2]
        \    Set IP to SE (heh);             STACK = [n(n+1)/2]
         %   Output ToS as number;           STACK = [n(n+1)/2]
          *  Multiply ToS by 2ndToS (no op); STACK = [n(n+1)/2]
caird coinheringaahing
fuente
13
1. Triangular, 10 bytes, A000217. * sigue el enlace * A000217 Triangular numbers...
MD XF
22

73. Starry , 363 bytes, A000252

, +      + *     '.     `
 + + + +  *  *  *  +     
 +`      +*       +    ` 
 + +   +  + +   + *  '   
   +   '  ####`  + +   + 
 + +    ####  +*   +    *
    '  #####  +      + ' 
  `    ######+  + +   +  
+ +   + #########   * '  
 +   +  + #####+ +      +
*  +      + * +  *  *   +
   +  *  + + + +  *  *   
+   +  +   *   + `  + +  
 +  + +   + *'    +    +.

Pruébalo en línea!

Siguiente secuencia

Utiliza la fórmula " a(n) = n^4 * product p^(-3)(p^2 - 1)*(p - 1)donde el producto está sobre todos los números primos p que dividen n" de OEIS.

La luna es un no-op, pero bueno, esto no es código golf.

No un arbol
fuente
estrellas en la luna? hmmm
betseg el
19

97. Python 3 (PyPy) , 1772 bytes, A000236

En primer lugar, muchas gracias al Dr. Max Alekseyev por ser paciente conmigo. Soy muy afortunado de haber podido contactarlo por correo electrónico para comprender este desafío. Su respuesta Math.SE aquí me ayudó mucho. Gracias a Wheat Wizard por ayudarme también. :)

plist = []

def primes(maximal = -1): # Semi-efficient prime number generator with caching up to a certain max.
	index = plist and plist[-1] or 2
	for prime in plist:
		if prime <= maximal or maximal == -1: yield prime
		else: break
	while index <= maximal or maximal == -1:
		composite = False
		for prime in plist:
			if index % prime == 0:
				composite = True
				break
		if not composite:
			yield index
			plist.append(index)
		index += 1

def modinv(num, mod): # Multiplicative inverse with a modulus
	index = 1
	while num * index % mod != 1: index += 1
	return index

def moddiv(num, dnm, mod):
	return num * modinv(dnm, mod) % mod

def isPowerResidue(num, exp, mod):
	for base in range(mod):
		if pow(base, exp, mod) == num:
			return base
	return False

def compute(power, prime):
	for num in range(2, prime):
		if isPowerResidue(moddiv(num - 1, num, prime), power, prime):
			return num - 1
	return -1

# file = open('output.txt', 'w')

def output(string):
	print(string)
	# file.write(str(string) + '\n')

def compPrimes(power, count):
	maximum = 0
	index = 0
	for prime in getValidPrimes(power, count):
		result = compute(power, prime)
		if result > maximum: maximum = result
		index += 1
		# output('Computed %d / %d = %d%% [result = %d, prime = %d]' % (index, count, (100 * index) // count, result, prime))
	return maximum

def isValidPrime(power, prime):
	return (prime - 1) % power == 0

def getValidPrimes(power, count):
	collected = []
	for prime in primes():
		if isValidPrime(power, prime):
			collected.append(prime)
		if len(collected) >= count:
			return collected
		# output('Collected %d / %d = %d%% [%d]' % (len(collected), count, (100 * len(collected)) // count, prime))

power = int(input()) + 2

output(compPrimes(power, 100))

# file.close()

Pruébalo en línea!

Si da el resultado incorrecto, simplemente aumente el 100 a algo más grande. Creo que 10000 funcionará para 4 pero dejaré mi computadora funcionando durante la noche para confirmarlo; Puede tardar un par de horas en terminar.

Tenga en cuenta que la parte (PyPy) es solo para que pueda usar Python nuevamente. Realmente no conozco muchos otros idiomas y no voy a intentar portar esto a Java y arriesgarme a no terminar a tiempo.

Siguiente secuencia (también, por favor, no hagas más cosas locas de matemáticas; no me quedan versiones de Python, así que alguien más tendrá que salvar este desafío D :)

Hiperneutrino
fuente
bueno, siempre hay pypy3
solo ASCII el
15

107. TrumpScript , 1589 bytes, A000047

My cat hears everything really well
because with me every cat is a safe cat
Everybody knows that one is 1000001 minus 1000000
but only most of you that two is, one plus one;
As always nothing is, one minus one;
My dog is one year old.
I promise you that as long as you vote on me, nothing will be less cool than a cat;:
Much dog is, dog times two;
Dead cat is, cat minus one;!
I will make dog feel good, food for dog plus one;
Roads can be made using different things. Asphalt is one of them.
As long as Hillary jailed, I love asphalt less than my dog;:
Roads are, always made using asphalt plus one of other things;
I promise my roadways are, two times asphalt than you want;
My roadways are great, always roadways plus one;
Vladimir is nothing more than my friend.
Name of Putin is Vladimir.
As long as, Putin eat less roadways;:
China is nothing interesting.
We all know people speaking Chinese are from China.
As long as, Chinese makes less roads;:
I will make economy, for Putin - Chinese will love me;
If it will mean, economy is asphalt in Russia?;:
I will make cat feel good, cat plus one dollar on food;
Make Vladimir roadways to help Russia economy.
Never make china roads!
I show you how great China is, China plus one; You can add numbers to China.
Like Chinese is, China times China makes sense;
Like Chinese is, two times Chinese letter;!
Make Vladimir happy, Vladimir plus one million dollars;
I also show you how great Putin is, Vladimir times Vladimir; You can do number stuff to Putin too!
I will make asphalt roads a lot!
Everybody say cat. You did it? America is great.

Pruébalo en línea!

Programando por primera vez en TrumpScript, es posible que haya reinventado la rueda varias veces: 4 líneas están dedicadas a calcular 2 ^ n. Traté de hacer que pareciera algo que (borracho) Trump pudiera decir. Como beneficio adicional, aquí hay un script de Python que escribí para verificar que estoy haciendo todo bien. Hay algunas diferencias con el programa anterior, pero gran parte es directamente equivalente.

cat = int(input())
dog = 2 ** cat + 1
asphalt = 1
cat = 0
while asphalt < dog:
    roads = asphalt + 1
    roadways = 2 * asphalt + 1
    vladimir = 0
    putin = vladimir
    while putin < roadways:
        china = 0
        chinese = china
        while chinese < roads:
            chair = putin - chinese
            if chair == asphalt:
                cat += 1
                vladimir = roadways
                china = roads
            china += 1
            chinese = 2 * china * china
        vladimir += 1
        putin = vladimir * vladimir
    asphalt = roads
print(cat)

Siguiente secuencia!

NieDzejkob
fuente
3
I will make cat feel goodO_O
Business Cat
Lamentablemente I will make Business Cat feel goodno funcionará ...
NieDzejkob
14

30. Python 1 , 1112 bytes, A000046

def rotations(array):
	rotations = []
	for divider_index in range(len(array)):
		rotations.append(array[divider_index:] + array[:divider_index])
	return rotations

def next(array):
	for index in range(len(array) - 1, -1, -1):
		array[index] = 1 - array[index]
		if array[index]: break
	return array

def reverse(array):
	reversed = []
	for index in range(len(array) - 1, -1, -1):
		reversed.append(array[index])
	return reversed

def primitive(array):
	for index in range(1, len(array)):
		if array == array[:index] * (len(array) / index): return 1
	return 0

def necklaces(size):
	previous_necklaces = []
	array = [0] * size
	necklaces = 0
	for iteration in range(2 ** size):
		if not primitive(array) and array not in previous_necklaces:
			necklaces = necklaces + 1
			for rotation in rotations(array):
				complement = []
				for element in rotation:
					complement.append(1 - element)
				previous_necklaces.append(rotation)
				previous_necklaces.append(complement)
				previous_necklaces.append(reverse(rotation))
				previous_necklaces.append(reverse(complement))
		array = next(array)
	return necklaces

Pruébalo en línea!

Ni siquiera voy a molestarme en jugar golf. ¡Hola, no es mi respuesta Python más larga en este sitio!

Siguiente secuencia

Hiperneutrino
fuente
1
Felicidades por decodificar las matemáticas: D
Leaky Nun
2
313 bytes, lol
Leaky Nun
@LeakyNun Como decía, no me molesté en jugar golf esta jajaja. Además, no es mi respuesta más larga de Python en este sitio, así que idc: P pero agradable
HyperNeutrino
@LeakyNun Y gracias: D Me tomó un tiempo entenderlo todo lol
HyperNeutrino
@LeakyNun 309 bytes porque el valor real de _es irrelevante; solo necesitamos repetir eso muchas veces
HyperNeutrino
13

2. Haskell, 44 bytes, A000010

f k|n<-k+1=length.filter(==1)$gcd n<$>[1..n]

Pruébalo en línea!

Secuencia siguiente

Alondra
fuente
12
Sin embargo, el nombre de la siguiente secuencia ...
totalmente humano
@totallyhuman pobres conejos ...
Erik the Outgolfer
¿Deberíamos vincularnos a la publicación anterior?
Leaky Nun
Me duele que no pueda jugar golf ahora. Tenía que ser el primero que veas
BlackCap
¿Cuál es la siguiente secuencia? No entiendo los tres: P
Beta Decay
13

9. Pyth , 19 bytes, A000025

?>Q0sm@_B1-edld./Q1

Banco de pruebas .

Siguiente secuencia

a (n) = número de particiones de n con rango par menos número con rango impar. El rango de una partición es su parte más grande menos el número de partes.

Monja permeable
fuente
Para aquellos que conocen Pyth, usé deliberadamente en >Q0lugar de Q, ya sabes, tener la siguiente secuencia para ser A000019.
Leaky Nun
1
Desde la página OEISKeywords: easy,nice
BlackCap
@LeakyNun Sí, ya que de lo contrario tendría que resolver A000017 ... asqueroso.
Erik the Outgolfer
12

8. Mathematica (10.1), 25 bytes, A000070

Tr@PartitionsP@Range@#+1&

Siguiente secuencia

LegionMammal978
fuente
La secuencia perfecta para usar Mathematica.
Leaky Nun
1
A000025 es increíblemente difícil. En su lugar, debe agregar un byte para obtener A000026. : P
MD XF
12

206. Protón , 3275 bytes, A000109

# This took me quite a while to write; if it's wrong, please tell me and I'll try to fix it without changing the byte count..

permutations = x => {
	if len(x) == 0 return [ ]
	if len(x) == 1 return [x]
	result = []
	for index : range(len(x)) {
		for permutation : permutations(x[to index] + x[index + 1 to]) {
			result.append([x[index]] + permutation)
		}
	}
	return result
}

adjacency = cycles => {
	cycles = cycles[to]
	size = cycles.pop()
	matrix = [[0] * size for i : range(size)]
	for cycle : cycles {
		i, j, k = cycle[0], cycle[1], cycle[2]
		matrix[i][j] = matrix[i][k] = matrix[j][i] = matrix[j][k] = matrix[k][i] = matrix[k][j] = 1
	}
	return matrix
}

transform = a => [[a[j][i] for j : range(len(a[i]))] for i : range(len(a))]

isomorphic = (a, b) => {
	return any(sorted(b) == sorted(transform(A)) for A : permutations(transform(a)))
}

intersection = (a, b) => [x for x : a if x in b]

union = (a, b) => [x for x : a if x not in b] + list(b)

validate = graph => {
	matrix = adjacency(graph)
	rowsums = map(sum, matrix)
	r = 0
	for s : rowsums if s + 1 < graph[-1] r++
	return 2 || r
}

graphs = nodes => {
	if nodes <= 2 return []
	if nodes == 3 return [[(0, 1, 2), 3]]
	result = []
	existing = []
	for graph : graphs(nodes - 1) {
		graph = graph[to]
		next = graph.pop()
		for index : range(len(graph)) {
			g = graph[to]
			cycle = g.pop(index)
			n = g + [(cycle[0], cycle[1], next), (cycle[1], cycle[2], next), (cycle[2], cycle[0], next), next + 1]
			N = sorted(adjacency(n))
			if N not in existing {
				existing += [sorted(transform(a)) for a : permutations(transform(adjacency(n)))]
				result.append(n)
			}
			for secondary : index .. len(graph) - 1 {
				g = graph[to]
				c1 = g.pop(index)
				c2 = g.pop(secondary)
				q = union(c1, c2)
				g = [k for k : g if len(intersection(k, intersection(c1, c2))) <= 1]
				if len(intersection(c1, c2)) == 2 {
					for i : range(3) {
						for j : i + 1 .. 4 {
							if len(intersection(q[i, j], intersection(c1, c2))) <= 1 {
								g.append((q[i], q[j], next))
							}
						}
					}
				}
				g.append(next + 1)
				N = sorted(adjacency(g))
				if N not in existing {
					existing += [sorted(transform(a)) for a : permutations(transform(adjacency(g)))]
					result.append(g)
				}
				for tertiary : secondary .. len(graph) - 2 {
					g = graph[to]
					c1 = g.pop(index)
					c2 = g.pop(secondary)
					c3 = g.pop(tertiary)
					q = union(union(c1, c2), c3)
					g = [k for k : g if len(intersection(k, intersection(c1, c2))) <= 1 and len(intersection(k, intersection(c2, c3))) <= 1]
					if len(q) == 5 and len(intersection((q1 = intersection(c1, c2)), (q2 = intersection(c2, c3)))) <= 1 and len(q1) == 2 and len(q2) == 2 {
						for i : range(4) {
							for j : i + 1 .. 5 {
								if len(intersection(q[i, j], q1)) <= 1 and len(intersection(q[i, j], q2)) <= 1 {
									g.append((q[i], q[j], next))
								}
							}
						}
						g.append(next + 1)
						N = sorted(adjacency(g))
						if N not in existing {
							existing += [sorted(transform(a)) for a : permutations(transform(adjacency(g)))]
							result.append(g)
						}
					}
				}
			}
		}
	}
	return [k for k : result if max(sum(k[to -1], tuple([]))) + 1 == k[-1] and validate(k)]
}

x = graphs(int(input()) + 3)
print(len(x))

Pruébalo en línea!

Secuencia siguiente

Hiperneutrino
fuente
Espera, ¿realmente lo hiciste? Si no escribes un artículo con estos programas y vas a hablar con algún profesor, estás pasando por alto algo genial: P
Stephen
@Stephen Actualmente corrección de errores lol
HyperNeutrino
¿Es este el enfoque de dividir triángulos, cuadrados y pentágonos según plantri? Parece que podría ser, pero parte de la sintaxis no es familiar.
Peter Taylor
1
@PeterTaylor Suponiendo que entiendo el enfoque que está describiendo, sí, busca triángulos y coloca un vértice adyacente a los 3 vértices, o dos ciclos adyacentes y elimina el borde común y coloca un vértice adyacente a los 4, lo mismo para 3 triángulos en un pentágono Creo que es uno que estás describiendo.
HyperNeutrino
1
@ChristianSievers math.stackexchange.com/a/2463430/457091
HyperNeutrino
12

308. ENIAC (simulador) , 3025 bytes, A006060

Pseudocódigo:

repeat{
    M←input
    N←-M
    A←1
    B←253
    while(N<0){
        C←60
        C←C-A
        repeat(194){
            C←C+B
        }
        A←B
        B←C
        N←N+1
    }
    output←A
}

Sin simulador en línea, resultado de ejecución: Entrada de lector de tarjeta Salida de tarjeta perforada

Registros y constantes:

A: 1-2
B: 3-4
C: 5-6
M: 7
N: 8

input: const. A
253: const. J
60: const. K
194: Master programmer decade limit 1B

Programa de flujo de señal y flujo de datos: Programa de flujo de señal y diagrama de flujo de datos

"Código" completo en pastebin o en comentarios HTML en el marcado de esta respuesta, para evitar linkrot y una respuesta bastante larga para desplazarse al mismo tiempo. ¡Esto es divertido!

Siguiente secuencia

leo3065
fuente
¿Podría agregar un enlace a la siguiente secuencia por favor
Zacharý
@ Zacharý El enlace está en la publicación. Lo moveré al final de la publicación para que sea más fácil de encontrar.
leo3065
12

15. CJam, 85 bytes, A000060

{ee\f{\~\0a*@+f*}:.+}:C;2,qi:Q,2f+{_ee1>{~2*\,:!X*X<a*~}%{CX<}*W=+}fX_0a*1$_C.- .+Q)=

Demostración en línea

Siguiente secuencia

Disección

OEIS da

Gf: S (x) + S (x ^ 2) -S (x) ^ 2, donde S (x) es la función generadora para A000151. - Pab Ter, 12 oct 2005

dónde

S(X)=Xyo11(1-Xyo)2s(yo)=Xyo1(1+Xyo+X2yo+...)2s(yo)
{           e# Define a block to convolve two sequences (multiply two polynomials)
  ee\f{     e#   Index one and use the other as an extra parameter for a map
    \~\0a*  e#     Stack manipulations; create a sequence of `index` 0s
    @+f*    e#     Shift the extra parameter poly and multiply by the coefficient
  }
  :.+       e#   Fold pointwise add to sum the polys
}:C;        e# Assign the block to C (for "convolve")
2,          e# Initial values of S: S(0) = 0, S(1) = 1
qi:Q        e# Read integer and assign it to Q
,2f+{       e# For X = 2 to Q+1
  _ee1>     e#   Duplicate accumulator of S, index, and ditch 0th term
  {         e#   Map (over notional variable i)
    ~2*\    e#     Double S(i) and flip i to top of stack
    ,:!     e#     Create an array with a 1 and i-1 0s
    X*X<    e#     Replicate X times and truncate to X values
            e#     This gives g.f. 1/(1-x^i) to the first X terms
    a*~     e#     Create 2S(i) copies of this polynomial
  }%
  {CX<}*    e#   Fold convolution and truncation to X terms
  W=+       e#   Append the final coefficient, which is S(X), to the accumulator
}fX
_0a*        e# Pad a copy to get S(X^2)
1$_C        e# Convolve two copies to get S(X)^2
.-          e# Pointwise subtraction
 .+         e# Pointwise addition. Note the leading space because the parser thinks
            e# -. is an invalid number
Q)=         e# Take the term at index Q+1 (where the +1 adjusts for OEIS offset)
Peter Taylor
fuente
1 minuto y 33 segundos por delante de mí ... mientras escribía la explicación
Leaky Nun
11

67. LOLCODE , 837 bytes, A000043

HAI 1.2
  CAN HAS STDIO?

  I HAS A CONT ITZ 0
  I HAS A ITRZ ITZ 1
  I HAS A NUMBAH
  GIMMEH NUMBAH
  NUMBAH R SUM OF NUMBAH AN 1

  IM IN YR GF
    ITRZ R SUM OF ITRZ AN 1

    I HAS A PROD ITZ 1
    IM IN YR MOM UPPIN YR ASS WILE DIFFRINT ITRZ AN SMALLR OF ITRZ AN ASS
      PROD R PRODUKT OF PROD AN 2
    IM OUTTA YR MOM
    PROD R DIFF OF PROD AN 1

    I HAS A PRAIME ITZ WIN
    I HAS A VAR ITZ 1
    IM IN YR MOM
      VAR R SUM OF VAR AN 1
      BOTH SAEM VAR AN PROD, O RLY?
        YA RLY, GTFO
      OIC
      BOTH SAEM 0 AN MOD OF PROD AN VAR, O RLY?
        YA RLY
          PRAIME R FAIL
          GTFO
      OIC
    IM OUTTA YR MOM

    BOTH SAEM PRAIME AN WIN, O RLY?
      YA RLY, CONT R SUM OF CONT AN 1
    OIC

    BOTH SAEM NUMBAH AN CONT, O RLY?
      YA RLY, GTFO
    OIC
  IM OUTTA YR GF

  VISIBLE ITRZ
KTHXBYE

Mi llave de mayúsculas está destinada a escapar, así que escribí todo esto mientras mantenía shift ...

Pruébalo en línea!

Siguiente secuencia

Alondra
fuente
+1 por usarPRAIME
Leaky Nun
3
Eres un programador, que podría haber escrito esto y luego ejecutarlo a través de un script en Python que upper'd que -.-
Stephen
55
@StepHen O simplemente gggUGen vim donde lo escribí, pero no soy tan inteligente
BlackCap
10

10. Magma, 65 bytes, A000019

f:=function(n);return NumberOfPrimitiveGroups(n+1);end function;

Pruébalo aquí

jajaja incorporado

Siguiente secuencia

Hiperneutrino
fuente
@ETHproductions :) no hay problema, gracias a la página de OEIS aunque porque tiene exactamente el mismo lol
HyperNeutrino
44
; _; Resolví A000064 y lo cambiaste. Voto negativo
Leaky Nun
Dios mío, tantas secuencias de partición
ETHproductions
Accidentalmente resolví A007317 al intentar hacer esto en Python ( TIO ): P
ETHproductions
¡Votado de nuevo! \ o /
Leaky Nun
9

121. Pip , 525 bytes, A000022

n:(a+1)//2
t:[[0]RL(3*a+3)PE1]
Fh,n{
  m:([0]RL(3*a+3))
  Fi,(a+1){
    Fj,(a+1){
      Fk,(a+1)m@(i+j+k)+:(t@h@i)*(t@h@j)*(t@h@k)
      m@(i+2*j)+:3*(t@h@i)*(t@h@j)
    }
    m@(3*i)+:2*(t@h@i)
  }
  t:(tAE(m//6PE1))
}
k:t@n
o:0
Fh,aFi,aFj,aI(h+i+j<a)o+:(k@h)*(k@i)*(k@j)*k@(a-1-h-i-j)
Fh,((a+1)//2){
  Fi,aI(2*h+i<a){o+:6*(k@h)*(k@i)*(k@(a-1-2*h-i))}
  I(a%2=1)o+:3*(k@h)*(k@((a-1-2*h)//2))
}
Fh,((a+2)//3)o+:8*(k@h)*(k@(a-1-3*h))
I(a%4=1)o+:6*k@(a//4)
o//:24
Ia(o+:t@n@a)
Fh,nFj,(a+1)o-:(t@(h+1)@j-t@h@j)*(t@(h+1)@(a-j))
o

Demostración en línea

Siguiente secuencia

Dato curioso: cuando se publicó el desafío por primera vez, elaboré una lista de pequeños números de secuencia desagradables a los que quería apuntar con CJam, y A000022 estaba en la parte superior de la lista.

Esto implementa la función de generación descrita en EM Rains y NJA Sloane, On Cayley's Enumeration of Alkanes (or 4-Valent Trees) , Journal of Integer Sequences, vol. 2 (1999), tomando la suma de tantos términos como sea necesario para que se fije el coeficiente th y luego telescópicamente tres cuartos de la suma. En particular, la primera mitad telescópica significa que el índice del ciclo solo debe aplicarse a uno de ellos, y no a todos.CknS4Th

El código se descompone como

; Calculate the relevant T_h
t:[[0]RL(3*a+3)PE1]
Fh,n{
  m:([0]RL(3*a+3))
  Fi,(a+1){
    Fj,(a+1){
      Fk,(a+1)m@(i+j+k)+:(t@h@i)*(t@h@j)*(t@h@k)
      m@(i+2*j)+:3*(t@h@i)*(t@h@j)
    }
    m@(3*i)+:2*(t@h@i)
  }
  t:(tAE(m//6PE1))
}

; Calculate the cycle index of S_4 applied to the last one
k:t@n
o:0
Fh,aFi,aFj,aI(h+i+j<a)o+:(k@h)*(k@i)*(k@j)*k@(a-1-h-i-j)
Fh,((a+1)//2){
  Fi,aI(2*h+i<a){o+:6*(k@h)*(k@i)*(k@(a-1-2*h-i))}
  I(a%2=1)o+:3*(k@h)*(k@((a-1-2*h)//2))
}
Fh,((a+2)//3)o+:8*(k@h)*(k@(a-1-3*h))
I(a%4=1)o+:6*k@(a//4)
o//:24

; Handle the remaining convolution,
; pulling out the special case which involves T_{-2}
Ia(o+:t@n@a)
Fh,nFj,(a+1)o-:(t@(h+1)@j-t@h@j)*(t@(h+1)@(a-j))

Tenga en cuenta que este es mi primer programa Pip, por lo que probablemente no sea muy idiomático.

Peter Taylor
fuente
Los comentarios no son para discusión extendida; Esta conversación se ha movido al chat .
Dennis
9

156. C # (Mono), 2466 bytes, A000083

Nota: la puntuación es 2439 bytes para el código y 27 para el indicador del compilador -reference:System.Numerics.

using Num = System.Numerics.BigInteger;
namespace PPCG
{
    class A000083
    {
        static void Main(string[] a)
        {
            int N = int.Parse(a[0]) + 1;

            var phi = new int[N + 1];
            for (int i = 1; i <= N; i++)
                phi[i] = 1;
            for (int p = 2; p <= N; p++)
            {
                if (phi[p] > 1) continue;
                for (int i = p; i <= N; i += p)
                    phi[i] *= p - 1;
                int pa = p * p;
                while (pa <= N)
                {
                    for (int i = pa; i <= N; i += pa)
                        phi[i] *= p;
                    pa *= p;
                }
            }

            var aik = new Num[N + 1, N + 1];
            var a035350 = new Num[N + 1];
            var a035349 = new Num[N + 1];
            aik[0, 0] = aik[1, 1] = a035350[0] = a035350[1] = a035349[0] = a035349[1] = 1;
            for (int n = 2; n <= N; n++)
            {
                // A000237 = EULER(A035350)
                Num nbn = 0;
                for (int k = 1; k < n; k++)
                    for (int d = 1; d <= k; d++)
                        if (k % d == 0) nbn += d * a035350[d] * aik[1, n - k];
                aik[1, n] = nbn / (n - 1);

                // Powers of A000237 are used a lot
                for (int k = 2; k <= N; k++)
                    for (int i = 0; i <= n; i++)
                        aik[k, n] += aik[k - 1, i] * aik[1, n - i];

                // A035350 = BIK(A000237)
                Num bn = 0;
                for (int k = 1; k <= n; k++)
                {
                    bn += aik[k, n];
                    if (k % 2 == 1)
                        for (int i = n & 1; i <= n; i += 2)
                            bn += aik[1, i] * aik[k / 2, (n - i) / 2];
                    else if (n % 2 == 0)
                        bn += aik[k / 2, n / 2];
                }
                a035350[n] = bn / 2;

                // A035349 = DIK(A000237)
                Num dn = 0;
                for (int k = 1; k <= n; k++)
                {
                    // DIK_k is Polyà enumeration with the cyclic group D_k
                    // The cycle index for D_k has two parts: C_k and what Bower calls CPAL_k
                    // C_k
                    Num cikk = 0;
                    for (int d = 1; d <= k; d++)
                        if (k % d == 0 && n % d == 0)
                            cikk += phi[d] * aik[k / d, n / d];
                    dn += cikk / k;

                    // CPAL_k
                    if (k % 2 == 1)
                        for (int i = 0; i <= n; i += 2)
                            dn += aik[1, n - i] * aik[k / 2, i / 2];
                    else
                    {
                        Num cpalk = 0;
                        for (int i = 0; i <= n; i += 2)
                            cpalk += aik[2, n - i] * aik[k / 2 - 1, i / 2];
                        if (n % 2 == 0)
                            cpalk += aik[k / 2, n / 2];
                        dn += cpalk / 2;
                    }
                }
                a035349[n] = dn / 2;
            }

            // A000083 = A000237 + A035350 - A000237 * A035349
            var a000083 = new Num[N + 1];
            for (int i = 0; i <= N; i++)
            {
                a000083[i] = aik[1, i] + a035349[i];
                for (int j = 0; j <= i; j++) a000083[i] -= aik[1, j] * a035350[i - j];
            }

            System.Console.WriteLine(a000083[N - 1]);
        }
    }
}

Demo en línea . Este es un programa completo que toma información de la línea de comando.

Siguiente secuencia

Disección

Sigo el comentario de Bowen en OEIS de que la función generadora A000083(x) = A000237(x) + A035349(x) - A000237(x) * A035350(x)donde las funciones generadoras de componentes están relacionadas se transforma como

  • A000237(x) = x EULER(A035350(x))
  • A035350(x) = BIK(A000237(x))
  • A035349(x) = DIK(A000237(x))

Utilizo las definiciones de BIKy DIKdesde https://oeis.org/transforms2.html, pero las fórmulas parecen tener varios errores tipográficos. Lo corregí LPALsin mucha dificultad e independientemente obtuve una fórmula DIKbasada en la aplicación de la enumeración de Pólya al índice del ciclo del grupo diédrico . Entre el 121 y el 156 estoy aprendiendo mucho sobre la enumeración de Pólya. He enviado algunas erratas , que pueden resultar útiles para otras personas si estas transformaciones vuelven a aparecer en la cadena.

Peter Taylor
fuente
8

13. VB.NET (.NET 4.5), 1246 bytes, A000131

Public Class A000131
    Public Shared Function Catalan(n As Long) As Long
        Dim ans As Decimal = 1
        For k As Integer = 2 To n
            ans *= (n + k) / k
        Next
        Return ans
    End Function
    Shared Function Answer(n As Long) As Long

        n += 7

        Dim a As Long = Catalan(n - 2)

        Dim b As Long = Catalan(n / 2 - 1)
        If n Mod 2 = 0 Then
            b = Catalan(n / 2 - 1)
        Else
            b = 0
        End If

        Dim c As Long = Catalan(n \ 2 - 1) ' integer division (floor)

        Dim d As Long
        If n Mod 3 = 0 Then
            d = Catalan(n / 3 - 1)
        Else
            d = 0
        End If

        Dim e As Long = Catalan(n / 4 - 1)
        If n Mod 4 = 0 Then
            e = Catalan(n / 4 - 1)
        Else
            e = 0
        End If

        Dim f As Long = Catalan(n / 6 - 1)
        If n Mod 6 = 0 Then
            f = Catalan(n / 6 - 1)
        Else
            f = 0
        End If

        Return (
                    a -
                    (n / 2) * b -
                    n * c -
                    (n / 3) * d +
                    n * e +
                    n * f
                ) /
                (2 * n)
    End Function
End Class

A001246

Pruébalo en línea!

Brian J
fuente
8

91. Python 2 (PyPy) , 1733 bytes, A000066

import itertools

girth = int(input()) + 3

v = 4

r = range

def p(v):
	a = [0 for i in r(v)]
	k = int((v * 2) ** .5)
	a[k - 1] = a[k - 2] = a[k - 3] = 1
	j = len(a) - 1
	for i in r(1, 3):
		a[j] = 1
		j -= i
	yield [x for x in a]
	while not all(a):
		for index in r(len(a) - 1, -1, -1):
			a[index] ^= 1
			if a[index]: break
		yield [x for x in a]

def wrap_(p, v):
	m = [[0 for j in r(v)] for i in r(v)]
	k = 0
	for i in r(0, v - 1):
		for j in r(i + 1, v):
			m[i][j] = m[j][i] = p[k]
			k += 1
	return m

def completes_cycle(edgelist):
	if not edgelist or not edgelist[1:]: return False
	start = edgelist[0]
	edge = edgelist[0]
	e = [x for x in edgelist]
	edgelist = edgelist[1:]
	while edgelist:
		_edges = [_edge for _edge in edgelist if _edge[0] in edge or _edge[1] in edge]
		if _edges:
			edgelist.remove(_edges[0])
			if _edges[0][1] in edge: _edges[0] = (_edges[0][1], _edges[0][0])
			edge = _edges[0]
		else:
			return False
	flat = sum(e, ())
	for i in flat:
		if flat.count(i) != 2: return False
	return edge[1] in start

def powerset(a):
	return sum([list(itertools.combinations(a, t)) for t in r(len(a))], [])

while True:
	ps = (v * (v - 1)) // 2
	skip = False
	for Q in p(ps):
		m = wrap_(Q, v)
		output = [row + [0] for row in m]
		output.append([0 for i in r(len(m[0]))])
		for i in r(len(m)):
			output[i][-1] = sum(m[i])
			output[-1][i] = sum(row[i] for row in m)
		if all(map(lambda x: x == 3, map(sum, m))):
			edges = []
			for i in r(v):
				for j in r(i, v):
					if m[i][j]: edges.append((i, j))
			for edgegroup in powerset(edges):
				if completes_cycle(list(edgegroup)):
					if len(edgegroup) == girth:
						print(v)
						exit(0)
					else:
						skip = True
						break
		if skip: break
	v += 1

Pruébalo en línea!

Espero que usar Python 2 PyPy cuente como otra versión principal. Si alguien pudiera conseguirme un intérprete de Python 0, también podría usarlo, pero espero que sea válido.

Esto comienza en 1 vértice y funciona hacia arriba, creando la representación de matriz de adyacencia de cada gráfico posible no dirigido con tantos vértices. Si es trivalente, mirará a través del conjunto de potencia de los bordes, que se ordenarán por longitud. Si el primer ciclo que encuentra es demasiado corto, continuará. Si el primer ciclo que encuentra coincide con la entrada (desplazamiento por 3), entonces generará el conteo de vértices correcto y terminará.

Siguiente secuencia <- tenga una fácil como un descanso de todas estas tonterías matemáticas: D

EDITAR : agregué algunas optimizaciones para hacerlo un poco más rápido (aunque todavía no puedo calcular el tercer término dentro del límite de 60 segundos de TIO) sin cambiar el conteo de bytes.

Hiperneutrino
fuente
... y estaba pensando seriamente que la cadena terminaría con la respuesta 90
pppery
1
@ppperry :) Me gusta hacer desafíos difíciles porque la mayoría de las personas ni siquiera pueden hacer una solución, así que no tengo que preocuparme por quedar fuera del campo :) (por ejemplo, el problema de la cadena de carbono)
HyperNeutrino
A menos que alguien tome su solución y la convierta a un lenguaje
terser
@ppperry that too o_O: P
HyperNeutrino
1
@HyperNeutrino ¡Felicidades por resolver eso! Me preocupaba haber roto la cadena y estaba considerando rellenar el conteo de bytes para señalar una secuencia diferente. ¡Buen trabajo!
Scott Milner
8

232. Funky , 326 330 332 bytes, A000938

function gcd (a, b) {
    while (b != 0) {
        c = a % b;
        a = b;
        b = c;
    };
    return a;
}

function A000938 (n) {
    n = n + 2;
    ans = 0;
    for (m = 2; m <= n; ++m) {
        for (k = 2; k <= n; ++k) {
            ans = ans + (((n - k) + 1) * ((n - m) + 1) * gcd(k - 1, m - 1));
        }
    }
    ans = (2 * ans) - (
        (n*n) *
        ((n*n)-1) / 6
    );
    return ans;
}

Pruébalo en línea!

Políglota con Javascript. Pruébalo en línea!

Secuencia siguiente .


Use la fórmula en la página OEIS para la O(n^2 log n)complejidad, en lugar de la ingenua O(n^6).

Explicación rápida:

  • Este código usa la fórmula a[n_] := 2*Sum[(n - k + 1)*(n - m + 1)*GCD[k - 1, m - 1], {m, 2, n}, {k, 2, n}] - n^2*((n^2 - 1)/6)descrita en la sección de código de Mathematica.
  • Prueba de fórmula:

    • La fórmula es equivalente a esto .

    • Deje que el tamaño del cuadro delimitador de tres puntos sea m * k. Considere 2 casos:

      • k != 0y m != 0: hay 2 formas de elegir la orientación de los tres puntos ( \o /), gcd(k-1, m-1)-1formas de elegir el punto que se encuentra entre los otros 2 puntos y (n - k) × (n - m)formas de elegir la posición del cuadro delimitador.
      • k == 0o m == 0: Hay 2 formas de elegir la orientación ( |o -), nformas de elegir la fila / columna en la que se encuentran los puntos y Binomial[n, 3] == (n*(n-1)*(n-2)) / 6formas de elegir los puntos en esa fila / columna.

Algunas notas políglotas:

  • Funky realmente no tiene palabra clave return. Sin embargo, como ATaco explicó , [Funky] piensa que returnes una variable. Entonces analiza esa expresión, que convenientemente no hace nada, luego analiza la siguiente expresión. Y esto se usa como salida.
  • Javascript se usa ^como bitor xor, a diferencia de Funky, que se usa ^como exponenciación. Por n*nlo tanto, debe usarse en lugar de n^2garantizar la compatibilidad de Javascript.
  • En Original, todos los operadores ( +, -, *, etc.) tienen la misma precedencia y asociativo por la derecha, por lo que necesitan ser adecuadamente entre paréntesis expresiones.
usuario202729
fuente
1
+1 no esperaba un políglota.
ATaco
No hay Pentagony, pero Hexagony encaja bien.
NieDzejkob
Este bytecount ya se usó ... enlace
NieDzejkob
Entonces, para solucionar el problema de bytecount, ¿podría rellenar esta respuesta a 330 bytes? Yo me encargaré del resto.
NieDzejkob
[La respuesta se completó a 332 bytes debido a problemas conflictivos de recuento, vea este mensaje de chat ]
user202729
8

11. Pari / GP, 64 bytes, A000065

{a(n) = if( n<0, 0, polcoeff ( 1 / eta(x + x*O(x^n) ), n) - 1)};

Pruébalo en línea!

Siguiente secuencia

MD XF
fuente
¿Es esa entrada válida?
Leaky Nun
¿Didya tiene que obtener 64 bytes? : P
totalmente humano
@totallyhuman sí:;_; I solved A000064 and you changed it. Downvoted.
Stephen
@totallyhuman se compromete jajaja. ver chat
HyperNeutrino
Dang
Sr. Xcoder
8

281. Java 5, 11628 bytes, A000947

// package oeis_challenge;

import java.util.*;
import java.lang.*;

class Main {

//  static void assert(boolean cond) {
//      if (!cond)
//          throw new Error("Assertion failed!");
//  }

    /* Use the formula a(n) = A000063(n + 2) - A000936(n).
    It's unfair that I use the formula of "number of free polyenoid with n
    nodes and symmetry point group C_{2v}" (formula listed in A000063)
    without understanding why it's true...
    */

    static int catalan(int x) {
        int ans = 1;
        for (int i = 1; i <= x; ++i)
            ans = ans * (2*x+1-i) / i;
        return ans / -~x;
    }

    static int A63(int n) {
        int ans = catalan(n/2 - 1);
        if (n%4 == 0) ans -= catalan(n/4 - 1);
        if (n%6 == 0) ans -= catalan(n/6 - 1);
        return ans;
    }

    static class Point implements Comparable<Point> {
        final int x, y;
        Point(int _x, int _y) {
            x = _x; y = _y;
        }

        /// @return true if this is a point, false otherwise (this is a vector)
        public boolean isPoint() {
            return (x + y) % 3 != 0;
        }

        /// Translate this point by a vector.
        public Point add(Point p) {
            assert(this.isPoint() && ! p.isPoint());
            return new Point(x + p.x, y + p.y);
        }

        /// Reflect this point along x-axis.
        public Point reflectX() {
            return new Point(x - y, -y);
        }

        /// Rotate this point 60 degrees counter-clockwise.
        public Point rot60() {
            return new Point(x - y, x);
        }

        @Override
        public boolean equals(Object o) {
            if (!(o instanceof Point)) return false;
            Point p = (Point) o;
            return x == p.x && y == p.y;
        }

        @Override
        public int hashCode() {
            return 21521 * (3491 + x) + y;
        }

        public String toString() {
            // return String.format("(%d, %d)", x, y);
            return String.format("setxy %d %d", x * 50 - y * 25, y * 40);
        }

        public int compareTo(Point p) {
            int a = Integer.valueOf(x).compareTo(p.x);
            if (a != 0) return a;
            return Integer.valueOf(y).compareTo(p.y);
        }

        /// Helper class.
        static interface Predicate {
            abstract boolean test(Point p);
        }

        static abstract class UnaryFunction {
            abstract Point apply(Point p);
        }

    }

    static class Edge implements Comparable<Edge> {
        final Point a, b; // guarantee a < b
        Edge(Point x, Point y) {
            assert x != y;
            if (x.compareTo(y) > 0) { // y < x
                a = y; b = x;
            } else {
                a = x; b = y;
            }
        }

        public int compareTo(Edge e) {
            int x = a.compareTo(e.a);
            if (x != 0) return x;
            return b.compareTo(e.b);
        }
    }

    /// A graph consists of multiple {@code Point}s.
    static class Graph {
        private HashMap<Point, Point> points;

        public Graph() {
            points = new HashMap<Point, Point>();
        }

        public Graph(Graph g) {
            points = new HashMap<Point, Point>(g.points);
        }

        public void add(Point p, Point root) {
            assert(p.isPoint());
            assert(root.isPoint());
            assert(p == root || points.containsKey(root));
            points.put(p, root);
        }

        public Graph map(Point.UnaryFunction fn) {
            Graph result = new Graph();
            for (Map.Entry<Point, Point> pq : points.entrySet()) {
                Point p = pq.getKey(), q = pq.getValue();
                assert(p.isPoint()) : p;
                assert(q.isPoint()) : q;
                p = fn.apply(p); assert(p.isPoint()) : p;
                q = fn.apply(q); assert(q.isPoint()) : q;
                result.points.put(p, q);
            }
            return result;
        }

        public Graph reflectX() {
            return this.map(new Point.UnaryFunction() {
                public Point apply(Point p) {
                    return p.reflectX();
                }
            });
        }

        public Graph rot60() {
            return this.map(new Point.UnaryFunction() {
                public Point apply(Point p) {
                    return p.rot60();
                }
            });
        }

        @Override
        public boolean equals(Object o) {
            if (o == null) return false;
            if (o.getClass() != getClass()) return false;
            Graph g = (Graph) o;
            return points.equals(g.points);
        }

        @Override
        public int hashCode() {
            return points.hashCode();
        }

        Graph[] expand(Point.Predicate fn) {
            List<Graph> result = new ArrayList<Graph>();

            for (Point p : points.keySet()) {
                int[] deltaX = new int[] { -1, 0, 1, 1,  0, -1};
                int[] deltaY = new int[] {  0, 1, 1, 0, -1, -1};
                for (int i = 6; i --> 0;) {
                    Point p1 = new Point(p.x + deltaX[i], p.y + deltaY[i]);
                    if (points.containsKey(p1) || !fn.test(p1)
                        || !p1.isPoint()) continue;

                    Graph g = new Graph(this);
                    g.add(p1, p);
                    result.add(g);
                }
            }

            return result.toArray(new Graph[0]);
        }

        public static Graph[] expand(Graph[] graphs, Point.Predicate fn) {
            Set<Graph> result = new HashSet<Graph>();

            for (Graph g0 : graphs) {
                Graph[] g = g0.expand(fn);
                for (Graph g1 : g) {
                    if (result.contains(g1)) continue;
                    result.add(g1);
                }
            }

            return result.toArray(new Graph[0]);
        }

        private Edge[] edges() {
            List<Edge> result = new ArrayList<Edge>();
            for (Map.Entry<Point, Point> pq : points.entrySet()) {
                Point p = pq.getKey(), q = pq.getValue();
                if (p.equals(q)) continue;
                result.add(new Edge(p, q));
            }
            return result.toArray(new Edge[0]);
        }

        /**
         * Check if two graphs are isomorphic... under translation.
         * @return {@code true} if {@code this} is isomorphic
         * under translation, {@code false} otherwise.
         */
        public boolean isomorphic(Graph g) {
            if (points.size() != g.points.size()) return false;
            Edge[] a = this.edges();
            Edge[] b = g.edges();
            Arrays.sort(a);
            Arrays.sort(b);

            // for (Edge e : b)
                // System.err.println(e.a + " - " + e.b);
            // System.err.println("------- >><< ");

            assert (a.length > 0);
            assert (a.length == b.length);
            int a_bx = a[0].a.x - b[0].a.x, a_by = a[0].a.y - b[0].a.y;
            for (int i = 0; i < a.length; ++i) {
                if (a_bx != a[i].a.x - b[i].a.x || 
                    a_by != a[i].a.y - b[i].a.y) return false;
                if (a_bx != a[i].b.x - b[i].b.x || 
                    a_by != a[i].b.y - b[i].b.y) return false;
            }

            return true;
        }

        // C_{2v}.
        public boolean correctSymmetry() {

            Graph[] graphs = new Graph[6];
            graphs[0] = this.reflectX();
            for (int i = 1; i < 6; ++i) graphs[i] = graphs[i-1].rot60();
            assert(graphs[5].rot60().isomorphic(graphs[0]));
            int count = 0;
            for (Graph g : graphs) {
                if (this.isomorphic(g)) ++count;
                // if (count >= 2) {
                    // return false;
                // }
            }
            // if (count > 1) System.err.format("too much: %d%n", count);
            assert(count > 0);
            return count == 1; // which is, basically, true
        }

        public void reflectSelfType2() {
            Graph g = this.map(new Point.UnaryFunction() {
                public Point apply(Point p) {
                    return new Point(p.y - p.x, p.y);
                }
            });

            Point p = new Point(1, 1);
            assert (p.equals(points.get(p)));

            points.putAll(g.points);

            assert (p.equals(points.get(p)));
            Point q = new Point(0, 1);
            assert (q.equals(points.get(q)));
            points.put(p, q);
        }

        public void reflectSelfX() {
            Graph g = this.reflectX();
            points.putAll(g.points); // duplicates doesn't matter
        }

    }

    static int A936(int n) {
        // if (true) return (new int[]{0, 0, 0, 1, 1, 2, 4, 4, 12, 10, 29, 27, 88, 76, 247, 217, 722, 638, 2134, 1901, 6413})[n];

        // some unreachable codes here for testing.
        int ans = 0;

        if (n % 2 == 0) { // reflection type 2. (through line 2x == y)
            Graph[] graphs = new Graph[1];
            graphs[0] = new Graph();

            Point p = new Point(1, 1);
            graphs[0].add(p, p);

            for (int i = n / 2 - 1; i --> 0;)
                graphs = Graph.expand(graphs, new Point.Predicate() {
                    public boolean test(Point p) {
                        return 2*p.x > p.y;
                    }
                });

            int count = 0;
            for (Graph g : graphs) {
                g.reflectSelfType2();
                if (g.correctSymmetry()) {
                    ++count;

                    // for (Edge e : g.edges())
                        // System.err.println(e.a + " - " + e.b);
                    // System.err.println("------*");

                    }
                // else System.err.println("Failed");
            }

            assert (count%2 == 0);

            // System.err.println("A936(" + n + ") count = " + count + " -> " + (count/2));

            ans += count / 2;

        }

        // Reflection type 1. (reflectX)

        Graph[] graphs = new Graph[1];
        graphs[0] = new Graph();

        Point p = new Point(1, 0);
        graphs[0].add(p, p);

        if (n % 2 == 0) graphs[0].add(new Point(2, 0), p);

        for (int i = (n-1) / 2; i --> 0;)
            graphs = Graph.expand(graphs, new Point.Predicate() {
                public boolean test(Point p) {
                    return p.y > 0;
                }
            });

        int count = 0;
        for (Graph g : graphs) {
            g.reflectSelfX();
            if (g.correctSymmetry()) {
                ++count;
                // for (Edge e : g.edges())

                    // System.err.printf(

                // "pu %s pd %s\n"
                // // "%s - %s%n"

                // , e.a, e.b);
                // System.err.println("-------/");

            }
            // else System.err.println("Failed");
        }

        if(n % 2 == 0) {
            assert(count % 2 == 0);
            count /= 2;
        }
        ans += count;

        // System.err.println("A936(" + n + ") = " + ans);

        return ans;
    }

    public static void main(String[] args) {

        // Probably
        if (! "1.5.0_22".equals(System.getProperty("java.version"))) {
            System.err.println("Warning: Java version is not 1.5.0_22");
        }

        // A936(6);

        for (int i = 0; i < 20; ++i)
            System.out.println(i + " | " + (A63(i+9) - A936(i+7)));
        //A936(i+2);
    }
}

Pruébalo en línea!


Nota al margen:

  1. Probado localmente con Java 5. (de modo que la advertencia no se imprima; consulte la pestaña de depuración de TIO)
  2. No lo hagas Siempre. Utilizar. Java. 1. Es más detallado que Java en general.
  3. Esto puede romper la cadena.
  4. La brecha (7 días y 48 minutos) no es más que la brecha creada por esta respuesta , que es de 7 días y 1 hora 25 minutos más tarde que la anterior .
  5. Nuevo récord en gran bytecount! Debido a que (¿equivocadamente?) Uso espacios en lugar de pestañas, el bytecount es más grande de lo necesario. En mi máquina son 9550 bytes. (al momento de escribir esta revisión)
  6. Secuencia siguiente .
  7. El código, en su forma actual, solo imprime los primeros 20 términos de la secuencia. Sin embargo, es fácil de cambiar para que se imprime primeros 1000 elementos (por el cambio de la 20de for (int i = 0; i < 20; ++i)a 1000)

¡Hurra! ¡Esto puede calcular más términos que los que figuran en la página OEIS! (Por primera vez, para un desafío, necesito usar Java) a menos que OEIS tenga más términos en alguna parte ...


Explicacion rapida

Explicación de la descripción de la secuencia.

La secuencia solicita el número de polienoides no planos libres con el grupo de simetría C 2v , donde:

  • polienoide: (modelo matemático de hidrocarburos de polieno) los árboles (o en caso degenerado, vértice único) con pueden ser incrustados en una red hexagonal.

Por ejemplo, considera los árboles

      O                O           O      O       (3)
      |                 \         /        \
      |                  \       /          \
O --- O --- O             O --- O            O --- O
      |                                             \
      |                    (2)                       \
 (1)  O                                               O

El primero no puede incrustarse en la red hexagonal, mientras que el segundo sí. Esa inclusión particular se considera diferente del tercer árbol.

  • polienoide no plano: incrustación de árboles de modo que existan dos vértices superpuestos.

(2)y el (3)árbol de arriba son planos. Este, sin embargo, no es plano:

   O---O O
  /       \
 /         \
O           O
 \         /
  \       /
   O --- O

(hay 7 vértices y 6 aristas)

  • polienoide libre: las variantes de un polienoide, que se pueden obtener por rotación y reflexión, se cuentan como una.

  • Grupo C 2v : los polienoides solo se cuentan si tienen 2 planos perpendiculares de reflexión, y no más.

Por ejemplo, el único polienoide con 2 vértices.

O --- O

tiene 3 planos de reflexión: el horizontal -, el vertical |y el paralelo a la pantalla de la computadora . Eso es demasiado.

Por otro lado, este

O --- O
       \
        \
         O

Tiene 2 planos de reflexión: /y .


Explicación del método.

Y ahora, el enfoque sobre cómo contar realmente el número.

Primero, doy a(n) = A000063(n + 2) - A000936(n)por sentado la fórmula (que figura en la página OEIS). No leí la explicación en el periódico.

[TODO arregla esta parte]

Por supuesto, contar plano es más fácil que contar no plano. Eso es lo que hace el periódico también.

Los polienoides geométricamente planos (sin vértices superpuestos) se enumeran mediante programación informática. Por lo tanto, los números de polienoides geométricamente no planos se vuelven accesibles.

Entonces ... el programa cuenta el número de polienoides planos y lo resta del total.

Como el árbol es plano de todos modos, obviamente tiene el plano de reflexión. Por lo tanto, la condición se reduce a "contar el número de árboles con un eje de reflexión en su representación 2D".

La forma ingenua sería generar todos los árboles con nnodos y verificar la simetría correcta. Sin embargo, debido a que solo queremos encontrar el número de árboles con un eje de reflexión, podemos generar todos los medios árboles posibles en una mitad, reflejarlos a través del eje y luego verificar la simetría correcta. Además, debido a que los polienoides generados son árboles (planos), debe tocar el eje de reflexión exactamente una vez.

La función public static Graph[] expand(Graph[] graphs, Point.Predicate fn)toma una matriz de gráficos, cada uno tiene nnodos y genera una matriz de gráficos, cada uno tiene n+1nodos, no iguales entre sí (bajo traducción), de modo que el nodo agregado debe satisfacer el predicado fn.

Considere 2 posibles ejes de reflexión: uno que atraviesa un vértice y coincide con los bordes ( x = 0), y otro que es la bisectriz perpendicular de un borde ( 2x = y). Podemos tomar solo uno de ellos porque los gráficos generados son isomórficos, de todos modos.

Entonces, para el primer eje x = 0, comenzamos desde el gráfico base que consiste en un solo nodo (1, 0)(en caso de que nsea ​​impar) o dos nodos con un borde en medio (1, 0) - (2, 0)(en caso de que nsea ​​par), y luego expandimos los nodos de tal manera y > 0. Esto se hace mediante la sección "Reflexión tipo 1" del programa, y ​​luego para cada gráfico generado, se refleja (refleja) a través del eje X x = 0( g.reflectSelfX()), y luego verifica si tiene la simetría correcta.

Sin embargo, tenga en cuenta que si nes divisible por 2, de esta manera contamos cada gráfico dos veces, porque también generamos su imagen especular por el eje 2x = y + 3.

(nota las 2 naranjas)

Similar para el eje 2x = y, si (y sólo si) nes par, partimos del punto (1, 1), generar gráficos de tal manera que 2*x > y, y reflejar cada uno de ellos sobre el 2x = yeje ( g.reflectSelfType2()), conectar (1, 0)con (1, 1), y comprobar si tienen simetría correcta. Recuerde dividir entre 2 también.

usuario202729
fuente
Dado que estaba dormido cuando esto (y el otro) fueron publicados, te daré el beneficio de la duda y aún no aceptaré una respuesta.
caird coinheringaahing
2
@cairdcoinheringaahing Estuviste en línea 3 minutos antes de la fecha límite ...
user202729
Uh oh, la siguiente secuencia puede estar codificada ... (aunque es infinita) si la leo correctamente. El cálculo en sí es --- bastante --- muy fácil, así que no lo hagas.
user202729
7

6. R , 71 bytes, A000072

function(n)length(unique((t<-outer(r<-(0:2^n)^2,r*4,"+"))[t<=2^n&t>0]))

Pruébalo en línea!

Siguiente secuencia

Monja permeable
fuente
1
Por el amor de Dios, no revisé la siguiente secuencia antes de publicar esta respuesta.
Leaky Nun
¿No es una próxima secuencia fácil una ventaja estratégica?
BlackCap
@BlackCap No pueden responder dos veces seguidas o menos de 1 hora después de la última respuesta.
Erik the Outgolfer
@EriktheOutgolferthe answer before the last posted (the one who didn't break the chain) will win
BlackCap
@BlackCap en este punto que no va a suceder
Stephen
7

26. TI-BASIC, 274 bytes , A000183

.5(1+√(5→θ
"int(.5+θ^X/√(5→Y₁
"2+Y₁(X-1)+Y₁(X+1→Y₂
{0,0,0,1,2,20→L₁
Prompt A
Lbl A
If A≤dim(L₁
Then
Disp L₁(A
Else
1+dim(L₁
(~1)^Ans(4Ans+Y₂(Ans))+(Ans/(Ans-1))((Ans+1))-(2Ans/(Ans-2))((Ans-3)L₁(Ans-2)+(~1)^AnsY₂(Ans-2))+(Ans/(Ans-3))((Ans-5)L₁(Ans-3)+2(~1)^(Ans-1)Y₂(Ans-3))+(Ans/(Ans-4))(L₁(Ans-4)+(~1)^(Ans-1)Y₂(Ans-4→L₁(Ans
Goto A
End

Evalúa la fórmula recursiva que se encuentra en el enlace OEIS.

Secuencia siguiente

Scott Milner
fuente
Cuando supe que el sitio se cayó, sabía que sería una locura cuando volviera a funcionar. Apenas me ganó.
Silvio Mayolo
No me di cuenta de que el sitio se cayó ...
Scott Milner
7

49. SageMath , 74 bytes, A000003

lambda n: len(BinaryQF_reduced_representatives(-4*n, primitive_only=True))

Pruébalo en línea!

Siguiente secuencia

alephalpha
fuente
Y acabo de pasar una hora tratando de resolver esta secuencia usando JavaScript ... bueno, tendré que pasar a la siguiente ...
ETHproductions
7

76. Pigmeo , 4147 bytes, A000036

globaln: 0                                                                                           

Pi:: 3.141592653589793                                                                               

floor:: (number) {                                                                                   
    floatPart: number % 1                                                                            
    number >= 0 =>                                                                                   
    number - floatPart                                                                               
    number - floatPart - 1                                                                           
}                                                                                                    

fsqrt:: (number) {                                                                                   
    floor| number ^ 0.5                                                                              
}                                                                                                    

summation:: (f i imax) {                                                                             
    i > imax => 0                                                                                    
    (f| i) + summation| f, i + 1, imax                                                               
}                                                                                                    

absoluteValue:: (number) {                                                                           
    number < 0 => -number                                                                            
    number                                                                                           
}                                                                                                    

A:: (number) {                                                                                       
    globaln~: number                                                                                 
    1 + 4 * (fsqrt| number)                                                                          
       + 4 * (fsqrt| number / 2) ^ 2                                                                 
       + 8 * summation| (j){ fsqrt| globaln - j * j }, (fsqrt| number / 2) + 1, (fsqrt| number)      
}                                                                                                    

V:: (number) {                                                                  
    Pi * number                                                                      
}                                                                                    

P:: (number) {                                             
    (A| number) - (V| number)                               
}                                                           

recordMax: 0                                           
findRecord:: (searchIndex record recordCount) {                                    
    x: absoluteValue| P| searchIndex                                               
    (x > record && recordCount = recordMax - 1) => searchIndex                     
    x > record => findRecord| searchIndex + 1, x, recordCount + 1                  
    findRecord| searchIndex + 1, record, recordCount                               
}                                                                                  

A000099:: (number) {                                                                 
    recordMax~: number                                                              
    findRecord| 1, 0, 0                                                              
}                                                                               

A000035:: (number) {                                                                       
    floor| (P| (A000099| number)) + 0.5                                         
}                                                                               

Secuencia siguiente

Puede ejecutar el código en esta página . Por ejemplo, puede obtener el décimo número en la secuencia copiando el código anterior y agregando:

alert| A000035| 10
Peter Olson
fuente
44
... la siguiente secuencia es indiscutible ...
HyperNeutrino
1
@HyperNeutrino Lo sé: PI hizo esto a propósito
Peter Olson
Evil ...>. <Pero de todos modos, simplemente codificaré los 4 elementos en la secuencia. Bastante fácil xD OP lo aprueba aparentemente ¯ \ _ (ツ) _ / ¯
HyperNeutrino