उस शब्द पर हस्ताक्षर करें!

12

एक शब्द हस्ताक्षर क्या है?

एक शब्द के हस्ताक्षर यह के पत्र के सभी के क्रम में रखा कर रहे हैं - के हस्ताक्षर this, histऔर hitsसब कर रहे हैं hist।

चुनौती

एक प्रोग्राम लिखें प्रोग्राम को इनपुट के लिए पूछना चाहिए, फिर उस शब्द के हस्ताक्षर का प्रिंट आउट लें। तो एक उदाहरण कार्यक्रम चलाने के लिए इस तरह लग सकता है:

Give me a string: this
The signature signature of 'this' is hist.

कोई आवश्यक इंटरैक्शन नहीं है, जब तक यह एक इनपुट लेता है और हस्ताक्षर को प्रिंट करता है, यह ठीक है।

स्कोरिंग

सबसे छोटी बाइट गिनती जीत के साथ कार्यक्रम!

लीडरबोर्ड

यहां एक नियमित लीडरबोर्ड और भाषा के अनुसार विजेताओं का अवलोकन करने के लिए एक स्टैक स्निपेट है।

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

# Language Name, N bytes

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

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

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

चुनौती समाप्त!

विजेता: jimmy23013

code-golf  string  sorting  word 
— समुदाय
स्रोत
3
हमें वाक्य Give me a string:और The signature signature of 'this' isअधिकार नहीं छपवाने हैं? हम सीधे इनपुट ले सकते हैं और परिणाम प्रिंट कर सकते हैं?
— घातक
4
डुप्लिकेट पत्रों के बारे में क्या? जैसे हस्ताक्षर है broom bmoorया bmor?
— समगक
3
@isaacg तुम क्यों हो?
— टिम
3
@ मुझे नहीं लगता कि हमारे पास ऐसी चुनौतियाँ होनी चाहिए जो इस सीधी-सादी हैं। मैं इसके बारे में मेटा पर पूछूँगा - यह वास्तव में विशेष रूप से इस प्रश्न के बारे में नहीं है।
— isaacg
2
मुझे लगता है कि यदि आप बिल्ट-इन छँटाई कार्यों का उपयोग नहीं कर सकते तो यह एक और दिलचस्प चुनौती होती।
— ग्लेन ओ

जवाबों:

49

गोल्फस्क्रिप्ट, 1 बाइट

$

हाँ, केवल 1 बाइट।

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

— jimmy23013
स्रोत
4
सही के रूप में चिह्नित क्योंकि कोई भी 1 बाइट को हरा नहीं सकता है।
9
@Klkgh सिद्धांत में, शायद कोई ऐसी भाषा पा सकता है जो इसे 0 बाइट्स में कर सकती है?
— jimmy23013
2
मैं कहूंगा कि यह "हैलो" के लिए विफल है
— जेम्स वेबस्टर
3
एक पूंजी के साथ कुछ भी तोड़ने के लिए लगता है, लेकिन लगता है कि यह निर्दिष्ट नहीं था
— लेन
1
राजधानियाँ कोड को नहीं तोड़ती हैं। यह पहले राजधानियों को छाँटता है फिर निचले हिस्से को। यानी cbaCBAfed -> ABCabcdef
— मूल रूप से
25

सी (x86 के साथ), 61 बाइट्स

s[];main(){qsort(s,read(0,s,99),1,"YXZQQQ\x8a\x00*\x02\x0f\xbe\xc0\xc3");puts(s);}

उस स्ट्रिंग में कच्चे बाइट्स होते हैं, वास्तविक नहीं \x.. कोड , और यह एक कच्चा मशीन कोड कॉलबैक होता है qsort। केवल x86 पर काम करता है:

59         pop   ecx
58         pop   eax
5a         pop   edx
51         push  ecx
51         push  ecx
51         push  ecx
8a 00      mov   al,  BYTE PTR [eax]
2a 02      sub   al,  BYTE PTR [edx]
0f be c0   movsx eax, al
c3         ret

जो अनिवार्य रूप से है:

int func(char *a, char *b) { return *a - *b; }

