Göreviniz kabul etmek istiyorsanız, pozitif bir tamsayı çıkaran bir program yazmaktır (0'dan yüksek). Kaynak kod çoğaltıldığında, çıktı aynı kalmalıdır. İşin en zor yanı, kaynak kodu üç defa yazıldığında (üçlü?) Çıktının 3 ile çarpılmasıdır.

kurallar

• Tam bir program oluşturmalısınız . Yani, çıktınızın STDOUT'a yazdırılması gerekiyor.

• İlk kaynak en az 1 bayt uzunluğunda olmalıdır.

• Her iki tam sayı da 10. basamakta yer almalıdır (bunları başka bir yerde veya bilimsel gösterime sokmak yasaktır).

• Programınız giriş yapmamalı (veya kullanılmamış, boş bir giriş yapmalıdır ).

• Tam sayıların sondaki / baştaki boşluklarla çıkmasına izin verilir.

• Ön Sıfırlara yalnızca rakam sayısı tutarlıysa izin verilir, örneğin: 001 - 001 - 003 veya 004 - 004 - 012

• Kaynağınızın kopyaları arasında yeni bir satır alamazsınız.

• Bu kod golf , yani her dilde en kısa (orijinal) kod kazanıyor!

• Varsayılan Loopholes uygulanır.

Örnek

Diyelim ki kaynak kodunuz Abcve bunun çıktısı çıktı 4. Onun AbcAbcyerine yazıp çalıştırıyorsam çıktı yine de olmalı 4. Ancak yazıp AbcAbcAbcçalıştırırsam, çıktı olması gerekir 12.

Utanmadan çalınmış Sn Xcoder en türeyen meydan

Wumpus , 6 bayt

{~)
@O

Çevrimiçi deneyin!
İki katına dene!
Üçe dene!

Baskılar 1ve 3.

açıklama

Kaba kuvvet arama ile 6-byte çözüm ton buldum, ancak 5 byte için hiçbiri. Bu mutlaka 5 byte'ta olmadığı anlamına gelmez, ancak muhtemelen garip karakterler veya başka şeyler kullanırlardı.

Bu çözümü seçmeye başladım, çünkü herhangi bir baştaki sıfırları yazdırmaz (çoğu yapar) ve bazı ilginç kontrol akışlarına sahiptir. Tek program ile başlayalım:

Yani yürütülen kod:

{~)O@

{   Turn the IP left by 60°.
~   Swap two implicit zeros on the stack, does nothing.
)   Increment the top zero to 1.
O   Print it.
@   Terminate the program.

Yeterince kolay. Şimdi iki katına program. İlk satır ikinci satıra eklendiğinden, ızgara kontrol akışını önemli ölçüde değiştiren genişliğe 5 (ve yükseklik 3) kadar uzanır:

IP bu döngüde tam olarak bir kez dolaşır, bu nedenle yürütülen kod şöyledir:

{~){~)){~O@

{~) As before, we end up with a 1 on top of the stack.
{   Turn left by 60° again.
~   Swap the 1 with the 0 underneath.
))  Increment the zero to 2.
{   Turn left by 60° again.
~   Swap the 2 with the 1 underneath.
O   Print the 1.
@   Terminate the program.

Son olarak, üçlü program iki katına benzeyen programa benzer, ancak bu üçüncü satırda birkaç önemli komut alırız:

Yani yürütülen kod:

{~){~)){~~)O@

{~){~)){~
    As before. We end up with a 1 on top of the stack and a 2 underneath.
~   Swap the 1 with the 2 underneath.
)   Increment the 2 to a 3.
O   Print the 3.
@   Terminate the program.

Kabuğu , 5 bayt

KΣK+1

Çevrimiçi deneyin!

İki kez tekrarladı!

Tekrarlı üç kez!

açıklama

