C'était amusant! Cependant, avec seulement trois chiffres, le plaisir était trop tôt. Ce défi est similaire, mais nous continuerons à nous amuser.

Le défi

Imprimez autant de chiffres du nombre d' or Golden que possible. Le Golden Ratio est défini comme le nombre qui satisfait φ = (φ + 1) / φ et les 100 premiers chiffres sont donnés par:

1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375 ...

Ce défi ne concerne pas l' informatique! Il s'agit d'imprimer autant de chiffres que possible sans utiliser aucune méthode pour le faire deux fois. Alors, trouvez autant de façons créatives d'obtenir vos chiffres que vous le pouvez!

Restrictions

En soi, imprimer les chiffres de φ serait un peu trop simple, voici donc les règles:

1. Vous devez construire le nombre dans l'ordre de gauche à droite , soit en l'imprimant pièce par pièce, soit en construisant une chaîne de gauche à droite et en l'imprimant à la fin - vous pouvez même générer un tableau de caractères numériques, puis le joindre et imprimez-le, tant que vous le faites dans l'ordre. Dans les règles suivantes, "print" et "output" peuvent faire référence à n'importe lequel de ces processus (par exemple, si vous créez une chaîne et que la chaîne contient 1.6qui compte comme ayant 1.6déjà été imprimée).
2. Pour votre code, vous obtenez un budget de 15 caractères par chiffre . La période ne compte pas dans ce budget, mais doit également être imprimée. Notez que la restriction concerne uniquement la taille totale du code: vous pouvez utiliser plus de 15 caractères pour n'importe quel chiffre tant que vous n'en utilisez pas plus en moyenne. En fait, vous pouvez accumuler une "dette" en caractères et "la rembourser" plus tard. Par exemple, pour imprimer, 1.618vous avez 60 caractères.
3. Les inclusions / importations de la bibliothèque standard ne comptent pas dans la taille du code. Mais vous ne pouvez pas donner ces alias raccourcis gratuitement!
4. Vous ne devez pas utiliser le chiffre que vous générez actuellement, ni aucun que vous avez déjà imprimé. Par exemple, il ne 1peut apparaître nulle part dans votre code source, car il s'agit du tout premier chiffre. Le code qui émet le 8en 1.618peut utiliser tout ou partie des chiffres [0234579], mais aucun d' entre [168]. À cette fin, tous les littéraux équivalents à un seul chiffre sont traités comme ce chiffre . Donc, si votre langue peut représenter 9car '\t'vous n'êtes pas autorisé à l'utiliser n'importe où, où vous ne pouvez pas utiliser un à la 9place.
5. Vous ne devez pas produire plusieurs chiffres à la fois. Il devrait être possible de diviser clairement votre code en morceaux qui génèrent un chiffre à la fois.

