Göreviniz, çalıştırıldığında kendisini çıktı olarak döndüren bir program oluşturmaktır (bu bir quine olarak bilinir). Bununla birlikte, bu tırnak kopyalanan nzamanlar tırnak kopyasını döndürmelidir, ancak karakterlerinin her biri yer nzamanlarında çoğaltılır , burada npozitif bir tamsayıdır.

Orijinal programınız Derp:

Derp -> Derp (must return itself as output to be a quine)

DerpDerp -> DDeerrpp
(the "Derp" is copied twice, so each character in the output has to be copied twice)

DerpDerpDerp -> DDDeeerrrppp
etc. etc.

"Temel" programınızda boşluk olmasına izin verildiğini, ancak "birbirinin içine girerken" sayıldığını unutmayın. Diyelim ki programınız

Derp 
{newline}

(Yeni satır, sondaki yeni bir satır anlamına gelir ve bundan sonra fazladan bir alan vardır Derp). Olmak için çoğaltıldığında

Derp 
Derp 
{newline}

Çıktı almalısınız

DDeerrpp  
{newline}
{newline}

Sonradan 2fazladan boşluk olduğunu unutmayın DDeerrpp.

Kurallar ve Özellikler:

• Programınız en az iki farklı karakter içermelidir (bu, kodunuzun en az 2 bayt uzunluğunda olması gerektiği anlamına gelir).
• Standart quine kuralları geçerlidir.

Bu kod golf , bayt en kısa kod kazanır!

Bölünme , 6 bayt

'!+OR"

Çevrimiçi deneyin! İki kopya deneyin! Üç deneyin!

açıklama

Bu sadece Fission standart modeli . Bu meydan okuma için işe yarıyor, çünkü Fission'ın programa açık giriş noktaları var. Özellikle, programı kopyalayarak, başka Rbir atom ekleyen başka bir atom ekliyoruz (talimat işaretçisi). Kaynak kodu toroidal olduğundan, yürütülen etkin kod başka şekilde değişmez - her bir atom için, kod yine de yerel olarak aynı görünür. Bununla birlikte, atomlar kilit adımında yürütülür, böylece yazdırdıkları şeyler serpiştirilir ve çıktıdaki her karakterin ek bir kopyasını alırız.

Tamlık uğruna, programın nasıl çalıştığını kısaca tekrarlayacağım. Programı tekrarlayıp tekrarlamamıza bakılmaksızın (örneğin '!+OR"'!+OR"'!+OR"), her atom aşağıdaki kodu görür:

R"'!+OR"'!+O

"Geçiş yapar dize baskı modu, böylece programın yazdırarak başlayan '!+ORtüm alıntı hariç Quine'ın olan STDOUT, doğrudan. Sonra '!karakter koduna atomun kütlesini belirler !, +verir o artışlarla, "ve Oaynı anda atom tahrip ederken onu yazdırır. Daha sonra program sona erer, çünkü atom kalmamıştır.

Python 2.7, 377 310 304 194 191 bayt!

Bu benim ilk golf, bu yüzden çok iyi olmasını beklemiyorduk. Ama bulduğum çözümdeki kavramın biraz komik olduğunu düşündüm, bu yüzden yine de gönderiyorum.

def f():
 import threading as T,inspect as i;global t,a,i
 try:t.cancel()
 except:a=0
 a+=1;t=T.Timer(1,d);t.start()
def d():print''.join(c*a for c in i.getsource(f)+i.getsource(d)+"f()")
f()

Gerçekten, bu bir kine; yapabilecekleriniz burada deneyin . İnceleme modülünü oldukça sert bir şekilde istismar eder.

Aynı kaynak kodu x2 ile çalıştırmayı denersek, doğru çıktıyı da alırız; yapabilecekleriniz burada deneyelim . x3, x4 vb. hepsi beklendiği gibi çalışır.

Açıklanamayan:

def f():                                   # Defines a central function f
    import threading as T,inspect as i     # Imports threading and inspect
    global t,a,i                           # Global vars
    try:
        t.cancel()                         # Tries to cancel Timer from previous code
    except:
        a = 0                              # Reached when code is 1st copy; initializes a.
    a += 1                                 # a++; this is the number of copies thus far.
    t = T.Timer(1,d)               # Creates, then starts a timer to call function
    t.start()                              # d in 1 second.

def d():                                   # Prints out the source code; the quine part.
    print''.join(c*a for c in i.getsource(f)+i.getsource(d)+"f()")

f()                                        # Calls f()!

CJam , 19 bayt

{]W=s"_~"+T):Te*}_~

Çevrimiçi deneyin!

