7 l8r 9 से अधिक है? (क्या सात बाद में नौ है?)

Question

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

इस उदाहरण पर एक नज़र डालें:

7-9इनपुट के रूप में वापस आ जाना चाहिए 1।

7ASCII कोड 55में 9कनवर्ट करता है , और ASCII कोड में कनवर्ट करता है57 ।

जैसा कि 57संख्यात्मक रूप से होता है 55, 9बाद में होता है 7।

एक और उदाहरण:

LKzb-LKaj इनपुट के रूप में वापस आ जाना चाहिए -1

इसके लिए ASCII कोड सीक्वेंस हैं 76-75-122-98और76-75-97-106

यह एक कोड गोल्फ चुनौती है, और बाइट काउंट है कि कैसे प्रविष्टियों को स्कोर किया जाएगा।

95 मुद्रण योग्य ASCII वर्णों में से किसी भी इनपुट को रिक्त स्थान को छोड़कर, और कुछ के लिए हाइफ़न को स्वीकार किया जाता है, लेकिन इनपुट को अलग करके। इसके अलावा, तार समान लंबाई होने की गारंटी नहीं है।

सौभाग्य!

EDIT: अधिक स्पष्ट होने के लिए, प्रत्येक वर्ण को एक संख्या में अंकों की तरह माना जाता है। उदाहरण में LKzb-LKaj, हालांकि j, बाद में है b, zकी तुलना में बाद में है a, और चूंकि यह अधिक महत्वपूर्ण अंक है, इसलिए यह पूर्ववर्तीता लेता है। एक स्ट्रिंग की आपूर्ति हमेशा न्यूनतम 3 वर्णों पर होगी, इस समस्या के दायरे से खाली तारों को हटा देगी।

संपादित करें: आपकी मदद के लिए यहां कुछ और परीक्षण मामले हैं:

• A-9 -> -1
• 11-Z -> -1
• 3h~J*-3h~J* -> 0
• Xv-Y0 -> 1

Comments

क्या दो तारों की लंबाई समान होने की गारंटी है?

— es1024

टेस्ट केस 11-Z-> -1इससे कोई मतलब नहीं है कि प्रश्न का वर्तमान शब्द क्या है। Z(90) 1(49) से अधिक है और सबसे महत्वपूर्ण अक्षर है। कृपया स्पष्ट करें कि विभिन्न लंबाई के तारों की तुलना कैसे की जाती है।

— जॉर्ज रीथ

और किस बारे में A-AA?

@SamWeaver मुझे पता है कि सबसे बाईं ओर सबसे महत्वपूर्ण अंक है इसलिए मेरा भ्रम है कि 11>Zआपके उदाहरण में ऐसा क्यों है 1<Z। अलग-अलग लंबाई के तारों के साथ करने के लिए कुछ अपरिभाषित व्यवहार होना चाहिए या उदाहरण गलत है।

— जॉर्ज रीथ

जैसा कि पहले बताया गया है: प्रत्येक स्ट्रिंग को आधार -1220 नंबर में एक अंक के रूप में माना जाना है। यदि आप इस प्रणाली में गिने जाते हैं, तो आप एक चरित्र के साथ शुरू करते हैं, इसे प्रिंट करने योग्य वर्णों के अवरोध तक बढ़ा सकते हैं, ~126 पर, फिर अगले अंक को एक से बढ़ाकर, प्रारंभिक अंक को वापस कर देंगे !। सबसे महत्वपूर्ण अंक में प्रत्येक वृद्धि 127 से दूसरे सबसे महत्वपूर्ण अंक में वृद्धि के बराबर है।

— सैम वीवर

Answer 1

पायथ - 11 बाइट्स

आसान, ._साइन प्राप्त करने के लिए और Cचार कोड प्राप्त करने के लिए साइन का उपयोग करता है ।

._-F_CMcz\-

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

टेस्ट सूट ।

._               Sign of number
 -F              Fold subtraction (this finds difference of a tuple)
  _              Reverse list to get correct order of operands when subtracting
   CM            Map char, already treats strings as digits of base256 number
    c \-         Split by "-"
     z           Input

Comments

बहुत अच्छा! उम्मीद के मुताबिक प्रदर्शन करता है।

— सैम वीवर

Answer 2

CJam, 12 बाइट्स

l'-/esfb~\-g

CJam दुभाषिया में इसे ऑनलाइन आज़माएं ।

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

l   e# Read a line from STDIN.
'-/ e# Split it at spaces.
es  e# Push the current time (milliseconds since epoch).
fb  e# Consider each string as digits in base huge-number.
~\  e# Dump the results and reverse their order.
-g  e# Subtract and apply sign function.

Comments

अति उत्कृष्ट! यह सभी परीक्षण मामलों को पास करता है।

— सैम वीवर

Answer 3

जावा, 86 118

