Bu komikti! Ancak, yalnızca üç basamaklı, eğlence çok yakında sona erdi. Bu zorluk benzer, ancak eğlenceyi devam ettireceğiz.

Meydan okuma

Altın Oranın birçok basamağını yazdır dig . Altın Oran, φ = (φ + 1) / φ değerini karşılayan ve ilk 100 basamağı veren sayı olarak tanımlanır:

1,6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375 ...

Bu zorluk bilgisayarla ilgili değil φ! Bunu iki kez yapmak için herhangi bir yöntem kullanmadan mümkün olduğu kadar çok rakam yazdırmakla ilgilidir. Bu nedenle rakamlarınızı olabildiğince almanın yaratıcı yollarını bulun!

Kısıtlamalar

Tek başına φ basamağını yazdırmak biraz fazla basit olurdu, işte kurallar:

1. Sayıyı soldan sağa sırayla , parça parça yazdırarak veya soldan sağa bir dize oluşturarak ve sonunda yazdırarak yapmanız gerekir - hatta bir rakam karakteri dizisi oluşturabilir ve sonra birleştirebilir ve sırayla yaptığınız sürece yazdırın. Aşağıdaki kurallarda "print" ve "output" bu işlemlerin herhangi birine atıfta bulunabilir (örneğin, bir dize oluşturuyorsanız ve dize sahip 1.6olduğu gibi sayar.1.6 zaten yazdırılmış ).
2. Kodunuz için rakam başına 15 karakterlik bir bütçe elde edersiniz . Dönem bu bütçeye göre sayılmaz, aynı zamanda basılması da gerekir. Kısıtlamanın yalnızca toplam kod boyutunda olduğunu unutmayın: Ortalama olarak daha fazla kullanmadığınız sürece herhangi bir rakam için 15'ten fazla karakter kullanabilirsiniz. Aslında, karakterlerde bir "borç" oluşturabilir ve daha sonra "öder". Örneğin yazdırmak 1.618için 60 karakter var.
3. Standart kütüphane içerir / alır kod boyutuna sayılmaz. Ama bu kestirme takma adları ücretsiz olarak veremezsiniz!
4. Şu anda oluşturduğunuz rakamı veya daha önce yazdırdığınız rakamları kullanmamalısınız. Örneğin 1, kaynak kodunuzda hiçbir yerde görünmeyebilir, çünkü ilk basamaktır. Çıktılar kod 8in 1.618basamak herhangi birini veya tümünü kullanabilir [0234579], ancak hiçbiri [168]. Bu amaçla, tek bir haneye eşdeğer tüm değişmezler bu basamak olarak değerlendirilir . . Yani eğer diliniz temsil edebiliyorsa 9, '\t'onu kullanamayacağınız herhangi bir yerde kullanmanıza izin verilmez 9.
5. Aynı anda birden fazla rakam üretmemelisiniz. Kodunuzu bir seferde bir rakam üreten parçalara açıkça ayırmanız mümkün olmalıdır.

6. Daha önceki bir basamağı oluşturan kodda kullandığınız herhangi bir yerleşik fonksiyon, matematiksel / boolean / bit bilge / string operatörü, değişken veya sabiti ifade etmemelisiniz . İstisnalar, tam sayıdan dizeye dönüştürme, dizgiyi birleştirme ve her basamak için gerekebilecek yazdırma işlevleridir. O hangi önemli değil Not adı başvurmak herhangi yerleşik: Yalnızca size çünkü takma adı, dahili PIhem pve qkullanmak anlamına gelmez pkez ve qbir kez. Aynı şekilde, vardır o dize gibi iki farklı dahili ins atıfta eğer iki kez bir isim kullanmasına izinlength ve dizinin length.

   _{Programlama dilinizde işlevler yoksa, eşdeğerin ne olacağına dair en iyi kararınızı kullanın - örneğin bash komut dosyası için, diğer programları çağırmak, işlevlere uygulanan kuralları takip etmelidir.}

7. Gönderiniz tek dilde yazılmalıdır. Bu yüzden o dilin yerleşiklerine erişmek için başka bir dilin tercümanını çalıştırma.

etkileri

Aşağıdaki hususların tümü yukarıdaki kurallarda belirtilmiştir, ancak daha önce sanal alana gelen soruları önlemek için buraya ekledim:

