42

Drucken Sie eine kontinuierliche Sinuswelle, die vertikal auf einem Terminal gescrollt wird. Das Programm sollte nicht beendet werden und die Welle kontinuierlich nach unten rollen (außer bis es irgendwie unterbrochen wird). Sie können davon ausgehen, dass ein Überlauf kein Problem darstellt (dh Sie können Endlosschleifen mit inkrementierenden Zählern oder eine Endlosrekursion verwenden).

Die Welle sollte die folgenden Eigenschaften erfüllen:

Amplitude = 20 Zeichen (Spitzenamplitude)
Periode = 60 bis 65 Zeilen (inklusive)
Die Ausgabe sollte nur aus Leerzeichen, Zeilenvorschub und bestehen |
Halten Sie nach jeder Ausgabezeile eine Pause von 50 ms ein

Beispielausgabe:

Die obige Ausgabe sollte für immer eingeschaltet bleiben, sofern nichts anderes unterbrochen wird, z. B. SIGINT oder SIGKILL oder das Schließen des Terminalfensters, oder Sie schalten Ihre Maschine aus, oder die Sonne verschluckt die Erde usw.

Kürzester Code gewinnt.

Hinweis. Ich kenne ein ähnliches Problem bei Display Scrolling Waves, aber das ist nicht genau dasselbe. Bei meinem Problem soll die Welle nicht "an Ort und Stelle" gescrollt werden - sondern nur auf einem Terminal ausgegeben werden. Dies ist auch ein Ascii-Art-Problem, verwenden Sie also nicht Mathematica, um es zu zeichnen.

code-golf ascii-art kolmogorov-complexity

— ace_HongKongIndependence
quelle

1

Spitzenamplitude, Spitze-Spitze-Amplitude oder Root-Square-Amplitude?

— DavidC

Spitzenamplitude.

— ace_HongKongIndependence

1

Ist es in Ordnung, eine Welle mit nur | s und ohne Leerzeichen zu zeichnen?

— Gelatine

1

Alle Antworten sind noch ungültig. Sie halten auch für SIGKILL, nicht nur für SIGINT.

— Max Ried

1

@Max Ried fein, ich werde es auf "sollte ewig so weitergehen, wenn nicht anders unterbrochen" ändern.

— ace_HongKongIndependence

12

APL (35)

(Ja, es passt in 35 Bytes, hier ist eine 1-Byte-APL-Codierung )

{∇⍵+⌈⎕DL.05⊣⎕←'|'↑⍨-21+⌈20×1○⍵×.1}1

Erläuterung:

{... }1: Rufen Sie die Funktion mit 1 am Anfang auf
1○⍵×.1: nah genug für die Regierungsarbeit an sin(⍵×π÷30). ( 1○ist sin).
-21+⌈20: auf den Bereich normalisieren 1..40und negieren
'|'↑⍨: Nimm die letzten NZeichen aus der Zeichenkette '|'(was zu einer Zeichenkette mit einem |am Ende führt
⎕←: Anzeige
⌈⎕DL.05: Warte 50 ms und kehre zurück 1. ( ⎕DLGibt die Zeitspanne zurück, die tatsächlich gewartet wurde und die in der Nähe sein wird 0.05, wobei dieser Wert aufgerundet wird 1).
∇⍵+: füge diese Nummer ( 1) hinzu ⍵und starte die Funktion erneut.

— Marinus
quelle

2

Verdammt ... Ich dachte, trigonometrische Funktionen und die Zeitverzögerung würden euch

— auslassen

2

Hier ein 33 char ein:{⎕←'|'↑⍨-⌈20×1+1○⍵⋄∇.1+⍵⊣⎕DL.05}0

— Tobia

3

@ace LOL. Sie sollten APL ausprobieren, es ist keine neue Sprache. Es ist sehr alt und wird seit Jahrzehnten in großen Systemen eingesetzt. Es ist ziemlich einzigartig im Vergleich zu allem anderen. IMHO die Symbole machen es viel besser lesbar, dass die ASCII-only-Derivate (J)

— Tobia

22

C, 74 73 70 69 67 Zeichen

67 Zeichen Lösung mit vielen guten Ideen von @ugoren & anderen:

i;main(j){main(poll(printf("%*c|\n",j=21+sin(i++*.1)*20,0),0,50));}

69 Zeichen Lösung mit while-Schleife statt Rekursion:

i;main(j){while(printf("%*c|\n",j=21+sin(i++*.1)*20,0))poll(0,0,50);}

Annäherung an Perl. :)

— treamur
quelle

1

Dies wurde von @ aces eigener C-Antwort inspiriert.

