उत्तर -चेनिंग - किसी संख्या का सकारात्मक विभाजक


13

यह पीछा करने की चुनौती आधिकारिक तौर पर खत्म हो गई है, जिसके परिणामस्वरूप कुल 7 उत्तरों के साथ गेहूं जादूगर की जीत हुई है। किसी भी अन्य उत्तर का स्वागत है, लेकिन यह इस चुनौती के लिए स्वीकृत उत्तर को प्रभावित नहीं करेगा, न ही विजेता।


कार्य:

xइनपुट के रूप में लिए गए किसी संख्या के सभी सकारात्मक विभाजनों को प्रिंट करें ।

इनपुट:

एक एकल संख्या xजो संख्या (आधार 10 में) है जिसका सकारात्मक विभाजक गणना की जानी चाहिए।

आउटपुट:

सभी के सकारात्मक divisors x। किसी भी प्रारूप सहित, की अनुमति दी है \n, ,, ;और विभाजक के रूप में खाली स्थान के, जब तक यह समझ में आता है के रूप में। आउटपुट इंटेगर या स्ट्रिंग्स का एक सरणी हो सकता है, भी (जैसे:) [1, 2, 3, 5, 30]। आप अपनी भाषा में डिवडर्स को स्टडआउट, कंसोल या समकक्ष के लिए आउटपुट कर सकते हैं या उन्हें किसी फ़ंक्शन से वापस किया जा सकता है


नियम

  • एक उपयोगकर्ता लगातार दो बार जवाब नहीं दे सकता है
  • आपका उत्तर पिछले उत्तर (व्हाट्सएप की गिनती नहीं करता है) से अधिक से अधिक 15 पात्रों को हटा, जोड़ या बदल सकता है , इसके अलावा उत्तर 2 के लिए जो चीजों को शुरू करने के लिए 20 वर्णों तक "रूपांतरित" कर सकता है।
  • आपको एक प्रोग्रामिंग भाषा में एक उत्तर पोस्ट करने की अनुमति नहीं है जिसमें पहले से ही एक उत्तर है, अपवाद उस भाषा का पूरी तरह से अलग संस्करण है (जैसे: यदि मैं एक उत्तर पोस्ट करता हूं Python 2.7, तो आप एक को सबमिट कर सकते हैं Python 3, लेकिन नहीं Python 2.6)
  • मानक खामियों की अनुमति नहीं है
  • आपको इस चुनौती के लिए, विभाजकों को प्राप्त करने के लिए बिल्ट-इन का उपयोग करने की अनुमति नहीं है
  • आपको प्रश्न के शीर्षक में उत्तर की संख्या और भाषा का नाम शामिल होना चाहिए और पिछले उत्तर से बदले गए वर्णों की संख्या

स्कोरिंग

सबसे अधिक सबमिशन वाला उपयोगकर्ता एक बार चीजें जीत जाता है। एक टाई के मामले में, उपयोगकर्ता अपने उत्तर में से एक पर उच्चतम स्कोर के साथ जीतता है। यदि स्कोर पर भी एक टाई है, तो सबसे पुराना सबमिशन (सबसे पुराना सबसे बड़ा जवाब) वाला उपयोगकर्ता विजेता घोषित किया जाएगा।

नोट: अंतिम उत्तर प्रस्तुत किए जाने के बाद "निपटारा" <=> 7 3 दिन बीत चुके हैं


उदाहरण:

Input, Output:

14 => [1, 2, 7, 14]
25 => [1, 5, 25]
65 => [1, 5, 13, 65]
114 => [1, 2, 3, 6, 19, 38, 57, 114]

या किसी भी अन्य समकक्ष आउटपुट उल्लेखित स्थितियों को संतुष्ट करता है।


अंतिम नोट : यह प्रश्न बेहतर है यदि आप सबसे पुराने उत्तर को हल करते हैं। मैं पहला उत्तर पायथॉन 2.7 में दूंगा, इसलिए आपको उसी के आधार पर दूसरा उत्तर देना चाहिए। गुड लक और मजा करें!


लीडरबोर्ड:

यह सूची पुरानी हो सकती है, इसे संपादित करने के लिए नि: शुल्क गिर गया:

1) गेहूं जादूगर [वर्तमान नेता 🏆] : 7 जवाब - अजगर 1.6 , 05AB1E , वास्तव में , डेल | मीटर | टी , डब्ल्यूएसएफ , ब्रेन-आलोचना , lenguage

2) रिले: 3 जवाब - गंभीरता से , सीजेएम , 2sable

3) जोनाथन एलन: 2 उत्तर - पायथन 3 , जेली

3) ETHproductions: 2 उत्तर - जाप , पायथ

3) मिस्टाहा फिगर्स: 2 जवाब - बेफ्यूज -98 , ब्रेन-फ्लैक क्लासिक

6) रिकर: 1 उत्तर - MATL

6) द्विजिमा: 1 उत्तर - एसओजीएल 0.8.2

6) LegionMammal978: 1 जवाब - श्वेत रिक्ति

6) निक क्लिफर्ड: 1 उत्तर - ओम

