N पाने के लिए Nth वर्ण चलाएँ

Question

सबसे कम संभव प्रोग्राम को ऐसे लिखें कि जब आप पहले चरित्र और प्रत्येक Nth वर्ण को एक नए प्रोग्राम में शामिल करते हैं, तो आउटपुट N है। यह N = 1, 2, ..., 16 के लिए काम करना चाहिए।

इसे कहने का एक और तरीका है, यदि आप अपने प्रोग्राम के सभी पात्रों को पहले एक और हर Nth को छोड़कर हटा दें , उसके बाद शेष कोड का आउटपुट N होना चाहिए।

उदाहरण

अगर आपका कोड था

ABCDEFGHIJKLMNOP

में एन = 1 परिणाम ABCDEFGHIJKLMNOP। इसे चलाने पर 1.
N = 2 में आउटपुट होना चाहिए ACEGIKMO। इसे चलाने से आउटपुट 2.
N = 3 में परिणाम होना चाहिए ADGJMP। इसे चलाने से आउटपुट 3.
N = 4 में परिणाम होना चाहिए AEIM। इसे चलाने से आउटपुट 4.
N = 5 में होना चाहिए AFKP। इसे रन करना चाहिए 5.
एन = 6 में आउटपुट AGM। इसे चलाने पर 6.
N = 7 में आउटपुट होना चाहिए AHO। इसे चलाने से 7.
N = 8 परिणाम प्राप्त होने चाहिए AI। इसे चलाने से 8.
एन = 9 परिणाम प्राप्त होना चाहिए AJ। इसे चलाने से आउटपुट में 9.
एन = 10 परिणाम होना चाहिए AK। इसे चलाने से आउटपुट 10.
N = 11 में होना चाहिए AL। इसे चलाने से उत्पादन में 11.
N = 12 परिणाम प्राप्त होने चाहिएAM। इसे चलाने से आउटपुट में 12.
N = 13 परिणाम प्राप्त होने चाहिए AN। इसे चलाना आउटपुट में 13.
N = 14 परिणाम होना चाहिए AO। इसे चलाने से 14.
N = 15 परिणाम प्राप्त होने चाहिए AP। इसे चलाने से 15.
N = 16 परिणाम प्राप्त होना चाहिए A। इसे चलाने से आउटपुट 16 होना चाहिए।

विवरण

• सभी वर्ण अनुमत हैं, ASCII और गैर- ASCII। (Newlines और unprintable ASCII के रूप में अच्छी तरह से अनुमति दी जाती है। ध्यान दें कि गाड़ी वापसी और लाइन फीड अलग वर्णों के रूप में गिना जाता है)।
• आपका अंक आपके अनछुए कार्यक्रम (उदाहरण में 15) के पात्रों में लंबाई है । सबसे कम स्कोर जीतता है।
• 16 से नीचे का स्कोर स्पष्ट रूप से असंभव है क्योंकि तब कम से कम दो परिवर्तित कार्यक्रम समान होंगे।
• आउटपुट एक फ़ाइल या stdout या कुछ और उचित हो सकता है। हालाँकि, 16 अलग-अलग कार्यक्रमों का आउटपुट सभी को एक ही जगह पर जाना चाहिए (जैसे कि अगर AOस्टडआउट जाना ठीक नहीं है, लेकिन Aफाइल में जाता है)। कोई इनपुट नहीं है।
• आउटपुट दशमलव में होना चाहिए, हेक्स में नहीं। वास्तविक आउटपुट में केवल 1 या 2 अक्षर होने चाहिए जो 1 से 16 तक की संख्या बनाते हैं, और कुछ नहीं। (मतलब जैसी बातें ans =ठीक हैं।)
• आपके प्रोग्राम को N = 17 या इसके बाद के संस्करण के लिए काम नहीं करना है।

Comments

कार्यक्रम में टिप्पणियों पर आपका रुख? हां या न?

— AndoDaan

@AndoDaan याय।

— केल्विन के

वापसी पर स्वागत है! =) मुझे यह महसूस करने से पहले थोड़ी देर घूरना पड़ा कि यह वास्तव में पूछा गया था, केल्विन शौक से संपादित नहीं किया गया था।

— वेक्टर

हाँ, तो आप हमें छोड़ दिया सब के बाद नहीं! : डी

— दरवाज़े

ऐसा लगता है कि जब कोड है ABCDEFGHIJKLMNOऔर N = 15, परिणाम कोड बस है A।

— स्नैक

Answer 1

एपीएल, ४ ९

⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_×   1_   _⍝_⍝ __2

बदल गए कार्यक्रम