— Treamur

2

Ich denke, Sie könnten 5E4anstelle von verwenden 50000.

— musiphil

2

Ich denke, Sie könnten * .1 anstelle von / 10 verwenden.

— Moala

1

@musiphil, ich habe auch über 5E4 nachgedacht, aber es stellt sich heraus, dass es nicht funktioniert: Ohne den Compiler- usleep()Prototypen zu zeigen, müssten Sie die 5E4 explizit gießen.

— Treamur

2

Sie können mehr Zeichen zwei , indem die Zuordnung zu j in den printf ausgeschnitten, wie folgt aus : printf("%*s\n",j=21+sin(i++*.1)*20,"|"). Der resultierende Typ ist immer noch int, sodass es sich um ein gültiges Feldbreitenargument handelt.

— Kunst

12

Mathematica 121 104 80 67 64

n=1;While[0<1,Spacer[70 Sin[n Pi/32]+70]~Print~"|";Pause@.05; n++]

Sinus

— DavidC
quelle

Frage sagt nicht, Mathematica zu verwenden, um es zu zeichnen. ist das irgendwie anders als das?

— Malachi

13

@ Malachi Ja. Hierbei wird wie bei jeder anderen Antwort Mathematica zur Berechnung verwendet. Die Verwendung von Mathematica zum Zeichnen würde bedeuten, dass Mathematica zum Zeichnen aufgefordert wird x=20*sin(pi*y/30)+20oder etwas Ähnliches.

— Justin

ok ich verstehe was du sagst danke für die Klarstellung

— Malachi

1

Und hier ist eine 58 char-VersionDo[Spacer[70*Sin[n*Pi/32]+70]~Print~"|";Pause@.05,{n,18!}]

— Ajasja

1

Im nicht ein Mathematica Benutzer, aber ich denke , die Sie ändern können , 1 == 1um 0 < 11 Zeichen zu verringern.

— KPCh

11

Perl, 48 (68)

GNU-Schlafversion: 48

print$"x(25+20*sin).'|
';$_+=.1;`sleep .05`;do$0

Plattformübergreifend: 68

use Time::HiRes"sleep";print$"x(25+20*sin).'|
';$_+=.1;sleep.05;do$0

Die Verwendung des Time :: HiRes-Moduls mithilfe der Shell-Sleep-Funktion wurde entfernt. Verkürztes Inkrement gemäß Ruby-Beispiel. Verkürzt mit $ "und $ 0, um Hinweise aus Primos Arbeit zu sehen. Danke für Hinweise, Primo.

— KevinColyer
quelle

Ich habe dies als Datei gespeichert test.plund ausgeführt perl ./test.pl, die Wartezeit stimmt jedoch nicht mit der Spezifikation überein. Auch die Amplitude der Welle ist zu klein. (Diese Amplitude bezieht sich auf die Länge zwischen dem Peak und der Gleichgewichtsposition.)

— ace_HongKongIndependence

Ich denke, wenn ich das Inkrement von .105 auf .1 ändern würde, würde ich Ruby mit 56 Zeichen schlagen!

— KevinColyer

@primo - mein Muschelschlaf macht mal kürzer als 1 Sekunde ...

— KevinColyer

man sleep→ unsigned int sleep(unsigned int seconds);. Es wird keinen Fehler machen, aber das tatsächliche Ruheintervall ist Null. Einige Vorschläge, um Ihre $dzu verkürzen : Wechseln Sie zu $_und verwenden Sie (25+20*sin)und ändern Sie die \nfür eine wörtliche Newline.

— Primo

2

@primo man 1 sleepauf einer GNU / Linux-Bash-Shell sagt uns, dassUnlike most implementations that require NUMBER be an integer, here NUMBER may be an arbitrary floating point number.

— ace_HongKongIndependence

11

Perl - 64 (oder 60) Bytes

Im Folgenden wird ein Windows-spezifischer Shell-Befehl verwendet:

`sleep/m50`,print$"x(20.5-$_*(32-abs)/12.8),'|
'for-32..31;do$0

Der folgende Befehl verwendet einen GNU / Linux-spezifischen Shell-Befehl:

`sleep .05`,print$"x(20.5-$_*(32-abs)/12.8),'|
'for-32..31;do$0

Beide bei 64 Bytes.

Zeitraum ist 64.
Die maximale Amplitude beträgt genau 20.
Die Kurve ist perfekt symmetrisch.
Jede Periode ist identisch.

Beachten Sie, dass dies keine Sinuswelle ist, sondern eine quadratische Interpolation. Verschworen gegen eine tatsächliche Sünde:

