È stato divertente! Tuttavia, con solo tre cifre, il divertimento era finito troppo presto. Questa sfida è simile, ma continueremo il divertimento.

La sfida

Stampa quante più cifre della sezione aurea φ possibile. Il rapporto aureo è definito come il numero che soddisfa φ = (φ + 1) / φ e le prime 100 cifre sono date da:

1,6180339887498948482045868343656381177203091798057628621354486227052604628189024497072072041893911375 ...

Questa sfida non riguarda il calcolo φ! Si tratta di stampare quante più cifre possibili senza usare alcun metodo per farlo due volte. Quindi trova quanti più modi creativi per ottenere le tue cifre!

restrizioni

Di per sé, stampare le cifre di φ sarebbe un po 'troppo semplice, quindi ecco le regole:

1. Devi costruire il numero in ordine da sinistra a destra , stampandolo pezzo per pezzo o costruendo una stringa da sinistra a destra e stampandolo alla fine - potresti persino generare un array di caratteri numerici e quindi unirlo e stampalo, finché lo fai in ordine. Nelle seguenti regole "stampa" e "output" possono riferirsi a uno di quei processi (ad esempio se si sta costruendo una stringa e la stringa contiene 1.6che conta 1.6già come stampata).
2. Per il tuo codice ottieni un budget di 15 caratteri per cifra . Il periodo non conta per quel budget, ma deve anche essere stampato. Si noti che la restrizione riguarda solo la dimensione del codice totale: è possibile utilizzare più di 15 caratteri per qualsiasi cifra purché non si utilizzino più in media. In effetti, potresti accumulare un "debito" nei personaggi e "ripagarlo" in seguito. Ad esempio per stampare 1.618hai 60 caratteri.
3. Le librerie / importazioni standard non contano per le dimensioni del codice. Ma non puoi dare gratuitamente questi alias abbreviati inclusi!
4. Non è necessario utilizzare la cifra che si sta generando al momento, né alcuna cifra già stampata. Ad esempio, 1potrebbe non apparire da nessuna parte nel codice sorgente, poiché è la prima cifra. Il codice che genera 8in 1.618può utilizzare una o tutte le cifre [0234579], ma nessuna [168]. A tale scopo, tutti i letterali equivalenti a una singola cifra vengono trattati come tale cifra . Quindi, se la tua lingua può rappresentare in 9quanto non '\t'ti è permesso usarla da nessuna parte, dove invece non potresti usare una 9.
5. Non è necessario produrre più cifre contemporaneamente. Dovrebbe essere possibile dividere chiaramente il codice in blocchi che generano una cifra alla volta.

6. Non si deve fare riferimento a qualsiasi built-in funzione, l'operatore / string matematico / booleano / bit-saggio, variabile o costante, che è stato utilizzato nel codice che ha generato una cifra precedente. Le eccezioni sono la conversione da numero intero a stringa, la concatenazione di stringhe e le funzioni di stampa che potrebbero essere necessarie per ogni singola cifra. Nota che non importa con quale nome ti riferisci a qualsiasi built-in: solo perché alias un built-in PIper entrambi pe qnon significa che devi usare puna volta e quna volta. Allo stesso modo, ti è permesso usare un nome due volte se si riferisce a due diversi built-in, come stringa lengthe matrice length.

   _{Se il tuo linguaggio di programmazione non ha funzioni, usa il tuo miglior giudizio su ciò che sarebbe equivalente - ad esempio per lo script bash, invocare altri programmi dovrebbe seguire le regole imposte alle funzioni}

7. La tua richiesta deve essere scritta in una sola lingua. Pertanto, non è possibile eseguire l'interprete di un'altra lingua per accedere anche ai built-in di quella lingua.

implicazioni

I seguenti punti sono tutti sottintesi dalle regole precedenti, ma le aggiungo qui per evitare domande che sono già emerse nella sandbox:

