배경

일부 보드 게임 제조업체에서 일하고 있으며 일부 게임의 경우 0에서 n 까지 숫자가 새겨진 나무 타일을 생산해야합니다 . 그러나 더 이상 고민하지 않으면 일부 타일은 구분할 수 없게됩니다 (예 : 6및) 9. 이를 방지하려면, 당신은 명확하게하는 점, 예를 들면와 (과 만) 다른 사람과 혼동 할 수있는 숫자를 장착해야합니다, 당신은 같은 타일 것 9.또는 6089..

불행히도, 인터페이스가 너무 깨져서 말할 것도없이 지루한 프로세스로 프로그램의 모든 문자를 인코딩 해야하는 구식이지만 프로그래밍 가능한 오래된 나무 조각 장치를 사용해야합니다. 다행히도 장치는 기존의 모든 프로그래밍 언어를 이해합니다. 따라서 이러한 타일을 인쇄하는 가장 짧은 프로그램을 찾고 있습니다.

실제 작업

가장 짧은 프로그램을 작성하십시오.

• 양의 정수 n 을 입력으로 사용합니다. 입력을 읽는 방법은 귀하에게 달려 있습니다.
• 단일 공백 ​​문자 (개행 문자 포함)로 구분하여 선택한 순서대로 0에서 n (0 및 n 포함)의 각 숫자를 정확히 한 번만 인쇄합니다 . 숫자는 선행 0없이 인쇄됩니다.
• 숫자가 n 보다 큰 경우에도 π (180 °) 회전 할 때 유효한 다른 숫자로 바뀌는 모든 숫자에 점 (.)을 추가합니다 . 서체의 0과 8은 회전 대칭이며 9는 회전 6입니다. 2와 5는 회전시 서로 다릅니다. 1은 회전 대칭이 아닙니다. 앞에 0이있는 숫자는 유효하지 않습니다.

예

다음과 같은 각 번호는이 방법으로 정확하게 인쇄해야합니다.

• 2
• 4
• 5
• 6.
• 8
• 9.
• 16
• 60
• 66.
• 68.
• 69
• 906
• 909.
• 8088.
• 9806.
• 9886
• 9889.

피스 -34 38

VhQJ`N+J*\.&nJX_J`69`96&eN!-J"0689

4 바이트를 제거하는 데 도움을 주신 @ Sp3000에 감사해야합니다. 나는 원래 수 &@JK에 6 또는 9가 있는지 확인하는 추가 검사 를 받았지만 게시하기 전에 답변을 읽은 후에 그의 답변을 읽었으며 동일한 번역 및 반전이 이미 처리되었음을 알았습니다.

또한 문자열이 반복 가능하다는 점을 지적 한 @isaacg 덕분에 세트 작업을 사용할 수 있습니다. 또한 현재 코드를 만들기 위해;)

설명:

                                    : (implicit) Q=eval(input())
VhQ                                 : for N in range(Q+1):
   J`N                              : J=str(N)
      +J*\.                         : J + "." * ...
           &nJX_J`69`96             : J!=translate(reversed(J),"69","96") and...
                       &eN          : N%10 and...
                          !-J"0689  : not(setwise_difference(J, "0689"))

CJam, 46 44 43 42 바이트

l~),{_A%g1$s_6890s-!\_69s_W%erW%=!&&'.*N}/

개선의 여지가 있다고 생각합니다.

여기에서 테스트하십시오.

설명

l~),{_A%g1$s_6890s-!\_69s_W%erW%=!&&'.*N}/
l~                                         "Read an eval input.";
  ),                                       "Get range from 0 to n.";
    {                                   }/ "For each...";
     _                                     "Get a copy of the integer.";
      A%g                                  "Ends with digit other than 0?";
         1$s_                              "Get another copy, convert to string, get a copy.";
             0689s-!                       "Contains rotation-safe digits?";
                    \                      "Swap with other copy.";
                     _                     "Get another copy.";
                      69s_W%er             "Swap 6 and 9.";
                              W%           "Reverse.";
                                =!         "Is different from original?";
                                  &&       "AND all three conditions.";
                                    '.*    "If true, push a period (else, an empty string).";
                                       N   "Push a newline.";

CJam, 46 45 43 42 바이트