Bei der erforderlichen Granularität sind diese visuell nicht unterscheidbar.

Wenn die Ästhetik nicht so wichtig ist, biete ich eine 60-Byte- Alternative mit einer Periodenlänge von 62, einer maximalen Amplitude von ~ 20,02 und leichten Asymmetrien an:

`sleep/m50`,print$"x(20-$_*(31-abs)/12),'|
'for-31..30;do$0

— primo
quelle

Dies ist keine Sinuswelle; es sind einfach Parabeln (wenn ich Ihren Code richtig lese). (Wenn Sie dies mit einer Sinuswelle darstellen können, würde ich gerne die Funktion sehen).

— Justin

Sinus ist eine Formel. Wenn Sie die Formel replizieren, handelt es sich immer noch um eine Sinuswelle. und dies ist wahrscheinlich in gewisser Weise eine Variante von Sinus.

— Malachi

8

Rubin 56

i=0
loop{puts" "*(20*Math.sin(i+=0.1)+20)+?|;sleep 0.05}

— daniero
quelle

Ist das Ersetzen von Puts durch p zulässig?

— Scheiben geschnitten

1

@Slicedpan glaube ich nicht, da dies eine Herausforderung ist, etwas zu zeichnen. pfügt um jede Zeile doppelte Anführungszeichen ein und ändert die "Zeichnung".

— Daniero

7

Befunge 98 - 103 100

:1g:02p' \k:02gk,'|,a,$ff*:*8*kz1+:'<\`*
468:<=?ABDEFGGGHGGGFEDBA?=<:86420.,+)'&$#"!!! !!!"#$&')+,.02

Beifall für ein Programm, das dies in einer Sprache ohne trigonometrische Fähigkeiten tut; das erste Programm in der Tat. Die zweite Zeile ist einfach Daten; Das Zeichen, das dem ASCII-Wert der Sünde entspricht und zu einem Leerzeichen hinzugefügt wird.

BEARBEITEN: Ich habe 3 Zeichen gespart, indem ich das Leerzeichen nicht abgezogen habe. Die Sinuskurve wird um 32 Einheiten nach rechts verschoben (was gültig ist).

Befunge hat auch keinen Schlafbefehl oder ähnliches. Es wäre schön, einen Fingerabdruck zu finden, aber ich konnte keinen finden, also ff*:*8*drückt 8*225**2( 405000) und kzführt so oft ein Noop aus (naja, so oft + 1). Auf der Windows-Kommandozeile mit Pyfunge sind es ungefähr 50 Millisekunden, also sage ich, dass ich gut bin. Hinweis: Wenn jemand einen guten Fingerabdruck dafür kennt, lassen Sie es mich bitte wissen.

Der letzte Teil des Codes prüft einfach, ob der Zähler (für die Datenzeile) hinter den Daten liegt. Wenn dies der Fall ist, wird der Zähler auf 0 zurückgesetzt.

Ich habe dies verwendet , um die Daten zu generieren.

Taylor-Reihe

Obwohl diese Version 105 Zeichen enthält, musste ich sie nur einfügen:

:::f`!4*jf2*-:::*:*9*\:*aa*:*:01p*-01g9*/a2*+\$\f`!4*j01-*b2*+:01p' \k:01gk,$'|,a,ff*:*8*kz1+:f3*`!3*j$e-

Ich habe versucht, mein Programm zu verkürzen, und habe mich dazu entschlossen, in der Taylor-Reihe nach Cosinus zu suchen (Sinus ist schwerer zu berechnen). Ich habe zu geändert x, pi * x / 30um die hier angeforderte Periode abzugleichen, und dann mit multipliziert 20, um die Amplitude abzugleichen. Ich habe einige Vereinfachungen vorgenommen (angepasste Faktoren für das Abbrechen, ohne den Wert der Funktion wesentlich zu verändern). Dann habe ich es umgesetzt. Leider handelt es sich nicht um eine kürzere Implementierung.

:f`!4*jf2*-

prüft, ob die Werte der Taylor-Reihe ungenau werden (ungefähr x = 15). Wenn ja, dann berechne ich die Taylor-Reihe für x - 30anstatt x.

:::*:*9*\:*aa*:*:01p*-01g9*/a2*+

Ist meine Implementierung der Taylor-Reihe um x = 0, wann xist der Wert auf dem Stapel.

