यदि कीथ संख्या है तो दी गई संख्या का परीक्षण करें

Question

चूंकि फाइबोनैचि संख्या और अनुक्रम कोड गोल्फ के लिए एक लोकप्रिय विषय की तरह लगता है, मुझे लगा कि कीथ संख्या के साथ गोल्फ को कोड करना एक मजेदार चुनौती हो सकती है ।

इसलिए मैं एक चुनौती का प्रस्ताव करता हूं जो एक ऐसा फ़ंक्शन बनाता है जो पूर्णांक लेता है और संख्या के आधार पर एक सही या गलत वापस देता है किथ संख्या है या नहीं।

कीथ संख्या के बारे में अधिक

मनोरंजक गणित में, एक कीथ संख्या या रेफ़िजिट संख्या (दोहराव वाले फाइबोनैचि-जैसे अंक के लिए छोटा) निम्नलिखित पूर्णांक अनुक्रम में एक संख्या है: 14, 19, 28, 47, 61, 75, 197, 742, 1104, 1537, 2208, 2580,…

नंबरफाइल में एक वीडियो है जिसमें बताया गया है कि कीथ संख्या की गणना कैसे की जाती है। लेकिन मूल रूप से आप एक संख्या के अंक लेते हैं। उन्हें एक साथ जोड़ें और फिर मूल संख्या के अंतिम अंक लें और उन्हें गणना, कुल्ला और दोहराने के योग में जोड़ें। और इसे स्पष्ट करने के लिए उदाहरण।

१४
१ + ४ = ५
४ + ५ = ९
५ + ९ = १४

इनपुट

पूर्णांक।

उत्पादन

सच है अगर संख्या एक कीथ संख्या है। झूठा है अगर नहीं ।।

Comments

सख्ती से बोलते हुए, "एक पूर्णांक" में शून्य या नकारात्मक संख्याएं शामिल हो सकती हैं। मुझे पूरा यकीन है कि न तो कीथ नंबर हो सकता है। क्या हमें इसके लिए हिसाब करने की जरूरत है?

— इज़्ज़ी

आपके समाधान के आधार पर एकल अंक संख्या सच के रूप में दिखाई दे सकती हैं। इसलिए आपको इनपुट में संभावित त्रुटियों की जांच करनी चाहिए।

— स्मिताड अनारकिस्ट

क्या इसे आउटपुट करना है true/ falseया क्या यह कुछ भी सत्य / गलत हो सकता है ?

— साइओस

Answer 1

GolfScript ( 31 25 वर्ण)