• Bazı geri baskılar bastırarak çıktınızın bölümlerinin üzerine yazmanıza izin verilmez (genellikle '\b'Aralarında .
• Birden fazla basamak üreten / veren döngüler yasaktır. (Tek bir basamağı hesaplayan döngüler yine de iyidir.)
• Karışık bir sürüm kullanma (1 + √5)/2 veya tek bir rakamdan fazlasını elde etmek için Fibonacci sayılarını bölmek yasaktır.
• Sen 10 haneli ön hesaplama ve 10 değişken saklayın ve bu değişken referanslar 'dont çünkü o zaman sadece, bu başvuruda bulunamaz oluşturmak haneyi - does değişkeni doldurur kod Bu kuralın 6 ihlalidir bu yüzden.
• Aslında, önceki (veya ara sonuçları) tekrar kullanamazsınız, çünkü bu iki rakamın üretilmek için kod paylaşacağı anlamına gelir .
• Aksi halde, rakamları oluşturmak için herhangi bir yöntemi (yalnızca matematiksel olarak gerekmeyen) kullanabilirsiniz. (Ve yapmalısın!)
• Aslında, standart kütüphanenizi kullanarak birçok farklı yerden doğru rakamları çıkarabilirseniz, hiçbir şeyi hesaplamaya gerek yoktur.
• Sen olabilir bir tek basamaklı oluşturulurken bir operatör birden çok kez kullanır ve böylece 2+2+2ilk üretmek için adil bir oyun6 (o kısa düşüktür rağmen).
• Sen olabilir bunlar yerleşik olmadığı için sabitler, sıklıkta istediğiniz gibi herhangi bir hazır bilgi kullanın. Yazdırmak zorunda olmadığınız sürece , kodunuzda istediğiniz kadar s 5kullanabilirsiniz 5.
• Çıktıyı kodlayamazsınız, çünkü çıktı aldığınız sayıları kullanmayı gerektirir.

Kısacası: İki kere rakam üretme yöntemini kullanmayın ve yazdırmakta olduğunuz rakamı veya daha önce basılmış olan rakamları kullanmayın.

Eğer (yarı) sonsuz bir skor elde etmenize izin veren bir kaçık noktası tespit ederseniz, lütfen onu kullanarak bu zorluğun üstesinden gelmeyin, ama bana bildirin, böylece kaçağın hiçbir şey kırılmadan sabitlenip sabitlenemeyeceğini göreyim.

puanlama

En fazla rakamı doğru basan program kazanır. Kravat olması durumunda, kısa kod bağı kırar.

Lütfen, kodunuzun hangi bölümünün hangi rakamı ürettiğini tanımlayan eski bir yorumlu sürüm ekleyin.

Not: Eğer biri yukarıdaki 100 haneyi geçerse, işte birkaç tane daha .

PHP, 100 basamak

Muhtemelen kuralları biraz burda bekliyorum, fakat PHP'nin seçebileceği onlarca sabiti var

<?php
echo TRUE . '.' . PM_STR . DNS_A . MSG_EOR . LC_ALL . T_FMT . LOCK_UN . SQL_DATE
. E_NOTICE . IMG_WBMP . INI_ALL . E_PARSE . SOCKET_EBADF . LOG_USER .
IMAGETYPE_JPC . IMG_PNG . GLOB_MARK . LOCK_NB . LOG_NDELAY . D_FMT . PHP_ZTS .
GLOB_ERR . AM_STR . SQL_DOUBLE . SOL_TCP . FILE_APPEND . LOG_ERR . SORT_ASC .
SOCK_RAW . LOG_INFO . LC_TIME . SQL_FLOAT . SORT_DESC . INFO_MODULES . E_ERROR .
IMG_GIF . SQL_REAL . LOG_DEBUG . DNS_NS . CODESET . CAL_FRENCH . CURLE_OK .
LDAP_OPT_RESTART . LOCK_SH . XML_PI_NODE . SQLITE_INTERRUPT . MYSQLI_ASYNC .
CURLM_OK . SNMP_NULL . SQLITE_NOMEM . LC_MESSAGES . IMG_JPG . SO_KEEPALIVE .
SOCKET_ENXIO . LOCK_EX . D_T_FMT . ENT_QUOTES . LOG_NOTICE . SOCK_RDM .
INPUT_ENV . CURLAUTH_NTLM . INPUT_SESSION . AF_INET . IMG_JPEG . SQL_CONCURRENCY
. SEEK_SET . SOCKET_EIO . LC_CTYPE . PHP_URL_QUERY . LOG_KERN . INI_SYSTEM .
IMAGETYPE_BMP . SEEK_END . JSON_HEX_QUOT . LOG_PID . LIBXML_DTDATTR .
XML_DOCUMENT_NODE . PHP_DEBUG . LOG_CRIT . ENT_IGNORE . LC_NUMERIC .
DOM_NOT_SUPPORTED_ERR . PHP_URL_FRAGMENT . FILE_TEXT . IMAGETYPE_TIFF_II .
LOG_CONS . LOG_EMERG . UPLOAD_ERR_CANT_WRITE . MSG_PEEK . SQLITE_OK . FNM_PERIOD
. AF_UNIX . CURLPROTO_FTPS . STREAM_NOTIFY_FAILURE . MYSQL_BOTH .
CURLE_FTP_ACCESS_DENIED . MSG_OOB . FTP_TEXT . LC_MONETARY .
CURLE_COULDNT_CONNECT . SQLITE_BUSY . "\n";

Bu muhtemelen çok taşınabilir bir kod değil, ancak sistemimde iyi çalışıyor. İşte onu oluşturan kod:

<?php
$phi = "6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375";
echo "<?php\necho TRUE . '.' . ";
$consts = get_defined_constants();
foreach($consts as $k=>$v) if (preg_match('/\d|TRUE|PHP_EOL/',$k)) unset($consts[$k]);
for ($p=0;$p<strlen($phi);$p++) {
  $d = ord($phi[$p]) - 48;
  $min = 999;
  foreach($consts as $k=>$v) {
    if (strlen("$v")==1 && $v==$d && strlen($k)<$min) {
      $min = strlen($k);
      $maxk = $k;
    }
  }
  if ($min==999) break;
  echo "$maxk . ";
  unset($consts[$maxk]);
}
echo "\"\\n\";\n";

Perl - 37 basamak

use Math::Trig;
use POSIX;

print
  !0,'.',chop$=||$=,A==A,2**3,$|,++$^F,75/5/5,pi*pi%\_,4+4,a^Y,w&'?',~"\xcb",$^=~y/_//c,
  ord"\b",unpack(h,"\t").@{[c,c,c,c]},$#{[b..j]},"$^W"|'$',$^H>>log$^H,cos()- -cos,$[,
  $-=sqrt%SIG,$%=$],$+[*$=~/($)/],split('',$~).map(glob,"{,,,}{,}"),index(\L,L),
  exp(exp)<<exp,ceil(sinh acosh$^C).keys{stat$0},rindex(\R,R),($s=ssssss)=~s/s//g,
  $?=acos(--$z),$^T=pack(u,$^T.$^T.TTTT),B~~B,C<=C,length$^V,

