क्रमिक रूप से विभाज्य

24

कभी-कभी सो जाने के लिए, मैं उतने ही गिने जाऊंगा, जितने की संख्या में स्किप कर सकूं, जो वर्ग-मुक्त न हों । जब मुझे एक पंक्ति में कई नंबरों को छोड़ना पड़ता है, तो मुझे थोड़ा रोमांच होता है - उदाहरण के लिए,48,49,50 सभी वर्ग-मुक्त नहीं हैं (48 2 ^ 2, 49 द्वारा 7 ^ 2, और 50 से 5 ^ 2 तक विभाज्य हैं)।

इससे मुझे आसन्न संख्याओं के सबसे पुराने उदाहरण के बारे में सोचना पड़ा जो विभाजकों के कुछ मनमाने अनुक्रम द्वारा विभाज्य था।

इनपुट

इनपुट a = [a_0, a_1, ...]कम से कम 1 तत्व वाले सख्ती से सकारात्मक पूर्णांकों की एक आदेशित सूची है।

उत्पादन

आउटपुट nउस संपत्ति के साथ सबसे छोटा धनात्मक पूर्णांक है जो a_0विभाजित करता है n, a_1विभाजित करता है n+1, और अधिक सामान्यतः a_kविभाजित होता है n+k। यदि ऐसा नहीं nहै, तो फ़ंक्शन / प्रोग्राम का व्यवहार परिभाषित नहीं है।

परीक्षण के मामलों

[15] -> 15
[3,4,5] -> 3
[5,4,3] -> 55
[2,3,5,7] -> 158
[4,9,25,49] -> 29348
[11,7,5,3,2] -> 1518

स्कोरिंग

यह कोड-गोल्फ है ; सबसे छोटा परिणाम (प्रति भाषा) डींग मारने का अधिकार जीतता है। सामान्य खामियों को बाहर रखा गया है।

code-golf 
— चास ब्राउन
स्रोत
— अलेहलफा

जवाबों:

5

MATL , 11 बाइट्स

`Gf@q+G\a}@

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

`           % Do ....
 Gf         %   Convert input to [1,2,...,]
   @q+      %   Add current iteration index minus one, to get [n, n+1, ....]
      G\    %   Elementwise mod([n,n+1,...],[a_0,a_1,...])
        a   % ...while any of the modular remainders is nonzero.
         }  % Finally:
          @ %   Output the iteration index.

गति के लिए बिल्कुल अनुकूलित नहीं ... सबसे बड़ा टेस्टकेस MATL का उपयोग करते हुए एक पूर्ण मिनट लेता है, और MATLAB पर लगभग 0.03 s। एक छोटी सी संभावना है MATL थोड़ा अधिक उपरि है।

— Sanchises
स्रोत
आह, मैं n:q`QtG\a]1)12 बाइट्स के लिए था, लेकिन n:स्पष्ट रूप से fयहाँ के रूप में ही है। मैं हमेशा इसके बारे में भूल जाता हूं, इसलिए आप इसे वैकल्पिक 11 बेटर के रूप में जोड़ सकते हैं।
— ग्यूसेप
1
@Giuseppe बहुत बुरा fq`QtG\a}@इनपुट की एक बाहरी प्रतिलिपि देता है।
— Sanchises
5

जावास्क्रिप्ट, 42 40 बाइट्स

यदि कोई समाधान नहीं है (या समाधान बहुत बड़ा है) तो पुनरावृत्ति त्रुटि को फेंक देगा।

a=>(g=y=>a.some(x=>y++%x)?g(++n):n)(n=1)

रिक हिचकॉक से एक सूचक के साथ 2 बाइट्स सहेजे गए

कोशिश करो

संख्याओं की अल्पविराम से अलग की गई सूची दर्ज करें।

o.innerText=(f=
a=>(g=y=>a.some(x=>y++%x)?g(++n):n)(n=1)
)(i.value=[5,4,3]);oninput=_=>o.innerText=f(i.value.split`,`.map(eval))
<input id=i><pre id=o>
स्निपेट का विस्तार करें

