Jeden OEIS po drugim

95

W dniu 13.03.2018 16:45 UTC zwycięzcą jest odpowiedź nr 345 autorstwa Scrooble . Oznacza to, że konkurs został oficjalnie zakończony, ale możesz kontynuować publikowanie odpowiedzi, pod warunkiem, że będą one zgodne z zasadami.

Ponadto wystarczy krótkie zawołanie do trzech największych osób odpowiadających pod względem liczby odpowiedzi:

1. NieDzejkob - 41 odpowiedzi

2. KSmarts - 30 odpowiedzi

3. Hyper Neutrino - 26 odpowiedzi

To jest łańcuchowe pytanie, które wykorzystuje sekwencje z OEIS i długość poprzedniego przedłożenia.

To pytanie łańcuchowe odpowiedzi będzie działać w następujący sposób:

  • Wyślę pierwszą odpowiedź. Wszystkie inne rozwiązania muszą z tego wynikać.
  • Następny użytkownik (nazwijmy go użytkownik A) znajdzie sekwencję OEIS, w której jej numer indeksu (patrz poniżej) jest taki sam jak długość mojego kodu.
  • Korzystając z sekwencji, muszą następnie zakodować, w nieużywanym języku , program, który przyjmuje liczbę całkowitą jako dane wejściowe, n i wypisuje nty numer w tej sekwencji.
  • Następnie umieszczają swoje rozwiązanie po moim, a nowy użytkownik (userB) musi powtórzyć to samo.

nP określenie sekwencji jest terminem n razy po pierwszym pracy z pierwszą wartością jest pierwsza wartość względu na jego stronie OEIS. W tym pytaniu użyjemy indeksowania 0 dla tych sekwencji. Na przykład w przypadku A000242 i n = 3prawidłowy wynik to 25 .

Jednak!

To nie jest gra w golfa , więc najkrótszy kod nie ma znaczenia. Ale długość twojego kodu wciąż ma wpływ. Aby zapobiec duplikowaniu sekwencji, twoje bajty muszą być unikalne . Oznacza to, że żaden inny przedstawiony tutaj program nie może mieć takiej samej długości w bajtach jak Twój.

Jeśli nie ma sekwencji odpowiadającej długości ostatniego postu, to sekwencja postu jest najniższą nieużywaną sekwencją. Oznacza to, że użyte sekwencje również muszą być unikalne i że sekwencja nie może być taka sama jak liczba bajtów.

Po opublikowaniu odpowiedzi i braku nowych odpowiedzi przez ponad tydzień, wygra odpowiedź przed ostatnim (tym, który nie złamał łańcucha).

Wejście i wyjście

Obowiązują ogólne zasady wejścia i wyjścia. Dane wejściowe muszą być liczbą całkowitą lub ciągiem znaków reprezentujących liczbę całkowitą, a dane wyjściowe muszą mieć poprawną wartość w sekwencji.

Formatowanie

Podobnie jak w przypadku większości pytań wymagających odpowiedzi, sformatuj swoją odpowiedź w ten sposób

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

`code`

[next sequence](link)

*anything else*

