Herkes program ekleyerek karakterleri ekleyerek daha büyük hale getirebilir, tam tersini yapalım.

Aşağıdaki kriterleri karşılayan bir dilde REPL ortamı için tam bir program, bir iç işlev veya bir snippet yazın:

1. Kodunuz en az 1 karakter uzunluğunda olmalı.

2. Orijinal kodun çalıştırılması, STDOUT'a (veya en yakın alternatife) x çıkış karakterini üretir , burada 0 ≤ x <+ ∞ .

3. Herhangi bir tek karakterin orijinal koddan kaldırılması , STDOUT'a en az x + 1 karakter çıktı veren geçerli kodla sonuçlanır .

4. Ne orijinal kod ne de değişiklikler herhangi bir hata çıktısı üretemez, STDOUT, STDERR, syslog veya başka bir yerde olabilir. Bu kuralın tek istisnası derleyici uyarılarıdır.

   Programınız, hata çıktısını bastırmak için herhangi bir bayrak veya ayar gerektirmeyebilir.

   Programınız herhangi bir çıktı üretmese bile önemli hatalar içermeyebilir.

5. Hem orijinal kod hem de modifikasyonlar deterministik olmalı ve sonunda bitmelidir (sonsuz döngü yok).

6. Ne orjinal kod ne de modifikasyonlar herhangi bir giriş gerektirebilir.

7. İşlevler veya pasajlar yürütmeler arasında herhangi bir durumu koruyamayabilir.

Bu görevin önemsiz olduğunu göz önünde bulundurarak bazı diller vardır ve diğerleri arasında düpedüz mümkün değildir, bu bir popülerlik yarışmasıdır .

Oy verirken, lütfen kodun "nispi kısalık" ını dikkate alın, yani daha kısa bir cevap , aynı dilde daha uzun bir cevaptan daha yaratıcı kabul edilmelidir .

XOR işlemi olan, 5 baytlık herhangi bir REPL

11^11

11^11Sadece diğer olasılıklar elbette 0 ait 1^11ya da 11^1bu 10, ya da 1111bunun kendisi de üretir.

TI-BASIC, 3 1

"

Bir programın son satırı bir ifade olduğunda, hesap makinesi bu ifadeyi görüntüler. Aksi takdirde, Doneprogram bittiğinde hesap makinesi görüntülenir . Buradaki ifade boş dizedir, ancak herhangi bir rakam ile de çalışabilir.

2 bayt:

isClockOn

Yukarıdakiyle aynı, ancak 2 baytlık bir jetonla.

3 bayt:

ππ⁻¹

1Zımni çarpma nedeniyle yazdırır . ⁻¹'S çiftleri ekleyerek süresiz olarak uzatılabilir . Aşağıdakiler de işe yarıyor.

