चुनौती

एक सकारात्मक पूर्णांक को देखते हुए, यह निर्धारित करें कि क्या यह एक त्रिकोणीय संख्या है, और तदनुसार किसी भी दो स्थिर, अलग-अलग मूल्यों में से एक आउटपुट।

परिभाषा

एक त्रिकोणीय संख्या एक संख्या है जिसे लगातार सकारात्मक पूर्णांक के योग के रूप में व्यक्त किया जा सकता है, 1 से शुरू। उन्हें सूत्र के साथ भी व्यक्त किया जा सकता है n(n + 1) / 2, जहां nकुछ सकारात्मक पूर्णांक है।

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

Truthy:

Falsy:

नियम

आपका प्रवेश एक समारोह या एक कार्यक्रम हो सकता है।
आप मान सकते हैं कि इनपुट 10 ^{6 के} तहत एक सकारात्मक पूर्णांक है ।
आपको दो श्रेणियों को अलग करने के लिए दो स्थिर, अलग-अलग आउटपुट लेने होंगे।

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

code-golf number decision-problem

— ETHproductions
स्रोत

1

संबंधित , संबंधित ।

— ETHproductions

संबंधित OEIS अनुक्रम

— १४'११

हास्केल , 23 बाइट्स

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

-1 बाइट: @xnor को कोष्ठक से छुटकारा मिला $।

अनाम फ़ंक्शन लेने Intऔर वापस लौटने में Char।

आउटपुट '1'त्रिकोणीय संख्याओं के लिए और '0'दूसरों के लिए है।

(!!)$show.(10^)=<<[0..]

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

के रूप में उपयोग करें ((!!)$show.(10^)=<<[0..]) 998991।
संख्या 1, 10, 100, 1000, ... उत्पन्न करता है, उन तारों को परिवर्तित करता है, और उन्हें समेटता है। फिर परिणामी अनंत स्ट्रिंग में अनुक्रमित करता है
```
"1101001000100001000001000000...
```

— अर्जन जोहान्सन
स्रोत

6

एक कल्पनाशील विधि! आप के साथ एक बाइट बचा सकते हैं (!!)$show.(10^)=<<[0..]।

— xnor

20

पायथन , 24 बाइट्स

lambda n:(8*n+1)**.5%1>0

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

बाकी के Falseलिए त्रिकोणीय संख्याओं के लिए आउटपुट True। जाँचता है कि 8*n+1क्या एक पूर्ण वर्ग है। पायथन सटीक वर्गों को पूर्णांक में ले जाएगा, चाहे कितना भी बड़ा क्यों न हो, फ्लोटिंग-पॉइंट समस्याएँ नहीं हैं।

— XNOR
स्रोत

3

(1<<10000)**.5: OverflowError: int बहुत बड़ी है जो फ्लोट में परिवर्तित होती है

— isaacg

@isaacg चुनौती को ऐसे इनपुट्स की आवश्यकता नहीं है जो बड़े हैं: "आप मान सकते हैं कि इनपुट 10 ^ 6 के तहत एक सकारात्मक पूर्णांक है"

— ट्राइकोप्लाक्स

1

@trichoplax मुझे लगता है कि मैं पाठ में xnor के दावे को विवादित कर रहा था। प्रस्तुत करना ठीक है, मैं सहमत हूं।

— इसहाक जुग

13

जेली , 4 बाइट्स

R+\ċ

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

कैसे?

R+\ċ - Main link: n
R    - range(n)   -> [1,2,3,...,N]
  \  - cumulative reduce by:
 +   -   addition -> [1,3,6,...,T(N)]
   ċ - count occurrences of right (n) in left -> 1 if triangular, 0 otherwise

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

मुझे आश्चर्य है कि संचयी कमी स्वचालित रूप से एक सीमा नहीं बनाती है। क्या इसके पीछे कोई डिज़ाइन विकल्प है?

— ETHproductions

मुझे 100% यकीन नहीं है, लेकिन मुझे लगता है कि यह (कम से कम वर्तमान में) डायडिक ऑपरेशन द्वारा कम करने की आवश्यकता होगी, जिससे एक सीमा बनाई जा सकेगी।

— जोनाथन एलन

... वास्तव में यह भी लागू नहीं होता है (जैसे यह बनाम यह । ऐसा लगता है कि क्विकलिंक कार्यान्वयन ओवरराइड होता है जैसे कि चलने योग्य एक सीमा नहीं बनाता है, भले ही डाइएडिक ऑपरेशन इसे एक तर्क के लिए ऐसा करने के लिए परिभाषित करता हो। पिंगड डेनिस को मैदान में लाने के लिए। यह एक :)

