14

एन दरवाजे और के बंदर हैं। प्रारंभ में, सभी दरवाजे बंद हैं।

राउंड 1: 1 बंदर हर दरवाजे पर जाता है और दरवाजे को टॉगल करता है (यदि दरवाजा बंद है, तो इसे खोला जाता है; यदि यह खुला है, तो यह बंद हो जाता है)।

दौर 2 : 1 बंदर हर दरवाजे पर जाता है और दरवाजे पर टॉगल करता है। तब दूसरा बंदर हर 2 वें दरवाजे पर जाता है और दरवाजे पर टॉगल करता है।

। । ।

राउंड k: 1 बंदर हर दरवाजे पर जाता है और दरवाजे पर टॉगल करता है। । । । । । । । । । Kth बंदर हर kth के दरवाजे पर जाता है और दरवाजे पर टॉगल करता है।

इनपुट: एनके (एक ही स्थान से अलग)

आउटपुट: डोर नंबर जो खुले हैं, प्रत्येक को एक ही स्थान से अलग किया गया है।

उदाहरण :

इनपुट: ३ ३

आउटपुट: १ २

अड़चनें :

0 <एन <101

0 <= के <= एन

नोट :

मान लें कि दरवाजे 1 से N तक और K बंदरों की संख्या 1 से K तक है
सबसे छोटा कोड जीतता है। इसके अलावा, एन = 23, के = 21 के लिए प्रदर्शन आउटपुट

code-golf number-theory

— कोडिंग आदमी
स्रोत

इस पहेली से प्रेरित ?

— गणित चिलर

मेरा बस एक सवाल है, अगर N = K, हर प्राइम नंबर का दरवाजा खुला है, है ना?

— फेनबाउट

@Fabinout कोई उर गलत n=k=3उत्पादन होगा 1 2... और 5 आउटपुट 1 2 4वहाँ एक पैटर्न है, लेकिन इसके बहुत कम स्पष्ट तो है कि।

— मैथ चिलर

@ फ़ैनबाउट यह एक बहुत ही अजीब प्रकार के फाइबोनैचि संख्या सेट का अनुसरण करता है, यह बहुत ही उन्नत अमूर्त गणित है।

— मैथ चिलर

@tryingToGetProgrammingStandard आप सही हैं, मेरी यादों ने मुझे जवाब दिया कि यह प्राइम नंबरों की सूची थी, जब यह वर्ग संख्याओं की सूची थी।

— फेनबाउट

14

एपीएल, 32 28 26

{(2|+/(⍳⍺)∘.{+/0=⍺|⍨⍳⍵}⍳⍵)/⍳⍺}/⎕

⎕:
      23 21
 1 2 4 8 9 16 18 23

explaination

{+/0=⍺|⍨⍳⍵}एक ऐसा फ़ंक्शन है जो कई बार दरवाजे की संख्या ⍺(बाएं तर्क) को गोल ⍵(दाएं तर्क) पर टॉगल करता है , जो उस के कारकों की संख्या के बराबर ⍺है ⍵:
- ⍳⍵ 1 से 1 तक संख्यात्मक सरणी उत्पन्न करें ⍵
- ⍺|⍨⍺प्रत्येक सरणी के मापांक की गणना करें
- 0= 1 के लिए बदलें जहाँ एक 0 था, और 0 हर चीज़ के लिए
- +/ परिणामी सारणी
बाहरी कार्य:
- (⍳⍺), ⍳⍵1 से N और 1 से K तक उत्पन्न करें
- ∘.{...}दो सरणियों के तत्वों की प्रत्येक जोड़ी के लिए, फ़ंक्शन लागू करें। यह बार-बार गिने जाने की संख्या का एक मैट्रिक्स देता है, प्रत्येक पंक्ति एक दरवाजे का प्रतिनिधित्व करती है और प्रत्येक स्तंभ एक गोल का प्रतिनिधित्व करता है।
- +/कॉलम को योग करें। इससे प्रत्येक चौखट के ऊपर प्रत्येक दरवाजे को टॉगल किया जाता है।
- 2|मापांक 2, इसलिए यदि एक दरवाजा खुला है, तो यह 1 है; यदि यह बंद है, तो यह 0 है।
- (...)/⍳⍺ अंत में, 1 से एन तक एक सरणी उत्पन्न करें और केवल उन लोगों का चयन करें जहां पिछले चरण पर सरणी में 1 है।
/⎕ अंत में, इनपुट से संख्याओं के बीच फ़ंक्शन डालें।

