Yaklaşık bir yıl önce 31 Aralık 2015 tarihinde, şunu düşündüm:

Zaman kapsülü ipi yapmalıyız. Herkes bir karakter ekler ve gelecek yeni yıllarda, o zamanlar mevcut olan karakterlerle en iyi programı kimin yapabileceğini görürüz.

Kapı tokmağı nezaketle toplanan karakterleri gelen PPCG toplum ve bir yıl boyunca onları güvende tuttu.

Bir kuyruklu 74 kişi katıldı, bu yüzden oynayacağımız bir 74 basılabilir ASCII karakterimiz var!

2016 zaman kapsülü dizesinin gönderildiği sıraya göre 74 karakter:

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

2016 ASCII sırasındaki 2016 zaman kapsülü dizesinin 74 karakteri:

 !!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

Çalışmak için çok fazla bir şey yok, ama buralarda bir meydan okumayı seviyoruz.

Meydan okuma

Zaman kapsülü dizgisinde hangi dilin "en iyi" olduğunu belirlemek için , her birinde 74 zaman kapsülü karakterinin bir alt kümesini kullanmanız gereken zorlukta artan 6 (201 6 ) zorluk vardır.

6 farklı zorluğa sahip olmak, daha fazla dilin rekabet edebilmesini sağlamaya yardımcı olur, ancak yalnızca en iyi diller hepsini yanıtlayabilir ve yüksek puanlar alabilir.

Puanlama:

• Her meydan okuma kaç karakterin kullanıldığına bağlı olarak 0 ile 74 arasında puanlanır.
• Yüksek puanlar daha iyidir.
• Diliniz bir meydan okumayı tamamlayamıyorsa, bu meydan okuma için puanınız 0'dır.
• Zorlukların boş olmayan herhangi bir alt kümesi tamamlanabilir.
• Son puanınız, 6 yarışmanın tümünden elde edilen puanların toplamıdır.
• Mümkün olan en iyi final puanı 6 × 74 veya 444'tür .

Mücadeleler

1. Çalıştır

Bir dilin kodu ilk etapta çalıştırılamıyorsa hiçbir şey yapamaz.

Derleme zamanı veya çalışma zamanı hataları olmadan çalışan / yürüten mümkün olan en uzun programı yazın (yalnızca 74 zaman kapsülü karakterini kullanın, unutmayın).

Programın ne yaptığı önemli değil, girdi / çıktıya sahip olması veya sonsuz bir döngüye girmesi önemli değil, sadece hatasız çalışması önemli. (Kötü kullanıcı girişinin neden olduğu hatalar gibi uyarılar tamamdır.)

Yorumlara izin verilir, bu yüzden bu kadar basit olabilir

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Python'da 74 puan için.

(Dilinizin tamamlayabileceği tek zorluk buysa, cevap vermekten korkmayın, ancak çok fazla oy beklemeyin.)

Puan = program uzunluğu (daha uzun program daha iyi)

2. G / Ç

Girdi veya çıktısı olmayan bir dil, koşamayan bir dil kadar işe yaramaz.

Bir Verilen yazdırılabilir ASCII karakteri !(0x33) için }yazdırılabilir ASCII karakter önce ve ondan sonra (0x7D) dahil, çıkış.

Çıktı, uzunluk iki dize ya da liste ya da boşluk ya da yeni satırla ayrılmış karakterler olabilir.

Örneğin giriş ise, }çıkış olabilir |~ya da ["|", "~"]ya da | ~ya da |\n~.

Aynı şekilde, "çıktı için !ve ACçıktıdır B.

Puan = 74 - program uzunluğu (daha kısa program daha iyi)

3. Branşlanabilirlik

Şartlılamalar genellikle Turing tamlığı için bir gerekliliktir , bu genellikle bir dilin faydalı olması için bir gerekliliktir.

O ondalık basamak içinde sona ererse, pozitif bir tamsayı Verilen 16sonra değiştirmek 6bir etmek 7ve çıkış sonucu; Aksi takdirde, girdiyi değişmeden çıkartın. İsterseniz giriş / çıkış için dizeleri kullanabilirsiniz.

Örnekler:

2016 -> 2017
16 -> 17
116 -> 117
1616 -> 1617
6 -> 6
15 -> 15
17 -> 17
106 -> 106
2106 -> 2106

Puan = 74 - program uzunluğu (daha kısa program daha iyi)

4. Loopability

Döngü yapamayan bir dil tekrarlayan kodlar doğurur, bu nedenle sıkıcı bir süre programlama molası vermeniz gerekir.

Pozitif bir tamsayı verildiğinde, iki farklı yazdırılabilir ASCII karakteri arasında değişen eş merkezli daha küçük kareler içeren bir ASCII-sanat karesini yazdırın . Farklı girişler için aynı iki karakter olmaları gerekmez.

Örneğin:

1    <- input
X    <- output

2
XX
XX

3
XXX
X-X
XXX

4
XXXX
X--X
X--X
XXXX

5
YYYYY
Y...Y
Y.Y.Y
Y...Y
YYYYY

6
XXXXXX
X----X
X-XX-X
X-XX-X
X----X
XXXXXX

7
ZZZZZZZ
Z-----Z
Z-ZZZ-Z
Z-Z-Z-Z
Z-ZZZ-Z
Z-----Z
ZZZZZZZ

Puan = 74 - program uzunluğu (daha kısa program daha iyi)

5. Matematik

Sayılar ve matematikle iyi olmayan bir dil, beşeri bilimler için de olabilir.

Girişten çıkmayın, 2016'daki 72 tamsayı bölenini olumlu ya da olumsuz olarak verin. Çıktı makul bir şekilde bir dize veya liste olarak biçimlendirilebilir.

Örnek:

-1, -2, -3, -4, -6, -7, -8, -9, -12, -14, -16, -18, -21, -24, -28, -32, -36, -42, -48, -56, -63, -72, -84, -96, -112, -126, -144, -168, -224, -252, -288, -336, -504, -672, -1008, -2016, 1, 2, 3, 4, 6, 7, 8, 9, 12, 14, 16, 18, 21, 24, 28, 32, 36, 42, 48, 56, 63, 72, 84, 96, 112, 126, 144, 168, 224, 252, 288, 336, 504, 672, 1008, 2016

Puan = 74 - program uzunluğu (daha kısa program daha iyi)

6. Ezoterizm

(Hayır, o .) Biz de PPCG bizim gibi ezoterik şeyler ve quines buna en iyi örnektir.

Normal quine kurallarına göre, alabildiğiniz en uzun quine yazın . Quine giriş yapılmayan ve kendini veren bir programdır.

Puan = program uzunluğu (daha uzun program daha iyi)

Özel Kurallar

• 6 zorluktan her birinde programınız istediğiniz şekilde yeniden düzenlenmiş 74 zaman kapsülü karakterinin bir alt kümesi olmalıdır . Boş bir alt küme veya uygun olmayan bir alt küme olabilir , bu nedenle programlarınızın her biri en az 0, en fazla 74 karakter içerebilir .
• Giriş / çıkış / kodun sonundaki tek bir son satır yeni bir yerdedir, çünkü bazı diller bunu gerektirir veya kolayca önlenemez.
• Aksi belirtilmedikçe, her bir meydan okuma varsayılan ayarlarımıza göre bir işlev veya tam program olarak tamamlanabilir .
• Tüm zorluklar aynı dilde tamamlanmalıdır.
• Dünyanın herhangi bir yerinde 2017 olmadan önceki bir dili (veya bir dilin sürümünü) kullanmanız gerekir .
• Zaman kapsülüne bir karakter ekleyip eklememediğiniz herkes size cevap verebilir.

_{2016 zaman kapsülü karakterlerini kendi zorluklarınızda kullanmaktan çekinmeyin.}

Glypho , 74 + (74 - 36) = 112

1. Çalıştır (74 bayt)

!!#%QTQT@=A@$!!$)()*!&))+...1449:@HILOQZ\\^`````````eefmpx|||{~~~~~~y~|~ ~

2. G / Ç (36 bayt)

!!!#!$!$4419TAHT\ee\OQQQ))*+)..)|~~~

açıklama

Glypho bu zorluk için oldukça iyi bir seçim gibi görünüyordu, çünkü kullanılan gerçek karakterleri önemsemiyor. Bunun yerine, dört karakterden oluşan gruplara bakar ve bu dört karakterdeki tekrarlama modeline göre komutu seçer. Zaman kapsülü dizgisi arasında birçok kopya olduğundan, yazabileceğimiz programlarda oldukça esnekiz, ancak 18 komuttan oluşan programlarla sınırlıyız (Glypho'da çok fazla değil). Bu, ilk iki sorunu kolayca çözmeme izin verirken, Glypho'nun diğerlerini bu kadar az karakterle çalıştırabileceğinden şüpheliyim.

Bunları , 2006-06-23'ten alınan, geri alma makinesinde , komutların biraz farklı bir eşlemesini kullanan Java tercümanı kullanarak test ettim :

0000 n
0001 i
0010 >
0011 \
0012 1
0100 <
0101 d
0102 [
0110 +
0111 o
0112 *
0120 -
0121 ]
0122 !
0123 e

Çalıştır programı şöyle açıklanabilir:

1d-+[...]

...Tercümanlık yapmadığım bir çöplük nerede .

1      Push 1.
d      Duplicate.
-      Turn into -1.
+      Add. Gives 0.
[...]  Skip the rest because the top of the stack is zero.

IO programı şöyle açıklanabilir:

id1-+o1+o

İşte bu ne yapıyor:

i   Read a character.
d   Duplicate.
1   Push 1.
-   Turn into -1.
+   Add to character, i.e. decrement it.
o   Output it.
1   Push another 1.
+   Add to character, i.e. increment it.
o   Output it.

CJam, 74 + (74 - 14) + (74 - 26) = 182 puan

1. Çalıştır (74 bayt)

e# !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````efmpxy{||||~~~~~~~~~

Hareketli e#öne bütün satırı dışında yorumlar.

2. G / Ç (14 bayt)

9`)ZH*+~):Q(Q)

Dennis 8 byte kurtardı.

Açıklama:

9`                   Push "9".
  )                  Extract character '9'.
   ZH*               Push 3 * 17 = 51.
      +              Add to get character 'l'.
       ~             Eval as CJam code. Command l reads a line.
        )            Extract the only character from the input line
         :Q(         Assign to Q and decrement
            Q)       Push Q and increment