Şu anda 392 bayt, (basamak başına 10,6).

Çıktı:

1.618033988749894848204586834365638117

Kendinden empoze edilen Kısıtlamalar

Sorunu önemsizleştirecek dil özelliklerinin kullanımını sınırlamak için birkaç ek kısıtlama ekledim. Örneğin, dizi başvurusu @{...}ve dizi son dizini $#{...}yalnızca bir kez kullanılır. Kullanılan her dizisi (farklı bir şekilde oluşturulmuş karşılaştırma olup [c,c,c,c], [b..j],split('',$~) , map(glob,"{,,,}{,}")). Ek olarak, meydan okuma tarifinde açıkça izin verilmesine rağmen, bir sembol veya bareword birden fazla kullanılmaz. Bence perl (veya sadece int özel değişkenleri olan herhangi bir dil (başkaları var mı?)) İçin iyi bir fikir, çünkü örtük int dönüşümlerinin sayısını sınırlıyor.

parçalar

!0                       # returns 1
'.'
chop$=||$=               # $= is 60, chop the 0, returns 6
A==A                     # returns 1 (because 0==0)
2**3                     # returns 8
$|                       # auto flush, returns 0
++$^F                    # max system filehandle pre-incremented, returns 3
75/5/5                   # returns 3
pi*pi%\_                 # pi² mod a large value, returns 9
4+4                      # returns 8
a^Y                      # bitwise 'a' xor 'Y', returns 8
w&'?'                    # bitwise 'w' and '?', returns 7
~"\xcb"                  # bitwise inversion of char 203, returns 4
$^=~y/_//c               # count non-underscores in $^, returns 9

ord"\b"                  # returns 8
unpack(h,"\t")           # unpack "\t" as a hex nibble, returns 9
@{[c,c,c,c]}             # anonymous array, returns 4 in scalar context
$#{[b..j]}               # final index of the range b..j, returns 8
"$^W"|'$'                # bitwise '0' or '$', returns 4
$^H>>log$^H              # $^H is 256, log$^H is ~5, returns 8
cos()- -cos              # cos(undef) is 1, subtract -1, returns 2
$[                       # array start index, returns 0

$-=sqrt%SIG              # set $- to sqrt(23), returns 4
$%=$]                    # set $% to the version number, returns 5
$+[*$=~/($)/]            # match end on *$ (aka *main::$), returns 8
split('',$~)             # split "STDOUT" into chars, returns 6 in scalar context
map(glob,"{,,,}{,}")     # an array of 8 empty strings, returns 8 in scalar context
index(\L,L)              # finds 'L' in 'SCALAR(...)', returns 3