Zasady

  • Po opublikowaniu odpowiedzi musisz poczekać przynajmniej godzinę.
  • Nie możesz publikować dwa razy (lub więcej) z rzędu.
  • Numer indeksu sekwencji to liczba po Aczęści, z usuniętymi zerami wiodącymi (np. Dla A000040numeru indeksu to 40)
  • Możesz założyć, że ani dane wejściowe, ani wymagane dane wyjściowe nie znajdą się poza zakresem liczbowym Twoich języków, ale nie nadużywaj tego, wybierając na przykład język, który może używać tylko cyfry 1.
  • Jeśli długość Twojego zgłoszenia jest większa niż 65536 znaków, podaj link do sposobu dostępu do kodu (na przykład pastebin).
  • n nigdy nie będzie większy niż 1000 ani nie będzie poza zakresem sekwencji, po prostu po to, aby zapobiec rozbieżnościom w dokładności w powstrzymywaniu języka przed konkurowaniem.
  • Co 150 (poprawnych) odpowiedzi rośnie liczba przypadków, w których można użyć języka. Po opublikowaniu 150 rozwiązań każdy język może być używany dwukrotnie (wszystkie wcześniejsze odpowiedzi się liczą). Na przykład, gdy opublikowano 150 odpowiedzi, Python 3 może być użyty dwukrotnie, ale z uwagi na fakt, że został już użyty raz, oznacza to, że można go użyć tylko raz, dopóki nie zostanie opublikowanych 300 odpowiedzi.
  • Bądź pomocny i opublikuj link do następnej sekwencji, która ma być użyta. Nie jest to wymagane, ale jest zaleceniem.
  • Różne wersje języków, np. Python 2 i Python 3 są różnymi językami . Zasadniczo, jeśli obie wersje są dostępne w Try It Online, są to różne języki, ale należy pamiętać, że jest to ogólna zasada, a nie sztywna odpowiedź.
  • Nie jest to zbanowane, ale proszę nie kopiować kodu ze strony OEIS i próbować go rozwiązać.
  • Kodowanie jest dozwolone tylko wtedy, gdy sekwencja jest skończona. Pamiętaj, że odpowiedź na to pytanie ( # 40 ) stanowi wyjątek od reguły. Kilka odpowiedzi na wczesnym etapie łańcucha kodu, ale można je zignorować, ponieważ nie ma sensu usuwać łańcucha do, powiedzmy, # 100.

Fragment łańcucha odpowiedzi

Pokaż fragment kodu

math code-challenge sequence answer-chaining Cairney Coheringaahing
źródło
Komentarze nie są przeznaczone do rozszerzonej dyskusji; ta rozmowa została przeniesiona do czatu .
Dennis
Czy jest OK, jeśli program potrzebuje lepszej dokładności zmiennoprzecinkowej dla wbudowanego float/ doubletypu, aby wygenerować wartości dla większych n?
NieDzejkob
1
@Giuseppe Nie, ponieważ generujesz liczby, wykonując matematykę, a nie tylko umieszczając je w tablicy / ciągu
caird coinheringaahing
2
@cairdcoinheringaahing Moim zdaniem to twarde kodowanie stałej gamma. Nie działa „teoretycznie” dla większych liczb.
user202729,
6
Pokój czatu
użytkownik202729,

Odpowiedzi:

4

345. brainfuck , 162 bajty, A000301

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

Wypróbuj online!

Następna sekwencja!

Pobiera to znak wejściowy z punktem kodowym n(według specyfikacji BF) i wypisuje w ten sam sposób. Aby zobaczyć liczby, sugeruję użycie EsotericIDE @ Timwi .

Wyjaśnienie:

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

Ponieważ przechowuje to wszystkie liczby Fibonacciego do ważnej, nie powiedzie się NAPRAWDĘ duże wejście na ograniczonej taśmie.

Można to znacznie skrócić poprzez twarde zakodowanie bazy (2), ale golfowość nie stanowi żadnego problemu.

Khuldraeseth na'Barya
źródło
Gdy następna odpowiedź (# 346) przerwała łańcuch, twoja odpowiedź jest zwycięzcą!
caird coinheringaahing
1
@cairdcoinheringaahing Dziękujemy za to niesamowite wyzwanie. Zasmuca mnie to, że powinno się to teraz skończyć, ale podobnie jak wszystkie dobre rzeczy na świecie, tak też się stało. Zagraj w tę marną wymówkę dla kodu, ponieważ jest to pierwsza odpowiedź, jaką zobaczy każdy, i musi być imponująco krótka ...
Khuldraeseth na'Barya
@ Scrooble, tak naprawdę nie możesz zmienić długości ...
NieDzejkob
@NieDzejkob Tak, ale mogę grać w golfa i dodać więcej wypełnienia, aby zachować tę samą długość.
Khuldraeseth na'Barya
@cairdcoinheringaahing "break a the chain"? Co to znaczy?
Magic Octopus Urn
40

22. FiM ++ , 982 bajty, A000024

Uwaga : jeśli czytasz to, możesz posortować według „najstarszego”.

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

Następna sekwencja

Gajówka
źródło
10
Hahaha, śmiał się tak mocno przez całą sprawę. +1 za wybór języka :-)
ETHproductions
Niesamowite, weź moje upvote
downrep_nation
22

1. Trójkątny , 10 bajtów, A000217

$\:_%i/2*<

Wypróbuj online!

Następna sekwencja

Jak to działa

Kod jest formatowany do tego trójkąta

   $
  \ :
 _ % i
/ 2 * <

z adresem IP rozpoczynającym się na $południowym wschodzie i przemieszczającym się (SE, heh), działa w następujący sposób:

$            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]
Cairney Coheringaahing
źródło
13
1. Trójkątny, 10 bajtów, A000217. * następuje link * A000217 Triangular numbers...
MD XF
22