3. Branşlanabilirlik (26 bayt)

4`)4Z|`I!`|~^~~T$AT$*%H(=+

Açıklama:

4`)                            Push character '4'
   4Z|`                        Push 4 | 3 = 7, stringify
       I!`                     Push !18 = 0, stringify
          |~                   Setwise or and eval to get 70
            ^                  XOR to get 'r'
             ~                 Eval to read input
              ~                Eval the input as CJam code to turn
                               it into an integer
               T$              Duplicate it
                 A             Push 10
                  T$*          Duplicate that and multiply → 100
                     %         Mod the copy by 100
                      H(=      Compare to 17 - 1 = 16
                         +     Add the result (1 or 0) to the original

Diğerlerine daha sonra bakacağım. ( EDIT : Muhtemel, blok veya string değişmezler olmadan… belki matematik olandan?) Şüpheliyim.

J, skor 71 + (74 - 19) = 126

Görev 1, uzunluk 71

AHILO=:( |T`T`Z`e`e`f`m`p`x`y|.~~%~@{|~^|Q@Q@Q+.*.449!~!~!~!!#$$&1\\~~)

Bu AHILO, içeride olacak bir fiili tanımlar . Kullanılmayan:

)))

Bundan daha uzun sürmenin bir yolu olduğunu sanmıyorum.

Görev 3, uzunluk 19

+($#~$~4)=1e4|&%:*~

Bu görevi hiçbir kısıtlama olmadan yapmanın yolu +16=100|]şöyledir:

        ]  Input
    100|   mod 100
 16=       equals 16? (Evaluates to 1 or 0)
+          Add to input.

Biz +, =ve birkaç kopya veya |Elimizdeki içinde ve çevresinde elde etmek kolaydır ], ama sayılar daha sorunludur. Modül 100 girişini hesaplayan ilk bölüm:

1e4|&%:*~
       *~  Input squared (multiplied with itself).
1e4        The number 10000.
   |       Perform modulo
    &      on
     %:    their square roots.

Bunu yaptıktan sonra, 16 sayısını verelim. Kolay yol *~4(4 ile çarpılır), ama biz zaten kullandık *, bu yasak. Bunun yerine, bazı dizi manipülasyonları yapacağız.

($#~$~4)
    $~4   Reshape 4 to shape 4, resulting in the array 4 4 4 4.
  #~      Replicate wrt itself: replace each 4 by four 4s.
 $        Take length.

İş

2

Bu kesinlikle imkansız. Karakter değerlerini manipüle etmenin tek yolu ve vardır a.ve u:ikisine de erişemeyiz.

Şimdi, aörneğin, yerine kullanabilirsek A, o zaman bu bir çözüm olacaktır:

Q{~(*^.4%9 1)+I.~&Q=:a.

Bu işe almak için en zor kısmı -1 sayısını üretmekti.

Q{~(*^.4%9 1)+I.~&Q=:a.
                     a.  The array of all bytes.
                  Q=:    Bind it to Q
              I.~&       and find the input's index in it.
   (        )+           Add the following array:
    *                    Signum of
     ^.                  logarithm of
       4%                4 divided by
         9 1             the array 9 1.
                         This evaluates to -1 1.
Q{~                      Index back into Q.

4

(*.1:"|~@+.)

Bu, kabuğun şeklini oluşturur, ancak karakter oluşturmanın bir yolunu bulamıyorum. Ne yazık ki.

5

Kuşkusuz ki, bu J'de yapılacak işlerin en kolayı gibi görünüyor. Ancak, olmadan i., bu oldukça zor olacak.

6

449Kapsül dizesi tırnak işaretleri veya J dizeleri üretmenin başka bir yolunu içermediğinden, bunun gibi sahte bir kın veya benzeri bir şey olmadan muhtemelen imkansızdır .

PowerShell - Toplam Puan: 74

1. Koş - Puan: 74

#~= `TeQ.)`~H|$QL4yA)\*`!^O$1)!Z`!`~|\`&T@!x+e(f|Q`.|!4%.{~`:~~)m@~`@p~I9~

PowerShell'de bu son derece zor olduğu için (giriş yapabilmek için mümkün olan her yöntem, söyleyebileceğim kadarıyla, verilen karakterlerle mümkün değildir), en azından ilk mücadeleyi rastgele seçmeye karar verdim; postadan.

İşte rastgele bir meydan okuma 1 cevap üreteci (yorum yapan diller için #)

'#'+$(-join([char[]]' !!!!!$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~'|Get-Random -Count 73))

Çevrimiçi deneyin!

memes , puanları ( 62 65 + 70) 135

1: Çalıştır

Tüm backticks ( `) ve matematiksel operatörleri kaldırdım . Her ihtilaf ve ikili işletmeciyi karşılamak için yeterli sayıda olmadığı için çelişkilendirdiler. Bazılarını bıraktım, sonuçta +3 bayt oldu . Sonuç programı:

 !!!!!#$$%&())))...+1^4*49:=@@@AHILOQQQTTZ\\eefmpxy{||||~~~~~~~~~

Bunun neden ve nasıl çalıştığı hakkında hiçbir fikrim yok. En azından herhangi bir C # çalışma zamanı istisnası atmaz ve bu nedenle çökmez.

6: Quine

Biliyorsunuz, eğer bu 74 karakterde bir yerde -küçük veya küçük harf qolsaydı, bu çok kolay olurdu. IOperatör için memnunum , en azından.

1/4I

Bu kod tam olarak belli değil. İşte bir açıklama:

1    Set object to 1 (1)
/4   Divide by 4     (0.25)
I    Set object to a fraction string. (1/4)

Kesir dizeleri (örneğin 1/4), tam olarak bunu belirtmek için sonunda bir I ile görüntülenir. IOperatör genellikle işe yaramaz, ben başka yollarla için eklenen, ama hey, bu gibi çalışıyor!

Yukarıdaki kod geçersiz. Aptal 74 karakterin tek bir bölme operatörü içermediğini görmedim, forwardwards ( /). Yine de başka bir şey buldum:

True

Açıklama:

T    Set object to "true" (bool value)
rue  None of these are valid tokens, so they don't get interpreted.

Çıktılar True(C # yönteminin Boolean.ToString()büyük ve küçük harf kullanma şekli nedeniyle). Bu doğru bir titreyse emin değilim, bu arada hala geçerli, gerçekten uygun ve sezgisel bir şey için kafamı kırarım.

G / Ç ve Matematik zorluğunu da çözebilir, ancak 74 karaktere dahil olmayan belirli belirteçleri (karakterleri) özlüyorum.

Brainfuck, 74 bayt

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Sadece zorundaydım.

Açıklama:

Geçerli bir Brainfuck karakteri olmayan herhangi bir karakter yorum olarak kabul edilir. Aslında çalışan tek kod şudur:

.+..

Bu, yazdırılabilir çıktı üretmez, çünkü 0 veya 1 ASCII'de yazdırılabilir karakter değildir. Ancak, bu bir hataya neden olmaz, bu yüzden ilk mücadeleyi başarıyla tamamlarız.

Mathematica, 62 puan

Mathematica'da 2-6 çalışmakta zorluk çekebilecek biri varsa şaşırırım. İşte meydan 1 ile yaptığım en iyisi:

A:=1.`!#&@(4`+4.`*9.`^$$H~I~L~O~Q~Q~Q~T~T||Z||e@@efmpxy%)!!!!

ASabit bir değere sahip oldukça aptal bir işlevi tanımlar . Kullanılmayan 12 karakter:

)))\\`````{~

Octave, skor 74

1. Çalıştır

x =@(AHILOQQQTTZeefmpy)+.1||!!!!!~~~~~~~~~4.^.4||9%#$$)))*@@\`````````{\&:

Bu karakterlerin 50'si işlevin bir parçası, geri kalan 24 ise değil.

Bu ne yapar:

x =@(AHILOQQQTTZeefmpy)xdeğişken AHILOQQQTTZeefmpyolarak girdi alabilen bir işlev yaratır .

Gerisini anlamak için:

a||bişlevini çağıran all()hem de ave b. Bunlardan biri veya her ikisi de doğru ||olursa , operatör doğru olarak döner.

!ave ~aburada aynı anlama geliyor, ikisi de not(a).

a.^b element bilge bir güçtür (a(1)^b(1), a(2)^b(2) ...)

Devamlı açıklama

Devam ettikçe adımların her birini kısaltacağım:

4.^.4||9  % This is 4 raised to the power of .4||9
          % .4||9 is true, since both .4 and 9 are true
          % true is evaluated to 1 when used in an expression
...       % 4 raised to the power of 1 is simply 4.
4         % The above expression simplified

Ve:

!!!!!~~~~~~~~~4  % ! and ~ are the not() operator, so this is equivalent to:
not(not(not(not(not(not(not(not(not(not(not(not(not(not(4))))))))))))))

Bir çift sayısı vardır not, yani bu not(not(4)), trueya da eşdeğerdir 1.

+.1||1      % This is equivalent to all(+.1) | all(1), which returns true

Gerisi yorumlanmıştır.

*> <> , toplam puan = 74

1. Koş, skor 74

f:4%*e+e14=p!Q H@~^)$.`~A|Q)~`\ZI~O.~@``#|9@)T\T`(!``|`~!y!`)Q~$x.|m~~&!L{

Burada dene!

Bu ;karakter olmadan yapmak son derece zordu . Aslında birkaç dakika için imkansız olacağını düşündüm, görene kadar %, temelde vazgeçtim.

Bu aynı zamanda geçerli bir> <> programıdır.

Açıklanan (alakasız kısımlar atlandı)

f:4%*e+e14=p!Q 

f:               copy 15
  4%             pop 15, push 15%4 (3)
    *            pop 15 and 3, push 15*3 (45)
     e+          pop 45, push 45+14 (59, ascii ";")
       e         push 14
        14=      push 0
           p     replace coord (14, 0) with ";"
            !Q   skip Q (this is just filler)
              ;  end execution

Karşılaşılan zorluklar

Diğer zorlukları deneyebilirim ... çok zor olacaklardı ve kuralları tuhaf şekillerde bükmeyi içerebilirlerdi ama |aynaların ve !trambolinlerin serbestçe kullanılması en az bir mücadeleyi mümkün kılmalı.

Bu zorluklar özellikle zor, çünkü *> <> ( ove n), hatta işlev çağrıları ( C), işlev geri dönüşleri ( R) veya program sonlandırıcıları ( ;) olan çıktılara izin verilmiyor . iGirdi için de eksik olsak da , artı olan yığına girdi koymaya devam edebiliriz. Bir başka artı, pkod kutusundaki bir talimatı değiştirmemize izin veren tek bir talimat almamızdır. Bu, diğer programların daha mümkün görünmesini sağlayacak (iki veya daha fazla talimat üretebileceğimiz gibi), birçok kez (henüz pratik bir yol bulmadı) kullanılmaya başlanabilir.

Haskell, skor 63

1. Çalıştır:

(!!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~)fmpxyAHILOQQQTTZ e=14`e`49

Kullanılmaz )))```````{. Haskell'deki yorumlar --veya{- ... -} , bu nedenle kolay bir yorum yapılmadı.

Bu kod !!!!!#$$%&*+...:@@@\^||||~~~~~~~~~iki argüman alan bir infix işleci tanımlar :

1. fmpxyAHILOQQQTTZ ihmal edilir ve bu nedenle keyfi bir şekilde olabilir
2. e, iki sayı alan bir işlev olmalıdır

Fonksiyon gövdesinde edaha sonra, kullanılarak 14 ve 49'a uygulanır.` -infix notasyonu .

