योग

17

चलो (इनपुट)n=42

फिर भाजक हैं: 1, 2, 3, 6, 7, 14, 21, 42

प्रत्येक भाजक को चुकता करना: 1, 4, 9, 36, 49, 196, 441, 1764

योग लेना (जोड़ना): 2500

चूंकि 50×50=2500 हम एक सत्य मान लौटाते हैं। यदि यह एक पूर्ण वर्ग नहीं है, तो मिथ्या मान लौटाएं।

उदाहरण :

42  ---> true
1   ---> true
246 ---> true
10  ---> false
16  ---> false

यह प्रत्येक भाषा की जीत के लिए बाइट्स में कोड-गोल्फ इतना छोटा कोड है

अनुक्रम इंगित करने के लिए @Arnauld को धन्यवाद: A046655

code-golf  math  number  decision-problem 
— Any3nymous उपयोगकर्ता
स्रोत
2
यदि परिणाम सत्य है, और यदि परिणाम गलत है, तो क्या कोई अन्य प्रोग्राम आउटपुट 0 कर सकता है?
— जोशियान्वेन

जवाबों:

6

आर , 39 37 बाइट्स

!sum((y=1:(x=scan()))[!x%%y]^2)^.5%%1

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

क्लासिक "परीक्षण का उपयोग करता है अगर सही वर्ग" दृष्टिकोण, वर्गमूल के गैर-अभिन्न अंग को S^.5%%1लेने और इसके बारे में तार्किक नकार लेने के लिए, क्योंकि यह शून्य (पूर्ण वर्ग) से TRUEऔर नॉनजेरो से मैप करता है FALSE।

रॉबर्ट एस के लिए धन्यवाद बाइट्स के एक जोड़े को बचाने के लिए!

— ग्यूसेप
स्रोत
1
क्या आप scan()कुछ बाइट्स को बचाने के लिए उपयोग कर सकते हैं ?
— राबर्ट एस।
3
@RobertS। doh! मैं बहुत "वास्तविक" आर कोडिंग कर रहा हूँ हाल ही में!
— Giuseppe
6

जावास्क्रिप्ट (ईएस 7),  46 44  42 बाइट्स

@Hedi को 1 बाइट का धन्यवाद दिया

n=>!((g=d=>d&&d*d*!(n%d)+g(d-1))(n)**.5%1)

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

टिप्पणी की गई

n =>             // n = input
  !(             // we will eventually convert the result to a Boolean
    (g = d =>    // g is a recursive function taking the current divisor d
      d &&       //   if d is equal to 0, stop recursion 
      d * d      //   otherwise, compute d²
      * !(n % d) //   add it to the result if d is a divisor of n
      + g(d - 1) //   add the result of a recursive call with the next divisor
    )(n)         // initial call to g with d = n
    ** .5 % 1    // test whether the output of g is a perfect square
  )              // return true if it is or false otherwise
— Arnauld
स्रोत
1
आप के साथ एक बाइट बचा सकता dसे जा रहा nकरने के लिए 0के बजाय 2करने के लिए n: इस तरहn=>!((g=d=>d?d*d*!(n%d)+g(d-1):0)(n)**.5%1)
— Hedi
5

शेक्सपियर प्रोग्रामिंग लैंग्वेज , 434 428 415 बाइट्स

,.Ajax,.Ford,.Puck,.Act I:.Scene I:.[Enter Ajax and Ford]Ford:Listen tothy.Scene V:.Ajax:You be the sum ofyou a cat.Ford:Is the remainder of the quotient betweenyou I worse a cat?[Exit Ajax][Enter Puck]Ford:If soyou be the sum ofyou the square ofI.[Exit Puck][Enter Ajax]Ford:Be you nicer I?If solet usScene V.[Exit Ford][Enter Puck]Puck:Is the square ofthe square root ofI worse I?You zero.If notyou cat.Open heart

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

-13 बाइट्स जो किंग को धन्यवाद!

1सच्चे परिणाम के लिए आउटपुट , 0झूठे परिणाम के लिए आउटपुट ।

— JosiahRyanW
स्रोत
एक तीसरे चरित्र के साथ 415 बाइट्स
— जो किंग
3

ब्रेकीलॉग , 12 8 बाइट्स

f^₂ᵐ+~^₂

-4 बाइट्स के लिए धन्यवाद Fatelize कारण है कि मुझे पता ही नहीं चला कि ब्रैकलॉग के एक कारक कार्य हैं

व्याख्या

f^₂ᵐ+~^₂            #   full code
f                   #       get divisors
 ^₂ᵐ                #           square each one
    +               #       added together
      ~^₂           #       is the result of squaring a number

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

