एक इनपुट को देखते हुए, सभी एक्सपोनेंट्स को प्रिंट करें जहां इनपुट के लिए बेस और पावर राशि है

20

इसलिए इस साइट पर यह मेरी पहली चुनौती है।

एक इनपुट पूर्णांक n में लेने की चुनौती है , जो सकारात्मक होगी, और आरोही क्रम में प्रिंट ( 1 से , सहित n ), का आउटपुट (जहां वर्तमान पूर्णांक है)। ni ( n - i ) iमैं(n-मैं)मैं

उदाहरण

इनपुट 5 को देखते हुए, कार्यक्रम प्रिंट होगा:

1  
8  
9  
4  
1

14 1 है और 8 है और है 9 और है 4 और 1 है 11+4=5
232+3=5
323+2=5
414+1=5
505+0=5

इनपुट और आउटपुट

इनपुट एक धनात्मक पूर्णांक के रूप में होगा। आउटपुट संख्याओं की एक सूची होगी, जिसे कॉमा या नई लाइनों द्वारा सीमांकित किया जाएगा।

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

code-golf  math  arithmetic 
— अज्ञान का अवतार
स्रोत
5
अल्पविराम / न्यूलाइन विवरण को छोड़ दिया जाना चाहिए, सूचियों के आउटपुट को किसी भी सुविधाजनक प्रारूप में रखने के लिए यहां सामान्य अभ्यास है, जिसमें किसी फ़ंक्शन / सूची ऑब्जेक्ट के रूप में एक फ़ंक्शन द्वारा लौटाया जाना है
— Sparr
3
क्या इनपुट हमेशा 0 से अधिक है या क्या हमें 0 और नकारात्मक से निपटना है?
— Veskah
इनपुट हमेशा सकारात्मक रहेंगे
— अज्ञानता
6
दो समान रूप से छोटे जवाब मायने नहीं रखते। यदि आपको कोई उत्तर स्वीकार करने का मन करता है, तो जल्द से जल्द एक पोस्ट करें। हालाँकि मैं दृढ़ता से कम से कम कुछ दिनों तक प्रतीक्षा करने की सलाह देता हूं , और यह सुझाव देगा कि कभी भी उत्तर स्वीकार न करें (अधिक प्रस्तुतियाँ प्रोत्साहित करने के लिए)।
— Οurous
2
शीर्षक नहीं होना चाहिए "एक पूर्णांक को देखते हुए , एक आधार के साथ प्राप्त सभी शक्तियों और इनपुट के लिए एक घातांक को प्रिंट करें "?
— निकोला सैप

जवाबों:

6

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

⍳*⊢-⍳

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

अनाम उपसर्ग tacit फ़ंक्शन। TIO रेंज के लिए परीक्षण [1..10]।

3 बाइट्स के लिए धन्यवाद @lirtosiast।

किस तरह:

⍳*⊢-⍳ ⍝ Tacit function
    ⍳ ⍝ Range. ⍳n generates the vector [1..n].
  ⊢- ⍝ Subtracted from the argument. The vector is now [n-1,n-2,...,0]
⍳*    ⍝ Exponentiate using the range [1..n] as base. The result is the vector
      ⍝ [1^(n-1), 2^(n-2), 3^(n-3),...]
— जे। सल्ल
स्रोत
2
⍳*⊢-⍳का उपयोग कर 5 बाइट्स है ⎕IO←1।
— lirtosiast
@lirtosiast मुझे यह पता लगाने में थोड़ा समय लगा कि वह काम क्यों करता है, लेकिन मुझे मिल गया। धन्यवाद।
— जे। सेले
5

ऐहुई (एस्कोप्टे) , 193 164 बाइट्स (56 )

방빠싹받분샥퍼붇바파쟈뿌차샦히망맣여
타빠바푸투반또분뽀뿌서썪삯타삯받반타
석차샦져쌲볼어타토싻삭빠쏛ㅇ또섞썪뻐

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

