Isso foi divertido! No entanto, com apenas três dígitos, a diversão acabou cedo demais. Esse desafio é semelhante, mas continuaremos com a diversão.

O desafio

Imprima o maior número possível de dígitos da Proporção áurea .. A Proporção áurea é definida como o número que satisfaz φ = (φ + 1) / φ e os 100 primeiros dígitos são dados por:

1.6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375 ...

Esse desafio não é sobre a computação! Trata-se de imprimir o maior número possível de dígitos sem usar nenhum método para fazer isso duas vezes. Portanto, encontre o maior número possível de maneiras criativas de obter seus dígitos!

Restrições

Por si só, imprimir os dígitos de φ seria um pouco simples demais, então aqui estão as regras:

1. Você precisa construir o número na ordem da esquerda para a direita , imprimindo-a peça por peça ou construindo uma string da esquerda para a direita e imprimindo-a no final - você pode até gerar uma matriz de caracteres de dígito e, em seguida, imprima, desde que faça em ordem. Nas regras a seguir, "print" e "output" podem se referir a qualquer um desses processos (por exemplo, se você está construindo uma string, e a string contém o 1.6que conta como 1.6já foi impresso).
2. Para o seu código, você recebe um orçamento de 15 caracteres por dígito . O período não conta para esse orçamento, mas deve ser impresso também. Observe que a restrição é apenas no tamanho total do código: você pode usar mais de 15 caracteres para qualquer dígito, desde que não use mais, em média. De fato, você pode criar uma "dívida" em caracteres e "pagar" mais tarde. Por exemplo, para imprimir 1.618você tem 60 caracteres.
3. As inclusões / importações da biblioteca padrão não contam para o tamanho do código. Mas você não pode fornecer esses aliases abreviados de graça!
4. Você não deve usar o dígito que está gerando no momento nem o que já imprimiu. Por exemplo, 1pode não aparecer em nenhum lugar no seu código-fonte, porque é o primeiro dígito. O código que gera o 8no 1.618pode usar qualquer um ou todos os dígitos [0234579], mas nenhum [168]. Para esse propósito, todos os literais equivalentes a um único dígito são tratados como esse dígito . Portanto, se o seu idioma puder representar 9como '\t'você não está autorizado a usá-lo em qualquer lugar, onde você não poderá usar um 9.
5. Você não deve produzir vários dígitos ao mesmo tempo. Deve ser possível dividir claramente seu código em partes que geram um dígito por vez.

6. Você não deve se referir a qualquer built-in função, operador / string matemática / boolean / bit-wise, variável ou constante que você usou no código que gerou um dígito antes. Exceções são funções de conversão de número inteiro para string, concatenação de strings e impressão, que você pode precisar para cada dígito. Observe que não importa com que nome você se refere a nenhum built-in: apenas porque você alias um built-in PIpara ambos pe qnão significa que você pode usar puma qvez. Da mesma forma, você está autorizado a usar um nome duas vezes se refere a dois diferentes built-ins, como cordas lengthe variedade length.

   _{Se a sua linguagem de programação não tiver funções, use seu melhor julgamento sobre qual seria o equivalente - por exemplo, para scripts bash, a chamada de outros programas deve seguir as regras impostas às funções}

7. Seu envio deve ser escrito em um único idioma. Portanto, não é necessário executar o intérprete de outro idioma para obter acesso aos recursos internos desse idioma.

Implicações

Os pontos a seguir estão todos implícitos nas regras acima, mas eu os adiciono aqui para evitar perguntas que já surgiram na sandbox:

• Você não tem permissão para substituir partes de sua saída imprimindo alguns backspaces (geralmente '\b') no meio.
• São proibidos os loops que geram / geram vários dígitos. (Os loops que calculam um único dígito são bons, no entanto.)
• (1 + √5)/2É proibida a utilização de uma versão ofuscada ou a divisão dos números de Fibonacci para obter mais de um dígito.
• Você não pode pré-calcular os 10 dígitos e armazená-los em 10 variáveis ​​e depois apenas se referir a eles, porque essas referências a variáveis ​​não geram o dígito - o código que preenche a variável, portanto, isso é uma violação da regra 6.
• Na verdade, você não pode reutilizar nenhum resultado anterior (ou intermediário), porque isso significaria que dois dígitos compartilhariam código para serem gerados .
• Caso contrário, você pode usar qualquer meio (que não precise ser puramente matemático) para gerar os dígitos. (E você deveria!)
• De fato, não há necessidade de calcular nada, se você puder obter os dígitos corretos de muitos lugares diferentes usando sua biblioteca padrão.
• Você pode usar um operador várias vezes enquanto gera um único dígito; portanto, 2+2+2é justo jogar o primeiro 6(embora seja improvável o menor).
• Você pode usar qualquer literal quantas vezes quiser, porque elas não são constantes internas. Contanto que você não precise imprimir 5, você pode quantos 5s em seu código quiser.
• Você não pode codificar a saída, porque isso envolveria o uso dos dígitos que você está produzindo.

Resumindo: não use nenhum método para gerar dígitos duas vezes e não use o dígito que você está produzindo no momento ou se já foi impresso.

Se você encontrar uma brecha que permita obter uma pontuação (quase) infinita, não estrague o desafio explorando-a, mas avise-me para que eu possa ver se a brecha pode ser corrigida sem quebrar nada.

Pontuação

O programa que imprime o maior número de dígitos vence corretamente. Em caso de empate, o código mais curto quebra o empate.

Por favor, adicione uma versão comentada não destruída que identifique qual parte do seu código gera qual dígito.

PS: Se alguém ultrapassar os 100 dígitos acima, aqui estão mais alguns .

PHP, 100 dígitos

Provavelmente estou flexionando um pouco as regras aqui, mas o PHP tem dezenas de constantes para escolher:

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

Provavelmente não é um código muito portátil, mas funciona bem no meu sistema. Aqui está o código que o gerou:

<?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 atualmente, (10,6 por dígito).

Saída:

1.618033988749894848204586834365638117

Restrições auto-impostas

Adicionei algumas restrições adicionais para limitar o uso de recursos de idioma que trivializariam o problema. Por exemplo, a desreferência de matriz @{...}e o índice final da matriz $#{...}são usados ​​apenas uma vez. Cada matriz usada é gerado de uma maneira diferente (comparar [c,c,c,c], [b..j], split('',$~), map(glob,"{,,,}{,}")). Além disso, nenhum símbolo ou palavra de barra é usado mais de uma vez, embora isso seja explicitamente permitido na descrição do desafio. Eu acho que é uma boa idéia para perl (ou qualquer linguagem com variáveis ​​especiais int-only (existem outras?)), Porque limita o número de conversões implícitas implícitas.

Peças

!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 trabalha com ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-openbsd]. Sistemas diferentes do OpenBSD 5.5 podem ter valores diferentes para alguns dígitos.

Interpretações

As restrições desse desafio, especialmente a restrição 6, não são precisas para Ruby. Então eu adiciono minhas próprias interpretações:

1. Os parênteses, ponto e dois pontos duplos não são operadores. Os parênteses apenas alteram a ordem das operações. O ponto chama métodos, como em $<.fileno, e os dois pontos duplos obtêm constantes, como em IO::LOCK_NB. O nome do método ou constante faz parte da operação. Como () . ::não são operadores, não aplico a restrição 6 a eles. Eu posso reutilizá-los para gerar mais dígitos.
2. Um método com uma implementação diferente é um método diferente. Por exemplo, Array#counte Enumerable#countnão são a mesma função para a restrição 6. Os dois métodos agem da mesma forma, mas Array#countsubstituem Enumerable#countpor uma implementação diferente. Se eu uso Array#countpara gerar um dígito, posso usar Enumerable#countpara gerar outro dígito.
3. A classe # new é um método. Em Ruby, Mutex.new, Random.new, Time.newe assim por diante se referem ao mesmo método, Class#new. Eu uso SignalException.newpara gerar um dígito. Por causa da restrição 6, nunca mais poderei usá-lo Class#new.
4. As constantes para classes ou módulos ainda são constantes. Em Ruby, nomes de classes gostam Floate IOsão constantes! Eu uso IO::LOCK_NBpara gerar um dígito. Por causa da restrição 6, nunca mais poderei usá-lo IO. Essa interpretação liga apenas Ruby, e não outras linguagens onde os nomes dos pacotes não são constantes.
5. Literais não são constantes. Embora 2 seja uma constante matemática (independente de qualquer variável), não é uma constante no Ruby. Não aplico a restrição 6 aos literais e posso reutilizar o literal 2 por mais de um dígito.
6. Literais não são operadores. Não aplico a restrição 6 aos colchetes ou aspas que formam matrizes literais, hashes, expressões regulares ou strings, como em [] {} // ''. Eu sempre posso usar esses literais para gerar mais dígitos.
7. Duas constantes com o mesmo valor são a mesma constante. File::APPENDe IPSocket::LOCK_UNexistem dois nomes para o mesmo número 8. A restrição 6 diz: "não importa com o nome que você se refere a qualquer built-in". Como File::APPENDe IPSocket::LOCK_UNdiferem apenas pelo nome, elas devem ser a mesma constante, portanto, não posso usá-las por dois dígitos.
8. Dois dígitos podem não se referir à mesma variável global. Isso fecha uma brecha. A restrição 6 se aplica apenas a funções, operadores e constantes. A restrição 4 se aplica apenas a literais. $SAFEé uma variável global interna, não uma função, operador, constante nem literal. $SAFEtem o valor 0. Com a brecha, posso reutilizar $SAFEpara gerar todos os dígitos 0 no programa. Fecho a brecha interpretando a restrição 6 para também restringir variáveis ​​globais.

Comentários

A primeira linha é #!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket. Rubi analisa esta linha e cargas seis partes de sua biblioteca padrão, como que por require 'date', require 'digest'e assim por diante. Não conto esses 56 caracteres, porque a restrição 3 isenta "a biblioteca padrão importa / inclui".

O restante do programa chama printcom uma longa lista de argumentos para convertê-los em seqüências de caracteres e imprimi-los em ordem. Os argumentos são os seguintes:

1. 1from 2/2: division Fixnum # /
   . from ?.: cadeia de caracteres únicos literal
2. 6de 9-3: subtração Fixnum # -
3. 1de 3&5: bit a bit e Fixnum # &
   • Pela interpretação 5, posso usar 3novamente.
4. 8from 2*4: multiplication Fixnum # *
5. 0from 2^2: bitwise exclusive-ou Fixnum # ^
6. 3de 7%4: módulo Fixnum #%
7. 3de 55>>4: shift direito Fixnum # >>
8. 9de 5+4: adição Fixnum # +
9. 8from 2<<2: left shift Fixnum # <<
10. 8from -~7: negação do complemento Fixnum # - @ Fixnum # ~
    • Subtração Fixnum # - e negação Fixnum # - @ são métodos diferentes.
11. 7from 5|2: bit a bit ou Fixnum # |
12. 4from 2**2: exponentiation Fixnum # **
13. 9de (2r+2+5).to_i: adição racional Rational # + Rational # to_i
    • Pela interpretação 2, Fixnum # + e Rational # + são métodos diferentes. Ambos adicionam números, mas têm implementações diferentes, começando de tipos diferentes para o número esquerdo.
    • Literais racionais como 2rsão novos no Ruby 2.1. 2r+2chama o Rational # + e retorna outro racional; 2r+2+5chama o Rational # + novamente.
    • Ruby imprime racionais como 2/1e flutua como 2.0. Para corrigir isso, eu converter para número inteiro: to_i rodadas para zero, ceil rodadas para cima, piso arredonda para baixo.
