sfondo

Stai lavorando per alcuni produttori di giochi da tavolo e devi produrre tessere di legno con i numeri da 0 a n incisi su di esse per alcuni giochi. Tuttavia, senza ulteriori indugi, alcune tessere diventerebbero indistinguibili, ad esempio, 6e 9. Per evitare ciò, devi dotare i numeri che possono essere confusi con altri (e solo quelli) con un punto non ambiguo, ad esempio, avresti tessere come 9.o 6089..

Sfortunatamente, devi usare un vecchio dispositivo di incisione del legno programmabile, per questo, la cui interfaccia è così rotta che devi codificare manualmente ogni carattere del programma in un processo indicibilmente noioso. Fortunatamente il dispositivo comprende ogni linguaggio di programmazione esistente. Quindi stai cercando il programma più breve per stampare tali tessere.

Compito effettivo

Scrivi il programma più breve che:

• Accetta un numero intero positivo n come input. Come viene letto l'input dipende da te.
• Stampa ciascuno dei numeri da 0 a n ( inclusi 0 e n ) esattamente una volta in un ordine a tua scelta, separati da un singolo carattere di spazi bianchi (inclusa la nuova riga). I numeri devono essere stampati senza zeri iniziali.
• Aggiunge un punto (.) A ogni numero che si trasforma in un altro numero valido alla rotazione di π (180 °), anche se quel numero è maggiore di n. 0 e 8 del tuo carattere tipografico sono simmetrici di rotazione e 9 è un 6. ruotato. 2 e 5 sono distinti al momento della rotazione; l'1 non è simmetrico alla rotazione. I numeri con zeri iniziali non sono validi.

Esempi

Ognuno dei seguenti numeri deve essere stampato esattamente in questo modo:

• 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

Devo ringraziare @ Sp3000 per avermi aiutato a rimuovere 4 byte. Inizialmente avevo un controllo aggiuntivo &@JKche mi assicurava che ci fossero 6 o 9 nel numero, ma dopo aver esaminato le risposte prima di postare, ho letto la sua risposta e ho notato che la mia identica traduzione e inversione si erano già occupate di questo.

Anche grazie a @isaacg per aver sottolineato che le stringhe sono iterabili e puoi usare le operazioni set su di esse. Anche per rendere il codice corrente;)

Spiegazione:

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

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

Penso che ci sia un certo margine di miglioramento.

Provalo qui.

Spiegazione

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 byte

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

Penso che possa essere giocato a golf un po 'di più.

Prende nda STDIN.

Provalo online qui

66 APL

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

Spiegazione:

¨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 

Provalo su tryapl.org

Si noti che nell'interprete online la funzione ⍎ non funziona, quindi ho dovuto sostituirlo con 2⊃⎕VFI che in questo caso fa lo stesso, esegue e restituisce il numero, dato una stringa.

Perl 5, 53 byte

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

Demo online.

Utilizza la sayfunzione Perl 5.10+ , quindi deve essere eseguito con perl -M5.010(o perl -E) per abilitarlo. (Vedi questo meta thread. ) Legge input da stdin, stampa su stdout.

Python 2, 130 116 113 byte

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

Definisce una funzione fche stampa i numeri su STDOUT, in ordine crescente.

Questa volta ho pensato di prendere una foglia dal libro di @ feersum con .translate:)

Allargato:

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

Soluzione precedente:

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)

Grazie a @xnor per avermi mostrato il .replacetrucco qualche tempo fa.

C #, 343 309 caratteri

Way troppo a lungo, ma in ogni caso:

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

Come funziona? Per aggiungere un punto al numero, deve corrispondere ai seguenti requisiti:

• Consiste solo di 0, 8, 6e 9.
• Non termina con uno zero.
• Non è lo stesso numero quando lo si ruota:
  • Se un numero ha una quantità uguale di 6s e 9s, e
  • if c= il numero con tutte le 6s sostituisce con 9s,
  • e invertito c== c,
  • quindi: il numero ruotato è uguale al numero stesso.

