Un OEIS dopo l'altro


94

Dal 13/03/2018 alle 16:45 UTC, il vincitore è la risposta # 345 , di Scrooble . Ciò significa che il concorso è ufficialmente terminato, ma sentiti libero di continuare a pubblicare risposte, purché rispettino le regole.

Inoltre, basta un breve grido ai primi tre risponditori in termini di numero di risposte:

1. NieDzejkob - 41 risposte

2. KSmarts - 30 risposte

3. Hyper Neutrino - 26 risposte


Questa è una domanda concatenata di risposta che utilizza sequenze di OEIS e la lunghezza dell'invio precedente.

Questa domanda concatenata di risposta funzionerà nel modo seguente:

  • Pubblicherò la prima risposta. Tutte le altre soluzioni devono derivare da questo.
  • L'utente successivo (chiamiamoli userA) troverà la sequenza OEIS in cui il suo numero indice (vedi sotto) è uguale alla lunghezza del mio codice.
  • Usando la sequenza, devono quindi codificare, in una lingua inutilizzata , un programma che accetta un numero intero come input, n, e genera l'ennesimo numero in quella sequenza.
  • Successivamente, pubblicano la loro soluzione dopo la mia e un nuovo utente (userB) deve ripetere la stessa cosa.

Il ntermine di una sequenza è il termine n volte dopo il primo, lavorando con il primo valore come primo valore dato nella sua pagina OEIS. In questa domanda, utilizzeremo l' indicizzazione 0 per queste sequenze. Ad esempio, con A000242 e n = 3il risultato corretto sarebbe 25 .

Però!

Questo non è un , quindi il codice più breve non ha importanza. Ma la lunghezza del tuo codice ha ancora un impatto. Per evitare la duplicazione delle sequenze, il tuo bytecount deve essere unico . Ciò significa che nessun altro programma inviato qui può avere la stessa lunghezza in byte del tuo.

Se non c'è una sequenza per la lunghezza dell'ultimo post, la sequenza per il tuo post è la sequenza più bassa inutilizzata. Ciò significa che anche le sequenze utilizzate devono essere univoche e che la sequenza non può essere la stessa del tuo conto secondario.

Dopo che una risposta è stata pubblicata e non sono state pubblicate nuove risposte per più di una settimana, la risposta prima dell'ultimo postato (quella che non ha interrotto la catena) vincerà.

Ingresso e uscita

Si applicano regole di input e output generiche. L'input deve essere un numero intero o una rappresentazione in formato stringa di un numero intero e l'output deve essere il valore corretto nella sequenza.

formattazione

Come per la maggior parte delle , si prega di formattare la risposta in questo modo

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

`code`

[next sequence](link)

*anything else*

Regole

  • Devi aspettare almeno 1 ora prima di inviare una risposta, dopo aver pubblicato.
  • Non puoi postare due volte (o più) di seguito.
  • Il numero indice di una sequenza è il numero dopo la Aparte e con zeri iniziali rimossi (ad es. Per A000040il numero indice è 40)
  • Puoi presumere che né l'input né l'output richiesto saranno al di fuori dell'intervallo numerico delle tue lingue, ma per favore non abusarne scegliendo una lingua che può usare solo il numero 1, ad esempio.
  • Se la lunghezza dell'invio è superiore a 65536 caratteri, fornire un collegamento a un modo per accedere al codice (ad esempio pastebin).
  • n non sarà mai maggiore di 1000 o fuori dai limiti della sequenza, semplicemente per impedire che discrepanze di precisione impediscano a una lingua di competere.
  • Ogni 150 (valide) risposte, aumenta il numero di volte in cui una lingua può essere utilizzata. Quindi, dopo che sono state pubblicate 150 soluzioni, ogni lingua può essere utilizzata due volte (con tutte le risposte precedenti che contano in questo senso). Ad esempio, quando sono state pubblicate 150 risposte, Python 3 può essere usato due volte, ma a causa del fatto che è già stato usato una volta, ciò significa che può essere usato solo una volta di più fino a quando non sono state pubblicate 300 risposte.
  • Sii utile e pubblica un link alla sequenza successiva da utilizzare. Questo non è richiesto, ma è una raccomandazione.
  • Versioni diverse di lingue, ad esempio Python 2 e Python 3 sono lingue diverse . Come regola generale, se le diverse versioni sono entrambe disponibili su Try It Online, sono lingue diverse, ma tieni presente che questa è una regola generale e non una risposta rigida.
  • Non è vietato, ma prova a non copiare il codice dalla pagina OEIS e prova effettivamente a risolverlo.
  • L'hardcoding è consentito solo se la sequenza è finita. Si noti che la risposta che ha richiesto questo ( # 40 ) è l'eccezione alla regola. Alcune risposte all'inizio del codice hard della catena, ma queste possono essere ignorate, poiché non è utile eliminare la catena fino, per esempio, al numero 100.

