... almeno per qualche definizione di "auto-modifica".

L'obiettivo

In questa sfida, il vostro compito è quello di scrivere tre corde A, Be Cche soddisfano le seguenti proprietà.

• La stringa Bha una lunghezza di almeno 1.

• Per ogni n ≥ 0, la stringa è un programma valido (che significa programma eseguibile completo o definizione di funzione) nel linguaggio di programmazione che preferisci. L'apice denota ripetizione, quindi questo significa corde , , , ecc Ogni programma richiede una stringa come input, e restituisce una stringa come output.ABnCACABCABBCABBBC

• Per qualsiasi m, n ≥ 0, se il programma viene eseguito con input , ritorna . Per input non in questo modulo, il programma può fare qualsiasi cosa, incluso l'arresto anomalo.ABmCABnCABm*n+1C

Alcuni esempi nel formato 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

Regole e punteggio

Il tuo punteggio è la lunghezza totale diAC , e il punteggio più basso è migliore. Si noti che mentre Bnon viene conteggiato ai fini del punteggio, deve essere prodotto da Ae Ccome nel primo esempio.

Le scappatoie standard non sono ammesse. Ai programmi non è consentito accedere direttamente o indirettamente al proprio codice sorgente (tranne quando gli viene dato come input). Ti viene richiesto di identificare le stringhe e A, in qualche modo, la tua risposta e incoraggiato a spiegare la tua soluzione.BC

CJam, 9 8 byte

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

Provalo online nell'interprete CJam .

Come funziona

(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).

CJam, 15 13 11 byte

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

Provalo online nell'interprete CJam .

Come funziona

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.

Alla fine, lo stack contiene il token letto da r, lo spazio prodotto da *, lo spazio SNe l'alimentazione di linea spinti da e la linea letta da q. CJam stampa tutti questi automaticamente.

Pyth, 10

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

Abbiamo diviso la fonte in due righe. La prima riga è A, la seconda riga sono i Bs. Dato che A è sulla prima riga, il primo wstampa solo A - facile, fatto.

In Pyth gli zero iniziali sono token separati, quindi in [00)realtà lo è [0, 0]. Si noti che la prima riga termina l[e la seconda riga è composta da 0000.... Quindi l[conta effettivamente il numero di Bs in questo programma. La seconda wlegge nella seconda riga dell'input: questo è il numero di Bs dell'input. Da qui è un semplice moltiplicare, incrementare e produrre molti zero.

Retina , 25 19 byte

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

<LF> stands for newline

ABCCodice di esempio :

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

Il codice ha due passaggi sostitutivi:

• modificare l'ingresso AB^mCin AB^(m*n)Ccambiando ogni Ba B^n:

  • ]\]corrisponde a tutti Bnell'input e nient'altro grazie alla fuga nelle linee del modello
  • ]]...]] è B^n

• passare B^(m*n)a B^(m*n+1)da

  • m`^]*$prendendo la linea con solo ]di
  • ]$0]aggiungendone un altro ]]in modo che questa riga non corrisponda al primo regex

Ho aggiunto 3 byte al punteggio per il -sflag multilinea che è necessario in modo che l'intero codice Retina possa essere in un file.

2 byte salvati grazie a @ MartinBüttner.

Python 3, 51 byte

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

Esempio di utilizzo:

>>> 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:]'

La funzione calcola n*m+1con (1+len("xxx")*(len(s)-51))dove ci sono m x's nella stringa ( xxxparte è la B^m). Moltiplicando la stringa "x"con questo numero si ottiene B^(n*m+1)e la funzione prende Ae Cesce dall'input e concatena tutti questi per ottenere AB^(n*m+1)C.

Lo stesso approccio in J:

J, 35 byte

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

CJam, 22

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

Esempio di esecuzione:

ABBC(ABC) -> ABBBC

che si traduce in

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

con input come

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

che fornisce il seguente output:

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

Come funziona :

Diamo un'occhiata a quali programmi ACe ABCaspetto:

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

Notiamo che C=B_~

Vediamo cosa Bsta facendo:

{])`\,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

Ora vediamo cosa ACfarà l' esecuzione senza alcun input:

{])`\,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/(*))*"_~"}_~

Caspita, l'output è ABC.

Fondamentalmente contiamo quanti ne Besistono nel codice. Quindi quanti sono nell'input (usando la lunghezza). Moltiplicali, incrementali due volte (poiché Cha anche B) e aggiungi _~per ottenereC

Provalo online qui

Haskell , 50 byte

fè una funzione che accetta e restituisce a String.

La stringa B è solo un singolo spazio, mentre C inizia con uno.

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

Provalo online!

• _:b=" "assegna letteralmente tutti tranne il primo degli spazi nella stringa b, rendendolo uguale alle copie m B del programma .
• s è la stringa di input. a:c<-words slo divide in parole separate dallo spazio, in modo che adiventi A e cdiventi un elenco delle parole che comprendono C. Le copie B vengono ignorate poiché wordscomprime più spazi (che il resto del programma evita).
• drop 50sè una stringa con lunghezza uguale al numero n di copie B nell'input.drop 50s>>bconcatena che molte copie di b, dando mn spazi.
• unwords$a:(drop 50s>>b):cunisce nuovamente tutte le stringhe insieme agli spazi. Poiché è presente una "parola" aggiuntiva (drop 50s>>b)nell'elenco, è presente anche uno spazio di unione aggiuntivo, che aggiunge automaticamente il +1 alla moltiplicazione.

Matlab, 85

La prima volta per me fare una sfida così astratta, quindi per me è stata più una sfida di codifica che una sfida di code-golf!

Le tre stringhe sono, senza virgolette:

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

Come funziona: ho diviso l'argomento di input su spazi bianchi, quindi npuò essere determinato dal numero di parti di stringa. B funziona come una sorta di contatore da ottenerem . Per ricostruire la risposta che uso A e C dalla divisione, ripeti B m * n + 1 volte e inserisco gli spazi usando il loro valore ASCII, in modo che non si verifichino divisioni indesiderate in C.

EDIT: whoops, contato per errore A + B

C (gcc) , 81 byte

Il requisito di identificare le stringhe sembra in contrasto con il nostro permesso di comportamenti arbitrari per input illegali, a meno che non abbiamo standard piuttosto lassisti su ciò che l'identificazione comporta. Naturalmente, ho preso l'interpretazione che perde più byte.

Provalo online!

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);}

TI-Basic (serie 83), 65 byte

Segmento A (33 byte):

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

Segmento B:

X

Segmento C (32 byte):

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

Sono davvero entusiasta di trovare questa sfida da quine! La maggior parte delle quine non funziona in TI-Basic senza almeno un po 'di barare, perché non c'è modo di sfuggire al "simbolo. (In entrambi i sensi della parola "escape".) Ma qui, otteniamo una stringa di input tramite il Inputcomando e digitando un" c'è perfettamente bene.

C'è ancora un po 'di stupidità TI-Basic da aggirare qui: una stringa vuota non è valida, quindi la soluzione ingenua di inserire la stringa "XXX...XX"in un ciclo non funzionerà quando n = 0. Invece, calcoliamo manualmente il valore di mn + 1 e inseriamo la stringa "X"più volte.

Le costanti magiche 27e 28nel programma sono leggermente fuori dai conteggi di byte 33 e 32, perché Str1, sub(elength( sono token a due byte che contribuiscono solo 1 alla lunghezza di una stringa.

Se usiamo newline invece di :, sembra che quando possiamo salvare qualche byte lasciando fuori le virgolette finali, ma in realtà non funziona. Prima di tutto, hai bisogno di un editor esadecimale prima di poter aggiungere il carattere di nuova riga in una stringa: non puoi semplicemente digitarlo, perché se premi INVIO durante un Inputcomando, invia l'input. Quando ho provato l'approccio dell'editor hex, ho finito per ottenere uno strano errore di overflow del buffer che ha modificato il contenuto del mio programma, quindi non provarlo a casa con la tua calcolatrice costosa.

Java 11, 135 65 + 26 = 91 byte

UN

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

B

B

C

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

Provalo online qui (TIO non ha ancora Java 11, quindi questo si basa su un metodo di supporto anziché 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
}