Gelen bu soruya ben çıktısı dayalı bir anagram Quine tahmin etmek istedi. Ancak, henüz anagram quine golf oynamak isteyen bir sorum yok gibi görünüyor. Böylece göreviniz, yapabileceğiniz en kısa anagram altını yapmak olacaktır.

Anagram keki nedir?

Anagram quine, orijinal kodundan başka, kaynak kodunun bir anagramını basan boş olmayan bir programdır.

İşte Python 2'deki bir anagram quine örneği:

print`'`print`*2'*2`

Bu zorluk için kendi kaynağınızı okumamalısınız.

Pyth , 2 bayt

)(

çıktılar

()

Çevrimiçi deneyin!

)  # Ends statement, does nothing in this program
 ( # Create an empty tuple
   # Implicitly print the empty tuple

V , 4 bayt

2ii2

Çıktılar:

i2i2

Çevrimiçi deneyin!

> <> , 9 8 7 bayt

@WheatWizard sayesinde !onu almak ve artırmak için arttırmak sayesinde Golf 1 bayt"

@ ConorO'Brien sayesinde #yerine 1 bayt golf<!

":1->o#

Çevrimiçi deneyin!

Çıkışlar "#o>-1:.

açıklama

":1->o#"        Push this string (note that the IP wraps around)
:               Duplicate the top value of the stack (35 from the "#")
1-              Subtract one from it to get 34 ('"')
>o#             Print every character on the stack until the program cannot pop any more and still tries to pop a value from the stack afterwards
                The program exits with an error from not being able to pop a value from an empty stack

Brainfuck, 158 bayt

>>--<<-[[<+>->+>->+++<<<]>-]<<<<<<[--->>.<<]>>++<<<[->>>.<<<]>>-<<<[--->>>.<<<]>>>--<<<<[++>>>>.<<<<]>>>>+++>--.[---<.>]>+.......++.......<<<>>>>>>>>>-----+++

Çevrimiçi deneyin!

En kısa sürüm olmayabilir, ama en azından çalışıyor.

Eğlenceli gerçek , çıkış kodu gerçekten çalıştırılabilir (ve sonlandırılır).

Çıktı

<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>--------------------------++++++++++++++++++<....................[[[[[[[]]]]]]]

açıklama

>>--<<-[[<+>->+>->+++<<<]>-]    Initializes the tape with the
                                help of a recurrence relation.
<<<<<<[--->>.<<]>>++<<<[->>>
.<<<]>>-<<<[--->>>.<<<]>>>--    Prints the characters using
<<<<[++>>>>.<<<<]>>>>+++>--.    classic loops.
[---<.>]>+.......++.......

<<<>>>>>>>>>-----+++            Junk to complete the anagram.

Python 3, 32 bayt

baskı ( "" "s" r "I", n "T" 2 ( ") *" "" * 2)

p"r"i"n"t"2(")*p"r"i"n"t"2(")*\nSıralanan çıktıyı yazdırır :\n""""""""""""(())**22iinnpprrtt

Ruby , 8 bayt

p"p*2"*2

Çevrimiçi deneyin!

Bu yazdırır

"p*2p*2"

açıklama

Bu sorudaki python cevabına benzer şekilde çalışır. Bu dize yapacak p*2p*2sonra Ruby'nin kullanılması dize pgösterimini basacaktır.

JavaScript (ES6), 40 32 bayt

f=($=`($)=>{$=$+"${"``"}$"}`)=>$+$

Function.toString ile de uğraşmak yok. Bir bonus olarak, dizginin içindeki kod neredeyse yasal görünüyor. Düzenleme: +yerine kullanarak 8 bayt kaydedildi repeat(2).

Klein , 7 + 6 = 13 bayt

>>>> Cevabını temel alan bir cevap .

":1+@!

Çevrimiçi deneyin!

Bu çıkışlar

:1+@!"

Japt , 10 9 bayt

Daha iyi bir yol buldum :-)

Q+2ç"Q+2ç

Çıkışlar "Q+2çQ+2ç. Çevrimiçi test edin!

açıklama

Q+2ç"Q+2ç    // Implicit: Q = quotation mark
    "Q+2ç    // Take this string.     Q+2ç
  2ç         // Repeat it twice.      Q+2çQ+2ç
Q+           // Prepend a quote.      "Q+2çQ+2ç
             // Implicit: output result of last expression

Olabilir Qi2ç"Qi2ç, hangi yazdırır Qi2çQi2ç". Bu, standart Japt quine'e daha yakın:

"iQ ²"iQ ²

Ancak 9 baytlık bir ip için dizenin ortasındaki tırnak işaretini sıkıştırmanın kolay bir yolu olduğuna inanmıyorum.

Ruby, 20 bayt

$><<%q($><<%q()*2)*2