Kullanım örneği:

Prelude> () !!!!!#$$%&*+...:@@@\\^||||~~~~~~~~~ (*)
686

İşleç, ()boş dize ve (*)çarpma işlecine uygulanır.14*49 = 686 hesaplanır.

Çevrimiçi deneyin!

Diğer zorluklar

Ben diğer zorluklardan herhangi en önemlisi çünkü sadece iki kez görünebilir olası değişken isimlerin eksikliği, ki mümkündür şüphe e(falan gibi eQTdeğişken adları büyük harfle başlamaz, çünkü). Tabii ki, sadece bir tanesine =sahip olmak da yardımcı olmuyor.

Pyth, şimdilik 131 (2 zorluk tamamlandı)

1. Koş, 74

# `````````!!!)!)!)*$AOeIefLmpxQ|Q|y|Q|~~~~~~~~~()${+%&\=@@@^\:.1.4.49TTZH

Bu program giriş yapmaz ve çıkış oluşturmaz.

Bu program $$, rasgele kod yürütülmesine olanak sağlayan ve çevrimiçi olarak yasaklandığı için kullanır , bu nedenle bu program çevrimiçi çevrimdışı çalışır. İşte derleme çıktısı, böylece gerçekte neyin çalıştığını görebilirsiniz:

while True:
 try:
  (repr(repr(repr(repr(repr(repr(repr(repr(repr(Pnot(Pnot(Pnot()))))))))))))
  imp_print(Pnot())
  imp_print(Pnot())
  imp_print(times(AOeIefLmpxQ|Q|y|Q|~~~~~~~~~(),uniquify(plus(mod(("=" and lookup(lookup(lookup(Ppow(":",.1),.4),.49),T)),T),Z))))
  imp_print(H)
 except Exception:
  break

