Un OEIS après l'autre

94

Au 13/03/2018 16:45 UTC, le gagnant est la réponse n ° 345 , de Scrooble . Cela signifie que le concours est officiellement terminé, mais n'hésitez pas à continuer à poster des réponses, du moment que les règles sont respectées.

De plus, un petit mot aux trois principaux intervenants en termes de nombre de réponses:

1. NieDzejkob - 41 réponses

2. KSmarts - 30 réponses

3. Hyper Neutrino - 26 réponses

Il s'agit d'une question d'enchaînement de réponses qui utilise des séquences de OEIS et la longueur de la soumission précédente.

Cette question d'enchaînement de réponses fonctionnera de la manière suivante:

  • Je vais poster la première réponse. Toutes les autres solutions doivent en découler.
  • L'utilisateur suivant (appelons-le utilisateur A) trouvera la séquence OEIS dans laquelle son numéro d'index (voir ci-dessous) est identique à la longueur de mon code.
  • À l'aide de la séquence, ils doivent ensuite coder, dans une langue non utilisée , un programme qui prend un entier en entrée, n, et génère le nième nombre de cette séquence.
  • Ensuite, ils publient leur solution après la mienne et un nouvel utilisateur (userB) doit répéter la même chose.

Le nième terme d'une séquence est le terme n fois après le premier, la première valeur étant la première valeur indiquée sur sa page OEIS. Dans cette question, nous allons utiliser l' indexation 0 pour ces séquences. Par exemple, avec A000242 et n = 3, le résultat correct serait 25 .

Pourtant!

Ce n'est pas un code-golf , donc le code le plus court n'a pas d'importance. Mais la longueur de votre code a toujours un impact. Pour éviter la duplication de séquences, votre décompte de tiers doit être unique . Cela signifie qu'aucun autre programme soumis ici ne peut avoir la même longueur en octets que le vôtre.

S'il n'y a pas de séquence pour alors la longueur du dernier message, la séquence de votre message est la séquence inutilisée la plus basse. Cela signifie que les séquences utilisées doivent également être uniques, et que la séquence ne peut pas être identique à votre décompte.