\$\f`!4*j01-*

Negiert den Wert der Taylor-Reihe, wenn die Taylor-Reihe angepasst werden muss.

b2*+

mache die Cosinuswelle positiv; Andernfalls würde der Druckvorgang nicht funktionieren.

:01p' \k:01gk,$'|,a,

druckt die Welle

ff*:*8*kz1+

notdürftig 50 Millisekunden warten, dann inkrementieren x

:f3*`!3*j$e-

Ist der xWert größer als 45, ändern Sie ihn auf -14 (erneut Taylor Series Error Adjustment).

— Justin
quelle

Dies ist genau die Art von Antwort, auf die ich mich freue, ich hoffe, Sie können es spielen :)

— ace_HongKongIndependence

1

Dort! Ich habe die Codelänge erfolgreich um -5 Zeichen verringert! Und es gibt noch Raum für Verbesserungen!

— Justin

@ Quincunx meine Perl-Lösung verwendet auch keine eingebauten Trigger-Funktionen;)

— Primo

6

Python, 108,93,90,8988

import math,time
a=0
while 1:print" "*int(20+20*math.sin(a))+"|";time.sleep(.05);a+=.1

Jetzt mit unendlichem Scrollen :)

Edit: ok, 90. Genug?

Bearbeiten: Bearbeiten: Nein, 89.

Edit: Edit: Edit: 88 danke an boothby .

— Gabriele D'Antona
quelle

Tut mir leid, wenn ich die Frage nicht geklärt habe - Ihr Programm sollte nicht beendet werden und die Welle kontinuierlich nach unten scrollen (außer bis SIGINT)

— ace_HongKongIndependence

1

a=0.-> a=0bekommt man auf 88

— Boothby

5

PHP, 59 Zeichen

<?for(;;usleep(5e4))echo str_pad('',22+20*sin($a+=.1)).~ƒõ;

— Alex Barrett
quelle

1

Sie können sich einige Bytes sparen, indem Sie echo ...;anstelle von verwenden fwrite(STDOUT,...);.

— Primo

Das macht Sinn, wenn man von der Kommandozeile aus aufruft. 10 Zeichen gespeichert - danke primo.

— Alex Barrett

1

58:<?for(;;)echo~str_pad(ƒõ,22+20*sin($a+=.1),ß,usleep(5e4));

— Primo

Sehr schön. Ich werde meine Antwort mit diesen Änderungen nicht bearbeiten. Sie sollten sie als Ihre eigene Antwort veröffentlichen.

— Alex Barrett

1

@ace muss mit einer ansi-Kodierung gespeichert werden. ideone konvertiert automatisch alles nach utf-8, was kaputt geht. ~ƒõist nur eine Abkürzung für "|\n".

— Primo

4

C64 BASIC, 64 PETSCII-Zeichen

Bildbeschreibung hier eingeben

Auf einem PAL C64 For i=0 to 2:next iwerden ca. 0,05 Sekunden, damit die Verzögerungszeit eingehalten wird.

— Gabriele D'Antona
quelle

3

Javascript 88 76 78 Zeichen

setInterval('console.log(Array(Math.sin(i++/10)*20+21|0).join(" ")+"|")',i=50)

Basierend auf Kendall Freys Code.

— joeytje50
quelle

Sie werden nie initialisiert i, sodass anstelle einer Welle eine gerade Linie gedruckt wird.

— gilly3

Mein Fehler ... Es hat wahrscheinlich funktioniert, weil ich Kendalls Skript bereits in meiner Konsole ausgeführt hatte, sodass ich bereits für mich initialisiert wurde.

— Joeytje50

3

C - 86 + 3 Zeichen

Danke Shiona und Josh für die Bearbeitung

i;main(j){for(;j++<21+sin(i*.1)*20;)putchar(32);puts("|");usleep(50000);i++;main(1);}

~~i; main (j) {für (j = 0; j ++ <20 + sin (i / 10.) * 20;) Putchar (32); Puts ("|"); Usleep (50000); i ++; main () ;}~~

~~float i; main (j) {für (j = 0; j ++ <20 + sin (i) * 20;) putchar (32); puts ("|"); usleep (50000); i + =. 1; main ( );}~~

Zusammengestellt mit der -lmFlagge, nehme ich an, dass ich 3 Zeichen hinzufügen muss

— ace_HongKongIndependence
quelle

1

Würde es funktionieren, wenn Sie im Rahmen des Aufrufs von sin () ein int machen und es einfach durch 10.0 (oder 9.9, um ein Zeichen zu speichern?) Teilen? i;main(j){for(j=0;j++<20+sin(i/10.0)*20;)putchar(32);puts("|");usleep(50000);i++;main();}

— Shiona

Sie können die Größe mit printf () auf etwa 76 Zeichen printf("%*s\n",(int)(21+sin(i++/10.)*20),"|")