— झबरा
स्रोत
अच्छा दृष्टिकोण, लेकिन जैसे, के साथ पुनरावृत्ति सीमा से अधिक से विफल रहता है [4,9,25,49]।
— चास ब्राउन
1
@ChasBrown, कोड गोल्फ के प्रयोजनों के लिए, हम अनंत स्मृति ग्रहण कर सकते हैं।
— झबरा
मुझे लगता है कि यह 38 बाइट्स के लिए काम करेगा: (a,y=n=0)=>a.some(x=>y++%x)?f(a,++n):n
— रिक हिचकॉक
ऊ, अच्छा एक, @ हिचकी - धन्यवाद। f=हालांकि, मत भूलना ।
— झबरा
आह, बिल्कुल। यह 40 बाइट्स है।
— रिक हिचकॉक
3

05AB1E , 9 बाइट्स

Xµā<N+sÖP

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

व्याख्या

Xµ          # loop until counter equals 1
  ā         # push range [1 ... len(input)]
   <        # decrement
    N+      # add current iteration index N (starts at 1)
      sÖ    # elementwise evenly divisible by
        P   # product
            # if true, increase counter
            # output N
— Emigna
स्रोत
मेरे 17 बाइट उत्तर, ouch को ध्वस्त करता है।
— मैजिक ऑक्टोपस Urn
3

क्लीन , 61 बाइट्स

import StdEnv
$l=hd[n\\n<-[1..]|and[i/e*e==i\\i<-[n..]&e<-l]]

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

— Οurous
स्रोत
2
मुझे लगता है कि आपको सिंगलटन सूचियों के लिए आउटपुट , एक गैर-सकारात्मक पूर्णांक से बचने के [1..]बजाय आवश्यकता है । [0..]0
— लकोनी
@ लाईकोनी धन्यवाद, निश्चित।
— Οसुरज
3

अजगर , 11 बाइट्स

f!s.e%+kTbQ

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

f!s.e%+kTbQ         Full program - inputs list from stdin and outputs to stdout
f                   First number T such that
   .e     Q         The enumerated mapping over the Input Q
      +kT           by the function (elem_value+T)
     %   b          mod (elem_index)
 !s                 has a false sum, i.e. has all elements 0
— डेव
स्रोत
क्या आपको 2अंत में आवश्यकता है ? मुझे यकीन है कि यहां और अधिक सहेजा जाना है, लेकिन मुझे पता नहीं है।
— झबरा
@ शैगी और @ गीसेप, आप दोनों सही हैं, और समाप्ति 2को समाप्त करने से समस्या ठीक हो जाती है
— डेव
2

जे , 23 बाइट्स

[:I.0=]+/@:|"1#]\[:i.*/

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

— गैलेन इवानोव
स्रोत
अच्छा लगा। क्या गणितीय तथ्य है जो आपको केवल इनपुट के उत्पाद की जांच करने की अनुमति देता है? हम कैसे जानते हैं कि इससे आगे कोई समाधान नहीं हो सकता है? इसके अलावा, हम कैसे जानते हैं कि I.केवल 1 परिणाम वापस आएगा? क्या यह संभव नहीं है कि कई हैं?
— योना
1
@ जोनाह - मुझे नहीं पता कि यह हमेशा काम करता है; मेरे द्वारा किए गए सभी परीक्षण इन सीमाओं में थे।
— गैलेन इवानोव
2

आर , 51 बाइट्स

function(l){while(any((F+1:sum(l|1))%%l))F=F+1
F+1}

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

प्रतिफल के बारे में चेतावनी के उपयोग के बारे में चेतावनी anyफेंकता kहै logical, जहां kवापसी मूल्य है।

— ग्यूसेप
स्रोत
— प्लेनपस
@plannapus मैंने माना कि लेकिन यह दुर्भाग्य l=c(15)से seq(l)==1:lउस मामले में विफल है । seqइस तरह गुस्सा आ रहा है!
— ग्यूसेप
वास्तव में arf और फिर मजबूर seq_alongकरना बहुत लंबा है।
— प्लेनपस
इसलिए, लेकिन उन चेतावनियों से छुटकारा पाने के sumबजाय any, FYI करें।
— प्लेनैपस
2

एपीएल (डायलॉग यूनिकोड) , 24 23 22 बाइट्स

{∨/×⍺|⍵+⍳⍴⍺:⍺∇⍵+1⋄⍵}∘1

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

तकनीकी रूप से, यह एक टैसिट फ़ंक्शन है। मुझे इसे बनाना पड़ा क्योंकि केवल इनपुट की अनुमति ही पूर्णांकों की सूची है। उपयोग ⎕IO←0(0-अनुक्रमण)