Après qu'une réponse ait été postée et qu'aucune nouvelle réponse n'ait été postée pendant plus d'une semaine, la réponse précédant la dernière réponse postée (celle qui n'a pas rompu la chaîne) l'emporte.

Entrée et sortie

Les règles d'entrée et de sortie génériques s'appliquent. L'entrée doit être un entier ou une chaîne représentant un entier et la sortie doit correspondre à la valeur correcte de la séquence.

Mise en page

Comme pour la plupart des questions d’enchaînement de réponses, veuillez formater votre réponse de la manière suivante

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

`code`

[next sequence](link)

*anything else*

Règles

  • Vous devez attendre au moins 1 heure avant de poster une réponse, après avoir posté.
  • Vous ne pouvez pas poster deux (ou plus) de suite.
  • Le numéro d'index d'une séquence est le numéro qui suit la Apartie et les zéros de gauche sont supprimés (par exemple, A000040le numéro d'index est 40).
  • Vous pouvez supposer que ni l'entrée ni la sortie requise ne seront en dehors de la plage numérique de votre langue, mais veuillez ne pas en abuser en choisissant une langue ne pouvant utiliser que le chiffre 1, par exemple.
  • Si la longueur de votre soumission dépasse 65 536 caractères, indiquez un lien permettant d'accéder au code (par exemple, pastebin).
  • n ne sera jamais supérieur à 1 000 ou ne sera pas interdit pour la séquence, simplement pour éviter que les écarts de précision empêchent une langue de se faire concurrence.
  • Toutes les 150 réponses (valides), le nombre d'utilisations d'une langue augmente. Ainsi, après l'affichage de 150 solutions, chaque langue peut être utilisée deux fois (avec toutes les réponses précédentes comptant pour cela). Par exemple, lorsque 150 réponses ont été postées, Python 3 peut être utilisé deux fois, mais comme il a déjà été utilisé une fois, cela signifie qu'il ne peut être utilisé qu'une seule fois jusqu'à ce que 300 réponses aient été postées.
  • S'il vous plaît être utile et poster un lien vers la prochaine séquence à utiliser. Ce n'est pas obligatoire, mais c'est une recommandation.
  • Différentes versions de langages, par exemple Python 2 et Python 3, sont des langages différents . En règle générale, si les différentes versions sont disponibles sur Try It Online, il s'agit de langues différentes, mais gardez à l'esprit qu'il s'agit d'une règle générale et non d'une réponse rigide.
  • Ce n'est pas interdit, mais essayez de ne pas copier le code de la page OEIS et essayez de le résoudre.
  • Le codage en dur n'est autorisé que si la séquence est finie. Veuillez noter que la réponse à l'origine de cette question ( # 40 ) constitue l'exception à la règle. Quelques réponses au début de la chaîne, mais elles peuvent être ignorées, car il n’est pas utile de supprimer la chaîne jusqu’à 100, disons.

Extrait de chaîne de réponse

Afficher l'extrait de code

math code-challenge sequence answer-chaining caird coinheringaahing
la source
Les commentaires ne sont pas pour une discussion prolongée; cette conversation a été déplacée pour discuter .
Dennis
Est-il acceptable qu'un programme ait besoin d'une meilleure précision en virgule flottante pour le type float/ intégré doubleafin de produire des valeurs pour des valeurs plus grandes n?
NieDzejkob
1
@Giuseppe Non, car vous générez les nombres en faisant le calcul, plutôt que de les placer simplement dans un tableau / une chaîne
caird coinheringaahing
2
@cairdcoinheringaahing À mon avis, c'est le codage en dur de la constante gamma. Cela ne fonctionne pas "en théorie" pour les grands nombres.
user202729
6
Salon de

Réponses:

4

345. brainfuck , 162 octets, A000301

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

Essayez-le en ligne!

Séquence suivante!

Ceci prend en entrée le caractère avec un point de code n(selon les spécifications de BF) et sort de la même manière. Pour voir les chiffres, je suggère d'utiliser EsotericIDE de @ Timwi .

Explication:

+<<,                                  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.

Etant donné que cela stocke tous les numéros de Fibonacci jusqu’à l’important, il échouera pour une entrée VRAIMENT importante sur une bande liée.

Cela pourrait être raccourci de manière significative en codant en dur la base (2), mais golfiness n'est pas un problème du tout.

Khuldraeseth na'Barya
la source
Comme la réponse suivante (# 346) a cassé la chaîne, votre réponse est gagnante!
Caird coinheringaahing
1
@cairdcoinheringaahing Merci pour cet incroyable défi. Cela m'attriste que cela se termine maintenant, mais comme toutes les bonnes choses du monde, c'est la fin. Maintenant, pour jouer au golf cette pauvre excuse pour le code, car c’est maintenant la première réponse que quiconque verra, et elle doit être impressionnante ...
Khuldraeseth na'Barya
@Scrooble vous ne pouvez pas vraiment changer la longueur ...
NieDzejkob
@NieDzejkob Ouais, mais je peux jouer au golf et ajouter un peu plus de rembourrage pour garder la même longueur.
Khuldraeseth na'Barya
@cairdcoinheringaahing "a brisé la chaîne"? Qu'est-ce que ça veut dire?
Urne magique Octopus
40

22. FiM ++ , 982 octets, A000024

Remarque : si vous lisez ceci, vous voudrez peut-être trier par "plus ancien".

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

Séquence suivante

BlackCap
la source
10
Hahaha, a tellement ri tout le temps. +1 pour le choix de la langue :-)
ETHproductions
Amazing, prendre mon vote positif
downrep_nation
22

1. triangulaire , 10 octets, A000217

$\:_%i/2*<

Essayez-le en ligne!

Séquence suivante

Comment ça fonctionne

Le code est formaté dans ce triangle

   $
  \ :
 _ % i
/ 2 * <

avec l’IP commençant au $sud-est et se déplaçant vers le sud-est (SE, heh), fonctionne comme suit:

$            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
la source
13
1. Triangulaire, 10 octets, A000217. * suit le lien * A000217 Triangular numbers...
MD XF
22

73. étoilé , 363 octets, A000252

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

Essayez-le en ligne!

Séquence suivante

Utilise la formule " a(n) = n^4 * product p^(-3)(p^2 - 1)*(p - 1)où le produit est sur tous les nombres premiers p qui divisent n" à partir d'OEIS.

La lune est un non-op, mais bon, ce n'est pas du code-golf.

Pas un arbre
la source
étoiles dans la lune? hmmm
mardi
19

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

Tout d’abord, merci au Dr Max Alekseyev d’avoir été patient avec moi. Je suis très chanceux d'avoir pu le contacter par courrier électronique pour comprendre ce défi. Sa réponse Math.SE ici m'a beaucoup aidé. Merci à Wheat Wizard de m'avoir aidé également. :)

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

Essayez-le en ligne!

Si cela donne un résultat erroné, augmentez simplement le 100 à quelque chose de plus grand. Je pense que 10000 fonctionnera pour 4 mais je laisserai mon ordinateur en marche toute la nuit pour le confirmer. cela peut prendre quelques heures.

Notez que la partie (PyPy) est juste pour que je puisse utiliser à nouveau Python. Je ne connais vraiment pas beaucoup d'autres langues et je ne vais pas essayer de porter cela en Java et risquer de ne pas finir à temps.

Séquence suivante (Merci également de ne pas faire plus de trucs de maths loufoques; je n'ai plus de version Python, alors quelqu'un d'autre devra sauvegarder ce défi D :)

HyperNeutrino
la source
Eh bien, il y a toujours pypy3
ASCII seulement
15

107. TrumpScript , 1589 octets, 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.

Essayez-le en ligne!

Première programmation en TrumpScript, il est possible que je réinvente la roue plusieurs fois - 4 lignes sont dédiées au calcul de 2 ^ n. J'ai essayé de faire en sorte que cela ressemble à quelque chose que Trump pourrait dire. En prime, voici un script Python que j'ai écrit pour vérifier que tout se passe bien. Le programme ci-dessus présente quelques différences, mais une grande partie est directement équivalente.

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)

Séquence suivante!

NieDzejkob
la source
3
I will make cat feel goodO_O
Business Cat
Malheureusement, I will make Business Cat feel goodcela ne fonctionnera pas ...
NieDzejkob Le
14

30. Python 1 , 1112 octets, 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

Essayez-le en ligne!

Même pas la peine de jouer au golf avec ça. Hé, ce n'est pas ma plus longue réponse en Python sur ce site!

Séquence suivante

HyperNeutrino
la source
1
Félicitations pour avoir décodé les maths: D
Leaky Nun
2
313 octets, lol
Leaky Nun
@ LeakyNun Comme je le disais, je n'ai pas pris la peine de jouer au golf avec ce lol. D'ailleurs ce n'est pas ma plus longue réponse en Python sur ce site alors idc: P mais sympa
HyperNeutrino
@ LeakyNun Et merci: D Il m'a fallu un certain temps pour tout comprendre lol
HyperNeutrino
@LeakyNun 309 octets, car la valeur réelle de _n'est pas pertinente; il nous faut juste répéter cela plusieurs fois
HyperNeutrino
13

2. Haskell, 44 octets, A000010

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

Essayez-le en ligne!

Séquence suivante

BlackCap
la source
12
Le nom de la prochaine séquence cependant ...
totalement humain
@totallyhuman pauvres lapins ...
Erik the Outgolfer
Devrions-nous créer un lien vers le post précédent?
Leaky Nun
Cela me fait de la peine de ne pouvoir jouer au golf maintenant. Je devais être le premier à voir
BlackCap
Quelle est cette séquence suivante? Je ne comprends pas les trois: P
Beta Decay le
13

9. Pyth , 19 octets, A000025

?>Q0sm@_B1-edld./Q1

Suite de test .

Séquence suivante

a (n) = nombre de partitions de n avec rang pair moins nombre avec rang impair. Le rang d'une partition est sa partie la plus grande moins le nombre de parties.

Fuite Nun
la source
Pour ceux qui connaissent Pyth, j’ai délibérément utilisé à la >Q0place de Q, vous savez, pour que la séquence suivante soit A000019.
Leaky Nun
1
De la page OEISKeywords: easy,nice
BlackCap le
@ LeakyNun Ouais, car sinon, je devrais résoudre A000017 ... brut.
Erik the Outgolfer
12

8. Mathematica (10.1), 25 octets, A000070

Tr@PartitionsP@Range@#+1&

Séquence suivante

LegionMammal978
la source
La séquence parfaite à utiliser pour Mathematica.
Leaky Nun
1
A000025 est incroyablement difficile. Vous devez ajouter un octet pour obtenir A000026 à la place. : P
MD XF
12

206. Proton , 3275 octets, 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))

Essayez-le en ligne!

Séquence suivante

HyperNeutrino
la source
Attends, tu l'as fait? Si vous n'écrivez pas un article avec ces programmes effrayants et que vous allez parler à un professeur, vous oubliez quelque chose de cool: P
Stephen
@Stephen Corrections de bogues lol
HyperNeutrino 10/10
Est-ce l’approche consistant à scinder des triangles, des carrés et des pentagones selon plantri? On dirait que cela pourrait être, mais une partie de la syntaxe est inconnue.
Peter Taylor
1
@PeterTaylor En supposant que je comprends l'approche que vous décrivez, oui, il recherche des triangles et place un sommet adjacent à tous les 3 sommets, ou deux cycles adjacents, supprime l'arête commune et place un sommet adjacent à tous les 4, identique pour 3 triangles. sur un pentagone. Je pense que c'est ce que vous décrivez.
HyperNeutrino
1
@ChristianSievers math.stackexchange.com/a/2463430/457091
HyperNeutrino
12

308. ENIAC (simulateur) , 3025 octets, A006060

Pseudocode: 

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
}

