Kaynak kodunu iki katına çıkarma konusunda bir takım zorluklar oldu: burada ve burada . Burada yaptığımız görev biraz daha zor, ancak hemen hemen her dilde yapılabilir.

Bu zorlukla, keyfi bir pozitif tamsayıya gireceksin. Programınız bu tamsayıyı iki katına çıkarmalıdır . Kaynak kodunuz ikiye katlandığında pozitif bir tamsayı alır ve karesini çıkarır .

Kaynak kodunuz nasıl ikiye katlanır? Peki, senin tarzın olabilir . Demek ki bu zaten, bayt veya karakter dizeleri içine kaynak kodu bölebilmeniz (veya dizgecikli DİLLER'de belirtilen belirteçleri) arasında herhangi eşit istediğiniz uzunlukta ve arka arkaya iki kez her öbek tekrarlayın.

Bir başlangıç ​​programı için ABCDEFGHIJKL, (uzunluk 12) burada iki olası programın tümü olasıdır:

Chunk length |   Doubled source code
-------------+-------------------------
           1 | AABBCCDDEEFFGGHHIIJJKKLL
           2 | ABABCDCDEFEFGHGHIJIJKLKL
           3 | ABCABCDEFDEFGHIGHIJKLJKL
           4 | ABCDABCDEFGHEFGHIJKLIJKL
           6 | ABCDEFABCDEFGHIJKLGHIJKL
          12 | ABCDEFGHIJKLABCDEFGHIJKL

Bunun, asal uzunluktaki programların yalnızca iki şekilde iki katına çıkarılabileceği anlamına gelir: her karakter iki katına çıkar veya tam program iki kez tekrarlanır.

Kurallar:

• Kod tam bir program veya işlev olmalıdır.
• Standart boşluklar yasaktır.
• Standart G / Ç yöntemlerine izin verilir.
• Boşluk ve satırsonları dahil tüm karakterler / baytlar kodun uzunluğunda sayılır ve topaklara katkıda bulunur.
• Sen olabilir girdi ve kare dilinizin int / tamsayı türü ile temsil edilebilir varsayalım.
• Sen olmayabilir bir eğik yeni satır veya başka bir karakter varsayalım.
• Bayt sayısından sonra başlık boyutunda yığın boyutunuzu girin.
• Bu kod golf , bu yüzden kısa programlar daha iyi! İki program aynı uzunluktaysa, daha küçük yığın uzunluğunu kullanan program kazanır. (Daha küçük bir yığın uzunluğu kullanan daha uzun bir programınız varsa, bu da göndermeye değer!)
• Programınız ikinci bir giriş / satır gerektiriyorsa, değeri hakkında hiçbir varsayımda bulunamazsınız. Özellikle, ikinci giriş boşsa, ilk ile aynı veya farklı bir tamsayıysa programınız çalışmalıdır. Programınız ikinci bir giriş / satır gerektirmiyorsa, bu kısıtlamayı göz ardı edebilirsiniz.

Sandbox bağlantısı

Perl 5 , 8 bayt (yığın boyutu 4)

$_*=~~+2

Çevrimiçi deneyin veya iki katına çıkmış sürümü deneyin .

tekli ~ bitsel saygısızlıktır, bu nedenle iki kez uygulamak bir nottur. Böylece, temel program basitçe $_(örtük giriş-çıkış değişkeni) 2 ile çarpılır .

İkili ~~bir boole döndüren smartmatch'tir. ~~+2~~+2ayrıştırır (~~+2) ~~ (+2). 2, 2'ye eşittir, bu doğru olur (1). Böylece, iki kat program ilk önce $_1 ile çarpılır, daha sonra $_kendi başına çoğalır .

05AB1E , 4 bayt (yığın boyutu 2 veya 4)

·Inr

Çevrimiçi deneyin veya tek bir 4 bayt öbek olarak iki katına veya iki 2 bayt öbek olarak iki katına çıkarın .

·        # double the implicit input
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 2]
         # if we stop here: implicitly output the top of the stack (input * 2)
