Contexte

Vous travaillez pour un fabricant de jeux de société et devez produire des tuiles en bois avec les numéros de 0 à n gravés dessus pour certains jeux. Cependant, sans plus tarder, certaines tuiles deviendraient indiscernables, par exemple, 6et 9. Pour éviter cela, vous devez équiper les numéros qui peuvent être confondus avec les autres (et seulement ceux-ci) d'un point sans ambiguïté, par exemple, vous auriez des tuiles comme 9.ou 6089..

Malheureusement, vous devez utiliser pour cela un appareil de gravure sur bois ancien, mais programmable, dont l'interface est si brisée que vous devez encoder tous les caractères du programme à la main dans un processus extrêmement fastidieux. Heureusement, l'appareil comprend tous les langages de programmation existants. Vous recherchez donc le programme le plus court qui imprime de telles tuiles.

Tâche réelle

Écrivez le programme le plus court qui:

• Prend un entier positif n en entrée. La façon dont l'entrée est lue dépend de vous.
• Imprime chacun des nombres de 0 à n (0 et n inclus) exactement une fois dans l'ordre de votre choix, séparés par un seul caractère d'espacement (y compris les retours à la ligne). Les chiffres doivent être imprimés sans zéros de tête.
• Ajoute un point (.) À chaque nombre qui se transforme en un autre nombre valide lors de la rotation de π (180 °), même si ce nombre est supérieur à n. Les caractères 0 et 8 de votre police sont symétriques en rotation et le 9 est un 6. pivoté. Les 2 et 5 sont distincts lors de la rotation; le 1 n'est pas symétrique en rotation. Les nombres avec des zéros non significatifs ne sont pas valides.

Exemples

Chacun des numéros suivants doit être imprimé exactement de cette façon:

• 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

Je dois remercier @ Sp3000 de m'avoir aidé à supprimer 4 octets. Au départ, j'avais une vérification supplémentaire &@JKqui m'assurait qu'il y avait un 6 ou 9 dans le nombre, mais après avoir lu les réponses avant de poster, j'ai lu sa réponse et j'ai remarqué que ma traduction et mon annulation identiques s'en étaient déjà occupées.

Merci également à @isaacg pour avoir souligné que les chaînes sont itérables et que vous pouvez utiliser des opérations de définition sur elles. Aussi pour faire le code actuel;)

Explication:

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

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

Je pense qu'il y a matière à amélioration.

Testez-le ici.

Explication

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 octets

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

Je pense qu'il peut être joué un peu plus.

Prend nde STDIN.

Essayez-le en ligne ici

APL 66

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

Explication:

¨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 

Essayez-le sur tryapl.org

Notez que dans l'interpréteur en ligne, la fonction doesn't ne fonctionne pas, j'ai donc dû la remplacer par 2⊃⎕VFI qui fait la même chose dans ce cas, exécute et renvoie le nombre, en fonction d'une chaîne.

Perl 5, 53 octets

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

Démo en ligne.

Utilise la fonctionnalité Perl 5.10+ say, doit donc être exécutée avec perl -M5.010(ou perl -E) pour l'activer. (Voir ce fil méta. ) Lit l'entrée depuis stdin, imprime vers stdout.

Python 2, 130 116 113 octets

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

Définit une fonction fqui imprime les nombres sur STDOUT, dans l'ordre croissant.

Cette fois, j'ai pensé que je prendrais une feuille du livre de @ feersum avec .translate:)

Étendu:

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

Solution précédente:

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)

Merci à @xnor de m'avoir montré l' .replaceastuce il y a quelque temps.

C #, 343 309 caractères

Beaucoup trop longtemps, mais de toute façon:

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

Comment ça marche? Pour ajouter une période au nombre, il doit correspondre aux exigences suivantes:

• Consiste seulement 0, 8, 6et9 .
• Ne se termine pas par un zéro.
• N'est pas le même nombre lorsque vous le faites pivoter:
  • Si un nombre a un nombre égal de 6s et9 s, et
  • if c= le nombre avec tous les 6s remplace par9 s,
  • et inversé c==c ,
  • ensuite: le nombre pivoté est le même que le nombre lui-même.

Les nombres sont séparés par un espace.