— जोनाथन एलन

@ETHproductions /और \संभवतः कार्यान्वित किए जाने वाले पहले पांच क्विक में से थे, जो पूर्णांक तर्कों को श्रेणी में लाने के लिए विचार प्रस्तुत करते हैं।

— डेनिस

13

रेटिना , 10 बाइट्स

(^1|1\1)+$

इनपुट एकतरफा है। आउटपुट 0या है 1।

इसे ऑनलाइन आज़माएं! (परीक्षण सूट के रूप में जो सुविधा के लिए दशमलव-से-एकात्मक रूपांतरण करता है।)

व्याख्या

फॉरवर्ड-रेफरेंस में यह सबसे बुनियादी अभ्यास है। अधिकांश लोग रेगेक्स में बैकरेफरेंस से परिचित हैं, उदाहरण के (.)\1लिए एक दोहराया चरित्र से मेल खाते हैं। हालाँकि, कुछ अधिक उन्नत फ़्लेवर आपको उस समूह के पहले या अंदर बैकरेक्शन का उपयोग करने की अनुमति देते हैं जिसका वह उल्लेख कर रहा है। उस मामले में, इसे आमतौर पर एक अग्रेषण-संदर्भ कहा जाता है। यदि संदर्भ दोहराया जाता है तो यह समझ में आ सकता है। इसे पहले पुनरावृत्ति पर अच्छी तरह से परिभाषित नहीं किया जा सकता है, लेकिन बाद के पुनरावृत्तियों पर, बाद में या आसपास के समूह ने कुछ पर कब्जा कर लिया है और इसका पुन: उपयोग किया जा सकता है।

यह आमतौर पर एकतरफा तारों पर आवर्तक पैटर्न को लागू करने के लिए उपयोग किया जाता है। इस स्थिति में, हम लगातार पूर्णांक के योग के रूप में इनपुट से मिलान करने का प्रयास करते हैं:

(        # This is group 1, which we'll repeat 1 or more times.
  ^1     #   Group 1 either matches a single 1 at the beginning of the string.
|        # or
  1\1    #   It matches whatever the previous iteration matched, plus another
         #   1, thereby incrementing our counter.
         # Note that the first alternative only works on the first iteration
         # due to the anchor, and the second alternative only works *after*
         # the first iteration, because only then the reference is valid.
)+
$        # Finally, we make sure that we can exactly hit the end of the
         # string with this process.

— मार्टिन एंडर
स्रोत

1

(^|1\1)+$काम क्यों नहीं करता?

— लीक नून

3

@ LeakyNun regex इंजन का एक अनुकूलन है कि वे एक समूह को दोहराना बंद कर देते हैं यदि यह खाली n समय है जहां n आपके द्वारा उपयोग किए जा रहे क्वांटिफायर का न्यूनतम है (आपके मामले में 1; यदि न्यूनतम 0 था, तो इसे किसी भी समय एक बार आज़माया जाएगा) । आप को बदलते हैं +करने के लिए {2,}है, यह काम करना चाहिए। यह अनुकूलन अनंत छोरों को रोकता है, लेकिन यह केवल एक चीज है जो .NET regex को अपने आप में ट्यूरिंग-पूर्ण होने से रोकता है।

— मार्टिन एंडर

यह बस मुझे 70 बाइट्स बचाए

— नील

धन्यवाद करने के लिए कि 74 बाइट्स बनाओ \G!

— नील

8

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

जाँचता है कि ( 8x + 1 ) एक वर्ग संख्या है।

lambda x:(8*x+1)**.5%1==0

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

— अदनान
स्रोत

8

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

