इनपुट:

हम दो इनपुट लेते हैं:

bदो अलग-अलग मूल्यों वाला एक इनपुट : Leftऔर Right। †
और एक सकारात्मक पूर्णांक n।

आउटपुट:

लेफ्ट / राइट इनपुट के आधार पर, हम या तो निम्न दो अनुक्रमों की श्रेणी में उत्पादन करते हैं 1-n(पहले 125 वस्तुओं के नीचे अनुक्रमों में प्रदर्शित होते हैं):

Left:
1, 6, 7, 56, 57, 62, 63, 960, 961, 966, 967, 1016, 1017, 1022, 1023, 31744, 31745, 31750, 31751, 31800, 31801, 31806, 31807, 32704, 32705, 32710, 32711, 32760, 32761, 32766, 32767, 2064384, 2064385, 2064390, 2064391, 2064440, 2064441, 2064446, 2064447, 2065344, 2065345, 2065350, 2065351, 2065400, 2065401, 2065406, 2065407, 2096128, 2096129, 2096134, 2096135, 2096184, 2096185, 2096190, 2096191, 2097088, 2097089, 2097094, 2097095, 2097144, 2097145, 2097150, 2097151, 266338304, 266338305, 266338310, 266338311, 266338360, 266338361, 266338366, 266338367, 266339264, 266339265, 266339270, 266339271, 266339320, 266339321, 266339326, 266339327, 266370048, 266370049, 266370054, 266370055, 266370104, 266370105, 266370110, 266370111, 266371008, 266371009, 266371014, 266371015, 266371064, 266371065, 266371070, 266371071, 268402688, 268402689, 268402694, 268402695, 268402744, 268402745, 268402750, 268402751, 268403648, 268403649, 268403654, 268403655, 268403704, 268403705, 268403710, 268403711, 268434432, 268434433, 268434438, 268434439, 268434488, 268434489, 268434494, 268434495, 268435392, 268435393, 268435398, 268435399, 268435448, 268435449

Right:
1, 4, 7, 32, 39, 56, 63, 512, 527, 624, 639, 896, 911, 1008, 1023, 16384, 16415, 16864, 16895, 19968, 19999, 20448, 20479, 28672, 28703, 29152, 29183, 32256, 32287, 32736, 32767, 1048576, 1048639, 1050560, 1050623, 1079296, 1079359, 1081280, 1081343, 1277952, 1278015, 1279936, 1279999, 1308672, 1308735, 1310656, 1310719, 1835008, 1835071, 1836992, 1837055, 1865728, 1865791, 1867712, 1867775, 2064384, 2064447, 2066368, 2066431, 2095104, 2095167, 2097088, 2097151, 134217728, 134217855, 134225792, 134225919, 134471680, 134471807, 134479744, 134479871, 138149888, 138150015, 138157952, 138158079, 138403840, 138403967, 138411904, 138412031, 163577856, 163577983, 163585920, 163586047, 163831808, 163831935, 163839872, 163839999, 167510016, 167510143, 167518080, 167518207, 167763968, 167764095, 167772032, 167772159, 234881024, 234881151, 234889088, 234889215, 235134976, 235135103, 235143040, 235143167, 238813184, 238813311, 238821248, 238821375, 239067136, 239067263, 239075200, 239075327, 264241152, 264241279, 264249216, 264249343, 264495104, 264495231, 264503168, 264503295, 268173312, 268173439, 268181376, 268181503, 268427264, 268427391

इन दृश्यों को आप कैसे पूछते हैं?

1 से एक डिफ़ॉल्ट अनुक्रम n=10होगा:

As integer:
1, 2, 3, 4, 5, 6, 7, 8, 9, 10

As binary:
1 10 11 100 101 110 111 1000 1001 1010

जब हम बाईं ओर खिंचते हैं, तो बाइनरी यह बन जाएगा:

1, 110, 111, 111000, 111001, 111110, 111111, 1111000000, 1111000001, 1111000110

क्यों? एक बार अंतिम बिट का उपयोग किया जाता है; एकल-अंतिम का उपयोग दो बार किया जाता है; दूसरा-अंतिम तीन बार उपयोग किया जाता है; आदि।

