Hintergrund

Sie arbeiten für einen Brettspielhersteller und müssen für ein Spiel Holzkacheln mit den Zahlen von 0 bis n herstellen . Einige Kacheln wären jedoch ohne weiteres nicht mehr zu unterscheiden, z . B. 6und 9. Um dies zu vermeiden, müssen Sie Zahlen, die mit anderen (und nur mit diesen) verwechselt werden können, mit einem eindeutigen Punkt versehen, z. B. mit Kacheln wie 9.oder 6089..

Leider müssen Sie dafür ein altes, aber programmierbares Holzstichgerät verwenden, dessen Oberfläche so kaputt ist, dass Sie jedes Zeichen des Programms in einem unbeschreiblich langwierigen Prozess von Hand codieren müssen. Zum Glück versteht das Gerät jede vorhandene Programmiersprache. Sie suchen also das kürzeste Programm, das solche Kacheln druckt.

Aktuelle Aufgabe

Schreiben Sie das kürzeste Programm, das:

• Übernimmt eine positive ganze Zahl n als Eingabe. Wie die Eingabe gelesen wird, liegt bei Ihnen.
• Gibt jede der Zahlen von 0 bis n ( einschließlich 0 und n ) genau einmal in einer Reihenfolge Ihrer Wahl aus, die durch ein einzelnes Leerzeichen (einschließlich Zeilenvorschub) getrennt ist. Die Zahlen sind ohne führende Nullen auszudrucken.
• Fügt einen Punkt (.) An jede Zahl an, die sich bei Drehung um π (180 °) in eine andere gültige Zahl verwandelt, auch wenn diese Zahl größer als n ist. Die 0 und 8 Ihrer Schrift sind rotationssymmetrisch und die 9 ist eine gedrehte 6. Die 2 und 5 unterscheiden sich bei der Drehung. Die 1 ist nicht rotationssymmetrisch. Zahlen mit führenden Nullen sind ungültig.

Beispiele

Jede der folgenden Zahlen muss genau so gedruckt werden:

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

Pyth - 34 38

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

Ich muss mich bei @ Sp3000 dafür bedanken, dass ich 4 Bytes entfernt habe. Ich hatte ursprünglich eine zusätzliche Überprüfung, &@JKdie sicherstellte, dass die Nummer eine 6 oder 9 enthielt, aber nachdem ich die Antworten vor dem Posten durchgesehen hatte, las ich seine Antwort und bemerkte, dass meine identische Übersetzung und Umkehrung dies bereits erledigten.

Vielen Dank auch an @isaacg für den Hinweis, dass Strings iterabel sind und Sie Set-Operationen für sie verwenden können. Auch zum Erstellen des aktuellen Codes;)

Erläuterung:

                                    : (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 Bytes

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

Ich denke, es gibt Raum für Verbesserungen.

Teste es hier.

Erläuterung

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 Bytes

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

Ich denke, es kann ein bisschen mehr golfen werden.

Nimmt nvon STDIN.

Probieren Sie es hier online aus

APL 66

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

Erläuterung:

¨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 

Probieren Sie es auf tryapl.org

Beachten Sie, dass im Online-Interpreter die ⍎-Funktion nicht funktioniert, sodass ich sie durch 2⊃⎕VFI ersetzen musste, was in diesem Fall dasselbe tut, die Zahl ausführt und mit einem String zurückgibt.

Perl 5, 53 Bytes

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

Online-Demo.

Verwendet die Perl 5.10+ say-Funktion und muss daher mit perl -M5.010(oder perl -E) ausgeführt werden, um sie zu aktivieren. (Siehe diesen Meta-Thread. ) Liest die Eingabe von stdin und druckt nach stdout.

Python 2, 130 116 113 Bytes

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

Definiert eine Funktion, fdie die Zahlen in aufsteigender Reihenfolge an STDOUT ausgibt.

Diesmal dachte ich, ich würde mit .translate:) ein Blatt aus @ feersums Buch ziehen

Erweitert:

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

Vorherige Lösung:

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)

Vielen Dank an @xnor, dass er mir den .replaceTrick vor einiger Zeit gezeigt hat.

C #, 343 309 Zeichen

Viel zu lang, aber trotzdem:

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)?". ":" "));}}}}

Wie funktioniert es? Um der Zahl einen Punkt hinzuzufügen, müssen die folgenden Anforderungen erfüllt sein:

• Besteht nur aus 0, 8, 6und 9.
• Endet nicht mit einer Null.
• Ist nicht die gleiche Nummer, wenn Sie es drehen:
  • Wenn eine Zahl die gleiche Anzahl von 6s und 9s hat, und
  • if c= die Zahl mit allen 6s ersetzt mit 9s,
  • und umgekehrt c== c,
  • dann: Die gedrehte Zahl ist die gleiche wie die Zahl selbst.

Die Zahlen sind durch ein Leerzeichen getrennt.

Code mit Einzug:

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) ? ". " : " "));
            }
        }
    }
}

M (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) "."

