एक गैर-नकारात्मक पूर्णांक ( n) को देखते हुए , एक फ़ंक्शन बनाएं जो nप्रत्येक अंक की शाब्दिक वर्तनी के अनुसार वर्णानुक्रम में वापस आता है n।

उदाहरण:

Input: 101
>> one, zero, one
>> one, one, zero
Output: 110

Input: 31948
>> three, one, nine, four, eight
>> eight, four, nine, one, three
Output: 84913

Input: 5544
>> five, five, four, four
>> five, five, four, four
Output: 5544

Input: 1234567890
Output: 8549176320

नोट: उदाहरण में परिचालनात्मक केवल चित्रण हैं और आउटपुट में शामिल करने की आवश्यकता नहीं है। केवल वर्णानुक्रम में क्रमबद्ध संख्या को वापस करने की आवश्यकता है।

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

संपादित करें: इनपुट को किसी भी वांछित प्रारूप में लिया जा सकता है जो आपकी भाषा के लिए सबसे अच्छा है, और फ़ंक्शन या प्रिंटिंग से लौटकर आउटपुट का उत्पादन इसी तरह किया जा सकता है। इनपुट हमेशा एक प्राकृतिक संख्या (0 सहित) होगी और इसमें अग्रणी 0 नहीं होगा।

@DomHastings द्वारा मिली प्रासंगिक OEIS प्रविष्टि (A057846)

code-golf number sorting

— atlasologist
स्रोत

1

क्या मैं एक स्ट्रिंग के रूप में भी संख्या ले सकता हूं और एक स्ट्रिंग आउटपुट कर सकता हूं?

— थ्रीएफएक्स

1

@nimi 00....

— TuxCrafting

5

आप यह निर्दिष्ट करना चाह सकते हैं कि इनपुट दशमलव में है, या आपको यूनीरी का उपयोग करके कुछ चुटीले उत्तर मिलेंगे ...

— मार्टिन एंडर

6

यह थोड़ा भ्रामक है: आपने टिप्पणियों में लिखा है कि आप फ़ंक्शन के इनपुट और आउटपुट के रूप में एक संख्यात्मक प्रकार की अपेक्षा करते हैं, लेकिन यह भी कि इसके बजाय परिणाम को प्रिंट करना ठीक है। इसलिए, यदि आउटपुट है 849, तो क्या इसका मतलब है कि हमें संख्या को प्रिंट करने की अनुमति है 849लेकिन स्ट्रिंग नहीं "849"? IMO यह पूरी तरह से ठीक चुनौती के शीर्ष पर सिर्फ एक बोझिल I / O प्रारूप (खराब!) है।

— लिन

1

अग्रणी शून्य महत्वपूर्ण है या नहीं? उदा। 001आउटपुट क्या है ? यदि वे महत्वपूर्ण हैं और परिणाम नहीं है 1, तो अधिकांश भाषाओं को स्ट्रिंग्स की आवश्यकता होगी क्योंकि सरल तथ्य के लिए इनपुट क्रूड, अव्यावहारिक है और आमतौर पर आधार 10 बेसल शाब्दिक संख्याओं में प्रमुख शून्य को संरक्षित करने के लिए पार्सर से पूछना असंभव है।

— बिल्ली

12

पर्ल 6 , 32 28 बाइट्स

{+[~] .comb.sort: *.Str.uniname}
{+[~] .comb.sort: *.uniname}

स्पष्टीकरण:

{
  # turn the following into a Numeric
  +

  # fold the following list using string concatenation operator
  [~]

    # split $_ into individual characters
    # (implicit method call on implicit parameter)
    .comb

    .sort:
    *.uniname # sort by the Unicode name of the character (digit)
}

परीक्षा:

#! /usr/bin/env perl6
use v6.c;
use Test;

my @tests = (
  101 => 110,
  31948 => 84913,
  5544 => 5544,
  1234567890 => 8549176320,
);

# give the lambda a lexical name for clarity
my &int-sort = {+[~] .comb.sort: *.uniname}

plan 3 * @tests;

for @tests -> $_ ( :key($input), :value($expected) ) {
  put '';
  isa-ok $input, Int, "input ($input) is an Int";

  my $output = int-sort $input;

  is $output, $expected, .gist;
  isa-ok $output, Int, "output ($output) is an Int"
}

1..12