..[10base{.{+}*+(\}@*]?0>

स्टैक के शीर्ष पर पूर्णांक के रूप में इनपुट। आउटपुट 0 (गलत) या 1 (सत्य) है। ऑनलाइन डेमो जो कीथ संख्या को 100 तक सूचीबद्ध करता है।

Comments

के साथ अच्छा विचार है 0>। दुर्भाग्य से मैं केवल एक बार +1 कर सकता हूं।

— हावर्ड

Answer 2

पायथन ( 78 75)

a=input()
n=map(int,`a`)
while a>n[0]:n=n[1:]+[sum(n)]
print(a==n[0])&(a>9)

n=n[1:]+[sum(n)]सभी जादू करता है। यह प्रत्येक आइटम को लेता है, लेकिन पहले आइटम n, के योग पर चिपक जाता है n(पहले आइटम के साथ), फिर उस पर सेट होता है n।

काश, आप listएक पूर्णांक पर कॉल कर सकते और अंकों को अलग कर सकते।

Falseनीचे दिए गए सभी इनपुट पर रिटर्न 10. अगर लौटा तो 8 अक्षर छोटे हो सकते हैं True।

Comments

यदि आप n[0]इसके बजाय तुलना करते हैं तो आप दो वर्णों को बचा सकते हैं n[-1]।

— होवार्ड

पाँच और बचाओ print 9<a==n[0]।

— रेस

n=n[1:]+[sum(n)]बन सकता हैn=n[1:]+sum(n),

— साइओस

Answer 3

GolfScript, 32 29 अक्षर

...[10base\{.{+}*+(\}*]&,\9>&

एक गोल्फस्क्रिप्ट कार्यान्वयन जिसे ऑनलाइन परीक्षण किया जा सकता है । इनपुट को स्टैक पर शीर्ष तत्व के रूप में दिया गया है और यह क्रमशः 0 (यानी गलत) या 1 देता है।

Comments

@PeterTaylor उस लिंक को देखें जहाँ मैंने बिलकुल ऐसा किया था - और यह काम करता है ...

— Howard

@PeterTaylor आपके समाधान को देखते हुए मैं अपने दृष्टिकोण में आगे चलकर संख्या को कम कर सकता था।

— हावर्ड

मुझे ताज़ा नहीं करना चाहिए था, क्योंकि मेरी टिप्पणी 1 संस्करण पर लागू होती है

— पीटर टेलर

Answer 4

एपीएल, 36 34 39 36 33 29 27

*+/x={(∇⍣(⊃x>¯1↑⍵))⍵,+/⍵↑⍨-⍴⍕x}⍎¨⍕x←⎕

उत्पादन 1अगर कीथ, 0अन्यथा

GolfScript फिर से हमला !!

---

संपादित करें

+/x={(∇⍣(x>⊢/⍵))⍵,+/⍵↑⍨-⍴⍕x}⍎¨⍕x←⎕

⊢/टेक माइनस 1 ( ) के बजाय राइट-रिडक्शन ( ) का उपयोग करते हुए ¯1↑, सीधे 1 char को सेव करना और अप्रत्यक्ष रूप से Disclose से 1 को सेव करना ⊃)

व्याख्या

⍎¨⍕x←⎕मूल्यांकित इनपुट लेता है (एक संख्या के रूप में माना जाता है) और इसे असाइन करता है x। इसे एक चरित्र सरणी (अन्य भाषाओं में उर्फ ​​"स्ट्रिंग") में परिवर्तित करता है, और प्रत्येक वर्ण (अंक) के माध्यम से लूप, इसे एक संख्या में परिवर्तित करता है। तो यह अंकों के एक संख्यात्मक सरणी में परिणाम है।

{(∇⍣(x>⊢/⍵))⍵,+/⍵↑⍨-⍴⍕x}मुख्य "लूप" फ़ंक्शन है: सरणी से
+/⍵↑⍨-⍴⍕xअंतिम ⍴⍕x(अंक का x) अंक लेता है और उन्हें रकम देता है।
⍵,इसे सरणी के अंत तक पहुंचाता है।
(x>⊢/⍵)जाँचें कि क्या सरणी पर अंतिम संख्या (जो +/⍵↑⍨-⍴⍕xअभी तक समाप्‍त नहीं हुई है) की तुलना में छोटा है xऔर कई बार नए सरणी पर इस फ़ंक्शन को देता है 1या 0
∇⍣निष्पादित करता है। इसलिए यदि अंतिम संख्या इससे छोटी है x, तो यह फ़ंक्शन पुनरावृत्ति करता है। अन्यथा बस नई सरणी लौटाएं

फ़ंक्शन निष्पादित करने के बाद, सरणी में सम बिंदु तक सममितियां होती हैं, जहां संख्याओं में से 2 इसके बराबर या उससे अधिक होती हैं x(जैसे 14उत्पन्न होगी 1 4 5 9 14 23, 13उत्पन्न होगी 1 3 4 7 11 18 29)
अंत में जांचें कि क्या प्रत्येक संख्या बराबर है xऔर परिणामी बाइनरी का योग आउटपुट है सरणी।

---

संपादित करें

1=+/x={(∇⍣(x>⊢/⍵))⍵,+/⍵↑⍨-⍴⍕x}⍎¨⍕x←⎕

0यदि इनपुट एक-अंक का है, तो आउटपुट बनाने के लिए 2 चार्ट जोड़े :-(

---

फिर भी एक और संपादन

+/x=¯1↓{(∇⍣(x>⊢/⍵))1↓⍵,+/⍵}⍎¨⍕x←⎕

व्याख्या

फ़ंक्शन अब 1↓अंतिम ⍴⍕x( ↑⍨-⍴⍕x) को लेने के बजाय सरणी से पहला नंबर ( ) ड्रॉप करता है ।
हालाँकि, यह दृष्टिकोण 1=एकल अंकों की संख्या को संभालने के लिए पर्याप्त नहीं है। तो यह अब x1 चर को जोड़कर समानता की जाँच करने से पहले सरणी से अंतिम संख्या को गिराता है

---

आपने यह अनुमान लगाया: EDIT

+/x=1↓{1↓⍵,+/⍵}⍣{x≤+/⍵}⍎¨⍕x←⎕

xपुराने अंतिम आइटम के बजाय नए जोड़े गए आइटम की तुलना में , इसलिए समानता को जांचने से पहले पहली (अंतिम) आइटम को गिराना xपर्याप्त है, एक ऋण चिह्न को बचाते हुए। पावर ऑपरेटर के दूसरे रूप का उपयोग करके एक और 3 बचाता है ( ⍣)

और 25-char gs उत्तर प्रकट होता है (Orz)

---

अंतिम संपादन

x∊1↓{1↓⍵,+/⍵}⍣{x≤+/⍵}⍎¨⍕x←⎕

विश्वास नहीं कर सकता कि मैं चूक गया।
अब इसे गोल्फ नहीं कर सकते।

Comments

आप इसे 24 वर्णों तक प्राप्त कर सकते हैं x∊{1↓⍵,+/⍵}⍣{x≤⊃⍺}⍎¨⍕x←⎕:। पावर फ़ंक्शन में, ⍺"बाद" मान है।

— मारिनस

Answer 5

आम लिस्प, 134

सीएल कई बार अपठनीय हो सकता है।

(defun k(n)(do((a(map'list #'digit-char-p(prin1-to-string n))(cdr(nconc a(list(apply'+ a))))))((>=(car a)n)(and(> n 9)(=(car a)n)))))

क्षैतिज स्क्रॉलिंग से बचने के लिए कुछ प्रारूपण:

(defun k(n)
  (do
    ((a(map'list #'digit-char-p(prin1-to-string n))(cdr(nconc a(list(apply'+ a))))))
    ((>=(car a)n)(and(> n 9)(=(car a)n)))))

परीक्षा:

(loop for i from 10 to 1000
      if (k i)
      collect i)

=> (14 19 28 47 61 75 197 742)

Answer 6

एफ # - 184 चार्ट

मुझे आशा है कि यह ठीक है कि मैं अपनी चुनौती में भाग लूंगा।

let K n=
let rec l x=if n<10 then false else match Seq.sum x with|v when v=n->true|v when v<n->l(Seq.append(Seq.skip 1 x)[Seq.sum x])|_->false
string n|>Seq.map(fun c->int c-48)|>l

छोटी संख्या के बारे में एक बग को संपादित करें ।

Comments

यह पूरी तरह से ठीक है :)

— beary605

आपका समाधान n <10 के लिए सही है जो मुझे लगता है कि गलत होना चाहिए।

— हावर्ड

तुम सही हो। मुझे उस पर गौर करना चाहिए।

— स्मिताड अनारकिस्ट

Answer 7

के, ५५

{(x>9)&x=*|a:{(1_x),+/x}/[{~(x~*|y)|(+/y)>x}x;"I"$'$x]}

।

k)&{(x>9)&x=*|a:{(1_x),+/x}/[{~(x~*|y)|(+/y)>x}x;"I"$'$x]}'!100000
14 19 28 47 61 75 197 742 1104 1537 2208 2580 3684 4788 7385 7647 7909 31331 34285 34348 55604 62662 86935 93993

Answer 8

पॉवरशेल: 120 128 123 111 111 110 97

$j=($i=read-host)-split''|?{$_};While($x-lt$i){$x=0;$j|%{$x+=$_};$null,$j=$j+$x}$x-eq$i-and$x-gt9

$i=read-host उपयोगकर्ता से इनपुट लेता है, इसे $ i में संग्रहीत करता है।

$j=(... )-split''|?{$_}$ मैं अंकों को एक सरणी में तोड़ता है और $ j में संग्रहीत करता है।

यह इंगित करने के लिए कि अनावश्यक है राइनेंट के लिए धन्यवाद -ne''।

While($x-lt$i) निम्नलिखित फिबोनेसी-जैसे लूप को सेट करने के लिए जब तक कि चर चर, $ x, तक पहुँच जाता है या $ i से अधिक नहीं हो जाता है।

$x=0 $ x को शून्य करता है, इसलिए यह योग के लिए उपयोग करने के लिए तैयार है (जब लूप वापस आता है)।

$j|%{$x+=$_} $ j से $ x में मान जोड़ने के लिए ForEach-Object लूप का उपयोग करता है।

$null,$j=$j+$x $ j बाएँ में मानों को बदलता है, पहले को त्यागते हुए, $ x को जोड़ते हुए।

वाह! मैंने आखिरकार शिफ्ट-एंड-अपेंड करने के लिए एक छोटा तरीका निकाला, और इस स्क्रिप्ट को 100 से कम में मिला!

$x-eq$i जब लूप पूरा हो जाता है, तो परीक्षण, यदि सम मूल्य, $ x, प्रारंभिक मान के बराबर होता है, तो $ - आम तौर पर कीथ संख्या का सूचक होता है।

-and$x-gt9 एकल-अंकों की संख्या, शून्य और नकारात्मक संख्याओं को अमान्य करता है, जो कीथ संख्या नहीं हो सकती है।

यह स्क्रिप्ट थोड़ी "गड़बड़" है। यह सुंदर रूप से $ i और $ j को बचे हुए को संभाल सकता है, लेकिन आपको रन के बीच $ x को साफ़ करने की आवश्यकता होगी।

कीथ हिल और mjolinor के लिए धन्यवाद अंकों की संख्या को तोड़ने के कुछ तरीकों के लिए जो इस स्क्रिप्ट के पुराने संस्करणों में उपयोग किए गए थे। जबकि वे अंतिम संस्करण में नहीं हैं, उन्होंने एक महान सीखने के अनुभव के लिए प्रदान किया।

Comments

आप इसे हटा सकते हैं -ne''ताकि यह बस हो ?{$_}।

— रयानंत

धन्यवाद @ रेनेंट मैं की तरह लग रहा भी बदल कर एक और नीचे यह ट्रिम कर सकते हैं $i=read-host;$j=$i-split''|?{$_}'के साथ $j=($i=read-host)-split''|?{$_}।

— इज़्ज़ी

Answer 9

रूबी, 82

def keith?(x)
  l="#{x}".chars.map &:to_i
  0while(l<<(s=l.inject :+)).shift&&s<x
  (s==x)&l[1]
end

इस एक के लिए पायथन का एक बेहतर उपकरण है।

Answer 10

सी, 123

k(v){
    int g[9],i,n,s,t=v;
    for(n=s=0;t;t/=10)s+=g[n++]=t%10;
    for(i=n;s<v;){
        i=(i+n-1)%n;
        t=g[i];g[i]=s;s=s*2-t;
    }
    return n>1&&s==v;
}

दोहन ​​के माध्यम से परीक्षण:

main(i){
    for(i=0;i<20000;i++)
        if(k(i)) printf("%d ",i);
}

देता है:

14 19 28 47 61 75 197 742 1104 1537 2208 2580 3684 4788 7385 7647 7909

Comments

आप बदल सकते हैं i=(i+n-1)%n;t=g[i];g[i]=s;s=s*2-t;के साथ i+=n-1;t=g[i%n];g[i%n]=s;s+=s-t;और दो वर्ण बचाने।

— श्नाडर

Answer 11

आर, ११६

अजगर चीर-फाड़:

a=scan();n=as.numeric(strsplit(as.character(a),"")[[1]]);while(a>n[1])n=c(n[-1],sum(n));if((n[1]==a)&&(a>9))T else F

Answer 12

पर्ल, 90

sub k{$-=shift;$==@$=split//,$-;push@$,eval join'+',@$[-$=..-1]while@$[-1]<$-;grep/$-/,@$}

एक मजेदार व्यायाम! मुझे पता है कि यह एक पुरानी पोस्ट है लेकिन मैंने देखा कि पर्ल गायब था!

मुझे यकीन है कि मैं अन्य प्रतिक्रियाओं को अधिक अच्छी तरह से पचाने से इसे बनाने के तरीके में सुधार कर सकता हूं, इसलिए मैं इस पर फिर से विचार करूंगा!

Answer 13

स्मालटाक - 136 चार

 [:n|s:=n asString collect:[:c|c digitValue]as:OrderedCollection.w:=s size.[n>s last]whileTrue:[s add:(s last:w)sum].^(s last=n and:n>9)]

इस ब्लॉक को भेजें value:

Answer 14

जावा - 1437

import java.io.*;
class keith
{
    public int reverse(int n)
    {
        int i,c=0;
        while(n>0)
        {
            c=(c*10)+(n%10);
            n/=10;
        }
        return(c);
    }
    public int countdigit(int n)
    {
        int i,c=0;
        while(n>0)
        {
            c++;
            n/=10;
        }
        return(c);
    }
    public void keith_chk()throws IOException
    {
        BufferedReader br=new BufferedReader(
        new InputStreamReader(System.in));
        int n,digi,r,p=0,a,tot=0,i;
        System.out.print("Enter number :-");
        n=Integer.parseInt(br.readLine());
        digi=countdigit(n);

        int ar[]=new int[digi+1];
        r=reverse(n);
        while(r>0)
        {
            a=r%10;
            ar[p++]=a;
            tot=tot+a;
            r/=10;
        }
        ar[p]=tot;
        while(true)
        {
            for(i=0;i<=p;i++)
            System.out.print(ar[i]+"\t");
            System.out.println(); 
            if(tot == n)
            {
                System.out.print("Keith Number....");
                break;
            }
            else if(tot > n)
            {
                System.out.print("Not Keith Number.....");
                break;
            }
            tot=0;
            for(i=1;i<=p;i++)
            {
                ar[i-1]=ar[i];
                tot=tot+ar[i];
            }
            ar[p]=tot;
        }
    }
}

Comments

CodeGolf.SE में आपका स्वागत है! चूंकि यह प्रश्न कोड-गोल्फ है , इसलिए आपको अपना कोड गोल्फ करना चाहिए (

— व्हाट्सएप

Answer 15

पायथन 3 104

#BEGIN_CODE
def k(z):
 c=str(z);a=list(map(int,c));b=sum(a)
 while b<z:a=a[1:]+[b];b=sum(a)
 return(b==z)&(len(c)>1)
#END_CODE score: 104

print([i for i in filter(k, range(1,101))])  #[14, 19, 28, 47, 61, 75]

और यह एक समारोह है;)

Answer 16

पायथन - 116 वर्ण

वास्तव में कोडगॉल्फ के विशेषज्ञ नहीं हैं, इसलिए आपके पास यह है- मेरी पहली कोशिश।

x=input();n=`x`;d=[int(i)for i in n];f=d[-1]
while f<x:d+=[sum(d[-len(n):])];f=d[-1]
if f==x>13:print 1
else:print 0

किसी फ़ंक्शन के लिए 2 परिवर्तन करें:

• बदलें printकरने के लिएreturn
• xपैरामीटर होने के लिए असाइन करें

PS I दूसरा @ beary605- अंकों / वर्णों को अलग करने के लिए एक बिल्ट-इन जोड़ें।

Answer 17

रूबी (OOP के साथ)

class Recreationalmathematics
def Check_KeithSequence(digit) 
    sequence,sum=digit.to_s.split(//).to_a,0
    while(sum<digit) do
        sum=0
        sequence.last(digit.to_s.size).each{|v|  sum=sum+v.to_i}
        sequence<<sum
    end 
    return (sum==digit)?"true":"false" 
end
end
test = Recreationalmathematics.new
puts test.Check_KeithSequence(197)
puts test.Check_KeithSequence(198)