Nel minor numero di byte possibile, il tuo compito è scrivere un programma che produca:

3.14

Per celebrare un tardo Pi, ovviamente! :)

Regole

Puoi farlo come preferisci, ma ci sono alcune restrizioni.

• Si può non usare operazioni aritmetiche qualsiasi punto del programma. Questo include +, -, *, /, %, ^(esponenziale), ecc ... Questo include anche l'incremento (solitamente ++), decrementando ( --), operazioni bit per bit e ogni costruito in funzioni che può essere usato come una sostituzione come sum(), prod(), mod(), double(), pow(), sqrt(), inc(), dec()ecc. (discrezione dell'autore)
• Le cifre 3, 1e 4potrebbero non apparire ovunque nel codice.
• Si può non usare alcun predefiniti variabili / costanti che la lingua può avere in sostituzione 3, 1e 4. (A discrezione dell'autore)
• Si può anche non utilizzare le funzioni trigonometriche, come sin(), cos(), tan(), arcsin(), arccos(), arctan(), sinh(), cosh(), tanh(), ecc ... (discrezione dell'autore)
• Si può non utilizzare valori incorporati o predefiniti di Pi (o 3.14). Nessuna richiesta web .
• Il tuo programma non può richiedere input di alcun tipo (oltre a eseguirlo).
• 3.14è l' unica cosa che potresti produrre, non può far parte di un output più lungo / più grande.

Vincitore

Vince la risposta con il minor numero di byte il 18 aprile . In bocca al lupo!

In attesa di risposte intelligenti da menti intelligenti! Malbolgere qualcuno? : P

CJam - 8 6

S`,'.E

CJam è un nuovo linguaggio che sto sviluppando, simile a GolfScript - http://sf.net/p/cjam .
Ecco la spiegazione:

Sè una variabile preinizializzata nello spazio ("")
`genera la rappresentazione in stringa dell'ultimo valore - che è esattamente " "(3 caratteri)
,calcola la lunghezza della stringa (3)
'.è il carattere punto
Eè una variabile preinizializzata in 14; 3, 1 e 4 non sono ammessi ma non dice nulla su 14 :)

Ringraziamenti a Doorknob per l'idea di backtick

PHP - 22 byte

<?=date('n.j',8899e5);

Il Pi Day dell'anno 1998 è stato davvero fantastico!

C, 39

Suppone che la macchina sia little-endian e utilizzi lo standard IEEE in virgola mobile.

main(){printf("%.2f",*(float*)"P@I@");}

Il fatto divertente è che in "P@I@"realtà non è correlato PIma è equivalente a 0x40494050quale è la rappresentazione3.144550323486328

http://ideone.com/uXVEtl

dc , 11 9 byte

zE[.]znPp

• z Spingere la profondità della pila corrente (0) sulla pila
• EPush E ₁₆ (== 14 ₁₀ )
• [.] Spingere la stringa "."
• z Spingere la profondità della pila corrente (3) sulla pila
• n Pop 3 e stampa come numero
• PPop "." e stampa come carattere
• p Pop 14 e stampa come numero con newline

Produzione:

$ dc <<< zE[.]znPp
3.14
$ 

JavaScript ( ES5 ) 20 byte

Una variante della soluzione JS di m.buettner.

(x='.'+0xE).length+x

Modifica: JavaScript ( ES5 ) 18 byte

Una variante dell'idea di ComFreek di utilizzare la funzione di decodifica base64.

atob('Mw')+'.'+0xE

Modifica: Javascript ( ES5 ) 16 byte

Se l' +operatore unario è autorizzato a trasmettere una stringa a un numero, può essere ridotto a:

+atob('MDMuMTQ')

Haskell, 41 byte

Quando è il giorno più in Australia?

p=(\(a:n:y:t:i:m:e:_)->[m,a,t,e])['.'..]

Modificato per aggiungere: come l'altra risposta di Haskell, che genera una stringa, quindi ha le virgolette. Puoi segnare 33 e rispettare rigorosamente le regole, ma è meno divertente:

p=putStr$map([','..]!!)[7,2,5,8]

Codice Morse, 33 byte

morse -d ...-- .-.-.- .---- ....-

Tecnicamente parlando, l'informazione richiede solo 21 byte.

J - 15 11 10 caratteri

Reso più breve, usando il fantastico i:.

6{i:6.28j8

Ha spiegato:

• 6.28j8 - Il numero complesso 6.28 + 8i.
• i:- Qui è dove avviene la magia. i:su un numero complesso A + Bi, B ≠ 0 prende B + 1 punti equidistanti dall'intervallo [-A, A].
• 6{ - Prendi l'elemento all'indice 6, che è 3.14.

In precedenza, abbiamo avuto le seguenti assurdità:

|.'.'2}":22b8d5

Spiegato dall'esplosione:

         22b8d5  NB. 8d5 in base 22 = 4163
       ":        NB. convert to string
  '.'2}          NB. change character at index 2 to '.'
|.               NB. reverse to make '3.14'

Riga di comando Linux, 35 byte

Questo da nessuna parte è vicino a vincere, ma qui è per divertimento:

ping -w2 67502862|grep -oP '.\..\d'

Uscita (dopo 2 secondi):

$ ping -w2 67502862|grep -oP '.\..\d'
3.14
$

GolfScript, 18 13 12

'.'.`,\.,n`,

Vecchia versione:

'...','.'.,'....',

È molto artistico, solo 3 personaggi unici! ;)