OddQ@Sqrt[1+8#]&

अनिवार्य रूप से xnor के पायथन समाधान का एक बंदरगाह । Trueत्रिकोणीय संख्याओं के लिए आउटपुट , Falseअन्यथा।

— ngenisis
स्रोत

7

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

सहेजे गए 2 बाइट्स kamoroso94 के लिए धन्यवाद

f=(n,k)=>n>0?f(n+~k,-~k):!n

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

कोड स्निपेट दिखाएं

f=(n,k)=>n>0?f(n+~k,-~k):!n

console.log('Testing truthy test cases');
console.log(f(1))
console.log(f(3))
console.log(f(6))
console.log(f(10))
console.log(f(15))
console.log(f(21))
console.log(f(55))
console.log(f(276))
console.log(f(1540))
console.log(f(2701))
console.log(f(5050))
console.log(f(7626))
console.log(f(18915))
console.log(f(71253))
console.log(f(173166))
console.log(f(222111))
console.log(f(303031))
console.log(f(307720))
console.log(f(500500))
console.log(f(998991))

console.log('Testing falsy test cases');
console.log(f(2))
console.log(f(4))
console.log(f(5))
console.log(f(7))
console.log(f(8))
console.log(f(9))
console.log(f(11))
console.log(f(16))
console.log(f(32))
console.log(f(50))
console.log(f(290))
console.log(f(555))
console.log(f(4576))
console.log(f(31988))
console.log(f(187394))
console.log(f(501500))
console.log(f(999999))

Expand snippet

गैर-पुनरावर्ती संस्करण (ES7), 19 बाइट्स

अदनान के जवाब का पोर्ट ।

x=>(8*x+1)**.5%1==0

— Arnauld
स्रोत

केवल अब यह देखकर कि आपने मेरा पोस्ट करने से कुछ मिनट पहले ही 19 बाइट समाधान आपके उत्तर में संपादित कर दिए । क्या मुझे अपना हटाना चाहिए? उस पर आम तौर पर स्वीकृत शिष्टाचार क्या है?

— झबरा

1

@ मुझे लगता है कि यह यहाँ एक वास्तविक समस्या नहीं है। मेरा 'मुख्य' उत्तर वास्तव में पुनरावर्ती है।

— अरनौलड

28 बाइट्स के साथ कम करें f=(n,k=1)=>n>0?f(n-k,k+1):!n?

— kamoroso94

1

@ kamoroso94 धन्यवाद! अपडेट किया गया। और तीसरे बाइट को आरंभीकरण को छोड़ कर बचा लिया गया था k।

— अरनौलद

शुरू- undefinedमूल्य के लिए एक इंक्रीमेंटर के रूप में बिटवाइज़ का सुरुचिपूर्ण उपयोग नहीं ; आपके द्वारा मेरे पूर्व समाधान पर स्वतंत्र रूप से आने के बाद आपके संपादन को पढ़ने में खुशी हुई।

— अप्सराएँ

6

सीजेएम , 11 बाइट्स

ri2*_mQ_)*=

1त्रिकोणीय के लिए आउटपुट , 0अन्यथा।

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

व्याख्या

इनपुट पर विचार करें 21।

ri               e# Input integer.             STACK: 21
  2*             e# Multiply by 2.             STACK: 42
    _            e# Duplicate.                 STACK: 42, 42
     mQ          e# Integer square root.       STACK: 42, 6
       _)        e# Duplicate, increment.      STACK: 42, 6, 7
         *       e# Multiply.                  STACK: 42, 42
          =      e# Equal?                     STACK: 1

— लुइस मेंडो
स्रोत

6

ब्रेन-फ्लैक , 40 बाइट्स

(([{}](((()))<>))<>){<>({}({}({})))}{}{}

गेहूं के जादूगर और मेरे पास इस सवाल पर एक विवाद था । जब हमने अपने समाधानों को पोस्ट करने का फैसला किया तो हम 42 बाइट्स में बंधे थे, लेकिन मुझे उनके समाधान का एक 2 बाइट गोल्फ मिला। हमने तय किया कि टाई ब्रेकर के रूप में गिना जाएगा (मेरा समाधान नीचे है)।

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

स्पष्टीकरण:

# Set up the stacks like this:  -input
                                     1     -input
                                     1          1
(([{}](((()))<>))<>)                 ^

# Output 1 for triangular and 0 for non-triangular 
{<>({}({}({})))}{}{}

पूर्ण विवरण के लिए कृपया गेहूं के जादूगर का उत्तर देखें ।

ब्रेन-फ्लैक , 42 बाइट्स

(([({})])<>){(({}())<>{}({})){((<>))}{}{}}

सत्य के लिए आउटपुट 0\n(शाब्दिक न्यूलाइन), और मिथ्या के लिए रिक्त स्ट्रिंग।

इस विचार को 1 तब 2 और फिर 3 को इनपुट तक लाना है। यदि आप 0 हिट करते हैं, तो आप जानते हैं कि यह एक त्रिकोणीय संख्या है, इसलिए आप वहां रुक सकते हैं।

इसे ऑनलाइन आज़माएं! (सच्चाई)
इसे ऑनलाइन आज़माएं! (falsy)

# Push -input on both stacks. One is a counter and the other is a running total
(([({})])<>)