exp(exp)<<exp            # 2.718281828 << 1, returns 4
ceil(sinh acosh$^C)      # ceil(2.30129...), returns 3
keys{stat$0}             # stat$0 is an array with 13 entries, which has 6 keys when
                         # interpreted as a hash, returns 6 in scalar context
rindex(\R,R)             # finds 'R' in 'SCALAR(...)' in reverse, returns 5
($s=ssssss)=~s/s//g      # replace the every 's' in 'ssssss' with nothing, returns 6

$?=acos(--$z)            # set $? to 3.14159... implicit int conversion, returns 3
$^T=pack(u,$^T.$^T.TTTT) # set $^T to "8,30P,...", returns 8
B~~B                     # returns 1 (because B represents the same thing as B)
C<=C                     # returns 1 (because 0<=0)
length$^V                # string length of $^V, returns 7

Python 2.7, 19 basamak, 231 ilgili karakter

from math import ceil, pi, trunc, gamma, sin

print ''.join(map(str,
[33-32,
chr(46),
~-7,
8>>3,
trunc(gamma(4.3)),
'x'.find('x'),
22/7,
range(4).pop(),
len('am I phi?'),
52%44,
2*4,
5|2,
ord('/'),
'\b',
5+2+2,
2<<2,
eval("5+2+2"),
ceil(pi),
'\b',
'\b',
str(sin(5))[5],
5&52]))

54 hane için Ruby 2.1, 808 karakter

#!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket
print 2/2,?.,9-3,3&5,2*4,2^2,7%4,55>>4,5+4,2<<2,-~7,5|2,2**2,(2r+2+5).to_i,(2.2+5).ceil,(55r/5-2).floor,(2.2*2).to_i,(2r*2*2).ceil,(2.2**2).floor,2.to_bn<<2,__LINE__,$<.to_i,IO::LOCK_NB,Errno::EIO::Errno,File::APPEND,'aaaaaa'.size,?a.encoding.name.sub(/\D+/,''),%w[a a a].size,%w[a b c d].to_set.size,%w[a a a].count,Socket::AF_NS,Date.jd(Date::ITALY).wday,*Digest::MD5.digest(?j).scan(/\d/),Set[?a,?b,?c].count,SignalException.new('FPE').signo,Float::ROUNDS,begin
exit false
rescue Object
$!.status
end,Process::RLIMIT_NPROC,:aaaaaaa.size,Prime.first,?/.next,{a:p,b:p,c:p}.size,STDIN.lineno,?a.crypt('at')[/\d/],{a: :a}.find_index([:a,:a]),/b/=~'aaaaaaaaab',[?a,?b].index(?b),:aaaaaaab=~/b/,?\t.ord,'aaaaaaaab'=~/b/,open(?/).pos,'aaaaab'.index(?b),?\a.bytes{|b|break b},'aaaaaaa'.rindex(?a),%w[a a].map.size

Bu program ile çalışır ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-openbsd]. OpenBSD 5.5 dışındaki sistemler birkaç basamak için farklı değerlere sahip olabilir.

Yorumlama

Bu zorluğun kısıtlamaları, özellikle de kısıtlama 6, Ruby için kesin değildir. Bu yüzden kendi yorumlarımı ekliyorum:

1. Parantezler, nokta ve çift kolon operatör değildir. Parantezler sadece işlemlerin sırasını değiştirir. Nokta, olduğu gibi yöntemleri çağırır $<.filenove çift kolon, olduğu gibi sabitlenir IO::LOCK_NB. Yöntemin veya sabitin adı işlemin bir parçasıdır. Çünkü () . ::operatörler değil, ben onlara kısıtlama 6 uygulanmaz. Daha fazla rakam üretmek için onları tekrar kullanabilirim.
2. Farklı bir uygulamaya sahip bir yöntem, farklı bir yöntemdir. Örneğin, Array#countve Enumerable#countaynı iki yöntem aynı hareket sınırlama 6 için fonksiyonu, aynı değildir Array#countgeçersiz kılar Enumerable#countfarklı uygulama ile. Bir Array#counthane Enumerable#countüretmek için kullanırsam , başka hane oluşturmak için kullanabilirim .
3. Yeni sınıf # bir yöntemdir. Ruby, Mutex.new, Random.new, Time.newve bu yüzden, aynı yönteme bakınız Class#new. SignalException.newBir rakam üretmek için kullanıyorum . Kısıtlama 6 nedeniyle, bir daha asla kullanamayacağım Class#new.
4. Sınıflar veya modüller için sabitler hala sabittir. Ruby'de sınıf isimleri gibi Floatve IOsabittir! IO::LOCK_NBBir rakam üretmek için kullanıyorum . Kısıtlama 6 nedeniyle, bir daha asla kullanamayacağım IO. Bu yorum, yalnızca Ruby'yi ve paket adlarının sabit olmadığı diğer dilleri bağlamaz.
5. Değişmezler sabit değildir. 2 matematiksel bir sabit olmasına rağmen (herhangi bir değişkenden bağımsız olarak), Ruby'de bir sabit değildir. 6. değişmeze kısıtlamaları uygulamıyorum ve değişmez 2'yi birden fazla basamağa yeniden kullanabilirim.
6. Değişmezler operatör değildir. Kısıtlama 6'yı, olduğu gibi değişmez diziler, kareler, normal ifadeler veya dizeler oluşturan parantezlere veya tırnaklara uygulamıyorum [] {} // ''. Her zaman daha fazla rakam üretmek için bu tür hazır bilgileri kullanabilirim.
7. Aynı değere sahip iki sabit aynı sabittir. File::APPENDve IPSocket::LOCK_UNaynı numara için iki addır. 8. Kısıtlama 6, “ herhangi bir yerleşik ismi hangi adla ifade ettiğiniz önemli değildir” der . Çünkü File::APPENDveIPSocket::LOCK_UN sadece adlarına göre farklılık gösterdikleri için, aynı sabit olmalıdır, bu yüzden onları iki basamak için kullanmayabilirim.
8. İki hane aynı global değişkeni göstermeyebilir. Bu bir boşluğu kapatır. Sınırlama 6 sadece fonksiyonlar, operatörler ve sabitler için geçerlidir. Kısıt 4, yalnızca değişmezler için geçerlidir. $SAFEyerleşik bir global değişkendir, bir işlev değil, operatör, sabit veya değişmez. $SAFE0 değerine sahiptir. Boşluk ile $SAFEprogramdaki her 0 basamağını tekrar kullanabilirim. Genel değişkenleri de kısıtlamak için kısıtlamayı 6 yorumlayarak boşluk deliğini kapatıyorum.

Yorumlar

İlk satır #!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket. Yakut bu satırı ve yükleri sanki tarafından standart kütüphanenin altı parça, ayrıştırır require 'date', require 'digest'vb. Bu 56 karakteri saymıyorum, çünkü kısıtlama 3 "standart kütüphane ithal / içeriyor" durumundan muaf.

Programın geri kalanı printuzun bir argüman listesiyle çağırır , bunları dizelere dönüştürür ve sırayla yazdırır. Argümanlar şunlardır:

1. 1from 2/2: division Fixnum # /
   . from ?.: literal tek karakterli dize
2. 6from 9-3: çıkarma Fixnum # -
3. 1from 3&5: bitwise ve Fixnum # &
   • 5. yorumu yaparak 3tekrar kullanabilirim .
4. 8from 2*4: çarpma Fixnum # *
5. 0from 2^2: bitwise exclusive-veya Fixnum # ^
6. 3from 7%4: modulus Fixnum #%
7. 3from 55>>4: sağa kaydırma Fixnum # >>
8. 9from 5+4: toplama Fixnum # +
9. 8from 2<<2: sol üst karakter Fixnum # <<
10. 8from -~7: olumsuzlama tamamlayıcısı Fixnum # - @ Fixnum # ~
    • Çıkarma Fixnum # - ve olumsuzlama Fixnum # - @ farklı yöntemlerdir.
11. 7from 5|2: bitwise veya Fixnum # |
12. 4kimden 2**2: exponentiation Fixnum # **
13. 9from (2r+2+5).to_i: rasyonel toplama Rasyonel # + Rasyonel # to_i
    • 2 yorumla, Fixnum # + ve Rational # + farklı yöntemlerdir. Her ikisi de sayı ekler, ancak sol sayı için farklı türlerden başlayarak farklı uygulamaları vardır.
    • Rasyonel gerçekler gibi 2rRuby 2.1 de yeni. Rational # +2r+2 çağırır ve başka bir rasyonel döndürür; Rational # + 'ı tekrar çağırır .2r+2+5
    • Ruby, rasyonelleri benzer şekilde yazdırır 2/1ve yüzer 2.0. Bunu düzeltmek için, ben tamsayıya dönüştürmek: to_i mermi sıfır, doğru tavan çekmek mermi yukarı, zemin aşağı mermi.