I numeri sono separati da uno spazio.

Codice con rientro:

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 maggior parte dei comandi e delle funzioni incorporate in M ​​hanno versioni abbreviate. Ho usato i nomi completi qui sotto.

READ n- Leggi una stringa dalla tastiera e memorizzala n.

FOR i=0:1:n- Ciclo da zero a n, incrementando idi 1 ogni volta. (Il resto della linea costituisce il corpo del loop.)

WRITE !,i- Stampa una nuova riga seguita dal valore di i.

SET r=$TRANSLATE($REVERSE(i),69,96))- Invertire i, sostituire nove con sei e sei con nove e riporlo r.

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

• :- Indica un'espressione postcondizionale, quindi il WRITEcomando viene eseguito solo se si r=+r*r'=i*'$TRANSLATE(i,0689)valuta un valore di verità.
• r=+r- Verifica che rnon abbia uno zero iniziale. L' +operatore unario converte una stringa in un numero, che elimina gli zero iniziali se ce ne sono.
• *- Operatore di moltiplicazione. M non ha un ordine di operazioni; tutti gli operatori binari vengono valutati nell'ordine in cui appaiono da sinistra a destra.
• r'=i- Verifica che inon sia uguale alla versione capovolta r.
• '$TRANSLATE(i,0689)- Rimuovi tutti gli zeri, i sei, gli otto e i nove ie controlla che non sia rimasto nulla. ( 'è l'operatore di negazione logica.)
• "."- Finalmente l'argomento del WRITEcomando (una stringa letterale).

Modifica: reso un po 'più breve abusando dell'operatore di moltiplicazione. Versione precedente:

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 caratteri

∊{⍵,'. '↓⍨∨/(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 # non deve essere così lungo ...
più o meno, una porta della mia risposta 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);}}}

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}

L'input viene preso dalla riga di comando.

Genera un elenco di Strings da 0a n. Li avvolge e li stampa. Aggiunge un punto se tutte le condizioni sono soddisfatte:

• invertire il numero e sostituire la 6s con 9s non produce l'originale
• il numero consiste solo delle cifre 0, 6, 8e9
• il numero non termina con 0

JavaScript (ES6) 101 104 106 109

Una funzione con n come argomento, output tramite console.log
Modifica usando% 10 per testare la riorganizzazione di 0
Modifica 2 for , non ho bisogno di comprensione dell'array dopo tutto
Modifica 3 ha modificato (di nuovo) il controllo per 0 iniziale

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 e più facile da testare

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)

Produzione

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

Test:

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

sed, 467

Più di C # ...

Ho praticamente completato questo quando @ edc65 ha sottolineato che le risposte devono elaborare i numeri 0-n e non solo n. L'aggiunta del codice sed all'incremento 0-n aggiunge MOLTO più codice, poiché questa attività non è adatta alla sed senza aritmetica.

: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

Come per l'OP, l'ordinamento non ha importanza, quindi lavoriamo verso il basso da n a 0.

Produzione:

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

Leggi il valore n da stdin.

Test:

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 + alcune annotazioni:

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

aC, 158

Dopo averlo fatto puramente in sed usando tutte le operazioni di stringa e regex senza aritmetica nativa, ero curioso di vedere come ciò si sarebbe verificato al contrario, vale a dire tutte le operazioni aritmetiche e logiche e nessuna stringa / 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"}

L'output è ordinato in ordine decrescente.

Produzione:

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

O versione leggibile:

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

Non sono molto contento della regex, qualche idea?

Edit : Imparato trucchetto con ~e for (... of ...)da @ edc65
Edit2 : condizioni Riorganizzazione
Edit3 : suggerimenti applicato @ edc65

05AB1E , 38 37 30 29 byte

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

Provalo online.

Spiegazione:

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

Spiegazione aggiuntiva per alcune parti:

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 byte

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

Script di test spiegato:

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

Produzione:

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 byte

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

Esegui ed esegui il debug

Disimballato, non golfato e commentato, sembra così.

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

Esegui questo