ऑटोग्राम कार्यक्रम


34

इस वाक्य में दो ए, दो सी, दो डी, अट्ठाईस ई, पांच एफ, तीन जी, आठ एच, ग्यारह ग्यारह, तीन एल, दो मीटर, तेरह एन, नौ ओ, दो पी, पांच आर, पच्चीस s की, तेईसवीं t की, छह v की, दस w की, दो x की, पांच y की, और एक z की।

ऐसे वाक्यों को ऑटोग्राम कहा जाता है । आपका कार्य एक प्रोग्राम या फ़ंक्शन लिखना है जिसमें समान संपत्ति है: यह इनपुट बाइट के रूप में लेता है, और एक पूर्णांक को आउटपुट करता है जो प्रोग्राम के स्रोत कोड में बाइट को प्रदर्शित करता है। यदि इसका इनपुट इसके स्रोत में प्रकट नहीं होता है तो इसे आउटपुट 0 होना चाहिए।

आपके कार्यक्रम को प्रत्यक्ष या अप्रत्यक्ष रूप से अपने स्वयं के स्रोत कोड को नहीं पढ़ना चाहिए , लेकिन इसके बजाय इसके आउटपुट देने के लिए आवश्यक सभी डेटा को हार्ड-कोडेड, क्वीन स्टाइल होना चाहिए। आपका कार्यक्रम लंबाई में कम से कम एक बाइट होना चाहिए।

यह , इसलिए सबसे छोटी प्रविष्टि (बाइट्स में) जीतती है। मैं एक उत्तर नहीं दूंगा, इसलिए अपनी पसंदीदा भाषा में सबसे छोटे समाधान के लिए स्वतंत्र महसूस करें।

आपको अपनी पोस्ट में स्पष्टीकरण शामिल करने के लिए दृढ़ता से प्रोत्साहित किया जाता है।

लीडरबोर्ड

नीचे समग्र स्कोर और प्रति भाषा दोनों के लिए लीडरबोर्ड हैं:


5
सैंडबॉक्स । (यह 2014 के बाद से वहाँ में हो गया है!)
नथानिएल

क्या कार्यों की अनुमति है, या केवल पूर्ण कार्यक्रम हैं?
एरियल

1
नोट: इस के समान उत्तर अब मान्य नहीं है।
user202729

1
एफडब्ल्यूआईडब्ल्यू, उचित क्वीन परिभाषा इस चुनौती के लिए जितना मैं वास्तव में चाहूंगा उससे थोड़ा अधिक मजबूत है। उदाहरण के लिए, मैं एक ऐसे कार्यक्रम को देखकर बहुत खुश होऊंगा, जो किसी न किसी सन्निहित सीमा में सभी वर्णों का उपयोग करता है, और सिर्फ 1 का आउटपुट देता है, यदि उसका इनपुट उस सीमा में है, भले ही उसके पास "प्रोग्राम का एक भाग न हो, जो एनकोड करता है कार्यक्रम का एक अलग हिस्सा "। इस कारण से मैं रेटिना के उदाहरण की अनुमति देने के लिए तैयार था, हालांकि यह निराशाजनक होता अगर यह दूसरों को पोस्टिंग से दूर कर देता, पहले से ही सिर्फ 1 बाइट होने के कारण। (@ user202729)
नथानियल

1
मेरी उक्त टिप्पणी के कारण, मैंने उस कथन को हटा दिया है जो कि नियम लागू होता है। (मैंने स्रोत कोड को नहीं पढ़ने के बारे में भाग लिया है।)
नथानिएल

जवाबों:


15

ऑक्टेव , 44 बाइट्स

@(x)sum([[39,'(())*,239==@[[]]msuxx']]==x)*2

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

फ़ंक्शन का परिणाम, इनपुट में फ़ंक्शन के प्रत्येक वर्ण का उपयोग करते समय:

'  (  )  *  ,  2  3  9  =  @  [  ]  m  s  u  x  
2  4  4  2  2  2  2  2  4  2  4  4  2  2  2  4  

अन्य सभी इनपुट वर्ण एक शून्य लौटाते हैं।

तथ्य यह है कि मुझे बचना 'था यह एक पूरी बहुत लंबा बना दिया। 4 कोष्ठक का हिसाब देने के लिए, मेरे पास स्ट्रिंग में एक डुप्लिकेट था। हालांकि, एपोस्ट्रोफ को डुप्लिकेट करने से एपोस्ट्रोफिस होता है, इसलिए यह हमें सही परिणाम से आगे ले जाता है। इसलिए, मुझे अपने एएससीआईआई-मूल्य के साथ एपोस्ट्रोफ की संख्या की गणना करनी थी 39। यह निश्चित रूप से मेरा मतलब था कि मुझे पात्रों की जांच करनी थी 3और 9यह भी कि यह सब बहुत लंबा है।


2
यह उस तरह की चीज है जिसकी मैं अधिक देखने की उम्मीद कर रहा हूं। (समस्या के लिए ऑप्टिमाइज़ करने के बजाय केवल एक मानक क्वीन लेने और वर्णों को गिनने के लिए कोड जोड़ें।)
नथानिएल

7

एक्सेल, 84 बाइट्स