73. Starry , 363 bajty, A000252

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

Wypróbuj online!

Następna sekwencja

Korzysta ze wzoru „ a(n) = n^4 * product p^(-3)(p^2 - 1)*(p - 1)gdzie produkt jest ponad wszystkimi liczbami pierwszymi p, które dzielą n” od OEIS.

Księżyc nie ma opozycji, ale hej, to nie jest golf golfowy.

Nie drzewo
źródło
gwiazdy na księżycu? hmmm
betseg
19

97. Python 3 (PyPy) , 1772 bajtów, A000236

Przede wszystkim bardzo dziękuję dr Maxowi Aleksiejewowi za cierpliwość wobec mnie. Mam szczęście, że mogłem skontaktować się z nim przez e-mail, aby zrozumieć to wyzwanie. Jego Math.SE odpowiedź tutaj pomógł mi dużo. Podziękowania dla Kreatora pszenicy za pomoc. :)

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

Wypróbuj online!

Jeśli daje zły wynik, po prostu zwiększ 100 do czegoś większego. Myślę, że 10000 będzie działać na 4, ale zostawię komputer na noc, aby to potwierdzić; zakończenie może potrwać kilka godzin.

Zauważ, że część (PyPy) jest po to, abym mógł ponownie używać Pythona. Naprawdę nie znam wielu innych języków i nie zamierzam przenosić tego na Javę i ryzykuję, że nie skończę na czas.

Następna sekwencja (Proszę, nie róbcie już żadnych szalonych zadań matematycznych; nie mam już żadnych wersji Pythona, więc ktoś inny będzie musiał zapisać to wyzwanie D :)

HyperNeutrino
źródło
cóż, zawsze jest pypy3
tylko ASCII
15

107. TrumpScript , 1589 bajtów, 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.

Wypróbuj online!

Przy pierwszym programowaniu w TrumpScript możliwe jest, że kilka razy wymyśliłem koło ponownie - 4 linie są przeznaczone do obliczania 2 ^ n. Starałem się, aby wyglądało to tak, jak mógł powiedzieć (pijany) Trump. Jako bonus, oto skrypt w języku Python, który napisałem, aby sprawdzić, czy wszystko robię dobrze. Istnieją pewne różnice w stosunku do powyższego programu, ale większość z nich jest bezpośrednio równoważna.

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)

Następna sekwencja!

NieDzejkob
źródło
3
I will make cat feel goodO_O
Business Cat
Niestety I will make Business Cat feel goodnie zadziała ...
NieDzejkob
14

30. Python 1 , 1112 bajtów, 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

Wypróbuj online!

Nawet nie zawracam sobie tym głowy golfa. Hej, to nie moja najdłuższa odpowiedź w języku Python na tej stronie!

Następna sekwencja

HyperNeutrino
źródło
1
Gratulujemy dekodowania matematyki: D
Leaky Nun
2
313 bajtów, lol
Leaky Nun
@LeakyNun Tak jak mówiłem, nie zawracałem sobie głowy graniem w ten lol. Poza tym nie jest to moja najdłuższa odpowiedź w języku Python na tej stronie, więc idc: P, ale fajnie
HyperNeutrino
@LeakyNun I dzięki: D Zajęło mi trochę czasu, aby to wszystko zrozumieć lol
HyperNeutrino
@LeakyNun 309 bajtów, ponieważ rzeczywista wartość nie _ma znaczenia; musimy to po prostu powtarzać wiele razy
HyperNeutrino
13

2. Haskell, 44 bajty, A000010

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

Wypróbuj online!

Następna sekwencja

Gajówka
źródło
12
Jednak nazwa następnej sekwencji ...
całkowicieludzki
@ Całkowicie ludzkie biedne króliki ...
Erik the Outgolfer
Czy powinniśmy link do poprzedniego postu?
Leaky Nun
Boli mnie, że nie mogę teraz grać w golfa. Musiałem być pierwszy, jak widzisz
BlackCap
Jaka jest następna sekwencja? Nie rozumiem tych trzech: P
Beta Decay
13

