14

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

नमूना इनपुट:

Johnny walked the dog to the park.

नमूना उत्पादन

aaddeeeghhhJklnnoooprtttwy

नियम:

• कोई भी भाषा

• सबसे छोटा कोड जीतता है।

code-golf

— अक्स।
स्रोत

5

ऊपरी / निचले मामले के पत्रों को कैसे छाँटा जाए? ऊपरी निचले से पहले, इसके विपरीत या इनपुट के साथ स्थिर?

— हावर्ड

क्या इसे मूल लैटिन वर्णमाला ("अंग्रेजी वर्णमाला") के बाहर किसी भी अक्षर को संभालने की आवश्यकता है?

— सेबेस्टियन नेग्रास्ज़स

3

शीर्षक से, मुझे उम्मीद थी कि मैं "वर्णमाला क्रम में वाक्य" प्रदर्शित करने के साथ दूर हो सकता हूं। या "सिनेस्ट"। (ठीक है, "Sceeennt", यदि आप सही पूंजीकरण और ASCII आदेश पर जोर देते हैं।)

— केशलैम

जब आप Spaces and symbols can be ignored or deleted, उस मतलब को नजरअंदाज किया जाना चाहिए; या आउटपुट , .aaddeeeffकी अनुमति के रूप में है ?

— ब्लुटोरेंज

4

क्या kआउटपुट में 2 एस नहीं होना चाहिए ?

— हाइपरनेत्रिनो

1

मठगोल्फ , 2 बाइट्स

áδ

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

उदाहरण आउटपुट

      .aaddeeeghhhJkklnnoooprtttwy

गैर-वर्णमाला वर्णों को हटाना

सभी गैर-वर्णमाला वर्णों को हटाने के लिए, यह समाधान काम करता है:

áδgÆ∞_δ¡

यह ऊपर दिए गए कोड के समान है, इसके बाद एक फ़िल्टरिंग है जहां प्रत्येक वर्ण को पहले दोगुना किया जाता है, और फिर इसकी अपनी पूंजीकरण की तुलना की जाती है। उदाहरण के लिए, स्ट्रिंग "a"को परिवर्तित किया जाता है "aa"और फिर पूंजीकृत किया जाता है "Aa", जो कि बराबर नहीं है "aa"। उसी तरह, स्ट्रिंग "B"को परिवर्तित "BB"और पूंजीकृत किया जाता है "Bb", जो इसके बराबर नहीं है "BB"। हालांकि, पूंजीकृत होने पर "."इसे बदल दिया जाता है ".."और अपरिवर्तित किया जाता है, इसलिए इसे फ़िल्टर किया जाएगा।

व्याख्या

मुझे वास्तव में MathGolf में अधिक स्ट्रिंग हैंडलिंग की आवश्यकता है ... अभी लोअरकेस / अपरकेस में बदलने के लिए कोई ऑपरेटर भी नहीं है। केवल एक चीज जो मैं उपयोग कर सकता था वह था कैपिटलाइज़ेशन ऑपरेटर, जो लंबाई के तार के लिए अपरकेस ऑपरेटर की तरह काम करता है। यह समाधान गैर-वर्णानुक्रमिक वर्णों को भी सॉर्ट करता है, लेकिन इन्हें अनदेखा किया जा सकता है। वर्णमाला के अक्षर उनके मामले को बनाए रखते हैं और सही क्रम में आउटपुट होते हैं।

á    sort by comparator
 δ   capitalize string

— maxb
स्रोत

12

GolfScript, 24/6 अक्षर

{26,{65+.32+}%?)},{31&}$

उदाहरण:

> Johnny walked the dog to the park.
aaddeeeghhhJkklnnoooprtttwy

यदि इनपुट प्रिंट करने योग्य ascii तक सीमित है, तो {95&.64>\91<&},फ़िल्टर के रूप में उपयोग करके कोड को तीन वर्णों से छोटा किया जा सकता है ।

यहां परीक्षण किया जा सकता है ।

अनदेखा किया जा सकता संस्करण भी छोटा है (6 वर्ण):

{31&}$

और उत्पादन प्राप्त करता है

> Johnny walked the dog to the park.
      aaddeeeghhhJkkl.nnoooprtttwy

— हावर्ड
स्रोत

