Bir 1'li quine bir Quine'ın çok benzer bir programdır. Buradaki en büyük fark, programın n kopyası bir araya getirildiğinde, sonucun orijinal programı n + 1 kez basmasıdır.

Örnek

Programınız Abc123:

Abc123  ->  Abc123Abc123
Abc123Abc123  ->  Abc123Abc123Abc123
Abc123Abc123Abc123  -> Abc123Abc123Abc123Abc123

Meydan okuma

Buradaki zorluk, herhangi bir dilde en kısa geçerli 1-up quine oluşturmaktır. Her zamanki quine kuralları geçerlidir, yani:

• Boş programı gönderin.
• Kaynak kodunu doğrudan veya dolaylı olarak okuyun ¹ .
• Sorgu yerleşik yapıları kullanın.

Bu kod golf, bayt cinsinden en kısa kod kazanır.

^{1 Bu, programınızın bir parçası olarak kodlanmış bir dize veya kod bloğu kullanmayı içermez.}

GolfScript, 12 bayt

{`'.~'+:n}.~

Çevrimiçi deneyin!

açıklama

Bu, standart GolfScript quine'deki fikirleri birleştirir:

{'.~'}.~

Ve kısa süre önce keşfedilen quine :

":n`":n`

Asıl fikir, nprogramın sonunda dolaylı olarak basılmış olan ve ekin kopyasını almak için kullanılmasıdır. Değişkeni atamak, sonraki kopyalarda tekrar yapıldığında hiçbir şeyi değiştirmediğinden, bu yalnızca bir kopya ekleyecektir. İşte kod bir dökümü:

{        # Standard quine framework. This pushes the block, duplicates it and runs the
         # second copy, such that it can process the first copy to create a quine.
  `      # Convert the block to its string representation.
  '.~'+  # Append the string '.~' to make a complete quine. This is simply left on the
         # stack to be printed at the end.
  :n     # Store the string in n such that one more copy is printed at the end.
}.~

GolfScript, 12 bayt

{: ".~"][}.~

Çevrimiçi deneyin!

Kaynak kodu nasıl çalışır?

{: ".~"][}.~

{        }    Define and push a code block.
          .~  Push a copy and execute it.
 :            Save the code block in the space character.
              Every subsequent space will now execute the code block.
   ".~"       Push that string.
       ]      Wrap everything up to the last [ in an array.
        [     Set a new array marker.

Yukarıdaki kaynak kod bir kez çalıştırılırsa, yığın aşağıdaki gibi bitecektir.

["" {: ".~"]} ".~"]

başlangıçtaki boş dize yığının başlangıç ​​durumuna karşılık gelir (boş giriş).

Kaynak kodun iki kopyası son halini bırakacak

["" {: ".~"]} ".~"] [{: ".~"]} ".~"]

üç kopya son hali

["" {: ".~"]} ".~"] [{: ".~"]} ".~"] [{: ".~"]} ".~"]

ve bunun gibi.

Sonra ne olur

Kaynak kodu yürüttükten sonra tercüman aşağıdakileri yapar.

1. Tüm diziyi bir diziye sarar ve bu diziyi yığına iter.

   Kaynak kodun iki kopyası için, yığın şimdi

   ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [["" {: ".~"][} ".~"] [{: ".~"][} ".~"]]
   

2. Bu yürütülen putsbir besleme ile, ardından sarılmış bir istif baskı amacıyla, ile.

   putsolarak tanımlanır {print n print}, bu nedenle aşağıdakileri yapar.

   1. printyığının sarılmış kopyasını incelemeden yazdırmaz (yani, dizgi temsiline dönüştürmeden). Bu gönderir

      {: ".~"][}.~{: ".~"][}.~
      

      (kaynak kodu) STDOUT'a gönderir ve yığın kopyasını yığının tepesinden çıkar.

      Yığın şimdi içeriyor

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"]
      

   2. Daha önce tanımladığımız kod bloğunu yürütür.

      :[{: ".~"][} ".~"]Boşluk karakterinde kaydederek başlar , sonra ".~"kendini iter, diziyi ]sarar ".~"ve [yeni bir dizi işaretleyici ayarlar.

   3. n tek bir satır beslemesinden oluşan bir ipi iter.

      Yığın şimdi içeriyor

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [".~"] "\n"
      

   4. bir kez daha yürütülür. Ancak, ilk defa aradığımızda yeniden tanımlandı ve şimdi bir kod bloğu değil bir dizi içeriyor.

      Aslında, [{: ".~"][} ".~"]yığını olduğu gibi bırakarak iter

      ["" {: ".~"][} ".~"] [{: ".~"][} ".~"] [".~"] "\n" [{: ".~"][} ".~"]
      

   5. Son olarak, printen üstteki yığın öğesini incelemeden yazdırır, gönderir ve

      {: ".~"][}.~
      

      STDOUT'a, kaynak kodunu 1-upping.

Javascript ES6 (REPL), 55 bayt

var a=-~a;$=_=>`var a=-~a;$=${$};$();`.repeat(a+1);$();

@ User81655 sayesinde 2 bayt kaydedildi!

açıklama

İşte standart quine çerçevesi:

$=_=>`$=${$};$()`;$()

Bu çerçeveyi sunumun içinde görebilmelisiniz. Aşağıda daha fazla açıklama.

var a=-~a;

Bu, varsayılan olarak 1 olarak ayarlanan sayaçtır. Temel olarak, aynı zamanda quin ve artımların ne kadar tekrarlanacağını söyler.

$=_=>`var a=-~a;$=${$};$();`.repeat(a+1);$();

Bu en güzel bölüm. Esas olarak quine string'i + 1 sayacı ile tekrarlıyoruz. Sonraki işlev çağrıları çıkışı geçersiz kılar.

CJam, 14 bayt

{"_~"]-2>_o}_~

Çevrimiçi deneyin!

Nasıl çalışır

{"_~"]-2>_o}_~

{          }    Define a code block and push it on the stack.
            _~  Push and execute a copy of it.
 "_~"           Push that string.
     ]          Wrap the entire stack in an array.
      -2>       Discard all but the last two elements (block and string).
         _o     Push and print a copy of that array.

Programın son kopyası çalıştırıldıktan sonra, bloğu ve dizgiyi içeren dizi hala yığındadır, bu nedenle dolaylı olarak yazdırılır.

Groovy, 83 bayt

s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//

Bir tane gömülü ve izleyen yeni satır yok. Bu yazdırır:

s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//s="s=%c%s%c;f={printf(s,34,s,34,10)};f()%cf()//";f={printf(s,34,s,34,10)};f()
f()//

İşlev f(), kalenin bir kopyasını yazdırır. İlk program iki kere çağırır. Eklenen kodun ilk satırı bir yorum haline gelir ve yalnızca ikinci çağrı yapılır f().

Ruby, 43 bayt

1;s="1;s=%p;$><<s%%s*n=2-0";$><<s%s*n=2-0

Kendi başına, bu kendini 2-0ya da 2zamanları yazdırır . Kendisinin başka bir kopyasıyla birleştirildiğinde, final print cümlesi bir $><<s%s*n=2-01kez kendini çıktığı anlamına gelir ( 01sekizlik 1). Böylece dizginin sadece son kopyası iki kez basılır, diğerleri bir kez basılır.

Satır içi ataması n, yalnızca işlemlerin düzgün çalışmasını sağlamak içindir; devlet aslında bir kopyadan diğerine geçmiyor.

DüğümJS, 63 61 60 55 bayt

Birden fazla konsol mesajının yeni satırlarla ayrılmasını düşünüyorsanız, bu da JavaScript'te (ES6) çalışacaktır (REPL gerekmez)

@ Dev-null sayesinde 2 bayt kaydedildi

(f=_=>(t=_=>console.log(`(f=${f})()`)||(_=>t))(t()))()

kodun sonunda yeni bir satır olduğunu unutmayın.

Bu ilginç bir taneydi, kesinlikle bu site için favorilerimden biriydi.

Bunun çok daha fazla golf oynayamayacağına eminim. (belki SpiderMonkey'nin printişlevi ...)

açıklama

//FIRST ITERATION
            console.log(`(f=${f})()`)                   //logs to the console a quine of the source code using function f's toString()
                                     ||                 //causes the expression to evaluate to the second part, since console.log's return value is falsy
                                       (_=>t)           //a function that returns function t when called
       t=_=>                                            //defines function t to be the code above. When called, t will log a quine and then return a function that returns t.
      (                                      )(t())     //call t twice. (one call is done via the t() as an ignored parameter) This will print the quine twice.
 f=_=>                                                  //define f as the above code.
(                                                  )()  //call function f with no arguments. this results in a function returning t. (the result of calling t once)
                                                        //this newline is to compensate for console.log's behavior of adding a newline to its output
//SECOND ITERATION
(                                                  )    //call the function that returns t that was returned from the first iteration. This expression will result in whatever that function returns, which is t.
 f=_=>(t=_=>console.log(`(f=${f})()`)||(_=>t))(t())     //this part evaluates to a function, which is passed as a parameter to the function that returns t, that ignores its parameter.
                                                    ()  //call whatever the last expression returned, which is the function t, with no parameters. This will print the quine once.
                                                        //this call will result in a function returning t, just like from the first iteration, so we can add on more iterations at will.

Ruby, 55 bayt

n||=2;s="n||=2;s=%p;$><<(s%%s)*n;n=1;";$><<(s%s)*n;n=1;

Burada çok ilginç bir şey yok, sadece bir sayaç ile normal bir yakut quine.

JavaScript (ES6), 164 bayt

console.log((`+String.fromCharCode(96)).repeat(window.a||(a=3,5)).slice(67,-14))
console.log((`+String.fromCharCode(96)).repeat(window.a||(a=3,5)).slice(67,-14))

İki konsol mesajı arasındaki boşluğun yeni satır sayıldığını varsayarak, Firefox'ta herhangi bir JS test sayfasında veya konsolunda çalışır.

Perl 6 , 58 53 bayt

Jo King'e -5 bayt için teşekkürler.

<say "<$_>~~.EVAL for 0..!.++;">~~.EVAL for 0..!.++;

Jo King'in sırtına dayanıyor .

Çevrimiçi deneyin!

Japt, 40 bayt

Oo("+Q ²pT°?1:2 é4;POo("+Q ²pT°?1:2 é4;P

Çevrimiçi test edin! Gelecek açıklama.

Y

Rekabet etmeyen, 6 bayt

UCn*px

Y, bir süredir yaşadığım bir savaş topu ve bu da bana yazmam için ilham verdi. Bu gibi sıralamanın anahtar olduğu zorluklar için yapılır. Kod "düğüm" karakterleriyle bağlantılara bölünmüştür. Bu durumda, kodumuz düğüm olmak üzere (başlangıçta) iki zincire konur C.

U  C  n* px
1  N    2

Uaşkın bir dize, yani bağlantıları kapsayan bir dize kaydeder. Başka biriyle karşılaşana kadar kayıt yapar U. A Udizenin sonunda karşılanmazsa, etrafına sarılır. Ayrıca, Udizeye varsayılan olarak eklenir. Dize kaydettikten sonra, Cbizi bir sonraki bağlantıya taşıyan düğüme ilerleriz .

nzincir sayısını zorlar. Temel durumumuz için, bu 2. Bir Kzincir dizisi için K+2, Kdüğümler olduğu gibi , zincirler de vardır . *dize tekrarıdır.pTüm yığını yazdırır (bu durumda, bir dize) ve xprogramı sonlandırır.

Bir metinde:

UCn*px
U..... record that string
 C     next link
  n*   repeat that string twice.
    px print and terminate

UCn*pxUCn*pxUCn*px
U.....U            record string
 C                 next link
  n*               repeat that string four times (three Cs)
    px             print and terminate

Burada dene!

Brachylog , 20 bayt

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Çevrimiçi deneyin!

Dan Modifiye bu Quine'a.

⊥                       Fail,
 ∨                      or
                w       print
  "⊥∨~kgjw₃w₅"          "⊥∨~kgjw₃w₅"
                 ₃      formatted
              gj        with itself;
                 ₃w₅    print it again at the end of the program if this route succeeds.

Bu, kendisiyle birleştiğinde sonuncusu dışındaki her rota başarısız olur ve program bir sonrakine w₃geçerek her w₅birini yürütür ve sonuncusu hariç her birini geriye doğru izler .

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Çevrimiçi deneyin!

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Çevrimiçi deneyin!

⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅⊥∨"⊥∨~kgjw₃w₅"gjw₃w₅

Çevrimiçi deneyin!