시퀀스를 결합하는 방법을 정의하여 시퀀스의 모든 숫자가 문자열로 연결된 다음 결과가 정수가된다는 것을 의미합니다.

[1, 2, 3] -> 123

시퀀스에서 정확히 하나의 요소가 누락 된 최소 3 개의 연속 정수의 모든 유한 시퀀스에 대해이 누락 된 요소는 시퀀스에서 첫 번째 또는 마지막 요소가 아닐 수 있으며 결합 된 시퀀스에서 생성 된 정수를 출력합니다. 이것을 "단순 손실 정수"라고합니다.

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

이 단일 손실 정수 시퀀스는 다음 하위 시퀀스 (파티션?)의 합집합입니다.

첫 번째 하위 시퀀스 {n, n+2}는 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)

이 정수는 오름차순으로 인쇄해야합니다. 처음 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, ...

첫 번째 7597 Singly Lossy Integers

골프화되지 않은 참조 구현. 나는 그것을 더 작게하기보다 빨리 만들었습니다.

• 이데온
• TIO (가장 빠른 최고 한계)

규칙 :

• 최단 코드 승리
• 다음 중 하나를 수행 할 수 있습니다.
  • 유일하게 손실 정수를 영원히 인쇄
  • 양의 정수 n이 주어지면 첫 번째 n 요소를 목록 또는 쉼표 또는 공백으로 구분 된 문자열로 인쇄하거나 반환하십시오 .
• 언어에서 허용하는 경우, 특히 영원히 인쇄하는 경우 임의로 큰 정수를 지원해야합니다.

영감 / 관련

참고 :이 순서에 대한 OEIS에는 아직 항목이 없습니다.

또 다른 메모 : 나는 그것들을 "Singly Lossy Integers"로 명명하여 "Doubly Lossy Integers", "N-ly Lossy Integers", "(N + 1) -ly Lossy Integers", "Lossy Integers" "(이들 모두의 연합).

Mathematica, 101 바이트

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

예이! 한 번은 가장 짧은 답변을 받았습니다!Party[Hard]

하스켈, 131 , 114 , 106 바이트

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

크기는에 의해 제한 Int되지만 다음 Int과 같이 바꾸면 쉽게 확장 할 수 있습니다.Integer .

덜 골프 :

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

@nimi가 골프를 타는 8 바이트.

파이썬 3 136 127 126 122 바이트

무차별 대입 솔루션, 나는 n = 7000도 시도하지 않습니다 (n = 100에 대해 이미 10 초가 걸립니다)

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]

설명

# 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

결과

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

도움을 주신 @ mbomb007 및 @FricativeMelon에게 감사합니다

파이썬 3, 319 , 270 , 251 바이트

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

걸린다 hSTDIN로부터 입력 된 상기 제 배열 인쇄 h단독 - 손실 정수. 매우 빠릅니다 h=7000.에 몇 초 밖에 걸리지 않습니다 .

설명 : 무한 시간이 있다면 단순히 모든 반복을 반복하고 n,k각 쌍에 대해 각각 n+1,n+2,...,n+k-1( k-1가능성)을 삭제하고 그로부터 모든 (무한대) 값을 얻은 다음 순서를 오름차순으로 정렬하고 잘라냅니다. h집단. 물론 실제로 그렇게 h할 수는 없지만 미래의 n,k쌍 값을 추가하여 첫 번째로 정렬 된 요소를 더 이상 변경할 수없는 지점에 도달 할 수 있다면 유한 시간에 자르고 완료 할 수 있습니다. 어떤 n,k쌍 이든 , 그것은 적어도 floor(log10(n)+1)*k자릿수 이상을 가질 수 있습니다. 그래서 이러한 쌍의 값으로 그룹을 수 있습니다 c(n,k)=floor(log10(n)+1)*k우리가있는 경우 그 보장 c(a,b)<c(n,k), 우리가 처리 할 자리를, 그리고 다음에 대한a,b 이전을 n,k. 목록이 정렬되어 있고 마지막 요소가dd<c(n,k)n,k우리는 더 이상 그 숫자 이하의 숫자를 얻을 수 없기 때문에 처리 할 것입니다. 우리는 이미 그 숫자를 처리 했으므로 계산을 끝내야하므로 계산을 끝내는 숫자에 관계없이 먼저h 요소는 변경할 수 없으므로 반환 할 수 있습니다.

이제 우리는에 명시된 순서를 보장하는 기능이 필요합니다 c(n,k). 에 대해 y얻을 수있는 각각에 대해 c(n,k), 우리는 (n,k)그러한 모든 것을 처리해야합니다 y=c(n,k). L=floor(log10(n)+1)일부에 대해 말해 봅시다 n. 그러므로 y=L*k붙잡아 야합니다. 로 시작한 k=2,L=y/2다음 수행 k=3,L=y/3;k=4,L=y/4...k=y,L=1하고 정수가 아닌 값을 건너 뛰십시오 L. 전체 생성하기 위해 c(n,k)기능을 시작 (1,2)으로 y=2, 및 증가 y(1)에 의해 당신이 얻을 때마다 다시 시작합니다 L==1. 이제 우리는 쌍을 열거 (L,k)하고 우리의 조건을 만족시킵니다. 그러나, 우리는 가능한 모든 검색해야 n에서 L모든 정수를 열거하여 우리가 할 수있는,L 자리. 그런 다음 각 (n,k)쌍에 대해k-1손실 된 요소는 결과적으로 손실 숫자를 생성하고 목록에 추가해야합니다. 그런 다음 목록을 정렬하고 다음 (L,k)쌍에서 반복하여d<c(n,k) 이전에 언급 한대로 합니다.

코드 분석 (약간 구식) :

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