¡Esto fue divertido! Sin embargo, con solo tres dígitos, la diversión terminó demasiado pronto. Este desafío es similar, pero mantendremos la diversión.

El reto

Imprima tantos dígitos de la Proporción Dorada φ como sea posible. La proporción áurea se define como el número que satisface φ = (φ + 1) / φ y los primeros 100 dígitos están dados por:

1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375 ...

Este desafío no se trata de computación φ! Se trata de imprimir tantos dígitos como sea posible sin usar ningún método para hacerlo dos veces. ¡Así que encuentra tantas formas creativas de obtener tus dígitos como puedas!

Restricciones

Por sí solo, imprimir los dígitos de φ sería demasiado simple, así que aquí están las reglas:

1. Debe construir el número en orden de izquierda a derecha , ya sea imprimiéndolo pieza por pieza o construyendo una cadena de izquierda a derecha e imprimiéndolo al final; incluso podría generar una matriz de caracteres de dígitos y luego unirlos y imprímalo, siempre que lo haga en orden. En las siguientes reglas, "imprimir" y "salida" pueden referirse a cualquiera de esos procesos (por ejemplo, si está creando una cadena, y la cadena contiene 1.6que cuenta que 1.6ya se ha impreso).
2. Para su código , obtiene un presupuesto de 15 caracteres por dígito . El período no cuenta para ese presupuesto, pero también debe imprimirse. Tenga en cuenta que la restricción solo se aplica al tamaño total del código: puede usar más de 15 caracteres para cualquier dígito, siempre que no use más en promedio. De hecho, puede acumular una "deuda" en los personajes y "pagarla" más adelante. Por ejemplo, para imprimir 1.618tienes 60 caracteres.
3. La biblioteca estándar incluye / importa no cuenta para el tamaño del código. ¡Pero no puedes dar esos alias abreviados de forma gratuita!
4. No debe usar el dígito que está generando actualmente, ni ninguno que ya haya impreso. Por ejemplo, 1puede no aparecer en ninguna parte de su código fuente, porque es el primer dígito. El código que da salida a la 8de 1.618puede utilizar cualquiera o todos los dígitos [0234579], pero ninguno de [168]. Para este propósito, todos los literales que son equivalentes a un solo dígito se tratan como ese dígito . Entonces, si su idioma puede representarlo, 9ya '\t'que no puede usarlo en ningún lugar, donde no podría usar uno 9.
5. No debe producir varios dígitos a la vez. Debería ser posible dividir claramente su código en fragmentos que generen un dígito a la vez.

6. No se debe hacer referencia a cualquier incorporada la función, el operador / secuencia matemática / boolean / bits sabia, variable o constante que se ha utilizado en el código que genera un dígito anterior. Las excepciones son la conversión de entero a cadena, la concatenación de cadenas y las funciones de impresión que puede necesitar para cada dígito. Tenga en cuenta que no importa con qué nombre se refiera a cualquier incorporado: solo porque alias un incorporado PIa ambos py qno significa que pueda usarlo puna y qotra vez. Del mismo modo, está permitido el uso de un nombre dos veces si se refiere a dos muebles empotrados diferentes, como cadena lengthy la matriz length.

   _{Si su lenguaje de programación no tiene funciones, use su mejor criterio sobre cuál sería el equivalente, por ejemplo, para bash scripting, la invocación de otros programas debe seguir las reglas impuestas a las funciones}

7. Su envío debe estar escrito en un solo idioma. Por lo tanto, no ejecutar el intérprete de otro idioma para obtener acceso a las funciones integradas de ese idioma también.

Trascendencia

Los siguientes puntos están implícitos en las reglas anteriores, pero los agrego aquí para evitar preguntas que ya han surgido en el sandbox ::