·        # double the top of the stack (giving input * 4, not that it matters)
 In      # square the input
   r     # reverse the stack: it's now [input ** 2, input * 4, input ** 2]
         # implicitly the top of the stack (input ** 2)

Python 3 , 26 bayt (yığın boyutu 13)

lambda n:"and n*n#"and 2*n

Çevrimiçi deneyin!

Doubled:

lambda n:"andlambda d:"and n*n#"and 2*n n*n#"and 2*n

Bu çözüm @Grimy tarafından sağlanmaktadır.

Python 3 , 32 30 28 bayt (yığın boyutu 16 15 14)

lambda n:bool(0)*n*n or  2*n

Çevrimiçi deneyin!

@NegativeSeven sayesinde -4 bayt

Doubled:

lambda n:bool(lambda n:bool(0)*n*n or  2*n0)*n*n or  2*n

Çevrimiçi deneyin!

Bu işlev, bu zorluğun benzersiz öbek kuralından faydalanır.

Befunge-98 (FBBI) , 8 bayt (yığın uzunluğu 2)

;&:#* +q

Çevrimiçi deneyin!

;&;&:#:#* * +q+q

Çevrimiçi deneyin! (İki kat)

Kontrol akışı hariç, birinci program yürütür &:+q(giriş, yığının çoğaltılması, ekleme, dönüş koduyla çıkma) ve ikinci çalıştırma &:*+q(giriş, yığının çoğaltılması, çarpma, toplama (0 ile örtülü toplamlar), dönüş ile çıkma kodu)

Altıgen , 14 bayt (yığın boyutu 14)

?"+==*/}=+!@!<

Expanded:

  ? " +
 = = * /
} = + ! @
 ! < . .
  . . .

Çevrimiçi deneyin!

Doubled

?"+==*/}=+!@!<?"+==*/}=+!@!<

Expanded:

   ? " + =
  = * / } =
 + ! @ ! < ?
" + = = * / }
 = + ! @ ! <
  . . . . .
   . . . .

Çevrimiçi olarak iki katına çıkmayı deneyin!

Altıgenlik bu zorlukta garip bir konumdadır, çünkü bu görevi başarmak, iki ayrı programı yazabilmekten daha zor değildir. Ancak, çözümün golf oynamak oldukça zor oldu.

Bu çözüm benim sığabileceğim en kısa formdaki önemsiz fikir, ancak daha kısa ve zekice cevaplar bulunduğundan şüpheleniyorum. Bu sürüm çok saf bir şekilde girişe iki değer atar ve kaynağın iki katına çıkmasına bağlı olarak bunları toplar veya çoğaltır. Tek kod yeniden kullanımı"+ , iki kat program için kopya kodunun kullanılmayan alana orijinal programdan sığacak kadar kısa olmasını sağlar.

IP değiştirme talimatlarını kullanmanın []parçaları izole etmeyi kolaylaştıracağından şüpheleniyorum , ancak gerçekten ideal bir çözüm ikisi arasında birçok kodu tekrar kullanacak. Altıgen kaynak kodunu iki katına çıkarmak için yardımcı bir program yaptım . Son no-op'ları kaldırdığına dikkat edin, böylece sonunda no-op'ların no-op'larına sahip olmak istiyorsanız sadece başka bir karakter doldurun ve sonra tekrar değiştirin. Her farklı programın çıktısını almak için henüz kod yazmadım, ancak farklı yığın boyutlarıyla başa çıkabiliyor (Hexagony tam yığın boyutunu kullanmaya başlıyor gibi görünüyor).

Altıgen , 12 bayt (yığın boyutu 4)

?"2+...}=*!@

Çevrimiçi deneyin!

biçimlendirilmiş:

  ? " 2
 + . . .
} = * ! @
 . . . .
  . . .

Ve iki katına çıktı , sonra formatlandı:

   ? " 2 +
  ? " 2 + .
 . . } . . .
} = * ! @ = *
 ! @ . . . .
  . . . . .
   . . . .