14. 8from (2.2+5).ceil: şamandıra toplama Şamandıra # + Kayan # ceil
    • Yorum 1 ile parantez kullanabilir ()ve .tekrar noktalayabilirim .
15. 9from (55r/5-2).floor: rasyonel bölünme ve çıkarma Rational # / Rational # - Rational # floor
16. 4from (2.2*2).to_i: float çarpma Float # * Float # to_i
17. 8from (2r*2*2).ceil: rasyonel çarpma Rasyonel # * Rasyonel # ceil
18. 4from (2.2**2).floor: rasyonel üstelleşme Rasyonel # **
19. 8Kimden 2.to_bn<<2: OpenSSL sol sayıyla kayma büyük sayı Fixnum # to_bn OpenSSL :: BN # <<
20. 2from __LINE__: Geçerli satır numarası için sihirli sabiti
21. 0from $<.to_i: standart giriş IO # to_i dosya tanımlayıcısı
22. 4from IO::LOCK_NB: bayrak engellemeyen dosya kilidi
    • Bu, sisteme bağlı olan birçok sabitin ilkidir. OpenBSD'de 4 tane var.
    • 4. yorumu yaparak, artık kullanmayabilirim IO. Yorum 7'ye göre, artık 4 değeri olan herhangi bir sabit kullanmıyorum.
23. 5from Errno::EIO::Errno: sayı / giriş hatası
24. 8 itibaren File::APPEND : flag bir dosyaya eklenecek
    • Bu, yorumlama 4'ün etrafındaki bir boşluktur. Kullanmayabilirim IO, ancak Filesabitleri devralır IO, yani File::APPENDalmanın farklı bir yoludur IO::APPEND.
25. 6from 'aaaaaa'.size: string uzunluğu Dize # boyut
26. 8from ?a.encoding.name.sub(/\D+/,''): kodlamanın adının bir kısmı String # encoding Kodlama # name String # sub
    • 6 yorumlanmasıyla, tekrar dize tırnak kullanabilirsiniz.
    • Ruby 2.0'dan bu yana, varsayılan kodlama UTF-8'dir. "UTF-8" adını alıyorum ve / \ D + / ile eşleşen "UTF-" yerine boş bir dize kullanıyorum. Bu "8" verir.
27. 3from %w[a a a].size: dizinin uzunluğu Array # size
28. 4from %w[a b c d].to_set.size: kümedeki öğelerin sayısı Array # to_set Set # size
29. 3from %w[a a a].count: tüm öğeleri say Array # count
    • Array # size ve Array # count arasındaki fark , ikincisinin hangi öğeleri sayacağını seçmek için isteğe bağlı argümanları almasıdır. Hiçbir argüman iletmiyorum, bu yüzden tüm unsurları sayar.
30. 6from Socket::AF_NS: NS adres ailesi için sayı
31. 5Tarih Date.jd(Date::ITALY).wday: 15 Ekim 1582 Cuma günü İtalya’nın Gregoryen takvimine geçtiği haftanın günü sayısı Tarih :: jd Tarih # wday
32. 6from *Digest::MD5.digest(?j).scan(/\d/): ilk ASCII hane "j" nin ikili MD5 özetinde Digest :: MD5 :: digest String # scan
    • String # scan tüm eşleşmelerin bir dizisini döndürür. *Bağımsız değişken olarak dizi elemanlarını geçer print. Bu dizi ["6"].
33. 3from Set[?a,?b,?c].count: tüm öğeleri saymak Set :: [] Numaralandırılabilir # saymak
    • 2 yorumuyla Array # count ve Enumerable # count farklı yöntemlerdir.
34. 8from SignalException.new('FPE').signo: SIGFPE Sınıfı sayısı # new SignalException # signo
35. 1 itibaren Float::ROUNDS : yuvarlama modu, buraya en yakına kadar 1
36. 1begin(newline) ' dan (newline) exit false(yeni rescue Objectsatır)$!.status (satır) endbaşarısızlığın çıkış durumu:
    • Bu, aynı değerdir SystemExit.new(false).statusancak 3. yorumla, artık Class # new'i arayamayabilirim . Bunun yerine bir SystemExit'i yükseltir ve kurtarırım.
37. 7 itibaren Process::RLIMIT_NPROC : bir kullanıcı için işlem sayısı için kaynak sınırı sayısı
38. 7from :aaaaaaa.size: sembolün uzunluğu Sembol # size
39. 2from Prime.first: ilk asal sayı # ilk
40. 0from ?/.next: "?" den sonraki dizgeDize # sonraki
41. 3from {a:p,b:p,c:p}.size: karma uzunluğu Hash # boyut String # p
42. 0from STDIN.lineno: standart giriş için geçerli satır numarası IO # lineno
    • 8. yorumu yaparak, tekrar kullanmayabilirim $<. Kullandığım STDIN. Aradaki fark, bu $<global bir değişkendir ve STDINbir sabittir. Bir program $<farklı bir girişe ayarlanmış olabilir , ancak STDINher zaman özgün değeridir $<.
