Das hat Spaß gemacht! Mit nur drei Ziffern war der Spaß jedoch viel zu früh vorbei. Diese Herausforderung ist ähnlich, aber wir werden den Spaß am Laufen halten.

Die Herausforderung

Drucken Sie so viele Ziffern des Goldenen Schnitts φ wie möglich. Der Goldene Schnitt ist definiert als die Zahl, die φ = (φ + 1) / φ erfüllt, und die ersten 100 Stellen sind gegeben durch:

1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375 ...

Bei dieser Herausforderung geht es nicht darum, φ zu berechnen! Es geht darum, so viele Ziffern wie möglich auszudrucken, ohne dies zweimal zu tun. Finden Sie also so viele kreative Möglichkeiten, wie Sie können!

Beschränkungen

Das Ausdrucken der Ziffern von φ wäre für sich genommen etwas zu einfach. Hier also die Regeln:

1. Sie müssen die Zahl in der Reihenfolge von links nach rechts konstruieren , indem Sie sie entweder Stück für Stück drucken oder indem Sie eine Zeichenfolge von links nach rechts konstruieren und am Ende ausdrucken. Sie können sogar ein Array von Ziffernzeichen generieren und dann verbinden und drucke es aus, solange du es in der richtigen Reihenfolge machst. In den folgenden Regeln beziehen sich "Drucken" und "Ausgabe" möglicherweise auf einen dieser Prozesse (z. B. wenn Sie eine Zeichenfolge erstellen und die Zeichenfolge enthält 1.6, die als 1.6bereits gedruckt gilt).
2. Für Ihren Code erhalten Sie ein Budget von 15 Zeichen pro Ziffer . Der Zeitraum zählt nicht zu diesem Budget, sondern muss ebenfalls ausgedruckt werden. Beachten Sie, dass die Einschränkung nur für die Gesamtcodegröße gilt: Sie können mehr als 15 Zeichen für jede Ziffer verwenden, sofern Sie im Durchschnitt nicht mehr verwenden. In der Tat können Sie eine "Schuld" in Zeichen aufbauen und später "auszahlen". ZB zum Ausdrucken haben 1.618Sie 60 Zeichen.
3. Standardbibliotheksinhalte / -importe werden nicht auf die Codegröße angerechnet. Aber Sie können diese Beinhaltet-Aliase nicht kostenlos vergeben!
4. Sie dürfen weder die Ziffer verwenden, die Sie gerade generieren, noch eine, die Sie bereits gedruckt haben. ZB 1kann nirgendwo in Ihrem Quellcode erscheinen, weil es die allererste Ziffer ist. Der Code, der die Ausgänge 8in 1.618kann irgendeine oder alle Ziffern verwenden [0234579], aber keiner von [168]. Zu diesem Zweck werden alle Literale, die einer einzelnen Ziffer entsprechen, als diese Ziffer behandelt . Also , wenn Sie die Sprache darstellen kann , 9wie '\t'es nicht erlaubt ist, dass überall zu verwenden, in dem Sie eine nicht verwenden konnten , 9statt.
5. Sie dürfen nicht mehrere Ziffern gleichzeitig eingeben. Es sollte möglich sein, Ihren Code klar in Abschnitte zu unterteilen, die jeweils eine Ziffer generieren.

6. Sie dürfen sich nicht auf eine integrierte Funktion, einen mathematischen / booleschen / bitweisen / String-Operator, eine Variable oder Konstante beziehen, die Sie in Code verwendet haben, der eine frühere Ziffer generiert hat. Ausnahmen sind die Umwandlung von Ganzzahlen in Strings, die Verkettung von Strings und die Druckfunktionen, die Sie möglicherweise für jede einzelne Ziffer benötigen. Beachten Sie, dass es keine Rolle, von welchem Namen Sie beziehen sich auf alle integrierten in: nur weil Sie alias einen eingebauten, PIsowohl auf pund qbedeutet nicht , Sie verwenden erhalten peinmal und qeinmal. Ebenso Sie werden einen Namen zweimal verwenden darf , wenn es zwei verschiedene Einbauten bezieht sich, wie String lengthund Array length.

   _{Wenn Ihre Programmiersprache über keine Funktionen verfügt, sollten Sie nach bestem Wissen entscheiden, wie diese aussehen würden - z. B. für Bash-Skripte. Beim Aufrufen anderer Programme sollten die für Funktionen geltenden Regeln eingehalten werden}