Nasıl çalışır

{               }_~  Define an anonymous code block (function).
                 _~  Push a copy, and execute the copy.
 ]W=                 Wrap the entire stack in an array and select its last element.
                     This discards whatever was on the stack before the original
                     code block, which is needed for subsequent iterations.
    s"_~"+           Cast the code block to string, push "_~", and concatenate.
                     This pushes the stringified source code on the stack.
          T):T       Push T (initially 0), increment it, and save the result in T.
              e*     Repeat each character in the stringified source code T times.

RProgN , 66 bayt

Önemli Boşluk benim ölümüm olsun

[ "[ %q ] F 0 1 + `0 = `. { 0 m } R " ] F 0 1 + `0 = `. { 0 m } R 

Açıklaması

[ "[ %q ] F 0 1 + `0 = `. { 0 m } R " ] F 0 1 + `0 = `. { 0 m } R   #
[                                                                   # Pop whatever is already on the stack, if anything.
  "[ %q ] F 0 1 + `0 = `. { 0 m } R "                               # This string contains basically the entire function.
                                      ] F                           # ] F duplicates the string, and then F formats it, which in this case puts the first string into the second at %q, surrounded by qoutes.
                                          0 1 + `0 =                # I needed an Incrementer, so I chose 0. 0, is conveniently, pre initilized at 0. And because RProgN is horrifying, you can remap the number functions as they're just more variables. So this increments 0 every time the group is called.
                                                     `. { 0 m } R   # Replace each character with itself repeated '0' times. Because '0' is an incrementer, each time the script is called, the amount of times the characters are repeated increase.

Tanrım ben bir canavarım ...

Çevrimiçi deneyin!

Perl 5, 107 bayt

$_=q[$_=q[S];s/S/$_/;$a++;END{s/./$&x$a/eg;print if$a;$a=0}];s/S/$_/;$a++;END{s/./$&x$a/eg;print if$a;$a=0}

Ungolfed:

$_ = '...INSERT_SOURCE_HERE...';      # Standard quine
s/INSERT_SOURCE_HERE/$_;
$a++;                                 # Count the number of repetitions
END {
    s/./$&x$a/eg;                     # Interweave
    print if $a;                      # Print...
    $a=0;                             # ...but only once
}

Çevrimiçi deneyin!

Piton 3 , 122 121 112 bayt

s='try:from atexit import*;n+=1\nexcept:n=1;register(lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s])';exec(s);

Çevrimiçi Deneyin: bir kopya | iki kopya | üç kopya | dört kopya, otomatik doğrulama ile

Nasıl çalışır

Bu standart Python quine kullanır: Yürütmek istediğiniz kodu bir değişkende (dize olarak) saklayın; bu dizeye kendisini, önceki her şeyi ve sonraki her şeyi yazdırmak için bir mantık ekleyin; ardından bu dizeyi yürütün.

S dizesi üzerinden yürütülen kod aşağıdaki gibidir.

try:from atexit import*;n+=1
except:n=1;register(lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s])

İlk satır , bir çıkış işleyicisini kaydetmemize izin veren atexit modülünü koşulsuz olarak içe aktarır . Aynı modülü birden çok kez içe aktarmayı denemek komut dosyasını hiçbir şekilde etkilemez. Daha sonra , kaynak kodun kaç kopyasının yürütüldüğünü takip etmek için n değişkenini artırmaya çalışır .

İkinci satır yalnızca ilk satır bir hata içeriyorsa yürütülür. İlk yinelemede durum böyle olacaktır, çünkü n hala tanımlanmamıştır. Bu durumda, n'yi 1 olarak başlatır ve gerçek büyüyü gerçekleştiren bir lambda kaydederiz.

Kayıtlı çıkış işleyicisi

lambda:[print(end=c*n)for c in"s=%r;exec(s);"%s]

program bitmeden hemen önce çağrılır. Lambda'nın kendisi dizeyi oluşturur "s=%r;exec(s);"%s- tekli tırnak işaretleri ve tırnak işaretleri arasındaki her şeyi içeren %rdoğru argüman ( lar ) ın bir dize temsilini oluşturur - sonra karakterleri üzerinde yinelenir. Her karakter için c , biz sadece yazdırmak n kopyalarını c . Geçme c*nadlı argüman olarak endkarşı printhiçbir satır besleme eklenecek araçlar.

CJam , 14 bayt

{s"_~"+]:.+}_~

Çevrimiçi deneyin!

açıklamalar

{s"_~"+]:.+}_~
{s"_~"+    }_~ Basic quine operator.
       ]:.+    Append each character to corresponding element of the previous result if existed.