6) लिन: 1 उत्तर - गोल्फस्क्रिप्ट

6) MickyT: 1 जवाब - Cubix

दूरी कैलकुलेटर

दो प्रविष्टियों के बीच की दूरी की गणना करने के लिए आप इस स्निपेट का उपयोग कर सकते हैं:

function L(s,t){if(s===t)return 0;var S=s.length,T=t.length;if(S*T===0)return S+T;for(var i=0,v0=[],v1=[];i<=T;i++)v0[i]=i;for(i=0;i<S;i++){v1[0]=i+1;for(var j=0;j<T;j++)v1[j+1]=Math.min(v1[j]+1,v0[j+1]+1,v0[j]+(s[i]!=t[j]));for(j=0;j<=T;j++)v0[j]=v1[j]}return v1[T]}
<textarea id=A rows=10></textarea><textarea id=B rows=10></textarea><br>
Distance: <span id=O>0</span> <button onclick="O.innerHTML=L(A.value.replace(/\s/g,''),B.value.replace(/\s/g,''))">Run</button>


15 काम करेंगे, 10 मानक है। मैं कहूंगा कि इसे 15 पर रखना होगा, क्योंकि यह सबसे कठिन है।
19

2
मुझे आशा है कि आपको कोई आपत्ति नहीं है, लेकिन मैंने पोस्ट के निचले हिस्से में दूरी कैलकुलेटर स्निपेट जोड़ दिया है
ETHproductions

2
ब्रेनफैक की ओर जाने के लिए यह सहयोगात्मक कार्य सुंदर है :)
वालफ्रैट

6
महत्वपूर्ण: जब आप एक सबमिशन करते हैं, तो लीडरबोर्ड को संपादित करें, इसलिए इसे बनाए रखना आसान है ..
श्री एक्सकोडर

2
लोगों को व्यापक रूप से फैली हुई भाषा से लेकर अब तक की सबसे अस्पष्ट प्रोग्रामिंग लैंग्वेज तक, पायथन से लेकर ब्रेन-फ्लैक तक के जवाबों को शानदार सहयोग के साथ देखना शानदार है। सभी के लिए धन्यवाद जिन्होंने इसे बनाया है! अब मुझे वास्तव में यह देखने में दिलचस्पी है कि इस चुनौती के साथ क्या होता है, क्योंकि DjMcMayhem ने इस पर एक इनाम रखा है।
मिस्टर एक्सकोडर

जवाबों:


12

उत्तर 20, ब्रेन-फ्लैक , 11

मैं केवल इस लक्ष्य में योगदान करने में मदद करने वाले सभी को धन्यवाद देने के लिए समय निकालना चाहता हूं:

  • रिले, 20 बाइट्स

  • लीजनमैमल, 15 बाइट्स

  • ETHproductions, 11 बाइट्स

  • लिन, 1 बाइट

निम्नलिखित उपयोगकर्ता सीधे बाइट्स का योगदान करने में सक्षम नहीं थे, लेकिन अन्य तरीकों से मदद की:

  • मिस्टाहा फिगर्स

  • DJMcMayhem

  • feersum

यह संभव बनाने के लिए सभी को धन्यवाद!

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

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


6
अंत में, ब्रेन फ्लैक! उन सभी को धन्यवाद जिन्होंने इस लक्ष्य को प्राप्त करने में मदद की! इस चुनौती के आसपास खर्च किए गए महान कार्यों और समय के लिए उपयोगकर्ता को सबसे अधिक जवाब देने के लिए गेहूं के जादूगर को बधाई!
मिस्टर एक्सकोडर

7

उत्तर 3: MATL, दूरी 15

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)

2
MATL %को जारी रखना वास्तव में कठिन है। दूसरों को शुभकामनाएं और मैं वास्तव में आशा करता हूं कि यह चुनौती यहां "मर" नहीं जाएगी!
श्री एक्सकोडर

क्या यह बिल्ट इन का उपयोग नहीं है?
जोनाथन एलन

@JonathanAllan नहीं, निश्चित रूप से नहीं। भाजक के लिए बनाया गया है Z\। यहां प्रासंगिक कोड है :tGw\~)(जो मैंने चैट में लिखा था, एक बिलिन नहीं)
जेम्स

वास्तव में, वहाँ कोई निर्मित में है
श्री Xcoder

1
@JonathanAllan तालिका थोड़ी भ्रामक हो सकती है। Z\, नहीं \, "भाजक" है। पिछले तीन स्तंभों में शीर्षक उपसर्ग संकेत करता है ( X, Y, या Z)। \अपने आप में पहला स्तंभ है, जिसका अर्थ है "मॉड"
लुइस मेंडो

7

उत्तर 7, जाप, 15

ò f!vU"Gw\((()<>))
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

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

बदल दिया #b∫I:b;\?tकरने के लिए ò f!vU(10 अंक) और बदलकर कुछ और ब्रेन-आलोचना कोड जोड़ ~(()के लिए ((()<>))(5 अंक)। मेरा मानना ​​है कि जिस कोड की ओर हम काम कर रहे हैं वह है

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