So `1010` will become (spaces added as clarification): `1111 000 11 0`

और ये नए बाएं-फैलाए गए बाइनरी स्ट्रिंग्स को पूर्णांक में बदल दिया गया है:

1, 6, 7, 56, 57, 62, 63, 960, 961, 966

स्ट्रेच राइट के लिए, पहले बिट का उपयोग एक बार किया जाता है; दूसरा दो बार; तीसरा तीन बार; आदि इस तरह:

As binary:
1, 100, 111, 100000, 100111, 111000, 111111, 1000000000, 1000001111, 1001110000

As integer:
1, 4, 7, 32, 39, 56, 63, 512, 527, 624

चुनौती नियम:

Any आप किसी भी दो अलग-अलग मूल्यों को ले सकते हैं, लेकिन राज्य जो आप उपयोग करते हैं। तो यह हो सकता है 1/0, true/false, null/undefined, "left"/"right", आदि
n हमेशा 0 से बड़ा होता है।
आपको कम से कम अपनी भाषा के डिफ़ॉल्ट पूर्णांक (जो कि अधिकांश भाषाओं के लिए 32-बिट है) के अधिकतम आउटपुट का समर्थन करना चाहिए।
आउटपुट स्वरूप लचीला है। सरणी / सूची के रूप में मुद्रित या लौटाया जा सकता है। एक स्थान के साथ हो सकता है, अल्पविराम के रूप में अल्पविराम, पाइप और एक जैसे। तुम्हारा फोन। (फिर, कृपया बताएं कि आपने क्या उपयोग किया है।)

सामान्य नियम:

यह कोड-गोल्फ है , इसलिए बाइट्स जीत में सबसे छोटा जवाब है।
कोड-गोल्फ भाषाओं को गैर-कोडगॉल्फिंग भाषाओं के साथ उत्तर पोस्ट करने से हतोत्साहित न करें। 'किसी भी' प्रोग्रामिंग भाषा के लिए यथासंभव कम उत्तर के साथ आने की कोशिश करें।
मानक नियम आपके उत्तर के लिए लागू होते हैं , इसलिए आपको उचित पैरामीटर और रिटर्न-टाइप, पूर्ण कार्यक्रमों के साथ STDIN / STDOUT, फ़ंक्शन / विधि का उपयोग करने की अनुमति दी जाती है। तुम्हारा फोन।
डिफ़ॉल्ट लूपोल्स निषिद्ध हैं।
यदि संभव हो, तो कृपया अपने कोड के लिए एक परीक्षण के साथ एक लिंक जोड़ें।
इसके अलावा, यदि आवश्यक हो तो एक स्पष्टीकरण जोड़ें।

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

1

क्या आप बिटवाइज़-आधारित उत्तरों को स्वीकार करने पर विचार करेंगे जो केवल समर्थन कर सकते हैं n < 128, ताकि परिणाम 32-बिट पूर्णांक में फिट हों?

— अरनुलद

@Arnauld इसके बारे में शंका कर रहा था, लेकिन जब से आपने पूछा, क्यों नहीं। आपकी भाषा के पूर्णांक के लिए उपयुक्त अधिकतम 1000 नियमों के लिए परिवर्तन करेगा।

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

@KevinCruijssen अभी भी कम से कम 16 बिट्स को सीमित करने की सिफारिश करेगी - वहाँ कम से कम एक भाषा है जो डेटा प्रकार के रूप में केवल एक बिट का समर्थन करती है।

7

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

BmxJ$mḄð€

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

-1बाएं के लिए, 1दाएं के लिए।

— लीक नन
स्रोत

6

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

lambda d,n:[int(''.join(c*-~i for i,c in enumerate(bin(x+1)[2:][::d]))[::d],2)for x in range(n)]

बाएं के लिए -1, दाएं के लिए 1

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

— Arfie
स्रोत

5

05AB1E , 14 13 बाइट्स

1 बाइट को एरिक आउटग्लोफर के लिए धन्यवाद दिया

LbεIiRƶRëƶ}JC

1छोड़ दिया के लिए।
0(या कुछ और) सही के लिए।

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