# Count up from -input to 0
{
  # Push the new total which is: (counter += 1) + total (popped) + input (not popped)
  # This effectively adds 1, then 2, then 3 and so on to the running total
  (({}())<>{}({}))
  # If not 0
  {
    # Push to 0s and switch stacks to "protect" the other values
    ((<>))
  # End if
  }
  # Pop the two 0s, or empty the stack if we hit 0
  {}{}
# End loop
}

यहाँ एक 46 बाइट समाधान है जो मुझे दिलचस्प लगा।

{<>(({}())){({}[()]<>{(<({}[()])>)}{}<>)}{}<>}

सत्य के लिए आउटपुट 0\n(शाब्दिक न्यूलाइन), मिथ्या के लिए रिक्त स्ट्रिंग।

विचार एक समय में लगातार संख्याओं, 1 द्वारा इनपुट से नीचे की गणना करना है। जैसे input - (1) - (1,1) - (1,1,1)। हर बार हम घटाते हैं, अगर हम 0 पर नहीं हैं, तो हम स्टैक पर एक अतिरिक्त मूल्य छोड़ते हैं। इस तरह, अगर हम 0 पर हैं और अभी भी घट रहे हैं जब हम पॉप करते हैं तो हम स्टैक पर अंतिम मान निकालते हैं। यदि इनपुट एक त्रिकोणीय संख्या थी, तो हम बिल्कुल 0 पर समाप्त हो जाएंगे, और 0 को पॉप नहीं करेंगे।

इसे ऑनलाइन आज़माएं! सच्चाई
यह ऑनलाइन की कोशिश करो! falsy

# Implicit input (call it I)

# Until we reach 0, or the stack is empty
{
  # Add 1 to the other stack and push it twice. This is our counter.
  <>(({}()))
  # While counter != 0
  {
    # counter -= 1
    ({}[()]
    # if I != 0 
    <>{
      # I -= 1, and push 0 to escape the if
      (<({}[()])>)
    # End if
    }
    # Pop from the stack with I. This is either the 0 from the if, or I
    {}
    # Get ready for next loop End while
    <>)
  # End While
  }
  # Pop the counter that we were subtracting from
  {}<>
# End Until we reach 0, or the stack is empty.
}

— रिले
स्रोत

6

जेली , 5 बाइट्स

×8‘Æ²

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

पृष्ठभूमि

N इनपुट होने दें । यदि n है कश्मीर ^वें त्रिकोणीय संख्या, हमारे पास है

n = \frac{कश्मीर (कश्मीर + 1)}{2} ⟺ {कश्मीर}^{2} + कश्मीर - 2 n = 0 ⟺ कश्मीर = \frac{1}{2} (- 1 \pm \sqrt{1 + 8 n}),

$n = \frac{k(k+1)}{2} \iff k^2+k-2n = 0 \iff k = \frac12 (-1 \pm \sqrt{1+8n}),$

जिसका अर्थ है कि अगर और केवल 1 + 8n एक विषम, पूर्ण वर्ग है तो एक प्राकृतिक समाधान होगा । स्पष्ट रूप से, 1 + 8n की समता की जाँच की आवश्यकता नहीं है।

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

×8‘Æ²  Main link. Argument: n

×8     Yield 8n.
  ‘    Increment, yielding 8n + 1.
   Æ²  Test if the result is a perfect square.

— डेनिस
स्रोत

5

पॉवरशेल , 31 30 बाइट्स

"$args"-in(1..1e6|%{($s+=$_)})

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

अच्छा और धीमी गति बल विधि। 10 ^{6 के} माध्यम से 1 के प्रत्येक योग की एक सरणी बनाएं , और देखें कि क्या तर्क वहां है।

— briantist
स्रोत

5

ब्रेन-फ्लैक , 42 बाइट्स

(([{}](<((())<>)>))<>){<>({}({}({})))}{}{}

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

व्याख्या

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

यहां हम दो ढेर बनाते हैं जो इनपुट से लगातार संख्या घटाते हैं और एक जो बस एक को घटाता है। वह जो लगातार संख्याओं को घटाता है वह केवल तभी समाप्त होगा जब संख्या त्रिकोणीय है, (अन्य बुद्धिमान यह सिर्फ शून्य पास करेगा और नकारात्मक में जाता रहेगा)। दूसरा हमेशा किसी भी सकारात्मक संख्या के लिए समाप्त होगा, लेकिन हमेशा पहले की तुलना में इतना धीमा काम करेगा, इस प्रकार गैर-त्रिकोणीय संख्या उस ढेर पर समाप्त हो जाएगी।

