yes, von coreutils, ist 91 Zeilen lang . Viele von ihnen sind Kommentare, aber das ist immer noch WAY zu lang.

Bearbeitung ab September 2019: Die Quelldatei ist in den letzten fünf Jahren gewachsen und umfasst nun 126 Zeilen.

Schreiben Sie ein Programm, das Folgendes imitiert yes:

• Ausgabe in stdouteinen unendlichen Strom von "y \ n"
• Es muss eine andere Option geben, um den Prozess zu stoppen, als ihn zu beenden SIGKILL: aber SIGINTund SIGPIPEsind in Ordnung
• Sie dürfen weder "y" noch "\ n" oder deren ASCII-Werte (121, 0x79, 0171, 10, 0xA oder 012) verwenden.

Kürzeste Antwort gewinnt.

Bonus:

• Subtrahieren Sie 10 von Ihrer Codelänge, wenn Sie einen Ausdruck erhalten stdinund anstelle von "y" ausdrucken können (aber immer noch den Zeilenumbruch enthalten).

CJam, 13 Bytes - 10 = 3

l_'x)?{_oNo}h

Sie müssen hierfür den Java-Interpreter verwenden , da der Online-Interpreter erst nach dem Beenden des Programms zurückgibt.

Sie können das Programm mit SIGINT abbrechen (durch Drücken von Strg-C). Es liest eine Zeile aus STDIN und gibt diese Zeile aus, oder ywenn die Eingabe leer war.

Erläuterung

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

Nach der Klarstellung des OP scheint Folgendes genauer zu sein:

l{_o9c)o1}g

Ich werde mit der Aktualisierung der Einreichung warten, bis das OP auf meinen Kommentar antwortet.

Brainfuck - 38 Bytes

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

Es werden keine 10 oder 121 verwendet, da +-<>.,[]es sowieso alle bedeutungsvollen Zeichen in der Sprache sind, aber es berechnet sie ziemlich naiv (0 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 + 1 =) 10, 10 · 12 + 1 = 121).

Dies hängt wahrscheinlich vom Interpreter ab, stirbt aber ^Cauf meinem Rechner ab.

Brainfuck - (63-10) = 53

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

Python 3, 27 Bytes

Funktioniert mindestens mit CPython und Jython.

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

SIGINT stoppt es.

Marbelous 14 Bytes

0978
]]/\++
!!

Dies ist ziemlich einfach, das '/ \' Gerät platziert zwei Kopien links und rechts davon, die rechte wird inkrementiert ++und fällt dann von der Platine und wird gedruckt. Das ]]Gerät schiebt eine beliebige Kugel nach rechts, wenn STDIN leer ist, lässt jedoch das erste Byte von STDIN nach unten fallen, wenn dies nicht der Fall ist. Dies wird dann das !!Gerät auslösen , das die Karte verlässt. Dies wird also y \ n drucken, bis Sie etwas auf stdin eingeben.

Dies funktioniert nur im Python-Interpreter.

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

#|zePG

Ich habe seit Ewigkeiten versucht, eine zu finden, mit der ich zufrieden bin. Grundsätzlich konvertiert zu:

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

C #, 81 78 76 Bytes

Kann nicht mit den anderen Sprachen konkurrieren, aber hier ist es trotzdem:

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

Kann mit SIGINT durch Drücken von Ctrl+ getötet werden C.

Kein Bonus, weil es mehr als 10 Bytes dauern würde, um es zu bekommen.

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

Drucken erfordert System, aber das yZeichen ist verboten. Daher musste ich Reflexion verwenden.

Perl: 18 Bytes - 10 = 8

Die Zeichenfolge stammt von STDIN.

$_=<>;{print;redo}

Ruby, 30 23 18 Bytes

loop{puts ?x.succ}

Kann mit SIGINT durch Drücken von Ctrl+ getötet werden C.

Dank an manatwork für das Teilen von Verbesserungen!

Perl, 26 Bytes

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

Benutzerdefinierte Eingabe von Argument (wie yestatsächlich funktioniert), 22 Bytes-10 = 12

{print @ARGV,$/;redo}

Benutzerdefinierte Eingabe von 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]);}

Ich bin nicht sehr glücklich damit, da es erfordert, dass das Programm "y" heißt und nur mit "y" aufgerufen wird, also muss es in $ PATH sein, aber hey, erster Codegolf :)

Alternative:

C, 30 (+ 1 Dateiname)

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

Mit der gleichen Technik wie mein geschätzter Kollege @Matt Windsor

• BEARBEITEN: Es stellt sich heraus, dass die Umgehung des Zeichens no \ n kürzer gemacht wurde
• EDIT2: "int" ist kürzer als "char"
• EDIT3: brauchte diese Variable überhaupt nicht
• EDIT4: Ein bisschen undefiniertes Verhalten hat noch nie jemanden verletzt
• EDIT5: Alternative Version hinzufügen