इसे AVIS ( कोरियाई) पर आज़माएं ) ; बस ऊपर दिए गए कोड को कॉपी और पेस्ट करें, स्टार्ट बटन दबाएं, एक नंबर इनपुट करें, देखें कि यह कैसे चलता है। आउटपुट देखने के लिए, बाईं ओर > _ आइकन दबाएं ।

यह ज्यादा गोल्फ नहीं है, लेकिन मैं इसे एक शॉट देता हूं।

— cobaltp
स्रोत
क्या एक चरित्र सेट चुना जाना संभव है, ताकि प्रत्येक चरित्र 2 बाइट्स में संग्रहीत हो?
— tsh
@tsh Aheui विनिर्देशन के अनुसार , Aheui कोड में केवल UTF-8 वर्ण होते हैं।
— कोबाल्ट
2

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

.+
*
_
$$.($.'*$($.>`$*)_¶
%~`^
.+¶

इसे ऑनलाइन आज़माएं! स्पष्टीकरण:

.+
*

इनपुट को unary में बदलें।

_

प्रत्येक स्थिति का मिलान करें। यह तब कई प्रतिस्थापन चर सेट करता है। $`मैच के बाईं ओर हो जाता है; $>`इसे बाएं और मिलान करने के लिए संशोधित करता है; $.>`यह लंबाई लेने के लिए इसे संशोधित करता है, अर्थात वर्तमान सूचकांक। $'इस बीच मैच का अधिकार है, इसलिए $.'लंबाई यानी वर्तमान घातांक है।

$$.($.'*$($.>`$*)_¶

एक स्ट्रिंग बनाएं $.(प्लस $.'की पुनरावृत्ति $.>`*के साथ साथ _। एक उदाहरण के लिए, 5 के मूल इनपुट में 2 के सूचकांक के लिए, $.'3 है और $.>`2 है इसलिए परिणामी स्ट्रिंग है $.(2*2*2*_। यह आसानी से एक रेटिना प्रतिस्थापन अभिव्यक्ति है जो 2ates को शांत करता है। प्रत्येक स्ट्रिंग अपनी लाइन पर आउटपुट है।

%~`^
.+¶

पिछले चरण द्वारा उत्पन्न प्रत्येक पंक्ति के लिए, उस पर एक पंक्ति .+को उपसर्ग करें , इसे एक प्रतिस्थापन चरण में बदल दें और उस चरण का मूल्यांकन करें, जिससे अभिव्यक्ति की गणना हो।

— नील
स्रोत
2

QBasic, 35 33 बाइट्स

@ बाइट के लिए धन्यवाद 2 बाइट्स!

INPUT a
FOR b=1TO a
?b^(a-b)
NEXT

REPL.IT पर थोड़ा विस्तारित संस्करण क्योंकि दुभाषिया पूरी तरह से अप-टू-युक्ति नहीं है।

उत्पादन

QBasic (qb.js)
Copyright (c) 2010 Steve Hanov

   5
1
8
9
4
1
— steenbergh
स्रोत
सही क्रम में सूची आउटपुट करके 2 बाइट्स बचाएं! (के b^(a-b)लिए b=1..a)
— नील
@ धन्यवाद, मैंने इसमें काम किया है!
— १
2

जावास्क्रिप्ट (Node.js) , 33 32 बाइट्स

n=>(g=i=>--n?++i**n+[,g(i)]:1)``

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

@ बग्घी को क्रेडिट के साथ -3 बाइट्स, और @ l4m2 द्वारा -1 बाइट!

जावास्क्रिप्ट (Node.js) , 36 बाइट्स

f=(n,i=1)=>n--?[i++**n,...f(n,i)]:[]

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

जावास्क्रिप्ट (Node.js) , 37 बाइट्स

n=>[...Array(n)].map(x=>++i**--n,i=0)

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

— शायरु असाकोतो
स्रोत
— झबरा
32
— l4m2
2

MATL , 5 बाइट्स

:Gy-^

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

व्याख्या

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

:     % Implicit input. Range
      % STACK: [1 2 3 4 5]
G     % Push input again
      % STACK: [1 2 3 4 5], 5
y     % Duplicate from below
      % STACK: [1 2 3 4 5], 5, [1 2 3 4 5]
-     % Subtract, element-wise
      % STACK: [1 2 3 4 5], [4 3 2 1 0]
^     % Power, element-wise. Implicit display
      % STACK: [1 8 9 4 1]
— लुइस मेंडो
स्रोत
2

जावा, 59 बाइट्स

for(int i=1;a+1>i;i++)System.out.println(Math.pow(i,a-i));
— isaace
स्रोत
1
PPCG में आपका स्वागत है। ऐसा लगता है कि "इनपुट" को पूर्वनिर्धारित चर को सौंपा जाना चाहिए a, जिसे हम अनुमति नहीं देते हैं।
— झबरा
2
नमस्ते, यहाँ आपके लिए एक फिक्स है: n->{for(int i=0;i++<n;)System.out.println(Math.pow(i,n-i));} 60 बाइट्स (लिंक में कोड और परीक्षण के मामले)
— ओलिवियर ग्रेजायर
1

साफ , 37 बाइट्स

import StdEnv
$n=[i^(n-i)\\i<-[1..n]]

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

$ :: Int -> [Int]पूर्णांक लेने और परिणामों की सूची वापस करने को परिभाषित करता है ।

$ n                // function $ of n
 = [i ^ (n-i)      // i to the power of n minus i
    \\ i <- [1..n] // for each i in 1 to n
   ]
— Οurous
स्रोत
1

आर , 34 बाइट्स

x=1:scan();cat(x^rev(x-1),sep=',')

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

— ग्यूसेप
स्रोत
क्या डिफ़ॉल्ट "sep" एक स्थान नहीं है? क्या वह काम नहीं करेगा?
— स्टुअर्ट स्टीवेंसन
1
@stuartstevenson "आउटपुट नंबरों की एक सूची होगी, जिसे कॉमा या नई लाइनों द्वारा सीमांकित किया जाएगा।"
— Giuseppe
1

05AB1E , 5 बाइट्स

LD<Rm

पोर्ट ऑफ @lirtosiast की जेली जवाब ।

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

स्पष्टीकरण:

L      # List in the range [1, (implicit) input integer]
       #  i.e. 5 → [1,2,3,4,5]
 D<    # Duplicate this list, and subtract 1 to make the range [0, input)
       #  i.e. [1,2,3,4,5] → [0,1,2,3,4]
   R   # Reverse it to make the range (input, 0]
       #  i.e. [0,1,2,3,4] → [4,3,2,1,0]
    m  # Take the power of the numbers in the lists (at the same indices)
       # (and output implicitly)
       #  i.e. [1,2,3,4,5] and [4,3,2,1,0] → [1,8,9,4,1]
— केविन क्रूज़सेन
स्रोत
1

आर, 22 बाइट्स

n=scan();(1:n)^(n:1-1)

काफी हद तक आत्म-व्याख्यात्मक; ध्यान दें कि :ऑपरेटर ऑपरेटर की तुलना में अधिक पूर्वता रखता है -ताकिn:1-1 उससे छोटा हो(n-1):0

यदि हमें 0 पर शुरू करने की अनुमति है, तो (0:n)^(n:0)-1 की आवश्यकता से बचने के लिए हम दो बाइट्स खो सकते हैं ।

— JDL
स्रोत
1

चारकोल , 9 बाइट्स

Ｉ⮌ＥＮＸ⁻θιι

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। स्पष्टीकरण:

   Ｎ        Input as a number
  Ｅ         Map over implicit range
       ι    Current value
     ⁻      Subtracted from
      θ     First input
    Ｘ       Raised to power
        ι   Current value
 ⮌          Reverse list
Ｉ           Cast to string
             Implicitly print on separate lines
— नील
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.