Husk'ta tekrarlanabilir bir program oluşturmak oldukça zor. Tip sistemi kendine uygulanabilecek bir işlevi yasakladığından, bir şekilde ilk kısmın bir işlevi değerlendirmesini ve kalanının bir değeri değerlendirmesini sağlamalıyım ve mevcut yerleşiklerin tipleri bunu önlemek için tasarlandı. belirsizlik türü. Programın belirteçleri

• Ksabit bir fonksiyon inşa eder. K a beşittir a.
• ΣHangi bir tamsayıdır alır n ve döner n üçgen sayıda inci.
• +, iki sayı ekler.
• 1, hangi kelimenin tam anlamıyla 1.

Orijinal program şöyle yorumlanır:

   K Σ (K+) 1
== Σ 1
== 1

Bu (K+)ilk tarafından yenen saçma bir fonksiyondur K.

İki kez tekrarlanan program şöyle yorumlanır:

   K Σ (K+1KΣK+) 1
== Σ 1
== 1

Parantez içindeki işlev ilk önce yine yenir K.

Üç kez tekrarlanan program şöyle yorumlanır:

   K (Σ (K (+1) (KΣK+) 1)) (KΣK+1)
== Σ (K (+1) (KΣK+) 1)
== Σ ((+1) 1)
== Σ (+1 1)
== Σ 2
== 3

Jöle , 7 5 bayt

»‘µ*Ḃ

Çevrimiçi deneyin!

İki katına dene!

Üçe dene!

Nasıl çalışır

»‘µ*Ḃ            Main link. No arguments. Implicit argument: x = 0

 ‘               Increment; yield x + 1 = 1.
»                Take the maximum of x and 1. Yields 1.
  µ              Begin a new, monadic chain. Argument: y = 1
    Ḃ            Bit; yield 1 if y is odd, 0 if it is even. Yields 1.
   *             Power; yield y**1 = 1.

»‘µ*Ḃ»‘µ*Ḃ       Main link.

»‘µ*Ḃ            As before.
      ‘          Increment; yield y + 1 = 2.
     »           Take the maximum of 1 and 2. Yields 2.
       µ         Begin a new, monadic chain. Argument: z = 2
         Ḃ       Bit; yield 1 if z is odd, 0 if it is even. Yields 0.
        *        Power; yield z**0 = 1.

»‘µ*Ḃ»‘µ*Ḃ»‘µ*Ḃ  Main link.

»‘µ*Ḃ»‘µ*Ḃ       As before.
           ‘     Increment; yield z + 1 = 3.
          »      Take the maximum of 1 and 3. Yields 3.
            µ    Begin a new, monadic chain. Argument: w = 3
              Ḃ  Bit; yield 1 if w is odd, 0 if it is even. Yields 1.
             *   Power; yield w**1 = 3.

Haskell , 24 bayt

main=print.div 3$4
 -1--

Baskılar 1: Çevrimiçi deneyin!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--

Ayrıca yazdırır 1: Çevrimiçi deneyin!

main=print.div 3$4
 -1--main=print.div 3$4
 -1--main=print.div 3$4
 -1--

Baskılar 3: Çevrimiçi deneyin!

Cubix , 5 bayt

)<@OP

Çevrimiçi deneyin: bir kez , iki kez , üç kez .

açıklama

Cubix, talimatları bir küpün dışına sarılmış yığın tabanlı bir dildir. Unutulmaması gereken, yığının başlangıçta sonsuz sıfırlarla doldurulmasıdır; bu, operatörleri açık bir şekilde itmek yerine "değerleri ince havadan çıkarmamızı" sağlar.

Bunun kaba bir güçlendirici tarafından bulunduğunu itiraf etmeliyim; Bunu asla kendi başıma bulmazdım. Aslında, @MartinEnder şanssız bir şekilde bu çözümü aradığı için kaba kuvvet denememi istedi. Brute-Forcer'ın bulduğu tek çözüm budur ve Cubix'deki en kısa ve tek çözüm olduğuna inanıyorum.