=IFERROR(MID("65496331125442343343233",FIND(A1,"""123456789,()=MINORFADEOMEN"),1),0)

Find()A1स्ट्रिंग के भीतर सेल में मूल्य की तलाश करेगा "123456789,()=MINORFADEOMEN( """शुरुआत में चरित्र से बचने के लिए है और सिर्फ मूल्यांकन करेगा ")।

के परिणाम के आधार पर Find(), Mid()फ़ंक्शन संख्या के स्ट्रिंग से संबंधित वर्ण वापस कर देगा। इस स्ट्रिंग को पुनरावृति के माध्यम से बनाया गया था जब तक कि इसे बदलना बंद न हो जाए।

यदि वर्ण A1नहीं मिला है, Find()तो एक त्रुटि देता है ताकि IfError()फ़ंक्शन बच जाता है कि 0इसके बजाय वापस लौटना है ।

OMENस्ट्रिंग से किया जा रहा में खोजा गया के अंत में Find()समारोह डुप्लिकेट पत्र तो उनकी स्थिति कभी नहीं लौटा दी जाएगी लेकिन वे चरित्र मायने रखता है समायोजित करने के लिए की जरूरत थी रहे हैं। उनके बिना, गिनती बदलने का एक अंतहीन लूप था। पत्र व्यवस्था शैलीगत पसंद है।


5

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

फ़ंक्शन के स्रोत को नहीं पढ़ता है, लेकिन यह काफी लंबा है। 1-वर्ण स्ट्रिंग के रूप में इनपुट लेता है।

i=>~(n='\\34=\'in(|)0257?:.>[]Odefx~'.indexOf(i))?'3733544333'[n]||2:0

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


आप अलग-अलग पात्रों की मात्रा को कम करने के लिए थोड़ा सा काम करके इस गुच्छा को छोटा कर सकते हैं: i=>'36335633'[i='\\36=\'i|&()25.>[]Odefx~n'.indexOf(i)]||~i&&2(8 बाइट्स बचाया)
यैर रैंड

5

रेटिना , 1 बाइट

यह कड़ाई से मान्य नहीं होगा यदि क्वीन्स नियमों का कड़ाई से पालन किया जाए, लेकिन ओपी ने स्पष्ट रूप से एक टिप्पणी में इसकी अनुमति दी ।

x

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

रेटिना में सिंगल-लाइन प्रोग्राम इनपुट में उस रेगेक्स की घटनाओं को गिनता है। इस चुनौती को छोड़कर किसी एक ASCII वर्ण द्वारा हल किया है `, ., +, *, ?, [, (, ), ^, $, \और न्यू लाइन।


5

सी # (विजुअल सी # कंपाइलर) , 88 57 बाइट्स

x=>"\\\"(())==>>??..::3300CCaaiinoossttx".Contains(x)?3:0

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

रिटर्न 3 यदि स्ट्रिंग पारित कर चार होता है, अन्यथा रिटर्न 0. स्ट्रिंग कम से कम एक बार और वास्तव में राशि चार के लिए आवश्यक कोड के प्रत्येक वर्ण है 3 कोड में कई बार।

-31 बाइट्स केविन क्रूज़सेन को धन्यवाद


अच्छा तरीका! मुझ से +1। आप चारों ओर कोष्ठक को हटाकर (a)=>और चार के रूप में इनपुट को स्ट्रिंग के रूप में ले कर कुछ बाइट्स बचा सकते हैं, इसलिए यह .ToString()अब आवश्यक नहीं है (और a+""कोड-गोल्फ चुनौतियों के लिए भी उपयोग किया जा सकता है, जिनकी आपको कभी आवश्यकता नहीं होगी .ToString())। इसके अलावा, चूंकि .Containsपहले से ही एक है a, आप इनपुट-चर को एक अलग अप्रयुक्त चरित्र (जैसे xया q) में प्रत्येक वर्ण के लिए 3 के बजाय 4 कर सकते हैं। EDIT: कभी भी अंतिम भाग को ध्यान में न रखें, मुझे लगता "है कि अब 4 बार उपयोग किया जाता है।
केविन क्रूज़सेन

@KevinCruijssen सलाह के लिए धन्यवाद। लेकिन क्या स्ट्रिंग इनपुट के रूप में मान्य है? ओपी ने इनपुट के रूप में एक बाइट के लिए कहा?
ह्यूरस

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

1
@ केविनक्रूजसेन उचित लगता है। और अगर हम "में से एक से बचते हैं, तो हम वांछित 3 प्रति
चार्ट पर

2
इनपुट के रूप में सिंगल कैरेक्टर स्ट्रिंग्स मेरे द्वारा ठीक हैं।
नथानियल

4

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

पहले दो संस्करण अनिवार्य रूप से एक क्वीन हैं जो आवश्यक वर्णों को फ़िल्टर करते हैं और फिर लंबाई लेते हैं:

q c=length.filter(==c)$id<>show$"q c=length.filter(==c)$id<>show$"

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


बिना वैकल्पिक (<>), 72 बाइट्स

q c=length.filter(==c)$(++)<*>show$"q c=length.filter(==c)$(++)<*>show$"

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


गैर-क्वीन विकल्प, 87 86 बाइट्स

अभी भी सुधार किया जा सकता है, लेकिन मुझे खुशी है कि मैं इसे केवल तीन अलग-अलग समूहों में ले गया।

मुझे यह सबसे अच्छा लगता है, भले ही यह सबसे अधिक बाइट्स गिना जाता है। यह 2,3 और 7 की राशि के रूप में चरित्र / बाइट की गणना करता है (ध्यान दें कि कुछ वर्ण कई समूहों में हैं):

u t=sum[fst e|e<-[(2," ()-237<=dflnst|"),(3," ()[\\]`mstu"),(7,"\",ee")],t`elem`snd e]

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