व्याख्या

L                # push range [1 ... first_input]
 b               # convert to binary
  ε              # apply to each
   Ii            # if second_input is true
     RƶR         # reverse, multiply each element with its 1-based index and reverse again
        ëƶ       # else, multiply each element with its 1-based index
          }      # end if
           J     # join
            C    # convert to base-10

— Emigna
स्रोत

2

आप के εलिए उपयोग कर सकते हैं -1:LbεIiRƶRëƶ}JC

— एरिक आउटगॉल्फ

@EriktheOutgolfer: उपयोग कर अच्छा विचार ë। ifइस मामले में एक आवेदन में मुद्दे के आसपास हो जाता है :)

— Emigna

3

भूसी , 13 बाइट्स

mȯḋṠṘo?ḣṫ⁰Lḋḣ

यह बहुत सारे पत्र हैं ...

पहले b( 0बाएं और 1दाएं के लिए) लेता है , फिर n। इसे ऑनलाइन आज़माएं!

व्याख्या

mȯḋṠṘo?ḣṫ⁰Lḋḣ  Inputs b=1 and n=5 (implicit).
            ḣ  Range to n: [1,2,3,4,5]
mȯ             Map function over the range:
                 Argument: number k=5
           ḋ     Binary digits: [1,0,1]
   ṠṘ            Repeat each digit with respect to the list
     o    L      obtained by applying to the length (3) the function
      ?  ⁰       if b is truthy
       ḣ         then increasing range: [1,2,3]
        ṫ        else decreasing range: [3,2,1].
                 We get [1,0,0,1,1,1].
  ḋ              Convert back to integer: 39
               Final result [1,4,7,32,39], implicitly print.

— Zgarb
स्रोत

आप शायद bतीन बाइट्स बचाते हुए सीधे ṫ या take के रूप में लेने का विकल्प चुन सकते हैं :)

— सिंह

@ लियो हम्म, यह एक फिसलन ढलान की तरह है। मैं पूरे कार्यक्रम के दो संस्करणों में से एक को भी ले सकता हूं bऔर मेरा समाधान सिर्फ I...

— Zgarb

3

जाप , 19 18 17 बाइट्स

01"दाएं" के लिए , "बाएं" के लिए। (यह वास्तव में उन 2 के स्थान पर कोई भी गलत या सच्चाई मान सकता है)

õÈ¤ËpV©EÄªEnFlÃn2

झसे आज़माओ

व्याख्या

पूर्णांकों का निहित इनपुट Uऔर V।

õ

1 से पूर्णांक, पूर्णांक की एक सरणी बनाएँ U।

È

एक समारोह के माध्यम से प्रत्येक गुजरती हैं।

¤

वर्तमान पूर्णांक को बाइनरी स्ट्रिंग में बदलें

Ë           Ã

स्ट्रिंग पर मैप करें, प्रत्येक वर्ण को एक फ़ंक्शन के माध्यम से पास करना, जहां Eवर्तमान सूचकांक है और Fपूर्ण स्ट्रिंग है।

वर्तमान चरित्र को दोहराएं

V©  ª

©तार्किक और ( &&) है और ªतार्किक OR है ||, इसलिए यहां हम जांच कर रहे हैं कि Vक्या सत्य (गैर-शून्य) है या नहीं।

YÄ

यदि Vसत्य है तो Xबार- Y+1बार आता है।

YnZl

तो Vफिर falsey है Xदोहराया जाता है Y(से घटाया n) लंबाई ( lके) Zबार।

n2

एक बेस 10 पूर्णांक में वापस कनवर्ट करें।

अवैध रूप से उत्पादन जिसके परिणामस्वरूप सरणी।

— झबरा
स्रोत

मुझे यह महसूस करने से पहले 16 से नीचे हो गया कि यह "nth आइटम" के बजाय "पहला n आइटम" था, इसलिए यह उतना बुरा नहीं है: P

— ETHproductions

@ETHproductions: आप उस गलती को करने वाले इकलौते नहीं थे;)

— झबरा

2

गैया , 15 बाइट्स

⟪¤bw¦¤;ċ%×†_b⟫¦