और अगर "वर्णमाला" का अर्थ "ASCII आदेश ठीक है" माना जा सकता है, तो इसे कम किया जा सकता है{}$

— McKay

@McKay प्रश्न अलग-अलग तरीके से स्पष्ट रूप से बताता है। और के {}$बराबर होगा $।

— हावर्ड

अरे हां। धन्यवाद, मैं गोल्फ सीखने की कोशिश कर रहा हूँ

— McKay

8

जीएनयू कोर के बर्तन - 25 अक्षर (29 छोड़ने वाले प्रतीक)

fold -1|sort -f|tr -d \\n

उदाहरण (GNU बैश 3 से):

$ echo "Johnny walked the dog to the park."|fold -1|sort -f|tr -d \\n
      .aaddeeeghhhJkklnnoooprtttwy   <<no trailing newline>>

प्रश्न से:

रिक्त स्थान और प्रतीकों को अनदेखा या हटाया जा सकता है

मैंने उन्हें अंदर जाने के लिए चुना! केवल वर्णमाला वर्णों को बनाए रखने fold -1के grep -o \\wलिए, +4 वर्णों के साथ बदलें ।

grep -o \\w|sort -f|tr -d \\n

सिफारिश करने के लिए फायर फ्लाई के लिए धन्यवाद grep -oसे अधिक sedके लिए, और Wumpus fold -1। ;-)

— joeytwiddle
स्रोत

यह वर्णानुक्रम नहीं है, अपरकेस J को अभी भी अन्य निचले अक्षरों के साथ वर्णानुक्रम में क्रमबद्ध होना चाहिए।

— अक्स

ओह अच्छा बिंदु अक्स। मुझे मामले को अनदेखा -fकरने के sortलिए (गुना) जोड़ना होगा ।

— joeytwiddle

6

सी, 121

यह अन्य प्रविष्टियों की तुलना में काफी लंबा है, लेकिन यह किसी भी निर्मित छँटाई या टावलर कार्यों पर निर्भर नहीं करता है:

j;main(k){char s[99],*p=s;gets(s);while(*p){j=p-s-1;k=*p++;while(j>=0&&(s[j]|32)>(k|32))s[j+1]=s[j--];s[j+1]=k;}puts(s);}

अधिक पठनीय संस्करण:

j; main(k) {
    char s[99], *p=s;
    gets(s);
    while(*p) {
        j = p-s-1;
        k = *p++;
        while(j >= 0 && (s[j]|32) > (k|32))
            s[j+1] = s[j--];
        s[j+1] = k;
    }
    puts(s);
}

यह तत्वों के बीच केस-असंवेदनशील तुलना ( |32बिटवाइज ऑपरेशन का उपयोग करके ) के साथ सम्मिलन प्रकार का कार्यान्वयन है । ऐसा इसलिए है क्योंकि ASCII में अपरकेस अक्षर और लोअरकेस अक्षरों को एन्कोडिंग केवल 2 ⁵ बिट से भिन्न होता है ।

— user12205
स्रोत

5

रूबी - 33 शुल्क

$><<gets.chars.sort(&:casecmp)*''

— शिव
स्रोत

आउटपुट कोड कहां है?

— जॉन ड्वोरक

के *""बजाय का उपयोग करके आप 2 वर्णों को छोड़ सकते हैं .join।

— मैनटवर्क

आप उपयोग कर सकते हैं p, लेकिन यह संदिग्ध है, इसलिए बस उपयोग करें puts। इसके अलावा, $<के लिए एक शॉर्टकट है ARGF

— Shelvacu

@manatwork संपादित ...

— शिव

आप 1 वर्ण को अलग कर सकते हैं $><<इसके बजाय इसका उपयोग करके putsअलग होने वाले स्थान को हटाया जा सकता है।

— मैनटवर्क

5

पॉवरशेल: 39

$([string[]][char[]](Read-Host)|sort)" #With spaces and symbols

परिणाम

  .aaddeeeghhhJkklnnoooprtttwy

C #: 100

Console.Write(new string(input.ToCharArray().OrderBy(a=>char.ToLower(a)).ToArray()).Trim('.',' '));

परिणाम

aaddeeeghhhJkklnnoooprtttwy

— राल्फ डी क्लेन
स्रोत

यह प्रश्न के अनुसार एक कार्यक्रम नहीं है ।

— हावर्ड