43. 3from ?a.crypt('at')[/\d/]: şifreli paroladaki ilk ASCII hanesi String # crypt String # []
    • Farklı crypt () işlevine sahip sistem farklı sonuç verecektir.
44. 0from {a: :a}.find_index([:a,:a]): ilk anahtarın dizini: a, değer: a Enumerable # find_index
    • Bir dizi değil, karma kullanın, çünkü Array # find_index , yakında kullanmayı planladığım Array # indeksi için bir takma addır .
45. 9from /b/=~'aaaaaaaaab': index burada / b / ile eşleşir Regexp # = ~
46. 1from [?a,?b].index(?b): dizindeki ilk "b" dizini Array # index
47. 7from :aaaaaaab=~/b/: index, sembolün eşleştiği / b / Symbol # = ~
48. 9from ?\t.ord: ASCII "\ t" sekmesinin değeri String # ord
49. 8from 'aaaaaaaab'=~/b/: index burada eşleşiyor / b / String # = ~
    • Yorum 2'ye göre Regexp # = ~ ve String # = ~ farklı yöntemlerdir.
50. 0from open(?/).pos: "/" kök dizinini açtıktan sonra dosyada pozisyon Kernel # open IO # pos
51. 5from 'aaaaab'.index(?b): string "index" içindeki ilk "b" dizini
52. 7from ?\a.bytes{|b|break b}: ASCII uyarısı değeri "\ a" String # bytes
    • Bu, baytları "\ a" da yineleyerek, ancak ilk baytı döndürerek döngüyü kırarak çalışır.
53. 6from 'aaaaaaa'.rindex(?a): dizesinde son "a" dizesi Dize # rindex
54. 2from %w[a a].map.size: diziden eşlenen numaralandırıcı boyutu Array # map Enumerator # size

Java, 21 hane, 276 karakter

class C{public static void main(String[]a){System.out.print((3&5)+"."+(2|4)+Byte.BYTES+2*4+"".length()+(7-4)+~-4+(7+2)+(2<<2)+(int)Math.sqrt('@')+(2^5)+(int)Math.pow(2,2)+32%23+Byte.SIZE+('$'>>2)+Float.BYTES+Long.BYTES+Integer.BYTES+Double.BYTES+Short.BYTES+Math.round(.2));}}

class C {
  public static void main(String[] a) {
    System.out.print(
      (3&5)+       // 1
      "."+         // .
      (2|4)+       // 6
      Byte.BYTES+  // 1
      2*4+         // 8
      "".length()+ // 0
      (7-4)+       // 3
      ~-4+         // 3
      (7+2)+       // 9
      (2<<2)+      // 8
      (int)Math.sqrt('@')+  // 8
      (2^5)+       // 7
      (int)Math.pow(2,2)+   // 4
      32%32+       // 9
      Byte.SIZE    // 8

      // rest of explanation to come later today
    );
  }
}

Ruby, 74 karakter, 10 basamak

Bu sadece bir başlangıç; Gitmem gerek, sonra geliştireceğim.

$><<[3-2,?.,3+3,?..size,2**3,$*.size,24/8,7%4,[*7..77][2],2*4,7.next].join

Daha sonra zorlaşacağı zamandan beri 76 karakter kaydettim!

Ruby, 17 hane, 168 bayt

$><<[-~0,'.',9-3,3/3,2**3,$.,25%22,'   '=~/$/,2+7,2<<2,"10".oct,2|5,[2,2,2,2].size,[*$....2*5].last,(2^5).succ,'a'.to_i(25).pred,'aaaa'.count('a'),eval(55.chr.next)]*''

Ungolfed:

$><<[
  -~0,                # 1
  '.',                # .
  9-3,                # 6
  3/3,                # 1
  2**3,               # 8
  $.,                 # 0
  25%22,              # 3
  '   '=~/$/,         # 3
  2+7,                # 9
  2<<2,               # 8
  "#{'a'.hex}".oct,   # 8
  2|5,                # 7
  [2,2,2,2].size,     # 4
  [*$....2*5].last,   # 9
  (2^5).succ,         # 8
  'a'.to_i(25).pred,  # 9
  'aaaa'.count('a'),  # 4
  eval(55.chr.next)   # 8
]*''

Henüz zekice bir şey yapmak zorunda kalmadım, geri gelip rakam ekleyebilirim.

