Je définis la méthode de combinaison d'une séquence pour signifier que chaque numéro de la séquence est concaténé sous forme de chaîne, puis ce résultat est transformé en entier.

[1, 2, 3] -> 123

Pour chaque séquence finie d'au moins 3 entiers consécutifs, il manque exactement un élément dans la séquence, et cet élément manquant peut ne pas être le premier ou le dernier élément de la séquence, sortez l'entier résultant de la séquence combinée. Je me réfère à cela comme un "entier à perte unique".

[1, 2, 3] -> {1, 3} (missing an element) -> 13

Cette séquence d'entiers à perte unique est l'union des sous-séquences (partitions?) Suivantes:

La première sous {n, n+2}- séquence est A032607 .

{n, n+2}            -> 13, 24, 35, 46, 57, 68, 79, 810, 911, 1012, ...
{n, n+1, n+3}       -> 124, 235, 346, ...
{n, n+2, n+3}       -> 134, 245, 356, ...
{n, n+1, n+2, n+4}  -> 1235, 2346, 3457, ...
{n, n+1, n+3, n+4}  -> 1245, 2356, 3467, ...
{n, n+2, n+3, n+4}  -> 1345, 2456, 3567, ...
... 
for n ∈ ℕ (integers >= 1)

Ces nombres entiers doivent être imprimés dans l'ordre croissant. Les 25 premiers nombres entiers avec perte sont les suivants :

13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235, ...

7597 premiers nombres entiers avec perte

Implémentations de référence non gérées. Je l'ai fait pour être plus rapide, plutôt que plus petit.

• Ideone
• TIO (plus rapide, limites plus élevées)

Règles:

• Victoires de code les plus courtes
• Vous pouvez soit (dire lequel):
  • Imprimez les entiers à perte unique pour toujours
  • Étant donné un entier positif n , affichez ou renvoyez les n premiers éléments sous forme de liste, ou de chaîne délimitée par des virgules ou des espaces.
• Vous devez prendre en charge des entiers arbitrairement grands si votre langue le permet, surtout si vous imprimez pour toujours.

Inspiré par / Associé

Remarque: Il n'y a pas encore d'entrée dans l'OEIS pour cette séquence.

Autre remarque: je les ai nommés "Entiers à perte unique" afin qu'il puisse à son tour y avoir "Entiers à perte double", "Entiers à perte N-ly", "Entiers à perte avec perte (N + 1)" et "Entiers à perte avec perte" et les "Entiers à perte" "(union de tous ces éléments).

Mathematica, 101 octets