-1बाएँ और 1दाएँ के लिए उपयोग करता है ।

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

व्याख्या

⟪¤bw¦¤;ċ%×†_b⟫¦  Map this block over the range 1..n, with direction as an extra parameter:
 ¤                Swap, bring current number to the top
  b               List of binary digits
   w¦             Wrap each in a list
     ¤            Bring direction to the top
      ;ċ          Push the range 1..len(binary digts)
        %         Select every direction-th element of it (-1 reverses, 1 does nothing)
         ×†       Element-wise repetition
           _      Flatten
            b     Convert from binary to decimal

— बिजनेस कैट
स्रोत

2

प्रोटॉन , 79 बाइट्स

n=>d=>[int(''.join(b[x]*[l-x,x-1][d]for x:2..(l=len(b=bin(i)))),2)for i:1..n+1]

0छोड़ दिया है, 1सही है।

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

Ungolfed

f=n=>d=>                        # Curried function
[                               # Collect the results in a list
 int(                           # Convert from a binary string to an int:
  ''.join(                       # Join together
   b[x]                           # Each character of the binary string of n
   *[l-x,x-1][d]                  # Repeated by its index or its index from the end, depending on d
   for x:2..(l=len(b=bin(i))))    
 ,2)
 for i:1..n+1                   # Do this for everything from 1 to n inclusive
]

— बिजनेस कैट
स्रोत

2

सी # (.NET कोर) , 192 187 + 23 बाइट्स

-5 बाइट्स थैंथाल्कर के लिए धन्यवाद

b=>n=>new int[n].Select((_,a)=>{var g=Convert.ToString(a+1,2);return(long)g.Reverse().SelectMany((x,i)=>Enumerable.Repeat(x,b?i+1:g.Length-i)).Select((x,i)=>x>48?Math.Pow(2,i):0).Sum();})

बाइट काउंट में ये भी शामिल हैं:

namespace System.Linq{}

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

इनपुट: leftहै true,right हैfalse

स्पष्टीकरण:

b => n =>                                   // Take two inputs (bool and int)
    new int[n].Select((_, a) => {           // Create new collection the size of n
        var g = Convert.ToString(a + 1, 2); // Take every number in sequence 1..n and convert to base 2 (in a string)
        return (long)g.Reverse()            // Reverse the bits
               .SelectMany((x, i) =>        // Replace every bit with a collection of its repeats, then flatten the result
                   Enumerable.Repeat(x, b ? i + 1 : g.Length - i))
               .Select((x, i) => x > 48 ? Math.Pow(2, i) : 0)
               .Sum();                      // Replace every bit with a corresponding power of 2, then sum
    })

— ग्रेज़गोरज़ पुलावस्की
स्रोत

1

tio.run/…

— TheLethalCoder

185 + 23 ^ (एक टिप्पणी में बहुत लंबा था)

— TheLethalCoder

@LethalCoder धन्यवाद! हालांकि दुर्भाग्य से, यह 187 है क्योंकि हमें 0 में शुरू होने के बाद से सूचकांक में 1 जोड़ने की आवश्यकता है, और अनुक्रम 1 से शुरू होता है

— Grzegorz Puławski

using System.Linq;से छोटा नहीं है namespace System.Linq{}, या मैं यहाँ कुछ याद कर रहा हूँ? बहुत समय पहले मैंने .NET tbh .. में प्रोग्राम किया था

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

1

@KevinCruijssen इस का उपयोग करता है Mathऔर Convertजो दोनों Systemनामस्थान में हैं, इसलिए namespace System.Linqसबसे छोटा है - यह दोनों Systemऔर System.Linqवर्गों का उपयोग करने की अनुमति देता है ।

— ग्रेज़गोरज़ पुलावस्की 19

2

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

{2⊥b/⍨⌽⍣⍺⍳≢b←2⊥⍣¯1⊢⍵}¨⍳

बाएं 1दायां है 0(फ़ंक्शन के बाएं तर्क के रूप में पारित किया गया है)

⍳ सूचकांक जनरेटर है

{... }¨दाईं ओर प्रत्येक आइटम में ब्रेसिज़ में फ़ंक्शन लागू करें

