सभी संख्याएँ जो एक तार में फिट होती हैं

Question

एक प्रोग्राम या फ़ंक्शन लिखें जो एक सकारात्मक पूर्णांक एन में लेता है। सभी अलग दशमलव संख्याओं की एक सूची आउटपुट करें जो अंकों ( ), दशमलव बिंदुओं ( ) और नकारात्मक संकेतों ( ) का उपयोग करके बिल्कुल एन वर्णों में लिखा जा सकता है ।0123456789.-

उदाहरण के लिए, कुछ संख्या है कि एन = 4 उत्पादन सूची में होगा 1337, 3.14, .999, -789, -2.7, और -.09।

संख्या को सामान्य तरीके से लिखा जाना है, लेकिन जितना संभव हो उतना कम रूप में । इसका मतलब है की:

• दशमलव बिंदु को केवल तभी शामिल किया जाना चाहिए जब संख्या पूर्णांक नहीं हो।

  • उदा। 45.0और 45.इसे सादा लिखा जाना चाहिए45
  • -45.00 के रूप में लिखा जाना चाहिए -45

• दशमलव बिंदु के बाईं ओर कोई अग्रणी शून्य नहीं होना चाहिए।

  • 03और 003के रूप में लिखा जाना चाहिए 3, लेकिन 30और 300के रूप में वे कर रहे हैं ठीक हैं
  • 0.3और 00.3बस के रूप में लिखा जाना चाहिए.3
  • -03 के रूप में लिखा जाना चाहिए -3
  • -0.3 के रूप में लिखा जाना चाहिए -.3

• दशमलव बिंदु के दाईं ओर कोई अनुगामी शून्य नहीं होना चाहिए

  • .50और के .500रूप में लिखा जाना चाहिए.5
  • 900.090 के रूप में लिखा जाना चाहिए 900.09

• दो अंतिम नियमों का अपवाद शून्य है, जिसे हमेशा सादा लिखा0 जाना चाहिए ।

• सकारात्मक संकेत ( +) का उपयोग नहीं किया जाना चाहिए क्योंकि वे अनावश्यक रूप से संख्या को लंबा करते हैं।

यह भी ध्यान दें कि नकारात्मक चिन्ह ( -) को घटाव चिन्ह के रूप में उपयोग नहीं किया जाना चाहिए। यह केवल शून्य से कम संख्याओं के पहले चरित्र के रूप में प्रकट होना चाहिए।

का प्रारूपण

संख्याओं के आउटपुट सूची का क्रम मायने नहीं रखता है। यह आरोही, अवरोही या पूरी तरह मिश्रित हो सकता है। यह केवल मायने रखता है कि एन अक्षरों में लिखे जा सकने वाले सभी अलग-अलग नंबर मौजूद हैं।

जब तक चीजें संगत होती हैं, तब तक रिक्त स्थान, newlines, अल्पविराम, या शायद कुछ और के बीच सूची का उपयोग करके सूची को प्रारूपित किया जा सकता है। अग्रणी और अनुगामी कोष्ठक (या समान) ठीक हैं, लेकिन संख्याओं के आसपास उद्धरण जैसी चीजें नहीं हैं। (यानी आउटपुट में स्ट्रिंग्स और इन्टस / फ्लोट्स को न मिलाएं।)

उदाहरण के लिए, जब N = 1, कुछ मान्य आउटपुट होंगे:

0 1 2 3 4 5 6 7 8 9

[1, 2, 3, 4, 5, 6, 7, 9, 0]

ans = { 5 8 9 1 3 2 0 3 4 7 6 }

लेकिन यह अमान्य होगा:

[0, 1, 2, 3, 4, "5", "6", "7", "8", "9"]

उदाहरण

N = 1 -> 0 1 2 3 4 5 6 7 8 9

N = 2 -> -9 -8 -7 -6 -5 -4 -3 -2 -1 .1 .2 .3 .4 .5 .6 .7 .8 .9 10 11 12 ... 97 98 99

N = 3 -> -99 -98 ... -11 -10 -.9 -.8 ... -.2 -.1 .01 .02 ... .98 .99 1.1 1.2 ... 1.9 2.1 2.2 ... 2.9 3.1 ...... 9.9 100 101 ... 998 999

सूची आरोही क्रम में हैं, पढ़ने की सुविधा के लिए कुछ स्थानों पर ellipsized।

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है। संबंधों के मामले में, उच्च मतदान जवाब जीत जाता है

Comments

-0वैध आउटपुट होना चाहिए ?

— दरवाज़े

@DoorknobAlso note that the negative sign (-) should not be used as a subtraction sign. It should only appear as the first character of numbers less than zero.

— Mego

@ मेगो हाँ। क्या शून्य शून्य शून्य से अलग है?

— दरवाज़े

@Doorknob क्या शून्य से कम शून्य है?

— मीगो

@ डॉर्कनब नं। मेगो ने क्या कहा, और यह भी कि "[शून्य] हमेशा सादे के रूप में लिखा जाना चाहिए 0"।

— केल्विन के शौक

Answer 1

पायथ, 47 45 बाइट्स