• No está permitido sobrescribir partes de su salida imprimiendo algunos espacios (generalmente '\b') en el medio.
• Los bucles que generan / generan múltiples dígitos están prohibidos. (Sin embargo, los bucles que calculan un solo dígito están bien).
• (1 + √5)/2Está prohibido usar una versión ofuscada o dividir números de Fibonacci para obtener más de un solo dígito.
• No puede calcular previamente los 10 dígitos y almacenarlos en 10 variables y luego solo referirse a ellos, porque esas referencias de variables no generan el dígito; el código que llena la variable sí lo hace, por lo que esto es una violación de la regla 6.
• De hecho, no puede reutilizar ningún resultado anterior (o intermedio), porque eso significaría que dos dígitos compartirían el código para ser generado .
• De lo contrario, puede utilizar cualquier medio (que no sea puramente matemático) para generar los dígitos. (¡Y deberías!)
• De hecho, no es necesario calcular nada, si puede extraer los dígitos correctos de muchos lugares diferentes utilizando su biblioteca estándar.
• Usted puede utilizar un operador varias veces mientras se genera un solo dígito, por lo que 2+2+2es juego limpio para generar la primera 6(aunque es poco probable que el más corto).
• Usted puede utilizar cualquier literal con la frecuencia que desee, porque no son constantes integradas. Por lo tanto, siempre que no tenga que imprimir 5, puede incluir tantos 5s en su código como desee.
• No puede codificar la salida, porque eso implicaría usar los dígitos que está generando.

En resumen: no use ningún método para generar dígitos dos veces y no use el dígito que está emitiendo actualmente o ninguno que ya haya impreso.

Si detecta un vacío que le permite obtener una puntuación (casi) infinita, no arruine el desafío explotándolo, pero avíseme para que pueda ver si el vacío puede solucionarse sin romper nada.

Tanteo

El programa que imprime el mayor número de dígitos gana correctamente. En caso de empate, el código más corto rompe el empate.

Agregue una versión comentada no escrita que identifica qué parte de su código genera qué dígito.

PD: Si alguien supera los 100 dígitos anteriores, aquí hay algunos más .

PHP, 100 dígitos

Probablemente estoy doblando las reglas un poco aquí, pero PHP tiene docenas de constantes para elegir:

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

Probablemente este no sea un código muy portátil, pero funciona bien en mi sistema. Aquí está el código que lo generó:

<?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 dígitos

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 bytes actualmente, (10.6 por dígito).

Salida:

1.618033988749894848204586834365638117

Restricciones autoimpuestas

Agregué algunas restricciones adicionales para limitar el uso de las funciones del lenguaje que trivializarían el problema. Por ejemplo, la desreferencia de matriz @{...}y el índice final de matriz $#{...}solo se usan una vez. Cada matriz utilizado se genera de una manera diferente (comparar [c,c,c,c], [b..j], split('',$~), map(glob,"{,,,}{,}")). Además, no se usa ningún símbolo ni palabra más de una vez, aunque esto está explícitamente permitido en la descripción del desafío. Creo que es una buena idea para Perl (o cualquier lenguaje con variables especiales solo int (¿hay alguna otra?)), Ya que limita el número de conversiones int implícitas.

Piezas

!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 dígitos, 231 caracteres relevantes

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 para 54 dígitos, 808 caracteres

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

Este programa funciona con ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-openbsd]. Los sistemas que no sean OpenBSD 5.5 pueden tener valores diferentes para unos pocos dígitos.

Interpretaciones

Las restricciones de este desafío, especialmente la restricción 6, no son precisas para Ruby. Entonces agrego mis propias interpretaciones:

