281. Java 5, 11628 bytes, A000947
// package oeis_challenge;
import java.util.*;
import java.lang.*;
class Main {
// static void assert(boolean cond) {
// if (!cond)
// throw new Error("Assertion failed!");
// }
/* Use the formula a(n) = A000063(n + 2) - A000936(n).
It's unfair that I use the formula of "number of free polyenoid with n
nodes and symmetry point group C_{2v}" (formula listed in A000063)
without understanding why it's true...
*/
static int catalan(int x) {
int ans = 1;
for (int i = 1; i <= x; ++i)
ans = ans * (2*x+1-i) / i;
return ans / -~x;
}
static int A63(int n) {
int ans = catalan(n/2 - 1);
if (n%4 == 0) ans -= catalan(n/4 - 1);
if (n%6 == 0) ans -= catalan(n/6 - 1);
return ans;
}
static class Point implements Comparable<Point> {
final int x, y;
Point(int _x, int _y) {
x = _x; y = _y;
}
/// @return true if this is a point, false otherwise (this is a vector)
public boolean isPoint() {
return (x + y) % 3 != 0;
}
/// Translate this point by a vector.
public Point add(Point p) {
assert(this.isPoint() && ! p.isPoint());
return new Point(x + p.x, y + p.y);
}
/// Reflect this point along x-axis.
public Point reflectX() {
return new Point(x - y, -y);
}
/// Rotate this point 60 degrees counter-clockwise.
public Point rot60() {
return new Point(x - y, x);
}
@Override
public boolean equals(Object o) {
if (!(o instanceof Point)) return false;
Point p = (Point) o;
return x == p.x && y == p.y;
}
@Override
public int hashCode() {
return 21521 * (3491 + x) + y;
}
public String toString() {
// return String.format("(%d, %d)", x, y);
return String.format("setxy %d %d", x * 50 - y * 25, y * 40);
}
public int compareTo(Point p) {
int a = Integer.valueOf(x).compareTo(p.x);
if (a != 0) return a;
return Integer.valueOf(y).compareTo(p.y);
}
/// Helper class.
static interface Predicate {
abstract boolean test(Point p);
}
static abstract class UnaryFunction {
abstract Point apply(Point p);
}
}
static class Edge implements Comparable<Edge> {
final Point a, b; // guarantee a < b
Edge(Point x, Point y) {
assert x != y;
if (x.compareTo(y) > 0) { // y < x
a = y; b = x;
} else {
a = x; b = y;
}
}
public int compareTo(Edge e) {
int x = a.compareTo(e.a);
if (x != 0) return x;
return b.compareTo(e.b);
}
}
/// A graph consists of multiple {@code Point}s.
static class Graph {
private HashMap<Point, Point> points;
public Graph() {
points = new HashMap<Point, Point>();
}
public Graph(Graph g) {
points = new HashMap<Point, Point>(g.points);
}
public void add(Point p, Point root) {
assert(p.isPoint());
assert(root.isPoint());
assert(p == root || points.containsKey(root));
points.put(p, root);
}
public Graph map(Point.UnaryFunction fn) {
Graph result = new Graph();
for (Map.Entry<Point, Point> pq : points.entrySet()) {
Point p = pq.getKey(), q = pq.getValue();
assert(p.isPoint()) : p;
assert(q.isPoint()) : q;
p = fn.apply(p); assert(p.isPoint()) : p;
q = fn.apply(q); assert(q.isPoint()) : q;
result.points.put(p, q);
}
return result;
}
public Graph reflectX() {
return this.map(new Point.UnaryFunction() {
public Point apply(Point p) {
return p.reflectX();
}
});
}
public Graph rot60() {
return this.map(new Point.UnaryFunction() {
public Point apply(Point p) {
return p.rot60();
}
});
}
@Override
public boolean equals(Object o) {
if (o == null) return false;
if (o.getClass() != getClass()) return false;
Graph g = (Graph) o;
return points.equals(g.points);
}
@Override
public int hashCode() {
return points.hashCode();
}
Graph[] expand(Point.Predicate fn) {
List<Graph> result = new ArrayList<Graph>();
for (Point p : points.keySet()) {
int[] deltaX = new int[] { -1, 0, 1, 1, 0, -1};
int[] deltaY = new int[] { 0, 1, 1, 0, -1, -1};
for (int i = 6; i --> 0;) {
Point p1 = new Point(p.x + deltaX[i], p.y + deltaY[i]);
if (points.containsKey(p1) || !fn.test(p1)
|| !p1.isPoint()) continue;
Graph g = new Graph(this);
g.add(p1, p);
result.add(g);
}
}
return result.toArray(new Graph[0]);
}
public static Graph[] expand(Graph[] graphs, Point.Predicate fn) {
Set<Graph> result = new HashSet<Graph>();
for (Graph g0 : graphs) {
Graph[] g = g0.expand(fn);
for (Graph g1 : g) {
if (result.contains(g1)) continue;
result.add(g1);
}
}
return result.toArray(new Graph[0]);
}
private Edge[] edges() {
List<Edge> result = new ArrayList<Edge>();
for (Map.Entry<Point, Point> pq : points.entrySet()) {
Point p = pq.getKey(), q = pq.getValue();
if (p.equals(q)) continue;
result.add(new Edge(p, q));
}
return result.toArray(new Edge[0]);
}
/**
* Check if two graphs are isomorphic... under translation.
* @return {@code true} if {@code this} is isomorphic
* under translation, {@code false} otherwise.
*/
public boolean isomorphic(Graph g) {
if (points.size() != g.points.size()) return false;
Edge[] a = this.edges();
Edge[] b = g.edges();
Arrays.sort(a);
Arrays.sort(b);
// for (Edge e : b)
// System.err.println(e.a + " - " + e.b);
// System.err.println("------- >><< ");
assert (a.length > 0);
assert (a.length == b.length);
int a_bx = a[0].a.x - b[0].a.x, a_by = a[0].a.y - b[0].a.y;
for (int i = 0; i < a.length; ++i) {
if (a_bx != a[i].a.x - b[i].a.x ||
a_by != a[i].a.y - b[i].a.y) return false;
if (a_bx != a[i].b.x - b[i].b.x ||
a_by != a[i].b.y - b[i].b.y) return false;
}
return true;
}
// C_{2v}.
public boolean correctSymmetry() {
Graph[] graphs = new Graph[6];
graphs[0] = this.reflectX();
for (int i = 1; i < 6; ++i) graphs[i] = graphs[i-1].rot60();
assert(graphs[5].rot60().isomorphic(graphs[0]));
int count = 0;
for (Graph g : graphs) {
if (this.isomorphic(g)) ++count;
// if (count >= 2) {
// return false;
// }
}
// if (count > 1) System.err.format("too much: %d%n", count);
assert(count > 0);
return count == 1; // which is, basically, true
}
public void reflectSelfType2() {
Graph g = this.map(new Point.UnaryFunction() {
public Point apply(Point p) {
return new Point(p.y - p.x, p.y);
}
});
Point p = new Point(1, 1);
assert (p.equals(points.get(p)));
points.putAll(g.points);
assert (p.equals(points.get(p)));
Point q = new Point(0, 1);
assert (q.equals(points.get(q)));
points.put(p, q);
}
public void reflectSelfX() {
Graph g = this.reflectX();
points.putAll(g.points); // duplicates doesn't matter
}
}
static int A936(int n) {
// if (true) return (new int[]{0, 0, 0, 1, 1, 2, 4, 4, 12, 10, 29, 27, 88, 76, 247, 217, 722, 638, 2134, 1901, 6413})[n];
// some unreachable codes here for testing.
int ans = 0;
if (n % 2 == 0) { // reflection type 2. (through line 2x == y)
Graph[] graphs = new Graph[1];
graphs[0] = new Graph();
Point p = new Point(1, 1);
graphs[0].add(p, p);
for (int i = n / 2 - 1; i --> 0;)
graphs = Graph.expand(graphs, new Point.Predicate() {
public boolean test(Point p) {
return 2*p.x > p.y;
}
});
int count = 0;
for (Graph g : graphs) {
g.reflectSelfType2();
if (g.correctSymmetry()) {
++count;
// for (Edge e : g.edges())
// System.err.println(e.a + " - " + e.b);
// System.err.println("------*");
}
// else System.err.println("Failed");
}
assert (count%2 == 0);
// System.err.println("A936(" + n + ") count = " + count + " -> " + (count/2));
ans += count / 2;
}
// Reflection type 1. (reflectX)
Graph[] graphs = new Graph[1];
graphs[0] = new Graph();
Point p = new Point(1, 0);
graphs[0].add(p, p);
if (n % 2 == 0) graphs[0].add(new Point(2, 0), p);
for (int i = (n-1) / 2; i --> 0;)
graphs = Graph.expand(graphs, new Point.Predicate() {
public boolean test(Point p) {
return p.y > 0;
}
});
int count = 0;
for (Graph g : graphs) {
g.reflectSelfX();
if (g.correctSymmetry()) {
++count;
// for (Edge e : g.edges())
// System.err.printf(
// "pu %s pd %s\n"
// // "%s - %s%n"
// , e.a, e.b);
// System.err.println("-------/");
}
// else System.err.println("Failed");
}
if(n % 2 == 0) {
assert(count % 2 == 0);
count /= 2;
}
ans += count;
// System.err.println("A936(" + n + ") = " + ans);
return ans;
}
public static void main(String[] args) {
// Probably
if (! "1.5.0_22".equals(System.getProperty("java.version"))) {
System.err.println("Warning: Java version is not 1.5.0_22");
}
// A936(6);
for (int i = 0; i < 20; ++i)
System.out.println(i + " | " + (A63(i+9) - A936(i+7)));
//A936(i+2);
}
}
Experimente online!
Nota:
- Testado localmente com Java 5. (para que o aviso não seja impresso - consulte a guia de depuração do TIO)
- Não. Sempre. Usar. Java. 1. É mais detalhado que o Java em geral.
Isso pode quebrar a corrente. - O intervalo (7 dias e 48 minutos) não é mais do que o intervalo criado por esta resposta , que é de 7 dias e 1 hora e 25 minutos depois que o anterior .
Novo recorde em grande bytecount! Como eu (por engano?) Uso espaços em vez de guias, o número de bytes é maior que o necessário. Na minha máquina são 9550 bytes. (no momento da redação desta revisão)- Próxima sequência .
- O código, em sua forma atual, imprime apenas os 20 primeiros termos da sequência. No entanto, é fácil de mudar para que ele imprime primeiros 1000 itens (pela mudança do
20em for (int i = 0; i < 20; ++i)a 1000)
Yay! Isso pode calcular mais termos do que os listados na página OEIS! (pela primeira vez, para um desafio que preciso usar Java), a menos que o OEIS tenha mais termos em algum lugar ...
Explicação rápida
Explicação da descrição da sequência.
A sequência solicita o número de polenoides não planares livres com grupo de simetria C 2v , em que:
- polienoide: (modelo matemático de hidrocarbonetos de polieno) árvores (ou em caso degenerado, vértice único) podem ser incorporadas na estrutura hexagonal.
Por exemplo, considere as árvores
O O O O (3)
| \ / \
| \ / \
O --- O --- O O --- O O --- O
| \
| (2) \
(1) O O
O primeiro não pode ser incorporado na estrutura hexagonal, enquanto o segundo pode. Essa incorporação específica é considerada diferente da terceira árvore.
- polenoide não planar: incorporação de árvores de modo que exista dois vértices sobrepostos.
(2)e a (3)árvore acima são planares. Este, no entanto, não é plano:
O---O O
/ \
/ \
O O
\ /
\ /
O --- O
(existem 7 vértices e 6 arestas)
- polienoide livre: as variantes de um polienoide, que podem ser obtidas por rotação e reflexão, são contadas como uma.
- Grupo C 2v : Os polienoides são contados apenas se tiverem dois planos de reflexão perpendiculares e não mais.
Por exemplo, o único polenoide com 2 vértices
O --- O
possui 3 planos de reflexão: o horizontal -, o vertical |e o paralelo à tela do computador ■. Isso é demais.
Por outro lado, este
O --- O
\
\
O
tem 2 planos de reflexão: /e ■.
Explicação do método
E agora, a abordagem sobre como realmente contar o número.
Primeiro, aceito a fórmula a(n) = A000063(n + 2) - A000936(n)(listada na página OEIS) como garantida. Não li a explicação no jornal.
[TODO conserte esta parte]
Obviamente, contar planar é mais fácil do que contar não planar. É o que o jornal também faz.
Os polienoides geometricamente planos (sem vértices sobrepostos) são enumerados por programação de computador. Assim, o número de polienoides geometricamente não planares se torna acessível.
Então ... o programa conta o número de polienoides planares e subtrai-o do total.
Como a árvore é plana de qualquer maneira, obviamente tem o ■plano de reflexão. Portanto, a condição se resume a "contar o número de árvores com um eixo de reflexão em sua representação 2D".
A maneira ingênua seria gerar todas as árvores com nnós e verificar a simetria correta. No entanto, como queremos encontrar apenas o número de árvores com um eixo de reflexão, podemos gerar toda a meia-árvore possível em uma metade, espelhá-las através do eixo e verificar a simetria correta. Além disso, como os polienoides gerados são árvores (planares), devem tocar o eixo de reflexão exatamente uma vez.
A função public static Graph[] expand(Graph[] graphs, Point.Predicate fn)pega uma matriz de gráficos, cada um tem nnós, e gera uma matriz de gráfico, cada um tem n+1nós, não iguais entre si (em conversão) - de modo que o nó adicionado deve satisfazer o predicado fn.
Considere dois eixos possíveis de reflexão: um que passa por um vértice e coincide com as arestas ( x = 0) e outro que é o bissetor perpendicular de uma aresta ( 2x = y). Podemos usar apenas um deles, porque os gráficos gerados são isomórficos.
Portanto, para o primeiro eixo x = 0, partimos do gráfico base composto por um único nó (1, 0)(caso nseja ímpar) ou dois nós com uma aresta entre (1, 0) - (2, 0)(caso nseja par) e depois expandimos os nós de modo que y > 0. Isso é feito na seção "Tipo de reflexão 1" do programa e, em seguida, para cada gráfico gerado, reflita (espelhe) o próprio eixo X x = 0( g.reflectSelfX()) e verifique se a simetria correta está correta.
No entanto, observe que se né divisível por 2, dessa forma contamos cada gráfico duas vezes, porque também geramos sua imagem no espelho pelo eixo 2x = y + 3.
(observe os 2 laranja)
Semelhante para o eixo 2x = y, se (e somente se) né ainda, começamos a partir do ponto (1, 1), gerar gráficos de tal forma que 2*x > y, e refletir cada um deles ao longo do 2x = yeixo ( g.reflectSelfType2()), conectar (1, 0)com (1, 1), e verificar se eles têm simetria correta. Lembre-se de dividir por 2 também.