b←2⊥⍣¯1⊢⍵b (बाइनरी के रूप में एन्कोडेड है ( ⍵बेस 2 में प्रतिनिधित्व करने के लिए आवश्यक बिट्स की न्यूनतम संख्या प्राप्त करने के लिए डिकोड के व्युत्क्रम का उपयोग करके )

⍳≢bवेक्टर बी के लिए अनुक्रमणिका बनाएं (b ≢bकी लंबाई है)

⌽⍣⍺ उलटा ⍺ समय (बाएं या दाएं खिंचाव के लिए सशर्त रूप से यहां उपयोग किया जाता है)

b/⍨ b ((रिवर्स) इंडेक्स के अनुसार बिट्स की प्रतिकृति)

2⊥ बेस 2 से डीकोड

TryAPL ऑनलाइन

— गिल
स्रोत

2

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

यह शैगी के जवाब से काफी लंबा है , लेकिन मैं विशुद्ध रूप से बिटवाइज़ दृष्टिकोण की कोशिश करना चाहता था।

JS बिटवाइज़ ऑपरेशंस की 32-बिट सीमा के कारण, यह केवल n <128 के लिए काम करता है ।

करी वाक्यविन्यास में इनपुट लेता है (n)(r), जहाँ r दाएं / बाएं सत्य के लिए मिथ्या है ।

n=>r=>[...Array(n)].map((_,n)=>(z=n=>31-Math.clz32(n),g=n=>n&&(x=z(b=n&-n),r?2<<z(n)-x:b*2)-1<<x*(r?2*z(n)+3-x:x+1)/2|g(n^b))(n+1))

प्रारूपित और टिप्पणी की गई

n => r => [...Array(n)]       // given n and r
  .map((_, n) => (            // for each n in [0 .. n - 1]
    z = n =>                  //   z = helper function returning the
      31 - Math.clz32(n),     //       0-based position of the highest bit set
    g = n =>                  //   g = recursive function:
      n && (                  //     if n is not equal to 0:
        x = z(b = n & -n),    //       b = bitmask of lowest bit set / x = position of b
        r ?                   //       if direction = right:
          2 << z(n) - x       //         use 2 << z(n) - x
        :                     //       else:
          b * 2               //         use b * 2
      ) - 1                   //       get bitmask by subtracting 1
      << x * (                //       left-shift it by x multiplied by:
        r ?                   //         if direction = right:
          2 * z(n) + 3 - x    //           2 * z(n) + 3 - x
        :                     //         else:
          x + 1               //           x + 1
      ) / 2                   //       and divided by 2
      | g(n ^ b)              //     recursive call with n XOR b
    )(n + 1)                  //   initial call to g() with n + 1
  )                           // end of map()

डेमो

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

let f =

n=>r=>[...Array(n)].map((_,n)=>(z=n=>31-Math.clz32(n),g=n=>n&&(x=z(b=n&-n),r?2<<z(n)-x:b*2)-1<<x*(r?2*z(n)+3-x:x+1)/2|g(n^b))(n+1))

console.log(JSON.stringify(f(10)(false)))
console.log(JSON.stringify(f(10)(true)))

Expand snippet

— Arnauld
स्रोत

ठीक है, मैं अब अपनी लंबाई के बारे में थोड़ा बेहतर महसूस कर रहा हूं, यह देखते हुए कि आप एक छोटे समाधान के बजाय लंबे समाधान के लिए गए थे।

— झबरा

1

" (ओपी के अनुमोदन पर लंबित)। " मुझसे अनुमोदित :) +1।

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

2

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

ओह, यह अभी बहुत लंबा है! यह तब होता है जब आप "वास्तविक" जावास्क्रिप्ट लिखने के दिन बिताते हैं, kiddies; आप ठीक से गोल्फ कैसे भूल जाते हैं!

"बाएं" होने और "दाएं" होने के bसाथ, किसी भी सत्य या गलत मूल्यों का उपयोग करता है ।falsetrue

n=>b=>[...Array(n)].map(_=>eval("0b"+[...s=(++e).toString(2)].map((x,y)=>x.repeat(b?++y:s.length-y)).join``),e=0)