ri){Is___69`96`erW%=!\6809`-!&IA%g&'.*N}fI

좀 더 골프를 칠 수 있다고 생각합니다.

nSTDIN에서 가져 옵니다.

여기에서 온라인으로 사용해보십시오

APL 66

∊' ',¨{a←⌽'0.....9.86'[⎕D⍳b←⍕⍵]⋄'.'∊a:b⋄('0'=⊃a)∨⍵=⍎a:b⋄b,'.'}¨0,⍳

설명:

¨0,⍳           applies the function to each number 0-n
a←⌽'0.....9.86'[⎕D⍳b←⍕⍵] inverts 6s and 9s, leaving 8s and 0s, and replacing other numbers with dots. Reverses vector after substitution.
'.'∊a          if there is a dot in the number....
('0'=⊃a)       .. or if the number starts with 0...
⍵=⍎a           or if the (inverted) number is the same as original
:b             then print the original number
b,'.'          else print a dot in the end
∊' ',¨        Finally to give the result in the asked format i add a single space after each result and join them all 

tryapl.org에서 사용해보십시오

온라인 인터프리터에서 ⍎ 함수가 작동하지 않으므로이 경우 동일한 기능을 수행하는 2⊃⎕VFI로 대체해야하고 문자열이 주어진 경우 숫자를 실행하고 반환합니다.

펄 5, 53 바이트

say$_,"."x(!/[1-57]|0$/&&reverse!=y/96/69/r)for 0..<>

온라인 데모.

Perl 5.10+ say기능을 사용하므로이 기능을 사용하려면 perl -M5.010(또는 perl -E)로 실행해야합니다. ( 이 메타 스레드를 참조하십시오 . ) stdin에서 입력을 읽고 stdout으로 인쇄합니다.

파이썬 2 130 116 113 바이트

def f(n):S=`n`;n and f(n-1);print S+"."*all([n%10,set(S)<=set("0689"),(u""+S[::-1]).translate({54:57,57:54})!=S])

f숫자를 STDOUT에 오름차순으로 인쇄 하는 함수 를 정의합니다 .

이번에는 @feersum의 책에서 잎을 가져갈 것이라고 생각했습니다. .translate:)

넓히는:

def f(n):
 S=`n`        
 n and f(n-1)                                      # Recurse if not 0                                     
 print S+"."*all([n%10,                            # Not divisible by 10
                  set(S)<=set("0689"),             # Consists of 0689
                  (u""+S[::-1]).translate
                  ({54:57,57:54})!=S])             # When rotated is not itself

이전 솔루션 :

def f(n):S=`n`;print S+"."*all([n%10,set(S)<=set("0689"),eval("S[::-1]"+".replace('%s','%s')"*3%tuple("6a96a9"))!=S]);n and f(n-1)

.replace얼마 전에 트릭 을 보여준 @xnor에게 감사드립니다 .

C #, 343 309 자

방법 너무 긴하지만, 어쨌든 :

namespace System.Linq{class C{static void Main(){int n=int.Parse(Console.ReadLine());for(int i=0;i<=n;i++){var b=i+"";var c=b.Replace("6","9");Console.Write(b+(b.All(x=>x=='0'|x=='8'|x=='6'|x=='9')&!b.EndsWith("0")&!(b.Count(x=>x=='6')==b.Count(x=>x=='9')&new String(c.Reverse().ToArray())==c)?". ":" "));}}}}

어떻게 작동합니까? 숫자에 마침표를 추가하려면 다음 요구 사항과 일치해야합니다.

• 단지로 구성 0, 8, 6와 9.
• 0으로 끝나지 않습니다.
• 회전 할 때 같은 숫자가 아닙니다 :
  • 숫자가 6s와 9s의 양이 같은 경우
  • 경우 c= 모든과 수가 6로 대체합니다을이야 9의,
  • 반대로 c== c,
  • 회전 된 숫자는 숫자 자체와 동일합니다.

숫자는 공백으로 구분됩니다.

들여 쓰기 코드 :

namespace System.Linq
{
    class C
    {
        static void Main()
        {
            int n = int.Parse(Console.ReadLine());
            for (int i = 0; i <= n; i++)
            {
                var b = i + "";
                var c = b.Replace("6", "9");
                Console.Write(b +
                    (b.All(x => x == '0' | x == '8' | x == '6' | x == '9') &
                    !b.EndsWith("0") &
                    !(b.Count(x => x == '6') == b.Count(x => x == '9') &
                    new String(c.Reverse().ToArray()) == c) ? ". " : " "));
            }
        }
    }
}

남 (MUMPS) -72 70

R n F i=0:1:n W !,i S r=$TR($RE(i),69,96) W:r=+r*r'=i*'$TR(i,0689) "."

M의 대부분의 내장 명령 및 기능에는 약어 버전이 있습니다. 아래의 전체 이름을 사용했습니다.

READ n-키보드에서 문자열을 읽고 저장하십시오 n.

FOR i=0:1:n- 매번 1 n씩 증가 i하여 0에서로 반복 합니다. (라인의 나머지 부분은 루프의 본문을 구성합니다.)

WRITE !,i -줄 바꿈과 값을 인쇄하십시오. i .

SET r=$TRANSLATE($REVERSE(i),69,96))-반대로 i, 9를 6으로 바꾸고 6을 9로 바꾸고 그 안에 저장하십시오 r.

WRITE:r=+r*r'=i*'$TRANSLATE(i,0689) "."

• :-사후 조건식을 나타내므로 WRITE명령은 다음과 같은 경우에만 실행됩니다r=+r*r'=i*'$TRANSLATE(i,0689) 정확한 값으로 평가 .
• r=+r- r앞에 0이 없는지 확인하십시오 . 단항+ 연산자는 문자열을 숫자로 변환하며 앞에 0이 있으면 제거합니다.
• *-곱셈 연산자. M은 작업 순서가 없습니다. 모든 이진 연산자는 왼쪽에서 오른쪽으로 나타나는 순서대로 평가됩니다.
• r'=i- i뒤집힌 버전과 동일하지 않은지 확인r .
• '$TRANSLATE(i,0689)-에서 0, 6, 8 및 9를 모두 제거하고 i남은 것이 없는지 확인합니다. ( '논리 부정 연산자입니다.)
• "."-마지막으로 WRITE명령에 대한 인수 (리터럴 문자열).

편집 : 곱셈 연산자를 남용하여 조금 짧게 만들었습니다. 이전 버전:

R n F i=0:1:n W !,i S r=$TR($RE(i),69,96) I '$TR(i,0689),i'=r,r=+r W "."

APL, 53 자

∊{⍵,'. '↓⍨∨/(3≡⊃i)(5∊i),⍵≡'9608x'[i←⌽'6908'⍳⍵]}∘⍕¨0,⍳

0,⍳N        numbers 0..N
{...}∘⍕¨    format each number as a string and do the thing in curly braces
                inside the braces ⍵ is the current string
'6908'⍳⍵    encode '6' as 1, '9' as 2, '0' as 3, '8' as 4, and all others as 5
⌽           reverse
'9608x'[A]  use each element of A as an index in '9608x':
                effectively: swap '9'←→'6', preserve '08', mask other digits
⍵≡          does it match the original string?
                this is the first boolean condition, two more to come
5∊i         did we have a digit other than '0689'?
3≡⊃i        is the first of i (that is, the last of ⍵) a '0' (encoded as 3)?
∨/          disjunction ("or") over the three conditions, returns 0 or 1
'. '↓⍨      drop 0 or 1 elements from the beginning of the string '. '
⍵,          prepend ⍵
∊           flatten the results to obtain a single output string

C # 205209

C #은 그리 길지 않아도됩니다 ...
약간의 JavaScript 답변 포트

class P{static void Main(string[]a){for(int n=int.Parse(a[0]);n>=0;--n){string p="",u=n+p;int e=n%10;foreach(var d in u)p=(d<56?d!=54?d>48?e=0:0:9:120-d-d)+p;System.Console.WriteLine(e!=0&p!=u?u+".":u);}}}

언 골프

class P 
{
    static void Main(string[] a)
    {
        for (int n = int.Parse(a[0]); n >= 0; --n)
        {
            string p = "", u = n + p;
            int e = n % 10;
            foreach (var d in u) p = (d < 56 ? d != 54 ? d > 48 ? e = 0 : 0 : 9 : 120 - d - d) + p;
            System.Console.WriteLine(e != 0 & p != u ? u + "." : u);
        }
    }
}

루비, 81

?0.upto(*$*){|x|puts x.reverse.tr('69','96')!=x&&x=~/^[0689]+$/&&/0$/!~x ?x+?.:x}

입력은 명령 행에서 가져옵니다.

String에서 0까지 의 목록을 생성합니다 n. 그것들을 통과시켜 인쇄합니다. 모든 조건이 충족되면 점을 추가합니다.

• 숫자를 반대로 바꾸고 6s를 9s로 바꾸면 원본이 나오지 않습니다.
• 숫자는 숫자로 구성 0, 6,8 및9
• 숫자는 끝나지 않습니다 0

자바 스크립트 (ES6) 101 104 106 109

CONSOLE.LOG 통해 인수 출력 된 N과 함수
편집 0 유도하기위한 시험의 10 %를 사용하여
편집 2 for 모두 이후에 재구성, I 배열 이해를하지 않아도
편집 3 0을 유도하기위한 (다시) 체크 수정

F=n=>{
   for(;e=~n;console.log(e*l&&p-n?n+'.':n),--n)
     for(d of(p='')+n)p=(l=d<8?d-6?-d?e=0:0:9:24-d-d)+p
}

확고 하고 테스트하기 쉬운

F=n=>
{
  o = '';
  for( ; ~n; --n) // loop on n decreasing to 0 (~n is 0 when n==-1)
  {
    e = ~n; // init to a nonzero value, zero will mark 'invalid digit'
    p = ''; // build rotated number in p
    for(d of '' + n)
    {
      // l is the current digit, on exit will be the first digit of p
      l = d < 8 ?
            d != 6 ?
              d != 0 ?
                e = 0 // invalid char found, no matter what
                : 0 
              : 9 // 6 become 9
            : 24 - d - d; // calc 8 => 8, 9 => 6
      p = l + p;
    }       
    // e==0 if invalid char, l==0 if leading 0
    o += ' ' + ( e * l && p-n ? n+'.' : n);
  }
  console.log(o);
}

F(100)

산출

100 99. 98. 97 96 95 94 93 92 91 90 89. 88 87 86. 85 84 83 82 81 80 79 78 77 76 75 74 73 72 71 70 69 68. 67 66. 65 64 63 62 61 60 59 58 57 56 55 54 53 52 51 50 49 48 47 46 45 44 43 42 41 40 39 38 37 36 35 34 33 32 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 15 14 13 12 11 10 9. 8 7 6. 5 4 3 2 1 0

배쉬 + coreutils, 105

for((i=0;i<=$1;i++));{
[ ${i//[0689]/} ]||[ $i = `rev<<<$i|tr 69 96` ]||((!${i: -1}))||d=.
echo $i$d
d=
}

테스트:

$ ./rotproof.sh 100 | grep "\."
6.
9.
66.
68.
86.
89.
98.
99.
$ 

sed, 467

C #보다 길다 ...

@ edc65가 대답이 n이 아니라 숫자 0-n을 처리해야한다고 지적했을 때 이것을 거의 완성했습니다. 0-n을 증가시키기 위해 sed 코드를 추가하면이 작업이 산술적 sed에 적합하지 않기 때문에 많은 코드가 추가됩니다.

:l
/^[0689]*$/{
h
s/$/:/
:x
s/([0-9]):(.*)/:\2\1/
tx
s/://
y/69/96/
G
/^([0-9]+)\n\1/be
s/^[^0].*/&./
:e
s/.*\n//
}
p
s/\.//
s/[0-9]/<&/g
s/0//g;s/1/_/g;s/2/__/g;s/3/___/g;s/4/____/g;s/5/_____/g
s/6/______/g;s/7/_______/g;s/8/________/g;s/9/_________/g
:t
s/_</<__________/
tt
s/<//g
s/_//
:b
s/__________/</g
s/<([0-9]*)$/<0\1/
s/_________/9/;s/________/8/;s/_______/7/;s/______/6/
s/_____/5/;s/____/4/;s/___/3/;s/__/2/;s/_/1/
s/</_/g
tb
s/^$/0/
/^0$/by
bl
:y
c\
0
p

OP에 따라 순서는 중요하지 않으므로 n에서 0으로 하향 조정됩니다.

산출:

$ sed -rnf rotproof.sed <<< 100 | grep "\."
99.
98.
89.
86.
68.
66.
9.
6.
$ 

AWK : 120

{a[a[6]=9]=6;a[8]=8;for(j=a[0]=0;j<=$0;++j){r="";for(i=j;i;i=int(i/10))r=r a[i%10];print(j~/[^0689]|0$/||j==r)?j:j"."}}

stdin에서 n 값을 읽습니다.

테스트:

C : \ AWK> gawk -f revnum.awk | grep \.
100
^ Z
6.
9.
66.
68.
86.
89.
98.
99.

리볼-195

for n 0 do input 1[b: copy a: form n d: c: 0 parse reverse a[any[m:"6"(change m"9"++ c)|"9"(change m"6"++ c)|"0"|"8"| skip(++ d)]]print rejoin [b either all[d = 0 c > 0 a != b a/1 != #"0"]"."{}]]

Ungolfed + 일부 주석 :

for n 0 do input 1 [
    b: copy a: form n
    d: c: 0

    ; reverse number and rotate "6" & "9"
    ; and do some counts (c when "6" or "9" and d when != "0689")
    parse reverse a [
        any [
            m:
              "6" (change m "9" ++ c)
            | "9" (change m "6" ++ c)
            | "0"
            | "8"
            | skip (++ d)
        ]
    ]

    print rejoin [
        b either all [
            d = 0               ; only has 0689 digits
            c > 0               ; must have at least one "6" or "9"
            a != b              ; not same when reversed
            a/1 != #"0"         ; does not "end" with zero
        ]
        "." {}                  ; if ALL then print "." else blank {}
    ]
]

기원전 158

네이티브 산술없이 모든 문자열 및 정규식 작업을 사용하여 sed에서 순수 하게이 작업을 수행 한 후 이것이 다른 방식으로 어떻게 보일지 궁금합니다. 즉 모든 산술 및 논리 연산과 문자열 / 정규 표현식이 없습니다.

for(i=read();i+1;r=0){p=1
for(x=i;x;x/=A){d=x%A
if(x==i&&!d)p=0
if(d==6||d==9)d=F-d else if(d%8)p=0
r=r*A+d}
if(r==i)p=0
print i--
if(p)print "."
print "\n"}

출력은 내림차순으로 정렬됩니다.

산출:

$ bc rotproof.bc <<< 100 | grep "\."
99.
98.
89.
86.
68.
66.
9.
6.
$ 

파이썬-152

for i in range(input()+1):print`i`+("."*all([j in"0689"for j in`i`])and`i`[-1]!="0"and`i`!=`i`.replace("9","x").replace("6","9").replace("x","6")[::-1])

자바 스크립트 - 168 129 119 113 111 108

F=n=>{for(;~n;n--){r='';for(c of""+n)r=(c-6?c-9?c:6:9)+r;console.log(r-n&&!/[1-57]/.test(r)&&n%10?n+".":n)}}

4 5 6. 8 9. 16 60 66. 68. 69 906 909. 6090 9806. 9886 9889.

또는 읽을 수있는 버전 :

F=n=>{for(;~n;n--){
    r='';for(c of ""+n)r=(c-6?c-9?c:6:9)+r; // rotate
    console.log( // output, new-line is added
        // original number, and
        // append dot only if number is different than its rotated version and no un-rotatable digit is present and there is no zero at the end
        r-n && !/[1-57]/.test(r) && n%10
           ?n+".":n
    )}}

나는 정규식, 어떤 아이디어에 만족하지 않습니까?

편집 :와 깔끔한 트릭을 습득 ~하고 for (... of ...)@ edc65에서
Edit2가 개편 조건 :
EDIT3이 :에 의해 제안을 적용 @ edc65

05AB1E , 38 37 30 29 바이트

ÝεÐSUT%ĀiŽR!XåPiÐ69‡RÊi'.«]»

온라인으로 사용해보십시오.

설명:

Ý                # Inclusive 0-based range: [0, (implicit) input]
 ε               # Map each integer to:
  Ð              #  Triplicate the current integer
  SU             #  Convert it to a list of digits, and pop and store it in variable `X`
    T%Āi         #  If the current integer contains no trailing zeros
    ŽR!XåPi      #  And if the current integer only consists of the digits [0689]
    Ð69‡RÊi     #  And if the current integer is not the same when its 6s and 9s
                 #  are swapped and then the total is reversed
             '.« #   Concat a '.'
                 #  Implicit else: use the top of the stack (the duplicate current integer)
]                # Close all three ifs and the map
 »               # Join the resulting list by newlines (and output implicitly)

일부 부품에 대한 추가 설명 :

T%Āi       # Check if the integer contains no trailing zeros:
T          #  Push 10 (T is a builtin for 10)
 %         #  Modulo
  Ā        #  Trutified: 0 remains 0 (falsey), everything else becomes 1 (truthy)
           #   i.e. 12 % 10 → 2 → 1 (truthy)
           #   i.e. 68 % 10 → 8 → 1 (truthy)
           #   i.e. 70 % 10 → 0 → 0 (falsey) (70 remains as is)
           #   i.e. 609 % 10 → 9 → 1 (truthy)
           #   i.e. 808 % 10 → 8 → 1 (truthy)

ŽR!XåPi    # Check if the integer only consists of the digits 0, 6, 8 and/or 9:
ŽR!        #  Push 6890 (Ž is a builtin for 2-char compressed integers, where R! is 6890)
   X       #  Push variable `X` (the list of digits)
    å      #  Check for each of these digits if they're in "6890"
     P     #  Take the product of that list
           #   i.e. [1,2] → [0,0] → 0 (falsey) (12 remains as is)
           #   i.e. [6,8] → [1,1] → 1 (truthy)
           #   i.e. [6,0,9] → [1,1,1] → 1 (truthy)
           #   i.e. [8,0,8] → [1,1,1] → 1 (truthy)

Ð69‡RÊi   # Check if the integer with 6s and 9s swapped and then reversed isn't unchanged:
Ð          #  Triplicate the integer
 69        #  Push 69
   Â       #  Bifurcate (short for Duplicate & Reverse)
    ‡      #  Transliterate (in `a` replace all characters `b` with characters `c`)
     R     #  Reverse
      Ê    #  Check for inequality
           #   i.e. 68 → "68" → "98" → "89" → 68 != "89" → 1 (truthy) (68 becomes "68.")
           #   i.e. 609 → "609" → "906" → "609" → 609 != "609" → 0 (falsey) (609 remains as is)
           #   i.e. 808 → "808" → "808" → "808" → 808 != "808" → 0 (falsey) (808 remains as is)

펄-84

for(0..$ARGV[0]){s/6/x/g;s/9/6/g;s/x/9/g;printf"$_%s\n",$_=~/^[0689]+[689]$/?".":""}

파워 쉘, 111 102 바이트

param($s)$s+'.'*!($s-match'[1-57]|0$|'+-join$(switch -r($s[($s.Length-1)..0]){'0|8'{$_}'6'{9}'9'{6}}))

설명 된 테스트 스크립트 :

$f = {

param($s)           # input string
$l=$s.Length        # length of the string
$c=$s[($l-1)..0]    # chars of the string in the reversed order
$d=switch -r($c){   # do switch with regex cases for each char
    '0|8'{$_}       # returns the current char if it equal to 8 or 0
    '6'{9}          # returns 9 if the current char is 6
    '9'{6}          # returns 6 if the current char is 9
}                   # returns array of new chars (contains 0,6,8,9 only)
$s+'.'*!(            # returns s. Add '.' if not...
    $s-match'[1-57]|0$|'+-join$d
                    # $s contains chars 1,2,3,4,5,7 or
                    # ends with 0 or
                    # equal to string of $d
)

}

@(
    ,('2'    ,'2'   )
    ,('4'    ,'4'   )
    ,('5'    ,'5'   )
    ,('6.'   ,'6'   )
    ,('7'    ,'7'   )
    ,('9.'   ,'9'   )
    ,('16'   ,'16'  )
    ,('60'   ,'60'  )
    ,('66.'  ,'66'  )
    ,('68.'  ,'68'  )
    ,('69'   ,'69'  )
    ,('906'  ,'906' )
    ,('909.' ,'909' )
    ,('8088.','8088')
    ,('9806.','9806')
    ,('9886' ,'9886')
    ,('9889.','9889')
) | % {
    $e,$s = $_
    $r = &$f $s
    "$($r-in$e): $r"
}

산출:

True: 2
True: 4
True: 5
True: 6.
True: 7
True: 9.
True: 16
True: 60
True: 66.
True: 68.
True: 69
True: 906
True: 909.
True: 8088.
True: 9806.
True: 9886
True: 9889.

Stax , 27 바이트

Ç▒≈♣▌╬"÷╜─B↓«âpø←╚S☼ì>♫è;&╛

실행 및 디버깅

포장을 풀고 포장을 풀고 주석을 달았습니다.

0p      print 0 with no line break
F       for each [1 .. n] execute the rest of the program, where n is the input
  zP    print a newline
  q     peek and print the iterating variable without newline
  A%!C  modulo 10, and cancel iteration if zero (this cancels for multiples of 10)
  _$cc  convert iterating value to string and duplicate it twice on the stack
  7R6-$ construct the string "123457"
  |&C   if the character intersection is truthy, cancel the iteration
  r     reverse string
  69$:t map 6 and 9 characters to each other
  =C    if this rotated string is equal to the original, cancel iteration
        print "." with no newline 
        (this comment precedes the instruction because it's an unterminated literal)
  ".

이것을 실행