Pyth'te hata yapmayan, rastgele karakter içeren bir program yazmak oldukça zor. Programın kullanıcı girişi gerektirmeden çalışması için kendime ek bir zorluk getirdim.

İlk adım, #tüm hataları yemek için kullanmaktır . Sonra, neden hatalarından kaçınmak gerekir ~, Ive Lher biri kendi ayrıntılara sahip olan. Bu, $$onları çıktı derlemesinin içine yerleştiren içine koyarak elde edilir ve böylece Pythhon'un derleme kurallarına tabi tutulur. Son olarak, kullanıcı girişi almaktan kaçınmak için, çeşitli arite 0 belirteçleri (Değişkenler ve benzerleri) sonuna yerleştirilir ve Qs, $$bloğun içine taşınır .

2. GÇ

Mümkünse, bu inanılmaz zor olacak. Rasgele dizeler veya karakterler oluşturan Pyth işlevlerinin hiçbiri dışında .fyoktur ve bu, rasgele karakterler oluşturmak için gerçekten zayıf bir iş yapar.

3. Branşlenebilirlik: 74 - 17 = 57

|&x%Q*TTye|LZ9Q+1

Çevrimiçi deneyin

Eşdeğer bir Pyth programı şöyle olabilir:

?n%Q100 16Q+1