कोशिश करो

o.innerText=(f=
n=>b=>[...Array(n)].map(_=>eval("0b"+[...s=(++e).toString(2)].map((x,y)=>x.repeat(b?++y:s.length-y)).join``),e=0)
)(i.value=10)(j.value=1);oninput=_=>o.innerText=f(+i.value)(+j.value)

label,input{font-family:sans-serif;font-size:14px;height:20px;line-height:20px;vertical-align:middle}input{margin:0 5px 0 0;width:100px;}

<label for=i>Size: </label><input id=i type=number><label for=j>Direction: </label><input id=j min=0 max=1 type=number><pre id=o>

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

— झबरा
स्रोत

1

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

B€xJṚ⁹¡$$€Ḅ

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

तर्क # 1: n
तर्क # 2: 1बाएं के लिए, 0दाएं के लिए।

— आउटगोल्फ को एरिक करें
स्रोत

1

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

\d+
$*
1
$`1¶
+`(1+)\1
${1}0
01
1
.
$.%`$*R$&$.%'$*L
+s`(R?)(\d)(L?)(.*¶\1\3)$
$2$2$4
¶*[RL]

1
01
+`10
011
%`1

इसे ऑनलाइन आज़माएं! संख्या और या तो Lया Rप्रत्यय के रूप में लेता है (या एक अलग रेखा पर)। स्पष्टीकरण:

\d+
$*
1
$`1¶

दशमलव से यूनरी में परिवर्तित करें और 1 से गिनती करें n।

+`(1+)\1
${1}0
01
1

अनरी से बाइनरी में कनवर्ट करें।

.
$.%`$*R$&$.%'$*L

लाइन में अपनी स्थिति के अनुसार प्रत्येक बिट को Rऔर Lवर्णों में लपेटें ।

+s`(R?)(\d)(L?)(.*¶\1\3)$
$2$2$4

उपयुक्त आसन्न अंक के साथ प्रासंगिक Rया Lवर्ण बदलें ।

¶*[RL]

1
01
+`10
011
%`1

बाईं ओर के वर्णों को निकालें और बाइनरी से दशमलव में परिवर्तित करें।

— नील
स्रोत

1

नमस्ते, आपको सभी नंबरों से आउटपुट 1करना होगा n। सिर्फ n'वें नंबर नहीं।

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

@ केविनक्रूजसेन बाह, मेरी उप -100 बाइट की गिनती ...

— नील

1

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

3 बाइट्स, धन्यवाद केविन

मुझे यकीन है कि इस साइट के लिए पर्याप्त ES6 पता नहीं है, लेकिन मैंने कोशिश की! प्रत्येक संख्या के माध्यम से लूप, और उस संख्या के लिए प्रत्येक बाइनरी प्रतिनिधित्व के माध्यम से लूप, प्रत्येक वर्ण को दोहराते हुए हालांकि कई बार जरूरत होती है।

d=>n=>{i=0;while(i++<n){b=i.toString(2),s="",k=-1,l=b.length;while(++k<l)s+=b[k].repeat(d?k+1:l-k);console.log(parseInt(s,2))}}

f=d=>n=>{i=0;while(i++<n){b=i.toString(2),s="",k=-1,l=b.length;while(++k<l)s+=b[k].repeat(d?k+1:l-k);console.log(parseInt(s,2))}}
f(1)(10)
f(0)(10)

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

— स्वेन राइट्स कोड
स्रोत

1

मुझ से +1। :) मुझे लगता है कि आप एक करी इनपुट ( d=>n=>) का उपयोग करके एक बाइट को बचा सकते हैं , जैसे अन्य दो जेएस ईएस 6 जवाबों ने किया था। इसके अलावा, मुझे लगता है कि आप को बदलने के द्वारा एक और 2 बाइट्स बचा सकते हैं k=-1,l=b.length;while(++k<l)s+=b[k].repeat(d?k+1:l-k);करने के लिए k=0,l=b.length;while(k<l)s+=b[k++].repeat(d?k:l+~k);(शुरू करने k=0के बजाय -1, और l-k-1जो तब के लिए आवश्यक है करने के लिए छोटा है l+~k)। इसके अलावा, क्या (i).toString(2)आवश्यक के आसपास कोष्ठक हैं ?

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