1. Los paréntesis, punto y doble punto no son operadores. Los paréntesis solo cambian el orden de las operaciones. El punto llama a los métodos, como en $<.fileno, y el doble colon obtiene constantes, como en IO::LOCK_NB. El nombre del método o constante es parte de la operación. Como () . ::no somos operadores, no les aplico la restricción 6. Puedo reutilizarlos para generar más dígitos.
2. Un método con una implementación diferente es un método diferente. Por ejemplo, Array#county Enumerable#countno son la misma función para la restricción 6. Ambos métodos actúan igual, pero Array#countanulan Enumerable#countcon una implementación diferente. Si uso Array#countpara generar un dígito, puedo usar Enumerable#countpara generar otro dígito.
3. Clase # nuevo es un método. En Ruby, Mutex.new, Random.new, Time.newy así sucesivamente se refieren al mismo método, Class#new. Yo uso SignalException.newpara generar un dígito. Debido a la restricción 6, es posible que nunca más vuelva a usar Class#new.
4. Las constantes para clases o módulos siguen siendo constantes. ¡En Ruby, los nombres de clase como Floaty IOson constantes! Yo uso IO::LOCK_NBpara generar un dígito. Debido a la restricción 6, es posible que nunca más vuelva a usar IO. Esta interpretación solo vincula a Ruby, y no a otros idiomas donde los nombres de paquetes no son constantes.
5. Los literales no son constantes. Aunque 2 es una constante matemática (independiente de cualquier variable), no es una constante en Ruby. No aplico la restricción 6 a literales, y puedo reutilizar el literal 2 para más de un dígito.
6. Los literales no son operadores. No aplico la restricción 6 a los corchetes o comillas que forman matrices literales, hashes, expresiones regulares o cadenas, como en [] {} // ''. Siempre puedo usar tales literales para generar más dígitos.
7. Dos constantes con el mismo valor son la misma constante. File::APPENDy IPSocket::LOCK_UNson dos nombres para el mismo número 8. La restricción 6 dice: "no importa con qué nombre se refiera a ninguno incorporado". Debido File::APPENDy IPSocket::LOCK_UNsólo se diferencian por su nombre, que debe ser la misma constante, por lo que no pueden utilizarlos para los dos dígitos.
8. Dos dígitos pueden no referirse a la misma variable global. Esto cierra una escapatoria. La restricción 6 solo se aplica a funciones, operadores y constantes. La restricción 4 solo se aplica a literales. $SAFEes una variable global incorporada, no una función, operador, constante ni literal. $SAFEtiene el valor 0. Con la escapatoria, puedo reutilizar $SAFEpara generar cada dígito 0 en el programa. Cierro la escapatoria interpretando la restricción 6 para restringir también las variables globales.

Comentarios

La primera línea es #!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket. Ruby analiza esta línea y carga seis partes de su biblioteca estándar, como por require 'date', require 'digest'y así sucesivamente. No cuento estos 56 caracteres, porque la restricción 3 exime a "importación / inclusión de biblioteca estándar".

El resto del programa llama printcon una larga lista de argumentos, para convertirlos en cadenas e imprimirlos en orden. Los argumentos son estos:

1. 1from 2/2: division Fixnum # /
   . from ?.: cadena de un solo carácter literal
2. 6de 9-3: resta Fixnum # -
3. 1desde 3&5: bitwise y Fixnum # &
   • Por interpretación 5, puedo usar de 3nuevo.
4. 8de 2*4: multiplicación Fixnum # *
5. 0de 2^2: bitwise exclusive-o Fixnum # ^
6. 3de 7%4: módulo Fixnum #%
7. 3desde 55>>4: desplazamiento a la derecha Fixnum # >>
8. 9de 5+4: además Fixnum # +
9. 8desde 2<<2: desplazamiento a la izquierda Fixnum # <<
10. 8de -~7: negación del complemento Fixnum # - @ Fixnum # ~
    • La resta Fixnum # - y la negación Fixnum # - @ son métodos diferentes.
11. 7desde 5|2: bitwise o Fixnum # |
12. 4de 2**2: exponenciación Fixnum # **
13. 9de (2r+2+5).to_i: suma racional Racional # + Racional # to_i
    • Por interpretación 2, Fixnum # + y Rational # + son métodos diferentes. Ambos agregan números, pero tienen implementaciones diferentes, comenzando desde diferentes tipos para el número izquierdo.
    • Los literales racionales como 2rson nuevos en Ruby 2.1. 2r+2llama a Rational # + y devuelve otro racional; 2r+2+5llama a Rational # + nuevamente.
    • Ruby imprime racionales como 2/1y flota como 2.0. Para solucionar este problema, puedo convertir a entero: to_i rondas hacia cero, ceil rondas arriba, planta redondea hacia abajo.