int f(String...s){return(int)Math.signum((s=s[0].split("-"))[1].compareTo(s[0])*(s[0].length()==s[1].length()?1:-1));}  

---

तार की तुलना करने का एक बहुत ही अजीब तरीका। एक त्वरित सुधार किया है ताकि यह अतिरिक्त परीक्षण मामलों से गुजरता है, बाद में अधिक गोल्फ की तलाश करेगा।

signumसुझाव के लिए टिप्पणियों में वार्तन का धन्यवाद

Comments

क्या जावा की तुलना 1,0, -1 किसी भी तरह से नहीं होती है? मुझे पता है कि इसकी गारंटी नहीं है, लेकिन क्या इसका कोई मामला नहीं है? जो मामले मेंreturn s[0].compareTo(s[1]);

— वार्टन

यह अच्छा है, लेकिन यह 11-Zवापसी के परीक्षण के मामले को पारित नहीं करता है -1, यह रिटर्न करता है 1।

— सैम वीवर

इससे पहले, उन परीक्षण मामलों को जोड़ने से पहले यह मेरे लिए स्पष्ट नहीं था। फिक्स्ड।

— जोबिट्स

@Vartan नहीं, यह पहली गैर-मिलान स्थिति में मूल्य में अंतर लौटाता है (या यदि एक और सभी वर्णों का मिलान होता है तो लंबाई का अंतर)। उदाहरण के लिए, "A".compareTo("Z") रिटर्न-25 । दुर्भाग्य से।

— जोबिट्स

क्या आप इस लाइन की व्याख्या कर सकते हैं? i = a!=b ? b-a : s[1].compareTo(s[0]);मैं इसे पाने के लिए प्रतीत नहीं होता ... इसके अलावा, आप शायद Math.signum का उपयोग कर सकते हैं और अपने आप को बचाने की घोषणा कर सकते हैं i;

— वर्तन

Answer 4

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

#!/usr/bin/perl -p
/-/;$_=($`.$'^$`)cmp($'.$`^$')

के लिए 30 बाइट्स + 1 बाइट -p। STDIN पर इनपुट स्वीकार करता है।

व्याख्या

जब ऑपरेंड की cmpलंबाई अलग-अलग होती है, जैसे chickenऔर egg, वे इस तरह से संरेखित होते हैं:

c  h  i  c  k  e  n
e  g  g  \0 \0 \0 \0

ताकि egg> chicken( \0एक अशक्त बाइट है)। लेकिन हम चाहते हैं कि उन्हें इस तरह से जोड़ा जाए:

c  h  i  c  k  e  n
\0 \0 \0 \0 e  g  g

ताकि chicken> egg।

ऐसा करने के लिए, हम उन्हें chickenपहले , एक बार पहले eggऔर एक बार eggपहले के साथ chicken:

c  h  i  c  k  e  n  e  g  g
e  g  g  c  h  i  c  k  e  n

अब जब हमारे दो तार एक ही लंबाई के हैं, तो हम पाने के लिए XOR का उपयोग करते हुए प्रमुख शब्द को हटा देते हैं:

\0 \0 \0 \0 \0 \0 \0 e  g  g
\0 \0 \0 c  h  i  c  k  e  n

और अब हम cmpखोजने के लिए उपयोग कर सकते हैं जो पहले आया था। (वहाँ, मैंने कहा!)

Comments

बहुत चालाक- ब्रावो!

— सैम वीवर

Answer 5

पायथन 2, 88 वर्ण

a=raw_input().split('-');print-cmp(*(map(ord,s.rjust(max(map(len,a)),'\0'))for s in a))

cmpसही काम नहीं करता है जब आपके पास दो अलग-अलग लंबाई के तार होते हैं, इसलिए मुझे उस मामले को संभालने के लिए दोनों को अशक्त चरित्र (जो कि ordधर्मान्तरित होता है 0) के साथ पैड करना होगा। दुर्भाग्य से, इसमें लगभग 35 वर्ण जोड़े गए, साथ ही यह अब एक के बजाय दो लाइनें है क्योंकि मुझे इनपुट की लंबाई और उस पर पुनरावृति करने की आवश्यकता है।

Comments

दुर्भाग्य से, यह एक वैध समाधान नहीं है। निम्नलिखित परीक्षण मामला: 1-2जो 1रिटर्न लौटाना चाहिए -1। चतुर काम।

— सैम वीवर

वूप्स, ऐसा प्रतीत होता है कि ऑपरेंड स्वैप किए गए हैं। यह बहुत अजीब है, मैंने इसे आपके परीक्षण मामलों के एक जोड़े के साथ परीक्षण किया और मुझे लगा कि यह ठीक काम कर रहा है! कोई फर्क नहीं पड़ता, मैं इसे चरित्र की गिनती को बदलने के बिना बदल सकता हूं। इसे अभी एक शॉट दें।