1

ऐसा +~kलगता है कि यह काम करना चाहिए, लेकिन मैं इसका पता नहीं लगा सकता, पागल हो रहा है। अन्य सुझावों के लिए धन्यवाद!

— स्वेन कोड कोड

1

आह, l+~kयह गलत है, क्योंकि यह नहीं है .. l-k-1लेकिन l-k+1मेरा बुरा है। आप अभी भी kशून्य पर शुरू करके एक बाइट को गोल्फ कर सकते हैं k=0,l=b.length;while(k<l)s+=b[k++].repeat(d?k:l-k+1);:।

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

1

रूबी, 98 बाइट्स

->n,r{t=->a{r ?a:a.reverse};(1..n).map{|k|i=0;t[t[k.to_s(2).chars].map{|d|d*(i+=1)}].join.to_i 2}}

— एम-Chrzan
स्रोत

क्या टर्नरी में स्थान a{r ?a:a.reverse}आवश्यक है?

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

2

हाँ। रूबी विधियां समाप्त हो सकती हैं ?, r?एक विधि नाम के रूप में व्याख्या की गई होगी।

— m-chrzan

आह ठीक है, स्पष्टीकरण के लिए धन्यवाद। रूबी में कभी भी प्रोग्राम नहीं किया गया था, लेकिन यह एक नियमित टर्नरी जैसा दिखता था-अगर मैं जावा (या सी #) में उपयोग करता हूं, तो मेरी टिप्पणी।

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

1

जावा 8, 136 बाइट्स

के Booleanएक उपभोक्ता से लैम्ब्डा (करी) Integer। बूलियन पैरामीटर इंगित करता है खिंचाव बाईं ओर है कि क्या (मूल्यों true, false)। आउटपुट को स्टैंडर्ड आउट करने के लिए प्रिंट किया जाता है, जिसे नई कड़ियों द्वारा अलग किया जाता है, एक अनुगामी न्यूलाइन के साथ।

l->n->{for(int i=0,o,c,d,s=0;i++<n;System.out.println(o)){while(i>>s>0)s++;for(o=c=0;c++<s;)for(d=0;d++<(l?s-c+1:c);o|=i>>s-c&1)o<<=1;}}

अघोषित लंबोदर

l ->
    n -> {
        for (
            int i = 0, o, c, d, s = 0;
            i++ < n;
            System.out.println(o)
        ) {
            while (i >> s > 0)
                s++;
            for (o = c = 0; c++ < s; )
                for (
                    d = 0;
                    d++ < (l ? s - c + 1 : c);
                    o |= i >> s - c & 1
                )
                    o <<= 1;
        }
    }

यह ऑनलाइन की कोशिश करो

सीमाएं

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

व्याख्या

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

आंतरिक whileलूप sबिट्स की संख्या में वृद्धि करता है i, और बाद में प्रत्येक बिट स्थिति पर forपुनरावृत्त cहोता है। उस लूप के भीतर, dवर्तमान बिट को दोहराने के लिए कई बार गिना जाता है, जो इनपुट पर निर्भर करता है l। प्रत्येक चरण पर, oबाईं ओर स्थानांतरित कर दिया जाता है और उपयुक्त बिट iको नकाबपोश किया जाता है और अंदर जाता है।

— जेकब
स्रोत

यह एक खिंचाव की एक बिट है St

इनपुट:

आउटपुट:

चुनौती नियम:

सामान्य नियम:

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

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

05AB1E , 14 13 बाइट्स

भूसी , 13 बाइट्स

व्याख्या

जाप , 19 18 17 बाइट्स

व्याख्या

गैया , 15 बाइट्स

व्याख्या

प्रोटॉन , 79 बाइट्स

Ungolfed

सी # (.NET कोर) , 192 187 + 23 बाइट्स

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

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

प्रारूपित और टिप्पणी की गई

डेमो

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

कोशिश करो

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

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

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

रूबी, 98 बाइट्स

जावा 8, 136 बाइट्स

अघोषित लंबोदर

सीमाएं

व्याख्या

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