7. Ihre Einreichung muss in einer einzigen Sprache verfasst sein. Sie müssen also nicht den Interpreter einer anderen Sprache ausführen, um auch auf die integrierten Funktionen dieser Sprache zuzugreifen.

Implikationen

Die folgenden Punkte werden alle durch die obigen Regeln impliziert, aber ich füge sie hier hinzu, um Fragen zu vermeiden, die bereits in der Sandbox aufgetaucht sind:

• Sie dürfen Teile Ihrer Ausgabe nicht überschreiben, indem Sie (normalerweise '\b') ein paar Leerzeichen dazwischen drucken .
• Schleifen, die mehrere Ziffern erzeugen / ausgeben, sind verboten. (Schleifen, die eine einzelne Ziffer berechnen, sind jedoch in Ordnung.)
• Die Verwendung einer verschleierten Version (1 + √5)/2oder das Teilen von Fibonacci-Zahlen, um mehr als eine Ziffer zu erhalten, ist verboten.
• Sie können die 10 Ziffern nicht vorberechnen und in 10 Variablen speichern und dann nur auf diese verweisen, da diese Variablenreferenzen nicht die Ziffer generieren - der Code, der die Variable ausfüllt, verstößt also gegen Regel 6.
• Tatsächlich können Sie keine vorherigen (oder Zwischen-) Ergebnisse wiederverwenden, da dies bedeuten würde, dass zwei Ziffern den Code für die Generierung gemeinsam nutzen würden .
• Andernfalls können Sie beliebige Mittel verwenden (die nicht rein mathematisch sein müssen), um die Ziffern zu generieren. (Und du solltest!)
• Tatsächlich müssen Sie nichts berechnen, wenn Sie mit Ihrer Standardbibliothek die richtigen Ziffern von vielen verschiedenen Stellen abrufen können.
• Sie können einen Operator mehrmals verwenden, während Sie eine einzelne Ziffer 2+2+2generieren. Daher ist es fair, das erste zu generieren 6(obwohl dies wahrscheinlich nicht das kürzeste ist).
• Sie können jedes Literal so oft verwenden, wie Sie möchten, da es sich nicht um integrierte Konstanten handelt. Solange Sie nicht drucken müssen 5, können Sie so viele 5s in Ihrem Code eingeben, wie Sie möchten.
• Sie können die Ausgabe nicht fest codieren, da dies die Verwendung der von Ihnen ausgegebenen Ziffern erfordern würde.

Kurz gesagt: Verwenden Sie keine Methode zum zweimaligen Generieren von Ziffern, und verwenden Sie nicht die Ziffer, die Sie gerade ausgeben oder die bereits gedruckt wurden.

Wenn Sie eine Lücke entdecken, die es Ihnen ermöglicht, eine (quasi) unendliche Punktzahl zu erzielen, ruinieren Sie die Herausforderung bitte nicht, indem Sie sie ausnutzen. Lassen Sie es mich jedoch wissen, damit ich sehen kann, ob die Lücke behoben werden kann, ohne etwas zu beschädigen.

Wertung

Das Programm, das die höchste Anzahl von Ziffern korrekt ausgibt, gewinnt. Im Falle eines Unentschieden unterbricht der kürzere Code das Unentschieden.

Bitte fügen Sie eine kommentierte Version ohne Golf hinzu, die angibt, welcher Teil Ihres Codes welche Ziffer generiert.

PS: Wenn jemand die oben genannten 100 Stellen schlägt, hier noch ein paar mehr .

PHP, 100 Stellen

Ich bin wahrscheinlich dabei, die Regeln ein wenig zu ändern, aber PHP hat Dutzende von Konstanten zur Auswahl:

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

Dies ist wahrscheinlich kein sehr portabler Code, aber auf meinem System funktioniert er einwandfrei. Hier ist der Code, der es generiert hat:

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

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,

Derzeit 392 Byte (10,6 pro Ziffer).