Tek program

Çalıştırılmasını izleyin!

Orijinal program bir ünite küpüne sığar. İşte katlanmış net:

  )
< @ O P
  .

IP (talimat işaretçisi) <doğu yönündeki en soldaki yüzden başlar . <Hemen batı bunu işaret ve çevresinde kaydırılır P. Püs alma işlemi yapılır, ve yığın üzerinde hiçbir şey olduğundan, yorumlayıcı iki çeker 0 S ve hesaplar 0 ⁰ olduğu, 1 JavaScript göre yöntem. Odaha sonra bu değeri yazdırır ve @programı sonlandırır.

Çift program

Çalıştırılmasını izleyin!

)<@OP)<@OP

10 baytlık bir program bir birim küpüne sığmayacak kadar uzundur ve bu nedenle 2 boyutlu bir küp boyutuna genişletilir:

    ) <
    @ O
P ) < @ O P . .
. . . . . . . .
    . .
    . .

Daha önce olduğu gibi, IP, en soldaki yüzün sol üst kısmında başlar. Bu sefer, ilk yönerge, Pbir 1'i daha önce olduğu gibi itiyor . Sonraki, )en üstteki öğeyi artıran ve 2'ye çeviren şeydir . Ardından <IP'yi döndürür ve 2'yi a'ya )dönüştürerek tekrar vurur. 3 .

İşte ilginçleştiği yer. Pyukarıdan ikinci öğeyi 0 ³ = 0 veren birinci öğenin gücüne yükseltir . Sonra IP, en sağdaki yüze dolanır ve .bir başkasına çarpmadan önce iki tane işlemeden geçer P. Burada bir başka Cubix tuhaflığı görüyoruz: ikili işleçler (örneğin P) işlenenlerini yığından çıkarmıyor. Böylece, yığın şimdi olduğu için, programı çıkaran ve sonlandıran 3 ⁰ = 1 değerini [3, 0]hesaplıyoruz .O@

Üçlü program

Çalıştırılmasını izleyin!

)<@OP)<@OP)<@OP

İkili programda olduğu gibi, üçlü bir boyut 2 küpün üzerine sığabilir:

    ) <
    @ O
P ) < @ O P ) <
@ O P . . . . .
    . .
    . .

Bu program öncekiyle aynı şekilde başlar: 1P iter , artışlar, IP batı yönünü işaret eder, tekrar artış yapar ve şimdi 0 iter . IP daha sonra en sağdaki yüze sarılır ve IP zaten batıya yöneldiğinden hiçbir şey yapmaz.)<)P<

İkili programdan bir fark: işte yığının üstündeki 0) artar 1 . Zaman daha büyü gerçekleştirir, bu kez hesaplar 3 ¹ = 3 . çıktılar ve sona erer ve üçüncü kez gerçekten de cazibe olduğunun kanıtıyız.PO@

Beyin Flak , 10 bayt

<>([]{}())

Çevrimiçi deneyin!

İki katına dene!

Üçe dene!

Açıklama:

#Toggle stacks
<>

#Push
(
    #Stack-height (initially 0) + 
    []

    #The TOS (initially 0) + 
    {}

    #1
    ()
)

Bunu bir kez çalıştırdığımızda (0 + 0 + 1) == 1, alternatif yığına koyacaktır . İkinci kez koştu, aynı şeyi ana yığına koyar. Ancak üçüncü kez çalıştırın , bunu değerlendirir (1 + 1 + 1) == 3ve alternatif yığına iter ve dolaylı olarak yazdırır.

SQL, 25 24 23 bayt

( -1 Bayt Her zaman yorumlanmış ve hiçbir şey yapmadan yanlış yazılmış bir karakter kaldırıldı )
( -1 Bayt Değişti SELECTiçin PRINTRazvan Socol tarafından tavsiye edildiği gibi )

PRINT 2/*
*2+1--*/-1
--

