Rien संख्या

38

Champernowne स्थिरांक एक ऐसी संख्या है जिसका निर्माण अनंत की ओर झुकाव के nसाथ, पहली संख्या को समाप्‍त करके nकिया जाता है। यह कुछ इस तरह दिखता है:

0.123456789101112131415161718192021222324252627282930...

अब, मैं आपको Rien संख्या का वर्णन करूंगा । इसे एक पूर्णांक के रूप में Champernowne स्थिरांक के न्यूनतमकरण के रूप में माना जा सकता है। मैं री ( n ) के रूप में पहले अंकों के साथ Rien संख्या का उल्लेख करूंगा । इसे कैसे तैयार किया जाए:n

  1. पहली nप्राकृतिक संख्याएं (अनुक्रम {1,2,3, ...}) समवर्ती हैं।
  2. यह परिणाम तब अंकों के अनुसार क्रमबद्ध होता है। तो 1..12ऐसा लगेगा 011111223456789।
  3. चूंकि Rien संख्या अग्रणी शून्य नहीं हो सकता है, हम ले जाने के सभी 0, इसलिए कि वे महत्वपूर्ण हैं, संख्या कम से कम, में, कहते हैं, जिसके परिणामस्वरूप रखने whilst 101111223456789। यह Ri ( n ) है, इस मामले में, Ri (12)।

री ( n ) के लिए कुछ परिणाम यहां दिए गए हैं :

एन     री ( एन )
1 1
२ १२
3 123
7 1234567
९ १२89४५६89 ९ 89
10 10123456789
15 101111111223344556789
34 100011111111111112222222222222223333333334444555666777888999
42 10000111111111111112222222222222223333333333333333334444444555566667777888899
45 1000011111111111111222222222222222333333333333333333344444444445555556666777788889999
55 1000001111111111111222222222222222222333333333333333333334444444444444444455555555555555666667777788889999999
100 100000000000111111111111111111112222222222222222222222233333333333333333333333333333334444444444444444444444445555555555555555555555555566666666666666666666777777777777777777777777778888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888887
999100000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000011111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111111222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222222333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333333444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444444555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555555666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777777888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888888999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999999

उद्देश्य एक संख्या को देखते हुए Given n<10000 इनपुट के रूप में (तर्कों के माध्यम से, STDIN, या हार्डकोडिंग यदि आपकी भाषा पारंपरिक इनपुट का समर्थन नहीं करती है), आउटपुट / वापसी री ( n)।

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

संदर्भ कार्यान्वयन

मैंने IE में इसका परीक्षण किया, इसलिए वास्तव में कोई समस्या नहीं होनी चाहिए। अगर वहाँ है एक समस्या है, वहाँ एक आसान समाधान है: एक समझदार ब्राउज़र प्राप्त करें।

function min(n) {
  var seq = [];
  for(var i = 1; i <= n; i++) seq.push(i);
  seq = seq.join("").split("").map(Number);
  var to;
  if(seq.indexOf(1) >= 0) to = seq.splice(seq.indexOf(1), 1);
  seq.sort(function(a, b) {
    return a - b;
  });
  if(to) seq = to.concat(seq);
  return seq.join("");
}
t.onchange = t.onkeyup = function() {
  h.innerHTML = min(this.value)
}
* {
  font-family: Consolas, monospace;
}
input {
  border: 2px dotted #aaaaaa;
  border-radius: 5px;
  margin: 10px;
}
<input id="t" type="number">
<div id="h">
स्निपेट का विस्तार करें

लीडरबोर्ड

इस पोस्ट के निचले हिस्से में स्टैक स्निपेट उत्तर से सूची बनाता है) क) प्रति भाषा में सबसे छोटे समाधान की सूची के रूप में और बी) एक समग्र लीडरबोर्ड के रूप में।

यह सुनिश्चित करने के लिए कि आपका उत्तर दिख रहा है, कृपया अपना उत्तर शीर्षक मार्कडाउन टेम्पलेट का उपयोग करके शीर्षक के साथ शुरू करें:

