To była zabawa! Jednak z trzema cyframi zabawa skończyła się zbyt wcześnie. To wyzwanie jest podobne, ale będziemy kontynuować zabawę.

Wyzwanie

Wydrukuj jak najwięcej cyfr Golden Ratio φ. Złoty współczynnik jest definiowany jako liczba, która spełnia φ = (φ + 1) / φ, a pierwszych 100 cyfr podaje:

1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375 ...

Wyzwanie to nie dotyczy komputerów φ! Chodzi o wydrukowanie jak największej liczby cyfr bez użycia metody podwójnego wykonania tej czynności. Znajdź więc tyle kreatywnych sposobów na zdobycie swoich cyfr, ile możesz!

Ograniczenia

Samo drukowanie cyfr φ byłoby nieco zbyt proste, więc oto zasady:

1. Musisz konstruować liczbę w kolejności od lewej do prawej , drukując ją kawałek po kawałku lub konstruując ciąg znaków od lewej do prawej i drukując go na końcu - możesz nawet wygenerować tablicę cyfr, a następnie połączyć wydrukuj, o ile zrobisz to po kolei. W poniższych regułach „print” i „output” mogą odnosić się do dowolnego z tych procesów (np. Jeśli budujesz ciąg, a ciąg zawiera 1.6to, co 1.6już zostało wydrukowane).
2. W przypadku kodu otrzymujesz budżet 15 znaków na cyfrę . Okres ten nie wlicza się do tego budżetu, ale również musi zostać wydrukowany. Pamiętaj, że ograniczenie dotyczy tylko całkowitego rozmiaru kodu: możesz użyć więcej niż 15 znaków na dowolną cyfrę, o ile średnio nie używasz więcej. W rzeczywistości możesz narastać „dług” w postaciach i „spłacać” później. Np. Do wydrukowania 1.618masz 60 znaków.
3. Biblioteka standardowa zawiera / importy nie liczą się do rozmiaru kodu. Ale nie możesz za darmo podać tych skrótów!
4. Nie wolno używać cyfr, które obecnie generujesz, ani cyfr, które już wydrukowałeś. Np. 1Może pojawić się nigdzie w kodzie źródłowym, ponieważ jest to pierwsza cyfra. Kod, który wyprowadza 8in 1.618może stosować dowolne lub wszystkie cyfry [0234579], ale żadna [168]. W tym celu wszystkie literały, które są równoważne pojedynczej cyfrze, są traktowane jak ta cyfra . Więc jeśli twój język może reprezentować, 9ponieważ '\t'nie możesz go używać nigdzie, gdzie nie możesz go użyć 9.
5. Nie wolno tworzyć wielu cyfr jednocześnie. Powinno być możliwe wyraźne podzielenie kodu na części generujące jedną cyfrę na raz.

6. Nie wolno odwoływać się do żadnej wbudowanej funkcji, operatora matematycznego / logicznego / bitowego / łańcucha, zmiennej lub stałej, które zostały użyte w kodzie, który wygenerował wcześniejszą cyfrę. Wyjątek stanowią funkcje konwersji liczb całkowitych na ciąg, konkatenacja ciągów i funkcje drukowania, które mogą być potrzebne dla każdej cyfry. Zauważ, że nie ma znaczenia, jaką nazwą odwołujesz się do jakiejkolwiek wbudowanej: tylko dlatego, że masz alias wbudowanej PIdo obu pi qnie oznacza, że ​​możesz użyć praz i qraz. Podobnie, są dopuszczone do używania nazwy dwukrotnie, jeśli odnosi się do dwóch różnych wbudowanych wtyczek, jak struny lengthi tablicy length.

   _{Jeśli twój język programowania nie ma funkcji, dokonaj najlepszego osądu co do jego odpowiednika - np. W przypadku skryptów bash, wywoływanie innych programów powinno być zgodne z regułami nałożonymi na funkcje}

7. Twoje zgłoszenie musi być napisane w jednym języku. Więc nie trzeba wykonywać interpretera innego języka, aby uzyskać dostęp do wbudowanych również w tym języku.

Implikacje

Powyższe zasady implikują następujące punkty, ale dodaję je tutaj, aby uniknąć pytań, które już pojawiły się w piaskownicy:

• Nie wolno nadpisywać części danych wyjściowych, drukując niektóre odstępy (zwykle '\b') pomiędzy nimi.
• Pętle generujące / wysyłające wiele cyfr są zabronione. (Pętle obliczające jedną cyfrę są jednak w porządku.)
• Używanie zaciemnionej wersji (1 + √5)/2lub dzielenie liczb Fibonacciego w celu uzyskania więcej niż jednej cyfry jest zabronione.
• Nie można wstępnie obliczyć 10 cyfr i zapisać ich w 10 zmiennych, a następnie po prostu odwołać się do nich, ponieważ odniesienia do zmiennych nie generują cyfry - robi to kod wypełniający zmienną, więc jest to naruszenie reguły 6.
• W rzeczywistości nie można ponownie użyć żadnych poprzednich (lub wyników pośrednich), ponieważ oznaczałoby to, że dwie cyfry współużytkują kod do wygenerowania .
• W przeciwnym razie możesz użyć dowolnych środków (które nie muszą być czysto matematyczne), aby wygenerować cyfry. (I powinieneś!)
• W rzeczywistości nie trzeba niczego obliczać, jeśli można wyciągnąć prawidłowe cyfry z wielu różnych miejsc przy użyciu standardowej biblioteki.
• Państwo może użyć odpowiedniego operatora wielokrotnie podczas generowania pojedynczej cyfry, więc 2+2+2jest uczciwa gra wygenerować pierwszy 6(choć to mało prawdopodobne, najkrótsza).
• Państwo może użyć dowolnego dosłownym tak często, jak chcesz, ponieważ nie są one wbudowane w stałych. Tak długo, jak nie musisz drukować 5, możesz tyle 5s w swoim kodzie, ile chcesz.
• Nie można na stałe zakodować wyniku, ponieważ wymagałoby to użycia cyfr, które są wyprowadzane.

W skrócie: nie używaj żadnej metody generowania cyfr dwa razy i nie używaj cyfry, którą obecnie wyprowadzasz lub któraś już wydrukowała.

Jeśli zauważysz lukę, która pozwala uzyskać (quasi-) nieskończony wynik, nie rujnuj wyzwania, wykorzystując go, ale daj mi znać, żebym mógł sprawdzić, czy luki można naprawić bez zerwania czegokolwiek.

Punktacja

Program, który poprawnie drukuje największą liczbę cyfr, wygrywa. W przypadku remisu krótszy kod zrywa remis.

Dodaj nieskomentowaną wersję, która określa, która część kodu generuje którą cyfrę.

PS: Jeśli ktoś przekroczy 100 cyfr powyżej, oto kilka innych .

PHP, 100 cyfr

Prawdopodobnie tutaj trochę naginam reguły, ale PHP ma dziesiątki stałych do wyboru:

<?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";

To prawdopodobnie nie jest zbyt przenośny kod, ale działa dobrze w moim systemie. Oto kod, który go wygenerował:

<?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 cyfr

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,

Obecnie 392 bajty (10,6 na cyfrę).

Wydajność:

1.618033988749894848204586834365638117

Narzucone ograniczenia

Dodałem kilka dodatkowych ograniczeń, aby ograniczyć korzystanie z funkcji językowych, które trywializowałyby problem. Na przykład dereferencja tablicy @{...}i indeks końcowy tablicy $#{...}są używane tylko raz. Każda macierz używana jest wytwarzana w różny sposób (porównaj [c,c,c,c], [b..j], split('',$~), map(glob,"{,,,}{,}")). Ponadto żaden symbol ani słowo nie jest używane więcej niż jeden raz, chociaż jest to wyraźnie dozwolone w opisie wyzwania. Myślę, że to dobry pomysł dla Perla (lub dowolnego języka ze specjalnymi zmiennymi typu int-only (czy są jeszcze jakieś inne?)), Ponieważ ogranicza liczbę niejawnych konwersji int.

Kawałki

!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 cyfr, 231 odpowiednich znaków

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]))

Ruby 2.1 dla 54 cyfr, 808 znaków

#!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

Ten program działa z ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-openbsd]. Systemy inne niż OpenBSD 5.5 mogą mieć różne wartości dla kilku cyfr.

Interpretacje

Ograniczenia tego wyzwania, szczególnie ograniczenie 6, nie są precyzyjne dla Ruby. Dodaję więc własne interpretacje:

1. Nawiasy, kropka i dwukropek nie są operatorami. Nawiasy tylko zmieniają kolejność operacji. Kropka wywołuje metody, jak w $<.fileno, a podwójny dwukropek otrzymuje stałe, jak w IO::LOCK_NB. Nazwa metody lub stałej jest częścią operacji. Ponieważ () . ::nie są operatorami, nie stosuję wobec nich ograniczenia 6. Mogę ich ponownie użyć do wygenerowania większej liczby cyfr.
2. Metoda z inną implementacją to inna metoda. Na przykład Array#counti Enumerable#countnie są tą samą funkcją dla ograniczenia 6. Obie metody działają tak samo, ale Array#countzastępują Enumerable#countinną implementacją. Jeśli użyję Array#countdo wygenerowania jednej cyfry, mogę użyć Enumerable#countdo wygenerowania innej cyfry.
3. Klasa # nowa to jedna metoda. W Ruby Mutex.new, Random.new, Time.newi tak dalej odnoszą się do tej samej metody Class#new. Używam SignalException.newdo generowania jednej cyfry. Z powodu ograniczenia 6 nigdy więcej nie mogę użyć Class#new.
4. Stałe dla klas lub modułów są nadal stałymi. W Ruby nazwy klas takie jak Floati IOsą stałymi! Używam IO::LOCK_NBdo generowania jednej cyfry. Z powodu ograniczenia 6 nigdy więcej nie mogę użyć IO. Ta interpretacja wiąże tylko Ruby, a nie inne języki, w których nazwy pakietów nie są stałymi.
5. Literały nie są stałe. Chociaż 2 jest stałą matematyczną (niezależną od jakichkolwiek zmiennych), nie jest stałą w Rubim. Nie stosuję ograniczenia 6 do literałów i mogę ponownie użyć literału 2 dla więcej niż jednej cyfry.
6. Literały nie są operatorami. Nie stosuję ograniczenia 6 do nawiasów lub cytatów, które tworzą dosłowne tablice, skróty, wyrażenia regularne lub ciągi, jak w [] {} // ''. Zawsze mogę używać takich literałów do generowania większej liczby cyfr.
7. Dwie stałe o tej samej wartości są tą samą stałą. File::APPENDi IPSocket::LOCK_UNsą to dwie nazwy dla tego samego numeru 8. Ograniczenie 6 mówi: „nie ma znaczenia, jaką nazwą odwołujesz się do żadnego wbudowanego”. Ponieważ File::APPENDi IPSocket::LOCK_UNróżnią się tylko nazwą, muszą być tej samej stałej, więc nie mogę ich używać dla dwóch cyfr.
8. Dwie cyfry mogą nie odnosić się do tej samej zmiennej globalnej. To zamyka lukę. Ograniczenie 6 dotyczy tylko funkcji, operatorów i stałych. Ograniczenie 4 dotyczy tylko literałów. $SAFEjest wbudowaną zmienną globalną, a nie funkcją, operatorem, stałą ani literałem. $SAFEma wartość 0. Dzięki luce mogę ponownie użyć $SAFEdo wygenerowania każdej cyfry 0 w programie. Zamykam lukę, interpretując ograniczenie 6, aby również ograniczyć zmienne globalne.

Komentarze

Pierwsza linia to #!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket. Ruby analizuje tę linię i ładuje sześć części swojej standardowej biblioteki, jakby przez require 'date', require 'digest'i tak dalej. Nie liczę tych 56 znaków, ponieważ ograniczenie 3 zwalnia „standardowe importowanie / dołączanie bibliotek”.

Reszta programu wywołuje printdługą listę argumentów, aby przekonwertować je na ciągi znaków i wydrukować je w kolejności. Argumenty są następujące:

1. 1from 2/2: Division Fixnum # /
   . from ?.: dosłowny ciąg jednoznakowy
2. 6from 9-3: odejmowanie Fixnum # -
3. 1from 3&5: bitwise i Fixnum # &
   • Zgodnie z interpretacją 5 mogę użyć 3ponownie.
4. 8z 2*4: mnożenie Fixnum # *
5. 0from 2^2: bitwise exclusive-or Fixnum # ^
6. 3od 7%4: moduł Fixnum #%
7. 3od 55>>4: prawy shift Fixnum # >>
8. 9od 5+4: dodatek Fixnum # +
9. 8od 2<<2: lewy shift Fixnum # <<
10. 8z -~7: negacja uzupełnienia Fixnum # - @ Fixnum # ~
    • Odejmowanie Fixnum # - i negacja Fixnum # - @ to różne metody.
11. 7from 5|2: bitwise lub Fixnum # |
12. 4from 2**2: potęgowanie Fixnum # **
13. 9from (2r+2+5).to_i: wymierne dodanie Rational # + Rational # to_i
    • Zgodnie z interpretacją 2, Fixnum # + i Rational # + to różne metody. Obaj dodają liczby, ale mają różne implementacje, zaczynając od różnych typów dla lewej liczby.
    • Racjonalne literały, takie jak, 2rsą nowe w Ruby 2.1. 2r+2wywołuje Rational # + i zwraca inny wymierny; 2r+2+5wywołuje ponownie Rational # + .
    • Ruby drukuje racjonalne jak 2/1i unosi się jak 2.0. Aby to naprawić, przeliczam na liczbę całkowitą: to_i zaokrągla w kierunku zera, sufit zaokrągla w górę, podłoga zaokrągla w dół.