Bu kod 100 giriş modunu alır, 16 ile karşılaştırır ve giriş ile giriş artı birini seçmek için üçlü bir değer kullanır. Karakter kısıtlamaları nedeniyle bazı değişiklikler yaptım:

• ?Üçüncüsü yerine |&, oro zaman and, aynı işlevselliğe sahip olan kullandım , ancak girdi sıfırsa kırılır, ancak pozitif tamsayı girişi garantili olduğumuz için sorun değil. (Bu, herhangi bir ek karakter olmadan düzeltilmiş olabilir, ancak bu şekilde daha kolaydır.)

• İki sayıyı doğrudan karşılaştırmak yerine, XOR'larını x, istenirse eşit ve eğer eşitse sıfır olan sıfır ile alırım .

• 100Doğrudan yazmak yerine , başlatıldığımdan *TTberi onu kullanarak oluşturuyorum .T10

• 16Doğrudan yazmak yerine , onu üretiyorum ye|LZ9. |LZtemelde, aralık fonksiyonu olarak işlev görür, yani |LZ9verir [0, 1, 2, 3, 4, 5, 6, 7, 8]. ebir listenin son elemanını alır, verir 8. istediğiniz gibi yvererek, ikiye katlar 16. Fazladan +veya fazladan *bir karakter kaydedebilirim, ama ikisi de başka yerlerde daha faydalı.

Gelmek için daha fazla!

Yakut - Puan: 74

1. Çalıştır

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Mücadeleden yakalandın.

JavaScript (ES6), puan = 74

1. Çalıştır, 74 bayt

Z=` !!!!!#$$%())))...1449:@@@\AHILOQQQTT^\`eefmpxy{||||~~~~~~~~~`*``+``&``

6. Ezoterizm (geçersiz)

Kayıt için önerdiğim quine:

1.4e+49

Aşağıdaki yorumlarda tartışıldığı gibi geçersiz olduğu ortaya çıktı.

Retina, skor 74

1. Koş, skor 74

)))` !!!!!#$$%&()*.+..1449:=@@@AHILOQQQTTZ\\^````````eefmpxy{||||~~~~~~~~~

Ekstra parenleri regex'te dengede tutabilmek için config'e taşıdım. Ben de taşındı `olanlar sonra hakkını ve değiştirilen +.için.+ .

Çevrimiçi deneyin

Diğerleri imkansız, çünkü yeni hatları yok. Ayrıca -, Harf çevirisi veya drakam karakter sınıfı için de yok .

Pip, skor 74 + (74 - 19) = 129

Nary ile pek çok backticks tek veya çift görülmesi gereken bir alıntı!

Görev 1, puan 74

`` `\``!!!!!`#$$%&())))*+...1449:=@@@ILOQQQTTZ\^efmpx{|||~~~~~~~~~`|`yeAH`

Temelde backticks'te sadece bir dizi desen (regex) değişmezleri, sonuncusu basılıyor. Çok sayıda backtick bulunduğundan, bunlardan birini ters eğmek zorundayız ( `\``). Hiçbir uyarının üretilmediğini kanıtlamak için bayrakla çevrimiçi olarak deneyin-w .

Görev 3, puan 55 (uzunluk 19)