इस बात से ध्यान हटाने के लिए कि यह कोई फर्क नहीं पड़ता, FryAmTheEggman को धन्यवाद ।

jf!sm:Td)c".- \..*\. ^-?0. [.-]0*$"d^{`c_T17Q

इसे ऑनलाइन आज़माएं।

रनटाइम भयानक है, मूल रूप से ओ (12 ^एन ), लेकिन मैंने इसे nअपने कंप्यूटर पर = 6 के लिए परीक्षण किया (जिसमें 2 मिनट लगे)। n5 रनिंग ऑनलाइन टाइम हो जाएगा ।

जिस तरह से मैं पात्रों 0123456789.-को उत्पन्न करता हूं उसके कारण आउटपुट वास्तव में अजीब क्रम में है।

कोई तकनीकी रूप {से अंत के करीब निकाल सकता है , लेकिन इसका परिणाम ओ (19 ^एन ) की जटिलता होगी । (यह बहुत सारे डुप्लिकेट का उत्पादन भी करेगा, लेकिन इसकी अनुमति है।)

व्याख्या

                  _T       -10
                 c  17     -10 / 17 = -0.5882352941176471
                `          representation: "-0.5882352941176471"
               {           uniquify: "-0.582394176"
              ^       Q    input'th Cartesian power
 f                         filter on:
         c"…"d               split this string by spaces
    m:Td)                    check if the parts match the current string
  !s                         true if none of the parts matched
j                            join by newlines

कोड का मुख्य भाग है ".- \..*\. ^-?0. [.-]0*$", जिसमें किसी भी आउटपुट से मेल नहीं खाता regexes शामिल है ।

.-         minus must be first character
\..*\.     there may only be one decimal point
^-?0.      no extra leading zeroes
[.-]0*$    number must not end with decimal/minus and 0+ zeroes

Answer 2

पायथ, 57 बाइट्स

j-f:T"^0$|^-?([1-9]\d*)?(\.\d*[1-9])?$"0{.P*Q+jkUT".-"Q\-

इसे ऑनलाइन दुभाषिया पर आज़माएँ ।

बहुत लंबा रास्ता, और भयावह रनटाइम के साथ (एन = 4 के लिए कई सेकंड लगते हैं, एन = 5 के साथ चलने की सिफारिश नहीं की जाती है)।

            .P           Q    all permutations of length (input) of
                 jkUT         ... the string "0123456789"
                +    ".-"     ... plus the chars "." and "-"
              *Q              ... whole thing times the input -- pyth has
                              no repeated_permutation, so this is necessary
           {                  uniquify
  f                           filter by
   :T"..."0                   does it match the really long regex?
 -                        \-  get rid of "-"
j                             join on newline

रेगेक्स स्पष्टीकरण:

^0$|            "0", or...
^
 -?             optional negative sign
 ([1-9]\d*)?    optional part-before-decimal
 (\.\d*[1-9])?  optional part-after-decimal
$

Comments

एक गोल्फ नहीं है, लेकिन मुझे लगता है कि आप *Qअपने क्रमपरिवर्तन की चीज को इससे पहले रख सकते हैं +ताकि यह केवल अंकों को प्रभावित करे, इससे प्रदर्शन में थोड़ा सुधार होना चाहिए। यह regex में कुछ बाइट्स को बचाने में भी मदद कर सकता है?

— FryAmTheEggman

Answer 3

जूलिया, 126 117 बाइट्स

n->filter(i->ismatch(r"^0$|^-?([1-9]\d*)?(\.\d*[1-9])?$",i)&&i!="-",∪(map(join,combinations((".-"join(0:9))^n,n))))

यह एक लैम्ब्डा फ़ंक्शन है जो एक पूर्णांक को स्वीकार करता है और स्ट्रिंग्स की एक सरणी देता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें। यहाँ का दृष्टिकोण Doorknob के Pyth उत्तर के समान है ।

Ungolfed:

function g(n::Int)
    # Get all n-character combinations of .-0123456789
    c = combinations((".-"join(0:9))^n, n)

    # Join each group of n characters into a string and take unique
    u = ∪(map(join, c))

    # Filter to only appropriately formatted strings
    filter(i -> ismatch(r"^0$|^-?([1-9]\d*)?(\.\d*[1-9])?$", i) && i != "-", u)
end

Answer 4

MATL , 60 बाइट्स

45:57iZ^!"@!'^(-?(([1-9]\d*)|([1-9]\d*)?(\.\d*[1-9]))|0)$'XX

इसे ऑनलाइन आज़माएं!

यह फ़िल्टरिंग (एक नियमित अभिव्यक्ति के माध्यम से) के बाद सुपर-ब्रुश बल (कार्टेशियन शक्ति के माध्यम से) का उपयोग करता है। मैं बाद में एक स्पष्टीकरण जोड़ूंगा।

परिणाम कार्यक्रम के अंत में प्रदर्शित किए जाते हैं। इसमें थोड़ा सा समय लग सकता है। यदि आप परिणाम उत्पन्न होते देखना चाहते हैं D, तो अंत में जोड़ें :

45:57iZ^!"@!'^(-?(([1-9]\d*)|([1-9]\d*)?(\.\d*[1-9]))|0)$'XXD