## Language Name, N bytes

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

## Ruby, <s>104</s> <s>101</s> 96 bytes

यदि आप अपने हेडर में कई संख्याओं को शामिल करना चाहते हैं (जैसे कि आपका स्कोर दो फ़ाइलों का योग है या आप दुभाषिया ध्वज दंड को अलग से सूचीबद्ध करना चाहते हैं), तो सुनिश्चित करें कि हेडर में वास्तविक अंक अंतिम संख्या है:

## Perl, 43 + 2 (-p flag) = 45 bytes

आप भाषा के नाम को एक लिंक भी बना सकते हैं जो बाद में स्निपेट में दिखाई देगा:

## [><>](http://esolangs.org/wiki/Fish), 121 bytes

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

code-golf  math  number  sequence  sorting 
— कोनोर ओ ब्रायन
स्रोत
22
मैंने हमेशा सोचा था 0कि रियान नंबर है।
— दोष
यकीन नहीं होता कि मुझे कुछ याद आ रहा है, लेकिन हम सिर्फ 1एस में से एक के सामने कदम रख सकते हैं 0, हाँ?
— FryAmTheEggman
@FryAmTheEggman आप सही हैं।
— कॉनर ओ'ब्रायन
@ मार्टिनबटनर ओ / आपको मिला।
— कॉनर ओ'ब्रायन
@ C @O'Bʀɪᴇɴ नहीं कि एक अलग था। यह केवल उनके व्यक्तिगत अंकों की नहीं बल्कि पूरे नंबरों की अनुमति देता है।
— मार्टिन एंडर

जवाबों:

12

अजगर,,

+1SjktSQ

एक सूची बनाता है [1, .. , input]फिर अग्रणी को हटाता है, जुड़ता है और सॉर्ट करता है, फिर 1 को प्रीपेन्ड करता है।

परीक्षण सूट

— FryAmTheEggman
स्रोत
13

पर्ल, 44 42 41 33 31 बाइट्स

याय, पहली पोस्ट कभी!

2 बाइट बचाने के लिए प्राइमो का धन्यवाद।

print 1,sort"@{[2..<>]}"=~/\d/g

जैसा कि अन्य लोगों ने किया, 1 को हटाकर इसे मैन्युअल रूप से तैयार करने का काम करता है।

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

— पॉल पिकार्ड
स्रोत
2
PPCG में आपका स्वागत है, और आपकी पहली पोस्ट पर बधाई (हालांकि यह अजीब लग रहा है कि मैं आपका स्वागत करता हूं, क्योंकि आपने मेरे साथ काम किया था ...)। दो चीजें - मैं 43 बाइट्स गिनता हूं ... दूसरा, आपका "यह ऑनलाइन प्रयास करें" लिंक आपके कोड के पुराने / अलग संशोधन को इंगित करता है। अपने कोड को Ideone में मैन्युअल रूप से कॉपी-पेस्ट करना, लेकिन आपका लिंक नहीं।
— AdmBorkBork
आपकी टिप्पणी के लिए धन्यवाद ! मैंने बाइट काउंट के लिए TextWrangler का उपयोग किया, मुझे लगता है कि मैं 1 बहुत दूर चला गया ... (प्लस एक स्थान की आवश्यकता नहीं थी, ताकि पूरे बाइटकाउंट को 42 तक कम कर दिया जाए)। Ideone अब तय किया जाना चाहिए।
— पॉल पिकार्ड
ओह, उस के बारे में पता नहीं था। मेरे मैक पर मेरे पर्ल पर भी काम करता है (5.18) धन्यवाद!
— पॉल पिकार्ड
5
— AdmBorkBork
2
विभाजन से छुटकारा पाने के लिए दो बाइट्स print 1,sort"@{[2..<>]}"=~/\d/g
— बचाएं
11

जाप, 14 12 बाइट्स

1+2o°U ¬¬n ¬

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

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

1+2o°U ¬¬n ¬  // Implicit: U = input integer
  2o°U        // Generate the range of integers from 2 to U, inclusive.
       ¬¬     // Join, then split into chars.
         n    // Sort.