Come funziona:

# cmd   # stack
'...',  # 3
'.'.    # 3 '.' '.'
,       # 3 '.' 1
'....', # 3 '.' 1 4

Ecco una spiegazione della versione a 12 caratteri (molto più interessante, IMO):

'.' # '.'
.`, # '.' 3
\.  # 3 '.' '.'
,   # 3 '.' 1
n`, # 3 '.' 1 4

Funziona perché n`,è 4, poiché n`è '"\n"'. Stessa logica per '.'`,. Inoltre scambia invece di creare una nuova stringa per salvare un carattere (grazie @algorithmshark).

Versione alternativa:

'pi ','.'.,'day!',

o

'Hi ','.'.,'PPCG',

O qualsiasi cosa in quelle corde, davvero. : P

La risposta dell'OP.

Mathematica, 21 20 18

Sembra economico ...

Range[2,5,.06][[20]]

o

Range[2,5,.02][[58]]

Capito come farlo 18:

Range[-.86,5][[5]]

Haskell, 49 48 12

(48 include il nuovo carattere di riga)

p=[-6..]
r=concat$show(p!!9):".":(show$p!!20):[]

Eseguilo chiamando la rfunzione.

Utilizzando il metodo come con Mathematica sopra, è possibile digitare questo in GHCi:

[-2.86..]!!6

Java, 87 86

class P{public static void main(String[]a){System.out.print("tri".length()+"."+0xe);}}

Scala, 27

Tradotto da Java come suggerito da Score_Under . (Non conosco davvero Scala)

print("tri".length+"."+0xe)

Bash, 50

I messaggi di aiuto / errore non sono risorse esterne, sono l'output di un comando!

Se qualcosa è abuso di regole, questo è tutto. Utilizza la coincidenza a cui è stato inviato il messaggio di aiuto STDERRdal comando esatto

ping6

è lungo 314 caratteri (almeno su Ubuntu 13.10 con iputils-121221). EDIT: apprezzo che sia molto meno portatile di quanto mi aspettassi ...

m=`ping6|&wc -c`
false
o=$?
echo ${m:0:o}.${m:o:2}

La prima riga prende la lunghezza del carattere del messaggio di aiuto e lo memorizza in una variabile.

Come nelle mie altre risposte, le prossime righe ottengono il numero 1 prendendo lo stato di uscita di false(non molto portatile ma dopo tutto è code-golf !), Quindi utilizzare quel valore per inserire un punto decimale nell'ultima riga

Produzione: 3.14

Bash + TeX 28 byte

Se hai installato TeX:

tex -v|head -c8|cut -d\  -f2

Il numero di versione di TeX si avvicina asintoticamente al miglioramento del software. Quindi, col passare del tempo, è possibile utilizzare questa implementazione (non conforme) per stampare sempre più cifre!

tex -v|cut -d\  -f2 | head -n1

Questo ha stampato 3.1415926 nel 2011; a partire da gennaio 2014, verrà stampato 3.14159265.

JavaScript, 20 byte

'...'.length+'.'+0xe

Usalo in una console, in modo che il risultato sia stampato direttamente. Altrimenti, alert(...)aggiungerà altri 7 caratteri.

Come la mia altra risposta, ho appena notato che è molto più breve in JS.

L'idea di usare 0xeper 14 è presa dalla presentazione del PO con il gentile permesso del PO.

Data GNU, 17 byte

date -d2/5 +%u.%y

Questo ha garantito il funzionamento solo quest'anno, ma non vedo alcuna limitazione nelle regole al riguardo ;-)

Il +è semplicemente indica l'inizio del formato, per datee non è un'aggiunta aritmetica. Lo stesso vale per l' -indicazione della data di inserimento.

Produzione:

$ date -d2/5 +%u.%y
3.14
$

Bash, 17 byte

tr 0 .<<<$[62#MC]

Dash, 41 byte

perl -pechomp,s/./$./<<$


..










.

Bash 23 22

seq 2 .02 5|sed -n 58p

Shell (senza espansione della cronologia) 20

seq 2 .02 5|sed 58!d

Python, 39 o 28 47 o 34

(Grazie Score_Under per averlo giocato così tanto)

print"%s.%s%c"%(len('aaa'),len('a'),52)

+ ecco l'operatore di concatenazione delle stringhe, non l'aggiunta.

Copiando il 0xetrucco dall'OP, ecco 28 caratteri con l'aiuto di @psal

print('%X.%s'%(675,0xE))[2:]

Vecchie versioni:

print str(len('aaa'))+'.'+str(len('a'))+chr(52)

print str(len('aaa'))+'.'+str(0xe)

print"%s.%s"%(len('aaa'),0xe)

GolfScript, 8 byte

'??.'(\(

Questo programma contiene caratteri ASCII non stampabili, quindi non può essere incollato direttamente qui. Invece, i punti interrogativi nel codice sopra dovrebbero essere sostituiti con i byte 03e 0Ein esadecimali.

Per comodità, ecco un dump esadecimale del programma attuale. Gli utenti Unix / Linux possono eseguire questo dump esadecimale xxd -rper ricostruire il programma:

0000000: 2703 0e2e 2728 5c28                      '...'(\(

Spiegazione:

• I primi cinque byte del programma formano una stringa a virgoletta singola che codifica i tre caratteri con i codici ASCII 3, 14 e 46 (= periodo ASCII).

• (taglia il primo carattere dalla stringa e inserisce il suo codice ASCII (3) nello stack. \scambia i primi due oggetti nello stack, riportando la stringa in alto, e il secondo (taglia un altro carattere dalla stringa, spingendo di nuovo il suo codice ASCII (14) nello stack.

Alla fine del programma, lo stack (esclusa la stringa di input vuota) si presenta così:

3 "." 14

Alla fine del programma, il comportamento predefinito dell'interprete GolfScript è di stringere e stampare tutto nello stack, producendo l'output desiderato.

bash - 39

Sappiamo tutti che le prime cifre di Pi possono essere calcolate dalla seguente dichiarazione:

Posso avere un grande contenitore di caffè

Abbiamo bisogno solo di 2 decimali, giusto?

m=May
i=I
h=have
echo ${#m}.${#i}${#h}

Mathematica - 78

DateList["March"<>ToString@FromDigits@"E"]~DateString~{"MonthShort",".","Day"}

Perl, 15 20 byte

print 05706=~s/0/./r
print 0xbc6=~s/0/./r

tr + Bash, 17 byte

tr a-j 0-9<<<d.be

I -caratteri qui non sono operatori di sottrazione aritmetica. Indicano la portata.

Produzione:

$ tr a-j 0-9<<<d.be
3.14
$

BASH, 57

Questo è più lungo della maggior parte delle risposte, ma non c'è niente di male nel provare.

f=`echo aaaaaaaaaaaaa|wc -c`;e=`echo aa|wc -c`;echo $e.$f

dà

3.14

C, 36

main(){printf("%d\b.%o\b",' ','`');}

