पृष्ठभूमि

आप कुछ बोर्ड-गेम निर्माता के लिए काम कर रहे हैं और कुछ गेम के लिए उन पर 0 से n तक की संख्या के साथ लकड़ी की टाइलें बनाने की आवश्यकता है । हालांकि, आगे की हलचल के बिना, कुछ टाइलें अप्रभेद्य हो जाएंगी, जैसे, 6और 9। इससे बचने के लिए, आपको उन नंबरों से लैस करना होगा जो दूसरों (और केवल उन) के साथ भ्रमित हो सकते हैं, जैसे कि एक निराशाजनक डॉट, उदाहरण के लिए, आपके पास टाइल जैसी 9.या6089. ।

दुर्भाग्य से, आपको इसके लिए कुछ पुराने, अभी तक प्रोग्राम करने योग्य लकड़ी-उत्कीर्णन उपकरण का उपयोग करने की आवश्यकता है, जिसका इंटरफ़ेस इतना टूट गया है कि आपको प्रोग्राम के हर चरित्र को एक अनपेक्षित रूप से कठिन प्रक्रिया में हाथ से बदलना होगा। सौभाग्य से डिवाइस हर मौजूदा प्रोग्रामिंग भाषा को समझता है। इस प्रकार आप सबसे छोटे प्रोग्राम की तलाश कर रहे हैं जो इस तरह के टाइल्स को प्रिंट करता है।

वास्तविक कार्य

सबसे छोटा कार्यक्रम लिखिए कि:

इनपुट के रूप में धनात्मक पूर्णांक n लेता है । इनपुट कैसे पढ़ा जाता है यह आपके ऊपर है।
अपनी पसंद के क्रम में 0 से n (0 और n शामिल) में से प्रत्येक में एक बार प्रिंट करता है , एक ही व्हाट्सएप चरित्र (न्यूलाइन सहित) द्वारा अलग किया गया। संख्या को प्रमुख शून्य के बिना मुद्रित किया जाना है।
प्रत्येक संख्या पर एक डॉट (।) लागू होता है जो valid (180 °) द्वारा रोटेशन पर दूसरे, मान्य संख्या में बदल जाता है, भले ही वह संख्या n से बड़ा हो । आपके टाइपफेस के 0 और 8 रोटेशन-सममित हैं और 9 एक घुमाया हुआ है। रोटेशन पर 2 और 5 अलग हैं; 1 रोटेशन-सममित नहीं है। अग्रणी शून्य वाले नंबर मान्य नहीं हैं।

उदाहरण

निम्नलिखित में से प्रत्येक संख्या को इस तरह से प्रिंट करना होगा:

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

code-golf number

— Wrzlprmft
स्रोत

नहीं करना चाहिए 60हो 60.?

— लाल-एक्स

2

@ रेड-एक्स "प्रमुख शून्य के साथ संख्याएं मान्य नहीं हैं।"

— Sp3000

2

@ तर्कवाद: इसके लिए एक मानक खामियाजा है । (इसके अलावा, यह अर्थपूर्ण नहीं होगा, क्योंकि आपको उस मशीन को उस भाषा को सिखाना होगा।) किसी भी तरह, मैंने एक मौजूदा

— Wrzlprmft

2

@rationalis आम तौर पर क्या होता है कि चुनौती की पोस्टिंग से पहले मौजूद भाषा संस्करण केवल जीतने का कार्यक्रम होने के योग्य हैं। बाद के किए गए संस्करण अभी भी मनोरंजन के लिए पोस्ट कर सकते हैं, लेकिन उन्हें अपने पोस्ट में निर्दिष्ट करना चाहिए कि वे विवाद नहीं कर रहे हैं। तो हाँ आप इस तरह की भाषा को परिभाषित कर सकते हैं, लेकिन यह एक मानक खामियों (जैसा कि ऊपर) होने के कारण अयोग्य और सबसे अच्छी तरह से प्राप्त नहीं होने की संभावना है।

— Sp3000

3

मुझे लगता है कि यह 8088.आपके उदाहरणों में एक रोटेशन-असुरक्षित संख्या के रूप में शामिल करने में मददगार होगा , जिसमें 6 या 9 नहीं है