Linux Bash, 33-10 = 23

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

Kann mit SIGINT durch Drücken von Ctrl+ getötet werden C.

Rust, 52 Zeichen

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

Es gibt anscheinend keine ygute Art zu rechnen, ohne in Rust frech zu sein - sie haben es zu gut gemacht, Zeichen sicher zu tun. ICH:

• Es kann keine nicht-wörtliche Zeichenfolge für angegeben werden println!, daher sind dort keine Tricks zulässig.
• Kann nicht zu 1 addieren 'x', da in Rust Zeichen keine Zahlen sind;
• Kann nicht ROT13 (warum hat Rust ROT13 nicht in seiner Standardbibliothek !?);
• Es ist nicht einfach, unsichere Dinge wie das Ablegen in C-Strings, das Konvertieren von Zahlen in Zeichen usw. zu tun, ohne unglaublich wortreich zu sein und über 52c zu gehen.

Es lohnt sich auch nicht für den Code-Bonus, denn das Lesen von stdinwürde eine Fehlerbehandlung = 3 erfordern

Ein Großteil der Codeverkürzungen, die ich finden konnte, war darauf zurückzuführen, dass ich in der Compiler-Umgebung zunehmend gegen Regeln verstieß:

Rust, 44 Zeichen (+ mindestens 1 Zeichen für Dateiname)

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

Veraltet von unten. Dieser zählt wahrscheinlich nicht, da der Name der Quelldatei damit beginnen muss y.

Edit: Rust, 36 Zeichen (35 Quellen, 1 Dateiname)

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

Wie oben, aber die Datei muss aufgerufen werden y(nicht y.rs, y). Humorvoll überschreibt Rust die Quelle mit der Binärdatei! Zumindest auf meinem Rechner funktioniert die Binärdatei danach jedoch.

Rust, 37 Zeichen (+ Äquivalent zu env K='y'auf Ihrer Plattform)

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

Dieser ist sogar noch schlimmer: die Umgebungsvariable einstellen müssen , Kum ybei der Kompilierung .

Bearbeiten : Wenn Sie setzen Kauf y\n, könnten Sie die Drop - lnin println!, für eine Gesamtsumme von 35 Zeichen und mehrere facepalms:

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

Linux Bash - 19 Bytes

Dies ist wahrscheinlich ein Betrug und kann fehlschlagen, wenn Sie nicht über / usr / bin / yes oder ein / usr / bin / xes oder / usr / bin / zes verfügen:

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

Ich denke, es erfüllt die Anforderungen, obwohl es möglicherweise gegen die Regel "Nichts, das als y bewertet wird" verstößt. Und vielleicht verstößt das Nachahmen yesdurch Laufen yesgegen die Regeln.

Dies könnte ein wenig optimiert werden (obwohl es weniger wahrscheinlich ist, dass es funktioniert), um es auf 11 Bytes zu reduzieren:

/*/*/?es $*

Ich konnte nicht herausfinden, wie ich den 10-Punkte-Bonus erhalten konnte, indem ich eine Zeichenfolge aus stdin las, ohne dem Code mehr als 10 Bytes hinzuzufügen

dc, 12

[30986Pdx]dx

Nur Ausgänge y\n. Liest nicht von stdin, also kein Bonus.

30986 ist 0x790A (dh "y \ n"). Der PBefehl konvertiert einfach die Zahl in Basis 256 und gibt das entsprechende Zeichen für jede Basis 256-Stelle aus.

Common Lisp: (30-10) = 20

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

• (read) aus dem Eingabestream
• In Ausgabestream drucken: (format t ... )
• Iterieren Sie über alle formatArgumente (nur eines hier):~@{ ... ~}

• innerhalb der Schleife für jedes Argument:

  • print Argument ~Agefolgt von einem Zeilenumbruch~%
  • Aktuelles Element auf das vorherige zurückspulen ~:*(Endlosschleife)

Sie können die Schleife mit unterbrechen Ctrl+C, was bei Neustartoptionen einen Fehler signalisiert (Fortfahren / Abbrechen).

Haskell, 29 Bytes

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

Ich glaube, das wird von beiden SIGINTund gestoppt SIGPIPE.

Ruby, 27 Bytes - 10 = 17

Es ist nur @ ProgramFOXs Lösung mit dem Bonus (es dauerte 9 Bytes, um die Bonusfrage zu lösen).

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

Gleichstrom, 21 Bytes - 10 = 11

C1st?st[ltP[]ps0dx]dx

Beachten Sie, dass die Eingabe eingeschlossen werden muss [], z. B. [no]weil dies ?die einzige Möglichkeit ist, Eingaben zu übernehmen, die sie als dcCode ausführen .