यह ध्यान देने योग्य है कि यदि फ़ंक्शन nमौजूद नहीं है, तो मौजूद नहीं है।

1 बाइट के लिए @ngn और @ H.PWiz को धन्यवाद।

कैसे?

{∨/×⍺|⍵+⍳≢⍺:⍺∇⍵+1⋄⍵}∘1 ⍝ Main function. ⍺=input; ⍵=1.
{                   }∘1 ⍝ Using 1 as right argument and input as left argument:
           :            ⍝ If
        ⍳≢⍺             ⍝ The range [0..length(⍺)]
      ⍵+                ⍝ +⍵ (this generates the vector ⍵+0, ⍵+1,..., ⍵+length(⍺))
    ⍺|                  ⍝ Modulo ⍺
   ×                    ⍝ Signum; returns 1 for positive integers, ¯1 for negative and 0 for 0.
 ∨/                     ⍝ Logical OR reduction. Yields falsy iff the elements of the previous vector are all falsy.
            ⍺∇⍵+1       ⍝ Call the function recursively with ⍵+1.
                 ⋄⍵     ⍝ Else return ⍵.
— जे। सल्ल
स्रोत
1

जाप, 10 बाइट्स

undefinedयदि कोई समाधान मौजूद नहीं है, तो अंततः यह आउटपुट देगा , यदि यह आपके ब्राउज़र को पहले क्रैश नहीं करता है।

@e_X°vZÃ}a

कोशिश करो

व्याख्या

               :Implicit input of array U
@       }a     :Loop and output the first integer X that returns true.
 e_    Ã       :For every element Z in U
   X°          :X, postfix increcemnted
     vZ        :Is it divisible by Z?
— झबरा
स्रोत
1

मानक एमएल (एमएलटन) , 96 बाइट्स

open List;fun$n% =if all hd(tabulate(length%,fn i=>[1>(n+i)mod nth(%,i)]))then n else$(n+1)%;$1;

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

Ungolfed:

open List
fun f n l = 
    if all (fn x=>x)
           (tabulate ( length l
                     , fn i => (n+i) mod nth(l,i) = 0))
    then n 
    else f (n+1) l
val g = f 1

इसे ऑनलाइन आज़माएं! के साथ शुरू n=1, समारोह fवेतन वृद्धि nजब तक allशर्त पूरी हो जाती है, जिसमें मामले nदिया जाता है।

tabulate(m,g)कुछ पूर्णांक mऔर फ़ंक्शन gके साथ सूची बनाता है [g 0, g 1, ..., g m]। हमारी स्थिति tabulateमें इनपुट सूची की लंबाई lऔर एक फ़ंक्शन के साथ कॉल किया जाता है जो जांचता है कि क्या iवें तत्व को lविभाजित करता है n+i। यह बूलियन्स की एक सूची देता है, इसलिए allपहचान समारोह के साथfn x=>x जांचता है कि सभी तत्व सत्य हैं या नहीं।

मैं इस मामले में पहचान समारोह चार बाइट्स से छोटा करने के लिए एक अच्छा गोल्फ चाल पाया: लैम्ब्डा के बजाय (fn x=>x), निर्माण में समारोह hdप्रयोग किया जाता है, जो एक सूची के पहले तत्व देता है, और जिसके परिणामस्वरूप bools tabulateमें लिपटे रहे हैं [और ]करने के लिए एकल सूची बनाएं।

— Laikoni
स्रोत
1

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

for(){$o=1;$i=++$j;$args[0]|%{$o*=!($i++%$_)};if($o){$j;exit}}

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

PowerShell के पास एक anyया एक समान के समान नहीं है some, इसलिए हमें थोड़ा अलग दृष्टिकोण की आवश्यकता है।

यह $args[0]एक सरणी के रूप में इनपुट लेता है , फिर एक अनंत forलूप में प्रवेश करता है । प्रत्येक पुनरावृत्ति जिसे हम निर्धारित $oकरते हैं 1(बाद में समझाया गया है), और $iहोने के लिए निर्धारित है ++$j। वेतन वृद्धि $jप्रस्तावित समाधान की पहली संख्या क्या है, इस पर नजर रखती है$i बाकी प्रस्तावित समाधान से अधिक वेतन वृद्धि होगी।