1+         ¬  // Join again, and add a 1 to the beginning.
              // Implicit: output last expression
— ETHproductions
स्रोत
4
o_o ने आपको 5 मिनट के ग्रेस पीरियड में गोल्फ दिया? सबसे तेज़-बंदूक-इन-वेस्ट
— कॉनर ओ'ब्रायन
@ C @O'Bʀɪᴇɴ मुझे लगता है कि आप उसके बाद नए कोड
— गोल्फ
9

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

रेटिना की कुछ नई विशेषताओं को दिखाने का समय (यह अभी भी बहुत प्रतिस्पर्धी नहीं है, लेकिन आज से पहले यह संभवतः 300 बाइट्स के करीब होगा)।

.+
$0$*1
\B
 $`
(1)+
$#1
^1| 

.
 1$0$*1
+r`(1+\2) (1+)\b
$2 $1
 1(1)*
$#1
^
1

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

व्याख्या

हालांकि दशमलव और यूनीरी के बीच अब बहुत आसानी से परिवर्तित करना संभव है, यह अभी भी काफी लंबा है क्योंकि मुझे कई बार आगे और पीछे बदलना होगा क्योंकि कुछ संचालन दशमलव में यूरीरी और इसके विपरीत में अधिक उल्लेखनीय हैं।

.+
$0$*1

आइए इनपुट को यूनरी में परिवर्तित करके शुरू करें। यह इनपुट के मिलान से काम करता है और फिर $*1जिसके उपयोग से 1कई बार दोहराता है (यह पुनरावृत्ति सुविधा आज की तरह नई है)।

\B
 $`

इसके बाद, हम से एक सीमा उत्पन्न 1करने के लिए Nएकल में। मैंने बताया है कि यह मेरे FizzBuzz उत्तर में क्यों काम करता है ।

(1)+
$#1

हम प्रत्येक संख्या को वापस सीमा में दशमलव में परिवर्तित करते हैं ताकि हम दशमलव अंकों के साथ काम कर सकें। यह प्रत्येक यूनरी संख्याओं के मिलान द्वारा किया जाता है जैसे कि प्रत्येक 1एक अलग कैप्चर उत्पन्न करता है। फिर हम नए कैप्चर काउंट सिंटैक्स का उपयोग करते हुए समूह एक के कैप्चर की संख्या के साथ प्रतिस्थापित करते हैं $#1।

^1|

यह 1स्ट्रिंग से सभी रिक्त स्थान के साथ-साथ अग्रणी को भी हटा देता है ताकि हम केवल अंकों (एक को छोड़कर 1) के साथ छोड़ दें ।

.
 1$0$*1

हम वापस यूनरी में परिवर्तित होते हैं 1और प्रत्येक अंक में जोड़ते हैं (यह सुनिश्चित करने के लिए कि 0एक गैर-रिक्त भी है)। हम यह सुनिश्चित करने के लिए कि वे अलग हैं, प्रत्येक अंक के सामने एक स्थान सम्मिलित करते हैं।

+r`(1+\2) (1+)\b
$2 $1

हम बार-बार एक बड़ी संख्या से पहले एक छोटी संख्या से मेल खाते हैं और उन्हें स्वैप करते हैं। यह रेटिना में बुलबुला की तरह है। :)

 1(1)*
$#1

Aaaand वापस दशमलव के लिए।

^
1

अंत में, हम 1सामने वाले को पहले से हटाए गए खाते के लिए एक एकल सम्मिलित करते हैं ।