e+!!e%(1.#x.!9)=4*4

Oldukça garip bir giriş yöntemi kullanarak - beşinci komut satırı argümanı - bu mümkündür. Çevrimiçi deneyin!

                     e is 5th cmdline arg; x is empty string
       1.#x.!9       Concatenate 1, 0 (length of x), and 0 (not 9)
    e%(       )      e mod 100...
               =4*4  ... equals 16?
  !!                 Logically negate twice
e+                   Add to e (+1 if number mod 100 is 16, +0 otherwise)
                     Expression is autoprinted

Diğer görevler

Görev 2 için girdi , yukarıdaki görev 3 ile aynı yöntemle elde edilebilir. Sorun ASCII koduna dönüşüyor ve karaktere geri dönüyor. Eski ile yapılabilirA , ancak ikincisi gerektirir Cveya büyük olasılıkla PAdeğişkene indekslenir . Kod oluşturma ve değerlendirme olmadan yapılamazV . Görevin mümkün olduğunu sanmıyorum.

Görev 4 , kısıtlanmış bir karakter seti olmadan bile zorlu. Tahminen, listeleri ( []sınırlayıcıları kullanmadan ya da RL(tekrar listesini) kullanmadan ve yalnızca bir tane kullanma şansına sahip olması gerekir)AL (listeyi ekle) - olasılıkla değil) veya muhtemelen CG(koordinat ızgarası) veya MC(harita koordinatlarına) sahip bir şeyi ( her ikisi de izin verilmeyen) gerektirecektir. .

Görev 5 , olanakların kenarındadır. Döngüler zor olabilir, çünkü Fveya Map mümkün değildir ve aralıklar ile inşa edilemez ,. THasta ile yapılacak bir şey olabilir . Artış olabilirx:x+1 çeşitlilik olabilir (açıkçası xolsa da, bir değişkenle ). Bölünebilirlik kontrolleri kullanabilir% . Yine de olması gereken her şeyi yapmak için yeterli karakter - özellikle de tekrarlanan harfler - olduğunu sanmıyorum.

Görev 6 tamamen imkansız görünüyor. Bilinen tüm Pip quinesinde var ". Ayrıca , hiçbiri uygun olmayan R(yerine), RP(repr) veya V(eval) kullanırlar.

Aslında, skor (74 + 0 + 0 + 0 + 0 + 0 ) = 74

Evet, kapsül dizesi Aslında Çalıştır'daki gibi çalışır, çünkü aslında tüm hataları reddeder ve her hata bir NOP olur.

H@~*^)$.~+1A|Q)p~\Z!IQ~e:O.~@#|9@)Tf\eT`=(!|~!y!) Q~$x.4|m4~~&!L{%( Çevrimiçi deneyin! )

Yine de bir şeyler karışıklığı çıkartacaktır (ancak bir kez de kaynağı: 3).

Ancak diğer zorluklar üzerinde çalışacağım.

05AB1E - Toplam puan: 74

1. Çalıştır, 74 bayt

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

Hataya sebep olan her şey 05AB1E tarafından atlanır. Bütün bu kod satırı bir NOP.

Çevrimiçi deneyin!

(kötüye kullanılan) PHP, 74 + 74 = 148

H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``#|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

PHP tercümanı, kaynak kodunu boşa harcayana kadar kaynak kodunu boşa harcar, <?çünkü <bu karakterlerin her permülasyonunun çalışmaması için bir eksikliktir . Sanırım bu yerleşik bir quine komutu kullanmaktan daha kötü değil: P

Mathematica, puan 68

`A: = .1% *. 44y # +. 9 ^` H @ `$ I @` L @ (`$ O ~` Q ~ `Q ~` Q ~ `T ~ T ~ Z ~ e ~ e | f | m | p | x) !!!!! ve \

Sondaki yeni satıra dikkat edin. Mathematica ile diğer zorluklardan herhangi birinin çözülebileceğine inanmıyorum.

Labirent, skor 74

AH)
IL)
OQ:
`=!)~`{+4.@ !!!$$%&(*..149@@TTZ\\^```eefmpxy||||~~~~~~~~
`Q#
`Q)
``!

