Kod-Bowling

Brunswick Bowling tarafından, metinleri Code Bowlingekranlarında yazdırmak için basit bir program oluşturmak üzere işe aldınız . Bu şirket, güzel bir kuruş değer ve oldukça onları dolandırmaya hissediyorum biraz nakit.

Görev tanımı, puanlama bazında ödediklerini açıkça belirtiyor ve puanlama sistemlerini kendi avantajınıza göre ayarlayabileceğinizden ve bu adamlardan mümkün olan en büyük ödeme çekini alabileceğinizden oldukça eminiz. Bunu yapmak için , puanlama sisteminiz sizi engellemeniz için tasarlanmış olsa bile, programınıza / işlevinize mümkün olduğunca fazla kod koymanızı gerektirir .

Domuzcuk bankalarınızı çıkarın, haydi kod yazalım!

Meydan okuma

Buradaki zorluk, metni Code Bowling, tam olarak burada yazıldığı gibi, mümkün olan en yüksek puanla almaktır. (Bkz. Bölüm: Aşağıdaki Puanlama Sistemi )

Önde gelen ve takip eden yeni çizgiler (satır sonları) kabul edilebilir.

Kodunuz tüm bir program veya yalnızca çalıştırılabilir bir işlev olabilir.

kurallar

Zorunlu: Bu zorluk Kodu Bowling: Ortak Kural, Revizyon 1.0.0 ; Ayrıntılar için Meta'ya bakınız.

1. Karakter: Bayt Oranı
   Kod Bowling'inde bir bayt sayımı yerine karakter sayımı tercih edilir. Bunun açık bir nedeni, çok baytlık unicode karakterlerin (örneğin characters), bayt sayısını artırmak için tek baytlık unicode karakterleri yerine kullanılabileceği ve yüksek bayt unicode karakterleri olan en çok değişkenleri kimin yeniden adlandırdığı konusunda bowling yapmasıdır. En stratejik olarak anlamlı karmaşık kod oluşturanlardan.

2. Değişken / İşlev / Nesne Adları
   Tüm değişken adları (veya nesne işaretçileri, işlev adları vb.) 1 karakter uzunluğunda olmalıdır. 2 karakterli değişken adlarını kullanmak için sadece kabul edilebilir süre, tüm olası 1 karakterli değişkenlerin kullanılmasından sonradır. 3 karakterli değişken adlarını kullanmak için yalnızca kabul edilebilir süre, tüm olası 2 karakterli değişkenlerin kullanılmasından sonradır. Vb.

3. Kullanılmayan Kod
   Tüm kodlar kullanılmalıdır. Yani, herhangi bir karakter (veya değişken karakter karakterleri) kaldırılırsa / kaldırılırsa, programın görevi her zaman tam olarak yerine getirememesi gerekir. Doğal olarak, programın bir alt kümesi, programın geri kalanı olmadan görevi kendi başına tamamlayamamalıdır.

4. Yorumlar
   Programınız / işleviniz bir şekilde kullanılmadıkça karakter sayımı için yorumlara izin verilmez.

Skor sistemi:

  Pangram Mücadelesi:

Pangram , her harfi en az bir kere kullanan bir cümledir. (Hızlı kahverengi tilki tembel köpeğin üstünden atlar).

Bu meydan okuma tipi mükemmel pangram teorik maksimum puanı elde ediyorum tasarlanmış bir puanlama sistemi vardır (eğer olmadığı halde gerekli en azından her karakter kullanmak.) Ayrıca, bir cezaya maruz başlayacak defadan fazla herhangi bir karakter kullanılarak. Bu zorluk aynı zamanda sadece alfabetik karakterlerden daha da genişler.

  Puanlama Metriği:

1. Kullanılan her karakter 1 puanınızı artırır.
2. Herhangi bir alfasayısal karakterin (az, AZ, 0-9) tekrar tekrar kullanılması, tekrar başına 3 puan düşülmesine neden olur (ilk kullanım, bir kesinti ile sonuçlanmaz).
3. Temel noktalama işaretlerinin tekrar tekrar kullanılması ([!?.-,":';])- parantez dahil - tekrarlama başına 2 puan düşülmesine neden olacaktır.
4. {`~@#$%^&*_+=|\/><}Kıvrımlı parantez dahil - diğer ASCII karakterlerinin tekrar tekrar kullanılması, tekrar başına 4 puan düşülmesine neden olacaktır.
5. Boşlukların, sekmelerin ve yeni satırların kullanılması kullanım başına 1 puan düşülmesine neden olacaktır. Yani, karakter toplamına sayılmazlar.
6. Yukarıda belirtilmeyen karakterler (Egzotik Karakterler) kullanım başına 1 puan düşülmesine neden olacaktır. Yani, karakter toplamına sayılmazlar.

  Puanlama Aracı:

Bir otomatik skorlama Widget oluşturuldu ve bulunabilir burada .

Bu bir kod bovling çeşididir. En yüksek puana sahip program kazanır! (En fazla puan aldığı için 94, ilk önce kim ulaşırsa (ulaşılabilirse), diğerleri eğlence için cevap vermekte özgür olsalar bile, kabul edilen cevap olarak işaretlenecektir)

Glypho , 94

Kaynak dosya CP437'de kodlanmıştır .

␀␀!"☺☺#$☻♥♥☻♦♣♦♣%♠♠&•◘•◘'○○(◙♂◙♂♀♪♪♀♫☼♫☼►◄◄►↕↕)*‼¶¶‼§§+,▬↨↨▬↑↓↑↓→←→←∟∟-.↔▲▲↔/▼▼▼⌂Ç⌂Çüééüââ01ää23àååàçêçê4ëë5èïèïîî67ìÄÄì8ÅÅ9ÉÉ:;æÆÆæô<=ôöòòöûùûù>ÿÿÿÖÖ?@ÜÜAB¢££¢¥₧¥₧CƒƒDáíáíóóEFúññúѪѪGººHI¿¿J⌐¬⌐¬K½½½¼¼LM¡««¡N»»»░░OP▒▒QR▓││▓┤╡┤╡S╢╢T╖╕╖╕U╣╣V║╗║╗╝╜╜╝W╛╛╛┐X┐┐Y└└└┴┬┴┬├─├─Z┼┼┼╞╞[\╟╟]^╚╔╔╚╩╦╩╦_╠╠`═╬═╬╧╨╨╧╤╥╥╤a╙╙╙╘╘bc╒╒de╓╓fg╫╪╪╫┘┌┌┘█▄█▄▌hi▌▐j▐▐▀αα▀ßΓßΓπΣπΣkσσσµlµµτmnτΦΘΘΦΩδΩδo∞∞∞φpφφεεqr∩≡≡∩±±st≥≤≤≥u⌠⌠⌠⌡⌡vw÷xy÷≈°°≈∙∙z{·|}·√ⁿⁿ√~²²²

Çevrimiçi deneyin!

açıklama

Glypho bu gibi zorluklar için oldukça kullanışlıdır çünkü hiç kullanılmakta olan gerçek karakterleri önemsemez. Bunun yerine 4 karakterin her bir yığınına bakar ve kullanılan komut bu dört karakterin yaptığı kalıpla belirlenir:

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

Bu, sorunu sadece çözebildiğimiz ve sonra her dörtlüdeki benzersiz karakterleri yazdırılabilir karakterlerle ve tüm tekrarlananları ise puanlama tarafından göz ardı edilen "egzotik" karakterlerle doldurabiliriz. Glypho, normal bir el yazısı çözümünün, içinde yazdırılabilir tüm 94 yazıcıya sığacak kadar benzersiz karakter içerdiği konusunda yeterince ayrıntılı. Aslında, tamamen 94 olana kadar golf oynamayı bıraktım, böylece tekrarlananlar için benzersiz egzotik karakterleri kullanabildim (umarım, programı azaltmayı zorlaştırmak için).

Yukarıdaki programın kısa şekli şudur:

11+d*d*d+d+1+1+dd1+o
d+11+d*d1+*1+-+do
11+d*d1+d**do
1+o
11+d*d*d+o
<o
ddo
11+d*d++o
111++d-<+ddo
<-+do
<1+1+o
1-+1-+o

Her satırın karakterlerden birini yazdırdığı yer.

Ben kullandım bu Retina senaryoyu kullanarak Glypho dönüştürmek için 0123. Daha sonra, rakamların yerine karakterleri doldurdum.

Teorik olarak, eğer birileri steno programında golf oynamayı başardıysa ve sonra doğru kalıpları gösterecek şekilde karakterleri birleştirmeyi başardıysa, bunu daha da azaltmak mümkün olabilirdi, ancak bunun mümkün olduğunu nasıl ispatlayacağımı veya ispatlayacağından emin değilim. . Herhangi biri programımın bir alt kümesinden geçerli bir çözüm oluşturmayı başarırsa, lütfen cevabı düzeltinceye kadar silebilmem için bana bildirin. O zamana kadar bunun geçerli olduğunu kabul etmek zorunda kalacağım.

Python 3, 82 87 88

@JonathanAllan +1 puan için teşekkürler

print("g!#$%&'*n+,./012i34579;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ ^_`abchejkmqsuvdyz{|}~ \x6f       C"[::-8])

Çevrimiçi deneyin!

Özel bir şey yok, sadece karakterleri dilimlemek ve atlamak. Dize ters çevrilir, böylece karakterleri kaldıramazsınız ve orijinal dizgenin yazdırılmasını sağlayamazsınız.

> <> , 92 94

Evet, yaptım!

␑Ondalık değeri 17 olan egzotik karakterdir \x11. Program sonucu yazdırdıktan sonra bir hata ile çıkar (bu bir yığın akışıdır). Hangi aynaları ve yön komutlarını dikkatli kullandım, her birini yalnızca bir kez kullanabildiğim için yönetmek zorunda kaldım.

   >"vCoUV␑3`h]Z_X
       /a[f+
#$%&'r(!
.0456~8?
:;<=@9l)
ABDEFcGe
HIJKL*
MNOPQ7
RSTWYd
bgijk1
mnqst-
uwxyz2
{|}  ,
     \p^

Çevrimiçi deneyin

Çekirdek programı:

   >"vCoUV␑3`h]Z_X
       /a[f+
     r !
     ~ ?
     9 )
     c e
     *
     7
     d
     1
     -
     2
     ,
     \p^

Açıklama:

Dize basın vCoUV␑3`h]Z_X >(yürütme tamamladı). Aşağı doğru hareket et. Yığını ters çevirin ve çıkarın v.

9Ve c(12) düğmelerine basın . Almak için çarpın 108( l). İttir 7. İt d(13), çıkarmak 1, 2almak için bölün 6. lAltındaki (13,6) (x, y) yerine koyun e. Bu şekilde daha kısa yapabilirdim, ama bu uzatıldı, bu yüzden daha fazla ASCII karakteri koyacak yerim var.

Bir döngü içine yukarı hareket ettirin. Yığın uzunluğu ile itin l. 14'ten büyükse, çıkış karakteri, aksi takdirde ilk 10 öğeye sahip yeni bir yığın oluşturun, sonra 15 ekleyin, ardından yürütmeyi yansıtın, sonra da çıktısını alın. Bu, fazladan boşlukların ve >sonunda yazdırılmasını önlemek ve rastgele görünümlü ipi yazdırılması gerekenlere dönüştürmek için kullanılır. Dönmeye devam et.

Çizgilerden herhangi biri daha kısa ise (bir karakter kaldırılarak), programın dikey kısımları artık hizalanmadığından veya yazdırılacak dizginin artık doğru olmadığından program çalışmayacaktır. Her satırın önünden bir karakter çıkarmaya çalışmak, yığın derinliğini ve lyerleştirildiği yeri değiştirerek sorunlara neden olur.

^_Balık

Octave, 20 21 22 25 27 33

Şu ana kadar idare ettiğim en iyisi

g=@()disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0));

Bu, fgiriş yapmayan anonim bir işlev oluşturur . Arayabilirsin f(). İşlev gövdesinin yazdırılmasını önlemek için, sonunda noktalı virgülün gerekli olduğunu söyleyebilirim.

Bu evalve birleştirme ile geliştirilebilir printf, ancak tekrar tekrar denedim ve başarısız oldum.

Bu, tüm basamakları bir kez kullanır; Octave'in mod(x,256)sayıları karakterlere dönüştürürken bir işlem gerçekleştirdiğini açıklar . Bu, normal sayıların dışındaki negatif sayıların yanı sıra sayıları da kullanabileceğimiz anlamına gelir 32-126. Aşağıdaki sayılar her harfi neden ikarakterlere dönüştürüldüğünde: ... -2455 -2199 -1943 ... 105 361 .... 'owling'Sonunda kullanmak yerine "nvkhmf"1 ekleriz ve ekleriz. Bu, dolaylı olarak karakterlere dönüştürülen bir tam sayı vektörü oluşturur. Bunun yerine, 1kullanıyoruz !0(veya not(false). Ayrıca, iki ceza puanından kaçınmak "yerine kullanıyoruz '.

En düşük puanı veren sayıları bulmalıyız. Dize Code Bowling, çıkardığımız ve -10 * 256 - 10 * 256 eklediğimizde, aşağıdaki matrisle sonuçlanır.

  -2493  -2449  -2460  -2459  -2528  -2494  -2449  -2441  -2452  -2455  -2450  -2457
  -2237  -2193  -2204  -2203  -2272  -2238  -2193  -2185  -2196  -2199  -2194  -2201
  -1981  -1937  -1948  -1947  -2016  -1982  -1937  -1929  -1940  -1943  -1938  -1945
  -1725  -1681  -1692  -1691  -1760  -1726  -1681  -1673  -1684  -1687  -1682  -1689
  -1469  -1425  -1436  -1435  -1504  -1470  -1425  -1417  -1428  -1431  -1426  -1433
  -1213  -1169  -1180  -1179  -1248  -1214  -1169  -1161  -1172  -1175  -1170  -1177
   -957   -913   -924   -923   -992   -958   -913   -905   -916   -919   -914   -921
   -701   -657   -668   -667   -736   -702   -657   -649   -660   -663   -658   -665
   -445   -401   -412   -411   -480   -446   -401   -393   -404   -407   -402   -409
   -189   -145   -156   -155   -224   -190   -145   -137   -148   -151   -146   -153
     67    111    100    101     32     66    111    119    108    105    110    103
    323    367    356    357    288    322    367    375    364    361    366    359
    579    623    612    613    544    578    623    631    620    617    622    615
    835    879    868    869    800    834    879    887    876    873    878    871
   1091   1135   1124   1125   1056   1090   1135   1143   1132   1129   1134   1127
   1347   1391   1380   1381   1312   1346   1391   1399   1388   1385   1390   1383
   1603   1647   1636   1637   1568   1602   1647   1655   1644   1641   1646   1639
   1859   1903   1892   1893   1824   1858   1903   1911   1900   1897   1902   1895
   2115   2159   2148   2149   2080   2114   2159   2167   2156   2153   2158   2151
   2371   2415   2404   2405   2336   2370   2415   2423   2412   2409   2414   2407
   2627   2671   2660   2661   2592   2626   2671   2679   2668   2665   2670   2663

Böylece, ['',2627 2415 2148 1893 -2528 66 -1169 -1161 2668 105 -146 103]sonuçlanır ans = Code Bowling. Bu durumda zorluk, puanı en çok azaltan sayı ve karakter kümesini bulmaktır. Tüm rakamları kullanmak elbette iyidir, fakat kopyalar kötüdür. Tüm rakamlar kullanıldığından ve iki kez kullanılmadığından, bu mümkün olan en iyi karışımdır. Ayrıca -bir noktayla sonuçlanan kullanacağız .

Birisi, altındaki çizgiye indirgenebileceğini iddia edebilir (31 puan), ancak daha sonra artık bir "çalıştırılabilir işlev" olmayacaktı ve bu nedenle farklı bir işlevselliğe sahip olacağını söyledi.

disp(horzcat([67 9583 -412],'e B',"nvkhmf"+!0))

QBasic, 34

Bu biçimlendirilmemiş koddur (büyük küçük harfe duyarsızlık için yay). Bunu QB64'te veya archive.org'da çalıştırabilirsiniz (ikincisinin kodu yazarken biçimlendireceğini unutmayın). Ben düşünüyorum ben bütün kurallara uymak başardınız.

CLS
PrINT "C
LOcatE 1, 2 : ? CHR$(957-846); "de Bowling

Bu CLSgereklidir: onsuz C, ekranın sol üst köşesine, aynı hizada olacakları yerde basmaları garanti edilmez ode Bowling. LOcatEGereklidir: o olmadan ode Bowlingaşağıda satırda basılacaktır C. Silinebilen ve aynı çıktıyı tutabilen programın herhangi bir alt kümesinin (boşluk hariç) olduğuna inanmıyorum.

C, 27 29

@Ceilingcat sayesinde +2 puan!

f(){char q<:]="Code B\157wling";puts(q);%>

Haskell , skor 21 38 46 47 21 70

putStr$toEnum(length"!#%&'*+,-./012345789;<=>?@ADGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~"):"ode B\x6Fwling"

Çevrimiçi deneyin! Buradaki fikir, Cbaşka türlü kullanılmayan karakterleri içeren ve bu dizenin uzunluğunu bir karaktere dönüştüren bir uzunluk 67 dizisi oluşturarak öncü olmaktır. İle başladım putStr$toEnum(length""):"ode B\x6Fwling"( verim '\x6F'onaltılı ) ve programda '\111'bulunmayan 'o'tüm yazdırılabilir ASCII karakterlerini hesapladım:

!#%&'*+,-./012345789;<=>?@ACDGHIJKLMNOPQRTUVWXYZ[]^_`abcfjkqsvyz{|}~

Bu arada, dizgeye girebilecek tam olarak yazdırılabilir ASCII karakterleri ve dizgede Cgörünmeyen tam olarak kalıyor, çünkü program sadece indirgenebilir putStr"Code B\x6Fwling".

Önceki çözüm: (puan 21)

f|x<-'C'=mapM putStr[(:)x"ode Bowling"]

fGirdi almayan ve dizeyi basan bir işlev tanımlar . Çevrimiçi deneyin!

JavaScript, 19

prompt('C\157de B\x6fwlin'+"g")

Çok yüksek bir skor değil.

Jöle , 94

“!#"$&('*)+-/,13.0456:79<;>=@B?ADFHJLNCPRTEVXZ\G^IKMQ`SWbY[]d_acfhjegliknmprotquvxwy{z}¹|³⁵⁷~°⁹⁻”O%2s8UḄỌ

Çevrimiçi deneyin!

105 benzersiz karakter, 11 ekzotiği ( “¹³⁵⁷°⁹⁻”ḄỌ).

Nasıl?

Her bitin bir karakterin Unicode değerinin LSB'si kullanılarak kodlandığı 8-bit ters ASCII'den dize oluşturur.

“...”O%2s8UḄỌ - Main link: no arguments
“...”         - the string enclosed            !  #  "  $  &  (  '  *  )  +  -  /  ,  1  3  .  0  4  5  6  :  7  9  <  ;  >  =  @  B  ?  A  D  F  H  J  L  N  C  P  R  T  E  V  X  Z  \  G  ^  I  K  M  Q  `  S  W  b  Y  [  ]   d  _  a  c   f   h   j   e   g   l   i   k   n   m   p   r   o   t   q   u   v   x   w   y   {   z   }   ¹   |   ³    ⁵    ⁷   ~   °    ⁹    ⁻
     O        - cast to ordinal (vectorises) [33,35,34,36,38,40,39,42,41,43,45,47,44,49,51,46,48,52,53,54,58,55,57,60,59,62,61,64,66,63,65,68,70,72,74,76,78,67,80,82,84,69,86,88,90,92,71,94,73,75,77,81,96,83,87,98,89,91,93,100,95,97,99,102,104,106,101,103,108,105,107,110,109,112,114,111,116,113,117,118,120,119,121,123,122,125,185,124,179,8309,8311,126,176,8313,8315]
      %2      - mod 2 (vectorises)           [ 1, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1,  0, 1, 1, 1,  0,  0,  0,  1,  1,  0,  1,  1,  0,  1,  0,  0,  1,  0,  1,  1,  0,  0,  1,  1,  1,  0,  1,  1,  0,  1,   1,   1,  0,  0,   1,   1]
        s8    - split into chunks of 8       [[1,1,0,0,0,0,1,0], [1,1,1,1,0,1,1,0], [0,0,1,0,0,1,1,0], [1,0,1,0,0,1,1,0], [0,0,0,0,0,1,0,0], [0,1,0,0,0,0,1,0], [1,1,1,1,0,1,1,0], [1,1,1,0,1,1,1,0], [0,0,1,1,0,1,1,0], [1,0,0,1,0,1,1,0], [0,1,1,1,0,1,1,0], [1,1,1,0,0,1,1]]
          U   - upend (vectorises)           [[0,1,0,0,0,0,1,1], [0,1,1,0,1,1,1,1], [0,1,1,0,0,1,0,0], [0,1,1,0,0,1,0,1], [0,0,1,0,0,0,0,0], [0,1,0,0,0,0,1,0], [0,1,1,0,1,1,1,1], [0,1,1,1,0,1,1,1], [0,1,1,0,1,1,0,0], [0,1,1,0,1,0,0,1], [0,1,1,0,1,1,1,0], [1,1,0,0,1,1,1]]
           Ḅ  - binary to int (vectorises)   [67, 111, 100, 101, 32, 66, 111, 119, 108, 105, 110, 103]
            Ọ - to character (vectorises)    ['C', 'o', 'd', 'e', ' ', 'B', 'o', 'w', 'l', 'i', 'n', 'g']
              - implicit print               Code Bowling

Röda , 33

{["ode B\x6fwling"]|push chr(3*4+57-2).._}

Çevrimiçi deneyin!

Tüm kuralları takip etmeye çalıştım. İlk önce ipi ode Bowling!akışa iterek ve sonra C= 3 * 4 + 57-2'yi öne doğru sokarak çalışır .

Kardinal 20

23 boşluk olmayan karakterler
% #> / NI "CodeB8 ^ o) wl, ing

Tekrarlanan "o" için -3

   I
 >\/N
%# "CodeB
 8^o
 ) w
   l
 , i
   n
   g

İşaretçi yolları:

Adım 1:
İşaretçi% oranında yaratıldı

Adım 2:
İşaretçi yukarı, aşağı ve yukarı gitmek için # işaretine böler (P1, P2, P3)

Adım 3 :
P1> Gönderen sağ>
P2 Sağa
gitme P3 8'te 3 adım bekleyin Set

Adım 4:
P1 \ ile aşağı yansıtılır. \ / /
P2 olarak değiştirildi. Baskı moduna ayarla "
P3 8'de 2 onay bekle

Adım 5:
P1 Aşağıya
Gitme P2 Yazdır C
P3 8'de 1 onay bekleyin

Adım 6:
P1 Gönderen ^
P2 Yazdır o
P3 Devam etmeyi bekle, "" (32) ASCII değerini al)

Adım 7: P1 Yukarı
Git P2 Baskı d
P3 Aşağı doğru Git

Adım 8: P1 / tarafından değiştirilen sağa yansıtılır /
P2 Yazdırma e
P3 ASCII değerine sahip yazdırma karakteri = işlemden 32

Adım 9:
P1 \
P2 tarafından değiştirildi / yansıtıldı Yazdır B
P3 Alanın sonuna ulaşıldı ve durdu

10. Adım:
P1 I
P2 tarafından yansıtıldı Alanın sonuna ulaşıldı ve durdu

Adım 11:
P1 \ tarafından değiştirilen sağ / tarafından yansıtılır. / Olarak geri dönüş

Adım 12:
P1 N'den sola yansır

Adım 13:
P1 / tarafından aşağı yansıtıldı

Adım 14:
P1 Yazdırma moduna ayarlayın "ile

Adım 15:
P1 Yazdır o

Adım 16:
P1 Baskı w

Adım 17:
P1 Yazdır l

Adım 18:
P1 Yazdır i

Adım 19:
P1 Baskısı n

Adım 20:
P1 Yazdır g

Adım 21:
P1 Alanın sonuna ulaşır ve durur.

Çevrimiçi Deneyin

C, 73

@Laikoni'ye teşekkürler!

F(){printf("Code B\157wli%cg",48+strlen("!#$&'*-../2369:<=>?@ADEGHIJKLMNOPQRSTUVWXYZ[]^_`abhjkmquvxyz|~"));}

Çevrimiçi deneyin!

C,  31   33  35

F(){printf("Code B\157wli%cg",96|0xD+3*4/8);}

@Ceilingcat ve @DLosc için iki puan daha, @ Ørjan Johansen, iki puan daha için teşekkürler!

Çevrimiçi deneyin!

Toplu iş, 19 karakter

@echO(Cod%TMP:~5,1% Bowling

Windows Vista ile başlayarak, TMPile başlar C:\Users\ve bu nedenle %TMP:~5,1%yazının bir ayrıntılı bir yoldur ebir duble gerektiren rağmen %-4 cezası.

Brainfuck: -204

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

Eh, korkunç puan, ama yazmak için eğlenceliydi.

• 122 karakter uzunluğunda
• tekrarlanan alnum: -0 ()
• tekrarlanan noktalama işaretleri: -134 (- [---]. ----------- ..-- [---] -. [-] .- [---] ..-- ---------. --- ..-------.)
• tekrarlanan diğer: -192 (+++++++> +> + <> ++++> + <> +> ++ <>> + <> +++++++++++++++ ++++)
• boşluk karakterleri: -0 ()
• egzotik karakterler: -0 ()

Java 8, 2 3 5 13 17 18 19 20 21 24 77 78 puan

@Likonik sayesinde +53 puan (24 → 77) .

v->(char)"!#$%&'*,/0234689:;<=?@ADEFGHIJKLMNOPQRSTUVWXYZ[]^_`bfjkmpqsuxyz{|}~".length()+"\157de Bowling"

104 karakter uzunluğunda
- tekrarlanan alnum: -15 ( helng)
- tekrarlanan noktalama işaretleri: -10 ( "()"")
- tekrarlanan diğer ASCII: none
- boşluk karakterleri: -1
SCORE: 78

Çevrimiçi deneyin.

Eski 24 baytlık cevap:

v->"C\157de Bowlin"+(char)103;

30 karakter uzunluğunda
- tekrarlanan alnum: -3 ( 1)
- tekrarlanan noktalama işaretleri: -2 ( ")
- tekrarlanan diğer ASCII: yok
- boşluk karakterleri: -1
SCORE: 24

Çevrimiçi deneyin.

yığılmış , 42

(67:43,1 ab)2 9*pf sum 8/0\|>+chr'de Bowling',EPS#`

Çevrimiçi deneyin!

Yığında çıktı bırakır. İşte dağılım:

length: 51
repeated alnum:        -0 ()
repeated punct:        -4 (',)
repeated other:        -0 ()
whitespace characters: -5 (     )
exotic characters:     -0 ()
total score: 42

Muhtemelen daha yüksek yapabilirim, ama saat 42'de ...

Başka bir rakip, 40:

(67:43,sum)9 pf 2%MIN 0\|>+chr'de Bowling',EPS#`

Bu senaryoyu puanlamak için kullandım.

kötülük , -81

Brainfuck'tan daha iyi!

aeeaeuwkaaeeuwygaeaeclaaxjlwalusbdgueuewguwpweewpuuuwuuuwpuweew

açıklama

aeeaeuw //Write 'C'
k       //Set P[0] to 'C'
aaeeuw  //Write 'O'
y       //Set W[0] to 'O'
gaeae   //Set Accumulator to 'D'
claa    //Create new Wheel cell at index 0, swap with Accumulator, add 2
xj      //Set alternate marker mode and drop marker
lwa     //Write value of W[0], add 1
lu      //Put it back, subtract 1 from Accumulator
sb      //Go to 'j' if Accumulator != 0
d       //Delete W[0]
        //The above loop writes 'D' and 'E'
gueuew  //Write ' '
guw     //Write 'B'
pw      //Write 'o'
eew     //Write 'w'
puuuw   //Write 'l'
uuuw    //Write 'i'
puw     //Write 'n'
eew     //Write 'g'

Gönderildi çünkü kimse kötülükte bir şey yapmıyor, ama bu eğlenceli.

Puan:

Uzunluk = 63

a*8  = -24
e*12 = -36
g*2  = -6
l*2  = -6
p*2  = -6
u*12  = -36
w*10  = -30

Çevrimiçi deneyin!

EDIT: TiO yeni Tekerlek hücrelerinin oluşturulmasını ve silinmesini yanlış ele alıyor gibi görünüyor - konuyla ilgili bir hata raporu hazırladım. Orada düzgün çalışmayacak, ama kendi tercümanımda koştum ve işe yarıyor ve bana güvenebilirsin, bu yüzden endişelenmemek için;)

Perl: 29 , 33

$_=OWLING;printf%s,"C\157de".chr(30+8/4).B.lc

Puan:

- 46 characters long
- repeated alnum:       -6 (rc)
- repeated punctuation: -6 ("..)
- repeated other:       -0 ()
- whitespace characters:  -1 (
)
- exotic characters:  -0 ()

Total score: 33

05AB1E , 94 puan

”X1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"”€a7ôJCç€?

Çevrimiçi deneyin!

- 100 characters long
- repeated alnum:       -0 ()
- repeated punctuation: -0 ()
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -6 (””€ôç€)

Total score: 94

Temelde dönüştürür (Code Bowling'in İkili ASCII'si):

['1000011', '1101111', '1100100', '1100101', '0100000', '1000010', '1101111', '1110111', '1101100', '1101001', '1101110', '1100111']

1 ve 0'dan oluşan bir dize içine, her biri 1 harfini alfabedeki bir harfle ve her 0 ise boşluk karakteri veya bir sembol veya rakam ile değiştirir.

”X1234bcde5fghijk68l9<mn>,o.p|q\/{})r(_-+s=tu*vwxyzAB&YDEFG^HI%$ZK#L@!MNO~PQR`ST':UVW[0];"”

1'in harfleri ve 0'ların sembolleri, sayıları veya başka herhangi bir şey olduğu dizedir. Daha sonra alfabetik olarak 0 için 0'a basarak hangisinin alfabetik olduğunu görerek yineliyoruz. Daha sonra 7 gruba ayrıldık, tekrar ASCII'ye dönüştürdük ve her karakteri yazdırdık.

T-SQL, 65 18 32! makas

PRINT char(78-9605*43%12) + 'ode Bowling'

Dlosc'un QBasic cevabındaki hileden esinlenerek , 10 basamağın tümünü ve matematiksel operatörlerin çoğunu dahil etmenin bir yolunu buldum ( %geri kalan / modulo, yalnızca eksik /), çoğunlukla deneme yanılma yoluyla. Ben yok düşünüyorum rakam / semboller herhangi bir kombinasyonunu kaldırarak bir 67 almak için herhangi bir yolu yoktur, ancak Deneyebilirsiniz.

Sürüm 2 (18 puan, önemsiz):

DECLARE @ char(12)='Code Bowling'PRINT @

Harika bir skor değil, fakat ilk sürümüm basitleşti (teşekkürler MickyT). Çalıştığım her şey (hex64'ü kodlamak ve kodunu çözmek, dizgeden ayrı elemanları seçmek, ASCII değerlerini dönüştürmek, vb.) Hepsinde, onu eksiğe dönüştüren çok sayıda tekrarlanan karakter (özellikle ECRve semboller (),@) vardı.

Sürüm 1 (65 puan, geçersiz):

DECLARE @ char(123)=
'Code Bowling FGHJKMOQSUVWXYZbjkmpqsuvxyz045789 [!?.-":;]{`~#$%^&*_+|\><}'
PRINT left(@,LEN(@)/6)

Sol taraftan kaç karakter kullandığımı belirlemek için dizenin uzunluğunu kullandım, bu nedenle dizgiden tek bir karakterin çıkarılması , tamsayı bölme sonucunu yalnızca çıktı olarak 11'e düşürecek Code Bowlin.

; # , skor -1163, rekabet etmeyen

Rekabet edebilse bile bunun fazla rekabet olacağını düşünmüyorum.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;#

Çevrimiçi deneyin! Not: TIO'da; # # tercüman yoktur, sadece; # +.

CJam , skor 47

"'#?GyQ2wE(s6&␟JI!gF$u*Aq;0p4BvOKkHLhM"3/{:i~-z+c}%

Umarım bu konuda sorun yok ...

Bir egzotik karakter kullanır (Birim Ayırıcı, ASCII 31, ile temsil edilir ␟) ve bir tekrarlanan karakter ( "). Daha uzun süre yapılabileceğini düşünüyorum, ancak şimdilik olduğu gibi bırakacağım.

Çevrimiçi deneyin!

Program bu uzun dizeyi alarak ve uzunluğu 3 alt dizgeye bölerek çalışır. Her alt dizgi daha sonra karakterlerini ASCII değerlerine dönüştüren, değerleri yığına döken, ikinci ikisinin mutlak farkını alan, sonucu birinciye ekleyen, daha sonra bir ASCII'ye dönüştüren bloğa eşlenir karakter.

CJam, skor 93

"g!#$&'()n*+/0134i5689:;<l=>?@ADEwFGHIJKLoMNOPQRSBTUVWXYZ [\]^_`aebcfhjkmdqrstuvxpyz{|}  C"7~%2,.-

Çevrimiçi deneyin

TidB'nin Python cevabından ilham aldı .
Çift tırnakların tekrarlanmasından kaçınmanın bir yolu olup olmadığından emin değilsiniz.

Açıklama:

Dize, her 8 karakterden birinde ters "Cpde Bowling" içerir.
7~%"Cpde Bowling" ( 7~= -8) ayıklar
2,.-p karakterini ( 2,= [0 1]) azaltır

PHP, 33 puan

Bu gelip oldukça zordu.

Skor gelecekte kanıtlanmış olabilir.

<?echo IHASZODECG9F^"
'%6z\r+2/.W!";

Newline, Linux tarzı bir newline olarak kabul edilir! Windows tarzı ve Eski Mac Tarzı düzgün çalışmayacak.

Ruby, 75

Yaklaşık olarak Python'un bir bağlantı noktası yanıtlıyor, ancak Ruby'nin kullandığı harika adım işlevi yok gsub. Ayrıca egzotik karakterlerle Google Translate'e cümleler ekleyerek biraz eğlenmeye karar verdim.

Çevrimiçi deneyin!

print"Cachjkmq\x6fvyzADEFdGHIJKLMeNOPQRST UVWXYZ0B234589[o!?-:;]`w~@\#$%^&l*_+=|><i コードゴルフn 代碼保齡球 gκωδικός".gsub /(.).{7}/,'\1'

USML, 12 veya 9 puan (yarışmaz)

"Code\tBowling'

Çevrimiçi deneyin!

Bu cevap, HTML'nin nasıl işlendiğini kötüye kullanarak biraz hile yapıyor. Aslında bu tarafından oluşturulan dize "Code\tBowling ". "O" karakterini tekrarlamak için puanlar kaybolur.

Hile yapılmayan bir cevap için:

"Code Bowling

USML hala gelişme aşamasında oldukça erken ve programın boyutunu daha da artırabilecek durumda değil.

Cubix , 85

Codeha1spqumtr;$"gnilwoB"Sv"ADEFH%IJK2f!OPUzQ0V3XY&*[-|L:]\T`~#x>MR56cGk'?W<()b4j}.{Z_^/978@

Çevrimiçi deneyin!

Yerine, önemsiz karakterlerle kübrasyon yapıldı.

        C o d e
        . . . .
        . . u . 
        . . ; . 
" g n i l w o B " S v " . . . .
. . . . . . . ! . . U . . . . .
. . . . . . . L . . \ . . . . .
> . R . . . . . . . W < . . . .
        . . . {
        . . ^ /
        . . . @
        . . . .

Sanırım yolu kaldırmak, karakterleri kaldırmak çok zor kıracak.

Çalıştırılmasını izle

- 92 characters long
- repeated alnum:       -3 (o)
- repeated punctuation: -4 ("")
- repeated other:       -0 ()
- whitespace characters:  -0 ()
- exotic characters:  -0 ()

Total score: 85

VB.net, 68

cONSOLE.WRITE("Code BowlingADEFGHJKQUVXYZfhjkmpqyz`!@#$%^&*9876543~][{}\|';:<>?+=-_".subStrinG(0,12))

VB'nin duyarsızlığına ve “sisteme” ihtiyaç duymama durumuna büyük önem veren hızlı bir test.

Kabuk: 17 puan

#!/bin/bash
echo "CODE BoWLING" | tr D-X d-x

• 44 karakter uzunluğunda
• tekrarlanan alnum: -12 (bhoD)
• tekrarlanan noktalama işaretleri: -4 ("-)
• diğer tekrarlanan: -4 (/)
• boşluk karakterleri: -7 ()
• egzotik karakterler: -0 ()

Toplam puan: 17

Acc !! , 171 karakter

119
Write _-52
Write _-8
Count i while i-2 {
	Write _-19+i
}
32
Write _
_+34
Write _
_+45
Write _
_+8
Write _
_-11
Write _
Count i while i-2 {
	Write 105+i*5
}
_-5
Write _

Çevrimiçi deneyin!

Acc !! boşluk için gerekli ve döngüler maliyetli olduğu için bu zorluk için iyi çalışır. Karakterleri arttırmak için Acc umulator'ı kullandım ama çok zayıf bir şekilde kullandım. Sayfadan kısa bir genel bakış:

AccumulatorTek başına duran herhangi bir ifade değerlendirilir ve akümülatöre atanır (ki bu şekilde erişilebilir _). Böylece, örneğin 3, akümülatörü 3'e ayarlayan bir ifadedir; _ + 1 akümülatörü arttırır; ve _ * N bir karakter okur ve akümülatörü karakter koduyla çarpar. (N giriş yapar)

Write <charcode> Verilen ASCII / Unicode değerine sahip tek bir karakteri stdout'a verir. Karakter kodu herhangi bir ifade olabilir.

Acc'deki döngüler, en azından golf oynamak için acı vericidir. Diş telleri gerektirirler ve tüm boşluklar gereklidir. Aksi halde açıklayıcıdır.