तो हम ढेर कैसे सेट करते हैं ताकि एक ही ऑपरेशन एक पर लगातार संख्या घटाए और दूसरे पर एक घटाए? प्रत्येक स्टैक पर हमारे पास शीर्ष पर इनपुट होता है, ताकि जाँच की जा सके, कि नीचे हमारे पास अंतर है और नीचे हमारे पास अंतर का अंतर है। जितनी बार हम चलाते हैं, हम "अंतर के अंतर" को नियमित "अंतर" में जोड़ते हैं और इनपुट से घटाते हैं। त्रिभुजाकारता के लिए जाँच करने वाले स्टैक के लिए हम अपना दोहरा अंतर निर्धारित करते हैं 1ताकि हम हर बार चलाते समय लगातार पूर्णांक प्राप्त करें, दूसरे स्टैक के लिए हम इसे सेट करते हैं 0ताकि हम कभी भी अंतर को न बदलें, यही है कि यह हमेशा 1. रहता है। स्टैक को शुरुआत में कैसे सेट किया जाता nहै, इनपुट कहां है:

-n  -n
 0   1
 1   0

जब हम अंत में समाप्त करते हैं, तो हम इन अंतरों का उपयोग करके यह जांच सकते हैं कि हम किस स्टैक पर हैं, हम शीर्ष दो मूल्यों को पॉप करते हैं और हम 1एक त्रिकोणीय संख्या के लिए और 0एक गैर-त्रिकोणीय संख्या के लिए प्राप्त करते हैं।

एनोटेट कोड

(([{}](<((())<>)>))<>) Set up the stack
{                      While
 <>                    Switch stacks
 ({}({}({})))          Add bottom to second to bottom, add second to bottom to top
}                      End while
{}{}                   Pop the top two values

यहाँ एक 50 बाइट समाधान है जो मुझे पसंद है।

{(({}[()]))}(([[]])<>){({}{}())<>}({}{()<><{}>}{})

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

— गेहूं का जादूगर
स्रोत

5

क्यूबिक्स , 23 24 25 बाइट्स

I1Wq/)s.;0..s;p-?\.+O@u

सत्य के लिए ० और मिथ्या के लिए कुछ नहीं । काउंटर को बढ़ाकर, संचयी योग में जोड़कर और इनपुट की तुलना करके सेनाएं लाता है। ~~अब कोशिश करें और इसे 2x2x2 क्यूब पर फिट करें।~~ ने करदी!

    I 1
    W q
/ ) s . ; 0 . .
s ; p - ? \ . +
    O @
    u .

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

/ सामना करने के लिए प्रतिबिंबित।
I10\ पूर्णांक इनपुट प्राप्त करें, 1 (काउंटर), पुश 0 (योग) और प्रतिबिंबित करें
+s;p-पाश शरीर। योग और काउंटर जोड़ें, पिछली राशि छोड़ें, इनपुट बढ़ाएं और घटाएं
? घटाव के परिणाम का परीक्षण करें
- 0 परिणाम को सीधे आगे ले जाने के \.uO@लिए नीचे के चेहरे, नो-ऑप, यू-टर्न, आउटपुट और पड़ाव को दर्शाते हैं।
- सकारात्मक परिणाम के लिए, नीचे के चेहरे और @पड़ाव पर दाएं मुड़ें
- नेगेटिव रिजल्ट टर्न के लिए लेफ्ट ;qWs)/suड्रॉप घटाव, नीचे से इनपुट डालें, लेफ्ट, स्वैप काउंटर और योग, इंक्रीमेंट काउंटर, रिफ्लेक्ट, स्वैप योग और काउंटर, मुख्य लूप बॉडी पर यू-टर्न।

— MickyT
स्रोत

इतने तांत्रिक रूप से करीब ... कि आखिरी बाइट हालांकि बहुत प्रयास और चतुराई से करने वाली है।

— ETHproductions

हां, मुझे लगा कि मेरे पास है लेकिन मायावी हो रहा है

— मिकी

1

@ETHproductions को बाइट मिली

— मिकी

आपका कोड और आपका सामने आया क्यूब अलग प्रतीत होता है, निचला दायां कोना .क्यूब पर होता है लेकिन 1आपके कोड में होता है।

— गेहूं जादूगर

@WheatWizard इसके लिए धन्यवाद, मेरी ओर से बुरा संपादन

— मिकट

4

05AB1E , 7 6 बाइट्स

संपादित करें : @Dennis के लिए धन्यवाद: एक बाइट को बचाया क्योंकि मैं वेतन वृद्धि ऑपरेटर के बारे में भूल गया था