1  ⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_×   1_   _⍝_⍝ __2
2  ⌊⍟7⍟|21189×1×345× 1  ⍝⍝_2
3  ⌊○⍟/119-××5 1 ⍝ 2
4  ⌊7|18××4×1 ⍝2
5  ⌊⍟21×○5   
6  ⌊⍟19×51⍝2
7  ⌊11-4 ⍝
8  ⌊|8×× 2
9  ⌊/9×1 
10 ⌊2×5 
11 ⌊11 ⍝
12 ⌊1×12
13 ⌊13 
14 ⌊14⍝
15 ⌊15 
16 ⌊8×2

explaination

मैं नीचे से शुरू करूँगा क्योंकि यह आसान समझा जाएगा

ध्यान में रखने के लिए एपीएल की दो भाषा विशेषताएं हैं। एक, एपीएल के पास कोई ऑपरेटर नहीं है, बयानों का मूल्यांकन हमेशा दाएं से बाएं किया जाता है। दो, कई एपीएल फ़ंक्शन बहुत अलग तरीके से व्यवहार करते हैं, अगर यह इसके दायीं ओर एक तर्क दिया जाता है या इसके बाईं और दाईं ओर दो तर्क दिए जाते हैं ।

Monadic ⌊दौर नीचे (मंजिल समारोह), dyadic है ×स्पष्ट रूप से गुणा, है ⍝बाहर लाइन के बाकी टिप्पणियां
यह इन स्पष्ट करना चाहिए:

16 ⌊8×2
15 ⌊15 
14 ⌊14⍝
13 ⌊13 
12 ⌊1×12
11 ⌊11 ⍝
10 ⌊2×5 

9:⌊/9×1
/ कम करना है। मूल रूप से यह बाईं ओर फ़ंक्शन और दाईं ओर सरणी लेता है, सरणी के प्रत्येक जोड़ी के बीच फ़ंक्शन सम्मिलित करें और मूल्यांकन करें। (इसे कुछ भाषाओं में "गुना" कहा जाता है)
यहां, सही तर्क एक अदिश राशि है, इसलिए /कुछ भी नहीं करता है।

8:⌊|8×× 2
Monadic ×है Signum समारोह और monadic |निरपेक्ष मूल्य समारोह तो, है × 2करने के लिए मूल्यांकन करता है 1और |8×1निश्चित रूप से है8

7:⌊11-4 ⍝ स्पष्ट होना चाहिए

6:⌊⍟19×51⍝2
मोनाडिक ⍟प्राकृतिक लॉग है
, इसलिए, इसका ⍟19×51मूल्यांकन करता है ln(19×51) = 6.87626...और ⌊इसे नीचे करता है6

5:⌊⍟21×○5
मोनाडिक ○अपने तर्क को mult से गुणा करता
⍟21×○5हैln(21×5π) = 5.79869...

4:⌊7|18××4×1 ⍝2
डायडिक |वह मॉड फंक्शन है जो
×4×1मूल्यांकन करता है 1, और 7|18×1है18 mod 7 = 4

3:⌊○⍟/119-××5 1 ⍝ 2
अंतरिक्ष-पृथक मान एक सरणी है। ध्यान दें कि एपीएल में, जब अधिकांश स्केलर फ़ंक्शन सरणी तर्क देते हैं, तो यह एक निहित मानचित्र है।
Dyadic ⍟लॉग ऑन है
तो ××5 1, पर 5 और 1 Signum की Signum है, जो देता है 1 1, 119-1 1है ¯118 ¯118( ¯सिर्फ ऋण चिह्न है। एपीएल ऋणात्मक संख्याओं और घटाव के बीच भेद करने के लिए है), और ⍟/¯118 ¯118है लॉग _-118 (-118) = 1

2:⌊⍟7⍟|21189×1×345× 1 ⍝⍝_2
आप इसे स्वयं काम कर सकते हैं

1:⌊⊃⍟○7⍟⍟1|/2111118 9⍝×-1 ×○3×4_5_× 1_ _⍝_⍝ __2
यह एक अधिक जटिल उपयोग से मिलकर बनता है /। यदि nएक संख्या है, Fएक फ़ंक्शन है, और Aएक सरणी है, तो nF/Aप्रत्येक समूह की nलगातार प्रविष्टियों को लेता है Aऔर लागू करता है F/। उदाहरण के लिए, 2×/1 2 3प्रत्येक जोड़े को लगातार प्रविष्टियां (जो हैं ) और ले जाती हैं 1 2और प्रत्येक समूह को देने के लिए 2 3लागू होती हैं , बस रिटर्न (जैसा कि यह परिमाण पर लागू होता है)। फिर, ln लागू करता है, फिर उन संख्याओं में ₇ लॉग करें , फिर उन्हें l से गुणा करें और फिर से ln करें। दूसरे पक्ष से जो संख्याएँ निकलती हैं वे यहाँ हैं, बस एक सरणी के पहले तत्व का चयन करने के लिए उपयोग की जाती है।×/2 6
1|/2111118 92111118 9|/⍟○7⍟⍟1.46424... 0.23972...
⊃