— एल'एंडिया स्ट्रैटन

6

अजगर - 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"))

— FryAmTheEggman
स्रोत

मुझे नहीं लगता कि आपको पूर्णांक की सूचियों का उपयोग करने की आवश्यकता है - Kऔर Jइसके बजाय केवल तार का उपयोग करें। K<Backtick> 69 और J<backtick> N पर स्विच करने से कुछ अक्षर बचते हैं, जैसा Kकि परिणामी प्रोग्राम में इनलाइनिंग करता है । सबसे कम मैं उस तकनीक के तहत प्राप्त कर सकता था VhQJ``N+J*\.&nJX_J``69``96&eN!-J"0689, 34 अक्षर। (दो backticks वास्तव में एक हैं।)

— isaacg

@isaacg टिप के लिए धन्यवाद! मुझे लगता है कि किसी कारण से मैं यह भूल गया था कि संख्याओं का एक तार `का उपयोग करके वास्तव में अजगर में कम था। वैसे भी, आप backticks के साथ उन्हें भागने से कोड ब्लॉक लिख सकते हैं। उदाहरण के लिए:hell`o wo`rld

— FryAmTheEggman 15

स्पष्टीकरण में, आप एक अतिरिक्त _, से पहले दिखाई देते हैं `96।

— इसहाक

@isaacg धन्यवाद, निश्चित

— FryAmTheEggman

10

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

— मार्टिन एंडर
स्रोत

जब इनपुट 8 है तो यह क्या लौटाता है? (मैंने इनपुट में कोड पेस्ट किया और फिर रन बटन पर क्लिक किया, लेकिन एक त्रुटि कहा गया।)

— डेविड डिक

@DavidCarraher ने "कोड" और nइनपुट में कोड डाला ।

— मार्टिन एंडर

इनपुट 98, आपका प्रोग्राम 66 के बगल में एक बिंदी लगाता है, जो गलत है।

— स्पार्क

3

@ उत्तर का जवाब अमान्य होने से पहले आपको अपने प्रश्न का उत्तर देने के लिए इंतजार करना चाहिए। उनका कथन: "निम्नलिखित संख्याओं में से प्रत्येक को बिल्कुल इस तरह से मुद्रित करना है" आपकी व्याख्या के विपरीत प्रतीत होती है।

— FryAmTheEggman

मुझे सीजेएम स्पष्टीकरण की सुंदरता पसंद है।

— nyuszika7h

8

CJam, 46 45 43 42 बाइट्स

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

मुझे लगता है कि इसे थोड़ा और बढ़ाया जा सकता है।

nSTDIN से लेता है।

इसे यहाँ ऑनलाइन आज़माएँ

— अनुकूलक
स्रोत

5

एपीएल 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 पर आज़माएं

ध्यान दें कि ऑनलाइन दुभाषिया में in फ़ंक्शन काम नहीं करता है इसलिए मुझे इसे 2⊃⎕VFI के साथ स्थानापन्न करना था जो इस मामले में भी ऐसा ही करता है, एक स्ट्रिंग को देखते हुए, संख्या को निष्पादित और वापस करता है।

— मोरिस ज़ुक्का
स्रोत

गलत लगता है: 60, 69, 90 और 96 में डॉट्स नहीं होने चाहिए।

— ngn

धन्यवाद @ngn, मैंने इसे सही किया, मुझे लगता है कि यह अब सही ढंग से काम करता है।

— मोरिस ज़ुक्का

2

अच्छी तरह से किया गया :) ⊃,/या इसके बजाय ,/आप ∊सामने की तरफ इस्तेमाल कर सकते हैं ।

— NGN

अरे हाँ! मैं आमतौर पर ml1 में काम नहीं करता इसलिए मैं ml के बारे में भूल जाता हूं।

— मोरिस ज़ुक्का

4

पर्ल 5, 53 बाइट्स

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

ऑनलाइन डेमो।