Commodore 64 Basic: 14 13 Bytes

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

Wie üblich habe ich in PETSCII Zeichen ersetzt, die in Unicode nicht vorhanden sind. |wird verwendet, um darzustellen SHIFT+H, während ╭darstellt SHIFT+U. Beachten Sie, dass dies ASCII-Zeichen "y" (Byte-Wert 121) anstelle eines Zeichens ausgibt, das im Standard-Commodore-Zeichensatz als "y" angezeigt wird.

BASIC ist angeblich eine leicht zu erlernende Programmiersprache in englischer Sprache. Wenn Sie die Tastenkombinationen verwenden, die in vielen frühen Dialekten enthalten sind, erhalten Sie etwas, das kürzer und weniger lesbar ist als Perl.

BEARBEITEN : Im "Shifted Mode" werden diese zwei Bytes kürzer, da Kleinbuchstaben "y" mit dem Dezimalwert 89 codiert sind. Die Verwendung eines Nicht-ASCII-Zeichensatzes zur Umgehung der Regel "Die ASCII-Werte dürfen nicht verwendet werden" kann sein Schummeln.

1?cH(89):rU

AWK, 38 Bytes

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

Variante, die den String auf stdin liest: 14 bytes-10 = 4

{for(;;)print}

Aber da es nicht beides kann (kehren Sie zu "y" zurück, wenn kein stdin angegeben ist), bin ich mir nicht sicher, ob es zählt ...: o)

Beide können mit Strg + C verlassen werden.

Spaltung , 5 Bytes

Rx+!N

Dies ist ziemlich wettbewerbsfähig für Fission. :)

Der Kontrollfluss beginnt mit einem (1,0)rechtsgerichteten Atom bei R. xsetzt die Masse auf 120und +erhöht sie, um zu geben (121,0). Dann !druckt das entsprechende Zeichen ( y) und Ndruckt eine neue Zeile. Der Quellcode wird an den Rändern herumgewickelt, so dass das Atom Rerneut durchläuft (was jetzt nichts mehr macht), xdie Masse auf 120erneut setzt, sie +inkrementiert und so weiter und so fort ...

C 32 Bytes

Benötigt Little-Endian-Maschine und Kompilierung mit -O2 (um Stapelüberlauf zu vermeiden).

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

PowerShell, 27 - 10 = 17

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

Funktioniert möglicherweise nicht in Pash. Eine robustere Alternative sollte sein

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

Lua, 42 Bytes - 10 = 32

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

Lua, 49 Bytes - 10 = 39

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

Beide wurden mit Lua 5.1.4 getestet und können mit SIGINT ( Ctrl+ C) getötet werden.

Perl, 31

Hier ist eine Perl-Version, die sich tatsächlich wie GNU verhält yes, soweit ich das beurteilen kann:

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

Dies funktioniert, wenn es in Ordnung ist, die Befehlszeilenoptionen von Perl ( -lfür die neue Zeile) zu verwenden, da es sonst 3 Zeichen länger werden würde:

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

CAPL 1.5+; 6 ohne Eingabe; 10 - 10 = 0 bei Eingabe

Nebenbemerkung
Ich habe irgendwo gelesen, dass benutzerdefinierte Sprachen in Golffragen nicht zulässig sind, da sie integrierte Funktionen enthalten können, die genau das tun, was die Frage stellt. Ich habe jedoch CAPL entwickelt, um das Golfspiel im Allgemeinen zu vereinfachen . Wenn Sie denken, dass dies hier nicht erlaubt ist, lassen Sie es mich wissen!

Ich habe einige Ideen von > <> und Befunge (Sie können zwischen den Zeilen wechseln und hexadezimale Zeichen verwenden, um Zahlen zu drücken), einige von Ruby und einige von mir, um das Golfen zu vereinfachen.
CAPL liest von links nach rechts und geht am Ende der Zeile eine Zeile nach unten. Wenn es sich um die letzte Zeile handelt, wird das Programm beendet.

Da diese Sprache noch niemand kennt, werde ich versuchen, so viel wie möglich zu erklären.

Y ausgeben. 6 Bytes

bb*.n<

bb* bist hexadezimal für 11, also bb*ist 11*11= 121, was das UTF-8-Äquivalent von ist y. Dieser Wert wird in den Stack verschoben.
.Öffnet den obersten Wert des Stapels und gibt ihn als UTF-8 aus. Wie 121oben auf dem Stapel wird der Index hier ignoriert.
nAusgabe einer neuen Zeile
<Sendet den Zeiger an den Zeilenanfang und wiederholt diese Zeile. Da wir keine Eingabe erwarten, können wir dies sicher tun, ohne erneut nach der Eingabe zu fragen.