Pas de simulateur en ligne, résultat d'exécution: Entrée du lecteur de carte Sortie de la carte perforée

Registres et 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

Flux du signal du programme et des données: Flux de signal de programme et diagramme de flux de données

Complétez le "code" sur pastebin ou dans les commentaires HTML dans le balisage de cette réponse, afin d’empêcher linkrot et une réponse assez longue à faire défiler simultanément. C'est marrant!

Séquence suivante

leo3065
la source
Pourriez-vous ajouter un lien à la prochaine séquence s'il vous plaît
Zacharý
@ Zacharý Le lien est dans le post. Je vais le déplacer à la fin du post afin que ce soit plus facile à trouver.
leo3065
12

15. CJam, 85 octets, A000060

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

Démo en ligne

Séquence suivante

Dissection

OEIS donne

Gf: S (x) + S (x ^ 2) -S (x) ^ 2, où S (x) est la fonction génératrice de A000151. - Pab Ter, 12 octobre 2005

où

S(X)=XΠje≥11(1-Xje)2s(je)=XΠje≥1(1+Xje+X2je+…)2s(je)
{           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
la source
1 minute et 33 secondes devant moi ... pendant que je tapais l'explication
Leaky Nun
11

67. LOLCODE , 837 octets, 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

Ma touche majuscule est vouée à s’échapper, j’ai donc écrit tout ça en maintenant la touche shift

Essayez-le en ligne!

Séquence suivante

BlackCap
la source
+1 pour utiliserPRAIME
Leaky Nun
3
Vous êtes un programmeur, vous auriez pu l'écrire puis l'exécuter à l'aide d'un script Python qui upperle serait -.-
Stephen
5
@StepHen Ou simplement gggUGdans vim où je l'ai écrit, mais je ne suis pas si malin
BlackCap
10

10. Magma, 65 octets, A000019

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

Essayez-le ici

lol intégré

Séquence suivante

HyperNeutrino
la source
@ETHproductions :) pas de problème, merci à la page OEIS bien que parce qu'elle a l'exact construit
HyperNeutrino
4
; _; J'ai résolu A000064 et vous l'avez changé. Moins voté.
Leaky Nun
Mon Dieu, tellement de séquences de partition
ETHproductions
J'ai accidentellement résolu A007317 alors que j'essayais de le faire en Python ( TIO ): P
ETHproductions
Re-voté! \ o /
Leaky Nun
9