व्याख्या

ò           Generate the range [0...input].
  f         Filter to only items Z where
   !vU        U.v(Z) returns truthily. (`fvU` would be Z.v(U))
              This returns true if U is divisible by Z, false otherwise.
      "...  The rest of the program is enclosed in this string, which is passed as an extra
            argument to `f`. Fortunately, `f` ignores it.
            Implicit: output result of last expression

6

उत्तर 8, 05AB1E , 14

"'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'".e

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

व्याख्या

सौभाग्य से 05AB1E में एक बिलियन पायथन दुभाषिया (प्रकार का) है। इस रन को बनाने के लिए हम धक्का देते हैं

'ò f!vUGw\((()<>)){((({'
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)
'#Rḍ⁸T”'

स्टैक के शीर्ष पर एक स्ट्रिंग के रूप में। हमें यहां टिप्पणियों के बजाय स्ट्रिंग शाब्दिकों का उपयोग करना होगा क्योंकि 05AB1E वास्तव में अपने पायथन कोड में टिप्पणियों को पसंद नहीं करता है। हमें "मूल कोड से भी छुटकारा पाना होगा क्योंकि यह स्ट्रिंग को समय से पहले समाप्त कर देता है।

एक बार स्ट्रिंग को धक्का देने के बाद हम .eइसे अजगर कोड के रूप में निष्पादित करने के लिए उपयोग करते हैं ।

ब्रेन-फ्लैक की ओर काम करें

मैं ब्रेन-फ्लैक उत्तर बनाने के लक्ष्य की ओर 5 अतिरिक्त वर्ण जोड़ने में सक्षम था। मैं 6 जोड़ सकता था, लेकिन अफसोस कि मैं व्हॉट्सएप भूल गया था कि अंक स्कोर की ओर गिनती नहीं है।

अब तक हमारे पास:

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

6

उत्तर 13, अजगर , 15

f!%QTS|Q"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input({})(<>))i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX
╜R;`;╜%Y*`M∩

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

व्याख्या

इसलिए मुझे बहुत ज्यादा जानकारी नहीं है, लेकिन मुझे पता है कि स्रोत कोड एक पेड़ के रूप में होता है, प्रत्येक कमांड अपने दायीं ओर एक विशिष्ट संख्या में तर्क लेती है। मेरे द्वारा लिखे गए भाजक कार्यक्रम का वृक्ष इस प्रकार है:

     f
    / \
   !   S
   |   |
   %   Q
  / \
 Q   T

Qइनपुट है fदो तर्क लेता है, Fऔर A, उन वस्तुओं Tको लौटाता है Aजहां F(T)एक सत्य मूल्य देता है। इस मामले में, Fएक फ़ंक्शन है जो तार्किक नहीं लौटाता है Q%T, और Aवह है SQ, जो सीमा बनाता है [1...Q]। इसमें केवल पूर्णांकों को फ़िल्टर करने का प्रभाव होता Tहै [1...Q]जहां Q%T == 0

बाकी कोड को पार्स करने से बचने के लिए, पूरी चीज़ को एक तार में लपेटा जाता है, फिर |Q"...तार्किक OR Qऔर स्ट्रिंग लौटाता है । चूंकि Qयह हमेशा सकारात्मक है, यह हमेशा सत्य है, और इस तरह हमेशा तार्किक या से वापस आ जाता है।


ब्रेन-फ्लैक की ओर काम करें

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

वास्तव में यह देखने के लिए उत्सुक हैं कि ब्रेन-फ्लैक का जवाब कौन देगा, अगर यह कभी होता है ..
श्री एक्सकोडर

हम करीब आ रहे हैं। हमें उत्तर 20 (यदि पहले नहीं)
कैलकुलेटर 14

खैर, हमें जाने के लिए 54
चार्ट मिले

ठीक है, हम के बारे में कर रहे हैं आधे रास्ते वहाँ, और इसलिए हम 18 के आसपास खत्म करना चाहिए इस, जवाब 8 चारों ओर कहा गया है
CalculatorFeline

6

उत्तर 16, गोल्फस्क्रिप्ट, 15