14. 8from (2.2+5).ceil: float add Float # + Float # ceil
    • Zgodnie z interpretacją 1 mogę użyć nawiasów ()i kropki .ponownie.
15. 9from (55r/5-2).floor: racjonalny podział i odejmowanie Rational # / Rational # - Rational # floor
16. 4from (2.2*2).to_i: float mnożenie Float # * Float # to_i
17. 8from (2r*2*2).ceil: wymierne mnożenie Rational # * Rational # ceil
18. 4from (2.2**2).floor: racjonalne potęgowanie Rational # **
19. 8od 2.to_bn<<2: lewy shift z dużą liczbą OpenSSL Fixnum # do_bn OpenSSL :: BN # <<
20. 2from __LINE__: stała magiczna dla bieżącego numeru linii
21. 0from $<.to_i: deskryptor pliku standardowego wejścia IO # to_i
22. 4from IO::LOCK_NB: flaga blokady pliku nie blokującej
    • Jest to pierwsza z wielu stałych zależnych od systemu. OpenBSD ma 4.
    • Zgodnie z interpretacją 4 nie mogę już używać IO. Zgodnie z interpretacją 7 nie mogę już używać żadnej stałej o wartości 4.
23. 5od Errno::EIO::Errno: numer błędu wejścia / wyjścia
24. 8from File::APPEND: flaga, aby dołączyć do pliku
    • Jest to luka wokół interpretacji 4. Nie mogę używać IO, ale Filedziedziczy stałe IO, więc File::APPENDjest inny sposób na uzyskanie IO::APPEND.
25. 6from 'aaaaaa'.size: długość ciągu String # size
26. 8from ?a.encoding.name.sub(/\D+/,''): część nazwy kodowania Ciąg # kodowania Kodowanie # nazwa Ciąg # sub
    • Zgodnie z interpretacją 6 mogę ponownie użyć cudzysłowów łańcuchowych.
    • Od Ruby 2.0 domyślnym kodowaniem jest UTF-8. Biorę nazwę „UTF-8” i zastępuję / \ D + / dopasowując „UTF-” pustym ciągiem. Daje to „8”.
27. 3from %w[a a a].size: długość tablicy Array # size
28. 4from %w[a b c d].to_set.size: liczba elementów w zestawie Array # to_set Set # size
29. 3from %w[a a a].count: count all elements Array # count
    • Różnica między rozmiarem # liczby a liczbą Array # polega na tym, że ten drugi bierze opcjonalne argumenty, aby wybrać, które elementy mają być liczone. Nie przekazuję żadnych argumentów, więc liczy wszystkie elementy.
30. 6od Socket::AF_NS: numer dla rodziny adresów NS
31. 5od Date.jd(Date::ITALY).wday: numer dnia tygodnia w piątek 15 października 1582 r., kiedy Włochy przeszły na kalendarz gregoriański Data :: jd Data # wday
32. 6od *Digest::MD5.digest(?j).scan(/\d/): pierwsza cyfra ASCII w binarnym skrócie MD5 podsumowania „j” Digest :: MD5 :: digest String # scan
    • Skanowanie ciągu # zwraca tablicę wszystkich dopasowań. *Przechodzi elementy tablicy jako argumenty print. Ta tablica to [„6”].
33. 3from Set[?a,?b,?c].count: count all elements Set :: [] Enumerable # count
    • Zgodnie z interpretacją 2 Array # count i Enumerable # count to różne metody.
34. 8from SignalException.new('FPE').signo: numer SIGFPE Class # new SignalException # signo
35. 1z Float::ROUNDS: tryb zaokrąglania, tutaj 1 dla zaokrąglania do najbliższego
36. 1from begin(nowa linia) exit false(nowa linia) rescue Object(nowa linia) $!.status(nowa linia) end: status wyjścia w przypadku niepowodzenia
    • Jest to ta sama wartość SystemExit.new(false).status, ale zgodnie z interpretacją 3 nie mogę już nazywać klasy # nowa . Zamiast tego podnoszę i ratuję SystemExit.
