Définition

Appelons une séquence entière (infinie) universelle si elle contient chaque séquence entière finie comme sous-séquence contiguë.

En d'autres termes, la séquence entière (a ₁ , a ₂ ,…) est universelle si et seulement si, pour chaque séquence entière finie (b ₁ ,…, b _n ) , il existe un décalage k tel que (a _{k + 1} ,…, A _{k + n} ) = (b ₁ ,…, b _n ) .

La séquence de nombres premiers positifs, par exemple, n'est pas universelle, entre autres pour les raisons suivantes.

• Il ne contient aucun entier négatif, 1 ou nombre composé.

• Bien qu'il contienne 3 , il ne contient pas la sous-séquence contiguë (3, 3, 3) .

• Bien qu'il contienne 2 et 5 , il ne contient pas la sous-séquence contiguë (2, 5) .

• Bien qu'il contienne la sous-séquence contiguë (7, 11, 13) , il ne contient pas la sous-séquence contiguë (13, 11, 7) .

Tâche

Choisissez n'importe quelle séquence entière universelle unique (a ₁ , a ₂ ,…) et implémentez-la dans un langage de programmation de votre choix, en respectant les règles suivantes.

• Vous pouvez soumettre un programme complet ou une fonction.

• Vous avez trois options pour les E / S:

  1. Ne prenez aucune entrée et imprimez ou renvoyez la séquence entière.

  2. Prenez un index n comme entrée et imprimez ou retournez un _n .

  3. Prenez un index n comme entrée et imprimez ou retournez (a ₁ ,…, a _n ) .

• Pour les options d'E / S 2 et 3 , vous pouvez utiliser une indexation basée sur 0 si vous préférez.

• Votre soumission doit être déterministe: si elle est exécutée plusieurs fois avec la même entrée, elle doit produire la même sortie.

De plus, à moins que ce ne soit immédiatement évident, veuillez prouver que la séquence que vous avez choisie est universelle. Votre preuve peut ne pas dépendre de conjectures non prouvées.

Les règles de code-golf standard s'appliquent. Que le code le plus court en octets gagne!

Husk , 5 octets

Cela imprime une liste infinie

ΣṖ…ݱ

Essayez-le en ligne! ou trouvez le premier index de votre séquence . (Prend beaucoup de mémoire pour la plupart des séquences)

Explication:

   ݱ   Infinite list [1,-1,2,-2,3,-3,4,-4,5,-5...]
  …     Rangify       [1,0,-1,0,1,2,1,0,-1,-2,...]
 Ṗ      Powerset
Σ       Concatenate

Dans Husk Ṗse comporte bien pour les listes infinies. Vous pouvez voir son comportement ici

Python 2 , 49 46 43 octets

def f(n):d=len(`n`);return n/d**(n%d)%d-d/2

f(n)renvoie uniquement un _n . Cela utilise le plus petit chiffre de ndans la base dpour extraire l'un des chiffres les plus élevés.

Essayez-le en ligne! Ce script (gracieuseté de Dennis) prend n'importe quelle séquence finie et vous donne un nendroit où cette séquence commence.

Explication

n/d**(n%d)%d-d/2
     (n%d)         least significant digit of n
n/d**(   )%d       get n%d-th digit of n
            -d/2   offset to get negative values

Par exemple, pour nl'ordre 3141592650de 3141592659, d=10et le dernier chiffre nsélectionne l' un des autres chiffres. Ensuite, nous ajoutons -d/2pour obtenir des valeurs négatives.

n%d:       0  1  2  3  4  5  6  7  8  9
f(n)+d/2:  0  5  6  2  9  5  1  4  1  3
f(n):     -5  0  1 -3  4  0 -4 -1 -4 -2

Alternative autonome, également 43 octets:

n=input();d=len(`n`);print n/d**(n%d)%d-d/2

Brachylog 2, 11 octets

≜~×-₂ᵐ~ȧᵐ≜∋

Essayez-le en ligne!

J'ai également essayé un algorithme utilisant des partitions additives sur une liste, mais il n'était pas plus court. Il s'agit d'un générateur qui produit un flux infini d'entiers en sortie; le lien TIO a un en-tête pour en imprimer les dix mille premiers.

Explication

