वैन Corput अनुक्रम der के सरलतम उदाहरण में से एक है कम विसंगति अनुक्रम । इसका nकार्यकाल सिर्फ 0.(n written in base 10 and mirrored)इतना है, इसलिए इसकी पहली शर्तें हैं:

0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.01, 0.11, 0.21, 0.31, 0.41, 0.51, 0.61, 0.71, 0.81, 0.91, 0.02, 0.12, 0.22, 0.32, 0.42, 0.52, 0.62, 0.72, 0.82, 0.92, ...

चुनौती

किसी भी प्रोग्रामिंग भाषा में प्रोग्राम या फ़ंक्शन लिखें जो इनपुट पॉजिटिव पूर्णांक से nकम लेता है 10^6और रिटर्न या nवैन डेर कोर्पुट अनुक्रम के पहले शब्दों को प्रिंट करता है । आउटपुट स्वरूप फ़्लोटिंग पॉइंट नंबरों की सूची 0.digits, फ़ॉर्म के तार की एक सूची या एक अद्वितीय स्ट्रिंग हो सकती है , जहाँ अल्पविराम और / या व्हाट्सएप, नईलाइन्स द्वारा शब्दों को अलग किया जाता है।

मानक खामियों को मना किया जाता है। सबसे छोटा स्रोत कोड जीतता है।

code-golf sequence

— बॉब
स्रोत

16

05AB1E , 6 बाइट्स

कोड:

>GNÞR,

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

स्पष्टीकरण:

>       # Increment, pushes input + 1
 G      # For N in range(1, input + 1):
  N     # Push N
   Þ    # Convert to double, which appends `.0` at the end of an integer
    R   # Reverse top of the stack
     ,  # Pop and print with a newline

CP-1252 एन्कोडिंग का उपयोग करता है।

— अदनान
स्रोत

तुम्हारा मतलब है, विंडोज़ -1252?

— इस्माईल मिगुएल

@IsmaelMiguel वही है

— अदनान

मुझे पता है, लेकिन यह आमतौर पर CP-1252

— Ismael Miguel

क्या आपको इस चुनौती के उद्देश्य से अपनी भाषा को संशोधित करना था?

— एंड्रयू साविनिख

@AndrewSavinykh नहीं, जिसे धोखा माना जाता है और इस साइट पर इसकी अनुमति नहीं है। यह संस्करण 7.3 के साथ काम करता है , जिसे इस चुनौती को पोस्ट करने से पहले जारी किया गया था।

— अदनान

8

Oracle SQL 11.2, 64 62 58 बाइट्स

SELECT REVERSE(LEVEL||'.0')FROM DUAL CONNECT BY LEVEL<=:1;

पुराना संस्करण

SELECT '0.'||REVERSE(TRIM(LEVEL))FROM DUAL CONNECT BY LEVEL<=:1;

संख्या को '' समेटना '' इसे एक स्ट्रिंग में डाल देता है। यह TRIM () का उपयोग करने से 2 बाइट्स छोटा है, जो TO_CHAR () से कम है।

किसी स्ट्रिंग को NUMBER में परिणाम करने के लिए एक स्ट्रिंग को बदलने के बाद, '0.' को प्रबंधित करने के लिए उस स्ट्रिंग का उपयोग करना संभव है। परिणाम का हिस्सा।

— Jeto
स्रोत

7

CJam, 14 11 बाइट्स

3 बाइट बचाने के लिए Sp3000 के लिए धन्यवाद।

ri{)d`W%S}/

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

व्याख्या

ri     e# Read input and convert to integer N.
{      e# For each i from 0 to N-1...
  )    e#   Increment.
  d    e#   Convert to double.
  `    e#   Get string representation (which ends in ".0").
  W%   e#   Reverse.
  S    e#   Push a space.
}/

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

7

पर्ल 6, 24 22 20 बाइट्स

{"0."X~(^$_)».flip}

धन्यवाद अलेक्सा-डैनियल जेकिमेंको-ए। अभी तक एक और दो बाइट्स के लिए

पुराना संस्करण

{("0."~.flip for ^$_)}
# Alternate below, same byte count
{map ^$_: "0."~*.flip}

संपादित करें: अतिरिक्त 2 बाइट्स के लिए धन्यवाद raiph

प्रयोग