37. 7from Process::RLIMIT_NPROC: numer limitu zasobów dla liczby procesów dla jednego użytkownika
38. 7od :aaaaaaa.size: długość symbolu Symbol # rozmiar
39. 2od Prime.first: pierwsza liczba pierwsza Wyliczalna # pierwsza
40. 0from ?/.next: następny ciąg po „?” Ciąg # następny
41. 3from {a:p,b:p,c:p}.size: długość skrótu Hash # rozmiar String # p
42. 0from STDIN.lineno: aktualny numer linii dla standardowego wejścia IO # lineno
    • Zgodnie z interpretacją 8 nie mogę ponownie wykorzystywać $<. Używam STDIN. Różnica polega na tym, że $<jest to zmienna globalna i STDINjest stała. Program może $<mieć inne wejście, ale STDINzawsze ma oryginalną wartość $<.
43. 3od ?a.crypt('at')[/\d/]: pierwsza cyfra ASCII w zaszyfrowanym haśle String # crypt String # []
    • System z inną funkcją crypt () da inny wynik.
44. 0from {a: :a}.find_index([:a,:a]): indeks pierwszego klucza: a, wartość: a w haszu Enumerable # find_index
    • Używam skrótu, a nie tablicy, ponieważ Array # find_index jest aliasem dla indeksu Array # , którego zamierzam wkrótce użyć.
45. 9from /b/=~'aaaaaaaaab': indeks, gdzie ciąg pasuje / b / Regexp # = ~
46. 1from [?a,?b].index(?b): indeks pierwszego „b” w tablicy Array # index
47. 7from :aaaaaaab=~/b/: indeks, w którym symbol pasuje / b / Symbol # = ~
48. 9from ?\t.ord: wartość ASCII karty „\ t” String # ord
49. 8from 'aaaaaaaab'=~/b/: indeks, gdzie ciąg pasuje / b / String # = ~
    • Zgodnie z interpretacją 2 Regexp # = ~ i String # = ~ są różnymi metodami.
50. 0from open(?/).pos: pozycja w pliku po otwarciu katalogu głównego „/” jako plik Jądro # otwórz IO # pos
51. 5from 'aaaaab'.index(?b): indeks pierwszego „b” w ciągu String # index
52. 7from ?\a.bytes{|b|break b}: wartość ASCII alertu „\ a” Ciąg # bajtów
    • Działa to poprzez iterowanie bajtów w „\ a”, ale przerywanie pętli przez zwracanie pierwszego bajtu.
53. 6from 'aaaaaaa'.rindex(?a): indeks ostatniego „a” w ciągu String # rindex
54. 2from %w[a a].map.size: rozmiar modułu wyliczającego, który odwzorowuje z tablicy Array # map Enumerator # size

Java, 21 cyfr, 276 znaków

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
    );
  }
}

Rubinowy, 74 znaki, 10 cyfr

To tylko początek; Muszę iść, więc poprawię to później.

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

Mam 76 znaków zapisanych na później, kiedy będzie trudniej!

Rubinowy, 17 cyfr, 168 bajtów

$><<[-~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)]*''

Nie golfowany:

$><<[
  -~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
]*''

Nie byłem jeszcze zmuszony do robienia czegokolwiek szczególnie sprytnego, mogę wrócić i dodać cyfry.

Golfscript , 17 cyfr

Prosta próba. Golfscript może mieć wiele niealfanumerycznych wbudowanych jednoliterowych znaków, ale nie ma wielu wbudowanych jako całości!

".",                         # 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, 5 cyfr w 65 znakach

Niedługo to zaktualizuję! Na razie po prostu drukuje 1.6180i nie zawiera żadnych cyfr.

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

Wyjaśnienie

Do wygenerowania cyfr stosuje się następujące metody:

1: status wyjścia z false

6: długość sznurka

1: nlnadużycie

8: killnumery sygnałów

0: wartość liczbowa pustego wyrażenia

Mathematica 9 8 cyfr, w 86 83 78 znaków.

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

Wydajność:

1.6180339

Julia - 23 cyfry po 345 znaków (dokładnie 15 na cyfrę)

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())))

Wyjście: 1,6180339887498948482045

Zinterpretowałem znaki i łańcuchy jako użyteczne, o ile nie użyłem ponownie określonego znaku lub łańcucha (znaki w łańcuchu mogą być ponownie użyte, o ile łańcuch nie był); nie pozwoliłem sobie jednak na bezpośrednie użycie wartości int postaci. Jest jeden znak spoza ASCII (©).

W bardziej czytelny sposób (nie rzeczywisty kod):

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 ++ 12,4 znaków na linię, po 14 znaków na każdą cyfrę

Naprawiono mój błąd ponownego wykorzystywania operatorów.

#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;
}

Nie jesteś pewien, czy używanie takich znaków jest takie jak literały char, czy nie? Jeśli ten kod jest akceptowalny, może być kontynuowany na zawsze, a dług char zostanie spłacony.

#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;
}