चुनौती

इस प्रश्न में आपका कार्य एक प्रोग्राम या एक नामांकित फ़ंक्शन लिखना है, जो एक सकारात्मक पूर्णांक n(0 से अधिक) को STDIN, ARGV या फ़ंक्शन तर्कों के माध्यम से इनपुट के रूप में लेता है और STDOUT या फ़ंक्शन द्वारा दिए गए मान के माध्यम से एक सरणी आउटपुट करता है।

काफी सरल लगता है? अब यहाँ नियम हैं

सरणी केवल से पूर्णांकों में शामिल होंगे 1करने के लिएn
से प्रत्येक पूर्णांक 1को nदोहराया जाना चाहिए xबार जहां xप्रत्येक पूर्णांक का मूल्य है।

उदाहरण के लिए:

इनपुट:

आउटपुट:

[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5]

सरणी को सॉर्ट किया जा सकता है या नहीं किया जा सकता है।

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

बक्शीश

0.5यदि आपके आउटपुट सरणी में कोई भी समीपवर्ती पूर्णांक समान नहीं है, तो अपने स्कोर को गुणा करें ।

उदाहरण के लिए n = 5, ऐसा एक विन्यास होगा

[5, 4, 5, 4, 3, 4, 5, 2, 5, 3, 1, 2, 3, 4, 5]

code-golf array-manipulation

— अनुकूलक
स्रोत

6

एपीएल, 4 वर्ण

/⍨⍳⎕

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

⎕उपयोगकर्ता इनपुट पढ़ता है। आउटपुट के लिए, एपीएल डिफ़ॉल्ट रूप से हर लाइन से परिणाम प्रिंट करता है।

⍳n1 से पूर्णांक है n। उदाहरण:⍳3←→ 1 2 3

/का अर्थ है प्रतिकृति । सही तर्क से प्रत्येक तत्व को बाएं तर्क से उसके संबंधित तत्व द्वारा निर्दिष्ट के रूप में कई बार दोहराया जाता है। उदाहरण:2 0 3/'ABC'←→ 'AACCC'

⍨है लघुकरण ऑपरेटर । जब यह किसी फ़ंक्शन के दाईं ओर होता है, तो यह उसके व्यवहार को संशोधित करता है, इसलिए यह या तो तर्कों को स्वैप करता है ( A f⍨ B ←→ B f Aइसलिए, "कम्यूट") या दोनों पक्षों पर एक ही तर्क प्रदान करता है ( f⍨ A ←→ A f A, एक "सेल्फी")। बाद वाले फॉर्म का उपयोग इस समाधान में किया जाता है।

बक्शीश:

6-∊⌽⍳¨⍳⎕(8 अक्षर, धन्यवाद @ फिल-एच )

⍳5(कोटा पांच) है 1 2 3 4 5।

⍳¨ ⍳5(प्रत्येक कोटा पाँच) (,1)(1 2)(1 2 3)(1 2 3 4)(1 2 3 4 5), वैक्टर का एक वेक्टर है। प्रत्येक ( ¨) एक ऑपरेटर है, यह बाईं ओर एक फ़ंक्शन लेता है और इसे दाईं ओर सरणी से प्रत्येक आइटम पर लागू करता है।

⌽ सरणी को उलट देता है, इसलिए हम प्राप्त करते हैं (1 2 3 4 5)(1 2 3 4)(1 2 3)(1 2)(,1) ।

∊है लेनी चाहिए (उर्फ समतल )। पुन: तर्क का पता लगाता है और एक वेक्टर के रूप में इसमें से साधारण स्केल को लौटाता है।

— NGN
स्रोत

4-चरित्र की अभिव्यक्ति के बारे में कैसे ? /⍨⍳n

— ngn

जैसा कि आप चाहते हैं, श्रीमान, मैंने पाठ को अद्यतन किया है। लेकिन निश्चित रूप से आपकी आपत्ति अन्य समाधानों पर लागू होनी चाहिए जो कार्यों में लिपटे नहीं हैं?

— ngn

3

