yes, da coreutils, è lungo 91 linee . Molti di loro sono commenti, ma è ancora MODO troppo lungo.

Modifica da settembre 2019: il file sorgente è cresciuto negli ultimi cinque anni e ora è lungo 126 righe.

Scrivi un programma che imita yes:

• in uscita a stdoutun flusso infinito di "y \ n"
• ci deve essere un'opzione per fermarlo oltre a uccidere il processo con SIGKILL: ma SIGINTe va SIGPIPEbene
• non ti è permesso usare "y" o "\ n" o i loro valori ASCII (121, 0x79, 0171, 10, 0xA o 012)

Vince la risposta più breve.

Bonus:

• sottrai 10 dalla lunghezza del tuo codice, se puoi ricevere una frase stdine stamparla invece di "y" (ma includendo comunque l'interruzione di riga).

CJam, 13 byte - 10 = 3

l_'x)?{_oNo}h

A tale scopo dovrai utilizzare l'interprete Java , poiché l'interprete online ritorna solo al termine del programma.

È possibile interrompere il programma con SIGINT (premendo Ctrl-C). Legge una riga da STDIN e stampa quella riga o yse l'input era vuoto.

Spiegazione

l             "Read line from STDIN.";
 _            "Duplicate.";
  'x          "Push character x.";
    )         "Increment to get y.";
     ?        "Ternary operator. Replaces line with y if it was empty.";
      {    }h "Repeat while true. Leaves condition on the stack, which is the output string.";
       _o     "Duplicate line and print.";
         No   "Push string with newline and print.";

Dopo il chiarimento del PO, le seguenti sembrano più specifiche:

l{_o9c)o1}g

Aspetterò con l'aggiornamento dell'invio fino a quando l'OP non risponderà al mio commento.

Brainfuck - 38 byte

++++++++++[>++++++++++++>+<<-]>+[.>.<]

Non usa 10 o 121, perché +-<>.,[]sono comunque tutti i caratteri significativi nella lingua, ma li calcola in modo abbastanza ingenuo (0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 = 10, 10 * 12 + 1 = 121).

Questo probabilmente dipende dall'interprete, ma muore ^Csulla mia macchina.

Brainfuck - (63-10) = 53

++++++++++[>,]<<[[<]>>[[.>]<[<]>]]>[>++++++++++++>+<<-]>+[.>.<]

Python 3, 27 byte

Funziona con almeno CPython e Jython.

while 1:print(str(help)[1])

SIGINT lo ferma.

Marbelous 14 byte

0978
]]/\++
!!

Questo è piuttosto semplice, il dispositivo '/ \' posiziona due copie a sinistra e a destra, quella destra viene incrementata di, ++quindi cade dalla scheda e viene stampata. Il ]]dispositivo spinge qualsiasi marmo verso destra se STDIN è vuoto ma lascia cadere il primo byte su STDIN se non lo è. Ciò attiverà quindi il !!dispositivo, che esce dalla scheda. Quindi questo stamperà y \ n fino a quando non inserisci nulla su stdin.

Funziona solo nell'interprete Python.

Pyth, 10 9 6 byte - 10 = 0 -1 -4

#|zePG

Ho cercato per anni di ottenerne uno di cui sono soddisfatto. Fondamentalmente converte in:

#      = while True
(implied print)
|      = or
z      = (automatically initialized from stdin)
ePG    = second-to-last lowercase letter = 'y'

C #, 81 78 76 byte

Non è possibile competere con le altre lingue, ma eccolo qui:

class A{static void Main(){for(;;)System.Console.WriteLine((char)('x'+1));}}

Può essere ucciso con SIGINT premendo Ctrl+ C.

Nessun bonus, perché sarebbero necessari più di 10 byte per ottenerlo.

Java, 178

class C{public static void main(String[]a)throws Exception{for(char c='x'+1;;)((java.io.PrintStream)Class.forName("java.lang.S"+c+"stem").getField("out").get(null)).println(c);}}

La stampa richiede System, ma il ypersonaggio è proibito. Quindi, ho dovuto usare la riflessione.

Perl: 18 byte - 10 = 8

La stringa proviene da STDIN.

$_=<>;{print;redo}

Rubino, 30 23 18 byte

loop{puts ?x.succ}

Può essere ucciso con SIGINT premendo Ctrl+ C.

Grazie a manatwork per condividere miglioramenti!

Perl, 26 byte

{print chr$=*2+1,$/;redo}

Input personalizzato dall'argomento (come yeseffettivamente funziona), 22 byte-10 = 12

{print @ARGV,$/;redo}

Input personalizzato da stdin, 22 byte-10 = 12

while(<>){print;redo}

C, 64 55 53 45 40 - 10 = 30

main(int c,int**a){for(;;)puts(a[c>1]);}