Answer 2

पायथन - 1201 1137 (जनरेटर: 241 218) - लंबे समय तक हैश रहते हैं!

रणनीति:

मैं वांछित उत्पादन के रूप में कई हैश के साथ हर लाइन शुरू करने की कोशिश की n। फिर अन्य सभी संस्करण इस लाइन को पूरी तरह से छोड़ देंगे।

हालाँकि, मुख्य कठिनाई हैश की सही संख्या को जोड़ना था, ताकि अगला रन अगली पंक्ति की शुरुआत में सटीक रूप से हिट हो। इसके अलावा, अन्य संस्करणों के साथ हस्तक्षेप हो सकता है, उदाहरण printके लिए लाइन 5 की कमान में 16 संस्करण कूदना और इसी तरह। तो यह बहुत परीक्षण और त्रुटि थी जिसे तेजी से परीक्षण के लिए एक सहायक स्क्रिप्ट के साथ जोड़ा गया था।

सांख्यिकी:

• वर्ण: १२०१ ११३ 11
• हैशिंग: 1066 1002 (88.1%)
• गैर-हैश: 135 (11.9%)

कोड:

#
print 1#####
#p#r#i#n#t# #2######################
##p##r##i##n##t## ##3###
###p###r###i###n###t### ###4
####p####r####i####n####t#### ####5#########
#####p#####r#####i#####n#####t##### #####6##########
######p######r######i######n######t###### ######7###########
#######p#######r#######i#######n#######t####### #######8###
########p########r########i########n########t######## ########9##
#########p#########r#########i#########n#########t######### #########1#########0##
##########p##########r##########i##########n##########t########## ##########1##########1##
###########p###########r###########i###########n###########t########### ###########1###########2##
############p############r############i############n############t############ ############1############3##
#############p#############r#############i#############n#############t############# #############1#############4##
##############p##############r##############i##############n##############t############## ##############1##############5##
###############p###############r###############i###############n###############t############### ###############1###############6

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

with open('printn.py', 'r') as f:
    c = f.read()

for n in range(1, 17):
    print "n =", n, "yields",
    exec c[::n]

आउटपुट:

n = 1 yields 1
n = 2 yields 2
n = 3 yields 3
n = 4 yields 4
n = 5 yields 5
n = 6 yields 6
n = 7 yields 7
n = 8 yields 8
n = 9 yields 9
n = 10 yields 10
n = 11 yields 11
n = 12 yields 12
n = 13 yields 13
n = 14 yields 14
n = 15 yields 15
n = 16 yields 16

---

अद्यतन: एक स्क्रिप्ट बनाने!

मैंने अपने समाधान के बारे में सोचा और यह कि इसे एल्गोरिथम बनाने के लिए एक पैटर्न होना चाहिए। तो अब हम शुरू करें:

lines = ['#']
for i in range(1, 17):
    lines.append(('#' * (i - 1)).join('\nprint ' + `i`))
    fail = True
    while fail:
        while ''.join(lines)[::i].find('print ' + `i`) < 0:
            lines[i] = '#' + lines[i]
        fail = False
        for n in range(1, 17):
            try:
                exec ''.join(lines)[::n]
            except:
                lines[i] = '#' + lines[i]
                fail = True
                break
print ''.join(lines)

यह प्रोग्राम लाइन को लाइन द्वारा बनाता है:

1. एक हैश के साथ शुरू करो।
2. प्रत्येक दो पड़ोसी पात्रों के बीच कमांड और हैश के iसाथ एक नई लाइन को जोड़ें ।print ii - 1
3. जबकि मौजूदा कार्यक्रम के "आई-वर्जन" (हर आई-वें चरित्र) में कमांड print i( nमिसलिग्न्मेंट के कारण) या किसी n in range(1, 17)अपवाद के साथ -version नहीं है, एक अन्य हैश को पिछली पंक्ति में जोड़ें।

यह वास्तव में मैं आज सुबह मिला एक छोटे कार्यक्रम से लौट आया। (इसलिए मैंने अपने समाधान को ऊपर अद्यतन किया है।) इसके अलावा, मुझे पूरा यकीन है कि इस पैटर्न के बाद कोई कम कार्यान्वयन नहीं है। लेकिन आप कभी नहीं जान पाते!