Nasıl çalışır:
SQL'de şu şekilde yorum etiketlerini yorumlayabilirsiniz:

/*
'Comment'--*/

vs

--/*
'Not Comment'--*/

Hariç tutulan yorumları içeren 1 satırdaki kod:
İlk yineleme: SELECT 2-1Çıktı: 1
İkinci yineleme: SELECT 2-1*2+1Çıktı: 1
Üçüncü yineleme: SELECT 2-1*2+1*2+1Çıktı:3

SOGL V0.12 , 7 5 4 bayt

ē»«I

Burada dene!

İki katına dene!

Üçe dene!

Açıklama:

ē»«I
ē     push counter, then increment it.
      First time running this will push 0, then 1, then 2.
             TOS on each: 0  1  2
 »    floor divide by 2   0  0  1
  «   multiply by 2       0  0  2
   I  and increment       1  1  3

05AB1E , 6 5 bayt

.gDÈ+

Çevrimiçi deneyin! veya iki katına deneyin! veya Üçlü deneyin!

açıklama

.g     # push length of stack
  D    # duplicate
   È   # check if even
    +  # add

Tek: 0 + (0 % 2 == 0) -> 1
Çift: 1 + (1 % 2 == 0) -> 1
Üçlü:2 + (2 % 2 == 0) -> 3

> <> , 9 bayt

\5 n;
\\1

Çevrimiçi deneyin!

İki katına dene!

Üçe dene!

"Balığın yolunu yeterince kıvrımlı yaparsanız, sonunda bir şeyin işe yarayacağını" felsefesini kullanarak bu tür bir şans buldum. Orijinal ve iki kat sürümler 5 yazdırır ve üçlü sürüm 1 = 5 ve 15 = 3 × 5 olur. İncelemeniz için çarpılmış versiyonlar:

\5 n;
\\1\5 n;
\\1

\5 n;
\\1\5 n;
\\1\5 n;
\\1

Python 2 ,  46 45  39 bayt

Halvard'ın cevabından ilham aldı . Mücadelemin daha da ilginç bulduğum yeni bir tanesine ilham verdiğine sevindim. Kevin Cruijssen sayesinde 6 bayt kaydedildi .

print open(__file__,"a").tell()/79*3|1#

Çevrimiçi deneyin!

İki katına dene!

Üçe dene!

Nasıl çalışır (eski)

k=open(__file__,"a").tell() # Read the source code in "append" mode and get its length.
                            # Assign it to a variable k.
;print k>>(k==90)#          # Print k, with the bits shifted to the right by 1 if k
                            # is equal to 90, or without being shifted at all overwise.
                            # By shifting the bits of a number to the right by 1 (>>1),
                            # we basically halve it.

O iki katına zaman, uzunluk olur 90 , ancak yeni kod sayesinde göz ardı edilir #, böylece k==90için değerlendirir True. Boolean'ler Python'da bir tamsayı alt sınıfıdır, yani esasen k / 2 = 45 olan k>>Trueeşdeğerdir . Üçlü hale getirildiğinde, yeni kod tekrar ihmal edilir, dolayısıyla yeni uzunluk 135'tir , bu da değerlendirilir , çünkü olduğu gibi değerlendirilir ve k , olduğu gibi basılır.k>>1k==90Falsek>>(k==90) ⟶ k>>(135==90) ⟶ k>>False ⟶ k>>0 ⟶ k

Python 2,36 bayt

Bu, Aidan F. Pierce tarafından 38 byte'lık bir öneriydi ve 2 byte golf oynadım. Bunu ana çözümüm olarak göndermiyorum çünkü kendi başıma bulamadım.

0and""
True+=1
print True>3and 3or 1

Çevrimiçi deneyin! İki katına dene! Üçe dene!

R , 37 31 28 bayt

Giuseppe , son 3 baytı golf oynadığı için teşekkürler .

length(readLines())%/%2*2+1