Ausgabe:

1.618033988749894848204586834365638117

Selbst auferlegte Einschränkungen

Ich habe ein paar zusätzliche Einschränkungen hinzugefügt, um die Verwendung von Sprachfunktionen zu beschränken, die das Problem trivialisieren würden. Beispielsweise werden die Array-Dereferenzierung @{...}und der Array-Endindex $#{...}nur einmal verwendet. Jedes Array verwendet wird , in einer anderen Art und Weise erzeugt (vergleiche [c,c,c,c], [b..j], split('',$~), map(glob,"{,,,}{,}")). Darüber hinaus wird kein Symbol oder Bareword mehrmals verwendet, obwohl dies in der Herausforderungsbeschreibung ausdrücklich erlaubt ist. Ich denke, es ist eine gute Idee für Perl (oder jede Sprache mit speziellen Int-Only-Variablen (gibt es noch andere?)), Weil es die Anzahl der impliziten Int-Konvertierungen begrenzt.

Stücke

!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 Ziffern, 231 relevante Zeichen

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 für 54 Ziffern, 808 Zeichen

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

Dieses Programm funktioniert mit ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-openbsd]. Andere Systeme als OpenBSD 5.5 haben möglicherweise unterschiedliche Werte für einige Ziffern.

Interpretationen

Die Einschränkungen dieser Herausforderung, insbesondere Einschränkung 6, sind für Ruby nicht genau. Also füge ich meine eigenen Interpretationen hinzu:

1. Die Klammern, Punkt und Doppelpunkt sind keine Operatoren. Die Klammern ändern nur die Reihenfolge der Operationen. Der Punkt ruft Methoden wie in auf $<.filenound der Doppelpunkt erhält Konstanten wie in IO::LOCK_NB. Der Name der Methode oder Konstante ist Teil der Operation. Da () . ::es sich nicht um Operatoren handelt, wende ich keine Einschränkung 6 auf sie an. Ich kann sie wiederverwenden, um mehr Ziffern zu generieren.
2. Eine Methode mit einer anderen Implementierung ist eine andere Methode. Zum Beispiel Array#countund Enumerable#countsind nicht dieselbe Funktion für die Einschränkung 6. Beide Methoden verhalten sich gleich, Array#countüberschreiben jedoch Enumerable#counteine andere Implementierung. Wenn ich Array#counteine Ziffer generiere, kann ich Enumerable#counteine andere Ziffer generieren.
3. Die Klasse # new ist eine Methode. In Ruby Mutex.new, Random.new, Time.newund verweist so auf das gleiche Verfahren, Class#new. Ich benutze SignalException.new, um eine Ziffer zu generieren. Wegen Einschränkung 6 darf ich nie wieder verwenden Class#new.
4. Konstanten für Klassen oder Module sind weiterhin Konstanten. In Ruby sind Klassennamen wie Floatund IOKonstanten! Ich benutze IO::LOCK_NB, um eine Ziffer zu generieren. Wegen Einschränkung 6 darf ich nie wieder verwenden IO. Diese Interpretation bindet nur Ruby und keine anderen Sprachen, in denen Paketnamen keine Konstanten sind.
5. Literale sind keine Konstanten. Obwohl 2 eine mathematische Konstante ist (unabhängig von Variablen), ist sie in Ruby keine Konstante. Ich wende die Einschränkung 6 nicht auf Literale an und kann das Literal 2 für mehr als eine Ziffer wiederverwenden.
6. Literale sind keine Operatoren. Ich wende die Einschränkung 6 nicht auf Klammern oder Anführungszeichen an, die wie in Literal-Arrays, Hashes, reguläre Ausdrücke oder Zeichenfolgen bilden [] {} // ''. Ich kann solche Literale immer verwenden, um mehr Ziffern zu generieren.
7. Zwei Konstanten mit demselben Wert sind dieselbe Konstante. File::APPENDund IPSocket::LOCK_UNsind zwei Namen für die gleiche Nummer 8. Die Einschränkung 6 besagt: "Es spielt keine Rolle, unter welchem Namen Sie auf einen eingebauten Namen verweisen." Weil File::APPENDund IPSocket::LOCK_UNunterscheiden sich nur durch den Namen, müssen sie die gleiche Konstante sein, damit ich sie nicht für zwei Ziffern verwenden kann.
8. Zwei Ziffern beziehen sich möglicherweise nicht auf dieselbe globale Variable. Dies schließt eine Lücke. Einschränkung 6 gilt nur für Funktionen, Operatoren und Konstanten. Einschränkung 4 gilt nur für Literale. $SAFEist eine integrierte globale Variable, keine Funktion, kein Operator, keine Konstante und kein Literal. $SAFEhat den Wert 0. Mit der Lücke kann ich wieder $SAFEjede Ziffer 0 im Programm generieren. Ich schließe die Lücke, indem ich Restriktion 6 interpretiere, um auch globale Variablen einzuschränken.