Non sono molto contento di questo, poiché richiede che il programma sia chiamato "y" e sia chiamato solo con "y", quindi deve essere in $ PATH, ma ehi, primo codegolf :)

Alternativa:

C, 30 (+ 1 nome file)

main(){for(;;)puts(__FILE__);}

Usando la stessa tecnica del mio stimato collega @Matt Windsor

• EDIT: risulta aggirare il carattere no \ n rendendolo più breve
• EDIT2: "int" è più corto di "char"
• EDIT3: non aveva bisogno di quella variabile
• EDIT4: un po 'di comportamento leggermente indefinito non fa mai male a nessuno
• EDIT5: aggiungi versione alternativa

Linux Bash, 33-10 = 23

read a; while :; do echo $a; done

Può essere ucciso con SIGINT premendo Ctrl+ C.

Ruggine, 52 caratteri

fn main(){loop{println!("{}",'Y'.to_lowercase())}}

yApparentemente non c'è un bel modo di lavorare senza essere sfacciati in Rust: hanno fatto un lavoro troppo bello nel fare i caratteri in modo sicuro. IO:

• Non è possibile fornire una stringa non letterale a println!, quindi non sono ammessi trucchi lì;
• Impossibile aggiungere 1 a 'x', perché in Rust i caratteri non sono numeri;
• Impossibile ROT13 (perché Rust non ha ROT13 nella sua libreria standard !?);
• Non si può facilmente fare qualcosa di pericoloso come passare alle stringhe C, convertire da numeri in caratteri, ecc. Senza essere incredibilmente prolisso e andare oltre 52c.

Né vale la pena per il bonus del codice, perché la lettura da stdinrichiederebbe la gestione degli errori = 3

Gran parte delle riduzioni del codice che ho potuto trovare coinvolte nel fare cose sempre più in contrasto con l'ambiente del compilatore:

Rust, 44 caratteri (+ almeno 1 carattere per il nome file)

fn main(){loop{println!("{:.1}", file!())}}

Obsoleted dal basso. Questo probabilmente non conta, poiché il nome del file sorgente deve iniziare y.

Modifica: Rust, 36 caratteri (35 sorgente, 1 nome file)

fn main(){loop{println!(file!())}}

Come sopra, ma il file deve essere chiamato y(no y.rs, y). Umoristicamente, Rust sovrascriverà la fonte con il binario! Almeno sulla mia macchina, il binario funziona dopo quello però.

Rust, 37 caratteri (+ equivalente di env K='y'sulla tua piattaforma)

fn main(){loop{println!(env!("K"))}}

Questo è anche peggio: è necessario impostare la variabile di ambiente Ksu yal momento della compilazione .

Edit : se si imposta Ka y\n, si potrebbe cadere la lna println!, per un totale di 35 caratteri e diverse facepalms:

fn main(){loop{print!(env!("K"))}}

Linux Bash - 19 byte

Questo è probabilmente un imbroglio e soggetto a fallimento se non hai / usr / bin / yes o hai / usr / bin / xes o / usr / bin / zes:

/usr/bin/[x-z]es $*

Penso che soddisfi i requisiti, anche se forse sta violando la regola "niente che valuta y". E forse imitare yeseseguendo effettivamente yesè contro le regole.

Questo potrebbe essere ottimizzato un po '(anche se meno probabile che funzioni) per portarlo fino a 11 byte:

/*/*/?es $*

Non sono riuscito a capire come ottenere il bonus di 10 punti leggendo una stringa da stdin senza aggiungere più di 10 byte al codice

dc, 12

[30986Pdx]dx

Solo uscite y\n. Non legge dallo stdin, quindi nessun bonus.

30986 è 0x790A (ovvero "y \ n"). Il Pcomando converte semplicemente il numero in base 256 e stampa il carattere corrispondente per ogni 256 base base.

Lisp comune: (30-10) = 20

(format t"~@{~a~%~:*~}"(read))

• (read) dal flusso di input
• stampa nel flusso di output: (format t ... )
• iterare su tutti gli formatargomenti (solo uno qui):~@{ ... ~}

• all'interno del ciclo, per ogni argomento:

  • argomento di stampa ~Aseguito da una nuova riga~%
  • riavvolgi l'elemento corrente a quello precedente ~:*(loop infinito)

È possibile interrompere il ciclo con Ctrl+C, che segnala un errore con le opzioni di riavvio (continua / interrompi).

Haskell, 29 byte

main=putStrLn[succ 'x']>>main

Credo che questo sia fermato da entrambi SIGINTe SIGPIPE.

Rubino, 27 byte - 10 = 17

È solo la soluzione di @ ProgramFOX con il bonus (ci sono voluti i miei 9 byte per risolvere la domanda di bonus).

loop{puts ARGV[0]||?x.succ}

dc, 21 byte - 10 = 11

C1st?st[ltP[]ps0dx]dx