— Kroppeb
स्रोत
f^₂ᵐ4 बाइट्स की तुलना में कम हैḋ{⊇×^₂}ᵘ
— घातक
3

मठगोल्फ , 5 4 बाइट्स

─²Σ°

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

व्याख्या

─     Get all divisors as list (implicit input)
 ²    Square (implicit map)
  Σ   Sum
   °  Is perfect square?

अन्य जवाबों के समान, 05AB1E की तुलना में मैं अपने "पूर्ण वर्ग" ऑपरेटर के लिए एक बाइट प्राप्त करता हूं।

— maxb
स्रोत
तुम्हें पता है, "मैथॉल्फ" नामक कुछ चीज़ों में वास्तव में एक मानक ऑपरेटर होना चाहिए ... जो आपको 3 बाइट्स तक पहुंचा देगा :)
— मिशा लावरोव
@ मिशलारोव एक बुरा विचार नहीं है! अभी मेरे पास उतने वेक्टर ऑपरेशन नहीं हैं जितने मैं चाहूंगा, इन दिनों में से एक को मैं बदल
— दूंगा
2

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

param($n)1..$n|%{$a+=$_*$_*!($n%$_)};1..$a|?{$_*$_-eq$a}

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

लगता है लंबे ...
-12 बाइट्स mazzy के लिए धन्यवाद

जैसा नाम, वैसा काम। श्रेणी से 1इनपुट तक ले जाता है $nऔर वर्ग $_*$_समय को गुणा करता है चाहे वह विभाजक हो या न हो !($n%$_)। यह एक गैर-संख्या और गैर-भाजक के बराबर विभाजक को शून्य के बराबर बनाता है। हम फिर अपने संचयकर्ता के साथ उनका योग लेते हैं $a। इसके बाद, हम पाश फिर से 1अप करने के लिए $aऔर उसके अंकों को जहां बाहर खींच |?{...}यह चुकता है -eqकरने के लिए UAL$a । यह पाइपलाइन पर छोड़ दिया गया है और आउटपुट निहित है।

सत्य के लिए एक सकारात्मक पूर्णांक आउटपुट करता है, और फ़ासी के लिए कुछ भी नहीं।

— AdmBorkBork
स्रोत
दुर्लभ मामला जहां $args[0]कम है :)1..$args[0]|%{$a+=$_*$_*!($n%$_)};1..$a|?{$_*$_-eq$a}
— 19
1
@ माज़ज़ी यह नहीं है, क्योंकि आपको $nलूप के अंदर की ज़रूरत है !($n%$_)। लेकिन, योग के अपने पुनर्लेखन ने 12 बाइट्स बचाए, इसलिए धन्यवाद!
— AdmBorkBork
शर्म की बात है। इसलिए मैं एक ऐसा मामला खोजना चाहता हूं, जो $args[0]कम हो :)
— mazzy
2

जाप , ११ ९ apt बाइट्स

-2 बाइट्स @Giuseppe से और दूसरा -2 @ शागी से

â x²¬v1

â x²¬v1             Full program. Implicity input U
â                   get all integer divisors of U
  x²                square each element and sum
    ¬               square root result
     v1           return true if divisible by 1

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

— लुइस फेलिप डी जेउस मुनोज़
स्रोत
— झबरा
2

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

0=1|.5*⍨2+.*⍨∘∪⍳∨⊢

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

अनाम लम्बा। सत्य के लिए 1 रिटर्न और झूठी के लिए 0 (टीआईओ में परीक्षण के मामले पूर्व-निर्धारित हैं)।

4 बाइट्स के लिए @ H.PWiz को शाउट्स!

किस तरह:

0=1|.5*⍨2+.*⍨∘∪⍳∨⊢   ⍝ Main function, argument ⍵ → 42
                ∨⊢   ⍝ Greatest common divisor (∨) between ⍵ (⊢)
               ⍳      ⍝ and the range (⍳) [1..⍵]
              ∪      ⍝ Get the unique items (all the divisors of 42; 1 2 3 6 7 14 21 42)
             ∘        ⍝ Then
            ⍨         ⍝ Swap arguments of
        2+.*          ⍝ dot product (.) of sum (+) and power (*) between the list and 2 
                      ⍝ (sums the result of each element in the vector squared)
       ⍨              ⍝ Use the result vector as base
    .5*               ⍝ Take the square root
  1|                  ⍝ Modulo 1