Snippet della catena di risposta


I commenti non sono per una discussione estesa; questa conversazione è stata spostata in chat .
Dennis,

Va bene se un programma avrebbe bisogno di una migliore precisione in virgola mobile per il tipo float/ incorporato doubleper produrre valori più grandi n?
NieDzejkob,

1
@Giuseppe No, mentre stai generando i numeri facendo i calcoli, piuttosto che metterli in un array / stringa
caird coinheringaahing

2
@cairdcoinheringaahing Secondo me questo è hardcoding della costante gamma. Non funziona "in teoria" per numeri più grandi.
user202729

Risposte:


4

345. brainfuck , 162 byte, A000301

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

Provalo online!

Prossima sequenza!

Questo prende come input il carattere con il punto di codice n(secondo le specifiche di BF) e lo produce allo stesso modo. Per vedere i numeri, suggerisco di usare EsotericIDE di @ Timwi .

Spiegazione:

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

Dal momento che questo memorizza tutti i numeri di Fibonacci fino a quello importante, fallirà per un input DAVVERO grande su un nastro limitato.

Ciò potrebbe essere abbreviato in modo significativo codificando la base (2), ma il golfiness non è affatto un problema.


Mentre la prossima risposta (# 346) ha rotto la catena, la tua risposta è il vincitore!
caird coinheringaahing

1
@cairdcoinheringaahing Grazie per questa fantastica sfida. Mi rattrista che dovrebbe finire adesso, ma come tutte le cose buone del mondo, finiscono per farlo. Ora a golf questa povera scusa per il codice, perché ora è la prima risposta che chiunque vedrà, e deve essere incredibilmente breve ...
Khuldraeseth na'Barya

@Scrooble non puoi davvero cambiare la lunghezza ...
NieDzejkob

@NieDzejkob Sì, ma posso giocare a golf e aggiungere qualche altra imbottitura, per mantenere la stessa lunghezza.
Khuldraeseth na'Barya,

@cairdcoinheringaahing "ha rotto la catena"? Cosa significa?
Magic Octopus Urn

40

22. FiM ++ , 982 byte, A000024

Nota : se stai leggendo questo, potresti voler ordinare per "più vecchio".

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

Prossima sequenza


10
Hahaha, ha riso così tanto per tutto. +1 per la scelta della lingua :-)
ETHproductions

Incredibile, prendi il mio
voto

22

1. Triangolare , 10 byte, A000217

$\:_%i/2*<

Provalo online!

Prossima sequenza

Come funziona

Il codice si formatta in questo triangolo

   $
  \ :
 _ % i
/ 2 * <

con l'IP che inizia a $sud-est e si sposta (SE, eh), funziona così:

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

13
1. Triangolare, 10 byte, A000217. * segue il collegamento * A000217 Triangular numbers...
MD XF del

22

73. Stellato , 363 byte, A000252

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

Provalo online!

Prossima sequenza

Utilizza la formula " a(n) = n^4 * product p^(-3)(p^2 - 1)*(p - 1)dove il prodotto è sopra tutti i numeri primi p che dividono n" da OEIS.

La luna è una no-op, ma ehi, questo non è il golf del codice.