Dyalog APL दो फ्लेवर में आता है: "क्लासिक" और "यूनिकोड"। क्लासिक संस्करण दशकों से अस्तित्व में है, क्योंकि यूनिकोड मानक दिखाई देने से पहले, और एपीएल वर्ण सेट के लिए एक कस्टम बाइट-प्रति-वर्ण एन्कोडिंग का उपयोग करता है। यह अभी भी समर्थित है, हालांकि इसका उपयोग हतोत्साहित किया जाता है। इसलिए, मैं इसे एक बहाने के रूप में उपयोग करना चाहूंगा। मोटे तौर पर, मुझे लगता है कि गोल्फ में हमें चरित्रों की गिनती करनी चाहिए, बाइट्स की नहीं। तथ्य यह है कि यूनिकोड में सबसे कम कोड अंक अंग्रेजी केंद्रित ASCII द्वारा कब्जा कर लिए जाते हैं, यह एक ऐतिहासिक दुर्घटना है जो आज मायने नहीं रखना चाहिए। दिलचस्प बात यह है कि ASCII के बाहर आने से पहले APL की कल्पना की गई थी।

— ngn

3

@ng की गिनती के चार्ट एक अच्छा विचार नहीं है , क्योंकि उत्तर आम तौर पर वर्णमाला सूप डिकोड बन जाएंगे। एपीएल चार्ट को बाइट्स के रूप में गिना जाता है क्योंकि इनकोडिंग मौजूद है; यह इस साइट पर अच्छी तरह से स्थापित है। यह किसी भी बाइट एन्कोडिंग के साथ काम करता है जो प्रश्न पूछने से पहले मौजूद था।

— FryAmTheEggman

1

@ngn: क्या आप अपने बोनस उत्तर की व्याख्या कर सकते हैं? क्योंकि यह के माध्यम से किया जा सकता है: 5 4 3 2 1 5 4 3 2 5 4 3 5 4 4 5 या 6 माइनस प्रत्येक 1 2 3 4 5 1 2 3 4 1 2 3 1 2 1, जो ऐसा लगता है कि दूर नहीं है अपने प्रारंभिक उत्तर से।

— फिल एच

11

रूबी (पुनरावर्ती), 41 बाइट्स * 0.5 = 20.5

def n(n,i=1);i>n ?[]:n(n,i+1)+[*i..n];end

या लंबोदर (हिस्टोक्रैट और वेंटरो द्वारा अनुशंसित) का उपयोग करके: 34 बाइट्स * 0.5 = 17

r=->n,i=n{i>0?[*i..n]+r[n,i-1]:[]}

(कॉल का उपयोग करते हुए r[argument])

— AlexRath
स्रोत

2

यह वास्तव में अच्छा समाधान है। आप कुछ बाइट्स को विधि ( n=->x,i=1{...n[x,i+1]...) के बजाय लंबोदर बनाकर और कुछ के साथ बचा सकते हैं [*i..n]।

— हिस्टोक्रेट

1

तर्क का प्रयोग करके, आप r=->n,i=n{i>0?[*i..n]+r[n,i-1]:[]}

— व्हाटसएप

11

पायथ , 9 बाइट्स * 0.5 = 4.5

smrhQhdUQ

@FryAmTheEggman की मदद से

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

व्याख्या

s             reduce + on list
 m            map
  rhQhd       lambda d: reversed(range(d+1, Q+1)), over
       UQ     range(Q)

Qइनपुट कहाँ है

— Sp3000
स्रोत

5

आपकी मदद नहीं करनी चाहिए: D

— FryAmTheEggman

8

हास्केल, 31 वर्ण = 15.5 स्कोर

f n=[y|x<-[n,n-1..1],y<-[x..n]]

बोनस के बिना 27 अक्षर

f n=[x|x<-[1..n],_<-[1..x]]

प्राउड हास्केलर द्वारा हराया गया

— जॉन ड्वोरक
स्रोत

आपका पहला उपाय सही नहीं है। एक संभावित फिक्स हैg n = [y|x<-[n,n-1..1],y<-[x..n]]

— कारकाफा

@ शकर उफ़: - / / और फिक्स के लिए धन्यवाद

— जॉन डेवोरक

मेरा हास्केल जवाब सिर्फ एक बालक से कम है

— गर्वित हेकेलर

क्या इसे बढ़ावा देने के लिए मुझे इसे अपने समाधान से जोड़ना चाहिए?

— जॉन ड्वोरक

@JDDvorak मैं वास्तव में ...

— गर्वित हेकलर

7

सी, 22 = 44 बाइट्स * 0.5

फ़ंक्शन hदो पैरामीटर लेता है। पहला एक intनिर्दिष्ट n है । दूसरा वह है int*जो आउटपुट बफर है।

h(n,o)int*o;{for(n&&h(~-n,o+=n);*--o=n--;);}

परीक्षण कार्यक्रम

main(){
int wow[999],*i;
memset(wow,0,sizeof(wow));
h(6, wow);
for(i=wow;*i;i++)printf("%d ", *i);
}

— feersum
स्रोत

मुझे नहीं मिला। कृपया समझाएँ?

— Bacchusbeale

@bacchusbeale ओके .. यह n से 0. तक अवरोही क्रम लिखता है। शॉर्ट सीक्वेंस को जल्द ही पुनरावृत्ति के गहरे स्तर पर लिखा जाता है। यदि तर्क n 0 है, तो n गलत है, इसलिए कोई पुनरावृत्ति नहीं है, और केवल 0 लिखा है, जो सरणी के अंत को चिह्नित करने का कार्य करता है।

— झगड़ा

7

पायथ - 15 10 * .5 = 5

smr-QdhQUQ

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

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

स्पष्टीकरण:

Q=eval(input())       : implicit
s                     : The sum of...
 m      UQ            : map(...,range(Q))
  r-QdhQ              : range(Q-d,Q+1)

— FryAmTheEggman
स्रोत

2

अच्छा समाधान है। क्या कभी ऐसी स्थिति है जिसमें पायथ कोड गोल्फ नहीं जीत पाएगा ? :)

