yes, de coreutils, a 91 lignes . Beaucoup d’entre eux sont des commentaires, mais c’est encore BEAUCOUP trop long.

Edition de septembre 2019: le fichier source a augmenté au cours des cinq dernières années et compte maintenant 126 lignes.

Ecrivez un programme qui imite yes:

• sortie vers stdoutun flux infini de "y \ n"
• il doit y avoir une option pour l'arrêter autre que de tuer le processus avec SIGKILL: mais SIGINTet ça SIGPIPEva
• vous n'êtes pas autorisé à utiliser "y" ou "\ n" ou leurs valeurs ASCII (121, 0x79, 0171, 10, 0xA ou 012)

La réponse la plus courte gagne.

Prime:

• soustrayez 10 de votre longueur de code, si vous pouvez recevoir une phrase stdinet l’imprimer au lieu de "y" (tout en incluant le saut de ligne).

CJam, 13 octets - 10 = 3

l_'x)?{_oNo}h

Pour ce faire, vous devrez utiliser l'interpréteur Java , car l'interpréteur en ligne ne sera renvoyé qu'une fois le programme terminé.

Vous pouvez abandonner le programme avec SIGINT (en appuyant sur Ctrl-C). Il lira une ligne de STDIN et imprimera cette ligne ou ysi l'entrée était vide.

Explication

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

Après clarification du PO, ce qui suit semble plus spécifique:

l{_o9c)o1}g

J'attendrai la mise à jour de la soumission jusqu'à ce que le PO réponde à mon commentaire.

Brainfuck - 38 octets

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

Il n’utilise pas 10 ou 121, car +-<>.,[]tous les caractères de la langue ont du sens, mais il les calcule assez naïvement (0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 = 10, 10 * 12 + 1 = 121).

Cela dépend probablement de l'interprète, mais il meurt ^Csur ma machine.

Brainfuck - (63-10) = 53

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

Python 3, 27 octets

Fonctionne avec au moins CPython et Jython.

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

SIGINT l'arrête.

Marbelous 14 octets

0978
]]/\++
!!

C’est assez simple, le périphérique '/ \' place deux copies à gauche et à droite, celle de droite est incrémentée ++puis tombe du tableau et est imprimée. L' ]]appareil pousse n'importe quelle bille vers la droite si STDIN est vide mais laisse tomber le premier octet sur STDIN s'il ne l'est pas. Cela déclenchera ensuite le !!périphérique qui sort du tableau. Donc, cela imprimera y \ n jusqu'à ce que vous saisissiez quoi que ce soit sur stdin.

Cela ne fonctionne que dans l'interpréteur Python.

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

#|zePG

Je cherche depuis longtemps à en obtenir un qui me satisfait. Convertit essentiellement en:

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

C #, 81 78 76 octets

Vous ne pouvez pas rivaliser avec les autres langues, mais la voici quand même:

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

Peut être tué avec SIGINT en appuyant sur Ctrl+ C.

Pas de bonus, car il faudrait plus de 10 octets pour l'obtenir.

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

L'impression nécessite System, mais le ycaractère est interdit. Par conséquent, je devais utiliser la réflexion.

Perl: 18 octets - 10 = 8

La chaîne est de STDIN.

$_=<>;{print;redo}

Ruby, 30 23 18 octets

loop{puts ?x.succ}

Peut être tué avec SIGINT en appuyant sur Ctrl+ C.

Merci à manatwork pour le partage des améliorations!

Perl, 26 octets

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

Entrée personnalisée à partir d'un argument (comme si cela yesfonctionnait réellement), 22 octets-10 = 12

{print @ARGV,$/;redo}

Entrée personnalisée à partir de stdin, 22 octets-10 = 12

while(<>){print;redo}

C, 64 55 53 45 40 - 10 = 30

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

Je ne suis pas très heureux avec cela, car le programme doit être nommé "y" et appelé avec "y" uniquement, il doit donc être dans $ PATH, mais bon, premier codegolf :)

Alternative:

C, 30 (+ 1 nom de fichier)

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

En utilisant la même technique que mon estimé collègue @ Matt Windsor