stelle nella luna? hmmm
betseg

19

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

Innanzitutto, molte grazie al Dr. Max Alekseyev per essere stato paziente con me. Sono molto fortunato di essere riuscito a contattarlo via e-mail per comprendere questa sfida. La sua risposta Math.SE qui mi ha aiutato molto. Grazie a Wheat Wizard per avermi aiutato. :)

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

Provalo online!

Se dà il risultato sbagliato, aumenta il 100 a qualcosa di più grande. Penso che 10000 funzionerà per 4 ma lascerò il mio computer acceso durante la notte per confermarlo; potrebbero essere necessarie alcune ore per terminare.

Nota che la parte (PyPy) è solo per poter usare nuovamente Python. Davvero non conosco molte altre lingue e non proverò a portarlo su Java e rischi di non finire in tempo.

Prossima sequenza (Inoltre, per favore, non fare più cose folli in matematica; Non mi sono rimaste versioni di Python, quindi qualcun altro dovrà salvare questa sfida D :)


bene c'è sempre pypy3
solo ASCII il

15

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

Provalo online!

La prima volta che ho programmato in TrumpScript, è possibile che ho reinventato la ruota alcune volte: 4 linee sono dedicate al calcolo di 2 ^ n. Ho provato a farlo sembrare qualcosa che (ubriaco) Trump potesse dire. Come bonus, ecco uno script Python che ho scritto per verificare che sto facendo tutto bene. Ci sono alcune differenze rispetto al programma sopra, ma gran parte di esso è direttamente equivalente.

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

Prossima sequenza!


3
I will make cat feel goodO_O
Business Cat

Purtroppo I will make Business Cat feel goodnon funzionerà ...
NieDzejkob,

14

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

Provalo online!

Nemmeno si preoccuperà di giocare a golf. Ehi, non è la mia risposta Python più lunga su questo sito!

Prossima sequenza


1
Congratulazioni per aver decodificato la matematica: D
Leaky Nun il


@LeakyNun Come stavo dicendo, non mi sono preoccupato di giocare a golf in questo lol. Inoltre, non è la mia risposta Python più lunga su questo sito così idc: P ma carino
HyperNeutrino,

@LeakyNun E grazie: D Mi ci è voluto un po 'per capire tutto lol
HyperNeutrino,

@LeakyNun 309 byte perché il valore effettivo di _è irrilevante; dobbiamo solo ripeterlo molte volte
HyperNeutrino,


13

9. Pyth , 19 byte, A000025

?>Q0sm@_B1-edld./Q1

Suite di test .

Prossima sequenza

a (n) = numero di partizioni di n con rango pari meno numero con rango dispari. Il rango di una partizione è la sua parte più grande meno il numero di parti.


Per coloro che conoscono Pyth, ho usato deliberatamente >Q0invece di Q, per avere una sequenza successiva, A000019.
Leaky Nun,

1
Dalla pagina OEISKeywords: easy,nice
BlackCap

@LeakyNun Sì, poiché altrimenti dovrei risolvere A000017 ... disgustoso.
Erik the Outgolfer,


12

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

Provalo online!

Prossima sequenza


Aspetta, l'hai fatto davvero? Se non scrivi un documento con questi programmi eccentrici e vai a parlare con un professore, stai tramandando qualcosa di interessante: P
Stephen,

@Stephen Attualmente correzione bug lol
HyperNeutrino,

È questo l'approccio della divisione di triangoli, quadrati e pentagoni secondo i plantri? Sembra che potrebbe essere, ma parte della sintassi non è familiare.
Peter Taylor,

1
@PeterTaylor Supponendo che comprendo l'approccio che stai descrivendo, sì, cerca triangoli e posiziona un vertice adiacente a tutti e 3 i vertici, oppure due cicli adiacenti ed elimina il bordo comune e posiziona un vertice adiacente a tutti e 4, lo stesso per 3 triangoli su un pentagono. Penso che sia quello che stai descrivendo.
HyperNeutrino,


12

308. ENIAC (simulatore) , 3025 byte, A006060