पर्ल 5.10+ sayसुविधा का उपयोग करता है , इसलिए इसे सक्षम करने के लिए perl -M5.010(या perl -E) चलाने की आवश्यकता है। ( यह मेटा थ्रेड देखें । ) स्टड से इनपुट पढ़ता है, प्रिंट से स्टडआउट करता है।

— इल्मरी करोनें
स्रोत

4

पायथन 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 को धन्यवाद ।

— Sp3000
स्रोत

आप उपयोग कर सकते हैं (u''+S[::-1])के बजाय unicode(S[::-1])। इसके अलावा, यदि आप अदला-बदली करते हैं printऔर पुनरावर्ती कॉल करते हैं, तो संख्या बढ़ती क्रम में सामने आएगी।

— ngn

@ आह धन्यवाद, मुझे नहीं लगा u""+कि वास्तव में काम करेगा

— Sp3000

देखें कि मुझे लगता है कि यह छोटा होना चाहिए, उदाहरण के लिए यह आपकी गलती नहीं है कि प्रिंट सही प्रिंट है, न कि "पी" कहते हैं, लेकिन अगर आपको "पी = प्रिंट" लिखना था और आपके "आधिकारिक" सबमिशन में बाइट्स के रूप में गिनती नहीं है 'इसे छोटा करो!

— एलेक टील

4

सी #, 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, से मिलकर बनता है ।869
एक शून्य के साथ समाप्त नहीं होता है।
जब आप इसे घुमाएंगे तो वही संख्या नहीं है:
- यदि किसी संख्या में 6s और 9s के बराबर राशि है , और
- यदि c= 6s के साथ सभी s के स्थान पर संख्या 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) ? ". " : " "));
            }
        }
    }
}

— ProgramFOX
स्रोत

1

मेरा जवाब लम्बा है;) मैं गोल्फ कोर्स में गेंदबाजी करता हूँ।

— डिजिटल ट्रॉमा

1

8808 के बारे में क्या? यह कोई 6s या 9s नहीं है, लेकिन घुमाए जाने पर 8088 है।

— एल'एंडिया स्ट्रैटन

1

@ El'endiaStarman बहुत बहुत धन्यवाद! अपने सबमिशन को ठीक करते हुए, मैंने वास्तव में पात्रों को बचाया :)

— ProgramFOX

4

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

एम में निर्मित अधिकांश कमांड और फ़ंक्शन संक्षिप्त संस्करण हैं। मैंने नीचे पूर्ण नामों का उपयोग किया है।

READ n- कीबोर्ड से एक स्ट्रिंग पढ़ें और इसे स्टोर करें n।

FOR i=0:1:n- शून्य से बढ़ाकर n, बढ़ानाi प्रत्येक बार 1 से । (शेष रेखा लूप के शरीर का गठन करती है।)

WRITE !,i- के मूल्य के बाद एक नई लाइन प्रिंट करें i।

SET r=$TRANSLATE($REVERSE(i),69,96))- उल्टा i, नौ के स्थान पर छक्के और छक्के के साथ नौ की जगह, और उस में स्टोर करें r।

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

:- उत्तर-पूर्व अभिव्यक्ति को अस्वीकार करता है, इसलिए WRITEयदि केवल सत्य r=+r*r'=i*'$TRANSLATE(i,0689)मूल्य का मूल्यांकन किया जाता है , तो कमांड को निष्पादित किया जाता है।
r=+r- जांचें कि rएक अग्रणी शून्य नहीं है। एकरी +संचालक एक स्ट्रिंग को एक संख्या में परिवर्तित करता है, जो अगर कोई हो तो अग्रणी शून्य को स्ट्रिप्स करता है।
*- गुणन संचालक। एम के पास संचालन का कोई आदेश नहीं है; सभी बाइनरी ऑपरेटरों का मूल्यांकन उस क्रम में किया जाता है जो वे बाएं से दाएं दिखाई देते हैं।
r'=i- जांचें कि iयह वही नहीं है जैसा कि यह फ़्लिप किया गया संस्करण है r।
'$TRANSLATE(i,0689)- सभी शून्य, छक्के, आठ और nines से निकालें 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 "."

— temporicide
स्रोत

3

एपीएल, 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

— NGN
स्रोत

