स्व-संशोधन द्वारा गुणा

Question

... कम से कम "आत्म-संशोधन" की कुछ परिभाषा के लिए।

काम

इस चुनौती में, आपका कार्य तीन तार लिखना है A, Bऔर Cयह निम्नलिखित गुणों को पूरा करता है।

• स्ट्रिंग Bकी लंबाई कम से कम 1 है।

• हर एक के लिए n ≥ 0, स्ट्रिंग आपकी पसंद की प्रोग्रामिंग भाषा में एक वैध कार्यक्रम (मतलब पूर्ण चल कार्यक्रम या फ़ंक्शन परिभाषा) है। सुपरस्क्रिप्ट को दर्शाता है पुनरावृत्ति, तो यह साधन तार , , , आदि प्रत्येक प्रोग्राम एक स्ट्रिंग इनपुट के रूप में लेता है, और रिटर्न आउटपुट के रूप में एक स्ट्रिंग।ABnCACABCABBCABBBC

• किसी के लिए m, n ≥ 0, यदि प्रोग्राम इनपुट के साथ चलाया जाता है , तो यह वापस आ जाता है । इस फॉर्म के इनपुट्स के लिए, प्रोग्राम क्रैश सहित कुछ भी कर सकता है।ABmCABnCABm*n+1C

प्रारूप में कुछ उदाहरण program(input) -> output:

AC(AC) -> ABC
ABC(AC) -> ABC
ABBBBBC(AC) -> ABC
AC(ABC) -> ABC
AC(ABBBBC) -> ABC
ABC(ABC) -> ABBC
ABBC(ABC) -> ABBBC
ABBBBC(ABBBC) -> ABBBBBBBBBBBBBC
ABBBC(ABBBBBBC) -> ABBBBBBBBBBBBBBBBBBBC

नियम और स्कोरिंग

आपका स्कोर कुल लंबाई है, AऔरC कम स्कोर बेहतर है। ध्यान दें कि जब Bस्कोर की ओर नहीं गिना जाता है, तो इसे पहले उदाहरण के अनुसार Aऔर उसके द्वारा निर्मित किया जाना चाहिए C।

मानक खामियों को अस्वीकार कर दिया जाता है। कार्यक्रमों को प्रत्यक्ष या अप्रत्यक्ष रूप से अपने स्वयं के स्रोत कोड तक पहुंचने की अनुमति नहीं है (सिवाय इसके कि उन्हें कब इनपुट के रूप में दिया जाए)। आपको स्ट्रिंग्स की पहचान करने की आवश्यकता है A, Bऔर Cआपके उत्तर में किसी तरह से, और आपके समाधान को समझाने के लिए प्रोत्साहित किया जाता है।

Answer 1

CJam, 9 8 बाइट्स

A: 1
B: 0
C:  r,(#0q

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

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

(ABcode) e# Push the integer 10 ** len(Bcode).
<SP>     e# Noop. Separates (AB) and C for input reading.
r        e# Read the first whitespace-separated token from STDIN (ABinput).
,(       e# Push the string length minus 1: len(Binput)
#        e# Power operator: 10 ** len(Bcode) len(Binput) # ->
         e#   (10 ** len(Bcode)) ** len(Binput) = 10 ** (len(Bcode) * len(Binput))
0        e# Push an additional 0 to complete len(Bcode) * len(Binput) + 1 zeroes.
q        e# Read the remaining input (C).

Answer 2

CJam, 15 13 11 बाइट्स

A: rl"
B: <SP>
C: <LF>",(*SNq

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

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

e# A

r     e# Read a whitespace-separated token from STDIN.
      e# This reads the input up to the first space, but does not consume it.
l     e# Read the rest of the first line from STDIN.
      e# This reads up to the first linefeed and consumes it.

"     e# Initiate a string.

e# B

<SP>  e# Fill the string with as many spaces as there are copies of B.

e# C

<LF>" e# Terminate the string with a linefeed.
      e# This serves as a delimiter for the `l' command.
,(    e# Compute the length of the string minus 1 (to account for the LF).
*     e# Repeat the string read by `l' that many times.
SN    e# Push a space and a linefeed.
q     e# Read the remaining input (i.e., the second line) from STDIN.

अंत में, स्टैक में द्वारा पढ़ा गया टोकन होता है r, जिसके द्वारा निर्मित स्पेस *, स्पेस और लाइनफीड द्वारा धक्का दिया जाता है SNऔर लाइन द्वारा पढ़ा जाता है q। CJam इन सभी को अपने आप प्रिंट करता है।

Comments

हाँ, वहाँ उद्धरण का अच्छा उपयोग: D

— अनुकूलक

Answer 3

अजगर, १०

A: w*\0hl*w[<newline>
B: 0
C: <empty>

हम स्रोत को दो लाइनों में विभाजित करते हैं। पहली पंक्ति A है, दूसरी पंक्ति Bs हैं। चूँकि A पहली पंक्ति पर है, पहला wसिर्फ A को प्रिंट करता है - आसान।

पायथ में अग्रणी जीरो सेपरेट टोकन हैं, इसलिए [00)वास्तव में यह है [0, 0]। ध्यान दें कि पहली पंक्ति में समाप्त होता है l[, और दूसरी पंक्ति में होते हैं 0000...। तो l[वास्तव में इस कार्यक्रम में Bs की संख्या गिना जाता है। दूसरा wइनपुट की दूसरी पंक्ति में पढ़ता है - यह इनपुट के Bs की संख्या है। यहाँ से यह एक सरल गुणा, वृद्धि और कई शून्य उत्पादन है।

Answer 4

रेटिना , 25 19 बाइट्स

A: ]\]<LF>
B: ]]
C: <LF>m`^]*$<LF>]$0]

<LF> stands for newline

उदाहरण ABCकोड:

]\]
]]
m`^]*$
]$0]