9. Pyth , 19 bajtów, A000025

?>Q0sm@_B1-edld./Q1

Zestaw testowy .

Następna sekwencja

a (n) = liczba partycji n o parzystej randze minus liczba o nieparzystej randze. Ranga partycji to jej największa część minus liczba części.

Leaky Nun
źródło
Dla tych, którzy znają Pytha, celowo użyłem >Q0zamiast Q, aby, wiesz, następną sekwencją była A000019.
Leaky Nun
1
Ze strony OEISKeywords: easy,nice
BlackCap
@LeakyNun Tak, bo inaczej musiałbym rozwiązać A000017 ... brutto.
Erik the Outgolfer
12

8. Mathematica (10.1), 25 bajtów, A000070

Tr@PartitionsP@Range@#+1&

Następna sekwencja

LegionMammal978
źródło
Idealna sekwencja dla Mathematica.
Leaky Nun
1
A000025 jest niezwykle trudny. Zamiast tego należy dodać bajt, aby uzyskać A000026. : P
MD XF
12

206. Proton , 3275 bajtów, 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))

Wypróbuj online!

Następna sekwencja

HyperNeutrino
źródło
Zaraz, właściwie to zrobiłeś? Jeśli nie napiszesz artykułu z tymi dziwacznymi programami i nie pójdziesz porozmawiać z jakimś profesorem, omijasz coś fajnego: P
Stephen
@Stephen Obecnie naprawia błąd lol
HyperNeutrino 10.10.17
Czy takie podejście polega na dzieleniu trójkątów, kwadratów i pięciokątów według plantri? Wygląda na to, że tak może być, ale część składni jest nieznana.
Peter Taylor,
1
@PeterTaylor Zakładając, że rozumiem podejście, które opisujesz, tak, szuka trójkątów i umieszcza wierzchołek przylegający do wszystkich 3 wierzchołków lub dwóch sąsiednich cykli i usuwa wspólną krawędź i umieszcza wierzchołek przylegający do wszystkich 4, taki sam dla 3 trójkątów na pięciokącie. Myślę, że to opisujesz.
HyperNeutrino,
1
@ChristianSievers math.stackexchange.com/a/2463430/457091
HyperNeutrino 10.10.17
12

308. ENIAC (symulator) , 3025 bajtów, A006060

Pseudo kod: 

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
}

Brak symulatora online, wynik wykonania: Wejście czytnika kart Wyjście karty dziurkacza

Rejestry i stałe: 

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

Przepływ sygnału programu i przepływ danych: Zaprogramuj przepływ sygnału i schemat przepływu danych

Pełny „kod” na pastebinie lub w komentarzach HTML w znacznikach tej odpowiedzi, aby zapobiec linkrotowi i dość długiej odpowiedzi do przewijania w tym samym czasie. To jest fajne!

Następna sekwencja

leo3065
źródło
Czy możesz dodać link do następnej sekwencji
Zacharý
@ Zacharý Link jest w poście. Przeniosę go na koniec wpisu, aby łatwiej go znaleźć.
leo3065
12

15. CJam, 85 bajtów, A000060

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

Demo online

Następna sekwencja

Sekcja

OEIS daje

Gf: S (x) + S (x ^ 2) -S (x) ^ 2, gdzie S (x) jest funkcją generującą dla A000151. - Pab Ter, 12 października 2005 r

gdzie

S(x)=x∏i≥11(1−xi)2s(i)=x∏i≥1(1+xi+x2i+…)2s(i)
{           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
źródło
1 minuta i 33 sekundy przede mną ... kiedy pisałem wyjaśnienie
Leaky Nun
11

67. LOLCODE , 837 bajtów, 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

Mój klawisz Capslock musi uciec, więc napisałem to wszystko, trzymając Shift.

Wypróbuj online!

Następna sekwencja

Gajówka
źródło
+1 za użyciePRAIME
Leaky Nun
3
Jesteś programistą, mógłbyś to napisać, a następnie uruchomić za pomocą skryptu w języku Python, który upperto zrobił.
Stephen
5
@StepHen Lub po prostu gggUGvim tam, gdzie to napisałem, ale nie jestem taki sprytny
BlackCap
10

10. Magma, 65 bajtów, A000019

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

Wypróbuj tutaj

wbudowane lol

Następna sekwencja

HyperNeutrino
źródło
@ETHproductions :) nie ma problemu, dziękuję stronie OEIS, ponieważ ma tam dokładnie wbudowane lol
HyperNeutrino
4
; _; Rozwiązałem A000064, a ty go zmieniłeś. Doceniony.
Leaky Nun
Mój Boże, tyle sekwencji partycji
ETHprodukcje
Przypadkowo rozwiązałem A007317 , próbując to zrobić w Pythonie ( TIO ): P
ETHproductions
Ponownie głosowałem! \ o /
Leaky Nun
9