ok 1 - input (101) is an Int
ok 2 - 101 => 110
ok 3 - output (110) is an Int

ok 4 - input (31948) is an Int
ok 5 - 31948 => 84913
ok 6 - output (84913) is an Int

ok 7 - input (5544) is an Int
ok 8 - 5544 => 5544
ok 9 - output (5544) is an Int

ok 10 - input (1234567890) is an Int
ok 11 - 1234567890 => 8549176320
ok 12 - output (8549176320) is an Int

— ब्रैड गिल्बर्ट b2gills
स्रोत

8

05AB1E, 12 11 10 बाइट्स

•OWÿ¾•vy†J

व्याख्या की

•OWÿ¾•        # push sortorder (236719458)
      v       # for each number in sortorder
       y†     # filter to the front
         J    # join
              # implicitly print

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

अदनान की बदौलत बचा 1 बाइट

— Emigna
स्रोत

8

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

समान चार गिनती संपादित करें , लेकिन वैश्विक चर से परहेज करेंz

इनपुट / आउटपुट स्ट्रिंग्स के रूप में

n=>[...n].sort((a,b)=>n[a]-n[b],n='9487216503').join``

परीक्षा

f=n=>[...n].sort((a,b)=>n[a]-n[b],n='9487216503').join``

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

test()

<input id=I type=number value=31948 oninput='test()'>
<pre id=O></pre>

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

— edc65
स्रोत

2

स्ट्रिंग के सूचकांकों के रूप में इनपुट अंकों का उपयोग करके इसे प्यार करें z...

— डोम हेस्टिंग्स

6

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

जैसा कि @nimi ने सुझाव दिया था, सूची संकलन का उपयोग करना रचनाओं की तुलना में कम है:

f x=0+read[a|a<-"8549176320",b<-show x,a==b]

मेरे संस्करण के संदर्भ के लिए:

f n=read.(=<<)(\x->filter(==x)$show n)$"8549176320"

पॉइंटफ्री संस्करण थोड़ा लंबा है:

f=flip(read.)"8549176320".(=<<).flip(filter.(==)).show

सीधा: अंकों को सही क्रम में फ़िल्टर करें और फिर परिणाम को संक्षिप्त करें।

— ThreeFx
स्रोत

5

पायथ, 12 10 बाइट्स

ox`C" »Ä\0

यकीन नहीं होता कि इसे और आगे बढ़ाया जा सकता है। इनपुट को उद्धरणों में संलग्न करने की आवश्यकता है।

2 बाइट्स @isaacg की बदौलत बच गए!

पायथोनिक स्यूडोकोड में:

                Q = input()
o          Q    sort(Q, key = lambda N:
  `C" »Ä\0        repr(base256toDec(" »Ä\0"))
 x        N         .index(N)     # 8 being absent from the number yields -1
                )

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

— busukxuan
स्रोत

@busukxuan मैं भी 14 बाइट्स प्राप्त करता हूं : पी।

— अदनान

@ अदनान फिर नंबर पर लौट आए। ऐसा लगता है कि इन नंबरों को संपीड़ित करने का कोई तरीका नहीं है ...

— बसुकक्सुआन

2

की जगह 2 बाइट्स सहेजें 549176320के साथC" »Ä\0

— isaacg

@isaacg धन्यवाद! मैंने इसे कुछ ही बार आधार 256 में बदलने की कोशिश की लेकिन परिणाम गलत था। आपने इसे सही कैसे किया?

— बसुक्ज़ुआन

1

आपको उनके साथ प्रतिस्थापित करके अशक्त बाइट्स से बचना होगा \0। शायद यही समस्या आप में चल रही थी।

— isaacg

4

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

36 बाइट्स कोड + 1 बाइट कमांड लाइन (-F)

say sort{8549176320=~/$b.*$a/||-1}@F

उपयोग उदाहरण:

echo -n "04823" | perl -F -M5.010 entry.pl

— Jarmex
स्रोत

3

MATL , 19 बाइट्स

Vt'8549176320'&m2$S

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

व्याख्या

V              % Implicitly input number. Convert to string (¹)
t              % Push copy of (¹)
'8549176320'   % Push this string (²), which defines order
&m             % Indices (³) of each element of (¹) in (²)
2$S            % Sort copy of (¹) according to (³). Implicitly display

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

3

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

“U1°ŀ”OṾf@€

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

व्याख्या