Bu çıkışlar

$><<%q()*2$><<%q()*2

%q(...)İç içe parantezleri destekleyen Ruby'nin dize sözdiziminden yararlanmak .

Retina , 8 bayt

_

$nn$

Çevrimiçi deneyin!

Baskılar

n$_
n$

Her ikisi de bir _, iki n, iki $ve üç satır besleme içerir.

Neredeyse başka bir karakterin takip ettiği bir satır beslemesinin önemsiz bir çözüm olduğunu unutmayın, ancak geçerli olup olmadığı şüphelidir, çünkü ikinci karakter yalnızca kendisini kodlar ve satır beslemesi her iki çıktı karakterini de gerçekten kodlamaz.

açıklama

_

Boş girişi a ile değiştirin _.

$nn$

Hem öncesi hem de sonrasında gerçekleşen boş bir dize ile _eşleşip bir linefeed ( $n), an nve a ekleyin $. Bunu ilk eklediğimizden beri _, bu karakterlerin her birini iki kere ekler, bu nedenle nve $hesabını verir $nve çıktıda ihtiyacımız olan üç satır beslemesinden ikisini alırız. Üçüncü satır besleme, Retina varsayılan olarak izleyen satır besleme yazdırdığı için yazdırılır.

n$n$Bu aşamada da kullanabileceğiz , sonra şunu yazdırabiliriz:

n
$_n
$

Python Repl, 4 bayt

Bu benim ilk Code Golf çözümüm, umarım kuralları yerine getirir. Python 2 veya 3 etkileşimli tercümanında:

>>> (1),
(1,)

Çıkış, girişin bir anagramıdır.

Bir diğeri:

>>> 2*'2*'
'2*2*'

Python 2'de:

>>> type('rst <>'),
(<type 'str'>,)

Python 3'te:

>> {1, 0}
{0, 1}

Güncelleme 2017-06-15: Başka bir tane daha:

>>> 01.
1.0

Haskell , 38 39 bayt

main=print$[0,0]>>"main=print$[0,0]>>"

Çevrimiçi deneyin! Çıktı:

"main=print$[0,0]>>main=print$[0,0]>>"

Düzenleme: +1 bayt daha önce örtülü izleyen yeni satırını unuttum çünkü print.

Alternatif: (Aynı bayt sayısı, ancak ASCII-baykuş içermiyor)

main=print$e++e;e="main=print$e++e;e="

Çevrimiçi deneyin!

Çıktı:

"main=print$e++e;e=main=print$e++e;e="

Büyük, 24 20 bayt

{"""{""*""2""}"""*2}

-4 CalculatorFeline sayesinde, boşluk nedeniyle sonuçta gerekli değildi!

Çıktı:

{""*""2""}{""*""2""}

Açıklama:

İsimsiz kapatma, çağrıldığında geri döner {""*""2""} iki kez (bitiştirilir).

05AB1E , 10 bayt

'∞∞''∞'JJ∞

Çevrimiçi deneyin!

Çıktı:

∞∞''JJ''∞∞

Açıklama:

Code       | Explanation                | Stack
-----------+----------------------------+-------------------
'∞         | Push literal '∞'.          | ["∞"]
  ∞        | Mirror.                    | ["∞∞"]
   ''      | Push literal "'".          | ["∞∞","'"]
     ∞     | Mirror.                    | ["∞∞","''"]
      'J   | Push literal 'J'.          | ["∞∞","''","J"]
        J  | Join it all together.      | ["∞∞''J"]
         ∞ | Mirror.                    | ["∞∞''JJ''∞∞"]
-----------+----------------------------+-------------------
           | Implicit print.            | ∞∞''JJ''∞∞

CJam , 6 bayt

"_`"_`

Çevrimiçi deneyin!

Baskılar

_`"_`"

açıklama

"_`"   e# Push this string.
_      e# Duplicate.
`      e# Stringify it, which wraps it in quotes.
       e# Implicitly print stack contents.

Bash, 36 bayt

tee f<<<'tee f<<<""cat f'"''"
cat f

Bu çıkışlar

tee f<<<""cat f''
tee f<<<""cat f''

(ve dosyayı fyan etki olarak oluşturur , ancak bu meta başına izin verilir .)

Hem programın hem de çıktının izleyen bir yeni hattı var.

Düşünce süreci: Bir dizgeye iki kez çıktı vermenin en kolay yolunun, bir değişkene atamanın yanı sıra, yapmak olduğunu düşündüm.

tee f<<<string
cat f

Dize alıntı yapılması gerekir, çünkü boşluklar ve <karakterler içerecektir.

tee f<<<'tee f<<<cat f'
cat f

Bu, neredeyse hiç işe yaramaz. Neyse ki, Bash basitçe birbirlerinin yanına yerleştirerek string bitiştirmeyi destekliyor, bu yüzden "''"kulübe eklenmesi ""ve tek alıntı kısmının içine yerleştirilmesi bu çözümü veriyor .

PHP , 44 bayt

<?=str_repeat('<?=\str_\repeat(\'\',2);',2);

Çevrimiçi deneyin!

CJam , 8 bayt

"2*`"2*`