इस के p6-7 देखें पर्चे जापानी भाषा में देखें ।

— लिन
स्रोत
यह सामान्य सी भाषा नहीं है, क्योंकि यह एक विशिष्ट वास्तुकला को लक्षित करता है। यह शीर्षक में निर्दिष्ट होना चाहिए
— edc65
20

अटक, 4 बाइट्स

sc$d

यह भाषा विकी पर कल ही प्रलेखित की गई थी! मम, ताजा एसोलंग।

— लिन
स्रोत
1
अच्छी तरह से किया! :)
— Kade
19

अटक, 5 बाइट्स

मैं अंत में अपनी भाषा, अटक का उपयोग करने के लिए मिलता हूं ! : डी

s$""j

यह स्टड, सॉर्ट्स, जॉइन और अंतर्निहित प्रिंट के माध्यम से एक इनपुट लेता है। इसने मुझे हालांकि बदलाव के लिए कुछ विचार दिए।

संपादित करें: अरे वाह, किसी ने पहले से ही मुझे अपनी भाषा में पोस्ट और हरा दिया है!

— Kade
स्रोत
16

गोटो ++, 432 430 बाइट्स

गोटो ++ प्रोजेक्ट साइट ।

niveaugourou 0
s=ENTRETONTEXTE()
§2 a=LeCaracNumero()&s *(1)
n=*(1)
costaud i=*(2)/&i infeg NombreDeLettres(&s)/i=+*(1)
b=LeCaracNumero()&s &i
GOTONULPOURLESNULS %1 }&b inf &a{
a=&b
n=&i
§1 faiblard
GOTOPRINTDUTEXTE()&a
t=PrendsUnMorceau()&s *(0) &n
u=PrendsUnMorceau()&s }&n+*(1){ *(0)
e=BOITEAPINGOUINS()&t &u
s=Marijuana()&e «»
GOTONONNULPOURLESNULS %3 }NombreDeLettres(&s) eg *(1){
GOTOPASMALIN %2
§3 GOTOPRINTDUTEXTE()&s

मुझे यकीन नहीं है कि मैंने खुद को यह क्यों दिखाया, लेकिन मैंने ऐसा किया

— Fatalize
स्रोत
13

gs2, 1 बाइट

/

गोल्फस्क्रिप्ट जवाब के रूप में भी, लेकिन gs2 छँटाई के लिए एक अलग ऑपरेटर का उपयोग करता है।

— लिन
स्रोत
10

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

print sort<>=~/./g

3 बाइट्स बचाने में मेरी मदद करने के लिए डॉम हेस्टिंग्स का धन्यवाद।

— Samgak
स्रोत
यदि आप एक का उपयोग कर कुछ बाइट्स बचा सकता है /./gके बजाय split'',: print sort<>=~/./g!
— डोम हेस्टिंग्स
के साथ -nE, आप कर सकते हैं say sort/./g।
— डेनिस
6

सी#, 114 110 वर्ण

कमांड लाइन तर्क से इनपुट लेता है। बहुत छोटा कार्यक्रम नहीं है, लेकिन अच्छी तरह से ... यह सी # है। : पी

namespace System.Linq{class P{static void Main(string[]a){Console.Write(string.Concat(a[0].OrderBy(x=>x)));}}}

4 बाइट बचाने के लिए अब्बास को धन्यवाद!

— ProgramFOX
स्रोत
1
के Writeबजाय का उपयोग करके आप 4 वर्णों को बचा सकते हैं WriteLine। ;)
— अब्बास
@ अब्बास धन्यवाद! पूरी तरह से उस एक को याद किया? पी
— ProgramFOX
6

ब्रेनफक, 40 बाइट्स

,[>>+>>,]<<[[<<]>>[-[<]>>[.<<->]>+>>]<<]

यह गिनती सॉर्ट एल्गोरिथ्म का उपयोग करता है , जो इसे O (n) समाधान बनाता है ।

कोड को 8-बिट कोशिकाओं के बाएं-अनंत या रैपिंग टेप की आवश्यकता होती है। इसे ऑनलाइन आज़माएं!

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