Le programme commence par essayer tous les entiers possibles en séquence ( ≜essaie toutes les possibilités restantes, pour les entiers par défaut). C'est 0, 1, -1, 2, -2, etc. (bien que les entiers négatifs n'atteignent pas la fin du programme). Il s'agit de la seule étape "infinie" du programme; tous les autres sont finis.

~×génère ensuite toutes les factorisations possibles de l'entier, en traitant différents ordres comme différents et en utilisant uniquement des valeurs à partir de 2 (il n'y en a donc qu'un nombre fini); notez que les nombres composites sont autorisés dans la factorisation, pas seulement les nombres premiers. Cela signifie que toutes les séquences possibles d'entiers ≥ 2 seront générées par cette étape à un moment donné de l'exécution de la fonction (car une telle séquence a nécessairement un certain produit, et ce produit sera généré à un moment donné par l'initiale ≜).

Nous devons ensuite mapper l'ensemble de ces séquences sur l'ensemble de toutes les séquences entières, ce qui se fait en deux étapes: soustraire 2 ( -₂) de chaque élément ( ᵐ), nous donnant l'ensemble de toutes les séquences entières non négatives, puis prendre plus ou moins ( ~ȧ, c'est-à-dire "une valeur dont la valeur absolue est") chaque élément (ᵐ). Cette dernière étape n'est évidemment pas déterministe, donc Brachylog la traite comme un générateur, générant toutes les listes possibles dont les éléments sont plus ou moins l'élément correspondant de la liste d'entrée. Cela signifie que nous avons maintenant un générateur pour toutes les séquences entières possibles, et il les génère dans un ordre qui signifie qu'elles sont toutes générées (en particulier, l'ordre que vous obtenez si vous prenez la valeur absolue de chaque élément, ajoutez 2 à chaque élément, puis triez par le produit des éléments résultants).

Malheureusement, la question veut une seule séquence, pas une séquence de séquences, nous avons donc besoin de deux commandes supplémentaires. Premièrement, ≜demande à Brachylog de générer explicitement la séquence de séquences strictement (au lieu de produire une structure de données décrivant le concept d'une séquence générée via cette méthode, et de ne pas réellement générer les séquences tant que cela n'est pas nécessaire); cela se produit à la fois pour rendre le programme plus rapide dans ce cas, et garantit que la sortie est produite dans l'ordre demandé. Enfin, ∋oblige le générateur à sortir les éléments des séquences individuelles un par un (en passant à la séquence suivante une fois qu'il a sorti tous les éléments de la précédente).

Le résultat final: chaque séquence entière possible est générée et sortie, un élément à la fois, et toutes concaténées ensemble dans une seule séquence universelle.

Pyth - 11 octets

ne produit cartésien de puissance [-n, n], pour tous n.

.V1js^}_bbb

Essayez-le en ligne ici (définitivement).

Python 2 , 100 99 octets

• Sauvegardé d'un octet grâce aux ovs ; itération sur une itertoolsboucle intégrée pour indéfiniment.

from itertools import*
for n in count():
 for P in permutations(range(-n,n)*n):
	for p in P:print p

Essayez-le en ligne!

Imprime indéfiniment toutes les permutations de la nplage d'entiers répétés -temps [-n; n)pour tous les entiers non négatifs n.
Vous pouvez rechercher le premier décalage kpour toute sous-séquence à l'aide de cette version modifiée .

Perl 6 , 91 octets

loop (my$i=1;;$i++){my@n=(-$i..$i);my@m=@n;loop (my$k=1;$k <$i;$k++){@m=@m X@n;};print @m;}

Essayez-le en ligne!

Cela utilise une méthode similaire à certaines des autres réponses. Il utilise des produits cartésiens pour imprimer les éléments de (-1,0,1), puis toutes les paires ordonnées des éléments dans (-2,-1,0,1,2), puis tous les triplets ordonnés des éléments dans (-3,-2,-1,0,1,2,3), etc.

Je suis nouveau à Perl, donc il pourrait y avoir plus de golf qui pourrait être fait.

Version plus lisible:

loop (my $i = 1; ; $i++) {
  my @n = (-$i..$i);
  my @m = @n;
  loop (my $k=1; $k <$i; $k++) {
    @m = @m X @n;
  }
  print @m;
}