हम इनपुट के प्रत्येक तत्व को लूप $args[0]में भेजते हैं ForEach-Object। आंतरिक लूप के अंदर, हम बूलियन- $oगणना के परिणाम में गुणा करते हैं । यह इसे ऐसा बना देगा कि यदि मान किसी मान के लिए विफल हो जाता है, तो $oयह चालू हो जाएगा 0। गणना है !($i++%$_), या मॉडुलो ऑपरेशन की बूलियन-नहीं। चूंकि PowerShell में कोई भी नॉनज़ेरो वैल्यू सत्य नहीं है, इसलिए यह किसी भी अवशेष को फाल्सी वैल्यू $oमें बदल देता है, इस प्रकार बदल जाता है 0।

इनर लूप के बाहर, if $oनॉनजरो है, हमने एक वृद्धिशील समाधान पाया है जो काम करता है, इसलिए हम आउटपुट $jऔर exit।

— AdmBorkBork
स्रोत
1

टिनिइलिश , 108 बाइट्स

(load library
(d ?(q((L N)(i L(i(mod N(h L))0(?(t L)(inc N)))1
(d S(q((L N)(i(? L N)N(S L(inc N
(q((L)(S L 1

अंतिम पंक्ति एक अनाम लंबो फ़ंक्शन है जो सूची लेता है और पूर्णांक देता है। इसे ऑनलाइन आज़माएं!

Ungolfed

(load library)

(comment Function to check a candidate n)
(def sequentially-divisible?
 (lambda (divisors start-num)
  (if divisors
   (if (divides? (head divisors) start-num)
    (sequentially-divisible? (tail divisors) (inc start-num))
    0)
   1)))

(comment Function to check successive candidates for n until one works)
(def search
 (lambda (divisors start-num)
  (if (sequentially-divisible? divisors start-num)
   start-num
   (search divisors (inc start-num)))))

(comment Solution function: search for candidates for n starting from 1)
(def f
 (lambda (divisors)
  (search divisors 1)))
— DLosc
स्रोत
1

पायथन 2, 78 बाइट्स

def f(a,c=0):
 while [j for i,j in enumerate(a) if(c+i)%j<1]!=a:c+=1
 return c

EDIT: -26 धन्यवाद @ चास ब्राउन को

— sonrad10
स्रोत
अच्छा! मैंने आपके लूप से बाहर निकलने की स्थिति को बदल दिया, और 78 बाइट पाने के लिए आपके विचार में सुधार किया जा सकता है ।
— चास ब्राउन
@ धन्यवाद धन्यवाद, मैंने ऐसा करने के बारे में नहीं सोचा था। बदला हुआ!
— sonrad10
0

एपीएल नार, 140 बाइट्स, 70 चार्ट

r←f w;i;k
i←r←1⊃,w⋄k←¯1+⍴w⋄→0×⍳k=0
A:→0×⍳0=+/(1↓w)∣(k⍴r)+⍳k⋄r+←i⋄→A

परीक्षा

  f 15
15
  f 3 4 5
3
  f 5 4 3
55
  f 2 3 5 7
158
  f 4 9 25 49
29348
  f 11 7 5 3 2 
1518
— RosLuP
स्रोत
0

जावा 8, 82 75 बाइट्स

a->{for(int r=1,i,f;;r++){i=f=0;for(int b:a)f+=(r+i++)%b;if(f<1)return r;}}

स्पष्टीकरण:

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

a->{                 // Method with integer-array parameter and integer return-type
  for(int r=1,       //  Return-integer, starting at 1
          i,         //  Index-integer
          f;         //  Flag-integer
      ;r++){         //  Loop indefinitely, increasing `r` by 1 after every iteration
    i=f=0;           //   Reset both `i` and `f` to 0
    for(int b:a)     //   Inner loop over the input-array
      f+=(r+i++)%b;  //    Increase the flag-integer by `r+i` modulo the current item
    if(f<1)          //   If the flag-integer is still 0 at the end of the inner loop
      return r;}}    //    Return `r` as result
— केविन क्रूज़सेन
स्रोत
0

रूबी , 47 46 43 42 बाइट्स

->a{(1..).find{|i|a.all?{|v|i%v<1&&i+=1}}}

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

NB: (1..)वाक्यविन्यास केवल रूबी 2.6 में समर्थित है, फिलहाल TIO केवल 2.5 का समर्थन करता है इसलिए लिंक एक पुराने संस्करण (43 बाइट्स) के लिए है।

— आसोन तुहिद
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.