pseudocodice:

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
}

Nessun simulatore online, risultato di esecuzione: Ingresso lettore di schede Uscita della scheda perforata

Registri e costanti:

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

Flusso del segnale del programma e flusso di dati: Flusso del segnale del programma e diagramma del flusso di dati

"Codice" completo su pastebin o nei commenti HTML nel markup di questa risposta, per evitare linkrot e una risposta abbastanza lunga da scorrere contemporaneamente. Questo è divertente!

Prossima sequenza


Potresti aggiungere un link alla sequenza successiva per favore
Zacharý

@ Zacharý Il link è nel post. Lo sposterò alla fine del post in modo che sia più facile da trovare.
leo3065,

12

15. CJam, 85 byte, A000060

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

Demo online

Prossima sequenza

Dissezione

OEIS dà

Gf: S (x) + S (x ^ 2) -S (x) ^ 2, dove S (x) è la funzione generatrice di A000151. - Pab Ter, 12 ottobre 2005

dove

S(X)=XΠio11(1-Xio)2S(io)=XΠio1(1+Xio+X2io+...)2S(io)
{           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)

1 minuto e 33 secondi davanti a me ... mentre scrivevo la spiegazione
Leaky Nun,

11

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

La mia chiave maiuscola è destinata a scappare, quindi ho scritto l'intera cosa tenendo premuto MAIUSC ..

Provalo online!

Prossima sequenza


+1 per l'utilizzoPRAIME
Leaky Nun,

3
Sei un programmatore, avresti potuto scrivere questo e poi eseguirlo attraverso uno script Python che upperlo ha fatto.
Stephen Stephen

5
@StepHen O semplicemente gggUGin vim dove l'ho scritto, ma non sono così intelligente
BlackCap

10

10. Magma, 65 byte, A000019

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

Provalo qui

lol builtin

Prossima sequenza


@ETHproductions :) nessun problema, grazie alla pagina OEIS anche se ha esattamente lì incorporato lol
HyperNeutrino

4
; _; Ho risolto A000064 e l'hai cambiato. Downvoted.
Leaky Nun,

Mio Dio, tante sequenze di partizioni
ETHproductions

Ho risolto accidentalmente A007317 mentre cercavo di farlo in Python ( TIO ): P
ETHproductions

Re-upvoted! \ o /
Leaky Nun,


9

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

Prossima sequenza

Curiosità: quando la sfida è stata pubblicata per la prima volta, ho redatto un elenco di piccoli numeri di sequenza cattivi che volevo puntare con CJam e A000022 era in cima alla lista.

Questo implementa la funzione generatrice descritta in EM Rains e NJA Sloane, On Cayley's Enumeration of Alkanes (or 4-Valent Trees) , Journal of Integer Sequences, Vol. 2 (1999), prendendo la somma per tutti i termini necessari per fissare il th coefficiente e poi telescopizzando tre quarti della somma. In particolare, telescopizzare la prima metà significa che l'indice di ciclo di deve essere applicato solo a uno piuttosto che a tutti.CknS4Th

Il codice si scompone come

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

Nota che questo è il mio primo programma Pip, quindi probabilmente non è molto idiomatico.


I commenti non sono per una discussione estesa; questa conversazione è stata spostata in chat .
Dennis,

9

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

Nota: il punteggio è 2439 byte per il codice e 27 per il flag del compilatore -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 . Questo è un programma completo che accetta input dalla riga di comando.

Prossima sequenza

Dissezione

Seguo il commento di Bowen in OEIS che la funzione di generazione in A000083(x) = A000237(x) + A035349(x) - A000237(x) * A035350(x)cui le funzioni di generazione del componente sono correlate da trasformazioni come

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

Uso le definizioni di BIKe DIKda https://oeis.org/transforms2.html ma le formule sembrano avere un certo numero di errori di battitura. Ho corretto LPALsenza troppe difficoltà e ho derivato in modo indipendente una formula DIKbasata sull'applicazione dell'enumerazione di Pólya all'indice di ciclo del gruppo diedrico . Tra il n. 121 e il n. 156 sto imparando molto sull'enumerazione di Pólya. Ho presentato alcuni errata , che possono rivelarsi utili ad altre persone se queste trasformazioni si ripresentano nella catena.