संपादित करें

{(2|+⌿0=(,↑⍳¨⍳⍵)∘.|⍳⍺)/⍳⍺}/⎕

,↑⍳¨⍳⍵सभी "बंदर" उत्पन्न करें (यदि K = 4, तो यह है 1 0 0 0 1 2 0 0 1 2 3 0 1 2 3 4)
- ⍳⍵1 से ⍵(K) तक की सरणी
- ⍳¨ उनमें से प्रत्येक के लिए, उस नंबर पर 1 से सरणी उत्पन्न करें
- ,↑नेस्टेड एरे को एक मैट्रिक्स में बदलें ( ↑) और फिर एक साधारण ऐरे ( ,) में अनरेल करें
(,↑⍳¨⍳⍵)∘.|⍳⍺1 से ⍺(एन) तक की प्रत्येक संख्या के लिए , इसे प्रत्येक बंदर के साथ मॉड करें।
0=1 के लिए बदलें जहाँ एक 0 था, और 0 हर चीज़ के लिए। यह टॉगल का एक मैट्रिक्स देता है: पंक्तियाँ प्रत्येक दौर पर प्रत्येक बंदर हैं, स्तंभ दरवाजे हैं; 1 का अर्थ है टॉगल, 0 का अर्थ है टॉगल नहीं।
+⌿ पंक्तियों को जोड़ो ताकि प्रत्येक दरवाजे की संख्या के बराबर हो

अन्य भागों को बदला नहीं गया है

संपादित करें

{(≠⌿0=(,↑⍳¨⍳⍵)∘.|⍳⍺)/⍳⍺}/⎕

≠⌿राशि और मॉड 2 ( 2|+⌿) के बजाय XOR कम ( ) का उपयोग करें

— TwiNight
स्रोत

क्या एपीएल को गोल्फ स्क्रिप्ट के लिए डिज़ाइन किया गया था? ;-)

— celtschk

@celtschk हाँ, आंशिक रूप से, एक तरह से। यह एल्गोरिदम को स्पष्ट रूप से व्यक्त करने के लिए डिज़ाइन किया गया था।

— लूसर डॉग

आप डीएफएन के {}/लिए तर्क के रूप में सिर्फ एन और के लेने के बजाय डीएफएन कटौती का उपयोग क्यों करते हैं ?

— 13:27 पर Adám

@ Adám क्योंकि 1) यह मेरा अतीत है; 2) यह प्रश्न "प्रोग्राम या फ़ंक्शन" और I / O मानकीकरण से पहले का है; 3) ओपी ने विशेष रूप से कहा "एक ही स्थान से अलग"

— ट्विनट

काफी उचित है, लेकिन कम से कम आप के साथ एक बाइट बचा सकते हैंi←⍳⍺

— Adám

4

GolfScript, 33 अक्षर

~:k;),1>{0\{1$)%!k@-&^}+k,/}," "*

यदि दरवाजों को शून्य से शुरू किया गया था तो इससे 3 अक्षर बचेंगे।

उदाहरण ( ऑनलाइन ):

> 3 3
1 2

> 23 21
1 2 4 8 9 16 18 23

— हावर्ड
स्रोत

3

गणितज्ञ, १०४ वर्ण