गोल्फ संस्करण - 241 218:

h='#';L=[h];I=range(1,17);J=''.join
for i in I:
 p='print '+`i`;L+=[(h*(i-1)).join('\n'+p)]
 while 1:
  while J(L)[::i].find(p)<0:L[i]=h+L[i]
  try:
   for n in I:exec J(L)[::n]
   break
  except:L[i]=h+L[i]
print J(L)

ध्यान दें कि प्रत्येक पंक्ति के लिए सफल हैश की आवश्यक संख्या को हार्ड-कोडिंग करके एक छोटा जनरेटर हो सकता है। लेकिन यह उन्हें खुद ही गणना करता है और किसी भी एन> 16 के लिए इस्तेमाल किया जा सकता है।

Comments

चरित्र को आमतौर पर "हैश" (या "ऑक्टोथोरपे" कहा जाता है यदि आप फैंसी, या "नंबर साइन" महसूस करते हैं)

— फायरफली

अच्छा काम! रूबी का उपयोग करके आप p 1इसके बजाय का उपयोग करके इसे बहुत छोटा कर सकते हैं print 1।

— केल्विन के

हाँ बिल्कुल! कोड गोल्फ के संदर्भ में यह पायथन की प्रमुख कमजोरी हो सकती है। - लेकिन AndoDaan के 5765776-चरित्र समाधान के लिए धन्यवाद मेरी कोड लंबाई अभी भी औसत से परे है! :)

— फाल्को

Answer 3

Befunge 93 - पांच करोड़ सात सौ पैंसठ हजार और सात सौ सत्तर वर्ण

मैं इसे गंभीरता से लेने की मांग करता हूं ...

v                                                                               &(720 720 - 80) X SPACE
""""""""""""""""                                                                &(720 720 - 80) X SPACE
1234567890123456                                                                &(720 720 - 80) X SPACE
"""""""""1111111                                                                &(720 720 - 80) X SPACE
,,,,,,,,,"""""""                                                                &(720 720 - 80) X SPACE
@@@@@@@@@,,,,,,,                                                                &(720 720 - 80) X SPACE
         ,,,,,,,                                                                &(720 720 - 80) X SPACE
         @@@@@@@                                                                &(720 720 - 80) X SPACE

3 कारण 1 कारण: एक befunge script हमेशा 80x25 होती है, इसलिए कोई बात नहीं, वहाँ कुछ होना चाहिए जो कोड के आधार पर कम हो गया। 2 कारण: क्यों कि कुछ लगभग 5.5 मिलियन रिक्त स्थान है, क्योंकि 720 720 1 से 16 तक का सबसे छोटा सामान्य गुण है ... इसका मतलब है कि जब हम वर्णों को छोड़ रहे होते हैं तो गड़बड़ के आसपास कोई लपेट नहीं होगा। 3 कारण: वाह, यह बहुत बेतुका है।

Answer 4

209 अक्षर (विभिन्न भाषाएँ)

मैंने बस चीजों को सरल रखने और बहुत सारे प्रमुख कारकों के साथ कुछ भी डालने से बचने की कोशिश की। लाभ कई स्क्रिप्टिंग भाषाओं में चलने की क्षमता है। यह किसी भी भाषा में काम करना चाहिए जो जानबूझकर विकृत नहीं है और इसमें निम्नलिखित विशेषताएं हैं:

• पूर्णांक शाब्दिक
• बुनियादी अंकगणितीय ऑपरेटर +, - (घटाव और नकार), *, /
• एक नंगे अभिव्यक्ति का मूल्यांकन प्रिंट करता है
• एक एकल चरित्र है जो एक पंक्ति टिप्पणी शुरू करता है

उदाहरण के लिए,

पायथन 2 कमांड-लाइन दुभाषिया (हालांकि एक फ़ाइल से नहीं):

+                1 #            4 /   23      #    #   5            #            9   #            7   6 *         #    # -        5     2   *  -        ##  2        6   #2                     *   2       6   4