Die meisten in M ​​integrierten Befehle und Funktionen haben abgekürzte Versionen. Ich habe die vollständigen Namen unten verwendet.

READ n- Lesen Sie eine Zeichenfolge von der Tastatur und speichern Sie sie in n.

FOR i=0:1:n- Schleife von Null bis n, ijedes Mal um 1 inkrementierend . (Der Rest der Linie bildet den Körper der Schleife.)

WRITE !,i- Drucken Sie eine neue Zeile, gefolgt vom Wert von i.

SET r=$TRANSLATE($REVERSE(i),69,96))- Kehren Sie um i, ersetzen Sie Neunen durch Sechser und Sechser durch Neunen und speichern Sie diese in r.

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

• :- Bezeichnet einen nachbedingten Ausdruck, sodass der WRITEBefehl nur ausgeführt wird, wenn r=+r*r'=i*'$TRANSLATE(i,0689)er einen Wahrheitswert ergibt.
• r=+r- Stellen Sie sicher, dass rkeine führende Null vorhanden ist. Der unäre +Operator konvertiert eine Zeichenfolge in eine Zahl, die führende Nullen entfernt, falls vorhanden.
• *- Multiplikationsoperator. M hat keine Operationsreihenfolge; Alle binären Operatoren werden in der Reihenfolge ausgewertet, in der sie von links nach rechts erscheinen.
• r'=i- Überprüfen Sie, ob dies inicht mit der gespiegelten Version übereinstimmt r.
• '$TRANSLATE(i,0689)- Entfernen Sie alle Nullen, Sechser, Achter und Neuner von iund prüfen Sie, ob nichts mehr übrig ist. ( 'Ist der logische Negationsoperator.)
• "."- Schließlich das Argument zum WRITEBefehl (eine Literalzeichenfolge).

Bearbeiten: Durch Missbrauch des Multiplikationsoperators etwas kürzer. Vorherige Version:

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 Zeichen

∊{⍵,'. '↓⍨∨/(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 # 205 209

C # muss nicht so lang sein ...
mehr oder weniger ein Port meiner JavaScript-Antwort

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);}}}

Ungolfed

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);
        }
    }
}

Ruby, 81

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

Die Eingabe erfolgt über die Befehlszeile.

Erzeugt eine Liste von Strings von 0bis n. Es durchläuft sie und druckt sie. Es wird ein Punkt angehängt, wenn alle Bedingungen erfüllt sind:

• Das Umkehren der Zahl und das Ersetzen des 6s durch 9s ergibt nicht das Original
• Die Nummer besteht nur aus den Ziffern 0, 6,8 und9
• Die Zahl endet nicht mit 0

JavaScript (ES6) 101 104 106 109

Eine Funktion mit n als Argument, die über console.log ausgegeben wird.
Bearbeiten mit% 10, um auf führende 0 zu testen.
Bearbeiten 2- for Reorganisation. Ich benötige kein Array-Verständnis.
Bearbeiten 3 hat (erneut) die Prüfung auf führende 0 geändert

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
}

Ungolfed und einfacher zu testen

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)

Ausgabe

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

Bash + Coreutils, 105

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

Prüfung:

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

sed, 467

Länger als C # ...

Ich habe dies so ziemlich abgeschlossen, als @ edc65 darauf hinwies, dass Antworten die Zahlen 0-n und nicht nur n verarbeiten müssen. Das Hinzufügen des sed-Codes zum Inkrementieren von 0-n fügt VIEL mehr Code hinzu, da diese Aufgabe für arithmetiklose sed ungeeignet ist.

: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

Entsprechend dem OP spielt die Bestellung keine Rolle, daher arbeiten wir von n nach 0 abwärts.

Ausgabe:

$ 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"."}}

Lesen Sie den n-Wert von stdin.

Prüfung:

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

Rebol - 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 + einige Anmerkungen:

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

bc, 158

Nachdem ich dies rein in sed mit allen String- und Regex-Operationen ohne native Arithmetik getan hatte , war ich gespannt, wie dies andersherum aussehen würde, dh mit allen arithmetischen und logischen Operationen und ohne String / Regex:

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"}

Die Ausgabe wird in absteigender Reihenfolge sortiert.

Ausgabe:

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

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

JavaScript - 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.

Oder lesbare Version:

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

Ich bin nicht sehr glücklich mit dem Regex, irgendwelche Ideen?

Edit : Gelernt ordentlicher Trick mit ~und for (... of ...)von @ edc65
Edit2 : Reorganisierte Bedingungen
Edit3 : Angewandte Vorschläge von @ edc65

05AB1E , 38 37 30 29 Bytes

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

Probieren Sie es online aus.

Erläuterung:

Ý                # 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)

Zusätzliche Erklärung für einige Teile:

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)

Perl - 84

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

Powershell, 111 102 Bytes

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

Erklärtes Testskript:

$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"
}

Ausgabe:

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 Bytes

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

Führen Sie es aus und debuggen Sie es

Ausgepackt, ungolfed und kommentiert sieht es so aus.

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)
  ".

Führen Sie dieses aus