Bemerkungen

Die erste Zeile ist #!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket. Ruby parst diese Zeile und Lasten sechs Teile seiner Standardbibliothek, als ob durch require 'date', require 'digest'und so weiter. Ich zähle diese 56 Zeichen nicht, da die Einschränkung 3 "Standardbibliotheksimporte / -einschlüsse" ausschließt.

Der Rest des Programms ruft printmit einer langen Liste von Argumenten auf, um sie in Zeichenfolgen umzuwandeln und in der angegebenen Reihenfolge auszudrucken. Die Argumente sind diese:

1. 1from 2/2: division Fixnum # /
   . from ?.: Literal Single Character String
2. 6von 9-3: subtraction Fixnum # -
3. 1von 3&5: bitwise und Fixnum # &
   • Nach Interpretation 5 darf ich 3wieder verwenden.
4. 8von 2*4: multiplication Fixnum # *
5. 0from 2^2: bitweises Exklusiv-oder Fixnum # ^
6. 3von 7%4: modulus Fixnum #%
7. 3von 55>>4: Rechtsverschiebung Fixnum # >>
8. 9von 5+4: zusätzlich Fixnum # +
9. 8von 2<<2: Linksverschiebung Fixnum # <<
10. 8von -~7: Negation des Komplements Fixnum # - @ Fixnum # ~
    • Subtraction Fixnum # - und Negation Fixnum # - @ sind verschiedene Methoden.
11. 7from 5|2: bitwise oder Fixnum # |
12. 4von 2**2: Exponentiation Fixnum # **
13. 9aus (2r+2+5).to_i: rationale Addition Rational # + Rational # to_i
    • Nach Interpretation 2 sind Fixnum # + und Rational # + verschiedene Methoden. Beide fügen Nummern hinzu, haben jedoch unterschiedliche Implementierungen, beginnend mit unterschiedlichen Typen für die linke Nummer.
    • Rationale Literale wie 2rsind neu in Ruby 2.1. 2r+2ruft Rational # + auf und gibt ein anderes Rational zurück; 2r+2+5ruft Rational # + wieder.
    • Ruby druckt Rationen wie 2/1und schwimmt wie 2.0. Um dies zu beheben, konvertiere ich in eine Ganzzahl: to_i rundet gegen Null, ceil rundet auf, floor rundet ab.
14. 8von (2.2+5).ceil: float addition Float # + Float # ceil
    • Nach Interpretation 1 kann ich wieder Klammern ()und Punkte verwenden ..
15. 9aus (55r/5-2).floor: rationale Division und Subtraktion Rational # / Rational # - Rational # Etage
16. 4from (2.2*2).to_i: float multiplication Float # * Float # to_i
17. 8aus (2r*2*2).ceil: rationale Multiplikation Rational # * Rational # ceil
18. 4aus (2.2**2).floor: rationale Potenzierung Rational # **
19. 8von 2.to_bn<<2: Linksverschiebung mit OpenSSL-Nummer Fixnum # to_bn OpenSSL :: BN # <<
20. 2from __LINE__: Magische Konstante für die aktuelle Zeilennummer
21. 0from $<.to_i: Dateideskriptor der Standardeingabe IO # to_i
22. 4from IO::LOCK_NB: Flag für nicht blockierende Dateisperre
    • Dies ist die erste von vielen Konstanten, die vom System abhängen. OpenBSD hat 4.
    • Nach Interpretation 4 darf ich nicht mehr verwenden IO. Nach Interpretation 7 darf ich keine Konstante mit dem Wert 4 mehr verwenden.