> my &f = {"0."X~(^$_)».flip}
-> ;; $_? is raw { #`(Block|333498568) ... }
> f(25)
(0.0 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 0.01 0.11 0.21 0.31 0.41 0.51 0.61 0.71 0.81 0.91 0.02 0.12 0.22 0.32 0.42)

— हॉटकी
स्रोत

1

{("0."~.flip for ^$_)}2 बाइट्स की बचत होती है

— raiph

6

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

"0."<>StringReverse@ToString@#&~Array~#&

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

%[20]
(* {0.1,0.2,0.3,0.4,0.5,0.6,0.7,0.8,0.9,0.01,0.11,0.21,0.31,0.41,0.51,0.61,0.71,0.81,0.91,0.02} *)

— njpipeorgan
स्रोत

5

पायथ, 8 बाइट्स

m_`cd1SQ

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

यह वास्तव में इस और इस उत्तर का एक संयोजन है । इसलिए मैं इसे एक सामुदायिक विकि बना रहा हूँ।

— Pietu1998 को संशोधित किया
स्रोत

4

अजगर, 11 बाइट्स

m+"0."_`dSQ

यहाँ कोशिश करो!

व्याख्या

m + "0"। _ `dSQ # Q = इनपुट

m SQ # श्रेणी (1, Q) को मैप करें ...
 + # ... का संयोजन:
  ""। "_ _ D #" 0. " और उलटा तत्व

— Denker
स्रोत

4

पायथ - 10 बाइट्स

_M+R".0"SQ

इसे यहाँ ऑनलाइन आज़माएँ ।

— Maltysen
स्रोत

यदि आप करते हैं तो एक बाइट छोटा हैVSQ...

— जकूबे

4

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

अल्पविराम से अलग किए गए मानों के साथ एक अनाम फ़ंक्शन एक स्ट्रिंग लौटाता है

n=>[...[...Array(n)].map(_=>n--+'.0')+''].reverse().join``

परीक्षा

f=n=>[...[...Array(n)].map(_=>n--+'.0')+''].reverse().join``

function test() { R.textContent = f(+I.value) }

test()

N:<input id=I type=number value=20 oninput="test()"><br><pre id=R></pre>

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

— edc65
स्रोत

4

MATL , 10 बाइट्स

:"'0.'@VPh

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

:          % implicit input. Generate vector [1,2,...,input]
"          % for each
  '0.'     %   push string '0.'
  @        %   push loop variable (that is, 1,2,3,... in each iteration)
  V        %   convert to string
  P        %   reverse
  h        %   concatenate horizontally
           % implicit end of loop
           % implicit display of all stack contents

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

4

हास्केल, 36 , 27 बाइट्स

f n=reverse.show<$>[1.0..n]

दो बाइट्स को निमि द्वारा बचाया गया और लिन द्वारा एक अतिरिक्त 7।

— माइकल क्लेन
स्रोत

f n=reverse.show<$>[1.0..n]

— लिन

3

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

:0re:""rcr:"0."rcw,@Sw\

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

काफी सरल। दुर्भाग्य से हमें इस संख्या को एक स्ट्रिंग ( :""rc) में बदलने के लिए एक खाली स्ट्रिंग के साथ संख्या को बदलना है , क्योंकि अभी तक कोई अंतर्निहित रूपांतरण विधेय नहीं है।

स्ट्रिंग में रूपांतरण आवश्यक है, क्योंकि यदि हम संख्या के अंकों को उल्टा करते हैं, तो अग्रणी शून्य (जैसे 10बन जाता है 01) खो जाएगा।

— Fatalize
स्रोत

3

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

while($a++-$args[0]){"0."+-join"$a"["$a".Length..0]}

थोड़ा अधिक लंबे समय तक मैं चाहूंगा, लेकिन कुछ साफ-सुथरी चालों का उपयोग करता है।

whileपाश स्पष्ट है, लेकिन सशर्त एक छोटे से मुश्किल है - हमारे पास $a(जो के रूप में शुरू होता है $nullजब पहली संदर्भित) और फिर हमारे इनपुट संख्या घटाना $args[0]। PowerShell में, गणित संचालन $nullइसे शून्य के रूप में मानता है, इसलिए 20उदाहरण के लिए इनपुट के लिए यह परिणाम होगा -20। किसी भी गैर शून्य संख्या है के बाद से $true, पाश सशर्त होगा $trueसही है जब तक $aहमारे इनपुट संख्या (जो उस समय घटाव के बराबर होगा के बराबर होती है 0या $false)। ट्रिक पोस्ट-इन्क्रीमेंट से आती है ++, जो घटाव की गणना के बाद तक निष्पादित नहीं होती है, इसलिए 1वसीयत के इनपुट को सही ढंग से आउटपुट करना 0.1और फिर अगले पुनरावृत्ति पर लूप को रोकना।

लूप में हर बार, हम बस एक स्ट्रिंग शाब्दिक बनाते हैं जो पाइप लाइन पर छोड़ दिया जाता है और तदनुसार उत्पादन होता है। हम इसे कंसट्रक्शंस के "0."साथ असमान -joinऑपरेटर के परिणाम के साथ बनाते हैं, जिसने स्ट्रिंग को "$a"पीछे की ओर ले जाने (रेंज के माध्यम से अनुक्रमित करके "$a".length..0) से बनाए गए चार-सरणी पर कार्य किया है ।

टेस्ट रन

PS C:\Tools\Scripts\golfing> .\van-der-corput-sequence.ps1 1
0.1

PS C:\Tools\Scripts\golfing> .\van-der-corput-sequence.ps1 20
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21
0.31
0.41
0.51
0.61
0.71
0.81
0.91
0.02

— AdmBorkBork
स्रोत

3

बैश, 36 बाइट्स

for i in `seq $1`;do rev<<<$i.0;done

एक कमांड लाइन तर्क के रूप में एक संख्या लेता है, और प्रत्येक शब्द को एक अलग लाइन पर आउटपुट करता है। उदाहरण के लिए:

$ ./vdc.sh 12
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21

— बग़ल में ossifrage
स्रोत

2

यदि शुद्ध बैश वैसे भी नहीं seq -f%g.0 $1|rev:।

— मैनेटवर्क

@manatwork कूल। मुझे नहीं पता था कि seqस्वरूपित आउटपुट कर सकता है।

— फुहार ossifrage

3

जाप, 12 बाइट्स

Uò1 ®+".0" w

इसे ऑनलाइन टेस्ट करें!

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

           // Implicit: U = input integer
Uò1 ®      // Create the inclusive range [1..U], and map each item Z to:
+".0" w    //  Z + ".0", reversed.
           // Implicit: output last expression

— ETHproductions
स्रोत

3

मोम ,57 53 बाइट्स

Rosettacode के लिए द्विआधारी अंक आउटपुट समस्या पर काम करते हुए मैंने देखा कि मैं वैन डेर कोर्पुट अनुक्रम के लिए एक ही शॉर्ट डिवीजन एल्गोरिथ्म का उपयोग कर सकता हूं, बस 2. के बजाय 10 से विभाजन और मोडुलो का उपयोग कर रहा हूं। आउटपुट दोनों मामलों में उलट है।

कोड को मिरर करके, 4 बाइट्स द्वारा नीचे गिराया गया:

`.0` XfE@~@L#;
 { %X<#dP@T~P9_
   q<#   N
    >:'bg?b

आसान अभिविन्यास के लिए हेक्सागोनल प्रीट्रिप्रिंट:

` . 0 `   X f E @ ~ @ L # ;
 {   % X < # d P @ T ~ P 9 _
    q < #       N
     > : ' b g ? b

मूल कोड का उपयोग करके कार्यक्रम के माध्यम से एक चक्र की व्याख्या:

;#L@~@EfX `0.`
_9P~T@Pb#>X% {
      N   #>p
      d?gd':<


                                                  lstack   gstack
                                _9P              [0,0,10]•         create bee, set top to 10
                                   ~T            [0,10,n]•         flip top and 2nd, enter n
                                     @P          [n,10,1]•         flip top and 3rd, increment top
                                       b                           redirect to upper left
                     [n,10,1]•        E          [n,10,1]•      (2)clone bee in horizontal direction
flip lstack 1st/3rd  [1,10,n]•       @ f         [n,10,1]•  [1]•   push lstack top on gstack       
flip lstack 1st/2nd  [1,n,10]•       ~   X                         clone bee in all directions
flip 1st/3rd         [10,n,1]•      @     `0.`                     print "0." to STDOUT
skip if 1st>2nd      [10,n,1]•     L      >                     (1)redirect 
if 1st<2nd, del. bee              #        X                       clone bee in all directions
(if 1st>2nd, terminate program)  ;          % {  [n,10,1]•         1st=1st%2nd, output lstack 1st to STDOUT
                                            >p                     redirect
                                             <                     redirect
                                            :    [n,10,0]•         1st=1st/2nd
                                           '                       skip next instr. if 1st=0
                                          d                        redirect to upper right, loop back to (1)
                                         g       [n,10,1]   [1]•   push gstack top on lstack 1st
                                       d?                   []•    pop gstack, redirect to upper right
                                       N                           print newline to STDOUT
                                       P         [n,10,2]          increment lstack 1st
                                       E                           looped back to (2)

उदाहरण:

julia> beeswax("vandercorput.bswx",0,0.0,Int(20000))
i300
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21
0.31
0.41
  .
  .
  .
0.492
0.592
0.692
0.792
0.892
0.992
0.003

Program finished!

— एमएल
स्रोत

2

आर, 59 बाइट्स

example(strsplit);cat(strReverse(sprintf('%s.0',1:scan())))

व्याख्या

example(strsplit)फ़ंक्शन बनाता है strReverse(तब यह स्पष्ट होना चाहिए)

का उपयोग करते हुए IRanges::reverse, यह 47 बाइट्स के लिए गोल्फ हो सकता है

cat(IRanges::reverse(sprintf('%s.0',1:scan())))

— mnel
स्रोत

2

पायथन 3, 47 बाइट्स

lambda n:['0.'+str(i+1)[::-1]for i in range(n)]

पायथन 2 के साथ एक छोटा समाधान

lambda n:['0.'+`i+1`[::-1]for i in range(n)]

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

>>> f(25)
['0.1', '0.2', '0.3', '0.4', '0.5', '0.6', '0.7', '0.8', '0.9', '0.01', '0.11', '0.21', '0.31', '0.41', '0.51', '0.61', '0.71', '0.81', '0.91', '0.02', '0.12', '0.22', '0.32', '0.42', '0.52']

— एर्वान
स्रोत

मेरा पायथन समाधान समान था, लेकिन मुझे लगता है कि f=इसकी आवश्यकता नहीं है, इसलिए यह 47 बाइट्स लंबा है।

— बॉब

@Bob ठीक है, मैं इसे हटा दिया

— एर्वान

यह पहला n-1शब्द आउटपुट करता है ।

— 14

@ आप सही हैं मैं समाधान को बदल देता हूं, यह बाइट्स काउंट को नहीं बदलता है

— एरवान

lambda n:['0.'+`i+1`[::-1]for i in range(n)]यदि आप Python 2 का उपयोग करते हैं तो यह छोटा है। इसके अलावा, आपको "Python 3.5" नहीं कहना चाहिए, जब तक कि इसे 3.5 की आवश्यकता न हो, जिसे यह नहीं चाहिए। इस संस्करण में अजगर 2. की आवश्यकता है

— mbomb007

1

S, 12 चार्ट / 15 बाइट्स

⩤⁽1ï⒨ß)Ė⍞.0ᴙ

Try it here (Firefox only).

ठीक है।

व्याख्या

⩤⁽1ï⒨[1,ï]मैप करने के लिए एक सीमा बनाता है , ß)मैपिटेम (संख्या) को स्ट्रिंग में Ė⍞.0परिवर्तित .0करता है, अंत तक कंसट्रेट करता है, और ᴙपूरे स्ट्रिंग को उलट देता है।

— मामा फन रोल
स्रोत

1

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

def f(i):
    for i in range(1,i):print("."+str(i)[::-1])

स्पष्टीकरण:

सेट के माध्यम से [1,input)Iterate करें और उलट iको जोड़ दें .।

फिर भी एक और अधिक गोल्फ हो।

— intboolstring
स्रोत

के `i`बजाय का उपयोग करें str(i)। इसके अलावा, मुझे लगता है कि आपको अग्रणी शून्य को प्रिंट करने की आवश्यकता है।

— mbomb007

1

PHP, 45 41 बाइट्स

for(;$i++<$argv[1];)echo strrev(",$i.0");

CLI से इनपुट तर्क लेता है। इस तरह से चलाएं:

php -r 'for(;$i++<$argv[1];)echo strrev(",$i.0");' 100

पीछे पलटने से पहले स्ट्रिंग को समतल करके 3 बाइट्स बचाए

— aross
स्रोत

1

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

1
1$`0. 
(1)+
$#1
+`(\d)0\.(\d*)
0.$2$1

अनरीट में इनपुट लेता है।

इसे यहाँ ऑनलाइन आज़माएँ।

— randomra
स्रोत

1

गामा, 45 वर्ण

*=@set{i;0}@repeat{*;@incr{i}0.@reverse{$i} }

नमूना रन:

bash-4.3$ gema '*=@set{i;0}@repeat{*;@incr{i}0.@reverse{$i} }' <<< 12
0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 0.01 0.11 0.21

— आदमी काम पर है
स्रोत

1

जूलिया ,50 38 33 31 बाइट्स

मैं 12 बाइट्स द्वारा कोड को छोटा करने के लिए एक अलग आउटपुट प्रारूप के लिए गया था। फ़ंक्शन अब स्ट्रिंग्स की एक सरणी देता है। 5 और बाइट्स द्वारा छोटा। एलेक्स ए को मुझे स्ट्रिंग इंटरपोलेशन की याद दिलाने और एक अनाम फ़ंक्शन (2 और बाइट्स से छुटकारा पाने के लिए) का उपयोग करने के लिए धन्यवाद ।

n->["0."reverse("$i")for i=1:n]

या वैकल्पिक रूप से

n->[reverse("$(i/1)")for i=1:n]

परीक्षा

julia> @time f(10000)
  0.002260 seconds (60.01 k allocations: 2.823 MB)
10000-element Array{ASCIIString,1}:
 "0.1"
 "0.2"
 "0.3"
 "0.4"
 "0.5"
 "0.6"
 "0.7"
 "0.8"
 "0.9"
 "0.01"
 "0.11"
 "0.21"
 "0.31"
 "0.41"
 "0.51"
 "0.61"
 "0.71"
 "0.81"
 "0.91"
 "0.02"
 "0.12"
 "0.22"
 "0.32"
 ⋮
 "0.8799"
 "0.9799"
 "0.0899"
 "0.1899"
 "0.2899"
 "0.3899"
 "0.4899"
 "0.5899"
 "0.6899"
 "0.7899"
 "0.8899"
 "0.9899"
 "0.0999"
 "0.1999"
 "0.2999"
 "0.3999"
 "0.4999"
 "0.5999"
 "0.6999"
 "0.7999"
 "0.8999"
 "0.9999"
 "0.00001"

— एमएल
स्रोत

1

31 बाइट्स:n->["0."reverse("$i")for i=1:n]

— एलेक्स ए।

1

वैसे, आप अनुरोध कर सकते हैं कि आपकी प्रोफ़ाइल को यहां पुराने के साथ विलय कर दिया जाए ।

— एलेक्स ए।

बहुत अच्छा, पता नहीं था। धन्यवाद!

— एमएल

@AlexA। अनाम फ़ंक्शन स्वयं कुछ भी आउटपुट नहीं करता है। map(n->["0."reverse("$i")for i=1:n],3)(N = 3 के लिए) कोई लंबा संस्करण नहीं होगा जो किसी भी आउटपुट का उत्पादन करने के लिए आवश्यक हो? जब तक यह (कम से कम) मेरा समाधान नहीं होगा।

— ML

1

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

— एलेक्स ए।

1

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

lambda n:[`i+1.`[::-1]for i in range(n)]

उदाहरण:

>>> f=lambda n:[`i+1.`[::-1]for i in range(n)]
>>> f(30)
['0.1', '0.2', '0.3', '0.4', '0.5', '0.6', '0.7', '0.8', '0.9', '0.01', '0.11', '0.21', '0.31', '0.41', '0.51', '0.61', '0.71', '0.81', '0.91', '0.02', '0.12', '0.22', '0.32', '0.42', '0.52', '0.62', '0.72', '0.82', '0.92', '0.03']

बीजीय हल:

corput(x) = reversed(str(float(x+1)))
          = reversed(str(x+1.))
          = str(x+1.)[::-1]
          = `x+1.`[::-1]

— seequ
स्रोत

1

jq 1.5, 40 35 वर्ण

(34 वर्ण कोड + 1 वर्ण कमांड लाइन विकल्प।)

range(.)|"\(.+1).0"/""|reverse|add

नमूना रन:

bash-4.3$ jq -r 'range(.)|"\(.+1).0"/""|reverse|add' <<< 12
0.1
0.2
0.3
0.4
0.5
0.6
0.7
0.8
0.9
0.01
0.11
0.21

ऑन-लाइन परीक्षण ( -rURL से गुजरना समर्थित नहीं है - स्वयं रॉ आउटपुट की जाँच करें।)

प्रलेखन के लिंक के साथ ही:

रेंज ( ? ) | " \ \ ; + 1 ) .0" / "" | उल्टा | जोड़ना

अधिक पठनीय विकल्प के रूप में, ऊपर भी इस तरह लिखा जा सकता है ( ऑन-लाइन ):

range(.) | . + 1 | tostring | . + ".0" | split("") | reverse | join("")

— आदमी काम पर है
स्रोत

jq वास्तव में अच्छा है। कैसे "\(.+1).0"/""काम करता है?

— रात १५:५०

कुछ भी विशेष नहीं है, बस एक स्ट्रिंग प्रक्षेप \(…) और एक विभाजन है / , जो तार के मामले में विभाजित है।

— मैनावर्क

1

बीबीसी बेसिक, 89 88 87 बाइट्स

0T=1:REP.P."0."FNR(STR$T):T=T+1:U.0
1DEFFNR(S$)IFS$="":=""EL.=FNR(MI.S$,2))+LE.S$,1)

जितना संभव हो चीजों को छोटा करने के लिए संक्षिप्त रूप का उपयोग किया। मूल मशीन पर ब्रांडी बेसिक और बेसिक 2 दोनों के साथ संगत।

आधुनिक बीबीसी बेसिक के लिए आप दो और बाइट को बचाने के लिए लाइन नंबरों को भी छोड़ सकते हैं।

— Darzzr
स्रोत

1

दिल्लोग एपीएल , 12 बाइट्स

{'0.',⌽⍕⍵}¨⍳

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

स्ट्रेट-फ़ॉरवर्ड: एन के माध्यम से संख्या 1 में से प्रत्येक के लिए फ़ंक्शन के तर्क के प्रत्यावर्ती स्ट्रिंग-प्रतिनिधित्व से पहले फ़ंक्शन {स्ट्रिंग ।'0.',⌽⍕⍵}¨ ⍳

— एडम
स्रोत

0

जेएस, 66

T=101; // set T to the number of iterations wanted
for(o=[],i=0;i<T;i++)o[i]="0."+(""+i).split("").reverse().join("") // 66b

आउटपुट "ओ" नामक सरणी है

— XEM
स्रोत

0

ग्रूवी, 36 वर्ण

{(1..it).collect{"$it.0".reverse()}}

नमूना रन:

groovy:000> ({(1..it).collect{"$it.0".reverse()}})(12)
===> [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 0.01, 0.11, 0.21]

— आदमी काम पर है
स्रोत

आउटपुट वैन डेर कोर्पुट अनुक्रम

चुनौती

05AB1E , 6 बाइट्स

Oracle SQL 11.2, 64 62 58 बाइट्स

CJam, 14 11 बाइट्स

व्याख्या

पर्ल 6, 24 22 20 बाइट्स

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

पायथ, 8 बाइट्स

अजगर, 11 बाइट्स

व्याख्या

पायथ - 10 बाइट्स

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

MATL , 10 बाइट्स

हास्केल, 36 , 27 बाइट्स

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

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

टेस्ट रन

बैश, 36 बाइट्स

जाप, 12 बाइट्स

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

मोम ,57 53 बाइट्स

आर, 59 बाइट्स

पायथन 3, 47 बाइट्स

S, 12 चार्ट / 15 बाइट्स

व्याख्या

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

PHP, 45 41 बाइट्स

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

गामा, 45 वर्ण

जूलिया ,50 38 33 31 बाइट्स

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

jq 1.5, 40 35 वर्ण

बीबीसी बेसिक, 89 88 87 बाइट्स

दिल्लोग एपीएल , 12 बाइट्स

जेएस, 66

ग्रूवी, 36 वर्ण