— एलेक्स वान एलवाईयू

आपके संपादन ने उस मामले को ठीक कर दिया, लेकिन यह अब इस 11-Aमामले को विफल करता है, जिसे इस उदाहरण में -1वापस लौटने के बजाय वापस लौटना चाहिए 1।

— सैम वीवर

मुझे लंबाई के लिए आपके नियम पसंद नहीं हैं। मैंने इसे लगभग 35 पात्रों की लागत पर तय किया, और मुझे नहीं लगता कि मैं इसे बेहतर बना सकता था।

— एलेक्स वान एलवाईयू

मैं स्ट्रिंग से एक हेक्स प्रारूप में एन्कोडिंग द्वारा एक छोटे से उत्तर पाने में कामयाब रहा, फिर उस स्ट्रिंग को एक इंट के रूप में पार्स करना। अजगर 2 में, यह इसके लिए बड़े-धीरज के लिए डिफ़ॉल्ट लगता है। इस प्रकार, 0 पैडिंग की अब आवश्यकता नहीं है।

— टिब्बा

Answer 6

आर, 54 बाइट्स

इसके लिए प्रकाश पुस्तकालय की आवश्यकता होती है। यह इनपुट स्ट्रिंग को विभाजित करता है- । राइट स्ट्रिंग्स को सही ठहराता है। उन्हें रैंक करता है और एक अंतर करता है।

तो 11-7 के लिए हम "11" और "7" स्ट्रिंग्स के साथ समाप्त होते हैं। इनमें से रैंक [2, 1] है। अंतर -1 है। 3h ~ जे * -3 एच ~ जे * के लिए हमें "3 एच ~ जे *" और "3 एच ~ जे *" मिलता है। इनमें से रैंक 0 के अंतर के साथ [1.5, 1.5] है।

diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))

परीक्षा के उदाहरण

> diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))
1: LKzb-LKaj
3: 
Read 2 items
[1] -1
> diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))
1: A-9
3: 
Read 2 items
[1] -1
> diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))
1: 11-Z
3: 
Read 2 items
[1] -1
> diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))
1: 3h~J*-3h~J*
3: 
Read 2 items
[1] 0
> diff(rank(pracma::strjust(scan(,'',sep='-'),"right")))
1: Xv-Y0
3: 
Read 2 items
[1] 1

Comments

चतुर। अच्छा काम :)

— एलेक्स ए।

Answer 7

कॉफीस्क्रिप्ट, 143 140 139

f=(s)->[a,b]=((t=s.split '-').map (y)->Array((m=Math.max) 1, 1+(m ((l=(c)->c.length) t[0]),l t[1])-l y).join('\u0000')+y);`b<a?-1:(b>a?1:0)`

यहाँ परिणामों के साथ एक jsfiddle है (कंसोल में देखें)

Answer 8

पेरल, 46 36 बाइट्स

print$2cmp$1if"@ARGV"=~/(\S+)-(\S+)/

Argv सूची को एक स्ट्रिंग में परिवर्तित करता है, हाइफ़न द्वारा एक बाएँ और दाएँ पक्षीय कोई रिक्त स्थान arg में विभाजित करता है, फिर cmp कॉल लौटाता है।

Comments

मुझे संदेह है कि आप कई रिक्त स्थान और से छुटकारा पा सकते हैं;

— मिकट

के साथ दूर जाने में सक्षम होना चाहिए: "@ARGV"=~/-/;print$`cmp$' (

— निष्कलंक

उपयोग करने के लिए अच्छा विचार है cmp, लेकिन यह तब काम नहीं करता है जब स्ट्रिंग की लंबाई अलग हो। "A" cmp "9"1 है, जबकि "11" cmp "Z"-1 है, भले ही दोनों इनपुट को इस चुनौती के लिए समान मूल्य वापस करना चाहिए।

— ThisSuitIsBlackNot

Answer 9

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

x,y=[int.from_bytes(i.encode(),"big")for i in input().split("-")];print((x<y)-(y<x))

द्वारा स्ट्रिंग इनपुट विभाजित करें "-"। यूनिकोड स्ट्रिंग्स को बाइट्स स्ट्रिंग्स में कनवर्ट करें, फिर इन बाइट स्ट्रिंग्स को बड़े-एंडियन पूर्णांक के रूप में व्याख्या करें। अंत में तुलना करें - (संयुक्त राष्ट्र) सौभाग्य cmpसे अब पायथन 3 में उपलब्ध नहीं है।

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

print -cmp(*[int(i.encode("hex"),16)for i in raw_input().split("-")]) 

Comments

आप के बीच की जगह को हटाकर एक चरित्र बंद दाढ़ी कर सकते हैं printऔर cmp।

— एलेक्स वान एलवाईयू

Answer 10

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

सुंदर सरल समाधान, और यह समझना आसान है। स्ट्रिंग की लंबाई की तुलना करता है, फिर तार की तुलनात्मक रूप से करता है।

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

s,t=raw_input().split('-')
x,y=len(s),len(t)
print(x<y)*2-1if x-y else cmp(t,s)

Answer 11

perl5, 64

perl -aF- -pe '@f=map{length}@F;$_=$f[1]<=>$f[0]||$F[1]cmp$F[0]'

बस इसे कमांडलाइन से चलाएं। हालाँकि यह एक नई लाइन के साथ बेहतर लगेगा लेकिन इसकी कीमत 1 char है।

perl -laF- -pe '@f=map{length}@F;$_=$f[1]<=>$f[0]||$F[1]cmp$F[0]'

यह लंबा संस्करण बेमेल लंबाई को सही ढंग से संभालता है।

Comments

/-/,$_=$`cmp$'आसान होगा, और आप -aF-थोड़ा छोड़ सकते हैं । इसके अलावा, मैं इसे 20 (16 के लिए $_=$F[1]cmp$F[0], और 4 के लिए paF-, एक फ़ाइल में सहेजा गया और इस रूप में चलाता हूं) की गणना करता हूं perl -paF- file.pl।