Si noti che è necessario includere l'input [], ad es [no]. Perché ?è l'unico modo per accettare l'input, che lo esegue come dccodice.

Commodore 64 Basic: 14 13 byte

1?C|(11↑2):R╭

Come al solito, ho effettuato sostituzioni per personaggi in PETSCII che non sono presenti in Unicode. |è usato per rappresentare SHIFT+H, mentre ╭rappresenta SHIFT+U. Si noti che ciò genera ASCII 'y' (valore byte 121) anziché un carattere che il set di caratteri Commodore predefinito visualizza come 'y'.

BASIC è presumibilmente un linguaggio di programmazione simile all'inglese facile da imparare. Inserisci le scorciatoie da tastiera presenti in molti primi dialetti e otterrai qualcosa che è più breve e meno leggibile di Perl.

EDIT : in "modalità spostata", questo si accorcia di due byte, grazie alla minuscola "y" codificata al valore decimale 89. L'utilizzo di un set di caratteri non ASCII per aggirare la regola "non consentito utilizzare i loro valori ASCII" potrebbe essere barare, però.

1?cH(89):rU

AWK, 38 byte

BEGIN{for(;;)printf("%c%c",60+61,5+5)}

Variante che leggerà la stringa su stdin: 14 byte-10 = 4

{for(;;)print}

Ma dal momento che non può fare entrambe le cose (ripristina "y" se non viene fornito alcuno stdin), non sono sicuro che conti ...: o)

Entrambi possono essere usciti con Ctrl + C.

Fissione , 5 byte

Rx+!N

Questo è abbastanza competitivo per Fission. :)

Il flusso di controllo inizia con un (1,0)atomo a destra in corrispondenza di R. ximposta la massa su 120e la +incrementa per dare (121,0). Quindi !stampa il carattere corrispondente ( y) e Nstampa una nuova riga. Il codice sorgente si avvolge ai bordi, quindi l'atomo passa di Rnuovo (che non fa nulla ora), ximposta di 120nuovo la massa , la +incrementa e così via e così via ...

C, 32 byte

Richiede la macchina little endian e la compilazione con -O2 (per evitare lo overflow dello stack).

a=11*11;main(){main(puts(&a));}

PowerShell, 27-10 = 17

param($s=$Host[1])for(){$s}

Potrebbe non funzionare in Pash. Un'alternativa più solida dovrebbe essere

param($s="$(gal gh*)"[2])for(){$s}

Lua, 42 byte - 10 = 32

while 1 do print(...or('').char(90+31))end

Lua, 49 byte - 10 = 39

y=...or(string.char(60+61))while 1 do print(y)end

Entrambi sono stati testati con Lua 5.1.4 e possono essere uccisi con SIGINT ( Ctrl+ C).

Perl, 31

Ecco una versione Perl che in realtà si comporta come GNU yes, per quanto ne so:

{print "@ARGV"||chr 11**2;redo}

Funziona se va bene usare le opzioni -ldella riga di comando di perl ( per la nuova riga), altrimenti diventerebbe più lungo di 3 caratteri:

{print "@ARGV"||chr 11**2,$/;redo}

CAPL 1.5+; 6 senza input; 10 - 10 = 0 con input

Sidenote
Ho letto da qualche parte [link?] Che le lingue personalizzate non sono consentite nelle domande sul golf, in quanto potrebbero creare funzioni integrate che fanno esattamente ciò che la domanda pone, tuttavia ho reso CAPL più semplice per giocare a golf in generale . Se pensi che questo non sia consentito qui, fammi sapere!

Ho avuto alcune idee da > <> e Befunge (puoi muoverti tra le righe e usare caratteri esadecimali per spingere i numeri), alcuni da Ruby e alcuni dai miei per rendere più facile il golf.
CAPL legge da sinistra a destra e scende di una riga alla fine della riga. Se è come ultima riga, il programma verrà chiuso.

Dato che nessuno conosce ancora questa lingua, cercherò di spiegare il più possibile.

In uscita y. 6 byte

bb*.n<

bb* bè esadecimale per 11, quindi bb*è 11*11= 121, che è l'equivalente UTF-8 di y. Questo valore viene inserito nello stack.
.Estrae il valore più alto dallo stack e genera come UTF-8. Come 121è in cima allo stack, l'indice viene ignorato qui.
nEmette una nuova riga Riporta
<il puntatore all'inizio della riga, ripetendo così quella riga. Poiché non prevediamo input, possiamo farlo in modo sicuro senza richiedere nuovamente l'input.

Uscita da input. 10 byte, 0 dopo il bonus

i~a&{X:.)}