,          Read a char from STDIN.
[          While the byte under the pointer (last read char) is non-zero:
  >>+        Move the pointer two steps to the right and increment.
  >>,        Move the pointer two steps to the right and read a char.
]
<<         Move the pointer two steps to the left.

           If the input was "sort", the tape now contains the following:
           0 0 115 0 1 0 111 0 1 0 114 0 1 0 116 0 1 0 0
                                                   ^

[          While the byte under the pointer is non-zero:
  [<<]       Advance two steps to the left until a null byte is encountered.
  >>         Advance two steps to the right.

             This will place the pointer on the first input character.

  [          While the byte under the pointer is non-zero:
    -          Decrement.
    [<]        Move the pointer to the left until a null byte is encountered.
    >>         Move the pointer two steps to the right.

               If the decremented character is non-zero, [<] will move to the
               null byte before it, so >> brings the pointer to the null byte
               after it. If the decremented character is zero, [<] is a no-op, so
               >> advances two steps to the right, to a non-zero byte.

    [          While the byte under the pointer is non-zero:
      .          Print the char under the pointer.
      <<-        Move the pointer two steps to the left and decrement.
      >          Move the pointer to the right.
    ]

               If the decremented character gave zero, this will print the value
               of the accumulator after it, and decrement the character once more
               to make it non-zero, then place the pointer to the right of the
               character, thus exiting the loop.

    >+         Move the pointer to the right and increment.

               This increments the accumulator each time an input character is
               decremented.

    >>         Move the pointer two steps to the right.

               This moves the pointer to the next character.
  ]
  <<         Move the pointer two steps to the left.

             This moves the pointer to the accumulator of the last character.
]

             After 255, th accumulator wraps around to 0, and the loop ends.
— डेनिस
स्रोत
5

CJam, 2 बाइट्स

l$

इनपुट की एक पंक्ति पढ़ता है ( l) और इसे सॉर्ट करता है ( $)।

— लिन
स्रोत
4

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

यह मूल रूप से केवल C # उत्तर के साथ प्रतिस्पर्धी है, क्योंकि, अच्छी तरह से, जावा।

(कम से कम यह गोटो ++ धड़कता है। वास्तव में एक उपलब्धि नहीं है ...)

class C{public static void main(String[]s){s=s[0].split("");java.util.Arrays.sort(s);System.out.print("".join("",s));}}

1 बाइट बचाने के लिए ProgramFOX का धन्यवाद, 2 बाइट बचाने के लिए rink.attenders।

— TheMadHaberdasher
स्रोत
आप के बीच की जगह को हटाने के द्वारा एक चार को बचा सकता है String[]और s।
— प्रोग्रामफॉक्स
ओह, मैं उस बारे में भूल गया। अब मेरी बाइट गिनती एक अच्छा वर्ग संख्या है। धन्यवाद!
— theMadHaberdasher
मुझे लगता है कि आप System.out.printprintln
— rink.attenders.6
धन्यवाद! कोड गोल्फ में यह मेरा पहला प्रयास है, इसलिए मुझे अभी भी इस तरह से सामान सीखना है।
— theMadHaberdasher
आप के साथ 12 अक्षर बचा सकता हैpublic static void main(String[]s){s[0].chars().sorted().forEach(i->System.out.print((char)i));}
— assylias
3

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

डेमो केवल लेखन के समय फ़ायरफ़ॉक्स और एज में काम करता है, क्योंकि Chrome / Opera डिफ़ॉल्ट रूप से ES6 का समर्थन नहीं करता है:

संपादित करें: मैंने पोस्ट करने से पहले उत्तरों को नहीं देखा था, लेकिन अब मुझे पता है कि यह निंजाबियरमोनकी द्वारा किए गए सटीक रूप से बहुत सटीक है ।

f=x=>alert([...x].sort().join``)
<form action=# onsubmit='f(document.getElementById("I").value);return false;'>
  <input type=text pattern=\w+ id=I>
  <button type=submit>Sort letters</button>
</form>
स्निपेट का विस्तार करें

— rink.attendant.6
स्रोत
2

एसडब्ल्यूआई-प्रोलॉग, 34 बाइट्स