23. 5from Errno::EIO::Errno: Nummer für Ein- / Ausgabefehler
24. 8from File::APPEND: Flag zum Anhängen an eine Datei
    • Dies ist ein Schlupfloch um Interpretation 4. Ich kann nicht verwenden IO, sondern Fileerben Konstanten aus IO, so File::APPENDeine andere Art und Weise zu bekommen IO::APPEND.
25. 6from 'aaaaaa'.size: Länge des Strings String # size
26. 8from ?a.encoding.name.sub(/\D+/,''): Teil des Namens der Kodierung String # encoding Kodierung # name String # sub
    • Nach Interpretation 6 kann ich wieder Anführungszeichen verwenden.
    • Seit Ruby 2.0 ist die Standardkodierung UTF-8. Ich nehme den Namen "UTF-8" und ersetze / \ D + /, das mit "UTF-" übereinstimmt, durch einen leeren String. Dies ergibt "8".
27. 3from %w[a a a].size: Länge des Arrays Größe des Arrays
28. 4from %w[a b c d].to_set.size: Anzahl der Elemente in set Array # to_set Set # size
29. 3from %w[a a a].count: zählt alle Elemente Array # count
    • Der Unterschied zwischen der Größe des Arrays und der Anzahl der Arrays besteht darin, dass letzterer optionale Argumente verwendet, um die zu zählenden Elemente auszuwählen. Ich übergebe keine Argumente, also zählt es alle Elemente.
30. 6von Socket::AF_NS: Nummer für NS-Adressfamilie
31. 5von Date.jd(Date::ITALY).wday: Wochentagsnummer für Freitag, den 15. Oktober 1582, als Italien auf gregorianischen Kalender umstellte Datum :: jd Datum # wTag
32. 6from *Digest::MD5.digest(?j).scan(/\d/): erste ASCII-Ziffer im binären MD5-Digest von "j" Digest :: MD5 :: digest String # scan
    • String # scan gibt ein Array aller Übereinstimmungen zurück. Der *übergibt die Array-Elemente als Argumente an print. Dieses Array ist ["6"].
33. 3from Set[?a,?b,?c].count: count all elements Set :: [] Enumerable # count
    • In Interpretation 2 sind Array-Anzahl und Enumerable-Anzahl verschiedene Methoden.
34. 8from SignalException.new('FPE').signo: Nummer der SIGFPE- Klasse # new SignalException # signo
35. 1from Float::ROUNDS: Rundungsmodus, hier 1 für Rundung zum nächsten
36. 1from begin(newline) exit false(newline) rescue Object(newline) $!.status(newline) end: Exit-Status für Fehler
    • Dies ist derselbe Wert wie SystemExit.new(false).status, aber nach Interpretation 3 kann ich Class # new nicht mehr aufrufen . Stattdessen hebe ich ein SystemExit auf und rette es.
37. 7from Process::RLIMIT_NPROC: Anzahl für Ressourcenlimit für die Anzahl der Prozesse für einen Benutzer
38. 7from :aaaaaaa.size: Länge des Symbols Symbol # size
39. 2from Prime.first: erste Primzahl Enumerable # first
40. 0from ?/.next: nächster String nach "?" String # next
41. 3from {a:p,b:p,c:p}.size: Länge des Hash Hash # size String # p
42. 0from STDIN.lineno: aktuelle Zeilennummer für Standardeingabe IO # lineno
    • Nach Interpretation 8 kann ich nicht wiederverwenden $<. Ich benutze STDIN. Der Unterschied besteht darin, dass $<es sich um eine globale Variable und STDINeine Konstante handelt. Ein Programm kann $<auf einen anderen Eingang eingestellt sein, aber es STDINist immer der ursprüngliche Wert von $<.
43. 3from ?a.crypt('at')[/\d/]: erste ASCII-Ziffer im verschlüsselten Passwort String # crypt String # []
    • Ein System mit einer anderen crypt () - Funktion liefert ein anderes Ergebnis.