Bu karakterlerin herhangi bir ürün yelpazesinin geçerli bir Labirent programı ürettiğinden eminim, ama en azından biraz daha ilginç hale getirmek için, bu 2016rakam basamağı basar . (Özetle: 2yığına 2 'yi bastırın , birini bastırın / yazdırın, diğerini aux yığınına taşıyın, 0'ı bastırın 1, yığına 2'yi bastırın , pop / print 1, artırın, bit yönünde değil, olumsuzlayın (en son 1bir3 ) bu noktada ile Özetle2 aux yığından, * 10 + 4 = 54 5, aSCII değeri olarak baskı sona)

Uzun çizgilerin çoğu, sadece @Programı sonlandırdığı için .

Labirentlerin giriş komutlarının hiçbiri uygun olmadığından ( ,ya da ?) ve 5 veya 6 için hiçbir şey bulamadığım için 2, 3 ve 4. zorluklar imkansızdır .

SmileBASIC, 48 puan

1. meydan okuma:

@LOQQQTTZ A$=H$+@efmy+@9414*!exp(!!.||!!.#||I%):

açıklama:

@LOQQTTZ 'label
A$= 'set value of A$ (string)
H$ 'string
+@efmy 'adds label, interpreted as string literal
+@9414 'adds label, interpreted as string literal
*!exp( 'multiplies by logical not e^x (= 0)
!!. 'not not 0.0 (= 0)
||!!.# 'or not not 0.0 converted to a float (= 0)
||I% 'or I% (integer variable)
: 'equivalent to a line break, does nothing here

diğerleri:

Giriş / çıkış komutları kullanılamaz, bu nedenle gerisi mümkün değildir.

Yine de, yorumları kullanmadan gerçek bir dil için fena değil.

Matl , toplam puan 74

1. Koş, skor 74

`4.e4 1.$!!!!!T+Zyf9.)AH^ILx@Q@Q@Qm||||~~~~~~~~~:=Tp*O%#$&()))\\````````e{

Her şey %gerçek koddur. %yorum sembolü olduğundan sağındaki karakterler yoksayılır.

Program 1hatasız çıktı.

Çevrimiçi deneyin!

bash, skor 74

1: Çalıştır. Hepimiz 74 koyabiliriz

#H@~*^)$.`~+1A|Q)p~`\Z!IQ~e:O.~@``|9@)Tf\eT`=(!``|`~!y!`) Q~$x.4|m4~~&!L{%

6: Ezoterizm:

Boş program bash'ta bir koddur.

Herhangi bir boşluk karakteri olmadan, listede başka hiçbir şey gerçekleştirilemez. Ergo, kazanan bash girişine sahibim.

Perl 6 , toplam puan 74

1. Koş, skor 74

my @TOTAL=$!||(e*4...9^e)Z+1~4||!!Q`{fp)))\#\&`~Q!```HI````!~Q:x~~~$~@~@~%

Yorum yok.
(Sadece koyarak# her şeyi bir yorum yapmak için öne aynı zamanda işe yarıyor, ama bu daha eğlenceli.)

İş

Bu, yalnızca izin verilen karakterleri kullanan Perl 6 dilinin alt kümesidir:

Sabitler: e

Tip adları: IO

İşlevler: exp

Yöntem:
    IO türünde: .e .f .x
    (... muhtemelen daha fazla.)

Operatörler: | infix: | önek:
    ----------- + ----------------------- + ---------
    sayısal: | + * + ^ + | + &% | + + ^
    string: | ~ x ~ ^ ~ | ~ & | ~
    boole: | || ~~ | !
    kavşaklar: | | & ^ |  
    misc: | =: = Z .. ... |  

sözdizimi:
    sayı değişmezleri: 1 4 9
    string değişmezleri: Q` `Q! ! vb.
    kabuk komutları: Q: x` `Q: x! ! vb.
    Hangi yıldız olursa olsun: *
    değişkenler: my \ $ @ &
    gruplama: ()
    yorumlar: # # `()
    boşluk: \

Mücadeleleri 2-6 önleyen acil engel, G / Ç yapmanın bir yolunun olmadığı görünüyor:

• Eğer bir dosya olduğunu varsayarsak f, Q`f`.IO.eolup olmadığını kontrol etmek için ya Q`f`.IO.xda çalıştırılabilir olup olmadığını kontrol etmek için kullanabiliriz. Ama okuyamıyor ya da ondan yazamıyoruz.

• Q:x` `Bir kabuk komutu çalıştırmak için kullanabiliriz (birinin karakterini bulduğumuzu varsayıyoruz). Ama hiçbir şeyi enterpolasyona sokamayız, bu yüzden sadece okumak için iyi olur, yazmak için değil.

• Kapama ayracı olmadığı için {1 + $_}, son ifadesinin değerini otomatik olarak döndüren bir blok lambda (örn. ) Yapamayız .

• Biz olabilir bir ifade lambda (örn yapmak için yıldız kullanabilirsiniz 1+*), ancak o zaman sadece bir argüman alabilir yalnızca bir kere argüman bakın ve daha sınırlı kullanabileceğimiz sözdizimi / operatörler bulunmaktadır.

Lua, skor 31

1. Koş (74 üzerinden 31)

AHILOQQQTTZeefmpxy=1.%4+(4.*9.)

Jelly , skor 74

1. Koş , 74

 ||||!!!!!$$~~~~~~~~^@=@~%449:`e@`e`QAHILOQQTTZ{\\f`m`p`x`y`&`*.#1+.()))).

Diğerlerinden nasıl yapılacağından emin değilim.

/// , Puan: 146

1. Koş, Skor: 74

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ\\^`````````eefmpxy{||||~~~~~~~~~

6. Quine, Puan: 72

!!!!!#$$%&())))*+...1449:=@@@AHILOQQQTTZ^`````````eefmpxy{||||~~~~~~~~~

Yay, kodda herhangi bir geri veya geri eğik çizgi yoksa, sadece kendini yazdırır.