कोड के दो स्थानापन्न चरण हैं:

• हर AB^mCमें बदलाव करके इनपुट में AB^(m*n)Cबदलाव Bकरें B^n:

  • ]\]हर Bइनपुट में मेल खाता है और पैटर्न लाइनों में भागने के लिए धन्यवाद और कुछ नहीं
  • ]]...]] है B^n

• परिवर्तन B^(m*n)करने के लिए B^(m*n+1)से

  • m`^]*$केवल के साथ लाइन लेने ]की
  • ]$0]एक अतिरिक्त जोड़ी को ]]इस तरह से जोड़ना कि यह रेखा पहले रेगेक्स से मेल नहीं खाती

मैंने -sमल्टी-लाइन फ़्लैग के लिए 3 बाइट्स जोड़े हैं जो कि आवश्यक है ताकि पूरे रेटिना कोड एक फ़ाइल में हो सके।

2 बाइट्स ने @ मार्टिनबटनर को धन्यवाद दिया।

Answer 5

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

A: lambda s:s[:28]+"x"*(1+len("
B: x
C: ")*(len(s)-51))+s[-23:]

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

>>> f=lambda s:s[:28]+"x"*(1+len("xx")*(len(s)-51))+s[-23:]
>>> f('lambda s:s[:28]+"x"*(1+len("xxx")*(len(s)-51))+s[-23:]')
'lambda s:s[:28]+"x"*(1+len("xxxxxxx")*(len(s)-51))+s[-23:]'

समारोह गणना n*m+1के साथ (1+len("xxx")*(len(s)-51))जहां देखते हैं m xस्ट्रिंग में की ( xxxहिस्सा है B^m)। "x"इस संख्या के साथ स्ट्रिंग को गुणा करना B^(n*m+1)और फ़ंक्शन इनपुट से बाहर ले जाता है Aऔर Cइन सभी को प्राप्त करने के लिए सहमति देता है AB^(n*m+1)C।

जे में एक ही दृष्टिकोण:

जे, 35 बाइट्स

A: (19{.]),('x'#~1+(#'
B: x
C: ')*35-~#),_16{.]

Answer 6

CJam, 22

A:<empty>
B:{])`\,q,K/(*))*"_~"}
C:{])`\,q,K/(*))*"_~"}_~

उदाहरण रन:

ABBC(ABC) -> ABBBC

जिसका अनुवाद है

{])`\,q,K/(*))*"_~"}{])`\,q,K/(*))*"_~"}{])`\,q,K/(*))*"_~"}_~

इनपुट के साथ

{])`\,q,K/(*))*"_~"}{])`\,q,K/(*))*"_~"}_~

जो निम्न आउटपुट देता है:

{])`\,q,K/(*))*"_~"}{])`\,q,K/(*))*"_~"}{])`\,q,K/(*))*"_~"}{])`\,q,K/(*))*"_~"}_~

यह कैसे काम करता है :

आइए एक नज़र डालते हैं कि कौन-कौन से प्रोग्राम ACऔर कैसे ABCदिखते हैं:

AC :{])`\,q,K/(*))*"_~"}_~
ABC:{])`\,q,K/(*))*"_~"}{])`\,q,K/(*))*"_~"}_~

हम गौर करते हैं C =B_~

चलो देखते हैं क्या Bकर रहा है:

{])`\,q,K/(*))*"_~"}

{                  }    e# This is a code block. Alone, this does nothing except
                        e# pushing this block to stack as is
 ]                      e# Wrap everything on stack in an array
  )`                    e# Take out the last part and convert it to its string representation
    \,                  e# Take length of remaining array
      q,K/              e# Read the input, take its length and int divide by K (i.e. 20)
          (*            e# Decrement and multiply by the array length on stack
            ))          e# Add two to the product
              *         e# Repeat the string representation on stack that many times
               "_~"     e# Put this string on stack

अब देखते हैं कि ACबिना किसी इनपुट के क्या चल रहा है:

{])`\,q,K/(*))*"_~"}_~                      e# Copy the block and run it
{])`\,q,K/(*))*"_~"}{])`\,q,K/(*))*"_~"}~   e# Block is copied, run it
{      ...         } ])                     e# Wrapped array has the block in it.
                       `\,                  e# Stringify it and take length of remaining = 0
                          q,K/              e# No input so 0
                              (*))          e# 0 * -1 = 0. 0 + 2 = 2
                                  *         e# Repeat the stringified block 2 times:
                                            e# "{])`\,q,K/(*))*"_~"}{])`\,q,K/(*))*"_~"}"
                                   "_~"     e# Put this string. Program ends, so print stack:
                                            e# {])`\,q,K/(*))*"_~"}{])`\,q,K/(*))*"_~"}_~

वाह, आउटपुट है ABC ।

हम मूल रूप से गिनती करते हैं कि Bकोड में कितने मौजूद हैं। फिर इनपुट (लंबाई का उपयोग करके) कितने हैं। उन्हें गुणा करें, दो बार वेतन वृद्धि (साथ Cही B) और _~पाने के लिए अपील करेंC

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

Answer 7

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

fएक समारोह लेने और वापस आ रहा है String।

स्ट्रिंग B एक एकल स्थान है, जबकि C एक से शुरू होता है।

A:_:b="
B: 
C: ";f s|a:c<-words s=unwords$a:(drop 50s>>b):c

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

• _:b=" "स्ट्रिंग शाब्दिक में रिक्त स्थान के लिए सभी को असाइन करता है b, जो प्रोग्राम के एम के बराबर बनाता है बी प्रतियां।
• sइनपुट स्ट्रिंग है। a:c<-words sइसे अंतरिक्ष से अलग किए गए शब्दों में विभाजित करता है, जिससे aA cबन जाता है और C में शामिल शब्दों की एक सूची बन जाती है। B प्रतियों को अनदेखा किया जाता है।words कई स्थानों को निचोड़ने के (जो कि कार्यक्रम के बाकी हिस्से से बच जाता है)।
• drop 50sइनपुट में B प्रतियों की संख्या n के बराबर लंबाई वाला एक स्ट्रिंग है । drop 50s>>bकी कई प्रतियां b, एमएन दे रही है रिक्त स्थान ।
• unwords$a:(drop 50s>>b):cरिक्त स्थान के साथ वापस सभी तार जुड़ते हैं। चूंकि (drop 50s>>b)सूची में एक अतिरिक्त "शब्द" डाला गया है, इसमें एक अतिरिक्त जुड़ने वाला स्थान भी है, स्वचालित रूप से गुणन में +1 जोड़ रहा है।

Answer 8

मतलब, 85५

मेरे लिए पहली बार इस तरह की एक अमूर्त चुनौती, इसलिए मेरे लिए यह एक कोड-गोल्फ चुनौती की तुलना में एक कोडिंग चुनौती से अधिक था!

उद्धरण चिह्नों के बिना तीन तार हैं:

A:    "X=strsplit(input('','s'));m=0 "
B:    "+1 "
C:    ";[X{1},32,repmat(['+1',32],1,m*(length(X)-2)+1),X{end}]"

यह कैसे काम करता है: मैं व्हाट्सएप पर इनपुट तर्क को विभाजित करता हूं, इसलिए nइसे स्ट्रिंग भागों की संख्या से निर्धारित किया जा सकता है। B प्राप्त करने के लिए एक प्रकार के काउंटर के रूप में काम करता हैm । विभाजन से मैं ए और सी का उपयोग करने वाले उत्तर के पुनर्निर्माण के लिए, बी एम * एन + 1 बार दोहराता हूं और मैं उनके एएससीआईआई मूल्य का उपयोग करके रिक्त स्थान सम्मिलित करता हूं, ताकि सी में कोई अवांछित विभाजन न हो।

EDIT: हूप्स, गलती से A + B गिना जाता है

Answer 9

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

स्ट्रिंग्स की पहचान करने की आवश्यकता अवैध इनपुट के लिए हमारे मनमाने व्यवहार की अनुमति के साथ बाधाओं पर लगती है, जब तक कि हमारे पास कोई मानक नहीं है कि पहचान क्या होती है। स्वाभाविक रूप से, मैंने उस व्याख्या को लिया जो सबसे अधिक बाइट्स बहाती है।

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

A: m;f(char*s){m=strrchr(s+66,32)-s-65;printf("%.66s%*s",s,m*strlen("
B: <SPACE>
C: ")+16,s+m+66);}

Comments

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

— जर्ग

Answer 10

टीआई-बेसिक (83 श्रृंखला), 65 बाइट्स

खंड ए (33 बाइट्स):

Input Str1:sub(Str1,1,27:For(I,0,(length(Str1)-55)(length("

खंड बी:

X

खंड सी (32 बाइट्स):

Y")-1:Ans+"X":End:Ans+sub(Str1,length(Str1)-27,28

---

मैं वास्तव में इस क्वीन जैसी चुनौती को लेकर उत्साहित हूं! टीआई-बेसिक में ज्यादातर क्वीन कम से कम धोखा खाए बिना काम नहीं करते, क्योंकि "सिंबल से बचने का कोई रास्ता नहीं है । ("बच" शब्द के दोनों अर्थों में।) लेकिन यहां, हमें Inputकमांड के माध्यम से एक इनपुट स्ट्रिंग मिलती है , और "वहां टाइप करना पूरी तरह से ठीक है।

टीआई-बेसिक की कुछ मात्रा अभी भी यहाँ काम करने के लिए है: एक खाली स्ट्रिंग अमान्य है, इसलिए स्ट्रिंग "XXX...XX"को लूप में डालने का भोला घोल तब काम नहीं करेगा जब n = 0 हो। इसके बजाय, हम मैन्युअल रूप से mn + 1 के मान की गणना करते हैं, और स्ट्रिंग "X"को कई बार सम्मिलित करते हैं ।

जादू स्थिरांक 27और 28कार्यक्रम में, थोड़ा बाइट मायने रखता है 33 और 32 से बंद कर रहे हैं क्योंकि Str1, sub(औरlength( दो-बाइट टोकन कि केवल एक स्ट्रिंग की लंबाई के लिए 1 योगदान कर रहे हैं।

यदि हम इसके बजाय नई कड़ियों का उपयोग करते हैं :, तो ऐसा लगता है कि कब समाप्त होने वाले उद्धरणों को छोड़ कर कुछ बाइट्स बचा सकते हैं, लेकिन यह वास्तव में काम नहीं करता है। सबसे पहले, आपको नई संपादक को एक स्ट्रिंग में जोड़ने से पहले एक हेक्स संपादक की आवश्यकता है: आप इसे केवल टाइप नहीं कर सकते, क्योंकि यदि आप एक Inputकमांड के दौरान ENTER दबाते हैं , तो यह इनपुट को सबमिट करता है। जब मैंने हेक्स संपादक दृष्टिकोण की कोशिश की, तो मुझे एक अजीब बफर अतिप्रवाह त्रुटि मिली जो मेरे कार्यक्रम की सामग्री को संशोधित करती है, इसलिए अपने महंगे कैलकुलेटर के साथ घर पर यह कोशिश न करें।

Answer 11

जावा 11, 135 65 + 26 = 91 बाइट्स

ए

s->{var p=s.split("\\(\"|\"\\.");return p[0]+"(\"B"+p[1].repeat("

बी

B

सी

".length())+'"'+'.'+p[2];}

इसे यहाँ ऑनलाइन आज़माएँ (TIO में अभी जावा 11 नहीं है, इसलिए यह सहायक विधि के बजाय निर्भर करता है String::repeat())।

Ungolfed:

s -> { // lambda taking and returning a String
    var p = s.split("\\(\"|\"\\."); // split input into parts A, B^n, C (where n may be 0) at the "(\"" and "\"."
    return p[0] + "(\"B" + // put it back together: A plus the part the split shaved off, plus an extra B ...
    p[1].repeat("BBB".length()) + // ... plus B^(n*m)
    '"' + '.' + p[2]; // plus C, with the part the split shaved off reattached
}