— प्रिमो जूल

जैसा कि मैंने एरिक के जवाब पर उल्लेख किया है , cmpतब काम नहीं करता है जब दो तार अलग-अलग लंबाई के होते हैं, जैसे 11-Z।

— ThisSuitIsBlackNot

@ThisSuitIsBlackNot, निश्चित।

— हल्दी

अच्छा लगा। आप नीचे 39 /-/;$_=length$'<=>length$`||$' cmp$`और उसके साथ गोल्फ कर सकते हैं -p। ( $`रेगेक्स मैच से पहले सब कुछ स्टोर करता है, $'बाद में सब कुछ स्टोर करता है।) mapवास्तव में केवल lengthदो बार कॉल करने की तुलना में अधिक बाइट्स का उपयोग करना ।

— ThisSuitIsBlackNot 13

Answer 12

एफ #, 53

fun s->let[|a;b|]=s="";s.Split[|'-'|]in b.CompareTo a

यह एक अनाम फ़ंक्शन (लैम्ब्डा) के रूप में है, इसलिए आपको इसे पेस्ट करना होगा और सीधे पैरामीटर प्रदान करना होगा (या, पाइपिंग नोटेशन का उपयोग करके)। उदाहरण के लिए (एफएसआई में):

> "7-9" |> fun s->let[|a;b|]=s="";s.Split[|'-'|]in b.CompareTo a
1
> "abc-abc" |> fun s->let[|a;b|]=s="";s.Split[|'-'|]in b.CompareTo a
0
> "LKzb-LKaj" |> fun s->let[|a;b|]=s="";s.Split[|'-'|]in b.CompareTo a
-1

Answer 13

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

f=s=>((a=s.split('-'))[1]>a[0])-(a[1]<a[0])

Comments

अच्छा काम है, लेकिन यह परीक्षण के मामले को पूरा नहीं करता है 2: 11-Zवापस आना चाहिए -1लेकिन यह वापस आ जाता है 1।

— सैम वीवर

@SamWeaver दरअसल, जो उत्तर के बाद जोड़ा गया था और अन्य उत्तर भी तोड़ता है। क्या आप बता सकते हैं कि '11'>'Z'जब '11'<'ZZ'अलग-अलग लंबाई के स्ट्रिंग की तुलना या खाली स्ट्रिंग का क्या मूल्य है, इसके बारे में सवाल में कुछ भी नहीं है।

— जॉर्ज रीथ

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

— सैम वीवर

@SamWeaver परिभाषित करने के लिए अपरिभाषित व्यवहार से परिवर्तन इसे बदलता है। कुछ भी चरित्र नहीं है। जब तक इसका अशक्त चरित्र, जो यह संभालता है।

— जॉर्ज रीथ

Answer 14

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

a,b=gets.chomp.split ?-
p (b.size<=>a.size).nonzero?||b<=>a

Answer 15

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

'-¡₄ö¥0.S

इसे ऑनलाइन आज़माएं या सभी परीक्षण मामलों को सत्यापित करें ।

स्पष्टीकरण:

'-¡          # Split the (implicit) input on '-'
             #  i.e. 'LKzb-LKaj' → ['LKzb','LKaj']
   ₄ö        # Convert both parts to a Base-1000 number
             #  i.e. ['LKzb','LKaj'] → [21020061037,21020036045]
     ¥       # Push the deltas (subtraction between each sub sequential pair) of the list
             #  i.e. [21020061037,21020036045] → [-24992]
      0.S    # Get the sign [1 for a>0; -1 for a<0; 0 for a==0] (and output implicitly)
             #  i.e. [-24992] → [-1]