22

इस साइट पर एक प्रश्न है जो इस प्रश्न के समान है, लेकिन मैंने एक ट्विस्ट जोड़ा है।

आपके पास तीन इनपुट हैं, सर्कल n में लोगों की संख्या , k -th व्यक्ति प्रत्येक चरण में गिना जाता है, और q -th व्यक्ति जो जीवित रहता है। सर्कल के लोगों की संख्या 1 से n तक है ।

उदाहरण के लिए, 20 लोगों के एक सर्कल में, जीवित रहने वाला 20 वां व्यक्ति बहुत पहले व्यक्ति को हटा दिया जाता है, 19 वां उत्तरजीवी दूसरा व्यक्ति हटा दिया जाता है और इसी तरह। सामान्य रूप से, जोसेफस समस्या को हटाए गए अंतिम व्यक्ति को निर्धारित करना है, यहां पहले उत्तरजीवी कहा जाता है ।

सबसे छोटा प्रोग्राम या फ़ंक्शन लिखें, जो उन तीन इनपुटों के साथ जीवित रहने के लिए q -th व्यक्ति की संख्या लौटाता है ।

अगर स्पष्टता के साथ कोई समस्या है, तो कृपया मुझे बताएं।

कुछ उदाहरण:

>>> josephus(20, 3, 9)
4
>>> josephus(4, 3, 1)
1
>>> josephus(100, 9, 12)
46

संपादित करें: मान लें कि सभी इनपुट मान्य हैं। कि कोई भी 0 या किसी भी नकारात्मक संख्या के लिए नहीं पूछेगा और कोई भी 5 लोगों के सर्कल में 20 वें उत्तरजीवी के लिए नहीं पूछेगा (अर्थात, 1 ≤ q) n)

संपादित करें: मैं 2 दिसंबर की शुरुआत में मध्यरात्रि UTC + 7 पर एक उत्तर स्वीकार करूंगा।

code-golf

— Sherlock9
स्रोत

1

कृपया प्रश्न में उन्हें शामिल करने के बजाय उत्तर के रूप में अपने स्वयं के समाधान पोस्ट करें।

— दरवाज़े

समझ गया। इस बारे में क्षमा करें

— शर्लक

1

स्पष्टीकरण के लिए, यदि q=1यह जोसेफस से जुड़े प्रश्न के समान ही है, है ना?

— AdmBorkBork

@ टिम्मीड बिल्कुल

— शर्लक

5

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

eu.<PGvzh-QvwShQ

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट

इनपुट फॉर्म का है k<newline>n<newline>q।

स्पष्टीकरण:

eu.<PGvzh-QvwShQ   implicit: z = first input line (string)
                             Q = second input line (integer)
              hQ   Q + 1
             S     the range [1, 2, ..., Q+1]
 u      h-Qvw      apply the following statement (Q-input()+1) times to G=^
    PG                remove the last number of G
  .<  vz              and rotate eval(z) to the left
e                  print the last number of the resulting list

— Jakube
स्रोत

7

पीट, 280 273 कोडेल

संपादित करें: मैंने इसे कुछ और नीचे गोल्फ किया है, और मुझे लगता है कि मैं इसे और भी नीचे गोल्फ कर सकता हूं, लेकिन यह अभी भी आने वाला है। अभी के लिए, मुझे खुशी है कि यह काम करता है, और यह कि मेरे पास नीचे बाएं कोने में इस पर हस्ताक्षर करने के लिए कमरा है। दो विचारों के लिए मुझे अधिक कोडेल को सहेजना है a) अंतिम निर्देशों को बदलने के लिए a pop, push 1, add, out num(पॉप n, आउटपुट r + 1) और b) बाद में लूप में स्टैक हेरफेर में कोडेल्स को बचाने के लिए नीचे बाएँ कोने पर फिर से डुप्लिकेट करना है।

ऊपर दी गई तस्वीर 8 पिक्सेल प्रति कोडेल पर मेरा कोड है। सामान्य तौर पर, यह मेरे पायथन उत्तर के समान ही एल्गोरिदम है, लेकिन k , q , n के क्रम में इनपुट के साथ । व्यवहार में, स्टैक हेरफेर का एक बड़ा सौदा भी है। आप यहाँ पर इमेज को खोलकर और इसके साथ कोड चलाकर इसे आजमा सकते हैं ।