Ausgabe von der Eingabe. 10 Bytes, 0 nach Bonus

i~a&{X:.)}

iNimmt Eingaben vom Benutzer entgegen, drückt als UTF-8 oben auf den Stapel und drückt die Länge danach. Das heißt, es wird [72,101,108,108,111,5]
~eine Zahl aus dem Stapel entfernt und dann die Anzahl der Bytes umgekehrt. Das heißt, [111,108,108,101,72]
ahexadezimal für 10das Newline-Zeichen.
&{...}Erstellt eine Endlosschleife. Wir haben Eingaben, daher können wir den Zeiger nicht zurück in die Zeile senden. Ich könnte die Funktion in der Zeile darunter platzieren, was mir ein Byte ersparen würde, aber Zeilenumbrüche sind in dieser Herausforderung nicht zulässig.
XEntfernt den obersten Wert vom Stapel (Der Index aus der Schleife).
:.Dupliziert den obersten Wert und gibt ihn als UTF-8 aus.
)Dreht den Stapel nach rechts. ( [1,2,3,4,5]-> [5,1,2,3,4])

Dies bedeutet jedoch, dass wir mit einer neuen Zeile beginnen und dann die Eingabe, dann eine neue Zeile, dann die Eingabe usw. ausgeben. Wenn wir nicht mit einer neuen Zeile beginnen dürfen, verwenden Sie nach dem Subtrahieren den folgenden Code mit 12 Bytes oder 2 der Bonus.

iXa#~&{X:.)}

Der einzige neue Befehl hier ist #, der die Anzahl der Elemente auf dem Stapel auf den Stapel schiebt.
Ich habe die Länge von entfernt i, da das Hinzufügen von 1 und das Austauschen mit der neuen Zeile länger ist als das Entfernen und erneute Abrufen der Länge.

Nur zum Spaß gibt es hier ein "Hello World" -Programm

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

Die ?!Bedienung ist die gleiche wie bei> <>

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

Warnung: stützt sich auf eine undokumentierte und nicht unterstützte Funktion / einen nicht unterstützten Fehler.

⎕←⍣≢⍞

Leere STDIN druckt leere Zeilen (nicht „y“), die erlaubt ist , und vorgeschlagen worden .

Probieren Sie es online!

⎕ STDOUT mit nachgestellten Zeilenumbrüchen,

← bekommt

⍣ wiederholt bis

≢ es unterscheidet sich von

⍞ STDIN

dh niemals, aber unterbrechungsfrei durch Anhalten des Threads.

> <>, 6 Bytes

b:*oao

Wenn Sie ;am Ende kein "a " einfügen , schwimmt das " > <>" so lange weiter, bis es von einem "SIGINT" freigegeben wird.

Erläuterung

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 Bytes

Die vorherige ist eine ziemlich langweilige Lösung, hier ist eine, die Eingaben von stdin nimmt. Dies missbraucht die Tatsache, dass die Standardmethode zum Bereitstellen von Eingaben für ein > <> -Programm darin besteht echo 'input' | fish.py yes.fish, echodas \nZeichen bereitzustellen.

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

Erläuterung

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

Am 0rEnde kann die Schleife durch Umwickeln entstehen, wobei wir immer noch davon ausgehen, dass der Stapel mit einem -1Oben umgedreht wird .

Anscheinend ist das nicht ganz portabel. Meins sys.version ist , also wenn deins anders ist 2.7.9 (default, Dec 11 2014, 04:42:00) \n[GCC 4.9.2], funktioniert das wahrscheinlich nicht.

Python 2 - (76-10) = 66

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

Ziemlich lang, aber ich wollte den Bonus bekommen (obwohl er mehr als 10 Bytes kostete). Offenbar ist es lang, zu prüfen, ob stdin leer ist oder nicht, ohne zur Eingabe aufzufordern.

Zuerst habe ich den Bonus falsch verstanden, weil ich ein Argument anstelle von stdin genommen habe. Ich bin stolz auf meine Lösung dafür, also poste ich sie trotzdem;)

Python 2 - (52-10 + ∞) = ∞ (ungültig!)

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

sys.argvist eine Liste, in der das nullte Element der Dateiname ist und jedes Element afterwords ein Argument für das Programm ist. Ich füge am Ende der Liste einen Falsey-Wert hinzu. Wenn es keine Argumente gibt, ist das erste Element dieser falsche Wert, andernfalls ist es das erste Argument. a or bin Python wird der erste Wert zurückgegeben, der bestätigt, wie das Ergebnis aaussehen wird: Wenn es wahr ist, wissen wir bereits, dass das Ganze wahr sein wird, sodass es nur zurückgegeben wird. Wenn es falsch ist, bwird zurückgegeben (seit False or b== b).