121. Pip , 525 bajtów, 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

Demo online

Następna sekwencja

Ciekawostka: kiedy po raz pierwszy opublikowano wyzwanie, sporządziłem listę małych, nieprzyjemnych numerów sekwencji, które chciałem wycelować w CJam, a A000022 był na szczycie listy.

To implementuje funkcję generowania opisaną w EM Rains i NJA Sloane, On Cayley's Enumeration of Alkanes (or 4-Valent Trees) , Journal of Integer Sequences, tom. 2 (1999), biorąc sumę na tyle określeń, ile jest koniecznych do ustalenia współczynnika th, a następnie teleskopowo trzy czwarte sumy. W szczególności teleskopowanie pierwszej połowy oznacza, że ​​wskaźnik cyklu musi być zastosowany tylko do jednego z nich, a nie do wszystkich.CknS4Th

Kod rozkłada się jak

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

Zauważ, że jest to mój pierwszy w historii program Pip, więc prawdopodobnie nie jest bardzo idiomatyczny.

Peter Taylor
źródło
Komentarze nie są przeznaczone do rozszerzonej dyskusji; ta rozmowa została przeniesiona do czatu .
Dennis
9

156. C # (mono), 2466 bajtów, A000083

Uwaga: wynik wynosi 2439 bajtów dla kodu i 27 dla flagi kompilatora -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 online . Jest to pełny program, który pobiera dane z wiersza poleceń.

Następna sekwencja

Sekcja

Śledzę komentarz Bowena w OEIS, że funkcja generująca, w A000083(x) = A000237(x) + A035349(x) - A000237(x) * A035350(x)której funkcje generujące komponent są powiązane przez przekształcenia as

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

Używam definicje BIKi DIKz https://oeis.org/transforms2.html ale wzory wydają się mieć wiele literówek. Poprawiłem LPALbez większych trudności i samodzielnie wyprowadziłem wzór DIKoparty na zastosowaniu wyliczenia Pólyi do indeksu cyklu grupy dwuściennej . Między 121 a 156 dużo się uczę o wyliczaniu Pólyi. Przedłożyłem niektóre erraty , które mogą okazać się przydatne dla innych osób, jeśli te transformacje pojawią się ponownie w łańcuchu.

Peter Taylor
źródło
8

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

Wypróbuj online!

Brian J.
źródło
8

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

Wypróbuj online!

Mam nadzieję, że użycie Python 2 PyPy liczy się jako kolejna ważna wersja. Jeśli ktoś mógłby zdobyć dla mnie interpreter języka Python 0, mógłbym również tego użyć, ale mam nadzieję, że jest to poprawne.

Zaczyna się to od 1 wierzchołka i działa, tworząc macierz przyległości dla każdego możliwego niekierowanego wykresu z tyloma wierzchołkami. Jeśli jest trójwartościowy, przejrzy zestaw power krawędzi, który zostanie posortowany według długości. Jeśli pierwszy cykl, który znajdzie, jest zbyt krótki, przejdzie dalej. Jeśli pierwszy znaleziony cykl pasuje do wartości wejściowej (przesunięcie o 3), wyświetli prawidłową liczbę wierzchołków i zakończy działanie.

Next Sequence <- miej łatwą przerwę od wszystkich tych nonsensów matematycznych: D

EDYCJA : Dodałem kilka optymalizacji, aby uczynić go nieco szybszym (wciąż nie mogę obliczyć trzeciego terminu w granicach 60 sekund TIO) bez zmiany liczby bajtów.