Çevrimiçi deneyin!

açıklama

Sorudaki Python örneğine benzer

"2*`"     e# Push the string "2*`"
     2*   e# Repeat it twice
       `  e# Get its string representation (wrap in quotes)

Çıktı "2*`2*`".

Befunge, 11 bayt

' 2+">:#,_@

Baskılar:

+2 '@_,#:>"

Açıklama:

' 2+"        Put a " on the stack (32 + 2)
    "        Put the rest of the code on stack (wrap-around string)
     >:#,_   Print stack
          @  End

QBIC , 8 bayt

?A+@?A@+

Ben sadece anladım Qbic içinde uygun bir Quine nasıl. Bunun dışında bir anagram yapılması, basitçe dizgede karakterlerin etrafında geçiş yaparak yapılır. Bu şekilde 24 olası anagram var.

Befunge-98 , 8 bayt

"'$<@,k7

Çevrimiçi deneyin!

Ohm , 14 bayt

"æ3M.Cæ"æ3M."C

Çevrimiçi deneyin!

Çıktı:

æ3M.CæC.M3æ"""

açıklama

"æ3M.Cæ"æ3M."C
"æ3M.Cæ"       # Pushes "æ3M.Cæ"
        æ      # Palindrone of that string
         3M    # 3 times...
           ."   # Push " on the stack
             C  # Concatenate with the string above

JavaScript (ES6), 15 bayt

f=(s='f=')=>f+s

Çıktılar:

(s='f=')=>f+sf= 

Pasaj:

f=(s='f=')=>f+s

console.log(f());

Fisyon 2 , 9 8 6 bayt

R"'!+O

Çevrimiçi deneyin!

açıklama

RDoğru hareket eden bir atom yaratılır . Bu atom daha sonra ", baskı moduna başlayan a ile karşılaşır . Yazdırma modunda, tüm karakterler (eşleşene kadar ") yazdırılır. Bu '!+OR, bu durumda yazdırdığı anlamına gelir . Ardından "kalan tek şey, kalan karakterler tarafından yapılan baskıdır. '!Atomun karakteri koduna kütlesini belirler !ve +karakter koduna artışlarını o ". Daha sonra karakter kodu tarafından verilir Ove program sonlandırılır ve atom tahrip edilir.

(Aslında, bu sadece en kısa sıranın bir dönüşüdür)

Mathematica, 2 bayt

.0

Çıktı:

0.

Gibi bir ondalık basamağa sahip başlayan bir sayı .123olarak yorumlanır 0.123, yani .0olarak yorumlanır 0.0. Ondalık noktadan sonra sayının parçası sıfır olduğundan, Mathematica yazdırmıyor.

JavaScript (başka bir tane), 11 bayt

f=_=>'=f'+f

Denilen f()çıktılar

=f_=>'=f'+f

f=_=>'=f'+f

console.log(f());

Python 3, 31 bayt

a='a=%r;pritn(a%%a)';print(a%a)

Stax , 8 4 bayt

.S.S

Çevrimiçi çalıştırın ve hata ayıklayın!

Bu cevabın doğrudan bir limanı .

Eski versiyon, 8 bayt

..b..LbL

Çevrimiçi çalıştırın ve hata ayıklayın!

Hemen hemen her dilde uygun sıralara uygulanabilecek ucuz bir hile ile alternatif versiyonu.

"43bL"34bL

Çevrimiçi çalıştırın ve hata ayıklayın!

Çünkü "34bL"34bL Stax'ta uygun bir intiştir.

Yine başka bir sürüm, sadece tek karakterli dize değişmezleri kullanarak.

''c'Lc'cccLcLL

Çevrimiçi çalıştırın ve hata ayıklayın!

açıklama

.S.S        Generates powerset ["","S","S.","."]
            Implicit flatten and output

..b         Push string ".b"
   ..L      Push string ".L"
      b     Duplicate both strings
       L    Concatenate all 4 strings to a single one.

05AB1E , 13 bayt

"34çJ∞"34çJ∞

Çıktılar:

34çJ∞""∞Jç43

Çevrimiçi deneyin!

"34çJ∞"      # Push this string                 | [ 34çJ∞ ]
       34ç   # Push a quote (")                 | [ 34çJ∞, " ]
          J  # Join                             | [ 34çJ∞" ]
           ∞ # Mirror                           | [ 34çJ∞""∞Jç43 ]
             # Implicitly output with a newline