0=                    ⍝ Equals 0
— जे। सल्ल
स्रोत
क्या आप बाइट को बचाने के notबजाय बराबर कर सकते हैं 0=?
— सड़क पर
@streetster दुर्भाग्य से, मैं 2 कारणों से नहीं कर सकता। सबसे पहले, एपीएल के notऑपरेटर ( ~), जब उपयोग किया जाता है, तो केवल मल के साथ काम करता है (या तो 0 या 1)। चूँकि कोई भी संख्या modulo 1 कभी भी 1 के बराबर नहीं होती है, अगर मैं ~इसके बजाय प्रयोग करता हूं, तो मुझे किसी भी संख्या पर एक पूर्ण वर्ग नहीं 0=मिलेगा domain error, क्योंकि दशमलव मान ~डोमेन से बाहर हैं । इसके अलावा, मैं बस को छोड़ नहीं सकता 0=, क्योंकि एपीएल का सत्य मूल्य 1 है, 0 नहीं है, और इसमें गलत मूल्यों के लिए एक सुसंगत आउटपुट नहीं होगा।
— जे। सेले
2

के (ओके) , 26 25 22 बाइट्स

समाधान:

{~1!%+/x*x*~1!x%:1+!x}

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

स्पष्टीकरण:

{~1!%+/x*x*~1!x%:1+!x} / the solution
{                    } / lambda taking x as input
                   !x  / range 0..x-1                        \
                 1+    / add 1                               |
              x%:      / x divided by and save result into x |
            1!         / modulo 1                            | get divisors
           ~           / not                                 |
         x*            / multiply by x                       /
       x*              / multiply by x (aka square)          > square
     +/                / sum up                              > sum up
    %                  / square root                         \  
  1!                   / modulo 1                            | check if a square
 ~                     / not                                 /

टिप्पणियाँ:

  • -1 बाइट्स पॉवरशेल समाधान से प्रेरणा लेते हुए
  • -3 बाइट्स एपीएल समाधान से प्रेरणा लेते हैं
— streetster
स्रोत
2

मतलाब, 39 37 बाइट्स

@(v)~mod(sqrt(sum(divisors(v).^2)),1)

दुर्भाग्य से, यह ऑक्टेव (टियो पर) पर काम नहीं करता है इसलिए कोई टियो लिंक नहीं है।

नोट @LuisMendo के अनुसार, divisors()प्रतीकात्मक टूलबॉक्स से संबंधित है।

— DimChtz
स्रोत
1
ऐसा लगता divisorsहै कि प्रतीकात्मक टूलबॉक्स से संबंधित है। आपको शीर्षक में यह बताना चाहिए। इसके अलावा, आप उपयोग कर सकते हैं ~···के बजाय···==0
— लुइस Mendo
sum(...)^.5इसके बजाय आप इसका उपयोग छोटा कर सकते हैंsqrt(sum(...))
— Sanchises
2

हास्केल , 78 64 53 बाइट्स

-14 बाइट्स थैंक्स टू अर्जन जोहान्सन । -11 बाइट्स ओव्स के लिए धन्यवाद ।

f x=sum[i^2|i<-[1..x],x`mod`i<1]`elem`map(^2)[1..x^2]

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

अरे, जब से मैंने ... कोई कोड लिखा है , तब से कुछ समय हो गया है , इसलिए मेरा हास्केल और गोल्फ थोड़ा रूखा हो सकता है। मैं परेशान हास्केल संख्यात्मक प्रकार भूल गया। : पी

— totallyhuman
स्रोत
1
किसी अन्य सूची समझ के साथ वर्गमूल की खोज करके उन रूपांतरणों से बचने के लिए यह छोटा (लेकिन धीमा) है। इसे ऑनलाइन आज़माएं!
— अर्जन जोहान्सन
1
छोटा: fx | s -sum [i ^ 2 | i <- [1..x], mod x i <1] = गोल (sqrt $ tonnum s) ^ 2 == s
— डेमियन
2
अर्जन जोहान्सन के सुझाव पर निर्माण, यह 53 बाइट्स के लिए काम करना चाहिए।
— अंडा
2

पाईट , 7 बाइट्स

ð²ƩĐř²∈

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

व्याख्या

            Implicit input
ð           Get list of divisors
 ²          Square each element
  Ʃ         Sum the list [n]
   Đ        Duplicate the top of the stack
    ř²      Push the first n square numbers
      ∈     Is n in the list of square numbers?
            Implicit output

ð²Ʃ√ĐƖ=

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

व्याख्या

            Implicit input
ð           Get list of divisors
 ²          Square each element
  Ʃ         Sum the list [n]
   √        Take the square root of n
    Đ       Duplicate the top of the stack
     Ɩ      Cast to an integer
      =     Are the top two elements on the stack equal to each other?
            Implicit output