Code avec indentation:

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

La plupart des commandes et fonctions intégrées dans M ont des versions abrégées. J'ai utilisé les noms complets ci-dessous.

READ n - Lire une chaîne du clavier et la stocker dans n .

FOR i=0:1:n- Boucle de zéro à n, incrémentant ide 1 à chaque fois. (Le reste de la ligne constitue le corps de la boucle.)

WRITE !,i- Imprime une nouvelle ligne suivie de la valeur de i.

SET r=$TRANSLATE($REVERSE(i),69,96))- Inversez i, remplacez les neuf par des six et les six par des neuf et stockez-le dans r.

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

• :- Indique une expression postconditionnelle, donc la WRITEcommande n'est exécutée que si elle est r=+r*r'=i*'$TRANSLATE(i,0689)évaluée à une valeur véridique.
• r=+r- Vérifiez qu'il rn'y a pas de zéro non significatif. L' +opérateur unaire convertit une chaîne en nombre, ce qui supprime les zéros en tête s'il y en a.
• *- Opérateur de multiplication. M n'a aucun ordre de fonctionnement; tous les opérateurs binaires sont évalués dans l'ordre dans lequel ils apparaissent de gauche à droite.
• r'=i- Vérifiez que ce in'est pas la même chose que sa version retournée r.
• '$TRANSLATE(i,0689)- Supprimez tous les zéros, six, huit et neuf iet vérifiez qu'il ne reste plus rien. ( 'est l'opérateur de négation logique.)
• "."- Enfin l'argument de la WRITEcommande (une chaîne littérale).

Edit: rendu un peu plus court en abusant de l'opérateur de multiplication. La version précédente:

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 caractères

∊{⍵,'. '↓⍨∨/(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 # ne doit pas être aussi long ...
plus ou moins, un port de ma réponse 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);}}}

Non golfé

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

Rubis, 81

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

L'entrée provient de la ligne de commande.

Génère une liste de Strings de 0à n. Il les boucle et les imprime. Il ajoute un point si toutes les conditions sont remplies:

• inverser le nombre et remplacer le 6s par 9s ne donne pas l'original
• le nombre ne comprend que des chiffres 0, 6,8 et9
• le nombre ne se termine pas par 0

JavaScript (ES6) 101 104 106 109

Une fonction avec n comme argument, sortie via console.log
Edit en utilisant% 10 pour tester la réorganisation de
Edit 0 for, je n'ai pas besoin de la compréhension du tableau après tout,
Edit 3 a modifié (à nouveau) la vérification de l'interlignage 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
}

Non golfé et plus facile à tester

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)

Sortie

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

Tester:

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

sed, 467

Plus long que C # ...

J'ai à peu près terminé cela lorsque @ edc65 a souligné que les réponses doivent traiter les nombres 0-n et pas seulement n. L'ajout du code sed à l'incrémentation 0-n ajoute BEAUCOUP plus de code, car cette tâche n'est pas adaptée aux sed sans arithmétique.

: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

Selon l'OP, la commande n'a pas d'importance, nous travaillons donc vers le bas de n à 0.

Sortie:

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

Lisez la valeur n de stdin.

Tester:

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

Non golfé + quelques annotations:

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

avant JC, 158

Après avoir fait cela purement en sed en utilisant toutes les opérations de chaîne et d'expression régulière sans arithmétique native, j'étais curieux de voir à quoi cela ressemblerait, à savoir toutes les opérations arithmétiques et logiques et sans chaîne / expression régulière:

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

La sortie est triée par ordre décroissant.

Sortie:

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

Ou version lisible:

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

Je ne suis pas très content du regex, des idées?

Edit : Astuce soignée apprise avec ~et for (... of ...)depuis @ edc65
Edit2 : Conditions réorganisées
Edit3 : suggestions appliquées par @ edc65

05AB1E , 38 37 30 29 octets

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

Essayez-le en ligne.

Explication:

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

Explication supplémentaire pour certaines parties:

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 octets

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

Script de test expliqué:

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

Sortie:

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 octets

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

Exécuter et déboguer

Déballé, non golfé et commenté, il ressemble à ceci.

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

Exécutez celui-ci