• Non è consentito sovrascrivere parti dell'output stampando alcuni backspaces (di solito '\b') in mezzo.
• Sono vietati i loop che generano / producono più cifre. (Tuttavia, i loop che calcolano una singola cifra vanno bene.)
• (1 + √5)/2È vietato utilizzare una versione offuscata o dividere i numeri di Fibonacci per ottenere più di una singola cifra.
• Non è possibile precalcolare le 10 cifre e memorizzarle in 10 variabili, quindi fare riferimento a quelle, perché quei riferimenti alle variabili non generano la cifra - il codice che riempie la variabile lo fa, quindi questa è una violazione della regola 6.
• In effetti, non è possibile riutilizzare alcun risultato precedente (o intermedio), perché ciò significherebbe che due cifre condividono il codice per essere generato .
• Altrimenti, puoi usare qualsiasi mezzo (che non deve essere puramente matematico) per generare le cifre. (E dovresti!)
• In realtà non è necessario calcolare nulla, se è possibile estrarre le cifre corrette da molti luoghi diversi utilizzando la libreria standard.
• È possibile utilizzare più volte un operatore durante la generazione di una sola cifra, quindi 2+2+2è giusto creare il primo 6(anche se è improbabile il più breve).
• È possibile utilizzare qualsiasi letterale tutte le volte che si vuole, perché non sono costanti predefinite. Quindi, purché non sia necessario stampare 5, è possibile inserire 5nel codice tutte le s che si desidera.
• Non è possibile codificare l'output, poiché ciò implicherebbe l'utilizzo delle cifre che si stanno trasmettendo.

In breve: non usare alcun metodo per generare cifre due volte e non usare la cifra che stai producendo o che hai già stampato.

Se trovi una scappatoia che ti consente di ottenere un punteggio (quasi) infinito, per favore non rovinare la sfida sfruttandola, ma fammi sapere così posso vedere se la scappatoia può essere risolta senza rompere nulla.

punteggio

Il programma che stampa il numero più alto di cifre vince correttamente. In caso di pareggio il codice più corto rompe il pareggio.

Aggiungi una versione non commentata commentata che identifichi quale parte del codice genera quale cifra.

PS: Se qualcuno batte le 100 cifre sopra, eccone alcune .

PHP, 100 cifre

Probabilmente sto piegando un po 'le regole qui, ma PHP ha dozzine di costanti tra cui scegliere:

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

Questo probabilmente non è un codice molto portatile, ma funziona bene sul mio sistema. Ecco il codice che l'ha generato:

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

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 byte attualmente, (10,6 per cifra).

Produzione:

1.618033988749894848204586834365638117

Restrizioni autoimposte

Ho aggiunto alcune restrizioni aggiuntive per limitare l'uso delle funzionalità del linguaggio che banalizzerebbero il problema. Ad esempio, la dereference array @{...}e l'indice finale di array $#{...}vengono utilizzati una sola volta. Ogni matrice utilizzata è generata in modo diverso (confrontare [c,c,c,c], [b..j], split('',$~), map(glob,"{,,,}{,}")). Inoltre, nessun simbolo o parola nuda viene utilizzato più di una volta, sebbene ciò sia esplicitamente consentito nella descrizione della sfida. Penso che sia una buona idea per perl (o qualsiasi linguaggio con variabili speciali int-only (ce ne sono altri?)), Perché limita il numero di conversioni int implicite.

pezzi

!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 cifre, 231 caratteri rilevanti

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 per 54 cifre, 808 caratteri

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

Questo programma funziona con ruby 2.1.0p0 (2013-12-25 revision 44422) [x86_64-openbsd]. I sistemi diversi da OpenBSD 5.5 potrebbero avere valori diversi per alcune cifre.

interpretazioni

Le restrizioni di questa sfida, in particolare la restrizione 6, non sono precise per Ruby. Quindi aggiungo le mie interpretazioni:

1. Le parentesi, il punto e il doppio punto non sono operatori. Le parentesi cambiano semplicemente l'ordine delle operazioni. Il punto chiama i metodi, come in $<.fileno, e i due punti diventano costanti, come in IO::LOCK_NB. Il nome del metodo o della costante fa parte dell'operazione. Poiché () . ::non sono operatori, non applico loro la restrizione 6. Potrei riutilizzarli per generare più cifre.
2. Un metodo con un'implementazione diversa è un metodo diverso. Ad esempio, Array#counte Enumerable#countnon sono la stessa funzione per la restrizione 6. Entrambi i metodi agiscono allo stesso modo, ma Array#countsostituiscono Enumerable#countcon un'implementazione diversa. Se utilizzo Array#countper generare una cifra, posso utilizzare Enumerable#countper generare un'altra cifra.
3. La classe # nuovo è un metodo. In Ruby, Mutex.new, Random.new, Time.newe così via consultare lo stesso metodo, Class#new. Uso SignalException.newper generare una cifra. A causa della restrizione 6, non potrò mai più utilizzarlo Class#new.
4. Le costanti per classi o moduli sono ancora costanti. In Ruby, i nomi delle classi piacciono Floate IOsono costanti! Uso IO::LOCK_NBper generare una cifra. A causa della restrizione 6, non potrò mai più utilizzarlo IO. Questa interpretazione lega solo Ruby e non altre lingue in cui i nomi dei pacchetti non sono costanti.
5. I letterali non sono costanti. Sebbene 2 sia una costante matematica (indipendente da qualsiasi variabile), non è una costante in Ruby. Non applico la restrizione 6 ai valori letterali e posso riutilizzare i valori letterali 2 per più di una cifra.
6. I letterali non sono operatori. Non applico la restrizione 6 alle parentesi o alle virgolette che formano array letterali, hash, espressioni regolari o stringhe, come in [] {} // ''. Posso sempre usare tali letterali per generare più cifre.
7. Due costanti con lo stesso valore sono la stessa costante. File::APPENDe IPSocket::LOCK_UNsono due nomi per lo stesso numero 8. La restrizione 6 dice "non importa con quale nome ti riferisci a qualsiasi built-in". Perché File::APPENDe IPSocket::LOCK_UNdifferiscono solo per nome, devono essere la stessa costante, quindi non posso usarli per due cifre.
8. Due cifre potrebbero non riferirsi alla stessa variabile globale. Questo chiude una scappatoia. La restrizione 6 si applica solo a funzioni, operatori e costanti. La restrizione 4 si applica solo ai letterali. $SAFEè una variabile globale incorporata, non una funzione, un operatore, costante o letterale. $SAFEha il valore 0. Con la scappatoia, posso riutilizzare $SAFEper generare ogni cifra 0 nel programma. Chiudo la scappatoia interpretando la restrizione 6 per limitare anche le variabili globali.

Commenti

La prima riga è #!ruby -rdate -rdigest -ropenssl -rprime -rset -rsocket. Rubino analizza questa linea e carichi sei parti della sua libreria standard, come per require 'date', require 'digest'e così via. Non conto questi 56 caratteri, poiché la restrizione 3 esenta "importazioni / include librerie standard".

Il resto del programma chiama printcon un lungo elenco di argomenti, per convertirli in stringhe e stamparli in ordine. Gli argomenti sono questi:

1. 1from 2/2: division Fixnum # /
   . from ?.: stringa letterale a singolo carattere
2. 6da 9-3: sottrazione Fixnum # -
3. 1da 3&5: bitwise e Fixnum # &
   • Con l'interpretazione 5, potrei 3riutilizzarlo.
4. 8da 2*4: moltiplicazione Fixnum # *
5. 0da 2^2: bitwise exclusive-o Fixnum # ^
6. 3da 7%4: modulo Fixnum #%
7. 3da 55>>4: spostamento a destra Fixnum # >>
8. 9da 5+4: aggiunta Fixnum # +
9. 8da 2<<2: spostamento a sinistra Fixnum # <<
10. 8da -~7: negazione del complemento Fixnum # - @ Fixnum # ~
    • Sottrazione Fixnum # - e negazione Fixnum # - @ sono metodi diversi.
11. 7da 5|2: bitwise o Fixnum # |
12. 4da 2**2: esponenziale Fixnum # **
13. 9da (2r+2+5).to_i: aggiunta razionale Rational # + Rational # to_i
    • Dall'interpretazione 2, Fixnum # + e Rational # + sono metodi diversi. Entrambi aggiungono numeri, ma hanno implementazioni diverse, a partire da tipi diversi per il numero sinistro.
    • I letterali razionali come 2rsono nuovi in ​​Ruby 2.1. 2r+2chiama Rational # + e restituisce un altro razionale; 2r+2+5chiama di nuovo Rational # + .
    • Ruby stampa razionali come 2/1e galleggia come 2.0. Per risolvere questo problema, converto in numero intero: to_i arrotonda verso zero, il soffitto arrotonda per eccesso , il pavimento arrotonda per difetto .
