पता करें कि कोई संख्या खुश है या नहीं?

Question

एक खुश संख्या को निम्नलिखित प्रक्रिया द्वारा परिभाषित किया गया है। किसी भी धनात्मक पूर्णांक से शुरू होकर, संख्या को उसके अंकों के वर्गों के योग से बदलें, और जब तक संख्या 1 (जहाँ यह रहेगी) के बराबर होने तक प्रक्रिया को दोहराएं, या यह एक चक्र में अंतहीन रूप से लूप करता है जिसमें शामिल नहीं है 1. वे संख्याएँ जिसके लिए यह प्रक्रिया 1 में समाप्त होती है, वे खुश संख्या हैं, जबकि जो 1 में समाप्त नहीं होती हैं वे दुखी संख्या (या दुखद संख्या) हैं। एक नंबर प्रिंट को देखते हुए कि क्या वह खुश है या दुखी है।

Sample Inputs
7
4
13

Sample Outputs
Happy
Unhappy
Happy

नोट: आपके प्रोग्राम को 1,000,000,000 से नीचे किसी भी संख्या के लिए 10 सेकंड से अधिक नहीं लेना चाहिए।

Answer 1

गोल्फस्क्रिप्ट - 34 वर्ण

~{0\`{48-.*+}/}9*1="UnhH"3/="appy"

मूल रूप से यह और ये समान हैं ।

इन टिप्पणियों में 9 पुनरावृत्तियों का कारण वर्णित है (यह सैद्धांतिक रूप से 10^10^10^974( ए 001273 ) के बारे में सही मान देता है )।

Answer 2

रूबी, 77 वर्ण

a=gets.to_i;a=eval"#{a}".gsub /./,'+\&**2'until a<5
puts a<2?:Happy: :Unhappy

Comments

ठीक है, इसलिए मुझे पता है कि यह कैसे काम करता है (शाब्दिक रूप से प्रत्येक संख्या को लेना, इसे विभाजित करना और प्रत्येक अंक का वर्ग जोड़ना), लेकिन क्या (<5) की स्टॉप स्थिति और एक (2 <) का उपयोग करके यह तय करना है कि यह खुश है या नहीं। या नहीं? मैं वैधता पर सवाल नहीं उठाता, सिर्फ तर्क।

— श्री लामा

जैसा है a <= 4और वैसा ही है a <= 1। यदि चक्र में 1 है तो यह खुश है, और यदि इसमें 4 है, तो यह खुश नहीं है। नाखुश चक्र के बारे में विकिपीडिया अनुभाग देखें । इसलिए एक बार जब मूल्य a4 या उससे कम है, तो वह जांचता है कि क्या है - उसी का परिणाम आपका उत्तर है।

— केसी

Answer 3

सी - 115

char b[1<<30];a;main(n){for(scanf("%d",&n);b[n]^=1;n=a)for
(a=0;a+=n%10*(n%10),n/=10;);puts(n-1?"Unhappy":"Happy");}

यह एक 2 ³⁰ -बाइट (1 जीबी) सरणी का उपयोग करता है , जिसके लिए चक्र में नंबर का सामना करने के लिए बिटमैप के रूप में रखा गया है। लिनक्स पर, यह वास्तव में काम करता है, और कुशलतापूर्वक, इसलिए, बशर्ते मेमोरी ओवरकोमिटिंग सक्षम है (जो कि आमतौर पर डिफ़ॉल्ट रूप से होता है)। ओवरकॉमिटिंग के साथ, सरणी के पृष्ठों को आवंटित किया जाता है और मांग पर शून्य किया जाता है।

ध्यान दें कि लिनक्स पर इस प्रोग्राम को संकलित करने के लिए एक गीगाबाइट रैम का उपयोग किया जाता है।

Comments

इस समस्या के लिए आपको स्मृति की उस राशि के करीब कहीं भी आवश्यकता क्यों होगी?

— पीटर ओल्सन

@Peter: मुझे लगता है कि दृष्टिकोण (भोले रूप से) 1 से 1,000,000,000 तक की अनुमत इनपुट रेंज में किसी भी संख्या के लिए एक चक्र को पकड़ना है। लेकिन मैं इस बात से सहमत हूं कि खुशहाल संख्या सिद्धांत के आलोक में, केवल जाँच आवश्यक है यदि संख्या 4 तक पहुँच गई है, क्योंकि यह एकमात्र चक्र है जो कभी भी घटित होगा।

— मेलमोकब

मैं उत्सुक हूं: संकलन करने के लिए इतनी रैम की आवश्यकता क्यों है?

— पीटर टेलर

MSVC 10 के साथ विंडोज 7 पर ठीक काम करने की अपील करता है। संकलन करते समय किसी भी उल्लेखनीय मात्रा में मेमोरी का उपभोग नहीं करता है और केवल पेज फ़ाइल में सरणी को चिह्नित करता है (कुछ ऐसा लगता है जो कहानी से अधिक सुरक्षित लगता है, जो आपको स्मृति के बारे में जुड़ा हुआ है; ।

— जॉय

मुझे इस दृष्टिकोण का भोलापन पसंद है। और छोरों के लिए दुरुपयोग सुंदर है।

— dmckee

Answer 4

हास्केल - 77

f 1="Happy"
f 4="Unhappy"
f n=f$sum[read[c]^2|c<-show n]
main=interact$f.read

Answer 5

गोल्फस्क्रिप्ट, 49 43 41 40 39 वर्ण

~{0\10base{.*+}/.4>}do(!"UnhH"3/="appy"

प्रत्येक खुश संख्या 1 में परिवर्तित होती है; हर दुखी संख्या में एक चक्र होता है, जिसमें 4. इस तथ्य का फायदा उठाने के अलावा, यह मुश्किल से ही होता है।

(वेंटरो के लिए धन्यवाद, जिनके रूबी समाधान से मैंने एक चाल निकाली है और 6 वर्णों को बचाया है)।

Answer 6

eTeX, 153

\let~\def~\E#1{\else{\fi\if1#1H\else Unh\fi appy}\end}~\r#1?{\ifnum#1<5
\E#1\fi~\s#1{0?}}~\s#1{+#1*#1\s}~~{\expandafter\r\the\numexpr}\message{~\noexpand

के रूप में कहा जाता है etex filename.tex 34*23 + 32/2 ?(अंत में प्रश्न चिह्न सहित)। अभिव्यक्ति में अंतर मायने नहीं रखता।

संपादित करें: मैं 123 पर नीचे गया , लेकिन अब आउटपुट dvi है (यदि संकलित किया गया है etex) या pdf (यदि संकलित किया गया है pdfetex)। चूंकि TeX एक टाइपसेटिंग भाषा है, मुझे लगता है कि यह उचित है।

\def~{\expandafter\r\the\numexpr}\def\r#1?{\ifnum#1<5 \if1#1H\else
Unh\fi appy\end\fi~\s#1{0?}}\def\s#1{+#1*#1\s}~\noexpand

Answer 7

अजगर - 81 वर्ण

n=input()
while n>4:n=sum((ord(c)-48)**2for c in`n`)
print("H","Unh")[n>1]+"appy"

वेंटरो और पीटर टेलर से ली गई कुछ प्रेरणा।

Comments

एक int(c)से बेहतर कर ord(c)-48....

— st0le

Answer 8

जावास्क्रिप्ट ( 94 92) 87 86)

do{n=0;for(i in a){n+=a[i]*a[i]|0}a=n+''}while(n>4);alert(['H','Unh'][n>1?1:0]+'appy')

वांछित संख्या के लिए एक सेट करके इनपुट प्रदान किया जाता है।

मेलामोकब को श्रेय।

Comments

1 char सहेजें:n==4?h="Unh":n==1?h="H":a=n+""}alert(h+"appy")

— mellamokb

@ मीला धन्यवाद। मैं भी बदल कर एक और चार मुंडा ||था |।

— पीटर ओल्सन

8 वर्ण सहेजें: निकालें n==4?h...। ऐसा करने के लिए परिवर्तित करें ... जबकि शर्त के साथ पाश while(n>4)। इसके बजाय इस अंतिम कथन का उपयोग करें:alert(["H","Unh"][n>1?1:0]+"appy")

— mellamokb

@ मेरी चालाक, मुझे यह पसंद है।

— पीटर ओल्सन

@ मीला एन को लूप से पहले परिभाषित करने की आवश्यकता है, मैं यह सोचने की कोशिश कर रहा हूं कि मैं कैसे नहीं दोहराऊंn=0;

— पीटर ओल्सन

Answer 9

अजगर (98, लेकिन साझा न करने के लिए भी गड़बड़)

f=lambda n:eval({1:'"H"',4:'"Unh"'}.get(n,'f(sum(int(x)**2for x in`n`))'))
print f(input())+"appy"

रास्ता, प्रतिस्पर्धी होने के लिए बहुत लंबा रास्ता, लेकिन शायद एक हंसी के लिए अच्छा है। यह पायथन में "आलसी" मूल्यांकन करता है। वास्तव में काफी हद तक हास्केल प्रविष्टि के समान है कि मैं इसके बारे में सोचता हूं, बिना किसी आकर्षण के।

Answer 10

डीसी - 47 वर्ण

[Unh]?[[I~d*rd0<H+]dsHxd4<h]dshx72so1=oP[appy]p

संक्षिप्त विवरण:

I~: 10. भाग देते समय भागफल और शेषफल प्राप्त करें: शेषफल
d*को काटें।
0<H: यदि भागफल 0 से अधिक है, तो पुनरावर्ती रूप से दोहराएं।
+: पुनरावर्ती स्टैक को सिकोड़ते समय मानों को योग करें।

4<h: सम-वर्गों को थोड़ा दोहराएं जबकि मान 4 से अधिक है।

Answer 11

बेफुज, 109

1 <= n <= 10 ⁹ -1 के लिए सही मान देता है ।

v v              <   @,,,,,"Happy"<      >"yppahnU",,,,,,,@
>&>:25*%:*\25*/:#^_$+++++++++:1-!#^_:4-!#^_10g11p

Answer 12

जे, ५६

'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)

प्रश्न के अस्पष्ट होने के बाद से एक स्टैंडअलोन स्क्रिप्ट के बजाय एक क्रिया।

उपयोग:

   happy =: 'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)
happy =: 'Happy'"_`('Unhappy'"_)`([:$:[:+/*:@:"."0@":)@.(1&<+4&<)
   happy"0 (7 4 13)
happy"0 (7 4 13)
Happy  
Unhappy
Happy  

Answer 13

स्काला, 145 चर

def d(n:Int):Int=if(n<10)n*n else d(n%10)+d(n/10)
def h(n:Int):Unit=n match{
case 1=>println("happy")
case 4=>println("unhappy")
case x=>h(d(x))}

Comments

के (n*n)रूप में छोटा नहीं होगा n*n , या व्हॉट्सएप एक से अभिव्यक्ति को अलग करने के लिए पर्याप्त नहीं है else?

— पीटर टेलर

हां, मैंने ऐसा किया, पीटर।

— उपयोगकर्ता अज्ञात

यहाँ एक 126 बाइट्स टेल-पुनरावर्ती संस्करण है, पैटर्न मिलान के बिना:def h(s: String):String=if(s=="1")"H"else if(s=="4")"Unh"else h(s.map(_.asDigit).map(a=>a*a).sum+"");print(h(readLine)+"appy")

— 6infinity8

@ 6infinity8: आप इसे नए उत्तर के रूप में पोस्ट क्यों नहीं करते?

— उपयोगकर्ता अज्ञात

प्रारंभिक पद पुराना है; मैं सिर्फ आपके समाधान में सुधार करने की कोशिश कर रहा था।

— 6infinity8

Answer 14

जे (50)

'appy',~>('Unh';'H'){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)

मुझे यकीन है कि मैं इसे और भी छोटा बना सकता हूं। मैं एक रिश्तेदार newb हूँ।

नया और बेहतर:

('Unhappy';'Happy'){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)

नए और भी बेहतर, धन्यवाद andıʎu :s:

(Unhappy`Happy){~=&1`$:@.(>&6)@(+/@:*:@:("."0)@":)

Comments

आप 'appy' को विभाजित नहीं करके एक चरित्र प्राप्त कर सकते हैं। मुझे लगता है कि आप कोष्ठकों को चारों ओर से हटा सकते हैं ("।" 0) - क्रियाविशेषण कंजरों की तुलना में कसकर बांधते हैं।

— जेसी मिलिकन

मैं चारों ओर कोष्ठक नहीं हटा सकता ("."0)। यह एक रैंक त्रुटि पैदा करता है, लेकिन अगर मैं 'हैप्पी' को विभाजित नहीं करता हूं और परिणाम को बॉक्सिंग छोड़ देता हूं, तो मैं एक चरित्र को बचा सकता हूं।

— ग्रेगरी हिगले

जिस कारण मैं कोष्ठक को बाहर नहीं छोड़ सकता, ("."0)वह यह है कि संयोजन क्रियाओं की पूरी पूर्ववर्ती ट्रेन पर लागू होते हैं जिसमें वे संलग्न होते हैं, जो कि मैं नहीं चाहता। अगर मैं कहूं +/@:("."0)@":, तो यह बहुत अलग है +/@:"."0@:, जो वास्तव में है (+/@:".)"0@:।

— ग्रेगरी हिगले

एक बड़े पैमाने पर necro, लेकिन आप को बदल कर 4 वर्ण को बचा सकता है 'Unhappy';'Happy'के साथ Unhappy`Happy।

— atı

@ whereı isuʎs यह काम करता है, लेकिन यह कहां से प्रलेखित है कि आप `के साथ तार के उद्धरण को छोड़ सकते हैं?

— ग्रेगरी हिगले

Answer 15

पायथन (91 अक्षर)

a=lambda b:b-1and(b-4and a(sum(int(c)**2for c in`b`))or"Unh")or"H";print a(input())+"appy"

Answer 16

आम लिस्प 138

(format t"~Aappy~%"(do((i(read)(loop for c across(prin1-to-string i)sum(let((y(digit-char-p c)))(* y y)))))((< i 5)(if(= i 1)"H""Unh"))))

अधिक पठनीय:

(format t "~Aappy~%"
        (do
          ((i (read)
              (loop for c across (prin1-to-string i)
                    sum (let
                          ((y (digit-char-p c)))
                          (* y y)))))
          ((< i 5) (if (= i 1) "H" "Unh"))))

सिर्फ "हैप्पी" या "नाखुश" से वापस लौटने के लिए छोटा होगा (do), लेकिन यकीनन यह पूरे कार्यक्रम के रूप में नहीं गिना जाएगा

Answer 17

के, ४३

{{$[4=d:+/a*a:"I"$'$x;unhappy;d]}/x;`happy}

Answer 18

जेली , 17 बाइट्स (गैर-प्रतिस्पर्धी *)

* भाषा के बाद की चुनौती

D²SµÐLỊị“¢*X“<@Ḥ»

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

कैसे?

D²SµÐLỊị“¢*X“<@Ḥ» - Main link: n
   µÐL            - loop while the accumulated unique set of results change:
D                 -   cast to a decimal list
 ²                -   square (vectorises)
  S               -   sum
                  - (yields the ultimate result, e.g. n=89 yields 58 since it enters the
                  -  "unhappy circle" at 145, loops around to 58 which would yield 145.)
      Ị           - insignificant? (abs(v)<=1 - in this case, 1 for 1, 0 otherwise)
        “¢*X“<@Ḥ» - dictionary lookup of ["Happy", "Unhappy"] (the central “ makes a list)
       ị          - index into
                  - implicit print

Answer 19

पर्ल 5 - 77 बाइट्स

{$n=$_*$_ for split//,$u{$n}=$n;exit warn$/.'un'[$n==1].'happy'if$u{$n};redo}

$ n इनपुट मूल्य है

Answer 20

05AB1E , 21 बाइट्स

'ŽØs[SnOD5‹#}≠i„unì}™

इसे ऑनलाइन आज़माएं या पहले 100 परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

प्रत्येक संख्या अंत में या तो में परिणाम होगा 1या 4, तो हम पाश को अनिश्चित काल के, और जल्द ही नंबर 5 से कम है के रूप में के रूप में बंद।

'ŽØ                    '# Push string "happy"
   s                    # Swap to take the (implicit) input
    [       }           # Loop indefinitely
     S                  #  Convert the integer to a list of digits
      n                 #  Square each
       O                #  Take the sum
        D5‹#            #  If this sum is smaller than 5: stop the infinite loop
             ≠i    }    # If the result after the loop is NOT 1:
               „unì     #  Prepend string "un" to string "happy"
                    ™   # Convert the string to titlecase (and output implicitly)

मेरा यह 05AB1E टिप देखें (अनुभाग कैसे शब्दकोश उपयोग कैसे करें? ) को समझने के लिए क्यों 'ŽØहै "happy"।

Answer 21

सी ++ 135, 2 लाइन्स

#include<iostream>
int n,i,j;int main(){for(std::cin>>n;n>1;n=++j&999?n*n+i:0)for(i=0;n/10;n/=10)i+=n%10*(n%10);std::cout<<(n?"H":"Unh")<<"appy";}

यह मेरे द्वारा यहां किए गए का एक संशोधित संस्करण है:

/programming/3543811/code-golf-happy-primes/3545056#3545056

Comments

क्या &999करना है? और अगर jकचरा मूल्य है तो यह कैसे काम करता है ?

— डेविड का कहना है कि मोनिका

@ Dgrin91, मैंने इसे 3 साल पहले लिखा था, इसलिए मुझे याद नहीं है कि यह कैसे काम करता है। मुझे लगता है कि & 999 स्टेटमेंट बनाता है if(j==999){n = 0;}else{n=n*n +i;}, जम्मू को कचरा मूल्य नहीं होना चाहिए, ग्लोबल्स शून्य आरंभीकृत हैं।

— स्कॉट लोगन

Answer 22

हां, इस चुनौती के तीन साल हैं; हां, इसका पहले से ही एक विजेता उत्तर है; लेकिन जब से मैं ऊब गया था और एक और चुनौती के लिए ऐसा किया, मैंने सोचा कि मैं इसे यहाँ रख सकता हूं। आश्चर्य चकित, इसके लंबे - और ...

जावा - 280 264 बाइट्स

import java.util.*;class H{public static void main(String[]a){int n=Integer.parseInt(new Scanner(System.in).nextLine()),t;while((t=h(n))/10!=0)n=t;System.out.print(t==1?"":"");}static int h(int n){if(n/10==0)return n*n;else return(int)Math.pow(n%10,2)+h(n/10);}}

Ungolfed:

import java.util.*;

class H {

    public static void main(String[] a) {
        int n = Integer.parseInt(new Scanner(System.in).nextLine()), t;
        while ((t = h(n)) / 10 != 0) {
            n = t;
        }
        System.out.print(t == 1 ? "" : "");
    }

    static int h(int n) {
        if (n / 10 == 0) {
            return n * n;
        } else {
            return (int) Math.pow(n % 10, 2) + h(n / 10);
        }
    }
}

Answer 23

सी # 94 बाइट्स

int d(int n)=>n<10?n*n:(d(n%10)+d(n/10));string h(int n)=>n==1?"happy":n==4?"unhappy":h(d(n));

किसी भी संख्या के लिए (as int), h()सही मान लौटाएगा। आप कोड को .NetFiddle पर आज़मा सकते हैं ।

मूल एल्गोरिथ्म के लिए उपयोगकर्ता अज्ञात के लिए यश ।

Answer 24

क्लोजर, 107 97 बाइट्स

अद्यतन: अनावश्यक letबंधन हटाया ।

#(loop[v %](case v 1"Happy"4"Unhappy"(recur(apply +(for[i(for[c(str v)](-(int c)48))](* i i))))))

मूल:

#(loop[v %](let[r(apply +(for[i(for[c(str v)](-(int c)48))](* i i)))](case r 1"Happy"4"Unhappy"(recur r))))

नेस्टेड का उपयोग करते हुए पहली बार for: ओ

Answer 25

आर, 117 91 बाइट्स

-16 बाइट्स ग्यूसेप के लिए धन्यवाद

a=scan();while(!a%in%c(1,4))a=sum((a%/%10^(0:nchar(a))%%10)^2);`if`(a-1,'unhappy','happy')

Comments

के strtoiबजाय as.numericऔर के pasteबजाय का उपयोग करें as.character, लेकिन अंक प्राप्त करने के लिए एक छोटा दृष्टिकोण है । यदि आप `if`(a-1,"unhappy","happy")इसके बजाय का उपयोग करते हैं जो एक और बाइट को बचाना चाहिए। अंत में, आप इस अनाम को कुछ और बाइट्स से दाढ़ी बनाने के लिए कर सकते हैं।

— ग्यूसेप

Answer 26

पर्ल 5 , 62 + 1 ( -p) = 63 बाइट्स

$_=eval s/./+$&**2/gr while$_>1&&!$k{$_}++;$_=un x($_>1).happy

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

Answer 27

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

f=lambda n:n>4and f(sum(int(d)**2for d in`n`))or("H","Unh")[n>1]+"appy"

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

... या, एक ही बाइट गिनती के लिए:

f=lambda n:n>4and f(eval('**2+'.join(`n*10`)))or("H","Unh")[n>1]+"appy"

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

Answer 28

C: 1092 वर्ण

#include <iostream>
using namespace std ;
int main ()
{
    int m , a[25] , kan=0 , y , z=0  , n , o=0, s , k=0 , e[25]  ;
    do {
m :
        for ( int j=1 ; j <10000 ; j++ )
        {   
n:
            for (int i=0 ; j!=0 ; i++ )
            {
                a[i]=j%10 ;
                j/=10 ;
                kan++ ;
            }
            for ( int i=0 ; i<kan ; i++ )
            {
                y=a[i]*a[i] ;
                z+=y ;
            }
            k+=1 ;
            if (z==1)
            {
              cout<<j<<endl;
               o++ ;
            }

            else 
            {   
                 for (int f=0 ; f<k ; f++ )
                 {
                     e[f]=z ;
                 }
                 for ( int f=0 ; f=k-1 ; f++ )
                 {
                     for ( int p=f+1 ; p <k-1 ; p++ )
                     {
                         if(e[f]=e[p])
                             goto m ;
                         else { j=z ; goto n ; } 
                     }
                 }
            }
        }
    }while(o!=100) ;
    return 0 ;
}

Comments

प्रोग्रामिंग पहेलियाँ और कोड गोल्फ, @ जन्नत में आपका स्वागत है। कृपया ध्यान दें कि कोड गोल्फ सबसे छोटा कोड संभव लिखने की एक चुनौती है। इसका मतलब है, यहाँ हम बिना पढ़े लिखे और लगभग अपठनीय कोड लिखते हैं और अपने कोड को यथासंभव छोटा करने के लिए भाषा सिंटैक्स की सीमाओं को बाध्य करते हैं।

— मैनटवर्क

xkcd.com/292

— aditsu