8

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

Provalo online!


8

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

Provalo online!

Spero che usare Python 2 PyPy conti come un'altra versione principale. Se qualcuno potesse procurarmi un interprete Python 0, anch'io potrei usarlo, ma spero che sia valido.

Questo inizia con 1 vertice e funziona, creando la rappresentazione della matrice di adiacenza di ogni possibile grafico non orientato con quel numero di vertici. Se è trivalente, allora guarderà attraverso il powerset dei bordi, che saranno ordinati per lunghezza. Se il primo ciclo che trova è troppo corto, allora andrà avanti. Se il primo ciclo che trova corrisponde all'input (offset di 3), verrà emesso il conteggio dei vertici corretto e terminato.

Prossima sequenza <- fatevi una pausa facile da tutte queste sciocchezze matematiche: D

EDIT : ho aggiunto alcune ottimizzazioni per renderlo un po 'più veloce (comunque non riesco ancora a calcolare il terzo termine entro il limite di 60 secondi di TIO) senza cambiare il byte.


... e pensavo seriamente che la catena sarebbe finita con la risposta 90
pepery

1
@ppperry :) Mi piace fare le sfide difficili perché la maggior parte delle persone non possono nemmeno fare una soluzione in modo che non devono preoccuparsi di ottenere outgolfed :) (ad esempio, il problema di carbonio Namer catena)
HyperNeutrino

A meno che qualcuno non prenda la tua soluzione e la converta in un linguaggio più
terser

@ppperry that too o_O: P
HyperNeutrino

1
@HyperNeutrino Complimenti per averlo risolto! Ero preoccupato di aver spezzato la catena e stavo considerando di riempire il conteggio dei byte per indicare una sequenza diversa. Buon lavoro!
Scott Milner,

8

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

Provalo online!

Poliglotta con Javascript. Provalo online!

Prossima sequenza .


Utilizzare la formula nella pagina OEIS per O(n^2 log n)complessità, anziché ingenuo O(n^6).

Spiegazione veloce:

  • Questo codice utilizza la formula 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)descritta nella sezione del codice Mathematica.
  • A prova di formula:

    • La formula è equivalente a questo .

    • Lascia che la dimensione del rettangolo di selezione di tre punti sia m * k. Considera 2 casi:

      • k != 0e m != 0: ci sono 2 modi per scegliere l'orientamento dei tre punti ( \o /), i gcd(k-1, m-1)-1modi per scegliere il punto si trovano tra gli altri 2 punti e i (n - k) × (n - m)modi per scegliere la posizione del rettangolo di selezione.
      • k == 0oppure m == 0: ci sono 2 modi per scegliere l'orientamento ( |o -), i nmodi per scegliere la riga / colonna su cui si trovano i punti e i Binomial[n, 3] == (n*(n-1)*(n-2)) / 6modi per scegliere i punti su quella riga / colonna.

Alcune note poliglotta:

  • Funky non ha davvero una parola chiave return. Tuttavia, come spiegato da ATaco , [Funky] pensa che returnsia una variabile. Quindi sta analizzando quell'espressione, che convenientemente non fa nulla, quindi analizza l'espressione successiva. E questo è usato come output.
  • Javascript usa ^come bit xor, a differenza di Funky che usano ^come esponenziazione. Quindi n*ndevono essere utilizzati invece di n^2garantire la compatibilità Javascript.
  • In Funky, tutto operatore ( +, -, *, etc.) hanno uguale precedenza e destra-associativo, così le espressioni devono essere tra parentesi correttamente.

1
+1 non si aspettava un poliglotta.
ATaco,

Non c'è Pentagonia, ma Hexagony si adatta bene.
NieDzejkob,

Questo byte è stato già utilizzato ... link
NieDzejkob il