आप की जरूरत नहीं है ToCharArray; StringऔजारIEnumerable<char>

— राक

@ तो क्या स्क्रिप्ट्स को एक प्रोग्राम के रूप में गिना जाता है?

— राल्फ डे क्लेन

1

आपके प्रतीक-बहिष्करण समाधान केवल नमूना इनपुट के लिए काम करते हैं। वह इनपुट केवल एक नमूना था (वास्तविक इनपुट में अन्य प्रतीकों को भी शामिल किया जा सकता है)।

— सेंडर

1

@RalfdeKleine क्षमा करें, मुझे इस बारे salमें याद आ रहा है, मुझे नहीं लगता कि आप इसका उपयोग कर सकते हैं। लेकिन, आप चर असाइनमेंट से छुटकारा पा सकते हैं "$([string[]][char[]](Read-Host)|sort)"।

— क्रिश हार्पर

4

पर्ल 6: 26 अक्षर

शॉर्ट्स आउटपुट अपरकेस पहले, फिर लोअरकेस, प्रतीकों / व्हाट्सएप को हटाता है

say [~] sort comb /\w/,get

यदि आउटपुट में व्हॉट्सएप / प्रतीकों को भी अनदेखा किया जा सकता है, तो यह केवल 21 अक्षर हैं।

say [~] get.comb.sort

यह मामला असंवेदनशील है, प्रतीक रखता है (26 वर्ण)

say [~] get.comb.sort: &lc

— Ayiko
स्रोत

इसे केस को असंवेदनशील तरीके से सुलझाना पड़ता है लेकिन अगर पसंद है तो यह व्हाट्सएप और प्रतीकों को नजरअंदाज कर सकता है।

— टिमटेक

4

एपीएल 16

      ⍞←A[⍋48|⎕av⍳A←⍞]
Johnny walked the dog to the park.
      aaddeeeghhhJkklnnoooprtttwy.

— मार्क प्लॉटनिक
स्रोत

यह आवश्यकताओं को पूरा नहीं करता है, क्योंकि जे ए, डी, ई, आदि से पहले नहीं आता है

— टाइमटेक

बहुत अच्छा काम वहाँ +1

— टिमटेक

3

पर्ल 34

अब इनपुट लेता है STDIN।

print sort{lc$a cmp lc$b}<>=~/\w/g

पर्ल 18

यदि राजधानियों सहित उत्पादन पहले और शामिल प्रतीकों स्वीकार्य है:

print sort<>=~/./g

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

मुझे संदेह है कि आप इसे cmdline से प्राप्त करने के बजाय इनपुट (विवरण के अनुसार) से स्ट्रिंग लेकर इसे और छोटा कर सकते हैं।

— ब्रेडबॉक्स

ऊओह ठीक है आप!

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

2

पायथन 3: 45

print(''.join(sorted(input(),key=str.lower)))

— evuez
स्रोत

मैं अजगर में नहीं हूं, लेकिन क्या आपका कोड रिक्त स्थान को हटा देता है?

— राल्फ डी क्लेन

नहीं, लेकिन "रिक्त स्थान और प्रतीकों को अनदेखा या हटाया जा सकता है", इसलिए मैं उन्हें अनदेखा करता हूं!

— ईवूज़

आह पढ़ना मुश्किल है;)

— राल्फ डे क्लेन

लैम्ब्डा का उपयोग कुछ बाइट्स बचाता है: इसे ऑनलाइन आज़माएं

— वेदांत कंदोई

2

हास्केल, 88

import Data.List
import Data.Char
import Data.Ord
main=interact$sortBy$comparing toLower

(38 मानक मानक से आयात के बिना)

— Vektorweg
स्रोत

2

k ( १० ९)

स्टड से पढ़ता है

x@<_x:0:0

उदाहरण

x@<_x:0:0
Johhny walked the dog to the park.
"      .aaddeeeghhhhJkklnoooprtttwy"

— skeevey
स्रोत

2

C #: 83

Console.Write(new string(Console.ReadLine().OrderBy(i=>i+"".ToLower()).ToArray()));

अपडेट: 65

LinQPad में निष्पादन योग्य

new string(Console.ReadLine().OrderBy(i=>i+"").ToArray()).Dump();

— अब्बास
स्रोत

1

आप डंप को हटा सकते हैं और इसे लिनक्पैड के एक्सप्रेशन मोड में चला सकते हैं :)