— मार्टिन एंडर
स्रोत
1
क्या नई सुविधाओं की बात करते हो?
— कॉनर ओ'ब्रायन
1
@ C @O'Bʀɪᴇɴ मैं बाद में एक स्पष्टीकरण जोड़ूंगा। यह एक कैप्चर की गिनती और दोहराए जाने वाले वर्णों के लिए नए प्रतिस्थापन वाक्यविन्यास का उपयोग करता है जो कि यथोचित रूप से लघु दशमलव / एकरी रूपांतरण के लिए उपयोग किया जा सकता है। यहाँ पूरा चैंज है: github.com/mbuettner/retina/blob/master/CHANGELOG.md
— मार्टिन एंडर
@ मार्टिनबटनर अच्छा लगा। क्या इसका मतलब यह है कि रेटिना अब इस छूट का दावा नहीं कर सकती है ?
— डिजिटल ट्रामा
@DigitalTrauma मुझे लगता है कि यह अभी भी इनपुट का सबसे स्वाभाविक रूप है। इसके अलावा मुझे यह समझ में नहीं आया कि इस तरह की भाषा-इस्म को कभी इस साइट पर इतना समर्थन कैसे मिला।
— मार्टिन एंडर
6

हास्केल, 44 बाइट्स

import Data.List
f n='1':sort(show=<<[2..n])

दुर्भाग्य sortसे Data.List, यह 17 बाइट्स में है!

— nimi
स्रोत
6

जावास्क्रिप्ट (ईएस 6), 65 62 54 52 बाइट्स

सहेजे गए 3 बाइट्स edc65 के लिए धन्यवाद

x=>eval("for(b='';x>1;)1+[...b+=x--].sort().join``")

2 से लेकर सभी संख्याओं की एक स्ट्रिंग बनाता है x, फिर विभाजित करता है, जुड़ता है, और शुरुआत में 1 जोड़ता है। यह अभी भी गोल्फ हो सकता है; सुझावों का स्वागत है!

— ETHproductions
स्रोत
मेरे पास हाथ पर ES6 नहीं है, लेकिन क्या आप सिर्फ (नए) का उपयोग नहीं कर सकते हैं Array(x-1).map((_,y)=>y+2)?
— कॉनर ओ'ब्रायन
@ C @O'Bʀɪᴇɴ नक्शा खाली सरणी तत्वों को छोड़ देता है, इसलिए आपको उपयोग करना चाहिए Array(n).fill().map(...(
— ईएस
मेरे पोस्ट करने के लिए बहुत देर हो चुकी है, लेकिन आपके लिए एक संकेत: n=>1+[...[...Array(n-1)].map(_=>++n,n=1).join``].sort().join`` (1 बाइट छोटी, यह विभाजन है)
— edc65
@ edc65 और Cᴏɴᴏʀ O'Bʀɪᴇɴ सुझावों के लिए धन्यवाद! मैंने सोचा कि क्यों .split()अजीब लगा ...
— ETHproductions
@ edc65 हुह, क्या मेरा समाधान आपकी लंबाई के समान है:n=>1+[...[...Array(n+1).keys()].slice(2).join``].sort().join``
— नील
5

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