121. Pip , 525 octets, 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

Démo en ligne

Séquence suivante

Anecdote: lorsque le défi a été publié pour la première fois, j'ai dressé une liste de petits numéros de séquence désagréables que je voulais viser avec CJam, et A000022 était en haut de la liste.

Ceci implémente la fonction génératrice décrite dans EM Rains et NJA Sloane, Enumeration of Alkanes ( Sur Cayley), ou 4-Valent Trees , Journal of Integer Sequences, Vol. 2 (1999), en prenant la somme pour autant de termes qu'il est nécessaire pour fixer le coefficient e et en télescopant les trois quarts de la somme. En particulier, le fait de télescoper la première moitié signifie que l'indice de cycle de ne doit être appliqué qu'à l'un d'entre eux plutôt qu'à tous.CknS4Th

Le code se décompose en

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

Notez que ceci est mon tout premier programme Pip, ce n’est donc probablement pas très idiomatique.

Peter Taylor
la source
Les commentaires ne sont pas pour une discussion prolongée; cette conversation a été déplacée pour discuter .
Dennis
9

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

Remarque: le score est de 2439 octets pour le code et de 27 pour le drapeau du compilateur -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]);
        }
    }
}

Démo en ligne . C'est un programme complet qui prend des entrées à partir de la ligne de commande.