Temel olarak, bu ilk kenarı girişe, ardından ikinci kenarı 2girişin bir kopyasına ya da bir kopyasına ayarlar , sonra bu iki kenarı üçüncü kenara çarpar, basar ve sonlandırır. Yürütülen talimatların listesi sadece

?"2}=*!@

ve

?"2+}=*!@

Tek fark , ikinci programın üzerinde +baskın olmak 2.

JavaScript (ES6),  24  22 bayt

Alışılmadık biçimine rağmen, bu, doğrudan çağrılabilen veya bir değişkene atanabilen isimsiz bir fonksiyonun tanımıdır.

+(g=x=>x*x)?g:(x=>x*2)

Çevrimiçi deneyin!

+(g=x=>x*x)?g:(x=>x*2)+(g=x=>x*x)?g:(x=>x*2)

İki katına çevrimiçi deneyin!

Nasıl?

Unary'i +bir işleve uygulamak, onu bir sayıya zorlama girişimi olarak yorumlanır ve NaN ile sonuçlanır . Bu nedenle, öncü +(g=x=>x*x)her iki versiyonda da sahte.

Öte yandan, +iki işlev arasındaki ikiliyi uygulamak bir dizgede sonuçlanır. Bu nedenle, (x=>x*2)+(g=x=>x*x)ikiye katlanan versiyonda truthy var.

Perl 6 , 8 bayt (yığın boyutu 1)

* *<1 2>

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

Bir numara alan ve ilk program için bir sayı ve ikinci program için bir tekil liste döndüren bir Her Neyse / HyperWhatever lambda. Temel olarak bu, çarpma işlecinin ( *) üstel olanın ( **) ile değiştirilmesi haricinde, aynı mantığı korur .

**  **<<11  22>>

Ne olursa olsun, kelimenin tam anlamıyla (kafa karıştırıcı bir şekilde a ile de temsil edilir *) **listelerde eşlenenler dışında temelde aynı olan bir HyperWhatever ( ) ile ikiye katlanır . Her ne anlama geliyorsa onu çarpmadan ayırmak için boşluk gerekir ve iki katına çıkarıldığında yoksayılır. Sadece 2(iki katına çıkarılacak 22) yerine, sayısal bir bağlamda 2'yi değerlendiren iki element içeren bir liste kullanırız). <>İnterpolasyonlu bir listeye iki katına edilebilir ve içinde iki element katına, ancak listenin ne bu değişimin uzunluğu.

Runik Büyüleri , 9 bayt (yığın boyutu 3)

i3?:*@:+@

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

( 3?3) ile sonuçlanan sonraki 3 talimatı atlar i3?...:+@. Ne zaman bir infaz sonuçlanır katına i3?...:*@nerede .3 NOP'd talimatları temsil eder. @"Tüm yığını yazdır ve sonlandır."

C # (Visual C # Etkileşimli Derleyici) / Javascript, 22 bayt, yığın boyutu 11

m=>/*      /2*m//*/m*2

Çevrimiçi deneyin!

Brain-Flak , 48 30 bayt (yığın boyutu 10)

(({}))<>( {({}[()])}{}<>{}{}) 

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

Bu temelde üç adım alır, daha sonra iki katına çıkıldığında bu adımları her iki kez uygular. İlk program:

1. TOS'u çoğaltın, yığınları değiştirin ve bir değeri itmeye başlayın
2. TOS'un üçgen numarasını alın n * (n-1) / 2
3. TOS'u açın, yığını değiştirin ve iki kez pop açın, ardından sonucu itin.

nŞüphesiz bir programa giriş yapmak için bu:

1.  Start stack: n n
    Other stack: <
    Third stack: 
2.  Start stack: n n
    Other stack: 0 <
    Third stack: tri(0) = 0
3.  Start stack: n+n+tri(0) = 2n <
    Other stack:
    Third stack:

İki kat program için:

1a. Start stack: n n
    Other stack: <
    Third stack: 
1b. Start stack: n n <
    Other stack: 0 0
    Third stack: 
2a. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)
2b. Start stack: n 0 <
    Other stack: 0 0
    Third stack: tri(n)+tri(0) = tri(n)
3a. Start stack: n
    Other stack: tri(n) <
    Third stack: tri(n)
3a. Start stack: 0+n+tri(n)+tri(n) = n + 2*tri(n) = n + n*(n-1) = n*n <
    Other stack: 
    Third stack: 

Brain-Flak , 76 bayt, 76 bayt parçası

({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>

Çevrimiçi deneyin!

Doubled (netlik için newline ile)

({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>
({}<>)(()[([][()])]{(<{}{}({({})({}[()])}<>)<>>)}{}){{}(({})({})<>)(<>)}{}<>

Çevrimiçi deneyin!

İşte daha karmaşık bir ikiye katlama prosedürü kullanan bir versiyon. 15 boyutunda 5 parça yapar. Buradaki kod 46 bayttır, ancak gerekli dolgu nedeniyle esasen daha uzundur.

105 90 bayt, 15 bayt parçası

(              {<><({}()())><><><            <>>({})({}[()])}{}            )<>            

Çevrimiçi deneyin!

Doubled (netlik için newlines ile)

(              (              
{<><({}()())><>{<><({}()())><>
<><            <><            
<>>({})({}[()])<>>({})({}[()])
}{}            }{}            
)<>            )<>            

Çevrimiçi deneyin!

Cubix , 18 14 bayt (yığın uzunluğu 9 7)

*OI$|:/@O+:I. 

Sondaki boşluğa dikkat edin. Çevrimiçi deneyin!

Doubled:

*OI$|:/*OI$|:/@O+:I. @O+:I. 

Yine, bir sondaki boşluk var. Çevrimiçi deneyin!

açıklama

Ana fikir, kodun iki katına çıkması küpün daha büyük olmasına neden oluyor, bu nedenle komut gösterici farklı bir sembolle başlar. Ekleme programı 1 nolu bir küpün üzerine yerleştirilemediğinden, 2 nolu yan uzunluk 2 olacaktır. Ayrıca, iki kat kodun 3 yan uzunlukta bir küp üzerinde olması gerekir, bu nedenle iki kat kodun en az 25 bayt olması gerekir. . Bu, kodun en az 13 bayt olması gerektiği anlamına gelir. Bu sayede en fazla 1 bayt kaydedilebilir.

Şimdi gerçek koda. İlk gözlem, üst yüzün (yani ilk 4 karakter) ekleme programı tarafından kullanılmadığıdır. Ayrıca 5. karakterin küpün etrafındaki IP'yi yansıtmasını sağlarsak, 2 karakter daha kazanabiliriz. Kare alma programını koymak için bu karakterleri kullanacağız.

Mornington Crescent , 656 Bayt (Parça boyutu 328)

Neredeyse her dilde çözülebilecek olan bu teoriye ağırlık katmak ...

Take Northern Line to Bank
Take District Line to Bank
Take District Line to Parsons Green
Take District Line to Bank
Take District Line to Hammersmith
Take Piccadilly Line to Russell Square
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Hammersmith
Take District Line to Upminster
Take District Line to Embankment
Take District Line to Hammersmith
Take District Line to Upminster
Take District Line to Acton Town
Take District Line to Acton Town
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Bounds Green
Take Piccadilly Line to Leicester Square
Take Northern Line to Leicester Square
Take Northern Line to Mornington Crescent

(Sondaki yeni satır önemlidir)

Tek versiyonunu dene! ... veya ... İkili sürümü dene!

Buradaki teori basittir: Tekli versiyonda 'Yeşiller Sınırları' rastgele bir dize ile doldurulur, ancak ikilü versiyonda kare girişi ile doldurulur. Öbek bittikten sonra, her iki sürüm de 'girişi' ikiye katlar, ancak kodun iki katına sürümünde girdi, 0 ile değiştirildi.

Bu sonuç, çıktısını almadan önce iki kez max () işlemi yapan Bounds Green'e geri döndürülür. Tekli sürümde bu, iki katının değiştirilmemesine neden olur (int ve string sadece ileri ve geri çevrilir), ancak ikili sürümde bu, 0 değerinin Bounds Green'te önceden kaydedilmiş kare sonuçla değiştirilir.

JavaScript (Node.js) , 15 12 bayt (yığın boyutu: 6)

x=>/**/2*(x)

Çevrimiçi deneyin!

Tek dava:

x=>/**/2*(x)

Çift vaka:

x=>/**x=>/**/2*(x)/2*(x)

Değişen ise ayrıca C # iş ve Java gibi görünüyor =>için ->?

R , 42 35 28 bayt (yığın boyutu 4)

Şimdi daha küçük bir yığınla ve hatasız. Ayrıca yığın boyutu 3 ile daha uzun bir çözüm var; aşağıya bakınız.

Parça boyutu 1 veya 2 olan bir R cevabı yazmanın mümkün olduğunu sanmıyorum; Mutlu olduğumu ispatlayan herkese lütuf ederim.

s =scan#
n=s()# 
  
n/2*4#  

Çevrimiçi deneyin!

#3. satır önceki ve sonraki öbek hiçbir yeni satır olabilir böylece, yeni satır + 2 alanlarda + satır bir parça yapmak, sadece boşluk olduğunu R. açıklamalarda içindir.

İki katına, olur:

s =ss =scan#can#
n=s
n=s()# ()# 
  

  
n/2*n/2*4#  4#  

Çevrimiçi deneyin!

Tek versiyon hesaplar $\frac n2\times4=2n$; çift ​​versiyon hesaplar$\frac n2\times \frac n2\times4=n^2$.

İşte biraz daha uzun bir çözüm, ancak yığın boyutu 3:

R , 39 bayt (yığın boyutu 3)

s =bbb=scan#
n=s(#
 
)# 
n* 1/ 2/ 1* 4#

Çevrimiçi deneyin!

Doubled:

s =s =bbbbbb=sc=scan#an#
n=
n=s(#s(#
 

 
)# )# 
n*
n* 1/ 1/ 2/ 2/ 1* 1* 4# 4#

Çevrimiçi deneyin!

Giuseppe'nin, 30 bitlik bir yığınla başka bir R cevabı olduğunu unutmayın .

R , 59 30 bayt (yığın boyutu 59 30)

F=F+1;f=function(n)n*c(2,n)[F]

Çevrimiçi deneyin!

Bu ilham için Robin Ryder'a teşekkür ederiz; FHer seferinde artış yapar ve işlev fuygun çıktıyı seçer.

Bu özellikle ilginç değil, ama kuşkusuz büyüklüğü manipüle akıllıca bir şey hayal kırıklığına uğrayacak. Beklendiği gibi, Robin Ryder ile geldi bu hem kısadır ve bazı zekice öbek manipülasyon olan.

PowerShell , 22 bayt (yığın boyutu 11)

param($p)
#   /
2 * $p

Çevrimiçi deneyin .

Doubled:

param($p)
#param($p)
#   /
2 * $p   /
2 * $p

Bu çözüm @ ShieruAsakoto'nun çözümüne dayanıyor .

PowerShell'e dönüştürülen @Grimy çözümü , 26 bayt (yığın boyutu 13)

param($p)$t=';$p*$p#';$p*2

Çevrimiçi deneyin .

Doubled:

param($p)$t=';param($p)$t=';$p*$p#';$p*2$p*$p#';$p*2

Perl 5 ( -p), 22 15 bayt

Grimy sayesinde -7 bayt

$_*=$'/4||2;//;

TIO

Kömür , 13 bayt

ＰＩ×Ｉθ⎇υＩθ²⊞υω

Çevrimiçi deneyin! Açıklama: Önceden tanımlanmış boş liste falsey, bu nedenle giriş 2 ile çarpılır. İkinci geçiş, iki katın boş dize listeye basıldığını görür ve bunun yerine girişi kendisi ile çarpar. Çevrimiçi deneyin! Ayrıntılı sözdiziminde bu karşılık gelir Multiprint(Cast(Times(Cast(q), Ternary(u, Cast(q), 2)))); Push(u, w);.

Python 3, 56 53 bayt

print(eval(input()+"**2"[len(*open(__file__))%2:])) #

Benim python becerilerimi tür emmek, bu yüzden kesinlikle golf olabilir .. Dayalı " Kaynağı ikiye , çıktıyı iki katına çıkar! " Python cevabına .

Öbek uzunluğu 53.

Çevrimiçi deneyin veya iki kez çevrimiçi deneyin .

Java 8, 62 bayt

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

Topak uzunluğu 62.

Çevrimiçi deneyin ya da çevrimiçi deneyin iki katına .

Açıklama:

n->                    // Method with integer as both parameter and return-type
  n*                   //  The input, multiplied by:
    (Byte.SIZE>8?      //   If Byte.SIZE is larger than 8:
      n                //    Multiply by the input itself
     :                 //   Else:
      2);              //    Multiply by 2
class Byte{            // Class which overwrites Byte
  static int SIZE=9;}  //  And sets the SIZE to 9

Java'da mevcut yorumlar // commentve /* comment */. Hangi bölümlerin üzerine yazmak için burada birleştirilir. Java vurgulaması sayesinde bu yorumların nasıl çalıştığını görün:

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///n->n*(Byte.SIZE>8?n:2);/*
class Byte{static int SIZE=9;}/**///

İkili program , varsayılan sınıfı ve Bytedeğerini yazan bir özel sınıf ve değeri oluşturdu .SIZE=9java.lang.ByteSIZE=8

Japt , 7 5 bayt

*N²jJ

Deneyin | Doubled

²2'yi giriş dizisine iter, Nardından jdizini J=-1(örneğin yeni eklenen 2) öğeyi kaldırır ve döndürür ve girişi bununla çarpar.

İki katına çıktığında Jçarpılmasıyla sonuçlanır 2, bu nedenle indeksindeki eleman -2(yani girdi) jçarpı olarak döndürülür ve kullanılır.

Jöle , 8 6 bayt (yığın uzunluğu 3)

Ḥ;²3ị 

Çevrimiçi deneyin!

Doubled

Güzel çözüm: Lua , 66 bayt (yığın boyutu 66 bayt)

a,x=a and...^2 or ...*2,setmetatable(x or{},{__gc=load'print(a)'})

Çevrimiçi deneyin!(kendin ikiye katla, çok zor değil)

Evet, bunun için daha kısa bir çözüm olduğuna eminim ama bu şekilde bulabildiğim en iyisi bu. Girdiyi ilk argüman olarak alın.

Kısa açıklama: ile olan bütün iş aherkes için oldukça açık, ikinci kısım xise daha ilginç. Temel olarak, finalizer ile bir tablo (ya da ikinci seferde mevcut olanı güncellemek) oluşturmak__gc program çıktığında çağrılan metamethod) ) oluşturuyorum.

Lame çözümü: Lua , 60 bayt (yığın boyutu 30 bayt)

a=a and...^2 or ...*2;                     print(a)os.exit()

Çevrimiçi deneyin! veya iki katına deneyin!

Daha küçük ve daha iyi ötme ile, ama sonuçta sıkıcı ve zekice bir numara olmadan topal. Bunun için yorum gerekmediğinden eminim.

J , ^{15 10} 9 bayt

+: :(*-:)

Çevrimiçi deneyin!

İki katlı sürüm: Çevrimiçi deneyin!

f : gfBir argüman gile çağrıldığında ve 2 argüman ile çağrıldığında çalıştırılan bir fiil oluşturur . Böylece bizimki +:orijinal kaynakla ve *-:kaynak iki katına çıktığında iki katına çıkar.

Bu, J'deki iki fiilin bir treni bir kanca haline geldiği ve dolayısıyla y'nin orijinal girdi olduğu f fgibi yürütüldüğü y f (f y)için çalışır. Ek olarak, *-:kendisi çarparak çalışan bir "dyadik kanca" dır.* sol argümanı-: sağ argümanın . Sol argüman orijinal girdi olacak ve sağ argüman iki misli girdi olacak ve bu orijinal girişin karesini üretecek.

orijinal cevap

J , 15 bayt

*:@]`(+:@])@.=~

Çevrimiçi deneyin!

İki katlı sürüm: Çevrimiçi deneyin!

Tekli sürümde, @.if yapmak için Gündem'i kullanan tek bir fiil var : o zaman mantık: Eğer argüman kendisine eşitse =~, o zaman argümanı al ve iki katına çıkar.(+:@[) .

Ancak kodu iki katına çıkardığımızda J kancası olur. Fiili fve girişi arayın y. Sonra kanca f fbu şekilde yürütülür:

y f (f y)

Bu, şimdi orijinal girişin sol argüman olduğu ve sağ argümanın iki kat giriş olduğu anlamına gelir. Bunlar eşit =~olmayacağından , bu kez yanıltıcı dönecektir ve şimdi Gündemin diğer çatalını uygulayacağız, yani *:@]"doğru argümanı kare yap". Ve ~didik fiillerin girişlerini tersine çevirdiğinden, doğru argüman orijinal girdi olacaktır.

Python 3 , 60 bayt

Chunk size 6.
Harika bir çözüm değil ama işe yarıyor. Bu eşsiz bir meydan okuma, gerçekten farklı bir bakış açısıyla düşünmenizi sağlar.

0;  i=input;0;  p=print;n=i()#
x=int(n)##
z=2*x#z=x*x
p(z)##

Çevrimiçi deneyin!

Doubled:

0;  i=0;  i=input;input;0;  p=0;  p=print;print;n=i()#n=i()#
x=int
x=int(n)##
(n)##
z=2*x#z=2*x#z=x*x
z=x*x
p(z)##p(z)##

Çevrimiçi deneyin!

Basamaklı , 13 bayt (yığın boyutu 13)

]
&/2
#
*
 2&

Çevrimiçi deneyin!

]
&/2
#
*
 2&]
&/2
#
*
 2&

İki katına dene!

Bu oldukça zordu. Bunun temel amacı 2, ilk program için çarpılan girişi yazdırmak ve2 ve ikinci giriş için kopyası .

Açıklama:

İlk programın yürütülen kısmı benziyor

]     Redirection
 /
#     Print
*     The multiplication of
 2&   Input and 2 (wrapping around the left)

İki katına çıkan program temel ]olarak son satırın ilkini sonuna kadar ekler , böylece program bunun yerine etrafına sarılır &. Bu dönüşüyor

]     Redirection
 /
#     Print
*     The multiplication of
 2 ]  Set the value of
& 2   The variable '2' to the input
      Then multiply the result of that (input) by '2' (input)

Zsh , 30 bayt (yığın boyutu 10)

m=$m[1]*2
x=$[$1$m]
return $x

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

İstismarlar gerçeği $varde $[$var], ona ilk genişletilmiş, daha sonra aritmetik bağlamda değerlendirilmiştir.

             # each line is 9 characters long. when doubled, each is run twice.
m=$m[1]*2    # first time: m='*2'   second time: $m[1] is '*', so m='**2'
x=$[$1$m]    # single: x=$[$1*2]    doubled: x=$[$1**2];x=$[$1**2].
return $x    # zsh supports 32-bit return values from functions, unlike bash

Bunu düşürmek isteyen biri varsa, işte 24/8aldığım bir çözüme en yakın ( x^2+2ikiye katlandığında çıktı)