14. 8da (2.2+5).ceil: aggiunta float Float # + Float # ceil
    • Dall'interpretazione 1, posso usare le parentesi ()e .ripetere il punto .
15. 9da (55r/5-2).floor: divisione e sottrazione razionali Rational # / Rational # - Rational # floor
16. 4da (2.2*2).to_i: moltiplicazione float Float # * Float # to_i
17. 8da (2r*2*2).ceil: moltiplicazione razionale Rational # * Rational # ceil
18. 4da (2.2**2).floor: esponenziale razionale N. razionale **
19. 8da 2.to_bn<<2: spostamento a sinistra con OpenSSL grande numero Fixnum # a_bn OpenSSL :: BN # <<
20. 2da __LINE__: costante magica per il numero di riga corrente
21. 0from $<.to_i: descrittore di file dello standard input IO # to_i
22. 4from IO::LOCK_NB: flag per blocco file non bloccante
    • Questa è la prima di molte costanti a dipendere dal sistema. OpenBSD ha 4.
    • Dall'interpretazione 4, non posso più usare IO. Dall'interpretazione 7, non posso più usare alcuna costante con il valore di 4.
23. 5from Errno::EIO::Errno: numero per errore di input / output
24. 8from File::APPEND: flag da aggiungere a un file
    • Questa è una scappatoia attorno all'interpretazione 4. Non posso usare IO, ma Fileeredita costanti da IO, quindi File::APPENDè un modo diverso di ottenere IO::APPEND.
25. 6from 'aaaaaa'.size: lunghezza della stringa String # size
26. 8from ?a.encoding.name.sub(/\D+/,''): parte del nome della codifica String # codifica Codifica # nome String # sub
    • Dall'interpretazione 6, posso usare nuovamente le virgolette.
    • A partire da Ruby 2.0, la codifica predefinita è UTF-8. Prendo il nome "UTF-8" e sostituisco / \ D + / corrispondente "UTF-" con una stringa vuota. Questo produce "8".
27. 3from %w[a a a].size: lunghezza dell'array # Dimensione array
28. 4from %w[a b c d].to_set.size: numero di elementi nel set Array # to_set Set # size
29. 3from %w[a a a].count: count all elements # array # count
    • La differenza tra Array # size e Array # count è che quest'ultimo accetta argomenti opzionali per scegliere quali elementi contare. Non passo argomenti, quindi conta tutti gli elementi.
30. 6da Socket::AF_NS: numero per la famiglia di indirizzi NS
31. 5da Date.jd(Date::ITALY).wday: numero del giorno della settimana per venerdì 15 ottobre 1582, quando l'Italia passò al calendario gregoriano Date :: jd Date # wday
32. 6da *Digest::MD5.digest(?j).scan(/\d/): prima cifra ASCII nel digest binario MD5 di "j" Digest :: MD5 :: digest String # scan
    • String # scan restituisce una matrice di tutte le corrispondenze. Il *passa gli elementi dell'array come argomenti per print. Questo array è ["6"].
33. 3from Set[?a,?b,?c].count: count all elements Set :: [] Enumerable # count
    • Dall'interpretazione 2, Array # count e Enumerable # count sono metodi diversi.
34. 8from SignalException.new('FPE').signo: numero di SIGFPE Class # new SignalException # signo
35. 1da Float::ROUNDS: modalità arrotondamento, qui 1 per arrotondamento al più vicino
36. 1from begin(newline) exit false(newline) rescue Object(newline) $!.status(newline) end: esci dallo stato per errore
    • Questo è lo stesso valore di SystemExit.new(false).status, ma dall'interpretazione 3, non posso più chiamare Classe # nuova . Invece alzo e salvo un SystemExit.