√(25
e^(πi
⁻ii
ii³
2ππ   
cos(2π

Daha uzun çözümler:

11/77►Frac
ᴇ⁻⁻44
cos(208341   //numerator of a convergent to pi; prints "-1"

Muhtemelen çok hatlı çözümler de var ama hiçbirini bulamıyorum.

CJam, JavaScript, Python, vb, 18 bayt

8.8888888888888888

CJam’deki çıktılar:

8.8888888888888888 -> 8.88888888888889
8.888888888888888  -> 8.888888888888888
88888888888888888  -> 88888888888888888
.8888888888888888  -> 0.8888888888888888

JavaScript ve Python benzer şekilde çalışır. JavaScript ve Python'da rekabetçi değil, ancak CJam'da daha kısa bir tane bulmak kolay değil .

Oktav, 5 bayt

10:10

(x: y), x ile y arasındaki 1 sayısını 1'lik artışlarla verir; böylece 10 ile 10 arasında tek öğe 10 olur:

> 10:10
ans = 10

İkinci argüman birinciden küçük olduğunda, oktav boş matrisi ve boyutlarını yazdırır:

> 10:1
ans = [](1x0)

> 10:0
ans = [](1x0)

Bir karakter ilk sayıdan kaldırıldığında, dizide daha fazla öğe vardır:

> 1:10
ans = 1 2 3 4 5 6 7 8 9 10

> 0:10
ans = 0 1 2 3 4 5 6 7 8 9 10

Kolon kaldırıldığında, sayı kendisini döndürür:

> 1010
ans = 1010

Mikroscript, 1 bayt

h

Bu h, dilin örtük basımını bastırdığı için hiçbir çıktı üretmez . Tek karakterin kaldırılması, çıktısı olan bir program üretir 0\n.

Daha sonra daha iyi bir cevap bulmaya çalışacağım.

17 KASIM'DA EDİT:

Bu aynı zamanda Microscript II'de de çalışır, bunun yerine 0\nboş programın verimini vermek yerine çalışır null.

Pyth, 3 bayt

cGG

Galfabedeki küçük harflerle önceden başlatılmıştır. cbölünmüş işlevdir.

cGGalfabeyi, biten ['', ''](8 byte) ile başlayan alfabenin oluşumlarına göre böler .

İkinci parametre eksik olduğunda, cdizeyi beyaz boşluklara, sekmelere veya yeni satırlara böler. Bunların hiçbiri görünür beri G, için çıkış cGolduğunu ['abcdefghijklmnopqrstuvwxyz'](30 bayt).

Ve GGiki ayrı satırda alfabenin iki katı basılır: abcdefghijklmnopqrstuvwxyz\nabcdefghijklmnopqrstuvwxyz(53 bayt)

Çevrimiçi deneyin: Gösteri

Python REPL, 6 bayt

En kısa değil, ama işte başka bir kayan nokta kötüye kullanımı cevabı:

>>> 1e308
1e+308
>>> 11308
11308
>>> 11e08
1100000000.0
>>> 11e38
1.1e+39
>>> 11e30
1.1e+31

Fakat...

>>> 11e308
inf

JavaScript (ve çok daha fazlası), 5 byte

44/44 veya

44/44 -> 1
44/4  -> 11
4444  -> 4444
4/44  -> 0.09090909090909091

CJam, 5

''''=

Çevrimiçi deneyin

''''=   compares two apostrophes and prints 1
'''=    prints '=
''''    prints ''

Lenguage , 5 bayt

00000

Programın uzunluğu, ,giriş karakterinin sonunu okuyan ve çıktısız sonlanan beyin programına karşılık gelen 5'tir .

Herhangi bir karakterin çıkarılması 0000, bir .karakteri (kod noktası 0) basan ve sonlanan brainf *** programına karşılık gelen 4 uzunluğa sahip kodla sonuçlanır .

Tekli eşdeğer olacak 0000000000000bir lider öne eklemek zorunda çünkü (13 sıfır) 1kodu böylece ikili uzunluğuna 101olur 1101.

PHP, 6 bayt

Bu grubu birkaç haftadır izliyorum ve programlama tekniklerinize hayran kaldım. Şimdi oturum açmak zorunda kaldım, yapabileceğim bir şey var, üzgünüm :-) Ancak, buradaki son mesajım olabilir ...

<?php 

(saniye sonra boşluğu not alın p)

Bu boş dize çıktılar. Herhangi bir karakterin kaldırılması, metni karakter olmadan çıkarır. HTML hataları üretebileceğini unutmayın (örneğin, tarayıcılar tarafından işlenmeyen içerik <?ph).

Ben de echoetiketi ile denedim . yani. Örneğin.:

<?= __LINE__;;

Bu bir çıktı 1. Eğer =atlanırsa, <? __LINE__;;verilir. Ancak, sihirli sabit karakterlerden herhangi birinin kaldırılması E_NOTICE ile sonuçlanacaktır : Notice: tanımsız sabit LNE kullanımı - içinde ' LNE ' olduğu varsayılır ...

Eğer uyarılar dikkate alınmaz hataları (kurallar noktası 4), bu da :-) uygular

Python, 10 8 bayt

256**.25

Python ve arkadaşlarıyla çalışır. Nasıl 2 bayt daha küçük yapmak için gösteren Jakube için teşekkürler.

IDLE'den:

>>> 256**.25
4.0
>>> 26**.25
2.2581008643532257
>>> 56**.25
2.7355647997347607
>>> 25**.25
2.23606797749979
>>> 256*.25
64.0
>>> 256*.25
64.0
>>> 256**25
1606938044258990275541962092341162602522202993782792835301376L
>>> 256**.5
16.0
>>> 256**.2
3.0314331330207964

Aslında bu vardı (10 bayt):

14641**.25

IDLE'den:

>>> 14641**.25
11.0
>>> 4641**.25
8.253780062553423
>>> 1641**.25
6.364688382085818
>>> 1441**.25
6.161209766937384
>>> 1461**.25
6.18247763499657
>>> 1464**.25
6.185648950548194
>>> 14641*.25
3660.25
>>> 14641*.25
3660.25
>>> 14641**25
137806123398222701841183371720896367762643312000384664331464775521549852095523076769401159497458526446001L
>>> 14641**.5
121.0
>>> 14641**.2
6.809483127522302

ve aynı notta:

121**.25*121**.25

Python'un güzel yuvarlaması nedeniyle aynı şekilde çalışır, 17 bayt.

>>> 121**.25*121**.25
11.0
>>> 21**.25*121**.25
7.099882579628641
>>> 11**.25*121**.25
6.0401053545372365
>>> 12**.25*121**.25
6.172934291446435
>>> 121*.25*121**.25
100.32789990825084
>>> 121*.25*121**.25
100.32789990825084
>>> 121**25*121**.25
3.8934141282176105e+52
>>> 121**.5*121**.25
36.4828726939094
>>> 121**.2*121**.25
8.654727864164496
>>> 121**.25121**.25
29.821567222277217
>>> 121**.25*21**.25
7.099882579628641
>>> 121**.25*11**.25
6.0401053545372365
>>> 121**.25*12**.25
6.172934291446435
>>> 121**.25*121*.25
100.32789990825084
>>> 121**.25*121*.25
100.32789990825084
>>> 121**.25*121**25
3.8934141282176105e+52
>>> 121**.25*121**.5
36.4828726939094
>>> 121**.25*121**.2
8.654727864164496

SWI-Prolog tercümanı

__A=__A.

Not: Finali kaldıramazsınız. . Prolog tercümanları, sorgunuzu çalıştırmak için daima son bir dönem arayacaklardır, bu nedenle bu yarışmanın kurallarına sıkı sıkıya bağlı kalacağız ve çalışmayan süreyi kaldırmamıza izin verirsek, bir satır atlayıp bir tane daha komutları bekleyecektir. bir süre ile sona erer.

Orijinal sorgu __A=__A.çıktı true..

Sorgu _A=__A.çıktılar _A = '$VAR'('__A'). Benzer modifikasyonlar (yani _ikisinden birinin veya birinin çıkarılması A) benzer çıktılara neden olacaktır.

Son olarak, sorgu __A__A.SWI-Prolog'da çıktı verir:

% ... 1,000,000 ............ 10,000,000 years later
% 
%       >> 42 << (last release gives the question)

Sed, 1 bayt

d

Gibi sedbir giriş akışı gerektirir, ben programın kendisi girdi olarak temin edilmelidir bir kongre teklif edeceğiz.

$ sed -e 'd' <<<'d' | wc -c
0
$ sed -e '' <<<'d' | wc -c
2

Alternatif bir programdır x, ama bu sadece gelen değişiklikleri 1için 2silindiğinde çıktı bayt.

K, 3 bayt

2!2

0REPL'deki çıkışlar . İlk 2 çıkışları çıkarılması 0 1, ünlem sonuçlar çıkarılması 22ve K uygulamaları arasında farklılık gösterir, fakat, her zaman en az 2 karakter bir dizi son 2 sonuçlar çıkarılması (OK olarak, bu kadar (2!); @Dennis Kona çıkışlara göre 2!).

MATLAB, 9 7 bayt

Diğer MATLAB / Octave cevabından 2 bayt daha uzun, ama yine de biraz daha karmaşık olduğu için hoşuma gidiyor.

Matlab'ın 'operatörü karmaşık konjuge transpozisyondur. Bunu skalar hayali bir sayı üzerinde kullanarak elde edersiniz i' = -i. Hayali sayılar basit 2ibir şekilde yazılabildiği gibi :

2i--2i'
ans =
     0    

Karakterlerden herhangi birini silmek aşağıdakilerden biriyle sonuçlanacaktır:

ans =
   0.0000 - 1.0000i
   2.0000 - 2.0000i
   0.0000 + 4.0000i
   0.0000 + 4.0000i
   0.0000 + 1.0000i
   2.0000 + 2.0000i
   0.0000 + 4.0000i

GolfScript, 2 bayt

Bu cevap rekabetçi değil, ancak bu zorluğa ilham veren bir kod parçası olduğu için yine de paylaşmak istedim.

:n

Varsayılan olarak, tüm GolfScript programları yığının tamamını, ardından yığının tamamını çalıştırarak satır beslemesi yapar puts. İşlev , gerçek bir yerleşik olan ve dizgiyi varsayılan olarak tutan bir değişken olan tercümandaki putsgibi uygulanır .{print n print}printn"\n"

Şimdi, bir GolfScript programı her zaman girişi yığıntaki STDIN'den iter. Bu durumda, herhangi bir giriş olmadığından, boş bir dize itilir. Değişken atama :n, boş nsatır dizisini gizleyerek, gizli satır beslemesini bastırarak ve çıktının tamamen boş olmasını sağlar.

Yok nederek, tamamlanmamış değişken atamasından vazgeçersiniz :(bunun bir sözdizimi hatası olduğunu düşünürsünüz ama hayır), bu nedenle örtük satır besleme her zamanki gibi yazdırılır.

Ortadan kaldırarak :, sen kalacaksın nyığın bir satır besleme iter, böylece program baskılar iki linefeeds hangi.

APL, J ve muhtemelen diğer varyantlar, 3 bayt

--1

Bu çıktılar 1APL içinde. -1çıkışları ¯1ve TryAPL'de-- aşağıdakileri çıkarır :

┌┴┐
- -

J, 5 bayt

|5j12

REPL'deki karmaşık sayının büyüklüğü 5 + 12i.

   |5j12 NB. original, magnitude of the complex number `5 + 12i`
13
   5j12  NB. the complex number `5 + 12i`
5j12
   |j12  NB. magnitude of the undefined function j12
| j12
   |512  NB. magnitude of 512
512
   |5j2  NB. magnitude of 5 + 2i
5.38516
   |5j1  NB. magnitude of 5 + 1i
5.09902

.

J, 9 bayt

%0.333333

Kayan nokta hassasiyetine dayanarak, karşılıklı ve matris ters.

   %0.333333 NB. original, reciprocal of 0.333333
3
   0.333333  NB. 0.333333
0.333333
   %.333333  NB. matrix inverse of 333333
3e_6
   %0333333  NB. reciprocal of 333333
3e_6
   %0.33333  NB. reciprocal of 0.33333
3.00003

Burada çevrimiçi deneyin.

Mathematica, 3 bayt

4!0

4!0  ->  0    the factorial of 4, times 0
4!   ->  24   the factorial of 4
40   ->  40
!0   ->  !0   the logical not of 0, but 0 is not a boolean value

Dyalog APL , 2 bayt

⍴0 boş bir dize döndürür (uzunluk 0)

⍴döner ⍴(uzunluk 1)

0döner 0(uzunluk 1)

Hızlı (ve çok daha fazlası), 8 bayt

93^99<84

çıkış (4 karakter):

true

N karakteri çıkarırken çıktı:

n -> out
----------
0 -> false
1 -> false
2 -> false
3 -> false
4 -> false
5 -> 10077
6 -> false
7 -> false

Biçiminde bunun gibi 78 olası çözüm vardır a^b<c.

Bence bu zorluğun amacı mümkün olduğu kadar çok bayt olmalı, çünkü ne kadar çok bayt, o kadar fazla byte kaldırılabilir ve bu nedenle daha zor.

MathGolf , 2 bayt

♂(

Çevrimiçi deneyin!

açıklama

♂   Push 10
 (  Decrement TOS by 1

Bu neden işe yarıyor?

Düzenli çıktı 9. Eğer (çıkarılır, çıkış ise 10'dur ♂kaldırılır program dolaylı beslemek için yığından 0 çıkar (ki çıkışları operatörü -1.

Clojure, 11 bayt

(defn x[]1)

İlk başta, REPL'de diğer dillerde olduğu gibi sadece tek bir karakter cevabı göndermeyi düşündüm.

user=> 1
1

Ancak sorun şu ki, eğer bu karakteri kaldırırsanız, REPL enter tuşuna basıldığında hiçbir şey yapmaz. Öyleyse bunun yerine, sorunun kuralları tarafından izin verilen bir fonksiyonla sarılması gerekiyordu. Bu işlevi çağırdığınızda, 1 değerini döndürür. İşlevdeki tek karakteri kaldırırsanız,

(defn x[])

işlev, niliki bayt daha basacak şekilde döner .

user=> (defn x[]1)
#'user/x
user=> (x)
1
user=> (defn y[])
#'user/y
user=> (y)
nil

05AB1E (eski), 1 bayt

[(Sonsuz döngü) hariç, 05AB1E'deki (eski) herhangi bir tek bayt işe yarar .

Tüm olası tek-byte 05AB1E programları için mümkün olan tüm çıktılara bakınız.

Tek bir baytı kaldırmak, böylece boş bir program kalır, info.txt içeriğini varsayılan olarak STDOUT'a gönderir.

Çevrimiçi deneyin.

05AB1E , 1 bayt

?

Çevrimiçi deneyin.

Ne yazık ki 05AB1E'nin yeni sürümündeki boş bir program varsayılan olarak yalnızca 1 baytlık yeni bir satır çıkarır ( çevrimiçi olarak deneyin ), bu nedenle 1 baytlık karakterlerin hiçbiri bir şey çıkarmayacaklarından neredeyse mümkün değildir. Hiçbir şey çıkaran tek olası program (bu yüzden örtük yeni çizgiyi de değil) ?bildiğim kadarıyla.

Japt , 2 bayt

AÉ

Çevrimiçi deneyin!

A10 ön-başlatılır, É1 çıkarır, ve sonuç 1 bayt olan: 9.

É'nin çıkarılmasıA , A'nın değerini veren programda sonuçları alır 10, böylece sonuç 2 bayttır.

Benzer şekilde, A'nın çıkarılması sadece É-1 olarak yorumlanır ve çıktısı olarak çıkar -1, böylece sonuç 2 bayttır.

Runic Enchantments , 6 (değiştirilebilir) bayt

11-{{B\
/B~~@/
\00<
R"Error"@

Çevrimiçi deneyin!

Runic, bir REPL ortamına sahip değildir ve kısıtlamaları karşılamak için tam bir program yazmak kolay değildir (geçersiz programlara ya da çıktılara yol açmaz). Böylece kodun bir kısmı 11-{{Bbir iç fonksiyon olarak hareket eder ve sadece bu kısım değiştirilebilir. BKullanıcı bir işlev işaretçisi ve bu sınıflandırma olarak kabul edilebilir olması gerektiği iade ifade yeterince yakın (bu kodun bir konuma IP atlar gibi aynı zamanda bir sonraki tarafından erişilebilen yığına bir dönüş konumunu bastırıyor Bya da atılması) .

• Standart çıktı: 0
• S'den birini çıkarma 1:05
• Çıkarma -:11
• İkisinden birini çıkarma {:Error051
• Çıkarma B:120

\İlk satırın sonundaki son , geri dönüş talimatının kaldırılması durumunda IP'nin her yerde kıvrımlı olmayacağı (ve çıktısı alınmadığı) için, iç fonksiyon etrafında bir dış sınır sağlar.

Bunun Error051yalnızca rastgele bir dize olduğunu unutmayın , kodun bu bölümüne istediğim her şeyi koyabilirim ve "Hata", dönüş koordinatlarını ve IP ışınlarını rasgele bir konuma yönlendiren kodun olması için eğlenceli bir sonuçtur.