8*>t.ï

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

nsqrt(8n + 1)पूर्णांक है तो त्रिकोणीय

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

8* # multiply implicit input by 8
  > # add one
   t # sqrt
    .ï # is integer

— नील ए।
स्रोत

संभवत: उस समय अभी तक उपलब्ध नहीं था, लेकिन ये दिन t.ïहो सकते हैं Å², जो एक संख्या एक वर्ग है, यह जांचने के लिए एक अंतर्निहित है।

— केविन क्रूज़सेन

4

पर्ल 6 , 17 बाइट्स

{$_∈[\+] 1..$_}

बस यह जांचता है कि क्या $_, फ़ंक्शन के लिए इनपुट त्रिकोणीय जोड़ में कमी के किसी भी तत्व के बराबर है (1, 1+2, ..., 1+2+...+$_)।

— शॉन
स्रोत

4

ऐलिस , 38 22 बाइट्स

बहुत सारे बाइट्स ने मार्टिन और लियो को धन्यवाद दिया

/ i \ 2 * .2RE.h * -n / o @

एक अनुगामी न्यूलाइन है। 1त्रिकोणीय के लिए आउटपुट , 0अन्यथा।

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

व्याख्या

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

i2*.2RE.h*-no@

जहां iऔर oवास्तव में क्रमिक मोड में हैं।

21उदाहरण के रूप में इनपुट पर विचार करें ।

i         Input integer                       STACK: 21
2*        Multiply by 2                       STACK: 42
.         Duplicate                           STACK: 42, 42
2RE       Integer square root                 STACK: 42, 6
.         Duplicate                           STACK: 42, 6, 6
h         Increment                           STACK: 42, 6, 7
*         Multiply                            STACK: 42, 42
-         Subtract                            STACK: 0
n         Logical negation                    STACK: 1
o         Output integer                      STACK:
@         End program

— लुइस मेंडो
स्रोत

मेरा पहला ऐलिस जवाब

— लुइस मेंडो

1

मुझे लगता है कि यह मार्टिन की फैंसी नियंत्रण संरचनाओं में से एक के साथ लगभग आधा हो सकता है ...

— ETHproductions

तो क्या मैं ... :-)

— लुइस मेंडो

मेरा पहला ऐलिस गोल्फ: एक ही कोड, 23 बाइट्स

— नाइट्रोडोन

कार्यक्रम के इस प्रकार के लिए एक अधिक "मानक" लेआउट होगा इस । उस ने कहा, आप स्टैक पर 1 से छुटकारा पा सकते हैं, और बस घटाव के तार्किक निषेध का उत्पादन कर सकते हैं (यानी ...h*-no@)

— लियो

4

जाप , 10 7 बाइट्स

सहेजे गए 3 बाइट्स @Luke और @ETHproductions के लिए धन्यवाद

*8Ä ¬v1

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

स्पष्टीकरण:

*8Ä ¬v1
    ¬    // Square root of:
*8       //   Input * 8
  Ä      //   +1
     v1  // Return 1 if divisible by 1; Else, return 0

õ å+ øU

स्पष्टीकरण:

õ å+ øU
õ           // Create a range from [1...Input]
  å+        // Cumulative reduce by addition
     øU     // Does it contain the input?

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

— ओलिवर
स्रोत

सवाल दो निरंतर विशिष्ट ouputs के लिए पूछता है।

— xnor

*8Ä ¬u1 c9 बी के लिए (आउटपुट 0 अगर इनपुट त्रिकोणीय है, तो 1)

— ल्यूक

@Luke आप को बदल सकता है u1 cके लिए v1, मेरा मानना है कि (आउटपुट स्विचिंग)

— ETHproductions

7 बाइट्स? अच्छा! किसी तरह यह मेरी याद करते हुए पोस्ट किया, इसी तरह के समाधान देर से पिछले हो सकता है। अगर आप मुझे इसे हटाना चाहते हैं तो मुझे बताएं।

— झबरा

4

आर , २३ 19 बाइट्स

अन्य उत्तरों के समान दृष्टिकोण। यह देखने के लिए जाँच करता है कि क्या 8x+1एक पूर्ण वर्ग है।
-4 बाइट्स धन्यवाद ग्यूसेप और मिकी।

!(8*scan()+1)^.5%%1

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

— रॉबर्ट एस।
स्रोत

2

आप के !बजाय का उपयोग कर सकते हैं==0

— Giuseppe

यह वेक्टर होने के बाद से अतिरिक्त अच्छा है!