{n,k}=FromDigits/@StringSplit@InputString[];Select[Range@n,OddQ@DivisorSum[#,If[#>k,0,k+1-#]&]&]~Row~" "

उदाहरण:

[1] में: = {n, k} = FromDigits / @ StringSplit @ InputString []; चयन करें [श्रेणी @ n, OddQ @ DivisorSum [#, अगर [#> k, 0, k1 # - #] &] ] ~ रो ~ ""

? २३ २१

आउट [1] = 1 2 4 8 9 16 18 23

— alephalpha
स्रोत

1

आप इनपुट स्ट्रीम मानकर इनपुट पार्स करने से एक और 15 अक्षर खटखटा सकते हैं, जैसे {n,k}=%~Read~{Number,Number}:।

— थॉमस ऑक्ट

3

रूबी, 88

@ मैनटवर्क के जवाब के आधार पर।

gets;~/ /
$><<(1..$`.to_i).select{|d|(1..k=$'.to_i).count{|m|d%m<1&&(k-m+1)%2>0}%2>0}*$&

उन डॉगी ग्लोबल्स हमेशा सिंटैक्स हाइलाइटिंग को तोड़ते हैं!

— पॉल प्रेस्टिज
स्रोत

क्षमा करें, लेकिन 90 वर्ण ( 2 संशोधन ) और 86 वर्ण ( संशोधन 3 ) छोटी गाड़ी प्रतीत होते हैं: एक नया नंबर, 22, उनके परिणामों में दिखाई दिया।

— मैनटवर्क

@manatwork अच्छा कॉल, मुझे लगता है कि मैंने इसे दो पात्रों की कीमत पर तय किया है। मुझे लगता है कि उस countबिट में और सुधार किया जा सकता है, काश रूबी के पास इस #sumतरह की चीजों के लिए एक विधि होती:>

— पॉल प्रेस्टिज

वाह! वास्तव में प्रभावित हुआ।

— मैनटवर्क

3

पायथन 3, 97 84

यदि कोई बंदर एक समान संख्या में गोल दिखाई देता है, तो यह बिल्कुल भी परिवर्तन नहीं है। यदि एक बंदर एक समान संख्या में दिखाई देता है, तो यह ठीक एक दौर में जैसा है।

इस प्रकार कुछ बंदरों को छोड़ा जा सकता है, और दूसरों को बस एक बार दरवाजे बंद करने होंगे।

N,K=map(int,input().split())
r=set()
while K>0:r^=set(range(K,N+1,K));K-=2
print(*r)

इसके लिए आउटपुट 23 21:

1 2 4 8 9 16 18 23

— मोनिका को बहाल करो
स्रोत

सेट ऑपरेशन का चतुर उपयोग! मुझे लगता है कि आप छोटा कर सकते हैं range(2-K%2,K+1,2)करने के लिए range(K,0,-2)।

— xnor

या बेहतर अभी तक, forलूप को एक whileलूप से बदलें :while K>0:r^=set(range(K,N+1,K));K-=2

— xnor

@ xnor: धन्यवाद, यह बहुत अच्छा है!

— मोनिका

2

आर - 74

x=scan(n=2);cat(which(colSums((!sapply(1:x[1],`%%`,1:x[2]))*x[2]:1)%%2>0))

सिमुलेशन:

> x=scan(n=2);cat(which(colSums((!sapply(1:x[1],`%%`,1:x[2]))*x[2]:1)%%2>0))
1: 23 21
Read 2 items
1 2 4 8 9 16 18 23

— flodel
स्रोत

2

जावास्क्रिप्ट 148 127

function e(n,k){b=array(n);d=[];function a(c){for(i=0;i<n;i+=c)b[i]=!b[i];c<k&&a(c+1)}a(1);for(i in b)b[i]&&d.push(i);return d}

यहाँ एक (छोटा सा) पठनीय संस्करण है:

function e(n, k) {     //define N and K
     b = array(n); //declare all doors as closed
     d = [];     //create array later used to print results

     function a(c) {   //(recursive) function that does all the work
         for (i = 0; i < n; i += c)  //increment by c until you reach N and...
              b[i] = !b[i];  //toggle said doors
         c < k && a(c + 1)  //until you reach k, repeat with a new C (next monkey)
     }
     a(1); //start up A

     for (i in b) b[i] && d.push(i); //convert doors to a list of numbers
     return d //NO, i refuse to explain this....
}   //closes function to avoid annoying errors

डेमो

मुझे ध्यान देना चाहिए कि इसकी गिनती 0 से शुरू होती है (तकनीकी रूप से एक-एक त्रुटि)

— मैथ चिलर
स्रोत

यदि आप दूसरी पंक्ति को बदल देते हैं तो आप अपनी तीसरी पंक्ति को हटा सकते हैं। b=Array(n);यह आपके सरणी को अपरिभाषित से भरी हुई लंबाई के रूप में आरंभ करता है। अपरिभाषित सच है, इसलिए पहले बंदर पास यह सब trues में बदल जाएगा।

— path411

@ path411 बहुत बहुत धन्यवाद! मुझे आश्चर्य है कि मैं भूल गया कि "उचित" सरणी घोषणा कैसे काम करती है! आप मुफ्त में महसूस कर सकते हैं+1

— मैथ चिलर

दिलचस्प। ऐसा लगता है कि आपका केवल वही है जिसे मैंने अब तक देखा है जो एन = 23, के = 21 के लिए मेरा समान जवाब पाने के लिए प्रतीत होता है। एकमात्र अंतर यह है कि एक-से-एक मुद्दा जिसमें 0 शामिल हैं और 23 शामिल नहीं हैं।

— इज़्ज़ी

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

— 5

2

जावास्क्रिप्ट, 153

(function(g){o=[],f=g[0];for(;i<g[1];i++)for(n=0;n<=i;n++)for(_=n;_<f;_+=n+1)o[_]=!o[_];for(;f--;)o[f]&&(l=f+1+s+l);alert(l)})(prompt().split(i=l=s=' '))

N = 23, K = 21 के लिए आउटपुट:

1 2 4 8 9 16 18 23

क्रोम में परीक्षण किया गया है, लेकिन किसी भी ब्राउज़र में काम करना चाहिए ताकि कोई फैंसी नई ईसीएमएस्क्रिप्ट सुविधाओं का उपयोग न करें!

मुझे पता है कि मैं अन्य प्रविष्टियों के खिलाफ कभी नहीं जीत पाऊंगा और उस @tryingToGetProgrammingStrainght ने पहले ही जावास्क्रिप्ट में एक प्रविष्टि सबमिट कर दी थी, लेकिन मुझे N = 23, K = 21 के लिए समान परिणाम नहीं मिल रहे थे, क्योंकि बाकी सभी उस के साथ मिल रहे थे, इसलिए मैंने सोचा था कि मैं मेरे अपने संस्करण में एक जाना है।

संपादित करें : एनोटेट स्रोत (इस पर फिर से देखने में, मैंने अन्य 3 वर्णों को सहेजने के लिए स्थानों को देखा, इसलिए इसे शायद अभी भी बेहतर बनाया जा सकता है ...)

(function(g) {
    // initialise variables, set f to N
    o = [], f = g[0];

    // round counter
    // since ++' ' == 1 we can use the same variable set in args
    for (; i < g[1]; i++)
        // monkey counter, needs to be reset each round
        for (n = 0 ; n <= i; n++)
            // iterate to N and flip each Kth door
            for (_ = n; _ < f; _ += n + 1)
                // flip the bits (as undef is falsy, we don't need to initialise)
                // o[_] = !~~o[_]|0; // flips undef to 1
                o[_] = !o[_]; // but booleans are fine
    // decrement f to 0, so we don't need an additional counter
    for (;f--;)
        // build string in reverse order
        o[f] && (l = f + 1 + s + l); // l = (f + 1) + ' ' + l
    alert(l)
    // return l // use with test
// get input from user and store ' ' in variable for use later
})(prompt().split(i = l = s = ' '))
// })('23 21'.split(i = l = s = ' ')) // lazy...

// == '1 2 4 8 9 16 18 23  '; // test

— डोम हेस्टिंग्स
स्रोत

अच्छा कार्य! यदि आप एक पठनीय और टिप्पणी वाला संस्करण भी प्रदान करेंगे तो मैं शायद+1

— मैथ चिलर

उत्तर अपडेट किया गया! चूँकि मैं आपके उत्तर पर टिप्पणी नहीं कर सकता, @ path411 की टिप्पणी में जोड़ने के लिए, आप b = [] सेट कर सकते हैं और खाली इंडेक्स अभी भी अपरिभाषित हैं और यह आपको अन्य 6 वर्णों को बचाता है!

— डोम हेस्टिंग्स

मैंने ऐसा पहले ही कर लिया था ....

— मैथ चिलर

1

रूबी - 65 अक्षर

(1..n).each{|d|
t=0
(1..k).each{|m|t+=n-m+1 if d%m==0}
p d if t%2>0}

n = 23, k = 21 # => 1 2 4 8 9 16 18 23

यहाँ छद्म कोड में गणना है:

बता दें कि s (d) k राउंड के बाद दरवाजे की संख्या को छुआ जाता है।
s (d) = sum (m = 1..m = k) (d% m == 0? (n-m + 1):)
दरवाजा d, k राउंड के बाद खुला है यदि s (d)% 2 = 1 (या> 0)

यदि आप आश्वस्त नहीं हैं कि s (d) के लिए अभिव्यक्ति सही है, तो इसे इस तरह देखें:

बता दें कि एस (डी, आर) आर राउंड के बाद कई बार दरवाजे की संख्या को स्पर्श किया जाता है।
s (d, k) - s (d, k-1) = sum (m = 1, .., m = k) (d% m == 0? 1: 0)
s (d, k-1) - s (d, k-2) = sum (m = 1, .., m = (k-1)) (d% m == 0? 1: 0)
...
s (d, 2) - s (d, 1) = d% 2 == 0? 1: 0
s (d, 1) = 1
s (d) के लिए उपरोक्त अभिव्यक्ति प्राप्त करने के लिए दोनों पक्षों को योग, जो s (d, k) के बराबर है

— कैरी स्वेवेलैंड
स्रोत

बहुत संक्षिप्त! हालांकि, कहां से nऔर कहां kसे आते हैं? और आउटपुट रिक्त स्थान के बजाय नए सिरे से अलग होने लगता है।

— पॉल प्रेस्टिज

1

पॉवरशेल: 132

गोल्फ कोड:

$n,$k=(read-host)-split' ';0|sv($d=1..$n);1..$k|%{1..$_|%{$m=$_;$d|?{!($_%$m)}|%{sv $_ (!(gv $_ -Va))}}};($d|?{(gv $_ -Va)})-join' '

अन-गोल्फ, टिप्पणी कोड:

# Get number of doors and monkeys from user as space-delimited string.
# Store number of doors as $n, number of monkeys as $k.
$n,$k=(read-host)-split' ';

# Store a list of doors in $d.
# Create each door as a variable set to zero.
0|sv($d=1..$n);

# Begin a loop for each round.
1..$k|%{

    # Begin a loop for each monkey in the current round.
    1..$_|%{

        # Store the current monkey's ID in $m.
        $m=$_;

        # Select only the doors which are evenly divisible by $m.
        # Pass the doors to a loop.
        $d|?{!($_%$m)}|%{

            # Toggle the selected doors.
            sv $_ (!(gv $_ -Va))
        }
    }
};

# Select the currently open doors.
# Output them as a space-delimited string.
($d|?{(gv $_ -Va)})-join' '

# Variables cleanup - don't include in golfed code.
$d|%{rv $_};rv n;rv d;rv k;rv m;

# NOTE TO SELF - Output for N=23 K=21 should be:
# 1 2 4 8 9 16 18 23

— Iszi
स्रोत

ओह, मैं देख रहा हूं कि मेरी समस्या क्या है। मैं सवाल गलत समझा - यह नहीं 100 लाकर्स समस्या। यह है कि, एक पायदान ऊपर ले लिया! इसके लिए थोड़ी और

— मेहनत करनी पड़ेगी

1

मिठाई! चुनौती आवश्यकताओं को ठीक से पूरा करने के लिए इसे ठीक करने से अंत में केवल 6 पात्रों का लाभ हुआ।

— Iszi

0

पॉवरशेल, 66 बाइट्स

कैरी स्वेवेलैंड के जवाब पर आधारित ।

param($n,$k)1..$n|?{$d=$_
(1..$k|?{($n-$_+1)*!($d%$_)%2}).Count%2}

टेस्ट स्क्रिप्ट:

$f = {

param($n,$k)1..$n|?{$d=$_
(1..$k|?{($n-$_+1)*!($d%$_)%2}).Count%2}

}

@(
    ,(3, 3   , 1,2)
    ,(23, 21 , 1, 2, 4, 8, 9, 16, 18, 23)
) | % {
    $n,$k,$expected = $_
    $result = &$f $n $k
    "$("$result"-eq"$expected"): $result"
}

आउटपुट:

True: 1 2
True: 1 2 4 8 9 16 18 23

— Mazzy
स्रोत

एन डोर, के बंदर

एपीएल, 32 28 26

संपादित करें

संपादित करें

GolfScript, 33 अक्षर

गणितज्ञ, १०४ वर्ण

रूबी, 88

पायथन 3, 97 84

आर - 74

जावास्क्रिप्ट 148 127

जावास्क्रिप्ट, 153

पॉवरशेल: 132

पॉवरशेल, 66 बाइट्स