Golfscript , 17 basamak

Basit bir girişim. Golfscript, çok sayıda alfasayısal olmayan tek harfli yerleşiklere sahip olabilir, ancak bir bütün olarak pek çok yerleşikliğe sahip değil!

".",                         # 1: string length (separate from array length)
'.'    
3 3+                         # 6: addition
''[49]+                      # 1: string concatenation
-9~                          # 8: bitwise not
2!                           # 0: boolean not
7 4%                         # 3: modulus
4(                           # 3: decrement
7))                          # 9: increment
257 2/2/2/2/2/               # 8: division
4 2*                         # 8: multiplication
22 5- 5- 5-                  # 7: subtraction
2 2?                         # 4: power
[2 5] 2 base                 # 9: base conversion
[2 2 2 2 2 2 2 2],           # 8: array length (separate from str length)
[2 2 2 2 2 2 2 2 2 5]5?      # 9: array.find()
2 2+                         # 4: addition
"2 2*2*"~                    # 8: eval

Bash, 65 karakterde 5 basamak

Bunu yakında güncelleyeceğim! Şimdilik, sadece yazdırır 1.6180ve herhangi bir rakam içermez.

false
tr -d ' '<<<$?.`wc -c<<<abcde``nl<<<' '``kill -l FPE`$(())

açıklama

Rakamları oluşturmak için aşağıdaki yöntemler kullanılır:

1: çıkış durumu false

6: dize uzunluğu

1: nl kötüye kullanma

8: kill sinyal numaraları

0: boş ifadenin sayısal değeri

Mathematica 9 8 basamak, 86 83 78 karakter.

10`8FromDigits@#/10^Length@#&@{a/a,3!,-I I,2π/(45°),#&''[],Prime@2,Sqrt@9,4+5}

Çıktı:

1.6180339

Julia - 345 karakterde 23 hane (tam olarak hane başına 15)

print(div(2,2),'.','/'+7,length(" "),2^3,size([])[end],isqrt(9),int(cbrt(27)),54-45,'h'$'P',[2:22][7],endof("2222222"),count(isodd,[5,5,5,5]),search("Hello man",'n'),nextpow2(5),rsearch("Love boat",'t'),sizeof('й'),("I"summary(b"H"))[22],iceil(float(pi)),iround(cosh(e)),ifloor(exp(catalan)),cmp(5,5),itrunc(5sin(one(Int))),uint(erfcx(-ones())))

Çıktı: 1.6180339887498948482045

Belirli bir karakteri veya dizgiyi yeniden kullanmadığım sürece karakterleri ve dizgileri kullanılabilir olarak yorumladım (dizgideki karakterler, dizge olmadığı sürece yeniden kullanılabilir); ancak kendime bir karakterin int değerini doğrudan kullanma izni vermedim. Bir ASCII olmayan karakter var (й).

Daha okunaklı bir şekilde (gerçek kod değil):

1> div(2,2)
.> '.'
6> '/'+7
1> length(" ")
8> 2^3
0> size([])[end]
3> isqrt(9)
3> int(cbrt(27))
9> 54-45
8> 'h'$'P'
8> [2:22][7]
7> endof("2222222")
4> count(isodd,[5,5,5,5])
9> search("Hello man",'n')
8> nextpow2(5)
9> rsearch("Love boat",'t')
4> sizeof('й')
8> ("I"summary(b"H"))[22]
4> iceil(float(pi))
8> iround(cosh(e))
2> ifloor(exp(catalan))
0> cmp(5,5)
4> itrunc(5sin(one(Int)))
5> uint(erfcx(-ones()))

C ++ satır başına 12.4 karakter, her basamak için satır başına 14 karakter

Operatörleri tekrar kullanma hatam düzeltildi.

#include <iostream>
#include <math.h>
#define S std::string
#define C(x) std::cout<<x
int main()
{
C(cos(0));
C(char(46));
C('j'%'d');
C('\0'+3-2);
C(sqrt('@'));
C(log(1));
C('c'/'!');
S s("xyz");
C(s.size());
return 0;
}

Bunun gibi karakterleri kullanmak, karakter değişmezleri olarak sayılır mı sayılmaz mı? Bu kod kabul edilebilir ise sonsuza kadar devam edilebilir ve char borcu geri ödenir.

#include <iostream>
#define C(x) std::cout<<x
int main()
{
C('b'-'a');//1
C(char(46));//.
C('g'-'a');//6
C('b'-'a');//1
C('i'-'a');//8
C('a'-'a');//0
C('d'-'a');//3
C('d'-'a');//3
C('j'-'a');//9
//etc
return 0;
}