व्याख्या

यह समाधान का एक कदम-दर-चरण ungolfing है।

in num    get k
dup       Stack: k k
push 1
subtract  Stack: k k-1
in num    get q
dup       Stack: k k-1 q q
dup       Stack: k k-1 q q q
push 4
push 2
roll      Stack: k q q k-1 q
mod       Stack: k q q r
in num    get n
# note: the loop will return to the following codel
dup       Stack: k q q r n n
push 4
push 3
roll      Stack: k q r n n q
greater   1 or 0
pointer   Here the loop begins. If q>n, the pointer moves clockwise.
          Else, it points straight ahead

LOOP:     Stack: k i r n (i=q at the start of the loop)
push 4
push 2
roll      Stack: r n k i
push 1
add       Stack: r n k i=i+1
push 2
push 1
roll      Stack: r n i k
dup       Stack: r n i k k
push 5
push 4
roll      Stack: n i k k r
add       Stack: n i k m=r+k
push 3
push 2
roll      Stack: n k m i
dup       Stack: n k m i i
push 3
# here it turns the corner
push 1
roll      Stack: n k i m i
mod       Stack: n k i r=m%i
push 4
# here it turns the corner and avoids the black codels
push 1
roll      Stack: r n k i
dup       Stack: r n k i i
push 5
push 3
roll      Stack: k i i r n
dup       Stack: k i i r n n
# and we meet up with the dark green codel once more
push 4
push 3
roll      Stack: k i r n n i
greater   Stack: k i r n (0 or 1)
pointer   if else again

# else    Stack: k i r n
push 2    
push 1
roll      Stack: k i n r
# and turn the corner
push 1
add       Stack: k i n r+1
out num   print r+1
# turn the corner into the end pattern (the shape with the black edges)
END

— Sherlock9
स्रोत

आप खाली स्थान नहीं गिन रहे हैं? क्या पीट स्कोर करने के बारे में कहीं एक मेटा पोस्ट है? शायद होना चाहिए।

— शुक्राणु

@ शेपर, मैं खाली जगह गिन रहा हूं। यह 13 कोडल छवि वाला 21 कोडेल है, इसलिए स्कोर 273 कोडेल है।

— शर्लक

आह, मैं दुखी हो गया। माफ़ कीजिये।

— शुक्राणु

4

CJam, 22 20 19 बाइट्स

q~_,@a@*{m<)\}%\~=)

यह इनपुट को पढ़ता है q k n। CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

यह काम किस प्रकार करता है

q~                   Read and evaluate all input. This pushes q, k, and n.
  _,                 Push A := [0 ... n-1].
    @a               Rotate on top of the stack and wrap it in an array.
      @*             Rotate the original n on top and repeat [k] n times.
        {    }%      For each of the n k's:
         m<            Rotate A k units to the left.
           )\          Pop the last element and swap it with A.
               \~    Swap the resulting array with q and apply bitwise NOT.
                 =)  Select the corresponding element and add 1 to it.

— डेनिस
स्रोत

3

गोल्फस्क्रिप्ट, 58 56 55 35 31 30 बाइट्स

मान लें कि तीन इनपुट पहले से ही स्टैक में हैं, क्रम n , k , q में

~1$(1$%3$),@),-{\2$+\%}%\)])\;

यह समाधान मानता है कि मुझे हर चीज से छुटकारा पाने की जरूरत है लेकिन अंतिम जवाब।

यह काम किस प्रकार करता है

j(n,k,q)अधिक विस्तार के लिए मेरे पायथन 3 समाधान में देखें ।

~                                   Read the inputs n, k, q
 1$(                                Duplicate k, decrement
    1$                              Duplicate q
      %                             (k-1)%q
       3$),                         Create array [0..n+1]
           @),                      Create array [0..q+1]
              -                     Subtract the second array from the first,
                                        leaving only [q+1..n+1]
               {      }%            Map the following statement onto [q+1..n+1].
                                        The numbers from this array will be denoted i.
                \                   Swap i and r
                 2$+                Duplicate k, add to r
                    \               Swap r and i
                     %              r mod i
                        \)          Swap the leftover array from map with r, increment
                          ]         Put the whole stack into an array
                           )        Remove the last member of the array, r
                            \;      Pop the array, leaving only the result

1 संपादित करें: @ Doorknob के सुझाव का उपयोग किया (सरणी में सभी जानकारी प्राप्त करने के लिए एक + जोड़ा गया)