iRiceve input dall'utente, inserisce UTF-8 nella parte superiore dello stack e successivamente ne inserisce la lunghezza. Cioè [72,101,108,108,111,5]
~estrae un numero dallo stack, quindi inverte quella quantità di byte. [111,108,108,101,72]
aVale a dire esadecimale per 10, il personaggio newline
&{...}crea un ciclo infinito. Abbiamo input, quindi non possiamo inviare il puntatore alla riga. Potrei posizionare la funzione sulla riga in basso, il che mi metterebbe in salvo un byte, ma i newline non sono ammessi in questa sfida.
XRimuove il valore superiore dallo stack (l'indice dal loop)
:.Duplica il valore superiore, quindi viene emesso come UTF-8
)Ruota lo stack a destra. ( [1,2,3,4,5]-> [5,1,2,3,4])

Tuttavia, questo significa che iniziamo con una nuova riga, quindi iniziamo a presentare l'input, quindi una nuova riga, quindi l'input, ecc. Se non ci è permesso iniziare con una nuova riga, utilizzare il seguente codice con 12 byte o 2 dopo la sottrazione il bonus.

iXa#~&{X:.)}

L'unico nuovo comando qui è #, che spinge la quantità di oggetti nella pila nella pila.
Ho rimosso la lunghezza da i, perché l'aggiunta di 1, quindi lo scambio con la nuova riga è più lungo della rimozione e del recupero della lunghezza.

Solo per divertimento, ecco un programma "Hello World"

"Hello World"#~
#?!;.<

L' ?!operazione è uguale a> <>

APL (Dyalog APL) , 5-10 = -5 byte

Avvertenza: si basa su una funzione / bug non documentato e non supportato.

⎕←⍣≢⍞

STDIN vuoto stampa righe vuote (non "y"), che è consentito ed è stato suggerito .

Provalo online!

⎕ STDOUT con newline finali,

← prende

⍣ ripetutamente fino al

≢ differisce da

⍞ STDIN

cioè mai, ma senza interruzioni mettendo in pausa il thread.

> <>, 6 byte

b:*oao

Non includendo un ;alla fine, il <<> continuerà a nuotare fino a quando non verrà rilasciato da un SIGINT.

Spiegazione

b:*oao
b         Push 11
 :        Duplicate
  *       Multiply top elements to get 121
   o      Print as character
    a     Push 10
     o    Print as character (yielding '\n')
          No program terminator, so our ><> will 
          keep on swimming this path forever.
^----' 

> <>, 17-10 = 7 byte

La precedente è una soluzione piuttosto noiosa, quindi eccone una che prende input dallo stdin. Questo abusa del fatto che il modo predefinito di fornire input a un programma > <> è echo 'input' | fish.py yes.fish, dove echofornisce il \ncarattere.

 i:0)?!v
0r}o:r~<

Spiegazione

 i:0)?!v     Load STDIN into the stack (reversed)

             NOP           <----------,
 i           Push a byte from STDIN   |
  :          Duplicate top element    |
   0         Push 0                   |
    )?       If (i > 0):              |
      !        Wrap around  ----------'
             Else:
       v       Move to the second part

0r}o:r~<     Print STDIN until halted

       <     Go right         <---------------,
      ~      Remove top element (duplicated   |
                -1 from EOF)                  |
     r       Reverse stack                    |
    :        Duplicate top element            |
   o         Output as character              |
  }          Rotate stack to right (go to     |
                next character)               |
 r           Reverse the stack                |
0            Push 0                           |
             Wrap around       ---------------'

Alla 0rfine permettono di realizzare il loop avvolgendosi, dove ipotizziamo che lo stack sia invertito con un -1in cima.

Apparentemente questo non è totalmente portatile. Il mio sys.version è 2.7.9 (default, Dec 11 2014, 04:42:00) \n[GCC 4.9.2], quindi se il tuo è diverso questo potrebbe non funzionare immagino.

Python 2 - (76-10) = 66

import sys
s=sys.stdin;a=`help`[1]if s.isatty()else s.read()
while 1:print a

Abbastanza lungo, ma volevo andare per il bonus (anche se costava più di 10 byte). Controllare se lo stdin è vuoto o meno senza richiedere input è lungo, a quanto pare.

All'inizio, ho letto male il bonus come prendere una discussione invece di stdin. Sono orgoglioso della mia soluzione per questo, quindi lo pubblicherò comunque;)

Python 2 - (52-10 + ∞) = ∞ (non valido!)

import sys
while 1:print(sys.argv+[0])[1]or`help`[1]

sys.argvè un elenco in cui l'elemento zeroth è il nome file e ogni elemento secondario è un argomento fornito al programma. Aggiungo un valore falso alla fine dell'elenco; se non ci sono argomenti, il primo elemento è quel valore false, altrimenti è il primo argomento. a or bin Python restituisce il primo valore che conferma quale sarà il risultato: se aè vero, sappiamo già che tutto sarà vero, quindi viene restituito. Se è falso, bviene restituito (poiché False or b== b).