— याकूब

1

जे, 12 वर्ण

(/:32|a.i.])

किसी भी गैर-अल्फा वर्णों को अनदेखा करता है।

— गैरेथ
स्रोत

यह कार्य एक कार्यक्रम के लिए पूछता है। मैं यहाँ I / O नहीं देख सकता। यदि आप किसी भी दुभाषिया झंडे का उपयोग कर रहे हैं, तो आपको उन्हें बताना होगा - और उन्हें चरित्र की गिनती में गिनना होगा।

— जॉन ड्वोरक

@JDDvorak ठीक है, क्या कोई फ़ंक्शन गिनती होगी - f=.या क्या आप मुझे जोड़ना चाहते हैं 1!:1[1?

— गारेथ

1!:1[1और echoकृपया

— जॉन ड्वोरक

@JanDvorak आप क्यों चाहेंगे echo?

— गारेथ

स्क्रिप्ट फ़ाइल चलाते समय J दुभाषिया स्वचालित रूप से अंतिम अभिव्यक्ति के परिणाम का उत्पादन करता है? या, आप इसे कैसे चलाते हैं?

— जॉन ड्वोरक

1

जावास्क्रिप्ट - 74

दुर्भाग्य से, जिस तरह से जेएस वर्णों के कारण, हम मानक छँटाई फ़ंक्शन का उपयोग नहीं कर सकते हैं:

prompt().split("").sort(function(a,b){return a.localeCompare(b)}).join("")

वास्तव में इसे छोटा किया जा सकता है:

prompt().split("").sort((a,b)=>a.localeCompare(b)).join("")

— eithed
स्रोत

1

एफ # ( 68 56)

मैं F # सीख रहा हूं इसलिए मुझे यकीन है कि यह कम हो सकता है:

let f s=s|>Seq.sortBy Char.ToLower|>Seq.iter(printf"%c")

आउटपुट:

> f "Johnny walked the dog to the park."
        .aaddeeeghhhJkklnnoooprtttwy

— रिक
स्रोत

1

PHP, 50 बाइट्स

$a=str_split($argn);natcasesort($a);echo join($a);

गैर-पत्रों को नहीं हटाता, एसटीडीआईएन से इनपुट लेता है; साथ चलाना -R।

— टाइटस
स्रोत

0

आर, 48 वर्ण

cat(sort(unlist(strsplit(scan(,""),""))),sep="")

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

> cat(sort(unlist(strsplit(scan(,""),""))),sep="")
1: Johnny walked the dog to the park.
8: 
Read 7 items
.aaddeeeghhhJkklnnoooprtttwy

— plannapus
स्रोत

0

q / k4 (3? 5? 8?)

यदि यह कोड और इनपुट को सीधे REPL में दर्ज करने के लिए पर्याप्त है, तो यह सिर्फ asc:

q)asc"Johnny walked the dog to the park."
`s#"      .Jaaddeeeghhhkklnnoooprtttwy"

`s#है क्ष अंकन के बिट है कि इंगित करता है कि स्ट्रिंग क्रमबद्ध क्रम में है (बाइनरी खोजा जा सकता है, आदि)। अगर इसे जाना है, तो दो पात्रों की लागत है, जिससे पाँच बनते हैं:

q)`#asc"Johnny walked the dog to the park."
"      .Jaaddeeeghhhkklnnoooprtttwy"

यदि आप चाहते हैं कि यह स्टड पर प्रदान किया जाए, तो यह k4 पर स्विच करने का समय है (और हम मुफ्त में छुटकारा पा लेते `s#हैं), और यह एक आठ-वर्ण समाधान है:

  x@<x:0:0
Johnny walked the dog to the park.
"      .Jaaddeeeghhhkklnnoooprtttwy"

वह एक, btw, एक कोड फ़ाइल के रूप में ठीक वैसे ही काम करेगा (अभी भी आठ वर्ण हैं, क्योंकि q एक कोड फ़ाइल में अंतिम न्यूलाइन नहीं होने के साथ ठीक है)। आम तौर पर स्वागत बैनर के साथ और खुले रहने वाले REPL के साथ समस्याएँ होती हैं, लेकिन यदि आप इनपुट को हेरिंग के रूप में पास करते हैं, तो सभी चले जाते हैं:

$ cat asc.k
x@<x:0:0
$ q asc.k<<<'Johnny walked the dog to the park.'
"\n      .Jaaddeeeghhhkklnnoooprtttwy"
$

वास्तव में यकीन नहीं है कि उत्पादन में अतिरिक्त newline कहाँ से आ रहा है ...।

— हारून डेविस
स्रोत

0

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

ŒlÞ

इस साइट पर मेरा पहला जेली समाधान! मुझे बनाने के लिए जेली और @ डेनिस का उपयोग करने के तरीके के लिए @LeakyNun और @ErikTheOutgolfer का धन्यवाद! : डी

व्याख्या

ŒlÞ
  Þ Sort using the function to its left
Œl  Converts to lowercase (because it's sort alphabetically, not by codepoint)

वैकल्पिक रूप से, ŒuÞइसके बजाय अपरकेस को परिवर्तित करने के अलावा सटीक काम करता है।

— HyperNeutrino
स्रोत

0

जावा 10, 72 बाइट्स (लैम्बडा फंक्शन के रूप में)

s->{for(int i=64;++i<91;)for(var c:s)if((c&~32)==i)System.out.print(c);}

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

लेकिन चूंकि यह पूर्ण कार्यक्रम बताते हुए एक पुरानी चुनौती है:

जावा 10, 126 बाइट्स (पूर्ण कार्यक्रम के रूप में)

interface M{static void main(String[]a){for(int i=64;++i<91;)for(var c:a[0].toCharArray())if((c&~32)==i)System.out.print(c);}}

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

स्पष्टीकरण:

interface M{                        // Class
  static void main(String[]a){      //  Mandatory main method
    for(int i=64;++i<91;)           //   Loop over the uppercase alphabet
      for(var c:a[0].toCharArray()) //    Inner loop over the characters of the input
        if((c&~32)                  //     If the current character converted to uppercase,
                  ==i)              //     equals the current letter of the alphabet
          System.out.print(c);}}    //      Print the character of the input-loop

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

0

05AB1E , 3 2 बाइट्स

Σl

गैर-अक्षर वर्णों को अनदेखा करता है, इसलिए कुछ प्रमुख हैं और कुछ पीछे चल रहे हैं।

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

एक संस्करण जो गैर-अक्षर वर्णों को हटाता है, उसके बजाय 3 बाइट्स हैं:

áΣl

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

स्पष्टीकरण:

á    # Optional: only leave the letters ([a-zA-Z]) of the (implicit) input-string
 Σ   # Sort the characters in the string by (sorted by their ASCII unicode value):
  l  #  Their lowercase equivalent (in case of the letters)
     # (And output the result implicitly)

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

0

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

-join($args-split'\W|(.)'-ne''|sort)

टेस्ट स्क्रिप्ट:

$f = {

-join($args-split'\W|(.)'-ne''|sort)

}

@(
    ,("Johnny walked the dog to the park.", "aaddeeeghhhJkklnnoooprtttwy")
) | % {
    $s,$expected = $_
    $result = &$f $s
    "$("$result"-eq"$expected"): $result"
}

आउटपुट:

True: aaddeeeghhhJkklnnoooprtttwy

— Mazzy
स्रोत

0

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

s->join(sort([s...],by=lowercase))

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

— wilkben
स्रोत

वर्णमाला के क्रम में वाक्य प्रदर्शित करें

मठगोल्फ , 2 बाइट्स

उदाहरण आउटपुट

गैर-वर्णमाला वर्णों को हटाना

व्याख्या

GolfScript, 24/6 अक्षर

जीएनयू कोर के बर्तन - 25 अक्षर (29 छोड़ने वाले प्रतीक)

सी, 121

रूबी - 33 शुल्क

पर्ल 6: 26 अक्षर

एपीएल 16

पर्ल 34

पर्ल 18

पायथन 3: 45

हास्केल, 88

k ( १० ९)

C #: 83

अपडेट: 65

जे, 12 वर्ण

एफ # ( 68 56)

PHP, 50 बाइट्स

आर, 48 वर्ण

q / k4 (3? 5? 8?)

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

व्याख्या

जावा 10, 72 बाइट्स (लैम्बडा फंक्शन के रूप में)

जावा 10, 126 बाइट्स (पूर्ण कार्यक्रम के रूप में)

05AB1E , 3 2 बाइट्स

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

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