MATLAB ('' 'को'% 'से बदलें):

                 1 %            4 /   23      %    %   5            %            9   %            7   6 *         %    % -        5     2   *  -        %%  2        6   %2                     *   2       6   4

एनबी पहले '1' से पहले 17 स्थान होना चाहिए। आप लोग बहुत सी भाषाएं जानते हैं, इसलिए कृपया मुझे और अधिक सूचीबद्ध करने में मदद करें जो इसमें चल सके (:

संपादित करें: जोड़ा गया लाइन से बचने के लिए पायथन के लिए 0 पर स्थिति + जोड़ा गया।

Comments

स्पाइडर IndentationErrorकमांड लाइन में एक रन फेंकता है । लेकिन हो सकता है कि आपने यहां कोड पोस्ट करते समय सही मार्कडाउन सिंटैक्स का उपयोग नहीं किया हो।

— फल्को

जैसा कि मुझे डर था कि रिक्त स्थान की संख्या गलत हो गई है, लेकिन अब यह तय हो गया है। @ फालो प्रत्येक कार्यक्रम एक पंक्ति में होना चाहिए ताकि मुझे नहीं लगता कि लापता स्थानों को एक इंडेंटेशन त्रुटि का कारण बनना चाहिए। हो सकता है कि आपका दुभाषिया मांग करता है कि सब कुछ संरेखित किया जाए, या हो सकता है कि प्रत्येक संख्या के लिए कार्यक्रम को सभी के बजाय अलग-अलग चलाने की आवश्यकता हो।

— feersum

मेरा दुभाषिया पहली पंक्ति को बहुत शुरुआत में शुरू करने की उम्मीद करता है। तो आपका कोड निष्पादित नहीं किया जा सकता है।

— फल्को

मैं unexpected indentपायथन 2.7 कंसोल में भी मिल रहा हूं । लेकिन यह कोई चिंता नहीं तो Matlab में काम करता है। मेरा मानना ​​है कि यह रूबी में भी काम करता है।

— केल्विन के शौक

उफ़ माफ करना फल्को और केल्विन के शौक, आप सही हैं यह काम नहीं किया। लेकिन मैं पहले चरित्र को '+' में बदलकर त्रुटि को दरकिनार करने में कामयाब रहा।

— feersum

Answer 5

सीजेएम, 89 बाइट्स

GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(iiii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-

यह दृष्टिकोण किसी भी प्रकार की टिप्पणियों का उपयोग नहीं करता है।

iपूर्णांक में जाती है, इसलिए यह यहाँ एक noop है। इसे व्हाट्सएप द्वारा प्रतिस्थापित किया जा सकता है, लेकिन अक्षर मुझे अधिक पठनीय लगते हैं ...

निम्नलिखित कोड निष्पादित करके इसे ऑनलाइन आज़माएं :

G,{)
"GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(iiiii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-"
%_~}%N*

उदाहरण चलाते हैं

$ cat nth-char.cjam 
G,{)"GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(i
iii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-"%_~}%N*N
$ cjam nth-char.cjam 
GiiAHH(5A5(7ii)ii;(;(-i((i(-i)i)ii)i()i((i(i(i
iii(iii(iiiii(iiiii(i-i(iiiiiii(ii(ii(-ii-
1
GiH(A(i)i((i((iii)(i(((
i(i(ii(ii(-(iii(ii(i-
2
GA(5ii(-(-ii(((iii(i(i(iii(((i
3
GHAii((ii(((iii(i-iii(-
4
GH(i(iii(i(i(i(ii-
5
G(i((i((i(((i((
6
G5)-ii(iii(i(
7
GAi(i(iiiii-
8
G5(-(i(ii(
9
G((i((((i
10
G7ii(i(i-
11
Gi((i(i(
12
Gi((ii(
13
G)i(i((
14
Giii(i
15
Giiiii
16

Answer 6

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

1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6

यह टिप्पणियों ( #) और अनिर्दिष्ट "सुपर-कॉमेंट्स" का लाभ उठाता है ( एक बेजोड़ का अनुसरण करते हुए सब कुछ }चुपचाप नजरअंदाज कर दिया जाता है)।

_एक noop है। इसे व्हाट्सएप द्वारा प्रतिस्थापित किया जा सकता है, लेकिन अंडरस्कोर मुझे अधिक पठनीय लगता है ...

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

उदाहरण चलाते हैं

$ cat nth-char.gs
16,{)"1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6"\%.~}%n*
$ golfscript nth-char.gs
1})_#;#;;00123358_(_};}_}_}} _}_(__6
_})4_)_+)__(__}__;_}___6
1
1)##;0238(}}}} }(_
}4)+_(__;}_6
2
1_#025(;}}}_
)))(};_6
3
1#;28}} (
4+(_}6
4
1;05}_}64)__6
5
1#2(}}
)(;6
6
1;3; 6)_}
7
1;8}(4(}
8
10(}
);
9
10}}4_6
10
11}_+_
11
12}
(6
12
13})_
13
13 )}
14
15})6
15
18((
16