~:
),(;{
\%!},p#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}<>)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

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

मैंने जोड़ा ~:␤),(;{␤\%!},p#, आकार की कसौटी पर फिट होने के लिए एक चर नाम के रूप में नई लाइन का उपयोग करना, और इसे पूरा करने के लिए पूरे कार्यक्रम को एक पंक्ति में वापस स्क्विट किया। यह दूरी 14. तब, मैंने ब्रेन-फ्लैक के लिए {पहले जोड़ा था }printdiv

~:␤                    Read input, store as NL
   ),(;                Range [1, 2... NL]
       {␤\%!},         Filter elements that divide NL
              p#       Print and comment everything else out

ब्रेन-फ्लैक की ओर काम करें

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

6

उत्तर 17, सीजेएम , 15

qd:A
),(;
{A\%!},p
e#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{)){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

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

qd:A     # Get input as decimal and store it in A
),(;     # range [0..A]
{    },  # Filter where
 A\%!    # A mod this value == 0
       p # print 
e#...    # comment

ब्रेन-फ्लैक (जाने के लिए 30) की ओर काम करें

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

हम वास्तव में केवल 30 दूर हैं। अतिरिक्त 4 अक्षर आप बदल सकता छोड़ते हुए के बजाय )({}(((करने के लिए ()({})((केवल दो की कीमत पर, इस सटीक कार्यक्रम हम मन में था नहीं है, लेकिन ()और ({})इस संदर्भ में दोनों कोई-ऑप्स कर रहे हैं।
तदर्थ गार्फ हंटर

@HeatWizard अच्छा लगा! मैंने वास्तविक कोड को नहीं देखा, बस प्रश्न में दूरी चेकर के माध्यम से इसे चलाया।
रिले

5

उत्तर 4 - जेली , 4

:tGw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T

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

प्रासंगिक कोड:

Rḍ⁸T

)जहाँ तक पार्सर का सवाल है (मेरा मानना है कि) लिंक के बीच एक को तोड़ने के रूप में कार्य करता है।

बिल्ट-इन होगा ÆD, इसके बजाय यह 1इनपुट से एक सीमा बनाता है , इनपुट के साथ Rविभाजन की जांच करता है ḍ⁸, फिर उसके साथ सत्य एक-आधारित अनुक्रमित की सूची देता है T


5

उत्तर 9, व्हॉट्सएप, 15

f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

जहां <SPACES>निम्नलिखित स्ट्रिंग द्वारा प्रतिस्थापित किया जाता है, जहां T0x09 है, L0x0A है, और S0x20 है:

SSSLSLSTLTTTTTSSSLLSSSLSTSSTLSTSSTLTSSTLTSSSLSSSTLTSSSSTSSTLSTSSTLTSTTLTSTLLSLSL
LSSTLSLSTLSTSSSTSTSLTLSSLSLSLLSSSSLLLL

स्पष्टता के लिए शाब्दिक नई पंक्ति जोड़ी गई। ध्यान दिया कि नियम केवल गैर-व्हाट्सएप वर्ण निर्दिष्ट करते हैं। नहीं, खुद की मदद नहीं कर सकता।

ब्रेन-फ्लैक की ओर काम करें

मुझे नहीं पता कि पहले क्या चल रहा था, इसलिए अब हमारे पास है:

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

5

उत्तर 18, डब्ल्यूएसएफ , 15

q   

































































    d:A(),(;{A\%!},pe#&f!0pv'%QTS|Q"@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(i)i=i+1{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\

(यह वर्ण कोड के माध्यम से इनपुट और आउटपुट लेता है)

व्याख्या

डब्ल्यूएसएफ अनिवार्य रूप से दिमागी रूप से सिवाय इसके है कि यह ब्रेनफॉक के बजाय ऑपरेटरों के सामान्य सेट के बजाय व्हाट्सएप का उपयोग करता है। यहाँ कोड को ब्रेनफॉक में विघटित किया गया है:

,
[->+>>>>+<<<<<]>

[
[-<+>>>>+<<<]<[->+<]
>>>>>[-<<+>>]<[->+<]<
[>+>->+<[>]>[<+>-]<<[<]>-]
>>[-]+>[<->[-]]
<
[<<<<.>>>>-]<[->+<]<<<
-
]

ब्रेन-फ्लैक की ओर प्रगति

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

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

चूँकि मैं खुद ब्रेन-फ्लैक जवाब पोस्ट करने नहीं जा रहा हूं, मैंने सोचा कि मैं सिर्फ उस समय को धन्यवाद दूंगा जिसने इस लक्ष्य में योगदान करने में मदद की है:

  • रिले, 16 बाइट्स

  • लीजनमैमल, 15 बाइट्स

  • ETHproductions, 11 बाइट्स

  • लिन, 1 बाइट

निम्नलिखित उपयोगकर्ता सीधे बाइट्स का योगदान करने में सक्षम नहीं थे, लेकिन अन्य तरीकों से मदद की:

  • मिस्टाहा फिगर्स

यह संभव बनाने के लिए सभी को धन्यवाद!


5

उत्तर 19, 2sable , 15

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>){ifn%i==g00div.append(>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"
ILD¹s%_Ï,

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

मैंने अतिरिक्त व्हाट्सएप को हटा दिया, एक स्ट्रिंग में पहले मौजूद हर चीज को लपेट दिया, फिर:

IL        # Push [1 .. input]
  D       # Duplicate
   ¹s%    # For each element: input % element
      _   # Logical not
       Ï  # Keep the values from [1 .. input] where this is 1
        , # print

5

उत्तर 21, क्यूबिक्स , 15

अंत में इसे फिट करने में कामयाब रहे :) शुक्र है कि यह ब्रेन-फ्लैक जवाब देने के बाद है, क्योंकि मुझे लगता है कि मैंने बाधा डाली होगी। लागू करने के लिए पूरे 15 चाहिए।

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw
)(Is{})%?;ONou{((({}[()]<n=int(inpu;<@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>([{}()]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}
#R
{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

यह निम्नलिखित घन के लिए मैप करता है

              " q d : A ( )
              , ( ; { A \ %
              ! } , p e # &
              f ! 0 p v ' %
              Q T S | Q @ ░
              ┼ _ ¥ f : : +
              ! v U G w ) (
I s { } ) % ? ; O N o u { ( ( ( { } [ ( ) ] < n = i n t
( i n p u ; < @ ! - ; < > ) ) > < > ) < { i = 1 d i v =
w v h i l e ( ( { } ) ) { ( { } [ ( ) ] ) < > } { } } {
} < > ( [ { } ( ) ] { } ) > < > ) < > { i f n % i = = g
0 0 d i v . a p p e n d ( < { } < > { } < > > i ) i = i
+ 1 } { } p r i n t d i v ) } # R { } T : . e X ╜ R ; j
` ; ╜ 0 % Y * ` M ∩ \ " I L D ¹ s % _ Ï , . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .
              . . . . . . .

आप इसे यहाँ आज़मा सकते हैं , लेकिन आपको इसे पेस्ट करने की आवश्यकता होगी। मुझे संदेह है कि कुछ विशेष पर्मलिंक के लिए समस्या पैदा कर रहे हैं।

कोड अनिवार्य रूप से 2 लाइनों से अधिक है। महत्वपूर्ण भाग हैं:

I s     ) % ? ; O N o u 
        u ; < @ ! - ; 

I s )यह इनपुट प्राप्त करता है, स्टैक के शीर्ष स्वैप करता है (0 ने भी काम किया होगा) और वेतन वृद्धि
% ?प्राप्त करें और परीक्षण करें। यदि 0 आगे ले जाता है या रिडायरेक्ट पर नीचे जाता है,
; O N oतो मॉड परिणामों को ड्रॉप करें और एक न्यूलाइन
uयू के बाद नंबर को आउटपुट करें। नीचे दिए गए लाइन पर बारी
है, जिसे निष्पादित किया
; - ! @ गया है स्टैक से 10 निकालें, इनपुट से संख्या घटाएं, परीक्षण करें और शून्य होने पर समाप्त करें
< ; uपहले परीक्षण के लिए पुनर्निर्देशित लक्ष्य। स्टैक के शीर्ष (या तो मॉड या घटाव परिणाम) को हटाएं और वेतन वृद्धि पर वापस जाएं


4

उत्तर 6, अजगर 1.6, 15

#b∫I:b;\?t"Gw\~(()
n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i=i+1
print(div)#Rḍ⁸T”

मैंने %प्रतीकों को हटा दिया और पहली पंक्ति और थोड़ी अंतिम पंक्ति के बारे में टिप्पणी की। इस अकेले ने मुझे अपने १५ में से १० अंक दिए। हालाँकि मैं अभी तक नहीं किया गया था; चूंकि पायथन 1 नहीं है, इसलिए मुझे एक अतिरिक्त 3 अंक की लागत के साथ +=बदलना पड़ा । चूंकि मेरे पास 2 बचे थे इसलिए मैंने शुरुआत में भी जोड़ा । मैं बाद में ब्रेन-फ्लैक में एक सबमिशन करने की योजना बना रहा हूं और मुझे परेंस की जरूरत है।i+=1i=i+1((


1
+1 के बाद भी ओपी ने कहा कि अजगर के साथ किया गया था, जाहिरा तौर पर नहीं ....
हाइपरन्यूट्रीनो

4

उत्तर 10, ओम , दूरी 5

@░┼_¥
f!vUGw((({})<>)){((({}n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e<SPACES>

... जहां व्हाट्सएप जवाब <SPACES>से उस राक्षसी स्ट्रिंग द्वारा प्रतिस्थापित किया जाता है ।

थोड़ा सा चुटीला जवाब, क्योंकि बाकी सब कुछ सिर्फ एक तार है जो बेपर्दा करता है।


यहां ब्रेन-फ्लैक की ओर कोई काम?
कैलक्यूलेटरफलाइन

@CalculatorFeline नहीं डरता।
निक क्लिफर्ड

बहुत बुरा। Brainflak की ओर 10 चार्ट! काश।
कैलकुलेटरफ्लीन

4

उत्तर 12, गंभीरता से , 15

╩"@░┼_¥
f!vUGw((({})<>)){((({}[()]n=int(input())i=1div=while((<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.e"X
╜R;`;╜%Y*`M∩

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

से फर्क सिर्फ इतना है असल में जवाब यह है कि गंभीरता से एक समारोह जहां वास्तव में उपयोग करता है चिह्नित करने के लिए बैकटिक का उपयोग करता है और और एक स्ट्रिंग में हम सिर्फ अतिरिक्त वर्ण बनाने के तो पॉप और यह त्यागें।


ब्रेन-फ्लैक की ओर काम

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

+1 प्रतियोगिता को ब्रेन-फ्लैक के करीब एक कदम लाना। बस 1 प्रश्न: क्या आप किसी भी प्रोग्रामिंग भाषा को गंभीरता से समान मानते हैं?
श्री एक्सकोडर

वास्तव में अन्य के अलावा।
मिस्टर एक्सकोडर

@ Mr.Xcoder मैंने कोई उपयोग नहीं किया है। मुझे केवल इतना पता था कि सीरियसली भी ऐसा ही था क्योंकि वास्तव में सिर्फ सीरियसली वर्जन 2.0 है
रिले

4

उत्तर 14, Del | m | t , 15

                                                f!%QTS|Q"@░┼_¥f!vUGw((({})<>)){((({}[()]<n=int(input({})(<>))><>)<{i=1div=while(({})){({}<>)){ifn%i==0div.append(i)i=i+1}printdiv)}#R{}T.eX╜R;`;╜%Y*`M∩

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

व्याख्या

मैं वास्तव में इस तथ्य का दुरुपयोग करना शुरू कर रहा हूं कि व्हॉट्सएप की गिनती यहां के अंतर की ओर नहीं है। Del | m | t वास्तव में इस बात की परवाह नहीं करता है कि आपके द्वारा कोड के विशाल बहुमत में कौन से वर्ण हैं जो प्रोग्राम की शुरुआत में रिक्त स्थान और गाड़ी के रिटर्न का एक क्रम है। कोड के वास्तविक दृश्य भागों को बिल्कुल भी निष्पादित नहीं किया जाता है।

यहाँ कोड को अधिक "उचित" फैशन में बदला गया है:

O R ^ V O @ A K T A J O @ A K U N R O @ B K U @ A K T Q ^ X @ B K T R ^ P O @ A K T K R ^ _ @ ^ @

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

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

शुरू करने के लिए हमारे पास O R ^ V पहले लूप पर इनपुट लेने का काम करता है और अन्य सभी समयों में यह काम करता है।

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

@ A K Tस्मृति स्थिति -1 में संग्रहीत चर को याद करता है (कार्यक्रम की शुरुआत में यह 0 है) और A Jइसे बढ़ाता है। O @ A K Uअब हमारे अगले लूप के लिए मेमोरी स्थिति -1 में अब बढ़े हुए मूल्य को वापस स्टोर करें।

Nहम कुछ समय पहले किए गए इनपुट की कॉपी के मॉड की गणना करते हैं और मूल्य सिर्फ मेमोरी से याद किया जाता है और Rइसे नकारता है।

एक साथ N Rएक बूलियन बनाते हैं जो इंगित करता है कि हमारे इनपुट टीओएस द्वारा विभाज्य है या नहीं।

हम इस बूलियन की एक प्रति मेमोरी स्पेस -2 का उपयोग करके स्टोर करते हैं O @ B K Uऔर मेमोरी स्पेस -2 का उपयोग करके मूल्य को याद करते हैं @ A K T

हम Qयह सुनिश्चित करने के लिए शीर्ष दो तत्वों को स्वैप करते हैं कि बूलियन शीर्ष पर है और यदि बूलियन का उपयोग करना सही है तो मूल्य का उत्पादन करें ^ X

यदि बूलियन झूठ था, तो हमारे पास एक अतिरिक्त मूल्य है जिसे मिटाने की आवश्यकता है इसलिए हम बूलियन को अंतरिक्ष -2 में संग्रहीत करते हैं @ B K Tऔर यदि यह गलत है तो एक मान को पॉप-अप किया जाता है R ^ P

हम के साथ इनपुट मान को डुप्लिकेट करते हैं Oऔर मेमोरी -1 पर मान को घटाते हैं @ A K T K। यदि यह शून्य है तो हम बाहर निकल जाते हैं R ^ _

अंत में हमारे पास @ ^यह स्किप है जो भी अगला मूल्य है। हमें इसकी आवश्यकता है क्योंकि @कोड के दृश्य भाग द्वारा उत्पन्न कबाड़ (वास्तव में केवल एक प्रतीक) का एक गुच्छा है ।

एक बार जब यह अंत तक पहुँचता है तो यह शुरुआती में वापस आ जाता है।

यह उच्च स्तर पर कैसे काम करता है

मूल विचार यह है कि हमारे पास मुख्य रूप से मेमोरी लोकेशन -1 में संग्रहित मूल्य होता है जो कि हर बार लूप होने पर बढ़ जाता है। यदि वह मान हमारे इनपुट को विभाजित करता है तो हम इसे आउटपुट करते हैं और जब दोनों समान होते हैं तो हम निष्पादन को समाप्त कर देते हैं।

प्रगति ब्रेन-फ्लैक की ओर

क्योंकि व्हॉट्सएप मेरे 15 अंकों में से किसी को भी खर्च किए बिना कोड को बदलने में सक्षम नहीं था और इस तरह उन सभी को ब्रेन-फ्लैक कोड में निवेश किया गया था।

यहाँ हमारी वर्तमान स्थिति है।

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

कृपया हर बार लीडरबोर्ड को अपडेट करें जब आप एक जवाब प्रस्तुत करते हैं।
श्री Xcoder 20

ब्रेन-फ्लैक जवाब के लिए केवल 39 अक्षर बचे हैं! :) इसका मतलब है कि हमें अभी भी कम से कम 3 उत्तरों की आवश्यकता है ...
हाइपरन्यूट्रीनो

4

उत्तर 15, बेफ्यूज -98, 15

&f!0pv
'         %QTS|Q" @ ░┼_¥f
:
:      
+      
!         vUGw(((   {})<>)){((({}[()
]    <    n=int(i   nput({})(<>))><>)
<      {i=1di     v
  =
w    v  
       hile(({      })){({}<>)){ifn%i==
g
0
0    div.app   en   d(i)i=i+1}printdiv)}#R{}T
:      
.    eX╜R;
j      
`      ;╜
0      
%  Y*`M∩
\

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

(शायद अनावश्यक व्हॉट्सएप का एक बहुत कुछ है, लेकिन मैं इसे अभी बाहर करने के लिए परेशान नहीं कर सकता)

मैंने सभी 15 का उपयोग बेफ्यूज कार्यक्रम के लिए किया, इसलिए इस बार ब्रेन-फ्लैक में कोई बदलाव नहीं हुआ।

इसके लिए मेरी मुख्य रणनीति आईपी को लंबवत भेजना और व्हाट्सएप का उपयोग करते हुए preexisting कोड से कुछ वर्णों को निष्पादित करना था।

स्पष्टीकरण:

कोड जो Befunge प्रोग्राम के लिए मायने रखता है वह यह है:

&f!0pv
'                 @
:
:
+
!
]    <
<                 v
w    v
g
0
0    d
:
.    e
j
`
0
%    `
\

जो इसके बराबर है:

&f!0pv   Gets input, and stores it at (0, 0) (where the & is)
         The v goes down, hits the < and ], which turns the IP up along the first line

!+::'&   There is a 0 at the bottom of the stack, so ! changes it to a 1 and + increments
         :: duplicates twice, and '& gets the input value

\%       swaps the input and iterator mods them
  0`j.   Checks if input mod iterator is 0 - if it is, print iterator

:00gw    gets the input again, and compares it to the iterator.
         If they are different, the IP travels right to the v
         Otherwise, it continues straight, and hits arrows leading to the end (@)

de`      pushes 0, to be used in the increment line

3

उत्तर 2 - पायथन 3 , 5

n=int(input())
i=1
div=[]
while (i<=n):
    if n % i == 0:
        div.append(i)
    i+=1
print(div)

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


अब आपने पायथन में उत्तर सूची को बंद कर दिया है। अच्छा!
श्री एक्सकोडर

@ Mr.Xcoder क्या होगा यदि कोई Python 3.5 का उपयोग करता है asyncया awaitबिल्ट-इन का उपयोग करता है ? क्या यह एक पूरी तरह से अलग भाषा के रूप में गिना जाएगा?
HyperNeutrino

3

उत्तर 5 - एसओजीएल 0.8.2 , 9

b∫I:b;\?t"Gw\~)
%n=int(input())
%i=1
%div=[]
%while (i<=n):
%    if n % i == 0:
%        div.append(i)
%    i+=1
%print(div)Rḍ⁸T”

स्पष्टीकरण:

b∫              repeat input times                [0]
  I             increment (the loop is 0-based)   [1]
   :b           duplicate                         [1, 1]
     ;          put the input one under the stack [1, 114, 1]
      \?        if divides                        [1, 1]
        t        output                           [1, 1]
         "...”   push that long string            [1, 1, "Gw\~...Rḍ⁸T"]

नोट: दुभाषिए को वर्तमान में इनपुट के रूप में नहीं गिनने के लिए \nएस की जगह चाहिए , लेकिन पार्सर खुद को इंटरचेंजेबल मानता है।


3

उत्तर 11, वास्तव में , 15

╩@░┼_¥
f!vUGw((({})<>)){((({}]n=int(input())i=1div=while(i<=n):ifn%i==0:div.append(i)i=i+1printdiv)}#R{}T”.e
╜R;⌠;╜%Y*⌡M∩

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

व्याख्या

वास्तव में एक ÷संख्या के कारकों को खोजने के लिए एक अच्छा बिलिन है , हालांकि हमें ऐसे बिलिन का उपयोग करने की अनुमति नहीं है।

मैं रजिस्टरों के लिए इनपुट को स्टोर करके शुरू करता हूं ताकि यह आने वाले समय से अप्रभावित हो जाए। मैं इसका उपयोग करता हूं, लेकिन मैं आसानी से उपलब्ध अन्य आदेशों में से एक का उपयोग कर सकता हूं।

फिर मेरे पास पहले से मौजूद कोड है (मैंने सभी व्हाट्सएप को हटा दिया क्योंकि यह साथ काम करने के लिए कष्टप्रद था, मैं ऐसा कर सकता हूं क्योंकि "व्हॉट्सएप की गिनती नहीं होती है")। सौभाग्य से स्टैक खाली होने पर यह बहुत कुछ नहीं करता है।

फिर हमारे पास बाकी कार्यक्रम हैं

╜   Pull our input from the register
R   Create the range of n
;   Duplicate the range
⌠   Declare a function
 ;  Duplicate n
 ╜  Pull from register
 %  Mod
 Y  Logical not
 *  Multiply by n
⌡   End Function
M   Map the function across the range
∩   Remove the zeros with a Intersection

ब्रेन-फ्लैक की ओर काम

वह सब काम और मैं केवल एक अतिरिक्त में प्रवेश पाने में सक्षम था।

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

तुम्हें पता है, अगर हम ब्रेन-फ्लैक कोड को संलग्न करते []हैं तो हमारे पास इसके बाद ब्रेनफेक कोड हो सकता है। संभावनाओं को खोल सकता है।
कैल्क्युलेटरलाइन

@CalculatorFeline मुझे नहीं लगता कि हम करते हैं। ब्रेन-फ्लैक अपने दम पर करता है ब्रेनफक में कुछ भी नहीं है। Brainfuck में सबमिशन करना बहुत कठिन होगा लेकिन मुझे नहीं लगता कि Brain-Flak इसे किसी भी तरह से नुकसान पहुंचाने वाला है।
तदर्थ गार्फ हंटर

खैर, ब्रेनफक की योजना इस स्तर पर एक अच्छा विचार होगा। बाइट्स जो फ्लैक की ओर नहीं जा सकती हैं उन्हें अन्य नियोजन (जैसे बीएफ, जिम या पारंपरिक भाषाओं) में रखा जा सकता है।
कैलकुलेटरफ्लीन

@CalculatorFeline बात यह है कि बाइट्स जैसी कोई चीज़ बहुत सुंदर नहीं है जो ब्रेन-फ्लैक की ओर नहीं जा सकती है। जब तक किसी भाषा में परेंस के बारे में कुछ बहुत ही अजीब नियम नहीं हैं (जिस स्थिति में यह शायद पहले से ही अनुपयोगी है) हम बेंस को सम्मिलित करने के लिए अतिरिक्त बाइट्स का उपयोग कर सकते हैं।
तदर्थ गार्फ हंटर

सरणी से पहले आपका कोड अतिरिक्त 0 आउटपुट क्यों करता है ??
श्री एक्सकोडर

3

23, ब्रेन-फ्लैक क्लासिक, 13

"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[])<>}{}}{}<>({<({}[])>[]}[]{}{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

मूल रूप से, @Wheat विज़ार्ड ने मस्तिष्क-फ्लैक-क्लासिक कोड पोस्ट किया था क्योंकि यह उत्तर 22 पर था:

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

यह 17 अक्षर बंद है। हालाँकि, मैं इसे प्राप्त करने के {})लिए प्रस्तावित कोड में बस आगे की ओर बढ़ते हुए इसे संक्षिप्त करने में सक्षम था

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

जो केवल 13 वर्णों का है! इसलिए मैंने जो कुछ भी किया था वह प्रस्तावित कोड प्राप्त करने के लिए कोष्ठक जोड़ / हटा दिया था।


मैंने जो मूल कोड पोस्ट किया था उसमें एक टाइपो था, यह अब तय हो गया है। ( साभार @WheatWizard! )



1

22, पेंग्वेज , 15

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

,[->+>>>>+<<<<<]>[[-<+>>>>+<<<]<[->+<]>>>>>[-<<+>>]<[->+<]<[>+>->+<[>]>[<+>-]<<[<]>-]>>[-]+>[<->[-]]<[<<<<.>>>>-]<[->+<]<<<-]

मैंने बाद के उत्तरों की सुविधा के लिए मुख्य कार्यक्रम में कुछ बदलाव किए, लेकिन अंतिम परिणाम इस प्रकार है:

<SPACES>"qd:A(),(;{A\%!},pe#&f!0pv'%QTS|Q@░┼_¥f::+!vUGw)(Is(({})<>))%?;ONou{((({}[()]<n=int(inpu;({})(@!-;<>))><>)<{i=1div=wvhile(({})){({}[()])<>}{}}{}<>({<[{}[]{})><>)<>{ifn%i==g00div.append(<{}<>{}<>>i)i=i+1}{}printdiv)}#R{}T:.eX╜R;j`;╜0%Y*`M∩\"ILD¹s%_Ï,

जहां 555014291951739769894021307527885530462809719809021945310204867505067676767937656404963353226262683331681717880399306 स्थान वर्णों का <SPACES>प्रतिनिधित्व करता है।

क्या मैं व्हाट्सएप को गाली देते हुए नियम नहीं गिनता? शायद।

ब्रेन-फ्लैक क्लासिक की ओर काम करें

हमारे पास उन सभी पार्नों में पहले से ही मौजूद थे, इसलिए मैंने सोचा कि मैं हमें ब्रेन-फ्लैक क्लासिक की तरफ शुरू करूंगा।

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

एक और लक्ष्य ... वह पागलपन है। मुझें यह पसंद है!
श्री एक्सकोडर

तो ब्रेन-फ्लैक क्लासिक की शीर्ष पंक्ति वह है जो हमारे पास है, और नीचे वह है जो हमें चाहिए?
MildlyMilquetoast

@ मिस्ताफिगिंस हां
एड हॉक गार्फ हंटर

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