HyperNeutrino
źródło
... i poważnie myślałem, że łańcuch zakończy się odpowiedzią 90
pppery
1
@ppperry :) Lubię robić trudne wyzwania, ponieważ większość ludzi nie potrafi nawet rozwiązać problemu, więc nie muszę się martwić, że zostanę wyrzucony z gry :) (np. problem z nazwą łańcucha węglowego)
HyperNeutrino
Chyba, że ​​ktoś przyjmie twoje rozwiązanie i przekształci je w krótszy język
pppery
@ppperry that too o_O: P
HyperNeutrino
1
@HyperNeutrino Gratulujemy rozwiązania! Martwiłem się, że zerwałem łańcuch i rozważałem uzupełnienie liczby bajtów, aby wskazać inną sekwencję. Dobra robota!
Scott Milner,
8

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

Wypróbuj online!

Polyglot z Javascriptem. Wypróbuj online!

Następna sekwencja .

Użyj wzoru na stronie OEIS dla O(n^2 log n)złożoności, a nie naiwności O(n^6).

Szybkie wyjaśnienie:

  • W tym kodzie zastosowano wzór 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)opisany w sekcji kodu Mathematica.

  • Dowód formuły:

    • Wzór jest równoważny z tym .

    • Niech wielkość ramki ograniczającej trzech punktów będzie m * k. Rozważ 2 przypadki:

      • k != 0oraz m != 0: Istnieją 2 sposoby wyboru orientacji trzech punktów ( \lub /), gcd(k-1, m-1)-1sposoby wyboru punktu leżącego pomiędzy pozostałymi 2 punktami oraz (n - k) × (n - m)sposoby wyboru położenia ramki granicznej.
      • k == 0lub m == 0: Istnieją 2 sposoby wyboru orientacji ( |lub -), nsposoby wyboru wiersza / kolumny, na których leżą punkty, oraz Binomial[n, 3] == (n*(n-1)*(n-2)) / 6sposoby wyboru punktów w tym rzędzie / kolumnie.

Niektóre notatki poliglotyczne:

  • Funky tak naprawdę nie ma słowa kluczowego return. Jednak, jak wyjaśnił ATaco , [Funky] uważa, że returnjest zmienną. Więc analizuje to wyrażenie, które wygodnie nic nie robi, a następnie analizuje następne wyrażenie. I to jest używane jako wynik.
  • JavaScript używa ^jako bitowej xor, w przeciwieństwie do Funky, który wykorzystuje ^jako potęgowanie. Dlatego n*nnależy go używać zamiast w n^2celu zapewnienia zgodności z Javascriptem.
  • W funky, wszystko operatora ( +, -, *, itd.) Mają równe pierwszeństwo iw prawo zrzeszania się, więc wyrażenia muszą być odpowiednio umieszczone w nawiasach.
użytkownik202729
źródło
1
+1 nie spodziewał się poliglota.
ATaco
Nie ma Pentagony, ale Hexagony pasuje dobrze.
NieDzejkob
Ten bytecount był już używany ... link
NieDzejkob
Tak więc, aby rozwiązać problem z liczbą bajtów, czy mógłbyś wpisać tę odpowiedź do 330 bajtów? Zajmę się resztą.
NieDzejkob,
[Odpowiedź uzupełniono do 332 bajtów z powodu konfliktu liczby bajtów, zobacz ten komunikat na czacie ]
user202729
8

11. Pari / GP, 64 bajty, A000065

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

Wypróbuj online!

Następna sekwencja

MD XF
źródło
Czy to prawidłowe dane wejściowe?
Leaky Nun
Czy trzeba było dostać 64 bajty? : P
totalnie ludzki,
@totallyhuman yes:;_; I solved A000064 and you changed it. Downvoted.
Stephen
@totallyhuman kompromisy lol. patrz czat
HyperNeutrino
Dang
Mr. Xcoder,
8

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

Wypróbuj online!

