एक चेन पर नंबर

Question

कुछ सकारात्मक पूर्णांकों को श्रृंखला विभाजन के नाम पर एक संपत्ति के रूप में दिखाया जा सकता है । किसी संख्या के लिए n द्वारा चेन-विभाज्य  होना, यह तीन आवश्यकताओं को पूरा करना चाहिए:

1. प्रत्येक  अंक उस एन अंकों द्वारा गठित संख्या को विभाजित करता है जो उसका पालन करते हैं।

   उदाहरण के लिए, संख्या 7143 चेन विभाज्य 2 क्योंकि 7 विभाजित 14 और 1 विभाजित 43 यह है के द्वारा होता है नहीं चेन विभाज्य द्वारा क्योंकि 3 से 7 143 विभाजित नहीं होता।

2. विभाज्यता के लिए ध्यान में रखे जाने वाले प्रत्येक परिणाम में अग्रणी शून्य नहीं होना चाहिए।

   उदाहरण के लिए, संख्या 14208 श्रृंखला 2 से विभाज्य नहीं है क्योंकि 08 में एक अग्रणी शून्य है। हालाँकि, यह 3 से चेन-विभाज्य है, क्योंकि 208 में अग्रणी शून्य नहीं है।

3. संख्या के सभी अंक अद्वितीय होने चाहिए।

उदाहरण के लिए, संख्या 14280 2, 3 और 4 द्वारा चेन-विभाज्य है। यदि श्रृंखला विभाजन की मेरी व्याख्या स्पष्ट नहीं है, तो कृपया टिप्पणियों में प्रश्न पूछें।

इनपुट

कार्यक्रम के इनपुट में एक पूर्णांक होता है n, उसके बाद एक स्थान होता है, फिर एक संख्या जिसमें कुछ अंकों को अंडरस्कोर द्वारा प्रतिस्थापित किया जाता है। उदाहरण के लिए, निम्नलिखित एक संभावित इनपुट है:

3 6__2__4508

n 1. से अधिक होगा। संख्या कभी भी पूरी तरह से अंडरस्कोर नहीं होगी। आपको इस बात की गारंटी नहीं है कि पहला अंक अंडरस्कोर नहीं है। पहला अंक कभी भी 0. नहीं होगा। n अंक में अंकों की संख्या के बराबर या उससे अधिक कभी नहीं होगा।

उत्पादन

संख्याओं को आउटपुट करें, पूर्णांक द्वारा प्रतिस्थापित अंकों के साथ जैसे कि परिणामी संख्या n द्वारा चेन-विभाज्य है । यदि श्रृंखला-विभाज्य संख्या को पूरा करने का एक से अधिक तरीका मौजूद है, तो किसी भी आउटपुट के रूप में उपयोग किया जा सकता है। अगर कोई संख्या नहीं है जो इसे पूरा कर सकती है, आउटपुट no answer। उदाहरण के लिए, उदाहरण इनपुट का आउटपुट निम्न हो सकता है:

6132794508

यह कोड गोल्फ है, इसलिए सबसे छोटा कोड जीतता है।

Comments

मेरा मानना ​​है कि यदि nउस संख्या में अंकों की संख्या के बराबर या उससे अधिक है, तो संख्या श्रृंखला विभाज्य है?

— जॉन ड्वोरक

@ जान ड्वोरक n इनपुट में अंकों की संख्या के बराबर या उससे अधिक कभी नहीं होगा। यह हमेशा छोटा होगा। मैं उस को प्रतिबिंबित करने के लिए संपादित करूंगा।

— अनुपम

क्या हमें एक पूर्ण कार्यक्रम लिखना आवश्यक है, या एक फ़ंक्शन पर्याप्त है?

— जॉन ड्वोरक

@ मर्टिन हाँ। चरित्र सीमा पैडिंग।

— absinthe

@ जान ड्वोरक एक पूरा कार्यक्रम।

— अनुपम

Answer 1

बैश + कोरुटिल्स, 197 बाइट्स