— ग्यूसेप

1

मुझे लगता है कि आप बाहरी कोष्ठकों से भी छुटकारा पा सकते हैं!(8*scan()+1)^.5%%1

— मिकी

3

MATL , 5 बाइट्स

t:Ysm

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

स्पष्टीकरण:

t       % Duplicate input
 :      % Range(1, input)
  Ys    % Cumulative sum. This will push the first *n* triangular numbers
    m   % ismember. Pushes true if the input is contained within the array we just pushed

— DJMcMayhem
स्रोत

मैं पोस्ट करने जा रहा था t:Ys=a। m:-)

— लुइस मेंडो

1

@LuisMendo mजब तक मैं इस जवाब को नहीं देख पाया, तब तक मैं इसके बारे में नहीं जानता था । डी: अजीब बात है कि कैसे दो जवाब लगभग समान हैं

— DJMcMayhem

3

बैच, 72 बाइट्स

@set/aj=i=0
:l
@if %1% gtr %j% set/aj+=i+=1&goto l
@if %1==%j% echo 1

सफलता पर आउटपुट 1, असफलता पर कुछ भी नहीं। शून्य के लिए भी काम करता है, हालांकि किसी कारण से प्रश्न का अनुरोध नहीं किया गया है।

— नील
स्रोत

3

जावास्क्रिप्ट (ईएस 7), 19 18 बाइट्स

से मेरा उत्तर एक करने के लिए संबंधित सवाल ।

falseत्रिकोणीय संख्याओं के लिए या trueगैर-त्रिकोणीय के लिए आउटपुट , जैसा कि ओपी द्वारा अनुमति है।

n=>(8*n+1)**.5%1>0

कोशिश करो

f=
n=>(8*n+1)**.5%1>0
oninput=_=>o.innerText=f(+i.value)

<input id=i type=number><pre id=o>

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

— झबरा
स्रोत

मुझे लगता है कि आप एक बाइट को बचा सकते हैं n=>(8*n+1)**.5%1>0(जो आउटपुट को उल्टा कर देगा)

— ETHproductions

@ETHproductions: ठीक है, जब तक आप इसकी अनुमति दे रहे हैं। क्या ऐसा करना आम तौर पर अनुमति है, हालांकि?

— झबरा

1

यह "दो स्थिर, अलग आउटपुट" के रूप में योग्य है, इसलिए हाँ। अन्य निर्णय-समस्या चुनौतियों के लिए सत्य / मिथ्या की आवश्यकता हो सकती है।

— ETHproductions

3

PHP, 30 बाइट्स

सत्य के लिए प्रिंट 1 और असत्य के लिए कुछ भी नहीं

<?=fmod(sqrt(8*$argn+1),2)==1;

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

fmod

PHP, 37 बाइट्स

सत्य के लिए प्रिंट 1 और असत्य के लिए कुछ भी नहीं

<?=($x=sqrt($q=2*$argn)^0)*$x+$x==$q;

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

— जार्ग हुल्सरमन
स्रोत

3

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

!Accumulate@Range@#~FreeQ~#&

— J42161217
स्रोत

मैं 7!द्वारा प्रतिस्थापित करने की सलाह देता हूं #। पहले, यह छोटा है; इससे भी महत्वपूर्ण बात, वर्तमान समाधान सही नहीं है, क्योंकि यह कृत्रिम रूप से उस इनपुट के आकार पर एक सीमा लगाता है जिस पर वह काम करता है।

— ग्रेग मार्टिन

1

ओपी कहते हैं: "आप मान सकते हैं कि इनपुट 10 ^ 6 के तहत एक सकारात्मक पूर्णांक है"। लेकिन मुझे आपका विचार पसंद है और मैं इसे ले जाऊंगा, हालांकि मेरा हर मामले के लिए 5040 तत्वों की सूची का उपयोग करके सही परिणाम देता है लेकिन आपका सबसे खराब मामला है 999999 तत्वों की सूची की आवश्यकता है। टिप के लिए धन्यवाद!

— J42161217

1

ओफ़ सॉरी, ओपी की टिप्पणी नहीं देखी! हां, कोड गोल्फिंग में कुछ "विकृत" प्रोत्साहन हैं: 1-बाइट बचत दुनिया की सभी दक्षता की तुलना में कोड-गोल्फ प्रश्न में अधिक महत्वपूर्ण है :)

— ग्रेग मार्टिन

3

परी / जीपी , 18 बाइट्स

n->issquare(8*n+1)

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

