Il tuo compito è scrivere un programma per stampare la somma dei codici ASCII dei caratteri del programma stesso. Non è consentito aprire alcun file (è vietato qualsiasi input come argomenti della riga di comando, input standard o file).

Vince il programma che stampa il numero più basso (ovvero ha la somma più bassa di codici ASCII).

Ecco un esempio (non il più breve) di un tale programma scritto in C:

#include <stdio.h>
int main(){
printf("4950");/*i*/
return 0;
}

(nessuna nuova riga dopo })

wc, stampa 0

Qualcuno ha detto "linguaggi da gatto", quindi ...

Un file vuoto:

Eseguire con wc -c file.wc. A 0 byte, penso che questo sia il vincitore nella categoria "non proprio un linguaggio di programmazione".

Anche

gatto, stampe 80 (base 13)

80

Nessuna riga finale, il numero 80 ₁₃ equivale a 104 in decimale. Puoi andare più corto con 60 ₁₇ (102 dic), ma ho pensato che "base 13" varrebbe più punti geek.

EDIT: Nuovo wcesempio, questo può essere eseguito come programma.

#!/usr/bin/wc
ÿÿzw17

(Come codificato in latino-1 - ÿ è un byte con valore 255)

La somma dei byte è 2223, l'output è:

  2  2 23 ./w

PHP, m4 e altre lingue simili a un gatto: 150

150

Ho trovato questa soluzione usando un semplice programma Haskell per forzare la forza:

f :: String -> Bool
f s = (read s :: Int) == (sum . map fromEnum) s

main = mapM_ print [filter f $ sequence $ replicate n ['0'..'9'] | n <- [1..10]]

Brainf * ck, 255

-.¤

Questo non stamperà il numero 255, ma piuttosto il 255 ° carattere ASCII.

Questo potrebbe essere considerato un imbroglio perché il compilatore BF salta sopra ¤.

Javascript, stampa 9432 6902

(function a(){b="("+a+")()";c=0;for(i=0;i<b.length;i++){c+=b.charCodeAt(i-0)}alert(c)})()

Questa è la prima soluzione di quine finora, a meno che non capisca correttamente quella di Haskell .

PowerShell

((310))

stampe 310.

Perl, 500

say     500

Ci sono due schede tra saye 500. :)

(Esegui come one-liner con perl -E, per quanto posso dire questo è all'interno delle regole)

Rubino, stampe 380

p (380)

Nessuna nuova riga finale dopo la parentesi di chiusura.

PowerShell

(230)

stampa 230, ovviamente.

PowerShell

-(-320)

stampe 320.

J, 150

?!6

Con l'avvertenza che sarà corretto solo 1/720 del tempo.

Python, stampe 781

print  781

Due spazi.

Elemento, 220

Questo è un linguaggio di mia creazione ed è documentato sulla mia risposta a un'altra domanda qui .

220`!

Ecco una procedura dettagliata di come funziona: 220Spinge quel numero sullo stack. Quindi `` outputs the top element of the stack. The! `Esegue quindi un logico non nello stack di controllo (uno stack separato), impostandolo su 1.

PHP, stampa 4440

<?php
for($x=0;$x<15000;$x++)if($x==4440){printf($x);exit;}

PowerShell, stampa 3902

&{[char[]]$myinvocation.Line|%{$s+=+$_};$s}

Cerca nella riga attualmente in esecuzione e somma i valori dei punti di codice.

INTERCAL, 1572

Non riesco a credere che nessuno abbia ancora fatto INTERCAL!

DOREADOUT#1572


DOGIVEUP

(Include terminazione newline.) Questo programma stampa MDLXXII.

Perl, stampe 690

die 690 . $/

Oppure, se possiamo pubblicare una riga ( perl -E)

say(570)

Stampe 570.

(Nessuna nuova riga finale)

JavaScript, 1750 900 860 790

alert(790)

(Ritorno a capo (CR, \ro \x0D) dopo o prima del programma)

Questi programmi si trovano a forza bruta.

Valori più grandi:

alert(860)%0
alert(900)&&6
document.write(1750)

Java -128

So che leggere stdin non è permesso, ma volevo fornire un esempio di come ho calcolato il mio punteggio.

Il mio codice somma il conteggio ASCII di se stesso trasmesso su stdin e stampa -128

class P{public static void main(String[]z)throws Exception{byte v=0;int b=0;while((b=System.in.read())!=-1){v+=(byte)b;}System.out.println(v);}}

Nessuna nuova riga finale

Rubino, stampa 300

p   300

C'è uno spazio e una scheda tra il pe il 300. Nessuna nuova riga finale.

File batch, 500

ECHO  500

Inoltre, notare i due spazi tra "ECHO" (maiuscolo apposta) e "500".

C, 1700

Strano: nessuno ha ancora pubblicato una soluzione C (escluso l'esempio nella domanda).

main(R){puts("1700");}

Nessuna nuova riga alla fine.

K ( 923 796 795 746 513)

Non sono sicuro che ciò si ritorni alle regole o meno. Non usa lo stdin, si apre come un vettore di byte e somme.

+/1:.z.f

Uso:

q scriptname.k

modifica 2012.05.08 - non è necessario eseguire l'mss dell'handle di file 2012.05.09 - salvato 1 punto convertendo in byte anziché in int

2012.05.17 - Può salvare un sacco di punti leggendo il file come bytestream anziché come testo:

J, 198

33*6

e

6*33

L'ho trovato con la forza bruta. In J non ci sono soluzioni a 1 o 2 caratteri e l'unica soluzione a 3 caratteri è 150. Escludendo eventuali bug nella mia ricerca, non ci sono nemmeno altre soluzioni a 4 caratteri.

Dal canale IRC #jsoftware, avevamo anche <.%:10!20429 e un quine di auto-conteggio +/a.i.2#(,{:)'+/a.i.2#(,{:)'''al 1706.

aC 1160

invocato con eco e spazi vuoti, l'intera stringa, inclusi 7 spazi vuoti, echo 1160 | bcha un byte di 1160.

echo 1160    |  bc

150 funziona anche per bc:

echo "150" > 150
bc -q 150
150

D, 9752

questo in realtà lo calcola in modo simile al mio quine

enum c=q{import std.stdio;void main(){int s;foreach(d;"enum c=q{"~c~"};mixin(c);")s+=d;write(s);}};mixin(c);

Spazio bianco, 369

Questo programma di 20 caratteri stampa il numero 369, che è la somma dei valori ascii dei suoi caratteri (che sono i caratteri Tab, Space, Linefeed, qui simboleggiati rispettivamente da T, S, L):

SSSTSTTTSSSTLTLSTLLL

(369 = 7 * 9 + 8 * 32 + 5 * 10, con 7 schede, 8 spazi e 5 avanzamenti riga).

Haskell, 7518

Una piccola modifica del mio quine :

main=print.sum.map fromEnum$q++show q;q="main=print.sum.map fromEnum$q++show q;q="

Brainf * ck, 253 (o 252)

Leggero miglioramento sulla soluzione di Peter Olson:

---.H

Se sono consentiti non stampabili, è possibile migliorarlo ulteriormente aggiungendo a -e sostituendo Hcon il codice ASCII 26.

Scala 1090

println (1090)

Python, 5440

Il punteggio più alto vince, giusto?

import sys
print sum(ord(i)for i in open(sys.argv[0]).read())

Ho solo pensato di pubblicarlo comunque b / c è una soluzione a metà strada.