"1"<>ToString/@Sort[Join@@IntegerDigits[2~Range~#]]&

एक बार फिर, स्ट्रिंग प्रसंस्करण हुआ ...

— LegionMammal978
स्रोत
मुझे लगता है कि IntegerDigitsसूचियों पर धागे हैं इसलिए आपको इसके नक्शे की आवश्यकता नहीं है।
— मार्टिन एंडर
ओह ठीक है, मिसाल।
— मार्टिन एंडर
4

एपीएल (17)

'1',∆[⍋∆←1↓∊⍕¨⍳⎕]

स्पष्टीकरण:

'1',∆[⍋∆←1↓∊⍕¨⍳⎕]
-----------------
               ⎕   read a number from the keyboard
               ⍳    get the natural numbers up to and including that number
             ⍕¨    get the string representation for each number
           ∊       flatten the array (giving a string of digits)
         1↓        remove the first digit (which is always 1)
       ∆←          store the result in ∆
      ⍋            get a permutation to sort ∆ upwards
    ∆[           ] rearrange ∆ so that it is sorted
'1',               add a 1 to the front

परीक्षा:

      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      1
1
      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      10
10123456789
      '1',∆[⍋∆←1↓∊⍕¨⍳⎕]
⎕:
      55
10000011111111111111122222222222222223333333333333333444444444444444455555555555566666777778888899999
— मारीनस
स्रोत
अच्छा! मेरे से बहुत बेहतर। : DI को यह एहसास नहीं था कि ∊यह सरणी को समतल कर देगा और आपको एक स्ट्रिंग देगा। यह जानकर अच्छा लगा।
— एलेक्स ए।
3

क्लोजुरस्क्रिप्ट, 48 बाइट्स

#(apply str"1"(sort(apply str(range 2(inc %)))))

सभी के रूप में ही, बहुत ज्यादा। आरईपीएल उपलब्ध यहाँ ।

— MattPutnam
स्रोत
3

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

एक अनाम फ़ंक्शन। मूल रूप से बस कुछ अन्य जवाब यहाँ Rubyfied ..

->n{n>1?(?1+[*2..n].join.chars.sort*'').to_i: n}
— daniero
स्रोत
3

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

1 .;{,1:.e?}?:1fcbZlL,ZoOlM,10^(L-M)=:Oc.

इनपुट के रूप में एक संख्या लेता है।

यह समाधान उन कुछ परिवर्तनों के साथ काम करता है जो मैंने अंतर्निहित Findall में समर्पित किए थे f। ओपी स्पष्ट रूप से उत्तर की तुलना में पुरानी भाषाओं का उपयोग करने के साथ ठीक है, इसलिए मुझे लगता है कि यह ठीक है (जो बदलाव मैंने किए थे, वे बहुत समय पहले किए गए थे, मैंने सिर्फ इस चुनौती के कारण ऐसा करने के लिए खुद को प्रेरित किया था)।

व्याख्या

1 .                                            § If the input is 1, unify output with 1

   ;                                           § Else

    {      }?:1f                               § Output a list of all inputs which satisfy
                                               § the predicate in brackets with the input
                                               § of the main predicate (ie the input number)
                                               § as output

     ,1:.e?                                    § True if the input is an integer between 1
                                               § and . (the output)

                cbZ                            § Concatenate everything into a single number,
                                               § remove the first digit (1) and call it Z

                   lL,ZoOlM,                   § L is the length of Z, M is the length of O
                                               § O being Z sorted (which removes the leading
                                               § 0s)

                            10^(L-M)=:Oc.      § Concatenate 10^(L-M) at the beginning of O
                                               § and unify it with the output
— Fatalize
स्रोत
3

स्मालटाक, 76 बाइट्स

स्मालटाक में हमेशा की तरह, वैचारिक रूप से बहुत ही चर्चित, लेकिन पाठकीय रूप से बहुत ही क्रियात्मक ...

f:l^'1',((2to:l)fold:[:p :q|p asString,q asString])asByteArray sort asString

इसे क्लास विधि के रूप में जोड़ें Stringऔर इस तरह से कॉल करें, जैसे 20 के लिए,String f: 20

3

बैश + जीएनयू उपयोगिताओं, 58

seq $1|sed 's/./&\n/g'|sort|tr -d \\n|sed 's/\(0*\)1/1\1/'

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

— डिजिटल आघात
स्रोत
1
मेरे पास एक समान दृष्टिकोण था, लेकिन "1 शुरुआत में" भाग (52 बाइट्स) का एक अलग हैंडलिंग। आपके साथ, आप शेव कर सकते हैं: सॉर्ट (1 अंक लंबा, एन-एन की कोई आवश्यकता नहीं)।
— ओलिवियर दुलक
3

बैश, 35 34 बाइट्स

printf %d 1`seq 2 $1|fold -1|sort`

यह @DigitalTrauma और @OlivierDulac के उत्तर पर बनाता है । Ideone के साथ इसे ऑनलाइन आज़माएं ।

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

  • seq 2 $1कमांड लाइन पर निर्दिष्ट 2 से सभी पूर्णांक प्रिंट करता है ।

  • fold -1 चौड़ाई 1 के साथ सभी पंक्तियों को लपेटता है, अर्थात, प्रत्येक वर्ण को अपनी रेखा पर रखता है।

    -1 एक अनिर्दिष्ट सुविधा लगती है।

  • sort वर्णों को उनके संख्यात्मक मान द्वारा क्रमबद्ध करें।

  • printf %d 1`...`​पहली पंक्ति में 1 को प्रीपेन्ड करता है और प्रत्येक लाइन को पूर्णांक ( %d) के रूप में प्रिंट करता है , जिसमें कोई अलगाव नहीं है।

    यह बैश के उत्सुक प्रिंटफ कार्यान्वयन का लाभ उठाता है, जो प्रारूप स्ट्रिंग को बार-बार दोहराता है, जब तक कि सभी तर्कों का उपभोग नहीं किया जाता है।

— डेनिस
स्रोत
+1, मुझे यह पसंद है कि हमारी तुलना में बेहतर है :)
— ओलिवियर दुलक
3

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

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

F=
x=>1+[...(g=_=>x>1?x--+g``:_)``].sort().join``

;console.log(F(15))
स्निपेट का विस्तार करें

— l4m2
स्रोत
1
मुझे कुछ ऐसा ही मिला लेकिन 1 बाइट छोटी थी। बिना किसी तर्क के एक पुनरावर्ती कार्य का उपयोग करने का प्रयास करें, मूल पैरामीटर x
— edc65
2

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

n->"1"*join(sort([join(2:n)...]))

यह एक लंबोतरा फ़ंक्शन है जो एक पूर्णांक को स्वीकार करता है और एक स्ट्रिंग लौटाता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

हम सीमा का निर्माण करते हैं 2:n, जो n<2 के लिए खाली होगा , इसे एक स्ट्रिंग में शामिल करें, स्ट्रिंग को वर्णों की एक सरणी में विभाजित करें, उन्हें सॉर्ट करें, इसे एक स्ट्रिंग में शामिल करें, और 1 प्रीपेन्ड करें।

— एलेक्स ए।
स्रोत
2

एपीएल, 21 बाइट्स

{' '~⍨⍕1,x[⍋x←⍕1↓⍳⍵]}

यह एक अनाम मोनोडिक फ़ंक्शन है जो दाईं ओर पूर्णांक को स्वीकार करता है और एक स्ट्रिंग लौटाता है। इसे कॉल करने के लिए, इसे एक वैरिएबल पर असाइन करें।

स्पष्टीकरण:

            x←⍕1↓⍳⍵]}   ⍝ Get the numbers 1:input, drop 1, convert to string
         x[⍋            ⍝ Sort
      ⍕1,               ⍝ Tack 1 onto the front, flatten to string
{' '~⍨                  ⍝ Remove the spaces (side effect of ⍕ on an array)

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

— एलेक्स ए।
स्रोत
2

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

P=input();print"1"+"".join(sorted(`range(2,P+1)`)[P*2-4:-2])

जीत के लिए इंडेक्सिंग। :-)

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

P=input();print"1"+"".join(sorted(`range(-P,-1)`))[P*3-5:-2]

बस एक विकल्प है।

— Zach गेट्स
स्रोत
2

मिल्की वे 1.6.4 , 22 बाइट्स (प्रतिस्पर्धा नहीं)

^^'LH=^^JB", "-Q"1";+!

मुझे इस चुनौती के लिए एक छँटाई opcode जोड़ना पड़ा।

व्याख्या

^^                      ` pop the TOS
  '                     ` read input from the command line
   LH                   ` push a reversed Pythonic range(TOS+1)
     =^^J               ` remove the top 2 items from the TOS
         B              ` push the string literal of the TOS
          ", "-         ` remove ", " from the TOS
               Q        ` sort the TOS
                "1";+   ` add "1" to the beginning of the TOS
                     !  ` output the TOS
— Zach गेट्स
स्रोत
2

बैश और जीएनयू उपकरण, 58 52 बाइट्स

echo 1$(seq 2 $1|sed -e 's/./&\n/g'|sort|tr -d \\n)
— ओलिवियर दुलैक
स्रोत
@ डिजिटल-आघात की तुलना में समान दृष्टिकोण, लेकिन 1 को जोड़ने का अलग तरीका, और संख्याओं की कोई आवश्यकता नहीं है क्योंकि संख्याएं 1 अंक लंबी हैं। (मैंने अपना पहला प्रयास करने के बाद उसका जवाब देखा)
— ओलिवियर दुलक
2

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

param($a)(("1"+-join([char[]]-join(2..$a)|sort)),1)[$a-eq1]

इनपुट लेता है param($a)और फिर इसे एक सरणी में अनुक्रमित करने के लिए उपयोग करता है [$a-eq1]। यदि सही है, तो हम दूसरे तत्व और आउटपुट को अनुक्रमित करते हैं 1। अन्यथा, हम 1 द्वारा बनाई गई एड एरे के "1"साथ सम्‍मिलित करते हैं join) एक नई रेंज को परिभाषित करते हैं 2..$aजो खुद joinएक साथ एड होती है, 2) जो कि एक चार-एरे के रूप में कास्टिंग करते हैं, और 3) इसे Sort-Objectcmdlet के माध्यम से भेजते हैं , जो सभी तब आउटपुट है।

Edit1 - आंतरिक -joinऑपरेटर को स्थानांतरित करके 2 बाइट्स सहेजे गए ।

— AdmBorkBork
स्रोत
2

गोग , ९ 7 बाइट्स

GJT1-1P

आप इसका उपयोग करके चला सकते हैं:

$ ./gogh noi 'GJT1-1P' <input>

G     “ Push a range (1, TOS]       ”
J     “ Join the TOS                ”
T     “ Sort the TOS                ”
1-    “ Remove the first 1          ”
P     “ Prepend the TOS to the STOS ”
— Zach गेट्स
स्रोत
"आप इस प्रतियोगिता के बाद बनाई गई भाषा का उपयोग कर सकते हैं, जब तक कि इस चुनौती का जवाब देने के लिए नहीं बनाया गया था।" मैं ऐसी भाषाओं को अपनी चुनौतियों में आमतौर पर प्रतिस्पर्धी होने की अनुमति देता हूं;)
— कॉनर ओ'ब्रायन
@ C @O'Bʀɪᴇɴ: ओह, ज़बरदस्त! उस ओर इशारा करने के लिए धन्यवाद :)
— Zach Gates
2

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

RDFṢ1œ|Ḍ

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

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

RDFṢ1œ|Ḍ  Main link. Argument: n (integer)

R         Range; yield r := [1, ..., n].
 D        Convert each k in r into the array of its digits in base 10.
  F       Flatten the resulting array of lists.
   Ṣ      Sort the resulting flat list of digits.
    1œ|   Perform multiset union with 1 as left argument.
          This moves a single 1 to the beginning of the list.
       Ḍ  Convert the resulting list of base 10 to integer.
— डेनिस
स्रोत
2

Oracle SQL 11.2, 222 211 बाइट्स

SELECT 1||TRIM(xmlagg(xmlelement(e,c)).EXTRACT('//text()'))FROM(SELECT SUBSTR(s,LEVEL+2,1)c FROM(SELECT MAX(sys_connect_by_path(LEVEL,' '))s FROM DUAL CONNECT BY LEVEL<=:1)CONNECT BY LEVEL<=LENGTH(s)ORDER BY 1);

संयुक्त राष्ट्र के golfed

SELECT 1||TRIM(xmlagg(xmlelement(e,c)).EXTRACT('//text()'))  -- add leading 1, concatenate each char and remove spaces
FROM   (
         SELECT SUBSTR(s,LEVEL+2,1)c                          -- split the string in characters, omiting the first number (1)   
         FROM   (
                  SELECT MAX(sys_connect_by_path(LEVEL,' '))s -- create a string by concatenating numbers
                  FROM   DUAL 
                  CONNECT BY LEVEL<=:1
                )
         CONNECT BY LEVEL<=LENGTH(s)ORDER BY 1
       )
— Jeto
स्रोत
2

MATL , 17 बाइट्स

भाषा / संकलक के वर्तमान संस्करण (7.0.0) का उपयोग करता है ।

49[]i:"@YUh]6L)Sh

FryTheEgggman के जवाब से प्रेरित ।

EDIT (29 जुलाई, 2016): आप भाषा में बदलाव के अनुरूप कुछ संशोधनों के साथ इसे ऑनलाइन आज़मा सकते हैं।

उदाहरण

>> matl
 > 49[]i:"@YUh]6L)Sh
 >
> 12
101111223456789

व्याख्या

49        % push '1'
[]        % push empty array
i:        % input "N" and build vector [1, 2, ... N]
"         % for each number in this vector
   @      % push that number
   YU     % convert to string
   h      % concatenate horizontally
]         % end
6L)       % remove first element
S         % sort
h         % concatenate horizontally
— लुइस मेंडो
स्रोत
1

05AB1E , 6 बाइट्स

नोट: यह सबमिशन उन विशेषताओं का उपयोग करता है जो इस चुनौती को स्थगित करते हैं और इसलिए प्रतिस्पर्धी नहीं हैं

कोड:

Lß?J{?

स्पष्टीकरण:

L      # Creates the list [1 .. input]
 ß     # Extract the smallest value of the list
  ?    # Print this value (always 1)
   J   # ''.join(list)
    {  # Sort the string
     ? # Print this value

आईएसओ 8859-1 एन्कोडिंग का उपयोग करता है

— अदनान
स्रोत
यह कैसे काम करता है?
— २०:१६ पर lirtosiast
@ThomasKwa स्पष्टीकरण जोड़ा गया
— अदनान
वाह। यह शानदार है!
— कॉनर ओ'ब्रायन
1

मथकड, 86 "बाइट्स"

फ़ंक्शन s (n) प्रत्येक संख्या को उसके स्ट्रिंग रूप में परिवर्तित करके और उन्हें एक साथ समेट कर चम्पारणी "पूर्णांक" बनाने के लिए लूप के लिए उपयोग करता है। फिर स्ट्रिंग को ASCII कोड के अपने समकक्ष वेक्टर में बदल दिया जाता है और सॉर्ट किया जाता है। फ़ंक्शन फिर पहले वाले के साथ किसी भी अग्रणी शून्य को स्वैप करता है, अंत में वेक्टर को एक स्ट्रिंग में परिवर्तित करता है।

फ़ंक्शन की जांच करने के लिए, मैंने परीक्षण मामलों को वेक्टर vn में डाल दिया, फिर वेक्टर ऑपरेटर के उपयोग से v पर लागू किया गया। फिर मैं दिए गए परीक्षण मामले के मूल्यों के खिलाफ परिणामों की जांच करता हूं।

यहाँ छवि विवरण दर्ज करें

मथकाद गणितीय अनुप्रयोग है जो 2 डी वर्कशीट पर आधारित है जिसमें "क्षेत्र" शामिल हैं, जिनमें से प्रत्येक पाठ, एक गणितीय अभिव्यक्ति, कार्यक्रम, कथानक या स्क्रिप्टेड घटक हो सकता है।

गणितीय या प्रोग्रामिंग निर्देश को पैलेट टूलबार से उठाया जाता है या कीबोर्ड शॉर्टकट का उपयोग करके दर्ज किया जाता है। गोल्फ उद्देश्यों के लिए, एक ऑपरेशन ("बाइट") नाम या अभिव्यक्ति बनाने के लिए आवश्यक कीबोर्ड संचालन की संख्या के लिए लिया जाता है (उदाहरण के लिए, चर को 3 पर सेट करने के लिए, हम a: = 3 लिखेंगे। परिभाषा ऑपरेटर) : = एक सिंगल कीपर है ":", जैसा कि a और 3 कुल 3 "बाइट्स" दे रहे हैं। ऑपरेटर के लिए प्रोग्रामिंग के लिए टाइपिंग ctl-shft- # (या प्रोग्रामिंग टूलबार पर एक सिंगल क्लिक) की आवश्यकता होती है, इसलिए फिर से बराबर है। 1 बाइट।

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