यदि कोई संख्या बहुभुज संख्या है, तो परीक्षण करने के लिए एक अंतर्निहित है, लेकिन यह एक बाइट लंबी है।

परी / जीपी , 19 बाइट्स

n->ispolygonal(n,3)

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

— alephalpha
स्रोत

3

एक्सेल, ३१ 22 बाइट्स

9 बाइट्स ने ऑक्टोपस को धन्यवाद दिया

TRUEत्रिकोणीय संख्याओं के लिए आउटपुट । एल्स FALSE। जाँचता है कि 8*n+1क्या एक पूर्ण वर्ग है।

=MOD(SQRT(8*B1+1),1)=0

— Wernisch
स्रोत

1

=MOD(SQRT(8*A1+1),1)=0कुछ बाइट्स बचाता है

— ऑक्टोपस

2

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

≥ℕ⟦+?

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

व्याख्या

≥ℕ⟦+?
≥ℕ     There is a number from 0 to {the input} inclusive
  ⟦    such that the range from 0 to that number
   +   has a sum
    ?  that equals the input

2

फूरियर , 26 बाइट्स

I~X1(&N^*N/2{X}{1~O}N=X)Oo

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

— बीटा डिके
स्रोत

2

पायथन - 52 बाइट्स

नोट: मुझे पता है कि अन्य दो पायथन उत्तर बहुत कम हैं, लेकिन यह पुराने-स्कूल का तरीका है, एक हाथ से एल्गोरिथ्म का अधिक

n=input();i=s=0
while s<n:s=(i*i+i)/2;i+=1
print s>n

— मिस्टर एक्सकोडर
स्रोत

2

एपीएल (डायलॉग) , 6 बाइट्स

⊢∊+\∘⍳

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

व्याख्या

⊢∊+\∘⍳
      ⍳                 Creates a range from 1 to the right_argument
  +\                    Cumulative sum of this range; 1 1+2 1+2+3 .. 1+2+..+n. These are the triangular numbers
⊢∊                      Does the right argument belong to this list of integers in this cumulative sum

0असत्य के लिए और 1सत्य के लिए आउटपुट ।

— क्रिकटी लिथोस
स्रोत

2

टीआई-बेसिक, 10 7 बाइट्स

-3 @lirtosiast को धन्यवाद

:not(fPart(√(8Ans+1

पर इनपुट लेता है X। जाँचता है कि √(8X+1)क्या पूरी संख्या है

— स्कॉट मिलनर
स्रोत

क्यों नहीं not(fPart(√(8Ans+1?

— lirtosiast

@lirtosiast यह काम करेंगे, धन्यवाद!

— स्कॉट मिलनर

क्या यह संख्या त्रिकोणीय है?

चुनौती

परिभाषा

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

नियम

हास्केल , 23 बाइट्स

पायथन , 24 बाइट्स

जेली , 4 बाइट्स

कैसे?

रेटिना , 10 बाइट्स

व्याख्या

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

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

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

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

गैर-पुनरावर्ती संस्करण (ES7), 19 बाइट्स

सीजेएम , 11 बाइट्स

व्याख्या

ब्रेन-फ्लैक , 40 बाइट्स

स्पष्टीकरण:

ब्रेन-फ्लैक , 42 बाइट्स

यहाँ एक 46 बाइट समाधान है जो मुझे दिलचस्प लगा।

जेली , 5 बाइट्स

पृष्ठभूमि

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

पॉवरशेल , 31 30 बाइट्स

ब्रेन-फ्लैक , 42 बाइट्स

व्याख्या

एनोटेट कोड

क्यूबिक्स , 23 24 25 बाइट्स

05AB1E , 7 6 बाइट्स

पर्ल 6 , 17 बाइट्स

ऐलिस , 38 22 बाइट्स

व्याख्या

जाप , 10 7 बाइट्स

स्पष्टीकरण:

स्पष्टीकरण:

आर , २३ 19 बाइट्स

MATL , 5 बाइट्स

बैच, 72 बाइट्स

जावास्क्रिप्ट (ईएस 7), 19 18 बाइट्स

कोशिश करो

PHP, 30 बाइट्स

PHP, 37 बाइट्स

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

परी / जीपी , 18 बाइट्स

परी / जीपी , 19 बाइट्स

एक्सेल, ३१ 22 बाइट्स

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

व्याख्या

फूरियर , 26 बाइट्स

पायथन - 52 बाइट्स

एपीएल (डायलॉग) , 6 बाइट्स

व्याख्या

टीआई-बेसिक, 10 7 बाइट्स