ð²Ʃ√1%¬

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

व्याख्या

            Implicit input
ð           Get list of divisors
 ²          Square each element
  Ʃ         Sum the list [n]
   √        Take the square root of n
    1%      Take the square root of n modulo 1
      ¬     Negate [python typecasting ftw :)]
            Implicit output
— mudkip201
स्रोत
1

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

IntegerQ@Sqrt[2~DivisorSigma~#]&

शुद्ध कार्य। इनपुट और रिटर्न के रूप में Trueया Falseआउटपुट के रूप में एक संख्या लेता है । पूरी तरह से यकीन नहीं है अगर वहाँ सही वर्गों की जाँच के लिए एक छोटा तरीका है।

— LegionMammal978
स्रोत
1

एफ #, 111 बाइट्स

let d n=Seq.where(fun v->n%v=0){1..n}
let u n=
 let m=d n|>Seq.sumBy(fun x->x*x)
 d m|>Seq.exists(fun x->x*x=m)

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

तो d1 और nसमावेशी के बीच सभी संख्याओं के लिए भाजक प्राप्त करता है। मुख्य कार्य में u, पहली पंक्ति सभी वर्ग विभाजकों का योग बताती है m। दूसरी पंक्ति के लिए भाजक मिलता है mऔर यह निर्धारित करता है कि उनमें से कोई भी बराबर है m।

— Ciaran_McCarthy
स्रोत
1

पर्ल 5, 47 बाइट्स

$a+=$_*$_*!($n%$_)for 1..$n;$a=!($a**.5=~/\D/);

सत्य के लिए 1 लौटाता है और असत्य के लिए कुछ नहीं।

स्पष्टीकरण:

$a+=              for 1..$n;                      sum over i=1 to n
    $_*$_                                         square each component of the sum
         *!($n%$_)                                multiply by 1 if i divides n.
                            $a=                   a equals
                                ($a**.5           whether the square root of a
                               !       =~/\D/);   does not contain a non-digit.
— user591898
स्रोत
1

ग्रूवी , 47 बाइट्स

अंकीय तर्क को स्वीकार करने वाला एक लंबोदर।

n->s=(1..n).sum{i->n%i?0:i*i}
!(s%Math.sqrt(s))

व्याख्या

(1..n) 1 से n मानों की एक सरणी बनाता है

n%iगलत है (जैसा कि 0 मिथ्या है) यदि शेष के बिना iविभाजित nहो

n%i ? 0 : i*iमान के वर्ग का योग है iयदि यह nशेष के बिना विभाजित होता है, अन्यथा 0 है

sum{ i-> n%i ? 0 : i*i }iसरणी में सभी में पिछले परिणाम रकम ।

s%Math.sqrt(s)गलत है (जैसा कि 0 झूठी है) यदि शेष के बिना sविभाजन विभाजित हैs

!(s%Math.sqrt(s))लैम्बडा से रिटर्न ( returnपिछले स्टेटमेंट पर !falseअंकित ) जब शेष के बिना sविभाजित sहोता है

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

— archangel.mjj
स्रोत
1

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

n->{int s=0,i=0;for(;++i<=n;)s+=n%i<1?i*i:0;return Math.sqrt(s)%1==0;}

-5 बाइट्स के लिए धन्यवाद @ archangel.mjj ।

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

स्पष्टीकरण:

n->{             // Method with integer parameter and boolean return-type
  int s=0,       //  Sum-integer, starting at 0
      i=0;       //  Divisor integer, starting at 0
  for(;++i<=n;)  //  Loop `i` in the range [1, n]
    s+=n%i<1?    //   If `n` is divisible by `i`:
        i*i      //    Increase the sum by the square of `i`
       :         //   Else:
        0;       //    Leave the sum the same by adding 0
  return Math.sqrt(s)%1==0;}
                 //  Return whether the sum `s` is a perfect square
— केविन क्रूज़सेन
स्रोत
1
नमस्ते, आप टी चर को हटाकर 5 बाइट्स काट सकते हैं (लूप के लिए शरीर के भीतर ईवैल और असाइनमेंट करें), जैसे कि:n->{int s=0,i=0;for(;++i<=n;)s+=n%i<1?i*i:0;return Math.sqrt(s)%1==0;}
— archangel.mjj
@ archangel.mjj आह, बिल्कुल। यकीन नहीं होता कि मैं कैसे चूक गया। धन्यवाद! :)
— केविन क्रूज़सेन
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.