“U1°ŀ”O       Get the Unicode ordinals of “U1°ŀ”
                (all of which are coincidentally single bytes
                in the Jelly code page!)
              The result is [85, 49, 176, 320].
       Ṿ      Uneval. This gets us the string “85,49,176,320”.
        f@€   For each char in this string, extract all chars
                from the first command line argument that
                equal it.

— लिन
स्रोत

3

गणितज्ञ 35 78 47 बाइट्स

LIAMnYP द्वारा एक सुझाव के लिए 31 बाइट्स बचाए गए!

FromDigits@SortBy[IntegerDigits@#,IntegerName]&

IntegerDigitsअंकों को अंकों में तोड़ता है जो तब अंग्रेजी में उनके नाम के अनुसार क्रमबद्ध होते हैं। FromDigitsअंकों को आधार -10 संख्या में संयोजित करता है।

FromDigits@SortBy[IntegerDigits@#,IntegerName]&[1234567890]

8549176320

— DavidC
स्रोत

"SortBy" का उपयोग करके आपको शब्दों को अंकों में वापस परिवर्तित करने की समस्या नहीं है। FromDigits@SortBy[IntegerName]@IntegerDigits@#&

— LLLAMnYP

इसके अलावा Interpreterदर्द धीमा है, इसलिए यह एक अतिरिक्त बोनस है।

— LLLAMnYP

शानदार सुधार।

— डेविड जूल

मटक्का में 11 बाइट्स, जब भी अस्तित्व में आती है।

— माइकल स्टर्न

3

सी, 142 141 117

के रूप में पैरामीटर दर्रा long long *के लिए f(); फ़ंक्शन पैरामीटर को संशोधित करता है:

f(long long*n){char*c="8549176320",g[10]={0};for(;*n;*n/=10)++g[*n%10];for(;*c;++c)for(;g[*c-48]--;*n=*n*10+*c-48);}

long longपिछले परीक्षण के मामले में intजब एक छंटनी हुई है, तब से आवश्यक है ।

— owacoder
स्रोत

2

पायथन 2 - 95 बाइट्स

def s(n):
    l=list("8549176320")
    return "".join(sorted(list(n),key=lambda x: l.index(x)))

आगे गोल्फ का प्रयास ... मुझे लगता है कि लाइन 2 अनावश्यक है और यह 1 लंबोदर बन सकता है।

संपादित करें: टिप्पणी में 49 चार संस्करण, मदद के लिए xnor और vaultah के लिए thx।

— जेरेमी
स्रोत

lambda n:''.join(sorted(`n`,key="8549176320".find))

— तिजोरी

4

@vaultah अच्छा समाधान, आप इसे पोस्ट करना चाहिए! मुझे लगता है कि आप 8इतना छोड़ सकते हैं कि findदेता है -1।

— xnor

1

ऊह वह चतुर है @xnor। सबसे छोटा मुझे यह मिला lambda n: "".join(sorted(n,key="549176320".find)), जो वास्तव में आपके सुझाव के समान है, वॉल्टाह। आपको इसे पोस्ट करना चाहिए!

— जेरेमी

1

@ जेरेमी आपको उस संस्करण को अपनी पोस्ट में संपादित करना चाहिए।

— DJMcMayhem

2

कम से कम अति सुंदर व्हाट्सएप से छुटकारा पाएं ... इंडेंटेशन एक ही स्थान के साथ किया जा सकता है। यह भी अमान्य है, क्योंकि ओपी ने कहा कि आउटपुट एक संख्यात्मक प्रकार होना चाहिए।

— मेघो

2

- ओरेकल 11 (एसक्यूएल): 164 बाइट्स

  SELECT LISTAGG(DECODE(s,0,'zero',TO_CHAR(TO_DATE(s,'j'),'jsp')),',')WITHIN GROUP(ORDER BY 1)FROM(SELECT SUBSTR(&1,level,1)s FROM dual CONNECT BY LEVEL<=LENGTH(&1));

लंबा रूप और स्पष्टीकरण

  SELECT LISTAGG(DECODE(s,0,'zero',TO_CHAR(TO_DATE(s,'j'),'jsp')),',') WITHIN GROUP (ORDER BY 1)
  FROM ( SELECT SUBSTR(&1,level,1)s FROM dual
           CONNECT BY LEVEL <= LENGTH(&1)
        );

स्क्रिप्ट के रूप में इनपुट प्राप्त करें:

  SELECT &1 FROM dual

इनपुट की लंबाई के आधार पर कनेक्ट द्वारा पंक्तियों का उपयोग करके "बनाएँ":

  CONNECT BY LEVEL <= LENGTH(&1)

प्रत्येक स्थिति के लिए स्ट्रिंग से प्रत्येक अंक को चीरें:

  SELECT SUBSTR(&1,level,1)s FROM dual

वर्तनी को प्राप्त करने के लिए अंक को जूलियन तिथि में बदलें, और चार में वापस जाएँ:

  TO_CHAR(TO_DATE(s,'j'),'jsp')

शून्य के लिए जांचें - विशेष मामला।

  DECODE(s,0,'zero'

LISTAGG फ़ंक्शन का उपयोग पंक्तियों को एक एकल पंक्ति सूची में वापस करने के लिए करें, अल्पविराम से, अल्पविराम से आदेश दिया गया

  LISTAGG(DECODE(s,0,'zero',TO_CHAR(TO_DATE(s,'j'),'jsp')),',') WITHIN GROUP (ORDER BY 1)

हमेशा इस तरह की चीजों के लिए एसक्यूएल को मोड़ने की कोशिश करना ... :) वास्तव में बेजर के मेरे ज्ञान का परीक्षण करता है ...

— ठीक इसी प्रकार से
स्रोत

1

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

->n{n.to_s.chars.sort_by{|c|'8549176320'.index c}.join.to_i}

— मूल्य स्याही
स्रोत

1

रैकेट, 142 130 बाइट्स

(λ(n)(string->number(list->string(sort(string->list(~a n))char<? #:key(λ(m)(string-ref "9487216503"(-(char->integer m)48)))))))

जिनमें से रूपांतरण हैं ~~और अधिक से अधिक~~ लगभग आधा लंबाई (की 76 64 बाइट्स)।

— स्टीवन एच।
स्रोत

(+ 1 answer)रैकेट के लिए!

— बिल्ली

@ मेरे लिए रैकेट का अभ्यास करना मेरे लिए उपयोगी है, क्योंकि यह मेरे सहकर्मियों द्वारा मेरे लिए छोड़ी गई इन प्रक्रियात्मक विरासत जावा (और थोड़ा-कम-विरासत पायथन) कार्यक्रमों पर काम करते हुए कार्यात्मक प्रोग्रामिंग ज्ञान बनाए रखने का एक तरीका है। मैं इस बारे में शेख़ी कर सकता हूं कि वस्तुओं का होना किसी प्रोग्राम को ऑब्जेक्ट-ओरिएंटेड बनाने की आवश्यकता नहीं है, बल्कि ऐसा करने के बजाय मैं रैकेट में अपनी समस्याओं को दूर कर रहा हूं।

— स्टीवन एच।

हम्म ... मैं निश्चित रूप से सहानुभूति रखता हूं, और यह संभव है और कार्यात्मक पायथन को लिखने के लिए मजेदार है, लेकिन जावा का सिर्फ फॉफफुल है। हो सकता है कि आप अपने वरिष्ठों को कार्यान्वयन के लिए स्काला का उपयोग करने और जावा को गोंद के रूप में उपयोग करने दें। :)

— बिल्ली

वैसे, यदि आप फोर्थ को पसंद करते हैं और आपकी आंखें लिस्प के अंदर-बाहर पढ़ने से थोड़ा थक जाती हैं, तो आपको फैक्टर की जांच करनी चाहिए , जो लिस्प और सीएलओएस है, लेकिन फोर्थ-वाई पोस्टफिक्स और प्वाइंट-फ्री भेस में है।

— बिल्ली

1

TSQL, 260 बाइट्स

कुछ बाइट्स को बचाने के लिए, लंबाई को संदर्भित करने से बचने के लिए उलट बुलबुला प्रकार का इस्तेमाल किया

golfed:

DECLARE @ varchar(99)=101

,@i INT=99,@j INT=98WHILE @i>1SELECT
@=IIF(CHARINDEX(x,'598327614')>CHARINDEX(y,'598327614'),STUFF(STUFF(@,@j,1,x),@i,1,y),@),@i-=IIF(@j=1,1,0),@j=IIF(@j=1,@i,@j-1)FROM(SELECT
SUBSTRING(@,@i,1)x,SUBSTRING(@,@j,1)y)z
PRINT @

Ungolfed:

DECLARE @s BIGINT=1234567890

DECLARE @ char(99)=@s,@i INT=99,@j INT=98
WHILE @i>1
  SELECT 
    @=IIF(CHARINDEX(x,'236719458')>CHARINDEX(y,'236719458'),
        STUFF(STUFF(@,@j,1,x),@i,1,y),@), 
    @i-=IIF(@j=1,1,0),
    @j=IIF(@j=1,@i,@j-1)
  FROM(SELECT SUBSTRING(@,@i,1)x,SUBSTRING(@,@j,1)y)z
PRINT CAST(@ as bigint)

पूर्णांक प्रकारों को इनपुट और आउटपुट के रूप में उपयोग करने पर जोर देते हुए 37 बाइट्स जोड़े

— t-clausen.dk
स्रोत

DECLARE @ varchar(99)=1010.o 101स्वचालित रूप से स्ट्रिंग में बदल जाता है?

— बिल्ली

इसके अलावा, stuffएक उद्देश्यपूर्ण भयानक कार्य नाम है। squashया shoveया packबेहतर होगा: पी

— बिल्ली

@cat हाँ, यह स्वचालित रूप से एक स्ट्रिंग में परिवर्तित हो जाता है, लेकिन यह विवरण के अनुसार धोखा होगा। मैं मानता हूं, सामान एक मूर्खतापूर्ण नाम है

— t-clausen.dk

1

मेरा मतलब है, हम हर फ़ंक्शन को कॉल कर stuffसकते हैं यही कारण है कि फ़ंक्शन क्या करते हैं: वे सामान करते हैं। तब आपका कोड ऐसा दिख सकता हैstuff(stuff(4, 5, stuff), stuff(stuff()).(stuff())()); stuff(stuff)

— बिल्ली

1

क्लोज्योरस्क्रिप्ट, 45 बाइट्स

#(apply str(sort-by(vec"9487216503")(str %)))

जावास्क्रिप्ट लीक से कुछ पेचीदा स्ट्रिंग-> अंतर रूपांतरण का उपयोग करता है, इसलिए यह मान्य क्लीज्योर नहीं है।

— MattPutnam
स्रोत

1

फायरबर्ड, 317 बाइट्स

golfed:

select list(s,'')from(with recursive q as(select 1 p,substring(:a from 1 for 1)s from rdb$database q union all select q.p+1 p,substring(:a from q.p+1 for 1)s from q where q.p<char_length(:a))select s from q order by iif(s=8,0,iif(s=5,1,iif(s=4,2,iif(s=9,3,iif(s=1,4,iif(s=7,5,iif(s=3,7,iif(s=2,8,iif(s=0,9,6))))))))))

Ungolfed:

select list(s, '')
from (
   with recursive q as (
      select 1 as p, substring(:a from 1 for 1) s
      from rdb$database q
      union all
      select q.p + 1 as p, substring(:a from q.p + 1 for 1) as s
      from q
      where q.p < char_length(:a)
   )
   select s
   from q
   order by iif(s = 8, 0,
               iif(s = 5, 1,
                  iif(s = 4, 2,
                     iif(s = 9, 3,
                        iif(s = 1, 4,
                           iif(s = 7, 5,
                              iif(s = 3, 7,
                                 iif(s = 2, 8,
                                    iif(s = 0, 9, 6)))))))))
)

फायरबर्ड में स्प्लिट फंक्शनलिटी नहीं है। इसके बजाय मैंने अगला चरित्र बार-बार प्राप्त करने के लिए एक पुनरावर्ती क्वेरी बनाई। फिर हमारे उचित क्रम से छँटाई करते हुए उन्हें फिर से आकार दें। अंत में उन परिणामों को वापस एक सूची में एक साथ सम्मिलित करें। रिक्त के साथ डिफ़ॉल्ट अल्पविराम सीमांकक को ओवरराइड करें। मैं इसके बजाय एक नई डमी तालिका बनाकर 11 बाइट्स बचा सकता rdb$databaseथा , लेकिन मैंने सोचा कि यह नियमों के खिलाफ हो सकता है।

— पॉल
स्रोत

1

ZX स्पेक्ट्रम, मशीन कोड, 53 48 47 45 44 बाइट्स

    org 49200 ; #c030

; table converts ascii to alfabetical order
; start from BASIC with any number as : PRINT "1234567890" AND USR 49208

convtab defb 249 ; zero defb 244 ; one defb 248 ; two defb 247 ; three defb 2+205 ; four defb 1+205 ; five defb 246 ; six defb 245 ; seven ; defb 0 ; eight ; defb 3 ; nine ; last 2 conversions hidden in call-command



start Call #2bf1    ; fetch stackindex
    call #2ab2 ; store back
    ld h,#c0    ; set highbyte of table


Sort Push de
loop ld b,d
    ld c,e
    inc de
    ld a,(bc)   ; fetch number
    Ld l,a
    ld a,(de)
    cp 34       ; endmarker "
    Jr z,exit   ; end reached?
    push hl     ; save number
    ld l,a
    Ld a,(hl)   ; convert second number
    pop hl
    cp (hl)     ; compare numbers
    jr nc,loop  ; in order, no swap
swap ld a,(bc)  ; swap original numbers
    ld l,a
    ld a,(de)
    ld (bc),a
    ld a,l
    ld (de),a
Exit pop de
    Ret z
    jr sort     ; check number for order

— जोहान कोएलमैन
स्रोत

सूक्ति-प्रकार के साथ इसे छोटा किया जा सकता है और तालिका 1 बाइट छोटी हो सकती है। नया संस्करण आने के लिए ...

— जोहान कोएलमैन

यहाँ सूक्ति क्रम लंबा है, लेकिन अन्य अनुकूलन।

— जोहान कोएलमैन

0

कारक, १२ Fact

[ 10 base> [ 48 - ] { } map-as dup [ number>text ] map zip [ second first ] sort-with [ first ] map [ 48 + ] ""map-as 10 >base ]

बिल्डरों के लिए हुर्रे! : डी

— बिल्ली
स्रोत

0

PHP, 126 बाइट्स

जहाँ तक मुझे पता है कि php का कोई भी निर्माण नहीं है जो वास्तव में इस के साथ मदद करेगा (सबसे अच्छा मैं एक usort (str_split ()) 5 बाइट्स लंबा उपयोग करके कर सकता था) इसलिए इस उत्तर के भीतर मैं खुश हूँ केवल एक ही चीज़ है $ i के साथ खेले जाने वाले खेल बाइट्स के एक जोड़े को बचाने के लिए।

<?php for($i=-1;$i<9;)$a[++$i]=preg_replace("/[^$i]/","",$argv[1]);array_multisort([9,4,8,7,2,1,6,5,0,3],$a);echo implode($a);

— user55641
स्रोत

0

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

{⍎n['8549176320'⍋n←⍕⍵]}

स्पष्टीकरण:

n←⍕⍵: स्ट्रिंग का प्रतिनिधित्व प्राप्त करें nऔर इसे स्टोर करेंn
'8549176320'⍋: आदेश दिए गए nउस प्रकार के क्रमचय का पता लगाएं ।n8549176320
n[... ]: nउस क्रमपरिवर्तन द्वारा पुन: क्रमबद्ध करें
⍎: परिणाम का मूल्यांकन करें (इसे एक संख्या में वापस लाने के लिए)

— मारीनस
स्रोत

चूंकि I / O स्ट्रिंग्स हो सकता है, आप निकाल सकते हैं ⍎और ⍕। को हटाने के द्वारा tradfn में बदलें {और }और प्रतिस्थापन ⍞के लिए ⍵। अंत में, 0असूचीबद्ध रूप से अंत में निकालें :n['854917632'⍋n←⍞]

— Adám

0

क्लोजर, 53 बाइट्स

खैर, हास्केल समाधान से सूची समझने वाला विचार सबसे छोटा प्रतीत होता है:

#(apply str(for[p"8549176320"b(str %):when(= p b)]p))

मेरा मूल दृष्टिकोण 1 बाइट लंबा है:

#(apply str(sort-by(zipmap"549176320"(range))(str %)))

आप यहां दोनों फ़ंक्शन ऑनलाइन देख सकते हैं: https://ideone.com/afac5n

— cliffroot
स्रोत

0

आम लिस्प, 104

(lambda(n)(#1=parse-integer(sort(format()"~A"n)'string<= :key(lambda(u)(format()"~R"(#1#(string u)))))))

Ungolfed

(lambda (n)
  (parse-integer
   (sort (format nil "~A" n)
         #'string<=
         :key (lambda (u) (format nil "~R" (parse-integer (string u)))))))

पूर्णांक को स्ट्रिंग के रूप में रूपांतरित करें, string<=कस्टम :keyफ़ंक्शन का उपयोग करते समय तुलना का उपयोग करके वर्णों को क्रमबद्ध करें जो किसी दिए गए चरित्र को संख्यात्मक मान के अंग्रेजी प्रतिनिधित्व के रूप में परिवर्तित करता है। आमतौर पर मैं एक महत्वपूर्ण फ़ंक्शन का उपयोग नहीं करता हूं जो इस एक के रूप में ज्यादा करता है, लेकिन इसे सजाने / छाँटने / अघोषित की तुलना में बाइट्स में कम खर्च होता है।

— कोर निपात
स्रोत

0

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

यह मेरे फैक्टर जवाब का सीधा अनुवाद है , सिर्फ मनोरंजन के लिए।

def f(n):
 s=list(map(int,str(n)))
 return int("".join(list(map(str,list(map(lambda x:x[1],sorted(list(zip(list(map(lambda t:{0:"zero",1:"one",2:"two",3:"three",4:"four",5:"five",6:"six",7:"seven",8:"eight",9:"nine"}[t],s)),s)))))))))

"आलसी" मानचित्र और जिप वस्तुओं के मूल्यांकन के शब्दार्थ ब्रह्मांड में वास्तविक घोड़े के मलमूत्र के सबसे सूक्ष्म से कठिन-से-खोज-बग-उत्प्रेरण टुकड़ा है। कभी-कभी, ठीक से या बिल्कुल भी उपयोग करने की s = map(f, x)अनुमति नहीं देगा s।

— बिल्ली
स्रोत

0

पाइके, 14 बाइट्स

.#uЀB`@

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

— नीला
स्रोत

0

सी, 80 बाइट्स

आधार 10 में एक संख्या वाली स्ट्रिंग लेता है और इसके लिए प्रिंट करता है stdio:

F(char*i){for(char*p,d,*o="8549176320";*o;++o)for(p=i;d=*p++;d-*o||putchar(d));}

— स्टेफानो सैनफिलिपो
स्रोत

0

पायथन 2.7.11, 67 बाइट्स

lambda n:''.join(sorted(list(n),key=lambda s:"9487216503"[int(s)]))

एक स्ट्रिंग को इनपुट के रूप में लेता है और एक स्ट्रिंग को आउटपुट करता है।

— डैनियल
स्रोत

0

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

lambda x:''.join(i[1]for i in sorted(['9487216503'[int(j)],j]for j in x))

— 8BitTRex
स्रोत

आप

— डैनियल

0

PHP , 107 बाइट्स

function($a){usort($a,function($a,$b){return($z=array_flip([8,5,4,9,1,7,6,3,2,0]))[$a]-$z[$b];});return$a;}

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

छँटाई क्रम को समायोजित करने के लिए उपयोगकर्ता-परिभाषित तुलना फ़ंक्शन का उपयोग करता है।

उत्पादन

101         110
31948       84913
5544        5544
1234567890  8549176320

— 640KB
स्रोत

किसी संख्या को वर्णानुक्रम में पुनर्व्यवस्थित करें

उदाहरण:

पर्ल 6 , 32 28 बाइट्स

स्पष्टीकरण:

परीक्षा:

05AB1E, 12 11 10 बाइट्स

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

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

पायथ, 12 10 बाइट्स

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

MATL , 19 बाइट्स

व्याख्या

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

व्याख्या

गणितज्ञ 35 78 47 बाइट्स

सी, 142 141 117

पायथन 2 - 95 बाइट्स

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

रैकेट, 142 130 बाइट्स

TSQL, 260 बाइट्स

क्लोज्योरस्क्रिप्ट, 45 बाइट्स

फायरबर्ड, 317 बाइट्स

ZX स्पेक्ट्रम, मशीन कोड, 53 48 47 45 44 बाइट्स

कारक, १२ Fact

PHP, 126 बाइट्स

एपीएल, 23 ​​बाइट्स

क्लोजर, 53 बाइट्स

आम लिस्प, 104

Ungolfed

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

पाइके, 14 बाइट्स

सी, 80 बाइट्स

पायथन 2.7.11, 67 बाइट्स

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

PHP , 107 बाइट्स

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