3

C # 205 209

C # को इतना लंबा नहीं होना है ...
कमोबेश, मेरे जावास्क्रिप्ट उत्तर का एक पोर्ट

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

— edc65
स्रोत

2

रूबी, 81

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

इनपुट कमांड लाइन से लिया गया है।

की एक सूची उत्पन्न Stringसे रों 0को n। यह उन्हें गला देता है और उन्हें प्रिंट करता है। यदि सभी शर्तें पूरी होती हैं, तो यह एक डॉट जोड़ता है:

संख्या को उलट देना और उसकी जगह ले लेना 6 एस के साथ 9एस की मूल उपज नहीं है
संख्या में केवल अंक होते हैं 0,6 , 8और9
संख्या के साथ समाप्त नहीं होता है 0

— britishtea
स्रोत

2

जावास्क्रिप्ट (ईएस 6) 101 104 106 109

तर्क के रूप में n के साथ एक फ़ंक्शन, कंसोल के माध्यम से आउटपुट .log 10% का उपयोग करके
संपादित करें अग्रणी 0 के लिए परीक्षण करने के लिए
2 for पुनर्गठन, मुझे सभी
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
}

Ungolfed और परीक्षण करने में आसान

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

— edc65
स्रोत

क्या कोष्ठक के भीतर लूप के साथ निर्माण के लिए एक नाम है []? मैं एक दस्तावेज की तलाश में हूं, क्योंकि मैं केवल अजगर से यह जानता था।

— 18

1

मुझे लगता है कि आप यहां पर नई कहानियों पर बहुत कुछ बचा सकते हैं।

— ब्रितिश

1

@britishtea नएपन और इंडेंटेशन ने पठनीयता के लिए जोड़ा और न गिना। यह एक ही लाइन है

— edc65

1

@flawr developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/…

— edc65

1

बैश + कोरुटिल्स, 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.
$

— डिजिटल आघात
स्रोत

1

सेड, ४६ 4

C # से अधिक लंबा ...

जब मैंने @ edc65 ने बताया कि उत्तर संख्या 0-n को संसाधित करने की आवश्यकता है, न कि केवल n को पूरा करने पर मैंने इसे बहुत पूरा कर लिया है। 0-n को बढ़ाने के लिए सेड कोड को जोड़ने से बहुत अधिक कोड जुड़ जाता है, क्योंकि यह कार्य अंकगणित-कम सेड के लिए अनुकूल नहीं है।

: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

ओपी के अनुसार, ऑर्डर देने से कोई फर्क नहीं पड़ता है, इसलिए हम नीचे से 0 तक काम करते हैं।

आउटपुट:

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

— डिजिटल आघात
स्रोत

1

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

स्टड से एन मान पढ़ें।

परीक्षा:

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

— LeFauve
स्रोत

1

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

अनगोल्डेड + कुछ एनोटेशन:

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

— draegtun
स्रोत

1

ई.पू., १५ b

शुद्ध रूप से सभी स्ट्रिंग और रेगेक्स संचालनों को बिना किसी मूल अंकगणित के उपयोग करने के बाद यह पूरी तरह से sed में करने के बाद , मैं यह देखने के लिए उत्सुक था कि यह दूसरे तरीके के आसपास कैसे दिखाई देगा, अर्थात सभी अंकगणितीय और तर्क संचालन और कोई स्ट्रिंग / 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"}

आउटपुट को अवरोही क्रम में क्रमबद्ध किया जाता है।

आउटपुट:

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

— डिजिटल आघात
स्रोत

1

अजगर - 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])

— KSFT
स्रोत

+1। अच्छा लग रहा है ... यदि आप इसे छोटा करने के लिए कुछ तरकीबें सीखना चाहते हैं तो अजगर 2 में एक और जवाब है जो बदले की जगह अनुवाद का उपयोग करता है, और संपादित इतिहास में यह उन 3 प्रतिकृति को 1 में संयोजित करने का एक तरीका भी है जो आ सकता है भविष्य के प्रश्नों के लिए आसान ...

— ट्राइकोप्लाक्स

2