पूर्व में,

\.(2$2$*1$4$%-{.5$3$*>!}{~)2$*1$/~)}while 4$3$*\-)\;\;\;\;

2 संपादित करें:विकी के नियमों के अनुसार जोड़ा गया ~, और कोड को छोटा कर दिया। धन्यवाद @ डेनिस

पूर्व में,

[\.(2$2$*1$4$%-{.5$3$*>!}{~)2$*1$/~)}while 4$3$*\-)]+)\;

संपादित करें 3: एक छोटे एल्गोरिथ्म को लागू किया।

पूर्व में,

~\.(2$2$*1$4$%-{.5$3$*>!}{~)2$*1$/~)}while 4$3$*\-)]-1=

संपादित करें 4: यह पता लगाया कि मैं उपयोग कर सकता हूं% मानचित्र के रूप में ।

पूर्व में,

~1$(1$%{1$4$<}{\)\2$+1$%}while)])\;

संपादित करें 5: मामूली संपादित करें। बदल दिया 2$करने के लिए @बनाने के लिए [0..q-1]और 3$करने के लिए 2$पुनः प्राप्त करने केk । काट लिया

पूर्व में,

~1$(1$%3$),2$),-{\3$+\%}%\)])\;

— Sherlock9
स्रोत

1

\;\;\;\;के साथ प्रतिस्थापित किया जा सकता है ])\;(एरे में लपेटें, राइट-अनकॉन्स, स्वैप, और पॉप)।

— दरवाज़े

मेरे कोड को स्पष्टता के लिए संपादित किया गया @ डेनिस।

— शर्लक

ठीक है @ डेनिस। ~ जोड़ा गया और केवल कार्यक्रमों और कार्यों की अनुमति देने के लिए प्रश्न को संपादित किया। आपके पास कोई और सुझाव है?

— शर्लक

नहीं, सब अच्छा है। :)

— डेनिस

2

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

(n,k,q)=>{r=(k-1)%q;for(i=q;i<n;r=(r+k)%++i);return r+1}

Ungolfed

मूल रूप से @ शर्लक 9 के पायथन उत्तर का एक जावास्क्रिप्ट अनुकूलन है ।

(n,k,q)=>{
  r=(k-1)%q;
  for(i=q;i<n;r=(r+k)%++i);
  return r+1
}

परीक्षा

n = <input type="number" id="N" value="100" /><br />
k = <input type="number" id="K" value="9" /><br />
q = <input type="number" id="Q" value="12" /><br />
<button onclick="result.innerHTML=(

(n,k,q)=>{r=(k-1)%q;for(i=q;i<n;r=(r+k)%++i);return r+1}

)(+N.value,+K.value,+Q.value)">Go</button><br />
<pre id="result"></pre>

स्निपेट का विस्तार करें

— user81655
स्रोत

मैं आपके ungolfed संस्करण को ungolfed नहीं कहूंगा: P

— फंड मोनिका के मुकदमे

1

गणितज्ञ, 50 बाइट्स

