23

इस स्टैक ओवरफ्लो प्रश्न से प्रेरित: एक सूची को क्रमबद्ध करना: आरोही में संख्या, अवरोही में अक्षर । आपका कार्य निम्न समस्या को हल करना है और, जैसा कि यह कोड-गोल्फ है , आपको यथासंभव बाइट्स में ऐसा करना चाहिए।

आप इनपुट पत्र युक्त के रूप में वस्तुओं की एक सूची ले जाना चाहिए (किसी भी उचित रूप: string, char, आदि) और संख्या। फिर आपको संख्याओं को आरोही क्रम में और अक्षरों को अवरोही क्रम में क्रमबद्ध करना चाहिए। हालांकि, आपको पत्र पदों और संख्या पदों में संख्याओं में अक्षरों को रखना चाहिए। उदाहरण के लिए, यदि सूची है:

[L, D, L, L, D, L]

आउटपुट सूची निम्न के रूप में होनी चाहिए:

[L, D, L, L, D, L]

के माध्यम से काम

इनपुट: ['a', 2, 'b', 1, 'c', 3]

संख्याओं को बढ़ते क्रम में क्रमबद्ध करें: [1, 2, 3]
अवरोही क्रम में अक्षरों को क्रमबद्ध करें: ['c', 'b', 'a']
उन्हें वापस शामिल करें लेकिन ऑर्डर को समान रखें: ['c', 1', 'b', 2, 'a', 3]

नियम

सूची में केवल अक्षर और अंक होंगे।
सूची रिक्त हो सकती है।
सूची में केवल अक्षर या केवल अंक हो सकते हैं।
यदि आपकी भाषा मिश्रित प्रकार के सरणियों का समर्थन नहीं करती है तो आप अंकों के बजाय अंक वर्णों का उपयोग कर सकते हैं। ध्यान दें कि यदि आपकी भाषा इसका समर्थन करती है तो आपको मिश्रित प्रकारों का उपयोग करना चाहिए।
पत्र केवल होंगे [a-z]या [A-Z], आप चुन सकते हैं कि कौन सा।
पत्र को aसबसे कम होने के रूप में क्रमबद्ध किया जाता है , zउच्चतम अर्थात a = 1, z = 26।
मानक खामियों को मना किया जाता है।
I / O किसी भी मानक साधन द्वारा एक स्ट्रिंग के रूप में हो सकता है।

परीक्षण के मामलों

[5, 'a', 'x', 3, 6, 'b'] -> [3, 'x', 'b', 5, 6, 'a']

[ 3, 2, 1] -> [ 1, 2, 3 ]

[ 'a', 'b', 'c' ] -> [ 'c', 'b', 'a' ]

[] -> []

[ 2, 3, 2, 1 ] -> [1, 2, 2, 3]

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

code-golf array-manipulation sorting

— TheLethalCoder
स्रोत

टिप्पणियाँ विस्तारित चर्चा के लिए नहीं हैं; इस वार्तालाप को बातचीत में स्थानांतरित कर दिया गया है ।

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

7

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

O`\d
O^`\D

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

Oरेटिना में मंच सीधे चयनात्मक इस चुनौती के लिए आवश्यक छंटाई की तरह का प्रदर्शन कर सकते हैं।

यहाँ पहली पंक्ति अंकों को छाँटती है जबकि दूसरी पंक्ति गैर-अंकों को उल्टा करती है।

— सिंह
स्रोत

13

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

^{-2 बाइट्स जी धन्यवाद के लिए}^{-1। जोनाथन}^{फ्रेच को}
^{बाइट धन्यवाद}

def F(x):n=sorted(x);print[n.pop((e<x)-1)for e in x]

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

sortedसूची पहले और उसके बाद वर्ण की तरह नंबर होगा [3, 5, 6, 'a', 'b', 'x'], तो का उपयोग e<xफिल्टर करने के लिए नंबर क्या है और चार है क्या, अजगर में किसी भी नंबर एक सूची (इनपुट) से कम है और एक सूची एक स्ट्रिंग से कम है।

— छड़ी
स्रोत

यह संस्करण विफल रहता है IndexError: pop index out of range। पूर्व समाधान ने काम किया।

— श्री एक्सकोडर

हालांकि यह 55 बाइट्स के साथ भी काम करता है। 1-(e<'`')होना चाहिए (e<'`')-1। आपने उन्हें गलत क्रम में रखा। BTW, आप मुझे निंजा चाहेंगे: / मेरे पास यह

— श्री एक्सकोडर

@ Mr.Xcoder मदद के लिए धन्यवाद:

— रॉड

2

साथ सहेजें दोe>x

— g.rocket

1

@RootTwo इच्छित व्यवहार के विपरीत कार्य करता है।

— LyricLy

9

APL (Dyalog) , 27 26 बाइट्स

पात्रों को अपरकेस होने की उम्मीद है

(⍋⊃¨⊂)@(~e)(⍒⊃¨⊂)@(e←∊∘⎕A)

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

यह फ़ॉर्म के केवल दो अनुप्रयोग हैं f@g, fद्वारा इंगित आइटम पर फ़ंक्शन लागू करें g।

पहले आवेदन हम उपयोग के लिए:
f: ⍒⊃¨⊂ उतरते ग्रेड ( ⍒) प्रत्येक पिक ( ⊃¨) पूरे तर्क से ( ⊂)।
g: इस समारोह के (e←∊∘⎕A) सदस्यों ( ∊) ( ए∘ ) एक वर्णमाला ( ⎕A), और दुकान ( ←) के रूप में e।

दूसरा आवेदन हम उपयोग के लिए:
f: ⍋⊃¨⊂ आरोही ग्रेड ( ⍋) प्रत्येक पिक ( ⊃¨) पूरे तर्क से ( ⊂)।
g: (~e) नहीं ( ~) वर्णमाला के सदस्यों ( e, हम पहले संग्रहीत समारोह)

— एडम
स्रोत

मुझे लगता है कि इसे सभी पूर्णांकों के लिए कवर करने की आवश्यकता है, इसलिए 83=⎕DR¨⍵

— यूरिल

@ यूरिल वास्तव में एक आवश्यकता नहीं लगती है, लेकिन एक बाइट को बचाती है। इसके अलावा, onlyDR संख्याओं के लिए सार्वभौमिक रूप से 83 नहीं है, केवल छोटे पूर्णांकों के लिए।

— अड्म

क्या यह हमेशा 3=10|⎕DRपूर्णांक के लिए होता है?

— उरियल

@ यूरील हाँ: 0 = यूनिकोडेकर, 1 = बुलियन, 2 = क्लासिककार, 3 = इंट, 5 = फ्लोट, 6 = पॉइंटर, 7 = दशमलव, 9 = जटिल। ⌊0.1×⎕DRआपको पॉइंटर्स को छोड़कर प्रत्येक स्केलर का प्रतिनिधित्व करने के लिए उपयोग किए जाने वाले बिट्स की संख्या प्रदान करता है, जो आर्किटेक्चर पर निर्भर करते हैं लेकिन हमेशा 326 होते हैं। इस प्रकार, सभी नंबर हैं 2|⎕DR।

— अड्म

8

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

20 बाइट्स का उपयोग करके sort()सहेजा गया, @JustinMariner द्वारा
सुझाए गए अनुसार @CravelAyre के लिए 4 और बाइट्स का धन्यवाद

रॉड के पायथन उत्तर के समान दृष्टिकोण का उपयोग करना :

a=>[...a].map(n=>a.sort()[1/n?'shift':'pop']())

परीक्षण के मामलों

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

let f =

a=>[...a].map(n=>a.sort()[1/n?'shift':'pop']())

console.log(JSON.stringify(f(['a', 2, 'b', 1, 'c', 3]))) // -> ['c', 1', 'b', 2, 'a', 3]
console.log(JSON.stringify(f([5, 'a', 'x', 3, 6, 'b']))) // -> [3, 'x', 'b', 5, 6, 'a']
console.log(JSON.stringify(f([3, 2, 1]))) // -> [ 1, 2, 3 ]
console.log(JSON.stringify(f(['a', 'b', 'c']))) // -> [ 'c', 'b', 'a' ]
console.log(JSON.stringify(f([]))) // -> []
console.log(JSON.stringify(f([2, 3, 2, 1]))) // -> [1, 2, 2, 3]

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

— Arnauld
स्रोत

क्या मुझे कुछ याद आ रहा है या आप पूरे sortसमारोह को नहीं हटा सकते हैं और सिर्फ sort()अपने दम पर उपयोग कर सकते हैं? यह फ़ंक्शन के बिना उसी तरह से सॉर्ट करना प्रतीत होता है (क्रोम / एफएफ / एज में)।

— जस्टिन मैरिनर

@JustinMariner सबसे पहले, मैंने सोचा था कि संख्यात्मक मान संख्या हो सकते हैं - जिस स्थिति में एक साधारण sort()विफल हो जाएगा। लेकिन जब से हम अंकों तक सीमित हैं, आप सही हैं: यह काम करता है। धन्यवाद!

— अरनौलड

1

अच्छा समाधान है, आप बदलाव कर सकता है / पर पॉप a.sort()बजाय करने के लिए बताए के प्रत्येक पाश x:.map(n=>a.sort()[1/n?'shift':'pop']())

— क्रेग आयरे

@CraigAyre अच्छी पकड़!

— Arnauld

मुझे पूरा यकीन है कि +nइसके बजाय इस्तेमाल किया जा सकता है1/n

— कॉनर ओ'ब्रायन

5

आर , 83 76 बाइट्स

-7 बाइट्स मिफ को धन्यवाद

function(n){u=unlist
d=n%in%0:9
n[d]=sort(u(n[d]))
n[!d]=sort(u(n[!d]),T)
n}

यह नीचे के समान ही है, लेकिन यह वेक्टर के listबजाय मिश्रित-प्रकार के इनपुट के लिए अनुमति देता है atomic(जो मिश्रित प्रकार के साथ वर्णों के रूप में सब कुछ टाइप करेगा)।

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

आर , 68 61 बाइट्स

-7 बाइट्स मिफ को धन्यवाद

function(n){d=n%in%0:9
n[d]=sort(n[d])
n[!d]=sort(n[!d],T)
n}

अनाम फ़ंक्शन। सभी अंक इस मामले में पात्रों को दिए गए हैं। n[-d]अंकों के बिना सरणी है। NULLखाली इनपुट पर रिटर्न (खाली सूची)।

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

— ग्यूसेप
स्रोत

आप कुछ पात्रों के साथ दाढ़ी बना सकते हैंd=n%in%0:9

— Miff

4

जाप , 18 15 बाइट्स

धन्यवाद @ बाइट्स -3 बाइट्स के लिए और 0एस के साथ सरणियों के लिए फिक्सिंग में मदद के लिए ।


c ñc
®¤?Vv :Vo

पहली पंक्ति जानबूझकर खाली छोड़ी गई है।

इसे ऑनलाइन आज़माएं! -Qस्वरूपित सरणी देखने के लिए उपयोग करना।

व्याख्या

इनपुट सरणी पर ओवरराइटिंग से बचने के लिए पहली पंक्ति रिक्त है।
[5, 'a', 'x', 3, 6, 'b']

c ñc

cइनपुट सरणी को समतल ( ) करके कॉपी बनाएं , फिर ñउनके चार कोड ( c) द्वारा दर्शाए गए तार के साथ क्रमबद्ध करें । इसमें संग्रहित है V।
[3, 5, 6, 'a', 'b', 'x']

£

फिर फ़ंक्शन द्वारा इनपुट सरणी को मैप करें ...

¤?Vv :Vo

बाइनरी स्ट्रिंग्स (सत्य) या स्ट्रिंग्स को ""(मिथ्या) ( ¤) में संख्याओं को बदल दें । यदि सत्य है, तो V( v) के शुरू से हटा दें, अन्यथा अंत ( o) से हटा दें ।

— जस्टिन मेरिनर
स्रोत

15 बाइट्स

— झबरा

@ शैगी नाइस, यह वास्तव में चालाक है। धन्यवाद!

— जस्टिन मेरिनर

आप स्विच Voऔर Vvचारों ओर भूल गए । मुझे यकीन है कि वहाँ एक छोटा रास्ता होना चाहिए, बिना त्रिगुट के।

— झबरा

@ शगुन ओह, व्हॉट्स। और हाँ, बस अगर oनकारात्मक मूल्यों या कुछ के साथ शुरुआत से हटा सकते हैं ...

— जस्टिन मैरिनर

4

जावास्क्रिप्ट, 164 162 158 142 बाइट्स

v का निरर्थक असाइनमेंट निकालने के बाद 1: 2 बाइट कम संपादित करें।

2 संपादित करें: 4 बाइट्स TheLethalCoder के लिए कम धन्यवाद।

संपादित करें 3: 16 बाइट्स कम से कम जस्टिन Mariner से शानदार संकेत के लिए धन्यवाद

x=>eval("n=v=>typeof(v)=='number';l=x.length;for(i=0;i<l;x[i++]=x[m],x[m]=w){for(v=w=x[j=m=i];++j<l;)n(e=x[j])==n(w)&&e<v==n(w)&&(m=j,v=e)}x")

यह मेरी पहली बार कोड-गोल्फ में है, इसलिए इसे निश्चित रूप से बेहतर किया जा सकता है ... लेकिन फिर भी, एक कोशिश के लायक है।

कार्यक्रम चयन प्रकार का एक प्रकार करता है, जो केवल वर्तमान के रूप में उसी प्रकार के मूल्यों को ध्यान में रखता है (केवल एक संख्या और एक नंबर स्वैप करना, या एक पत्र और एक पत्र)

पठनीय रूप:

x=>eval("
    n=v=>typeof(v)=='number';
    l=x.length;
    for(i=0;i<l;x[i++]=x[m],x[m]=w){
        for(v=w=x[j=m=i];++j<l;) 
            n(e=x[j])==n(w) && e<v==n(w) && (m=j,v=e)
    }
    x
")

— mackoo13
स्रोत

for(j=i+1;j<l;j++)-> for(j=i++;++j<l;)और बाहरी लूप में वृद्धि को हटा दें।

— TheLethalCoder

PPCG में भी आपका स्वागत है!

— TheLethalCoder

@ TheLethalCoder अगर हम इतनी जल्दी काउंटर बढ़ाते हैं, तो हमें उन लाइनों को भी बदलना होगा जहां मैं और j का उपयोग किया जाता है ... लेकिन विचार वास्तव में स्मार्ट है, मुझे लगता है कि वैसे भी इसका उपयोग कैसे करना है।

— mackoo13

आप को बढ़ा सकते हैं jके रूप में मैं सुझाव दिया है, मैं आप का उपयोग नहीं देखा था iऔर नीचे सिर्फ बदल x[i]=x[m]भीx[i++]=x[m]

— TheLethalCoder

आह, ज़रूर ... मैंने ऐसा क्यों नहीं सोचा x[i++]=x[m]... धन्यवाद!

— mackoo13

3

C ++ 17 (gcc) , 219 बाइट्स

#include <variant>
#include <set>
using V=std::variant<char,int>;void f(V*a,V*b){std::set<V>S[2];for(V*c=a;c<b;++c)S[c->index()].insert(*c);auto
C=S->rbegin();auto N=S[1].begin();for(;a<b;++a)*a=(a->index()?*N++:*C++);}

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

शायद ही प्रतिस्पर्धी। लेकिन मुझे मिश्रित प्रकार के सरणियों का समर्थन करना चाहिए? ठीक।

श्रेणी शैली में भिन्न प्रकार के सरणी को स्वीकार करता है, और इसे जगह में संशोधित करता है। इनपुट को दो सॉर्ट किए गए सेटों में कॉपी करता है, और फिर इनपुट / आउटपुट एरे में वापस आ जाता है।

— aschepler
स्रोत

यह दिलचस्प है। मैं इस तरह से "मिश्रित प्रकार के सरणियों का समर्थन" नहीं करूंगा। अन्यथा, मुझे void *C की एक सरणी का उपयोग करना होगा ;) लेकिन, हाँ, इस तरह के घेरा के माध्यम से एक समाधान कूदते हुए देखना दिलचस्प है।

— फेलिक्स पालमेन

आप रिक्त स्थान हटाकर दो बाइट्स बचा सकते हैं #include रों

— कोनोर ओ ब्रायन

2

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

(K=Reverse;B=Complement;L=Length;S=Position[#,_Integer];T=Sort@Cases[#,_Integer];G=K@B[#,T];V=B[Range@L@#,Flatten@S];R=K@Sort@#;Table[R[[Min@S[[i]]]]=T[[i]],{i,L@T}];Table[R[[V[[i]]]]=G[[i]],{i,L@G}];R)&

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

— J42161217
स्रोत

2

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

FOÞɓṪ}Ḣ}ẇØa$?€

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

मूल रूप से रॉड के पायथन समाधान का एक बंदरगाह है ।

— PurkkaKoodari
स्रोत

2

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

KSQm.(Kt>\@

इसे ऑनलाइन आज़माएं! या टेस्ट सूट की कोशिश करो।

व्याख्या

KSQm.(Kt<d\@  - Full program with implicit input.

KSQ           - Assign a variable K to the lexicographically sorted input.
   m          - Map over the input (with a variable d).
    .(K       - Pop the sorted list at this location:
       >\@    - If d is lexicographically lower than '@', at 0 (the first element). Else, at -1 (the last element).

— मिस्टर एक्सकोडर
स्रोत

रुको, आपको पूरे सरणी को ऑर्डर करने की आवश्यकता नहीं है, बस दो सजातीय सरणियों में विभाजित करें जो प्रत्येक को आसानी से छांटना चाहिए। APL मिश्रित सरणियों को (या तो) सॉर्ट नहीं कर सकता है, लेकिन मैं प्रत्येक प्रकार को अलग से सॉर्ट करता हूं।

— 12

@ Adám क्या मतलब है कि केवल दो सजातीय सरणियों में विभाजित करें जो प्रत्येक को आसानी से छांटना चाहिए ?

— श्री एक्सकोडर

जैसा कि ओपी के "वर्कथ्रू" में वर्णित है: 1. ध्यान दें कि कौन से तत्व संख्यात्मक हैं और कौन से वर्ण हैं। 2. सभी नंबरों को एक अलग ऐरे में निकालें और सॉर्ट करें। पात्रों के लिए भी यही करें। 3. सॉर्ट किए गए नंबर को वापस नंबर स्लॉट में डालें। पात्रों के लिए भी ऐसा ही करें।

— 12

@ Adám अगर ओपी इसे अमान्य मानता है, तो मैं वही करूंगा जो आपने कहा था (इसके परिणामस्वरूप, बहुत लंबा दृष्टिकोण होगा)

— श्री Xcoder

2

पायथन, 145 139 130 बाइट्स

6 बाइट्स @officialaimm की बदौलत बच गईं

9 बाइट्स ने @Chris_Rands को धन्यवाद दिया

g=lambda s,a:sorted(x for x in s if(type(x)==str)==a)
def f(s):l,n=g(s,1),g(s,0)[::-1];return[[n,l][type(x)==str].pop()for x in s]

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

— Uriel
स्रोत

139 बाइट्स

— आधिकारिक

type(x)==strisinstance(...)मुझे लगता है कि उपयोग करने पर कुछ बाइट्स

— बचाएगी

@ क्रिस_और धन्यवाद!

— उरियल

2

05AB1E , 17 बाइट्स

SaJ¹á{R¹þ{«vyay.;

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

SaJ               # Push 1 if letter 0 else, for all letters in string.
   ¹á{R           # Reverse sort letters from input.
       ¹þ{        # Regular sort digits from input.
          «       # Concatenate those two things.
           v      # For each letter in the sorted string...
            ya    # 0 if digit, 1 if letter.
              y.; # Replace first instance of 0/1 with digit/letter.

सॉर्ट-बाय क्लोजर का उपयोग करना वास्तव में बदतर था: Σ©Ç®ai0<*}}¹SaJsvyay.;

— जादू ऑक्टोपस Urn
स्रोत

2

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

यह उत्तर उस टिप्पणी पर आधारित है जो कहती है कि आप '1', '2' आदि का उपयोग कर सकते हैं, अगर भाषा में वर्ण और अंक तुलनीय नहीं हैं। पायथन 3 में 'ए' और 1 की तुलना नहीं की गई है।

def f(s):x=sorted(s,key=lambda c:ord(c)-95);return[x.pop(-(c>'.'))for c in s]

— RootTwo
स्रोत

2

क्यू / केडीबी +, ५४ ५३ बाइट्स

समाधान:

{x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}

उदाहरण:

q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}(5;"a";"x";3;6;"b") / mixed list
3
"x"
"b"
5
6
"a"
q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}3 2 1   / simple list
1 2 3
q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}"abc"   / simple list
"cba"
q){x[w,q]:asc[x w:(&)d],desc x q:(&)(~)d:-7=type@/:x;x}2 3 2 1 / simple list
1 2 2 3

स्पष्टीकरण:

सूची में वर्ण ढूंढें, अवरोही क्रमबद्ध करें, सूची में लंबी खोजें, उन्हें क्रमबद्ध करें, सूची की सूची प्राप्त करने के लिए शामिल हों, जैसे ("x";"b";"a";3;5;6), फिर क्रमबद्ध मानों को सूची में उनके मूल पदों पर वापस असाइन करें, जैसे 0 3 4 1 2 5।

गोल्फ केवल q कीवर्ड को स्विच कर रहा है (each , whereऔर notउनके लिए) kसमकक्ष (जो उन्हें कोष्ठक में लिपटे होने की आवश्यकता)।

{x[w,q]:asc[x w:where d],desc x q:where not d:-7=type each x;x} / ungolfed
{                                                           ; } / lambda function with 2 statements
                                                 type each x    / return types of elements in mixed list
                                              -7=               / true where item is a long
                                            d:                  / save this bool array in d
                                        not                     / invert
                                  where                         / indices where true (we have chars)
                                q:                              / save these indices in q
                              x                                 / values of x at these indices
                         desc                                   / sort them descending
                        ,                                       / join/contatenate
                where d                                         / indices where we have digits
              w:                                                / save this in w
            x                                                   / values of x at these indices
        asc[           ]                                        / sort them ascending
 x[w,q]:                                                        / assign this list to x at indices w,q
                                                             x  / return x

संपादित करता

-1 बाइट के रूप में चारों ओर वर्ग कोष्ठक की जरूरत नहीं है desc

— streetster
स्रोत

2

सी (जीसीसी) , 125 113 110 बाइट्स

main(i){char*b,*c,s[99];for(gets(c=b=s);*++c||*(c=++b);)i=*b&64,i^*c&64||*c>*b^!i&&(i=*c,*c=*b,*b=i);puts(s);}

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

व्याख्या की:

main(i)
{
    char*b,*c,s[99];

    // slightly modified stupid bubblesort, this line in fact
    // does nested looping with a single for statement
    for(gets(c=b=s);*++c||*(c=++b);)
    // (undefined behavior here, there's no sequence point between accesses to c,
    // so this could go wrong. Works with the gcc version on tio.)

        // determine whether the current b is a letter:
        i=*b&64,

        // for doing anything, b and c must be the same "type":
        i^*c&64

            // when c > b for letter or c <= b for digit
            || *c>*b^!i

            // then swap
            && (i=*c,*c=*b,*b=i);

    puts(s);
}

अपरकेस में पत्र अपेक्षित हैं।

— फेलिक्स पालमेन
स्रोत

2

PHP, 66 बाइट्स:

for($a=$argv,sort($a);a&$c=$argv[++$i];)echo$a[$c<A?++$k:--$argc];

कमांड लाइन तर्कों से इनपुट लेता है, एक स्ट्रिंग प्रिंट करता है। इसे ऑनलाइन चलाएं -nrया इसके लिए प्रयास करें ।

PHP 7.1 में चेतावनी देता है; ठीक करने के a&साथ बदलें ""<।

— टाइटस
स्रोत

1

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

(s=#;s[[p]]=Sort[s[[p=#&@@@s~($=Position)~_String]],#2~Order~#>0&];s[[c]]=Sort@s[[c=#&@@@s~$~_Integer]];s)&

— user202729
स्रोत

1

सी # (.NET कोर) , 171 बाइट्स

a=>{var b=a.Where(x=>x is int).ToList();b.Sort();int i=0,j=0;return a.Select(x=>b.Contains(x)?b[i++]:a.Except(b).OrderByDescending(y=>y).ToList()[j++]);}

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

using System.Linq;

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

स्पष्टीकरण:

a =>
{
    var b = a.Where(x => x is int).ToList(); // Filter to only ints and transform to list
    b.Sort();                                // Sort the list
    int i = 0, j = 0;                        // Create index counters
    return a.Select(x =>                     // Replace each input element with
                    b.Contains(x) ?          // If it is in list b:
                    b[i++] :                 // Get the next element from b
                    a.Except(b)              // Otherwise take input and filter out those in b
                     .OrderByDescending(x=>x)// Order them z to a
                     .ToList()[j++]);        // Get the next element

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

1

पर्ल 5 , 107 + 1 (एन) = 108 बाइट्स

y/][//d;@a=split/, /;@l=sort grep/\D/,@a;@d=sort grep/\d/,@a;@r=map{/\d/?pop@d:shift@l}@a;$"=", ";say"[@r]"

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

— Xcali
स्रोत

1

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

x.sort_by(&:to_s).select{|a| a.is_a?(String)}.zip(x.map.with_index {|a, i| a.is_a?(String) ? i : nil}.compact).each{|a,i| x[i] = a}
x.sort_by(&:to_s).select{|a| a.is_a?(Integer)}.zip(x.map.with_index {|a, i| a.is_a?(Integer) ? i : nil}.compact).each{|a,i| x[i] = a}

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

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

बेहतर रूबी उत्तरों को देखने के लिए, सबसे अच्छा तरीका है, यह देखने के लिए कि क्या है। मुझे आशा है कि मैं भविष्य के उत्तरों में सुधार करूँगा)

पठनीय

x = ["c", 1, "a", 3, "b", 2]

b = x.map.with_index {|a, i| a.is_a?(Integer) ? i : nil}.compact
s = x.map.with_index {|a, i| a.is_a?(String) ? i : nil}.compact

o = x.sort_by(&:to_s).select{|a| a.is_a?(Integer)}
d = x.sort_by(&:to_s).select{|a| a.is_a?(String)}

d.zip s
d.zip(s).each {|a, i| x[i] = a}

o.zip b
o.zip(b).each {|a, i| x[i] = a }

p x

— गुस्तावो गेब्रियल
स्रोत

1

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

छोटे तरीके हो सकते हैं, लेकिन मुझे सिर्फ Lensलाइब्रेरी के साथ प्रयास करना था ।

import Control.Lens
import Data.List
i(!)f=partsOf(traverse.filtered(!'='))%~f.sort
f x=x&i(<)id&i(>)reverse

मैं fकेवल दो iइनवोकेशन की संरचना को परिभाषित कर सकता था , लेकिन xमोनोमोर्फिस्म प्रतिबंध से एक प्रकार की त्रुटि से बचने के लिए मुझे अभी भी इसे लागू करना होगा। ध्यान दें कि यह किस प्रकार का fहै Traversable t => t Char -> t Charइसलिए इसका उपयोग Strings के साथ किया जा सकता है जो कि Chars की सूची के साथ-साथ सरणियों के साथ भी हैChar है।

यहाँ परीक्षण के मामले हैं:

*Main> map f ["5ax36b","321","abc","","2321"]
["3xb56a","123","cba","","1223"]

— क्रिश्चियन सिवर्स
स्रोत

1

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

def f(s):x=sorted(s,key=lambda c:(type(c)==str,c));return[x.pop(-(type(c)==str))for c in s]

— RootTwo
स्रोत

1

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

#(map(fn[t c](nth((if(=(type 1)t)vec reverse)(sort((group-by type %)t)))(-(c t)1)))(map type %)(reductions(partial merge-with +)(for[i %]{(type i)1})))

उदाहरण:

(def f #( ... ))
(f [5 \a \x 3 6 \b])
; (3 \x \b 5 6 \a)

यह पूर्णांकों और वर्णों की संचयी ~~योग~~ गणना की गणना करता है, और इसी प्रकार के तत्वों की क्रमबद्ध सूची से सही तत्व को देखने के लिए इसका उपयोग करता है।

— NikoNyrh
स्रोत

0

एपीएल (डायलॉग) , 26 बाइट्स

a[⍒i][⍋⍋27>i←(⎕a,⌽⍳9)⍳a←⎕]

(उपयोग करता है ⎕IO=1)

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

— NGN
स्रोत

संख्या में वृद्धि जबकि पत्र में कमी

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

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

APL (Dyalog) , 27 26 बाइट्स

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

परीक्षण के मामलों

आर , 83 76 बाइट्स

आर , 68 61 बाइट्स

जाप , 18 15 बाइट्स

व्याख्या

जावास्क्रिप्ट, 164 162 158 142 बाइट्स

C ++ 17 (gcc) , 219 बाइट्स

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

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

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

व्याख्या

पायथन, 145 139 130 बाइट्स

05AB1E , 17 बाइट्स

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

क्यू / केडीबी +, ५४ ५३ बाइट्स

सी (जीसीसी) , 125 113 110 बाइट्स

PHP, 66 बाइट्स:

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

सी # (.NET कोर) , 171 बाइट्स

पर्ल 5 , 107 + 1 (एन) = 108 बाइट्स

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

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

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

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

एपीएल (डायलॉग) , 26 बाइट्स