37. 7from Process::RLIMIT_NPROC: numero per limite di risorse per numero di processi per un utente
38. 7da :aaaaaaa.size: lunghezza del simbolo Simbolo # dimensioni
39. 2da Prime.first: primo numero primo Enumerable # first
40. 0da ?/.next: stringa successiva dopo "?" String # successiva
41. 3from {a:p,b:p,c:p}.size: lunghezza dell'hash # dimensione # String # p
42. 0da STDIN.lineno: numero di riga corrente per l'ingresso standard IO # lineno
    • Dall'interpretazione 8, non posso riutilizzare $<. Io uso STDIN. La differenza è che $<è una variabile globale ed STDINè una costante. Un programma può essere impostato $<su un input diverso, ma STDINè sempre il valore originale di $<.
43. 3da ?a.crypt('at')[/\d/]: prima cifra ASCII nella password crittografata String # crypt String # []
    • Il sistema con diversa funzione crypt () darà risultati diversi.
44. 0from {a: :a}.find_index([:a,:a]): indice della prima chiave: a, valore: a in hash Enumerable # find_index
    • Uso un hash, non un array, perché Array # find_index è un alias per l' indice Array # , che prevedo di utilizzare presto.
45. 9da /b/=~'aaaaaaaaab': indice dove stringa corrisponde / b / Regexp # = ~
46. 1from [?a,?b].index(?b): indice della prima "b" nella matrice Array # index
47. 7da :aaaaaaab=~/b/: indice dove il simbolo corrisponde / b / Simbolo # = ~
48. 9da ?\t.ord: valore ASCII della scheda "\ t" String # ord
49. 8from 'aaaaaaaab'=~/b/: indice dove stringa corrisponde / b / String # = ~
    • In base all'interpretazione 2, Regexp # = ~ e String # = ~ sono metodi diversi.
50. 0from open(?/).pos: posizione nel file dopo aver aperto la directory root "/" come file # kernel N. IO # pos pos
51. 5from 'aaaaab'.index(?b): indice della prima "b" nella stringa String # index
52. 7da ?\a.bytes{|b|break b}: valore ASCII dell'avviso "\ a" String # byte
    • Questo funziona ripetendo i byte in "\ a", ma interrompendo il ciclo restituendo il primo byte.
53. 6from 'aaaaaaa'.rindex(?a): indice dell'ultima "a" nella stringa String # rindex
54. 2from %w[a a].map.size: dimensione dell'enumeratore che mappa dall'array Array # map Enumerator # size

Java, 21 cifre, 276 caratteri

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

Rubino, 74 caratteri, 10 cifre

È solo un inizio; Devo andare, quindi lo migliorerò in seguito.

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

Ho 76 personaggi salvati per dopo, quando sarà più difficile!

Rubino, 17 cifre, 168 byte

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

Non sono ancora stato costretto a fare qualcosa di particolarmente intelligente, potrei tornare indietro e aggiungere cifre.

Golfscript , 17 cifre

Un tentativo semplice. Golfscript può avere molti built-in non alfanumerici di una lettera, ma non ha molti built-in nel suo insieme!

".",                         # 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 cifre in 65 caratteri

Lo aggiornerò presto! Per ora, stampa 1.6180e non contiene cifre.

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

Spiegazione

I seguenti metodi vengono utilizzati per generare le cifre:

1: stato di uscita di false

6: lunghezza della stringa

1: nlabuso

8: killnumeri di segnale

0: valore numerico di un'espressione vuota

Mathematica 9 8 cifre, in 86 83 78 caratteri.

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

Produzione:

1.6180339

Julia - 23 cifre in 345 caratteri (15 esattamente per cifra)

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

Uscita: 1.6180339887498948482045

Ho interpretato i caratteri e le stringhe come utilizzabili, purché non riutilizzassi un carattere o una stringa specifici (i caratteri in una stringa potrebbero essere riutilizzati, purché la stringa non lo fosse); tuttavia, non mi sono permesso di usare direttamente il valore int di un personaggio. Esiste un carattere non ASCII (©).

In un modo più leggibile (non codice reale):

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 caratteri per riga, era 14 caratteri per riga per ogni cifra

Risolto il mio errore di riutilizzo degli operatori.

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

Non sei sicuro che l'utilizzo di caratteri come questo contenga come caratteri letterali o no? Se questo codice è accettabile, può essere continuato per sempre e il debito verrà rimborsato.

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