a(X):-msort(X,Y),writef("%s",[Y]).

इस तरह कहा जाता है:a(`this`).

— Fatalize
स्रोत
2

स्काला, 21 बाइट्स

print(args(0).sorted)

कमांड लाइन उदाहरण से चलाएँ:

$ scala -e "print(args(0).sorted)" this
hist
— गिलाद होच
स्रोत
2

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

s->join(sort([s...]))

और मज़े के लिए, यहां 53 बाइट्स के लिए एक इनबिल्ट सॉर्टिंग फ़ंक्शन का उपयोग किए बिना आप इसे कैसे कर सकते हैं:

f=s->s>""?(k=indmax(s);f(s[k+1:end]s[1:k-1])s[k:k]):s
— ग्लेन हे
स्रोत
2

जावास्क्रिप्ट, 34 बाइट्स

alert([...prompt()].sort().join``)

यह इतना लंबा होने का कारण यह है कि जावास्क्रिप्ट केवल सरणियों को क्रमबद्ध कर सकता है, इसलिए स्ट्रिंग को एक सरणी में विभाजित किया जाना चाहिए, सॉर्ट किया गया और फिर वापस स्ट्रिंग में शामिल हो गया। यह ईसीएमएस्क्रिप्ट 6 है; ES5 में समतुल्य है:

alert(prompt().split('').sort().join(''))
— NinjaBearMonkey
स्रोत
EcmaScript 6 को निर्दिष्ट करना चाहिए क्योंकि यह प्रयोग कर रहा है ...और टेम्पलेट स्ट्रिंग्स
— edc65
@ edc65 तुम सही हो, मैं भूल गया। किया हुआ।
— निन्जाबियरमोनकी
1

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

print`sorted(raw_input())`[2::5]

हेमवती @ कामेहा के जवाब से प्रेरित है। अजगर में परिवर्तित 2. बहुत अधिक गोल्फ नहीं कर सकता।

— नीला
स्रोत
1
आप reprइसे किसी अन्य बाइट को नीचे लाने के लिए उपयोग कर सकते हैं (अब आप जानते हैं कि मैंने समाधान का पायथन 3 संस्करण क्यों चुना: पी) - print`sorted(raw_input())`[2::5](वे बैकटिक्स हैं, एकल उद्धरण नहीं)
— कम्मेहा
1

एपीएल, 7 वर्ण

मेरे लिए ngn-apl पर काम नहीं करता है, लेकिन सिद्धांत में काम करना चाहिए:

X[⍋X←⍞]

⍞ मानक इनपुट से एक पंक्ति पढ़ता है, जिसे सौंपा गया है X । ⍋Xजिन सूचकांकों में Xआरोही क्रम होता है, और X[...]वास्तव Xमें इन सूचकांकों द्वारा क्रमबद्ध होता है ।

— लिन
स्रोत
1
Dyalog (डेस्कटॉप संस्करण, TryAPL नहीं) पर काम करता है।
— एलेक्स ए।
1

निम, 102 101 79 73 बाइट्स

let s=stdin.readAll
for i in 1..'~':
 for j in s:(if i==j:stdout.write j)

अभी भी निम सीख रहा है और गोल्फ के गुर सीख रहा है। जाहिरा तौर पर यह बेहतर है किsort बिलिन का उपयोग न करें , जिसके लिए बहुत अधिक आयात की आवश्यकता होगी (धन्यवाद @ मौरिस)

— Sp3000
स्रोत
let s=stdin.readAll;for i in 1..'~':(for j in s:(if i==j:echo j)) 65 बाइट्स है।
— लिन
@ मौरिस वाह, मैंने नहीं सोचा था कि बिल्टिन सॉर्ट का इस्तेमाल कम नहीं होगा! केवल समस्या हालांकि - क्या echoअनुगामी न्यूलाइन के बिना एक रास्ता है ?
— Sp3000
ओह, उफ़, बिल्कुल। stdout.write jकाम करने लगता है, और आपके &=पाश से थोड़ा छोटा है ।
— लिन
@ मौरिस वास्तव में, यह काम करने लगता है - धन्यवाद :)
— Sp3000
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.