Séquence suivante

Dissection

Je suis le commentaire de Bowen dans OEIS selon lequel la fonction génératrice, dans A000083(x) = A000237(x) + A035349(x) - A000237(x) * A035350(x)laquelle les fonctions génératrices de composant sont liées par

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

J'utilise les définitions de BIKet DIKde https://oeis.org/transforms2.html mais les formules semblent comporter un certain nombre de fautes de frappe. J'ai corrigé LPALsans trop de difficulté et dérivé indépendamment une formule DIKbasée sur l'application de l'énumération de Pólya à l' indice de cycle du groupe dièdre . Entre les numéros 121 et 156, j'apprends beaucoup sur l'énumération de Pólya. J'ai soumis des errata , qui pourraient s'avérer utiles pour d'autres personnes si ces transformations se répètent dans la chaîne.

Peter Taylor
la source
8

13. VB.NET (.NET 4.5), 1246 octets, 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

Essayez-le en ligne!

Brian J
la source
8

91. Python 2 (PyPy) , 1733 octets, 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

Essayez-le en ligne!

J'espère que l'utilisation de Python 2 PyPy compte comme une autre version majeure. Si quelqu'un pouvait me procurer un interprète Python 0, je pourrais aussi l'utiliser, mais j'espère que cela est valide.

Cela commence à 1 sommet et fonctionne, créant ainsi la représentation de la matrice d'adjacence de tous les graphes non dirigés possibles avec autant de sommets. S'il est trivalent, il examinera la puissance des bords, qui seront triés par longueur. Si le premier cycle trouvé est trop court, il passera à autre chose. Si le premier cycle trouvé correspond à l'entrée (décalage de 3), il génère le nombre de sommets correct et se termine.

Prochaine séquence <- ayez un facile comme une pause de tout ce non-sens mathématique: D

EDIT : J'ai ajouté quelques optimisations pour accélérer un peu (je ne peux toujours pas calculer le troisième terme dans la limite de 60 secondes de TIO) sans changer le nombre de bytec.