Quindi, per risolvere il problema di bytecount, potresti riempire questa risposta a 330 byte? Mi occuperò del resto.
NieDzejkob,

[Risposta riempita a 332 byte a causa di problemi conflittuali bytecount, vedi questo messaggio di chat ]
user202729


8

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

Provalo online!


Nota a margine:

  1. Testato localmente con Java 5. (in modo tale che l'avviso non sia stampato - consultare la scheda debug TIO)
  2. Non farlo. Mai. Uso. Giava. 1. È più dettagliato di Java in generale.
  3. Questo potrebbe spezzare la catena.
  4. Il divario (7 giorni e 48 minuti) non è altro che il divario creato da questa risposta , che è di 7 giorni e 1 ora e 25 minuti più tardi rispetto al precedente .
  5. Nuovo record su grande byte! Poiché io (erroneamente?) Uso gli spazi anziché le schede, il bytecount è più grande del necessario. Sulla mia macchina sono 9550 byte. (al momento in cui scrivo questa revisione)
  6. Prossima sequenza .
  7. Il codice, nella sua forma attuale, stampa solo i primi 20 termini della sequenza. Tuttavia è facile da cambiare in modo che stia stampando i primi 1000 articoli (cambiando 20in for (int i = 0; i < 20; ++i)in 1000)

Sìì! Questo può calcolare più termini di quelli elencati nella pagina OEIS! (per la prima volta, per una sfida, devo usare Java) a meno che OEIS non abbia più termini da qualche parte ...


Spiegazione veloce

Spiegazione della descrizione della sequenza.

La sequenza richiede il numero di polienoide non piano libero con gruppo di simmetria C 2v , dove:

  • polienoide: (modello matematico degli idrocarburi polienici) gli alberi (o in caso degenerato, vertice singolo) possono essere incorporati in un reticolo esagonale.

Ad esempio, considera gli alberi

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

Il primo non può essere incorporato nel reticolo esagonale, mentre il secondo può essere incorporato. Quel particolare incorporamento è considerato diverso dal terzo albero.

  • polienoide non piano: inclusione di alberi in modo tale che esistano due vertici sovrapposti.

(2)e l' (3)albero in alto sono planari. Questo, tuttavia, non è planare:

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

(ci sono 7 vertici e 6 bordi)

  • polienoide libero: le varianti di un polienoide, ottenibili mediante rotazione e riflessione, sono conteggiate come una sola.

  • Gruppo C 2v : i polienoidi vengono contati solo se hanno 2 piani perpendicolari di riflessione e non di più.

Ad esempio, l'unico polienoide con 2 vertici

O --- O

ha 3 piani di riflessione: quello orizzontale -, quello verticale |e quello parallelo allo schermo del computer . È troppo.

D'altra parte, questo

O --- O
       \
        \
         O

ha 2 piani di riflessione: /e .


Spiegazione del metodo

E ora, l'approccio su come contare effettivamente il numero.

Innanzitutto, prendo la formula a(n) = A000063(n + 2) - A000936(n)(elencata nella pagina OEIS) per scontata. Non ho letto la spiegazione nel documento.

[TODO corregge questa parte]

Ovviamente, contare il planare è più semplice del conteggio non planare. Questo è anche quello che fa il giornale.

I polienoidi geometricamente planari (senza vertici sovrapposti) sono elencati dalla programmazione del computer. In questo modo il numero di polienoidi geometricamente non piani diventa accessibile.

Quindi ... il programma conta il numero di polienoide planare e lo sottrae dal totale.

Poiché l'albero è comunque planare, ovviamente ha il piano di riflessione. Quindi la condizione si riduce a "contare il numero di albero con un asse di riflessione nella sua rappresentazione 2D".

Il modo ingenuo sarebbe generare tutti gli alberi con nnodi e verificare la corretta simmetria. Tuttavia, poiché vogliamo solo trovare il numero di alberi con un asse di riflessione, possiamo semplicemente generare tutto il possibile mezzo albero su metà, rispecchiarli attraverso l'asse e quindi verificare la corretta simmetria. Inoltre, poiché i polienoidi generati sono alberi (planari), devono toccare l'asse di riflessione esattamente una volta.

La funzione public static Graph[] expand(Graph[] graphs, Point.Predicate fn)accetta una matrice di grafici, ognuno ha nnodi e genera una matrice di grafici, ognuno ha n+1nodi, non uguali tra loro (in fase di traduzione) - in modo tale che il nodo aggiunto deve soddisfare il predicato fn.

Considera 2 possibili assi di riflessione: uno che attraversa un vertice e coincide con i bordi ( x = 0) e uno che è la bisettrice perpendicolare di un bordo ( 2x = y). Possiamo prenderne solo uno perché i grafici generati sono comunque isomorfi.

Quindi, per il primo asse x = 0, partiamo dal grafico di base costituito da un singolo nodo (1, 0)(nel caso nsia dispari) o da due nodi con un bordo tra (1, 0) - (2, 0)(nel caso nsia pari), quindi espandiamo i nodi in modo tale y > 0. Questo è fatto dalla sezione "Tipo di riflessione 1" del programma, quindi per ogni grafico generato, rifletti (specchia) stesso attraverso l'asse X x = 0( g.reflectSelfX()), quindi verifica se ha la simmetria corretta.

Tuttavia, si noti che se nè divisibile per 2, in questo modo abbiamo contato ogni grafico due volte, perché generiamo anche la sua immagine speculare per l'asse 2x = y + 3.

(nota i 2 arancioni)

Simile per l'asse 2x = y, se (e solo se) nè ancora, si parte dal punto (1, 1), generare grafici tale che 2*x > y, e riflettere ciascuno di loro al 2x = yasse ( g.reflectSelfType2()), collegare (1, 0)con (1, 1), e controllare se hanno corretto simmetria. Ricorda di dividere anche per 2.


Dato che stavo dormendo quando questo (e l'altro) sono stati pubblicati, ti darò il beneficio del dubbio e non accetterò ancora una risposta.
caird coinheringaahing il

2
@cairdcoinheringaahing Eri online 3 minuti prima della scadenza ...
user202729

Uh oh, la sequenza successiva può essere codificata ... (anche se è infinita) se la leggo correttamente. Il calcolo in sé è --- piuttosto --- molto semplice, quindi non farlo.
user202729

7

6. R , 71 byte, A000072

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

Provalo online!

Prossima sequenza


1
Per amore di Dio, non ho controllato la sequenza successiva prima di pubblicare questa risposta.
Leaky Nun,

Una prossima sequenza facile non è un vantaggio strategico?
BlackCap

@BlackCap Non possono rispondere due volte di seguito o meno di un'ora dopo l'ultima risposta.
Erik the Outgolfer,

@EriktheOutgolferthe answer before the last posted (the one who didn't break the chain) will win
BlackCap

@BlackCap a questo punto che non accadrà
Stephen


7

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

Valuta la formula ricorsiva presente nel collegamento OEIS.

Prossima sequenza


Agh sapevo quando il sito è andato giù che sarebbe tornato fuori di testa. Mi ha appena battuto.
Silvio Mayolo,

Non mi ero reso conto che il sito fosse andato in rovina ...
Scott Milner,




7

76. Pigmeo , 4147 byte, 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                                         
}                                                                               

Prossima sequenza

È possibile eseguire il codice in questa pagina . Ad esempio, puoi ottenere il decimo numero nella sequenza copiando il codice sopra e aggiungendo:

alert| A000035| 10

4
... la sequenza successiva è indiscutibile ...
HyperNeutrino,

1
@HyperNeutrino Lo so: PI lo ha fatto apposta
Peter Olson,

Evil ...>. <Ma comunque, mi limiterò a codificare i 4 elementi nella sequenza. Abbastanza facile xD OP lo approva apparentemente ¯ \ _ (ツ) _ / ¯
HyperNeutrino
Utilizzando il nostro sito, riconosci di aver letto e compreso le nostre Informativa sui cookie e Informativa sulla privacy.
Licensed under cc by-sa 3.0 with attribution required.