— एलेक्स ए।

2

@Alex समस्या की प्रकृति पर निर्भर करता है, के आधार गोल्फ भाषाओं (Golfscript, CJam) क्रीम कर सकते हैं यह, यह कर सकते हैं खो पुस्तकालय सामान (करने के लिए भी ढेर खांसी बैश खांसी );)

— FryAmTheEggman

6

सीजाम, 12 15 बाइट्स * 0.5 = 7.5

li_,f{),f-W%~}`

यह पूरा STDIN-to-STDOUT कार्यक्रम है। यह 1 ... nसीमा के बढ़ते प्रत्ययों को समेटता है , जो यह सुनिश्चित करता है कि कोई भी निकटवर्ती संख्या समान न हो।

इसका परीक्षण यहां करें।

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

6

पायथन 2, 53 बाइट्स * 0.5 = 26.5

i=n=input()
x=[]
while i:x+=range(i,n+1);i-=1
print x

बेशर्मी से @ VisualMelon का विचार उधार लिया गया

— Sp3000
स्रोत

6

हास्केल, 34 बाइट्स * 0.5 = 17

0%n=[]
i%n=[i..n]++(i-1)%n
g n=n%n

मैंने पहली बार गोल्फ के लिए हास्केल का उपयोग किया है। के साथ बुलाओ g <number>।

— Sp3000
स्रोत

5

बैश + कोरुटिल्स, 28/2 = 14

बेशर्मी से @ पगी का आइडिया और गोल्फ चोरी करना :

seq -f"seq %g $1" $1 -1 1|sh

शुद्ध बैश (कोई कोरयूटिल्स) नहीं, 30/2 = 15

बेदखली, पलायन और विस्तार नरक:

eval eval echo \\{{$1..1}..$1}

— डिजिटल आघात
स्रोत

5

गोल्फस्क्रिप्ट (14 बाइट्स * 0.5 = स्कोर 7)

 ~:x,{~x),>~}%`

ऑनलाइन डेमो

मुझे लगता है कि यह संभवतः कुछ मौजूदा जवाबों के समान है जिसमें यह सरणी का निर्माण करता है concat( [n], [n-1, n], [n-2, n-1, n], ..., [1, 2, ..., n] )

अफसोस की बात है कि मैं किसी भी और अधिक यकीन है कि और अधिक सुंदर गोल्फ में सक्षम नहीं था:

~:x]{{,{x\-}/}%}2*`

जो इनपुट xको एक सरणी में रखता है और फिर दो बार लागू होता है {,{x\-}/}%, जो सरणी में प्रत्येक तत्व को उस कई तत्वों से गिनता है x।

— पीटर टेलर
स्रोत

5

C # - 81 (161bytes * 0.5)

सी # में सरल नौकरी, उम्मीद है कि नो-निबोरिंग-नंबरों का बोनस मिलेगा। स्टड से एक उदाहरण पढ़ता है, उदाहरण के लिए स्टडआउट की तरह एक सरणी लिखता है।

class P{static void Main(){int n=int.Parse(System.Console.ReadLine()),m=n-1,i;var R="["+n;for(;m-->0;)for(i=m;i++<n;)R+=", "+i;System.Console.WriteLine(R+"]");}}

अधिक पठनीय:

class P
{
    static void Main()
    {
        int n=int.Parse(System.Console.ReadLine()),m=n-1,i;
        var R="["+n;
        for(;m-->0;)
            for(i=m;i++<n;)
                R+=", "+i;
        System.Console.WriteLine(R+"]");
    }
}

उदाहरण आउटपुट:

n = 5
[5, 4, 5, 3, 4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5]

— VisualMelon
स्रोत

मैं वास्तव में एक छोटे सी # समाधान का पता लगाने की कोशिश कर रहा हूं, लेकिन मैं इसे प्राप्त करने के लिए प्रतीत नहीं कर सकता ... अच्छी तरह से किया

— ब्रैंडन

1

@MarkKnol System.Consoleस्टेटिक है, आप इसे किसी वैरिएबल को असाइन नहीं कर सकते हैं, लेकिन C # 6 में या जो भी अगला है, आप कर सकते हैं using System.Console;( using System;इस उदाहरण में भुगतान नहीं करते हैं ), यह सुनिश्चित करने के लिए कि मैं इस फीचर के बारे में कैसा महसूस कर रहा हूं, इस कारण से कई पुराने गोल्फ सवालों को ठीक से प्रभावित करते हैं;)

— विज़ुअलमेल

1

@IchabodClay यह खराब हो जाता है, using C=System.Console3 बाइट्स बचाता है, और शायद यही है कि @MarkKnol का मतलब है (क्षमा करें!), मेरी ओर से शर्मनाक लापरवाही।

— विजुअलमेल डे

1

इसके अलावा, नियमों के अनुसार, आप एक पूर्ण कार्यक्रम बनाने के बजाय केवल विधि स्वयं कर सकते थे। कुछ इस तरह ... यह । (व्हॉट्सएप के साथ 114 बाइट्स और ऐसे निकाले गए। बोनस के साथ 57 बाइट्स।)

— इचबॉड क्ले

1

@IchabodClay वास्तव में; मैं कार्यों के लिए पूर्ण कार्यक्रम प्रस्तुत करना पसंद करता हूं, कोई अच्छा कारण नहीं, आईओ सिर्फ मज़े के हिस्से की तरह लगता है (मैं argv का उपयोग नहीं करता, या तो)। इन बेवजह की बाधाओं के बिना बेहतर स्कोरिंग उत्तर देने के लिए स्वतंत्र महसूस करें!

— विजुअलमेल

4

जावास्क्रिप्ट, ईएस 6, 41 बाइट्स

f=i=>[...Array(i).fill(i),...i?f(--i):[]]

यह एक फ़ंक्शन बनाता fहै जिसे पसंद किया जा सकता है f(6)और यह आवश्यक सरणी देता है।

यह एक पुनरावर्ती दृष्टिकोण का उपयोग करता है, जहां प्रत्येक पुनरावृत्ति iसभी मूल्यवान तत्वों की एक सरणी बनाता है iऔर एक सरणी f(i-1)को रोकता है जो की स्थिति को रोकने के द्वारा लौटाया जाता हैi==0 ।

नवीनतम फ़ायरफ़ॉक्स पर काम करता है।

— अनुकूलक
स्रोत

4

हास्केल, 14 = 28 बाइट्स / 2

f n=n:[1..n-1]>>= \r->[r..n]

उदाहरण आउटपुट:

>f 5
[5,1,2,3,4,5,2,3,4,5,3,4,5,4,5]

बोनस के बिना 24 बाइट्स:

f n=[1..n]>>= \r->[r..n]

— गर्वित हेकलर
स्रोत

=<<व्हॉट्सएप से बचने में मदद कर सकता है ? मुझे लगता है कि ऐसा हो सकता है, लेकिन मुझे आश्चर्य होगा अगर आपने पहले से ही ऐसा नहीं माना है।

— जॉन ड्वोरक

@JDDvorak अगर मैंने इस्तेमाल किया होता तो मुझे लंबोदर के =<<लिए कोष्ठकों की आवश्यकता होती

— गर्वित हेकलर

मैं उलझन में हूँ कि कब लंबोदर को कोष्ठक की जरूरत है। क्या लैम्ब्डा हेडर में उतनी ही शुद्धता है जितनी >>=?

— जॉन डेवोरक

@JDDvorak उनकी कोई शुद्धता नहीं है; मुझे यकीन है कि नहीं कर रहा हूँ कैसे सही इस नियम है, लेकिन जहां ऑपरेटरों नहीं (वर्गों की अनदेखी) कर सकते हैं lambdas केवल तभी दिखाई देंगे: के बाद (, [, =, ,, किसी भी ऑपरेटरों के बाद, और की तरह

— गर्व haskeller

मुझे लगता है कि न तो लंबोदर और न ही ऑपरेटर पैटर्न के रूप में दिखाई दे सकते हैं? let \x->y = (2+) in (x,y)थोड़े असंभव लगता है।

— जॉन डेवोरक

4

हेक्से , 53 बाइट्स

function l(v)return[for(i in 0...v)for(j in 0...i)i];

एल (6) के साथ काम करता है; सरणी समझ की वजह से।
टेस्ट ऑनलाइन http://try.haxe.org/#741f9

— मार्क नॉल
स्रोत

3

vba, 76 * 0.5 = 38

Sub i(q)
For Z=1 To q:For x=q To Z Step -1:Debug.?x;",";:Next:Next
End Sub

— SeanC
स्रोत

आप संघनक द्वारा 1 (0.5, तकनीकी रूप से) बाइट (रों) खो सकते हैं For Z=1 Toकरने के लिएFor Z=1To

— टेलर स्कॉट

आप भी कर सकते हैं गाढ़ा Next:Nextकरने के लिएNext x,Z

— टेलर स्कॉट

2

आर, 44 * .5 = 22

f=function(n){r=0;for(i in 1:n)r=c(r,n:i);r}

एक त्वरित परीक्षण

> f(1)
[1] 1
> f(2)
[1] 2 1 2
> f(3)
[1] 3 2 1 3 2 3
> f(4)
 [1] 4 3 2 1 4 3 2 4 3 4

— MickyT
स्रोत

क्या ? कोई TSQL नहीं?

— ऑप्टिमाइज़र

@ ऑप्टिमाइज़र शायद बाद में :)

— मिकटी

2

जावास्क्रिप्ट, ईएस 6, 66 बाइट्स * 0.5 = 33

f=i=>(g=n=>[...Array(n).fill().map((v,x)=>i-x),...n?g(n-1):[]])(i)

ऑप्टिमाइज़र के पुनरावर्ती दृष्टिकोण पर निर्माण , हम घटती लंबाई के अवरोही रन बना सकते हैं, जैसे [4,3,2,1, 4,3,2, 4,3, 4]।

के साथ समान-मूल्य वाले उप-संस्करण बनाने के बजाय Array(i).fill(i), हम undefinedउपयुक्त लंबाई की उप-परतें बनाते हैं Array(n).fill()और फिर मानों को एक अवरोही रन में बदलते हैं .map((v,x)=>i-x)। इसके अलावा, हम एक आंतरिक फ़ंक्शन को परिभाषित करते हैं और पुनरावृत्ति करते हैं g; बाहरी फ़ंक्शन fकेवल उसी iसमय के मान को संग्रहीत करने के लिए मौजूद है, जब gपुनरावर्ती होता है।

— apsillers
स्रोत

2

टी-एसक्यूएल, 176 * 0.5 = 88

चूँकि आपको T-SQL @Optimizer याद आ रहा था, यहाँ पर यह सब क्रिया महिमा है :)।

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

इनलाइन टेबल वेल्यूड फंक्शन, 176 * .5

CREATE FUNCTION F(@ INT)RETURNS TABLE RETURN WITH R AS(SELECT @ N UNION ALL SELECT N-1FROM R WHERE N>0)SELECT B.N FROM R CROSS APPLY(SELECT TOP(R.N)N FROM R A ORDER BY N DESC)B

इस प्रकार कहा जाता है

SELECT * FROM dbo.F(5)

SQLFiddle उदाहरण

स्केलर फंक्शन, 220 * .5

CREATE FUNCTION G(@ INT)RETURNS VARCHAR(MAX)AS BEGIN DECLARE @S VARCHAR(MAX),@N INT=1,@I INT,@C INT WHILE @N<=@ BEGIN SELECT @I=@N,@C=@ WHILE @C>=@I BEGIN SELECT @S=CONCAT(@S+',',@C),@C-=1 END SET @N+=1 END RETURN @S END

इस प्रकार कहा जाता है

SELECT dbo.G(5)

SQLFiddle उदाहरण

— MickyT
स्रोत

2

गणितज्ञ, 34 * 0.5 = 17

f=Join@@Table[x,{y,#},{x,#,y,-1}]&

— alephalpha
स्रोत

2

पर्ल, 26 बाइट्स

for(1..$n){print"$_ "x$_;}

— michael501
स्रोत

1

कृपया अपना स्कोर पोस्ट करें। इसके अलावा, चूंकि यह कोड गोल्फ है, आप अतिरिक्त रिक्त स्थान और की परिभाषा को हटाकर बाइट्स बचा सकते हैं $n।

— एलेक्स ए।

यह मेरे लिए Perl 6.

— Alex A.

@ एलेक्स, त्रुटि क्या है, 5.10 के तहत काम करता है

— माइकल ५०१

Unable to parse postcircumfix:sym<{ }>, couldn't find final '}' at line 3। इसे ideone.com पर आज़माया।

— एलेक्स ए।

@ एलेक्स, यह कोशिश करें: C: \ Windows \ system32> perl -e "$ n = 5; के लिए (1 .. $ n) {प्रिंट qq ($ _) x $ _;};" 1 2 2 3 3 3 4 4 4 4 5 5 5 5 5

— michael501

2

जावास्क्रिप्ट (पठनीय), 131 बाइट्स

मैं कोड गोल्फ में नया हूँ इसलिए यह सबसे अच्छा नहीं है

function f(n) {
    var arr = [];
    for(var i = 1; i <= n; i++) {
        for(var j = 0; j < i; j++) {
            arr.push(i);
        }
    }
    return arr;
}

जावास्क्रिप्ट (कम पठनीय), 87 बाइट्स

Jscompress.com का उपयोग करके न्यूनतम

function f(e){var t=[];for(var n=1;n<=e;n++){for(var r=0;r<n;r++){t.push(n)}}return t}

— SirPython
स्रोत

2

टीईसीओ, 25 बाइट्स * 0.5 = 12.5

a\+1%a%b<qauc-1%b<-1%c=>>

13 बाइट्स में उपर्युक्त नॉन-बोनस संस्करण को बमुश्किल बीट करता है:

a\%a<%b<qb=>>

— feersum
स्रोत

2

सी #, 114 99 * 0.5 = 49.5 बाइट्स

(VisualMelon के जवाब से थोड़ी मदद के साथ) संपादित करें: और जेम्स वेबस्टर की टिप्पणी

int[]A(int n){int m=n,i,c=0;var a=new int[n*(n+1)/2];while(m-->0)for(i=m;i++<n;)a[c++]=i;return a;}

Ungolfed:

int[] FooBar(int n)
{
    int altCounter = n, i, arrayCounter = 0;
    var returnArray = new int[n * (n + 1) / 2];
    while(m-->0)
        for(i = altCounter; i++ < n; )
            returnArray[arrayCounter++]=i;
    return returnArray;
}

एक असुरक्षित संस्करण है जिसे मैंने बेशर्मी से feersum के सी उत्तर से लिया था, लेकिन मैं 100% सुनिश्चित नहीं हूं कि यह नियमों के भीतर फिट बैठता है क्योंकि आपको विधि को कॉल करने से पहले मेमोरी आवंटित करना होगा।

सी # (असुरक्षित), 82 * 0.5 = 41 बाइट्स

unsafe void A(int n,int*p){int*z=p;int m=n,i;while(m-->0)for(i=m;i++<n;)z++[0]=i;}

इस प्रकार कहा जाता है:

int n = 5, length = (int)((n / 2f) * (n + 1));
int* stuff = stackalloc int[length];
int[] stuffArray = new int[length];
A(n, stuff);
System.Runtime.InteropServices.Marshal.Copy(new IntPtr(stuffArray), stuffArray, 0, stuffArray.Length);
//stuffArray == { 5, 4, 5, 3, 4, 5, 2, 3, 4, 5, 1, 2, 3, 4, 5 }

विजुअलमेलन के सुझाव (धन्यवाद!) के अनुसार, असुरक्षित कोड को सुरक्षित कोड के साथ फिर से बनाया जा सकता है जो आकार को और भी कम कर देता है! फिर भी प्रश्न बनता है कि क्या अंतिम परिणाम सरणी का निर्माण विधि के बाहर करने की अनुमति है।

सी #, 72 * 0.5 = 36 बाइट्स

void A(int n,int[]p){int z=0,m=n,i;while(m-->0)for(i=m;i++<n;)p[z++]=i;}

— इचबॉड क्ले
स्रोत

अच्छा काम! प्रति-आवंटित संस्करण के लिए, यह सुरक्षित जाना और इसे int[]सीधे बंद करने के लिए बहुत सस्ता है void A(int n,int[]p){int z=0,m=n,i;while(m-->0)for(i=m;i++<n;)p[z++]=i;}- मैं सहमत हूँ कि यह नियमों के संबंध में शायद थोड़ा सा iffy है;)

— विज़ुअलमेल

आपको असुरक्षित संस्करण के लिए एक स्थानीय पॉइंटर बनाने की आवश्यकता नहीं होनी चाहिए, जो एक अच्छे 8bytes को काटता है। इसके अलावा, मुझे यह बिंदु याद आ रहा है, लेकिन क्या असुरक्षित कॉलिंग कोड की अंतिम पंक्ति होनी चाहिए System.Runtime.InteropServices.Marshal.Copy(new IntPtr(stuff), stuffArray, 0, length);?

— विजुअलमेल

@VisualMelon यही कि मुझे नाम बदलने के बाद चरों के नामों की पुनरावृत्ति न करने के लिए मिलता है। सिर के लिए धन्यवाद: डी। अपनी टिप्पणी में छोटे संस्करण के लिए जवाब देने का संपादन किया।

— इचबोड क्ले

आप उस सुरक्षित संस्करण से थोड़ी दूरी काट सकते हैं, var a=new int[(int)((n/2f)*(n+1))];जो मुझे लगता है कि इसे 109 तक ले जाता है

— जेम्स वेबस्टर

कैल्क को फिर से लिखना एक और बंद है:(n*(n+1)/2)

— जेम्स वेबस्टर

1

Seq, expr और xargs = 59/2 = 29.5 के साथ बैश करें

इसे सहेजें और पहले तर्क के रूप में संख्या के साथ चलाएं।

seq $1|xargs -n1 seq|xargs -n1 expr $1 + 1 -|sed 1d;echo $1

— PGY
स्रोत

महान विचार! मैंने इसे चुरा लिया और इसे काफी बड़ा कर लिया

— डिजिटल ट्रॉमा

1

सी #, 116 115 + 33 = 148 बाइट्स

सबसे छोटा कोड नहीं है, लेकिन ... यह वैसे भी काम करता है: पी

int[]l(int m){List<int>i=new List<int>();for(int j=1;j<=m;j++){for(int x=0;x<j;x++){i.Add(j);}}return i.ToArray();}

फ़ाइल के शीर्ष पर इसकी आवश्यकता होती है (33 बाइट्स):

using System.Collections.Generic;

गैर-गोल्फ संस्करण:

int[] RepatedNumberList(int m)
{
    List<int> intList = new List<int>();
    for (int j = 1; j <= m; j++)
    {
        for (int x = 0; x < j; x++)
        {
            intList.Add(j);
        }
    }
    return initList.ToArray();
}

— ProgramFOX
स्रोत

1

जे, 23 * 0.5 = 11.5

   f=.-;@(<@|.@i."0@>:@i.)
   f 5
5 4 5 3 4 5 2 3 4 5 1 2 3 4 5

जे, ११

   f=.#~@i.@>:
   f 5
1 2 2 3 3 3 4 4 4 4 5 5 5 5 5

— Randra
स्रोत

1

23 * 0.5है 11.5, नहीं 10.5।

— प्रोग्राम फॉक्स

@ProgramFOX अच्छी पकड़। क्या आप संपादित करने जा रहे हैं, या मुझे चाहिए? IMO को कम करने का एक बड़ा कारण नहीं।

— जॉन ड्वोरक

@JDDvorak बस इसे संपादित किया। और मैंने गलती नहीं की, इससे पहले कि मैंने गलती देखी, मैंने इसे बढ़ा दिया।

— प्रोग्राम फॉक्स

अब जब गलती तय हो गई है, तो क्या बोनस समाधान को नीचे तक ले जाना चाहिए?

— जॉन ड्वोरक

-1बाइट:, f=.-[:;<@|.@i."0@>:@i.स्कोर को समान बनाते हुए!

— बोल्से बूसियर

1

जावास्क्रिप्ट (ईएस 6) 29 (58 * 0.5)

हटाएं संपादित करें ; thx @Optimizer

Q=o=>(m=>{for(n=o,r=[];n>m||++m<(n=o);)r.push(n--)})(0)||r

FireFox / FireBug कंसोल में टेस्ट करें

Q(9)

उत्पादन

[9, 8, 7, 6, 5, 4, 3, 2, 1, 9, 8, 7, 6, 5, 4, 3, 2, 9, 8, 7, 6, 5, 4, 3, 9, 8, 7, 6, 5, 4, 9, 8, 7, 6, 5, 9, 8, 7, 6, 9, 8, 7, 9, 8, 9]

Ungolfed

Q=o=>{
  for(m=0,r=[];m<o;++m)
    for(n=o;n>m;)
      r.push(n--);
  return r
}

— edc65
स्रोत

1

ECMAScript6, 67 * 0.5 = 33.5 बाइट्स

f=n=>{a=[],b=0;while(c=n+b,n--){while(c-b)a.push(c--);b++}return a}

इस एक के साथ बहुत खुश ... यह मेरे मूल के एक चौथाई के आकार के बारे में है।

f(4) रिटर्न:

[ 4, 3, 2, 1, 4, 3, 2, 4, 3, 4 ]

पुराना उत्तर:

f=i=>{a=b=Array;while(i)a=a.concat(b.apply(null,b(i)).map(e=>i)),i--;return a}

कोड गोल्फ में यह मेरा पहला शॉट है ... मैं अभी भी उस 0.5x बोनस को प्राप्त करना चाहता हूं। किसी भी सुझाव का स्वागत किया है!

F (n) से पुकारा गया।

— binormal
स्रोत

आपको स्वयं को जावास्क्रिप्ट के लिए बहुत नया होना चाहिए :)। (१) तर्क के चारों ओर कोष्ठक निकालें d, (२) a=b=c=[]घोषणा भाग के लिए, (३) c[a].map(e=>a)(४)b.push(...c)

— ऑप्टिमाइज़र

मैंने आपकी टिप्पणी पढ़ने से पहले एक छोटा संस्करण बनाया, जिसे मैं अपनी पोस्ट में डालूँगा। JS के साथ मेरा अनुभव ज्यादातर साधारण वेब ऐप्स के लिए DOM / स्टाइल मैनिपुलेशन तक ही सीमित है ... और मैंने आज तक शायद ही कोई नया ES6 फीचर इस्तेमाल किया हो।

— द्विवार्षिक

1

सी #, 108 बाइट्स * 0.5 = 54

List<int> f(int n){var r=new List<int>();int m=n-1,i;r.Add(n);for(;m-->0;)for(i=m;i++<n;)r.Add(i);return r;}

कड़ी मेहनत करने के लिए VisualMelon का धन्यवाद! मुझे लगा कि मैं इसे जितना संभव हो उतना नीचे निचोड़ने की कोशिश करूंगा।

(114 बाइट्स * 0.5 = 57, यदि आप उपयोग करने पर जोर देते हैं। तोर्रे () int वापस लौटने के लिए [])

— Romen
स्रोत

बार-बार संख्या के साथ एक सरणी बनाएं

चुनौती

एपीएल, 4 वर्ण

रूबी (पुनरावर्ती), 41 बाइट्स * 0.5 = 20.5

पायथ , 9 बाइट्स * 0.5 = 4.5

व्याख्या

हास्केल, 31 वर्ण = 15.5 स्कोर

बोनस के बिना 27 अक्षर

सी, 22 = 44 बाइट्स * 0.5

पायथ - 15 10 * .5 = 5

सीजाम, 12 15 बाइट्स * 0.5 = 7.5

पायथन 2, 53 बाइट्स * 0.5 = 26.5

हास्केल, 34 बाइट्स * 0.5 = 17

बैश + कोरुटिल्स, 28/2 = 14

शुद्ध बैश (कोई कोरयूटिल्स) नहीं, 30/2 = 15

गोल्फस्क्रिप्ट (14 बाइट्स * 0.5 = स्कोर 7)

C # - 81 (161bytes * 0.5)

जावास्क्रिप्ट, ईएस 6, 41 बाइट्स

हास्केल, 14 = 28 बाइट्स / 2

बोनस के बिना 24 बाइट्स:

हेक्से , 53 बाइट्स

vba, 76 * 0.5 = 38

आर, 44 * .5 = 22

जावास्क्रिप्ट, ईएस 6, 66 बाइट्स * 0.5 = 33

टी-एसक्यूएल, 176 * 0.5 = 88

गणितज्ञ, 34 * 0.5 = 17

पर्ल, 26 बाइट्स

जावास्क्रिप्ट (पठनीय), 131 बाइट्स

जावास्क्रिप्ट (कम पठनीय), 87 बाइट्स

टीईसीओ, 25 बाइट्स * 0.5 = 12.5

सी #, 114 99 * 0.5 = 49.5 बाइट्स

Seq, expr और xargs = 59/2 = 29.5 के साथ बैश करें

सी #, 116 115 + 33 = 148 बाइट्स

जे, 23 * 0.5 = 11.5

जे, ११

जावास्क्रिप्ट (ईएस 6) 29 (58 * 0.5)

ECMAScript6, 67 * 0.5 = 33.5 बाइट्स

सी #, 108 बाइट्स * 0.5 = 54