HyperNeutrino
la source
... et je pensais sérieusement que la chaîne se terminerait par la réponse 90
pppery le
1
@ppperry :) J'aime relever des défis difficiles, car la plupart des gens ne peuvent même pas trouver de solution. Je n'ai donc pas à craindre de me faire gommer :) (par exemple, le problème de dénomination de la chaîne du carbone)
HyperNeutrino
À moins que quelqu'un prenne votre solution et la convertisse en langage
incertain
@ppperry that too o_O: P
HyperNeutrino
1
@HyperNeutrino Félicitations pour avoir résolu ce problème! J'étais inquiet d'avoir cassé la chaîne et envisageais d'augmenter le nombre d'octets pour indiquer une séquence différente. Bon travail!
Scott Milner
8

232. Funky , 326 330 332 octets, 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;
}

Essayez-le en ligne!

Polyglot avec Javascript. Essayez-le en ligne!

Séquence suivante .

Utilisez la formule sur la page OEIS pour la O(n^2 log n)complexité, au lieu de la naïve O(n^6).

Explication rapide:

  • Ce code utilise la formule 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)décrite dans la section Code de Mathematica.

  • Preuve de formule:

    • La formule est équivalente à ceci .

    • Laisser la taille de la boîte englobante de trois points être m * k. Considérons 2 cas:

      • k != 0et m != 0: Il existe 2 manières de choisir l'orientation des trois points ( \ou /), les gcd(k-1, m-1)-1manières de choisir le point se situent entre les 2 autres points et les (n - k) × (n - m)manières de choisir la position du cadre de sélection.
      • k == 0ou m == 0: Il existe deux manières de choisir l'orientation ( |ou -), les nmanières de choisir la ligne / colonne sur laquelle se trouvent les points et les Binomial[n, 3] == (n*(n-1)*(n-2)) / 6manières de choisir les points sur cette ligne / colonne.

Quelques notes polyglottes:

  • Funky n'a pas vraiment de mot clé return. Cependant, comme l' explique ATaco , [Funky] pense qu'il returns'agit d'une variable. Donc, il s'agit d'analyser cette expression, qui ne fait rien commodément, puis analyse l'expression suivante. Et ceci est utilisé comme sortie.
  • Javascript utilise ^bitor xor, contrairement à Funky qui utilise ^comme exponentiation. Donc, n*ndoivent être utilisés à la place de n^2pour assurer la compatibilité Javascript.
  • En Très tendance, tout opérateur ( +, -, *, etc.) ont la même priorité et le droit associatif, donc les expressions doivent être correctement parenthésée.
utilisateur202729
la source
1
+1 ne s'attendait pas à un polyglotte.
ATaco
Il n'y a pas de Pentagonie, mais Hexagony convient bien.
NieDzejkob
Ce compte a déjà été utilisé ... lien
NieDzejkob
Donc, pour résoudre le problème du bytecount, pourriez-vous s'il vous plaît apposer cette réponse sur 330 octets? Je vais gérer le reste.
NieDzejkob
[Réponse complétée à 332 octets en raison de conflits de bytecount, voir ce message de discussion ]
user202729
8

11. Pari / GP, 64 octets, A000065

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

Essayez-le en ligne!

Séquence suivante

MD XF
la source
Est-ce que cette entrée est valide?
Leaky Nun
Didya ont pour obtenir 64 octets? : P
totalement humain
@totallyhuman yes:;_; I solved A000064 and you changed it. Downvoted.
Stephen, le
@ Totallyhuman compromet lol. see chat
HyperNeutrino
Dang
M. Xcoder
8

281. Java 5, 11628 octets, 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);
    }
}

Essayez-le en ligne!