JavaScript - 23 byte

atob('Mw')+atob('LjE0')

Grazie a nderscore (vedi i suoi commenti)!

C #

 ((int)'ĺ').ToString("#\\.##");

ĺ è il carattere 314, non una variabile o costante predefinita. .ToString formatta l'output in una cifra, un punto e quindi altre 2 cifre.

GolfScript, 13 10

{xy}.*'.'\

Grazie a Ilmari Karonen per la versione migliorata!

xe ysono caratteri non stampabili (vedere http://www.asciitable.com/ per ulteriori informazioni), rispettivamente ETXe SO, che decodificano in 3 e 14.

Che cosa fa questo codice dovrebbe essere abbastanza chiaro.

Nota: la seguente regola

You may not use any predefined variables/constants that your language may have as a replacement for 3, 1, and 4. (Author's discretion)

non è rotto, poiché i caratteri ASCII non sono né variabili né costanti.

Nuovo sul sito e non posso ancora scrivere commenti, quindi lo posterò qui. Mi chiedo solo questa soluzione Javascript:

'...'.length+'.'+0xe

e questa regola:

3.14 è l'unica cosa che potresti produrre, non può far parte di un output più lungo / più grande.

Se eseguo questo codice nella mia console del browser, ottengo:

"3.14"

o usando Nodo dalla riga di comando:

'3.14'

ma se eseguo questo codice:

parseFloat('...'.length+'.'+0xe)

Ottengo:

3.14

Utilizzando Node.js per eseguire un file .js, posso scrivere:

console.log('...'.length+'.'+0xe)

e prendi:

3.14

Mathematica, 56 byte

(l=ToString@StringLength@#&)@"..."<>"."<>l@"."<>l@"...."

Non c'è molto da dire. Sto generando le cifre come lunghezze di stringa e le concateno.