Dygresja:

  1. Testowane lokalnie w Javie 5. (takie, że ostrzeżenie nie jest drukowane - patrz karta debugowania TIO)
  2. Nie rób Zawsze. Posługiwać się. Jawa. 1. Jest bardziej szczegółowy niż Java.
  3. Może to przerwać łańcuch.
  4. Różnica (7 dni i 48 minut) to nie więcej niż przerwa utworzona przez tę odpowiedź , która wynosi 7 dni i 1 godziny i 25 minut później niż poprzednia .
  5. Nowy rekord na dużej liczbie bajtów! Ponieważ (błędnie?) Używam spacji zamiast tabulatorów, liczba bajtów jest większa niż to konieczne. Na mojej maszynie jest to 9550 bajtów. (w momencie pisania tej wersji)
  6. Następna sekwencja .
  7. Kod, w obecnej formie, drukuje tylko pierwsze 20 terminów sekwencji. Łatwo to jednak zmienić, aby wydrukować pierwsze 1000 elementów (poprzez zmianę 20w for (int i = 0; i < 20; ++i)na 1000)

Tak! Może to obliczyć więcej terminów niż te wymienione na stronie OEIS! (po raz pierwszy, dla wyzwania muszę używać Java), chyba że OEIS ma gdzieś więcej warunków ...

Szybkie wyjaśnienie

Objaśnienie opisu sekwencji.

Sekwencja pyta o liczbę wolnych nieplanarnych polenoidów z grupą symetrii C 2v , gdzie:

  • polenoid: (model matematyczny węglowodorów polienowych) drzewa (lub w zdegenerowanym przypadku, pojedynczy wierzchołek) z mogą być osadzone w sieci sześciokątnej.

Weźmy na przykład drzewa

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

Pierwszy nie może być osadzony w sześciokątnej kratce, podczas gdy drugi może. To szczególne osadzenie jest uważane za różne od trzeciego drzewa.

  • nieplanarny polenoid: osadzanie drzew w taki sposób, że istnieją dwa zachodzące na siebie wierzchołki.

(2)a (3)drzewo powyżej jest płaskie. Ten jest jednak niepłaski:

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

(jest 7 wierzchołków i 6 krawędzi)

  • wolny polienoid: warianty jednego polienoidu, które można uzyskać przez obrót i odbicie, są liczone jako jeden.

  • Grupa C 2v : Polienoidy są liczone tylko wtedy, gdy mają 2 prostopadłe płaszczyzny odbicia i nie więcej.

Na przykład jedyny polienoid z 2 wierzchołkami

O --- O

ma 3 płaszczyzny odbicia: poziomy -, pionowy |i równoległy do ​​ekranu komputera ■. To za dużo.

Z drugiej strony ten

O --- O
       \
        \
         O

ma 2 płaszczyzny refleksji: /i ■.

Objaśnienie metody

A teraz podejście do tego, jak liczyć liczbę.

Po pierwsze, biorę formułę a(n) = A000063(n + 2) - A000936(n)(wymienioną na stronie OEIS) za pewnik. Nie przeczytałem wyjaśnienia w gazecie.

[TODO napraw tę część]

Oczywiście liczenie planarne jest łatwiejsze niż liczenie niepłaskie. To właśnie robi papier.

Geometrycznie płaskie polenoidy (bez nakładających się wierzchołków) są wyliczane przez programowanie komputerowe. W ten sposób liczba geometrycznie niepłaskich polenoidów staje się dostępna.

Więc ... program zlicza liczbę płaskich polenoidów i odejmuje ją od sumy.

Ponieważ drzewo i tak jest płaskie, ma oczywiście ■płaszczyznę odbicia. Zatem warunek sprowadza się do „zliczenia liczby drzew z osią odbicia w ich reprezentacji 2D”.

Naiwnym sposobem byłoby wygenerowanie wszystkich drzew z nwęzłami i sprawdzenie poprawności symetrii. Ponieważ jednak chcemy znaleźć tylko liczbę drzew z osią odbicia, możemy po prostu wygenerować wszystkie możliwe pół-drzewa na jednej połowie, odbić je przez oś, a następnie sprawdzić poprawność symetrii. Ponadto, ponieważ generowane polioidy są drzewami (płaskimi), muszą dokładnie dotknąć osi odbicia.

Funkcja public static Graph[] expand(Graph[] graphs, Point.Predicate fn)pobiera tablicę wykresów, z których każdy ma nwęzły i wyprowadza tablicę wykresu, każdy ma n+1węzły, które nie są sobie równe (w tłumaczeniu) - tak, że dodany węzeł musi spełniać predykat fn.