Note de côté:

  1. Testé localement avec Java 5. (de sorte que l'avertissement ne soit pas imprimé - voir l'onglet de débogage de TIO)
  2. Ne pas Déjà. Utilisation. Java. 1. C'est plus bavard que Java en général.
  3. Cela peut briser la chaîne.
  4. L'écart (7 jours et 48 minutes) n'est rien de plus que l'écart créé par cette réponse , qui est de 7 jours et 1 heure 25 minutes plus tard que la précédente .
  5. Nouveau record sur un grand nombre! Parce que j'utilise (à tort?) Des espaces au lieu de tabulations, le nombre de tours est plus grand que nécessaire. Sur ma machine, c'est 9550 octets. (au moment de la rédaction de cette révision)
  6. Séquence suivante .
  7. Le code, dans sa forme actuelle, n’imprime que les 20 premiers termes de la séquence. Cependant , il est facile de changer de sorte qu'il imprime 1000 premiers éléments (par le changement le 20dans for (int i = 0; i < 20; ++i)à 1000)

Yay! Cela peut calculer plus de termes que ceux énumérés sur la page OEIS! (pour la première fois, pour un défi, j’ai besoin d’utiliser Java) à moins que OEIS ait plus de termes quelque part ...

Explication rapide

Explication de la description de la séquence.

La séquence demande le nombre de polyénoïdes non plans libres avec groupe de symétrie C 2v , où:

  • polyénoïde: (modèle mathématique des hydrocarbures polyéniques), les arbres (ou dans le cas dégénéré, sommet simple) peuvent être inclus dans un réseau hexagonal.

Par exemple, considérons les arbres

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

Le premier ne peut pas être intégré dans le réseau hexagonal, alors que le second le peut. Cette intégration particulière est considérée comme différente du troisième arbre.

  • polyénoïde non planaire: incrustation d'arbres telle qu'il existe deux sommets qui se chevauchent.

(2)et l' (3)arbre ci-dessus sont planes. Celui-ci, cependant, est non plan:

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

(il y a 7 sommets et 6 arêtes)

  • polyénoïde libre: Les variantes d'un polyénoïde, obtenues par rotation et réflexion, comptent pour un.

  • Groupe C 2v : Les polyénoïdes ne sont comptés que s'ils ont 2 plans de réflexion perpendiculaires, pas plus.

Par exemple, le seul polyénoïde à 2 sommets

O --- O

a 3 plans de réflexion: l’horizontal -, le vertical |et l’autre parallèle à l’écran de l’ordinateur ■. C'est trop.

D'autre part, celui-ci

O --- O
       \
        \
         O

a 2 plans de réflexion: /et ■.

Explication de la méthode

Et maintenant, l'approche sur la façon de compter le nombre.

Premièrement, je prends la formule a(n) = A000063(n + 2) - A000936(n)(listée sur la page OEIS) pour acquise. Je n'ai pas lu l'explication dans le journal.

[TODO réparer cette partie]

Bien sûr, compter en plan est plus facile que de compter en plan. C'est ce que le papier fait aussi.

Les polyénoïdes géométriquement planaires (sans sommets superposés) sont énumérés par programmation informatique. Ainsi, le nombre de polyénoïdes géométriquement non plans devient accessible.

Alors ... le programme compte le nombre de polyénoïde plan et le soustrait du total.

Parce que l’arbre est quand même planaire, il a évidemment le ■plan de réflexion. La condition se résume donc à "compter le nombre d’arbres avec un axe de réflexion dans sa représentation 2D".

La manière naïve serait de générer tous les arbres avec des nnoeuds et de vérifier la symétrie correcte. Cependant, comme nous voulons seulement trouver le nombre d’arbres avec un axe de réflexion, nous pouvons simplement générer tous les demi-arbres possibles sur une moitié, les refléter sur l’axe, puis vérifier la symétrie correcte. De plus, comme les polyénoïdes générés sont des arbres (plans), il doit toucher l’axe de réflexion exactement une fois.

La fonction public static Graph[] expand(Graph[] graphs, Point.Predicate fn)prend un tableau de graphes, chacun ayant des nnœuds, et génère un tableau de graphes, chacun ayant des n+1nœuds non égaux les uns des autres (en translation) - de sorte que le nœud ajouté doit satisfaire le prédicat fn.