• EDIT: finit par contourner le caractère no \ n raccourci
• EDIT2: "int" est plus court que "char"
• EDIT3: n'a pas du tout besoin de cette variable
• EDIT4: un comportement légèrement indéfini ne fait de mal à personne
• EDIT5: ajouter une version alternative

Linux Bash, 33-10 = 23

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

Peut être tué avec SIGINT en appuyant sur Ctrl+ C.

Rouille, 52 caractères

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

Il n’ya apparemment pas de bonne façon d’informatique ysans être insolent à Rust - ils ont trop bien réussi à faire les personnages en toute sécurité. JE:

• Impossible de fournir une chaîne non littérale à println!, donc aucune astuce autorisée ici;
• Impossible d'ajouter 1 à 'x', car dans Rust, les caractères ne sont pas des nombres;
• Can't ROT13 (pourquoi Rust n’a-t-il pas ROT13 dans sa bibliothèque standard!?);
• Vous ne pouvez pas facilement faire quelque chose de dangereux, comme passer à des chaînes de caractères C, convertir des nombres en caractères, etc. sans être incroyablement prolixe et passer au-dessus de 52c.

Le bonus au code ne vaut pas non plus la peine, car la lecture de celle- stdinci exigerait une gestion des erreurs = 3

Une grande partie des réductions de code que je pouvais trouver impliquaient de faire de plus en plus bafouer les règles avec l'environnement de compilation:

Rust, 44 caractères (+ au moins 1 caractère pour le nom de fichier)

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

Obsolète par ci-dessous. Celui-ci ne compte probablement pas, car le nom du fichier source doit commencer y.

Edit: Rust, 36 caractères (35 sources, 1 nom de fichier)

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

Comme ci-dessus, mais le fichier doit être appelé y(pas y.rs, y). Humour, Rust remplacera la source par le binaire! Au moins sur ma machine, le binaire fonctionne après.

Rust, 37 caractères (+ équivalent de env K='y'sur votre plate-forme)

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

Celui-ci est encore pire: vous devez définir la variable d'environnement Ksur ylors de la compilation .

Edit : si vous définissez Ksur y\n, vous pouvez déposer l’ lnin println!, pour un total de 35 caractères et plusieurs facepalms:

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

Linux Bash - 19 octets

C'est probablement de la triche et un échec si vous n'avez pas / usr / bin / yes ou si vous avez un / usr / bin / xes ou / usr / bin / zes:

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

Je pense que cela répond aux exigences, même s’il enfreint peut-être la règle du "rien qui s’évalue en y". Et peut-être qu'imiter yesen courant yesest contraire aux règles.

Cela pourrait être un peu optimisé (bien que moins susceptible de fonctionner) pour le réduire à 11 octets:

/*/*/?es $*

Je ne comprenais pas comment obtenir le bonus de 10 points en lisant une chaîne de caractères stdin sans ajouter plus de 10 octets au code.

dc, 12

[30986Pdx]dx

Seules les sorties y\n. Ne lit pas de stdin, donc pas de bonus.