Sort@Flatten@Table[FromDigits[""<>ToString/@(z~Range~x~Delete~y)],{x,3,#},{z,1,x-1},{y,2,x-z}][[1;;#]]&

Yay! Pour une fois, j'ai la réponse la plus courte!Party[Hard]

Haskell, 131 , 114 , 106 octets

iterate(\n->minimum[x|x<-[read(show=<<filter(/=k)[i..j])::Int|i<-[1..n],j<-[i+2..n],k<-[i+1..j-1]],x>n])13

Ceci est limité par la taille de Int, mais il peut être facilement étendu en remplaçant IntparInteger .

Moins golfé:

concatInt x = read (concatMap show x) ::Int
allUpToN n = [concatInt $ filter (/=k) [i..j] | i <- [1..n], j <- [i+2..n], k <- [i+1..j-1]]
f n = minimum[x | x <- allUpToN, x > n ]
iterate f 13

8 octets golfés par @nimi.

Python 3, 136 127 126 126 122 octets

solution de force brute, je n'essaye même pas n = 7000 (ça prend déjà 10s pour n = 100)

r=range
f=lambda n:sorted(int(''.join(str(i+k)for i in r(1,j)if l-i))for k in r(n)for j in r(4,n)for l in r(2,j-1))[:n]

Explication

# f=lambda n:sorted( int(''.join(str(i+k) for i in r(1,j)   if l-i)) for k in r(n) for j in r(4,n) for l in r(2,j-1))[:n]
#            ──┬──                        ───────┬───────    ───┬──  ──────┬──────  ──────┬──────  ────────┬──────── ─┬─
#              │                                 │              │          │              │                │          └── selection of the n first numbers
#              │                                 │              │          │              │                └── loop to remove missing element
#              │                                 │              │          │              └── loop for the dimension of the list n to be sure we miss nothing xD
#              │                                 │              │          └── loop on the n in op description 
#              │                                 │              └── Test to remove missing element
#              │                                 └── loop on {n, n+1 ...} in the op description
#              └──── sort the list

Résultats

>>> f(25)
[13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235]

>>> f(100)
[13, 24, 35, 46, 57, 68, 79, 124, 134, 235, 245, 346, 356, 457, 467, 568, 578, 679, 689, 810, 911, 1012, 1113, 1214, 1235, 1245, 1315, 1345, 1416, 1517, 1618, 1719, 1820, 1921, 2022, 2123, 2224, 2325, 2346, 2356, 2426, 2456, 2527, 2628, 2729, 2830, 2931, 3032, 3133, 3234, 3335, 3436, 3457, 3467, 3537, 3567, 3638, 3739, 3840, 3941, 4042, 4143, 4244, 4345, 4446, 4547, 4568, 4578, 4648, 4678, 4749, 4850, 4951, 5052, 5153, 5254, 5355, 5456, 5557, 5658, 5679, 5689, 5759, 5789, 5860, 5961, 6062, 6163, 6264, 6365, 6466, 6567, 6668, 6769, 6870, 6971, 7072, 7173, 7274, 7375]

Merci à @ mbomb007 et @FricativeMelon pour leur aide

Python 3, 319 , 270 , 251 octets

t,h,n,k,q*=range,input(),1,2,
while h>len(q)or n*k<=len(str(q[h])):
 q+=[int("".join([str(c+s)for c in t(k+1)if c-y]))for s in t(10**~-n,10**n)for y in t(1,k)]
 if~-n:n*=k;k+=1
 else:n,k=k+1,2
 while n//k*k-n:k+=1
 n//=k;q.sort()
print(q[:h])

Prend une hentrée de STDIN et imprime un tableau des premiers hentiers à perte unique. Il est également très rapide, ne prenant que quelques secondes pourh=7000 .

Explication: Notez que, si nous avions un temps infini, nous pourrions simplement répéter sur tout n,ket pour chaque paire supprimer chacune des n+1,n+2,...,n+k-1( k-1possibilités), et obtenir toutes les valeurs (infiniment nombreuses) de celles-ci, puis trier simplement la séquence dans l'ordre croissant et tronquer pour héléments. Bien sûr, nous ne pouvons pas vraiment le faire, mais si nous pouvons atteindre un point où les premiers héléments triés ne peuvent plus changer en ajoutant les valeurs des futures n,kpaires, nous pouvons simplement tronquer ensuite et terminer en un temps fini. Pour n'importe quelle n,kpaire, il a au moins des floor(log10(n)+1)*kchiffres, peut-être plus. Permet donc de regrouper ces paires par la valeur c(n,k)=floor(log10(n)+1)*k, où nous garantissons que si c(a,b)<c(n,k), nous traitons a,bavant n,k. Si nous avons trié la liste et que son dernier élément adchiffres, et d<c(n,k)pour le prochain que éléments ne peuvent pas changer, donc on peut juste les renvoyer.n,knous allons traiter, nous pouvons arrêter, car nous ne pouvons plus obtenir un nombre avec autant ou moins de chiffres, car par notre garantie nous aurions déjà dû le traiter à ce moment-là, et donc peu importe les nombres que nous finirions par calculer, le premierh

Alors maintenant, nous avons juste besoin de la fonction qui garantit l'ordre indiqué c(n,k). Pour chacun ypouvant être obtenu pour c(n,k), nous devons traiter tout (n,k)cela y=c(n,k). Disons L=floor(log10(n)+1)pour certains n. y=L*kDoit donc tenir. Commencez par k=2,L=y/2, puis faites k=3,L=y/3;k=4,L=y/4...k=y,L=1, en ignorant les valeurs non entières de L. Pour générer toute c(n,k)fonction, commencez par (1,2)avec y=2, et d' augmenter yde 1 et recommencer chaque fois que vous obtenez L==1. Maintenant, nous avons une énumération de paires (L,k), et cela satisfait notre condition. Cependant, nous avons besoin de récupérer possible ndeL , que nous faisons tous les entiers en dénombrant avec Lchiffres. Ensuite, pour chacune de ces (n,k)paires, pour chacune desk-1les éléments supprimés possibles, nous devons générer le nombre de pertes que nous obtenons en conséquence et l'ajouter à notre liste, qui commence vide. Ensuite, nous trions la liste et répétons la prochaine(L,k) paire , en nous arrêtant lorsque nous l'avons d<c(n,k)comme indiqué précédemment.

Décomposition du code (un peu dépassé):

t=range                     #shortens code
def f(r,n,k):               #helper function
 for s in t(10**~-n,10**n): #for the (L,k) pair, add value of (s,k,y)
  for y in t(1,k):r+=[(int("".join(map(str,[c+s for c in t(k+1)if c!=y]))))]
 if n>1:                    #case where L!=1
  n*=k;k+=1                 #multiply n (which is n'/k from prev iter), inc k
 else:n,k=k+1,2             #reset n and k
 while n//k*k-n:k+=1        #find next proper divisor of n
 return(r,n//k,k)           #divide by that divisor and return
def g(h):                   #main function
 q,a,b=[],1,2               #initial values
 while h>=len(q)or a*b<=len(str(q[h])):(q,a,b)=f(q,a,b);q.sort()
 return q[:h]               #continues until at least h numbers and surpassed current max