44. 0from {a: :a}.find_index([:a,:a]): Index des ersten Schlüssels: a, Wert: a in Hash Enumerable # find_index
    • Ich verwende einen Hash, kein Array, da Array # find_index ein Alias ​​für Array # index ist , den ich bald verwenden möchte .
45. 9from /b/=~'aaaaaaaaab': Index, bei dem die Zeichenfolge mit / b / Regexp # = ~ übereinstimmt
46. 1from [?a,?b].index(?b): Index des ersten "b" im Array Array # index
47. 7from :aaaaaaab=~/b/: Index, bei dem das Symbol mit / b / Symbol # = ~ übereinstimmt
48. 9from ?\t.ord: ASCII-Wert der Registerkarte "\ t" String # ord
49. 8from 'aaaaaaaab'=~/b/: Index, bei dem der String mit / b / String # = ~ übereinstimmt
    • Nach Interpretation 2 sind Regexp # = ~ und String # = ~ unterschiedliche Methoden.
50. 0from open(?/).pos: Position in der Datei nach dem Öffnen des Stammverzeichnisses "/" als Datei Kernel # open IO # pos
51. 5from 'aaaaab'.index(?b): Index des ersten "b" in der Zeichenfolge String # index
52. 7from ?\a.bytes{|b|break b}: ASCII-Wert von alert "\ a" String # bytes
    • Dies funktioniert, indem die Bytes in "\ a" durchlaufen werden, die Schleife jedoch unterbrochen wird, indem das erste Byte zurückgegeben wird.
53. 6from 'aaaaaaa'.rindex(?a): Index des letzten "a" in der Zeichenfolge String # rindex
54. 2from %w[a a].map.size: Größe des Enumerators, der aus dem Array Array # map Enumerator # size zugeordnet wird

Java, 21 Ziffern, 276 Zeichen

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 Zeichen, 10 Ziffern

Es ist nur ein Anfang; Ich muss gehen, damit ich es später verbessern kann.

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

Ich habe 76 Zeichen für später gespeichert, wenn es schwieriger wird!

Ruby, 17 Stellen, 168 Bytes

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

Ich war noch nicht gezwungen, etwas besonders Kluges zu tun. Vielleicht komme ich zurück und füge Ziffern hinzu.

Golfscript mit 17 Ziffern

Ein einfacher Versuch. Golfscript enthält zwar viele nicht-alphanumerische Ein-Buchstaben-Funktionen, aber insgesamt sind nicht viele Funktionen integriert!

".",                         # 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 Ziffern in 65 Zeichen

Ich werde dies bald aktualisieren! Derzeit wird nur gedruckt 1.6180und enthält keine Ziffern.

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

Erläuterung

Die folgenden Methoden werden zum Generieren der Ziffern verwendet:

1: Beenden Sie den Status von false

6: Stringlänge

1: nlMissbrauch

8: killSignalnummern

0: numerischer Wert eines leeren Ausdrucks

Mathematica 9 8 Ziffern, in 86 83 78 Zeichen.

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

Ausgabe:

1.6180339

Julia - 23 Ziffern in 345 Zeichen (genau 15 pro Ziffer)

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

Ausgabe: 1.6180339887498948482045

Ich habe Zeichen und Zeichenketten als verwendbar interpretiert, solange ich ein bestimmtes Zeichen oder eine bestimmte Zeichenkette nicht wiederverwendet habe (Zeichen in einer Zeichenkette konnten wiederverwendet werden, solange die Zeichenkette nicht wiederverwendet wurde). Ich erlaubte mir jedoch nicht, den int-Wert eines Zeichens direkt zu verwenden. Es gibt ein Nicht-ASCII-Zeichen (©).

In besser lesbarer Weise (kein tatsächlicher Code):

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 Zeichen pro Zeile waren 14 Zeichen pro Zeile für jede Ziffer

Mein Fehler bei der Wiederverwendung von Operatoren wurde behoben.

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

Sie sind sich nicht sicher, ob die Verwendung solcher Zeichen als Zeichen-Literale gilt oder nicht? Wenn dieser Code akzeptabel ist, kann er für immer fortgesetzt werden und die Schulden werden zurückgezahlt.

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