* आयात (<>)क्योंकि TIO का GHC संस्करण 8.0.2 है


3

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

-20 बाइट्स ओव्स के लिए धन्यवाद

("''+.23cnotu()"*2+'"*'*3).count

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


1
आप कैसे आते हैं या तो लैम्ब्डा या इनपुट नहीं है?
स्टीवी ग्रिफिन

2
@StewieGriffin पायथन स्वचालित रूप से एक विधि संदर्भ को बांधता है, इसलिए "xxx".countइसके बराबर है lambda c:"xxx".count(c)
नील

@StewieGriffin और आप दोनों का एक ही तरह से उपयोग करते हैं -> f="xxx".countऔर f=lambda c:"xxx".count(c)इसे जैसे ही बुलाया जाएगाf('a')
Rod

3

भूसी , 11 10 8 बाइट्स

-2 बाइट्स के लिए धन्यवाद लियो !

#sD"#sD"

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

व्याख्या

यह सुनिश्चित करता है कि यह केवल ASCII का उपयोग करता है (क्योंकि showयह गड़बड़ करेगा) और यह कि प्रत्येक वर्ण दो बार निहित है:

#sD"#sD"  -- character as input, eg. '"'
   "#sD"  -- string literal (note the redundant '"'): "#sD"
  D       -- double: "#sD#sD"
 s        -- show: "\"#sD#sD\""
#         -- number of occurences: 2

मानक क्वीन एक्सटेंशन, 11 बाइट्स

#hS+s"#hS+s

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

व्याख्या

#hS+s"#hS+s  -- character as input, eg. '"'
     "#hS+s  -- string literal: "#hS+s"
  S+         -- join with itself: ("#hS+s"++)
    s        -- | and itself shown: "\"#hS+s\""
             -- : "#hS+s\"#hS+s\""
 h           -- init: "#hS+s\"#hS+s"
#            -- number of occurences in string: 1

1
आप इसे दिखाने से पहले स्ट्रिंग को दोगुना करके उद्धरणों को अधिक आसानी से प्रबंधित कर सकते हैं: इसे ऑनलाइन आज़माएं!
सिंह

3

जावा 10, 164 81 57 बाइट्स

q->"q-->>\\\"..ccoonttaaiiss(())??33::00".contains(q)?3:0

पोर्ट ऑफ @ हयर्स 'सी # जवाब है , इसलिए उसे उभारना सुनिश्चित करें!

स्पष्टीकरण:

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

q->      // Method with String parameter and integer return-type
  "q->\\\"..ccoonttaaiiss(())??33::00".contains(q)?
         //  If the string above contains the input character
   3     //   Return 3
  :      //  Else:
   0     //   Return 0

पुरानी 164-बाइट्स उत्तर:

c->{var s="c->{var s=%c%s%1$c;return s.format(s,34,s).replaceAll(%1$c[^%1$c+c+']',%1$c%1$c).length();}";return s.format(s,34,s).replaceAll("[^"+c+']',"").length();}

स्पष्टीकरण:

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

c->{                                  // Method with char parameter and integer return-type
  var s="c->{var s=%c%s%1$c;return s.format(s,34,s).replaceAll(%1$c[^%1$c+c+']',%1$c%1$c).length();}";
                                      //  Unformatted source code
  return s.format(s,34,s)             //  Create the formatted source code (the quine),
          .replaceAll("[^"+c+']',"")  //  remove all characters not equal to the input,
          .length();}                 //  and return the length

:

  • स्ट्रिंग sमें बिना स्रोत वाला स्रोत कोड होता है।
  • %sइस स्ट्रिंग को स्वयं के साथ इनपुट करने के लिए उपयोग किया जाता है s.format(...)
  • %c, %1$cऔर 34डबल-कोट्स को फॉर्मेट करने के लिए उपयोग किया जाता है।
  • s.format(s,34,s) यह सब एक साथ रखता है

चुनौती हिस्सा:

  • .replaceAll("[^"+c+']',"") इनपुट के बराबर वाले सभी वर्णों को हटा देता है।
  • .length() फिर इस स्ट्रिंग की लंबाई लेता है।

नोट: .split(c).length( Stringइनपुट के बजाय char) कम लग सकता है, लेकिन दो समस्याएं हैं:

  1. पहला चरित्र एक गलत परिणाम देता है, इसलिए यदि c( c->प्रमुख भाग के रूप में) इनपुट है, तो यह गलत तरीके से एक चरित्र को बहुत कम लौटाएगा। इसे +(c==99?1:0)स्रोत कोड और बिना स्रोत वाले स्रोत कोड स्ट्रिंग (और बदलने के .split(c)लिए) दोनों में जोड़कर ठीक किया जा सकता है .split(c+""), लेकिन फिर भी हमें निम्नलिखित समस्या है:
  2. यदि एक रेगेक्स वर्ण (यानी $) इनपुट है, तो .splitइसे एक गलत परिणाम देते हुए, रेगेक्स के रूप में व्याख्या करेगा।