(takip eden bir newline ile).

Bir kere dene!

İki kere dene!

Üç kere dene!

Bu readLines(), Giuseppe'nin 8 sayıdaki mücadeleye verdiği cevabın numarasını kullanır ;stdin kaynak dosyaya yönlendirir. Bu kod temelde ilk satırın altında kaç satır olduğunu sayar ve 11 veya 3 satır varsa (yani kod tek veya iki katlıdır) veya 35 satır varsa (yani kod üçe katlanır) çıkar.

Kayıp , 38 bayt

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Çevrimiçi deneyin!

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Çevrimiçi deneyin!

\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v\\<<<<</<<<<>
2>((1+@>?!^%^
.........v

Çevrimiçi deneyin!

açıklama

Kayıp bu meydan okuma için çok ilginç bir dildir. Her zamanki kayıp tekniği bir "tuzak" inşa etmektir. Tuzak, programın tüm IP'leri bir yerde yakalamak için tasarlanmış bir bölümüdür, böylece yığınları temizlenebilir ve belirli bir yöne gitmek üzere kontrol edilebilirler. Bu, Lost programlarında yazma programlarını daha yönetilebilir hale getirir. Ancak, program çoğaltıldığı için, tuzak çoğaltmasından da kaçınmamız gerekir. Bu, bizim için düzgün çalışan yeni bir tuzak tasarlamamızı gerektirir. Buradaki temel fikrim şudur:

v<<<<>
>%?!^^

Yığın boş ?olmasa da, bir öğeyi kaldırır ve o öğe sıfır değilse geri başlangıcına atlamasına neden olur. Buradaki anahtar, bu durum ^^sıraya dizildiğinde

v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^v<<<<>
>%?!^^

Yani, nasıl girdiğiniz önemli değil, daima aynı yerden çıkacaksınız.

Buradan aynı fikri Klein cevabımdan uygulamaya çalışabiliriz .

\\<<<<<v<<<<>
2>((1+@>?!^%^

Programımızın bel kemiği, sol tarafta bir miktar 2s iter . Programın bir kopyasını her eklediğimizde, programın 2omurgasına bir tane daha eklenir, yani yığına 2 ek verilir. Alttan indiğinde, \\>zıplar ve kodu çalıştırır.

((1+@

Bu, ilk 2 yığın öğesini kaldırır, kalana bir tane ekler ve çıkar. Omurgamız 3 2'ye ulaştığında, 1 ekleyeceğiz ve 3 alacağız, eğer 3'ten daha az öğeye sahipsek, sadece tüm yığını atacağız ve 1 döndüreceğiz.

Şimdi geriye kalan tek sorun, !programımızın içinde sonsuz bir döngüye neden olabileceğidir. Eğer ip !yukarı doğru ilerlemeye başlarsa, zıplayacak ve bulunduğu yere geri dönecektir. Bu, döngüyü önlemek için altına başka bir satır eklememiz gerektiği anlamına gelir.

\\<<<<</<<<<>
2>((1+@>?!^%^
.........^

Bunun tuzağımızın arasına biraz eğik çizgiler koyma problemi var ^. Ancak, mucizevi bir şekilde, her şey yolunda. IP'lerimiz düzgün bir şekilde zıplar ve fark yaratmaz.

Stax , 5 bayt

|dhH^

Çevrimiçi çalıştırın ve hata ayıklayın! · İki Katlı · Üçlü

açıklama

|dhH^
|d       Push Current stack depth `d`, originally 0
         Doubled -> 1, Tripled -> 2
  hH^    Map d to 2*(floor(d/2))+1
         Implicit print

C (gcc) , 95 91 85 bayt

#ifndef a
#define a-1
main(){puts(3
#include __FILE__
?"1":"3");}
#define a
#endif
a

Çevrimiçi deneyin!

Japt , 8 6 5 bayt

@ETHproductions sayesinde -1 bayt

°U-v

Açıklama:

°U-v
 U     # variable U=0                # U=0
°U     # ++U                         # U=1
  -    # minus:
   v   #   1 if U is divisible by 2  
       #     else
       #   0                         # U=1

Bu değerlendirir 1-0 = 1

İki katına değerlendirilir 2-1 = 1

Üçlü değerlendirir 3-0 = 3

Saf Bash (hayır wcveya başka harici araçlar), 27

trap echo\ $[a++&2|1] EXIT

• Bir kere dene.
• İki kere dene.
• Üç kere dene.

Perl 5 , 18 15 13 12 11 bayt

Nwellnhof sayesinde -3 bayt

say 1|
+.7#

Bir kez çevrimiçi deneyin!

İki kez çevrimiçi deneyin!

Thrice Çevrimiçi deneyin!

> <> , 10 9 8 bayt

562gn|

Çevrimiçi deneyin!

İki katına dene!

Üçe dene!

Eminim orada bir yerde 8 baytlık bir çözüm vardır.

Sonunda yazdırılamayan ASCII değer 1'e sahiptir ve yalnızca güçüncü yinelemedeki et komutu tarafından alınır. İlk ikisi için yazdırır 05ve sonra yazdırır 15.

C (gcc) , 107 bayt

C'deki ilk başvurum (gcc). Yol çok uzun ...

i;
#ifdef c
#define c
#ifdef b
i=2;
#else
#define b
#endif
#else
#define c main(){putchar(i+49);}
#endif
c

TIO bağlantıları: tek , çift , üçlü .

Labirent , 12 11 9 bayt

:! #% @
 7

TIO (1x) , TIO (2x) , TIO (3x)

JavaScript, 81 77 74 70 bayt

^{Shaggy sayesinde 4 bayt kaydedildi}

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Oldukça topal JS çözümü. Dizideki değerleri [3,1,1]sağdan tüketir ( pop()). Gelecekteki mevcut değeri görüntülemek için bir zaman aşımı kaydeder. Zaman aşımı zaten kaydedilmişse, iptal edin. varDeğişken bildirimleri olan kirli doğasına güvenir .

İki kere:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

Üç kere:

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

var t,i=(i||[3,1,1]),a=i.pop()
clearTimeout(t)
t=setTimeout(alert,9,a)

C (gcc) , 53 52 bayt

Sonra boşluğa dikkat edin #endif.

n;main(){putchar(n+49);}
#if __LINE__>7
n=2;
#endif 

Çevrimiçi deneyin!

Kömür , 12 bayt

⎚≔⁺ι¹ιＩ⁻ι⁼ι²

Çevrimiçi deneyin! Link ayrıntılı kod için.

İki katına dene!

Üçe dene!

açıklama

⎚             Clear
 ≔⁺ι¹ι        Assign plus(i, 1) to i
       Ｉ      Cast (and implicitly print)
         ⁻ ⁼ι² Subtract equals(i, 2) from
          ι    i

JavaScript, 43 40 Bayt

var t=t?--t:~!setTimeout`t=alert(1|~t)`;

2 kere:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

3x:

var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;var t=t?--t:~!setTimeout`t=alert(1|~t)`;

PowerShell , 54 48 45 44 bayt

if(99-gt(gc $PSCOMMANDPATH|wc -c)){1;exit}3#

Çevrimiçi deneyin!

İki katına dene!

Üçe dene!

İle kendi çağırma yolunu alır $PSCOMMANDPATHve bir gerçekleştirir get- cdosya üzerinde ontent. Ifo dosyanın karakter sayısı daha azdır 99(aracılığıyla kontrol wc -c, o zaman çıkış coreutils itibaren) 1ve exit(yani yürütme durdurma). Bu orijinal kod ve iki kat kod için hesaplar. Aksi takdirde 3çıkıp çıkıyoruz . İki katına veya üçe katlanmış bölümlerdeki gerçek kod anlamsızdır, çünkü biz bunu exitalmadan önce ya da bir yorumun arkasındayız# .

Mr. Xcoder sayesinde 6 bayt kurtarıldı Pavel sayesinde 3 4 bayt kurtardı

C # (178 Bayt)

Console.WriteLine(1+2*4%int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]=(int.Parse(System.Configuration.ConfigurationManager.AppSettings["z"]??"0"))+1+""));

çılgın C # çözümü, ama C # 'da bir satırda mümkün olduğu için mutluyum. :)

Benim için en zor kısım, aynı değişkeni kuvvetlendirecek veya artıracak geçerli bir C # 'ya sahipti, bu yüzden ConfigurationManager'ı kötüye kullandım, çünkü bellekte güncelleyebileceğimi düşünebildiğim tek statik isimValueCollection ve ConfigurationManager'ı kullandım. EnvironmentVariables, baktığım başka bir seçenekti, ancak bir dizinleyiciye sahip değildi, bu nedenle, istenen çıktıyı belirtmek için istenen çıktıyı elde etmek için kopyalanabilecek bir satırda nasıl yapılacağından emin değilim.

Runik Büyüleri , 35 bayt

^w3'\
    f
    1
/1@
/
 '54\w
/yyy

Çevrimiçi deneyin!

Bunun üzerinde çalışmak, ayrıştırıcımda yeni gecikme değiştirici karakterlerle ilgili bir hata bulmama izin verdi, ancak sonuçta bunlardan etkilenmeme rağmen, sonuçta bunlara ihtiyaç duymuyorum.

Nihai çizginin sonunda yeni bir IP adresi (ya da bunun için zemin boşlukları) olmadığından, yinelenen IP'lerin farklı bir yerde ortaya çıkmasına izin veren işlevler. Sol üstteki ikinci \, 6. sıradaki çizgiyi a ile değiştirmek için bir Yansıtma işlemi gerçekleştirirken, ızgara etrafında büyük bir ilmek oluşturur . Bu IP daha sonra sonsuza kadar döngü ve hiçbir şey yapmaz.

Üçüncü IP aynı anda aynı bu yedek yapar, ancak üzerinde yer çünkü 13. satırda, o reflektör onun kopyası yukarı gönderir ve yürüteceği 1f'3wyerini sağ üst köşesinde bulunan diziyi, 1bir ile 314 çizgi, özgün IP çıkışına üçe programı neden çalıştırır hemen önce 3yerine 1(değerler de olabilir 2ve 6, 3ve 9, 4ve 12ya da 5ve 15bağlı mevcudiyetine a-fsayısal sabitler; 1ve 3isteğe bağlı olarak seçilmiş edilmiştir). Daha sonra hiçbir şey yapmadan daha fazla yansıma komutu veren sonsuz bir döngüde kalır.

Üçlü olarak dene!

Perl 5, 28 25 bayt

@Neil sayesinde -3 bayt!

print"\e[D$a"if(++$a!=2);

İmleci geriye doğru hareket ettirir (satır başlangıcında hiçbir şey yapmaz) ve $abirinci ve üçüncü kez (yani 1'in üçüncü basıldığı zaman, imleç hareket eder ve 3'ün 1'in üzerine basıldığı) değerini yazdırır.

QBasic, 19 bayt

CLS
x=2^x
?x-1OR 1

Kaynak, takip eden bir yeni satır içermelidir.

açıklama

Biz çıktısını istiyoruz 1, 1, 3. Bu sayıların 2'nin gücünden daha düşük olduğunu gözlemleyin.

CLS      ' CLear Screen of any output from previous copies of the code

x        ' Numeric variables are preset to 0...
 =2^x    ' so as this statement is repeated, the value of x goes 1, 2, 4

 x-1     ' Therefore x-1 goes 0, 1, 3...
    OR 1 ' and we bitwise OR it with 1 to change the 0 to 1...
?        ' and print.