14. 8from (2.2+5).ceil: adição de flutuador Float # + Float # ceil
    • Pela interpretação 1, posso usar parênteses ()e pontuar .novamente.
15. 9from (55r/5-2).floor: divisão e subtração racional Rational # / Rational # - Rational # floor
16. 4from (2.2*2).to_i: multiplicação de flutuador Float # * Float # to_i
17. 8from (2r*2*2).ceil: multiplicação racional Rational # * Rational # ceil
18. 4from (2.2**2).floor: exponenciação racional Rational # **
19. 8from 2.to_bn<<2: shift à esquerda com grande número do OpenSSL Fixnum # to_bn OpenSSL :: BN # <<
20. 2from __LINE__: constante mágica para o número da linha atual
21. 0from $<.to_i: descritor de arquivo da entrada padrão IO # to_i
22. 4de IO::LOCK_NB: sinalizador para bloqueio de arquivo sem bloqueio
    • Esta é a primeira de muitas constantes a depender do sistema. O OpenBSD possui 4.
    • Pela interpretação 4, não posso mais usar IO. Pela interpretação 7, não posso mais usar nenhuma constante com o valor de 4.
23. 5from Errno::EIO::Errno: número para erro de entrada / saída
24. 8from File::APPEND: flag para anexar a um arquivo
    • Esta é uma brecha em torno da interpretação 4. Posso não usar IO, mas Fileherda constantes de IO, então File::APPENDé uma maneira diferente de obter IO::APPEND.
25. 6from 'aaaaaa'.size: comprimento da string String # size
26. 8from ?a.encoding.name.sub(/\D+/,''): parte do nome da codificação String # encoding Encoding # name String # sub
    • Pela interpretação 6, posso usar aspas de string novamente.
    • Desde o Ruby 2.0, a codificação padrão é UTF-8. Pego o nome "UTF-8" e substituo / \ D + / correspondente "UTF-" por uma string vazia. Isso produz "8".
27. 3from %w[a a a].size: length of array Tamanho da matriz #
28. 4from %w[a b c d].to_set.size: número de elementos no conjunto Array # to_set Set # size
29. 3from %w[a a a].count: count todos os elementos Array # count
    • A diferença entre o tamanho Array # e Array # contagem é que este último tem argumentos opcionais para escolher quais elementos para contar. Eu não passo argumentos, então conta todos os elementos.
30. 6from Socket::AF_NS: number para a família de endereços NS
31. 5de Date.jd(Date::ITALY).wday: número do dia da semana para sexta-feira 15 de outubro de 1582, quando a Itália mudou para o calendário gregoriano Data :: jd Data # wday
32. 6from *Digest::MD5.digest(?j).scan(/\d/): primeiro dígito ASCII no resumo binário MD5 de "j" Digest :: MD5 :: digest String # scan
    • String # scan retorna uma matriz de todas as correspondências. O *passa os elementos da matriz como argumentos para print. Essa matriz é ["6"].
33. 3from Set[?a,?b,?c].count: count todos os elementos Set :: [] Enumerable # count
    • Pela interpretação 2, Array # count e Enumerable # count são métodos diferentes.
34. 8from SignalException.new('FPE').signo: número de SIGFPE Class # new SignalException # signo
35. 1from Float::ROUNDS: modo de arredondamento, aqui 1 para arredondar para o mais próximo
36. 1from begin(nova linha) exit false(nova linha) rescue Object(nova linha) $!.status(nova linha) end: status de saída por falha
    • Esse é o mesmo valor que SystemExit.new(false).status, mas pela interpretação 3, não posso mais chamar Classe # novo . Em vez disso, levanto e resgato um SystemExit.