— verringern

1

Hmm ... Ich würde mich wirklich schuldig fühlen, wenn ich diese Idee in meiner Antwort verwende, besonders wenn dies meine eigene Frage ist ... Würden Sie in Betracht ziehen, eine Antwort selbst zu posten?

— ace_HongKongIndependence

OK mach ich. Vielen Dank. :)

— Treamur

1

Sie können aus zwei Zeichen rasieren , wenn Sie das entfernen j=0: i;main(j){for(;j++<21+sin(i/10.)*20;)putchar(32);puts("|");usleep(50000);i++;main(1);}. Dies setzt voraus, dass das Programm mit 0 Argumenten aufgerufen wird.

— Josh

3

Ti-Basic, 33 Bytes

While 1:Output(8,int(7sin(X)+8),"!":Disp "":π/30+X→X:End

Die folgenden Einschränkungen bestehen :

Aufgrund der Bildschirmbegrenzung von 16x8 hat diese Sinuswelle nur eine Amplitude von 7 (Periode von 60 bleibt erhalten)
Aufgrund des Fehlens einer einfachen Möglichkeit, auf das |Zeichen zuzugreifen , !wird stattdessen verwendet
Aufgrund des Fehlens eines genauen Systemzeitgebers wird die Verzögerung nicht implementiert. Die Laufgeschwindigkeit scheint jedoch ungefähr korrekt zu sein.

— Mike Clark
quelle

1

Heh, da TI-BASIC in Ein- / Zwei-Byte-Tokens gezählt wird, sind dies tatsächlich 33 Bytes (nicht "56 Zeichen"), also hätte es die Herausforderung tatsächlich gewinnen sollen!

— MI Wright

Bis auf die Amplitude ...

— Lirtosiast

Nun ja, aber byteweise ist es in Ordnung.

— MI Wright

2

JavaScript - 88

setInterval(function(){console.log(Array(Math.sin(i++/10)*20+21|0).join(" ")+"|")},i=50)

Ich bin sicher, jemand kann sich etwas einfallen lassen, das eigentlich klug ist.

— Kendall Frey
quelle

2

J - 103,58,5754

Vielen Dank an die tollen Jungs vom IRC

(0.1&+[6!:3@]&0.05[2:1!:2~' |'#~1,~[:<.20*1+1&o.)^:_]0

In Worten von rechts nach links heißt es: Ausgehend von 0 unendlich oft: sin, addiere 1, multipliziere mit 20, füge 1 hinzu (so wird es zu einem Array von 2 Elementen), kopiere zwei Bytes '|' entsprechend ausdrucken, 0.05s warten und 0.1 addieren

Anstelle der Endlosschleife können wir auch die Rekursion verwenden. Sie würde 2 Zeichen speichern, aber auch nach einigen Iterationen einen Stapelfehler erzeugen

($:+&0.1[6!:3@]&0.05[2:1!:2~' |'#~1,~[:<.20*1+1&o.)0

Wo $:ist ein rekursiver Aufruf.

— Swish
quelle

Würde es Ihnen etwas ausmachen, eine kleine Erklärung hinzuzufügen, damit auch Personen, die mit der J-Syntax nicht vertraut sind (wie ich), Ihre Antwort verstehen können?

— ace_HongKongIndependence

Es ist möglich , dies über mit der Zug - Struktur Getue zu 50 Zeichen zu verkürzen: (+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)^:_]0. Die Rekursionsversion spart diesmal nur 1 Zeichen, $:@(+2*(%20)6!:3@[2:1!:2~' |'#~1,~[:<.20*1+1&o.)0obwohl sie länger zu dauern scheint, bevor der Tiefpunkt erreicht wird.

— Algorithmushai

2

Haskell - 75

main=putStr$concat["|\n"++take(floor$20+20*sin x)(repeat ' ')|x<-[0,0.1..]]

Leider konnte ich das Programm nicht dazu bringen, 50 ms anzuhalten, ohne meine Zeichenanzahl zu verdoppeln, sodass es nur die Konsole überflutet, aber die Sinuswelle erzeugt.

Hier ist der vollständige Code mit Pause (138 Zeichen mit Zeilenumbrüchen):

import GHC.Conc
import Control.Monad
main=mapM_(\a->putStr a>>threadDelay 50000)(["|\n"++take(floor$20+20*sin x)(repeat ' ')|x<-[0,0.1..]])

— Zaq
quelle

2

Das Anhalten war eine der Anforderungen. Kannst du den Code auch mit der Pause posten?

— Justin

Okay, ich habe es gepostet. Ich wünschte, Haskell würde Sie Code ohne Importe pausieren lassen.

— Zaq

Mit Amplitude meine ich die Spitzenamplitude, dh die doppelte Amplitude Ihres aktuellen Programms. Möglicherweise möchten Sie es ändern, um sich 20+20*sin xzu qualifizieren.

— ace_HongKongIndependence

Oh sicher. Ich glaube, ich habe diesen Teil der Frage falsch interpretiert.

— Zaq

2

Perl 6: 46 Zeichen

sleep .05*say ' 'x(25+20*.sin),'|'for 0,.1...*

Erstellen Sie einen unendlichen faulen Bereich, indem Sie die 0,0.1 ... *Schleife darüber ziehen. Gibt sayzurück, Bool::Truewas als 1 multipliziert wird. Auf diese Weise kann ich es in einer einzigen Anweisung belassen.

— Ayiko
quelle

Ich kann verstehen warum sleepund .05muss getrennt werden. Aber ich frage mich, ob der Abstand zwischen sayund ' 'obligatorisch ist?

— Matthias

Ja: s Es gibt "2 Terme in einer Reihe" Fehler für say' 'Man kann verwenden, say(' ')aber das ist 1

— Zeichen

1

@Matthias: In Perl 6 müssen Listops entweder keine Argumente nehmen, ein Leerzeichen nach sich ziehen oder Klammern verwenden. Im Gegensatz zu Perl 5 ist es keine für Code-Golf entwickelte Sprache (sie enthält jedoch viele nette eingebaute Funktionen, sodass sie verwendet werden können).

— Konrad Borowski

@ xfix Danke für die Erklärung. Ich mag die Sprache, habe sie aber noch nicht gründlich untersucht, weil ich sie noch nicht in einem Arbeitsprojekt verwenden kann. Ich plane jedoch immer, einige Perl 6-Skripte zu schreiben. @ Ayiko, ich schätze deine Perl 6 Beiträge :-)

— Matthias

2

_fugly Javascript - 77

i=setInterval("console.log(Array(Math.sin(i+=.1)*20+20|0).join(' ')+'|')",50)

und wenn wir es in Firefox - 73 tun

i=setInterval("console.log(' '.repeat(Math.sin(i+=.1)*20+20|0)+'|');",50)

und wenn wir böse sind - 67

i=setInterval("throw(' '.repeat(Math.sin(i+=.1)*20+20|0)+'|');",50)

— eithed
quelle

1

Scala, 92,8987

def f(i:Int){println(" "*(20+20*math.sin(i*.1)).toInt+"|");Thread sleep 50;f(i+1)};f(1)

— ValarDohaeris
quelle

(20+20*math.sin(i*.1))reduziert es um 1 Zeichen, vorausgesetzt, dies ist eine gültige Syntax (ich habe keine Erfahrung mit Scala)

— ace_HongKongIndependence

Danke, aber ich habe das gerade selbst entdeckt :)

— ValarDohaeris

1

Python 3, 103

Blöder Frikk'n importiert ...

import time,math
t=0
while 1:t+=(.05+t<time.clock())and(print(' '*int(20+20*math.cos(t*1.9))+'|')or.05)

Anstelle von "sleep" wird bei dieser Implementierung die CPU geschliffen, da es mit Python einfacher ist, eine Gleitkomma-CPU-Uhr als eine Wanduhr zu erhalten. Dieser Ansatz wird Friols nicht schlagen , aber es macht Spaß, also lasse ich es.

— boothby
quelle

1

C #

[152] Charaktere

namespace System{class P{static void Main(){for(var i=0d;;){Console.Write("{0,"+(int)(40+20*Math.Sin(i+=.1))+"}\n",'|');Threading.Thread.Sleep(50);}}}}

Ich konnte die existierende C # -Antwort nicht auf "Ausführen" bekommen und konnte nicht abstimmen, weil ich nicht genug Reputation habe

Es fehlten ein paar {und ein )nach der For-Loop-Deklaration.

Ich nehme an, dass die Abweichung im Aussehen der Welle, wenn sie ausgeführt wird, auf die Art und Weise zurückzuführen ist, wie wir versuchen, diese Welle anzuzeigen.

Wenn der Namespace und die Methodendeklaration nicht gezählt werden, sind dies [104] Zeichen für die Arbeitsversion

for(var i=0d;;){Console.Write("{0,"+(int)(40+20*Math.Sin(i+=.1))+"}\n",'|');Threading.Thread.Sleep(50);}

— Malachi
quelle

Die andere C # -Antwort funktioniert auf gmcs. Zuerst kann es nicht kompiliert werden, aber ich denke, das liegt daran, dass der Quellcode einige nicht druckbare Zeichen enthält. Nach erneuter Eingabe in eine leere Datei ist die Kompilierung erfolgreich.

— ace_HongKongIndependence

Compiler können wählerisch sein, oder?

— Malachi

1

VB [236] [178]

Ich bin mir nicht sicher, wie du die Tabs zählen würdest. Ich habe die Zählung nur von Notepadd ++ übernommen, bevor ich sie hier eingefügt habe. Zeilenumbrüche sind obligatorisch, wahrscheinlich, warum niemand sie gerne zum Code-Golfen verwendet.

Module Module1
Sub Main()
Dim i
While True
Console.WriteLine("{0:" & (40 + 20 * Math.Sin(i = i + 0.1)) & "}", "|")
Threading.Thread.Sleep(50)
End While
End Sub
End Module

— Malachi
quelle

1

C #

Die magische Linie [91] Charaktere

for(var i=0d;;Console.Write("{0,"+(int)(40+20*Math.Sin(i+=.1))+"}\n",'|'))Thread.Sleep(50);

Arbeitsprogramm unten. [148] Charaktere

namespace System{class P{static void Main(){for(var i=0d;;Console.Write("{0,"+(int)(40+20*Math.Sin(i+=.1))+"}\n",'|'))Threading.Thread.Sleep(50);}}}

— John ClearZ
quelle

Es tut mir leid, wenn ich die Frage nicht geklärt habe - Ihr Programm sollte nicht beendet werden und die Welle kontinuierlich nach unten scrollen (außer bis SIGINT). Fügen Sie außerdem eine Zeichenanzahl hinzu.

— ace_HongKongIndependence

Tut mir leid, das bisschen vergessen zu haben. Jetzt behoben.

— John ClearZ

Ich denke, Sie können "Thread.Sleep" verlieren und "float" mit var :) 117 Zeichen ändern. - Ich habe die Wartezeit leider nicht gesehen.

using System;class P{static void Main(){for(var i=0d;;Console.Write("{0,"+(int)(40+20*Math.Sin(i+=.1))+"}\n",'|'))Thread.Sleep(50);}}

— Medeni Baykal

1

Ich kann es nicht in VS2010 kompilieren, wenn Threading.Thread.Sleep(50)ich etwas falsch mache.

— Malachi

1

Ich konnte es zum Laufen bringen, aber ich musste einige Klammern und Semikolons hinzufügen und es sieht nicht in jeder Periode gleich aus

— Malachi

1

Bash + bc (um zu rechnen), 80

$ for((;;i++)){ printf "%$(bc -l<<<"a=20*s($i/10);scale=0;a/1+20")s|
";sleep .05;}
                |
                 |
                   |
                     |
                       |
                         |
                           |
                            |
                              |
                               |
                                |
                                 |
                                  |
                                   |
                                   |
                                   |
                                   |
                                   |
                                   |

— Digitales Trauma
quelle

1

TI-BASIC, 30 Bytes

Geringe Größenverbesserung gegenüber der anderen Antwort auf Kosten einer gewissen Genauigkeit. Beachten Sie, dass TI-Basic technisch die | Charakter, aber Sie müssen es über den Computer übertragen oder ein Assembler-Programm verwenden, um darauf zuzugreifen.

While 1
Output(8,int(8+7sin(Ans)),":
Disp "
.03π+Ans
End

— MI Wright
quelle

Woah, habe nicht gesehen, wie alt diese Herausforderung war! Ich wollte mehr Golf spielen (was definitiv möglich ist), aber es lohnt sich wirklich nicht ...

— MI Wright,

Übrigens .03πkann das sein .1, was immer noch im geforderten Intervall liegt.

— Lirtosiast

Netter Fang, danke! Sehen Sie eine Möglichkeit, wie ich den Ausgabebefehl ausführen kann? Da ich eine CSE besitze, könnte ich diese auf die richtige Amplitude bringen (26-Zeichen-Bildschirm), und das zu einem Preis von ein paar Bytes.

— MI Wright

Nein, der Ausgabebefehl sieht gut aus - schade, dass der Disp ein Angebot benötigt. Die Amplitude sollte tatsächlich 20 Zeichen betragen, sodass die Bildschirmbreite 39 erforderlich ist. Sie funktioniert also nur auf dem Grafikbildschirm, und es gibt keinen kurzen Weg, dies zu tun.

— Lirtosiast

1

Julia - 68

Edit: Danke an ML und Ass.

i=0;while 0<1;println(" "^int(20sin(.1i)+20)*"|");i+=1;sleep(.05)end

Nun, es kann nicht mit APL konkurrieren, aber hier ist mein Versuch.

Ausgabe:

— CCP
quelle

1

Ich kenne Julia nicht, aber ist es möglich, .05anstelle von 0.05in zu verwenden sleep?

— ace_HongKongIndependence

Eigentlich ja! Danke

— KPCh

Reduzieren Sie den Wert auf 68 Zeichen : i=0;while 0<1;println(" "^int(20sin(.1i)+20)*"|");i+=1;sleep(.05)end——— sin(i/10)*20entspricht20sin(.1i)

— ML

Ich kenne Julia nicht, aber könntest du stattdessen eine for-Schleife verwenden, die alle natürlichen Zahlen durchläuft?

— Lirtosiast

1

MATLAB, 81 Bytes

t=0;while(fprintf('%s\n',i))i=[];t=t+1;i(fix(21+20*sind(t*6)))='|';pause(.05);end

Ich habe die Tatsache missbraucht, dass iimmer in MATLAB initialisiert wird, was bedeutete, dass ich das fprintfin die whileAnweisung einfügen konnte, ohne es izuerst zu initialisieren . Dies bedeutet, dass das Programm zuerst eine leere Zeile ausgibt, aber ich denke, dass dies in der Spezifikation nicht verboten ist.

Außerdem wird die Tatsache missbraucht, dass Matlab die meisten ASCII-Steuerzeichen ignoriert und statt NULL ein Leerzeichen ausgibt (auch für die erste leere Zeile).

— Sanchises
quelle

"Ich habe die Tatsache missbraucht, dass ich immer in MATLAB initialisiert werde, was bedeutete, dass ich das fprintf in die while-Anweisung einfügen konnte, ohne i zuerst zu initialisieren." Sehr schlau! +1!

— Stewie Griffin

0

F # - 90 79 77 76

Hier ist eine Lösung mit Rekursion

let rec f x=printfn"%*c"(int(20.*sin x)+21)'|';Thread.Sleep 50;f(x+0.1)
f 0.

Es könnte wahrscheinlich weiter verbessert werden.

— pswg
quelle

Ohne etwas über F # zu wissen, gehe ich davon aus, dass Thread.Sleep einen Wert in ms erwartet, sodass Sie eine der Nullen

— entfernen

@ValarDohaeris Du hast recht. Ich habe die Anforderungen falsch verstanden.

— pswg

0

AutoHotkey 176

SetKeyDelay,-1
run Notepad.exe
WinWaitActive, ahk_class Notepad
p:=0
loop
{
sleep 50
p+=Mod(Floor(A_index/40),2)?-1:1,t:=""
loop % p
t .= " "
sendinput % t "|`n"
}
esc::Exitapp

Führen Sie das Skript aus. Es öffnet Notepad und druckt die Zeichen. Drücken Sie jederzeit die Esc-Taste, um das Menü zu verlassen.

— Avi
quelle

0

Clojure, 121

Kurzfassung:

(loop[a 0](println(clojure.string/join(repeat(int(+ 20 (* 20 (Math/sin a)))) " ")) \|)(Thread/sleep 50)(recur(+ a 0.1)))

Hübsche Version:

(loop [a 0]
  (println (clojure.string/join (repeat (int (+ 20 (* 20 (Math/sin a)))) " ")) \|)    
  (Thread/sleep 50)
  (recur(+ a 0.1)))

Zeitraum ist 64.

Tippe dies in lein repldie Datei oder speichere es in der Datei sin.cljund lein exec sin.cljstarte es mit (benötigt ein Lein-Exec-Plugin).

— ctrlrsf
quelle

Drucken einer Sinuswelle (vertikal)

APL (35)

C, 74 73 70 69 67 Zeichen

Mathematica 121 104 80 67 64

Perl, 48 (68)

Perl - 64 (oder 60) Bytes

Rubin 56

Befunge 98 - 103 100

Taylor-Reihe

Python, 108,93,90,8988

PHP, 59 Zeichen

C64 BASIC, 64 PETSCII-Zeichen

Javascript 88 76 78 Zeichen

C - 86 + 3 Zeichen

JavaScript - 88

J - 103,58,5754

Haskell - 75

Perl 6: 46 Zeichen

Scala, 92,8987

Python 3, 103

C #

VB [236] [178]

C #

Bash + bc (um zu rechnen), 80

TI-BASIC, 30 Bytes

Julia - 68

MATLAB, 81 Bytes

F # - 90 79 77 76

AutoHotkey 176