Rozważ 2 możliwe osie odbicia: jedną przechodzącą przez wierzchołek i pokrywającą się z krawędziami ( x = 0) oraz drugą, która jest prostopadłą dwusieczną krawędzi ( 2x = y). Możemy wziąć tylko jeden z nich, ponieważ generowane wykresy są zresztą izomorficzne.

Tak więc, dla pierwszej osi x = 0, zaczynamy od wykresu podstawowego składającego się z pojedynczego węzła (1, 0)(w przypadku, gdy njest nieparzysty) lub dwóch węzłów z krawędzią pomiędzy (1, 0) - (2, 0)(w przypadku, gdy njest parzysty), a następnie rozwiń węzły, aby y > 0. Odbywa się to w sekcji programu „Typ odbicia 1”, a następnie dla każdego wygenerowanego wykresu odbij się (odbicie lustrzane) przez oś X x = 0( g.reflectSelfX()), a następnie sprawdź, czy ma prawidłową symetrię.

Zauważ jednak, że jeśli nmożna podzielić przez 2, w ten sposób policzyliśmy każdy wykres dwukrotnie, ponieważ generujemy również jego odbicie lustrzane według osi 2x = y + 3.

(zwróć uwagę na 2 pomarańczowe)

Podobnie dla osi 2x = y, jeśli (i tylko jeśli) njest parzysta, zaczynamy od punktu (1, 1), generujemy wykresy, które 2*x > yodbijają każdy z nich nad 2x = yosią ( g.reflectSelfType2()), łączymy (1, 0)się (1, 1)i sprawdzamy, czy mają prawidłową symetrię. Pamiętaj też o podzieleniu przez 2.

użytkownik202729
źródło
Biorąc pod uwagę, że spałem, kiedy opublikowano ten (i ten drugi), dam ci korzyść z wątpliwości i jeszcze nie przyjmuję odpowiedzi.
caird coinheringaahing
2
@cairdcoinheringaahing Byłeś online 3 minuty przed terminem ...
user202729,
Och, następna sekwencja może być zakodowana na stałe ... (chociaż jest nieskończona), jeśli poprawnie ją odczytam. Samo obliczenie jest --- dość --- bardzo łatwe, więc nie rób tego.
user202729,
7

6. R , 71 bajtów, A000072

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

Wypróbuj online!

Następna sekwencja

Leaky Nun
źródło
1
Na miłość boską nie sprawdziłem następnej sekwencji przed opublikowaniem tej odpowiedzi.
Leaky Nun
Czy łatwa kolejna sekwencja nie jest strategiczną przewagą?
BlackCap
@BlackCap Nie mogą odpowiedzieć dwa razy z rzędu lub krócej niż 1 godzinę po ostatniej odpowiedzi.
Erik the Outgolfer
@EriktheOutgolferthe answer before the last posted (the one who didn't break the chain) will win
BlackCap
@BlackCap w tym momencie to się nie wydarzy
Stephen
7

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

Ocenia rekurencyjną formułę znalezioną na łączu OEIS.

Następna sekwencja

Scott Milner
źródło
Agh, wiedziałem, kiedy strona się zepsuła, że ​​będzie szalony pośpiech, gdy wróci. Ledwo mnie bije.
Silvio Mayolo,
Nie zdawałem sobie sprawy, że witryna uległa awarii ...
Scott Milner,
twitter.com/Nick_Craver/status/888553194313449472
Silvio Mayolo
7

49. SageMath , 74 bajty, A000003

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

Wypróbuj online!

Następna sekwencja

alephalpha
źródło
Właśnie spędziłem godzinę, próbując opracować tę sekwencję za pomocą JavaScript ... no cóż, będę musiał przejść do następnej ...
ETHproductions
7

76. Pigmej , 4147 bajtów, 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                                         
}

Następna sekwencja

Możesz uruchomić kod na tej stronie . Na przykład możesz uzyskać 10. liczbę w sekwencji, kopiując powyższy kod i dodając:

alert| A000035| 10
Peter Olson
źródło
4
... następna sekwencja jest nieobliczalna ...
HyperNeutrino
1
@HyperNeutrino Wiem: PI zrobił to celowo
Peter Olson
Zło ...>. <Ale tak czy inaczej, po prostu na stałe zakoduję 4 elementy w sekwencji. Dość łatwe xD OP zatwierdza to najwyraźniej ¯ \ _ (ツ) _ / ¯
HyperNeutrino