3

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

f c=sum[2|x<-succ '!':"f c=sum[2|x<-succ '!':,x==c]",x==c]

इसे ऑनलाइन आज़माएं! या समाधान सत्यापित करें

एक ही बाइट गिनती विकल्प:

f c=sum[2|x<-tail$show"f c=sum[2|x<-tail$show,x==c]",x==c]
f c=sum[1|x<-id<>show$"f c=sum[1|x<-id<>show$,x==c]",x==c]

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

sum.($zip"1234\"$,.[\\]opu+()iklmsz652"$[4,4,11,3,3,3,16,5,3,3,3,3,3,3,3]++[2,2..]).lookup

इसे ऑनलाइन आज़माएं! या समाधान सत्यापित करें । इस तथ्य का उपयोग करता है कि sum Nothing = 0और जैसे sum (Just 4) = 4


3

स्मालटाक , 112 132 बाइट्स

स्मालटाक वास्तव में अपनी गोल्फ उपयुक्तता के लिए नहीं जाना जाता है :-)

क्लास कैरेक्टर में परिभाषित विधि (वीए स्मॉलटॉक और स्क्वीक में परीक्षण की गई, विजुअलवर्क्स और फारो जैसी अन्य बोलियों में भी काम करना चाहिए):

a^(0to:6),#(10 18)at:(#('' ',[]^|+68cForu' '#0adefln' '1it' '()' ':s' ' ' '''')findFirst:[:s|s includes:self])+1

स्रोत में होने वाले वर्णों को घटना गणना द्वारा वर्गीकृत किया जाता है। समूहों को पहले एक के लिए परीक्षण किया जाता है जिसमें रिसीवर होता है, और मिलान घटना गिनती वापस आ जाती है।

पुरानी विधि:

a^('''''((((())))):::[[[[]]]]^^^^^0000066666aaaacccccdddddeefffFFFFFiiilllnnnnnrrrrrsssTTTTTuuuu'includes:self)ifTrue:[6]ifFalse:[0]

विधि में दिखाई देने वाला प्रत्येक वर्ण ठीक 6 बार (स्ट्रिंग स्थिरांक में दोहराए जाने से) प्रकट होता है, इसलिए विधि सिर्फ यह जांचती है कि क्या रिसीवर स्ट्रिंग में समाहित है और यदि वह है, तो 6 वापस आता है, अन्यथा।

उपरोक्त विधि को परिभाषित करने के बाद, आप इसका उपयोग करके इसे सत्यापित कर सकते हैं

| code |
code := Character sourceCodeAt: #a.
((0 to: 255) collect: [:b | b asCharacter]) reject: [:c | c a = (code occurrencesOf: c)]

परिणाम रिक्त होना चाहिए।


1
PPCG में आपका स्वागत है!
मार्टिन एंडर

2

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

f=c=>~-`f=${f}`.split(c).length

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


1
मुझे लगता है कि यह अपना स्वयं का स्रोत कोड पढ़ता है, है ना? यह स्पष्ट रूप से प्रतिबंधित है, बोल्ड में, सवाल में।
नथानियल

1
@ नथानियल, यहाँ देखें ।
झबरा

2
हम्म। अच्छी तरह से ईमानदारी से मुझे लगता है कि यह बेवकूफी है, लेकिन मैं वास्तव में मेटा सर्वसम्मति से सहमत नहीं हूं जो मुझे लगता है।
नथानिएल

1
@ नथानियल उन सभी कार्यक्रमों के लिए जो निष्कासन को आसान बनाते हैं, वे भी क्वीन को आसान बनाते हैं।
user202729

1
@ user202729 मुझे नहीं लगता कि यह इस प्रकार है? उदाहरण के लिए, आप पायथन में एक ही चाल नहीं कर सकते। यह एक रिवर्स इवैल है, न कि इवैल
नथानिएल



2

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

n"n"=15;n"="=14;n" "=2;n";"=13;n"\\"=3;n"\""=25;n"0"=2;n"1"=4;n"2"=4;n"3"=4;n"4"=5;n"5"=5;n n3=0

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

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

n 'n'=15;n '='=14;n ' '=14;n ';'=13;n '\\'=3;n '\''=25;n '0'=2;n '1'=5;n '2'=4;n '3'=4;n '4'=5;n '5'=5;n n3=0

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

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

n 'n'=21
n '='=14
n ' '=14
n '\n'=12
n '\\'=4
n '\''=32
n '0'=2
n '1'=5
n '2'=5
n '3'=3
n '4'=5
n '5'=5
n nnnnnn4'''''''=0

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

स्पष्टीकरण

ये उत्तर बहुत परिष्कृत नहीं हैं। यह घोषणाओं की एक श्रृंखला है, कार्यक्रम में मौजूद प्रत्येक चरित्र के लिए एक है। अंत में हमारे पास एक ऐसा सब होता है जो प्रोग्राम में मौजूद पात्रों के लिए 0 रिटर्न देता है।

मैं प्रोग्राम में आवश्यक वर्णों की संख्या को कम करने के लिए कुछ ट्रिक्स का उपयोग करता हूं और वहां से मैंने चीजों के साथ फ़िड किया जब तक कि संख्याएं सही निकलीं। आप देख सकते हैं कि मैंने अंतिम घोषणा में चर नाम को उनमें से 3 में रखा है। 3 कार्यक्रमों के बीच का अंतर यह है कि क्या मैंने एक नई लाइन का उपयोग करने के लिए चुना है या ;लाइन ब्रेक के लिए और क्या मैंने चार्ट को इनपुट या स्ट्रिंग्स के रूप में चुना है। ;दृष्टिकोण स्वाभाविक दूसरों यह सिर्फ भाग्य और समाप्त होता है हो जाता है ऊपर कम से बेहतर प्रतीत नहीं होता है, लेकिन यह प्रतीत होता है कि तार का उपयोग कर वर्ण की तुलना में एक बेहतर विचार है, क्योंकि वर्ण समारोह नाम एक तार नहीं है के बाद रिक्त स्थान की आवश्यकता होती है।


: | स्पष्टीकरण में आपकी वर्तनी का क्या हुआ
ASCII-only

2

व्हॉट्सएप , 140 बाइट्स

[S S S N
_Push_0][S N
S _Duplicate][S N
S _Duplicate][T N
T   S _Read_STDIN_as_character][T   T   T   _Retrieve][S S S T  S S T   N
_Push_9][T  S S T   _Subtract][S N
S _Duplicate][N
T   S S T   N
_If_0_Jump_to_Label_TAB][S S S T    N
_Push_1][T  S S T   _Subtract][S N
S _Duplicate][N
T   S S N
_If_0_Jump_to_Label_NEWLINE][S S S T    S T T   S N
_Push_22][T S S T   _Subtract][N
T   S T N
_If_0_Jump_to_Label_SPACE][N
S T N
_Jump_to_Label_PRINT][N
S S S T N
_Create_Label_TAB][S S S T  S S T   S T N
_Push_37][N
S T N
_Jump_to_Label_PRINT][N
S S S N
_Create_Label_NEWLINE][S S S T  S S S S T   N
_Push_33][N
S T N
_Jump_to_Label_PRINT][N
S S T   N
_Create_Label_SPACE][S S S T    S S S T T   S N
_Push_70][N
S S N
_Create_Label_PRINT][T  N
S T _Print_as_integer]

पत्र S(स्थान), T(टैब), और N(नई-पंक्ति) केवल हाइलाइटिंग के रूप में जोड़े गए।
[..._some_action]केवल स्पष्टीकरण के रूप में जोड़ा गया।

70 रिक्त स्थान, 37 टैब और 33 नई लाइनें उपयोग की गईं।

आम तौर पर मैं क्रम में लेबल बनाएं का उपयोग NSSN, NSSSN,NSSTN , NSSSSN, NSSSTN, NSSTSN, NSSTTN, आदि लेकिन क्योंकि एक संख्या जहां द्विआधारी मुद्रण S=0/ T=1प्रयोग किया जाता है संख्या मैं उत्पादन करने की आवश्यकता को प्रभावित करता है, मैं लेबल का उपयोग किया NSSN, NSSSN, NSSTN, और NSSSTNबजाय, जो दे दी है बाइनरी नंबर SSSTSSSSTN(33, नई लाइनों की राशि), SSSTSSTSTN(37, टैब की राशि औरSSSTSSSTTSN (70; रिक्त स्थान की राशि ।

छद्म कोड में स्पष्टीकरण:

Character c = STDIN-input as character
If c is a tab:
  Print 37
Else if c is a new-line:
  Print 33
Else if c is a space:
  Print 70
Else
  Print 0

उदाहरण चलता है:

इनपुट: स्पेस

Command       Explanation                   Stack       Heap     STDIN   STDOUT   STDERR

SSSN          Push 0                        [0]
SNS           Duplicate top (0)             [0,0]
SNS           Duplicate top (0)             [0,0,0]
TNTS          Read STDIN as character       [0,0]       {0:32}   \n
TTT           Retrieve                      [0,32]      {0:32}
SSSTSSTN      Push 9                        [0,32,9]    {0:32}
TSST          Subtract top two (32-9)       [0,23]      {0:32}
SNS           Duplicate top (23)            [0,23,23]   {0:32}
NTSSTN        If 0: Jump to Label_TAB       [0,23]      {0:32}
SSSTN         Push 1                        [0,23,1]    {0:32}
TSST          Subtract top two (23-1)       [0,22]      {0:32}
SNS           Duplicate top (22)            [0,22,22]   {0:32}
NTSSN         If 0: Jump to Label_NEWLINE   [0,22]      {0:32}
SSSTSTTSN     Push 22                       [0,22,22]   {0:32}
TSST          Subtract top two (22-22)      [0,0]       {0:32}
NTSTN         If 0: Jump to Label_SPACE     [0]         {0:32}
NSSTN         Create Label_SPACE            [0]         {0:32}
SSSTSSSTTSN   Push 70                       [0,70]      {0:32}
NSTN          Jump to Label_PRINT           [0,70]      {0:32}
NSSN          Create Label_PRINT            [0,70]      {0:32}
TNST          Print as integer              [0]         {0:32}            70
                                                                                  error

प्रोग्राम एक त्रुटि के साथ बंद हो जाता है: कोई निकास निर्धारित नहीं।
इसे ऑनलाइन आज़माएं (कच्चे स्थान, टैब और नई-नई लाइनों के साथ)।

इनपुट: टैब

STDIN होगा \t9 इसके बजाय ( ) होगा, जिस स्थिति में यह 0पहली If 0जांच में होगा, LABEL_TAB/ को जाता है NSSSTN, और धक्का देगा और प्रिंट करेगा37 इसके बजाय ।

इसे ऑनलाइन आज़माएं (कच्चे स्थान, टैब और नई-नई लाइनों के साथ)।

इनपुट: नई-लाइन

STDIN इसके बजाय \n( 10) होगा, जिस स्थिति में यह 0दूसरे स्थान पर होगाIf 0 जांच में होगा, Label_NEWLINE/ को जाता है NSSSN, और धक्का देगा और प्रिंट करेगा33 इसके बजाय ।

इसे ऑनलाइन आज़माएं (कच्चे स्थान, टैब और नई-नई लाइनों के साथ)।

इनपुट: कुछ और

कोई भी अन्य इनपुट-कैरेक्टर NSTNतीसरे के बाद (जंप टू लेबल_PRINT) करेगाIf 0 जांच के करेगा0 जो अभी भी स्टैक पर था (जिसे हमने बहुत शुरुआत में डुप्लिकेट किया है)।

इसे ऑनलाइन आज़माएं (कच्चे स्थान, टैब और नई-नई लाइनों के साथ)।


1
इस चुनौती के लिए यह एक महान भाषा है।
qwr

2

जाप , 27 बाइट्स

\Ua"" a a a " ÄU\\\"a "aU Ä
            " ÄU\\\"a "     // Given this string literal,
                       aU   // find the last index of the input
                          Ä // and add +1.
\Ua"" a a a                 // Do nothing useful, but make the results match.

मौजूदा जाप उत्तर की तुलना में लंबा है, लेकिन एक अलग दृष्टिकोण का उपयोग करता है।
अंतर्निहित सीमा है कि सभी वर्णों को कई बार एक अद्वितीय संख्या प्राप्त करने की आवश्यकता होती है।

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

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


2

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

+print+0+((0)x40,6,6,0,3,43,0,0,0,22,12,6,3,5,2,4,0,1,0,0,0,1,0,1,(0)x28,1,0,1,(0)x6,1,(0)x4,1,(0)x4,1,1,1,0,2,0,1,0,0,0,5)[ord<>]

कोई नई रेखा या अन्य व्हाट्सएप नहीं है। मानक आउटपुट से एक पंक्ति पढ़ता है, लेकिन केवल इसकी पहली बाइट्स के बारे में परवाह करता है, फिर बाइट की संख्या को दशमलव में अपने स्वयं के स्रोत कोड में, बिना किसी नई रेखा के प्रिंट करता है।

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

उदाहरण के लिए, 22, 12, 6, 3, 5, 2, 4, 0, 1, 0स्रोत कोड में हिस्सा अंकों की आवृत्ति देता है, इसलिए स्रोत कोड में 22 शून्य, 12 लोग, 6 जुड़वां आदि होते हैं। परिणामस्वरूप, यदि आप 0प्रोग्राम के मानक इनपुट में प्रवेश करते हैं, तो प्रोग्राम प्रिंट होगा 22


2

सी (जीसीसी) , 1033 बाइट्स

#include <stdio.h>
int main(int argc,char *argv[]){int r=0*14811;switch((int)argv[1][0]){case' ':r=6;break;case'"':r=3;break;case'#':r=2;break;case'%':r=2;break;case'\'':r=101;break;case'(':r=5;break;case')':r=5;break;case'*':r=5*1*1;break;case'.':r=2;break;case':':r=51;break;case';':r=103;break;case'<':r=2;break;case'=':r=52;break;case'>':r=2;break;case'[':r=4;break;case'\\':r=3;break;case']':r=4;break;case'0':r=11;break;case'1':r=20;break;case'2':r=20;break;case'3':r=9;break;case'4':r=7;break;case'5':r=12;break;case'6':r=3;break;case'7':r=2;break;case'8':r=5;break;case'9':r=2;break;case'a':r=106;break;case'b':r=51;break;case'c':r=55;break;case'd':r=4;break;case'e':r=102;break;case'f':r=2;break;case'g':r=4;break;case'h':r=4;break;case'i':r=10;break;case'k':r=51;break;case'l':r=2;break;case'm':r=2;break;case'n':r=8;break;case'o':r=2;break;case'p':r=2;break;case'r':r=108;break;case's':r=53;break;case't':r=8;break;case'u':r=2;break;case'v':r=3;break;case'w':r=2;break;case'{':r=3;break;case'}':r=3;break;}printf("%d",r);}

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

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


2

सी (जीसीसी) , 192 बाइट्स

F(J){J=J-70?J-40?J-41?J-74?J-'{'?J-'}'?J-39?J-48?J-49?J-50?J-51?J-52?J-53?J-54?J-55?J-56?J-57?J-47?J-61?J-63?J-45?J-58?J-59?0:1:23:23:23:1:2:3:3:4:4:14:14:10:10:15:6:4:2:2:25:1:1:1;}//84332211

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

संभवत: आगे गोल्फ के लिए संभव है। अतिरिक्त अंक जोड़ने के लिए एक 'स्क्रैच स्पेस' के रूप में अंत में एक टिप्पणी का उपयोग करता है। जब मुझे X से Y तक का अंक बदलना होता है, तो मैं क्षतिपूर्ति करने के लिए Y में से किसी एक को X के लिए बदल देता हूं। इसके अलावा, यह केवल एक फ़ंक्शन है जो एक पूर्णांक लेता है, असाइनमेंट ट्रिक का उपयोग करके एक बड़े टर्नरी सशर्त के आधार पर एक मान लौटाता है।


मैं 0*84332211अन्य सी उत्तर की तरह शून्य के बाद संख्यात्मक स्थिरांक को स्थानांतरित करके 1 बाइट बचा सकता हूं , लेकिन मैं बाइट को बचाने के लिए यह कहकर भी बचा सकता हूं कि छोटा होना है, इसलिए मैं अभी तक परेशान नहीं करने जा रहा हूं।
लैंबडाबेटा

क्या आप कम सामान्य संख्याओं के लिए रेंज चेक का उपयोग करके बाइट्स बचा सकते हैं? यदि हम 4-9 दुर्लभ अक्षर हैं, तो हम सशर्त जांच के साथ एक साथ उन सभी को संभाल सकते हैं।
qwr

लगभग निश्चित रूप से। हम शायद चीजों के लिए चतुर नाम चुनकर और भी अधिक निकाल सकते हैं ताकि कुछ प्रतीक कभी प्रकट न हों या ताकि बिट-पैटर्न का उपयोग किया जा सके (जैसे J&1?सभी विषम वर्णों का मिलान करने के लिए)। अगर मुझे ऐसा करने का समय मिल जाता है तो मैं इसे आगे बढ़ा सकता हूं।
लैंबडाबेटा

2

x86 .COM, 17 बाइट्स, विवादास्पद

0120 BF2001        MOV     DI,0120 (120 be the current address)
0123 B91100        MOV     CX,0011
0126 AE            SCASB
0127 7502          JNZ     012B
0129 FEC4          INC     AH
012B E2F9          LOOP    0126
012D C1E808        SHR     AX,8
0130 C3            RET

36 बाइट्स

0100 BF????        MOV     DI,(an copy of this code)
0103 B91200        MOV     CX,0012
0106 AE            SCASB
0107 7503          JNZ     010C
0109 80C402        ADD     AH,02
010C E2F8          LOOP    0106
010E C1E808        SHR     AX,8
0111 C3            RET

2
क्या यह पढ़ना स्वयं का कोड नहीं है?
रज़वान सोकोल

@RazvanSocol मुझे लगता है कि यह जावास्क्रिप्ट समाधान की तरह है
l4m2

@RazvanSocol अच्छी तरह से यह एक फ़ाइल में बचत की आवश्यकता नहीं है तो यह ठीक है। बहुत सारे फंगेजोइड और जेएस भी ऐसा करते हैं
केवल

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




1

x86, 42 40 बाइट्स

यहां मैं अन्य की तरह ही रणनीति का उपयोग करता हूं: अद्वितीय बाइट्स के साथ प्रोग्राम की एक स्ट्रिंग कॉपी बनाएं, फिर alइनपुट alमें स्ट्रिंग में होने पर 2 वापस करें । यदि हम खुद को ऐसे कोड को पढ़ने की अनुमति देते हैं जो वास्तव में चलाया जाता है, तो हमें l4m2 का समाधान मिलता है ।

मुझे एक शांत स्ट्रिंग निर्देश का उपयोग करने के लिए मिला scasb। मेरे ज्ञान का सबसे अच्छा करने के लिए, कोई डुप्लिकेट बाइट्स नहीं हैं, लेकिन यह कुछ ऐसा है जिसे मैं आसानी से खराब कर दूंगा। स्ट्रिंग पता लोड हो रहा है 5 बाइट्स लेता है, लेकिन मैं किसी भी छोटे समाधान के बारे में पता नहीं है (64-बिट lea)rip भरपाई के साथ 6 बाइट्स लेता है)।

-2 02दो बार उपयोग करने से बचने के लिए पीछे की ओर कूद कर ।

.section .text
.globl main
main:
        mov     $0xff, %eax

start:
        push    $20             # program length
        pop     %ecx            # counter
        mov     $str, %edi      # load string

loop:
        scasb                   # if (al == *(edi++))  
        jne     loop1           
        mov     $2, %al         # ret 2
end:    ret             
loop1:
        loop    loop            # do while (--counter)
        xor     %eax, %eax      # ret 0
        jmp     end

str:    .byte 0x6a,0x14,0x59,0xbf,0xf4,0x83,0x04,0x08 
        .byte 0xae,0x75,0x03,0xb0,0x02,0xc3,0xe2,0xf8
        .byte 0x31,0xc0,0xeb,0xf9 

Hexdump (बाइनरी फाइल फॉर्मेट elf32-i386 की, क्योंकि obj फाइल दुर्भाग्य से के लिए 00बाइट्स हैstr पते के ):

000003e0  6a 14 59 bf f4 83 04 08  ae 75 03 b0 02 c3 e2 f8  |j.Y......u......|
000003f0  31 c0 eb f9 6a 14 59 bf  f4 83 04 08 ae 75 03 b0  |1...j.Y......u..|
00000400  02 c3 e2 f8 31 c0 eb f9                           |....1...|

x86, 256 बाइट्स

बोरिंग जवाब जो एक विशाल टिप्पणी के बराबर है। इनपुट cl, तुरंत 1 में रिटर्न al। खाली समय होने पर मैं एक वास्तविक उत्तर दूंगा।

00000039  b0 01 c3 00 02 03 04 05  06 07 08 09 0a 0b 0c 0d  |................|
00000049  0e 0f 10 11 12 13 14 15  16 17 18 19 1a 1b 1c 1d  |................|
00000059  1e 1f 20 21 22 23 24 25  26 27 28 29 2a 2b 2c 2d  |.. !"#$%&'()*+,-|
00000069  2e 2f 30 31 32 33 34 35  36 37 38 39 3a 3b 3c 3d  |./0123456789:;<=|
00000079  3e 3f 40 41 42 43 44 45  46 47 48 49 4a 4b 4c 4d  |>?@ABCDEFGHIJKLM|
00000089  4e 4f 50 51 52 53 54 55  56 57 58 59 5a 5b 5c 5d  |NOPQRSTUVWXYZ[\]|
00000099  5e 5f 60 61 62 63 64 65  66 67 68 69 6a 6b 6c 6d  |^_`abcdefghijklm|
000000a9  6e 6f 70 71 72 73 74 75  76 77 78 79 7a 7b 7c 7d  |nopqrstuvwxyz{|}|
000000b9  7e 7f 80 81 82 83 84 85  86 87 88 89 8a 8b 8c 8d  |~...............|
000000c9  8e 8f 90 91 92 93 94 95  96 97 98 99 9a 9b 9c 9d  |................|
000000d9  9e 9f a0 a1 a2 a3 a4 a5  a6 a7 a8 a9 aa ab ac ad  |................|
000000e9  ae af b1 b2 b3 b4 b5 b6  b7 b8 b9 ba bb bc bd be  |................|
000000f9  bf c0 c1 c2 c4 c5 c6 c7  c8 c9 ca cb cc cd ce cf  |................|
00000109  d0 d1 d2 d3 d4 d5 d6 d7  d8 d9 da db dc dd de df  |................|
00000119  e0 e1 e2 e3 e4 e5 e6 e7  e8 e9 ea eb ec ed ee ef  |................|
00000129  f0 f1 f2 f3 f4 f5 f6 f7  f8 f9 fa fb fc fd fe ff  |................|

1

APL (Dyalog Classic) , 30 बाइट्स

⊢⊢⊢11-11-11-'''''''1''⊢-⍳⍳0'⍳⊢

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

व्याख्या

एपीएल में, स्ट्रिंग के भीतर एकल उद्धरण दोहरीकरण से बच जाते हैं, इसलिए '''''''1''⊢-⍳⍳0'स्ट्रिंग है'''1'⊢-⍳⍳0 , जिसमें कार्यक्रम में उपयोग किए जाने वाले प्रत्येक चरित्र होते हैं।

APL सरणियाँ डिफ़ॉल्ट रूप से 1-अनुक्रमित होती हैं, और इंडेक्स-ऑफ़ फ़ंक्शन, दिलचस्प रूप से, रिटर्न देता है 1 + max index अगर तत्व नहीं मिला है।

इसलिए, स्ट्रिंग पर इंडेक्स-इन और इनपुट रिटर्न का उपयोग करके

Input    Index    Count
'        1        10
1        4        7
⊢        6        5
-        7        4
⍳        8        3
0        10       1
<other>  11       0

जैसा कि एक देख सकता है, 11 - indexकार्यक्रम में चरित्र की गिनती देता है। तो, बुनियादी एल्गोरिथ्म है

11-'''''''1''⊢-⍳⍳0'⍳⊢

बाकी चरित्रों को ब्लॉट्स में अच्छी तरह से फिट होने की अनुमति देने के लिए फूला हुआ है।


1

आर , 135 बाइट्स

इस पायथन जवाब से प्रेरित है

पिछले संस्करण टूट गए थे। pasteयह इंगित करने के लिए @Giuseppe का धन्यवाद कि आवश्यक नहीं था कि उसने 18 बाइट या तो बचाए। lengths(regmatches(z,gregexpr(x,z)))से है इस सवाल का जवाब

function(x,z=rep(c("afilo2679=:","hmpu15'","nstxz","cgr","e","()",'"',","),c(2:5,7,9,15,16)))sum(lengths(regmatches(z,gregexpr(x,z))))

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



0

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

->x{%q[->x{%q[].count(x.chr)*2}].count(x.chr)*2}

%q[str]एक स्ट्रिंग शाब्दिक लिखने के लिए एक और अधिक सुविधाजनक तरीका है "str"क्योंकि इसे बिना किसी भागने के अंदर ही घोंसला बनाया जा सकता है। इसलिए मैंने अभी इसके अंदर की कॉपी को छोड़कर पूरा कोड डाल दिया, फिर गिनती को दोगुना किया।


0

जेली , 12 10 बाइट्स

“;Ṿċƈ”;Ṿċƈ

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

STDIN के एक चरित्र को पढ़ता है।

12 बाइट्स

Ḣ“Ḣċ;Ṿ¤”;Ṿ¤ċ

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

कमांड लाइन तर्क से इनपुट का उपयोग करना।

इसके अलावा 12 बाइट्स:

ẇ“Ṿẇ¤Ḥ”Ṿ¤Ḥ“”

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

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.