37. 7from Process::RLIMIT_NPROC: número para limite de recursos para número de processos para um usuário
38. 7from :aaaaaaa.size: comprimento do símbolo Symbol # size
39. 2from Prime.first: primeiro número primo Enumerável # primeiro
40. 0from ?/.next: próxima string depois de "?" String # next
41. 3from {a:p,b:p,c:p}.size: comprimento do hash Hash # size String # p
42. 0from STDIN.lineno: número da linha atual para entrada padrão IO # lineno
    • Pela interpretação 8, não posso reutilizar $<. Eu uso STDIN. A diferença é que $<é uma variável global e STDINé uma constante. Um programa pode definir $<uma entrada diferente, mas STDINé sempre o valor original de $<.
43. 3from ?a.crypt('at')[/\d/]: primeiro dígito ASCII na senha criptografada String # crypt String # []
    • O sistema com função diferente crypt () dará um resultado diferente.
44. 0from {a: :a}.find_index([:a,:a]): índice da primeira chave: a, valor: a em hash Enumerable # find_index
    • Eu uso um hash, não uma matriz, porque Array # find_index é um alias para o índice Array # , que pretendo usar em breve.
45. 9from /b/=~'aaaaaaaaab': index onde a string corresponde a / b / Regexp # = ~
46. 1from [?a,?b].index(?b): índice do primeiro "b" na matriz Array # index
47. 7from :aaaaaaab=~/b/: index onde o símbolo corresponde a / b / Symbol # = ~
48. 9from ?\t.ord: valor ASCII da guia "\ t" String # ord
49. 8from 'aaaaaaaab'=~/b/: index onde a string corresponde a / b / String # = ~
    • Pela interpretação 2, Regexp # = ~ e String # = ~ são métodos diferentes.
50. 0from open(?/).pos: posição no arquivo após abrir o diretório raiz "/" como um arquivo Kernel # open IO # pos
51. 5from 'aaaaab'.index(?b): índice do primeiro "b" na string String # index
52. 7from ?\a.bytes{|b|break b}: valor ASCII do alerta "\ a" String # bytes
    • Isso funciona iterando os bytes em "\ a", mas interrompendo o loop retornando o primeiro byte.
53. 6from 'aaaaaaa'.rindex(?a): índice do último "a" na string String # rindex
54. 2from %w[a a].map.size: tamanho do enumerador que mapeia da 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
    );
  }
}

Ruby, 74 caracteres, 10 dígitos

É apenas um começo; Eu tenho que ir, então melhorarei mais tarde.

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

Tenho 76 caracteres guardados para mais tarde, quando ficar mais 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)]*''

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

Ainda não fui forçado a fazer algo particularmente inteligente, posso voltar e adicionar dígitos.

Golfscript , 17 dígitos

Uma tentativa direta. O Golfscript pode ter muitos embutidos não alfanuméricos de uma letra, mas não possui muitos embutidos como um todo!

".",                         # 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 em 65 caracteres

Vou atualizar isso em breve! Por enquanto, ele apenas imprime 1.6180e não contém dígitos.

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

Explicação

Os seguintes métodos são usados ​​para gerar os dígitos:

1: status de saída de false

6: comprimento da corda

1: nlabuso

8: killnúmeros de sinal

0: valor numérico de uma expressão vazia

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

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

Saída:

1.6180339

Julia - 23 dígitos em 345 caracteres (15 por dígito exatamente)

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

Saída: 1.6180339887498948482045

Interpretei caracteres e seqüências de caracteres como utilizáveis, desde que não reutilizasse um caractere ou sequência específica (caracteres em uma sequência poderiam ser reutilizados, desde que a sequência não fosse); no entanto, não me permiti usar o valor int de um personagem diretamente. Há um caractere não ASCII (©).

De uma maneira mais legível (não código 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 linha, era de 14 caracteres por linha para cada dígito

Corrigido meu erro 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;
}

Não tem certeza se o uso de caracteres como este conta como literais ou não? Se esse código for aceitável, ele poderá ser continuado para sempre e a dívida será devolvida.

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