for i in $(eval printf '%s\\n' ${2//_/{0..9\}}|grep -vP '(\d).*\1');{
for((f=d=0;d<${#i}-$1;d++));{
((${i:d+1:1}==0||10#${i:d+1:$1}%${i:d:1}))&&f=
}
[ $f ]&&echo $i&&((c++))
}
((c))||echo no answer

आउटपुट:

$ ./chain.sh 3 714_
7140
$ ./chain.sh 2 7141
no answer
$ ./chain.sh 2 14208
no answer
$ ./chain.sh 3 14208
14208
$ ./chain.sh 2 1_208
no answer
$ ./chain.sh 3 1_208
14208
$ ./chain.sh 2 6__2__4508
no answer
$ ./chain.sh 3 6__2__4508
6132794508
$

व्याख्या

• पैरामीटर विस्तार के ${2//_/{0..9\}}साथ सभी अंडरस्कोर बदलता है {0..9}।
• परिणामस्वरूप स्ट्रिंग evalइन सभी ब्रेस अभिव्यक्तियों का विस्तार करने के लिए एड है।
• उन grepसभी संभावनाओं को मात देता है जहां कोई भी दोहराया गया अंक होता है।
• फिर प्रत्येक शेष संख्या की जाँच की जाती है, अंक 1 और 2 के लिए अंक-दर-अंक।

Answer 2

पायथन - 239 267

from itertools import*
T=raw_input()
n=int(T[0])
N=len(T)-2
J=''.join
for i in permutations('0123456789',N):
 if all([S in[I,'_']for S,I in zip(T[2:],i)])*all([i[j]>'0'<i[j+1]and int(J(i[j+1:j+n+1]))%int(i[j])<1for j in range(N-n)]):print J(i);exit()
print'no answer'

धीमा, लेकिन छोटा। बस दिए गए पैटर्न के साथ हर संभव एन-डिजिट क्रमोन्नति की तुलना करें और सभी आवश्यकताओं की जांच करें। मैंने इसे केवल 7 या 8 अंकों के साथ परीक्षण किया है। 9 या 10 के लिए भी काम करना चाहिए, लेकिन इसमें काफी समय लगेगा।

संपादित करें: मैंने लापता डिफ़ॉल्ट आउटपुट "कोई जवाब नहीं" जोड़ा।

Answer 3

गणितज्ञ रूबी, 349 224 229 बाइट्स

n=$*[0].to_i
r='no answer'
(?0..?9).to_a.permutation($*[1].count'_'){|q|s=$*[1]
q.map{|d|s=s.sub'_',d}
c=s.chars
(t=1
c.each_cons(n+1){|c|e=c.shift.to_i
(t=!t
break)if e<1||c[0]==?0||c.join.to_i%e>0}
(r=s)if t)if c==c.uniq}
$><<r

यह बहुत ही भोली कार्यान्वयन है। मैं अंडरस्कोर की संख्या गिनता हूं, और फिर हर संभव संयोजन को बल देने के लिए बस उस लंबाई के सभी अंकों-क्रमपरिवर्तन की सूची बनाता हूं। यह बड़ी संख्या में अंडरस्कोर के लिए बुरी तरह से प्रदर्शन करेगा, लेकिन यह कोड गोल्फ है और सबसे तेज-कोड नहीं है। :)

संपादित करें: इसे Mathematica से लिया गया है। मूल संस्करण के लिए संपादन इतिहास देखें।

संपादित करें: फिक्स्ड प्रमुख अंडरस्कोर मामले।

Comments

Tuples (वर्ण गणना को अनदेखा करते हुए) के बजाय Permutations का उपयोग नहीं किया जाना चाहिए?

— 14

@DavidCarraher क्यों? मुझे वहाँ बहुत सारे संयोजन याद आ रहे हैं, क्या मैं नहीं करूँगा?

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

संख्या में प्रत्येक अंक अद्वितीय होना चाहिए। Tuplesउस अड़चन को थोपता नहीं। Permutationsहोगा, बशर्ते इनपुट सेट में कोई दोहराया अंक न हों। और आप केवल उन अंकों को अनुमति दे सकते हैं जो अभी तक उपयोग नहीं किए गए हैं। (हालांकि, फिर से, यह आपके कोड को लंबा कर सकता है।)

— डेविड सीपी

@DavidCarraher ओह्ह, मैंने विशिष्टता की आवश्यकता की अनदेखी की। मुझे इसे तब आंतरिक लूप में जोड़ना होगा, जिस स्थिति में मैं Tuplesछोटा होने के साथ चिपक सकता हूं ।

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

@DavidCarraher तय

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

Answer 4

जावा, 421

class C{static int n;public static void main(String[]a){n=new Short(a[0]);f(a[1]);System.out.print("no answer");}static void f(String s){if(s.contains("_"))for(int i=0;i<=9;i++)f(s.replaceFirst("_",i+""));else{for(int i=1;i<s.length()-n+1;){String t=s.substring(i,i+n);if(t.charAt(0)<49||new Long(t)%new Long(s.substring(i-1,i++))>0||s.chars().distinct().count()<s.length())return;}System.out.print(s);System.exit(0);}}}

स्पष्टीकरण के साथ कम गोल्फ वाला:

class C {

    static int n;

    public static void main(String[] a) {
        n = new Short(a[0]);
        f(a[1]);
        System.out.print("no answer");
    }

    /**
     * This method is called recursively, each time with
     * another underscore replaced by a digit, for all possible digits.
     * If there is a solution, the method prints it and exits the program.
     * Otherwise, it returns.
     */
    static void f(String s) {
        if (s.contains("_")) {
            for (int i = 0; i <= 9; i++) {
                f(s.replaceFirst("_", i + ""));
            }
        } else {
            for (int i = 1; i < s.length() - n + 1;) {
                String t = s.substring(i, i + n);       // on each substring...
                if (                                    // test for the three rules
                    t.charAt(0) < 49 ||
                    new Long(t) % new Long(s.substring(i - 1, i++)) > 0 ||
                    s.chars().distinct().count() < s.length()
                ) {
                    return;            // a rule was broken
                }
            }
            System.out.print(s);       // if we made it this far, it's a success!
            System.exit(0);
        }
    }
}