6. Vous ne devez pas se référer à tout intégré dans lequel vous avez la fonction, opérateur / chaîne mathématique / booléenne / bit-wise, variable ou constante utilisée dans le code qui a généré un chiffre plus tôt. Les exceptions sont la conversion d'entier en chaîne, la concaténation de chaîne et les fonctions d'impression dont vous pourriez avoir besoin pour chaque chiffre. Notez que peu importe le nom auquel vous faites référence à n'importe quel intégré: simplement parce que vous alias un intégré PIaux deux pet qne signifie pas que vous pouvez l'utiliser pune qfois. De même, vous êtes autorisé à utiliser un nom deux fois s'il fait référence à deux éléments intégrés différents, comme une chaîne lengthet un tableau length.

   _{Si votre langage de programmation n'a pas de fonctions, utilisez votre meilleur jugement sur ce que serait l'équivalent - par exemple pour les scripts bash, invoquer d'autres programmes devrait suivre les règles imposées aux fonctions}

7. Votre soumission doit être rédigée dans une seule langue. Il n'est donc pas nécessaire d'exécuter l'interpréteur d'une autre langue pour accéder également aux fonctions intégrées de cette langue.

Implications

Les points suivants sont tous impliqués par les règles ci-dessus, mais je les ajoute ici pour éviter les questions qui se sont déjà posées dans le bac à sable:

• Vous n'êtes pas autorisé à écraser des parties de votre sortie en imprimant des espaces arrière (généralement '\b') entre les deux.
• Les boucles qui génèrent / produisent plusieurs chiffres sont interdites. (Les boucles qui calculent un seul chiffre sont bien, cependant.)
• Il (1 + √5)/2est interdit d' utiliser une version obscurcie ou de diviser des nombres de Fibonacci pour obtenir plus d'un chiffre.
• Vous ne pouvez pas précalculer les 10 chiffres et les stocker dans 10 variables, puis vous y référer, car ces références de variables ne génèrent pas le chiffre - le code qui remplit la variable le fait, c'est donc une violation de la règle 6.
• En fait, vous ne pouvez pas réutiliser les résultats précédents (ou intermédiaires), car cela signifierait que deux chiffres partageraient le code pour être généré .
• Sinon, vous pouvez utiliser n'importe quel moyen (qui ne doit pas être purement mathématique) pour générer les chiffres. (Et vous devriez!)
• En fait, il n'est pas nécessaire de calculer quoi que ce soit, si vous pouvez extraire les chiffres corrects de nombreux endroits différents en utilisant votre bibliothèque standard.
• Vous pouvez utiliser un opérateur plusieurs fois tout en générant un seul chiffre, il 2+2+2est donc juste de générer le premier 6(bien qu'il soit peu probable qu'il soit le plus court).
• Vous pouvez utiliser n'importe quel littéral aussi souvent que vous le souhaitez, car ce ne sont pas des constantes intégrées. Donc, tant que vous n'avez pas à imprimer 5, vous pouvez autant de 5s dans votre code que vous le souhaitez.
• Vous ne pouvez pas coder en dur la sortie, car cela impliquerait d'utiliser les chiffres que vous sortez.

En bref: n'utilisez aucune méthode de génération de chiffres deux fois et n'utilisez pas le chiffre que vous êtes en train de produire ou que vous avez déjà imprimé.

Si vous repérez une faille qui vous permet d'obtenir un score (quasi-) infini, veuillez ne pas gâcher le défi en l'exploitant, mais faites-le moi savoir afin que je puisse voir si la faille peut être corrigée sans rien casser.

Notation

Le programme qui imprime correctement le plus grand nombre de chiffres gagne. En cas d'égalité, le code le plus court rompt l'égalité.

Veuillez ajouter une version commentée non golfée qui identifie quelle partie de votre code génère quel chiffre.

PS: Si quelqu'un bat les 100 chiffres ci-dessus, en voici d'autres .

PHP, 100 chiffres

Je plie probablement les règles un peu ici, mais PHP a des dizaines de constantes parmi lesquelles choisir:

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

Ce code n'est probablement pas très portable, mais il fonctionne très bien sur mon système. Voici le code qui l'a généré:

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

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,

392 octets actuellement (10,6 par chiffre).

Sortie:

1.618033988749894848204586834365638117

Restrictions auto-imposées

J'ai ajouté quelques restrictions supplémentaires pour limiter l'utilisation des fonctionnalités linguistiques qui banaliseraient le problème. Par exemple, le déréférencement de tableau @{...}et l'index final de tableau $#{...}ne sont utilisés qu'une seule fois. Chaque réseau utilisé est généré d'une manière différente (comparer [c,c,c,c], [b..j], split('',$~), map(glob,"{,,,}{,}")). De plus, aucun symbole ou mot nu n'est utilisé plus d'une fois, bien que cela soit explicitement autorisé dans la description du défi. Je pense que c'est une bonne idée pour perl (ou tout langage avec des variables spéciales uniquement int (y en a-t-il d'autres?)), Car cela limite le nombre de conversions int implicites.

Pièces

!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 chiffres, 231 caractères pertinents

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 pour 54 chiffres, 808 caractères

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

Ce programme fonctionne avec ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-openbsd]. Les systèmes autres qu'OpenBSD 5.5 peuvent avoir des valeurs différentes pour quelques chiffres.

Interprétations

Les restrictions de ce défi, en particulier la restriction 6, ne sont pas précises pour Ruby. J'ajoute donc mes propres interprétations:

1. Les parenthèses, les points et les deux-points ne sont pas des opérateurs. Les parenthèses changent simplement l'ordre des opérations. Le point appelle les méthodes, comme dans $<.fileno, et le double signe deux points obtient des constantes, comme dans IO::LOCK_NB. Le nom de la méthode ou de la constante fait partie de l'opération. Parce que ce () . ::ne sont pas des opérateurs, je ne leur applique pas la restriction 6. Je peux les réutiliser pour générer plus de chiffres.
2. Une méthode avec une implémentation différente est une méthode différente. Par exemple, Array#countet Enumerable#countne sont pas la même fonction pour la restriction 6. Les deux méthodes agissent de la même manière, mais Array#countremplacent Enumerable#countavec une implémentation différente. Si j'utilise Array#countpour générer un chiffre, je peux utiliser Enumerable#countpour générer un autre chiffre.
3. La classe # new est une méthode. En Ruby, Mutex.new, Random.new, Time.newet ainsi de suite se référer à la même méthode, Class#new. J'utilise SignalException.newpour générer un chiffre. En raison de la restriction 6, je ne pourrai plus jamais l'utiliser Class#new.
4. Les constantes des classes ou des modules sont toujours des constantes. Dans Ruby, les noms de classe aiment Floatet IOsont des constantes! J'utilise IO::LOCK_NBpour générer un chiffre. En raison de la restriction 6, je ne pourrai plus jamais l'utiliser IO. Cette interprétation ne lie que Ruby et pas d'autres langages où les noms de package ne sont pas des constantes.
5. Les littéraux ne sont pas des constantes. Bien que 2 soit une constante mathématique (indépendante de toute variable), ce n'est pas une constante en Ruby. Je n'applique pas la restriction 6 aux littéraux et je peux réutiliser le littéral 2 pour plus d'un chiffre.
6. Les littéraux ne sont pas des opérateurs. Je n'applique pas la restriction 6 aux crochets ou aux guillemets qui forment des tableaux littéraux, des hachages, des expressions régulières ou des chaînes, comme dans [] {} // ''. Je peux toujours utiliser ces littéraux pour générer plus de chiffres.
7. Deux constantes avec la même valeur sont la même constante. File::APPENDet IPSocket::LOCK_UNsont deux noms pour le même numéro 8. La restriction 6 dit, "peu importe le nom auquel vous vous référez à n'importe quel intégré." Parce que File::APPENDet IPSocket::LOCK_UNne diffèrent que par leur nom, ils doivent être la même constante, donc je ne peux pas les utiliser pour deux chiffres.
8. Deux chiffres peuvent ne pas faire référence à la même variable globale. Cela ferme une faille. La restriction 6 ne s'applique qu'aux fonctions, opérateurs et constantes. La restriction 4 ne s'applique qu'aux littéraux. $SAFEest une variable globale intégrée, pas une fonction, un opérateur, une constante ni un littéral. $SAFEa la valeur 0. Avec l'échappatoire, je peux réutiliser $SAFEpour générer chaque chiffre 0 dans le programme. Je ferme l'échappatoire en interprétant la restriction 6 pour restreindre également les variables globales.

commentaires

La première ligne est #!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket. Ruby analyse cette ligne et charge six parties de sa bibliothèque standard, comme si require 'date', require 'digest'et ainsi de suite. Je ne compte pas ces 56 caractères, car la restriction 3 exempte les "importations / inclusions de bibliothèque standard".

Le reste du programme appelle printavec une longue liste d'arguments, pour les convertir en chaînes et les afficher dans l'ordre. Les arguments sont les suivants:

1. 1from 2/2: division Fixnum # /
   . from ?.: chaîne littérale à un caractère
2. 6de 9-3: soustraction Fixnum # -
3. 1de 3&5: au niveau du bit et Fixnum # &
   • Par l'interprétation 5, je peux utiliser à 3nouveau.
4. 8de 2*4: multiplication Fixnum # *
5. 0de 2^2: bitwise exclusive-ou Fixnum # ^
6. 3de 7%4: module Fixnum #%
7. 3de 55>>4: décalage à droite Fixnum # >>
8. 9de 5+4: addition Fixnum # +
9. 8de 2<<2: décalage à gauche Fixnum # <<
10. 8de -~7: négation du complément Fixnum # - @ Fixnum # ~
    • La soustraction Fixnum # - et la négation Fixnum # - @ sont des méthodes différentes.
11. 7de 5|2: au niveau du bit ou Fixnum # |
12. 4de 2**2: exponentiation Fixnum # **
13. 9de (2r+2+5).to_i: addition rationnelle Rational # + Rational # to_i
    • Selon l'interprétation 2, Fixnum # + et Rational # + sont des méthodes différentes. Ils ajoutent tous deux des nombres, mais ils ont des implémentations différentes, en commençant par des types différents pour le nombre de gauche.
    • Les littéraux rationnels comme 2rsont nouveaux dans Ruby 2.1. 2r+2appelle Rational # + et renvoie un autre rationnel; 2r+2+5appelle Rational # + .
    • Ruby imprime des rationnels comme 2/1et flotte comme 2.0. Pour résoudre ce problème, je convertis en entier: to_i arrondit vers zéro, ceil arrondit vers le haut, sol arrondit vers le bas.
14. 8de (2.2+5).ceil: ajout de flotteur Float # + Float # ceil
    • Selon l'interprétation 1, je peux utiliser ()à .nouveau des parenthèses et des points .
15. 9de (55r/5-2).floor: division et soustraction rationnelles Rational # / Rational # - Rational # floor
16. 4de (2.2*2).to_i: float multiplication Float # * Float # to_i
17. 8de (2r*2*2).ceil: multiplication rationnelle Rational # * Rational # ceil
18. 4de (2.2**2).floor: exponentiation rationnelle rationnelle # **
19. 8de 2.to_bn<<2: décalage à gauche avec un grand nombre OpenSSL Fixnum # to_bn OpenSSL :: BN # <<
20. 2de __LINE__: constante magique pour le numéro de ligne actuel
21. 0from $<.to_i: descripteur de fichier de l'entrée standard IO # to_i
22. 4from IO::LOCK_NB: indicateur de verrouillage de fichier non bloquant
    • Il s'agit de la première des nombreuses constantes à dépendre du système. OpenBSD en a 4.
    • Selon l'interprétation 4, je ne peux plus utiliser IO. Selon l'interprétation 7, je ne peux plus utiliser de constante de valeur 4.
23. 5 de Errno::EIO::Errno : numéro pour l'erreur d'entrée / sortie
24. 8 de File::APPEND : indicateur à ajouter à un fichier
    • Il s'agit d'une faille autour de l'interprétation 4. Je ne peux pas utiliser IO, mais Filehérite des constantes de IO, File::APPENDest donc une façon différente d'obtenir IO::APPEND.
25. 6from 'aaaaaa'.size: longueur de la chaîne String # taille
26. 8from ?a.encoding.name.sub(/\D+/,''): partie du nom de l'encodage String # encoding Encoding # name String # sub
    • Selon l'interprétation 6, je peux à nouveau utiliser des guillemets.
    • Depuis Ruby 2.0, l'encodage par défaut est UTF-8. Je prends le nom "UTF-8" et je remplace / \ D + / correspondant "UTF-" par une chaîne vide. Cela donne "8".
27. 3à partir de %w[a a a].size: longueur du tableau Taille du tableau #
28. 4from %w[a b c d].to_set.size: nombre d'éléments dans set Array # to_set Set # size
29. 3de %w[a a a].count: compter tous les éléments Tableau # count
    • La différence entre Array # size et Array # count est que ce dernier prend des arguments facultatifs pour choisir les éléments à compter. Je ne passe aucun argument, donc il compte tous les éléments.
30. 6 de Socket::AF_NS : numéro pour la famille d'adresses NS
31. 5à partir de Date.jd(Date::ITALY).wday: numéro de semaine du vendredi 15 octobre 1582, date à laquelle l'Italie est passée au calendrier grégorien Date :: jd Date # wday
32. 6de *Digest::MD5.digest(?j).scan(/\d/): premier chiffre ASCII dans le résumé binaire MD5 du résumé "j" :: MD5 :: digest String # scan
    • Le scan de chaîne # renvoie un tableau de toutes les correspondances. Le *passe les éléments du tableau comme arguments à print. Ce tableau est ["6"].
33. 3from Set[?a,?b,?c].count: compter tous les éléments Set :: [] Enumerable # count
    • Selon l'interprétation 2, Array # count et Enumerable # count sont des méthodes différentes.
34. 8de SignalException.new('FPE').signo: nombre de SIGFPE Classe # nouveau SignalException # signo
35. 1 de Float::ROUNDS : mode d'arrondi, ici 1 pour arrondir au plus proche
36. 1de begin(nouvelle ligne) exit false(nouvelle ligne) rescue Object(nouvelle ligne) $!.status(nouvelle ligne) end: quitter l'état pour échec
    • C'est la même valeur que SystemExit.new(false).status, mais selon l'interprétation 3, je ne peux plus appeler Class # new . Au lieu de cela, je lève et sauve un SystemExit.
37. 7de Process::RLIMIT_NPROC: nombre pour la limite de ressources pour le nombre de processus pour un utilisateur
38. 7de :aaaaaaa.size: longueur du symbole Symbole # taille
39. 2de Prime.first: premier nombre premier Enumerable # first
40. 0de ?/.next: chaîne suivante après "?" Chaîne # suivante
41. 3à partir de {a:p,b:p,c:p}.size: longueur du hachage Hash # taille String # p
42. 0de STDIN.lineno: numéro de ligne actuel pour l'entrée standard IO # lineno
    • Selon l'interprétation 8, je ne peux pas réutiliser $<. J'utilise STDIN. La différence est qu'il $<s'agit d'une variable globale et d' STDINune constante. Un programme peut être réglé $<sur une entrée différente, mais il STDINs'agit toujours de la valeur d'origine de $<.
43. 3de ?a.crypt('at')[/\d/]: premier chiffre ASCII dans le mot de passe crypté String # crypt String # []
    • Un système avec une fonction crypt () différente donnera un résultat différent.
44. 0from {a: :a}.find_index([:a,:a]): index de la première clé: a, valeur: a in hash Enumerable # find_index
    • J'utilise un hachage, pas un tableau, car Array # find_index est un alias pour l' index Array # , que je prévois d'utiliser bientôt.
45. 9from /b/=~'aaaaaaaaab': index où la chaîne correspond à / b / Regexp # = ~
46. 1from [?a,?b].index(?b): index du premier "b" du tableau Array # index
47. 7from :aaaaaaab=~/b/: index où le symbole correspond / b / Symbol # = ~
48. 9from ?\t.ord: valeur ASCII de l'onglet "\ t" String # ord
49. 8from 'aaaaaaaab'=~/b/: index où la chaîne correspond à / b / String # = ~
    • Selon l'interprétation 2, Regexp # = ~ et String # = ~ sont des méthodes différentes.
50. 0from open(?/).pos: position dans le fichier après ouverture du répertoire racine "/" en tant que fichier Kernel # open IO # pos
51. 5from 'aaaaab'.index(?b): index du premier "b" dans la chaîne String # index
52. 7de ?\a.bytes{|b|break b}: valeur ASCII de l'alerte "\ a" chaîne # octets
    • Cela fonctionne en itérant les octets dans "\ a", mais en rompant la boucle en renvoyant le premier octet.
53. 6from 'aaaaaaa'.rindex(?a): index du dernier "a" dans la chaîne String # rindex
54. 2from %w[a a].map.size: taille de l'énumérateur qui mappe à partir du tableau Array # map Enumerator # size

Java, 21 chiffres, 276 caractères

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 caractères, 10 chiffres

Ce n'est qu'un début; Je dois y aller donc je vais l'améliorer plus tard.

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

J'ai 76 caractères enregistrés pour plus tard, quand cela deviendra plus difficile!

Ruby, 17 chiffres, 168 octets

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

Non golfé:

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

Je n'ai pas encore été obligé de faire quelque chose de particulièrement intelligent, je peux revenir et ajouter des chiffres.

Golfscript , 17 chiffres

Une tentative simple. Golfscript peut avoir beaucoup de fonctions intégrées non alphanumériques à une lettre, mais il n'a pas beaucoup de fonctions intégrées dans leur ensemble!

".",                         # 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 chiffres en 65 caractères

Je mettrai cela à jour bientôt! Pour l'instant, il imprime juste1.6180 et ne contient aucun chiffre.

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

Explication

Les méthodes suivantes sont utilisées pour générer les chiffres:

1: état de sortie de false

6: longueur de chaîne

1: nl abus

8: kill numéros de signaux

0: valeur numérique d'une expression vide

Mathematica 9 8 chiffres, en 86 83 78 caractères.

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

Sortie:

1.6180339

Julia - 23 chiffres en 345 caractères (15 par chiffre exactement)

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

Sortie: 1.6180339887498948482045

J'ai interprété les caractères et les chaînes comme utilisables, tant que je n'ai pas réutilisé un caractère ou une chaîne spécifique (les caractères d'une chaîne pouvaient être réutilisés, tant que la chaîne ne l'était pas); cependant, je ne me suis pas permis d'utiliser directement la valeur int d'un caractère. Il y a un caractère non ASCII (©).

De manière plus lisible (pas de code réel):

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 caractères par ligne, soit 14 caractères par ligne pour chaque chiffre

Correction de mon erreur de réutilisation des opérateurs.

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

Vous ne savez pas si l'utilisation de caractères comme celui-ci compte comme des littéraux de caractères ou non? Si ce code est acceptable, il peut être poursuivi indéfiniment et la dette d'omble sera remboursée.

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