30986 est 0x790A (c'est-à-dire "y \ n"). La Pcommande convertit simplement le nombre en base 256 et imprime le caractère correspondant pour chaque chiffre de base 256.

Lisp commun: (30-10) = 20

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

• (read) du flux d'entrée
• imprimer dans le flux de sortie: (format t ... )
• itérer sur tous les formatarguments (un seul ici):~@{ ... ~}

• à l'intérieur de la boucle, pour chaque argument:

  • argument argument ~Asuivi d'une nouvelle ligne~%
  • rembobiner l'élément courant au précédent ~:*(boucle infinie)

Vous pouvez rompre la boucle avec Ctrl+C, ce qui signale une erreur avec les options de redémarrage (continuer / abandonner).

Haskell, 29 octets

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

Je crois que cela est arrêté par les deux SIGINTet SIGPIPE.

Ruby, 27 octets - 10 = 17

C'est juste la solution de @ ProgramFOX avec le bonus (il a fallu 9 octets pour résoudre la question du bonus).

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

dc, 21 octets - 10 = 11

C1st?st[ltP[]ps0dx]dx

Notez que l'entrée doit être encapsulée [], par exemple [no], car ?c'est le seul moyen de prendre une entrée, qui l'exécute en tant que dccode.

Commodore 64 Basic: 14 à 13 octets

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

Comme d'habitude, j'ai substitué des caractères dans PETSCII qui ne sont pas présents dans Unicode. |est utilisé pour représenter SHIFT+H, tandis que ╭représente SHIFT+U. Notez que ceci génère ASCII 'y' (valeur d'octet 121) plutôt qu'un caractère que le jeu de caractères Commodore par défaut affiche comme 'y'.

BASIC est censé être un langage de programmation de type anglais, facile à apprendre. Ajoutez les raccourcis de frappe présents dans de nombreux dialectes anciens et vous obtiendrez un résultat plus court et moins lisible que Perl.

EDIT : en "mode décalé", la taille est raccourcie de deux octets, car "y" minuscule est codé à la valeur décimale 89. L'utilisation d'un jeu de caractères non-ASCII pour contourner la règle "non autorisé à utiliser leurs valeurs ASCII" peut être tricher, cependant.

1?cH(89):rU

AWK, 38 octets

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

Variante qui lira la chaîne sur stdin: 14 octets-10 = 4

{for(;;)print}

Mais comme il ne peut pas faire les deux (revenez à "y" si aucun stdin n'est fourni), je ne suis pas sûr que cela compte ...: o)

Les deux peuvent être quittés avec Ctrl + C.

Fission , 5 octets

Rx+!N

C'est assez compétitif pour la fission. :)

Le flux de contrôle commence par un (1,0)atome allant de droite à R. xdéfinit la masse sur 120et l’ +augmente pour donner (121,0). Puis !imprime le caractère correspondant ( y) et Nimprime une nouvelle ligne. Le code source enveloppe les bords, de sorte que l'atome repasse R(ce qui ne fait plus rien maintenant), xredéfinit la masse sur 120, l' +incrémente, etc., etc.

C, 32 octets

Nécessite une petite machine endian et une compilation avec -O2 (pour éviter le débordement de pile).

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

PowerShell, 27 - 10 = 17

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

Pourrait ne pas fonctionner en Pash. Une alternative plus robuste devrait être

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

Lua, 42 octets - 10 = 32

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

Lua, 49 octets - 10 = 39

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

Les deux ont été testés avec Lua 5.1.4 et peuvent être tués avec SIGINT ( Ctrl+ C).

Perl, 31 ans

Voici une version de Perl qui se comporte réellement comme GNU yes, pour autant que je sache:

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

Cela fonctionne s'il est correct d'utiliser les commutateurs de ligne de commande de perl ( -lpour la nouvelle ligne), sinon cela aurait 3 caractères de plus:

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

CAPL 1.5+; 6 sans entrée; 10 - 10 = 0 avec entrée

Sidenote,
j'ai lu quelque part [lien?] Que les langues personnalisées ne sont pas autorisées dans les questions de golf, car elles pourraient créer des fonctions intégrées qui font exactement ce que la question demande, bien que j'ai aidé CAPL à rendre le golf plus facile en général . Si vous pensez que ce n'est pas permis ici, faites le moi savoir!

J'ai eu quelques idées de > <> et de Befunge (vous pouvez passer d'une ligne à une autre et utiliser des caractères hexadécimaux pour composer des chiffres), certaines de Ruby et d'autres des miennes pour faciliter la pratique du golf.
CAPL se lit de gauche à droite et passe d'une ligne à la fin de la ligne. Si c'est à la dernière ligne, le programme sera arrêté.

Comme personne ne connait encore cette langue, je vais essayer d’expliquer le plus possible.

Sortie y. 6 octets

bb*.n<

bb* best hexadécimal pour 11, donc bb*is 11*11= 121, qui est l’équivalent UTF-8 de y. Cette valeur est poussée dans la pile.
.Extrait la valeur la plus élevée de la pile et renvoie le format UTF-8. Comme 121en haut de la pile, l'index est ignoré ici.
nGénère une nouvelle ligne
<Envoie le pointeur au début de la ligne, répétant ainsi cette ligne. Comme nous ne nous attendons pas à une contribution, nous pouvons le faire en toute sécurité sans demander à nouveau cette entrée.

Sortie de l'entrée. 10 octets, 0 après bonus

i~a&{X:.)}

iPrend les entrées de l'utilisateur, place UTF-8 en haut de la pile, puis la longueur par la suite. Ie [72,101,108,108,111,5]
~Enlève un nombre de la pile, puis inverse cette quantité d'octets. En [111,108,108,101,72]
ahexadécimal 10, le caractère de nouvelle ligne
&{...}crée une boucle infinie. Nous avons des entrées, nous ne pouvons donc pas renvoyer le pointeur à la ligne. Je pourrais placer la fonction sur la ligne ci-dessous, ce qui me protégerait d'un octet, mais les nouvelles lignes ne sont pas autorisées dans ce défi.
XSupprime la valeur supérieure de la pile (L'index de la boucle)
:.Duplique la valeur supérieure, puis s'affiche en tant que UTF-8
)Tourne la pile à droite. ( [1,2,3,4,5]-> [5,1,2,3,4])

Cependant, cela signifie que nous commençons avec une nouvelle ligne, puis commençons à générer l'entrée, puis une nouvelle ligne, puis l'entrée, etc. Si nous ne sommes pas autorisés à commencer par une nouvelle ligne, utilisez le code suivant avec 12 octets, ou 2 après la soustraction le bonus.

iXa#~&{X:.)}

La seule nouvelle commande proposée est celle #qui pousse le nombre d'éléments de la pile dans la pile.
J'ai supprimé la longueur de i, car ajouter 1, puis permuter avec la nouvelle ligne est plus long que supprimer et récupérer la longueur.

Juste pour le plaisir, voici un programme "Hello World"

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

L' ?!opération est la même que celle de> <>

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

Avertissement: repose sur une fonctionnalité / bogue non documentée et non prise en charge.

⎕←⍣≢⍞

STDIN vide imprime des lignes vides (pas "y"), ce qui est autorisé et a été suggéré .

Essayez-le en ligne!

⎕ STDOUT avec des retours à la ligne,

← obtient

⍣ à plusieurs reprises jusqu'à

≢ il diffère de

⍞ STDIN

c'est-à-dire jamais, mais sans interruption en mettant en pause le fil.

> <>, 6 octets

b:*oao

En ne incluant pas ;à la fin, le > <> continuera à nager jusqu'à ce qu'il soit libéré par un SIGINT.

Explication

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 octets

La précédente est une solution assez ennuyeuse, alors voici une solution qui prend en compte stdin. Cela abuse du fait que le moyen par défaut de fournir des entrées à un programme > <> est echo 'input' | fish.py yes.fishoù echofournit le \ncaractère.

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

Explication

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

À 0rla fin, la boucle se passe en boucle, où nous supposons toujours que la pile est inversée avec un -1sommet.

Apparemment, ce n'est pas totalement portable. Mon sys.version est 2.7.9 (default, Dec 11 2014, 04:42:00) \n[GCC 4.9.2] , alors si le vôtre est différent, cela pourrait ne pas fonctionner, je suppose.

Python 2 - (76-10) = 66

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

Assez long, mais je voulais aller pour le bonus (même si cela coûte plus de 10 octets). Vérifier si stdin est vide ou non sans invite à la saisie est apparemment long.

Au début, j'ai mal interprété le bonus comme prenant un argument au lieu de stdin. Je suis fier de ma solution, alors je la poste quand même;)

Python 2 - (52-10 + ∞) = ∞ (invalide!)

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

sys.argvest une liste où l'élément zeroth est le nom du fichier et chaque élément après-mots est un argument donné au programme. J'ajoute une valeur falsey à la fin de la liste; s'il n'y a pas d'argument, le premier élément est cette valeur de falsey, sinon c'est le premier argument. a or bin Python renvoie la première valeur qui confirme le résultat: Si avérité, nous savons déjà que tout sera vrai, elle sera donc renvoyée. Si c'est faux, best retourné (depuis False or b== b).