अच्छी प्रगति! : उपरोक्त के अतिरिक्त यहां कुछ और golfs है "."if a[i]else"" -> "."*a[i], int(raw_input()) -> input()(जो वास्तव में सिर्फ है eval(raw_input()))

— Sp3000

कुछ golfes: (1) अजगर 2 में, आप बदल सकते हैं str(i)के साथ `i`। (2) आप aकेवल एक बार उपयोग करते हैं, इसलिए इसे एक चर में क्यों निर्दिष्ट करें।

— Wrzlprmft

मैं आपके दूसरे सुझाव का उपयोग करूँगा, लेकिन मैं str(i)कई बार उपयोग करता हूँ । मैं किसके साथ बदल सकता हूं i?

— केएसएफटी

1

नहीं i, बल्कि iबैकटिक्स के साथ, जो इसका पर्याय है repr(i)। आप इसे str(i)हर जगह के बजाय उपयोग कर सकते हैं , हालांकि यदि आपके पास हैstr(i) आस- कई बार यह एक चर को असाइन करने और backticks का उपयोग करने के अलावा इसका उपयोग करने के लिए छोटा हो सकता है। (यानी x=`i`; (do stuff with x))

— Sp3000

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

मैं रेगेक्स, किसी भी विचार से बहुत खुश नहीं हूं?

संपादित करें : @ edc65 से ~और साथ में साफ-सुथरी चाल को Edit2 : पुनर्गठन की स्थिति Edit3 : @ edc65 द्वारा सुझाए गए सुझावfor (... of ...)

— zabalajka
स्रोत

बुरी पुतली :) i=n+"";for(c of i)=> for(c of i=n+"")2 बाइट

— बचाएं

... और c==6?A:B=> c!=6=>B:A=>c-6?B:A

— edc65 20

इसके अलावा, आमतौर पर Regexp.test (स्ट्रिंग) का उपयोग String.match (Regexp) के बजाय, 1 बाइट छोटा किया जा सकता है।

— edc65

6 बाइट्स कुल हैं, धन्यवाद :) for(c of i=n+"")यह देखने में काफी तार्किक है, लेकिन मैं इसके बारे में नहीं सोचूंगा। c-6?B:Aभगवान न करे मैंने इसे उत्पादन कोड

— zabalajka

Regexp के बारे में आइडिया: आपको 1 अमान्य चार के लिए जांचना होगा, 1 अयस्क अधिक नहीं, इसलिए '+' की जरूरत नहीं है। यदि आप अपने कंसोल के साथ फिडेल करते हैं। तो अभिव्यक्ति आप 8 बाइट्स बचा सकते हैं ... लेकिन फिर मुझे लगता है कि आपका जवाब बहुत कम होगा

— edc65

1

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)

— केविन क्रूज़सेन
स्रोत

0

पर्ल - 84

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

— KSFT
स्रोत

0

पॉवर्सशैल, 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.

— Mazzy
स्रोत

0

स्टैक्स , 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)
  ".

इसको चलाओ

— पुनरावर्ती
स्रोत

रोटेशन-सुरक्षित नंबर प्रिंट करें

पृष्ठभूमि

वास्तविक कार्य

उदाहरण

अजगर - 34 38

CJam, 46 44 43 42 बाइट्स

व्याख्या

CJam, 46 45 43 42 बाइट्स

एपीएल 66

पर्ल 5, 53 बाइट्स

पायथन 2, 130 116 113 बाइट्स

सी #, 343 309 अक्षर

एम (MUMPS) - 72 70

एपीएल, 53 वर्ण

C # 205 209

रूबी, 81

जावास्क्रिप्ट (ईएस 6) 101 104 106 109

बैश + कोरुटिल्स, 105

परीक्षा:

सेड, ४६ 4

आउटपुट:

AWK: 120

Rebol - 195

ई.पू., १५ b

आउटपुट:

अजगर - 152

जावास्क्रिप्ट - 168 129 119 113 111 108

05AB1E , 38 37 30 29 बाइट्स

पर्ल - 84

पॉवर्सशैल, 111 102 बाइट्स

स्टैक्स , 27 बाइट्स