Considérez 2 axes de réflexion possibles: un qui passe par un sommet et qui coïncide avec des arêtes ( x = 0) et un qui est la bissectrice perpendiculaire d’une arête ( 2x = y). Nous ne pouvons en prendre qu'un seul car les graphes générés sont de toute façon isomorphes.

Ainsi, pour le premier axe x = 0, nous partons du graphe de base constitué d'un seul nœud (1, 0)(dans le cas où il nest impair) ou de deux nœuds avec un bord entre (1, 0) - (2, 0)(dans le cas où il nest pair), puis nous développons les nœuds de cette manière y > 0. Cela se fait par la section "Type de réflexion 1" du programme, puis pour chaque graphe généré, se reflète (se reflète) sur l'axe X x = 0( g.reflectSelfX()), puis vérifie si sa symétrie est correcte.

Cependant, notez que si nest divisible par 2, nous avons ainsi compté chaque graphe deux fois, car nous générons également son image miroir par l’axe 2x = y + 3.

(notez les 2 orange)

Similaire pour l'axe 2x = y, si (et seulement si) nest pair, nous partons du point (1, 1), générons des graphes tels que 2*x > y, et reflétons chacun d'eux sur l' 2x = yaxe ( g.reflectSelfType2()), nous connectons (1, 0)avec (1, 1), et vérifions s'ils ont la symétrie correcte. N'oubliez pas de diviser par 2, aussi.

utilisateur202729
la source
Étant donné que j'étais endormi quand ceci (et l'autre) a été posté, je vais vous donner le bénéfice du doute et ne pas accepter de réponse pour le moment.
Caird coinheringaahing
2
@cairdcoinheringaahing Vous étiez en ligne 3 minutes avant la date limite ...
user202729
Euh oh, la séquence suivante peut être codée en dur ... (même si c'est infini) si je le lis correctement. Le calcul lui-même est --- joli --- très facile, alors ne le faites pas.
user202729
7

6. R , 71 octets, A000072

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

Essayez-le en ligne!

Séquence suivante

Fuite Nun
la source
1
Pour l'amour de Dieu, je n'ai pas vérifié la séquence suivante avant de poster cette réponse.
Leaky Nun
Une suite facile n’est-elle pas un avantage stratégique?
BlackCap
@BlackCap Ils ne peuvent pas répondre deux fois de suite, soit moins d'une heure après la dernière réponse.
Erik the Outgolfer
@EriktheOutgolferthe answer before the last posted (the one who didn't break the chain) will win
BlackCap
@BlackCap à ce stade que cela ne va pas arriver
Stephen
7

26. TI-BASIC, 274 octets , 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

Evalue la formule récursive trouvée sur le lien OEIS.

Séquence suivante

Scott Milner
la source
Agh, je savais quand le site tomberait que ce serait une folle course quand il remonterait. À peine me battre.
Silvio Mayolo
Je ne savais pas que le site était en panne ...
Scott Milner
twitter.com/Nick_Craver/status/888553194313449472
Silvio Mayolo
7

49. SageMath , 74 octets, A000003

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

Essayez-le en ligne!

Séquence suivante

Alephalpha
la source
Et je viens de passer une heure à essayer de composer cette séquence en utilisant JavaScript ... eh bien, je vais devoir passer à la suivante ...
ETHproductions
7

76. Pygmée , 4147 octets, 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                                         
}

Séquence suivante

Vous pouvez exécuter le code sur cette page . Par exemple, vous pouvez obtenir le 10ème numéro de la séquence en copiant le code ci-dessus et en ajoutant:

alert| A000035| 10
Peter Olson
la source
4
... la prochaine séquence est non calculable ...
HyperNeutrino
1
@HyperNeutrino Je sais: PI l'a fait exprès
Peter Olson le
Mal ...>. <Mais bon, je vais juste coder en dur les 4 éléments de la séquence. Opération xD assez facile l'approuve apparemment ¯ \ _ (ツ) _ / ¯
HyperNeutrino