14. 8desde (2.2+5).ceil: flotación adicional Float # + Float # ceil
    • Por la interpretación 1, puedo usar paréntesis ()y puntos .nuevamente.
15. 9de (55r/5-2).floor: división racional y resta Racional # / Racional # - Racional # piso
16. 4desde (2.2*2).to_i: multiplicación de flotación Float # * Float # to_i
17. 8de (2r*2*2).ceil: multiplicación racional # racional * * racional # ceil
18. 4de (2.2**2).floor: exponenciación racional Racional # **
19. 8desde 2.to_bn<<2: desplazamiento a la izquierda con número grande de OpenSSL Fixnum # to_bn OpenSSL :: BN # <<
20. 2from __LINE__: constante mágica para el número de línea actual
21. 0from $<.to_i: descriptor de archivo de entrada estándar IO # to_i
22. 4from IO::LOCK_NB: marca para bloqueo de archivo sin bloqueo
    • Esta es la primera de muchas constantes que depende del sistema. OpenBSD tiene 4.
    • Por interpretación 4, ya no puedo usar IO. Por la interpretación 7, ya no puedo usar ninguna constante con el valor de 4.
23. 5from Errno::EIO::Errno: número de error de entrada / salida
24. 8from File::APPEND: marca para agregar a un archivo
    • Esta es una laguna en torno a la interpretación 4. No puedo usar IO, pero Filehereda constantes de IO, por lo que File::APPENDes una forma diferente de obtener IO::APPEND.
25. 6from 'aaaaaa'.size: longitud de la cadena String # size
26. 8from ?a.encoding.name.sub(/\D+/,''): parte del nombre de la codificación Cadena # codificación Codificación # nombre Cadena # sub
    • Por interpretación 6, puedo usar comillas nuevamente.
    • Desde Ruby 2.0, la codificación predeterminada es UTF-8. Tomo el nombre "UTF-8" y sustituyo / \ D + / coincidente "UTF-" con una cadena vacía. Esto produce "8".
27. 3from %w[a a a].size: longitud de la matriz Array # size
28. 4from %w[a b c d].to_set.size: número de elementos en set Array # to_set Set # size
29. 3from %w[a a a].count: cuenta todos los elementos Array # count
    • La diferencia entre Array # size y Array # count es que este último toma argumentos opcionales para elegir qué elementos contar. No paso argumentos, por lo que cuenta todos los elementos.
30. 6de Socket::AF_NS: número para la familia de direcciones NS
31. 5desde Date.jd(Date::ITALY).wday: número del día de la semana para el viernes 15 de octubre de 1582, cuando Italia cambió al calendario gregoriano Fecha :: fecha jd # día
32. 6de *Digest::MD5.digest(?j).scan(/\d/): primer dígito ASCII en el resumen binario MD5 del resumen "j" :: MD5 :: resumen String # scan
    • String # scan devuelve una matriz de todas las coincidencias. El *pasa los elementos de la matriz como argumentos a print. Esta matriz es ["6"].
33. 3from Set[?a,?b,?c].count: cuenta todos los elementos Set :: [] Enumerable # count
    • Por interpretación 2, Array # count y Enumerable # count son métodos diferentes.
34. 8desde SignalException.new('FPE').signo: número de SIGFPE Clase # nuevo SignalException # signo
35. 1desde Float::ROUNDS: modo de redondeo, aquí 1 para redondear al más cercano
36. 1from begin(nueva línea) exit false(nueva línea) rescue Object(nueva línea) $!.status(nueva línea) end: estado de salida por falla
    • Este es el mismo valor que SystemExit.new(false).status, pero por la interpretación 3, ya no puedo llamar a Class # new . En cambio, levanto y rescato un SystemExit