<<Combinatorica`
Tr@Position[Josephus@##2,1+#2-#]&

एक अनाम फ़ंक्शन। आदेश में इनपुट लेता हैq,n,k ।

— alephalpha
स्रोत

1

सी, 81 73 बाइट्स

पर आधारित मेरे पायथन उत्तर के @ user81655 के जावास्क्रिप्ट कार्यान्वयन के ।

संपादित करें: मुझे हटाया गया

int j(int n,int k,int q){int r=(k-1)%q;for(;q<n;r=(r+k)%++q);return r+1;}

परीक्षा

#include <stdio.h>
int j(int n,int k,int q){int r=(k-1)%q;for(;q<n;r=(r+k)%++q);return r+1;}
int main()
{
    printf("%d\n", j(20,3,9));
    return 0;
}

— Sherlock9
स्रोत

C के कुछ संस्करणों में, आप intपैरामीटर नाम से पहले छोड़ सकते हैं ।

— निधि मोनिका का मुकदमा

1

पायथन 3, 72 66 62 बाइट्स

62 बाइट्स में एक गतिशील प्रोग्रामिंग फ़ंक्शन। विकिपीडिया पर एल्गोरिथ्म से अनुकूलित । उस पृष्ठ पर q = 1 (यानी i = 1, r = 0) होने पर इस एल्गोरिथ्म का प्रत्यक्ष कार्यान्वयन हुआ करता था, लेकिन मुझे लगता है कि अब इसे हटा दिया गया है।

संपादित 1: मैंने निकालाi 4 बाइट्स बचाने के लिए । स्पष्टीकरण अपरिवर्तित रहता है।

2 संपादित करें: बाइट गिनती में विविधीकरण। मैं \r\nईओएल के लिए उपयोग कर रहा था और जब 3 बाइट्स जोड़े गए तो ध्यान नहीं दिया। मैंने अपने बाइट काउंट को उसी हिसाब से कम किया है।

def j(n,k,q):
 r=(k-1)%q
 while q<n:q+=1;r=(r+k)%q
 return r+1

यह कैसे काम करता है

def j(n,k,q):
 i=q;r=(k-1)%q              We start with the smallest possible circle to have a q-th
                                survivor, a circle of q people.
 while i<n:i+=1;            Iterate from q to n
                r=(r+k)%i   Every time you add people to the circle, r increases by k, 
                                modulo the current size of the circle i.
 return r+1                 Return the result.

मुझे याद दिलाने के लिए @ डेनिस का धन्यवाद कि मुझे अपना कोड समझाना चाहिए (यदि केवल संक्षेप में, क्योंकि उन्होंने अपने उत्तर में एक को शामिल किया है)। अगर कुछ स्पष्ट नहीं है तो कृपया मुझे बताएं।

संपादित करें:

पूर्व में,

एक पुनरावृत्त समारोह जिसे ग्राहम, नुथ और पटाशनिक द्वारा ठोस गणित से अनुकूलित किया गया है । हालांकि यह एल्गोरिथ्म लंबा है, यह बड़े एन और छोटे कश्मीर के लिए तेज़ है ।

def t(n,k,q):
 m=k-1;z=q*k-m%q
 while z<=n*m:z=-(-z*k//m)
 return n*k-z+1

— Sherlock9
स्रोत

1

ऐसा लगता है कि आपने कॉपी-पेस्टिंग में कुछ काट दिया है, एक फांसी है +।

— xnor

1

PHP, 71 बाइट्स

@ शर्लक 9 के जवाबों के आधार पर। एल्गोरिथ्म के लिए उसका पायथन उत्तर देखें।

function a($n,$k,$q){for($r=($k-1)%$q;$q<$n;$r=($r+$k)%++$q);echo$r+1;}

वैकल्पिक रूप से, यहां एल्गोरिथ्म के बिना मेरा मूल अनुभवहीन दृष्टिकोण है। यह एक सरणी का उपयोग करता है जो लोगों को पाया जाता है।

91 बाइट्स

function a($n,$k,$q){for($r=--$i;$q<=$n;++$i%$k||$c[$r]=$q++)while($c[$r=++$r%$n]);echo$r;}

— Xanderhall
स्रोत

1

हास्केल, 48 47 43 बाइट्स

(n!k)q=1+foldl(mod.(k+))(mod(k-1)q)[q+1..n]

दो इनपुट के साथ जोसेफस फ़ंक्शन के रोसेटा कोड पृष्ठ पर एक हास्केल एल्गोरिथ्म पर आधारित है। गोल्फ सुझावों का स्वागत है।

संपादित करें: एक पॉइंटफ़्री संस्करण का सुझाव देने के माध्यम से पहली एल्गोरिथ्म को गोल्फ के साथ मदद करने के लिए निम्मी के लिए मेरा धन्यवाद , और दूसरे एल्गोरिथ्म को गोल्फ के साथ मदद के लिए मुझे यह बताकर कि untilकीवर्ड मौजूद है।

(n#k)q|m<-k-1=1+n*k-until(>n*m)(\z-> -div(-z*k)m)(q*k-mod m q)

मेरे अजगर के अंत में एल्गोरिथ्म का एक संस्करण ग्रैहम, नुथ और पटाश्निक द्वारा ठोस गणित से अनुकूलित उत्तर है । हालांकि यह एल्गोरिथ्म 62 बाइट्स पर लंबा है, और पहले जितना नीचे नहीं गिरा है, यह बड़े nऔर छोटे के लिए तेज़ हैk ।

Ungolfed:

पहला एल्गोरिथ्म

jos_g num step q = 1 + foldl (\x -> mod (x + step) ) (mod (step-1) q) [q+1..num]

दूसरा एल्गोरिथ्म

jos_gkp num step q
    -- ceiling throws a type-related fit with ceiling(z*k/(k-1))
    -- better to use - div (-z * k) (k - 1)
    | m <- step-1 = 1 + num*step - until (>num*m)(\z-> -div (-z*k) m) (q*step - mod m q)

— Sherlock9
स्रोत

तो क्या आपने नई भाषाओं को सीखने के लिए यह प्रश्न उठाया है? 6/10 उत्तर आपके हैं: P

— Mego

@ मेगो मैंने चैट में इसका उल्लेख किया है: DI ने पूछा कि क्या मुझे इसे किसी भी तरह पोस्ट करना चाहिए और उन्होंने कहा कि आगे बढ़ो। इसके अलावा, हाँ। मेरे दोस्तों ने मुझे बताया है कि यह मेरा "हैलो, वर्ल्ड!" नई भाषाओं के लिए: D

— शर्लक

मैं यह नहीं कह रहा कि यह एक बुरी बात है। मैं बस खुश हूं, बस इतना ही।

— Mego

@ शर्लक 9: आप untilदूसरे एल्गोरिथ्म के पायथन संस्करण के (अधिक या कम) प्रत्यक्ष अनुवाद के लिए उपयोग कर सकते हैं (n#k)q|m<-k-1=1+n*k-until(>n*m)(\z-> -div(-z*k)m)(q*k-mod m q):।

— निमी

भगवान आपका भला करे, @nimi: DI उम्र, कोशिश foldlऔर अनंत सूचियों और सभी प्रकार के सामानों के लिए उस समस्या पर मेरा सिर पीट रहा था । आपकी सहायताके लिए धन्यवाद!

— शर्लक ९

1

गेममेकर लैंग्वेज (GML), 88 बाइट्स

@ User81655 के उत्तर के आधार पर

r=argument0
k=argument1
q=argument2
r=(k-1)mod q;for(i=q;i<n;r=(r+k)mod ++i){}return r+1

— Timtech
स्रोत

1

जेली , 14 13 बाइट्स

Rµṙ⁴ṖµL>⁵µ¿⁴ị

TryItOnline!

कैसे?

Rµṙ⁴ṖµL>⁵µ¿⁴ị - Main link: n, k, q
 µ            - monadic chain separation
R             - range(n): [1,2,3,...,n] - the circle of people
     µ   µ¿   - while
      L       -     length
       >      -     greater than
        ⁵     -     5th program argument (3rd input), i.e. q
  ṙ           -         rotate left by
   ⁴          -         4th program argument (2nd input) i.e. k
    Ṗ         -         pop - remove the rightmost person
            ị - get index
           ⁴  - 4th program argument (2nd input), i.e. k

— जोनाथन एलन
स्रोत

0

रूबी, ५३ 48 बाइट्स

एक मेमना।

->n,k,q{r=(k-1)%q;(q+=1;r=(r+k)%q)while q<n;r+1}

यह काम किस प्रकार करता है

def j(n,k,q)
  r=(k-1)%q   # r starts at j[q,k,q]
  while q<n
    q+=1
    r=(r+k)%q # Every time you add people to the circle, r increases by k, 
              # modulo the current size of the circle q.
  end
  r+1         # Return the result.
end

— Sherlock9
स्रोत

तीन इनपुट के साथ जोसेफस समस्या

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

स्पष्टीकरण:

पीट, 280 273 कोडेल

CJam, 22 20 19 बाइट्स

यह काम किस प्रकार करता है

गोल्फस्क्रिप्ट, 58 56 55 35 31 30 बाइट्स

यह काम किस प्रकार करता है

जावास्क्रिप्ट (ईएस 6), 56 बाइट्स

Ungolfed

परीक्षा

गणितज्ञ, 50 बाइट्स

सी, 81 73 बाइट्स

परीक्षा

पायथन 3, 72 66 62 बाइट्स

यह कैसे काम करता है

संपादित करें:

PHP, 71 बाइट्स

हास्केल, 48 47 43 बाइट्स

गेममेकर लैंग्वेज (GML), 88 बाइट्स

जेली , 14 13 बाइट्स

कैसे?

रूबी, ५३ 48 बाइट्स

यह काम किस प्रकार करता है