37. 7from Process::RLIMIT_NPROC: número para límite de recursos para número de procesos para un usuario
38. 7desde :aaaaaaa.size: longitud del símbolo Símbolo # tamaño
39. 2desde Prime.first: primer número primo Enumerable # first
40. 0from ?/.next: siguiente cadena después de "?" Cadena # siguiente
41. 3desde {a:p,b:p,c:p}.size: longitud del hash Hash # tamaño Cadena # p
42. 0from STDIN.lineno: número de línea actual para entrada estándar IO # lineno
    • Por interpretación 8, no puedo reutilizar $<. Yo uso STDIN. La diferencia es que $<es una variable global y STDINes una constante. Un programa puede establecer $<una entrada diferente, pero STDINsiempre es el valor original de $<.
43. 3from ?a.crypt('at')[/\d/]: primer dígito ASCII en la contraseña cifrada String # crypt String # []
    • El sistema con diferente función crypt () dará un resultado diferente.
44. 0from {a: :a}.find_index([:a,:a]): índice de la primera clave: a, valor: a en hash Enumerable # find_index
    • Utilizo un hash, no una matriz, porque Array # find_index es un alias para Array # index , que planeo usar pronto.
45. 9from /b/=~'aaaaaaaaab': índice donde la cadena coincide / b / Regexp # = ~
46. 1from [?a,?b].index(?b): índice de la primera "b" en la matriz Array # index
47. 7from :aaaaaaab=~/b/: índice donde el símbolo coincide / b / Símbolo # = ~
48. 9from ?\t.ord: valor ASCII de la pestaña "\ t" Cadena # ord
49. 8from 'aaaaaaaab'=~/b/: índice donde la cadena coincide / b / String # = ~
    • Por interpretación 2, Regexp # = ~ y String # = ~ son métodos diferentes.
50. 0from open(?/).pos: posición en el archivo después de abrir el directorio raíz "/" como un archivo Kernel # open IO # pos
51. 5from 'aaaaab'.index(?b): índice de la primera "b" en la cadena String # index
52. 7from ?\a.bytes{|b|break b}: valor ASCII de la alerta "\ a" Cadena # bytes
    • Esto funciona iterando los bytes en "\ a", pero rompiendo el ciclo devolviendo el primer byte.
53. 6from 'aaaaaaa'.rindex(?a): índice de la última "a" en la cadena String # rindex
54. 2from %w[a a].map.size: tamaño del enumerador que se asigna desde la matriz Array # map Enumerator # size

Java, 21 dígitos, 276 caracteres

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

Rubí, 74 caracteres, 10 dígitos.

Es solo un comienzo; Tengo que ir, así que lo mejoraré más tarde.

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

¡Tengo 76 caracteres guardados para más tarde, cuando será más difícil!

Ruby, 17 dígitos, 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)]*''

Sin 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
]*''

Todavía no me he visto obligado a hacer nada particularmente inteligente, puedo volver y agregar dígitos.

Golfscript , 17 dígitos

Un intento directo. ¡Golfscript puede tener muchas incorporaciones no alfanuméricas de una letra, pero no tiene muchas incorporaciones en su conjunto!

".",                         # 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 dígitos en 65 caracteres

¡Actualizaré esto pronto! Por ahora, solo imprime 1.6180y no contiene ningún dígito.

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

Explicación

Los siguientes métodos se utilizan para generar los dígitos:

1: estado de salida de false

6: longitud de la cuerda

1: nlabuso

8: killnúmeros de señal

0: valor numérico de una expresión vacía

Mathematica 9 8 dígitos, en 86 83 78 caracteres.

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

Salida:

1.6180339

Julia: 23 dígitos en 345 caracteres (15 por dígito exactamente)

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

Salida: 1.6180339887498948482045

Interpreté los caracteres y las cadenas como utilizables, siempre que no reutilizara un carácter o cadena específicos (los caracteres de una cadena podrían reutilizarse, siempre que la cadena no lo fuera); sin embargo, no me permití usar el valor int de un personaje directamente. Hay un carácter no ASCII (©).

De una manera más legible (código no real):

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 caracteres por línea, fue de 14 caracteres por línea para cada dígito

Se corrigió mi error de reutilizar operadores.

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

¿No está seguro si usar caracteres como este cuenta como literales char o no? Si este código es aceptable, se puede continuar para siempre y se pagará la deuda.

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